framework/modulelist.py
=== stdout of framework/tests/modulelist.py ===
[INFO] Steering file: /data/b2soft/buildbot/development/releases/current/framework/tests/modulelist.py
**************************************************************
Geant4 version Name: geant4-11-02-patch-01 (16-February-2024)
Copyright : Geant4 Collaboration
References : NIM A 506 (2003), 250-303
: IEEE-TNS 53 (2006), 270-278
: NIM A 835 (2016), 186-225
WWW : http://geant4.org/
**************************************************************
--------------------------------------------------------------------------------
alignment
AlignDQM DQM of Alignment for off line residuals per sensor,
layer, keep also On-Line DQM from tracking: their
momentum, Number of hits in tracks, Number of tracks.
AlignmentGenerator Generates VXD alignment.Generated alignment overrides
any existing one in reconstruction if done with this
module. The generated object can also be stored as
payload in the (local) DB, to keep track of it.
CopyRecoTracksWithOverlap Copy RecoTracks with overlap hits in VXD to a new
StoreArray (Will need a refit).
If particleList is specified, take only RecoTracks
associated to the particles (allows to make prior cuts
at analysis level).
CosmicsAlignmentValidation Alignment Validation with Cosmics
MergerCosmicTracks Select cosmic events containing two tracks (up/down) and
merge two tracks
MillepedeCollector Calibration data collector for Millepede Algorithm
SetRecoTrackMomentum Set momentum magnitude for RecoTracks seed to given
value (for runs without magnetic field)
Take the momentum direction from seed and update its
magnitude to artificial value for all RecoTracks -
needed for tracks without magnetic field.
By default activated automatically, when zero B-field
is detected at the origin
UpdateParticleTrackCand Updates the seed in TrackCand based on fitted state (at
vertex)
analysis
AllParticleCombiner This module combines all particles of the provided list
to one mother particle.
AnalysisConfiguration This is a supplementary module designed to configure
other modules
BelleBremRecovery
Takes the charged particle from the given charged
particle list (``inputListName``) and
copies it to the output list (``outputListName``). The
4-vector of the nearest (all) photon(s)
from ``gammaListName`` (considered as radiative) is
added to the charged particle, if it is
found inside the cone around the charged particle with
the given maximum angle (``angleThreshold``).
BelleNbarMVA Apply nbarMVA for Belle I, a DNN trained with ECLCluster
variables for discrimination of anti-neutrons against
photons. Anti-neutron-like particles have scores closer
to 1; photon-like particles have scores closer to 0.
BestCandidateSelection Sort particles by the value of a given ``variable``
in the input list and optionally remove particles after
the nth position.
Per default particles are sorted in descending order but
it can be switched to
an ascending order by setting ``selectLowest=True``. The
convenience functions
`modularAnalysis.rankByHighest` and
`modularAnalysis.rankByLowest` set this
parameter automatically based on their names.
Particles will receive an extra-info field containing
their rank as an integer
starting at 1 (best). The name of this extra-info field
defaults to
``${variable}_rank`` but can be chosen freely using the
``outputVariable``
parameter.
The ranking also takes antiparticles into account, so
there will only be one
B+- candidate with ``rank=1``. The remaining list is
sorted from best to worst
candidate (each charge, e.g. B+/B-, separately). The
sorting is guaranteed
to be stable between particle and anti particle list:
particles with the same
value for ``variable`` will keep their relative order.
That is, a particle "A"
which was before another particle "B" in the same list
and has the same value
for ``variable`` will also stay before "B" after
sorting.
If ``allowMultiRank=False`` (the default) candidates
with same value of
``variable`` will have different ranks. If
``allowMultiRank=True`` they will
share the same rank.
IF ``numBest>0`` only candidates with this rank or
better will remain in the
output list. If ``allowMultiRank=True`` that means that
there can be more than
``numBest`` candidates in the output list if they share
ranks.
BremsFinder
This module copies each particle in the ``inputList`` to
the ``outputList`` and uses
the results of the **eclTrackBremFinder** module to look
for possible bremsstrahlung photons; if these
photons exist, it adds their four momentum to the
particle in the ``outputList``.
It also adds the original particle and these photons as
daughters of the new, corrected particle.
Track and PID information of the original particle are
copied onto the new one to facilitate their access
in the analysis scripts.
The **eclTrackBremFinder** module uses the lepton track
PXD and SVD hits and extrapolates them to the ECL;
then looks for ECL clusters with energies between 0.02
and 1 times the track energy and without associated
tracks, and checks if the normalized distance between
each of these clusters
and the extrapolated hit is smaller than 0.05. If it is,
a *Bremsstrahlung* weighted relation
between said cluster and the track is established. The
weight is determined as
.. math::
\text{max}\left(\frac{\left|\phi_{\text{cluster}}-
\phi_{\text{hit}}\right|}{\Delta\phi_{\text{cluster}}+\D
elta\phi_{\text{hit}}}, \, \frac{\left|\theta_{\text{clu
ster}}-
\theta_{\text{hit}}\right|}{\Delta\theta_{\text{cluster}
}+\Delta\theta_{\text{hit}}}\right)
where :math:`\phi_i` and :math:`\theta_i` are the
azimuthal and polar angles of the ECL cluster and the
extrapolated hit, and :math:`\Delta x` represents the
uncertainty of the value :math:`x`. The details of the
calculation of these quantities are `here`_. By default,
only relations with a weight smaller than 3.0 are
stored.
The user can further reduce the maximally allowed value
of this weight to remove unwanted photons from the
bremsstrahlung correction.
This module looks for photons in the ``gammaList`` whose
clusters have a *Bremsstrahlung* relation with the track
of one of the particles in the ``inputList``, and adds
their 4-momentum to the particle's one. It also stores
the value
of each relation weight as ``extraInfo`` of the
corrected particle, under the name
``"bremsWeightWithPhotonN"``, where
N is the index of the photon as daughter of the
corrected particle; thus ``"bremsWeightWithPhoton0"``
gives the weight
of the Bremsstrahlung relation between the new,
corrected particle, and the first photon daughter.
Warning:
Even in the event of no bremsstrahlung photons found,
a new particle is still created, and the original one is
still
added as its daughter.
Warning:
Studies have shown that the requirements that the
energy of the photon must be between 0.2 and 1 times the
track energy and
that only track-photon relations with a weight below
three are considered, are too tight. Until these are
relaxed and a new
processing is done (MC15 and proc 13) it might be
better to use the alternative `BelleBremRecovery`
module.
See also:
`eclTrackBremFinder module`_
.. _eclTrackBremFinder module: https://gitlab.desy.de/be
lle2/software/basf2/-
/tree/main/ecl/modules/eclTrackBremFinder
.. _here: https://gitlab.desy.de/belle2/software/basf2/-
/tree/main/ecl/modules/eclTrackBremFinder/src/BremFindin
gMatchCompute.cc
BtubeCreator BtubeCreator : This module creates Btube object, an
object geometrically similar to a very long ellipsoid
along a particular direction and can be used as a
constraint in vertexing B particles. Upsilon4S decays to
two Bs. the user selects one B with a ^ in decaystring.
The order of daughters in reconstructdecay of Upsilon4S
and this decaystring should be same. Using selected B as
reference, the module calculates the direction in which
the other B should fly and constructs a Btube object
along that direction. In semi-leptonic analyses, the
selected B is usually the fully reconstructed one, while
for time dependent studies, the selected B is usually
signal B which can be partially reconstructed
ChargedPidMVA This module evaluates the response of an MVA trained for
binary charged particle identification between two
hypotheses, S and B. For a given input set of (S,B) mass
hypotheses, it takes the Particle objects in the
appropriate charged stable particle's ParticleLists,
calculates the MVA score using the appropriate xml
weight file, and adds it as ExtraInfo to the Particle
objects.
ChargedPidMVAMulticlass This module evaluates the response of a multi-class MVA
trained for global charged particle identification.. It
takes the Particle objects in the input charged stable
particles' ParticleLists, calculates the MVA per-class
score using the appropriate xml weight file, and adds it
as ExtraInfo to the Particle objects.
ContinuumSuppressionBuilder Creates for each Particle in the given ParticleLists
a ContinuumSuppression dataobject and makes basf2
relation between them.
CurlTagger Curl Tagger is a tool designed to identify and tag extra
tracks caused by low pt particles curling around the
detector. For further documentation please see
'tagCurlTracks' in modularAnalysis.
DistanceCalculator Calculates distance between two vertices, distance of
closest approach between a vertex and a track, distance
of closest approach between two tracks, distance of
closest approach between a vertex/track and Btube
DuplicateVertexMarker Identify duplicate vertices (distinct particles, but
built from the same daughters) and mark the one with
best chi2. Only works if the particle has exactly two
daughters. Mainly used to deal when merging V0 vertices
with hand-built ones.
EnergyBiasCorrection Module to modify energy from the lists. Include in your
code as
.. code:: python
mypath.add_module("EnergyBiasCorrection",
particleLists=['gamma:cut'], scale=tableName_Weight)
The module modifies the input particleLists by scaling
energy as given by the scale in the LookUpTable
EventKinematics Module to compute global event kinematic attributes like
missing momentum and energy.
EventShapeCalculator Module to compute event shape attributes starting from
particlelists. The core algorithms are not implemented
in this module, but in dedicated basf2 classes.
ExtraInfoPrinter Prints the names of all ExtraInfo set for each particle
in the event. Useful for debugging and development.
ExtraInfoRemover Deletes the ExtraInfo from each particle in the given
ParticleLists.
FlavorTaggerInfoBuilder Initializes the FlavorTaggerInfo DataObject that will be
used during the Flavor Tagging. Filling is done in the
FlavorTagger.py script
FlavorTaggerInfoFiller Creates a new flavorTaggerInfoMap DataObject for the
specific methods. Saves there all the relevant
information of the flavorTagger.
HelixErrorScaler scale the error of helix parameters
Creates a new charged particle list whose helix errors
are scaled by constant factors.
Different sets of scale factors are defined for tracks
with/without a PXD hit.
For tracks with a PXD hit, in order to avoid severe
underestimation of d0 and z0 errors,
lower limits (best resolution) can be set in a momentum-
dependent form.
The module also accepts a V0 Kshort particle list as
input and applies the error correction to its daughters.
Note the difference in impact parameter resolution
between V0 daughters and tracks from IP,
as V0 daughters are free from multiple scattering
through the beam pipe.
InclusiveBtagReconstruction Inclusive Btag reconstruction
InclusiveDstarReconstruction Inclusive Dstar reconstruction by estimating the
four vector using slow pions
KlongDecayReconstructorExpert
This module is used to employ kinematic constraints to
determine the momentum
of Klongs for two body B decays containing a K_L0 and
something else. The
module creates a list of K_L0 candidates whose K_L0
momentum is reconstructed
by combining the reconstructed direction (from either
the ECL or KLM) of the
K_L0 and kinematic constraints of the initial state.
KlongMomentumCalculatorExpert
This module is used to employ kinematic constraints to
determine the momentum of Klongs for two
body decays containing a K_L0 and something else. The
module creates a list of K_L0 candidates whose K_L0
momentum is
reconstructed by combining the reconstructed direction
of the K_L0 (either from the ECL or the KLM cluster) and
kinematic constraints of the initial state.
KlongMomentumUpdaterExpert This module calculates and updates the kinematics of
two body B decays including one Klong
LowEnergyPi0IdentificationExpert Low-energy pi0 identification.
LowEnergyPi0VetoExpert Low-energy pi0 veto.
MCDecayFinder Find decays in MCParticle list matching a given
DecayString and create Particles from them.
MCMatcherParticles Performs MC matching (sets relation
Particle->MCParticle) for all particles
(and its (grand)^N-daughter particles) in the
ParticleList. The relation can
be used in conjunction with MCMatching::MCErrorFlags
flags, e.g. using the
isSignal or mcPDG & mcErrors variables.
In addition to the usual mc matching algorithm the
module can run also loose mc
matching. The difference between loose and normal mc
matching algorithm is that
the loose algorithm will find the common mother of the
majority of daughter
particles while the normal algorithm finds the common
mother of all daughters.
The results of loose mc matching algorithm are stored to
the following extraInfo
items:
- looseMCMotherPDG: PDG code of most common mother
- looseMCMotherIndex: 1-based StoreArray
index of most common mother
- looseMCWrongDaughterN: number of daughters that don't
originate from the most common mother
- looseMCWrongDaughterPDG: PDG code of the daughter that
doesn't originate from
the most common mother (only if looseMCWrongDaughterN
= 1)
- looseMCWrongDaughterBiB: 1 if the wrong daughter is
Beam Induced Background
Particle
NeutralHadron4MomentumCalculator Calculates 4-momentum of a neutral hadron in a
given decay chain e.g. B0 -> J/Psi K_L0, or anti-B0 ->
p+ K- anti-n0.
NeutralHadronMatcher Perform geometrical match between MC neutral hadron
(given by mcPDG) and ECL clusters from the particleLists
OnlyWriteOutParticleLists Marks all objects in DataStore except those of type
ParticleList as WriteOut=False. Intended to run before
outputting an index file to remove unnecessary arrays.
PIDCalibrationWeightCreator Creates the calibration weight matrix
PIDNeuralNetworkParametersCreator Module that creates PID neural network
parameters and uploads them to the DB
ParticleCombiner Makes particle combinations
ParticleCombinerFromMC Makes particle combinations
ParticleCopier Replaces each Particle in the ParticleList with its
copy.
Particle's (grand)^n-daughter Particles are copied as
well.
The existing relations of the original Particle (or it's
(grand-)^n-daughters)
are copied as well.
ParticleExtractorFromROE Extract Particles that belong to the ROE and fill them
into ParticleLists.
ParticleKinematicFitter Kinematic fitter for modular analysis
ParticleListManipulator Manipulates ParticleLists: copies/merges/performs
particle selection
ParticleLoader Loads MDST dataobjects as Particle objects to the
StoreArray and collects them in specified
ParticleList.
ParticleMCDecayString Creates the Monte Carlo decay string of a Particle and
its daughters. The MC decay string of the particle is
hashed and saved as a 32bit pattern in the extra info
field decayHash of the particle. The MC decay string of
the particle + its daughters is hashed as well and saved
as another 32bit pattern in the extra info field
decayHashExtended of the particle. The mapping hash <->
MC decay string in saved in a TTree by this module. The
32bit pattern must be saved as a float (because our
extra info field, variable manager and ntuple output
only supports float) but they just represent 32 bits of
a hash! The MC decay string can also be stored in an
analysis ROOT file using the MCDecayString NtupleTool.
Details on the MC decay string format can be found here:
`MCDecayString`
ParticleMassHypothesesUpdater This module updates the mass hypothesis of
particleList to pdgCode. The module creates a new
particle list containing copies of the original
particles, with updated mass hypotheses. The newly
created particle list is named after the input one plus
the suffix ``_converted_from_`` and the old mass
hypothesis, e.g. ``e+:mylist`` to pdgCode = 13 becomes
``mu+:mylist_converted_from_e``. The only supported mass
hypotheses are electrons, muons, kaons, pions and
protons (for both input and output lists).
ParticleMassUpdater This module replaces the mass of the particles inside
the given particleLists with the invariant mass of the
particle corresponding to the given pdgCode.
ParticleMomentumUpdater This module replaces the momentum of the particles in
the selected target particle list by p(beam) -
p(selected daughters). The momentum of the mother
particle will not be changed.
ParticlePrinter Prints specified variables for all particles in the
specified particle list to screen (useful for
debugging).
Event-based variables can be printed by not specifying
the particle list (empty string).
ParticleSelector Removes Particles from given ParticleList that do not
pass specified selection criteria.
ParticleStats Make a summary of specific ParticleLists.
ParticleVertexFitter Vertex fitter for modular analysis
ParticleWeighting Append weights from the database into the extraInfo of
Particles.
ParticleWeightingLookUpCreator Creates test LookUp table
PhotonEfficiencySystematics Module to include data/MC weights for photon
detection efficiency. Include in your code as
.. code:: python
mypath.add_module("PhotonEfficiencySystematics",
particleLists=['gamma:cut'], tableName=tableName_Weight)
Pi0VetoEfficiencySystematics Includes data/MC weights for pi0 veto efficiency as
extraInfo for a given particle list. One must call
writeP0EtaVeto function in advance. Weights and their
errors will be provided for given mode and threshold.
PostMergeUpdater Synchronize parts of the events post merge/embedding.
Used in the signal embedding pipeline. Uses kinematic
information for the tag / simulated decay stored in
eventExtraInfo.
PrintMCParticles Print an MCParticle List
PseudoVertexFitter Pseudo fitter adds a covariance matrix which is sum of
the daughter covariance matrices.
RemoveParticlesNotInLists Removes all Particles that are not in one of the given
ParticleLists (or daughters of Particles in the lists).
All relations from/to Particles, daughter indices, and
other ParticleLists are fixed. Note that this does not
currently touch any data used to create final state
particles, which might make up a large fraction of the
total file size.
RestOfEventBuilder Creates for each Particle in the given ParticleList a
RestOfEvent dataobject and makes basf2 relation between
them.
RestOfEventInterpreter Creates a mask (vector of boolean values) for tracks and
clusters in RestOfEvent.
RestOfEventPrinter Prints basic or detailed RestOfEvent info to screen. It
is possible to print out ROEMasks for specific mask
names as well.
RestOfEventUpdater Updates an existing mask (map of boolean values) for
tracks or eclClusters in RestOfEvent with an available
property (e.g. after performing training).
SelectDaughters SelectDaughters
SignalSideParticleFilter The module returns true if the current RestOfEvent
object is related to
any of the Particles from the input ParticleList and
passes selection criteria.
The module should be executed only in the for_each ROE
path.
SignalSideParticleListCreator The module creates a ParticleList and fills it
with one of the daughter Particles.
SignalSideVariablesToDaughterExtraInfo The module writes properties (values of
specified variables) of the particle related to the
current ROE
as an ExtraInfo to the single particle in the input
ParticleList.
This module is intended to be executed only in for_each
ROE path.
SignalSideVariablesToExtraInfo The module writes property (value of specified
variable) of single particle
found in the input ParticleList as an ExtraInfo to the
Particle related to
the current ROE. This module is intended to be executed
only in for_each ROE
path.
SkimFilter Filter based on ParticleLists, by setting return value
to true if at least one of the given lists is not empty.
TagUniqueSignal Mark true (target=1) candidates from input list via
extra-info field. Only the first true candidate
associated with an MCParticle is marked.
TagVertex Tag side Vertex Fitter for modular analysis
TauDecayMarker Module to identify generated tau pair decays, using
MCParticle information. Each tau lepton decay channel is
numbered following the order in the default KKMC decay
table. Using this module, the channel number will be
stored in the variables `tauPlusMCMode`, and
`tauMinusMCMode`. Further details and usage can be found
at `TauDecayMCModes`.
TauDecayMode Module to identify generated tau pair decays, using
MCParticle information.
By default, each tau decay is numbered as
TauolaBelle2DecayMode [Ref: BELLE2-NOTE-PH-2020-055]
TrackFitResultEstimator
Create a TrackFitResult from the momentum of the
Particle assuming it originates from the IP and make a
relation between them. The
covariance, detector hit information, and fit-related
information (pValue, NDF) are assigned meaningless
values. The input
Particles must not have already Track or TrackFitResult
and thus are supposed to be composite particles, recoil,
dummy particles,
and so on. Since the source type is not overwritten as
Track, not all track-related variables are guaranteed to
be available.
TrackIsoCalculator Calculate track isolation variables on the charged
stable particles, or selected charged daughters, of the
input ParticleList.
TrackingEfficiency Module to remove tracks from the lists at random.
Include in your code as
.. code:: python
mypath.add_module("TrackingEfficiency",
particleLists=['pi+:cut'], frac=0.01)
The module modifies the input particleLists by randomly
removing tracks with the probability frac.
TrackingEnergyLossCorrection Module to modify Energy of tracks from the lists.
Include in your code as
.. code:: python
mypath.add_module("TrackingEnergyLossCorrection",
particleLists=['pi+:cut'], correction=0.001)
The module modifies the input particleLists by
subtracting the correction value to the track energy and
rescaling the momenta
TrackingMomentumScaleFactors Module to modify momentum of tracks from the lists.
Include in your code as
.. code:: python
mypath.add_module("TrackingMomentumScaleFactors",
particleLists=['pi+:cut'], scale=0.999)
The module modifies the input particleLists by scaling
track momenta as given by the parameter scale
TreeFitter Tree Fitter module. Performs simultaneous fit of all
vertices in a decay chain. Can also be used to just fit
a single vertex.
TwoBodyISRPhotonCorrector This module corrects the energy and momentum of high
energy ISR photons in single ISR events based on the
beam energy, photon direction, and mass of the recoil
particle. The corrected photons are stored in a new
list, the original photon kinematics can be accessed via
the originalParticle() metavariable.
UdstListFilter Filter udst file content based on a particle list. As a
result of the module, all object which are (not)
associated with the list are removed. The module is used
for signal embedding.
V0DaughterMassUpdater This module replaces the mass of two daughters of the
selected V0 particles inside the given particleLists
with masses of given pdgCode. The particle in selected
particleList has to have 2 daughters.
VariableToReturnValue Calculate event-based variable specified by the user and
sets return value of the module accordingly.
VariablesToEventBasedTree Calculate variables specified by the user for a given
ParticleList and save them into a TTree. The Tree is
event-based, meaning that the variables of each
candidate for each event are saved in an array of a
branch of the Tree.
VariablesToEventExtraInfo For each particle in the input list the selected
variables are saved in an event-extra-info field with
the given name. Can be used to save MC truth
information, for example, in a ntuple of reconstructed
particles.
VariablesToExtraInfo For each particle in the input list the selected
variables are saved in an extra-info field with the
given name. Can be used when wanting to save variables
before modifying them, e.g. when performing vertex fits.
VariablesToHistogram Calculate variables specified by the user for a given
ParticleList and save them into one or two dimensional
histograms.
VariablesToNtuple Calculate variables specified by the user for a given
ParticleList and save them into a TNtuple. The TNtuple
is candidate-based, meaning that the variables of each
candidate are saved into separate rows.
arich
ARICHBackground ARICHBackground module. Used to extract information
relevant for ARICH background from background files
ARICHChannelMask Collector for ARICH channel mask production in CAF
ARICHDQM Make summary of data quality.
ARICHDigitizer This module creates ARICHDigits from ARICHSimHits. Here
spatial digitization is done, channel-by-channel QE is
applied, and readout time window cut is applied.
ARICHFillHits Fills ARICHHits collection from ARICHDigits
ARICHMCParticles Creates collection of MCParticles related to tracks that
hit ARICH.
ARICHNtuple The module saves variables needed for performance
analysis, such as position and momentum of the hit,
likelihoods for hypotheses and number of photons.
ARICHPacker Raw data packer for ARICH
ARICHRateCal Fills ARICHHits collection from ARICHDigits
ARICHRawUnpacker Not set by the author
ARICHReconstructor This module calculates the ARICHLikelihood values for
all particle id. hypotheses, for all tracks that enter
ARICH in the event.
ARICHRelate Creates relations between ARICHAeroHits and ExtHits.
Allows to store simulation output without MCParticles
ARICHUnpacker Raw data unpacker for ARICH
arichBtest Module for the ARICH Beamtest data analysis. It creates
track form the MWPC hits and reads the HAPD hits
arichToNtuple Local arich extension of VariblesToNtuple module to
append detailed arich information to reconstructed
candidates in the analysis output Ntuple. The TNtuple is
candidate-based, meaning that the variables of each
candidate are saved separate rows.
b2bii
B2BIIConvertBeamParams Not set by the author
B2BIIConvertMdst Converts Belle mDST objects (Panther tables and records)
to Belle II mDST objects.
B2BIIFixMdst Used to fix the old Belle I mdst files before
processing. This module was taken from the old Belle I
code and converted into a basf2 module.There are a lot
of magic numbers in this module, where do they come
from? No one knows...Return value is -1 if something
went wrong, do not use these events!
B2BIIMCParticlesMonitor This module creates and fills B2BII MCParticles
monitoring histograms.
B2BIIMdstInput Module to read Belle MDST files.
BelleMCOutput Output of MC particle list in Belle format.
background
BGOverlayExecutor Overlay of measured background with simulated data
BGOverlayInput Input for BG overlay, either in form of Digits or raw
data. For run-dependent MC (experiments 1 to 999) the
overlay samples corresponding to the simulated run are
automatically selected from the input list at each
beginRun(), enabling production of multiple runs in a
single job. This feature can be turned off by setting
ignoreRunNumbers to True.
BeamBkgGenerator Beam background generator based on SAD files. The
generator picks up particles from the SAD file randomly
according to their rates. Number of events is determined
from 'realTime' and overall rate, and the generator
terminates the execution when this number is reached.
BeamBkgHitRateMonitor A module for off-line monitoring of beam background hit
rates.
BeamBkgMixer Beam background mixer at SimHit level that uses beam
background simulation output directly (collision files)
and not ROF files. Each background event is shifted in
time randomly within a time window specified with
minTime and maxTime.
BeamBkgTagSetter Sets beam background tag variable in SimHits and adds
BackgroundMetaData branch in persistent tree; returns
true if at least one of the SimHit store arrays has
entries. Return value can be used to discard empty
events at output.
beast
AnalysisPhase1Study Study module for BEAST
BeamDigitizer Beamabort digitizer module
Beamabort Creates BEAMABORT crystals - sub-detector of BEASTII
BeamabortStudy Study module for Beamaborts (BEAST)
Bgo Creates BGO crystals - sub-detector of BEASTII
BgoDigitizer Bgo digitizer module
BgoStudy Study module for Bgos (BEAST)
CLAWS Creates CLAWS crystals - sub-detector of BEASTII
Cave Creates the CAVE of phase 1 - BEASTII
Claw Creates CLAW crystals - sub-detector of BEASTII
ClawDigitizer Claw digitizer module
ClawStudy Study module for Claws (BEAST)
ClawsDigitizer Claws digitizer module
ClawsStudy Study module for Clawss (BEAST)
CsIDigitizer Digitizer for the BEAST CsI system
CsIStudy Analyze simulations of CsI readings in BEAST. Requires
HistoManager module.
Csi Creates CSI crystals - sub-detector of BEASTII
CsiDigitizer_v2 Csi digitizer_v2 module
CsiStudy_v2 Study_v2 module for Csis (BEAST)
Dosi Creates DOSI crystals - sub-detector of BEASTII
DosiDigitizer Dosi digitizer module
DosiStudy Study module for Dosis (BEAST)
FANGS Creates FANGS crystals - sub-detector of BEASTII
FANGSDigitizer FANGS digitizer module
FANGSStudy Study module for Fangs (BEAST)
He3Digitizer He3tube digitizer module
He3tube Creates Helium-3 tube - sub-detector of BEASTII
He3tubeStudy Study module for He3tubes (BEAST)
Microtpc Creates micro-Time Projection Chamber - sub-detector of
BEASTII
MicrotpcStudy Study module for Microtpcs (BEAST)
NtuplePhase1_v6 Read SKB PVs, simulated measurements of BEAST sensors,
and write scaled simulated Ntuple in BEAST phase 1 data
format
Ph1bpipe Creates phase 1 beam pipe - BEASTII
Ph1sustr Creates phase 1 support structure - BEASTII
PinDigitizer Pindiode digitizer module
Pindiode Creates PINDIODE crystals - sub-detector of BEASTII
PindiodeStudy Study module for Pindiodes (BEAST)
Plume Creates PLUME - sub-detector of BEASTII
PlumeDigitizer PLUME digitizer module
Qcsmonitor Creates QCSMONITOR crystals - sub-detector of BEASTII
QcsmonitorDigitizer Qcsmonitor digitizer module
QcsmonitorStudy Study module for Qcsmonitors (BEAST)
Reprocessor Reprocessor module
Srsensor Creates Synchroton Radiation senor - sub-detector of
BEASTII
TPCStudy Study module for Microtpcs (BEAST)
TpcDigitizer Microtpc digitizer module
calibration
CaTest Test Module for saving big data in CAF
DummyCollector Dummy module for running when you don't really need
output.
TestCalibDBAccess Testing DB objects made in Calibration
TriggerSkim Trigger Skim Module
Module will return an overall result (True/False) based
on whether or not ANY or
ALL (depending on ``logicMode``) of the specified
triggers returned the given
value (``expectedResult``) from the
SoftwareTriggerResult.
Optionally it can apply prescales on each trigger line.
In that case ``logicMode='and'``
might not be very meaningful as the return value will
only be true if all trigger
lines were accepted after their own prescale.
cdc
CDCCRTest CDC Cosmic ray test module
CDCCalibrationCollector Collector module for cdc calibration
CDCCosmicAnalysis Module for harvesting parameters of the two half
(up/down) of a cosmic track for performance study
CDCCosmicSelector Modify MCParticles for cosmics so that the global time
is zero at y=0 assuming a cosmic trajectory is a line.
And select cosmics passing through a trigger counter.
This module works only for the event with the no. of
primary charged MC particles=1. Please place this module
after the event-generator and before FullSim.
CDCCosmicSelectorAfterFullSim Modify CDCSimHits and MCParticles for cosmics so
that the global time is (approximately) zero at y=0
using FullSim output (=CDCSimHits). And select cosmics
passing through a user-specified region at y=0. This
module works only for the event with the no. of primary
charged MC particles=1. Please place this module after
FullSim and before CDCDigitizer. This module is not
needed for normal MC; only needed when you want to
evaluate performance of T0 extraction module.
CDCCosmicTrackMerger Select cosmic events containing two tracks (up/down) and
merge two tracksOld reco tracks store array will be
deleted afterwards, if the parameter is set to do so.
CDCCrossTalkAdder Overlays signal-induced asic cross-talk to CDCHits.
CDCCrudeT0Collector Collector for crude t0
CDCDQM Make summary of data quality.
CDCDedxCorrection Apply hit level corrections to the dE/dx measurements.
CDCDedxDQM CDC dE/dx DQM plots with bhabha/hadron events.
CDCDedxElectronCollector A collector module for CDC dE/dx electron calibrations
CDCDedxHadronCollector A collector module for CDC dE/dx hadron calibrations
CDCDedxHitSaver Module that stores CDC hit information from recoTracks,
which is needed for dedx.
CDCDedxPID Extract dE/dx and corresponding log-likelihood from
fitted tracks and hits in the CDC.
CDCDedxPIDCreator Module that creates PID likelihoods from CDC hit
information stored in CDCDedxHits using parameterized
means and resolutions.
CDCDedxScan Extract dE/dx and corresponding log-likelihood from
fitted tracks and hits in the CDC, SVD and PXD.
CDCDedxSkim Apply clean up cuts for dE/dx purposes.
CDCDedxSkimCDST Extract dE/dx information for calibration development.
CDCDedxValidation Make data quality monitoring plots for CDC dE/dx
CDCDigitizer Creates CDCHits from CDCSimHits.
CDCFudgeFactorCalibrationCollector Collector module for cdc fudege calibration
CDCHitFilter Filter CDCHits
CDCInitialT0Determination Module to determine crude t0
CDCJobCntlParModifier Change job contorol parameters. Please put this module
in the path (before Geometry module) with specified
input parameters when you want to change them.
CDCPacker Generate RawCDC object from CDCHit
CDCRecoTrackFilter use this module to exclude Layers in fitting, after
TrackFinding
CDCT0CalibrationCollector Collector module for cdc T0 calibration
CDCUnpacker CDCUnpacker generates CDCHit from Raw data.
HitLevelInfoWriter Extract dE/dx information for calibration development.
ScanCDCGeo This module fills CDC geometry information in histo/tree
format to a root file
cdcDQM7 CDC DQM module
daq
CertifyParallel Not set by the author
DAQPerf Monitor DAQ transfer performance
DeSerializer Encode DataStore into RingBuffer
DeSerializerCOPPER Encode DataStore into RingBuffer
DeSerializerFILE Encode DataStore into RingBuffer
DeSerializerHLT Encode DataStore into RingBuffer
DeSerializerPC Encode DataStore into RingBuffer
DeSerializerPXD Receives PXD-Data from ONSEN (or a simulator) and stores
it as RawPXD in Data Store
DeSerializerPrePC Encode DataStore into RingBuffer
DesSerPrePCMain Not set by the author
DqmHistoManager Module to manage histograms/Ntuples/TTrees
Ds2Raw Encode DataStore into RingBuffer
Ds2RawFile Encode DataStore into RingBuffer
Ds2Rbuf Encode DataStore into RingBuffer
Ds2Sample Encode DataStore into RingBuffer
DummyDataSource an Example to pack data to a RawCOPPER object
DummyDataSourceFile an Example to pack data to a RawCOPPER object
ElapsedTime Encode DataStore into RingBuffer
EvReduction Encode DataStore into RingBuffer
FastRbuf2Ds Encode DataStore into RingBuffer
GenRawSend GenRawSendModule module
GetEventFromSocket Get Event from EvtSocket
HLTDQM2ZMQ Module to collect DQM histograms (written out by
HistoModules) and send them every time period to a
running ZMQ DQM server (either a finalhistoserver or a
proxyhistorver). The address as well as the send
interval are module parameters. As the old DQM module,
this module works by streaming everything in the current
ROOT main directory, which is either a TDirectory or a
TH1. For the specific implementation on how the
streaming is done, please see the HLTStreamHelper class.
The histogram sending is handled via a confirmed
connection (output in this case), so all the usual
conventions for a confirmed connection apply. This
module does only makes sense to run on the HLT, it is
not useful for local file writeout.
HLTDs2ZMQ On every event, serialize the data store and send the
binary data out to the connected ZMQ application (most
likely a collector or final collector). The sending is
handled via a confirmed connection (output in this
case), so all the typical behaviour applies. Also sends
out end run and termination messages. Depending on the
module setting, can send out events in raw format (with
send header and trailer and a serialized event message
as buffer) or only as normal ROOT serialized stream
(evt message). The former is the typical use case when
talking with e.g. storage, the latter can be used for
local tests or when sending full events e.g. to the
event display. Please note that the environment setting
of the stream objects heavily influences the time spent
in this module (because serialization needs time). This
module is only useful in the HLT context or for testing
it and it optimized to be used together with the
HLTEventProcessor. Please note the special handling of
the first event in the HLTEventProcessor (therefore we
do not stream the first event)
HLTDs2ZMQRaw On every event, serialize the data store and send the
binary data out to the connected ZMQ application (most
likely a collector or final collector). The sending is
handled via a raw connection (output in this case), so
all the typical behaviour applies. Also sends out end
run and termination messages. Depending on the module
setting, can send out events in raw format (with send
header and trailer and a serialized event message as
buffer) or only as normal ROOT serialized stream (evt
message). The former is the typical use case when
talking with e.g. storage, the latter can be used for
local tests or when sending full events e.g. to the
event display. Please note that the environment setting
of the stream objects heavily influences the time spent
in this module (because serialization needs time). This
module is only useful in the HLT context or for testing
it and it optimized to be used together with the
HLTEventProcessor. Please note the special handling of
the first event in the HLTEventProcessor (therefore we
do not stream the first event)
HLTZMQ2Ds Input module in the ZMQ reconstruction path receiving
events via ZMQ and deserializing the to the data store.
The connection to the previous ZMQ application (most
likely a distributor or collector) is handled via a load
balanced connection (input in this case). The buffer
size for the load balanced connection can be controlled
via a module parameter. This module only works in the
context of the HLT when using the HLTEventProcessor, due
to the special form the first event as well as beginRun
and endRun are handled. Please read the overall
description in the HLTEventProcessor for an overview.
Before the first real event is received (which is the
first time the event function is called by the
HLTEventProcessor, but before the forking), the event
meta data is initialized with a predefined experiment
and run number (set via module parameters) so make
module initialization in all other modules possible.
However, no event function should be called for other
modules in this event (as the data store is invalid). In
the first real event after the forking, the connection
and streamer is initialized. Then, normal event messages
are deserialized and written to data store. End run or
terminate messages are handled by setting a special
flag of the EventMetaData. Also in this case the
remaining modules should not process this event via an
event function (assured by the HLTEventProcessor).
MonitorData Monitor Raw Data
MonitorDataCOPPER Monitor Raw Data
PartialSeqRootReader Partial sroot file reader
Raw2Ds Encode DataStore into RingBuffer
RawInput Raw data file input module
Rbuf2Ds Encode DataStore into RingBuffer
Rbuf2Rbuf Encode DataStore into RingBuffer
ReceiveEvent Receive Event from ExpReco
Root2Raw Not set by the author
RxSocket Encode DataStore into RingBuffer
SeqRootMerger Not set by the author
Serializer Encode DataStore into RingBuffer
StorageDeserializer Storage deserializer module
StorageRootOutput Writes DataStore objects into a .root file. Data is
stored in a TTree 'tree' for event-dependent and in
'persistent' for peristent data. You can use RootInput
to read the files back into basf2.
StorageSerializer Storage serializer module
StorageZMQ2Ds Input module in the ZMQ reconstruction path receiving
events via ZMQ and deserializing the to the data store.
The connection to the previous ZMQ application (most
likely a distributor or collector) is handled via a load
balanced connection (input in this case). The buffer
size for the load balanced connection can be controlled
via a module parameter. This module only works in the
context of the HLT when using the HLTEventProcessor, due
to the special form the first event as well as beginRun
and endRun are handled. Please read the overall
description in the HLTEventProcessor for an overview.
Before the first real event is received (which is the
first time the event function is called by the
HLTEventProcessor, but before the forking), the event
meta data is initialized with a predefined experiment
and run number (set via module parameters) so make
module initialization in all other modules possible.
However, no event function should be called for other
modules in this event (as the data store is invalid). In
the first real event after the forking, the connection
and streamer is initialized. Then, normal event messages
are deserialized and written to data store. End run or
terminate messages are handled by setting a special
flag of the EventMetaData. Also in this case the
remaining modules should not process this event via an
event function (assured by the HLTEventProcessor).
TrackAna The simplest physics analysis
TxSocket Encode DataStore into RingBuffer
display
AsyncDisplay Starts the Display module asynchronously (with buffered
input). Note that the buffer is limited in size and not
all events can be passed to the display once it is full.
(Configurable using 'discardOldEvents' param).
Display Interactive visualisation of Monte Carlo, intermediate
and reconstructed objects, plus geometry. See https://so
ftware.belle2.org/|release|/sphinx/display/doc/index.htm
l for detailed documentation.
dqm
DAQMonitor This module produces general DAQ DQM histograms.
DQMHistAnalysisARICH Modify and analyze the data quality histograms of ARICH
DQMHistAnalysisARICHMonObj Example module for making MonitoringObject in
DQMHistAnalysis module
DQMHistAnalysisCDCDedx Module to draw and compute values related to dEdx for
CDC.
DQMHistAnalysisCDCEpics Histogram Analysis module base class
DQMHistAnalysisCDCMonObj Modify and analyze the data quality histograms of
CDCMonObj
DQMHistAnalysisDAQMonObj Module to monitor DAQ information.
DQMHistAnalysisDeltaEpicsMonObjExample Example module for using delta
histogramming and sending values to EPICS
DQMHistAnalysisDeltaTest Testing module for using delta histogramming
functionality.
DQMHistAnalysisECL Provide a large number of ECL DQM analysis histograms:
1. Normalize some low-level DQM histograms by the event
count.
2. Display time offsets for each ECL crate.
3. Display the number of failed fits in each ECL
module.
DQMHistAnalysisECLConnectedRegions Histogram Analysis module base class
DQMHistAnalysisECLOutOfTimeDigits Module to collect and process 'out of time'
ECL digits
DQMHistAnalysisECLShapers Processes information involving ECL pedestals (widths
and rms).
DQMHistAnalysisECLSummary Histogram Analysis module base class
DQMHistAnalysisEpicsEnable EPICS output enabler module
DQMHistAnalysisEpicsExample Example module for EPICS
DQMHistAnalysisEpicsOutput EPICS output enabler/flusher module
DQMHistAnalysisEventT0Efficiency Calculate EventT0 algorithm efficiencies for
the different trigger types, EventT0 algorithm sources,
and event types (hadron, bhabha, µµ).
DQMHistAnalysisEventT0TriggerJitter Determining and processing EventT0s from
different subdetectors (ECL, CDC, TOP, SVD) for
different L1 trigger sources (ECL, CDC, and TOP) to
estimate trigger jitter information for different HLT
event types (hadron, BhaBha, µµ).
DQMHistAnalysisExample Example DQMHistAnalysisModule! with base features
DQMHistAnalysisExampleFlags Example DQMHistAnalysisModules with how canvas flag
settings.
DQMHistAnalysisHLT Modify and analyze the data quality histograms of HLT
DQMHistAnalysisHLTMonObj Produces MonitoringObject for the HLT from the
available DQM histograms
DQMHistAnalysisInput2 Histogram Analysis module base class
DQMHistAnalysisInputPVSrv Histogram Analysis module base class
DQMHistAnalysisInputRootFile Histogram Analysis module base class
DQMHistAnalysisInputTest Testing input file functionality for
DQMHistAnalysisModules
DQMHistAnalysisKLM Module used to analyze KLM DQM histograms.
DQMHistAnalysisKLM2 Module used to analyze KLM Efficiency DQM histograms
(depends on tracking variables).
DQMHistAnalysisMiraBelle Modify and analyze the data quality histograms of
MiraBelle
DQMHistAnalysisMonObj Example module for making MonitoringObject in
DQMHistAnalysis module
DQMHistAnalysisOutputFile Module to save histograms from DQMHistAnalysisModules
DQMHistAnalysisOutputImages Module to produce output images during 'events' for
dqm steering scripts.
DQMHistAnalysisOutputMonObj Module to process run information.
DQMHistAnalysisOutputRelayMsg Histogram Analysis module base class
DQMHistAnalysisPXDCM DQM Analysis for PXD Common Mode
DQMHistAnalysisPXDCharge DQM Analysis for PXD Cluster Charge
DQMHistAnalysisPXDDAQ DQM Analysis for PXD DAQ Statistics and Issues
DQMHistAnalysisPXDER PXD DQM analysis module for Express Reco
DQMHistAnalysisPXDEff DQM Analysis for PXD Efficiency
DQMHistAnalysisPXDFits DQM Analysis for PXD Raw
DQMHistAnalysisPXDInjection DQM Analysis for PXD Hits after Injection
DQMHistAnalysisPXDReduction PXD DQM analysis module for ONSEN Data Reduction
Monitoring
DQMHistAnalysisPXDTrackCharge DQM Analysis for PXD Track-Cluster Charge
DQMHistAnalysisPeak Modify and analyze the peaking distributions in data
quality histograms
DQMHistAnalysisPhysics DQM Analysis for Physics histograms
DQMHistAnalysisRooFitExample Histogram Analysis module base class
DQMHistAnalysisRunNr DQM Analysis for RunNr/Mixing Check
DQMHistAnalysisSVD DQM base SVD Analysis.
DQMHistAnalysisSVDClustersOnTrack DQM Analysis Module that produces colored
canvas for a straightforward interpretation of the SVD
Data Quality.
DQMHistAnalysisSVDDose Monitoring of SVD Dose with events from Poisson trigger
w/o inj. veto. See also SVDDQMDoseModule.
DQMHistAnalysisSVDEfficiency DQM Analysis Module that computes the average SVD
sensor efficiency.
DQMHistAnalysisSVDGeneral DQM Analysis Module that produces colored canvas for a
straightforward interpretation of the SVD Data Quality.
DQMHistAnalysisSVDOccupancy DQM Analysis Module that produces colored canvas for
a straightforward interpretation of the SVD Data
Quality.
DQMHistAnalysisSVDOnMiraBelle DQM Analysis Module that extracts monitoring
variables from SVD DQM histograms and provides input to
MiraBelle.
DQMHistAnalysisSVDUnpacker DQM Analysis Module that produces colored canvas for
a straightforward interpretation of the SVD Data
Quality.
DQMHistAnalysisTOP Histogram analysis module for TOP DQM.
DQMHistAnalysisTRG Histogram Analysis module base class
DQMHistAnalysisTRGECL Module for DQM histogram analysis of ECL trigger Event
T0 DQM histograms
DQMHistAnalysisTRGEFF Modify and analyze the data quality histograms of TRGEFF
DQMHistAnalysisTRGGDL Modify and analyze the data quality histograms of TRGGDL
DQMHistAnalysisTrackingAbort DQM Analysis Module of the Tracking HLT Plots.
DQMHistAnalysisTrackingER DQM Analysis Module of the Tracking ER Plots.
DQMHistAnalysisTrackingHLT DQM Analysis Module of the Tracking HLT Plots.
DQMHistAnalysisV0 Histogram Analysis module base class
DQMHistAutoCanvas Histogram Analysis module base class
DQMHistComparitor Histogram Analysis module base class
DQMHistDeltaHisto Histogram Analysis module base class
DQMHistInjection Histogram Analysis module base class
DQMHistOutputToEPICS Histogram Analysis module base class
DQMHistReference Histogram Analysis module base class
DQMHistSnapshots Histogram Analysis module base class
DelayDQM Processing Delay DQM module
IPDQM Monitor the position and the size of the interaction
point using mu+mu- events
PhysicsObjectsDQM Monitor Physics Objects Quality
PhysicsObjectsMiraBelle Monitor Physics Objects Quality
PhysicsObjectsMiraBelleBhabha Monitor Physics Objects Quality
PhysicsObjectsMiraBelleDst Monitor Physics Objects Quality
PhysicsObjectsMiraBelleDst2 Monitor Physics Objects Quality
PhysicsObjectsMiraBelleEcmsBB Monitor of the CMS collision energy based on
hadronic B decays
PhysicsObjectsMiraBelleHadron Monitor Physics Objects Quality
V0ObjectsDQM Monitor displaced vertices
ecl
ECLBackground Processes background campaigns and produces histograms.
Requires HistoManager
ECLBhabhaTCollector This module generates sum of all event times per crystal
ECLCRFinder ECLCRFinderModule
ECLCRFinderPureCsI ECLCRFinderModule
ECLChargedPID The module implements charged particle identification
using ECL-related observables. For each Track matched
with a suitable ECLShower, likelihoods for each particle
hypothesis are obtained from pdfs stored in a conditions
database payload, and then get stored in an
ECLPidLikelihood object. The dimensionality of the
likelihood depends on how many variables are stored in
the payload. The baseline method could be a simple
univariate likelihood based on E/p PDFs, but it could be
extended to include more ECL quantities (e.g. shower
shape variables, w/ proper decorrelation).
ECLChargedPIDDataAnalysis This module produces an ntuple with ECL-related
quantities starting from mdst
ECLChargedPIDDataAnalysisValidation This module dumps a set of histograms with
ECL charged PID-related info used for validation,
starting from an input file w/ particle-gun-generated
charged stable particles (and antiparticles).
ECLChargedPIDMVA This module implements charged particle identification
using ECL-related observables via a multiclass MVA. For
each track a set of relevant ECL variables(shower shape,
PSD etc.) are fed to the MVA method which is stored in a
conditions database payload. The MVA output variables
are then used to construct a likelihood from pdfs also
stored in the payload. The likelihood is then stored in
the ECLPidLikelihood object.
ECLClusterPSD Module uses offline two component fit results to compute
pulse shape discrimation variables for particle
identification.
ECLClusterProperties This module calculates some properties of ECL clusters.
ECLCompressBGOverlay Compress recorded waveforms for beam background overlay
in simulation.
ECLCovarianceMatrix ECLCovarianceMatrix: Sets the ECL photon shower
covariance matrix.
ECLCovarianceMatrixPureCsI ECLCovarianceMatrix: Sets the ECL photon shower
covariance matrix.
ECLDQM Primary module for ECL Data Quality Monitor.
This module provides a large set of low-level
histograms: occupancy, time distribution, number of
saved waveforms, etc.
ECLDQMConnectedRegions ECL Data Quality Monitor to monitor ECL Connected
Regions
ECLDQMEXTENDED ECL Data Quality Monitor. Logic Test
ECLDQMInjection Monitor Occupancy after Injection
ECLDQMOutOfTimeDigits ECL Data Quality monitoring module. See header file for
the detailed description.
ECLDataAnalysis This module produces an ntuple with ECL-related
quantities starting from mdst
ECLDigiStudy EclCovMatrixNtuple: write ECL waveform and fitted time
and amplitude in a root file
ECLDigitCalibrator Applies digit energy, time and time-resolution
calibration to each ECL digit. Counts number of out-of-
time background digits to determine the event-by-event
background level.
ECLDigitCalibratorPureCsI Applies digit energy, time and time-resolution
calibration to each ECL digit. Counts number of out-of-
time background digits to determine the event-by-event
background level.
ECLDigitizer Creates ECLDigiHits from ECLHits.
ECLDigitizerPureCsI Creates ECLDigiHits from ECLHits for Pure CsI.
ECLDumpGeometry Print out location of every crystal
ECLEventT0 EventT0 calculated using ECLCalDigits
ECLFillCellIdMapping Fills a dataobject that provides mapping between cell id
and store arrays and neighbour maps
ECLFinalizer ECLFinalizerModule: Converts ecl shower dataobjects to
mdst eclcluster dataobjects
ECLFinalizerPureCsI ECLFinalizerModule: Converts ecl shower dataobjects to
mdst eclcluster dataobjects
ECLHitDebug ECLHitDebugModule
ECLLOM module to emulate Luminosity Online Monitor
ECLLocalMaximumFinder ECLLocalMaximumFinderModule
ECLLocalMaximumFinderPureCsI ECLLocalMaximumFinderModule
ECLLocalRunCalibrator ECL Local Run Calibration.
ECLMatchingPerformanceExpert Module to test the matching efficiency between
tracks and ECLClusters. Additionally, information about
the tracks are written into a ROOT file.
ECLPacker The module reads ECLDigits from the DataStore and writes
ECLRaw data.
ECLShowerCorrector ECLShowerCorrectorModule: Corrects energy of ECLShowers
and highest energy crystal for shower leakage, beam
backgrounds, and clustering
ECLShowerCorrectorPureCsI ECLShowerCorrectorModule: Corrects energy of
ECLShowers and highest energy crystal for shower
leakage, beam backgrounds, and clustering
ECLShowerShape ECLShowerShapeModule: Calculate ECL shower shape
variables (e.g. E9oE21)
ECLShowerShapePureCsI ECLShowerShapeModule: Calculate ECL shower shape
variables (e.g. E9oE21)
ECLSplitterN1 ECLSplitterN1Module: Baseline reconstruction splitter
code for the n photon hypothesis.
ECLSplitterN1PureCsI ECLSplitterN1Module: Baseline reconstruction splitter
code for the n photon hypothesis.
ECLSplitterN2 ECLSplitterN2Module: Baseline reconstruction splitter
code for the neutral hadron hypothesis.
ECLSplitterN2PureCsI ECLSplitterN2Module: Baseline reconstruction splitter
code for the neutral hadron hypothesis.
ECLTRGInformation Get ECL TRG energy information
ECLTrackBremFinder Use Track direction to pick up possible ECL Brem Cluster
ECLTrackCalDigitMatch Find ECLCalDigits closest to a track (this is *not* a
track to cluster matcher)
ECLTrackClusterMatching Creates and saves a Relation between Tracks and
ECLCluster in the DataStore. It uses the existing
Relation between Tracks and ExtHit as well as the
Relation between ECLCluster and ExtHit.
ECLTrackClusterMatchingParametrizationExpert Store ExtHit related infos for
track cluster matching
ECLTrackClusterMatchingPerformance Module to test the track cluster matching
efficiency. Writes information about the tracks and
MCParticles in a ROOT file.
ECLTriggerClusterMatcher Match ECLTRGClusters to ECLClusters
ECLTrimShowersAndDigits Create trimmed ECLCalDigit and ECLShower dataobjects
ECLUnpacker The module reads RawECL data from the DataStore and
writes the ECLDigit data
ECLWaveformFit Module to fit offline waveforms and measure hadron
scintillation component light output.
EclCovMatrixNtuple EclCovMatrixNtuple: write ECL waveform and fitted time
and amplitude in a root file
EclDisplay Event display module for ECL.
EclDisplayAsync Starts the Display module asynchronously (with buffered
input). Note that the buffer is limited in size and not
all events can be passed to the display once it is full.
(Configurable using 'discardOldEvents' param).
MCMatcherECLClusters MCMatcherECLClustersModule
MCMatcherECLClustersPureCsI MCMatcherECLClustersModule
eclAutocovarianceCalibrationC1Collector Module to export histogram of noise
level of ECL waveforms in delayed Bhabha events
eclAutocovarianceCalibrationC3Collector Module to compute covarience matrix
using waveforms from delayed Bhabha events
eclAutocovarianceCalibrationC4Collector Module to test covariance matrix
calibrations using waveforms from delayed Bhabha events
eclBhabhaTimeCalibrationValidationCollector This module validates the ECL
cluster times
eclCosmicECollector Calibration Collector Module for ECL single crystal
energy calibration using cosmic rays
eclEdgeCollector Obtain location of crystal edges from geometry and
ECLCrystalOffsetTheta and ECLCrystalOffsetPhi payloads.
eclGammaGammaECollector Calibration Collector Module for ECL single crystal
energy calibration using gamma gamma events
eclHadronTimeCalibrationValidationCollector This module validates the ECL
cluster times
eclLeakageCollector Store quantities from single photon MC used to
calculated ECL energy leakage corrections
eclMuMuECollector Calibration Collector Module for ECL single crystal
energy calibration using muons
eclNOptimalCollector Calibration collector module to find optimal number of
crystal for cluster energies
eclTimeShiftsPlottingCollector This module reads the crystal and crate time
offset information from the database
eclWaveformCalibCollector Module to export waveforms to ntuple for template
calibration.
eclWaveformTemplateCalibrationC1Collector Module to export histogram of baseline
noise of energetic waveforms from ee->gg events. First
step in photon template calculation.
eclWaveformTemplateCalibrationC2Collector Module to export waveforms from gamma
gamma events for waveform template calibrations
eclee5x5Collector Calibration Collector Module for ECL single crystal
energy calibration using Bhabha events
framework
EventErrorFlag Returns error flags of the EventMetaData and can add
further error flags.
EventInfoPrinter Prints the current event meta data information (exp,
run, event numbers). LogLevel need to be set to INFO, at
least for this module.
EventInfoSetter Sets the event meta data information (exp, run, evt).
You must use this module to tell basf2 about the number
of events you want to generate, unless you have an input
module that already does so. Note that all
experiment/run combinations specified must be unique.
EventLimiter Allows you to set limits on the number of events per run
passing this module. It returns True until the limit is
reached, after which it returns False. basf2 conditional
paths can then be used to prevent events continuing
onwards from this module.
Gearbox Loads the Belle II detector parameters from an XML
document.
HistoManager Manage histograms/Ntuples/TTrees for modules inheriting
from the HistoModule class. See
https://xwiki.desy.de/xwiki/rest/p/297bb for details.
Interactive Start an interactive (I)python shell in each call of
event(). Also imports the ROOT.Belle2 namespace for
convenience, allowing you to use Belle2.PyStoreArray
etc. directly.
IoVDependentCondition Module which sets its return value based on the fact, if
the event is in the given run/exp interval or not. If
you set the maximal value of experiment and run to -1,
there will be no upper limit for the interval. If you
only set the maximal run to -1, there is no upper limit
on the run number.
PartialSelect
This module helps you set the interval of events to
process. It
returns True inside the set window and False
outside.
The input parameters are fractions which can be
interpreted as the
fraction of leading and (1-)fraction of trailing
events that will be
skipped. Internally, the total number of events of
the input file is
used to determine the event selection window
boundaries.
basf2 conditional paths can then be used to select
events that pass
this module for further processing.
This module can be used with GRID jobs when dataset
collections are
passed as input. It helps you control the range of
events per file so
that you can avoid processing all of the events but
still cover all
the files in the collection.
NOTE: This module has to be added directly after the
input module so
as to filter out events before any other processing.
It also only
works with one input file for now.
Prescale Returns True or False randomly for each event. Fraction
of the time that True is returned is set by the
'prescale' parameter. You can use conditional basf2
paths to allow only the events that return True (or
False) to continue.
PrintBeamParameters Print the BeamParameters every time they change
PrintCollections Prints the contents of the DataStore in an event,
listing all objects and arrays (including size).
Profile Records execution time and memory usage in ProfileInfo
objects for each event. Can also graph memory usage.
Progress Periodically writes the number of processed events/runs
to the logging system to give a progress indication.
The output is logarithmic, meaning it will output the
first 10 events, then every tenth event up to 100, then
every hundreth event up to 1000, etc. Output cannot be
suppressed using set_log_level. If you don't want
messages, you don't want this module
ProgressBar
Display a progress bar and an estimate of remaining
time when number of
events is known (e.g. reading from file, or -n
switch used).
The progress bar uses stderr for its output, so it
works best when stdout
is piped to a file. However it should also work when
printing direct to a
terminal.
.. versionchanged:: release-03-00-00
the module now detects if it outputs to a
terminal or into a file and
will only update the bar if it has changed and
not use any control
characters to make log files much more readable
than before.
PruneDataStore
Clears the content of the DataStore while it keeps
entries listed in the matchEntries option.
The EventMetaData object will always be kept, as it
is required by the framework to properly
work with the DataStore.
This logic can be inverted to remove only the
entries matched by the regex
in the matchEntries parameter by setting the
parameter to
keepMatchedEntries to False.
Note:
Also all Relations will be cleared if they are
not matched by one entry
in the matchEntries list. You have to ensure the
objects referenced by
kept relations are also matched by one entry in
the keepEntries list so
a relation does not point to nirvana.
RandomBarrier Sets gRandom to an independent generator for the
following modules. E.g. a module chain of the sort
[ParticleGun -> RandomBarrier -> FullSim] would use one
RNG instance for the ParticleGun, and another for
FullSim and all following modules. You may find this
useful if you want to change the simulation, but don't
want differences to affect the particle generation. The
output is equivalent to saving the output of ParticleGun
in a file, and reading it again to do the simulation.
Correct separation is not provided for terminate(),
don't use random numbers there.
RootInput Reads objects/arrays from one or more .root files saved
by the RootOutput module and makes them available
through the DataStore. Files do not necessarily have to
be local, http:// and root:// (for files in xrootd) URLs
are supported as well.
RootOutput Writes DataStore objects into a .root file. Data is
stored in a TTree 'tree' for event-dependent and in
'persistent' for persistent data. You can use RootInput
to read the files back into basf2.
SeqRootInput Read .sroot files produced by SeqRootOutput.
SeqRootOutput Save a sequential ROOT file (non-standard I/O format
used in DAQ). See
https://xwiki.desy.de/xwiki/rest/p/401e7 for further
information and a comparison with the .root format.
StatisticsSummary Sums up the statistics of preceding modules. All modules
until the first module or another StatisticsSummary
module in the module statistics are included.
TheKiller This Modules kills basf2 as horribly as possible (or as
selected)
With this module you can kill basf2 in a variety of ways
to test what happens if processing is interrupted by
* std::abort()
* std::terminate()
* std::quick_exit()
* std::exit(N)
* uncaught exception
* signal
* segfault
* bus error
This error can occur in a selected event to test
behavior during processing.
generators
AafhInput AAFH Generator to generate non-radiative two-photon
events like e+e- -> e+e-e+e-
BBBremInput Generates low scattering angle radiative Bhabha events
(Beam-Beam Bremsstrahlung).
BHWideInput Generates radiative BhaBha scattering events with
BHWide.
BabayagaNLOInput Generates radiative Bhabha scattering and exclusive two-
photon events with the high precision QED generator
called BabaYaga@NLO.
BeamParameters Setting of beam parameters. This module allows to set
the beamparameters to be used by generators and
analysis. One can either select from a list of
predefined parameter sets or manually set the parameters
to use.
BoostMCParticles Module for boosting the MCParticles from CM to LAB
frame. The module must be appended to the path only when
HepMC, Hepevt or LHE input files are used.
CRYInput Generates cosmic showers with CRY.
The showers will be generated in the xz plane in a
square plane of n bt n meters
centered at the IP (n can be chosen with the boxLength
parameter). Then the
cosmics will be propagated from there to the boundary of
the detector world volume.
Finally, if the track would intersect with the
acceptance volume the track is
kept. The acceptance volume can be either a sphere, a
cylinder or a box centered
at the IP. This depends on how many values are given to
the acceptance parameter.
Cosmics cosmics generator to generate cosmic ray tracks
EventT0Generator Module generates discrete event t0 in ~4ns steps (bunch
spacing) according to double gaussian distribution and
adds it to the production and decay times of
MCParticles. This means that after this module the time
origin (t = 0) is set to what L1 trigger would give as
the collision time. In case of cosmics, the L1
triggerjitter is generated according to a continuous
double gaussian distribution
EventT0Shifter Shift the time of all MCParticles so that the collision
time is t=0.It reverts the shift done by the
EventT0Generator module and should be used after the
simulation.Note that the collisionTime in the
MCInitialParticles is not changed.
EvtGenDecay This module decays unstable particles using EvtGen. The
event should be already generated by another generator.
If you need to generate full event with EvtGen, then use
the module 'EvtGenInput'.
EvtGenInput EvtGenInput module. The module is served as an interface
for EvtGen Event Generator so that the EvtGen generator
can store the generated particles into MCParticles. The
users need to provide their own decay mode based on the
standard DECAY.DEC.
Fragmentation Fragmention of (u/d/s/c) quarks using PYTHIA8
GeneratedVertexDisplacer Takes a list of PDG values and lifetime parameters to
displaces the vertex of MCParticles with matching PDG
value corresponding to the given lifetime parameter. Can
be used betwenerator and the detector simulation.
GeneratorPreselection Preselection based on generator truth information.
Returns 0 if no cut have been passed, 1 if only the
charged cut has been passed, 10 if only the photon cut
has been passed, and 11 if both charged and photon cuts
have been passed.
GeneratorPreselectionLeptonic Filtering based on generator truth information.
Returns 0 if cuts have not been passed, 1 only if all
cuts are passed.
HepMCInput HepMC file input. This module loads an event record from
HEPMC2 format and store the content into the MCParticle
collection. HEPMC format is used by for example pythia8.
HepMCOutput HepMC file output. This module loads an event record
from the MCParticle collection and store the content
back into the HepMC (2) format. HepMC format is a
standard event record format to contain an event record
in a Monte Carlo-independent format.
HepevtInput HepEvt file input. This module loads an event record
from HEPEVT format and store the content into the
MCParticle collection. HEPEVT format is a standard event
record format to contain an event record in a Monte
Carlo-independent format.
HepevtOutput HepEvt file output. This module loads an event record
from the MCParticle collection and store the content
back into the HEPEVT format. HEPEVT format is a standard
event record format to contain an event record in a
Monte Carlo-independent format.
InclusiveParticleChecker
Check for the existence of one or more inclusive
particles in the list of
generated particles. If any of the particles is found
the event is accepted and
the return value is set to True. Otherwise the return
value is set to false.
The particles to look for can either be given as
numerical pdg codes or as
particle names or even as a mix of both:
>>> checker =
path.add_module("InclusiveParticleChecker", particles =
[11, "pi+"])
Valid names are defined in the ``evt.pdl`` of evtgen and
can be inspected using
either the `pdg` module or ``b2help-particles``.
This module is intended for inclusive signal generation
where we run a
generator which produces generic events and we require a
certain particle to be
present in the resulting list of particles.
KKGenInput KKGenInput module. This an interface for KK2f Event
Generator for basf2. The generated events are stored
into MCParticles. You can find an expample of its decay
file (tau_decaytable.dat) for tau-pair events at
${BELLE2_RELEASE_DIR}/data/generators/kkmc. On the other
hand, when you like to generate mu-pair events,
${BELLE2_RELEASE_DIR}/data/generators/kkmc/mu.input.dat
should be set to tauinputFile in your steering file.
KoralWInput Generates four fermion final state events with KoralW.
LHEInput LHE file input. This module loads an event record from
LHE format and store the content into the MCParticle
collection. LHE format is a standard event record format
to contain an event record in a Monte Carlo-independent
format.
OverrideGenerationFlags Override generation flags for BeamParameters from
database.
PairGen Simple module to generate tracks of given PDG back to
back in CMS.
ParticleGun
Particle gun to generate simple tracks.
This module allows to generate simple events where all
tracks have the same
momentum, angular and vertex distributions. Several
distributions are
available for momentum, phi, theta and vertex position
generation:
fixed:
Fixed value, only one parameter has to be specified
``[value]``
uniform:
Uniform between two given values
``[min, max]``
uniformPt:
Generate flat transverse momentum pt
``[min_pt, max_pt]``
uniformCos:
Generate uniformly in the cosine, e.g. flat in
cos(theta). Parameters are
still the minimum and maximum angle (**not the
cosine of the angle**)
``[min_theta, max_theta]``
uniformLog:
Generate uniformly in the logarithm. Parameters are
still the normal
values
``[min, max]``
uniformLogPt:
Like uniformLog but for the transverse momentum.
normal:
Normal (Gaussian) distributed
``[mean, width]``
normalPt:
Generate normal distributed transverse momentum pt
``[mean_pt, width_pt]``
normalCos:
Generate normal distributed cosine of the angle
``[mean, width]``
polyline:
Generate according to a pdf given as polyline, first
the sorted x
coordinates and then the non-negative y coordinates
``[x1, x2, x3, ... xn, y1, y2, y3, ..., yn]``
polylinePt:
Like polyline but for pt, not p
polylineCos:
Like polyline, but for the cos(), not the absolute
value
inversePt:
Generate uniformly in the inverse of pt, that is
uniform in track
curvature
``[min_pt, max_pt]``
discrete:
Discrete Spectrum given as a list of weights and
values (useful for
radioactive sources)
``[weight1, value1, weight2, value2, ...]``
discretePt:
same as above but for transverse momentum
PhokharaInput Generates radiative return events with PHOKHARA 10.
PrintTauTauMCParticles Print an MCParticle Collection
RemoveMCParticles
Remove particles from the MCParticle Collection.
Warning:
At the moment, Relations to that MCParticle collection
will become invalid
and are not fixed automatically
SADInput Reads the SAD data from a root file and stores it into
the MCParticle collection.
SmearPrimaryVertex Smears primary vertex and all subsequent vertices of all
the MCParticles using the information stored in
BeamParameters.
TeeggInput Generates events with TEEGG.
TouschekTURTLEInput Reads the Touschek data from a TURTLE file and stores it
into the MCParticle collection.
TrepsInput Input from TREPS generator (No-tag), Input from TREPS
generator for ee->ee hadrons
geometry
CreateFieldMap Create Field maps of the Belle II magnetic field used in
the simulation
DensityScaler Scale density of simulation/reconstruction geometry
This is obviously only meant for systematic studies to
scale the density in different
parts of the detector to estimate the effect on for
example tracking performance.
This module is to be placed **before** the Geometry
module itself and will then
change the density of all materials which are created
using the Materials service
Warning:
This doesn't affect any materials created manually
somewhere. A way to check is
to set a global scaling factor and then do a material
scan with the :b2:mod:`MaterialScan`
module split by materials. The scaled materials will
have a different name
starting with 'scaled:' followed by the scaling factor
and the original name
ExportGeometry Saves the Belle II detector geometry to a root or GDML
file. GDML support is only available if Geant4 has been
compiled with GDML enabled. This requires the xerces XML
parser headers to be installed when compiling the
externals
FBXWriter Write the detector geometry in a (semi-)hierarchical FBX
format.
Geometry Setup geometry description
OverlapChecker Checks the geometry for overlaps.
VRMLWriter Write the detector geometry in a hierarchical VRML
format.
hlt
CosmicRayHLTDQM Monitor reconstruction of cosmic ray on HLT
OnlineEventT0Creator Module to write the EventT0s computed on the online
systems (HLT). By default, this module is run only on
the online systems unless the user specifically requires
to execute it.
SoftwareTrigger Module to perform cuts on various variables in the
event. The cuts can be defined
by elements loaded from the database. Each cut is
executed and its result stored.
The return value of this module is a bool, which is
either true (accept the event) or false (reject it).
It is defined from the results of the cuts in the given
trigger menu, which are all evaluated
and the trigger mode (accept mode or not).
if not in accept mode (= reject mode):
* 1: if one of the accept cuts has a true result and
none of the reject cuts is false ( = accepted)
* 0: if neither one of the accept cuts is true nor one
of the reject cuts false ( = don't know) or
* if one of the reject cuts is false ( = rejected)
In short: event accepted <=> (#true accept cuts > 0) &&
(#false reject cuts == 0)
Please note that the reject cuts override the accept
cuts decision in this case!
if in accept mode
* 1: if one of the accept cuts has a true result. ( =
accepted) or
* if neither one of the accept cuts is true nor one
of the reject cuts false ( = don't know)
* 0: if one of the reject cuts is false and none of the
accept cuts is true ( = rejected)
Please note that the accept cuts override the reject
cuts decision in this case!
In short: event accepted <=> (#true accept cuts > 0) ||
(#false reject cuts == 0)
SoftwareTriggerHLTDQM Monitor Physics Trigger
SoftwareTriggerResultPrinter Write out the software trigger results in an easily
accessible summary table to disk.
StatisticsTimingHLTDQM Monitor reconstruction runtime on HLT
klm
BKLMAna analyze bklm efficiency associated to CDC, check
performance of bklm et al.
BKLMDigitAnalyzer Module useful to quickly analyze BKLM unpacked data.
BKLMSimHistogrammer Analyzes bg
BKLMTracking Perform standard-alone straight line tracking for BKLM
EKLMAlignmentAlongStripsCollector Module for EKLM alignment along strip (data
collection).
EKLMDataChecker EKLM data checker module.
KLMChannelStatusCollector Module for KLM channel status calibration (data
collection).
KLMClusterAna Module for extracting KLM cluster shape information via
PCA.
KLMClusterEfficiency Module for KLM cluster reconstruction efficiency
studies.
KLMClustersReconstructor Unified BKLM/EKLM module for the reconstruction of
KLMClusters.
KLMDQM KLM data quality monitor.
KLMDQM2 Additional Module for KLMDQM plots after HLT filters
An additional module developed to display plane
efficiencies for the KLM during runs (i.e. for online
analyses).
This module would be called after HLT filter in
order to use mumu-tight skim to select reasonable
events.
The output histograms would be plane efficiencies =
MatchedDigits/AllExtits.
KLMDigitTimeShifter Shift the time of KLMDigits according to the cable delay
corrections.
KLMDigitizer KLM digitization module: create KLMDigits from
KLMSimHits.
KLMPacker KLM raw data packer (creates RawKLM from KLMDigits).
KLMReconstructor Create BKLMHit1ds from KLMDigits and then create
KLMHit2ds from BKLMHit1ds; create KLMHit2ds from
KLMDigits.
KLMScintillatorSimulator Standalone generation and studies of ADC output.
KLMStripEfficiencyCollector Module for KLM strip efficiency data collection.
KLMTimeCollector Module for KLM time calibration (data collection).
KLMTracking Perform standard-alone straight line tracking for KLM.
KLMUnpacker KLM unpacker (creates KLMDigits from RawKLM).
MCMatcherKLMClusters Module for MC matching for KLM clusters.
masterclass
MasterClass Module to write out data in a format for Belle II
masterclasses
mdst
FixMergedObjects Fix indices of mdst objects (Tracks, V0s, MCParticles)
after DataStores were merged using an independent path.
mva
MVAExpert Adds an ExtraInfo to the Particle objects in given
ParticleLists which is calcuated by an expert defined by
a weightfile.
MVAMultipleExperts Adds ExtraInfos to the Particle objects in given
ParticleLists which is calcuated by multiple experts
defined by the given weightfiles.
MVAPrototype Prototype of a module which uses the MVA package
online_book
AWESOMEBasic Here you can enter a description of the module which can
be displayed during runtime.
pxd
ActivatePXDClusterPositionEstimator Initialization of
PXDClusterPositionEstimator
ActivatePXDGainCalibrator Initialization of PXDGainCalibrator
ActivatePXDPixelMasker Initialization of PXDPixelMasker
PXDBackground PXD background module
PXDBadSensorTag Mark bad-data PXD modules
PXDBeamBackHitFilter This module filters out from the BeamBackHits StoreArray
the BeamBackHits not related to PXD.
PXDBgTupleProducer PXD background tuple producer module
PXDClusterChargeCollector Calibration collector module for cluster charge
related calibrations.
PXDClusterCheck This Modules compares to sets of clusters and their
relations to make sure they are identical. Intended to
cross check Clusterizer. Default Collection names are
assumed for MCParticles, PXDTrueHits and PXDDigits
PXDClusterPositionCollector Calibration collector module for PXD cluster
position estimation
PXDClusterPropFilter The module produce a StoreArray of PXDClusters with
specific cuts on properties.
PXDClusterizer Cluster PXDHits
PXDClustersFromTracks PXDClustersFromTracks module for creating a new
StoreArray of track matched PXDCluster.
PXDDAQDQM Monitor DAQ errors
PXDDQMClusters PXD DQM clusters module Recommended Number of events for
monitoring is 40 kEvents or more to fill all histograms
PXDDQMCorr PXD DQM Correlation module
PXDDQMEfficiency Create basic histograms for PXD efficiency
PXDDQMEfficiencyNtuple Create basic histograms for PXD efficiency
PXDDQMEfficiencyNtupleSelftrack Create basic histograms for PXD efficiency
PXDDQMEfficiencySelftrack Create basic histograms for PXD efficiency
PXDDQMExpressReco PXD DQM module for Express Reco Recommended Number of
events for monitor is 40 kEvents or more to fill all
histograms
PXDDQMTrackRawNtuple Create tuple PXD trigger studies
PXDDigitSorter This module sorts the existing PXDDigits collection and
also updates the corresponding Relation to MCParticles
and TrueHits. This is needed for unsorted pixel data as
the Clusterizer expects sorted input.
PXDDigitizer Digitize PXDSimHits
PXDEventPlot Plot Events on PXD Hit/Charge Maps and write pictures
PXDGatedDHCDQM Monitor Gating after Injection
PXDGatedInfoFiller Fill Gates Mode Information from ... for Reconstruction
PXDGatedModeDQM Monitor GatedMode
PXDHotPixelMaskCollector Calibration Collector Module for PXD hot pixel masking
from digits
PXDInjectionDQM Monitor Occupancy after Injection
PXDInjectionVetoEmulator The module emulates the timing for gated mode operation
of PXD.
PXDMCBgTupleProducer PXD background tuple producer module
PXDPacker Pack PXD Hits to raw data object
PXDPackerErr Create 'broken' PXD raw data to challenge Unpacker
PXDPerformance PXD performance module
PXDPerformanceCollector Calibration collector module for CDST data.
PXDPerformanceVariablesCollector Calibration collector module for CDST data.
PXDPostErrorChecker PXD: Check Post Unpacking for DAQ errors
PXDROIDQM Monitor ROIs
PXDROIPlot Plot ROIs on PXD Hit/Charge Maps and write pictures
PXDRawDQM Monitor raw PXD
PXDRawDQMChips Monitor raw PXD
PXDRawDQMCorr PXD DQM Correlation module
PXDRawDumper Not set by the author
PXDRawHitMasking This module masks the input collection of PXDRawHits
into a PXDRawHit output collection
PXDRawHitSorter This module converts the input collection of PXDRawHits
into a collection of PXDDigits sorted, for each half-
ladder, by frame, row,and column.
PXDRawHotPixelMaskCollector Calibration Collector Module for PXD hot pixel
masking from rawhits
PXDReadRawBonnDAQ Read a BonnDAQ file and stores it as RawPXD in Data
Store
PXDReadRawBonnDAQMatched Read a BonnDAQ form file, match to current event and
stores it as RawPXD in Data Store
PXDReadRawONSEN Read a Raw PXD-Data Dump from ONSEN (or a simulator) and
stores it as RawPXD in Data Store
PXDSpacePointCreator Imports Clusters of the PXD detector and converts them
to spacePoints.
PXDTrackClusterDQM DQM for PXD Cluster matched to a Track
PXDTrackingEventLevelMdstInfoFiller This module adds additional global event
level information about PXD track finding to the MDST
object 'EventLevelTrackingInfo'
PXDUnpacker Unpack Raw PXD Hits from ONSEN data stream
PXDUnpackerOT Unpack Raw PXD Hits from ONSEN data stream
PXDUnpackerOld Unpack Raw PXD Hits from ONSEN data stream
rawdata
CheckErrorEvent Encode DataStore into RingBuffer
Convert2RawDet convert from RawCOPPER or RawDataBlock to RawDetector
objects
DummyDataPacker an Example to pack data to a RawCOPPER object
HexDataPacker an Example to pack data to a RawCOPPER object
MakeDumHSLBData Encode DataStore into RingBuffer
PrintData Encode DataStore into RingBuffer
PrintDataTemplate Encode DataStore into RingBuffer
PrintEventRate Not set by the author
Root2Binary Encode DataStore into RingBuffer
TTDDQM Monitor TTD Trigger and Injection
TTDUnpacker TTD Unpacker, unpacks first RawFTSW object
reconstruction
BeamSpotCollector Collect data for BeamSpot calibration algorithm using
the position of mu+mu- events
BeamSpotMonitor Module for the monitoring of the BeamSpot position and
size
BoostVectorCollector Collect data for BoostVector calibration algorithm using
the momenta of the mu+mu- events
ClusterMatcher Match KLM cluster to ECL Clusters within a certain cone.
DataWriter Used to write flat ntuple for KlId classifier trainings
for both ECL and KLM KlID. Output is a root file.
DetectorOccupanciesDQM DQM Module to monitor basic detector quantities
ECLExpert Use to calculate KlId for each ECL cluster.
EcmsCollector Collect data for eCMS calibration algorithm using the
momenta of the hadronic events
EventT0Combiner Module to combine the EventT0 values from multiple sub-
detectors
EventT0DQM Make data quality monitoring plots for EventT0 for
bhabha, mu mu, and hadron samples for different trigger
(time) sources.
EventT0Validation Make data quality monitoring plots for EventT0 for
bhabha, mu mu, and hadron samples for different trigger
(time) sources.
EventsOfDoomBuster
Module that flags an event destined for doom at
reconstruction,
* based on the size of selected hits/digits containers
after the unpacking.
* This is meant to be registered in the path *after* the
unpacking, but *before* reconstruction.
KLMExpert Use to calculate KlId for each KLM cluster.
KLMMuonIDDNNExpert Get information from KLMMuIDLikelihood
KlongValidation Module used by the validation server to generate root
files for the K0L validation. It calculates fake rates
and efficiencies.
MdstPID Create MDST PID format (PIDLikelihood objects) from
subdetector PID info.
PIDNtuple Writes a flat ntuple of PIDLikelihoods with track info
into a root file
VXDDedxPID Extract dE/dx and corresponding log-likelihood from
fitted tracks and hits in the SVD and PXD.
VXDDedxPIDRemaker Module that re-makes VXD PID likelihoods by taking dE/dx
stored in VXDDedxTracks and lookup table PDF's from DB.
simulation
FullSim Performs the full Geant4 detector simulation. Requires a
valid geometry in memory.
FullSimTiming Provide more detailed timing info for FullSim module
MaterialScan This Module is intended to scan the material budget of
the geometry. Currently, there are two different kinds
of scans available: Spherical and Planar scan.
Spherical scan will shoot rays from the origin of the
detector and scan along the polar and azimuth angle.
Planar scan will shoot rays perpendicular to a given
plane.
ROIfindingConditionFromDB Module which sets its return value based on the
payload whether ROI-finding was enabled for the given
run/exp interval or not.
SimulateEventLevelTriggerTimeInfo Simple module that registers the
EventLevelTriggerTimeInfo if not yet present
svd
SVD3SamplesEmulator This module takes the SVDShaperDigit as input and select
three consecutive samples starting from the one chosen
by the user. The modules creates a new StoreArray of the
class ShaperDigit with three samples only, selected from
the original ShaperDigits. The three samples are stored
in the first three positions of the APVSamples store
array, and the last three are set to 0.
SVD6SampleEventSkim Skim Module for the SVD 6-sample acquired events, in
either the 6-sample only or the 3-mixed-6 sample DAQ
modes.
SVDB4CommissioningPlots This module check performances of SVD reconstruction on
Commissioning data
SVDBackground SVD background module
SVDBeamBackHitFilter This module filters out from the BeamBackHits StoreArray
the BeamBackHits not related to SVD.
SVDChannelMapping SVD Channel Mapping Verification Module
SVDChargeSharingAnalysis Module for monitoring DSSD cluster charge deposition
SVDClusterCalibrationsMonitor Module to produce a list of histograms showing the
uploaded calibration constants
SVDClusterEvaluation This module check performances of SVD reconstruction of
VXD TB data
SVDClusterEvaluationTrueInfo This modules generates performance plots on SVD
clustering.
SVDClusterFilter generates a new StoreArray from the input StoreArray
which has all specified Clusters removed
SVDClusterQualityEstimator Assignment of probability for a cluster being
generated from signal hit.
SVDClusterQualityEstimatorCalibration Generate PDFs used in assigning quality to
clusterss.
SVDClusterTimeShifterCollector Collector module used to create the histograms
needed for the SVD 6-Sample CoG, 3-Sample CoG and
3-Sample ELS Time calibration. This is for the cluster-
size dependent correction of the calibrated time.
SVDClusterizer This module produces SVDClusters from SVDShaperDigits,
providing 1-D hit position, charge and time on SVD
sensors.
SVDCoGTimeEstimator From SVDShaperDigit to SVDRecoDigit. Strip charge is
evaluated as the max of the 6 samples; hit time is
evaluated as a corrected Centre of Gravity (CoG) time.
SVDCrossTalkCalibrationsCollector This module collects the list of channels
exhibiting crossTalk readout.
SVDCrossTalkFinder Detect SVDRecoDigits created from cross-talk present in
the origami sensors
SVDDQMClustersOnTrack SVD DQM module for clusters related to tracks.
SVDDQMDose The SVD dose-monitoring DQM module. Fills histograms of
the SVD's instantaneous occupancy and of SVD occupancy
vs time since last injection and time in beam revolution
cycle.
SVDDQMEfficiency Create basic histograms to compute the average sensor
efficiency.
SVDDQMExpressReco Original SVD DQM module for ExpressReco.
SVDDQMHitTime Make data quality monitoring plots for SVD Hit Time for
bhabha, mu mu, and hadron samples seeded by different
trigger times (ECL, CDC).
SVDDQMInjection Monitor SVD Occupancy after Injection.
SVDDataFormatCheck Checks the SVD data format:
SVDDatabaseTest The SVD Test Module for the database interface
SVDDigitizer Creates SVDShaperDigits from SVDSimHits
SVDEventInfoSetter Sets the SVD event information. Use this module to fill
SVDEventInfo object which tells the digitizer the
conditions for creating ShaperDigits.
SVDEventT0PerformanceTTree This module is used to create a TTree to study SVD
eventT0 using clusters associated to tracks.
SVDHotStripFinder The svdHotStripFinder module finds hot strips in SVD
data SVDShaperDigit
SVDLatencyCalibration this module performs an analysis to find the APV25
latency
SVDLocalCalibrationsCheck Module to produce a list of histograms showing the
uploaded calibration constants
SVDLocalCalibrationsMonitor Module to produce a list of histograms showing the
uploaded calibration constants
SVDMaxStripTTree The module is used to create a TTree to study the number
of strips per APV per event.
SVDMissingAPVsClusterCreator This module produces clusters in the middle of a
region read by a disabled APV. It can be run only after
the SVDClusterizer because it does not register the
SVDClusters StoreArray in the DataStore, but only add
clusters.
SVDOccupancyAnalysis This module check performances of SVD reconstruction of
VXD TB data
SVDOccupancyCalibrationsCollector This module collects hits from shaper digits
to compute per sensor SVD occupancy
SVDPacker Not set by the author
SVDPerformance This module check performances of SVD reconstruction of
VXD TB data
SVDPerformanceTTree The module is used to create a TTree to study SVD
clusters, genfit unbiased residuals and many other
properties related to the track they belong to.
SVDPositionErrorScaleFactorImporter Module to produce a list of histograms
showing the uploaded calibration constants
SVDRecoDigitCreator This module reconstructs SVDShaperDigit in SVDRecoDigit,
i.e. calibrated strip with reconstructed charge and
time.
SVDShaperDigitSorter This module sorts an existing SVDShaperDigits collection
and also updates the corresponding relations to
MCParticles and TrueHits. This is needed for background
overlay as the Clusterizer expects sorted input. The
module is otherwise not required for simulation or
reconstruction, as both SVDDigitzer and SVDUnpacker
output sorted digit collections.
SVDShaperDigitsFromTracks generates two new StoreArray from the input
StoreArray. One contains all ShaperDigits related to
Tracks and the other contains all SahperDigits not
related to tracks
SVDSimpleClusterizer Clusterize SVDRecoDigits fitted by the Center of Gravity
estimator
SVDSpacePointCreator Imports Clusters of the SVD detector and converts them
to spacePoints.
SVDSpacePointQICalibration Generate PDFs used in assigning quality to
SpacePoints.
SVDStripMasking Remove from the SVDShaperDigit list the hot strips read
in the SVDHotStripsCalibrations from the DB.
SVDTimeCalibrationCollector Collector module used to create the histograms
needed for the SVD 6-Sample CoG, 3-Sample CoG and
3-Sample ELS Time calibration
SVDTimeCalibrationsMonitor Module to produce a list of histograms showing the
uploaded calibration constants
SVDTimeGrouping Assigns the time-group Id to SVD clusters.
SVDTimeValidationCollector Collector module used to create the histograms needed
for the SVD 6-Sample CoG, 3-Sample CoG and 3-Sample ELS
Time calibration
SVDTrackingEventLevelMdstInfoFiller This module adds additional global event
level information about SVD track finding to the MDST
object 'EventLevelTrackingInfo'
SVDTriggerQualityGenerator Generates a StoreObjPtr that contains random trigger
quality chosen between FINE and COARSE
SVDUnpacker Produce SVDShaperDigits from RawSVD. NOTE: only zero-
suppressed mode is currently supported!
SVDUnpackerDQM DQM Histogram of the SVD Raw Data format.
SVDZeroSuppressionEmulator Filters out SVDShaperDigit with less than 1 (default)
sample is below a certain threshold, by default set at
SN = 3.
SVDdEdxCollector Collector module used to create the ROOT ntuples used to
produce dE/dx calibration payloads
SVDdEdxValidationCollector Collector module used to create the ROOT ntuples used
to produce dE/dx calibration payloads
svdDump Module to create SVD data file
top
OpticalGun Source of optical photons
TOPAligner Alignment of TOP
TOPAlignmentCollector A collector for geometrical alignment of a TOP module
with dimuons or Bhabhas. Iterative alignment procedure
(NIMA 876 (2017) 260-264) is run here, algorithm just
collects the results.
TOPAsicShiftsBS13dCollector A collector for calibration of carrier shifts of
BS13d.
TOPBackground A module to analyze beam background simulations
regarding TOP
TOPBunchFinder A precise event T0 determination w.r.t local time
reference of TOP counter. Results available in
TOPRecBunch.
TOPCalPulseGenerator Realistic generator of calibration double pulses. Needs
TOPDigitizer to digitize
TOPChannelMaskCollector A collector for preparing masks of dead and hot channels
TOPChannelMasker Masks dead, hot and uncalibrated channels from the
reconstruction
TOPChannelT0Calibrator Alternative channel T0 calibration with dimuons or
bhabhas. This module can also be used to check the
calibration (channel, module and common T0).
Note: after this kind of calibration one cannot do the
alignment.
TOPChannelT0MC TOP channel T0 Calibration of MC extraction
TOPCommonT0BFCollector A collector for common T0 calibration with a fit of
bunch finder residuals (method BF)
TOPCommonT0Calibrator Common T0 calibration with dimuons or bhabhas.
TOPCommonT0LLCollector A collector for common T0 calibration with dimuons or
Bhabha's using neg. log likelihood minimization (method
LL)
TOPCosmicT0Finder Event T0 finder for global cosmic runs
TOPDQM TOP DQM histogrammer
TOPDigitizer Digitize TOPSimHits
TOPDoublePulseGenerator Generator of calibration double pulses
TOPGainEfficiencyCalculator Calculate pixel gain and efficiency for a given PMT
from 2D histogram of hit timing and pulse charge,
created by TOPLaserHitSelectorModule.
TOPGeometryParInitializer Class for initializing TOPGeometryPar. This class is
by default initialized when Geant geometry is created.
Useful if Geant geometry is not needed. Be carefull when
using!
TOPInterimFENtuple Create ntuple mainly from TOPDigit with double pulse
identification. Data taken with both InterimFE FW and
production FW are available. (since Jan, 2017)
TOPLLScanner A module to perform the TOP PID likelihood scan and find
the actual minimum as function of the mass
TOPLaserCalibrator T0 Calibration using the laser calibration system
TOPLaserCalibratorCollector Collector module for the TOP ChannelT0 calibration
and the quality monitoring using laser and pulser data
TOPLaserHitSelector TOP pixel-by-pixel gain analysis - first step : create
hit timing-pulse charge histogram
TOPMCTrackMaker Constructs Tracks and ExtHits from MCParticles and
TOPBarHits. Utility needed for testing and debugging of
TOP reconstruction.
TOPModuleT0Calibrator Module T0 calibration with dimuons or bhabhas. Useful
when the geometrical alignment is fine.
TOPModuleT0DeltaTCollector A collector for module T0 calibration with chi2
minimization of time differences between slots (method
DeltaT). Useful for initial (rough) calibration, since
the results are found slightly biased. For the final
(precise) calibration one has to use LL method.
TOPModuleT0LLCollector A collector for module T0 calibration with neg. log
likelihood minimization (method LL). Aimed for the final
(precise) calibrationafter initial one with DeltaT
method.
TOPNtuple Writes ntuple of TOPLikelihoods with tracking info into
a root file
TOPOffsetCollector A collector for eventT0 and fill pattern offset
calibrations
TOPPDFChecker Module for checking analytic PDF used in likelihood
calculation
TOPPDFDebugger This module makes an analytic PDF available in a store
array TOPPDFCollections, related from Tracks
TOPPacker Raw data packer for TOP
TOPPhotonYieldsCollector A collector for photon pixel yields aimed for PMT
ageing studies and for finding optically decoupled PMT's
TOPPulseHeightCollector A collector for channel pulse-height distributions
TOPRawDigitConverter Converts row digits to digits and applies time
calibration
TOPReconstructor Reconstruction for TOP counter. Uses reconstructed
tracks extrapolated to TOP and TOPDigits to calculate
log likelihoods for charged stable particles
TOPRingPlotter A module to plot the x-t images from TOP, and in general
study the distribution of the digits associated to the
particles in a particleList
TOPTBCComparator TOP Time Base Correction monitor module
TOPTimeBaseCalibrator Sample time calibrator
TOPTimeRecalibrator Utility module for re-calibrating time of TOPDigits.
Useful for checking new calibrations on existing cDST
files. Note that pulseWidth and timeError are not
changed although they also depend on time calibration.
TOPTriggerDigitizer Digitizer that provides time stamps for TOP trigger
TOPUnpacker Raw data unpacker for TOP
TOPValidationCollector A collector for automatic validation of TOP calibration
TOPWaveformFeatureExtractor Module adds raw digits that are found in waveforms
but not already present in TOPRawDigits. Only waveforms
related to TOPRawDigits are used.
TOPWaveformQualityPlotter TOP DQM histogram module
TOPXTalkChargeShareSetter Crosstalk & chargeshare flag setter
tracking
AddVXDTrackCandidateSubSets Module that creates additional candidates that each
miss a different SpacePoint.
AsicBackgroundLibraryCreator Findlet: Finds suitable ASICs with a single hit
attached to a track and uses them to create the library
BestVXDFamilyCandidateSelector Module that selects the best candidate for each
SPTC family
BestVXDTrackCandidatesSelector Module that selects a subset with a fixed size x
out of all SpacePointTrackCandidates. Based on
qualityIndicator.
CDCCKFTracksCombiner Combine related tracks from CDC, determined in SVD->CDC
CKF, and VXD (and VXD+CDC) into a single track by
copying the hit information and combining the seed
information. The sign of the weight defines, if the hits
go before (-1) or after (+1) the CDC track.
CDCHitBasedT0Extraction Findlet: Extracts the T0 time of an event only using CDC
Hits
CDCToSVDSeedCKF Combinatorial Kalman Filter used for merging existing
CDC tracks and SVD tracks.
CDCToSVDSpacePointCKF Combinatorial Kalman Filter used for extrapolating CDC
tracks into SVD and create merged tracks.
CDCTrackingEventLevelMdstInfoFillerFromHits Findlet: This module adds additional
global event level information based on hits about CDC
track finding results to the MDST object
EventLevelTrackingInfo
CDCTrackingEventLevelMdstInfoFillerFromSegments Findlet: This module adds
additional global event level information based on 2D
segments about CDC track finding results to the MDST
object EventLevelTrackingInfo
Chi2BasedT0Extractor (no description)
Chi2MCTrackMatcher Monte Carlo matcher using the helix parameters for
matching by chi2-method
CollectorTest CollectorTest.
CosmicsTrackMerger Module linking tracks based on their Phi parameter.
CurlingTrackCandSplitter Module for checking SpacePointTrackCands for curling
behaviour and (if wanted) splitting them into
SpacePointTrackCands that no longer show curling
behaviour. WARNING: MODULE IS DEPRECATED use SPTCReferee
instead!
DAFRecoFitter DAF Fitter using Genfit. If you have TrackCands, you
have to convert them to RecoTracksusing the
RecoTrackCreatorModule first. After that, you probably
want to add the measurements from thehits using the
MeasurementCreatorModule. Default parameters are read
from the database.
DATCON DATCON module which implementation is close to the one
actually used on the FPGA. This requires some
simplifications, as well as tweaks as the FPGA only can
deal with integers, so as far as possible or reasonable
numbers in this module are represented as int / long
instead of double.
DriftLengthBasedT0Extractor (no description)
EffPlots This module makes some plots related to V0 and saves
them into a root file. For the efficiency plots:
_noGeoAcc -> normalized to MCParticles; _withGeoAcc ->
normalized to RecoTracks.
Ext Extrapolates tracks from CDC to outer detectors using
geant4e
FastBDTClassifierAnalyzer analyzes performance of given FastBDT on a test and a
training set and determines a global classification cut.
TODO
FastBDTClassifierTraining TODO
FillTrackFitNtuple This module fills a ntuple with tracking variables under
different hypotheses
FittedTracksStorer A module to copy only the fitted reco tracks to the
output store array.
FlipQuality This Module is meant to apply the (index 1 or 2) mva
based filter to determine if a recoTracks should be
flipped
FlippedRecoTracksMerger This module will check the 2 flipping QIs of one
RecoTrack and update the original RecoTrack, Track and
TrackFitResults if the flipped one should be taken
(according to the 2 flipping QIs)
FullGridChi2TrackTimeExtractor (no description)
FullGridDriftLengthTrackTimeExtractor (no description)
GFTC2SPTCConverter Module for converting genfit::TrackCands (e.g. from
TrackFinderMCTruth) to SpacePointTrackCands.
GenfitVis Visualize genfit::Tracks using the genfit::EventDisplay.
HitXP This module builds a TTree with true hit information
(momentum, position, PDGID, and track parameters hit per
hit) running over simulated and reconstructed events.
IPTrackTimeEstimator Module estimating the track time of RecoTracks - before
or after the fit. Loops over all RecoTracks and set
their time seed correctly. In case of using the fitted
information,it also sets the track seeds of the position
and momentum into the first measurement (where the time
seedis calculated). It also deletes all fitted
information. Do not forget to refit the tracks
afterwards.
KalmanRecoFitter Kalman Fitter using Genfit. If you have TrackCands, you
have to convert them to RecoTracksusing the
RecoTrackCreatorModule first. After that, you probably
want to add the measurements from thehits using the
MeasurementCreatorModule.
KinkFinder This is a Kink finder module which preselects mother and
daughter candidate tracks and matches them and fits a
vertex for each pair. Depending on the outcome of each
fit, a corresponding ``Belle2::Kink`` is stored or not.
The parameters of the ``KinkFinder`` are stored as
payloads in ``KinkFinderParameters``.
A loose cut on the pair is applied before the fit; then,
a vertex fit is performed, and only pairs passing a
chi^2 (``KinkFinderParameters::m_vertexChi2Cut``) and
distance (``KinkFinderParameters::m_vertexDistanceCut``)
are stored as ``Belle2::Kink``.
If a corresponding ``KinkFitter`` mode is ON, hits are
reassigned between mother and daughter tracks to improve
the resolutions and efficiency. If a corresponding
``KinkFitter`` mode is ON, the track pair is also fitted
as one track and a special flag is filled based on the
result to suppress the clones.
If a corresponding ``KinkFitter`` mode is ON,
``KinkFinder`` preselects track candidates that might be
formed from two kink tracks, and ``KinkFitter`` splits
such tracks. After that the result is stored in
``Belle2::Kink``.
MCPXDROICreator Create artificial ROI just for PXDDigits from all
charged primary MCParticles or just slow pions from D*
decays based on MC information.
MCRecoTracksMatcher This module compares reconstructed tracks generated by
some pattern recognition algorithm for PXD, SVD and/or
CDC to ideal Monte Carlo tracks and performs a matching
from the former to the underlying MCParticles.
MCRelationCreator Create relations between MC-matched RecoTracks in CDC
and SVD.
MCTrackCandClassifier This module is meant to classify the MCTrackCands as
either ideal, fine and nasty
MCV0Matcher A module matching the V0s found by the V0Finder with
MCParticles
MCVXDCDCTrackMerger This module merges tracks which are reconstructed,
separately, in the silicon (PXD+VXD) and in the CDC
using MC
MLSegmentNetworkProducer SegmentNetwork Producer Module with a machine learning
classifier as three hit filter.
Muid Identifies muons by extrapolating tracks from CDC to KLM
using geant4e
NoKickCutsEval This module evaluate cuts necessary for the selection of
reco tracks based on Multiple Scattering, NoKickRTSel
OverlapResiduals The module studies consecutive hits in overlapping
sensors of a same VXD layer, and the differences of
their residuals, to monitor the detector alignment.
PXDROIFinder This module performs the reduction of the PXD data
output
PXDROIFinderAnalysis This module performs the analysis of the PXDROIFinder
module output
PXDRawHitFilter The module produce a StoreArray of PXDRawHit inside the
ROIs.
PXDSVDCut The module to deactivate the SpacePointTrackCandidates
with less than *minSVDSPs* SVD SpacePoints.
PXDclusterFilter The module produce a StoreArray of PXDClusters
inside/overlapping any of the ROIs.
PXDdigiFilter The module produce a StoreArray of PXDDigit inside the
ROIs. A second StoreArray with PXDDigits outside the ROI
can be created on demand.
ParallelTrackFilter Generates a new StoreArray from the input StoreArray
which contains only tracks that meet the specified
criteria.
PhaseSpaceAnalysis Module for analysing the phase space covered by
TrackCands (resp. their related MCParticles)
PlaneTriggerTrackTimeEstimator Module estimating the track time of RecoTracks -
before or after the fit. Loops over all RecoTracks and
set their time seed correctly. In case of using the
fitted information,it also sets the track seeds of the
position and momentum into the first measurement (where
the time seedis calculated). It also deletes all fitted
information. Do not forget to refit the tracks
afterwards.
PruneGenfitTracks Prunes genfit tracks
PruneRecoHits Prunes RecoHits, which are marked to be pruned.
PruneRecoTracks Prunes RecoTracks.
QualityEstimatorVXD The quality estimator module for
SpacePointTrackCandidates.
ROIDQM Monitor of the ROI creation on HLT
ROIGenerator This module is used to generate a certain number of ROIs
ROIPayloadAssembler This module assembles payload for the ROI in the correct
format to be sent to the ONSEN
ROIReadTest check the payload produced by the ROIPayloadAssembler
Module
ROISender Send the ROI payload to the external ring buffer
RT2SPTCConverter Module for converting RecoTracks (e.g. from
TrackFinderMCTruth) to SpacePointTrackCands.
RadiusTrackTimeEstimator Module estimating the track time of RecoTracks - before
or after the fit. Loops over all RecoTracks and set
their time seed correctly. In case of using the fitted
information,it also sets the track seeds of the position
and momentum into the first measurement (where the time
seedis calculated). It also deletes all fitted
information. Do not forget to refit the tracks
afterwards.
RawSecMapMerger this module takes a root file containing a raw sectorMap
created by the SecMapTrainerBaseModule and converts it
to a sectormap which can be read by the VXDTF. Please
check the parameters to be set...
ReattachCDCWireHitsToRecoTracks
Module to loop over low-ADC/TOT CDCWireHits and
RecoTracks
and reattach the hits to the tracks if they are closer
than a given distance.
RecoTrackCreator Converts the given genfit::TrackCands in the StoreArray
to RecoTracks for further use in the fitter.
RecoTrackParticleLoader Takes fitted RecoTracks and creates Particles from them
directly, skipping the step of creating Tracks and
TrackFitResults.
RecoTrackStoreArrayCombiner Combine two collections of tracks without additional
checks.
RecoTracksCopier Copies RecoTracks without their fit information.
RecoTracksReverter Revert the RecoTracks, including changing of the seed
position, reverting the momentum and revising the hits
Order
RegisterEventLevelTrackingInfo Simple module that registers the
EventLevelTrackingInfo that is used to set general
tracking-related flags
RelatedTracksCombiner Combine related tracks from CDC and VXD into a single
track by copying the hit information and combining the
seed information. The sign of the weight defines, if the
hits go before (-1) or after (+1) the CDC track.
SPTC2GFTCConverter Module for converting SpacePointTrackCand to
genfit::TrackCand.
SPTC2RTConverter Converts the given SpacePointTrackCandidates to
RecoTracks and stores them in the given
RecoTracksStoreArray
SPTCReferee Module that does some sanity checks on
SpacePointTrackCands to prevent some problematic cases
to be forwarded to other modules that rely on
'unproblematic' cases (e.g. FilterCalculator). Different
checks can be enabled by setting the according flags.
Using MC information for the tests can also be switched
on/off for tests where MC information can be helpful.
SPTCmomentumSeedRetriever A module for creating momentum seeds for spacepoint
track candidates.
SPTCvirtualIPRemover The quality estimator module for
SpacePointTrackCandidates using a circleFit.
SVDEventT0Estimator This module estimates the EventT0 as the average of
cluster time of SVD clusters associated to tracks. The
EventT0 is set to NaN if there are not RecoTracks or
there are not SVD clusters associated to tracks or
RecoTrack pt < ptMin OR RecoTrack pz < pzMin. The
EventT0 estimated is added to the temporaryEventT0s to
the StoreObjPtr as EventT0Component that contains:
eventT0, eventT0_error, detector=SVD, algorithm,
quality.
SVDHoughTracking Full Hough Transformation based SVD track finding.
SVDOverlapResolver Module checks for overlaps of SpacePointTrackCands
SVDROIDQM Monitor of the ROIs creation on HLT
SVDROIFinder This module finds the ROI on the SVD planes
SVDROIFinderAnalysis This module performs the analysis of the SVDROIFinder
module output
SVDROIFinderAnalysisData This module performs the analysis of the SVDROIFinder
module output ON DATA
SVDShaperDigitFilter The module produce a StoreArray of SVDShaperDigit inside
the ROIs.
SecMapTrainerBase this module analyzes a big number of events (pGun or
evtGen) to create raw sectorMaps which are needed for
the VXDTF 2.0. This information will be exported via
root files.
SecMapTrainerVXDTF this module analyzes a big number of events (pGun or
evtGen) to create raw sectorMaps which are needed for
the VXDTF. This information will be exported via root
files.
SectorMapBootstrap Create the VXDTF SectorMap for the following modules.
SegmentNetworkAnalyzer Module for analyzing the SegmentNetwork.
SegmentNetworkProducer The segment network producer module.
This module takes a given sectorMap and storeArrays of
spacePoints and creates a activeSectorNetwork, a
trackNodeNetwork and a segmentNetwork.These are filled
and stored in a StoreObjPtr of
DirectedNodeNetworkContainer:
SetupGenfitExtrapolation Sets up material handling for genfit extrapolation.
Also setups up I/O streams for genfit in order to
integrate it into basf2 logging system. Also sets up
update of VXDAlignment from DB (temporary).
SpacePoint2TrueHitConnector Module that tries to find the appropriate TrueHit to
each SpacePoint and to register a relation between them
for making MC information for SpacePoints more easily
accessible for Modules that need it. Module can also be
used to filter out 'fishy' SpacePoints.
SpacePointCreatorTest Tester module for the validity of the
SpacePointCreatorModule. TODO: at the moment, the
genfit-output can only verified visually (by checking,
whether the detector types match the number of
dimensions stored in the trackPoint)! when full reco
chain is working, this testerModule should be extended!
-> verification that input cluster(s) is/are converted
to genfit-stuff shall be resilient!
StandardTrackingPerformance Module to test the tracking efficiency. Writes
information about the tracks and MCParticles in a ROOT
file.
StudyMaterialEffects StudyMaterialEffects- should be used with single track
pGuns and without magnetic field.
TCConvertersTest Module for testing the functionality of the TrackCand
converter modules and their underlying classes.
TFCDC_AxialSegmentPairCreator Findlet: Creates axial axial segment pairs from a
set of segments filtered by some acceptance criterion
TFCDC_AxialStraightTrackFinder Findlet: Performs a search for straight tracks
coming from IP and ending in an ECL cluster
TFCDC_AxialTrackCreatorMCTruth Findlet: Constructs tracks from wire hits using
the MC truth information.
TFCDC_AxialTrackCreatorSegmentHough Findlet: Generates axial tracks from
segments using a hough space over phi0 impact and
curvature for the spares case.
TFCDC_AxialTrackFinderHough Findlet: Generates axial tracks from hits using
several increasingly relaxed hough space search over
phi0 and curvature.
TFCDC_AxialTrackFinderLegendre Findlet: Performs the pattern recognition in the
CDC with the Legendre hough finder
TFCDC_ClusterBackgroundDetector Findlet: Marks clusters as background if the
used filter detects them as such
TFCDC_ClusterPreparer Findlet: Clusters the wire hits in the CDC to form
locally connected groups with two granularities.
TFCDC_ClusterRefiner Findlet: Breaks bigger wire hit super cluster into
smaller wire hit clusters
TFCDC_FacetCreator Findlet: Creates hit triplet (facets) from each cluster
filtered by a acceptance criterion.
TFCDC_HitReclaimer Findlet: A small findlet that removes flags from hits
not accepted by conventional tracking.
TFCDC_MonopoleAxialTrackFinderLegendre Findlet: Performs the pattern recognition
in the CDC with the legendre looking for straight tracks
TFCDC_MonopoleStereoHitFinder Findlet: Tries to add CDC stereo hits to the found
CDC tracks by applying a histogramming method with a 3D
hough tree looking for hyperbolic cosines.
TFCDC_MonopoleStereoHitFinderQuadratic Findlet: Tries to add monopole CDC stereo
hits to the found CDC tracks by applying a histogramming
method with a quad tree.
WARNING This findlet is kept here just in case
hyperbolic one misbehaves and eats up too much RAM
If it doesn't, this one should be removed around
release-05 or earlier
TFCDC_SegmentCreatorFacetAutomaton Findlet: Constructs segments by extraction of
facet paths in a cellular automaton.
TFCDC_SegmentCreatorMCTruth Findlet: Constructs segments from wire hits using
the mc truth information.
TFCDC_SegmentFinderFacetAutomaton Findlet: Generates segments from hits using a
cellular automaton build from hit triples (facets).
TFCDC_SegmentFitter Findlet: Fits each segment with a selectable method
TFCDC_SegmentLinker Findlet: Links segments by extraction of segment paths
in a cellular automaton.
TFCDC_SegmentOrienter Findlet: Fixes the flight direction of segments to a
preferred orientation by simple heuristics.
TFCDC_SegmentPairCreator Findlet: Creates axial stereo segment pairs from a set
of segments filtered by some acceptance criterion
TFCDC_SegmentRejecter Findlet: Deletes fake segments that have been rejected
by a filter
TFCDC_SegmentTrackCombiner Findlet: Findlet for the combination of tracks and
segments.
TFCDC_SegmentTripleCreator Findlet: Creates segment triples from a set of middle
segments and already combined axial segment pairs
filtered by some acceptance criterion
TFCDC_StereoHitFinder Findlet: Tries to add CDC stereo hits to the found CDC
tracks by applying a histogramming method with a quad
tree.
TFCDC_SuperClusterCreator Findlet: Groups the wire hits into super cluster by
expanding the secondary wire neighborhood
TFCDC_TrackCombiner Findlet: Combines two sets of tracks to one final set by
merging tracks that have large overlaps.
TFCDC_TrackCreatorSegmentPairAutomaton Findlet: Constructs tracks by extraction
of segment pair paths in a cellular automaton.
TFCDC_TrackCreatorSegmentTripleAutomaton Findlet: Constructs tracks by
extraction of segment triple paths in a cellular
automaton.
TFCDC_TrackCreatorSingleSegments Findlet: Creates a track for each segments that
is yet unused by any of the given tracks.
TFCDC_TrackExporter Findlet: Creates a RecoTrack from each CDCTrack.
TFCDC_TrackFinder Combined track finder using the global legendre finder
as well as the cellular automaton track finder.
TFCDC_TrackFinderAutomaton Performs pattern recognition in the CDC based on
local hit following and application of a cellular
automaton in two stages.
TFCDC_TrackFinderCosmics Performs pattern recognition in the CDC based on local
hit following and application of a cellular automaton in
two stages - version suitable for cosmics.
TFCDC_TrackFinderSegmentPairAutomaton Findlet: Generates tracks from segments
using a cellular automaton built from segment pairs.
TFCDC_TrackFinderSegmentTripleAutomaton Findlet: Generates tracks from segments
using a cellular automaton built from segment triples.
TFCDC_TrackFlightTimeAdjuster Findlet: Adjusts the flight time of tracks
relative to the flight time zero location
TFCDC_TrackLinker Findlet: Links tracks by extraction of track paths in a
cellular automaton.
TFCDC_TrackOrienter Findlet: Fixes the flight direction of tracks to a
preferred orientation by simple heuristics.
TFCDC_TrackQualityAsserter Findlet: Many tracks in the CDC can not be fitted.
For fitting them, we remove parts of the hits or maybe
the whole track.
TFCDC_TrackQualityEstimator Findlet: Set the quality indicator for CDC tracks
and, if desired, delete tracks with a too low quality
value.
TFCDC_TrackRejecter Findlet: Deletes fake tracks that have been rejected by
a filter
TFCDC_WireHitBackgroundDetector Findlet: Marks hits as background based on the
result of a filter.
TFCDC_WireHitCreator Findlet: Combines the geometrical information and the
raw hit information into wire hits, which can be used
from all modules after that
TFCDC_WireHitPreparer Findlet: Combine the CDCHits from the DataStore with the
geometry information.
ToCDCCKF Combinatorial Kalman Filter used for extrapolating SVD
tracks into CDC and create merged tracks.
ToCDCFromEclCKF Combinatorial Kalman Filter used for extrapolating ECL
showers into CDC and create merged tracks.
ToPXDCKF Combinatorial Kalman Filter used for extrapolating
SVD/CDC tracks into PXD and create merged tracks.
TrackCreator Build Tracks with the TrackFitResults. Needs RecoTracks
as input, creates Belle2::Tracks and
Belle2::TrackFitResults as output.
TrackDQM DQM of finding tracks, their momentum, Number of hits in
tracks, Number of tracks.
TrackFilter generates a new StoreArray from the input StoreArray
which has all specified Tracks removed
TrackFinderMCTruthRecoTracks Uses the MC information to create
genfit::TrackCandidates for primary MCParticles and
Relations between them. Fills the created
genfit::TrackCandidates with all information (start
values, hit indices) needed for the fitting.
TrackFinderVXDAnalizer analyzes quality of SpacePointTrackCands delivered by a
test-TF compared to a reference TF
TrackFinderVXDBasicPathFinder The TrackFinderVXD BasicPathFinder module.
It uses the output produced by the
SegmentNetworkProducerModule to
createSpacePointTrackCands by simply storing all
possible paths stored in the SegmentNetwork.
TrackFinderVXDCellOMat The TrackFinderVXD Cell-O-Mat module.
It uses the output produced by the
SegmentNetworkProducerModule to
createSpacePointTrackCands using a Cellular Automaton
algorithm implementation.
TrackFinderVXDCosmicsStandalone The TrackFinderVXDCosmicsStandalone module.
TrackQETrainingDataCollector Module to collect training data for a specified
qualityEstimator and store it in a root file.
TrackQualityEstimatorMVA The quality estimator module for a fully reconstructed
track
TrackSetEvaluatorGreedyDEV Expects a container of SpacePointTrackCandidates,
selects a subset of non-overlapping TCs using the Greedy
algorithm.
TrackSetEvaluatorHopfieldNNDEV This module expects a container of
SpacePointTrackCandidates and an OverlapNetwork
and thenselects a subset of non-overlapping TCs
determined using a neural network of Hopfield type.
TrackTimeEstimator Computes the track time, defined as the difference
between the average of SVD clusters time and the
SVDEvent T0
TrackToMCParticleRelator A module to set relations from Track to MCParticle via
the RecoTrack the Track is related to. The functionality
is: Take Track, get relation to RecoTrack, from
RecoTrack get relation to MCParticle, and finally add a
relation from Track to MCParticle.
TrackingAbortDQM DQM Module to monitor Tracking Aborts and detector-
related quantities.
TrackingExpressRecoDQM Data Quality Monitoring of the tracking run on
ExpressReco.
TrackingHLTDQM Data Quality Monitoring of the tracking run on HLT.
TrackingPerformanceEvaluation This module evaluates the tracking package
performance
V0Finder This is a simple V0 finder for X = Ks, Lambda and
converted photons which matches all positive tracks with
all negative tracks, fitting a vertex for each pair.
Depending on the outcome of each fit, a corresponding
Belle2::V0 is stored or not.
A loose cut on the invariant mass (``massRangeX``) is
applied before the fit (not considering material
effects), then a vertex fit is performed and only pairs
passing a chi^2 (``vertexChi2CutOutside``) and a second
cut on the invariant mass (``invMassRangeX``) are stored
as Belle2::V0.
No V0s with vertex inside the beam pipe are saved as
they can be recovered at analysis level.
V0findingPerformanceEvaluation This module evaluates the V0 finding package
performance
VXDCDCTrackMerger This module merges tracks which are reconstructed,
separately, in the silicon (PXD+VXD) and in the CDC
VXDQETrainingDataCollector Module to collect training data for the
VXDQualityEstimatorMVA and store it in a root file.
VXDQualityEstimatorMVA The quality estimator module for
SpacePointTrackCandidates.
VXDSimpleClusterizer The VXDSimpleClusterizerModule generates PXD/SVD
Clusters using TrueHits. Energy-deposit threshold and
gaussian smearing can be chosen, non-primary-particles
can be filtered as well. Its purpose is fast
clusterizing for tracking test procedures, using
standardized PXD/SVD-Cluster
VXDTFTrainingDataCollector This module collect the data needed to train the
VXDTF sector map. The data are saved on a root file that
eventually will be chained and used by the training
module.
VXDTrackCandidatesQualityIndicatorCutter Module that selects a subset out of all
SpacePointTrackCandidates. Based on qualityIndicator
requirement.
trg
CDCTrigger2DFinder Hough tracking algorithm for CDC trigger.
CDCTrigger2DFitter The 2D fitter module of the CDC trigger.
Performs a circle fit on a given set of axial
CDCTriggerSegmentHits.
Requires a preceding track finder to sort hits to
tracks.
CDCTrigger3DFitter The 3D fitter module of the CDC trigger.
1. Selects stereo hits around a given 2D track by Hough
voting
2. Performs a linear fit in the s-z plane (s: 2D
arclength).
CDCTriggerETF The Event Time Finder module of the CDC trigger.
Uses fastest time of CDCTriggerSegmentHits to find the
event time.
CDCTriggerHoughETF Hough tracking algorithm for CDC trigger.
CDCTriggerMCMatcher A module to match CDCTriggerTracks to MCParticles.
Creates an array MCTracks of trackable MCParticles and
makes relations from MCTracks to CDCTriggerTracks and
vice-versa.
CDCTriggerNDFinder CDC Trigger NDFinder Module.
Implements a 3D Hough transformation for
3D track finding in omega, phi, theta.
Uses trained hit patterns for axial and
stereo TS and a density based clustering
algorithm.
CDCTriggerNeuro The NeuroTrigger module of the CDC trigger.
Takes track segments and 2D track estimates as input and
estimates
the z-vertex for each track using a neural network.
Requires one or several trained networks stored in a
file.
CDCTriggerNeuroDQM CDC Trigger DQM module
CDCTriggerNeuroDQMOnline CDC Trigger DQM Online module for HLT/Expressreco
CDCTriggerNeuroData This module takes 2dtracks, track segments, and
targettracks (either recotracks or mcparticles) as input
and generates training data for the neurotrigger in a
tab separated, gzip compressed file.
CDCTriggerNeuroIDHist description
CDCTriggerRecoHitMatcher A module to match CDCTriggerTracks to RecoTracks.
First makes relations from RecoTracks to
CDCTriggerSegmentHits, then makes relations from
RecoTracks to CDCTriggerTracks and vice-versa.
CDCTriggerRecoMatcher A module to match CDCTriggerTracks to RecoTracks.
First makes relations from RecoTracks to
CDCTriggerSegmentHits, then makes relations from
RecoTracks to CDCTriggerTracks and vice-versa.
CDCTriggerTSF The Track Segment Finder module of the CDC trigger.
Combines CDCHits from the same super layer to
CDCTriggerSegmentHits.
CDCTriggerTSFFirmware Firmware simulation of the Track Segment Finder for CDC
trigger.
CDCTriggerTrackCombiner The combiner module of the CDC trigger.
Takes tracks from the various trigger stages (finder,
fitter, neuro) and combines them to a single track list.
The 2D track parameters are taken from the fitter, if
present. For the 3D track parameters there are different
options (see parameters). Combined tracks are not
produced for tracks without 3D information from either
3D fitter or neuro.
CDCTriggerUnpacker Unpack the CDC trigger data recorded in B2L
GRLNeuro The NeuroTrigger module of the GRL.
Takes CDC track and ECL cluster to prepare input data
for the training of a neural network.
Networks are trained after the event loop and saved.
GRLNeuroTrainer The NeuroTriggerTrainer module of the GRL.
Takes CDC track and ECL cluster to prepare input data
for the training of a neural network.
Networks are trained after the event loop and saved.
KLMTrigger KLM trigger simulation
MCMatcherTRGECL MCMatcherTRGECLModule
TRGCDC TRGCDCModule(TRGCDCModule 5.07)
TRGCDCETFUnpacker TRGCDCETFUnpackerModule(1.00)
TRGCDCT2DDQM DQM for CDCT2D Trigger system
TRGCDCT3DConverter TRGCDCT3DConverterModule(1.00)
TRGCDCT3DDQM DQM for CDCT3D Trigger system
TRGCDCT3DUnpacker TRGCDCT3DUnpackerModule(1.10)
TRGCDCTSFDQM DQM for CDCTSF Trigger system
TRGCDCTSFUnpacker TRGCDCTSFUnpackerModule(1.00)
TRGCDCTSStream TRGCDCTSStreamModule(TRGCDCTSStreamModule 0.00)
TRGECL TRGECLModule(TRGECLModule 1.00)
TRGECLBGTCHit TRGECLBGTCHitModule(TRGECLBGTCHitModule 1.00)
TRGECLDQM DQM for ECL Trigger system
TRGECLEventTimingDQM ECL trigger event timing histograms
TRGECLFAM TRGECLFAMModule(TRGECLFAMModule 1.00)
TRGECLQAM TRGECLQAMModule(TRGECLQAMModule 1.00)
TRGECLRawdataAnalysis TRGECLRawdataAnalysisModule(TRGECLAnalysisModule 1.00)
TRGECLTimingCal example module for TRGECL timing calibration
TRGECLUnpacker TRGECLUnpackerModule(4.02)
TRGEFFDQM Make kinematics dependent efficiency plot
TRGGDL TRGGDLModule(TRGGDLModule 0.00)
TRGGDLCosmicRun Module that returns true, if the trigger condition for
the 2017 cosmic runs is fulfilled.
trigger conditions:
with back-to-back: two back-to-back track segments in
superlayer 2 plus one ECL hit
without back-to-back: on track segment in superlayer 2
plus one ECL hit
TRGGDLDQM DQM for GDL Trigger system
TRGGDLDST Fill experiment data to TRGGDLDST
TRGGDLSummary Fill experiment data to TRGSummary
TRGGDLUnpacker TRGGDLUnpackerModule(1.00)
TRGGRL TRGGRLModule(TRGGRLModule 0.00)
TRGGRLDQM DQM for GRL Trigger system
TRGGRLInjectionVetoFromOverlay Module for adding to MC samples the information
about the TRG injection veto from beam background
overlay files.
TRGGRLMatch match CDC trigger tracks and ECL trigger clusters
TRGGRLProjects TRGGRLProjectsModule
TRGGRLUnpacker TRGGRLUnpackerModule(1.00)
TRGRAWDATA TRG rawdata analyser
TRGTOPDQM DQM for TOP Trigger subsystem
TRGTOPTRD2TTSConverter TRGTOPTRD2TTSConverterModule(1.00)converts TOPRawDigits
to TOP TRG timestamps
TRGTOPUnpacker TRGTOPUnpackerModule(1.00)
TRGTOPUnpackerWaveform TRGTOPUnpackerWaveformModule(1.00)Unpacks TOP TRG
waveforms
TRGTOPWaveformPlotter TRGTOP Waveform Plotter
vxd
VXDDQMExpressReco VXD DQM module for Express Reco Recommended Number of
events for monitor is 40 kEvents or more to fill all
histograms
VXDMisalignment Initialize VXD misalignment
vxdDigitMasking vxdDigitMasking of pixels and strips in PXD and SVD base
on their firing
--------------------------------------------------------------------------------
To show detailed information on a module, including its parameters,
type 'basf2 -m ModuleName'. Use 'basf2 -m package' to only list
modules belonging to a given package.
PJFRY init
Set xalogm to normalized value 2.225074e-308
Set xalog2 to normalized value 1.491668e-154
Set xclogm to normalized value 2.225074e-308
Set xclog2 to normalized value 1.491668e-154
Disable FF warnings 0
=== stderr of framework/tests/modulelist.py ===
free(): invalid pointer
*** Break *** abort
===========================================================
There was a crash.
This is the entire stack trace of all threads:
===========================================================
Thread 3 (Thread 0x7fd704797640 (LWP 153427) "errlog"):
#0 0x00007fd744a8688a in __futex_abstimed_wait_common () from /lib64/libc.so.6
#1 0x00007fd744a88de2 in pthread_cond_wait
GLIBC_2.3.2 () from /lib64/libc.so.6
#2 0x00007fd7052ace3b in epicsEventWait (pevent=0x7809380) at ../osi/os/posix/osdEvent.c:104
#3 0x00007fd7052a5d09 in epicsEventMustWait (id=) at ../osi/epicsEvent.cpp:125
#4 0x00007fd705293cfe in errlogThread () at ../error/errlog.c:561
#5 0x00007fd7052a9f53 in start_routine (arg=0xa453f60) at ../osi/os/posix/osdThread.c:412
#6 0x00007fd744a897fa in start_thread () from /lib64/libc.so.6
#7 0x00007fd744b0e820 in clone3 () from /lib64/libc.so.6
Thread 2 (Thread 0x7fd704fff640 (LWP 153398) "ipToAsciiProxy"):
#0 0x00007fd744a8688a in __futex_abstimed_wait_common () from /lib64/libc.so.6
#1 0x00007fd744a88de2 in pthread_cond_wait
GLIBC_2.3.2 () from /lib64/libc.so.6
#2 0x00007fd7052ace3b in epicsEventWait (pevent=0x8a78120) at ../osi/os/posix/osdEvent.c:104
#3 0x00007fd7052a5c1c in epicsEvent::wait (this=this
entry=0x8af3650) at ../osi/epicsEvent.cpp:66
#4 0x00007fd7052a2ad0 in (anonymous namespace)::ipAddrToAsciiGlobal::run (this=0x8af3210) at ../misc/ipAddrToAsciiAsynchronous.cpp:304
#5 0x00007fd7052a4b09 in epicsThreadCallEntryPoint (pPvt=0x8af3660) at ../osi/epicsThread.cpp:95
#6 0x00007fd7052a9f53 in start_routine (arg=0x8a78820) at ../osi/os/posix/osdThread.c:412
#7 0x00007fd744a897fa in start_thread () from /lib64/libc.so.6
#8 0x00007fd744b0e820 in clone3 () from /lib64/libc.so.6
Thread 1 (Thread 0x7fd74385ac00 (LWP 153212) "basf2"):
#0 0x00007fd744ad85ff in wait4 () from /lib64/libc.so.6
#1 0x00007fd744a4b253 in do_system () from /lib64/libc.so.6
#2 0x00007fd74415f46a in TUnixSystem::Exec (this=0xc1b040, shellcmd=) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:2151
#3 TUnixSystem::StackTrace (this=0xc1b040) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:2442
#4 0x00007fd743db9dff in (anonymous namespace)::do_trace (sig=5) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx:189
#5 (anonymous namespace)::TExceptionHandlerImp::HandleException (this=, sig=5) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx:202
#6 0x00007fd74415ec21 in TUnixSystem::DispatchSignals (this=0xc1b040, sig=kSigAbort) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:3657
#7
#8 0x00007fd744a8b53c in __pthread_kill_implementation () from /lib64/libc.so.6
#9 0x00007fd744a3e686 in raise () from /lib64/libc.so.6
#10 0x00007fd744a28833 in abort () from /lib64/libc.so.6
#11 0x00007fd744a29170 in __libc_message.cold () from /lib64/libc.so.6
#12 0x00007fd744a955e7 in malloc_printerr () from /lib64/libc.so.6
#13 0x00007fd744a96e9c in _int_free () from /lib64/libc.so.6
#14 0x00007fd744a99925 in free () from /lib64/libc.so.6
#15 0x00007fd744a40dfd in __run_exit_handlers () from /lib64/libc.so.6
#16 0x00007fd744a40f40 in exit () from /lib64/libc.so.6
#17 0x00007fd744a295d7 in __libc_start_call_main () from /lib64/libc.so.6
#18 0x00007fd744a29680 in __libc_start_main_impl () from /lib64/libc.so.6
#19 0x000000000040f465 in _start ()
===========================================================
The lines below might hint at the cause of the crash. If you see question
marks as part of the stack trace, try to recompile with debugging information
enabled and export CLING_DEBUG=1 environment variable before running.
You may get help by asking at the ROOT forum https://root.cern/forum
preferably using the command (.forum bug) in the ROOT prompt.
Only if you are really convinced it is a bug in ROOT then please submit a
report at https://root.cern/bugs or (preferably) using the command (.gh bug) in
the ROOT prompt. Please post the ENTIRE stack trace
from above as an attachment in addition to anything else
that might help us fixing this issue.
===========================================================
#8 0x00007fd744a8b53c in __pthread_kill_implementation () from /lib64/libc.so.6
#9 0x00007fd744a3e686 in raise () from /lib64/libc.so.6
#10 0x00007fd744a28833 in abort () from /lib64/libc.so.6
#11 0x00007fd744a29170 in __libc_message.cold () from /lib64/libc.so.6
#12 0x00007fd744a955e7 in malloc_printerr () from /lib64/libc.so.6
#13 0x00007fd744a96e9c in _int_free () from /lib64/libc.so.6
#14 0x00007fd744a99925 in free () from /lib64/libc.so.6
#15 0x00007fd744a40dfd in __run_exit_handlers () from /lib64/libc.so.6
#16 0x00007fd744a40f40 in exit () from /lib64/libc.so.6
#17 0x00007fd744a295d7 in __libc_start_call_main () from /lib64/libc.so.6
#18 0x00007fd744a29680 in __libc_start_main_impl () from /lib64/libc.so.6
#19 0x000000000040f465 in _start ()
===========================================================
*** Break *** abort
===========================================================
There was a crash.
This is the entire stack trace of all threads:
===========================================================
Thread 3 (Thread 0x7fd704797640 (LWP 153427) "errlog"):
#0 0x00007fd744a8688a in __futex_abstimed_wait_common () from /lib64/libc.so.6
#1 0x00007fd744a88de2 in pthread_cond_wait
GLIBC_2.3.2 () from /lib64/libc.so.6
#2 0x00007fd7052ace3b in epicsEventWait (pevent=0x7809380) at ../osi/os/posix/osdEvent.c:104
#3 0x00007fd7052a5d09 in epicsEventMustWait (id=) at ../osi/epicsEvent.cpp:125
#4 0x00007fd705293cfe in errlogThread () at ../error/errlog.c:561
#5 0x00007fd7052a9f53 in start_routine (arg=0xa453f60) at ../osi/os/posix/osdThread.c:412
#6 0x00007fd744a897fa in start_thread () from /lib64/libc.so.6
#7 0x00007fd744b0e820 in clone3 () from /lib64/libc.so.6
Thread 2 (Thread 0x7fd704fff640 (LWP 153398) "ipToAsciiProxy"):
#0 0x00007fd744a8688a in __futex_abstimed_wait_common () from /lib64/libc.so.6
#1 0x00007fd744a88de2 in pthread_cond_wait
GLIBC_2.3.2 () from /lib64/libc.so.6
#2 0x00007fd7052ace3b in epicsEventWait (pevent=0x8a78120) at ../osi/os/posix/osdEvent.c:104
#3 0x00007fd7052a5c1c in epicsEvent::wait (this=this
entry=0x8af3650) at ../osi/epicsEvent.cpp:66
#4 0x00007fd7052a2ad0 in (anonymous namespace)::ipAddrToAsciiGlobal::run (this=0x8af3210) at ../misc/ipAddrToAsciiAsynchronous.cpp:304
#5 0x00007fd7052a4b09 in epicsThreadCallEntryPoint (pPvt=0x8af3660) at ../osi/epicsThread.cpp:95
#6 0x00007fd7052a9f53 in start_routine (arg=0x8a78820) at ../osi/os/posix/osdThread.c:412
#7 0x00007fd744a897fa in start_thread () from /lib64/libc.so.6
#8 0x00007fd744b0e820 in clone3 () from /lib64/libc.so.6
Thread 1 (Thread 0x7fd74385ac00 (LWP 153212) "basf2"):
#0 0x00007fd744ad85ff in wait4 () from /lib64/libc.so.6
#1 0x00007fd744a4b253 in do_system () from /lib64/libc.so.6
#2 0x00007fd74415f46a in TUnixSystem::Exec (this=0xc1b040, shellcmd=) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:2151
#3 TUnixSystem::StackTrace (this=0xc1b040) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:2442
#4 0x00007fd743db9d0f in (anonymous namespace)::do_trace (sig=5) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx:189
#5 (anonymous namespace)::TExceptionHandlerImp::HandleException (this=, sig=5) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx:208
#6 0x00007fd74415ec21 in TUnixSystem::DispatchSignals (this=0xc1b040, sig=kSigAbort) at /cvmfs/belle.cern.ch/el9/externals/v02-03-00/src/root/core/unix/src/TUnixSystem.cxx:3657
#7
#8 0x00007fd744a8b53c in __pthread_kill_implementation () from /lib64/libc.so.6
#9 0x00007fd744a3e686 in raise () from /lib64/libc.so.6
#10 0x00007fd744a28833 in abort () from /lib64/libc.so.6
#11 0x00007fd744a29170 in __libc_message.cold () from /lib64/libc.so.6
#12 0x00007fd744a955e7 in malloc_printerr () from /lib64/libc.so.6
#13 0x00007fd744a96e9c in _int_free () from /lib64/libc.so.6
#14 0x00007fd744a99925 in free () from /lib64/libc.so.6
#15 0x00007fd744a40dfd in __run_exit_handlers () from /lib64/libc.so.6
#16 0x00007fd744a40f40 in exit () from /lib64/libc.so.6
#17 0x00007fd744a295d7 in __libc_start_call_main () from /lib64/libc.so.6
#18 0x00007fd744a29680 in __libc_start_main_impl () from /lib64/libc.so.6
#19 0x000000000040f465 in _start ()
===========================================================
The lines below might hint at the cause of the crash. If you see question
marks as part of the stack trace, try to recompile with debugging information
enabled and export CLING_DEBUG=1 environment variable before running.
You may get help by asking at the ROOT forum https://root.cern/forum
preferably using the command (.forum bug) in the ROOT prompt.
Only if you are really convinced it is a bug in ROOT then please submit a
report at https://root.cern/bugs or (preferably) using the command (.gh bug) in
the ROOT prompt. Please post the ENTIRE stack trace
from above as an attachment in addition to anything else
that might help us fixing this issue.
===========================================================
#8 0x00007fd744a8b53c in __pthread_kill_implementation () from /lib64/libc.so.6
#9 0x00007fd744a3e686 in raise () from /lib64/libc.so.6
#10 0x00007fd744a28833 in abort () from /lib64/libc.so.6
#11 0x00007fd744a29170 in __libc_message.cold () from /lib64/libc.so.6
#12 0x00007fd744a955e7 in malloc_printerr () from /lib64/libc.so.6
#13 0x00007fd744a96e9c in _int_free () from /lib64/libc.so.6
#14 0x00007fd744a99925 in free () from /lib64/libc.so.6
#15 0x00007fd744a40dfd in __run_exit_handlers () from /lib64/libc.so.6
#16 0x00007fd744a40f40 in exit () from /lib64/libc.so.6
#17 0x00007fd744a295d7 in __libc_start_call_main () from /lib64/libc.so.6
#18 0x00007fd744a29680 in __libc_start_main_impl () from /lib64/libc.so.6
#19 0x000000000040f465 in _start ()
===========================================================
Traceback (most recent call last):
File "/data/b2soft/buildbot/development/releases/current/framework/tests/modulelist.py", line 12, in
assert 0 == os.system('basf2 -m')
^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError
=== end framework/tests/modulelist.py ===