Belle II Software light-2406-ragdoll
ParticleLoaderModule Class Reference

Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList. More...

#include <ParticleLoaderModule.h>

Inheritance diagram for ParticleLoaderModule:
Collaboration diagram for ParticleLoaderModule:

Public Types

enum  EModulePropFlags {
  c_Input = 1 ,
  c_Output = 2 ,
  c_ParallelProcessingCertified = 4 ,
  c_HistogramManager = 8 ,
  c_InternalSerializer = 16 ,
  c_TerminateInAllProcesses = 32 ,
  c_DontCollectStatistics = 64
}
 Each module can be tagged with property flags, which indicate certain features of the module. More...
 
typedef ModuleCondition::EAfterConditionPath EAfterConditionPath
 Forward the EAfterConditionPath definition from the ModuleCondition.
 

Public Member Functions

 ParticleLoaderModule ()
 Constructor.
 
virtual void initialize () override
 Initialize the Module.
 
virtual void event () override
 Event processor.
 
virtual void terminate () override
 Terminate the Module.
 
virtual std::vector< std::string > getFileNames (bool outputFiles)
 Return a list of output filenames for this modules.
 
virtual void beginRun ()
 Called when entering a new run.
 
virtual void endRun ()
 This method is called if the current run ends.
 
const std::string & getName () const
 Returns the name of the module.
 
const std::string & getType () const
 Returns the type of the module (i.e.
 
const std::string & getPackage () const
 Returns the package this module is in.
 
const std::string & getDescription () const
 Returns the description of the module.
 
void setName (const std::string &name)
 Set the name of the module.
 
void setPropertyFlags (unsigned int propertyFlags)
 Sets the flags for the module properties.
 
LogConfiggetLogConfig ()
 Returns the log system configuration.
 
void setLogConfig (const LogConfig &logConfig)
 Set the log system configuration.
 
void setLogLevel (int logLevel)
 Configure the log level.
 
void setDebugLevel (int debugLevel)
 Configure the debug messaging level.
 
void setAbortLevel (int abortLevel)
 Configure the abort log level.
 
void setLogInfo (int logLevel, unsigned int logInfo)
 Configure the printed log information for the given level.
 
void if_value (const std::string &expression, const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 Add a condition to the module.
 
void if_false (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to add a condition to the module.
 
void if_true (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to set the condition of the module.
 
bool hasCondition () const
 Returns true if at least one condition was set for the module.
 
const ModuleConditiongetCondition () const
 Return a pointer to the first condition (or nullptr, if none was set)
 
const std::vector< ModuleCondition > & getAllConditions () const
 Return all set conditions for this module.
 
bool evalCondition () const
 If at least one condition was set, it is evaluated and true returned if at least one condition returns true.
 
std::shared_ptr< PathgetConditionPath () const
 Returns the path of the last true condition (if there is at least one, else reaturn a null pointer).
 
Module::EAfterConditionPath getAfterConditionPath () const
 What to do after the conditional path is finished.
 
std::vector< std::shared_ptr< Path > > getAllConditionPaths () const
 Return all condition paths currently set (no matter if the condition is true or not).
 
bool hasProperties (unsigned int propertyFlags) const
 Returns true if all specified property flags are available in this module.
 
bool hasUnsetForcedParams () const
 Returns true and prints error message if the module has unset parameters which the user has to set in the steering file.
 
const ModuleParamListgetParamList () const
 Return module param list.
 
template<typename T >
ModuleParam< T > & getParam (const std::string &name) const
 Returns a reference to a parameter.
 
bool hasReturnValue () const
 Return true if this module has a valid return value set.
 
int getReturnValue () const
 Return the return value set by this module.
 
std::shared_ptr< PathElementclone () const override
 Create an independent copy of this module.
 
std::shared_ptr< boost::python::list > getParamInfoListPython () const
 Returns a python list of all parameters.
 

Static Public Member Functions

static void exposePythonAPI ()
 Exposes methods of the Module class to Python.
 

Protected Member Functions

virtual void def_initialize ()
 Wrappers to make the methods without "def_" prefix callable from Python.
 
virtual void def_beginRun ()
 Wrapper method for the virtual function beginRun() that has the implementation to be used in a call from Python.
 
virtual void def_event ()
 Wrapper method for the virtual function event() that has the implementation to be used in a call from Python.
 
virtual void def_endRun ()
 This method can receive that the current run ends as a call from the Python side.
 
virtual void def_terminate ()
 Wrapper method for the virtual function terminate() that has the implementation to be used in a call from Python.
 
void setDescription (const std::string &description)
 Sets the description of the module.
 
void setType (const std::string &type)
 Set the module type.
 
template<typename T >
void addParam (const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
 Adds a new parameter to the module.
 
template<typename T >
void addParam (const std::string &name, T &paramVariable, const std::string &description)
 Adds a new enforced parameter to the module.
 
void setReturnValue (int value)
 Sets the return value for this module as integer.
 
void setReturnValue (bool value)
 Sets the return value for this module as bool.
 
void setParamList (const ModuleParamList &params)
 Replace existing parameter list.
 

Private Types

enum  PListIndex {
  c_PListPDGCode ,
  c_PListName ,
  c_AntiPListName ,
  c_IsPListSelfConjugated
}
 Enum for describing each element in the above tuple. More...
 
typedef std::tuple< int, std::string, std::string, bool > PList
 tuple for collecting everything we know about the ParticlList to be created.
 

Private Member Functions

void mcParticlesToParticles ()
 Loads specified MCParticles as Particle to StoreArray<Particle>
 
void mdstToParticle ()
 Loads specified MSDT object as Particle to StoreArray<Particle>
 
void tracksToParticles ()
 Loads Track object as Particle to StoreArray<Particle> and adds it to the ParticleList.
 
void eclAndKLMClustersToParticles ()
 Loads ECLCluster and KLMCluster object as Particle to StoreArray<Particle> and adds it to the ParticleList.
 
bool isValidECLCluster (const ECLCluster *cluster, const int pdgCode, bool onlyNeutral) const
 Checks if the given ECLCluster is valid for the pdgCode.
 
void assignMCParticleFromECLCluster (Particle *newPart, const ECLCluster *cluster) const
 Assigns the MCParticle relation to the newPart.
 
void chargedClustersToParticles ()
 Loads ECLCluster and KLMCluster objects that are being matched with Track as Particle to StoreArray<Particle> and adds it to the ParticleList.
 
void v0sToParticles ()
 Loads V0 object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.
 
void roeToParticles ()
 Loads ROE object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.
 
void addROEToParticleList (RestOfEvent *roe, int mdstIndex, int pdgCode=0, bool isSelfConjugatedParticle=true)
 Helper method to load ROE object as Particle.
 
void dummyToParticles ()
 Loads dummy object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.
 
bool isValidPDGCode (const int pdgCode)
 returns true if the PDG code determined from the decayString is valid
 
void appendDaughtersRecursive (Particle *mother)
 recursively append bottom of a particle's decay chain (daughters of mother, granddaughters of daughter and so on).
 
std::list< ModulePtrgetModules () const override
 no submodules, return empty list
 
std::string getPathString () const override
 return the module name.
 
void setParamPython (const std::string &name, const boost::python::object &pyObj)
 Implements a method for setting boost::python objects.
 
void setParamPythonDict (const boost::python::dict &dictionary)
 Implements a method for reading the parameter values from a boost::python dictionary.
 

Private Attributes

StoreArray< Particlem_particles
 StoreArray of Particles.
 
StoreArray< MCParticlem_mcparticles
 StoreArray of MCParticles.
 
StoreArray< ECLClusterm_eclclusters
 StoreArray of ECLCluster.
 
StoreArray< KLMClusterm_klmclusters
 StoreArray of KLMCluster.
 
StoreArray< PIDLikelihoodm_pidlikelihoods
 StoreArray of PIDLikelihoods.
 
StoreArray< Trackm_tracks
 StoreArray of Tracks.
 
StoreArray< TrackFitResultm_trackfitresults
 StoreArray of TrackFitResults.
 
StoreObjPtr< EventExtraInfom_eventExtraInfo
 object pointer to event extra info
 
StoreObjPtr< ParticleExtraInfoMapm_particleExtraInfoMap
 object pointer to extra info map
 
StoreArray< RestOfEventm_roes
 StoreArray of ROEs.
 
StoreArray< V0m_v0s
 StoreArray of V0s.
 
bool m_useMCParticles
 Load MCParticle as Particle instead of the corresponding MDST dataobject.
 
bool m_useROEs
 Switch to load ROE as Particle.
 
bool m_useDummy
 Switch to load dummy as Particle.
 
bool m_loadChargedCluster
 Switch to load charged-cluster

 
bool m_useOnlyMostEnergeticECLCluster
 If true, only the most energetic ECLCluster is used.
 
DecayDescriptor m_decaydescriptor
 Decay descriptor for parsing the user specified DecayString.
 
int m_properties
 Particle property to be assigned only on V0s.
 
std::vector< std::string > m_decayStrings
 Input decay strings specifying the particles being created/loaded.
 
std::vector< PListm_MCParticles2Plists
 Collection of PLists that will collect Particles created from MCParticles.
 
std::vector< PListm_Tracks2Plists
 Collection of PLists that will collect Particles created from Tracks.
 
std::vector< PListm_V02Plists
 Collection of PLists that will collect Particles created from V0.
 
std::vector< PListm_ROE2Plists
 Collection of PLists that will collect Particles created from V0.
 
std::vector< PListm_ECLKLMClusters2Plists
 Collection of PLists that will collect Particles created from ECLClusters and KLMClusters.
 
std::vector< PListm_Dummies2Plists
 Collection of PLists that will collect Particles created from Dummies.
 
std::vector< PListm_ChargedCluster2Plists
 Collection of PLists that will collect Particles created from charged-cluster.
 
bool m_writeOut
 toggle particle list btw.
 
bool m_skipInitial
 toggle skip of initial MC particles
 
bool m_skipNonPrimary
 toggle skip of secondary MC particle
 
bool m_addDaughters
 toggle addition of the bottom part of the particle's decay chain
 
bool m_skipNonPrimaryDaughters
 toggle skip of secondary MC daughters
 
std::string m_roeMaskName
 ROE mask name to load.
 
std::string m_sourceParticleListName
 Particle list name from which we need to get related ROEs.
 
bool m_useMissing
 Use missing momentum to build a particle.
 
int m_trackHypothesis
 pdg code for track hypothesis that should be used to create the particle
 
int m_dummyMDSTIndex
 mdst index for dummy particles
 
double m_dummyCovMatrix
 diag value of cov matrix for dummy particles
 
bool m_dummyTreatAsInvisible
 should treeFitter treat the particle as invisible?
 
bool m_enforceFitHypothesis
 If true, a Particle is only created if a track fit with the particle hypothesis passed to the ParticleLoader is available.
 
std::vector< int > m_chargeZeroTrackCounts
 internally used to count number of tracks with charge zero
 
std::vector< int > m_sameChargeDaughtersV0Counts
 internally used to count the number of V0s with same charge daughters
 
std::string m_name
 The name of the module, saved as a string (user-modifiable)
 
std::string m_type
 The type of the module, saved as a string.
 
std::string m_package
 Package this module is found in (may be empty).
 
std::string m_description
 The description of the module.
 
unsigned int m_propertyFlags
 The properties of the module as bitwise or (with |) of EModulePropFlags.
 
LogConfig m_logConfig
 The log system configuration of the module.
 
ModuleParamList m_moduleParamList
 List storing and managing all parameter of the module.
 
bool m_hasReturnValue
 True, if the return value is set.
 
int m_returnValue
 The return value.
 
std::vector< ModuleConditionm_conditions
 Module condition, only non-null if set.
 

Detailed Description

Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList.

Charge conjugated particles are loaded as well and collected in the anti-ParticleList.

The type of the particle to be loaded is specified via the decayString module parameter. The type of the MDST dataobject that is used as an input is determined from the type of the particle.

The following types of the particles can be loaded:

o) charged final state particles (input MDST type = Tracks)

  • e+, mu+, pi+, K+, p, deuteron (and charge conjugated particles)

o) neutral final state particles

  • gamma (input MDST type = ECLCluster with 'n photons' ECLCluster::Hypothesis::c_nPhotons)
  • K_S0, Lambda0, converted photons (input MDST type = V0)
  • K_L0, n0 (input MDST type = KLMCluster, or ECLCluster with neutral hadron hypothesis)

The following basf2 relations are set by the ParticleLoader:

o) in the case of charged final state particles

o) in the case of neutral final state particles

In the case the useMCParticles module parameter is set to true the module loads specific MCParticle(s) as Particle(s) instead of the MDST dataobjects. In this case any particle type can be specified via the decayString module parameter.

Definition at line 77 of file ParticleLoaderModule.h.

Member Typedef Documentation

◆ EAfterConditionPath

Forward the EAfterConditionPath definition from the ModuleCondition.

Definition at line 88 of file Module.h.

◆ PList

typedef std::tuple<int, std::string, std::string, bool> PList
private

tuple for collecting everything we know about the ParticlList to be created.

The elements are: PDGCode, name, anti-list name, and isListSelfConjugated

Definition at line 83 of file ParticleLoaderModule.h.

Member Enumeration Documentation

◆ EModulePropFlags

enum EModulePropFlags
inherited

Each module can be tagged with property flags, which indicate certain features of the module.

Enumerator
c_Input 

This module is an input module (reads data).

c_Output 

This module is an output module (writes data).

c_ParallelProcessingCertified 

This module can be run in parallel processing mode safely (All I/O must be done through the data store, in particular, the module must not write any files.)

c_HistogramManager 

This module is used to manage histograms accumulated by other modules.

c_InternalSerializer 

This module is an internal serializer/deserializer for parallel processing.

c_TerminateInAllProcesses 

When using parallel processing, call this module's terminate() function in all processes().

This will also ensure that there is exactly one process (single-core if no parallel modules found) or at least one input, one main and one output process.

c_DontCollectStatistics 

No statistics is collected for this module.

Definition at line 77 of file Module.h.

77 {
78 c_Input = 1,
79 c_Output = 2,
85 };
@ c_HistogramManager
This module is used to manage histograms accumulated by other modules.
Definition: Module.h:81
@ c_Input
This module is an input module (reads data).
Definition: Module.h:78
@ c_DontCollectStatistics
No statistics is collected for this module.
Definition: Module.h:84
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:80
@ c_InternalSerializer
This module is an internal serializer/deserializer for parallel processing.
Definition: Module.h:82
@ c_Output
This module is an output module (writes data).
Definition: Module.h:79
@ c_TerminateInAllProcesses
When using parallel processing, call this module's terminate() function in all processes().
Definition: Module.h:83

◆ PListIndex

enum PListIndex
private

Enum for describing each element in the above tuple.

Definition at line 87 of file ParticleLoaderModule.h.

87 {
88 c_PListPDGCode, c_PListName, c_AntiPListName, c_IsPListSelfConjugated
89 };

Constructor & Destructor Documentation

◆ ParticleLoaderModule()

Constructor.

Definition at line 36 of file ParticleLoaderModule.cc.

36 : Module()
37
38{
39 setDescription("Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList.");
41
42 // Add parameters
43 addParam("decayStrings", m_decayStrings,
44 "List of decay strings (see :ref:`DecayString` for syntax) that specify all output ParticleLists to be created by the module.",
45 {});
46
47 addParam("useMCParticles", m_useMCParticles,
48 "Use MCParticles instead of reconstructed MDST dataobjects (tracks, ECL, KLM, clusters, V0s, ...)", false);
49
50 addParam("useROEs", m_useROEs,
51 "Use ROE instead of reconstructed MDST dataobjects (tracks, ECL, KLM, clusters, V0s, ...)", false);
52
53 addParam("roeMaskName", m_roeMaskName,
54 "ROE mask name to load", std::string(RestOfEvent::c_defaultMaskName));
55
56 addParam("sourceParticleListName", m_sourceParticleListName,
57 "Particle list name from which we need to get ROEs", std::string(""));
58
59 addParam("useMissing", m_useMissing,
60 "If true, the Particle List will be filled with missing momentum from the ROE and signal particle.", false);
61
62 addParam("writeOut", m_writeOut,
63 "If true, the output ParticleList will be saved by RootOutput. If false, it will be ignored when writing the file.", false);
64
65 addParam("skipInitial", m_skipInitial,
66 "If true, initial MCParticles will be skipped (default). If false, initial MCParticles will be included.", true);
67
68 addParam("skipNonPrimary", m_skipNonPrimary,
69 "If true, the secondary MC particle will be skipped, default is false",
70 false);
71
72 addParam("addDaughters", m_addDaughters,
73 "If true, the particles from the bottom part of the selected particle's decay chain will also be created in the datastore and mother-daughter relations are recursively set",
74 false);
75
76 addParam("skipNonPrimaryDaughters", m_skipNonPrimaryDaughters,
77 "If true, the secondary MC daughters will be skipped, default is false",
78 false);
79
80 addParam("trackHypothesis", m_trackHypothesis,
81 "Track hypothesis to use when loading the particle. By default, use the particle's own hypothesis.",
82 0);
83
84 addParam("enforceFitHypothesis", m_enforceFitHypothesis,
85 "If true, a Particle is only created if a track fit with the particle hypothesis passed to the ParticleLoader is available.",
87
88 addParam("useDummy", m_useDummy,
89 "Use Dummy instead of reconstructed MDST dataobjects (tracks, ECL, KLM, clusters, V0s, ...)", false);
90
91 addParam("dummyMDSTIndex", m_dummyMDSTIndex,
92 "mdst index to use for dummy particle", 0);
93
94 addParam("dummyCovMatrix", m_dummyCovMatrix,
95 "Diagonal value of covariance matrix to use for dummy particle", 10000.);
96
97 addParam("dummyTreatAsInvisible", m_dummyTreatAsInvisible,
98 "Should treeFitter treat the particle as invisible?", true);
99
100 addParam("loadChargedCluster", m_loadChargedCluster,
101 "Load neutral Particles from the clusters being matched with the track of the sourceParticleList",
102 false);
103 addParam("useOnlyMostEnergeticECLCluster", m_useOnlyMostEnergeticECLCluster,
104 "If true, the most energetic ECLCluster among ones matching with the Track is used. "
105 "If false, all matched ECLCluster are used. "
106 "This option is checked only when loadChargedCluster=True.",
107 true);
108}
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:208
Module()
Constructor.
Definition: Module.cc:30
std::vector< std::string > m_decayStrings
Input decay strings specifying the particles being created/loaded.
bool m_dummyTreatAsInvisible
should treeFitter treat the particle as invisible?
int m_trackHypothesis
pdg code for track hypothesis that should be used to create the particle
std::string m_sourceParticleListName
Particle list name from which we need to get related ROEs.
bool m_skipInitial
toggle skip of initial MC particles
int m_dummyMDSTIndex
mdst index for dummy particles
std::string m_roeMaskName
ROE mask name to load.
double m_dummyCovMatrix
diag value of cov matrix for dummy particles
bool m_addDaughters
toggle addition of the bottom part of the particle's decay chain
bool m_skipNonPrimaryDaughters
toggle skip of secondary MC daughters
bool m_enforceFitHypothesis
If true, a Particle is only created if a track fit with the particle hypothesis passed to the Particl...
bool m_useDummy
Switch to load dummy as Particle.
bool m_writeOut
toggle particle list btw.
bool m_useOnlyMostEnergeticECLCluster
If true, only the most energetic ECLCluster is used.
bool m_skipNonPrimary
toggle skip of secondary MC particle
bool m_useROEs
Switch to load ROE as Particle.
bool m_loadChargedCluster
Switch to load charged-cluster
bool m_useMissing
Use missing momentum to build a particle.
bool m_useMCParticles
Load MCParticle as Particle instead of the corresponding MDST dataobject.
static constexpr const char * c_defaultMaskName
Default mask name.
Definition: RestOfEvent.h:60
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560

Member Function Documentation

◆ addROEToParticleList()

void addROEToParticleList ( RestOfEvent roe,
int  mdstIndex,
int  pdgCode = 0,
bool  isSelfConjugatedParticle = true 
)
private

Helper method to load ROE object as Particle.

Definition at line 437 of file ParticleLoaderModule.cc.

438{
439
440 Particle* newPart = nullptr;
441 if (!m_useMissing) {
442 // Convert ROE to particle
443 newPart = roe->convertToParticle(m_roeMaskName, pdgCode, isSelfConjugatedParticle);
444 } else {
445 // Create a particle from missing momentum
446 auto* signalSideParticle = roe->getRelatedFrom<Particle>();
448 ROOT::Math::PxPyPzEVector boost4Vector = T.getBeamFourMomentum();
449
450 ROOT::Math::PxPyPzEVector signal4Vector = signalSideParticle->get4Vector();
451 ROOT::Math::PxPyPzEVector roe4Vector = roe->get4Vector(m_roeMaskName);
452 ROOT::Math::PxPyPzEVector missing4Vector = boost4Vector - signal4Vector - roe4Vector;
453 auto isFlavored = (isSelfConjugatedParticle) ? Particle::EFlavorType::c_Unflavored : Particle::EFlavorType::c_Flavored;
454 newPart = m_particles.appendNew(missing4Vector, pdgCode, isFlavored, Particle::EParticleSourceObject::c_Undefined, mdstIndex);
455 }
456
457 roe->addRelationTo(newPart);
458
459 for (auto roe2Plist : m_ROE2Plists) {
460 string listName = get<c_PListName>(roe2Plist);
461 StoreObjPtr<ParticleList> plist(listName);
462 plist->addParticle(newPart);
463 }
464}
Class to hold Lorentz transformations from/to CMS and boost vector.
ROOT::Math::PxPyPzEVector getBeamFourMomentum() const
Returns LAB four-momentum of e+e-, i.e.
StoreArray< Particle > m_particles
StoreArray of Particles.
std::vector< PList > m_ROE2Plists
Collection of PLists that will collect Particles created from V0.
Class to store reconstructed particles.
Definition: Particle.h:75
@ c_Unflavored
Is its own antiparticle or we don't know whether it is a particle/antiparticle.
Definition: Particle.h:95
@ c_Flavored
Is either particle or antiparticle.
Definition: Particle.h:96
void addRelationTo(const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
Add a relation from this object to another object (with caching).
FROM * getRelatedFrom(const std::string &name="", const std::string &namedRelation="") const
Get the object from which this object has a relation.
ROOT::Math::PxPyPzEVector get4Vector(const std::string &maskName=c_defaultMaskName) const
Get 4-momentum vector all (no mask) or a subset (use mask) of all Tracks and ECLClusters in ROE.
Definition: RestOfEvent.cc:306
Particle * convertToParticle(const std::string &maskName=c_defaultMaskName, int pdgCode=0, bool isSelfConjugated=true)
Converts ROE to Particle and adds it to StoreArray.
Definition: RestOfEvent.cc:443
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:246
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96

◆ appendDaughtersRecursive()

void appendDaughtersRecursive ( Particle mother)
private

recursively append bottom of a particle's decay chain (daughters of mother, granddaughters of daughter and so on).

Definition at line 1025 of file ParticleLoaderModule.cc.

1026{
1027 auto* mcmother = mother->getRelated<MCParticle>();
1028
1029 if (!mcmother)
1030 return;
1031
1032 vector<MCParticle*> mcdaughters = mcmother->getDaughters();
1033
1034 for (auto& mcdaughter : mcdaughters) {
1035 if (!mcdaughter->hasStatus(MCParticle::c_PrimaryParticle) and m_skipNonPrimaryDaughters) continue;
1036 Particle particle(mcdaughter);
1037 Particle* daughter = m_particles.appendNew(particle);
1038 daughter->addRelationTo(mcdaughter);
1039 mother->appendDaughter(daughter, false);
1040
1041 if (mcdaughter->getNDaughters() > 0)
1042 appendDaughtersRecursive(daughter);
1043 }
1044}
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:32
@ c_PrimaryParticle
bit 0: Particle is primary particle.
Definition: MCParticle.h:47
std::vector< Belle2::MCParticle * > getDaughters() const
Get vector of all daughter particles, empty vector if none.
Definition: MCParticle.cc:52
void appendDaughtersRecursive(Particle *mother)
recursively append bottom of a particle's decay chain (daughters of mother, granddaughters of daughte...
void appendDaughter(const Particle *daughter, const bool updateType=true, const int daughterProperty=c_Ordinary)
Appends index of daughter to daughters index array.
Definition: Particle.cc:676
T * getRelated(const std::string &name="", const std::string &namedRelation="") const
Get the object to or from which this object has a relation.

◆ assignMCParticleFromECLCluster()

void assignMCParticleFromECLCluster ( Particle newPart,
const ECLCluster cluster 
) const
private

Assigns the MCParticle relation to the newPart.

The given cluster is used to find the best MCParticle matching.

Definition at line 811 of file ParticleLoaderModule.cc.

812{
813 // ECLCluster can be matched to multiple MCParticles
814 // order the relations by weights and set Particle -> multiple MCParticle relation
815 // preserve the weight
816 const RelationVector<MCParticle> mcRelations = cluster->getRelationsTo<MCParticle>();
817
818 // order relations by weights
819 std::vector<std::pair<double, int>> weightsAndIndices;
820 for (unsigned int iMCParticle = 0; iMCParticle < mcRelations.size(); iMCParticle++) {
821 const MCParticle* relMCParticle = mcRelations[iMCParticle];
822 if (relMCParticle) {
823 double weight = mcRelations.weight(iMCParticle);
824 weightsAndIndices.emplace_back(weight, relMCParticle->getArrayIndex());
825 }
826 }
827
828 // sort descending by weight
829 std::sort(weightsAndIndices.begin(), weightsAndIndices.end(),
830 ValueIndexPairSorting::higherPair<decltype(weightsAndIndices)::value_type>);
831
832 // set relations to mcparticles
833 for (auto& weightsAndIndex : weightsAndIndices) {
834 const MCParticle* relMCParticle = m_mcparticles[weightsAndIndex.second];
835 double weight = weightsAndIndex.first;
836
837 // TODO: study this further and avoid hard-coded values
838 // set the relation only if the MCParticle(reconstructed Particle)'s
839 // energy contribution to this cluster amounts to at least 30(20)%
840 if (relMCParticle)
841 if (weight / newPart->getECLClusterEnergy() > 0.20
842 && weight / relMCParticle->getEnergy() > 0.30)
843 newPart->addRelationTo(relMCParticle, weight);
844 }
845
846}
float getEnergy() const
Return particle energy in GeV.
Definition: MCParticle.h:147
int getArrayIndex() const
Get 0-based index of the particle in the corresponding MCParticle list.
Definition: MCParticle.h:244
StoreArray< MCParticle > m_mcparticles
StoreArray of MCParticles.
double getECLClusterEnergy() const
Returns the energy of the ECLCluster for the particle.
Definition: Particle.cc:919
Class for type safe access to objects that are referred to in relations.
size_t size() const
Get number of relations.
float weight(int index) const
Get weight with index.

◆ beginRun()

◆ chargedClustersToParticles()

void chargedClustersToParticles ( )
private

Loads ECLCluster and KLMCluster objects that are being matched with Track as Particle to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 848 of file ParticleLoaderModule.cc.

849{
850 if (m_ChargedCluster2Plists.empty()) // nothing to do
851 return;
852
853 // loop over all ParticleLists
854 for (auto chargedCluster2Plist : m_ChargedCluster2Plists) {
855
856 string listName = get<c_PListName>(chargedCluster2Plist);
857 string antiListName = get<c_AntiPListName>(chargedCluster2Plist);
858 int pdgCode = get<c_PListPDGCode>(chargedCluster2Plist);
859 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(chargedCluster2Plist);
860 Const::ParticleType thisType(pdgCode);
861
862 StoreObjPtr<ParticleList> plist(listName);
863 // since a particle list in the ParticleLoader always contains all possible objects
864 // we check whether it already exists in this path and can skip any further steps if it does
865 if (plist.isValid())
866 continue;
867 plist.create();
868 plist->initialize(pdgCode, listName);
869
870 // create anti-particle list if necessary
871 if (!isSelfConjugatedParticle) {
872 StoreObjPtr<ParticleList> antiPlist(antiListName);
873 antiPlist.create();
874 antiPlist->initialize(-1 * pdgCode, antiListName);
875
876 antiPlist->bindAntiParticleList(*(plist));
877 }
878
880 if (!sourceList.isValid())
881 B2FATAL("ParticleList " << m_sourceParticleListName << " could not be found or is not valid!");
882
883 for (unsigned int iPart = 0; iPart < sourceList->getListSize(); iPart++) {
884
885 const Particle* sourcePart = sourceList->getParticle(iPart);
886 const Track* sourceTrack = sourceList->getParticle(iPart)->getTrack();
887 if (!sourceTrack)
888 continue;
889
890 // ECL clusters
892
893 const ECLCluster* cluster = sourcePart->getECLCluster();
894 if (isValidECLCluster(cluster, pdgCode, false)) {
895 Particle particle(cluster, thisType);
896 if (particle.getParticleSource() != Particle::c_ECLCluster) {
897 B2FATAL("Particle created from ECLCluster does not have ECLCluster type.");
898 }
899 Particle* newPart = m_particles.appendNew(particle);
900 assignMCParticleFromECLCluster(newPart, cluster);
901 plist->addParticle(newPart);
902 }
903 } else {
904
905 // loop over all clusters matched to this track
906 const RelationVector<ECLCluster> clusters = sourceTrack->getRelationsTo<ECLCluster>();
907 for (unsigned int iCluster = 0; iCluster < clusters.size(); iCluster++) {
908 const ECLCluster* cluster = clusters[iCluster];
909 if (!isValidECLCluster(cluster, pdgCode, false))
910 continue; // go to next iCluster
911
912 Particle particle(cluster, thisType);
913 if (particle.getParticleSource() != Particle::c_ECLCluster) {
914 B2FATAL("Particle created from ECLCluster does not have ECLCluster type.");
915 }
916 Particle* newPart = m_particles.appendNew(particle);
917 assignMCParticleFromECLCluster(newPart, cluster);
918 plist->addParticle(newPart);
919 }
920 }
921
922 // KLM clusters
923 const KLMCluster* cluster = sourcePart->getKLMCluster();
924 if (!cluster) continue; // go to next iPart
925
926 if (std::isnan(cluster->getMomentumMag())) {
927 B2DEBUG(19, "Skipping KLMCluster because its momentum is NaN. "
928 "This can happen if the timing calibration is missing or wrong, so that the velocity is calculated to be negative.");
929 continue;
930 }
931
932 // create particle and check its type before adding it to list
933 Particle particle(cluster, pdgCode);
934 if (particle.getParticleSource() != Particle::c_KLMCluster) {
935 B2FATAL("Particle created from KLMCluster does not have KLMCluster type.");
936 }
937 Particle* newPart = m_particles.appendNew(particle);
938
939 const MCParticle* mcParticle = cluster->getRelated<MCParticle>();
940 if (mcParticle) newPart->addRelationTo(mcParticle);
941
942 plist->addParticle(newPart);
943 }
944
945 } // loop over particle lists
946}
The ParticleType class for identifying different particle types.
Definition: Const.h:408
ECL cluster data.
Definition: ECLCluster.h:27
KLM cluster data.
Definition: KLMCluster.h:28
bool isValidECLCluster(const ECLCluster *cluster, const int pdgCode, bool onlyNeutral) const
Checks if the given ECLCluster is valid for the pdgCode.
std::vector< PList > m_ChargedCluster2Plists
Collection of PLists that will collect Particles created from charged-cluster.
void assignMCParticleFromECLCluster(Particle *newPart, const ECLCluster *cluster) const
Assigns the MCParticle relation to the newPart.
const KLMCluster * getKLMCluster() const
Returns the pointer to the KLMCluster object that was used to create this Particle (ParticleType == c...
Definition: Particle.cc:926
const ECLCluster * getECLCluster() const
Returns the pointer to the ECLCluster object that was used to create this Particle (if ParticleType =...
Definition: Particle.cc:891
RelationVector< TO > getRelationsTo(const std::string &name="", const std::string &namedRelation="") const
Get the relations that point from this object to another store array.
Class that bundles various TrackFitResults.
Definition: Track.h:25

◆ clone()

std::shared_ptr< PathElement > clone ( ) const
overridevirtualinherited

Create an independent copy of this module.

Note that parameters are shared, so changing them on a cloned module will also affect the original module.

Implements PathElement.

Definition at line 179 of file Module.cc.

180{
182 newModule->m_moduleParamList.setParameters(getParamList());
183 newModule->setName(getName());
184 newModule->m_package = m_package;
185 newModule->m_propertyFlags = m_propertyFlags;
186 newModule->m_logConfig = m_logConfig;
187 newModule->m_conditions = m_conditions;
188
189 return newModule;
190}
std::shared_ptr< Module > registerModule(const std::string &moduleName, std::string sharedLibPath="") noexcept(false)
Creates an instance of a module and registers it to the ModuleManager.
static ModuleManager & Instance()
Exception is thrown if the requested module could not be created by the ModuleManager.
const ModuleParamList & getParamList() const
Return module param list.
Definition: Module.h:363
const std::string & getName() const
Returns the name of the module.
Definition: Module.h:187
const std::string & getType() const
Returns the type of the module (i.e.
Definition: Module.cc:41
unsigned int m_propertyFlags
The properties of the module as bitwise or (with |) of EModulePropFlags.
Definition: Module.h:512
LogConfig m_logConfig
The log system configuration of the module.
Definition: Module.h:514
std::vector< ModuleCondition > m_conditions
Module condition, only non-null if set.
Definition: Module.h:521
std::string m_package
Package this module is found in (may be empty).
Definition: Module.h:510
std::shared_ptr< Module > ModulePtr
Defines a pointer to a module object as a boost shared pointer.
Definition: Module.h:43

◆ def_beginRun()

virtual void def_beginRun ( )
inlineprotectedvirtualinherited

Wrapper method for the virtual function beginRun() that has the implementation to be used in a call from Python.

Reimplemented in PyModule.

Definition at line 426 of file Module.h.

426{ beginRun(); }
virtual void beginRun()
Called when entering a new run.
Definition: Module.h:147

◆ def_endRun()

virtual void def_endRun ( )
inlineprotectedvirtualinherited

This method can receive that the current run ends as a call from the Python side.

For regular C++-Modules that forwards the call to the regular endRun() method.

Reimplemented in PyModule.

Definition at line 439 of file Module.h.

439{ endRun(); }
virtual void endRun()
This method is called if the current run ends.
Definition: Module.h:166

◆ def_event()

virtual void def_event ( )
inlineprotectedvirtualinherited

Wrapper method for the virtual function event() that has the implementation to be used in a call from Python.

Reimplemented in PyModule.

Definition at line 432 of file Module.h.

432{ event(); }
virtual void event()
This method is the core of the module.
Definition: Module.h:157

◆ def_initialize()

virtual void def_initialize ( )
inlineprotectedvirtualinherited

Wrappers to make the methods without "def_" prefix callable from Python.

Overridden in PyModule. Wrapper method for the virtual function initialize() that has the implementation to be used in a call from Python.

Reimplemented in PyModule.

Definition at line 420 of file Module.h.

420{ initialize(); }
virtual void initialize()
Initialize the Module.
Definition: Module.h:109

◆ def_terminate()

virtual void def_terminate ( )
inlineprotectedvirtualinherited

Wrapper method for the virtual function terminate() that has the implementation to be used in a call from Python.

Reimplemented in PyModule.

Definition at line 445 of file Module.h.

445{ terminate(); }
virtual void terminate()
This method is called at the end of the event processing.
Definition: Module.h:176

◆ dummyToParticles()

void dummyToParticles ( )
private

Loads dummy object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 331 of file ParticleLoaderModule.cc.

332{
333 if (m_Dummies2Plists.empty()) // nothing to do
334 return;
335 if (m_Dummies2Plists.size() != 1)
336 B2ERROR("ParticleLoaderModule::dummyToParticles Multiple particle lists are not supported!");
337 auto dummy2Plist = m_Dummies2Plists[0];
338 string dummyListName = get<c_PListName>(dummy2Plist);
339 string antiDummyListName = get<c_AntiPListName>(dummy2Plist);
340 int pdgCode = get<c_PListPDGCode>(dummy2Plist);
341 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(dummy2Plist);
342
343 StoreObjPtr<ParticleList> plist(dummyListName);
344 plist.create();
345 plist->initialize(pdgCode, dummyListName);
346
347 if (!isSelfConjugatedParticle) {
348 StoreObjPtr<ParticleList> antiPlist(antiDummyListName);
349 antiPlist.create();
350 antiPlist->initialize(-1 * pdgCode, antiDummyListName);
351 antiPlist->bindAntiParticleList(*(plist));
352 }
353
354 TMatrixFSym covariance(7);
355 for (int row = 0; row < 7; ++row) { //diag
356 covariance(row, row) = m_dummyCovMatrix;
357 }
358
359 Particle* newPart = nullptr;
360 Particle* newAntiPart = nullptr;
361
362 auto isFlavored = (isSelfConjugatedParticle) ? Particle::EFlavorType::c_Unflavored : Particle::EFlavorType::c_Flavored;
363
364 ROOT::Math::PxPyPzEVector zero4Vector = {0., 0., 0., 0.};
365
366 newPart = m_particles.appendNew(zero4Vector, pdgCode, isFlavored, Particle::EParticleSourceObject::c_NoMDSTSource,
368 if (m_dummyCovMatrix > 0.) newPart->setMomentumVertexErrorMatrix(covariance);
369 if (m_dummyTreatAsInvisible) newPart->writeExtraInfo("treeFitterTreatMeAsInvisible", 1);
370 plist->addParticle(newPart);
371
372 if (!isSelfConjugatedParticle) {
373 newAntiPart = m_particles.appendNew(zero4Vector, -pdgCode, isFlavored, Particle::EParticleSourceObject::c_NoMDSTSource,
375 if (m_dummyCovMatrix > 0.) newAntiPart->setMomentumVertexErrorMatrix(covariance);
376 if (m_dummyTreatAsInvisible) newAntiPart->writeExtraInfo("treeFitterTreatMeAsInvisible", 1);
377 plist->addParticle(newAntiPart);
378 }
379
380}
std::vector< PList > m_Dummies2Plists
Collection of PLists that will collect Particles created from Dummies.
void writeExtraInfo(const std::string &name, const double value)
Sets the user defined extraInfo.
Definition: Particle.cc:1308
void setMomentumVertexErrorMatrix(const TMatrixFSym &errMatrix)
Sets 7x7 error matrix.
Definition: Particle.cc:393

◆ eclAndKLMClustersToParticles()

void eclAndKLMClustersToParticles ( )
private

Loads ECLCluster and KLMCluster object as Particle to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 698 of file ParticleLoaderModule.cc.

699{
700 if (m_ECLKLMClusters2Plists.empty()) // nothing to do
701 return;
702
703 // loop over all ParticleLists
704 for (auto eclKLMCluster2Plist : m_ECLKLMClusters2Plists) {
705 string listName = get<c_PListName>(eclKLMCluster2Plist);
706 string antiListName = get<c_AntiPListName>(eclKLMCluster2Plist);
707 int pdgCode = get<c_PListPDGCode>(eclKLMCluster2Plist);
708 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(eclKLMCluster2Plist);
709 Const::ParticleType thisType(pdgCode);
710
711 StoreObjPtr<ParticleList> plist(listName);
712 // since a particle list in the ParticleLoader always contains all possible objects
713 // we check whether it already exists in this path and can skip any further steps if it does
714 if (plist.isValid())
715 continue;
716 plist.create();
717 plist->initialize(pdgCode, listName);
718
719 // create anti-particle list if necessary
720 if (!isSelfConjugatedParticle) {
721 StoreObjPtr<ParticleList> antiPlist(antiListName);
722 antiPlist.create();
723 antiPlist->initialize(-1 * pdgCode, antiListName);
724
725 antiPlist->bindAntiParticleList(*(plist));
726 }
727
728 plist->setEditable(true); // :all list is originally reserved. we have to set it as editable.
729
730 // load reconstructed neutral ECL clusters as photons or Klongs or neutrons
731 for (int i = 0; i < m_eclclusters.getEntries(); i++) {
732 const ECLCluster* cluster = m_eclclusters[i];
733
734 if (!isValidECLCluster(cluster, pdgCode, true))
735 continue;
736
737 // create particle and check it before adding to list
738 Particle particle(cluster, thisType);
739 if (particle.getParticleSource() != Particle::c_ECLCluster) {
740 B2FATAL("Particle created from ECLCluster does not have ECLCluster type.");
741 continue;
742 }
743 Particle* newPart = m_particles.appendNew(particle);
744
745 assignMCParticleFromECLCluster(newPart, cluster);
746
747 // add particle to list
748 plist->addParticle(newPart);
749 }
750
751 // load reconstructed KLM clusters as Klongs or neutrons or photons
752 for (int i = 0; i < m_klmclusters.getEntries(); i++) {
753 const KLMCluster* cluster = m_klmclusters[i];
754
755 if (std::isnan(cluster->getMomentumMag())) {
756 B2DEBUG(19, "Skipping KLMCluster because its momentum is NaN. "
757 "This can happen if the timing calibration is missing or wrong, so that the velocity is calculated to be negative.");
758 continue;
759 }
760
761 const MCParticle* mcParticle = cluster->getRelated<MCParticle>();
762
763 // create particle and check its type before adding it to list
764 Particle particle(cluster, pdgCode);
765 if (particle.getParticleSource() != Particle::c_KLMCluster) {
766 B2FATAL("Particle created from KLMCluster does not have KLMCluster type.");
767 }
768 Particle* newPart = m_particles.appendNew(particle);
769
770 if (mcParticle)
771 newPart->addRelationTo(mcParticle);
772
773 // add particle to list
774 plist->addParticle(newPart);
775 }
776
777 plist->setEditable(false); // set the :all list as not editable.
778 } // loop over particle lists
779}
std::vector< PList > m_ECLKLMClusters2Plists
Collection of PLists that will collect Particles created from ECLClusters and KLMClusters.
StoreArray< KLMCluster > m_klmclusters
StoreArray of KLMCluster.
StoreArray< ECLCluster > m_eclclusters
StoreArray of ECLCluster.

◆ endRun()

virtual void endRun ( )
inlinevirtualinherited

◆ evalCondition()

bool evalCondition ( ) const
inherited

If at least one condition was set, it is evaluated and true returned if at least one condition returns true.

If no condition or result value was defined, the method returns false. Otherwise, the condition is evaluated and true returned, if at least one condition returns true. To speed up the evaluation, the condition strings were already parsed in the method if_value().

Returns
True if at least one condition and return value exists and at least one condition expression was evaluated to true.

Definition at line 96 of file Module.cc.

97{
98 if (m_conditions.empty()) return false;
99
100 //okay, a condition was set for this Module...
101 if (!m_hasReturnValue) {
102 B2FATAL("A condition was set for '" << getName() << "', but the module did not set a return value!");
103 }
104
105 for (const auto& condition : m_conditions) {
106 if (condition.evaluate(m_returnValue)) {
107 return true;
108 }
109 }
110 return false;
111}
int m_returnValue
The return value.
Definition: Module.h:519
bool m_hasReturnValue
True, if the return value is set.
Definition: Module.h:518

◆ event()

void event ( )
overridevirtual

Event processor.

Reimplemented from Module.

Definition at line 289 of file ParticleLoaderModule.cc.

290{
291 if (not m_particleExtraInfoMap) {
292 m_particleExtraInfoMap.create();
293 }
294
295 if (m_useROEs)
297 else if (m_useDummy)
299 else if (m_useMCParticles)
301 else if (m_loadChargedCluster)
303 else {
307 }
308}
void mcParticlesToParticles()
Loads specified MCParticles as Particle to StoreArray<Particle>
void v0sToParticles()
Loads V0 object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList...
void roeToParticles()
Loads ROE object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleLis...
void tracksToParticles()
Loads Track object as Particle to StoreArray<Particle> and adds it to the ParticleList.
StoreObjPtr< ParticleExtraInfoMap > m_particleExtraInfoMap
object pointer to extra info map
void dummyToParticles()
Loads dummy object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleL...
void chargedClustersToParticles()
Loads ECLCluster and KLMCluster objects that are being matched with Track as Particle to StoreArray<P...
void eclAndKLMClustersToParticles()
Loads ECLCluster and KLMCluster object as Particle to StoreArray<Particle> and adds it to the Particl...

◆ exposePythonAPI()

void exposePythonAPI ( )
staticinherited

Exposes methods of the Module class to Python.

Definition at line 325 of file Module.cc.

326{
327 // to avoid confusion between std::arg and boost::python::arg we want a shorthand namespace as well
328 namespace bp = boost::python;
329
330 docstring_options options(true, true, false); //userdef, py sigs, c++ sigs
331
332 void (Module::*setReturnValueInt)(int) = &Module::setReturnValue;
333
334 enum_<Module::EAfterConditionPath>("AfterConditionPath",
335 R"(Determines execution behaviour after a conditional path has been executed:
336
337.. attribute:: END
338
339 End processing of this path after the conditional path. (this is the default for if_value() etc.)
340
341.. attribute:: CONTINUE
342
343 After the conditional path, resume execution after this module.)")
344 .value("END", Module::EAfterConditionPath::c_End)
345 .value("CONTINUE", Module::EAfterConditionPath::c_Continue)
346 ;
347
348 /* Do not change the names of >, <, ... we use them to serialize conditional pathes */
349 enum_<Belle2::ModuleCondition::EConditionOperators>("ConditionOperator")
356 ;
357
358 enum_<Module::EModulePropFlags>("ModulePropFlags",
359 R"(Flags to indicate certain low-level features of modules, see :func:`Module.set_property_flags()`, :func:`Module.has_properties()`. Most useful flags are:
360
361.. attribute:: PARALLELPROCESSINGCERTIFIED
362
363 This module can be run in parallel processing mode safely (All I/O must be done through the data store, in particular, the module must not write any files.)
364
365.. attribute:: HISTOGRAMMANAGER
366
367 This module is used to manage histograms accumulated by other modules
368
369.. attribute:: TERMINATEINALLPROCESSES
370
371 When using parallel processing, call this module's terminate() function in all processes. This will also ensure that there is exactly one process (single-core if no parallel modules found) or at least one input, one main and one output process.
372)")
373 .value("INPUT", Module::EModulePropFlags::c_Input)
374 .value("OUTPUT", Module::EModulePropFlags::c_Output)
375 .value("PARALLELPROCESSINGCERTIFIED", Module::EModulePropFlags::c_ParallelProcessingCertified)
376 .value("HISTOGRAMMANAGER", Module::EModulePropFlags::c_HistogramManager)
377 .value("INTERNALSERIALIZER", Module::EModulePropFlags::c_InternalSerializer)
378 .value("TERMINATEINALLPROCESSES", Module::EModulePropFlags::c_TerminateInAllProcesses)
379 ;
380
381 //Python class definition
382 class_<Module, PyModule> module("Module", R"(
383Base class for Modules.
384
385A module is the smallest building block of the framework.
386A typical event processing chain consists of a Path containing
387modules. By inheriting from this base class, various types of
388modules can be created. To use a module, please refer to
389:func:`Path.add_module()`. A list of modules is available by running
390``basf2 -m`` or ``basf2 -m package``, detailed information on parameters is
391given by e.g. ``basf2 -m RootInput``.
392
393The 'Module Development' section in the manual provides detailed information
394on how to create modules, setting parameters, or using return values/conditions:
395https://confluence.desy.de/display/BI/Software+Basf2manual#Module_Development
396
397)");
398 module
399 .def("__str__", &Module::getPathString)
400 .def("name", &Module::getName, return_value_policy<copy_const_reference>(),
401 "Returns the name of the module. Can be changed via :func:`set_name() <Module.set_name()>`, use :func:`type() <Module.type()>` for identifying a particular module class.")
402 .def("type", &Module::getType, return_value_policy<copy_const_reference>(),
403 "Returns the type of the module (i.e. class name minus 'Module')")
404 .def("set_name", &Module::setName, args("name"), R"(
405Set custom name, e.g. to distinguish multiple modules of the same type.
406
407>>> path.add_module('EventInfoSetter')
408>>> ro = path.add_module('RootOutput', branchNames=['EventMetaData'])
409>>> ro.set_name('RootOutput_metadata_only')
410>>> print(path)
411[EventInfoSetter -> RootOutput_metadata_only]
412
413)")
414 .def("description", &Module::getDescription, return_value_policy<copy_const_reference>(),
415 "Returns the description of this module.")
416 .def("package", &Module::getPackage, return_value_policy<copy_const_reference>(),
417 "Returns the package this module belongs to.")
418 .def("available_params", &_getParamInfoListPython,
419 "Return list of all module parameters as `ModuleParamInfo` instances")
420 .def("has_properties", &Module::hasProperties, (bp::arg("properties")),
421 R"DOCSTRING(Allows to check if the module has the given properties out of `ModulePropFlags` set.
422
423>>> if module.has_properties(ModulePropFlags.PARALLELPROCESSINGCERTIFIED):
424>>> ...
425
426Parameters:
427 properties (int): bitmask of `ModulePropFlags` to check for.
428)DOCSTRING")
429 .def("set_property_flags", &Module::setPropertyFlags, args("property_mask"),
430 "Set module properties in the form of an OR combination of `ModulePropFlags`.");
431 {
432 // python signature is too crowded, make ourselves
433 docstring_options subOptions(true, false, false); //userdef, py sigs, c++ sigs
434 module
435 .def("if_value", &Module::if_value,
436 (bp::arg("expression"), bp::arg("condition_path"), bp::arg("after_condition_path")= Module::EAfterConditionPath::c_End),
437 R"DOCSTRING(if_value(expression, condition_path, after_condition_path=AfterConditionPath.END)
438
439Sets a conditional sub path which will be executed after this
440module if the return value set in the module passes the given ``expression``.
441
442Modules can define a return value (int or bool) using ``setReturnValue()``,
443which can be used in the steering file to split the Path based on this value, for example
444
445>>> module_with_condition.if_value("<1", another_path)
446
447In case the return value of the ``module_with_condition`` for a given event is
448less than 1, the execution will be diverted into ``another_path`` for this event.
449
450You could for example set a special return value if an error occurs, and divert
451the execution into a path containing :b2:mod:`RootOutput` if it is found;
452saving only the data producing/produced by the error.
453
454After a conditional path has executed, basf2 will by default stop processing
455the path for this event. This behaviour can be changed by setting the
456``after_condition_path`` argument.
457
458Parameters:
459 expression (str): Expression to determine if the conditional path should be executed.
460 This should be one of the comparison operators ``<``, ``>``, ``<=``,
461 ``>=``, ``==``, or ``!=`` followed by a numerical value for the return value
462 condition_path (Path): path to execute in case the expression is fulfilled
463 after_condition_path (AfterConditionPath): What to do once the ``condition_path`` has been executed.
464)DOCSTRING")
465 .def("if_false", &Module::if_false,
466 (bp::arg("condition_path"), bp::arg("after_condition_path")= Module::EAfterConditionPath::c_End),
467 R"DOC(if_false(condition_path, after_condition_path=AfterConditionPath.END)
468
469Sets a conditional sub path which will be executed after this module if
470the return value of the module evaluates to False. This is equivalent to
471calling `if_value` with ``expression=\"<1\"``)DOC")
472 .def("if_true", &Module::if_true,
473 (bp::arg("condition_path"), bp::arg("after_condition_path")= Module::EAfterConditionPath::c_End),
474 R"DOC(if_true(condition_path, after_condition_path=AfterConditionPath.END)
475
476Sets a conditional sub path which will be executed after this module if
477the return value of the module evaluates to True. It is equivalent to
478calling `if_value` with ``expression=\">=1\"``)DOC");
479 }
480 module
481 .def("has_condition", &Module::hasCondition,
482 "Return true if a conditional path has been set for this module "
483 "using `if_value`, `if_true` or `if_false`")
484 .def("get_all_condition_paths", &_getAllConditionPathsPython,
485 "Return a list of all conditional paths set for this module using "
486 "`if_value`, `if_true` or `if_false`")
487 .def("get_all_conditions", &_getAllConditionsPython,
488 "Return a list of all conditional path expressions set for this module using "
489 "`if_value`, `if_true` or `if_false`")
490 .add_property("logging", make_function(&Module::getLogConfig, return_value_policy<reference_existing_object>()),
@ c_GE
Greater or equal than: ">=".
@ c_SE
Smaller or equal than: "<=".
@ c_GT
Greater than: ">"
@ c_NE
Not equal: "!=".
@ c_EQ
Equal: "=" or "=="
@ c_ST
Smaller than: "<"
Base class for Modules.
Definition: Module.h:72
LogConfig & getLogConfig()
Returns the log system configuration.
Definition: Module.h:225
void if_value(const std::string &expression, const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
Add a condition to the module.
Definition: Module.cc:79
void if_true(const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
A simplified version to set the condition of the module.
Definition: Module.cc:90
void setReturnValue(int value)
Sets the return value for this module as integer.
Definition: Module.cc:220
void setLogConfig(const LogConfig &logConfig)
Set the log system configuration.
Definition: Module.h:230
const std::string & getDescription() const
Returns the description of the module.
Definition: Module.h:202
void if_false(const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
A simplified version to add a condition to the module.
Definition: Module.cc:85
bool hasCondition() const
Returns true if at least one condition was set for the module.
Definition: Module.h:311
const std::string & getPackage() const
Returns the package this module is in.
Definition: Module.h:197
void setName(const std::string &name)
Set the name of the module.
Definition: Module.h:214
bool hasProperties(unsigned int propertyFlags) const
Returns true if all specified property flags are available in this module.
Definition: Module.cc:160
std::string getPathString() const override
return the module name.
Definition: Module.cc:192

◆ getAfterConditionPath()

Module::EAfterConditionPath getAfterConditionPath ( ) const
inherited

What to do after the conditional path is finished.

(defaults to c_End if no condition is set)

Definition at line 133 of file Module.cc.

134{
135 if (m_conditions.empty()) return EAfterConditionPath::c_End;
136
137 //okay, a condition was set for this Module...
138 if (!m_hasReturnValue) {
139 B2FATAL("A condition was set for '" << getName() << "', but the module did not set a return value!");
140 }
141
142 for (const auto& condition : m_conditions) {
143 if (condition.evaluate(m_returnValue)) {
144 return condition.getAfterConditionPath();
145 }
146 }
147
148 return EAfterConditionPath::c_End;
149}

◆ getAllConditionPaths()

std::vector< std::shared_ptr< Path > > getAllConditionPaths ( ) const
inherited

Return all condition paths currently set (no matter if the condition is true or not).

Definition at line 150 of file Module.cc.

151{
152 std::vector<std::shared_ptr<Path>> allConditionPaths;
153 for (const auto& condition : m_conditions) {
154 allConditionPaths.push_back(condition.getPath());
155 }
156
157 return allConditionPaths;
158}

◆ getAllConditions()

const std::vector< ModuleCondition > & getAllConditions ( ) const
inlineinherited

Return all set conditions for this module.

Definition at line 324 of file Module.h.

325 {
326 return m_conditions;
327 }

◆ getCondition()

const ModuleCondition * getCondition ( ) const
inlineinherited

Return a pointer to the first condition (or nullptr, if none was set)

Definition at line 314 of file Module.h.

315 {
316 if (m_conditions.empty()) {
317 return nullptr;
318 } else {
319 return &m_conditions.front();
320 }
321 }

◆ getConditionPath()

std::shared_ptr< Path > getConditionPath ( ) const
inherited

Returns the path of the last true condition (if there is at least one, else reaturn a null pointer).


Definition at line 113 of file Module.cc.

114{
115 PathPtr p;
116 if (m_conditions.empty()) return p;
117
118 //okay, a condition was set for this Module...
119 if (!m_hasReturnValue) {
120 B2FATAL("A condition was set for '" << getName() << "', but the module did not set a return value!");
121 }
122
123 for (const auto& condition : m_conditions) {
124 if (condition.evaluate(m_returnValue)) {
125 return condition.getPath();
126 }
127 }
128
129 // if none of the conditions were true, return a null pointer.
130 return p;
131}
std::shared_ptr< Path > PathPtr
Defines a pointer to a path object as a boost shared pointer.
Definition: Path.h:35

◆ getDescription()

const std::string & getDescription ( ) const
inlineinherited

Returns the description of the module.

Definition at line 202 of file Module.h.

202{return m_description;}
std::string m_description
The description of the module.
Definition: Module.h:511

◆ getFileNames()

virtual std::vector< std::string > getFileNames ( bool  outputFiles)
inlinevirtualinherited

Return a list of output filenames for this modules.

This will be called when basf2 is run with "--dry-run" if the module has set either the c_Input or c_Output properties.

If the parameter outputFiles is false (for modules with c_Input) the list of input filenames should be returned (if any). If outputFiles is true (for modules with c_Output) the list of output files should be returned (if any).

If a module has sat both properties this member is called twice, once for each property.

The module should return the actual list of requested input or produced output filenames (including handling of input/output overrides) so that the grid system can handle input/output files correctly.

This function should return the same value when called multiple times. This is especially important when taking the input/output overrides from Environment as they get consumed when obtained so the finalized list of output files should be stored for subsequent calls.

Reimplemented in RootInputModule, and RootOutputModule.

Definition at line 134 of file Module.h.

135 {
136 return std::vector<std::string>();
137 }

◆ getLogConfig()

LogConfig & getLogConfig ( )
inlineinherited

Returns the log system configuration.

Definition at line 225 of file Module.h.

225{return m_logConfig;}

◆ getModules()

std::list< ModulePtr > getModules ( ) const
inlineoverrideprivatevirtualinherited

no submodules, return empty list

Implements PathElement.

Definition at line 506 of file Module.h.

506{ return std::list<ModulePtr>(); }

◆ getName()

const std::string & getName ( ) const
inlineinherited

Returns the name of the module.

This can be changed via e.g. set_name() in the steering file to give more useful names if there is more than one module of the same type.

For identifying the type of a module, using getType() (or type() in Python) is recommended.

Definition at line 187 of file Module.h.

187{return m_name;}
std::string m_name
The name of the module, saved as a string (user-modifiable)
Definition: Module.h:508

◆ getPackage()

const std::string & getPackage ( ) const
inlineinherited

Returns the package this module is in.

Definition at line 197 of file Module.h.

197{return m_package;}

◆ getParamInfoListPython()

std::shared_ptr< boost::python::list > getParamInfoListPython ( ) const
inherited

Returns a python list of all parameters.

Each item in the list consists of the name of the parameter, a string describing its type, a python list of all default values and the description of the parameter.

Returns
A python list containing the parameters of this parameter list.

Definition at line 279 of file Module.cc.

280{
282}
std::shared_ptr< boost::python::list > getParamInfoListPython() const
Returns a python list of all parameters.
ModuleParamList m_moduleParamList
List storing and managing all parameter of the module.
Definition: Module.h:516

◆ getParamList()

const ModuleParamList & getParamList ( ) const
inlineinherited

Return module param list.

Definition at line 363 of file Module.h.

363{ return m_moduleParamList; }

◆ getPathString()

std::string getPathString ( ) const
overrideprivatevirtualinherited

return the module name.

Implements PathElement.

Definition at line 192 of file Module.cc.

193{
194
195 std::string output = getName();
196
197 for (const auto& condition : m_conditions) {
198 output += condition.getString();
199 }
200
201 return output;
202}

◆ getReturnValue()

int getReturnValue ( ) const
inlineinherited

Return the return value set by this module.

This value is only meaningful if hasReturnValue() is true

Definition at line 381 of file Module.h.

381{ return m_returnValue; }

◆ getType()

const std::string & getType ( ) const
inherited

Returns the type of the module (i.e.

class name minus 'Module')

Definition at line 41 of file Module.cc.

42{
43 if (m_type.empty())
44 B2FATAL("Module type not set for " << getName());
45 return m_type;
46}
std::string m_type
The type of the module, saved as a string.
Definition: Module.h:509

◆ hasCondition()

bool hasCondition ( ) const
inlineinherited

Returns true if at least one condition was set for the module.

Definition at line 311 of file Module.h.

311{ return not m_conditions.empty(); };

◆ hasProperties()

bool hasProperties ( unsigned int  propertyFlags) const
inherited

Returns true if all specified property flags are available in this module.

Parameters
propertyFlagsOred EModulePropFlags which should be compared with the module flags.

Definition at line 160 of file Module.cc.

161{
162 return (propertyFlags & m_propertyFlags) == propertyFlags;
163}

◆ hasReturnValue()

bool hasReturnValue ( ) const
inlineinherited

Return true if this module has a valid return value set.

Definition at line 378 of file Module.h.

378{ return m_hasReturnValue; }

◆ hasUnsetForcedParams()

bool hasUnsetForcedParams ( ) const
inherited

Returns true and prints error message if the module has unset parameters which the user has to set in the steering file.

Definition at line 166 of file Module.cc.

167{
169 std::string allMissing = "";
170 for (const auto& s : missing)
171 allMissing += s + " ";
172 if (!missing.empty())
173 B2ERROR("The following required parameters of Module '" << getName() << "' were not specified: " << allMissing <<
174 "\nPlease add them to your steering file.");
175 return !missing.empty();
176}
std::vector< std::string > getUnsetForcedParams() const
Returns list of unset parameters (if they are required to have a value.

◆ if_false()

void if_false ( const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

A simplified version to add a condition to the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

It is equivalent to the if_value() method, using the expression "<1". This method is meant to be used together with the setReturnValue(bool value) method.

Parameters
pathShared pointer to the Path which will be executed if the return value is false.
afterConditionPathWhat to do after executing 'path'.

Definition at line 85 of file Module.cc.

86{
87 if_value("<1", path, afterConditionPath);
88}

◆ if_true()

void if_true ( const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

A simplified version to set the condition of the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

It is equivalent to the if_value() method, using the expression ">=1". This method is meant to be used together with the setReturnValue(bool value) method.

Parameters
pathShared pointer to the Path which will be executed if the return value is true.
afterConditionPathWhat to do after executing 'path'.

Definition at line 90 of file Module.cc.

91{
92 if_value(">=1", path, afterConditionPath);
93}

◆ if_value()

void if_value ( const std::string &  expression,
const std::shared_ptr< Path > &  path,
EAfterConditionPath  afterConditionPath = EAfterConditionPath::c_End 
)
inherited

Add a condition to the module.

Please note that successive calls of this function will add more than one condition to the module. If more than one condition results in true, only the last of them will be used.

See https://confluence.desy.de/display/BI/Software+ModCondTut or ModuleCondition for a description of the syntax.

Please be careful: Avoid creating cyclic paths, e.g. by linking a condition to a path which is processed before the path where this module is located in.

Parameters
expressionThe expression of the condition.
pathShared pointer to the Path which will be executed if the condition is evaluated to true.
afterConditionPathWhat to do after executing 'path'.

Definition at line 79 of file Module.cc.

80{
81 m_conditions.emplace_back(expression, path, afterConditionPath);
82}

◆ initialize()

void initialize ( )
overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 111 of file ParticleLoaderModule.cc.

112{
113 B2INFO("ParticleLoader's Summary of Actions:");
114
115 if ((int)m_useMCParticles + (int)m_useROEs + (int)m_useDummy + (int)m_loadChargedCluster > 1)
116 B2FATAL("The options on how to load the Particle are not valid. The incompatible combination of options is selected. "
117 << "useMCParticles: " << m_useMCParticles << ", useROEs: " << m_useROEs << ", useDummy: " << m_useDummy
118 << ", loadChargedCluster: " << m_loadChargedCluster);
119
121 m_particleExtraInfoMap.registerInDataStore();
122 m_eventExtraInfo.registerInDataStore();
123 //register relations if these things exists
124 if (m_mcparticles.isOptional()) {
126 }
127 if (m_pidlikelihoods.isOptional()) {
129 }
130 if (m_trackfitresults.isOptional()) {
132 }
133
134 if (m_useMCParticles) {
135 m_mcparticles.isRequired();
136 }
137
138 if (m_useROEs) {
139 m_roes.isRequired();
140 m_roes.registerRelationTo(m_particles);
141
142 StoreArray<RestOfEvent> nestedRoes("NestedRestOfEvents");
143 if (nestedRoes.isOptional())
144 nestedRoes.registerRelationTo(m_particles);
145 }
146
147 if (m_decayStrings.empty()) {
148 B2WARNING("Obsolete usage of the ParticleLoader module (load all MDST objects as all possible Particle object types). Specify the particle type via decayStrings module parameter instead.");
149 } else {
150 for (auto decayString : m_decayStrings) {
151
152 // obtain the output particle lists from the decay string
153 const bool valid = m_decaydescriptor.init(decayString);
154 if (!valid)
155 B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString: " << decayString);
156
157 // Mother particle
159 int nProducts = m_decaydescriptor.getNDaughters();
160
161 int pdgCode = mother->getPDGCode();
162 // The default list name is "all"
163 string listName = mother->getName() + ":all";
164
165 // Full name for ROE, dummy, MCParticle, chargedCluster particles
167 listName = mother->getFullName();
168 // V0s get the label "V0"
169 else if (nProducts > 0)
170 listName = mother->getName() + ":V0";
171
172 string antiListName = ParticleListName::antiParticleListName(listName);
173 bool isSelfConjugatedParticle = (listName == antiListName);
174
175 StoreObjPtr<ParticleList> particleList(listName);
176 // if the particle list doesn't exist, we have to register it
177 if (!particleList.isOptional()) {
179 particleList.registerInDataStore(flags);
180 if (!isSelfConjugatedParticle) {
181 StoreObjPtr<ParticleList> antiParticleList(antiListName);
182 antiParticleList.registerInDataStore(flags);
183 }
184 } else if (m_useMCParticles) {
185 B2WARNING("ParticleList " << listName << " already exists and will not be created again. " <<
186 "Please note that the given options (addDaughters, skipNonPrimaryDaughters, skipNonPrimary, skipInitial) do not apply to "
187 << listName);
188 } else if (m_loadChargedCluster) {
189 B2WARNING("ParticleList " << listName << " already exists and will not be created again. " <<
190 "Please note that the given option, useOnlyMostEnergeticECLCluster, does not apply to "
191 << listName);
192 }
193
194 if (not isValidPDGCode(pdgCode) and (m_useMCParticles == false and m_useROEs == false and m_useDummy == false))
195 B2ERROR("Invalid particle type requested to be loaded. Set a valid decayString module parameter.");
196
197 // if we're not loading MCParticles and we are loading K0S, Lambdas, or photons --> ee then this decaystring is a V0
198 bool mdstSourceIsV0 = false;
199 if (!m_useMCParticles &&
200 (abs(pdgCode) == abs(Const::Kshort.getPDGCode()) || abs(pdgCode) == abs(Const::Lambda.getPDGCode())
201 || (abs(pdgCode) == abs(Const::photon.getPDGCode()) && m_addDaughters == true)))
202 mdstSourceIsV0 = true;
203
204 if (mdstSourceIsV0) {
205 if (nProducts == 2) {
206 m_properties = m_decaydescriptor.getProperty() | mother->getProperty(); // only used for V0s
208 B2ERROR("MDST source of the particle list is V0, the two daughters should have opposite charge");
209 } else {
210 B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString " << decayString
211 << ". MDST source of the particle list is V0, DecayString should contain exactly two daughters, as well as the mother particle.");
212 }
213 } else {
214 if (nProducts > 0) {
215 if (m_useROEs or m_useDummy) {
216 B2INFO("ParticleLoaderModule: Replacing the source particle list name by " <<
218 << " all other daughters will be ignored.");
220 } else {
221 B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString " << decayString
222 << ". DecayString should not contain any daughters, only the mother particle.");
223 }
224 }
225 }
226
228 B2ERROR("The sourceParticleListName is not given. The charged ParticleList is required for the chargedCluster loading.");
229
230 // add PList to corresponding collection of Lists
231 B2INFO(" o) creating (anti-)ParticleList with name: " << listName << " (" << antiListName << ")");
232 if (m_useROEs) {
233 B2INFO(" -> MDST source: RestOfEvents");
234 m_ROE2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
235 } else if (m_useDummy) {
236 B2INFO(" -> MDST source: No MDST source");
237 m_Dummies2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
238 } else if (m_useMCParticles) {
239 B2INFO(" -> MDST source: MCParticles");
240 m_MCParticles2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
241 } else if (m_loadChargedCluster) {
242 if (abs(pdgCode) == abs(Const::photon.getPDGCode()) || abs(pdgCode) == abs(Const::Klong.getPDGCode())
243 || abs(pdgCode) == abs(Const::neutron.getPDGCode())) {
244 m_ChargedCluster2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
245 B2INFO(" -> MDST source: ECLClusters and KLMClusters being matched with Tracks");
246 } else {
247 B2ERROR("The Particle type must be gamma, K_L0, or (anti-)n0 for the loadChargedCluster option.");
248 }
249 } else {
250 bool chargedFSP = Const::chargedStableSet.contains(Const::ParticleType(abs(pdgCode)));
251 if (chargedFSP) {
252 B2INFO(" -> MDST source: Tracks");
253 m_Tracks2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
254 }
255
256 if (abs(pdgCode) == abs(Const::photon.getPDGCode())) {
257 if (m_addDaughters == false) {
258 m_ECLKLMClusters2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
259 B2INFO(" -> MDST source: ECLClusters and KLMClusters");
260 } else {
261 B2INFO(" -> MDST source: V0");
262 m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
263 }
264 }
265
266 if (abs(pdgCode) == abs(Const::Kshort.getPDGCode())) {
267 B2INFO(" -> MDST source: V0");
268 m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
269 }
270
271 if (abs(pdgCode) == abs(Const::Klong.getPDGCode()) || abs(pdgCode) == abs(Const::neutron.getPDGCode())) {
272 B2INFO(" -> MDST source: exclusively KLMClusters or exclusively ECLClusters (matching between those not used)");
273 m_ECLKLMClusters2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
274 }
275
276 if (abs(pdgCode) == abs(Const::Lambda.getPDGCode())) {
277 B2INFO(" -> MDST source: V0");
278 m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle);
279 }
280 }
281 }
282 }
283
284
285 m_chargeZeroTrackCounts = std::vector<int>(m_Tracks2Plists.size(), 0);
286 m_sameChargeDaughtersV0Counts = std::vector<int>(m_V02Plists.size(), 0);
287}
bool contains(const ParticleType &p) const
Returns true if and only if the set contains 'p'.
Definition: UnitConst.cc:424
static const ParticleType neutron
neutron particle
Definition: Const.h:675
static const ParticleType Lambda
Lambda particle.
Definition: Const.h:679
static const ParticleSet chargedStableSet
set of charged stable particles
Definition: Const.h:618
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:678
static const ParticleType Kshort
K^0_S particle.
Definition: Const.h:677
static const ParticleType photon
photon particle
Definition: Const.h:673
EStoreFlags
Flags describing behaviours of objects etc.
Definition: DataStore.h:69
@ c_WriteOut
Object/array should be saved by output modules.
Definition: DataStore.h:70
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
Definition: DataStore.h:71
Represents a particle in the DecayDescriptor.
int getPDGCode() const
Return PDG code.
std::string getFullName() const
returns the full name of the particle full_name = name:label
std::string getName() const
evt.pdl name of the particle.
int getProperty() const
return property of the particle.
bool init(const std::string &str)
Initialise the DecayDescriptor from given string.
const DecayDescriptor * getDaughter(int i) const
return i-th daughter (0 based index).
int getNDaughters() const
return number of direct daughters.
int getProperty() const
return property of the particle.
const DecayDescriptorParticle * getMother() const
return mother.
StoreArray< TrackFitResult > m_trackfitresults
StoreArray of TrackFitResults.
std::vector< int > m_sameChargeDaughtersV0Counts
internally used to count the number of V0s with same charge daughters
bool isValidPDGCode(const int pdgCode)
returns true if the PDG code determined from the decayString is valid
StoreArray< PIDLikelihood > m_pidlikelihoods
StoreArray of PIDLikelihoods.
StoreArray< RestOfEvent > m_roes
StoreArray of ROEs.
std::vector< PList > m_MCParticles2Plists
Collection of PLists that will collect Particles created from MCParticles.
std::vector< PList > m_V02Plists
Collection of PLists that will collect Particles created from V0.
DecayDescriptor m_decaydescriptor
Decay descriptor for parsing the user specified DecayString.
std::vector< int > m_chargeZeroTrackCounts
internally used to count number of tracks with charge zero
std::vector< PList > m_Tracks2Plists
Collection of PLists that will collect Particles created from Tracks.
StoreObjPtr< EventExtraInfo > m_eventExtraInfo
object pointer to event extra info
int m_properties
Particle property to be assigned only on V0s.
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:140
std::string antiParticleListName(const std::string &listName)
Returns name of anti-particle-list corresponding to listName.

◆ isValidECLCluster()

bool isValidECLCluster ( const ECLCluster cluster,
const int  pdgCode,
bool  onlyNeutral 
) const
private

Checks if the given ECLCluster is valid for the pdgCode.

Definition at line 781 of file ParticleLoaderModule.cc.

782{
783 if (!cluster)
784 return false;
785
786 // ECLClusters can be reconstructed under different hypotheses, for
787 // example photons or neutral hadrons, we only load particles from these
788 // for now
789 if (!cluster->isNeutral() and onlyNeutral)
790 return false;
791
792 if (not cluster->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)
793 and not cluster->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron))
794 return false;
795
796 // don't fill photon list with clusters that don't have
797 // the nPhotons hypothesis (ECL people call this N1)
798 if (pdgCode == Const::photon.getPDGCode()
799 and not cluster->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons))
800 return false;
801
802 // don't fill a KLong nor a (anti-)neutron list with clusters that don't have the neutral
803 // hadron hypothesis set (ECL people call this N2)
804 if ((pdgCode == Const::Klong.getPDGCode() or abs(pdgCode) == Const::neutron.getPDGCode())
805 and not cluster->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron))
806 return false;
807
808 return true;
809}
@ c_nPhotons
CR is split into n photons (N1)
@ c_neutralHadron
CR is reconstructed as a neutral hadron (N2)

◆ isValidPDGCode()

bool isValidPDGCode ( const int  pdgCode)
private

returns true if the PDG code determined from the decayString is valid

Definition at line 999 of file ParticleLoaderModule.cc.

1000{
1001 bool result = false;
1002
1003 // is particle type = charged final state particle?
1004 if (Const::chargedStableSet.find(abs(pdgCode)) != Const::invalidParticle)
1005 return true;
1006
1007 if (abs(pdgCode) == abs(Const::photon.getPDGCode()))
1008 return true;
1009
1010 if (abs(pdgCode) == abs(Const::Kshort.getPDGCode()))
1011 return true;
1012
1013 if (abs(pdgCode) == abs(Const::Klong.getPDGCode()))
1014 return true;
1015
1016 if (abs(pdgCode) == abs(Const::Lambda.getPDGCode()))
1017 return true;
1018
1019 if (abs(pdgCode) == abs(Const::neutron.getPDGCode()))
1020 return true;
1021
1022 return result;
1023}
static const ParticleType invalidParticle
Invalid particle, used internally.
Definition: Const.h:681

◆ mcParticlesToParticles()

void mcParticlesToParticles ( )
private

Loads specified MCParticles as Particle to StoreArray<Particle>

Definition at line 948 of file ParticleLoaderModule.cc.

949{
950 if (m_MCParticles2Plists.empty()) // nothing to do
951 return;
952
953 // create all lists
954 for (auto mcParticle2Plist : m_MCParticles2Plists) {
955 string listName = get<c_PListName>(mcParticle2Plist);
956 string antiListName = get<c_AntiPListName>(mcParticle2Plist);
957 int pdgCode = get<c_PListPDGCode>(mcParticle2Plist);
958 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(mcParticle2Plist);
959
960 StoreObjPtr<ParticleList> plist(listName);
961 if (plist.isValid())
962 continue;
963 plist.create();
964 plist->initialize(pdgCode, listName);
965
966 if (!isSelfConjugatedParticle) {
967 StoreObjPtr<ParticleList> antiPlist(antiListName);
968 antiPlist.create();
969 antiPlist->initialize(-1 * pdgCode, antiListName);
970
971 antiPlist->bindAntiParticleList(*(plist));
972 }
973
974 for (int i = 0; i < m_mcparticles.getEntries(); i++) {
975 const MCParticle* mcParticle = m_mcparticles[i];
976
977 if (abs(pdgCode) != abs(mcParticle->getPDG()))
978 continue;
979
981 continue;
982
983 if (m_skipInitial and mcParticle->isInitial())
984 continue;
985
986 Particle particle(mcParticle);
987 Particle* newPart = m_particles.appendNew(particle);
988 newPart->addRelationTo(mcParticle);
989
990 //append the whole bottom part of the decay tree to this particle
992
993 plist->addParticle(newPart);
994 }
995
996 }
997}
bool hasStatus(unsigned short int bitmask) const
Return if specific status bit is set.
Definition: MCParticle.h:129
int getPDG() const
Return PDG code of particle.
Definition: MCParticle.h:112
bool isInitial() const
Check if particle is an initial particle such as ISR.
Definition: MCParticle.h:590

◆ roeToParticles()

void roeToParticles ( )
private

Loads ROE object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 383 of file ParticleLoaderModule.cc.

384{
385 if (m_ROE2Plists.empty()) // nothing to do
386 return;
387 // Multiple particle lists are not supported
388 auto roe2Plist = m_ROE2Plists[0];
389 string listName = get<c_PListName>(roe2Plist);
390 string antiListName = get<c_AntiPListName>(roe2Plist);
391 int pdgCode = get<c_PListPDGCode>(roe2Plist);
392 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(roe2Plist);
393
394 StoreObjPtr<ParticleList> plist(listName);
395 // since a particle list in the ParticleLoader always contains all possible objects
396 // we check whether it already exists in this path and can skip any further steps if it does
397 if (plist.isValid())
398 return;
399 plist.create();
400 plist->initialize(pdgCode, listName);
401
402 if (!isSelfConjugatedParticle) {
403 StoreObjPtr<ParticleList> antiPlist(antiListName);
404 antiPlist.create();
405 antiPlist->initialize(-1 * pdgCode, antiListName);
406 antiPlist->bindAntiParticleList(*(plist));
407 }
408 if (m_sourceParticleListName != "") {
409 // Take related ROEs from a particle list
411 if (!pList.isValid())
412 B2FATAL("ParticleList " << m_sourceParticleListName << " could not be found or is not valid!");
413
414 for (unsigned int i = 0; i < pList->getListSize(); i++) {
415 RestOfEvent* roe = pList->getParticle(i)->getRelatedTo<RestOfEvent>("ALL");
416 if (!roe) {
417 B2ERROR("ParticleList " << m_sourceParticleListName << " has no associated ROEs!");
418 } else {
419
420 if (isSelfConjugatedParticle)
421 addROEToParticleList(roe, i, pdgCode, isSelfConjugatedParticle);
422 else if (i < pList->getListSize(false))
423 addROEToParticleList(roe, i, pdgCode, isSelfConjugatedParticle);
424 else
425 addROEToParticleList(roe, i, -1 * pdgCode, isSelfConjugatedParticle);
426 }
427 }
428
429 } else {
430 // Take all ROE if no particle list provided
431 for (int i = 0; i < m_roes.getEntries(); i++) {
433 }
434 }
435}
void addROEToParticleList(RestOfEvent *roe, int mdstIndex, int pdgCode=0, bool isSelfConjugatedParticle=true)
Helper method to load ROE object as Particle.
TO * getRelatedTo(const std::string &name="", const std::string &namedRelation="") const
Get the object to which this object has a relation.
This is a general purpose class for collecting reconstructed MDST data objects that are not used in r...
Definition: RestOfEvent.h:57

◆ setAbortLevel()

void setAbortLevel ( int  abortLevel)
inherited

Configure the abort log level.

Definition at line 67 of file Module.cc.

68{
69 m_logConfig.setAbortLevel(static_cast<LogConfig::ELogLevel>(abortLevel));
70}
ELogLevel
Definition of the supported log levels.
Definition: LogConfig.h:26
void setAbortLevel(ELogLevel abortLevel)
Configure the abort level.
Definition: LogConfig.h:112

◆ setDebugLevel()

void setDebugLevel ( int  debugLevel)
inherited

Configure the debug messaging level.

Definition at line 61 of file Module.cc.

62{
63 m_logConfig.setDebugLevel(debugLevel);
64}
void setDebugLevel(int debugLevel)
Configure the debug messaging level.
Definition: LogConfig.h:98

◆ setDescription()

void setDescription ( const std::string &  description)
protectedinherited

Sets the description of the module.

Parameters
descriptionA description of the module.

Definition at line 214 of file Module.cc.

215{
216 m_description = description;
217}

◆ setLogConfig()

void setLogConfig ( const LogConfig logConfig)
inlineinherited

Set the log system configuration.

Definition at line 230 of file Module.h.

230{m_logConfig = logConfig;}

◆ setLogInfo()

void setLogInfo ( int  logLevel,
unsigned int  logInfo 
)
inherited

Configure the printed log information for the given level.

Parameters
logLevelThe log level (one of LogConfig::ELogLevel)
logInfoWhat kind of info should be printed? ORed combination of LogConfig::ELogInfo flags.

Definition at line 73 of file Module.cc.

74{
75 m_logConfig.setLogInfo(static_cast<LogConfig::ELogLevel>(logLevel), logInfo);
76}
void setLogInfo(ELogLevel logLevel, unsigned int logInfo)
Configure the printed log information for the given level.
Definition: LogConfig.h:127

◆ setLogLevel()

void setLogLevel ( int  logLevel)
inherited

Configure the log level.

Definition at line 55 of file Module.cc.

56{
57 m_logConfig.setLogLevel(static_cast<LogConfig::ELogLevel>(logLevel));
58}
void setLogLevel(ELogLevel logLevel)
Configure the log level.
Definition: LogConfig.cc:25

◆ setName()

void setName ( const std::string &  name)
inlineinherited

Set the name of the module.

Note
The module name is set when using the REG_MODULE macro, but the module can be renamed before calling process() using the set_name() function in your steering file.
Parameters
nameThe name of the module

Definition at line 214 of file Module.h.

214{ m_name = name; };

◆ setParamList()

void setParamList ( const ModuleParamList params)
inlineprotectedinherited

Replace existing parameter list.

Definition at line 501 of file Module.h.

501{ m_moduleParamList = params; }

◆ setParamPython()

void setParamPython ( const std::string &  name,
const boost::python::object &  pyObj 
)
privateinherited

Implements a method for setting boost::python objects.

The method supports the following types: list, dict, int, double, string, bool The conversion of the python object to the C++ type and the final storage of the parameter value is done in the ModuleParam class.

Parameters
nameThe unique name of the parameter.
pyObjThe object which should be converted and stored as the parameter value.

Definition at line 234 of file Module.cc.

235{
236 LogSystem& logSystem = LogSystem::Instance();
237 logSystem.updateModule(&(getLogConfig()), getName());
238 try {
240 } catch (std::runtime_error& e) {
241 throw std::runtime_error("Cannot set parameter '" + name + "' for module '"
242 + m_name + "': " + e.what());
243 }
244
245 logSystem.updateModule(nullptr);
246}
Class for logging debug, info and error messages.
Definition: LogSystem.h:46
void updateModule(const LogConfig *moduleLogConfig=nullptr, const std::string &moduleName="")
Sets the log configuration to the given module log configuration and sets the module name This method...
Definition: LogSystem.h:191
static LogSystem & Instance()
Static method to get a reference to the LogSystem instance.
Definition: LogSystem.cc:31
void setParamPython(const std::string &name, const PythonObject &pyObj)
Implements a method for setting boost::python objects.

◆ setParamPythonDict()

void setParamPythonDict ( const boost::python::dict &  dictionary)
privateinherited

Implements a method for reading the parameter values from a boost::python dictionary.

The key of the dictionary has to be the name of the parameter and the value has to be of one of the supported parameter types.

Parameters
dictionaryThe python dictionary from which the parameter values are read.

Definition at line 249 of file Module.cc.

250{
251
252 LogSystem& logSystem = LogSystem::Instance();
253 logSystem.updateModule(&(getLogConfig()), getName());
254
255 boost::python::list dictKeys = dictionary.keys();
256 int nKey = boost::python::len(dictKeys);
257
258 //Loop over all keys in the dictionary
259 for (int iKey = 0; iKey < nKey; ++iKey) {
260 boost::python::object currKey = dictKeys[iKey];
261 boost::python::extract<std::string> keyProxy(currKey);
262
263 if (keyProxy.check()) {
264 const boost::python::object& currValue = dictionary[currKey];
265 setParamPython(keyProxy, currValue);
266 } else {
267 B2ERROR("Setting the module parameters from a python dictionary: invalid key in dictionary!");
268 }
269 }
270
271 logSystem.updateModule(nullptr);
272}
void setParamPython(const std::string &name, const boost::python::object &pyObj)
Implements a method for setting boost::python objects.
Definition: Module.cc:234

◆ setPropertyFlags()

void setPropertyFlags ( unsigned int  propertyFlags)
inherited

Sets the flags for the module properties.

Parameters
propertyFlagsbitwise OR of EModulePropFlags

Definition at line 208 of file Module.cc.

209{
210 m_propertyFlags = propertyFlags;
211}

◆ setReturnValue() [1/2]

void setReturnValue ( bool  value)
protectedinherited

Sets the return value for this module as bool.

The bool value is saved as an integer with the convention 1 meaning true and 0 meaning false. The value can be used in the steering file to divide the analysis chain into several paths.

Parameters
valueThe value of the return value.

Definition at line 227 of file Module.cc.

228{
229 m_hasReturnValue = true;
230 m_returnValue = value;
231}

◆ setReturnValue() [2/2]

void setReturnValue ( int  value)
protectedinherited

Sets the return value for this module as integer.

The value can be used in the steering file to divide the analysis chain into several paths.

Parameters
valueThe value of the return value.

Definition at line 220 of file Module.cc.

221{
222 m_hasReturnValue = true;
223 m_returnValue = value;
224}

◆ setType()

void setType ( const std::string &  type)
protectedinherited

Set the module type.

Only for use by internal modules (which don't use the normal REG_MODULE mechanism).

Definition at line 48 of file Module.cc.

49{
50 if (!m_type.empty())
51 B2FATAL("Trying to change module type from " << m_type << " is not allowed, the value is assumed to be fixed.");
52 m_type = type;
53}

◆ terminate()

void terminate ( )
overridevirtual

Terminate the Module.

This method is called at the end of data processing.

Reimplemented from Module.

Definition at line 310 of file ParticleLoaderModule.cc.

311{
312 // report track errors integrated
313 for (size_t i = 0; i < m_Tracks2Plists.size(); i++)
314 if (m_chargeZeroTrackCounts[i] > 0) {
315 auto track2Plist = m_Tracks2Plists[i];
316 B2WARNING("There were " << m_chargeZeroTrackCounts[i]
317 << " tracks skipped because of zero charge for "
318 << get<c_PListName>(track2Plist));
319 }
320 // report V0 errors integrated
321 for (size_t i = 0; i < m_V02Plists.size(); i++)
323 auto v02Plist = m_V02Plists[i];
324 B2WARNING("There were " << m_sameChargeDaughtersV0Counts[i]
325 << " v0s skipped because of same charge daughters for "
326 << get<c_PListName>(v02Plist));
327 }
328}

◆ tracksToParticles()

void tracksToParticles ( )
private

Loads Track object as Particle to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 611 of file ParticleLoaderModule.cc.

612{
613 if (m_Tracks2Plists.empty()) // nothing to do
614 return;
615
616 // loop over all requested particle lists
617 for (size_t ilist = 0; ilist < m_Tracks2Plists.size(); ilist++) {
618 auto track2Plist = m_Tracks2Plists[ilist];
619 string listName = get<c_PListName>(track2Plist);
620 string antiListName = get<c_AntiPListName>(track2Plist);
621 int pdgCode = get<c_PListPDGCode>(track2Plist);
622 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(track2Plist);
623
624 StoreObjPtr<ParticleList> plist(listName);
625 // since a particle list in the ParticleLoader always contains all possible objects
626 // we check whether it already exists in this path and can skip any further steps if it does
627 if (plist.isValid())
628 continue;
629 plist.create();
630 plist->initialize(pdgCode, listName);
631
632 // if cc exists then also create and bind that list
633 if (!isSelfConjugatedParticle) {
634 StoreObjPtr<ParticleList> antiPlist(antiListName);
635 antiPlist.create();
636 antiPlist->initialize(-1 * pdgCode, antiListName);
637
638 antiPlist->bindAntiParticleList(*(plist));
639 }
640
641 plist->setEditable(true); // :all list is originally reserved. we have to set it as editable.
642
643 // the inner loop over all tracks from which Particles
644 // are created, and get sorted in the particle lists
645 for (int i = 0; i < m_tracks.getEntries(); i++) {
646 const Track* track = m_tracks[i];
647 const PIDLikelihood* pid = track->getRelated<PIDLikelihood>();
648 const auto& mcParticleWithWeight = track->getRelatedToWithWeight<MCParticle>();
649
650 // if a special track hypothesis is requested, use it
651 if (m_trackHypothesis != 0) pdgCode = m_trackHypothesis;
652 Const::ChargedStable type(abs(pdgCode));
653
654 // load the TrackFitResult for the requested particle or if not available use
655 // the one with the closest mass
656 const TrackFitResult* trackFit = track->getTrackFitResultWithClosestMass(type);
657
658 if (!trackFit) { // should never happen with the "closest mass" getter - leave as a sanity check
659 B2WARNING("Track returned null TrackFitResult pointer for ChargedStable::getPDGCode() = " << type.getPDGCode());
660 continue;
661 }
662
663 if (m_enforceFitHypothesis && (trackFit->getParticleType().getPDGCode() != type.getPDGCode())) {
664 // the required hypothesis does not exist for this track, skip it
665 continue;
666 }
667
668 // charge zero tracks can appear, filter them and
669 // count number of tracks filtered out
670 int charge = trackFit->getChargeSign();
671 if (charge == 0) {
672 B2DEBUG(19, "Track with charge = 0 skipped!");
674 continue;
675 }
676
677 // create particle and add it to the Particle list.
678 Particle particle(track->getArrayIndex(), trackFit, type);
679
680 if (particle.getParticleSource() == Particle::c_Track) { // should always hold but...
681
682 Particle* newPart = m_particles.appendNew(particle);
683 if (pid)
684 newPart->addRelationTo(pid);
685 if (mcParticleWithWeight.first)
686 newPart->addRelationTo(mcParticleWithWeight.first, mcParticleWithWeight.second);
687 newPart->addRelationTo(trackFit);
688
689 plist->addParticle(newPart);
690
691 } // sanity check correct particle type
692 } // loop over tracks
693
694 plist->setEditable(false); // set the :all list as not editable.
695 } // particle lists
696}
Provides a type-safe way to pass members of the chargedStableSet set.
Definition: Const.h:589
int getPDGCode() const
PDG code.
Definition: Const.h:473
Class to collect log likelihoods from TOP, ARICH, dEdx, ECL and KLM aimed for output to mdst includes...
Definition: PIDLikelihood.h:29
StoreArray< Track > m_tracks
StoreArray of Tracks.
Values of the result of a track fit with a given particle hypothesis.
short getChargeSign() const
Return track charge (1 or -1).
Const::ParticleType getParticleType() const
Getter for ParticleType of the mass hypothesis of the track fit.
double charge(int pdgCode)
Returns electric charge of a particle with given pdg code.
Definition: EvtPDLUtil.cc:44

◆ v0sToParticles()

void v0sToParticles ( )
private

Loads V0 object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.

Definition at line 467 of file ParticleLoaderModule.cc.

468{
469 if (m_V02Plists.empty()) // nothing to do
470 return;
471
472 // check if the order of the daughters in the decay string (decided by the user) is the same as the v0 daughters' order (fixed)
473 bool matchingDaughtersOrder = true;
476 matchingDaughtersOrder = false;
477
478 // loop over all ParticleLists
479 for (size_t ilist = 0; ilist < m_V02Plists.size(); ilist++) {
480 auto v02Plist = m_V02Plists[ilist];
481 string listName = get<c_PListName>(v02Plist);
482 string antiListName = get<c_AntiPListName>(v02Plist);
483 int pdgCode = get<c_PListPDGCode>(v02Plist);
484 bool isSelfConjugatedParticle = get<c_IsPListSelfConjugated>(v02Plist);
485
486 StoreObjPtr<ParticleList> plist(listName);
487 // since a particle list in the ParticleLoader always contains all possible objects
488 // we check whether it already exists in this path and can skip any further steps if it does
489 if (plist.isValid())
490 continue;
491 plist.create();
492 plist->initialize(pdgCode, listName);
493
494 if (!isSelfConjugatedParticle) {
495 StoreObjPtr<ParticleList> antiPlist(antiListName);
496 antiPlist.create();
497 antiPlist->initialize(-1 * pdgCode, antiListName);
498
499 antiPlist->bindAntiParticleList(*(plist));
500 }
501
502 plist->setEditable(true); // :V0 list is originally reserved. we have to set it as editable.
503
504 // load reconstructed V0s as Kshorts (pi-pi+ combination), Lambdas (p+pi- combinations), and converted photons (e-e+ combinations)
505 for (int i = 0; i < m_v0s.getEntries(); i++) {
506 const V0* v0 = m_v0s[i];
508
509 if (abs(pdgCode) != abs(v0Type.getPDGCode()))
510 continue;
511
512 // check if the charge of the 2 V0's daughters is opposite
513 if (v0->getTrackFitResults().first->getChargeSign() == v0->getTrackFitResults().second->getChargeSign()) {
514 B2DEBUG(19, "V0 with same charge daughters skipped!");
516 continue;
517 }
518
522
523 if (v0Type.getPDGCode() == Const::Kshort.getPDGCode()) { // K0s -> pi+ pi-
524 pTypeP = Const::pion;
525 pTypeM = Const::pion;
526 } else if (v0Type.getPDGCode() == Const::Lambda.getPDGCode()) { // Lambda -> p+ pi-
527 pTypeP = Const::proton;
528 pTypeM = Const::pion;
529 v0FlavorType = Particle::c_Flavored; // K0s are not flavoured, lambdas are
530 } else if (v0Type.getPDGCode() == Const::antiLambda.getPDGCode()) { // anti-Lambda -> pi+ anti-p-
531 pTypeP = Const::pion;
532 pTypeM = Const::proton;
533 v0FlavorType = Particle::c_Flavored;
534 } else if (v0Type.getPDGCode() == Const::photon.getPDGCode()) { // gamma -> e+ e-
535 pTypeP = Const::electron;
536 pTypeM = Const::electron;
537 } else {
538 B2WARNING("Unknown V0 hypothesis!");
539 }
540
541 // check if, given the initial user's decay descriptor, the current v0 is a particle or an anti-particle.
542 // in the V0 the order of the daughters is fixed, first the positive and then the negative; to be coherent with the decay descriptor, when creating
543 // one particle list and one anti-particle, the v0 daughters' order has to be switched only in one case
544 bool correctOrder = matchingDaughtersOrder;
545 if (abs(v0Type.getPDGCode()) == abs(m_decaydescriptor.getMother()->getPDGCode())
547 correctOrder = !correctOrder;
548
549 std::pair<Track*, Track*> v0Tracks = v0->getTracks();
550 std::pair<TrackFitResult*, TrackFitResult*> v0TrackFitResults = v0->getTrackFitResults();
551
552 Particle daugP((v0Tracks.first)->getArrayIndex(), v0TrackFitResults.first, pTypeP);
553 Particle daugM((v0Tracks.second)->getArrayIndex(), v0TrackFitResults.second, pTypeM);
554
555 const PIDLikelihood* pidP = (v0Tracks.first)->getRelated<PIDLikelihood>();
556 const PIDLikelihood* pidM = (v0Tracks.second)->getRelated<PIDLikelihood>();
557
558 const auto& mcParticlePWithWeight = (v0Tracks.first)->getRelatedToWithWeight<MCParticle>();
559 const auto& mcParticleMWithWeight = (v0Tracks.second)->getRelatedToWithWeight<MCParticle>();
560
561 // add V0 daughters to the Particle StoreArray
562 Particle* newDaugP;
563 Particle* newDaugM;
564
565 if (correctOrder) {
566 newDaugP = m_particles.appendNew(daugP);
567 newDaugM = m_particles.appendNew(daugM);
568 } else {
569 newDaugM = m_particles.appendNew(daugM);
570 newDaugP = m_particles.appendNew(daugP);
571 }
572
573 // if there are PIDLikelihoods and MCParticles then also add relations to the particles
574 if (pidP)
575 newDaugP->addRelationTo(pidP);
576 if (mcParticlePWithWeight.first)
577 newDaugP->addRelationTo(mcParticlePWithWeight.first, mcParticlePWithWeight.second);
578 newDaugP->addRelationTo(v0TrackFitResults.first);
579
580 if (pidM)
581 newDaugM->addRelationTo(pidM);
582 if (mcParticleMWithWeight.first)
583 newDaugM->addRelationTo(mcParticleMWithWeight.first, mcParticleMWithWeight.second);
584 newDaugM->addRelationTo(v0TrackFitResults.second);
585
586 // sum the 4-momenta of the daughters and construct a particle object
587 ROOT::Math::PxPyPzEVector v0Momentum = newDaugP->get4Vector() + newDaugM->get4Vector();
588 Particle v0P(v0Momentum, v0Type.getPDGCode(), v0FlavorType,
589 Particle::EParticleSourceObject::c_V0, v0->getArrayIndex());
590 v0P.setProperty(m_properties);
591
592 // add the daughters of the V0 (in the correct order) and don't update
593 // the type to c_Composite (i.e. maintain c_V0)
594 if (correctOrder) {
595 v0P.appendDaughter(newDaugP, false);
596 v0P.appendDaughter(newDaugM, false);
597 } else {
598 v0P.appendDaughter(newDaugM, false);
599 v0P.appendDaughter(newDaugP, false);
600 }
601
602 // append the particle to the Particle StoreArray and add the new particle to the ParticleList
603 Particle* newPart = m_particles.appendNew(v0P);
604 plist->addParticle(newPart);
605 }
606
607 plist->setEditable(false); // set the :V0 list as not editable.
608 }
609}
static const ChargedStable pion
charged pion particle
Definition: Const.h:661
static const ParticleType antiLambda
Anti-Lambda particle.
Definition: Const.h:680
static const ChargedStable proton
proton particle
Definition: Const.h:663
static const ChargedStable electron
electron particle
Definition: Const.h:659
StoreArray< V0 > m_v0s
StoreArray of V0s.
ROOT::Math::PxPyPzEVector get4Vector() const
Returns Lorentz vector.
Definition: Particle.h:547
EFlavorType
describes flavor type, see getFlavorType().
Definition: Particle.h:94
int getArrayIndex() const
Returns this object's array index (in StoreArray), or -1 if not found.
Object holding information for V0s.
Definition: V0.h:34
std::pair< Track *, Track * > getTracks() const
Get pair of yhe Tracks, that are part of the V0 particle.
Definition: V0.h:45
std::pair< TrackFitResult *, TrackFitResult * > getTrackFitResults() const
Get pair of the TrackFitResults, that are part of the V0 particle.
Definition: V0.h:58
Const::ParticleType getV0Hypothesis() const
Get the hypothesis under which the V0 particle was created.
Definition: V0.cc:35

Member Data Documentation

◆ m_addDaughters

bool m_addDaughters
private

toggle addition of the bottom part of the particle's decay chain

Definition at line 222 of file ParticleLoaderModule.h.

◆ m_ChargedCluster2Plists

std::vector<PList> m_ChargedCluster2Plists
private

Collection of PLists that will collect Particles created from charged-cluster.

Definition at line 216 of file ParticleLoaderModule.h.

◆ m_chargeZeroTrackCounts

std::vector<int> m_chargeZeroTrackCounts
private

internally used to count number of tracks with charge zero

Definition at line 236 of file ParticleLoaderModule.h.

◆ m_conditions

std::vector<ModuleCondition> m_conditions
privateinherited

Module condition, only non-null if set.

Definition at line 521 of file Module.h.

◆ m_decaydescriptor

DecayDescriptor m_decaydescriptor
private

Decay descriptor for parsing the user specified DecayString.

Definition at line 204 of file ParticleLoaderModule.h.

◆ m_decayStrings

std::vector<std::string> m_decayStrings
private

Input decay strings specifying the particles being created/loaded.

Definition at line 207 of file ParticleLoaderModule.h.

◆ m_description

std::string m_description
privateinherited

The description of the module.

Definition at line 511 of file Module.h.

◆ m_Dummies2Plists

std::vector<PList> m_Dummies2Plists
private

Collection of PLists that will collect Particles created from Dummies.

Definition at line 215 of file ParticleLoaderModule.h.

◆ m_dummyCovMatrix

double m_dummyCovMatrix
private

diag value of cov matrix for dummy particles

Definition at line 230 of file ParticleLoaderModule.h.

◆ m_dummyMDSTIndex

int m_dummyMDSTIndex
private

mdst index for dummy particles

Definition at line 229 of file ParticleLoaderModule.h.

◆ m_dummyTreatAsInvisible

bool m_dummyTreatAsInvisible
private

should treeFitter treat the particle as invisible?

Definition at line 231 of file ParticleLoaderModule.h.

◆ m_eclclusters

StoreArray<ECLCluster> m_eclclusters
private

StoreArray of ECLCluster.

Definition at line 185 of file ParticleLoaderModule.h.

◆ m_ECLKLMClusters2Plists

std::vector<PList> m_ECLKLMClusters2Plists
private

Collection of PLists that will collect Particles created from ECLClusters and KLMClusters.

Definition at line 214 of file ParticleLoaderModule.h.

◆ m_enforceFitHypothesis

bool m_enforceFitHypothesis
private
Initial value:
=
false

If true, a Particle is only created if a track fit with the particle hypothesis passed to the ParticleLoader is available.

Definition at line 233 of file ParticleLoaderModule.h.

◆ m_eventExtraInfo

StoreObjPtr<EventExtraInfo> m_eventExtraInfo
private

object pointer to event extra info

Definition at line 190 of file ParticleLoaderModule.h.

◆ m_hasReturnValue

bool m_hasReturnValue
privateinherited

True, if the return value is set.

Definition at line 518 of file Module.h.

◆ m_klmclusters

StoreArray<KLMCluster> m_klmclusters
private

StoreArray of KLMCluster.

Definition at line 186 of file ParticleLoaderModule.h.

◆ m_loadChargedCluster

bool m_loadChargedCluster
private

Switch to load charged-cluster

Definition at line 201 of file ParticleLoaderModule.h.

◆ m_logConfig

LogConfig m_logConfig
privateinherited

The log system configuration of the module.

Definition at line 514 of file Module.h.

◆ m_mcparticles

StoreArray<MCParticle> m_mcparticles
private

StoreArray of MCParticles.

Definition at line 184 of file ParticleLoaderModule.h.

◆ m_MCParticles2Plists

std::vector<PList> m_MCParticles2Plists
private

Collection of PLists that will collect Particles created from MCParticles.

Definition at line 209 of file ParticleLoaderModule.h.

◆ m_moduleParamList

ModuleParamList m_moduleParamList
privateinherited

List storing and managing all parameter of the module.

Definition at line 516 of file Module.h.

◆ m_name

std::string m_name
privateinherited

The name of the module, saved as a string (user-modifiable)

Definition at line 508 of file Module.h.

◆ m_package

std::string m_package
privateinherited

Package this module is found in (may be empty).

Definition at line 510 of file Module.h.

◆ m_particleExtraInfoMap

StoreObjPtr<ParticleExtraInfoMap> m_particleExtraInfoMap
private

object pointer to extra info map

Definition at line 191 of file ParticleLoaderModule.h.

◆ m_particles

StoreArray<Particle> m_particles
private

StoreArray of Particles.

Definition at line 183 of file ParticleLoaderModule.h.

◆ m_pidlikelihoods

StoreArray<PIDLikelihood> m_pidlikelihoods
private

StoreArray of PIDLikelihoods.

Definition at line 187 of file ParticleLoaderModule.h.

◆ m_properties

int m_properties
private

Particle property to be assigned only on V0s.

Flags are defined in Particle::PropertyFlags

Definition at line 205 of file ParticleLoaderModule.h.

◆ m_propertyFlags

unsigned int m_propertyFlags
privateinherited

The properties of the module as bitwise or (with |) of EModulePropFlags.

Definition at line 512 of file Module.h.

◆ m_returnValue

int m_returnValue
privateinherited

The return value.

Definition at line 519 of file Module.h.

◆ m_ROE2Plists

std::vector<PList> m_ROE2Plists
private

Collection of PLists that will collect Particles created from V0.

Definition at line 212 of file ParticleLoaderModule.h.

◆ m_roeMaskName

std::string m_roeMaskName
private

ROE mask name to load.

Definition at line 224 of file ParticleLoaderModule.h.

◆ m_roes

StoreArray<RestOfEvent> m_roes
private

StoreArray of ROEs.

Definition at line 192 of file ParticleLoaderModule.h.

◆ m_sameChargeDaughtersV0Counts

std::vector<int> m_sameChargeDaughtersV0Counts
private

internally used to count the number of V0s with same charge daughters

Definition at line 237 of file ParticleLoaderModule.h.

◆ m_skipInitial

bool m_skipInitial
private

toggle skip of initial MC particles

Definition at line 220 of file ParticleLoaderModule.h.

◆ m_skipNonPrimary

bool m_skipNonPrimary
private

toggle skip of secondary MC particle

Definition at line 221 of file ParticleLoaderModule.h.

◆ m_skipNonPrimaryDaughters

bool m_skipNonPrimaryDaughters
private

toggle skip of secondary MC daughters

Definition at line 223 of file ParticleLoaderModule.h.

◆ m_sourceParticleListName

std::string m_sourceParticleListName
private

Particle list name from which we need to get related ROEs.

Definition at line 225 of file ParticleLoaderModule.h.

◆ m_trackfitresults

StoreArray<TrackFitResult> m_trackfitresults
private

StoreArray of TrackFitResults.

Definition at line 189 of file ParticleLoaderModule.h.

◆ m_trackHypothesis

int m_trackHypothesis
private

pdg code for track hypothesis that should be used to create the particle

Definition at line 227 of file ParticleLoaderModule.h.

◆ m_tracks

StoreArray<Track> m_tracks
private

StoreArray of Tracks.

Definition at line 188 of file ParticleLoaderModule.h.

◆ m_Tracks2Plists

std::vector<PList> m_Tracks2Plists
private

Collection of PLists that will collect Particles created from Tracks.

Definition at line 210 of file ParticleLoaderModule.h.

◆ m_type

std::string m_type
privateinherited

The type of the module, saved as a string.

Definition at line 509 of file Module.h.

◆ m_useDummy

bool m_useDummy
private

Switch to load dummy as Particle.

Definition at line 199 of file ParticleLoaderModule.h.

◆ m_useMCParticles

bool m_useMCParticles
private

Load MCParticle as Particle instead of the corresponding MDST dataobject.

Definition at line 195 of file ParticleLoaderModule.h.

◆ m_useMissing

bool m_useMissing
private

Use missing momentum to build a particle.

Definition at line 226 of file ParticleLoaderModule.h.

◆ m_useOnlyMostEnergeticECLCluster

bool m_useOnlyMostEnergeticECLCluster
private

If true, only the most energetic ECLCluster is used.

Definition at line 202 of file ParticleLoaderModule.h.

◆ m_useROEs

bool m_useROEs
private

Switch to load ROE as Particle.

Definition at line 197 of file ParticleLoaderModule.h.

◆ m_V02Plists

std::vector<PList> m_V02Plists
private

Collection of PLists that will collect Particles created from V0.

Definition at line 211 of file ParticleLoaderModule.h.

◆ m_v0s

StoreArray<V0> m_v0s
private

StoreArray of V0s.

Definition at line 193 of file ParticleLoaderModule.h.

◆ m_writeOut

bool m_writeOut
private

toggle particle list btw.

transient/persistent

Definition at line 219 of file ParticleLoaderModule.h.


The documentation for this class was generated from the following files: