| PCK Required Reading |
Table of ContentsPCK Required Reading Abstract Intended Audience References Introduction Body Codes Epochs and Reference Frames Planetocentric Coordinates Using the PCK System: Overview Orientation Models used by PCK Software The Two Formats of PCK files Detection of Non-native Text Files DAF Run-Time Binary File Format Translation NAIF Text Kernel Format Text PCK Contents Text PCK Kernel Variable Names Restrictions on the Availability of Orientation Models in Text PCK Kernels Models for the Sun, Planets, and some Minor Bodies in Text PCK Kernels Models for Satellites in Text PCK Kernels Shape models in Text PCK Kernels Summary of PCK Variables used in Text PCK Kernels by Mice Creating and Modifying Text PCKs Binary PCK Kernel Format Segments--The Fundamental PCK Building Blocks The Comment Area Binary PCK Data Types Supported Data Types Type 2: Chebyshev (Angles only) Type 3: Chebyshev (Angles and their derivatives) Type 20: Chebyshev (Only angular derivatives) Creating Binary PCKs PCK Software Getting PCK Data into Your Program Loading Text PCK Kernels Loading Binary PCK Kernels Unloading Binary PCK Kernels Access Routines High-Level PCK Data Access Low-Level PCK Data Access Summary of Calling Sequences Appendix A --- Summary of PCK Routines Appendix B --- Epoch and Frame Specifications in Text PCK Kernels Appendix C --- Revision History 2013 JAN 22 by E. D. Wright, C. H. Acton 2010 JUN 03 by B. V. Semenov. Original version K.R. Gehringer, K. S. Zukor PCK Required Reading
Abstract
Intended Audience
References
Introduction
Historically, only one type of PCK existed, the text PCK (called the "P constants kernel.") These ASCII files can be easily viewed and modified via text editor. The current SPICE system also supports a non-ascii binary PCK. These files contain more precise body orientation information in binary format (no size and shape data). This format permits large amounts of data to be stored and quickly accessed. As of the date of this document, binary PCK files exists only for the moon, earth, and the asteroid Eros. The purpose of the PCK and associated software is to provide SPICE users a convenient mechanism for supplying planetary physical constants to application programs. Mice software reads files conforming to these formats and returns both the data contained in such files and a few commonly used numeric quantities derived from the kernel data. Body Codes
In this document, the following features of the code system will be relied on:
PNN, where P is 1, ..., 9 and NN is 01, ... 98
PXNNN, where P is 1, ..., 9, X is 0 or 5, and NNN is 001, ... 999 Codes with X = 5 are provisional.
Epochs and Reference Frames
Within Mice, reference frames are identified by short character strings such as 'J2000'. The names of the body-fixed reference frames are usually constructed by adding the prefix ``IAU_'' to the name of the body, for example ``IAU_MARS'' for Mars. The exception from this rule are body-fixed reference frames associated with high-precision orientation provided in binary PCK files. For more details see FRAMES Required Reading, frames.req. However, Mice also has a system of integer codes used by some routines to specify reference frames. This coding system is also described in detail in frames.req. Planetocentric Coordinates
Using the PCK System: Overview
The use of PCK data in an application program requires three steps:
Step 2 is referred to as ``loading'' a PCK file. Text PCK files are loaded by calling the Mice subroutine cspice_furnsh and supplying the name of the PCK file to load as the input argument or by loading a meta kernel that lists the PCK. All data in a text PCK file is read into memory when the file is loaded by an application program at run-time. Load binary PCKs in the same way. The program can access all loaded data during the program run, unless deliberately overwritten or unloaded. Multiple text and multiple binary PCKs can be used simultaneously. The data available from binary PCKs take precedence over that from text PCKs. If data for a requested planetary constant and time period is covered by a loaded binary PCK file, the subsystem returns and uses the binary data. If multiple binary PCK files are loaded, the most recently loaded file takes precedence, down to the binary file loaded earliest. The subsystem defaults to text PCK data when no binary PCK data is available. If the user loaded multiple text PCKs, and those PCKs contained variable assignments using the same variable name, the later loads overwrite the assignments defined by earlier loads. Step 3, using loaded PCK data, is accomplished via calls to Mice routines. At the lowest level, these access routines allow the calling program to retrieve specified data that has been read from one or more PCK files. Higher-level access routines can return quantities derived from loaded PCK data. For text PCK files, the PCK software can be thought of as ``buffering'' all data loaded from PCK files: the data from these files is retained in memory. Therefore, repeated calls to the PCK access routines do not incur the inefficiency of re-reading data from files. For binary PCK file, like the case of the SPK and CK readers, only a portion of the most recently used information is buffered. The data structure used by Mice to maintain associations of text kernel variable names and values is called the ``kernel pool.'' Data loaded into memory via cspice_furnsh is referred to as ``being present in the kernel pool.'' There is no analog to the kernel pool for binary PCK files. Orientation Models used by PCK Software
The orientation models use three Euler angles to describe the pole and prime meridian location: the first two angles, in order, are the right ascension and declination (henceforth RA and DEC) of the north pole of a body as a function of time. The third angle is the prime meridian location (represented by `W'), which is expressed as a rotation about the north pole, also a function of time. The coordinate transformation defined by the Euler angles is represented by the matrix product
[ W ] [ Pi/2 - Dec ] [ Pi/2 + RA ] 3 1 3where
[ W ] idenotes the matrix that rotates a coordinate system by W radians about the ith coordinate axis (or rotates vectors by -W radians about the same axis), using the right hand rule. (This notation is explained in detail in rotation.req). In PCK files, the time arguments of functions that define orientation always refer to Barycentric Dynamical Time (TDB), measured in centuries or days past a specified epoch such as J2000, which is Julian ephemeris date 2451545.0. The time units expected by the Mice software are ephemeris days for prime meridian motion and ephemeris centuries for motion of the pole. The Two Formats of PCK files
Detection of Non-native Text Files
Environment Native End-Of-Line Indicator ___________ _____________________ PC DOS/Windows <CR><LF> Mac OS X, Linux, Unix <LF> DAF Run-Time Binary File Format Translation
NAIF Text Kernel Format
Text PCK files conform to a flexible format called ``NAIF text kernel'' format. The SPICE file identification word provided by itself on the first line of the text PCK file is ``KPL/PCK''. Both the NAIF text kernel format and SPICE file identification word are described in detail in the Kernel Required Reading document, kernel.req. For the reader's convenience, an overview of the NAIF text kernel format is provided here. NAIF text kernels are, first of all, ASCII files. As such, they are human readable and can be easily modified by text editors. In addition, NAIF text kernels can be readily ported between computer systems, even when the systems in question have different file systems and file formats. The NAIF text kernel format provides for representation of data in a ``keyword = value'' syntax. The format also provides for the inclusion of free-form comment blocks. There are two kinds of data that can be placed in NAIF text kernel files: double precision numbers and UTC time strings. According to the text kernel format, a text kernel nominally consists of a series of sets of contiguous lines (or ``blocks'') of comments, alternating with blocks of data. Comment blocks are started with the string (called a ``control sequence'')
\begintextalone on a line, as shown here. Comment blocks are ended by the control sequence
\begindataalone on a line. In a text kernel file, the lines preceding the first
\begindatacontrol sequence are considered to constitute a comment block; the
\begintextcontrol sequence is optional for this comment block. Comment blocks can contain arbitrary text, except for non-printing characters or lines that can be interpreted as control sequences. On the other hand, data must be organized according to a very specific format: all of the data in a text kernel must appear in the form of an ``assignment'' such as
NAME = VALUEor
NAME = ( VALUE1, VALUE2, ... )where "NAME" is a string no longer than 32 characters, and one or more values appear on the right hand. A specific example is shown below:
BODY399_RADII = ( 6378.140 6378.140 6356.75 )The "VALUES" may be integer, double precision or string values. Some variations on the form shown here are allowed: commas between data values are optional, the right hand side of the assignment can be continued over multiple lines, and the data values can be expressed as integers or reals without causing the PCK software to fail. Either an "E" or "D" can be used to set off an exponent. Assignments of scalars do not require the value on the right hand side to be enclosed in parentheses, but that notation is frequently used as a visual cue. Blank lines within or between assignments are ignored by the Mice software that reads text kernels. In addition to numbers, UTC strings can be assigned to variables. The ``@'' character is used to identify the strings as time strings. The strings are stored internally as double precision numbers representing ``UTC seconds past J2000.'' An example is the assignment:
SCLK_KERNEL_ID = ( @01-MAY-1991/16:25 )See kernel.req for a complete discussion of the allowed form of assignments. The effect of an assignment in a text PCK file is to associate values with a name. The name is referred to as a ``kernel variable.'' When a text PCK file is loaded by an application, the associations of names and values established by the PCK are maintained: the values associated with a given name can be retrieved at any time. Text PCK Contents
Mice includes a set of routines (cspice_gipool, cspice_gdpool, cspice_gipool) for general access to text PCK defined data. Another set (cspice_bodvrd, cspice_bodvcd, cspice_sxform, cspice_pxform) recognizes and uses particular PCK data to return body constants or the matrices to transform position or state vectors between reference frames. In this document, the formulas defining time-varying coordinate transformation matrices and Euler angles are referred to as ``orientation models'' since they define the orientation of an extended body with respect to specific inertial frames. Because PCK access routines that deal with orientation models are used extensively in Mice and applications that use the Toolkit, the kernel variables that these routines rely on will be discussed in detail. Those functions defining the Euler angles are characterized by a set of parameters. The specific values of the parameters are values assigned to kernel variables in PCK files. The functions themselves are implemented by code within Mice routines. The general form of the functions is that used in the IAU/IAG 2000 report. Values shown in this document reflect the 2000 report. For the latest PCK values, check with NAIF. In a text PCK file, the variables (Euler angles)
RA, DEC, Wfor the Earth (Earth ID = 399) are represented by the names
BODY399_POLE_RA BODY399_POLE_DEC BODY399_POLE_PMThe equations above are expressed in a text PCK file by the kernel variable assignments (Values taken from IAU/IAG 2000 report.)
BODY399_POLE_RA = ( 0. -0.641 0. ) BODY399_POLE_DEC = ( +90. -0.557 0. ) BODY399_PM = ( 190.16 +360.9856235 0. )If you examine a PCK file produced by NAIF, you'll see an additional symbol grouped with the ones listed here; it is
BODY399_LONG_AXISIt represents the offset between the longest axis of the triaxial ellipsoid used to model a body and the prime meridian of the body. This term is currently zero for all bodies except Mars. Text PCK Kernel Variable Names
BODYnnn_<item name>where
<item name>is a short string that identifies the type of quantity the kernel variable represents. For example, the variable containing quadratic polynomial coefficients for the right ascension of the Earth's north pole is
BODY399_POLE_RAThe following sections specify the specific item names recognized by PCK access routines. Restrictions on the Availability of Orientation Models in Text PCK Kernels
Models for the Sun, Planets, and some Minor Bodies in Text PCK Kernels
Let RA and DEC represent the right ascension and declination of a body's north pole as expressed in the J2000 frame, and let W be the prime meridian location, measured in the counterclockwise direction, from the direction defined by the cross product of the Z direction in the J2000 frame (the Earth's ``mean'' North pole at the J2000 epoch) and BODY's North pole at ET, to BODY's prime meridian at ET. The variables RA, DEC, and W constitute sufficient information to compute the transformation from a specified inertial frame to body-fixed, planetocentric coordinates for the body to which they apply, at a specified time. The angles RA, DEC, and W are defined as follows:
2 RA2*t RA = RA0 + RA1*t/T + ------ 2 T 2 DEC2*t DEC = DEC0 + DEC1*t/T + ------- 2 T 2 W2*t W = W0 + W1*t/d + ----- 2 dwhere
d = seconds/day T = seconds/Julian century t = ephemeris time, expressed as seconds past the reference epoch for this body or planetary system Models for Satellites in Text PCK Kernels
Expressions for the right ascension and declination of the north pole and the location of the prime meridian for any satellite of a given planet are as follows:
2 ____ RA2*t \ RA = RA0 + RA1*t/T + ------ + / a * sin * theta 2 ---- i i T i 2 ____ DEC2*t \ DEC = DEC0 + DEC1*t/T + ------- + / d * cos * theta 2 ---- i i T i 2 ____ W2*t \ W = W0 + W1*t/d + ----- + / w * sin * theta 2 ---- i i d iwhere
d = seconds/day T = seconds/Julian century t = ephemeris time, expressed as seconds past a reference epochRA0, RA1, DEC0, DEC1, W0, and W1 are constants specific to each satellite. The nutation precession angles
theta iare specific to each planet. The coefficients
a , d , and w i i iare specific to each satellite. Mice software for text PCKs expects the models for satellite orientation to follow the form of the model shown here: the polynomial terms in the RA, DEC, and W expressions are expected to be quadratic, the trigonometric terms for RA and W (satellite prime meridian) are expected to be sums of sines of nutation precession angles, and the trigonometric terms for DEC are expected to be sums of cosines of nutation precession angles. The nutation precession angles themselves are defined by linear polynomial functions of time. Note that the number of values defining the nutation precession angles for a planetary system must be consistent with the number of trigonometric terms used in the expressions for the RA, DEC and W angles for the satellites of that system. See ``Creating and Modifying Text PCKs Kernels'' for details. Shape models in Text PCK Kernels
In text PCK files produced by NAIF, the radius values for body nnn are assigned to the variable as:
BODYnnn_RADII = ( a, b, c )where ``a,'' ``b,'' and ``c'' are the radius values for each axis. Three radius values are always assigned for each instance of this variable. The data are ordered as in the IAU/IAG report: the equatorial radii are listed with the largest axis, normally called the ``a'' axis, appearing first; the polar radius, normally called the ``c'' axis, is last. Spheroids and spheres are obtained when two or all three radii are equal. Summary of PCK Variables used in Text PCK Kernels by Mice
BODYppp_POLE_RA BODYppp_POLE_DEC BODYppp_PMFor a satellite (say body number sss), one or more PCK files containing values for the following variables must be loaded:
BODYsss_POLE_RA BODYsss_POLE_DEC BODYsss_PM BODYsss_NUT_PREC_RA BODYsss_NUT_PREC_DEC BODYsss_NUT_PREC_PM BODYbbb_NUT_PREC_ANGLESwhere the code bbb embedded in the last name above is that of the barycenter of the planetary system to which the satellite belongs. The triaxial ellipsoidal model for body nnn is expressed by the assignment
BODYnnn_RADII = ( <larger equatorial radius>, <smaller equatorial radius>, <polar radius> ) Creating and Modifying Text PCKs
Although the text PCK format makes it easy to modify text PCK files, NAIF recommends that application programmers avoid software designs that call for special-purpose, user-created text PCK files. The opportunities for confusion and errors increase with the number of available versions of a text PCK file (or any data file). NAIF recommends that you take the following precautions when modifying a text PCK file:
BODYnnn_where nnn is the NAIF integer code of the body corresponding to the variable. Kernel variables having names recognized by users' application software are a potential problem area: if the names used in the application don't match those in the text PCK file, the application will fail to obtain the data as intended. The most frequent cause of this type of failure is misspelling of variable names, but programmers who considering changing the names of PCK variables already in use should also keep this problem in mind. Modifying orientation models for satellites requires attention to the consistency between the number of nutation precession angles and the number of coefficients of trigonometric functions having the nutation precession angles as arguments. For any planetary system, there should be twice as many values for the nutation precession angles as the maximum number of trigonometric terms in the expressions for prime meridian location or right ascension or declination of the pole of any satellite in the system. This is because the nutation precession angles are defined by linear polynomials; each polynomial has two defining coefficients. Binary PCK Kernel Format
Segments--The Fundamental PCK Building Blocks
The data in each segment are stored as a single array. The summary for the array, called a `descriptor', has two double precision components:
The Comment Area
Mice provides a family of subroutines for handling this Comment Area. This software provides the ability to add, extract, read, and delete comments and convert commented files from binary format to transfer format and back to binary again. Binary PCK Data Types
Supported Data Types
Type 2: Chebyshev (Angles only)
The segments contain an arbitrary number of logical records with each record describing a set of Chebyshev coefficients valid across an interval of fixed length. A segment consists of a set of records, ordered by increasing initial epoch, each record containing the same number of coefficients. The segment structure is illustrated below:
+---------------+ | Record 1 | +---------------+ | Record 2 | +---------------+ . . . +---------------+ | Record N | +---------------+ | INIT | +---------------+ | INTLEN | +---------------+ | RSIZE | +---------------+ | N | +---------------+A four-number `directory' at the end of the segment contains the information needed to determine the location of the record corresponding to a particular epoch.
polynomial degree = ( RSIZE - 2 ) / 3 - 1The structure of each record:
--------------------------------------------------------------- | The midpoint of the approximation interval in TDB seconds | --------------------------------------------------------------- | The radius of the approximation interval in TDB seconds | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for RA | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for DEC | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for W | ---------------------------------------------------------------TDB seconds is time in ephemeris seconds past J2000, often called ET in the SPICE system. The first two elements in the record, MID and RADIUS, are the midpoint and radius of the time interval covered by coefficients in the record. These are used as parameters to perform transformations between the domain of the record (from MID - RADIUS to MID + RADIUS) and the domain of Chebyshev polynomials (from -1 to 1 ). Type 3: Chebyshev (Angles and their derivatives)
Each segment contains an arbitrary number of logical records. All records contain the same number of coefficients. A segment of this type is structured as follows:
+---------------+ | Record 1 | +---------------+ | Record 2 | +---------------+ . . . +---------------+ | Record N - 1 | +---------------+ | Record N | +---------------+The structure of each record:
--------------------------------------------------------------- | The midpoint of the approximation interval in TDB seconds | --------------------------------------------------------------- | The radius of the approximation interval in TDB seconds | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for RA | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for DEC | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for W | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for the body | | fixed X-axis rate | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for the body | | fixed Y-axis rate | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for the body | | fixed Z-axis rate | ---------------------------------------------------------------TDB seconds is time in ephemeris seconds past J2000, called ET in the SPICE system. The type 3 data type is seldom used. Type 20: Chebyshev (Only angular derivatives)
This data type is provided to accurately represent ``EPM'' orientation data developed by the Institute of Applied Astronomy (IAA), Russian Academy of Sciences (RAS). Each type 20 segment contains an arbitrary number of logical records. Each record contains a set of Chebyshev coefficients valid throughout an interval of fixed length. Each record also contains an Euler angle set applicable at the midpoint of its coverage interval. The records within a segment are ordered by increasing initial epoch. All records contain the same number of coefficients. A segment of this type is structured as follows:
+---------------+ | Record 1 | +---------------+ | Record 2 | +---------------+ . . . +---------------+ | Record N | +---------------+ | ASCALE | +---------------+ | TSCALE | +---------------+ | INITJD | +---------------+ | INITFR | +---------------+ | INTLEN | +---------------+ | RSIZE | +---------------+ | N | +---------------+A seven-number `directory' at the end of the segment contains the information needed to determine the location of the record and perform an evaluation of the record corresponding to a particular epoch.
polynomial degree = ( RSIZE/3 - 2 )Define the angles as:
angle * ASCALE = ( RA + pi/2 ) 1 angle * ASCALE = ( pi/2 - DEC ) 2 angle * ASCALE = ( W ) 3The structure of each record:
--------------------------------------------------------------- | (polynomial degree + 1) coefficients for the rate of | | angle 1 | --------------------------------------------------------------- | value of angle 1 at interval midpoint | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for the rate of | | angle 2 | --------------------------------------------------------------- | value of angle 2 at interval midpoint | --------------------------------------------------------------- | (polynomial degree + 1) coefficients for the rate of | | angle 3 | --------------------------------------------------------------- | value of angle 3 at interval midpoint | ---------------------------------------------------------------The rate coefficients have units of ASCALE radians/TSCALE seconds: multiplying a Chebyshev expansion's value by ASCALE/TSCALE converts angular rates to units of radians/s. Euler angles at a record's midpoint epoch are given in units of ASCALE radians: multiplying the angles by ASCALE converts the angles to units of radians. The Euler angles represent the orientation of the PCK reference frame relative to its base frame. The angles, which are numbered according to their ordinal position in the logical records, define a transformation matrix R as follows:
R = [ angle *A ] [ angle *A ] [ angle *A ] 3 3 2 1 1 3where A is the angular scale ASCALE. Here the notation
[ THETA ] idenotes a reference frame rotation of THETA radians in the right-hand sense about the ith coordinate axis. See the Rotation Required Reading for further discussion of this notation. Creating Binary PCKs
Only very knowledgeable users who need to incorporate new planetary/satellite orientation information in binary format should consider writing binary PCK files. Users who write binary PCK files must have a thorough understanding of the information they wish to place in a binary PCK file. They must also master the high level structure of the PCK files, and they must be sure to correctly package the data for the PCK writing subroutines provided in Mice. We also strongly recommend that the writer of a PCK file include descriptive comments in the comment area. The creation of binary form kernels is expected to occur using a Fortran or C based program rather than programmatically. If a user needs a custom routine for binary kernel creation, the SPICELIB and CSPICE Toolkits contain all needed APIs. The Mice Toolkit is based on CSPICE and so includes all CSPICE APIs. Also note most binary PCK APIs in C lack CSPICE wrappers and so C based code will need to call to f2c'd version of the corresponding SPICELIB routines.
PCK Software
Getting PCK Data into Your Program
It is also wise to avoid designing data processing systems that effectively place PCK loading in a tight loop by requiring repeated runs of programs that expend a significant fraction of their run time on loading PCK files. If a program loads PCK files, it is preferable that it do all of its processing in a single run, or at least in a small number of runs, rather than carry out its processing by being re-run a large number of times: the former design will greatly reduce the ratio of the time the program spends loading PCKs to the time it spends on the rest of its data processing. Loading Text PCK Kernels
cspice_furnsh( 'example_pck.tcp' )File names supplied to cspice_furnsh will generally be system-dependent. It is good programming practice to not use hard-coded file names in calls to cspice_furnsh. Instead, applications should obtain kernel file names by one of the following methods:
Each time a text PCK is loaded, the assignments made in the file are maintained in the PCK software. In particular, if a kernel variable occurs in multiple PCKs loaded in a single run of a program, the value of the variable will be the one assigned in the following priority: last binary PCK file loaded, previously loaded binary PCK files, then last loaded text PCK files followed by previously loaded text PCK files. All binary PCK files take precedence over text PCK files. Within the binary and/or text file groups, the last loaded files takes precedence. Loading Binary PCK Kernels
cspice_furnsh( 'example_binary_pck.tcp' )Once an PCK file has been loaded, it may be accessed by the PCK software. Each set of constants is computed from a distinct segment. A PCK file may contain any number of segments. In fact, the same file may contain overlapping segments: segments containing data for the same body over a common interval. When this happens, the latest segment in a file supersedes any competing segments earlier in the file. Similarly, the latest file loaded supersedes any earlier files. In effect, several loaded files become equivalent to one large file. Binary PCK files take precedence over text PCK files. Unloading Binary PCK Kernels
cspice_unload( 'example_binary_pck.tcp' ) Access Routines
All of the routines listed here make use of the orientation models discussed in the section titled ``Orientation Models used by PCK Software.'' Note that in order to use these routines, an application must first load a PCK file (or files) containing sufficient data to define all of the required orientation models. If needed data has not been loaded, these routines will signal run-time errors when called. High-Level PCK Data Access
rotate = cspice_pxform( from, to, et )In the argument list for cspice_pxform:
rotate = [ W ] [ Pi/2 - DEC ] [ Pi/2 + RA ] 3 1 3 Mice provides a routine analogous to cspice_pxform that returns the matrix to transform state vectors between reference frames for a particular time. This routine is called cspice_sxform; the calling sequence being
rotate = cspice_sxform( from, to, et )The input arguments ``from'', ``to'', and ``et'' have the same meanings as in the argument list of cspice_pxform. The output argument ``rotate'' is the 6x6 matrix required to transform state vectors from inertial to body-fixed coordinates. Left multiplication of a state vector by ``rotate'' will transform it from the frame specified by ``from'' to the frame specified by ``to'' at time ``et''. Low-Level PCK Data Access
The lowest-level Mice PCK access routines are cspice_gipool, cspice_gdpool and cspice_gcpool. These are general-purpose routines for retrieving any text kernel data by data type (integer, double precision, and character string, respectively) loaded via cspice_furnsh. The calling sequences for the routines:
[values, found] = cspice_gcpool( name, start, room ) [values, found] = cspice_gdpool( name, start, room ) [values, found] = cspice_gipool( name, start, room ) [string, found] = cspice_stpool( item, nth, contin )The meanings of the arguments are follows:
In text PCKs produced by NAIF, PCK variables will have names conforming to the naming convention used in Mice, that is, the kernel variable names have the form
BODYnnn_<item name>cspice_bodvrd and cspice_bodvcd retrieve the values of such variables from the kernel pool; cspice_bodvrd accepts as inputs the body name and a string making up the portion of the item's name following the prefix:
values = cspice_bodvrd( bodynm, item, maxn)cspice_bodvcd functions in the same manner as cspice_bodvrd except cspice_bodvcd accepts as inputs the body NAIF ID and the string, ``item'', as described for cspice_bodvrd:
values = cspice_bodvcd( bodyid, item, maxn) Summary of Calling Sequences
cspice_furnsh( filename )Unloading text or binary PCKs:
cspice_unload( filename ) Obtaining values for assigned variables from the text kernel pool:
values = cspice_bodvrd( bodynm, item, maxn) values = cspice_bodvcd( bodyid, item, maxn) [values, found] = cspice_gcpool( name, start, room ) [values, found] = cspice_gdpool( name, start, room ) [values, found] = cspice_gipool( name, start, room ) Obtaining position transformation matrices between reference frames:
rotate = cspice_pxform( from, to, et ) Obtaining state transformation matrices between reference frames:
rotate = cspice_sxform( from, to, et ) Appendix A --- Summary of PCK Routines
cspice_bodvcd ( Return d.p. values from the kernel pool ) cspice_bodvrd ( Return d.p. values from the kernel pool ) cspice_furnsh ( Furnish the environment with SPICE kernels ) cspice_gcpool ( Get character data from the kernel pool ) cspice_gdpool ( Get d.p. values from the kernel pool ) cspice_gipool ( Get integers from the kernel pool ) cspice_pxform ( Position Transformation Matrix ) cspice_sxform ( State Transformation Matrix ) cspice_unload ( Unload a kernel ) Appendix B --- Epoch and Frame Specifications in Text PCK Kernels
The default constants and frame for a body are overridden by setting the values of the kernel variables
BODY<id code>_CONSTANTS_REF_FRAMEand
BODY<id code>_CONSTANTS_JED_EPOCHHere
<id code>is:
BODY<id code>_CONSTANTS_REF_FRAMEare the frames IDs for the inertial reference frames coded into the Frames subsystem. Refer to the Frames Required Reading document, frames.req, for a list of the inertial reference frames and the corresponding frame IDs. For example, to use constants referenced to the FK4 frame (frame ID 3) for the asteroid Gaspra (ID code = 9511010), the PCK file containing the constants should include the assignment
BODY9511010_CONSTANTS_REF_FRAME = ( 3 )The values of the epoch specifier variable
BODY<id code>_CONSTANTS_JED_EPOCHare Julian ephemeris dates. To use constants for Gaspra referenced to the J1950 epoch, the PCK file containing the constants should include the assignment
BODY9511010_CONSTANTS_JED_EPOCH = ( 2433282.5 )The creator of a PCK file can set the frame and epoch of the constants on a body-by-body basis, except in the case of planets and their (natural) satellites, where a single choice of frame and epoch must be used for each planetary system. For example, to use constants referenced to the B1950 frame (frame ID 2) and J1950 epoch for the Earth and Moon, use the assignments
BODY3_CONSTANTS_REF_FRAME = ( 2 ) BODY3_CONSTANTS_JED_EPOCH = ( 2433282.5 )The ID code `3' designates the Earth-Moon barycenter. Note: the assignment
BODY399_CONSTANTS_REF_FRAME = ( 2 ) BODY399_CONSTANTS_JED_EPOCH = ( 2433282.5 )would be ignored by the PCK reader routines; you cannot assign a frame or epoch using the ID code of a planet or satellite. Appendix C --- Revision History2013 JAN 22 by E. D. Wright, C. H. Acton
Eliminated Examples section. Corrections to text eliminating typos in the code call examples. Update to document structure to include Revision History. The document now includes description of Icy, and Mice PCK APIs. 2010 JUN 03 by B. V. Semenov.
Original version K.R. Gehringer, K. S. Zukor
|


jQuery Invaders
Change grid size:
Min-Size: 5 cells
Max-Size: 150 cells
x
Change speed:
Very Slow
Slow
Normal
Fast
UltraFast
Walls:
Active
Add Enemies:
Controls:
Options


WooChain is a decentralized, transparent all-in-one platform based on the Ethereum blockchain which helps simplify the blockchain process. The platform is comprised of many components: a digital exchange for WooChain coins, analytics dashboard, record posting for timestamped documents such as: Financial Instruments, Records and Models, Public Records, Private Records, Physical Asset Keys, Intangibles, and more. We plan to implement reward systems to incentive every user.
Users will transact in $Woo to send data and money and the click of a button.
Professionals and Corporations will use $Woo to host, analyze, and share data within the economy. When users choose to send data/money within the WooChain ecosystem, they will be able to keep track of their records on our easy to use platform. Imagine an easy to use platform where you one can keep track of a currency, mortgage record, crowdfund, certificate, permit, escrow, physical key, coupon, trademark, online identity, etc. WooChain is the internets first smart data system, Woo!
Developers are able to utilze WooChain Developer section enabling APIs, shared ledgers, and even their own applications.


Class jala.Test.SmtpServer
Object
|
+--jala.Test.SmtpServer
- class
jala.Test.SmtpServer
Instances of this class represent an SMTP server listening on
localhost. By default jala.Test will create a global variable called
"smtpServer" that contains an instance of this class. To use the server call
start() in a test method (eg. in the basic setup method) and
stop() in the cleanup method.
Defined in Global/jala.Test.js
|
Method Summary |
Array
|
getMessages()
Returns an array containing all mails received by the server,
where each one is an instance of jala.Test.SmtpServer.Message
|
void
|
start()
Starts the SMTP server.
|
void
|
stop()
Stops the SMTP server and switches the "smtp" property of the tested
application back to the value defined in app or server.properties
|
jala.Test.SmtpServer
jala.Test.SmtpServer(<Number> port)
Creates a new SmtpServer instance
Parameters:
port
- Optional port to listen on (defaults to 25)
Returns:
A newly created SmtpServer instance
getMessages
Array getMessages()
Returns:
An array with all messages
start
void start()
Starts the SMTP server. Note that this method switches the SMTP server as
defined in app.properties of the tested application or server.properties
to "localhost" to ensure that all mails sent during tests are received
by this server. The SMTP server definition is switched back to the
original when stop() is called.
stop
void stop()
Stops the SMTP server and switches the "smtp" property of the tested
application back to the value defined in app or server.properties
Documentation generated by
JSDoc on Tue Jan 8 15:50:17 2008


Tic-Tac-Toe
Who are playing?
Player #1
Player #2
It's
's turn. Click a cell to place your mark.
Game Over
has won.
Game Over
It's a draw.


| Home | Libraries | People | FAQ | More |
boost::interprocess::list
// In header: <boost/interprocess/containers/list.hpp> template<typename T, typename A> class list { public: // types typedef T value_type; typedef A::pointer pointer; // Pointer to T. typedef A::const_pointer const_pointer; // Const pointer to T. typedef A::reference reference; // Reference to T. typedef A::const_reference const_reference; // Const reference to T. typedef A::size_type size_type; // An unsigned integral type. typedef A::difference_type difference_type; // A signed integral type. typedef A allocator_type; // The allocator type. typedef NodeAlloc stored_allocator_type; // The stored allocator type. typedef std::reverse_iterator< iterator > reverse_iterator; // Iterator used to iterate backwards through a list. typedef std::reverse_iterator< const_iterator > const_reverse_iterator; // Const iterator used to iterate backwards through a list. // construct/copy/destruct list(const allocator_type & = A()); list(size_type, const T & = T(), const A & = A()); list(const list &); list(list &&); template<typename InpIt> list(InpIt, InpIt, const A & = A()); list& operator=(const ThisType &); list& operator=(ThisType &&); ~list(); // public member functions allocator_type get_allocator() const; const stored_allocator_type & get_stored_allocator() const; stored_allocator_type & get_stored_allocator() ; void clear() ; iterator begin() ; const_iterator begin() const; iterator end() ; const_iterator end() const; reverse_iterator rbegin() ; const_reverse_iterator rbegin() const; reverse_iterator rend() ; const_reverse_iterator rend() const; const_iterator cbegin() const; const_iterator cend() const; const_reverse_iterator crbegin() const; const_reverse_iterator crend() const; bool empty() const; size_type size() const; size_type max_size() const; void push_front(const T &) ; void push_front(T &&) ; void push_back(const T &) ; void push_back(T &&) ; void pop_front() ; void pop_back() ; reference front() ; const_reference front() const; reference back() ; const_reference back() const; void resize(size_type, const T &) ; void resize(size_type) ; void swap(ThisType &&) ; void insert(const_iterator, size_type, const T &) ; template<typename InpIt> void insert(const_iterator, InpIt, InpIt) ; iterator insert(const_iterator, const T &) ; iterator insert(const_iterator, T &&) ; void emplace_back() ; void emplace_front() ; iterator emplace(const_iterator) ; iterator erase(const_iterator) ; iterator erase(const_iterator, const_iterator) ; void assign(size_type, const T &) ; template<typename InpIt> void assign(InpIt, InpIt) ; void splice(iterator, ThisType &&) ; void splice(const_iterator, ThisType &&, const_iterator) ; void splice(const_iterator, ThisType &&, const_iterator, const_iterator) ; void splice(const_iterator, ThisType &&, const_iterator, const_iterator, size_type) ; void reverse() ; void remove(const T &) ; template<typename Pred> void remove_if(Pred) ; void unique() ; template<typename BinaryPredicate> void unique(BinaryPredicate) ; void merge(list< T, A > &&) ; template<typename StrictWeakOrdering> void merge(list< T, A > &&, StrictWeakOrdering) ; void sort() ; template<typename StrictWeakOrdering> void sort(StrictWeakOrdering) ; };
A list is a doubly linked list. That is, it is a Sequence that supports both forward and backward traversal, and (amortized) constant time insertion and removal of elements at the beginning or the end, or in the middle. Lists have the important property that insertion and splicing do not invalidate iterators to list elements, and that even removal invalidates only the iterators that point to the elements that are removed. The ordering of iterators may be changed (that is, list<T>::iterator might have a different predecessor or successor after a list operation than it did before), but the iterators themselves will not be invalidated or made to point to different elements unless that invalidation or mutation is explicit.
list
public
construct/copy/destructlist(const allocator_type & a = A());
Effects: Constructs a list taking the allocator as parameter.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant.
list(size_type n, const T & value = T(), const A & a = A());
Effects: Constructs a list that will use a copy of allocator a and inserts n copies of value.
Throws: If allocator_type's default constructor or copy constructor throws or T's default or copy constructor throws.
Complexity: Linear to n.
list(const list & x);
Effects: Copy constructs a list.
Postcondition: x == *this.
Throws: If allocator_type's default constructor or copy constructor throws.
Complexity: Linear to the elements x contains.
list(list && x);
Effects: Move constructor. Moves mx's resources to *this.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant.
template<typename InpIt> list(InpIt first, InpIt last, const A & a = A());
Effects: Constructs a list that will use a copy of allocator a and inserts a copy of the range [first, last) in the list.
Throws: If allocator_type's default constructor or copy constructor throws or T's constructor taking an dereferenced InIt throws.
Complexity: Linear to the range [first, last).
list& operator=(const ThisType & x);
Effects: Makes *this contain the same elements as x.
Postcondition: this->size() == x.size(). *this contains a copy of each of x's elements.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to the number of elements in x.
list& operator=(ThisType && mx);
Effects: Move assignment. All mx's values are transferred to *this.
Postcondition: x.empty(). *this contains a the elements x had before the function.
Throws: If allocator_type's copy constructor throws.
Complexity: Constant.
~list();
Effects: Destroys the list. All stored values are destroyed and used memory is deallocated.
Throws: Nothing.
Complexity: Linear to the number of elements.
list
public member functionsallocator_type get_allocator() const;
Effects: Returns a copy of the internal allocator.
Throws: If allocator's copy constructor throws.
Complexity: Constant.
const stored_allocator_type & get_stored_allocator() const;
stored_allocator_type & get_stored_allocator() ;
void clear() ;
Effects: Erases all the elements of the list.
Throws: Nothing.
Complexity: Linear to the number of elements in the list.
iterator begin() ;
Effects: Returns an iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
const_iterator begin() const;
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
iterator end() ;
Effects: Returns an iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
const_iterator end() const;
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
reverse_iterator rbegin() ;
Effects: Returns a reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant.
const_reverse_iterator rbegin() const;
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant.
reverse_iterator rend() ;
Effects: Returns a reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant.
const_reverse_iterator rend() const;
Effects: Returns a const_reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant.
const_iterator cbegin() const;
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
const_iterator cend() const;
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
const_reverse_iterator crbegin() const;
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed list.
Throws: Nothing.
Complexity: Constant.
const_reverse_iterator crend() const;
Effects: Returns a const_reverse_iterator pointing to the end of the reversed list.
Throws: Nothing.
Complexity: Constant.
bool empty() const;
Effects: Returns true if the list contains no elements.
Throws: Nothing.
Complexity: Constant.
size_type size() const;
Effects: Returns the number of the elements contained in the list.
Throws: Nothing.
Complexity: Constant.
size_type max_size() const;
Effects: Returns the largest possible size of the list.
Throws: Nothing.
Complexity: Constant.
void push_front(const T & x) ;
Effects: Inserts a copy of t in the beginning of the list.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Amortized constant time.
void push_front(T && x) ;
Effects: Constructs a new element in the beginning of the list and moves the resources of t to this new element.
Throws: If memory allocation throws.
Complexity: Amortized constant time.
void push_back(const T & x) ;
Effects: Removes the last element from the list.
Throws: Nothing.
Complexity: Amortized constant time.
void push_back(T && x) ;
Effects: Removes the first element from the list.
Throws: Nothing.
Complexity: Amortized constant time.
void pop_front() ;
Effects: Removes the first element from the list.
Throws: Nothing.
Complexity: Amortized constant time.
void pop_back() ;
Effects: Removes the last element from the list.
Throws: Nothing.
Complexity: Amortized constant time.
reference front() ;
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant.
const_reference front() const;
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant.
reference back() ;
Requires: !empty()
Effects: Returns a reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant.
const_reference back() const;
Requires: !empty()
Effects: Returns a const reference to the first element from the beginning of the container.
Throws: Nothing.
Complexity: Constant.
void resize(size_type new_size, const T & x) ;
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size.
void resize(size_type new_size) ;
Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default constructed.
Throws: If memory allocation throws, or T's copy constructor throws.
Complexity: Linear to the difference between size() and new_size.
void swap(ThisType && x) ;
Effects: Swaps the contents of *this and x. If this->allocator_type() != x.allocator_type() allocators are also swapped.
Throws: Nothing.
Complexity: Constant.
void insert(const_iterator p, size_type n, const T & x) ;
Requires: p must be a valid iterator of *this.
Effects: Inserts n copies of x before p.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n.
template<typename InpIt> void insert(const_iterator p, InpIt first, InpIt last) ;
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of the [first, last) range before p.
Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws.
Complexity: Linear to std::distance [first, last).
iterator insert(const_iterator p, const T & x) ;
Requires: p must be a valid iterator of *this.
Effects: Insert a copy of x before p.
Throws: If memory allocation throws or x's copy constructor throws.
Complexity: Amortized constant time.
iterator insert(const_iterator p, T && x) ;
Requires: p must be a valid iterator of *this.
Effects: Insert a new element before p with mx's resources.
Throws: If memory allocation throws.
Complexity: Amortized constant time.
void emplace_back() ;
void emplace_front() ;
iterator emplace(const_iterator p) ;
iterator erase(const_iterator p) ;
Requires: p must be a valid iterator of *this.
Effects: Erases the element at p p.
Throws: Nothing.
Complexity: Amortized constant time.
iterator erase(const_iterator first, const_iterator last) ;
Requires: first and last must be valid iterator to elements in *this.
Effects: Erases the elements pointed by [first, last).
Throws: Nothing.
Complexity: Linear to the distance between first and last.
void assign(size_type n, const T & val) ;
Effects: Assigns the n copies of val to *this.
Throws: If memory allocation throws or T's copy constructor throws.
Complexity: Linear to n.
template<typename InpIt> void assign(InpIt first, InpIt last) ;
Effects: Assigns the the range [first, last) to *this.
Throws: If memory allocation throws or T's constructor from dereferencing InpIt throws.
Complexity: Linear to n.
void splice(iterator p, ThisType && x) ;
Requires: p must point to an element contained by the list. x != *this
Effects: Transfers all the elements of list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
Complexity: Constant.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
void splice(const_iterator p, ThisType && x, const_iterator i) ;
Requires: p must point to an element contained by this list. i must point to an element contained in list x.
Effects: Transfers the value pointed by i, from list x to this list, before the the element pointed by p. No destructors or copy constructors are called. If p == i or p == ++i, this function is a null operation.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
Complexity: Constant.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
void splice(const_iterator p, ThisType && x, const_iterator first, const_iterator last) ;
Requires: p must point to an element contained by this list. first and last must point to elements contained in list x.
Effects: Transfers the range pointed by first and last from list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
Complexity: Linear to the number of elements transferred.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
void splice(const_iterator p, ThisType && x, const_iterator first, const_iterator last, size_type n) ;
Requires: p must point to an element contained by this list. first and last must point to elements contained in list x. n == std::distance(first, last)
Effects: Transfers the range pointed by first and last from list x to this list, before the the element pointed by p. No destructors or copy constructors are called.
Throws: std::runtime_error if this' allocator and x's allocator are not equal.
Complexity: Constant.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
void reverse() ;
Effects: Reverses the order of elements in the list.
Throws: Nothing.
Complexity: This function is linear time.
Note: Iterators and references are not invalidated
void remove(const T & value) ;
Effects: Removes all the elements that compare equal to value.
Throws: Nothing.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
template<typename Pred> void remove_if(Pred pred) ;
Effects: Removes all the elements for which a specified predicate is satisfied.
Throws: If pred throws.
Complexity: Linear time. It performs exactly size() calls to the predicate.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
void unique() ;
Effects: Removes adjacent duplicate elements or adjacent elements that are equal from the list.
Throws: Nothing.
Complexity: Linear time (size()-1 comparisons calls to pred()).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
template<typename BinaryPredicate> void unique(BinaryPredicate binary_pred) ;
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list.
Throws: If pred throws.
Complexity: Linear time (size()-1 comparisons equality comparisons).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
void merge(list< T, A > && x) ;
Requires: The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this according to std::less<value_type>. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
Complexity: This function is linear time: it performs at most size() + x.size() - 1 comparisons.
template<typename StrictWeakOrdering> void merge(list< T, A > && x, StrictWeakOrdering comp) ;
Requires: p must be a comparison function that induces a strict weak ordering and both *this and x must be sorted according to that ordering The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: Nothing.
Complexity: This function is linear time: it performs at most size() + x.size() - 1 comparisons.
Note: Iterators and references to *this are not invalidated.
void sort() ;
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.
Complexity: The number of comparisons is approximately N log N, where N is the list's size.
template<typename StrictWeakOrdering> void sort(StrictWeakOrdering comp) ;
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: Nothing.
Notes: Iterators and references are not invalidated.
Complexity: The number of comparisons is approximately N log N, where N is the list's size.


Links to public releases of softwares developed by Urban Meteorology Group at University of Reading.
Please report issues here
Software
Data
Publications
- LUMPS
- Offerle B (2003) The energy balance of an urban area: Examining temporal and spatial variability through measurements – remote sensing and modeling. PhD thesis Indiana University
- LUMPS – NARP – OHM.
- Xu W Wooster MJ & Grimmond CSB (2008). Modelling of urban sensible heat flux at multiple spatial scales: A demonstration using hyperspectral imagery of Shanghai and a temperature-emissivity separation approach. Remote Sensing of Environment 112 3493-3510
- LUCY
- Allen L - F Lindberg CSB Grimmond (2011) Global to city scale model for anthropogenic heat flux International Journal of Climatology 31 1990-2005
- Lindberg F Grimmond CSB Nithiandamdan Y Kotthaus S Allen L (2013) Impact of city changes and weather on anthropogenic heat flux in Europe 1995–2015 Urban Climate
- GreaterQF
- SVF
- Lindberg F, CSB Grimmond 2010: Continuous sky view factor from high resolution urban digital elevation models [Climate Research 42: 177-183 doi:10.3354/cr00882]


Evolution of life cycles of homogeneous groups
From a solitary cell to a colony
The first organisms were unicellular. Whenever such a cell divided, its offspring ventured to live independently on each other. Multicellular life cycles emerged when daughter cells did not part their ways but remained together, forming a group. Much later, these organisms gave rise to the fascinating complexity of animals, plants, fungi, brown algae, and many other multicellular species. But what were the very first steps in the evolution of multicellularity?
In the absence of complex adaptations, the difference between unicellular and multicellular existence comes from the raw size of the cell colony. The larger size can bring benefits to the organism in a form of better protection or access to additional resources. However, evolutionary success requires the production of the offspring, which means that the colony must fragment into smaller pieces in order to multiply. Due to the smaller size, the offspring may not gain as many benefits as the parent group had.
Considering arbitrary benefits and costs of the colony size, what is the evolutionarily optimal fragmentation mode? Is it deterministic or stochastic? At which size the fragmentation should occur? Is it even beneficial to become multicellular at all? How many offspring should be produced, and should they be equal in size or diverse?
Papers:
Core model. What is the optimal fragmentation mode if the colony growth and death are determined by its size: Fragmentation modes and the evolution of life cycles. Pichugin, Y., Peña, J., Rainey, P.B., and Traulsen, A. PLoS Computational Biology, 2017. (link)
What if benefits and costs of colony size change with time: Evolution of simple multicellular life cycles in dynamic environments. Pichugin, Y., Park, H.J., and Traulsen, A., Journal of the Royal Society Interface, 2019 (link)
What if fragmentation cannot be performed for free: Evolution of multicellular life cycles under costly fragmentation. Pichugin, Y., and Traulsen, A., PLOS Computational Biology, 2020 (link)
What if the organism mass changes continuously - this extends the applicability of the model beyond just multicellularity: The possible modes of microbial reproduction are fundamentally restricted by distribution of mass between parent and offspring. Pichugin, Y., and Traulsen, A., Proceedings of the National Academy of Sciences, 2022 (link)
What if colonies compete with each other: Eco-evolutionary dynamics of clonal multicellular life cycles. Ress, V., Traulsen, A., and Pichugin, Y., eLife, 2022 (link)


Phenote is a general-purpose open source platform-independent application to facilitate data annotation using ontologies.
Originally developed as a literature curation tool for biomedical phenotype annotation, Phenote can be customized to suit any user-specified domain requiring ontology-based annotation. The all-in-one interface allows users to quickly search and view corresponding metadata for relevant ontology terms during data entry, browse through the ontology in a navigation window, and view the data annotations in a spreadsheet-like window. Data recorded with Phenote can be ported to any external application or database using one of its built-in data adapters, or by plugging in a custom data adapter generated with the API.
Phenote is a project of the Berkeley Bioinformatics Open-Source Projects (BBOP).


'Fantasy Grounds' is a trademark of SmiteWorks USA, LLC. 'Fantasy Grounds' is Copyright 2004-2014 SmiteWorks USA LLC.
The 3.5E6 ruleset and all included files are copyright 2004-2020, Smiteworks USA LLC.
Any copyright or licensing of data modules distributed by Smiteworks for use with this ruleset are addressed within the data modules themselves.


Russia to deliver S-400 missiles to India as planned: Putin
by ReutersBRASILIA: Russia plans to deliver S-400 surface-to-air missile systems to India on schedule, President Vladimir Putin said on Thursday.
India agreed to buy the S-400 system from Russia last year despite US warnings the purchase could trigger sanctions against it.
India said it needed the weapons to bolster its defences against China.
“As far as the S-400 deliveries are concerned, everything is
going according to plan. Our Indian colleagues have not asked to
speed anything up, it’s all going fine,” Putin told reporters at
a summit of BRICS countries in Brazil.


I'm an iOS developer and designer who loves to learn about new mobile and web technologies. I combine my Computer Science studies in Neural Networks and Probabilistic graphical models with developing iOS apps at Apple Developer Academy - Brazil.
I develop iOS, Watch OS and TV OS applications, in both Objective-C and Swift languages. At BEPiD all projects are developed using Agile methods, like SCRUM.
Using as main tools Adobe Photoshop and Illustrator, worked developing logos and visual identity of companies. Creating also arts for banners, plaques, cards and leaflets.
My preferred fields of study are: Machine Learning with Neural Networks (Supervised and Unsupervised Learning) and Natural Language using Probabilistic Graphical Models.
The purpose of Loop and Loop Assistant is to develop an up-to-date way of communication in the academic environment. Manage exchange of messages in the academic community: Students, Teachers and Institution. Manage student groups, which can be grouped by ongoing courses or by some other criteria defined by users. Groups study materials such as pdfs, articles and other documents. A virtual assistant, which is called Loop Assist, to facilitate as tasks. Student Presence Control. Smarter Academic Calendar. Notifications and Alerts on campus-less events.
This project was developed for the course of Probabilistic Graphical Models of Federal Institute of Education, Science and Technology of Ceará - IFCE. It uses Hidden Markov Models to classify a sentence in POS Tags in Brazilian Portuguese. In corpus linguistics, part-of-speech tagging (POS tagging or PoS tagging or POST), also called grammatical tagging or word-category disambiguation, is the process of marking up a word in a text (corpus) as corresponding to a particular part of speech, based on both its definition and its context—i.e., its relationship with adjacent and related words in a phrase, sentence, or paragraph. A simplified form of this is commonly taught to school-age children, in the identification of words as nouns, verbs, adjectives, adverbs, etc.
View ProjectThis project was developed for the course of Probabilistic Graphical Models of Federal Institute of Education, Science and Technology of Ceará - IFCE. It uses Hidden Markov Models to classify a sentence in POS Tags in Brazilian Portuguese. In corpus linguistics, part-of-speech tagging (POS tagging or PoS tagging or POST), also called grammatical tagging or word-category disambiguation, is the process of marking up a word in a text (corpus) as corresponding to a particular part of speech, based on both its definition and its context—i.e., its relationship with adjacent and related words in a phrase, sentence, or paragraph. A simplified form of this is commonly taught to school-age children, in the identification of words as nouns, verbs, adjectives, adverbs, etc.
View ProjectWith ML Filters you can mix your photos with the most famous paintings in the world, returning to you fabulous and colorful filtered images in realtime on custom photos.
View on App StoreActSports aims to facilitate the meeting of people interested in the same sports allowing them to exercise together. In addition, the app will also serve as a showcase for instructors of all types of sports to publicize their work and thus get more customers.
Visit Home PageWe want to introduce you in the Ludo Stadium world! Here we have two game modes: - Normal Ludo mode - Ludo Adventure mode Both modes are really exciting and fun to play with friends with a 3D experience! For those who loves nostalgic feelings, we recommend you our original version of Ludo game. But, if you prefer something more sophisticated and challenging, you should try the Ludo Adventure mode where you will face some fun obstacles to reach your objective!
View on App StoreThe Daily Memories is a kind of diary, where you save your records safely.  You can also keep everything secure using the Touch ID or a password, and you can be reminded to daily produce your memories.
View on App StoreIt's a game to help children to know more about notes and songs. In addition kids develop logical reasoning. The parents can see their children evolution. Earn points and envolve with your buddy!
View ProjectControl your exercises, body measures and progress. BestFit will help you to organize your training and keep you updated about all your body information. It perfectly integrates with HealthKit and can be easily edited for you.
View on App StoreThis is an app to help people saving money. We tried to do a simple app, easy and with fast use. The user can add their expense with one click and choose complete three things in forms: the name,the price and the category. The rest, he can edit after, if want. The same thing occur with goals: choose the category, the value that want to expend with things in this category and the time period that he want expend this value. The expenses that put in the first screen go immediately to the second, if this expense have the same category and time period that their goal. The last thing is: The user can organize the expenses that way their want.
View on App Store


https://www.maketecheasier.com/create-self-extracting-archives-without-installing-software/
https://ubuntuforums.org/showthread.php?t=847329


| Class | Description |
|---|---|
| Abs |
Abs elementwise function
|
| ACos |
Log elementwise function
|
| ACosh |
ACosh elementwise function
|
| And |
Boolean AND pairwise transform
|
| ASin |
Arcsin elementwise function
|
| ASinh |
Arcsin elementwise function
|
| Assign |
Assign op: x = y, with broadcast as required
|
| ATan |
Arc Tangent elementwise function
|
| ATan2 |
Arc Tangent elementwise function
|
| ATanh |
tan elementwise function
|
| BaseDynamicTransformOp | |
| BatchToSpace |
N-dimensional batch to space operation.
|
| BinaryMinimalRelativeError | |
| BinaryRelativeError | |
| Ceil |
Ceiling elementwise function
|
| Constant | |
| Cos |
Cosine elementwise function
|
| Cosh |
Cosine Hyperbolic elementwise function
|
| Cube |
Cube (x^3) elementwise function
|
| Dilation2D |
Dilation2D op wrapper
|
| DynamicPartition |
Transforms a given input tensor into numPartitions partitions, as indicated by the indices in "partitions".
|
| DynamicStitch |
Transforms a given input tensor into numPartitions partitions, as indicated by the indices in "partitions".
|
| ELU |
ELU: Exponential Linear Unit (alpha=1.0)
Introduced in paper: Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs) Djork-Arné Clevert, Thomas Unterthiner, Sepp Hochreiter (2015) http://arxiv.org/abs/1511.07289 |
| Erf |
Gaussian error function (erf) function, which is defined as
|
| Erfc |
Complementary Gaussian error function (erfc), defined as
|
| Exp |
Element-wise exponential function
|
| Expm1 |
Element-wise exponential function minus 1, i.e.
|
| Fill |
Fill an array of given "shape" with the provided "value", e.g.
|
| Floor |
Floor elementwise function
|
| HardSigmoid |
HardSigmoid function
|
| HardTanh |
Hard tanh elementwise function
|
| Histogram | |
| Identity |
Identity function
|
| InvertPermutation |
Inverse of index permutation.
|
| IsFinite |
IsFinite function
|
| IsInf |
IsInf function
|
| IsMax |
[1, 2, 3, 1] -> [0, 0, 1, 0]
|
| IsNaN |
IsNaN function
|
| LeakyReLU |
Leaky Rectified linear unit.
|
| LegacyDropOut |
DropOut implementation as Op
PLEASE NOTE: This is legacy DropOut implementation, please consider using op with the same opName from randomOps
|
| LegacyDropOutInverted |
Inverted DropOut implementation as Op
PLEASE NOTE: This is legacy DropOutInverted implementation, please consider using op with the same opName from randomOps
|
| Log |
Log elementwise function
|
| Log1p |
Log1p function
|
| LogSigmoid |
LogSigmoid function
|
| LogSigmoidDerivative |
LogSigmoid derivative
|
| LogSoftMax |
Log(softmax(X))
|
| LogX |
Log on arbitrary base op
|
| MatchConditionTransform |
Absolute sum the components
|
| MatrixDeterminant |
Matrix Determinant op
Given input with shape [..., N, N] output the determinant for each sub-matrix.
|
| MatrixDiag | |
| MatrixDiagPart | |
| MatrixInverse |
Matrix Inverse Function
|
| MatrixSetDiag | |
| MaxOut |
Max out activation:
http://arxiv.org/pdf/1302.4389.pdf
|
| MirrorPad | |
| Negative |
Negative function
|
| Not |
Boolean AND pairwise transform
|
| OldAtan2Op |
atan2 operation
|
| OldIdentity |
Identity function
|
| OldReverse |
OldReverse op
|
| OldSoftMax |
Soft max function
row_maxes is a row vector (max for each row)
row_maxes = rowmaxes(input)
diff = exp(input - max) / diff.rowSums()
Outputs a probability distribution.
|
| OneMinus |
1 - input
|
| Or |
Boolean OR pairwise transform
|
| ParallelConcat | |
| Pow |
Pow function
|
| PowDerivative |
Pow derivative
z = n * x ^ (n-1)
|
| RationalTanh |
Rational Tanh Approximation elementwise function, as described at https://github.com/deeplearning4j/libnd4j/issues/351
|
| Reciprocal |
Created by susaneraly on 3/28/18.
|
| RectifedLinear |
Rectified linear units
|
| RectifiedTanh |
RectifiedTanh
Essentially max(0, tanh(x))
|
| RelativeError | |
| Relu6 |
Rectified linear unit 6, i.e.
|
| ReluLayer |
Composed op: relu((X, W) + b)
|
| ReplaceNans |
Element-wise "Replace NaN" implementation as Op
|
| Reverse | |
| ReverseSequence |
Created by farizrahman4u on 3/16/18.
|
| ReverseV2 |
This is compatibility op for ReverseV2
|
| Rint |
Rint function
|
| Round |
Rounding function
|
| RSqrt |
RSqrt function
|
| SELU |
SELU activation function
|
| Set |
Set
|
| SetRange |
Set range to a particular set of values
|
| Sigmoid |
Sigmoid function
|
| SigmoidDerivative |
Sigmoid derivative
|
| Sign |
Signum function
|
| Sin |
Log elementwise function
|
| Sinh |
Sinh function
|
| SoftMax |
Soft max function
row_maxes is a row vector (max for each row)
row_maxes = rowmaxes(input)
diff = exp(input - max) / diff.rowSums()
Outputs a probability distribution.
|
| SoftMaxDerivative |
Softmax derivative
|
| SoftPlus | |
| SoftSign |
Softsign element-wise activation function.
|
| SpaceToBatch |
N-dimensional space to batch operation.
|
| Sqrt |
Sqrt function
|
| Square |
Square function (x ^ 2)
|
| Stabilize |
Stabilization function, forces values to be within a range
|
| Step |
Unit step function.
|
| Swish |
Swish function
|
| SwishDerivative |
Swish derivative
|
| Tan |
Tanh elementwise function
|
| TanDerivative |
Tan Derivative elementwise function
|
| Tanh |
Tanh elementwise function
|
| TanhDerivative |
Tanh derivative
|
| TimesOneMinus |
If x is input: output is x*(1-x)
|
| Trace |
Matrix trace operation
|
| Xor |
Boolean XOR pairwise transform
|
| XwPlusB |
Composed op: mmul (X, W) + b
|


Leeds Creative Labs: Bragg Edition Residency
Paired with concrete scientists, we explored concrete as a sonic material through a variety of experiments.
Paired with concrete scientists, we explored concrete as a sonic material through a variety of experiments.
A workshop for Site Gallery’s Society of Explorers exploring making musical instruments from DIY contact microphones and domestic objects.
In-house audio reports from the amateur avant-garde.
Short video pieces and soundtracking for Sheffield’s weirdest experimental music/sound/art TV show
10 week UNIT(e) Residency at g39 in Cardiff.
A Triangle Network Fellowship at Britto Arts Trust in Dhaka, Bangladesh in 2015
Workshop conducted as part of the Rammel Club/Reactor Halls E14: Cables event.
A 4 hour durational installation and performance hybrid
Nights of visionary global music in Nottingham, UK.
One off 12” vinyl commission for Mat Jenner’s FOAM project.
Sound installation and score drawing upon the alternative tuning systems of La Monte Young and the musical legacy of Sunny Murray.
An ongoing archive of staged realities and material flows leaking into the world, inviting you to listen with the ‘ear of the imagination’.
I was invited to run a workshop as part of PS2N’s Optophonic Workshop.
Based upon David Tudor’s Rainforest IV (1973) and realised as a collaborative electronics workshop and performance.
A realisation of the score ‘Do You Want To Expand Your Parameters Or Play Museums Like Some Dilettante’ is played back using vibrations to activate the windo...
Composed in response to Marvin Gaye Chetwynd’s exhibition at Nottingham Contemporary as part of their ‘Memory’ project and permanent collection.
In March 2014 I visited Nepal with my wife. I was there to run a workshop where we would turn objects in speakers allowing us to intervene locally with sound...
A 2 day workshop ran in the Katwe slums of Nsambya in Kampala, Uganda during December 2013.
Between the 25th and the 30th of September 2013, in groups and alone, we walked sections of the River Trent and Nottingham Canal. It was as if she knew we we...
Cardiff based DIY gig collective - bringing fringe highlights and dirt-rare performances to Cardiff between 2010 and 2012. And then Nottingham in 2013.
Audio installation activating listeners through dynamically modulating sound in space.
An exercise in fictional archives and mediated histories - focussing upon little-known, 1970s, German noise band, Lustfaust.


About upcoming limits on trusted certificates In our ongoing efforts to improve web security for our users, Apple is reducing the maximum allowed lifetimes of TLS server certificates.
Model Builder Updates for ML.NET this February | .NET Blog Train image classification models in Azure, recommendation models locally in the Model Builder, and create custom machine learning models!
Getting started with Contoso Crafts Contoso Crafts is a sample application that was created to help how the fundamental concepts behind creating a application with ASP.NET. In this episode, Brady Gaster sits with Christos to discuss the motivations behind the project. If you're hosting an i...
Minimal March – Part 1: Getting Started with .NET and C# at the Command-line Jeff starts ‘Minimal March’, a streaming a blog series about developing with C# and .NET using only command-line tools. In this post, he talks about his initial configuraiton
The Different Kinds of Exoplanets You Meet in the Milky Way Lava worlds. Hot Jupiters. Earth 2.0 candidates. Here's a rundown of some notable exoplanets.
Getting Started With React Hooks React Hooks is an amazing feature in React that allows you to leverage state and lifecycle methods inside of a functional component. You'll see more and more libraries updated to take advantage of React Hooks, so it's in your best interest to learn about ...
Let's Encrypt certificate issue requiring urgent renewal Stack Exchange's certificates are in need of renewal ASAP due to the Let's Encrypt CAA rechecking bug. They have sent out notification emails to affected users but I'm reporting this here just in c...
Episode 133 – Nick Craver: Stack Overflow to .NET Core | The 6 Figure Developer Nick is the Architecture Lead for Stack Exchange. He designs and builds very fast things in hopes of making life easier for millions of developers. His day to day job keeps him fairly busy,
Revoking certain certificates on March 4 Due to the 2020.02.29 CAA Rechecking Bug, we unfortunately need to revoke many Let’s Encrypt TLS/SSL certificates. We’re e-mailing affected subscribers for whom we have contact information. This post and thread will collect answers to frequently asked qu...
How to set up a tab profile in Windows Terminal to automatically SSH into a Linux box By now I hope you've installed Windows Terminal. If not, go do that, I'll wait. It's time. You may also have customize ...
0.3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 Just for fun on 3/3 - these are leftovers from our Pi Million Subscribers video at: https://youtu.be/__UlMppZZgs See who's who at: https://www.numberphile.com/pi-million NUMBERPHILE Website: http://www.numberphile.com/ Numberphile on Facebook: http://w...
Simple Systems Have Less Downtime The Maersk Triple-E Class container ship is 1,300 feet long, carries over 18,000 containers across 11,000 miles between Europe and Asia, and… Its entire crew can fit inside a passenger van.
Integrating Tailwind CSS with Blazor using Gulp - Part 2 In this post, I go deeping into Tailwind CSS. I'll show you how you can customise its settings, optimise the final CSS payload. Then finish up by showing how you can integrate Tailwind into a CI pipeline using Azure DevOps.
C# 8 default interface methods - Red Hat Developer Explore how C# 8 allows us to extend an interface and provide a default implementation.
Next Stream: Wednesday at 11 AM ET // @_clarkio || @clarkio on socials Twitch is the world's leading video platform and community for gamers.
Monsters Weekly 154 - Integration Testing in ASP.NET Core with Alba In this continuation of Episode #152 (https://youtu.be/GBKBCr6SjPs), Dave uses the GitHub Actions release trigger to generate a release version of a NuGet package that links back to the release notes
What's the Difference Between Blazor vs Razor What is Razor? How does it relate to Blazor, and which should you be using? Learn the difference between Blazor and Razor and how to use them in your web apps.
I rebuilt the same web API using Express, Flask, and ASP.NET. Here's what I found. I've been shopping around for a back end framework to support a tabletop game app [https://www.nightpathpub.com/entromancy], and decided to do some research to determine the best fit for my needs. The objective was straightforward: to build a simple RES...
Tip 251 - Working With Azure Functions in VS Code and GitHub Azure Functions is a Serverless component from Microsoft that allows you to create event-based functions that can be dynamically scaled to meet the demand. We can work with all kinds of events such as when a file is uploaded to storage, a message appears ...
svenpetersen1965's Thingiverse Profile I am an engineer in electronic hardware development since 1994. The 3D printing and 3D design came to me in September 2019 and I really enjoy using these tools for my hobbies (or just for fun). My interests are retro computing and electronics. I like to d...
AWS is updating minimum requirements for AWS Tools for PowerShell to Windows PowerShell 3.0 and .NET Framework 4.5 | Amazon Web Services On January 14th 2020 Microsoft ended extended support for Windows Server 2008 and Windows Server 2008 R2. The oldest supported Windows Server version, Windows Server 2012, comes with Windows PowerShell 3.0 and .NET Framework 4.5. The legacy variant of AWS...
Project LightSpeed: Rewriting Messenger to be faster, smaller, and simpler To build this new version of Messenger, we needed to rebuild the architecture from the ground up and rewrite the entire codebase.
Free Magazines for .NET and JavaScript Developers DotNetCurry Magazine better known as the 'DNC Magazine' is a FREE, bimonthly (once every 2 months) digital publication bringing you the latest from the .NET and JavaScript world presented by Microsoft MVP's and industry experts
C# and .NET Book | Covers C# 6, C# 7, .NET Framework and .NET Core A C# and .NET eBook with easy-to-follow concepts in a Q & A format. Use it build a solid foundation of .NET and C# concepts or use it for your next .NET Interview .
Robinhood App and Website Down Robinhood, the free trading app that has signed on more than 10 million users, went down this Monday morning. The app just shows an empty dashboard, buying power, and a message at the bottom saying, "There was an error loading your notifications". It's q...
fork() can fail: this is important Ah, fork(). The way processes make more processes. Well, one of them, anyway. It seems I have another story to tell about it.
Re: SMB over QUIC: Files Without the VPN yes the plan is to bring it to Azure Files too. Makes perfect sense there
GitTrends: GitHub Insights - Monitor Views and Clones of your GitHub Repositories | Product Hunt GitTrends helps you to monitor your GitHub Repositories! ✅ Connect to GitHub ✅ Monitor GitHub Repo Views ✅ Monitor GitHub Repo Clones ✅ Discover Referring Sites
microsoft-signalr - cdnjs.com - The best FOSS CDN for web related libraries to speed up your websites! microsoft-signalr - ASP.NET Core SignalR is an open-source library that simplifies adding real-time web functionality to apps. Real-time web functionality enables server-side code to push content to clients instantly. This client can also be used with the...


Try modifying the URL to get a greeting for somebody else's name.
An important attribute of the flask.render_template function is that it protects you against dangerous user input. For example, try the endpoint /hello/<em>Bob, which looks like it's intended by the user to turn everything from "Bob" to the end of the page italic. Check out what render_template produces instead. This is one way Flask provides you with tools to prevent injection attacks.


Hello! My name is Mansi
I was born in Jammu, India.
- North India
- Foothills of Himalayas
I moved to the United States when I was 3.
- first to Brooklyn
- then to Philadelphia
I like to sing.
I am currently learning piano.
I am short.
Below Average Height
I graduated college in 2007 and moved to New York City where I worked in finance and law.
After a certain point,
neither career options were satisfying or creative enough,
so I started looking into other options.
Enter Dev Bootcamp!
Email them!


Camping Costs
Item
Quantity
Price
Total
Tent
1
$279.00
$279.00
Sleeping Bags
2
$159.95
$319.90
Camp Chairs
2
$39.50
$79.00
Grand Total
$667.90


SEPA, the Single Euro Payments Area is an European initiative which aims to address making cashless payments across European borders by creating common payment instruments and a more innovative market for retail payments.
The European payments industry has created three basic payment instruments introduced across Europe: SEPA Credit Transfer, SEPA Direct Debit and SEPA for Cards.
| Step | Description | Screenshot |
|---|---|---|
| 1 | Select the SEPA payment method. | |
| 2 |
Provide your bank account details:
|
|
| 3 | Accept SEPA mandate by marking a check box | |
| 4 | You will be redirected to the Payment form success or the Payment form failure popup window. |
| Product | SEPA |
|---|---|
| Type | Direct debit |
| Channels | ecom, moto |
| Currencies | EUR |
| Countries |
AT, BE, CY, EE, FI, FR, DE, GR, IE, IT,
LV, LT, LU, MT, NL, PT, SK, SI, ES, CH |
| Technical Flow | synchronous |
| Recurring | yes |
| Chargebacks | yes |
| Reusable Payment Instruments | yes |
| Debit | yes |
|---|---|
| Preauthorization | yes |
| Cancelation | yes (full, partial) |
| Capture | yes (full, partial) |
| Refunds | yes * NOTE Refunds can only be executed if the merchant bank account connection is set up |
| Notifications | yes - webhook, email |
| Settlement Reporting | yes |
| API | yes |
|---|---|
| Widget | yes |
| Bridge |
|
| Shop Plugin | no (on the roadmap) |
| Paylink | yes |
Prerequisite: Collect mandate acceptance
Before creating a SEPA direct debit order, your customer must accept the SEPA Direct Debit mandate. The acceptance authorizes Concardis to collect payments for the specified amount from their bank account, using SEPA Direct Debit.
What is a Mandate?
Usually, the SEPA mandate is a paper document, but since it is not possible to implement a paper document in eCommerce, electronic mandates (eMandates) are used. The Mandates are stored within the Payengine payment instrument.
These mandates have a unique mandateId, and store the mandateText as well as the createdDateTime (the timestamp the customer agreed to the specific mandate).
Within Payengine, the mandate object of a payment instrument is used for tracking the usage of a payment instrument through the type property.
"Ich ermächtige die Concardis GmbH, Helfman-Park 7 in 65760 Eschborn, GläubigerID DE82ZZZ00000346626, Zahlungen von meinem Konto mittels SEPA-Lastschrift unter der Mandatsreferenz [mandateId] einzuziehen. Zugleich weise ich mein Kreditinstitut an, die von Concardis GmbH auf mein Konto gezogenen SEPA-Lastschriften einzulösen.
Hinweis: Ich kann innerhalb von acht Wochen, beginnend mit dem Belastungsdatum, die Erstattung des belasteten Betrages verlangen.

When a customer provides authorization for a single usage of his bank details for a payment.
You can:
For more information, see Single Order.
When a customer provides authorization to perform a series of payments with his bank details.
Recurring payments are handled with use of the directDebitType of mandate object which points to the type of usage for the particular order. Mark the orders as FIRST, RECURRING or FINAL.
There are two types of recurring orders: Recurring Order With initial Payment and Recurring Order Without initial Payment.
This option provides:
For more information, see Recurring Order Without Initial Payment.
This option provides:
For more information, see Recurring Order with Initial Payment.
| PARAMETER | MANDATORY/ OPTIONAL |
DESCRIPTION | |
|---|---|---|---|
| payment.bankName | O |
string The name of the bank of the SEPA account. minLength: 1 maxLength: 255 |
|
| payment.iban | M |
string maxLength: 34 IBAN of the SEPA account. |
|
| payment.bic | O | BIC of the SEPA account. | |
| payment.accountHolder | M |
string minLength: 4 maxLength: 128 The account holder's name of the SEPA account. |
|
| order.statementDescription | O |
The statement description from your system/shop of this order.
The field order.statementDescription will be used as purpose text. When no order.statementDescription is present the following logic will be applied: 1) order.merchantOrderId is used when it's present 2) order.orderId is used when order.merchantOrderId is not present For both cases fields merchant.companyName and merchant.shopUrl will be added after either order.merchantOrderId or order.orderId separated with space. The max length of the purpose text is 108 characters and it will be cut off if it's longer. Please see the sample below the table. |
|
| mandate.mandateId | O | The mandateId assigned to the SEPA mandate (Optionally, Payengine will generate the ID (if it not available). The ID must follow the '^[a-zA-Z0-9-]{1,35}' pattern. | |
| mandate.createdDateTime | M |
number($date-time) Timestamp for mandate creation (mandatory). |
|
| mandate.mandateText | M |
string Mandate text displayed to the customer (mandatory) |
|
| mandate.directDebitType | M |
string title: DirectDebitType The current mandate type of the direct debit type. The mandate type can be one of the following. FIRST: It is the first execution of the mandate SINGLE: It is used only for one execution of the mandate RECURRING: It is used for recurring mandate usage FINAL: It is the last execution of the recurring mandate. |
|
| mandate.directDebitType.SINGLE | One execution | ||
| mandate.directDebitType.FIRST | The initial usage of the recurring payment instrument |
String statementDescription = order.getStatementDescription();
if ( StringUtils.isEmpty( statementDescription ) ) {
statementDescription = order.getMerchantOrderId() != null ? order.getMerchantOrderId() : order.getBusinessKey() + " " + merchant.getCompanyName() + " " + merchant.getShopUrl();
}
return statementDescription.length() > MAX_LENGTH_OF_STATEMENT_DESCRIPTION ? statementDescription.substring( 0, MAX_LENGTH_OF_STATEMENT_DESCRIPTION ) : statementDescription;
| PARAMETER | MANDATORY/ OPTIONAL |
DESCRIPTION | ||||||
|---|---|---|---|---|---|---|---|---|
| mandateId | M | If there is no mandateID transmitted in the request, Payengine will generate one and send it back in the response. |
| PARAMETER | MANDATORY/ OPTIONAL |
DESCRIPTION | EXAMPLE | |||
|---|---|---|---|---|---|---|
| M | The customer's e-mail address. |<EMAIL_ADDRESS>|
| PARAMETER | MANDATORY/ OPTIONAL |
DESCRIPTION | |
|---|---|---|---|
| payment.bankName | O |
string The name of the bank of the SEPA account. minLength: 1 maxLength: 255 |
|
| payment.iban | M |
string maxLength: 34 IBAN of the SEPA account |
|
| payment.bic | O | BIC of the SEPA account. | |
| payment.accountHolder | M |
string minLength: 4 maxLength: 128 The account holder's name of the SEPA account. |
|
| mandate.mandateId | O | The mandateId assigned to the SEPA mandate (Optionally, Payengine will generate the ID if it is not available). The ID must follow the '^[a-zA-Z0-9-]{1,35}' pattern. | |
| mandate.createdDateTime | М |
number($date-time) Timestamp for mandate creation (mandatory). NOTE Should only be transmitted for directDebitType FIRST, SINGLE. |
|
| mandate.mandateText | М |
string Mandate text displayed to the customer (mandatory) NOTE Should only be transmitted for directDebitType FIRST, SINGLE. |
|
| mandate.directDebitType | М |
string title: DirectDebitType The current mandate type of the direct debit type. The mandate type can be one of the following. FIRST: It is the first execution of the mandate SINGLE: It is used only for one execution of the mandate RECURRING: It is used for recurring mandate usage FINAL: It is the last execution of the recurring mandate. |
|
| mandate.directDebitType.SINGLE | One execution | ||
| mandate.directDebitType.FIRST | The initial usage of the recurring payment instrument | ||
| mandate.directDebitType.RECURRING | Any further usage of the payment instrument. | ||
| mandate.directDebitType.FINAL | The last usage of a payment instrument. |
To use the refund service of Payengine, configure your bank account connection at the Concardis Merchant Center.
| Result | Description |
|---|---|
| Success | Any amount + any merchant/customer IBAN: The transaction's status changes from "OK" to "SUCCESS" |
| Chargeback |
Each of the amounts listed below + any merchant/customer IBAN: The transaction succeeds but a dispute is immediately created. The debit's/preauth's status stays in success and a new chargeback transaction is created with status "booked". This might take some time, according to the scheduler settings.
|
You can see all settlement information in the Unified Settlement Report. For more information on the format and mappings, see Unified Settlement Report.


The World Wide Web Consortium (W3C) is an international organization committed to improving the web. It is made up of several hundred member organizations from a variety of related IT industries. W3C sets standards for the World Wide Web (WWW) to facilitate interoperability and cooperation among all web stakeholders. It was established in 1994 by the creator of the WWW, Tim Berners-Lee.
Founded in 1994 by the inventor of the Web, Tim Berners-Lee, W3C has successfully overseen processes of issue raising, design, consensus building and testing resulting in over 335 technical standards that make the Web work. Success stories include HTML5, XML, CSS and Web accessibility guidelines. The Members and Staff of W3C, and its partners, are creating many more technologies that are designed to enable all Web users, from the elderly to the youngest generations, to share knowledge, expand commerce, and innovate.
HTML stands for Hypertext Markup Language. It allows the user to create and structure sections, paragraphs, headings, links, and blockquotes for web pages and applications. HTML is not a programming language, meaning it doesn’t have the ability to create dynamic functionality. Instead, it makes it possible to organize and format documents, similarly to Microsoft Word. When working with HTML, we use simple code structures (tags and attributes) to mark up a website page.
HTML was invented by Tim Berners-Lee, a physicist at the CERN research institute in Switzerland. He came up with the idea of an Internet-based hypertext system. Hypertext means a text that contains references (links) to other texts that viewers can access immediately. He published the first version of HTML in 1991, consisting of 18 HTML tags. Since then, each new version of the HTML language came with new tags and attributes (tag modifiers) to the markup. Due to a quick rise in popularity, HTML is now considered an official web standard. The HTML specifications are maintained and developed by the World Wide Web Consortium (W3C). You can check out the latest state of the language anytime on W3C’s website.
Cascading Style Sheets, fondly referred to as CSS, is a simple design language intended to simplify the process of making web pages presentable. CSS handles the look and feel part of a web page. Using CSS, you can control the color of the text, the style of fonts, the spacing between paragraphs, how columns are sized and laid out, what background images or colors are used, layout designs,variations in display for different devices and screen sizes as well as a variety of other effects. CSS is easy to learn and understand but it provides powerful control over the presentation of an HTML document. Most commonly, CSS is combined with the markup languages HTML or XHTML.
CSS is created and maintained through a group of people within the W3C called the CSS Working Group. The CSS Working Group creates documents called specifications. When a specification has been discussed and officially ratified by the W3C members, it becomes a recommendation. These ratified specifications are called recommendations because the W3C has no control over the actual implementation of the language. Independent companies and organizations create that software.
Cascading Style Sheets level 1 (CSS1) came out of W3C as a recommendation in December 1996. This version describes the CSS language as well as a simple visual formatting model for all the HTML tags. CSS2 became a W3C recommendation in May 1998 and builds on CSS1. This version adds support for media-specific style sheets e.g. printers and aural devices, downloadable fonts, element positioning and tables.


Xin chào! I'm John, and I'm a Senior in Computer Science at the University of Oklahoma. I'll be graduating in May 2019. I'm the Founder and the Executive Director of Hacklahoma and the President of the OU Student Chapter ACM. My mission with those is to create a diverse and inclusive tech community that accepts people of all backgrounds, majors, and skill levels in Oklahoma. I also play guitar and have a huge appreciation for music, games, architecture, and dogs.
I also had three internships. I'll start with my latest. I'm working at AT&T developing a fullstack application with AngularJS, MySQL, JPA, and Java in a team of eight. It gives a way for employees to access learning and career opportunities within the company. My second internship was with Sandia National Labs, where I optimized model calculations with multidimensional interpolation. My first internship was after my freshman year at Kirtland Air Force Base AFRL, where I created a graphical user interface for general purpose telescope control in a team of two using Java.
My next step in life is to land a good full time software development/engineering job, since I'll be graduating soon! I'm also open to internships. If you happen to be able to connect me with these opportunities, drop me an email! And if you have any other inquires, don't hesitate to talk to me!


NOTE: For this example to work you have to run it in a web server context. This is a simple example showing how to import data from an MS Project file directly to the Ext Gantt. With the help of the MPXJ library, we've built a Java based application which extracts data from .mpp files. This gives us the ability to extract Tasks, Resources, Assignments, Dependencies and Columns. The basic MSP columns will be converted to proper Ext JS columns, while any custom column will be added as an `Ext.tree.Column` type. The project is a standalone JAR package and the only dependency is Java JDK 1.5+.
For more information about the import feature, please refer to the README.txt file
To try this example, you can use your own MPP project file or download this sample MPP: AdvancedExample.mpp
Note that the js for the example code is not minified so it is readable. See import.js.