Glossary

Warning

Work in progress. Help wanted.

General

O²: acronym which stands for "online–offline" which refers to the online and offline reconstruction
DPL: Data Processing Layer; core O² framework for data processing, built on top of FairMQ
Arrow: the Apache Arrow format in which tables are processed in O²
JSON: format used for configuration of devices

Data reconstruction

timeframe, TF: snapshot of detector data over a given time window
dataframe, DF: self-contained unit of processing
FLP: First Level Processor
EPN: Event Processing Node
PDP: Physics Data Processing
particle collision: interaction of energetic particles (real or simulated). Simulated particle collisions are stored in the McCollisions table. Simulated particles are stored in the McParticles table.
reconstructed collision: primary vertex reconstructed from an observed activity in the detector suspected to be associated with a particle collision. Reconstructed collision are stored in the Collisions table. Reconstructed charged particles are stored in the Tracks table.

Data structures

AO2D: format of saving tables in ROOT files (typically called AO2D.root)
table: data format storing a collection of columns for each entry (table row). Rows represent objects of the given table type and columns represent properties of these objects. A table definition defines a C++ type and therefore must be unique. Declared with the DECLARE_SOA_TABLE(...) macros. Stored in AO2D as TTree.

Data processing

task: C++ struct which can process and produce tables and produce other output (e.g. histograms). A task is executed as a device of a workflow.
configurable: task parameter, whose value can be set without editing the code of the task. Implemented as a task member of type Configurable(...). Can be set via JSON configuration.
process function: task method, which subscribes to tables (i.e. consumes them as input) and performs some operations with their content (e.g. fills output tables or histograms).
process function switch: PROCESS_SWITCH macro which defines a configurable which allows to enable and disable the execution of a given process function.
device (DPL device): execution sub-unit of a workflow. Implemented as a task. Can be configured via configurables. The device name is generated from the task name, unless it is provided explicitly, using TaskName("device-name") as an argument of adaptAnalysisTask.
workflow (DPL workflow): execution unit in DPL, consisting of one or several devices. Implemented as a C++ .cxx file, compiled into a single executable binary file. The workflow name is generated from the arguments of the o2physics_add_dpl_workflow function in the CMakeLists.txt file. For workflows files located in PWG.. directories, a corresponding prefix is added: o2-<component>-[<pwg>-]<name>.; Example: o2-analysis-hf-task-d0

<component> is analysis, derived from COMPONENT_NAME Analysis,
<pwg> is hf, derived from the PWGHF directory name,
<name> is task-d0, provided in o2physics_add_dpl_workflow(task-d0.

workflow topology: the connection between running workflows, based on their inputs and outputs

Table content

static column: table column which stores a value provided when it is filled. Declared with the DECLARE_SOA_COLUMN(...) macros.; Example: The Collisions table of collisions has a static column PosZ which stores the value of the z coordinate of the primary vertex. The value has to be provided when a new collision row is being added in the table.
dynamic column: table column which behaves as a function of other (static or expression) columns of the same table. Declared with the DECLARE_SOA_DYNAMIC_COLUMN(...) macros. The value is calculated only when the column getter is called.; Dynamic column definitions can have free parameters, which have to be provided as arguments of the getter. Values of dynamic columns are not written in AO2D files and cannot be used for table filtering. Additional dynamic columns can be attached to a table inside a process function with Attach.; Example: The Tracks table of tracks has a dynamic column Px, representing the x component of the track momentum, defined as a function of other static columns. It's value is calculated every time the corresponding px getter is called.
expression column: table column which stores a value which is calculated by evaluating an expression when the table is written. Declared with the DECLARE_SOA_EXPRESSION_COLUMN(...) macros. Values of expression columns are written in AO2D files and can be used for table filtering.; Additional expression columns can be attached to a table inside a process function with Extend.; Example: The Tracks table of tracks has an expression column Phi, representing the azimuth of the track momentum, defined as a function of other static columns. All values of the Phi column are calculated for all tracks together (in bulk) when the Tracks table is written in the AO2D file.
index column: table column which stores the index of a table row. Declared with the DECLARE_SOA_INDEX_COLUMN(...) macros.; Example: The Tracks table of tracks has an index column pointing to rows of the Collisions table, which links each track to its collision. Calling the collision getter returns an iterator pointing to a given collision. Calling the collisionId getter returns the value of the index itself (i.e. the position of the row in the Collisions table).
column getter: method that returns the value stored in the column.; Example: The value of the transverse momentum of a given track in the Tracks table is stored in the Pt column. This value can be obtained by calling the corresponding pt getter as track.pt().
data model: collection of table definitions. Defined in header files in DataModel directories.
extended table: table consisting of expression columns which extends another table. Declared with the DECLARE_SOA_EXTENDED_TABLE(...) macros.
index table: table consisting of index columns. Declared with the DECLARE_SOA_INDEX_TABLE(...) macros.

Table production

Produces: A Produces<...> task member defines a table cursor which creates a new table row when called.
Spawns: A Spawns<...> task member defines a handle to an extended table. The extended table is created before the execution of the process functions.
Builds: A Builds<...> task member defines a handle to an index table. The index table is created before the execution of the process functions.

Table manipulation

Join: Declaration of a Join<...> object defines a table view which joins columns of matching rows in multiple tables of the same length.
grouping: Subscription to the iterator of a table defines a loop over that table where the rows of other tables are grouped by the index of the iterated table. For each iteration only the subset of the other tables linked to the given iterator (via the index column) is available.
SmallGroups: TODO
Filter: Definition of a Filter task member applies the corresponding condition to all compatible tables subscribed using Filtered<...>. Only the filtered subsets of the tables are available.; Filter definitions can reference configurables. Filter definitions cannot reference dynamic columns. Filter definitions can contain conditional expressions with ifnode.; Filtered tables can be grouped. Filtered tables can be created inside process functions with select.
Partition: Definition of a Partition<...> task member creates a table view for a subset of a table according to the corresponding condition.; Multiple partitions of the same table can co-exist together with the full table. Partitions can be filtered. Partitions cannot be grouped and have to be sliced instead. Partitions can be created inside process functions.
slicing: A partition slice corresponding to a given value of a given index column can be created using the sliceBy(...) methods of the partition.
Preslice: TODO

AliHyperloop

wagon: instance of a workflow on AliHyperloop, defined by its dependencies, configuration of devices and outputs
train: collection of wagons executed on AliHyperloop
derived data: AO2D file with tables produced as a result of processing another AO2D file (parent)
linked derived data: derived data containing tables with index columns pointing to tables in its parent files. Processing of linked derived data requires access to the parent files.
self-contained derived data: derived data containing tables without index columns pointing to tables in other files.