/** * @author Richard Davey<EMAIL_ADDRESS>* @copyright 2014 Photon Storm Ltd. * @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License} */ /** * Phaser.Input is the Input Manager for all types of Input across Phaser, including mouse, keyboard, touch and MSPointer. * The Input manager is updated automatically by the core game loop. * * @class Phaser.Input * @constructor * @param {Phaser.Game} game - Current game instance. */ Phaser.Input = function (game) { /** * @property {Phaser.Game} game - A reference to the currently running game. */ this.game = game; /** * @property {HTMLCanvasElement} hitCanvas - The canvas to which single pixels are drawn in order to perform pixel-perfect hit detection. * @default */ this.hitCanvas = null; /** * @property {CanvasRenderingContext2D} hitContext - The context of the pixel perfect hit canvas. * @default */ this.hitContext = null; /** * @property {function} moveCallback - An optional callback that will be fired every time the activePointer receives a move event from the DOM. Set to null to disable. */ this.moveCallback = null; /** * @property {object} moveCallbackContext - The context in which the moveCallback will be sent. Defaults to Phaser.Input but can be set to any valid JS object. */ this.moveCallbackContext = this; /** * @property {number} pollRate - How often should the input pointers be checked for updates? A value of 0 means every single frame (60fps); a value of 1 means every other frame (30fps) and so on. * @default */ this.pollRate = 0; /** * You can disable all Input by setting Input.disabled = true. While set all new input related events will be ignored. * If you need to disable just one type of input; for example mouse; use Input.mouse.disabled = true instead * @property {boolean} disabled * @default */ this.disabled = false; /** * @property {number} multiInputOverride - Controls the expected behaviour when using a mouse and touch together on a multi-input device. * @default */ this.multiInputOverride = Phaser.Input.MOUSE_TOUCH_COMBINE; /** * @property {Phaser.Point} position - A point object representing the current position of the Pointer. * @default */ this.position = null; /** * @property {Phaser.Point} speed - A point object representing the speed of the Pointer. Only really useful in single Pointer games; otherwise see the Pointer objects directly. */ this.speed = null; /** * A Circle object centered on the x/y screen coordinates of the Input. * Default size of 44px (Apples recommended "finger tip" size) but can be changed to anything. * @property {Phaser.Circle} circle */ this.circle = null; /** * @property {Phaser.Point} scale - The scale by which all input coordinates are multiplied; calculated by the ScaleManager. In an un-scaled game the values will be x = 1 and y = 1. */ this.scale = null; /** * @property {number} maxPointers - The maximum number of Pointers allowed to be active at any one time. For lots of games it's useful to set this to 1. * @default */ this.maxPointers = 10; /** * @property {number} currentPointers - The current number of active Pointers. * @default */ this.currentPointers = 0; /** * @property {number} tapRate - The number of milliseconds that the Pointer has to be pressed down and then released to be considered a tap or click. * @default */ this.tapRate = 200; /** * @property {number} doubleTapRate - The number of milliseconds between taps of the same Pointer for it to be considered a double tap / click. * @default */ this.doubleTapRate = 300; /** * @property {number} holdRate - The number of milliseconds that the Pointer has to be pressed down for it to fire a onHold event. * @default */ this.holdRate = 2000; /** * @property {number} justPressedRate - The number of milliseconds below which the Pointer is considered justPressed. * @default */ this.justPressedRate = 200; /** * @property {number} justReleasedRate - The number of milliseconds below which the Pointer is considered justReleased . * @default */ this.justReleasedRate = 200; /** * Sets if the Pointer objects should record a history of x/y coordinates they have passed through. * The history is cleared each time the Pointer is pressed down. * The history is updated at the rate specified in Input.pollRate * @property {boolean} recordPointerHistory * @default */ this.recordPointerHistory = false; /** * @property {number} recordRate - The rate in milliseconds at which the Pointer objects should update their tracking history. * @default */ this.recordRate = 100; /** * The total number of entries that can be recorded into the Pointer objects tracking history. * If the Pointer is tracking one event every 100ms; then a trackLimit of 100 would store the last 10 seconds worth of history. * @property {number} recordLimit * @default */ this.recordLimit = 100; /** * @property {Phaser.Pointer} pointer1 - A Pointer object. */ this.pointer1 = null; /** * @property {Phaser.Pointer} pointer2 - A Pointer object. */ this.pointer2 = null; /** * @property {Phaser.Pointer} pointer3 - A Pointer object. */ this.pointer3 = null; /** * @property {Phaser.Pointer} pointer4 - A Pointer object. */ this.pointer4 = null; /** * @property {Phaser.Pointer} pointer5 - A Pointer object. */ this.pointer5 = null; /** * @property {Phaser.Pointer} pointer6 - A Pointer object. */ this.pointer6 = null; /** * @property {Phaser.Pointer} pointer7 - A Pointer object. */ this.pointer7 = null; /** * @property {Phaser.Pointer} pointer8 - A Pointer object. */ this.pointer8 = null; /** * @property {Phaser.Pointer} pointer9 - A Pointer object. */ this.pointer9 = null; /** * @property {Phaser.Pointer} pointer10 - A Pointer object. */ this.pointer10 = null; /** * The most recently active Pointer object. * When you've limited max pointers to 1 this will accurately be either the first finger touched or mouse. * @property {Phaser.Pointer} activePointer */ this.activePointer = null; /** * @property {Pointer} mousePointer - The mouse has its own unique Phaser.Pointer object which you can use if making a desktop specific game. */ this.mousePointer = null; /** * @property {Phaser.Mouse} mouse - The Mouse Input manager. */ this.mouse = null; /** * @property {Phaser.Keyboard} keyboard - The Keyboard Input manager. */ this.keyboard = null; /** * @property {Phaser.Touch} touch - the Touch Input manager. */ this.touch = null; /** * @property {Phaser.MSPointer} mspointer - The MSPointer Input manager. */ this.mspointer = null; /** * @property {Phaser.Gamepad} gamepad - The Gamepad Input manager. */ this.gamepad = null; /** * @property {Phaser.Gestures} gestures - The Gestures manager. */ // this.gestures = null; /** * @property {Phaser.Signal} onDown - A Signal that is dispatched each time a pointer is pressed down. */ this.onDown = null; /** * @property {Phaser.Signal} onUp - A Signal that is dispatched each time a pointer is released. */ this.onUp = null; /** * @property {Phaser.Signal} onTap - A Signal that is dispatched each time a pointer is tapped. */ this.onTap = null; /** * @property {Phaser.Signal} onHold - A Signal that is dispatched each time a pointer is held down. */ this.onHold = null; /** * A linked list of interactive objects; the InputHandler components (belonging to Sprites) register themselves with this. * @property {Phaser.LinkedList} interactiveItems */ this.interactiveItems = new Phaser.LinkedList(); /** * @property {Phaser.Point} _localPoint - Internal cache var. * @private */ this._localPoint = new Phaser.Point(); /** * @property {number} _pollCounter - Internal var holding the current poll counter. * @private */ this._pollCounter = 0; /** * @property {Phaser.Point} _oldPosition - A point object representing the previous position of the Pointer. * @private */ this._oldPosition = null; /** * @property {number} _x - x coordinate of the most recent Pointer event * @private */ this._x = 0; /** * @property {number} _y - Y coordinate of the most recent Pointer event * @private */ this._y = 0; }; /** * @constant * @type {number} */ Phaser.Input.MOUSE_OVERRIDES_TOUCH = 0; /** * @constant * @type {number} */ Phaser.Input.TOUCH_OVERRIDES_MOUSE = 1; /** * @constant * @type {number} */ Phaser.Input.MOUSE_TOUCH_COMBINE = 2; Phaser.Input.prototype = { /** * Starts the Input Manager running. * @method Phaser.Input#boot * @protected */ boot: function () { this.mousePointer = new Phaser.Pointer(this.game, 0); this.pointer1 = new Phaser.Pointer(this.game, 1); this.pointer2 = new Phaser.Pointer(this.game, 2); this.mouse = new Phaser.Mouse(this.game); this.keyboard = new Phaser.Keyboard(this.game); this.touch = new Phaser.Touch(this.game); this.mspointer = new Phaser.MSPointer(this.game); this.gamepad = new Phaser.Gamepad(this.game); // this.gestures = new Phaser.Gestures(this.game); this.onDown = new Phaser.Signal(); this.onUp = new Phaser.Signal(); this.onTap = new Phaser.Signal(); this.onHold = new Phaser.Signal(); this.scale = new Phaser.Point(1, 1); this.speed = new Phaser.Point(); this.position = new Phaser.Point(); this._oldPosition = new Phaser.Point(); this.circle = new Phaser.Circle(0, 0, 44); this.activePointer = this.mousePointer; this.currentPointers = 0; this.hitCanvas = document.createElement('canvas'); this.hitCanvas.width = 1; this.hitCanvas.height = 1; this.hitContext = this.hitCanvas.getContext('2d'); this.mouse.start(); this.keyboard.start(); this.touch.start(); this.mspointer.start(); this.mousePointer.active = true; }, /** * Stops all of the Input Managers from running. * @method Phaser.Input#destroy */ destroy: function () { this.mouse.stop(); this.keyboard.stop(); this.touch.stop(); this.mspointer.stop(); this.gamepad.stop(); // this.gestures.stop(); this.moveCallback = null; }, /** * Sets a callback that is fired every time the activePointer receives a DOM move event such as a mousemove or touchmove. * It will be called every time the activePointer moves, which in a multi-touch game can be a lot of times, so this is best * to only use if you've limited input to a single pointer (i.e. mouse or touch) * @method Phaser.Input#setMoveCallback * @param {function} callback - The callback that will be called each time the activePointer receives a DOM move event. * @param {object} callbackContext - The context in which the callback will be called. */ setMoveCallback: function (callback, callbackContext) { this.moveCallback = callback; this.moveCallbackContext = callbackContext; }, /** * Add a new Pointer object to the Input Manager. By default Input creates 3 pointer objects: mousePointer, pointer1 and pointer2. * If you need more then use this to create a new one, up to a maximum of 10. * @method Phaser.Input#addPointer * @return {Phaser.Pointer} A reference to the new Pointer object that was created. */ addPointer: function () { var next = 0; for (var i = 10; i > 0; i--) { if (this['pointer' + i] === null) { next = i; } } if (next === 0) { console.warn("You can only have 10 Pointer objects"); return null; } else { this['pointer' + next] = new Phaser.Pointer(this.game, next); return this['pointer' + next]; } }, /** * Updates the Input Manager. Called by the core Game loop. * @method Phaser.Input#update * @protected */ update: function () { this.keyboard.update(); if (this.pollRate > 0 && this._pollCounter < this.pollRate) { this._pollCounter++; return; } this.speed.x = this.position.x - this._oldPosition.x; this.speed.y = this.position.y - this._oldPosition.y; this._oldPosition.copyFrom(this.position); this.mousePointer.update(); if (this.gamepad.active) { this.gamepad.update(); } this.pointer1.update(); this.pointer2.update(); if (this.pointer3) { this.pointer3.update(); } if (this.pointer4) { this.pointer4.update(); } if (this.pointer5) { this.pointer5.update(); } if (this.pointer6) { this.pointer6.update(); } if (this.pointer7) { this.pointer7.update(); } if (this.pointer8) { this.pointer8.update(); } if (this.pointer9) { this.pointer9.update(); } if (this.pointer10) { this.pointer10.update(); } this._pollCounter = 0; // if (this.gestures.active) { this.gestures.update(); } }, /** * Reset all of the Pointers and Input states * @method Phaser.Input#reset * @param {boolean} hard - A soft reset (hard = false) won't reset any Signals that might be bound. A hard reset will. */ reset: function (hard) { if (this.game.isBooted === false) { return; } if (typeof hard == 'undefined') { hard = false; } this.keyboard.reset(); this.mousePointer.reset(); this.gamepad.reset(); for (var i = 1; i <= 10; i++) { if (this['pointer' + i]) { this['pointer' + i].reset(); } } this.currentPointers = 0; if (this.game.canvas.style.cursor !== 'none') { this.game.canvas.style.cursor = 'inherit'; } if (hard === true) { this.onDown.dispose(); this.onUp.dispose(); this.onTap.dispose(); this.onHold.dispose(); this.onDown = new Phaser.Signal(); this.onUp = new Phaser.Signal(); this.onTap = new Phaser.Signal(); this.onHold = new Phaser.Signal(); this.interactiveItems.callAll('reset'); } this._pollCounter = 0; }, /** * Resets the speed and old position properties. * @method Phaser.Input#resetSpeed * @param {number} x - Sets the oldPosition.x value. * @param {number} y - Sets the oldPosition.y value. */ resetSpeed: function (x, y) { this._oldPosition.setTo(x, y); this.speed.setTo(0, 0); }, /** * Find the first free Pointer object and start it, passing in the event data. This is called automatically by Phaser.Touch and Phaser.MSPointer. * @method Phaser.Input#startPointer * @param {Any} event - The event data from the Touch event. * @return {Phaser.Pointer} The Pointer object that was started or null if no Pointer object is available. */ startPointer: function (event) { if (this.maxPointers < 10 && this.totalActivePointers == this.maxPointers) { return null; } if (this.pointer1.active === false) { return this.pointer1.start(event); } else if (this.pointer2.active === false) { return this.pointer2.start(event); } else { for (var i = 3; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].active === false) { return this['pointer' + i].start(event); } } } return null; }, /** * Updates the matching Pointer object, passing in the event data. This is called automatically and should not normally need to be invoked. * @method Phaser.Input#updatePointer * @param {Any} event - The event data from the Touch event. * @return {Phaser.Pointer} The Pointer object that was updated or null if no Pointer object is available. */ updatePointer: function (event) { if (this.pointer1.active && this.pointer1.identifier == event.identifier) { return this.pointer1.move(event); } else if (this.pointer2.active && this.pointer2.identifier == event.identifier) { return this.pointer2.move(event); } else { for (var i = 3; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].active && this['pointer' + i].identifier == event.identifier) { return this['pointer' + i].move(event); } } } return null; }, /** * Stops the matching Pointer object, passing in the event data. * @method Phaser.Input#stopPointer * @param {Any} event - The event data from the Touch event. * @return {Phaser.Pointer} The Pointer object that was stopped or null if no Pointer object is available. */ stopPointer: function (event) { if (this.pointer1.active && this.pointer1.identifier == event.identifier) { return this.pointer1.stop(event); } else if (this.pointer2.active && this.pointer2.identifier == event.identifier) { return this.pointer2.stop(event); } else { for (var i = 3; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].active && this['pointer' + i].identifier == event.identifier) { return this['pointer' + i].stop(event); } } } return null; }, /** * Get the next Pointer object whos active property matches the given state * @method Phaser.Input#getPointer * @param {boolean} state - The state the Pointer should be in (false for inactive, true for active). * @return {Phaser.Pointer} A Pointer object or null if no Pointer object matches the requested state. */ getPointer: function (state) { state = state || false; if (this.pointer1.active == state) { return this.pointer1; } else if (this.pointer2.active == state) { return this.pointer2; } else { for (var i = 3; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].active == state) { return this['pointer' + i]; } } } return null; }, /** * Get the Pointer object whos identified property matches the given identifier value. * @method Phaser.Input#getPointerFromIdentifier * @param {number} identifier - The Pointer.identifier value to search for. * @return {Phaser.Pointer} A Pointer object or null if no Pointer object matches the requested identifier. */ getPointerFromIdentifier: function (identifier) { if (this.pointer1.identifier == identifier) { return this.pointer1; } else if (this.pointer2.identifier == identifier) { return this.pointer2; } else { for (var i = 3; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].identifier == identifier) { return this['pointer' + i]; } } } return null; }, /** * This will return the local coordinates of the specified displayObject based on the given Pointer. * @method Phaser.Input#getLocalPosition * @param {Phaser.Sprite|Phaser.Image} displayObject - The DisplayObject to get the local coordinates for. * @param {Phaser.Pointer} pointer - The Pointer to use in the check against the displayObject. * @return {Phaser.Point} A point containing the coordinates of the Pointer position relative to the DisplayObject. */ getLocalPosition: function (displayObject, pointer, output) { if (typeof output === 'undefined') { output = new Phaser.Point(); } var wt = displayObject.worldTransform; var id = 1 / (wt.a * wt.d + wt.b * -wt.c); return output.setTo( wt.d * id * pointer.x + -wt.b * id * pointer.y + (wt.ty * wt.b - wt.tx * wt.d) * id, wt.a * id * pointer.y + -wt.c * id * pointer.x + (-wt.ty * wt.a + wt.tx * wt.c) * id ); }, /** * Tests if the pointer hits the given object. * * @method Phaser.Input#hitTest * @param {DisplayObject} displayObject - The displayObject to test for a hit. * @param {Phaser.Pointer} pointer - The pointer to use for the test. * @param {Phaser.Point} localPoint - The local translated point. */ hitTest: function (displayObject, pointer, localPoint) { if (!displayObject.worldVisible) { return false; } this.getLocalPosition(displayObject, pointer, this._localPoint); localPoint.copyFrom(this._localPoint); if (displayObject.hitArea && displayObject.hitArea.contains) { if (displayObject.hitArea.contains(this._localPoint.x, this._localPoint.y)) { return true; } return false; } else if (displayObject instanceof Phaser.TileSprite) { var width = displayObject.width; var height = displayObject.height; var x1 = -width * displayObject.anchor.x; if (this._localPoint.x > x1 && this._localPoint.x < x1 + width) { var y1 = -height * displayObject.anchor.y; if (this._localPoint.y > y1 && this._localPoint.y < y1 + height) { return true; } } } else if (displayObject instanceof PIXI.Sprite) { var width = displayObject.texture.frame.width; var height = displayObject.texture.frame.height; var x1 = -width * displayObject.anchor.x; if (this._localPoint.x > x1 && this._localPoint.x < x1 + width) { var y1 = -height * displayObject.anchor.y; if (this._localPoint.y > y1 && this._localPoint.y < y1 + height) { return true; } } } for (var i = 0, len = displayObject.children.length; i < len; i++) { if (this.hitTest(displayObject.children[i], pointer, localPoint)) { return true; } } return false; } }; Phaser.Input.prototype.constructor = Phaser.Input; /** * The X coordinate of the most recently active pointer. This value takes game scaling into account automatically. See Pointer.screenX/clientX for source values. * @name Phaser.Input#x * @property {number} x - The X coordinate of the most recently active pointer. */ Object.defineProperty(Phaser.Input.prototype, "x", { get: function () { return this._x; }, set: function (value) { this._x = Math.floor(value); } }); /** * The Y coordinate of the most recently active pointer. This value takes game scaling into account automatically. See Pointer.screenY/clientY for source values. * @name Phaser.Input#y * @property {number} y - The Y coordinate of the most recently active pointer. */ Object.defineProperty(Phaser.Input.prototype, "y", { get: function () { return this._y; }, set: function (value) { this._y = Math.floor(value); } }); /** * @name Phaser.Input#pollLocked * @property {boolean} pollLocked - True if the Input is currently poll rate locked. * @readonly */ Object.defineProperty(Phaser.Input.prototype, "pollLocked", { get: function () { return (this.pollRate > 0 && this._pollCounter < this.pollRate); } }); /** * The total number of inactive Pointers * @name Phaser.Input#totalInactivePointers * @property {number} totalInactivePointers - The total number of inactive Pointers. * @readonly */ Object.defineProperty(Phaser.Input.prototype, "totalInactivePointers", { get: function () { return 10 - this.currentPointers; } }); /** * The total number of active Pointers * @name Phaser.Input#totalActivePointers * @property {number} totalActivePointers - The total number of active Pointers. * @readonly */ Object.defineProperty(Phaser.Input.prototype, "totalActivePointers", { get: function () { this.currentPointers = 0; for (var i = 1; i <= 10; i++) { if (this['pointer' + i] && this['pointer' + i].active) { this.currentPointers++; } } return this.currentPointers; } }); /** * The world X coordinate of the most recently active pointer. * @name Phaser.Input#worldX * @property {number} worldX - The world X coordinate of the most recently active pointer. */ Object.defineProperty(Phaser.Input.prototype, "worldX", { get: function () { return this.game.camera.view.x + this.x; } }); /** * The world Y coordinate of the most recently active pointer. * @name Phaser.Input#worldY * @property {number} worldY - The world Y coordinate of the most recently active pointer. */ Object.defineProperty(Phaser.Input.prototype, "worldY", { get: function () { return this.game.camera.view.y + this.y; } });


Score
♪ CHILL | TRAP | EDM ♪
Name is invalid!
Play
Watch
Settings
Settings
Show lines
Show mass
Continue when mouse on other platform
Information
Join to party https://www.dubtrack.fm/join/nightblue3
Developer Nikita Sibul


--- title: Teaching layout: blank ---
\subsection{January 2019} {% assign semester = site.data.courses.jan2019 %} {% include tex-semester-courses.html %} \subsection{August 2019} {% assign semester = site.data.courses.aug2019 %} {% include tex-semester-courses.html %} \subsection{January 2020} {% assign semester = site.data.courses.jan2020 %} {% include tex-semester-courses.html %}


Locomotion Task Analysis
File hierarchy
The root directory to your project should have this hierarchy:
root
|-- Animal_Type_1 <-- all data for one specific animal type e.g. 'FoxP2-Cre'
| |-- ChR2 <-- Optogenetic expression
| | |-- Animal_0 <-- data for one animal in that animal type.
| | | |-- Protocol_0 <-- folders separate protocols e.g. 'Square_1_mW'
| | | | |-- DLC <-- contains body part trackings of all sessions derived from DLC
| | | | | |-- session_0_DLC.xlsx
| | | | | .
| | | | | .
| | | | `-- Laser <-- contains laser detection files
| | | | |-- session_0_laser.xlsx
| | | | |-- session_1_laser.xlsx
| | | | .
| | | | .
| | | .
| | | .
| | | |-- Protocol_n
| | | |
| | | `-- Spontaneous <-- Same everything just for Spontaneous sessions
| | | `DLC <-- only DLC folder since there's no laser
| | |
| | |-- Animal_1 <-- same for all other animals
| | .
| | .
| | |
| | `-- Animal_n
| `-- Control
| |-- Animal_0
| .
| `-- Animal_m
|
|-- Animal_Type_1
|
|
|-- Animal_Type_n <-- same for all other animal types
|
|-- data_npz
| |-- Protocol_0
| | |-- ChR2
| . `-- Control
| .
| |
| `-- Protocol_n
|
`-- Subplots
Jupyter notebook
Here you will find the jupyter notebook that contains different aspects of Locomotion task data analysis.
In the same location you would also find the Locomotion.py moodule used for this analysis. Here’s the documentation for its functions.
In order to start work on data analysis, you have to first fix some parameters specified under heading Constants:
video_height
: the height of video in pixels
video_width
: the width in pixels
fps
: number of frames per second of video
left_edge_x
: left end of treadmil in the frame in pixels
right_edge_x
: right end of treadmil in the frame in pixels
treadmill_len
: True length of the treadmill in cm
elec_shock
: length of the electro shock section of the treadmil in cm
treadmil_velocity
: velocity of the treadmill during task in cm/s
interval_in_sec
: duration of stimulation in sec
pre_stim_interval
: pre stimulus interval in sec for looking at x ,v and acceleration
pre_stim_interval_measure
: pre stimulus interval in seconds for the laser-OFF epoch before laser
post_stim_interval_measure
: pre stimulus interval in seconds for the laser-OFF epoch after stimulation
n_timebin
: number of frames for diffrentriation of position to yield velocity
window_pos
: moving average window for position curve smoothing
window_veloc
: moving average window for velocity curve smoothing
max_speed
: the presumed max speed of the animal to use for misdetections
mouse_no_dict
: Animal number dictionary. Every item is a tuple of two lists, first element represents ChR2 animals and second element the Control
e.g.
{'D2' : ([156, 165, 166, 195, 196, 198, 199],[172, 178]),
'Vglut2':([116, 117, 118, 119, 164, 165, 166],[359, 360]),
'FoxP2':([8, 9, 10, 11, 24, 27],[23, 26])}
pre_direct
: path to the root directory shown above
Data analysis
We first extract sessions from the readings obtained from the DeepLabCut package :
Where the blue shades show the intervals with laser stimulation.
We then extract all the windows that contain a certain period (pre_stim_interval_measure
) before laser onset, the duration of laser and (interval_in_sec
) and a period after (post_stim_interval_measure
).
If the experimenter has provided sessions with no laser stimulation (black line, here addressed as Spontaneous), we extraced the same number of trials from those sessions and plots them together to have an internal control.
- You will find the chance to assess your data through a variety of options:
look at single trials of specific animals,
averages of all or specific sessions for individual animals and all the animals at once.
You would also be able to categorize trials based on their charecteristics in the miliseconds prior to lase stimulation to see how the intial conditions would change the behavior during laser stimulation.
compare average of a chosen measure position, velocity or acceleration within an animal type group or between groups or for different animal groups with different optogenetic expression
distribution of pre laser position for individual animals
Compare the effect of simultaneous or separate laser stimulation in different brain areas within the same animal group e.g. stimulation of Subthalamic nucleus and External Globus Pallidus in Vglut2-Cre transgenic animals.
Misdetection correction
Even with an optimized trained network it so happens that there are mistakes in the trackings of body parts. This causes crazy changes in velocity of the animal and yield a noisy reading of what we are looking for. Here we try to reduce this type of noise in the data by thresholding and comparison between the two sets of data from identical cameras on each side.
Here are the steps taken:


El Capitan is a 3,000-foot (910 m) vertical rock formation in Yosemite National Park.
Tunnel View looks east into Yosemite Valley.
Upper Yosemite Falls are 1,430 ft and are among the twenty highest waterfalls in the world.
Hanging Rock, off Glacier Point, used to be a popular spot for people to, well, hang from. Crazy people.


True, GTID is upon us whether via MySQL 5.6 or Tungsten Replicator (and wasn't it in Google Patches since 2009?).
But some of us are still using standard replication with MySQL 5.5, and the "what's with all these binary log files and positions" question is ever erupting. The output of SHOW SLAVE STATUS confuses people new to it. It confuses me time and again.
So here's the semi visual guide to interpreting the SHOW SLAVE STATUS.
About binary logs and relay logs
A master writes binary logs. These are typically and conventionally called mysql-bin.##### or mysqld-bin.##### (replace ##### with digits).
A slave connects to its master, and reads entries from the master's binary logs. The slave writes those entries into its own relay logs. These are typically and conventionally called mysql-relay.##### or mysqld-relay.##### (replace ##### with digits).
There is nothing at all that connects the name or number of a slave's relay log with the master's binary log. There is nothing at all that connects the position within the relay log with the position within the master binary log. Files are flushed/rotated; have different size configuration; are re-created. However the slave does keep track on the current relay-log entry: it knows what's the matching entry on the master's binary logs. This is an important piece of information.
While the slave fetches entries and writes them into the relay log (via the IO_THREAD), it also reads the relay log to replay those entries (via the SQL_THREAD).
And so at each point in time we are interested in the following "coordinates":
- What are we fetching from the master? Which file are we fetching and from which position?
- Where are we writing this to? (This is implicitly the latest relay log file and its size)
- What's the position of currently executing slave query, in relay-log coordinates? As the slave lags these coordinates are farther (smaller) than the written-to position.
- What's the position of currently executing slave query, in master binary-log coordinates? This information really tells us how far apart we are from the master.
How do we interpret the above from SHOW SLAVE STATUS output? Take the following two images as guidelines. The first presents an up-to-date slave, the second presents a lagging slave.
Hopefully this "once and for all" explanation will last a couple weeks.
comments powered by Disqus


| SPICE Kernel Required Reading |
Table of ContentsSPICE Kernel Required Reading Abstract Document Outline Introduction to Kernels Kernel Types Text Kernels and the Kernel Pool Binary Kernels SPICE Kernel Type Identification and Kernel Naming SPICE Kernel Type Identification Recommendations on Kernel File Naming Binary Kernel Specifications Text Kernel Specifications and Interfaces Text Kernel Specifications Variable Name Rules Assignment Rules Variable Value Rules Additional Text Kernel Syntax Rules Maximum Numbers of Variables and Variable Values Treatment of Invalid Text Kernels Additional Meta-kernel Specifications Text Kernel Interfaces - Fetching Data from the Kernel Pool Informational Functions Section 5 -- Kernel Management Loading Kernels Kernel Priority Path Symbols in Meta-kernels Keeping Track of Loaded Kernels Reloading Kernels Changing Kernel Priority Load Limits Finding Out What's Loaded Unloading Kernels Loading of Non-native Text and Binary Kernels Manipulating Kernel Pool Contents Appendix A -- Discussion of Competing Data Binary Kernels SPKs CKs Binary PCKs Text Kernels Appendix B -- Glossary of Terms Assignment Continued string Control words Direct assignment Element Incremental assignment Keeper (subsystem) Kernel pool (sometimes just called ``the pool'') Kernel variable Meta-kernel (also known as ``FURNSH kernel'') Operator Principal data Value Variable name Vector value Appendix C -- Summary of Routines Appendix D -- Summary of Key Text Kernel Parameter Values Appendix E -- Revision History SPICE Kernel Required Reading
Abstract
Document Outline
``Kernel type identification and kernel naming'' contains specifications for kernel architecture and type identification and restrictions and recommendations concerning kernel file naming. ``Binary kernel specifications'' points the reader to other SPICE documents for most information on binary kernels. ``Text kernel specifications and interfaces,'' which includes extra rules for meta-kernels, provides a good deal of technical detail for both producers and consumers (users) of text kernels. ``Kernel management'' contains important information about managing and obtaining information about both text and binary kernels. Appendix A discusses the notion of ``competing data.'' Appendix B provides definitions of terms used in this document with SPICE-specific meaning. Appendix C provides a listing of kernel subsystem functions. Appendix D provides a summary of key text kernel parameter values. Appendix E provides the revision history of this document. Introduction to Kernels
Within each architecture there are several kernel types. Kernel Types
Text Kernels and the Kernel Pool
Text kernels should contain descriptive information, provided by the kernel producer, describing the sources and intended uses of the kernel data. Text kernels associate values with variables using a ``name = value(s)'' form of assignment. The kernel pool is the repository of the information provided in these assignments. Populating the kernel pool occurs in either or both of two ways: by loading text kernels -- by far the most used method -- or by using pool subsystem functions. Once ``name = value(s)'' assignments provided in a text kernel have been loaded into the kernel pool the value(s) are said to be associated with the names. You may access these data through kernel pool look-up functions using the names as keys to find the associated values. The kernel pool look-up functions are described in detail a bit later in this document. However, some higher-level and more often used functions also access data loaded into the kernel pool. Two tables in the tutorial named ``Summary of Key Points'' provide details. Binary Kernels
For EK binary kernels, the descriptive data mentioned above, and some database schema information, are read in at kernel load time. Principal data are read only when an EK query is made by a kernel reader function. Data from binary kernels do NOT get placed in the kernel pool; the pool is used only for text kernel data. Binary kernels contain a ``comment area'' where important descriptive information in ASCII form should be provided by the kernel producer. On occasion one may be given, or need to make, a ``transfer format'' file. This is an ASCII-format representation of a binary kernel, used in early versions of Mice to port binary kernels between dissimilar computers (e.g. IEEE - Little endian to IEEE - Big endian, or vice-versa). For the most part these transfer format files are no longer needed due to the addition of run-time translation capabilities in the binary kernel readers. But there are some situations when transfer format binary kernels are still needed; refer to the tutorial named ``Porting Kernels'' for details. SPICE Kernel Type Identification and Kernel NamingSPICE Kernel Type Identification
The first 6 to 8 bytes of a SPICE kernel are used for file type identification. In binary and text kernels this identifier consists of two string IDs separated by the ``/'' character. The first ID, identifying the file architecture of the kernel file (``DAF'', ``DAS'', ``KPL''), is always three characters long. The second ID, identifying the file type of the kernel file (``SPK'', ``PCK'', ``IK'', ``SCLK'', etc.), is two to four characters long. In transfer format files this file type identifier consists of a single string ID. See the Convert User's Guide for details. In binary kernels the kernel type identifier always occupies the first eight bytes. If the combined length of the kernel architecture ID, the ``/'' character, and the kernel type ID is less than 8 characters, the identifier is padded on the right to eight characters using blanks (e.g. ``DAF/SPK '', ``DAS/EK ''). The correct identifier is written to a binary kernel automatically when the kernel is created by calling the kernel type specific ``open new file'' function -- cspice_spkopn for SPK files, cspice_ckopn for CK files, etc. If a binary kernel is created by calling an architecture specific ``open new file'' function -- cspice_dafonw for DAF files, cspice_dasonw for DAS files, etc., -- it is the caller's responsibility to specify the correct kernel type in the corresponding input argument of these functions to make sure the correct kernel type identifier is written into the kernel. In text kernels the kernel type identifier occupies the first six to eight characters and is followed by optional trailing blanks and then by the end-of-line terminator character(s), resulting in the identifier appearing on a line by itself. If the combined length of the kernel architecture ID, the ``/'' character, and the kernel type ID is less than 8 characters, the identifier can, but does not have to be padded on the right to eight characters using blanks (e.g. ``KPL/SCLK'', ``KPL/IK '', etc.). Since most text kernels are created manually using a text editor, it is the responsibility of the person making the kernel to put the correct identifier by itself on the first line of the kernel. In transfer format files the SPICE kernel type identifier occupies the first six characters of the file and is followed by the expanded name of the format (e.g. ``DAFETF NAIF DAF ENCODED TRANSFER FILE''). The correct kernel type identifier is written to a transfer format file automatically when the file is created by the SPICE utility programs TOXFR or SPACIT. See their user guides, toxfr.ug and spacit.ug, for details. The SPICE kernel type identifiers used in modern SPICE kernels are as follows.
Binary Kernels: SPK DAF/SPK CK DAF/CK PCK DAF/PCK EK DAS/EK Text Kernels: FK KPL/FK IK KPL/IK LSK KPL/LSK MK KPL/MK PCK KPL/PCK SCLK KPL/SCLK Transfer format files: DAF DAFETF DAS DASETFSome older kernels used an earlier version of the kernel type identifier. In these kernels one would find:
NAIF/DAF NAIF/DASThe Toolkit includes the cspice_getfat function to retrieve the kernel file architecture and kernel type encapsulated in the SPICE kernel type identifier. A text kernel not having a kernel type identifier can, in fact, be processed by high-level functions, and by low-level functions other than cspice_getfat that use text kernel data. However, NAIF strongly recommends kernel creators to provide the identifier. Recommendations on Kernel File Naming
NAIF recommends kernel names use only lower case letters. NAIF further recommends one follows the conventions established for kernel name extensions, shown below.
.bc binary CK .bes binary Sequence Component EK .bpc binary PCK .bsp binary SPK .tf text FK .ti text IK .tls text LSK .tm text meta-kernel (FURNSH kernel) .tpc text PCK .tsc text SCLK Binary Kernel Specifications
Text Kernel Specifications and Interfaces
Text Kernel Specifications
As the name implies, SPICE text kernels contain printable ASCII text (ASCII code 32-126). Text kernels may not contain non-printing characters, excepting tab (ASCII code 9). However NAIF recommends against use of tabs in text kernels. NAIF also recommends caution be exercised when cutting/pasting text from a formatted document into a text kernel; the text characters displayed in a document may not be in the accepted ASCII range, in which case the text kernel parser will fail when reading those characters. Assignments in SPICE text kernels have a ``name = value(s)'' or ``name += value(s)'' format. We illustrate this format by way of an example using an excerpt from a SPICE text planetary constants kernel (PCK). The format description given below applies to all SPICE text kernels; the specific data names shown in this example apply only to text PCK kernels. The example begins with a SPICE kernel type identifier and is then filled out with a combination of descriptive information, called comment blocks, and data blocks.
KPL/PCK Planets first. Each has quadratic expressions for the direction (RA, Dec) of the north pole and the location and rotation state of the prime meridian. Planets with satellites (except Pluto) also have linear expressions for the auxiliary (phase) angles used in the nutation and libration expressions of their satellites. \begindata BODY399_POLE_RA = ( 0. -0.64061614 -0.00008386 ) BODY399_POLE_DEC = ( +90. -0.55675303 +0.00011851 ) BODY399_PM = ( 10.21 +360.98562970 +0. ) BODY399_LONG_AXIS = ( 0. ) BODY3_NUT_PREC_ANGLES = ( 125.045 -1935.53 249.390 -3871.06 196.694 -475263. 176.630 +487269.65 358.219 -36000. ) \begintext Each satellite has similar quadratic expressions for the pole and prime meridian. In addition, some satellites have nonzero nutation and libration amplitudes. (The number of amplitudes matches the number of auxiliary phase angles of the primary.) \begindata BODY301_POLE_RA = ( 270.000 -0.64061614 -0.00008386 ) BODY301_POLE_DEC = ( +66.534 -0.55675303 +0.00011851 ) BODY301_PM = ( 38.314 +13.1763581 0. ) BODY301_LONG_AXIS = ( 0. ) BODY301_NUT_PREC_RA = ( -3.878 -0.120 +0.070 -0.017 0. ) BODY301_NUT_PREC_DEC = ( +1.543 +0.024 -0.028 +0.007 0. ) BODY301_NUT_PREC_PM = ( +3.558 +0.121 -0.064 +0.016 +0.025 ) \begintext Here we include the radii of the satellites and planets. \begindata BODY399_RADII = ( 6378.140 6378.140 6356.755 ) BODY301_RADII = ( 1738. 1738. 1738. ) \begintextEnd of example text kernel. In this example there are several comment blocks providing information about the data. Except for the comments appearing just after the kernel type identifier and before the first data block, all comment blocks are introduced by the control word
\begintextA comment block may contain any number of comment lines. Once a comment block has begun, no special characters are required to introduce subsequent lines of comments within that block. A comment block is terminated by the control word
\begindataor by the end of the kernel file. The
\begindatacontrol word also serves to introduce a block of data that will be stored in the kernel pool. A data block is terminated by the control word
\begintextor by the end of the kernel file. Each of these control words must appear on a line by itself, and each may be preceded by white space. Within each data block there are one or more variable assignments. Each variable assignment consists of three components:
Variable Name Rules
Variable names are case-sensitive. Note that this behavior is different from that of most Mice high-level functions, which tend to ignore case in string inputs. Variable names that don't have the expected case will be invisible to Mice functions that try to fetch their values. Since high-level Mice functions that use kernel variables accept only upper case names, NAIF recommends upper case always be used for variable names. NAIF recommends you do not use a variable name with ``+'' as the last character. Assignment Rules
BODY301_NUT_PREC_RA = -3.878 BODY301_NUT_PREC_RA += -0.120 BODY301_NUT_PREC_RA += +0.070 BODY301_NUT_PREC_RA += -0.017 BODY301_NUT_PREC_RA += 0.has the same effect as the single assignment
BODY301_NUT_PREC_RA = ( -3.878 -0.120 +0.070 -0.017 0 ) Variable Value Rules
Numeric values may be provided in integer or floating point representation, with an optional sign. Engineering notation using an ``E'' or ``D'' is allowed. All numeric values, including integers, are stored as double precision numbers. Examples of assignments using valid numeric formats:
BODY399_RADII = ( 6378.1366 6378.1366 6356.7519 ) BODY399_RADII = ( 6.3781366D3 6.3781366D3 6.3567519D3 ) BODY399_RADII = ( 6.3781366d3 6.3781366d3 6.3567519d3 ) BODY399_RADII = ( 6.3781366E3 6.3781366E3 6.3567519E3 ) BODY399_RADII = ( 6.3781366e3 6.3781366e3 6.3567519e3 ) BODY399_RADII = ( 6378 6378 6357 )String values are supplied by quoting the string using a single quote at each end of the string, for example
DISTANCE_UNITS = ( 'KILOMETERS' )This quoting convention is independent of the Mice Toolkit language version being used. All string values, whether part of a scalar or vector assignment, must not exceed 80 characters on a given line. Creating a string value longer than 80 characters is possible through continuation of an assignment over multiple lines; this is described later. There is no practical limit on the length of a string value other than as mentioned in the section on String Continuation below. If you need to include a single quote in the string value, use the FORTRAN convention of ``doubling'' the quote.
MESSAGE = ( 'You can''t always get what you want.' )Date values may be entered in a wide variety of formats, using two methods. The easiest method is to enter a date as a string, as described above. There are no restrictions on the format of a date string entered as a string, but if you wish to later use that date string in SPICE software the string must conform to SPICE date/time formation rules (see the ``Time Required Reading'' document for details). A second method for entering dates, unique to text kernels, uses an ``@'' syntax. Some examples:
CALIBRATION_DATES = ( @31-JAN-1987, @feb/4/1987, @March-7-1987-3:10:39.221 )Dates entered using the ``@'' syntax may not contain embedded blanks. Dates entered using the ``@'' syntax are converted to double precision seconds past the reference epoch J2000 as they are read into the kernel pool. Note that NO time system specification (e.g. UTC or TDB) is implied by dates using the ``@'' syntax. Association of a time system with such dates is performed by the software that uses them. For example, in SPICE leapseconds kernels, such dates represent UTC times; in frames kernels, they represent TDB times. You should refer to software user's guides or API documentation to understand the interpretation of these dates for your application. Vector values, whether of numeric, string or date types, are enclosed in parenthesis, and adjacent components are separated by either white space (blank or carriage return, but not TAB) or commas.
MISSION_UNITS = ( 'KILOMETERS','SECONDS' 'KILOMETERS/SECOND' )The types of values assigned to a given kernel pool variable must all be the same. If you attempt to make an assignment such as the one shown here:
ERROR_EXAMPLE = ( 1, 2, 'THREE', 4, 'FIVE' )the kernel pool reader will regard the assignment as erroneous and reject it. Additional Text Kernel Syntax Rules
All assignments, or portions of an assignment, occurring on a line must not exceed 132 characters, including the assignment operator and any leading or embedded white space. String Continuation It is possible to treat specified, consecutive elements of a string array as a single ``continued'' string. String continuation is indicated by placing a user-specified sequence of non-blank characters at the end (excluding trailing blanks) of each string value that is to be concatenated to its successor. The string continuation marker can be any positive number of printing characters that fit in a string value (except not true for meta-kernels). For example, if the character sequence
//is used as the continuation marker, the assignment
CONTINUED_STRINGS = ( 'This // ', 'is // ', 'just //', 'one long //', 'string.', 'Here''s a second //', 'continued //' 'string.' )allows the string array elements on the right hand side of the assignment to be treated as the two strings
This is just one long string. Here's a second continued string.Everything between the single quotes, including white space and the continuation marker, counts towards the limit of 80 characters in the length of each string element. The Mice function cspice_stpool, and ONLY that function, provides the capability of retrieving continued strings from the kernel pool. See the discussion below under ``Fetching Data from the Kernel Pool'' or the header of cspice_stpool for further information. Maximum Numbers of Variables and Variable Values
See Appendix D for the numeric values of these limits. Treatment of Invalid Text Kernels
If the application calling cspice_furnsh catches Mice exceptions, all data loaded from the text kernel prior to discovery of the error will remain loaded. In this case, if an error occurs while a meta-kernel is being loaded, all files listed in that meta-kernel that have already been loaded will remain loaded. Files listed in the meta-kernel later than a file for which a failure occurred will not be loaded. Note that continuing program operation after a load failure could, due to changes in the availability of competing data, result in performing computations with data that were not planned to be used. Additional Meta-kernel Specifications
Text Kernel Interfaces - Fetching Data from the Kernel Pool
The values of variables stored in the kernel pool may be retrieved using the functions:
[values, found] = cspice_gcpool( name, start, room ) [values, found] = cspice_gdpool( name, start, room ) [values, found] = cspice_gipool( name, start, room ) [string, found] = cspice_stpool( item, nth, contin )The meanings of the arguments are as follows:
Informational Functions
Section 5 -- Kernel Management
Loading Kernels
The principal kernel loading function is named cspice_furnsh (pronounced ``furnish''). A kernel database stores the existence information for any kernel (text or binary) loaded by cspice_furnsh. The subsystem provides a set of functions that enable an application to find the names and attributes of kernels stored in the database. Early versions of Mice loaded kernels using functions specific to each kernel type. Code written for the binary kernels also supported a kernel unload facility. Mice continues to support the original kernel loaders and unloaders, but anyone writing new code should use the cspice_furnsh function instead of the kernel-specific functions. NAIF recommends loading multiple kernels using a ``meta-kernel'' rather than by executing multiple calls to cspice_furnsh. (``Meta-kernels'' are sometimes called ``furnsh kernels.'') A meta-kernel is a SPICE text kernel that lists the names of the kernels to load. At run time, the user's application supplies the name of the meta-kernel as an input argument to cspice_furnsh. For example, instead of loading kernels using the code fragment:
cspice_furnsh( 'leapseconds.tls' ) cspice_furnsh( 'mgs.tsc' ) cspice_furnsh( 'generic.bsp' ) cspice_furnsh( 'mgs.bc' ) cspice_furnsh( 'earth.bpc' ) cspice_furnsh( 'mgs.bes' )one may now write
cspice_furnsh( 'kernels.tm' )where the file ``kernels.tm'' is a SPICE text meta-kernel containing the lines
KPL/MK \begindata KERNELS_TO_LOAD = ( 'leapseconds.tls', 'mgs.tsc', 'generic.bsp', 'mgs.bc', 'earth.bpc', 'mgs.bes' ) \begintextThis technique has the important advantage of enabling a user to easily change the set of kernels to be loaded without modifying his source code. While far less robust, it is also possible to provide the names of kernels to be loaded as input arguments to cspice_furnsh. For example, one may write
kernels = { 'leapseconds.tls', 'mgs.tsc', 'generic.bsp', 'mgs.bc', 'earth.bpc', 'mgs.bes' }; % % cspice_furnsh accepts vectorized arguments. % cspice_furnsh( kernels ) Kernel Priority
If orientation data for a given body-fixed frame are provided in both a text PCK and a binary PCK, data from the binary PCK always have higher priority. Path Symbols in Meta-kernels
PATH_VALUES PATH_SYMBOLSTo create symbols for path names, one assigns an array of path names to the variable PATH_VALUES. Next, one assigns an array of corresponding symbol names to the variable PATH_SYMBOLS. The nth symbol in the second array represents the nth path name in the first array. Then you can prefix with path symbols the kernel names specified in the KERNELS_TO_LOAD variable. Each symbol is prefixed with a dollar sign to indicate that it is in fact a symbol. Suppose in our example above the MGS kernels reside in the path
/flight_projects/mgs/SPICE_kernelsand the other kernels reside in the path
/generic/SPICE_kernelsThen we can add paths to our meta-kernel as follows:
\begindata PATH_VALUES = ( '/flight_projects/mgs/SPICE_kernels', '/generic/SPICE_kernels' ) PATH_SYMBOLS = ( 'MGS', 'GEN' ) KERNELS_TO_LOAD = ( '$GEN/leapseconds.tls', '$MGS/mgs.tsc', '$GEN/generic.bsp', '$MGS/mgs.bc', '$GEN/earth.bpc', '$MGS/mgs.bes' ) \begintextIt is not required that paths be abbreviated using path symbols; it's simply a convenience available to you. Caution: the symbols defined using PATH_SYMBOLS are not related to the symbols supported by a host shell or any other operating system interface. Keeping Track of Loaded Kernels
When a kernel is loaded using cspice_furnsh, a new entry is created in the database of loaded kernels, whether or not the kernel is already loaded. All load and unload operations (see the discussion of cspice_unload below) affect the list of loaded kernels and therefore affect the results returned by the functions cspice_ktotal, cspice_kdata, and cspice_kinfo, all of which are discussed below under ``Finding Out What's Loaded.'' Reloading Kernels
Changing Kernel Priority
Load Limits
The DAF/DAS handle manager system imposes its own limit on the number of DAF binary kernels that may be loaded simultaneously. This limit is currently set to a total of 5000 DAF kernels. Finding Out What's Loaded
Mice provides kernel access functions to support these needs. For every loaded kernel, an application can find the name of the kernel, the kernel type (text or one of SPK, CK, PCK, or EK), the kernel's DAF or DAS handle if applicable, and the name of the meta-kernel used to load the kernel, if applicable. The function cspice_ktotal returns the count of loaded kernels of a given type. The function cspice_kdata returns information on the nth kernel of a given type. The two functions are normally used together. The following example shows how an application could retrieve summary information on the currently loaded SPK files:
count = cspice_ktotal( 'spk' ); if ( count == 0 ) fprintf( 'There are no SPK files loaded at this time.\n' ); else fprintf( 'The loaded SPK files are: \n' ); for which=1:count [ file, filtyp, source, handle, found ] = ... cspice_kdata( which, 'spk'); fprintf( '%s\n', file ); end endAbove, the input argument 'SPK' is a kernel type specifier. The allowed set of values is shown below.
SPK --- Only SPK kernels are counted in the total CK --- Only CK kernels are counted in the total PCK --- Only binary PCK kernels are counted in the total EK --- Only EK kernels are counted in the total TEXT --- Only text kernels that are not meta- kernels are included in the total META --- Only meta-kernels are counted in the total ALL --- Every type of kernel is counted in the totalIn this example, `filtyp' is a string indicating the type of kernel. `handle' is the file handle if the file is a binary SPICE kernel. `source' is the name of the meta-kernel used to load the kernel, if applicable. `found' indicates whether a kernel having the specified type and index was found. Mice also contains the function cspice_kinfo that returns summary information about a kernel whose name is already known. cspice_kinfo is called as follows:
[ filtyp, source, handle, found ] = cspice_kinfo( file ); Unloading Kernels
Text kernels are unloaded by clearing the kernel pool and then reloading the other text kernels not designated for removal. Note that unloading text kernels has the side effect of wiping out any kernel variables and associated values that had been entered in the kernel pool using any of the kernel pool assignment functions, such as cspice_pcpool. It is important to consider whether this side effect is acceptable when writing code that may unload text kernels or meta-kernels. Call cspice_unload as follows:
cspice_unload( kernel )Unloading a meta-kernel involves unloading all the kernels referenced by the meta-kernel. Loading of Non-native Text and Binary Kernels
Environment Native End-Of-Line Indicator ___________ _____________________ PC DOS/Windows <CR><LF> Unix <LF> Linux <LF> Mac OS X <LF>The Mice text kernel loader, cspice_furnsh, can read and parse non-native text files. (Caution: the FORTRAN SPICELIB text kernel readers do not include this capability.) The CSPICE text file reader, rdtext_c, does not possess the capability to read non-native text files. Starting with the version N0052 release of the SPICE Toolkit (January, 2002), supported platforms are able to read DAF-based binary kernels (SPK, CK and binary PCK) that were written using a non-native binary representation. This access is read-only; any operations requiring writing to the file--for example, adding information to the comment area, or appending additional ephemeris data-- require prior conversion of the kernel to the native binary file format. See the ``Convert User's Guide'' for details. Manipulating Kernel Pool Contents
% % Create a kernel in a text buffer. % textbuf = { ... 'DELTET/DELTA_T_A = 32.184', ... 'DELTET/K = 1.657D-3', ... 'DELTET/EB = 1.671D-2', ... 'DELTET/M = ( 6.239996 1.99096871D-7 )', ... 'DELTET/DELTA_AT = ( 10, @1972-JAN-1', ... ' 11, @1972-JUL-1', ... ' 12, @1973-JAN-1', ... ' 13, @1974-JAN-1', ... ' 14, @1975-JAN-1', ... ' 15, @1976-JAN-1', ... ' 16, @1977-JAN-1', ... ' 17, @1978-JAN-1', ... ' 18, @1979-JAN-1', ... ' 19, @1980-JAN-1', ... ' 20, @1981-JUL-1', ... ' 21, @1982-JUL-1', ... ' 22, @1983-JUL-1', ... ' 23, @1985-JUL-1', ... ' 24, @1988-JAN-1', ... ' 25, @1990-JAN-1', ... ' 26, @1991-JAN-1', ... ' 27, @1992-JUL-1', ... ' 28, @1993-JUL-1', ... ' 29, @1994-JUL-1', ... ' 30, @1996-JAN-1', ... ' 31, @1997-JUL-1', ... ' 32, @1999-JAN-1', ... ' 33, @2006-JAN-1', ... ' 34, @2009-JAN-1 )' ... }; % % Load the kernel data into the kernel pool. % cspice_lmpool( textbuf )See the headers of the kernel subsystem functions for specific details regarding their use. Appendix A -- Discussion of Competing DataBinary Kernels
SPKs
By definition, SPKs contain continuous data during the time interval covered by a segment, so there is no chance for a ``data gap'' in a segment within a higher priority file (later loaded file) leading to a state lookup coming from a segment in a lower priority file. SPK segment chaining may lead to a problem. It may happen that you have loaded into your program sufficient SPK data to compute the desired state or position vector, but Mice nevertheless returns an error message saying insufficient ephemeris data have been loaded. This can occur if a higher priority SPK segment, for which there are not sufficient additional SPK data to fully construct your requested state or position vector, is masking (blocking) a segment that is part of a viable (complete) chain. See the BACKUP section of the SPK tutorial for further discussion about this. Having competition between two SPKs can be a relatively common occurrence when using mission operations kernels, but is far less likely when using PDS-archived SPICE data sets because of the clean-up and consolidation actions usually taken when an archive delivery is produced. CKs
If transformation data from any two segments, whether found in a single CK file or in two CK files, are for the same object/structure (are for the same ``to'' frame) and have an overlap in the time span covered, then the two kernels may have competing data. But read on. However, unlike for SPKs, competition between CK files goes beyond segment-level considerations. The so-called ``continuous'' CK types (Types 2 through 5) do not necessarily provide orientation results for any epoch falling within a segment--there may be real data gaps. And the now little used Type 1 CK, containing discrete instances of orientation data, can be thought of as containing mostly data gaps. While some of the Toolkit software used to compute orientation obtained from CKs can provide an orientation result within a gap, this is usually not the case. See the CK tutorial and the ``CK Required Reading'' document for discussions on interpolation intervals, tolerance, and how the various CK readers work. CK segment chaining may lead to a problem. It may happen that you have loaded into your program sufficient CK data to compute the desired rotation matrix, but Mice nevertheless returns an error message saying insufficient data have been loaded. This can occur if a higher priority CK segment, for which there are not sufficient additional CK data to fully construct your requested rotation matrix, is masking (blocking) a segment that is part of a viable (complete) chain. Having competition between two CKs can be a relatively common occurrence when using mission operations kernels, but is far less likely when using PDS-archived SPICE data sets because of the clean-up and consolidation actions usually taken when an archive delivery is prepared. Binary PCKs
At present binary PCKs produced by NAIF exist only for the earth and the moon. Having competition between the latest high precision, short term earth orientation binary PCK and the lower precision, long term predict earth orientation binary PCK is a clear possibility -- be sure to load the long term predict file first to ensure any higher precision files also loaded have higher priority. Orientation data provided in any loaded binary PCK have priority over what would have otherwise been competing data provided in any loaded text PCK. Text Kernels
It is generally best to unload a text kernel before loading another one containing competing data. Appendix B -- Glossary of TermsAssignment
BODY399_RADII = ( 6378.14 6378.14 6356.75 )is an assignment with a vector value. Once a text kernel is loaded, the value(s) on the right hand sides of the assignments become associated with the variable names on the corresponding left hand sides. See ``direct assignment'' and ``incremental assignment'' below. Continued string
Control words
\begindata \begintext Direct assignment
Element
Incremental assignment
Keeper (subsystem)
Kernel pool (sometimes just called ``the pool'')
Kernel variable
Meta-kernel (also known as ``FURNSH kernel'')
Operator
Principal data
Value
variable name = value(s) Variable name
variable name = value(s) Vector value
Appendix C -- Summary of Routines
cspice_clpool ( Clear the pool of kernel variables ) cspice_dtpool ( Return information about a kernel pool variable ) cspice_furnsh ( Furnish the environment with SPICE kernels ) cspice_gcpool ( Get character data from the kernel pool ) cspice_gdpool ( Get double precision values from the kernel pool ) cspice_gipool ( Get integers from the kernel pool ) cspice_gnpool ( Get names of kernel pool variables ) cspice_kclear ( Clear and re-initialize the kernel database ) cspice_kdata ( Return informatin about the nth loaded kernel ) cspice_kinfo ( Return information about a specific loaded kernel ) cspice_ktotal ( Return the number of kernels loaded using KEEPER ) cspice_lmpool ( Load variables from memory into the pool ) cspice_pcpool ( Put character strings into the kernel pool ) cspice_pdpool ( Put double precision values into the kernel pool ) cspice_pipool ( Put integers into the kernel pool ) cspice_stpool ( Return a string associated with a kernel variable ) cspice_unload ( Unload a kernel ) Appendix D -- Summary of Key Text Kernel Parameter Values
Maximum variable name length: 32 Maximum length of any element of a string value: 80 Maximum number of distinct variables: 26003 Maximum number of numeric variable values: 400000 Maximum number of character strings stored in the kernel pool as values: 15000 Maximum length of a file name, including any path specification, placed in a meta-kernel: 255Other applicable limits
Maximum total number of kernel files of any type that can be loaded simultaneously: 5000 Appendix E -- Revision History
Updated numeric limits. Added discussion of kernel loading errors. Made small additions to discussion of file name restrictions. Added mention of treatment by GIPOOL of non-integer values. Made small addition to discussion of ``@'' time values in text kernels. Corrected a ``setparamsize'' setting that truncated function names. Changed quoting style to standard (`` '')for .ftm documents. Changed double quotes to single quotes in IDL code example. Made other miscellaneous, minor edits. 2011 October 24, CHA (JPL) Re-organization and added further clarifications. Also added Appendix A discussion of competing data, Appendix B providing a glossary of terms, and an Appendix C summarizing kernel subsystem functions. Includes much information provided by N. Bachman. 2011 APR 18, EDW (JPL) Edits for clarity and organization. Added description of the 32 character limit on user defined kernel pool variable names for cspice_furnsh, cspice_lmpool, cspice_pcpool, cspice_pdpool, and cspice_pdpool. Added mention that tabs are now allowed in text kernels. cspice_kclear now included in routines list. 2009 APR 08, BVS (JPL) Previous edits.
|


Bar Charts are defined by the flot
directive. The dataset and options attribute define the bar chart data and
options respectively. Dataset and Options are defined within the BarChartCtrl.
Note: Refer to the Flot Options page for details of chart options.
To convey chart information to users with assistive technologies, you can include a text version of the data. Use the sr-only
class to make the text hidden but visible to screen readers, and give the container a tabindex
attribute
so it can be reached with the keyboard, and place it near the chart.
Note: This component can be used in an Angular application by importing the HybridModule.


Park's Barbeque
Full Review: "On a blisteringly cold day in LA, several bros and I stepped into Park's for some kalbi and soondobu jjigae to warm the soul. Love the meat here - it's always so fresh and juicy. We ordered 4 platters of kalbi, 3 platters of bulgolgi, 3 platters of samgyobsal (pork belly), 4 orders of NY strip steak, 2 orders of grilled squid, and 4 bowls of soondobu jjigae. And the banchan here are soooo good!! Especially love the kimchi - Park's ferments their kimchi so it's pretty sour when you eat it, which is what I love. But, some of my non-Korean friends don't love it as much as I do, which is cool. My only request for Park's is to serve their food faster next time. They do use a classic KBBQ stalling technique to try to save some cash." - 12/28/2014
Service: 3/5
Atmosphere: 4/5
Value: 5/5
Food Quality: 5/5
Dress: Casual
Would Recommend: Yes


Actions, resources, and condition keys for AWS Resource Access Manager (RAM)
AWS Resource Access Manager (RAM) (service prefix:
ram
) provides the following service-specific resources, actions, and condition context keys for use in IAM permission policies.
References:
-
Learn how to configure this service .
-
View a list of the API operations available for this service .
-
Learn how to secure this service and its resources by using IAM permission policies.
Topics
Actions defined by AWS Resource Access Manager (RAM)
You can specify the following actions in the
Action
element of an IAM policy statement. Use policies to grant permissions to perform an operation in AWS. When you use an action in a policy, you usually allow or deny access to the API operation or CLI command with the same name. However, in some cases, a single action controls access to more than one operation. Alternatively, some operations require several different actions.
The
Resource types
column of the Actions table indicates whether each action supports resource-level permissions. If there is no value for this column, you must specify all resources ("*") to which the policy applies in the
Resource
element of your policy statement. If the column includes a resource type, then you can specify an ARN of that type in a statement with that action. If the action has one or more required resources, the caller must have permission to use the action with those resources. Required resources are indicated in the table with an asterisk (*). If you limit resource access with the
Resource
element in an IAM policy, you must include an ARN or pattern for each required resource type. Some actions support multiple resource types. If the resource type is optional (not indicated as required), then you can choose to use one of the optional resource types.
The
Condition keys
column of the Actions table includes keys that you can specify in a policy statement's
Condition
element. For more information on the condition keys that are associated with resources for the service, see the
Condition keys
column of the Resource types table.
For details about the columns in the following table, see Actions table .
| Actions | Description | Access level | Resource types (*required) | Condition keys | Dependent actions |
|---|---|---|---|---|---|
| AcceptResourceShareInvitation | Grants permission to accept the specified resource share invitation | Write | |||
| AssociateResourceShare | Grants permission to associate resource(s) and/or principal(s) to a resource share | Write | |||
| AssociateResourceSharePermission | Grants permission to associate a Permission with a Resource Share | Write | |||
| CreatePermission | Grants permission to create a Permission that can be associated to a Resource Share | Write |
ram:TagResource |
||
| CreatePermissionVersion | Grants permission to create a new version of a Permission that can be associated to a Resource Share | Write | |||
| CreateResourceShare | Grants permission to create a resource share with provided resource(s) and/or principal(s) | Write | |||
| DeletePermission | Grants permission to delete a specified Permission | Write | |||
| DeletePermissionVersion | Grants permission to delete a specified version of a permission | Write | |||
| DeleteResourceShare | Grants permission to delete resource share | Write | |||
| DisassociateResourceShare | Grants permission to disassociate resource(s) and/or principal(s) from a resource share | Write | |||
| DisassociateResourceSharePermission | Grants permission to disassociate a Permission from a Resource Share | Write | |||
| EnableSharingWithAwsOrganization | Grants permission to access customer's organization and create a SLR in the customer's account | Permissions management |
iam:CreateServiceLinkedRole organizations:DescribeOrganization organizations:EnableAWSServiceAccess |
||
| GetPermission | Grants permission to get the contents of an AWS RAM permission | Read | |||
| GetResourcePolicies | Grants permission to get the policies for the specified resources that you own and have shared | Read | |||
| GetResourceShareAssociations | Grants permission to get a set of resource share associations from a provided list or with a specified status of the specified type | Read | |||
| GetResourceShareInvitations | Grants permission to get resource share invitations by the specified invitation arn or those for the resource share | Read | |||
| GetResourceShares | Grants permission to get a set of resource shares from a provided list or with a specified status | Read | |||
| ListPendingInvitationResources | Grants permission to list the resources in a resource share that is shared with you but that the invitation is still pending for | Read | |||
| ListPermissionAssociations | Grants permission to list information about the permission and any associations | List | |||
| ListPermissionVersions | Grants permission to list the versions of an AWS RAM permission | List | |||
| ListPermissions | Grants permission to list the AWS RAM permissions | List | |||
| ListPrincipals | Grants permission to list the principals that you have shared resources with or that have shared resources with you | List | |||
| ListReplacePermissionAssociationsWork | Grants permission to retrieve the status of the asynchronous permission replacement | List | |||
| ListResourceSharePermissions | Grants permission to list the Permissions associated with a Resource Share | List | |||
| ListResourceTypes | Grants permission to list the shareable resource types supported by AWS RAM | List | |||
| ListResources | Grants permission to list the resources that you added to resource shares or the resources that are shared with you | List | |||
| PromotePermissionCreatedFromPolicy | Grants permission to create a separate, fully manageable customer managed permission | Write | |||
| PromoteResourceShareCreatedFromPolicy | Grants permission to promote the specified resource share | Write | |||
| RejectResourceShareInvitation | Grants permission to reject the specified resource share invitation | Write | |||
| ReplacePermissionAssociations | Grants permission to update all resource shares to a new permission | Write | |||
| SetDefaultPermissionVersion | Grants permission to specify a version number as the default version for the respective customer managed permission | Write | |||
| TagResource | Grants permission to tag the specified resource share or permission | Tagging | |||
| UntagResource | Grants permission to untag the specified resource share or permission | Tagging | |||
| UpdateResourceShare | Grants permission to update attributes of the resource share | Write | |||
Resource types defined by AWS Resource Access Manager (RAM)
The following resource types are defined by this service and can be used in the
Resource
element of IAM permission policy statements. Each action in the
Actions table
identifies the resource types that can be specified with that action. A resource type can also define which condition keys you can include in a policy. These keys are displayed in the last column of the Resource types table. For details about the columns in the following table, see
Resource types table
.
| Resource types | ARN | Condition keys |
|---|---|---|
| resource-share |
arn:$
{
Partition}:ram:$
{
Region}:$
{
Account}:resource-share/$
{
ResourcePath}
|
|
| resource-share-invitation |
arn:$
{
Partition}:ram:$
{
Region}:$
{
Account}:resource-share-invitation/$
{
ResourcePath}
|
|
| permission |
arn:$
{
Partition}:ram::$
{
Account}:permission/$
{
ResourcePath}
|
|
| customer-managed-permission |
arn:$
{
Partition}:ram:$
{
Region}:$
{
Account}:permission/$
{
ResourcePath}
|
Condition keys for AWS Resource Access Manager (RAM)
AWS Resource Access Manager (RAM) defines the following condition keys that can be used in the
Condition
element of an IAM policy. You can use these keys to further refine the conditions under which the policy statement applies. For details about the columns in the following table, see
Condition keys table
.
To view the global condition keys that are available to all services, see Available global condition keys .
| Condition keys | Description | Type |
|---|---|---|
| aws:RequestTag/${TagKey} | Filters access by the tags that are passed in the request when creating or tagging a resource share. If users don't pass these specific tags, or if they don't specify tags at all, the request fails | String |
| aws:ResourceTag/${TagKey} | Filters access by the tags associated with the resource | String |
| aws:TagKeys | Filters access by the tag keys that are passed when creating or tagging a resource share | ArrayOfString |
| ram:AllowsExternalPrincipals | Filters access by resource shares that allow or deny sharing with external principals. For example, specify true if the action can only be performed on resource shares that allow sharing with external principals. External principals are AWS accounts that are outside of its AWS organization | Bool |
| ram:PermissionArn | Filters access by the specified Permission ARN | ARN |
| ram:PermissionResourceType | Filters access by permissions of specified resource type | String |
| ram:Principal | Filters access by format of the specified principal | String |
| ram:RequestedAllowsExternalPrincipals | Filters access by the specified value for 'allowExternalPrincipals'. External principals are AWS accounts that are outside of its AWS Organization | Bool |
| ram:RequestedResourceType | Filters access by the specified resource type | String |
| ram:ResourceArn | Filters access by the specified ARN | ARN |
| ram:ResourceShareName | Filters access by a resource share with the specified name | String |
| ram:ResourceTag/${TagKey} | Filters access by the tags associated with the resource | String |
| ram:ShareOwnerAccountId | Filters access by resource shares owned by a specific account. For example, you can use this condition key to specify which resource share invitations can be accepted or rejected based on the resource share owner’s account ID | String |


--- title: Fluid Responsive Grid excerpt: There are many grid generators and frameworks out there. Many of them are really good. Most of them use a hardcoded number of columns (8, 12, 16 or whatever) with dummy ".grid-x" classes. I don't want that. date: '2012-05-27 21:04:49 +0200' date_gmt: '2012-05-27 19:04:49 +0200' categories: - Webdev tags: - tweets - web - design - development ---
There are many grid generators and frameworks out there. Many of them are really good. Most of them use a hardcoded number of columns (8, 12, 16 or whatever) with dummy ".grid-x" classes. I don't want that. What I want is a tool to generate a fluid, responsive and flexible grid system with any number of (nested) columns with custom gutter width. And I want to be able to quickly generate that grid system with my own classes (I might even use those dummy ".grid-x" classes, why not?).
So I've put together one more grid generator by merging The Semantic Grid with Trevor Davis' Sass & Compass Grid. You need LESS CSS preprocessor to use this tool. See the Fluid Grid on GitHub and play with it, to see if you can use it in your own projects.


Password Reminder
Click on the schools email addresses that you want to send passwords to.
You can edit the message that is sent by changing the subject and message.
-schoolname-
and
-password-
will be replaced by the respective name and password when sent to a school.
NOTE
- only schools that have email addresses are shown opposite.
Subject:
Message:
Dear -schoolname-, The following is your password for the BLPShare website. -password- Visit http://www.blpshare.co.uk and use the password above to login. Many thanks, TLO admin
Choose which schools to send this message to:
{ foreach my $org (@{$c{org}->get_child_array('org')}) { my $name = $org->name; my $org_id = $org->get_id; my $has_emails = undef; $OUT.=<<"+++";
$name
+++ foreach my $school (@{$org->ensure_child_array('users')}) { my $school_name = $school->get_fullname; my $email1 = $school->email1; my $email1name = $school->email1name; my $email2 = $school->email2; my $email2name = $school->email2name; if(($email1!~/\w/)&&($email2!~/\w/)) { next; } $has_emails = 1; my $school_id = $school->get_id; $OUT.=<<"+++";
$school_name
+++ if($email1=~/\w/) { $OUT.=<<"+++";
$email1name - $email1
+++ } if($email2=~/\w/) { $OUT.=<<"+++";
$email2name - $email2
+++ } } if(!$has_emails) { $OUT.=<<"+++"; +++ } } }
Sending Messages - Please Wait...


Review Order
Your order failed. Please try again.
Products
Edit
Total: {{subTotal() | currency}}
Billing Information
Edit
- Card Number: {{checkoutService.paymentInformation.maskedCardNumber()}}
- Expriation: {{checkoutService.paymentInformation.expirationMonth}}/{{checkoutService.paymentInformation.expirationYear}}
Shipping Information
Edit
{{checkoutService.shippingInformation.name}}
{{checkoutService.shippingInformation.street}}
{{checkoutService.shippingInformation.city}} {{checkoutService.shippingInformation.state | uppercase}} {{checkoutService.shippingInformation.zip}}


DEVSOC'21
Teams-
Log out
All
Submitted
Not Submitted
Shortlisted For DEVSOC'21
Not Shortlisted For DEVSOC'21
Shortlisted For Round 2
Not Shortlisted For Round 2
Selected For Final Round


Neuroplasticity and The Growth Mindset
In this sprint I learnt about Neuroplasticity and The Growth Mindset and how its related to my learning journey.
Neuroplasticity
The principle of neuroplasticity tells us how our brain goes through the process of learning, that if we confront the challenges of learning through practice we can improve our abilities in that area. For example if you practice a musical instrument over and over you get better and better day by day because the brain develops new neuron pathways as you practice more and more to make accessing the data for playing the instrument easier which will result in being able to play it easier and faster. This means that IQ or intelligence does not play a major role in learning. Its consistency that makes you a better learner.
To me this means that in order to be a better programmer I need to practice more. I don't have to be super smart, I just need to be consistent.
Some of the ways to increase your neuroplasticity are:
Travelling: this exposes your brain to novel stimuli and new environments, opening up new pathways and activity in the brain;
Using mnemonic devices: memory training can enhance connectivity in the prefrontal parietal network and prevent some age-related memory loss;
Learning a musical instrument: may increase connectivity between brain regions and help form new neural networks;
Non-dominant hand exercises: can form new neural pathways and strengthen the connectivity between neurons;
Reading fiction: increases and enhances connectivity in the brain as well as increasing creativity;
Expanding your vocabulary: activates the visual and auditory processes as well as memory processing;
Here is a link to a website that I found very useful for learning more about Neuroplasticity.
Growth Mindset
By understanding that our brain is not static and our intelligence and learning ability is not fixed, we can be more confident and encouraged about learning. Believing that our brain is malleable and that it can grow, stops us from having a negative fixed mindset that tells us we are not smart enough or we can't learn a specific subject because we're not good enough. Instead, we can develop a growth mindset to believe in our ability of learning. If we work hard and put the energy in we can learn and understand anything!
Knowing that learning is a journey and how it works really encourages me and gives me hope for success.
With effort, it's possible to increase intelligence levels, talents, and abilities, therefore I'll not let myself give in to the temptation of giving up.
Here is a link to a website that I found very useful for learning more about Growth Mindset.
How Neuroplasticity and Growth Mindset Has Affected My Learning Plan And Strategies
By understanding Neuroplasticity and Growth mindset, I've altered my learning plans a bit, leaving more space for sleep and rest and more emphasis on practice.


---
layout: page
title: "About"
description: "Statement"
active: about
header-img: "img/about-bg.jpg"
---
CREDITS
The posts were written and exported as markdown ready for publication with Dillinger, a useful online editor.
All the commits were performed with the help of Source Tree app.
The photos are organised in galleries with ISOTOPE.
The search overlay function code lies in SUPER SEARCH.
Image Source: Unsplash


>> type `ping`, `time`, or `echo [message]` to see what's happened >> type `count 15` (default 10) and you can interact with bot's card >> Download Saihubot


PMT is always available to answer any questions that you may have.
Plase don’t hesitate to contact us, we are here to help. To answer any questions or concerns you may have please fill out the form below or use one of these methods:
Toll-free:
Local phone:
Fax:
Email:
To contact management to escalate a question/concern or issue, please email:


Reports assignment expressions nested inside other expressions. While admirably terse, such expressions may be confusing, and violate the general design principle that a given construct should do precisely one thing.
Example:
a = b = 1


Hi guys! Today I had created my first plugin with commonplace name - Battlelog Some Improvements/Removes. I'm noob in Java, that's why you shouldn't see my plugin code :)
The idea belongs to the user I-Billy-Bonka-I, and I liked it immediately. If you have any ideas what else to remove - write here. In the meantime here's what the plugin can do at the moment:
1. Removes premium calendar tile in the main page
2. Removes Missions tile in the main page
3. Removes Recommended server tile in the main page
4. Removes Buttons "Play something" in the main page
5. Removes Suggestions tile in the main page
6. Removes right column below the main page tiles
7. Removes "Buy Hardline" tile in the main page
8. Fixed word wrap "commander" and so on any Platoon page in some languages
9. Button that's remove/show Com.center
10. Removes "BL Mobile App" Tile in ComCenter
In coming future:
1. Button that's combine Chat and Friends UI (maybe)
I-Billy-Bonka-I
Perfect.
Thank you so much.
Post edited 1 x times, last by
DaniluK4000
Community Manager
Topicstarter
DaniluK4000
Community Manager
Update 1.1 - Now you can hide the ComCenter for current session!
And now it available for all versions of BF!


Configure a GEE virtual host for LDAP authentication¶
You can use LDAP authentication, which is based on Microsoft
Active Directory, to authenticate users to access your GEE virtual
hosts. GEE server software is based on Apache httpd
.
It is easy to administer and manage user accounts. You can use a
simple .htpasswd
to secure a GEE virtual host, then you can
assign the permissions levels via groups or user level. If you
have an existing Active Directory user catalog, you can use that
instead of implementing a redundant authentication system. For
information about enabling your Active Directory for LDAP, see the
OpenLDAP documentation.
Tip
This article explains how to configure a virtual host for LDAP authentication using GEE Server 5.x.
To configure a GEE virtual host for LDAP authentication:
Make sure that the LDAP modules are loaded on your Apache server. For most GEE installations, these are loaded automatically.
Create a
geserver
Active Directory account that can access the user directory, and make sure to document the attributes.Load the modules in your
/opt/google/gehttpd/conf.d/virtual_servers/private_host.location
file or your custom virtual host file.After the modules are loaded, you can control access by querying the directory for particular attributes.
Point Apache to the LDAP server
AuthLDAPURL
key directive.An example of an
AuthLDAPURL
directive is:AuthLDAPURL ldap://ldapserver.example.com:389/ou=Users,dc=example,dc=com?uid
The key directive format declares the LDAP server, the distinguished name (DN), and the attribute to use in the search (typically the
Uid
attribute in theUsers
organizational unit). You can also customize these filters for additional security constraints.Restart the GEE server to load the modules into the system:
# /etc/init.d/geserver restart
Create a user account in Active Directory
geserver
. This can be any user account that has limited access. The user account only needs access to the global catalog. Make sure that your user has the full organizational unit name.
To bind to Active Directory GUI:
If you do not know your LDAP domain name, ask your system administrator. You can also find your domain name by searching for it in the format
Dn: CN=geserver,CN=Users,DC=location,DC=company,DC=com
. In this example, the domain name islocation.company.com
.Use your domain name to configure the Apache module. Alternatively, you can use the command prompt:
dsadd user UserDN [-samid SAMName] -pwd {Password|*}
Add the directives to your virtual server file at
/opt/google/gehttp/conf.d/virtual_servers
.For testing purposes, add the lines below to the
private_host.location
file:<Location /private/*> AuthType Basic AuthName "LDAP LOGIN" AuthBasicProvider ldap AuthLDAPURL "ldap://ldapserver.example.com:389/ou=Users,dc=example,dc=com?uid" AuthLDAPBindDN<EMAIL_ADDRESS>AuthLDAPBindPassword "somepassword" Require valid-user </Location>
Restart your server and try to access the virtual server via the client. A login screen appears. If you cannot access Apache, open the file error log at
/opt/google/gehttpd/logs/error_log and access_log
.
Directives
require valid-user
. Allows all users who log in with correct passwords.AuthLDAPBindDN
. The distinguished name (DN) of the user account that Apache uses to connect to the directory system and authenticate the user.AuthLDAPBindPassword
. The password for the user account configured with theAuthLDAPBindDN
directive.AuthLDAPURL
. The URL that tells where the directory server is, where to look for users, which user attribute is used to identify a user, and other miscellaneous things that are specific to the LDAP query syntax.AuthBasicProvider
. Tells Apache which authentication module to use for Basic Authentication.
For more information, see the Apache mod_ldap mod_authnz_ldap and mod_auth_basic documentation.
Tip
To troubleshoot any connection issues, begin by checking the logs on the LDAP server to make sure GEE server is correctly making authentication requests.


Richard Wolfe
Manager
- Id: M10
- Email<EMAIL_ADDRESS>- Office Number: 456654324
Deepa krishnan
Engineer
- Id: E01
- Email<EMAIL_ADDRESS>- Github Name: deeparkrish
Vivian Bob
Engineer
- Id: E02
- Email<EMAIL_ADDRESS>- Github Name: vivi
Benny Dayal
Intern
- Id: I011
- Email<EMAIL_ADDRESS>- School: UCBerkeley
Jared Doug
Intern
- Id: I021
- Email<EMAIL_ADDRESS>- School: USDavis


- Display rules violated passenger count
User ID {{ userID }}
Journey Date {{ journeryDate }}
Starting Location {{ startingLocation }}
Destination Location {{ destinationLocation }}
Destination {{ distance }}
Fare {{ fare }}
Route Name {{ routeName }}
Day {{ day }}
Hour {{ hour }}
Fine {{ fine }}
Email {{ emaila }}


{%extends "base.html"%} {% block breadcrumb %} | All Programs Scoreboard {% endblock %} {%block body%}
The following appear in sites but are missing from common.PROGRAMS:
The following appear in common.PROGRAMS:
| Program | # Sites |
|---|---|
| {{ program }} | {{ sites }} |


| ->
{{tx.value}} ETH |
You are about to send {{tx.value}} ETH to {{tx.to}} from {{tx.from}}
You are sending on the {{configs.getNodeName()}} chain, which is not susceptible to replay attacks.
The node you are sending through is provided by MyEtherWallet.
You are about to sign {{tx.string}} from account {{tx.from}}
Signature: {{tx.hash}}
{{tx.msg}}
| ->
{{tx.value}} ETH |
TX ID: {{tx.hash}}
{{tx.msg}}


We are a team based in the School of Computing, National University of Singapore.
Note that the following sub-projects (and sister projects) manage their own list of contributors:
Role: Project Advisor
Role: Mentor [2018 Jan - ]
Area Lead for Code Quality [2017 Aug - 2017 Dec]
Committer [2016 Dec - 2017 Jul]
Role: Project Lead [2020 May - ]
Committer [2019 May - 2020 Apr]
Role: Committer [2019 Jan - ]
Role: Committer [2019 Jan - 2020 May]
Role: Mentor [2018 Apr - 2019 Dec]
Project Lead [2017 Aug - 2018 Apr]
Committer [2017 Jan - 2017 Aug]
Contributor [2016 Dec - 2017 Jan]
Project Lead: [2018 Apr - 2019 Dec]
Area Lead for Logic [2017 Aug - 2018 - Apr]
Committer [2017 May - 2017 Aug]
Contributor [2016 Dec - 2017 Apr]
Role: Mentor [2018 Jan - 2019 Dec]
Committer [2017 Aug - 2017 Dec]
Contributor [2017 Feb - 2017 Jul]
Committer: [2018 Mar - 2018 Dec]
Contributor: [2018 Jan - 2018 Feb]
Committer: [2018 Mar - 2018 Dec]
Contributor: [2018 Jan - 2018 Feb]
Committer: [2018 Mar - 2018 Dec]
Contributor: [2018 Jan - 2018 Feb]
Committer [2017 Jan - 2017 May]
Contributor [2016 Dec - 2017 Jan]
Committer [2017 Jan - 2017 Apr]
Contributor [2016 Dec - 2017 Jan]
Project Mentor [2017 Arp - 2017 Dec]
Committer [2017 Jan - 2017 Apr]
Contributor [2016 Dec - 2017 Jan]
Area Lead for: UI [2016 Aug - 2017 May]
Area Lead for: Model [2016 May - 2017 May]
Main developer for the first version of AddressBook-Level1
Committer [2017 May - 2017 Aug]
Area Lead for: Dev Ops [2016 May - 2017 May]
Committer [2017 Jan - 2017 Apr]
Contributor [2016 Dec - 2017 Jan]
Area Lead for: Threading [2016 Aug - 2017 May]
Area Lead for: UI [2016 May - 2017 May]
Wrote the initial version of the now-defunct Collate tool [2015 Jun - 2015 Sep]


#MONITORYOURFITNESS
About
View the App
Nutritional sugesstionsSuggested Activities
The Team
If you are seeing this, the audio player is unsupported in this browser.
When it comes to losing weight, we’ve all heard the formula “it’s 80% nutrition and 20% exercise.” Follow simple nutritional tips and these will help you in a long way in your fitness journey.


Web Developer ◈ Designer ◈ Adventurer
Regan Lussier is a front-end developer with an eye for design. Who is always up for a challenge. Currently resides in Dallas, TX. She has traveled the world and enjoys working remotely. When Regan is not coding, she likes to spent her time outdoors and enjoying the music and theatre scene.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Aut optio velit inventore, expedita quo laboriosam possimus ea consequatur vitae, doloribus consequuntur ex. Nemo assumenda laborum vel, labore ut velit dignissimos.
For inquiries or any questions. Please reach out to<EMAIL_ADDRESS>or<PHONE_NUMBER>. Follow me on Social Media.


Nintendo details Mario Kart Tour’s Winter tour
by My Nintendo News AdminThe Winter tour in the popular smartphone title Mario Kart Tour will be starting later today and Nintendo has rather handily produced a video staring Lakitu showing what you can expect once the event begins at 10pm PT. You’ll be able to play the DK Pass track from Mario Kart DS and unlock the following characters: Santa Mario, Pink Gold Peach and Black Shy Guy. There’s also new karts and gliders for you to unlock. Have a watch down below.


SenseLife
Hello, User
Log Out
Hello, User
Navigation
Dashboard
Devices
Authorize Data
Authorize Data
Your Contacts
Contact Name
Relationship
Gokarna
Brother
Authorize
Authorize via email
Email address:
Authorize via phone
Phone Number:


A helper that tests 'DBI' back ends for conformity
to the interface.
| Version: |
1.5-2 |
| Depends: |
R (≥ 3.0.0) |
| Imports: |
blob, DBI (≥ 0.4-9), desc, hms, methods, R6, testthat (≥
1.0.2), withr |
| Suggests: |
knitr, lintr, rmarkdown |
| Published: |
2018-01-25 |
| Author: |
Kirill Müller [aut, cre],
RStudio [cph],
R Consortium [fnd] |
| Maintainer: |
Kirill Müller <krlmlr+r at mailbox.org> |
| BugReports: |
https://github.com/rstats-db/DBItest/issues |
| License: |
LGPL-2 | LGPL-2.1 | LGPL-3 [expanded from: LGPL (≥ 2)] |
| NeedsCompilation: |
no |
| Materials: |
README NEWS |
| In views: |
Databases |
| CRAN checks: |
DBItest results |


Case
: case
| Values: | Acc | Com | Dat | Nom |
A case is each of the different forms a nominal word can take to express a syntactic function in a sentence. Cases are characteristic (but not exclusive) of many Indo-European languages.
In Spanish, the closest equivalent that has been preserved is in the pronouns. In UD Spanish morphology, three cases are distinguished: Nominative, Dative and Accusative.
Nom
: nominative
The Nominative case is used when the pronoun functions as the subject of the sentence, which is the person, place, or thing doing the action. Examples of this in Spanish are pronouns like “yo” (I), “tú” (you), and “nosotros” (we).
Examples:
- Yo voy a la biblioteca. “I go to the library.”
- Nosotros comemos siempre. “We always eat.”
Acc
: accusative
The Accusative case is used for direct objects, which directly receive the action of the verb. In Spanish, the pronouns used in the accusative case are “me” (me), “te” (you), “lo” (him, it), and “la” (her, it), among others.
Examples:
- Yo lo veo. “I see it.”
- Mi hermana nos enseña. “My sister teaches us.”
Dat
: dative
Dative case is used for indirect objects, which indirectly receive the action of the sentence. The Spanish pronouns for the dative case are “me” (me), “te” (you), “le” (him, her, it), and “nos” (us), among others.
Examples:
- Yo le doy el regalo. “I give him the present.”
- Mi hermana me escribe. “My sister writes me.”
Com
: comitative
The comitative case is normally not morphological in Spanish and the corresponding meaning is expressed by the preposition con “with”. However, three pronouns fuse with the preposition and create a form that is different from other case forms of the pronoun and that can be described as comitative.
Examples
- conmigo “with me”
- contigo “with you”
- consigo “with himself/herself”
Acc,Nom
: nominative or accusative
In UD Spanish treebanks, certain pronouns are annotated with the double case value Acc,Nom
, which signifies that
these pronouns can function in both the Accusative (as direct objects) and Nominative (as subjects).
This group of pronouns includes “nosotros/nosotras” (we), “él/ella/ello” (he/she/it), and “ellos/ellas” (they). These
pronouns can be used as the subject of a sentence, but they can also receive the action of a verb directly, which would
typically be the function of an object. This dual function is why they are annotated with both the Nom
and Acc
case
values.
For example, consider the sentence Nosotros vemos a ellos. Here, nosotros is the subject of the sentence
(Nominative case), and ellos is the direct object (Accusative case). In this sentence, both “nosotros” and “ellos”
would be tagged with Case=Acc,Nom
, indicating their potential to function in either case, depending on the sentence
structure.
References
- REAL ACADEMIA ESPAÑOLA (2009): Nueva gramática de la lengua española. Madrid: Espasa.
Case in other languages: [am] [apu] [arr] [bej] [bg] [cs] [el] [eme] [en] [ess] [et] [fi] [ga] [gn] [grc] [gub] [hu] [hy] [kmr] [koi] [kpv] [ky] [mdf] [myu] [myv] [pcm] [pt] [qpm] [ru] [sl] [sv] [tl] [tpn] [tr] [tt] [u] [uk] [urb] [urj]


{% extends 'base.html' %} {% load commonmark %} {% block title %} Fix IRC permissions for NickServ user {{ request.user.profile.nickserv_username }} for IRC channel {{ team.irc_channel_name }} {% endblock %} {% block content %}
This will make the bot re-add IRC ACL for your NickServ user {{ request.user.profile.nickserv_username }} for IRC channel {{ team.irc_channel_name }}. Use this in cases where you are unable to join the team IRC channel after entering your NickServ username in your profile.
{% endblock %}