Nanodiffraction¶
-
class
@nanodiffraction.
nanodiffraction
(varargin)¶ NANODIFFRACTION Class that defines the experimental geometry and calculates geometrical parameters accordingly. The key method is ‘’ that is used to process x-ray diffraction data obtained from scanning experiments.
EXPERIMENT = NANODIFFRACTION()
creates an object, an experiment, with a list of key-value pairs. See further below for a list of keys and possible values.The nanodiffraction class holds two types of parameters, experiment-specific parameters and scan parameters. In addition, it contains smaller useful helper functions such as q_of_n() that takes in pixel coordinates and transforms them into q coordinates. Here is a short description of the available helper functions stored in
EXPERIMENT.helper
n_of_q(qr)
:- Requires a reciprocal wavevector coordinate and calculates the according pixel coordinate
q_of_n(n)
:- Requires a pixel coordinate and calculates the according reciprocal wavevector coordinate
twoTh_of_n(n)
:- Requires a pixel coordinate and calculates the according scattering angle 2*theta
to1dcol(x)
:- Requires a 2d array x and transforms this array into a 1d column vector
to1drow(x)
:- Requires a 2d array x and transforms this array into a 1d row vector
to2d(x,ny,nz)
:- Requires a 1d array x and transforms this array into a 2d array with dimensions (nz,ny)
reduce(i,start,skip)
:- Simplified indexing
simplify_sf(data)
:- Not used
scale(x)
:- Requires a 2d array x and rescales the array into the range (0,1) based on the minimum and maximum values in the array
scaleH(x,h)
:- Requires a 2d array x and rescales the array into the range (0,h) based on the minimum and maximum values in the array and the high value h
scaleLH(x,l,h)
:- Requires a 2d array x and rescales the array into the range (l,h) based on the minimum and maximum values in the array and the low value l and the high value h
clipL(x,l)
:- Requires a 1d or 2d array x. Values below the clipping value l will be set to l.
clipH(x,h)
:- Requires a 1d or 2d array x. Values above the clipping value h will be set to h.
clipLH(x,l,h)
:- Requires a 1d or 2d array x. Values below the clipping value l will be set to l and values above the clipping value h will be set to h.
autoClip(x)
:- Requires a 1d or 2d array and calculates the 5% low and high percentile.
getIndex(x,xloc)
:- Calculates the closest linear index in the 1d array x based on the query value xloc
addTransp(transp)
:- Overlays a transparency map over the current figure. Values in the transparency map should range between (0,1) and the size of the transparency map has to match the size of the data in the figure
normDist(x)
:- Removes the mean and divides by the standard deviation of a distribution x.
In order to perform calculations on real data, one has to couple the nanodiffraction class to the files class to “tell the experiment, where the data is stored”. This can be achieved by using the function
nanodiffraction.attach()
(seehelp attach
for usage information).Furthermore, three other properties of the nanodiffraction class are of interest:
- nanodiffraction.mask:
- A bad pixel mask can be set using the function set_mask().
- nanodiffraction.sels
- A mask identifying pixels that shall be analyzed can be defined using set_selection(). More selections can be added using add_selection(). This is useful since data has to be read only once, while the analysis can be performed multiple times on the same data (but different selections). In many cases it is useful to use the functions radial_mask() and azimuthal_mask() in order to define selections.
- nanodiffraction.corr
- A correction matrix that will be multiplied with the data prior to the analysis to compensate for semi-transparent objects such as glass capillaries.
- The following options are supported:
- energy: [0] (not necessary if wavenumber or wavelength are given)
- x-ray photon energy in [eV]
- wavenumber: [0] (not necessary if energy or wavelength are given)
- x-ray photon wavenumber in [m^-1]
- wavelength: [0] (not necessary if wavenumber or energy are given)
- x-ray photon wavelength in [m]
- detDistance: [5]
- detector distance in [m]
- pixelsize: [172E-6]
- detector pixel size in [m]
- Ny: [487]
- number of detector pixels along y axis (horizontal axis)
- Nz: [619]
- number of detector pixels along z axis (vertical axis)
- pby: [1]
- horizontal primary beam position relative to first pixel in top-left corner (when viewed along beam propagation direction)
- pbz: [1]
- vertical primary beam position relative to first pixel in top-left corner (when viewed along beam propagation direction)
- fluoCounters: [{}]
- Cell array of thresholds to generate maps of different element distributions
Example
See the following example for help:
experiment = nanodiffraction('energy',12.8e3,'detDistance',1.2,... 'pby',121.2,'pby',144.1,... 'Ny',1100,'Nz',1220,... 'fluoCounters',{{'total',1 4100},{'caka',600,660}});
-
See seperate help for each method. Also, refer to the methods
-
summary in ``doc nanodiffraction``.
Copyright 2017 Institute for X-ray Physics (University of Göttingen)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
add_selection
(sel)¶ ADD_SELECTION The function adds a logical selection matrix to the current stack of selections.
selections = add_selection(selection)
- The following arguments are supported:
- selection: []
- A two-dimensional array. The input should be a logical array.
Example
See the following example for help:
e = nanodiffraction(<some settings>); sel_small = e.radial_mask('r1',0,'r2',1.2,'grid',e.qr); sel_large = e.radial_mask('r1',2.4,'r2',3.2,'grid',e.qr); sel_all = ones(e.Nz,e.Ny); e.set_selection(sel_all); e.add_selection(sel_small); e.add_selection(sel_large);
- Output arguments:
- selections:
- Current set of selections.
Note, that the selections are stored in:(nanodiffraction_class).sels
-
analyze_scan
(method, varargin)¶ ANALYZE_SCAN Main method of nanodiffraction class. It analyzes a scan based on several implemented methods that can be chosen in a random order and combination. However, corrections are always performed before any subsequent analysis. The ‘’ functionality has a special role, as it is a method but is always performed before any other analysis but after background and other corrections, for obvious reasons.
RESULT = ANALYZE_SCAN(method,options)
outputs the results as a struct where each entry in the struct is named after the method that was chosen for analysis. All relevant data can be found therein.- The following arguments are accepted:
- method: [] (required)
A string composed of the following options: ‘debug’, ‘rotate’,’pca’,’stxm’,’maxProj’,’crystal’,’fluo’, ‘average’,’sum’,’data’,’circDist’. Methods can be combined using a ‘+’ symbol between the methods:
e.g.
'stxm+pca+maxProj+sum'
- options: [] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets:
- roi: []
- A logical mask of size SNy x SNz. A logical (1) indicates a scan point that will be analyzed.
- yCrop, zCrop: [start end]
- Start and end can be given to define a certain range within the scan to be analyzed.
- ySkip, zSkip: [1]
- If only every n-th scan point should be analyzed
- emptySub: [‘off’]
Subtracts an empty image from the data immediately after the data has been read. If an empty image is given (see keyword ‘empty’), it will be used, otherwise, it will be attempted to use the empty image that was defined at an earlier stage using set_empty().
Options: ‘on’ | ‘off’
- correction: [‘off’]
Multiplies a 2d correction matrix with the data. E.g. used to account for semitransparent objects obscuring the detector
Options: ‘on’ | ‘off’
- fluoCounters: [{}]
The format is {{<name>,<channel_low>,<channel_high>},…},
e.g.
{{'caka',1000,1400},{},...}
- parallel: [‘off’]
- When turned on, all available workers will be used to speed up the calculation process. Warning: This is currently only implemented for the stxm method.
- scanmode: [‘horz’]
See description below.
Options: ‘horz’|’horzalt’|’vert’|’vertalt’
Some methods can be given a set of arguments in a struct. Note, that all struct parameters are optional. If some or all arguments are not given, then default values will be used, as indicated in paranthesis [default value].
- pca:
Performs a PCA analysis as e.g. demonstrated in Bernhardt, et.al., X-Ray Micro- and Nanodiffraction Imaging on Human Mesenchymal Stem Cells and Differentiated Cells, Biophys. J. (2016), 110, 680-690.
- PARAMETER ARGUMENTS: ‘pcaArgs’,struct()
struct() can take the following arguments:
- ‘qy’:
- 2d array of horizontal wavevector transfer [repmat(obj.qyaxis ,obj.Nz,1)]
- ‘qz’:
- 2d array of vertical wavevector transfer [repmat(obj.qzaxis’,1,obj.Ny)]
- ‘sel’:
- Logical 2d array. A value of 1 represents a pixel that will be analyzed [obj.sels]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded [obj.mask]
- stxm:
Integrates the scattered intensity of each diffraction pattern (darkfield contrast).
- PARAMETER ARGUMENTS: ‘stxmArgs’,struct()
struct() can take the following arguments:
- ‘qrMin’:
- Only pixels above the radial wavevector transfer qrMin will be analyzed [-1]
- ‘qrMax’:
- Only pixels below the radial wavevector transfer qrMax will be analyzed [-1]
- ‘sel’:
- Logical 2d array. A value of 1 represents a pixel that will be analyzed [ones(obj.Nz,oabj.Ny))]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded [obj.mask]
- circDist:
Calculates the circular mean and circular’grid’,obj.phi2,’bins’,360,’sel’,obj.sels,’mask’,obj.mask,’bgr’,[]),… variance of a distribution. Here, used to calculate the circular mean of I(phi) for a given qr-Interval.
- PARAMETER ARGUMENTS: ‘circDistArgs’,struct()
struct() can take the following arguments:
- ‘grid’:
- Pixel map of azimuthal coordinates [obj.phi2]
- ‘bins’:
- Number of azimuthal bins [360]
- ‘bgr’:
- 2d background image that is going to be subtracted before the mean scattering angle is determined []
- ‘sel’:
- Logical 2d array. A value of 1 represents a pixel that will be analyzed [obj.sels]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded [obj.mask]
- maxProjection:
- Calculates the maximum projection of a stack of diffraction patterns. No arguments are required.
- maxProj:
- Synonymous to maxProjection
- mp:
- Synonymous to maxProjection
- crystal:
Performs a thresholding for crystal mapping based on SNR criterium.
- PARAMETER ARGUMENTS: ‘crystalArgs’,struct()
struct() can take the following arguments:
- ‘bgr’:
- 2d background image that is going to be subtracted before the summing procedure [zeros(obj.Nz,obj.Ny)]
- ‘threshold’:
- All pixels with counts above threshold will be summed [50]
- ‘qrMin’:
- Only pixels above the radial wavevector transfer qrMin will be analyzed [0]
- ‘qrMax’:
- Only pixels below the radial wavevector transfer qrMax will be analyzed [100]
- ‘sel’:
- Logical 2d array. A value of 1 represents a pixel that will be analyzed [obj.sels]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded [obj.mask]
- pyfai:
Fast azimuthal integration based on the python pyfai library.
- PARAMETER ARGUMENTS: ‘pyfaiArgs’,struct()
struct() can take the following arguments:
- ‘bins’:
- Number of bins along radial axis [100]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded []
- ‘cake’:
- Toggle cake integration, can be either ‘on’ or ‘off’ [off]
- ‘cakeRoi’:
- If ‘cake’ is ‘on’, then cakeRoi can be set within a range (phi1,phi2), where phi1 and phi2 are angles in degrees within the range (0,360) and phi2 should be smaller than phi1 [0 360]
- ‘angles’: []
- Missing description.
- ‘to2D’:
- Can be either ‘on’ or ‘off’. If ‘on’, then the 2d regridded pattern is output [‘off’]
- ‘roi2d’: [‘off’]
- Missing description.
- b1d:
Fast azimuthal integration based on rebinning the data.
- PARAMETER ARGUMENTS: ‘b1dArgs’,struct()
- struct() can take the following arguments:
- ‘grid’:
- Pixel coordinates, e.g. a 2d map of the radial wavevector transfer [obj.qr]
- ‘bins’:
- Number of bins along radial axis [100]
- ‘sel’:
- Logical 2d array. A value of 1 represents a pixel that will be analyzed [ones(obj.Nz,obj.Ny)]
- ‘mask’:
- Logical 2d array. A value of 1 represents a pixel that will be discarded [obj.mask]
- symmetry:
Identifies reflections in the data at calculates rotational order. Used e.g. in Carboni and Nicolas et al. (2017), Imaging of neuronal tissues by x-ray diffraction and x-ray fluorescence microscopy: evaluation of contrast and biomarkers for neurodegenerative diseases, Biomedical Optics Express 8 (10), pp. 4331-4347.
- PARAMETER ARGUMENTS: ‘symmetryArgs’,struct()
- struct() can take the following arguments:
- ‘bgr’:
- 2d background image that is going to be subtracted before the summing procedure [zeros(obj.Nz,obj.Ny)]
- ‘sigma’:
- Parameter of Gaussian filter [1.6]
- ‘noise_level’:
- SNR level that functions as a threshold for peak detection [6]
- heal:
Heals a scattering pattern by filling values were data has been lost or not recorded by reflecting measured data from the point-symmetric location. Note, that heal is executed before all other methods, such that the healed data can be used for the subsequent analysis.
PARAMETER ARGUMENTS: ‘healMask’: 2d logical masks that identifies bad or corrupted pixels that should be recovered.
- fluo:
- Integrates response within a pre-defined channel range for each given counter. Note, that fluoCounters have to be defined beforehand. Either during initialization or afterwards using e.g. > obj.fluoCounters = {{‘caka’},{200 500}};
- average:
- Averages a sequence of scattering data.
- sum:
- Takes the sum of a sequence of scattering data.
- data:
- Simply outputs the data in a cell array.
- Scanning modes:
Several raster scanning modes are possible:
horizontal <horz> (default):
*===================> ====================> ========>...
horizontal, alternating <horzalt>:
*===================v v===================< >=======>...
vertical <vert>:
* | | | V | | | | | | | | | . V V V V .
vertical,alternating <vertalt>:
* > v > v | | | | . | | | | . > A > A .
- Output arguments:
- Result:
- struct containing the results for each method.Syntax: struct_name.method_name.method_results
Current options:
data: processed data stack
maxProjection: maximum projection
mp: same as maxProjection
crystal: crystal map
devel: dpc: - dpcx
(differential phase contrast, horizontal)
- dpcy
(differential phase contrast, vertical)
stxm: df (darkfield)
pca: - w
(anisotropy)
- angle
(orientation of the scattering)
fluo: avg: sum: rotate: symmetry: Ln
b1d: - dat_1d
(azimuthally averaged intensities)
- qr
(radial axis)
- error
(error metric, L2 norm)
pyfai: - dat_1d
(azimuthally averaged intensities)
- r
(radial axis)
- error
(error metric, L2 norm)
Note, that the output structure can be split intovariables using the helper functionsplit_struct(). This should improve readabilityof the code.
-
around_y
(pixel)¶ AROUND_Y Returns a two-element array with a lower and upper bound centered around the horizontal primary beam position.
roi = around_y(pixel)
- The following arguments are supported:
- pixel: []
- Description.
Example
See the following example for help:
n = nanodiffraction(); ... n.set_roi_and_binning('roi','on',... 'roiY',n.around_y(150),...);
- Output arguments:
- roi:
- Description.
-
around_z
(pixel)¶ AROUND_Z Returns a two-element array with a lower and upper bound centered around the vertical primary beam position.
roi = around_z(pixel)
- The following arguments are supported:
- pixel: []
- Description.
Example
See the following example for help:
n = nanodiffraction(); ... n.set_roi_and_binning('roi','on',... 'roiY',n.around_y(150),... 'roiZ',n.around_z(150));
- Output arguments:
- roi:
- Description.
-
attach
(files_handle)¶ ATTACH Attaches a files-module to this class.
attach(files_handle)
- The following arguments are supported:
- files_handle: [] (required)
- Handle to a files-module.
Example
See the following example for help:
e = nanodiffraction(...); f = files(...); e.attach(f);
- Output arguments:
- This function does not return any arguments.
-
azimuthal_mask
(phi1, phi2)¶ AZIMUTHAL_MASK defines an azimuthal mask (e.g. useful for PCA analysis). This function creates a circular or ring-shaped mask. Note, that the angles in degrees follow the mathematical convention (counter-clockwise and 0° at 3 o’clock).
mask = azimuthal_mask(phi1,phi2)
- The following parameters are accepted:
- phi1:: [65] (optional)
- Start angle in degrees.
- phi2: [232] (optional)
- End angle in degrees
Example
See the following example for help:
e = nanodiffraction(); mask = e.azimuthal_mask(30,45);
- Output arguments:
- mask:
- A two-dimensional logical azimuthal mask.
-
azimuthal_spread
(dat_1d, qr)¶ AZIMUTHAL_SPREAD takes a one-dimensional intensity profile and the corresponding q_r position as input and reinterpolates the data onto the two-dimensional detector grid. This can be useful when semi-transparent objects such as a beamstop shall be corrected for.
image = azimuthal_spread(data_1d,qr)
- The following arguments are supported:
- dat_1d: [] (required)
- One-dimensional structure factor as obtained e.g. from any azimuthal integration routine such as b1d or pyfai.
- qr: [] (required)
- Corresponding x-axis, given in units of the radial wavevector transfer qr (reciprocal nanometers).
Example
See the following example for help:
e = nanodiffraction(<some settings>); e.set_scan_info('SNy',512,'SNz',651); mask = e.masks | e.azimuthal_mask('phi1',-20,'phi2',20); bs = e.analyze_scan('method','average','zCrop',[1 2],'yCrop',[2 1079]); rad_bgr = b1d(bs.avg,mask,[],e.qr,512); image = e.azimuthal_spread(rad_bgr.dat_1d,rad_bgr.qr);
- Output arguments:
- image:
- Filtered image.
-
calculate_composite
(varargin)¶ CALCULATE_COMPOSITE calculates a composite image from a series of diffraction patterns.
[composite, parameters] = calculate_composite(options)`- The following arguments are supported:
- options:: [see default values below] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets:
- yCrop: [1 obj.scan.SNy]
- Description.
- zCrop: [1 obj.scan.SNz]
- Description.
- ySkip: [1]
- Description.
- zSkip: [1]
- Description.
Example
See the following example for help:
e = nanodiffraction(<some settings here>); e.set_scan_info(<some settings here>); [comp,p] = e.calculate_composite(... struct('ySkip',4,'zSkip',4));
- Output arguments:
- composite:
- Processed composite matrix.
- parameters:
- Parameters used to combine the input data. Is used in combination with (display_class).composite. See help display.composite for more information
-
clicktool
(vis, map, varargin)¶ CLICKTOOL Once a parameter map of the data is shown in the active figure, clicktool can be called and a diffraction pattern or 1d saxs curves are loaded, based on the scan point that was clicked on.
clicktool(vis,map,optional)
- The following arguments are supported:
- vis: [] (required)
- visualization tool (required).
- map: [] (required)
- Depending on the crop and skip parameters used during the last scan analysis, the click location might have to be mapped onto the corresponding position in the scan. It map is empty, 1x1 mapping will be used, otherwise, map has to be an array containing the following parameters [yCrop zCrop ySkip zSkip]
- optional: [] (optional)
- If no optional parameters are given, then a diffraction pattern will loaded, otherwise, an arbitrary number of structs can be given, containing an m:SNy:SNz data block (m: length of single saxs curve). The struct has to contain a data block and a scale, hence, should be passed e.g. as struct(‘data’,data,’scale’,sc)
Example
See the following example for help:
Example missing.
- Output arguments:
- This function does not return any arguments.
-
copy
()¶ COPY Makes a copy of a handle object. This keeps track of all the given parameters so that multiple instances of a display module can be used.
new_instance = copy(nanodiffraction_object)
- The following arguments are supported:
- nanodiffraction_object: [] (required)
- This function requires a nanodiffraction object that should be copied.
Example
See the following example for help:
e_generic = nanodiffraction(); e_saxsdata = copy(e_generic); e_waxsdata = copy(e_generic);
- Output arguments:
- new_instance:
- A copy of the initial nanodiffraction_object.
-
get_index
(q, pos)¶ GET_INDEX Calculates pixel coordinate in pixels given a Q value.
out = get_index(q,position)
- The following arguments are supported:
- q: [] (required)
- q-axis, where q is the reciprocal wavevector coordinate in units of reciprocal nanometers.
- position: [] (required)
- Query position.
Example
See the following example for help:
Example missing.
- Output arguments:
- out:
- Linear index of the nearest matching element in the q-axis.
-
get_location_in_frame
(y, z, sn, stitch)¶ GET_LOCATION_IN_FRAME Calculates the scan position within a frame based on the location in the stitched image.
result = get_location_in_frame(y,z,sn,stitch);
- The following arguments are supported:
- y: [] (required)
- Description.
- z: [] (required)
- Description.
- sn: [] (required)
- Description.
- stitch: [] (required)
- Description.
Example
See the following example for help:
Example missing.
- Output arguments:
- result:
Structure containing the following fields:
linind: Description. linfield: Description. field: Description. ind: Description.
-
get_parameters
()¶ GET_PARAMETERS Returns the experimental parameters stored in the nanodiffraction class. Note, that helper functions and links to other classes are not returned.
result = get_parameters()- The following arguments are supported:
- This function does not require any arguments.
Example
e = nanodiffraction(); p = e.get_parameters()
- Output arguments:
- result:: Structure containing all experimental parameters
- stored in this instance of the nanodiffraction class.
-
heal
(data, mask)¶ HEAL uses make_mask_symmetric to find the correct mapping from valid to invalid pixels. Takes in an n x m data matrix and an n x m logical mask (1: corrupt pixel, 0: otherwise) and mirrors data that is lost due to e.g. modular gaps from the point-symmetric position in the data. This function was inspired by the article ‘’ by Liu et al., IUCrJ 2017, Vol. 4, Issue 4, pp. 455 - 465.
healed = heal(data,mask)
- The following arguments are supported:
- data: [] (required)
- An n x m data matrix.
- mask: [] (required)
- An n x m logical matrix indicating bad pixels. 1: invalid pixel, 0: valid pixel.
Example
See the following example for help:
e = nanodiffraction(); frame = e.read(1); mask = (frame == max(frame(:))); healed_frame = e.heal(frame,mask);
- Output arguments:
- healed:
- healed scattering pattern.
- il:
- index list (mapping from valid to invalid pixels)
-
helper
= u'struct'¶ holds helper functions
-
ind2sub
(ind, sny)¶ IND2SUB calculates the row and column index based on the linear index in the current scan.
[row,col] = ind2sub(linear_index, sny)
- The following arguments are supported:
- linear_index: [] (required)
- Linear index. The first index in the scan is 1.
- sny: [] (required)
- Number of scan points per line (fast axis).
Example
See the following example for help:
Example missing.
- Output arguments:
- row:
- Row index in scan.
- col:
- Column index in scan.
-
make_mask_symmetric
(mask)¶ MAKE_MASK_SYMMETRIC reads in a mask and then rotates the mask 180 degrees around the primary beam position. The rotated mask is compared to the unrotated mask and logically combined (&).
[symm_mask, mask_orig, mask, good_zero, bad_zero] = make_mask_symmetric(mask)
- The following arguments are supported:
- mask: [] (required)
- A valid logical detector mask.
Example
See the following example for help:
Example missing.
- Output arguments:
- symm_mask:
- Description missing.
- mask_orig:
- Description missing.
- mask:
- Description missing.
- good_zero:
- Description missing.
- bad_zero:
- Description missing.
-
moment_from_selection
(varargin)¶ MOMENT_FROM_SELECTION In an active figure, a roi can be selected and the mean, standard deviation, variance and the median can be obtained.
parameter = moment_from_selection(opts)
- The following arguments are supported:
- opts: [‘mean’] (optional)
Moment that should be calculated. By default, the mean will be calculated if opts is not set.
The following options are available:‘mean’,’std’,’var’,’median’
Example
See the following example for help:
Example missing.
- Output arguments:
- parameters:
- Description missing.
-
n_of_q
(q)¶ N_OF_Q Calculates pixel coordinate in pixels given a Q value. This function cannot be defined as an anonymous function, because pixelsize might in fact not be constant (and the other constants in some rare occasions as well)
n = n_of_q(q)
- The following arguments are supported:
- q: [] (required)
- Coordinate in units of the reciprocal wavevector (inverse nanometers)
Example
See the following example for help:
Example missing.
- Output arguments:
- n:
- Coordinate in units of detector pixels.
-
process
(dat)¶ PROCESS Used for processing detector images. The frame will be adapted to the current setting of a detector ROI and binning factors.
processed_data = process(data)
- The following arguments are supported:
- data: [] (required)
- A two-dimensional detector image. The dimensions of the array should correspond to the detector size.
Example
See the following example for help:
e = nanodiffraction(); frame = e.read(1); e.set_roi_and_binning('binning','on','binY',4,'binZ',4); processed_frame = e.process(frame);
- Output arguments:
- processed_data:
- The cropped and rebinned detector image.
-
process_mask
(mask)¶ PROCESS_MASK Used for processing logical masks. The mask will be adapted to the current setting of a detector ROI and binning factors.
processed_mask = process_mask(mask)
- The following arguments are supported:
- mask: [] (required)
- A two-dimensional mask. The dimensions of the array should correspond to the detector size.
Example
See the following example for help:
e = nanodiffraction(); mask = e.read(1) > 1000; e.set_roi_and_binning('binning','on','binY',4,'binZ',4); new_mask = e.process_mask(mask);
- Output arguments:
- processed_mask:
- The cropped and rebinned logical mask.
-
q_of_n
(n)¶ Q_OF_N Calculates Q coordinate in [nm^-1] given a pixel coordinate. This function cannot be defined as an anonymous function, because pixelsize might in fact not be constant (and the other constants in some rare occasions as well)
q = q_of_n(n)
- The following arguments are supported:
- n: [] (required)
- Coordinate in units of detector pixels
Example
See the following example for help:
Example missing.
- Output arguments:
- q:
- Coordinate in units of the radial wavevector transfer (reciprocal nanometers).
-
qr_tilt
(alpha, beta, gamma)¶ QR_TILT Description missing.
[qr,x,y,z] = qr_tilt(alpha, beta, gamma)
- The following arguments are supported:
- alpha: []
- Tilt angle of the detector in degrees.
- beta: []
- Tilt angle of the detector in degrees.
- gamma: []
- Tilt angle of the detector in degrees.
Example
See the following example for help:
Example missing.
- Output arguments:
- qr:
- Corrected radial wavevector transfer detector coordinates, based on the detector tilt angles.
- x:
- Corrected x-position of the detector pixel coordinates, based on the detector tilt angles.
- y:
- Corrected y-position of the detector pixel coordinates, based on the detector tilt angles.
- z:
- Corrected z-position of the detector pixel coordinates, based on the detector tilt angles.
-
radial_mask
(r1, r2, varargin)¶ RADIAL_MASK defines a radial mask (e.g. useful for a PCA analysis). Creates a circular or ring-shaped mask and stores it in (nanodiffraction_class).sels.
mask = radial_mask(r1,r2,grid)
The following arguments are accepted:
- r1: [] (required)
- Inner radius
- r2: [] (required)
- Outer radius (Inverse radius)
- grid: [nanodiffraction.qr] (optional)
- Two-dimensional detector coordinates.
Example
See the following example for help:
e = nanodiffraction(); mask = e.radial_mask(0.2,1.2,e.qr);
- Output arguments:
- mask:
- A two-dimensional logical radial mask.
-
read
(fn)¶ READ reads data from the data module. Note, that data is not treated in any way (binning, cropping, etc.).
raw_data = read(fn) reads single frame.
- The following arguments are supported:
- fn: [] (required)
- Frame number (>0). Note that the frame number always identifies the frame within a scan. This should not be confused with the file number used in the files-module. There, the file number is associated with a specific file within a newfile-session. For this reason, the file number could start with 0.
Example
See the following example for help:
e = nanodiffraction(); first_frame = e.read(1);
- Output arguments:
- raw_data:
- Raw detector frame.
-
readm
(fn)¶ READM reads data from data module. Note, that data is processed using the built-in function (nanodiffraction_class).process and the detector mask is applied on the data frame.
processed_data = readm(fn)
- The following arguments are supported:
- fn: [] (required)
- Frame number (>0). Note that the frame number always identifies the frame within a scan. This should not be confused with the file number used in the files-module. There, the file number is associated with a specific file within a newfile-session. For this reason, the file number could start with 0.
Example
See the following example for help:
e = nanodiffraction(); e.set_roi_and_binning('binning','on','binY',2,'binZ',2); e.set_mask(e.read(1) > 1000); first_frame = e.readm(1);
- Output arguments:
- processed_data:
- Processed detector frame.
-
readp
(fn)¶ READP reads data from data module. Note, that data is processed using the built-in function (nanodiffraction_class).process.
processed_data = readp(fn)
- The following arguments are supported:
- fn: [] (required)
- Frame number (>0). Note that the frame number always identifies the frame within a scan. This should not be confused with the file number used in the files-module. There, the file number is associated with a specific file within a newfile-session. For this reason, the file number could start with 0.
Example
See the following example for help:
e = nanodiffraction(); e.set_roi_and_binning('binning','on','binY',2,'binZ',2); first_frame = e.readp(1);
- Output arguments:
- processed_data:
- Processed detector frame.
-
refresh
()¶ REFRESH This function is needed in case the geometry settings change. This could happen eg. when for some reason the detector pixel size was changed (e.g. when binning was used) and q_r, primary beam position, etc. has to be recalculated.
refresh()
- The following arguments are supported:
- This function does not require any arguments.
Example
See the following example for help:
e = nanodiffraction(); e.pby = 1000; e.pbz = 1200; e.detDistance = 1.2; e.refresh();
- Output arguments:
- This function does not return any arguments.
-
remove_semitransparent_object
(im_in, phi1, phi2)¶ REMOVE_SEMITRANSPARENT_OBJECT Description.
[image_out,correction] = remove_semitransparent_object(image,phi1,phi2)
- The following arguments are supported:
- image: [] (required)
- Description.
- phi1: [] (required)
- Description.
- phi2: [] (required)
- Description.
Example
See the following example for help:
Example missing.
- Output arguments:
- image_out:
- A corrected image.
- correction:
- A correction matrix.
-
scan
= u'struct'¶ holds scan parameters
-
set_corr
(corr)¶ SET_CORR Defines a correction matrix to be applied in a subsequent analysis. Note, that a warning will be shown, if the size of the correction matrix does not correspond to the current detector dimensions.
[corr_out] = set_corr(corr)
- The following arguments are supported:
- corr: []
- A two-dimensional array. Input can a double array.
Example
See the following example for help:
e = nanodiffraction(<some settings>); e.set_scan_info('SNy',512,'SNz',651); mask = e.masks | e.azimuthal_mask('phi1',-20,'phi2',20); bs = e.analyze_scan('method','average','zCrop',[1 2],'yCrop',[2 1079]); rad_bgr = b1d(bs.avg,mask,[],e.qr,512); vq2d = e.azimuthal_spread(rad_bgr.dat_1d,rad_bgr.qr); e.set_corr(~e.masks.*(vq2d./bs.avg));
- Output arguments:
- corr_out:
- Active correction matrix
Note, that the correction matrix is stored in:(nanodiffraction_class).corr
after set_corr was used.
-
set_mask
(varargin)¶ SET_MASK The function accepts as many masks as needed as arguments, as long as their dimensions are identical. Note, that a warning will be shown, if the size of the mask does not correspond to the current detector dimensions.
[mask_out] = set_mask(mask, mask, mask, ...)
- The following arguments are supported:
- mask: [] (required)
- A two-dimensional array.The input should be a logical array.
- mask: [] (optional)
- Additional masks can be given. All masks will then be logically combined (OR combination [|]).
- mask: [] (optional)
- The amount of masks is not limited, all masks will then be logically combined (OR combination [|]).
Example
See the following example for help:
e = nanodiffraction(<some settings>); mask1 = e.radial_mask('r1',0,'r2',0.2,'grid',e.qr); mask2 = e.azimuthal_mask('phi1',30,'phi2',56,'grid',e.phi2); e.set_mask(mask1,mask2);
- Output arguments:
- mask_out:
- Combined mask.
Note, that the detector mask is stored in:(nanodiffraction_class).mask
-
set_roi_and_binning
(varargin)¶ SET_ROI_AND_BINNING All following functions require a standard pixel mask that mask hot pixels and intermodular gaps of detectors. In addition, a calibration could be added that corrects for solid angle deviations at larger scattering angles.
set_roi_and_binning(options)
- The following arguments are accepted:
- options: [] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets:
- roi: []
- Can be toggled between on and off
- roiY: [start end]
- [start end] in pixel units
- roiZ: [start end]
- [start end] in pixel units
- binning: [1]
- Can be toggled between on and off
- binY: [1]
- Binning ratio along y
- binZ: [1]
- Binning ratio along z
Example
See the following example for help:
e = nanodiffraction(); e.set_roi_and_binning('roi','on',... 'roiY',around_y(100),... 'roiZ',around_z(100),... 'binning','on',... 'binY',2,... 'binZ',2);
- Output arguments:
- This function does not return any arguments.
-
set_scan_info
(sny, snz, varargin)¶ SET_SCAN_INFO sets the scan information for all subsequent analyses.
set_scan_info(sny,snz,options)
- The following arguments are supported:
- sny: [] (required)
- number of scan points along fast axis
- snz: [] (required)
- number of scan points along slow axis
- options: [] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets:
- firstFile: [1]
- Description.
- stepY: [1e-6]
- Description.
- stepZ: [1e-6]
- Description.
- roi: []
- Description.
- roiMask: []
- Description.
Example
See the following example for help:
e = nanodiffraction(); e.set_scan_info(51,51);
- Output arguments:
- This function does not return any arguments.
-
set_selection
(varargin)¶ SET_SELECTION The function accepts as many selections as needed as arguments, as long as their dimensions are identical. Note, that a warning will be shown, if the size of the mask does not correspond to the current detector dimensions.
[sel_out] = set_selection(sel, sel, sel, …)- The following arguments are supported:
- sel: [] (required)
- A two-dimensional array. The input should be a logical array.
- sel: [] (optional)
- Additional selections can be given. All selections will then be logically combined (OR combination [|]).
- sel: [] (optional)
- The amount of selections is not limited, all selections will be combined to one.
Example
See the following example for help:
e = nanodiffraction(<some settings>); sel_small = e.radial_mask('r1',0,'r2',1.2,'grid',e.qr); sel_large = e.radial_mask('r1',2.4,'r2',3.2,'grid',e.qr); e.set_selection(sel_small,sel_large);
- Output arguments:
- sel_out:
- Current selection.
- Note, that selections are stored in:
- (nanodiffraction_class).sels
Note, that more selections can be used, for example, whenperforming a pca analysis or stxm. Additional selectionscan be added by calling(nanodiffraction).add_selection(sel)
For more help, please read:help nanodiffraction.add_selection
-
simulate_actomyosin
(phi0, varargin)¶ SIMULATE_ACTOMYOSIN Description.
simulation = simulate_actomyosin(opts)
- The following arguments are supported:
- phi0: [see default values below] (optional)
- Description.
Example
See the following example for help:
Example missing.
- Output arguments:
- simulation:
- A simulated diffraction pattern.
-
simulate_agbh
(varargin)¶ SIMULATE_AGBH Description.
simulation = simulate_agbh(opts)
- The following arguments are supported:
- opts: [see default values below] (optional)
- Description.
Example
See the following example for help:
Example missing.
- Output arguments:
- simulation:
- A simulated diffraction pattern.
-
simulate_airscattering
(varargin)¶ SIMULATE_AIRSCATTERING simulates the effect of air scattering.
[bgr] = simulate_airscattering(opts)
- The following arguments are supported:
- opts: [see default values below] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets. All distances are given in millimeters.
- l_pre:: [10]
- Pre-distance.
- l_post:: [10]
- Post-distance.
- l_sd:: [500]
- Distance sample-to-detector
- l_sampl:: [0.1]
- Sampling interval.
- ap_size:: [0.07]
- Aperture size.
- I0:: [1]
- number of incident photons
Example
See the following example for help:
e = nanodiffraction(); airscat = e.simulate_airscatting();
- Output arguments:
- bgr:
- Simulated air-scattering background.
-
simulate_bs
(bs_size, bs_dist)¶ SIMULATE_BS Estimates the size of the beamstop that can be expected projected on the detector.
[bs_size_det_q] = simulate_bs(bs_size, bs_dist)
- The following arguments are supported:
- bs_size: []
- Diameter of beamstop in (mm)
- bs_dist: []
- Distance in (mm) behind focal spot
Example
See the following example for help:
e = nanodiffraction(); bs = e.simulate_bs(0.5,100);
- Output arguments:
- bs_size_det_q:
- Size of a circular beamstop projected onto the detector.
-
simulate_streak
(varargin)¶ SIMULATE_STREAK simulates a gaussian streak at the location of the primary beam.
[streak] = simulate_streak(opts)
- The following arguments are supported:
- opts: [see default values below] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets.
- long: [0.005]
- long axis length of streak
- short: [0.05]
- short axis length of streak
- y: []
- Description.
- z: []
- Description.
- Ny: []
- Number of horizontal detector pixels
- Nz: []
- Number of vertical detector pixels
- angle: [30]
- rotation angle of the streak
- I0: [1]
- number of incident photons
Example
See the following example for help:
e = nanodiffraction(); streak = e.simulate_streak(); imagesc(streak); axis image;
- Output arguments:
- streak:
- A diffraction pattern containing a cigar-shaped streak.
-
stitch
(data, stitchy, stitchz, varargin)¶ STITCH takes a one-dimensional cell array of two-dimensional data and combines all data into a single array, based on the stitching dimensions.
stitched = stitch(dataset,stitchy,stitchz,opts)
- The following arguments are supported:
- dataset: [] (required)
- One-dimensional cell array data{:} that contains two-dimensional diffraction patterns of identical dimensions.
- stitchy: [] (required)
- Number of images to be concatenated horizontally.
- stitchz: [] (required)
- Number of images to be concatenated vertically.
- opts: [see default values below] (optional)
Structure that can contain the following fields. Note, that all fields are optional. Default values that are otherwise used are as usual given in angle brackets:
- win: []
- 4-element vector containing the lower and upper limits (in pixel units) along the horizontal and lower and upper limits along the vertical dimension of the scattering pattern. Example: [100 900 100 900]
- append: [0]
- Appends N fields of zeros.
- prepend: [0]
- Prepends N fields of zeros.
- replaceEmpty: [0]
- If a cell array at a random location is empty, it can be replaced by a field of zeros.
Example
See the following example for help:
Example missing.
- Output arguments:
- stitched:
- A stitched image.
-
strip
(data, winSize, iterations, varargin)¶ STRIP Model-indepentend background stripping for one-dimensional graphs with monotone background and superimposted, sharp features such as bragg reflections or spectral lines.
stripped = strip(data,windowSize,iterations,qr)
- The following arguments are supported:
- data: [] (required)
- A one-dimensional array of data points. See help: nanodiffraction.baseline.
- windowSize: [] (required)
- See help: nanodiffraction.baseline.
- iterations: [] (required)
- See help: nanodiffraction.baseline.
- qr: [] (optional)
- Detector coordinates in terms of the radial wavevector transfer. A matrix of size [Nz,Ny] is expected.
Example
See the following example for help:
Example missing.
- Output arguments:
- stripped:
- stripped background
- stripped_2d: (optional)
- 2d stripped background of size [Nz,Ny]. This is only output if a two-dimensional qr-grid was given to the function as optional argument.
-
sub2ind
(y, z)¶ SUB2IND calculates the linear index within the scan, based on the row and column index.
linear_index = sub2ind(col,row)
- The following arguments are accepted:
- row: [] (required)
- row index in scan (z-axis).
- col: [] (required)
- column index in scan (y-axis).
Example
See the following example for help:
Example missing.
- Output arguments:
- linear_index:
- Linear index.
-
verify_array
(arr_in, ref, process_handle)¶ VERIFY_ARRAY Description.
output_array = verify_array(input_array, ref, process_handle)- The following arguments are supported:
- input_array: []
- Description.
- ref: []
- Description.
- process_handle: []
- Description.
Example
See the following example for help:
Example missing.
- Output arguments:
- output_array:
- Description.


--- title: imagenette_experiments keywords: fastai sidebar: home_sidebar summary: "experiments with fastai imagenette / imagewoof datasets" description: "experiments with fastai imagenette / imagewoof datasets" ---
Notebooks with experiments. Models trained with fastai v1 on Imagewoof dataset.
This results was done with experimental model - XResnet with modification.
I used pool layer plus convolution stride 1 instead of convolution stride 2.
And instead of regular pytorch pool (AveragePool2d and MaxPool2d) i used MaxBlurPool as described here:
fastai forum topic
github ducha-aiki
Activation function - Mish, long disscussion on fastai forum
Fit with Ranger optimizer and flat with annealing - long tread on fastai forum
Model was created with model-constructor
Explanation how model was created here: https://github.com/ayasyrev/imagenette_experiments/blob/master/ResnetTrick_create_model_fit.ipynb
Current results vs results on leaderboard - ImageWOOF:
| Size (px) | Epochs | Accuracy | # Runs | My res | URL | Comments | |
|---|---|---|---|---|---|---|---|
| 128 | 5 | 73.37% | 5, mean | ||||
| 128 | 20 | 85.52% | 5, mean | 86.10% | |||
| 128 | 80 | 87.20% | 1 | 87.63% | notebook | 3 runs, start_pct=0.3 | |
| 128 | 200 | 87.20% | 1 | 88.30% | notebook | 3 runs, start_pct=0.2 | |
| 192 | 5 | 75.94% | 5, mean | 77.87% | notebook | added to board | |
| 192 | 20 | 87.25% | 5, mean | 87.85% | notebook | added to board | |
| 192 | 80 | 89.21% | 1 | 89.69% | notebook | 4 runs. | |
| 192 | 200 | 89.54% | 1 | 90.35% | notebook | 2 runs. | |
| 256 | 5 | 76.87% | 5, mean | 78,84% | notebook | added to board | |
| 256 | 20 | 88.29% | 5, mean | 88,58% | notebook | added to board | |
| 256 | 80 | 90.48% | 1 | 90.63% | notebook | 2 runs, start_pct=0.4 | |
| 256 | 200 | 90.38% | 1 | 91.14% | notebook | 3 runs, start_pct=0.2 |
How to repeat results:
All notebooks can be run on google colab.
Install this repo:
pip install -e git+https://github.com/ayasyrev/imagenette_experiments
Now import Model constructor and helper utils as:
from imagenette_experiments.train_utils import *
from imagenette_experiments.trick_model import *
Now create model constructor:
model = Model()
Now we can check model, for example:
model.body.l_1.bl_0
Lets create Learner:
learn = get_learn(woof=1, size=128, bs=64)
Now we cat train it regular fastai way, for example fit with annealing:
learn.fit_fc(tot_epochs=5, lr=1e-4, moms=(0.95,0.95), start_pct=0.72)


User ID for new BuildingC:
Entity id for calculateBuildingPointsRU:
Entity id for deleteBuildingD:
User id for getUserPoints:
Entity id for getBuildingTotalPoints:


{% extends "base_templates/login_base.html" %} {# base_templates extends base_templates/login_base.html #} {% block main %}
SnowFlake allows you to bookmark and share all of your most important links. Snowflake provides a way centralize your presance on the web. and all you need is a single snowflake.
Where all your links live


| header | status | |
|---|---|---|
| 18. Language support | ||
| <cstddef> | ready | |
| <limits> | ready | |
| <climits> | ready | |
| <cfloat> | ready | |
| <cstdint> | ready | |
| <cstdlib> | ready | |
| <new> | ready | |
| <typeinfo> | ready | |
| <exception> | ready | |
| <cstdarg> | ready | |
| <csetjmp> | ready | |
| <ctime> | ready | |
| <csignal> | ready | |
| <cstdbool> | ready | |
| 19. Diagnostics | ||
| <stdexcept> | ready | |
| <cassert> | ready | |
| <cerrno> | ready | |
| <system_error> | ready | |
| 20. General utilities | ||
| <utility> | ready | |
| <ratio> | pending review | |
| <tuple> | ready | |
| <bitset> | ready | |
| <type_traits> | pending review | |
| <functional> | ready | |
| <memory> | missing atomic/hash, pending review | |
| <chrono> | pending review | |
| <typeindex> | ready | |
| 21. Strings | ||
| <string> | pending 2nd review | |
| <cctype> | ? (added isblank) | |
| <cwctype> | pending review | |
| <cstring> | pending review | |
| <cwchar> | pending review | |
| <cuchar> | pending review | |
| 22. Localization | ||
| <locale> | ready | |
| <codecvt> | pending review | |
| <clocale> | ready | |
| 23. Containers | ||
| <array> | pending 2nd review | |
| <deque> | pending 2nd review | |
| <forward_list> | pending 2nd review | |
| <list> | pending 2nd review | |
| <queue> | ready | |
| <stack> | ready | |
| <vector> | pending 2nd review | |
| <map> | pending 2nd review | |
| <set> | pending 2nd review | |
| <unordered_map> | pending review | |
| <unordered_set> | pending review | |
| 24. Iterators | ||
| <iterator> | ready | |
| 25. Algorithms | ||
| <algorithm> | ready | |
| 26. Numerics | ||
| <cfenv> | ready | |
| <complex> | ready (no exceptions/data race) | |
| <random> | pending review | |
| <valarray> | ready | |
| <numeric> | ready | |
| <cmath> | ready | |
| <ctgmath> | ready | |
| 27. I/O | ||
| <iosfwd> | ready | |
| <iostream> | ready | |
| <ios> | ready | |
| <streambuf> | ready | |
| <istream> | ready | |
| <ostream> | ready | |
| <iomanip> | ready | |
| <sstream> | ready | |
| <fstream> | ready | |
| <cstdio> | pending review | |
| <cinttypes> | ready | |
| 28. Regular expressions | ||
| <regex> | pending review | |
| 29. Atomic operations | ||
| <atomic> | ready | |
| 30. Thread support | ||
| <thread> | ready | |
| <mutex> | ready | |
| <condition_variable> | ready | |
| <future> | ready |


Class
ProxyEmulates object of another class.
Emulates object of another class.
| All Subcl's | IteratorProxy |
|---|---|
| Defined in | <seqan/basic.h> |
| Signature |
template <typename TSpec>
class Proxy;
|
Template Parameters
TSpec |
The specializing types. |
|---|
Interface Metafunction Overview
-
Spec<TProxy>::Type;
Return specialization tag of Proxy. -
Value<TProxy>::Type;
Return emulated type.
Detailed Description
Use Value to get the emulated type. An instance of Proxy behaves like an object of its value type. Proxy can be used as reference type (see Reference).
Note that functions that are both general and specialized for the value type should be specialized for Proxy<TSpec> too, since otherwise the general version will be called.


The Pizza for you
Meat Pizza
Chicken Pizza
Vegeterian Pizza
Vegan Pizza
Borewores Pizza
Pepperoni Pizza
Hawaiian Pizza
Customizeyour Pizza
CREATE YOUR OWN PIZZA


| In-System Programming ← | ↑ ScratchMonkey | → High Voltage Serial Programming |
If your MCU has its fuse settings scrambled to an extent that ISP is no longer available to reprogram it, you have to resort to an alternative programming method: High Voltage Programming.
Depending on the MCU you have, you have to use High Voltage Serial Programming (for 8 and 14 pin ICs) or High Voltage Parallel Programming (for ICs with 20 pins or more). Connections for these methods are discussed in their respective sections, but both methods need a high voltage signal, controlled by the Slave Reset pin HVRESET (shown as ⚡RESET⚡ in the connection diagrams), for which you need a bit of external hardware.
As their name implies, the High Voltage Serial and High Voltage Parallel Programming techniques require a +12V signal. It should be noted that the current drawn from this signal is quite small.
Here are some ways to generate that 12V signal, depending on what components you have at hand.
By far the simplest method is to use an external 12V power supply. Either bring the power directly to the bread board (connecting the ground to the Arduino ground), or plug it into the Arduino and use the Arduino Vin pin as the 12V source. To switch this signal on and off using the Slave Reset pin HVRESET, any NPN transistor with a reasonably large hFE should work in this circuit.
R3 is a pull-up resistor ensuring that the 12V signal is turned off when HVRESET is disconnected (e.g. because the sketch is not running), while R1 limits the current flowing through the transistor.
A drawback of this circuit is that the RESET voltage drops as soon as a significant amount of current is drawn. This is not a problem in most programming situations, but can lead to problems if the RESET pin of the target MCU is programmed as an output.
The Maxim MAX662ACPA+ is an integrated circuit that, combined with some capacitors, can generate a 12V, 30mA signal from a 5V input (The same functionality is also available from STMicrolelectronics under the name ST662ACD-TR). The Slave Reset pin HVRESET is here connected to the SHDN pin, which will put the MAX662ACPA+ into shutdown mode.
Since in shutdown mode, the output of the MAX662ACPA+ is 5V instead of 0V, it is preferable to add a transistor as in the previous section to ensure that RESET is indeed 0V. In the circuit shown here, the PNP transistor will only conduct if the emitter is higher than 5V.
Experimentally, omitting the transistor works on all MCUs tested except the ATtiny861 and the ATtiny1634, so if you don't plan on targeting these, you may get away with omitting the transistor.
| In-System Programming ← | ↑ ScratchMonkey | → High Voltage Serial Programming |


Radio
An HTML form is a section of a document containing normal content, markup, special elements called controls (checkboxes, radio buttons, menus, etc.), and labels on those controls. Users generally "complete" a form by modifying its controls (entering text, selecting menu items, etc.), before submitting the form to an agent for processing (e.g., to a Web server, to a mail server, etc.)
Radio
Add .pmd-radio
in label to create a propeller customized radio. You can also add .pmd-radio-ripple-effect
to provide a ripple effect to the radio.


Gateway
BOT
06-Dec-18 01:03 PM
[dscrdvrsc] <plazma> Just used verus sapling shielded address to sapling shielded address....not instanious....took a sec....but fast and cool....
[dscrdvrsc] <Gloryman> No bro. I will state it as simply as I can. VRSC coin should fork as i believe to be the best for the project but if they dont I will want to mine with an FPGA.
[dscrdvrsc] <Cruz> Just support the project & do, as you please...
You seemed to put a lot of opinion out there, on this...
[dscrdvrsc] <Cruz> I got the feeling you were against FPGA...
Then I read before and after, then saw you on another discord... And I couldn't really tell what you though, except that you thought a lot
[dscrdvrsc] <Gloryman> Let me put it another way. Lets say I believe that fuel prices should be taxed to raise money for something else, military for example. If they dont tax the fuel, that doesnt mean I wont take advantage of the low fuel prices. Can you see what I mean?
[dscrdvrsc] <Gloryman> @Cruz Sorry. I will try to be clearer in future. People that know me on this discord know I am for FPGAs but not on this coin so early
[dscrdvrsc] <Gloryman> or at least without some reducing of performance, but mainly forking
[dscrdvrsc] <Cruz> Just a quick piece of honest advice...
Write in plain English...
You are saying, FPGA might or might not be taxed on Verus mining.. Either way, you want to reap the benefits, from FPGA mining...
(edited)
[dscrdvrsc] <Cruz> And that's fair
[dscrdvrsc] <Gloryman> It was an analogy to do with wanting a rule or law to be in place but taking advantage of the law if it comes into effect.
[dscrdvrsc] <Gloryman> FPGAs are never going to be fair, imo.
[dscrdvrsc] <Cruz> So, to sum this up---you like the Verus project...
But you also enjoy financial gain, wherever that might be.. Is that right?
[dscrdvrsc] <Gloryman> I like Verus project sure and yes, I am a miner that wants value.
[dscrdvrsc] <Gloryman> The issue is not simply for or against FPGAs. There are things such as timing, pacing, competitiveness, ect...
(edited)
[dscrdvrsc] <Cruz> In my opinion, there hasn't been an honest & clear discussion, about FPGAs. And what Verus is going to be giving up, in order to get -- from this company...
[dscrdvrsc] <Gloryman> @Cruz agreed. That's why I tried starting the conversation buddy..
[dscrdvrsc] <Cruz> I do trust Mike wholeheartedly though..
[dscrdvrsc] <Cruz> He has put in more work, than anyone, on this project
[dscrdvrsc] <Gloryman> I don't blindly trust anyone.
[dscrdvrsc] <Gloryman> but mike is very helpful and communicative
[dscrdvrsc] <Cruz> I believe that it is in his interest, to do what is best for Verus...
[dscrdvrsc] <Cruz> And, from his experience, it shows that he does have a skillet needed to do this
[dscrdvrsc] <Cruz> He has real world experience in an executive role, at some of the top tech companies in the world
[dscrdvrsc] <Gloryman> Well I go on my on decisions and opinions but people should do what they believe to be right
[dscrdvrsc] <Gloryman> People in executive tech roles fail all the time.
[dscrdvrsc] <Gloryman> Take Hawaei
[dscrdvrsc] <Cruz> Right is right and wrong is wrong..
But I trust a guy, with that type of experience, probably over any crypto dev out ther


Run arbitrary package scripts
npm.commands.run-script(args, callback)
This runs an arbitrary command from a package's "scripts" object.
It is used by the test, start, restart, and stop commands, but can be called directly, as well.
The 'args' parameter is an array of strings. Behavior depends on the number of elements. If there is only one element, npm assumes that the element represents a command to be run on the local repository. If there is more than one element, then the first is assumed to be the package and the second is assumed to be the command to run. All other elements are ignored.


| Rcpp::Rcpp-attributes | Rcpp-attributes | source | |||
| Rcpp::Rcpp-extending | Rcpp-extending | source | |||
| Rcpp::Rcpp-FAQ | Rcpp-FAQ | source | |||
| Rcpp::Rcpp-introduction | Rcpp-introduction | source | |||
| Rcpp::Rcpp-jss-2011 | Rcpp-JSS-2011 | source | |||
| Rcpp::Rcpp-libraries | Rcpp-libraries | source | |||
| Rcpp::Rcpp-modules | Rcpp-modules | source | |||
| Rcpp::Rcpp-package | Rcpp-package | source | |||
| Rcpp::Rcpp-quickref | Rcpp-quickref | source | |||
| Rcpp::Rcpp-sugar | Rcpp-sugar | source |


Members
(async, constant) fetchcategorySalesData
Take sales for category data (actions)
- Source:
(async, constant) fetchFavProductData
Take sales for category data (actions)
- Source:
(async, constant) fetchMainData
Take all data (actions)
- Source:
(async, constant) fetchSalesForMonthData
Take sales for month data (actions)
- Source:
(async, constant) fetchSalesNowData
Take sales now data (actions)
- Source:
(constant) store
Store from Redux
Methods
mapStateToProps()
state in redux
- Source:


This Software Tool is compatible with Firefox, Google chrome And other latest Browser. Please run this software in any one of these Browser.


ROTA products RoTrike, RoChair, and RoScooter are provided with the following warranty.
This warranty does not cover wearing items such as upholstered materials, padded materials, brakes, cables, tires, wheels, etc.
ROTA warrants the vehicle frame and powertrain against defects in materials and workmanship for one (1) year. Warranty does not transfer from original owner.
ROTA warrants all ROTA–made wheelchair components (including, but not limited to, armrest assemblies, backrest assemblies, footrest assemblies, camber tubes and plugs and caster forks) against defects in materials and workmanship for one (1) year from the date of purchase, except as provided below. Warranty does not transfer from original owner.
1. This warranty does not cover:
a. tires and tubes for front or rear wheels, upholstery (including cushions, foot straps, and armrest upholstery), or handle grips; or
b. damage arising from normal wear and tear or from other circumstances beyond ROTA’s control; or
c. any labor or shipping charges incurred in replacement part installation or repair of this product; or
d. ROTA powertrain components, unless ROTA, in its sole discretion, determines that the powertrain components were defectively manufactured.
2. This warranty is VOID if ROTA, in its sole discretion, determines that:
a. the original ROTA serial number tag has been removed, altered or defaced; or
b. the product has been subjected to negligence, accident, improper maintenance, storage or operation as required by your ROTA Owners Manual, commercial or institutional use, misuse or abuse, including, but not limited to, exceeding the maximum weight limit or using the product with tie downs or locking, clamping or other restraint systems related to the use of the product in a motor vehicle; or
c. the product has been damaged by improper repairs or repairs made to any component without the express written consent of ROTA; or
d. the product has been modified without ROTA’s express written consent, including, but not limited to, modification through the use of unauthorized parts or attachments.
3. This warranty applies only to the original intended user of the product.
If your product requires warranty service, please contact ROTA HQ.
For service, please contact ROTA by email<EMAIL_ADDRESS>or phone<PHONE_NUMBER> .
Do not return products without our prior consent. Most warranty issues can be remedied more quickly and efficiently locally.
1. The foregoing express warranty is exclusive and in lieu of all other warranties whatsoever, whether written or oral, express or implied, including the implied warranties of merchantability and fitness for a particular purpose.


--- layout: page title: About header-img: "img/about-bg.png" ---
This is definitely Kate Travers and not one of many, many test accounts.


Const XdccEvents
XdccEvents: object
ircAbort
ircAbort: string = "abort"
ircAction
ircAction: string = "action"
ircChannellist
ircChannellist: string = "channellist"
ircChannellistItem
ircChannellistItem: string = "channellist_item"
ircChannellistStart
ircChannellistStart: string = "channellist_start"
ircClose
ircClose: string = "close"
ircConnect
ircConnect: string = "connect"
ircConnected
ircConnected: string = "connected"
ircCtcp
ircCtcp: string = "ctcp"
ircCtcpNotice
ircCtcpNotice: string = "ctcp-notice"
ircCtcpPrivmsg
ircCtcpPrivmsg: string = "ctcp-privmsg"
ircCtcpVersion
ircCtcpVersion: string = "ctcp-version"
ircError
ircError: string = "error"
ircInvite
ircInvite: string = "invite"
ircJoin
ircJoin: string = "join"
ircKick
ircKick: string = "kick"
ircKill
ircKill: string = "kill"
ircMessage
ircMessage: string = "message"
ircModeAdd
ircModeAdd: string = "+mode"
ircModeRemove
ircModeRemove: string = "-mode"
ircMotd
ircMotd: string = "motd"
ircNames
ircNames: string = "names"
ircNeterror
ircNeterror: string = "netError"
ircNick
ircNick: string = "nick"
ircNotice
ircNotice: string = "notice"
ircOpered
ircOpered: string = "opered"
ircPart
ircPart: string = "part"
ircPing
ircPing: string = "ping"
ircPm
ircPm: string = "pm"
ircPong
ircPong: string = "pong"
ircQuit
ircQuit: string = "quit"
ircRaw
ircRaw: string = "raw"
ircRegistered
ircRegistered: string = "registered"
ircSelfMessage
ircSelfMessage: string = "selfMessage"
ircTopic
ircTopic: string = "topic"
ircWhois
ircWhois: string = "whois"
xdccCanceled
xdccCanceled: string = "xdcc-canceled"
xdccCompleted
xdccCompleted: string = "xdcc-completed"
xdccConnected
xdccConnected: string = "xdcc-connected"
xdccCreated
xdccCreated: string = "xdcc-created"
xdccDlError
xdccDlError: string = "xdcc-dlerror"
xdccError
xdccError: string = "xdcc-error"
xdccProgressed
xdccProgressed: string = "xdcc-progressed"
xdccQueued
xdccQueued: string = "xdcc-queued"
xdccRemoved
xdccRemoved: string = "xdcc-removed"
xdccRequested
xdccRequested: string = "xdcc-requested"
xdccStarted
xdccStarted: string = "xdcc-started"


This is generic HTML that can be configured via the site administration interface.
For a list of organizations currently participating in the Google Summer of Code for 2009, please visit the Community page.
The site administration interface will provide a mechanism to select a feed to be displayed here.


Foot fetish: Nibbles a specialty at Indonesian restaurant
Yogyakarta, Indonesia, As he scarfed down a traditional Indonesian meal, Adi Karyanov got himself the two-in-one special at a new restaurant offering pedicures by fish.
The tables and chairs at Soto Cokro Kembang in Indonesia's cultural capital Yogyakarta sit in ankle-deep water, home to thousands of little fish that nibble dead skin off the feet of diners.
"I felt the fish biting my feet -- it was ticklish but nice," Karyanov said.
"They make it fun to eat here. It's kind of unique."
Many spas across southeast Asia have for years touted a fishy pedicure as an unproven but novel way of treating various skin conditions.
But restaurant owner Imam Nur, who opened in June, has gone a step further by offering it alongside his traditional Javanese "sole food".
Nur credits his father for coming up with the idea for the open-air restaurant, which has some 7,000 Red Nile Tilapia swimming around its patrons.
"We initially opened this restaurant just for locals living nearby," he said.
"But what's happening now is beyond what we had initially planned. It's become like culinary tourism. Many people are coming here from different cities."
Pressing fish into service to remove dead skin is not without controversy.
Some cities in North America and Europe have banned it over concerns about bacterial outbreaks, while People for the Ethical Treatment of Animals (PETA) has warned over both the health risks and possible cruelty to animals.
Still, visitors like Anna Widia were keen to give the fish treatment a whirl.
"I've never seen any place like this," she said.
"And it's big enough to bring the whole family."
Read also
Read More
'Smart cities' urged to look beyond rich, white men
A growing push to put cities on a digital path to a greener future risks excluding groups like the poorest, disabled and elderly, and will fail to benefit those people unless technology is used to help meet their needs, rights advocates have warned.
Read More
Without better flood protection, Venice risks loss of heritage status
Venice could lose its status as a World Heritage Site if it does not adequately protect itself from worsening flooding, UNESCO representatives have warned, as they offered help after recent inundations.
Read More
A tour inside a Broadway theater is the place to geek out
Walking into a Broadway theater at show time is something special - the electricity, the excited murmurs, the shared anticipation. But, it turns out, walking into an empty Broadway theater can be just as fun.


"""Utilities for defining models """ # The following comment should be removed at some point in the future. # mypy: disallow-untyped-defs=False import operator class KeyBasedCompareMixin(object): """Provides comparison capabilities that is based on a key """ def __init__(self, key, defining_class): self._compare_key = key self._defining_class = defining_class def __hash__(self): return hash(self._compare_key) def __lt__(self, other): return self._compare(other, operator.__lt__) def __le__(self, other): return self._compare(other, operator.__le__) def __gt__(self, other): return self._compare(other, operator.__gt__) def __ge__(self, other): return self._compare(other, operator.__ge__) def __eq__(self, other): return self._compare(other, operator.__eq__) def __ne__(self, other): return self._compare(other, operator.__ne__) def _compare(self, other, method): if not isinstance(other, self._defining_class): return NotImplemented return method(self._compare_key, other._compare_key)


2 Kings 19:34
For I will defend this city, to save it, for mine own sake, and for my servant David's sake.


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 8
A classic Italian torte inspired by the rich, creamy flavours of tiramisu.
Preheat the oven to 180C/350F/Gas 4 and grease a 20cm/8in diameter springform cake tin.
For the torte, place the egg yolks in one glass bowl and the egg whites in another. Put the sugar in with the egg yolks and whisk until the mixture leaves a trail when you remove the whisk (it is called the ribbon stage).
Sieve in the cocoa powder and gently stir it into the egg yolk mixture.
Whisk the egg whites until stiff peaks form when you remove the whisk. Fold into the chocolate yolk mix. Place in the prepared cake tin and bake for 20 minutes.
Remove from the oven and allow to cool in the tin. Once cooled, cut the sponge in half horizontally and set aside.
Meanwhile make the crema inglese. Place the cream and milk in a large saucepan and place over a low heat to warm. Put the egg yolks in a large glass bowl, add the sugar and whisk. Add the warm cream and milk slowly to the eggs, whisking all the time.
Put the mixture back in a pan, add the coffee and heat until smooth and thickened.
To make the torte filling, pulse the chocolate in a food processor to break it up. Put the sugar and 100ml/3½fl oz water in a pan, bring to the boil and wait until the sugar has dissolved but has no colour.
Slowly add the sugar and water to the chocolate in the food processor while the motor is running. Add the egg yolks and blend until smooth.
In a separate bowl, whip the cream until stiff peaks form when the whisk is removed. Then fold in the chocolate mixture and mix until smooth.
To construct the torte, place one of the sponges in the bottom of the cake tin and pour over half the amaretto. Smooth over half the torte filling. Top with the other sponge and drizzle with the remaining amaretto. Smooth over the rest of the torte filling using a palette knife to get a neat finish.
Whip the cream for the topping and pipe on top. Sprinkle the grated chocolate over the on top.
To serve, cut a slice of the torte and pour the crema inglese around the torte.


34
1 Moreover, Elihu continued to speak:
2 "Listen to my words, you wise men;
hear me, you who have knowledge.
3 For the ear tries words
as the palate tastes food.
4 Let us choose for ourselves what is just:
let us discover among ourselves what is good.
5 For Job has said, 'I am righteous,
but God has taken away my rights.
6 Regardless of my rights, I am considered to be a liar.
My wound is incurable, although I am without sin.'
7 What man is like Job,
who drinks up mockery like water,
8 who goes around in the company of those who do evil,
and who walks with wicked men?
9 For he has said, 'It is no use to a person
to take pleasure in doing what God wants.'
10 So listen to me, you men of understanding:
far be it from God that he should do wickedness;
far be it from the Almighty that he should commit sin.
11 For he pays back a person's work;
he makes every man come upon the reward of his own ways.
12 Indeed, God does nothing wicked,
nor does the Almighty ever pervert justice.
13 Who put him in charge over the earth?
Who put the whole world under him?
14 If he ever set his intentions only on himself,
and if he ever gathered back to himself his spirit and his breath,
15 then all flesh would perish together;
mankind would return to dust again.
16 If now you have understanding, listen to this;
listen to the sound of my words.
17 Can one who hates justice govern?
Will you condemn God, who is righteous and mighty?
18 God, who says to a king, 'You are vile,'
or says to nobles, 'You are wicked'?
19 God, who does not show favoritism to leaders
and does not acknowledge rich people more than poor,
for they all are the work of his hands.
20 In a moment they will die;
at midnight people will be shaken and will pass away;
mighty people will be taken away, but not by human hands.
21 For God's eyes are upon a person's ways;
he sees all his steps.
22 There is no darkness, no thick gloom
where the doers of iniquity may hide themselves.
23 For God does not need to examine a person further;
there is no need for any person to go before him in judgment.
24 He breaks mighty men into pieces for their ways that need no further investigation;
he puts others in their places.
25 In this way he has knowledge of their deeds;
he overthrows these people in the night; they are destroyed.
26 In the open sight of others, he kills them for their wicked deeds like criminals
27 because they turned away from following him
and refused to acknowledge any of his ways.
28 In this way, they made the cry of poor people come to him;
he heard the cry of afflicted people.
29 When he stays silent, who can condemn him?
If he hides his face, who can perceive him?
He rules over nation and individual alike,
30 so that a godless man may not rule,
so that there may be no one to entrap people.
31 Suppose someone says to God,
'I am certainly guilty, but I will not sin any longer;
32 teach me what I cannot see;
I have committed sin, but I will do it no longer.'
33 Do you think that God will punish that person's sin, since you dislike what God does?
You must choose, not I.
So say what it is that you know.
34 Men of understanding will say to me—
indeed, every wise man who hears me will say,
35 'Job speaks without knowledge;
his words are without wisdom.'
36 If only Job were put on trial in the smallest details of his case
because of his talking like wicked men.
37 For he adds rebellion to his sin;
he claps his hands in mockery in our midst;
he piles up words against God."


Chunks
RAW mode
SIMPLE mode
ADVANCED mode
COMPILED mode (run `npm run build` in advance)
Load chunk1
Load chunk2


|
psl1ght
A free SDK for Sony's PS3 console
|
Pad peripheral information data structure. More...
#include <pad.h>
Data Fields | |
| u32 | max |
| max pads allowed to connect | |
| u32 | connected |
| how many pads connected | |
| u32 | info |
| bit 0 lets the system intercept pad? other bits are reserved | |
| u32 | port_status [MAX_PORT_NUM] |
| Bit 0: Connected (0: Disconnected, 1: Connected), Bit 1: assign changes? | |
| u32 | port_setting [MAX_PORT_NUM] |
| Bit 1: Pressure sensitivity turned on, Bit 2: Sensors turned on. | |
| u32 | device_capability [MAX_PORT_NUM] |
| Pad capability. More... | |
| u32 | device_type [MAX_PORT_NUM] |
| 0: Standard, 4: Bluray Remote, 5: LDD | |
| u32 | pclass_type [MAX_PORT_NUM] |
| Pad class type. | |
| u32 | pclass_profile [MAX_PORT_NUM] |
| Pad class profile. | |
Pad peripheral information data structure.
| u32 _pad_periph_info::device_capability[MAX_PORT_NUM] |
Pad capability.


Features
These two enchancements were sponsored and client agreed to share with community them!
You will find two new fields in "Synchronisation and sound settings" section.
execute doc/update_db/update_55.sql for update and follow standard upgrade tutorial I have also updated a little bit index.php file so it would be good if you replaced it also :)
Features
Download it from https://github.com/remdex/livehelperchat-extensions/raw/master/browsers-extensions/chrome/lhc/lhc_packed/lhc.crx
or just
https://github.com/remdex/livehelperchat-extensions/tree/master/browsers-extensions/chrome/lhc/lhc_packed
To operator should be assigned permission
"Chat" => "Allow user to user chrome extension"
After dowmloading chrome extension just drop it in chrome extensions window. Click options to enter chat path. And then just click icon and enter logins. To avoid entering logins every time just click remember me. I also recommend to grant browser to show notifications.
Here is chrome extension full tutorial
Bugfixes
And some other small bugfixes..
Features
Bugfixes:
execute doc/update_db/update_54.sql for update and follow standard upgrade tutorial I have also updated a little bit index.php file so it would be good if you replaced it also :)
So I and my good friend have established first commercial version for all who wants commercial support.
If you ask what's a difference between version you can download from github and the one i use for hosting. Actually there is NONE except I have written extension which handles automated hosting part, creating database, handling limitation etc. But all was done using extensions without changing a single core file. So you have enough knowledge you can do all that also!
If you ask me what this means for community?
Community version will be always for me the priority and you can always download it from github as you do now. So basically what you see in commercial version you can have it for free just by downloading and installing it on your server and do not depend on any service providers.
So be free, be independent!!!
So,
Finally decided to setup facebook page. You can find it here: https://www.facebook.com/LiveHelperChat If you like what I did in one year like this page.


Last updated: January 21, 2020
This website does not collect any personally identifiable information except for usernames, passwords, and images. However, it makes use of cookies and other tracking technologies.
Please contact me at szimmeckREPLACEWITHATwesleyan.edu for further information.
Sebastian Zimmeck


Innovative Software Engineer with 5 years of full software development lifecycle experience - from concept through delivery of cutting-edge software applications. An enthusiastic team player with a can-do attitude, phenomenal time management and a strong user focus.
Bachelor in Science & Computer Science currently working as Software engineer in a renowned company.
Aligarh Public School & College, Lahore
University of Management and Technology (UMT), Lahore
FreeLancer on various platforms like Freelancer.com and upwork.com
REDMATH is an agile and dynamic software house based in Lahore, Pakistan.
Vroozi Inc. was founded to help companies of all sizes and industries transform their supply chain operations.
Working Hours
Completed Projects
No. of Clients
Team Member


{% extends 'base.html' %} {% block content %} {% include 'questions/user_response_form.html' with instance=instance form=form %} {% endblock content %}


{{ref improve|date=April 2015}} {{Infobox prepared food | name = White bread | image = | caption = | alternate_name = | country = | region = | creator = | course = | type = Bread | served = | main_ingredient = Wheat flour | variations = | calories = | other = }} White bread typically refers to breads made from wheat flour from which the bran and the germ layers have been removed (and set aside) from the whole wheatberry as part of the flour grinding or milling process, producing a light-colored flour. This milling process can give white flour a longer shelf life by removing the natural oils from the whole grain. Removing the oil allows products made with the flour, like white bread, to be stored for longer periods of time avoiding potential rancidity.
The flour used in white breads may be bleached—that is, lightened further—by the use of chemicals such as potassium bromate, azodicarbonamide, or chlorine dioxide gas to remove any slight, natural yellow shade and make its baking properties more predictable. Some flour bleaching agents are banned from use in some countries.
In the United States, consumers sometimes refer to white bread as sandwich bread and sandwich loaf.<ref name="Mercuri 2009 p. 9"/>
{{portal|Food}}
{{commonscat|White breads}} {{Reflist|refs= <ref name="Mercuri 2009 p. 9">{{cite book | last=Mercuri | first=B. | title=American Sandwich | publisher=Gibbs Smith, Publisher | year=2009 | isbn=978-1-4236-1192-9 | url=http://books.google.com/books?id=k6tsfBwoTn8C&pg=PA9 | page=9}}</ref> }}
{{Bread}}
{{DEFAULTSORT:White Bread}}


1 March 2004 - Enzo is released to the public.
28 July 2003 - Enzo is released to friendly users.
1 July 2003 - Enzo bundle is prepared in preparation for release to friendly users. The code bundle includes: enzo, analysis tools (enzo_anyl, enzohop, findpeaks), inits, HDF 5 tools, ring. These packages compile and run on all currently allocated NCSA, SDSC and PSC systems as well as on various sites' Teragrid clusters. Pre-public release change information can be found here.


| Ticket ID: 409788 | Name: | Parker Seidel No Active Support |
Email: |<EMAIL_ADDRESS>| Response Time: | 72hours , 60 hours left | Last Action: | Never been locked. Link to public post |
Status: | Not answered |


We use local leaders, local accommodation and support local community projects, ensuring we keep sustainability and responsible tourism at the centre of everything we do. Our grassroots style of travel ensures unforgettable real life experiences for your family, while at the same time minimising our impact on the communities we visit.
Most importantly, our expert leaders take the stress and strain of organisation and timekeeping away from the parents. This allows you to sit back and share the experience with your children, so you can actually enjoy a holiday together rather than organising everything yourself.
We all know how much energy is needed to keep up with our kids and their constant need for entertainment. But on a Family Adventure, ready-made companions are aplenty as all the kids naturally band together. We strive to match the kid's ages on each of our trips, and with a highly trained, kid-friendly leader on board, you can join in on the fun or happily watch them in their games of discovery.
Our Family Adventures are not about kid's clubs and separate activities. Our trips encourage the whole family to get involved and share in the experience together. From riding camels through the desert and sea kayaking over a sunken city to meeting Africa's quirky wildlife and getting to know a family in Cuba, our trips introduce your family to new experiences that will create lasting memories to be shared around the dinner table for years to come.
We've put years of research into our itineraries, activities, operators and accommodation. So why spend hours agonising over every detail of your trip when you can leave it to someone who lives and breathes your style of travel? Whether your family has limited time or you want to explore a destination that's outside your comfort zone, your family will have the support and expertise you need for a hassle-free holiday.


Hello, I am Zyris Shakir
What's up! I love to build robots. Actually my best-friend is a robot named Clovis. Would you like to meet him? Nah your not cool enough. You'd have to beat me in a dance off first.
What's up! I love to build robots. Actually my best-friend is a robot named Clovis. Would you like to meet him? Nah your not cool enough. You'd have to beat me in a dance off first.


--- layout: post title: Ouvert sur l'anglais du monde date: 2016-12-22 10:33:03.000000000 -05:00 type: post published: true status: publish categories: - La langue des autres tags: - accents - Anglais mondiaux meta: _wpcom_is_markdown: '1' _rest_api_published: '1' _rest_api_client_id: "-1" _publicize_job_id: '30266524404' _publicize_done_external: a:1:{s:7:"twitter";a:1:{i:51729;s:60:"https://twitter.com/AngryFrenchGuy/status/811958648461205504";}} _publicize_done_13019344: '1' _wpas_done_51729: '1' publicize_twitter_user: AngryFrenchGuy author: login: angryfrenchguy email<EMAIL_ADDRESS>display_name: angryfrenchguy first_name: '' last_name: '' ---
Geoffrey Pullum, dans The Chronicle of Higher Education, raconte la fois à un étudiant s'est plaint de l'accent de son prof qui venait... d'Angleterre.
"Of course, it’s true that many Americans are far too insular, and one of the key things they need to get out of a college education is the experience of encountering smart people with accents they never heard before, and may initially have trouble understanding. Treating every different kind of accent as weird and upsetting as you go through life in this globalized world would be babyish, so students who have never been outside Riverside County or seen a foreign film do need to grow up a bit linguistically. " Make American Accents Great Again – Lingua Franca - Blogs - The Chronicle of Higher Education
So, on est rendu là? Pour être "ouvert sur le monde", il est suffisant de tolérer d'autres accents anglais?


This is the HTML implementation of UX, this page runs the same demo code while using standard HTML to render the controls.


Please take your time and peruse our site to gather the different pieces of information necessary to plan your tour.
Fill out the form below by writing down all the necessary informations. After we receive your email we’ll take it from there!
Thank you for your interests in Ethiopia and we look forward to serving with you.
THANK YOU FOR YOUR VALUABLE TIME!
All the information website visitors provide in the contact form is confidential and is not to be disclosed
without a given permission.


Absolute kinematic quantities of frame_a are determined and provided at the conditional output signal connectors. For example, if parameter "get_r = true", the connector "r" is enabled and contains the absolute vector from the world frame to the origin of frame_a. The following quantities can be provided as output signals:
Via parameter resolveInFrame it is defined, in which frame a vector is resolved:
| resolveInFrame = Types.ResolveInFrameA. |
Meaning |
|---|---|
| world | Resolve vectors in world frame |
| frame_a | Resolve vectors in frame_a |
| frame_resolve | Resolve vectors in frame_resolve |
If resolveInFrame = Types.ResolveInFrameA.frame_resolve, the conditional connector "frame_resolve" is enabled and the vectors are resolved in the frame, to which frame_resolve is connected. Note, if this connector is enabled, it must be connected.
In the following figure the animation of an AbsoluteSensor component is shown. The light blue coordinate system is frame_a and the yellow arrow is the animated sensor.
Velocity, acceleration, angular velocity and angular acceleration are determined by differentiating them in the world frame and then transforming them in to the frame defined by resolveInFrame.
For example, if resolveInFrame = Types.ResolveInFrameA.frame_a, then
v0 = der(frame_a.r0); v = resolve2(frame_a.R, v0);
is returned, i.e., the derivative of the absolute distance from the world frame to the origin of frame_a, resolved in frame_a.
The cut-force and the cut-torque in frame_resolve are always zero, whether frame_resolve is connected or not.
If get_angles = true, the 3 angles to rotate the world frame into frame_a along the axes defined by parameter sequence are returned. For example, if sequence = {3,1,2} then the world frame is rotated around angles[1] along the z-axis, afterwards it is rotated around angles[2] along the x-axis, and finally it is rotated around angles[3] along the y-axis and is then identical to frame_a. The 3 angles are returned in the range
-p <= angles[i] <= p
There are two solutions for "angles[1]" in this range. Via parameter guessAngle1 (default = 0) the returned solution is selected such that |angles[1] - guessAngle1| is minimal. The absolute transformation matrix of frame_a may be in a singular configuration with respect to "sequence", i.e., there is an infinite number of angle values leading to the same absolute transformation matrix. In this case, the returned solution is selected by setting angles[1] = guessAngle1. Then angles[2] and angles[3] can be uniquely determined in the above range.
The parameter sequence has the restriction that only values 1,2,3 can be used and that sequence[1] ≠ sequence[2] and sequence[2] ≠ sequence[3]. Often used values are:
sequence = {1,2,3} // Cardan or Tait-Bryan angle sequence = {3,1,3} // Euler angle sequence = {3,2,1}


| Platform | Since |
|---|---|
| iPhone | 3.3.0 |
| iPad | 3.3.0 |
The pitch of the device, in radians.
A pitch is a rotation around a lateral axis that passes through the device from side to side.
CoreMotionQuaternion
Returns a quaternion representing the device's attitude.
See CoreMotionQuaternion
for further information.
The roll of the device, in radians.
A roll is a rotation around a longitudinal axis that passes through the device from its top to bottom.
CoreMotionRotationMatrix
Returns a rotation matrix representing the device's attitude.
A rotation matrix in linear algebra describes the rotation of a body in three-dimensional Euclidean space.
The yaw of the device, in radians.
A yaw is a rotation around an axis that runs vertically through the device. It is perpendicular to the body of the device, with its origin at the center of gravity and directed toward the bottom of the device.
Yields the change in attitude given a specific attitude.
This method multiplies the inverse of the specified CoreMotionAttitude
object by the attitude represented by the receiving object. It replaces
the receiving instance with the attitude change relative to the object
passed in attitude. You should cache the CoreMotionAttitude
instance
you want to use as a reference and pass that object as the argument to
subsequent calls of this method.
CoreMotionAttitude
An object representing the device's attitude at a given moment of measurement.


{% include site-head.html %}
{% include docs-header.html %}Verify that you are running at least Node.js version 8.x or greater and npm version 5.x or greater by running node -v and npm -v in a terminal/console window.
$ npm install -g @aws-amplify/cli
$ amplify configure


( A) Temperature dependent PL spectra of CLSO:0.20Dy 3+/0.20Sm 3+ phosphor in the range of 303–423 K. ( B) The chromaticity diagram of CLSO:0.20Dy 3+ (0.286,0.312) and CLSO:0.20Dy 3+/0.20Sm 3+ (0.309,0.309) phosphors, and digital photograph shows that “FU” and “JIE” are spelled using CLSO:0.20Dy 3+ and CLSO:0.20Dy 3+/0.20Sm 3+ phosphors at 365 nm excitation respectively.


--- layout: post title: Separation of concerns for JIRA gadgets date: 2015-10-16 19:43:48.000000000 +01:00 type: post published: true status: publish categories: - web tags: - atlassian - atlassian plugin sdk - JIRA - opensocial meta: _wpcom_is_markdown: '1' _edit_last: '1' _publicize_twitter_user: "@dvdsmpsn" _syntaxhighlighter_encoded: '1' _wpas_done_all: '1' _pingme: '1' _encloseme: '1' _wpas_skip_11278197: '1' author: David Simpson excerpt_separator: ---
This blog post started out as an answer to a Stack Overflow question.
For my gadgets, I separate out all the XML, HTML, JavaScript and CSS from the atlassian-plugin.xml
.
The setup is initially more complex, but once you've got this correct, the separation of concerns is much nicer than mangling everything into the atlassian-plugin.xml
file.
The relative paths on the other hand do indeed look crazy.
My file system looks like this:
- resources/
- gadgets/
- css/
- example.css
- html/
- example.html
- js/
- example.js
- examaple-gadget.xml
- atlassian-plugin.xml
In /resources/atlassian-plugin.xml
:
<!-- add our web resources -->
<web-resource key="${project.artifactId}-resources" name="${project.artifactId} Web Resources">
<dependency>com.atlassian.auiplugin:ajs</dependency>
<resource type="download" name="example-gadgets/" location="/gadgets"/>
<context>immersive-for-connections</context>
</web-resource>
<gadget name="Example JIRA Gadget" i18n-name-key="example-jira-gadget.name"
key="example-jira-gadget" location="gadgets/example-gadget.xml">
<!--
hosted at:
/rest/gadgets/1.0/g/${project.groupId}.${project.artifactId}:example-gadgets/gadgets/example-gadget.xml
-->
<description key="jira-query-gadget.description">The JIRA Query Gadget Plugin</description>
</gadget>
In /resources/gadgets/example-gadget.xml
(replace ${project.artifactId}
& ${project.groupId}
with the correct value):
<?xml version="1.0" encoding="UTF-8" ?>
<Module>
...
<Content type="html" view="example.view" preferred_width="100%"
href="../../../../../../download/resources/${project.groupId}.${project.artifactId}:${project.artifactId}-resources/gadgets/html/example.html"/>
</Module>
In /resources/gadgets/html/example.html
(replace ${project.artifactId}
& ${project.groupId}
with the correct value):
<!DOCTYPE html>
<html>
<head>
...
<link href="../../../../../../download/resources/${project.groupId}.${project.artifactId}:${project.artifactId}-resources/gadgets/css/example.css"
type="text/css" rel="stylesheet">
<script src="../../../../../../download/resources/${project.groupId}.${project.artifactId}:${project.artifactId}-resources/gadgets/js/example.js">
</script>
</head>
<body>
...
</body>
</html>
From this somewhat excessing starting point, you'll have content, behaviour and styles completely separated. If that floats your boat, then you'll be happy.


Wasp Swarm
Wasp, Giant
Water Weird
Weasel, Dire
Weasel
Wendigo
Whale, Great White
White Dragon, Adult
White Dragon, Ancient
White Dragon, Great Wyrm
White Dragon, Juvenile
White Dragon, Mature Adult
White Dragon, Old
White Dragon, Very Old
White Dragon, Very Young
White Dragon, Wyrm
White Dragon, Wyrmling
White Dragon, Young Adult
White Dragon, Young
Wight, Barrow
Wight
Will-o'-Wisp
Winter Wolf
Witchwyrd
Wizard's Shackle
Worg
Wraith, Dread
Wraith
Wyvern


A FANTASTIC ENGAGING HEADLINE GOES HERE
Echo Park Bushwick street art VHS, whatever kitsch tilde swag Austin banh mi. Farm-to-table art party VHS, kale chips locavore PBR&B Neutra lomo 3 wolf moon pug. Actually occupy street art Pitchfork church-key. Direct trade viral selvage narwhal, Echo Park photo booth meditation seitan hella tote bag bicycle rights Blue Bottle aesthetic scenester. Photo booth roof party hashtag, direct trade craft beer Intelligentsia meh dreamcatcher keytar. Fixie Portland readymade 90's VHS church-key. Ennui Thundercats seitan PBR.
Vegan craft beer wayfarers cronut YOLO, yr paleo 8-bit gluten-free stumptown four loko gastropub flexitarian beard. Pickled taxidermy Williamsburg try-hard, beard semiotics pop-up. Retro street art heirloom, disrupt Schlitz squid occupy locavore forage ethical. Single-origin coffee fanny pack PBR&B leggings street art cliche photo booth McSweeney's. Deep v wolf pug vegan wayfarers, Brooklyn banjo four dollar toast. Try-hard art party Austin migas tilde Helvetica 8-bit seitan, artisan wayfarers Kickstarter flannel PBR&B disrupt forage. Austin lo-fi Brooklyn, ennui ethical taxidermy cold-pressed mlkshk meditation hoodie pop-up Tumblr Shoreditch.
This is a pull quote from the article.
McSweeney's four loko banjo freegan. Yr fap fanny pack fixie. Fashion axe squid VHS stumptown Carles before they sold out. Salvia post-ironic viral Pitchfork, American Apparel bicycle rights swag PBR&B Portland fashion axe polaroid plaid quinoa Carles disrupt. American Apparel keytar irony selvage, deep v paleo pour-over cred leggings typewriter Schlitz meditation whatever. Flexitarian mlkshk swag cliche, meditation art party bicycle rights taxidermy. Tote bag lomo synth Blue Bottle, Shoreditch drinking vinegar freegan raw denim chambray scenester fanny pack retro ugh.
Tote bag farm-to-table Echo Park direct trade, sustainable literally Brooklyn 3 wolf moon jean shorts XOXO sriracha. Keffiyeh Neutra polaroid, scenester 3 wolf moon gluten-free twee. Chambray migas direct trade, fap 90's meditation American Apparel meggings mustache pug Wes Anderson trust fund Pitchfork VHS banh mi. Lo-fi hashtag blog, fashion axe pop-up brunch fap roof party Wes Anderson taxidermy fingerstache Carles Marfa aesthetic meditation. Typewriter yr chambray, tote bag organic iPhone pug letterpress leggings hella VHS PBR&B. Organic YOLO direct trade salvia, biodiesel sustainable McSweeney's trust fund lomo skateboard. Swag XOXO butcher slow-carb, skateboard master cleanse yr authentic four dollar toast brunch viral before they sold out tattooed.


Last week I had the opportunity to attend Container.Camp in San Francisco and present an introduction to Project Atomic. If you didn’t get to attend – or just want to relive the talk – you can find it on YouTube (also embedded below).
If you’d like to see all of the Container.Camp presentations, they’re available on YouTube under the Container.Camp channel. Thanks again to the Container.Camp organizers for inviting me to speak, it was a great event. Fantastic speakers, really interesting venue, and a great crowd.


I'm really enjoying working with phaser. To paraphrase the Phaser website it is "A fast, free and fun open source framework for Canvas and WebGL powered browser games." and it really is!


Machine Translation¶
Models¶
Currently we support following models:
| Model description | SacreBLEU | Config file | Checkpoint |
|---|---|---|---|
| Transformer | 26.4 | transformer-big.py | TBD |
| ConvS2S | 25.0 | en-de-convs2s.py | TBD |
| GNMT | 23.0 | en-de-gnmt-like-4GPUs.py | TBD |
The model specification and training parameters can be found in the corresponding config file. We measure BLEU scores using SacreBLEU.
Getting started¶
For a simplest example using toy-data (string reversal task) please refer to toy models.
Next let’s build a small English-German translation model. This model should train in a reasonable time on a single GPU.
Get data¶
Download (this will take some time):
scripts/get_en_de.sh
This script will download English-German training data from WMT, clean it, and tokenize using Google’s Sentencepiece library By default, the vocabluary size we use is 32,768 for both English and German.
Training¶
To train a small English-German model:
- change
data_root
insideen-de-nmt-small.py
to the WMT data location - adjust
num_gpus
to train on more than one GPU (if available).
Start training:
python run.py --config_file=example_configs/text2text/en-de-nmt-small.py --mode=train_eval
If your GPU does not have enough memory, reduce the batch_size_per_gpu
. Also, you might want to disable parallel evaluation by using --mode=train
.
Inference¶
Once training is done (this can take a while on a single GPU), you can run inference:
python run.py --config_file=example_configs/text2text/en-de-nmt-small.py --mode=infer --infer_output_file=raw.txt --num_gpus=1
Note that the model output is tokenized. In our case it will output BPE segments instead of words. Therefore, the next step is to de-tokenize:
python tokenizer_wrapper.py --mode=detokenize --model_prefix=.../Data/wmt16_de_en/m_common --decoded_output=result.txt --text_input=raw.txt
Computing BLEU scores¶
We measure BLEU scores using SacreBLEU package: (A Call for Clarity in Reporting BLEU Scores) Run SacreBleu on detokenized data:
cat result.txt | sacrebleu -t wmt14 -l en-de > result.txt.BLEU