Belle II Software development
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
CDCTriggerNeuroDQMOnlineModule Class Reference

CDC Trigger DQM Module. More...

#include <CDCTriggerNeuroDQMOnlineModule.h>

Inheritance diagram for CDCTriggerNeuroDQMOnlineModule:
HistoModule Module PathElement

Classes

struct  TSLine
 

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

 CDCTriggerNeuroDQMOnlineModule ()
 Constructor.
 
virtual ~CDCTriggerNeuroDQMOnlineModule ()
 Destructor.
 
virtual std::vector< std::string > getFileNames (bool outputFiles)
 Return a list of output filenames for this modules.
 
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.
 
LogConfig & getLogConfig ()
 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 ModuleCondition * getCondition () 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< Path > getConditionPath () 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 ModuleParamList & getParamList () 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< PathElement > clone () 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

typedef std::vector< TSLine > TSLines
 

Private Member Functions

void initialize () override
 Module functions.
 
void beginRun () override
 Function to process begin_run record.
 
void event () override
 Function to process event record.
 
void endRun () override
 Function to process end_run record.
 
void terminate () override
 Function to terminate module.
 
void fillHWPlots ()
 
void fillSimPlots ()
 
void makeDebugOutput ()
 
void fillRecoPlots ()
 
void defineHisto () override
 Histogram definitions such as TH1(), TH2(), TNtuple(), TTree()....
 
void condFill (TH1F *histo, float value)
 Fill a histogram only with non-zero values.
 
unsigned getPattern (CDCTriggerTrack *track, std::string hitCollectionName)
 get pattern of the track
 
bool isValidPattern (unsigned pattern)
 Validity of the pattern.
 
std::string padto (std::string s, unsigned l)
 
std::string padright (std::string s, unsigned l)
 
bool have_relation (const CDCTriggerTrack &track, const CDCTriggerSegmentHit &hit, std::string &arrayname)
 
void sorted_insert (TSLines &lines, TSLine &line, std::string &arrayname, std::string &firstsortarray, std::string &secondsortarray)
 
std::list< ModulePtr > getModules () 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

std::string m_histogramDirectoryName
 Name of the histogram directory in ROOT file.
 
std::string m_unpackedNeuroInputAllSegmentHitsName
 Name for TS hits from unpacker.
 
std::string m_unpacked2DTracksName
 Name for 2D finder tracks from unpacker.
 
std::string m_unpackedNeuroTracksName
 Name for neuro tracks from unpacker.
 
std::string m_unpackedNeuroInputVectorName
 Name for neuro input vector from unpacker.
 
std::string m_unpackedNeuroInput2DTracksName
 Name for neuro input 2d finder tracks.
 
std::string m_unpackedNeuroInputSegmentHitsName
 Name for neuro input Track segments.
 
std::string m_simNeuroTracksName
 name of the storearray for hwsim tracks
 
std::string m_simNeuroInputVectorName
 Name for simulated neuro input vector using HW TS, HW 2D.
 
std::string m_recoTracksName
 Name for the RecoTrack array name.
 
bool m_useRecoTracks
 Switch to turn on use of recotracks.
 
bool m_useSimTracks
 Switch to turn on use of hw sim tracks.
 
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputAllSegmentHits
 StoreArray for all TS hits from neuro unpacker.
 
StoreArray< CDCTriggerTrack > m_unpacked2DTracks
 StoreArray for 2D finder tracks from unpacker.
 
StoreArray< CDCTriggerTrack > m_unpackedNeuroTracks
 StoreArray for neuro tracks from unpacker.
 
StoreArray< CDCTriggerMLPInput > m_unpackedNeuroInputVector
 StoreArray for neuro input vector from unpacker.
 
StoreArray< CDCTriggerTrack > m_unpackedNeuroInput2DTracks
 StoreArray for neuro input 2dfinder tracks.
 
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputSegmentHits
 StoreArray for neuro input Track segments.
 
StoreArray< CDCTriggerTrack > m_simNeuroTracks
 StoreArray for neuro tracks from TSIM.
 
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVector
 StoreArray for neuro input vector from TSIM.
 
StoreArray< RecoTrack > m_RecoTracks
 StoreArray for RecoTracks.
 
StoreObjPtr< BinnedEventT0 > m_eventTime
 storeobjpointer for event time
 
TH1F * m_neuroHWOutdzall = nullptr
 
TH1F * m_neuroHWOutdz0 = nullptr
 
TH1F * m_neuroHWOutdz1 = nullptr
 
TH1F * m_neuroHWOutdz2 = nullptr
 
TH1F * m_neuroHWOutdz3 = nullptr
 
TH1F * m_neuroHWSimRecodZ = nullptr
 
TH1F * m_neuroHWOutZ = nullptr
 
TH1F * m_recoZ = nullptr
 
TH1F * m_recoZ_related = nullptr
 
TH1F * m_neuroHWOutSTTZ = nullptr
 
TH1F * m_neuroHWOutCosTheta = nullptr
 
TH1F * m_neuroHWOutPhi0 = nullptr
 
TH1F * m_neuroHWOutPt = nullptr
 
TH1F * m_neuroHWOutP = nullptr
 
TH1F * m_neuroHWOutm_time = nullptr
 
TH1F * m_neuroHWValTracksNumber = nullptr
 
TH1F * m_neuroHWSector = nullptr
 
TH1F * m_neuroHWInTSID = nullptr
 
TH1F * m_neuroHWInTSIDSel = nullptr
 
TH1F * m_neuroHWInCDCFE = nullptr
 
TH1F * m_neuroHWInm_time = nullptr
 
TH1F * m_neuroHWIn2DTracksNumber = nullptr
 
TH1F * m_neuroHWOutHwSimdZ = nullptr
 
TH1F * m_neuroHWSimZ = nullptr
 
TH1F * m_neuroHWSimCosTheta = nullptr
 
TH1F * m_neuroErrors = nullptr
 
TH1F * m_neuroHWValTSCountAx = nullptr
 
TH1F * m_neuroHWValTSCountSt = nullptr
 
unsigned m_errcount = 0
 
std::vector< std::string > m_errdict {"Not All HWTrack ATS in 2DInTrack", "|HW-SW| > 1cm", "Delta Input IDs not all 0", "Delta Input Alphas not all 0", "Drifttime Overflow / Scaling Error", "TS only in HW", "TS only in SW", "Multiple ET per Track", "<4 related Axial TS", "<3 related Stereo TS", "Drift Time diff", "Eventcounter"}
 
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< ModuleCondition > m_conditions
 Module condition, only non-null if set.
 

Detailed Description

CDC Trigger DQM Module.

Definition at line 25 of file CDCTriggerNeuroDQMOnlineModule.h.

Member Typedef Documentation

◆ EAfterConditionPath

typedef ModuleCondition::EAfterConditionPath EAfterConditionPath
inherited

Forward the EAfterConditionPath definition from the ModuleCondition.

Definition at line 88 of file Module.h.

◆ TSLines

typedef std::vector<TSLine> TSLines
private

Definition at line 46 of file CDCTriggerNeuroDQMOnlineModule.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,
80 c_ParallelProcessingCertified = 4,
81 c_HistogramManager = 8,
82 c_InternalSerializer = 16,
83 c_TerminateInAllProcesses = 32,
84 c_DontCollectStatistics = 64,
85 };
Belle2::Module::c_HistogramManager
@ c_HistogramManager
This module is used to manage histograms accumulated by other modules.
Definition: Module.h:81
Belle2::Module::c_Input
@ c_Input
This module is an input module (reads data).
Definition: Module.h:78
Belle2::Module::c_DontCollectStatistics
@ c_DontCollectStatistics
No statistics is collected for this module.
Definition: Module.h:84
Belle2::Module::c_ParallelProcessingCertified
@ 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
Belle2::Module::c_InternalSerializer
@ c_InternalSerializer
This module is an internal serializer/deserializer for parallel processing.
Definition: Module.h:82
Belle2::Module::c_Output
@ c_Output
This module is an output module (writes data).
Definition: Module.h:79
Belle2::Module::c_TerminateInAllProcesses
@ c_TerminateInAllProcesses
When using parallel processing, call this module's terminate() function in all processes().
Definition: Module.h:83

Constructor & Destructor Documentation

◆ CDCTriggerNeuroDQMOnlineModule()

CDCTriggerNeuroDQMOnlineModule ( )

Constructor.

Definition at line 25 of file CDCTriggerNeuroDQMOnlineModule.cc.

25 : HistoModule()
26{
27 //Set module properties
28 setDescription("CDC Trigger DQM Online module for HLT/Expressreco");
29 setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
30 addParam("unpacked2DTracksName", m_unpacked2DTracksName,
31 "The name of the StoreArray of the unpacked 2D finder tracks",
32 std::string("CDCTrigger2DFinderTracks"));
33 addParam("simNeuroTracksName", m_simNeuroTracksName,
34 "The name of the StoreArray of the Neurotrigger tracks from HWSIM",
35 std::string("TSimNeuroTracks"));
36 addParam("unpackedNeuroTracksName", m_unpackedNeuroTracksName,
37 "The name of the StoreArray of the unpacked neurotrigger tracks",
38 std::string("CDCTriggerNeuroTracks"));
39 addParam("unpackedNeuroInput2dTracksName", m_unpackedNeuroInput2DTracksName,
40 "The name of the StoreArray of the neurotrigger input 2d tracks",
41 std::string("CDCTriggerNNInput2DFinderTracks"));
42 addParam("unpackedNeuroInputSegmentHits", m_unpackedNeuroInputSegmentHitsName,
43 "The name of the StoreArray of the neurotrigger input segment hits",
44 std::string("CDCTriggerNNInputSegmentHits"));
45 addParam("unpackedNeuroInputAllStereoSegmentHitsName", m_unpackedNeuroInputAllSegmentHitsName,
46 "The name of the StoreArray of all segmenthits arriving at the NN boards",
47 std::string("CDCTriggerNNInputAllStereoSegmentHits"));
48 addParam("histogramDirectoryName", m_histogramDirectoryName,
49 "Name of the directory where histograms will be placed",
50 std::string("TRGCDCTNN2"));
51 addParam("RecoTracksName", m_recoTracksName,
52 "Name of the RecoTrack StoreArray. Leave empty for skipping them.",
53 std::string("RecoTracks"));
54 addParam("useSimTracks", m_useSimTracks,
55 "switch on to use simulated tracks for plots, error logs and in debug output"
56 "Useful for debugging SW/HW Errors:",
57 false);
58 addParam("useRecoTracks", m_useRecoTracks,
59 "switch on to use recotracks",
60 true);
61
62}
Belle2::HistoModule::HistoModule
HistoModule()
Constructor.
Definition: HistoModule.h:32
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:208
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputSegmentHitsName
std::string m_unpackedNeuroInputSegmentHitsName
Name for neuro input Track segments.
Definition: CDCTriggerNeuroDQMOnlineModule.h:182
CDCTriggerNeuroDQMOnlineModule::m_unpacked2DTracksName
std::string m_unpacked2DTracksName
Name for 2D finder tracks from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:174
CDCTriggerNeuroDQMOnlineModule::m_useSimTracks
bool m_useSimTracks
Switch to turn on use of hw sim tracks.
Definition: CDCTriggerNeuroDQMOnlineModule.h:193
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInput2DTracksName
std::string m_unpackedNeuroInput2DTracksName
Name for neuro input 2d finder tracks.
Definition: CDCTriggerNeuroDQMOnlineModule.h:180
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputAllSegmentHitsName
std::string m_unpackedNeuroInputAllSegmentHitsName
Name for TS hits from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:172
CDCTriggerNeuroDQMOnlineModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
Name of the histogram directory in ROOT file.
Definition: CDCTriggerNeuroDQMOnlineModule.h:169
CDCTriggerNeuroDQMOnlineModule::m_recoTracksName
std::string m_recoTracksName
Name for the RecoTrack array name.
Definition: CDCTriggerNeuroDQMOnlineModule.h:188
CDCTriggerNeuroDQMOnlineModule::m_useRecoTracks
bool m_useRecoTracks
Switch to turn on use of recotracks.
Definition: CDCTriggerNeuroDQMOnlineModule.h:191
CDCTriggerNeuroDQMOnlineModule::m_simNeuroTracksName
std::string m_simNeuroTracksName
name of the storearray for hwsim tracks
Definition: CDCTriggerNeuroDQMOnlineModule.h:184
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroTracksName
std::string m_unpackedNeuroTracksName
Name for neuro tracks from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:176
Belle2::Module::addParam
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

◆ ~CDCTriggerNeuroDQMOnlineModule()

~CDCTriggerNeuroDQMOnlineModule ( )
virtual

Destructor.

Definition at line 65 of file CDCTriggerNeuroDQMOnlineModule.cc.

66{
67}

Member Function Documentation

◆ beginRun()

void beginRun ( void  )
overrideprivatevirtual

Function to process begin_run record.

Reimplemented from HistoModule.

Definition at line 216 of file CDCTriggerNeuroDQMOnlineModule.cc.

217{
218 // Just to make sure, reset all the histograms.
219
220 // histograms with recotracks (and hwsimtracks):
221
222 m_neuroHWOutdzall->Reset();
223 m_neuroHWOutdz0->Reset();
224 m_neuroHWOutdz1->Reset();
225 m_neuroHWOutdz2->Reset();
226 m_neuroHWOutdz3->Reset();
227 m_neuroHWSimRecodZ->Reset();
228
229 // histograms with only hwneurotracks
230
231 m_neuroHWOutZ->Reset();
232 m_recoZ->Reset();
233 m_recoZ_related->Reset();
234 m_neuroHWOutSTTZ->Reset();
235 m_neuroHWOutCosTheta->Reset();
236 m_neuroHWOutPhi0->Reset();
237 m_neuroHWOutPt->Reset();
238 m_neuroHWOutP->Reset();
239 m_neuroHWOutm_time->Reset();
240 m_neuroHWValTracksNumber->Reset();
241 m_neuroHWSector->Reset();
242 m_neuroHWInTSID->Reset();
243 m_neuroHWInTSIDSel->Reset();
244 m_neuroHWInCDCFE->Reset();
245 m_neuroHWInm_time->Reset();
246 m_neuroHWIn2DTracksNumber->Reset();
247
248 // histograms with hwsim tracks:
249
250 m_neuroHWOutHwSimdZ->Reset();
251 m_neuroHWSimZ->Reset();
252 m_neuroHWSimCosTheta->Reset();
253 m_neuroErrors->Reset();
254 for (unsigned i = 0; i < m_errcount; ++i) {
255 m_neuroErrors->GetXaxis()->SetBinLabel(i + 1, m_errdict[i].c_str());
256 }
257 //m_neuroErrorsRaw->Reset();
258}

◆ 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{
181 ModulePtr newModule = ModuleManager::Instance().registerModule(getType());
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}
Belle2::ModuleManager::registerModule
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.
Definition: ModuleManager.cc:80
Belle2::ModuleManager::Instance
static ModuleManager & Instance()
Exception is thrown if the requested module could not be created by the ModuleManager.
Definition: ModuleManager.cc:24
Belle2::Module::getParamList
const ModuleParamList & getParamList() const
Return module param list.
Definition: Module.h:363
Belle2::Module::getName
const std::string & getName() const
Returns the name of the module.
Definition: Module.h:187
Belle2::Module::getType
const std::string & getType() const
Returns the type of the module (i.e.
Definition: Module.cc:41
Belle2::Module::m_propertyFlags
unsigned int m_propertyFlags
The properties of the module as bitwise or (with |) of EModulePropFlags.
Definition: Module.h:512
Belle2::Module::m_logConfig
LogConfig m_logConfig
The log system configuration of the module.
Definition: Module.h:514
Belle2::Module::m_conditions
std::vector< ModuleCondition > m_conditions
Module condition, only non-null if set.
Definition: Module.h:521
Belle2::Module::m_package
std::string m_package
Package this module is found in (may be empty).
Definition: Module.h:510
Belle2::ModulePtr
std::shared_ptr< Module > ModulePtr
Defines a pointer to a module object as a boost shared pointer.
Definition: Module.h:43

◆ condFill()

void condFill ( TH1F *  histo,
float  value 
)
inlineprivate

Fill a histogram only with non-zero values.

Definition at line 65 of file CDCTriggerNeuroDQMOnlineModule.h.

66 {
67 if (value != 0) {
68 histo->Fill(value);
69 }
70 }

◆ 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(); }
Belle2::Module::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(); }
Belle2::Module::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(); }
Belle2::Module::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(); }
Belle2::Module::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(); }
Belle2::Module::terminate
virtual void terminate()
This method is called at the end of the event processing.
Definition: Module.h:176

◆ defineHisto()

void defineHisto ( )
overrideprivatevirtual

Histogram definitions such as TH1(), TH2(), TNtuple(), TTree()....

are supposed to be placed in this function.

Reimplemented from HistoModule.

Definition at line 73 of file CDCTriggerNeuroDQMOnlineModule.cc.

74{
75 // Create a separate histogram directory and cd into it.
76 TDirectory* oldDir = gDirectory;
77 if (m_histogramDirectoryName != "") {
78 oldDir->mkdir(m_histogramDirectoryName.c_str());
79 oldDir->cd(m_histogramDirectoryName.c_str());
80 }
81 //----------------------------------------------------------------
82
83 // define neurotrigger histograms
84
85 // histograms with recotracks (and hwsimtracks):
86
87 m_neuroHWOutdzall = new TH1F("NeuroHWOutZ-RecoZ",
88 "z Resolution of unpacked and valid neuro tracks; delta z [cm]",
89 200, -100, 100);
90 m_neuroHWOutdz0 = new TH1F("Q0NeuroHWOutZ-RecoZ",
91 "Quadrant0 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
92 200, -100, 100);
93 m_neuroHWOutdz1 = new TH1F("Q1NeuroHWOutZ-RecoZ",
94 "Quadrant1 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
95 200, -100, 100);
96 m_neuroHWOutdz2 = new TH1F("Q2NeuroHWOutZ-RecoZ",
97 "Quadrant2 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
98 200, -100, 100);
99 m_neuroHWOutdz3 = new TH1F("Q3NeuroHWOutZ-RecoZ",
100 "Quadrant3 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
101 200, -100, 100);
102 m_neuroHWSimRecodZ = new TH1F("NeuroHWSimZ-RecoZ",
103 "z Resolution of Simulated HW Tracks; delta z [cm]",
104 200, -100, 100);
105
106 // histograms wih just hwneuro and hw2dtracks:
107
108 m_neuroHWOutZ = new TH1F("NeuroHWOutZ",
109 "z distribution of unpacked and valid neuro tracks; z [cm]",
110 200, -100, 100);
111 m_recoZ = new TH1F("RecoTrackZ",
112 "z distribution of all RecoTracks; z [cm]",
113 400, -200, 200);
114 m_recoZ_related = new TH1F("RecoTrackZ_related",
115 "z distribution of all related Recotracks; z [cm]",
116 400, -200, 200);
117 m_neuroHWOutSTTZ = new TH1F("NeuroHWOutSTTZ",
118 "z distribution of unpacked and valid first not updated per event Neurotracks and p<0.7GeV; z [cm]",
119 200, -100, 100);
120 m_neuroHWOutCosTheta = new TH1F("NeuroHWOutCosTheta",
121 "cos theta distribution of unpacked and valid neuro tracks; cos(#theta) ",
122 100, -1, 1);
123 m_neuroHWOutPhi0 = new TH1F("NeuroHWOutPhi0",
124 "phi distribution of unpacked and valid neuro tracks; #phi [#circ]",
125 80, 0, 360); // shift to reduce the binning error
126 m_neuroHWOutP = new TH1F("NeuroHWOutP",
127 "P distribution of unpacked neuro tracks; p_{T} [GeV]",
128 100, 0, 3);
129 m_neuroHWOutPt = new TH1F("NeuroHWOutPt",
130 "Pt distribution of unpacked neuro tracks; p_{T} [GeV]",
131 10, 0, 3);
132 m_neuroHWOutm_time = new TH1F("NeuroHWOutM_time", "m_time distribution of unpacked neuro tracks; clock cycle",
133 48, 0, 48);
134 m_neuroHWValTracksNumber = new TH1F("NeuroHWValTracksNumber", "number of valid neurotracks per event; track count",
135 20, 0, 20);
136 m_neuroHWSector = new TH1F("NeuroHWExpert",
137 "Expert of unpacked neuro tracks; Expert",
138 5, 0, 5);
139 m_neuroHWInTSID = new TH1F("NeuroHWInTSID", "ID of incoming track segments",
140 2336, 0, 2336);
141 m_neuroHWInTSIDSel = new TH1F("NeuroHWInSelTSID", "ID of selected NNT track segments",
142 2336, 0, 2336);
143 m_neuroHWInCDCFE = new TH1F("NeuroHWInCDCFE", "Number of incoming CDCFE board",
144 300, 0, 300);
145 m_neuroHWInm_time = new TH1F("NeuroHWInM_time", "m_time distribution from incoming 2dtracks; clock cycle",
146 48, 0, 48);
147 m_neuroHWIn2DTracksNumber = new TH1F("NeuroHWIn2DTracksNumber", "number of incoming 2dtracks per event; track count",
148 20, 0, 20);
149 m_neuroHWValTSCountAx = new TH1F("NeuroHWValTSCountAx", "Number of axial TS related to a valid NNTrack", 6, 0, 6);
150 m_neuroHWValTSCountSt = new TH1F("NeuroHWValTSCountSt", "Number of stereo TS related to a valid NNTrack", 5, 0, 5);
151
152 // now the histograms with hwsim neurotracks:
153
154 m_neuroHWOutHwSimdZ = new TH1F("NeuroHWOutZ-NeuroHWSimZ",
155 "dz Distribution of Valid Neuro Tracks and Simulated HW Tracks; z [cm]",
156 200, -100, 100);
157 m_neuroHWSimZ = new TH1F("NeuroHWSimZ",
158 "z Distribution of Simulated HW Tracks; z [cm]",
159 200, -100, 100);
160 m_neuroHWSimCosTheta = new TH1F("NeuroHWSimCosTheta",
161 "cos theta Distribution of Simulated HW Tracks; cos(#theta) ",
162 100, -1, 1);
163 m_errcount = m_errdict.size();
164 m_neuroErrors = new TH1F("Neurotrigger-Errors", "Errors in the Neuro Hardware", m_errcount, 0, m_errcount);
165 // cd back to root directory
166 oldDir->cd();
167}

◆ endRun()

void endRun ( void  )
overrideprivatevirtual

Function to process end_run record.

Reimplemented from HistoModule.

Definition at line 860 of file CDCTriggerNeuroDQMOnlineModule.cc.

861{
862}

◆ 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}
Belle2::Module::m_returnValue
int m_returnValue
The return value.
Definition: Module.h:519
Belle2::Module::m_hasReturnValue
bool m_hasReturnValue
True, if the return value is set.
Definition: Module.h:518

◆ event()

void event ( void  )
overrideprivatevirtual

Function to process event record.

Reimplemented from HistoModule.

Definition at line 259 of file CDCTriggerNeuroDQMOnlineModule.cc.

260{
261 if (m_unpackedNeuroInputSegmentHits.getEntries() == 0) {
262 B2DEBUG(150, "No unpacked TS found, skipping event.");
263 return;
264 }
265
266 fillHWPlots();
267
268 if (m_useRecoTracks) {fillRecoPlots();}
269
270 if (m_useSimTracks) {
271 fillSimPlots();
272 makeDebugOutput();
273 }
274
275
276
277}
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputSegmentHits
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputSegmentHits
StoreArray for neuro input Track segments.
Definition: CDCTriggerNeuroDQMOnlineModule.h:207

◆ 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")
350 .value(">", Belle2::ModuleCondition::EConditionOperators::c_GT)
351 .value("<", Belle2::ModuleCondition::EConditionOperators::c_ST)
352 .value(">=", Belle2::ModuleCondition::EConditionOperators::c_GE)
353 .value("<=", Belle2::ModuleCondition::EConditionOperators::c_SE)
354 .value("==", Belle2::ModuleCondition::EConditionOperators::c_EQ)
355 .value("!=", Belle2::ModuleCondition::EConditionOperators::c_NE)
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://xwiki.desy.de/xwiki/rest/p/f4fa4/#HModuleDevelopment
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>()),
491 &Module::setLogConfig)
Belle2::ModuleCondition::c_GE
@ c_GE
Greater or equal than: ">=".
Definition: ModuleCondition.h:35
Belle2::ModuleCondition::c_SE
@ c_SE
Smaller or equal than: "<=".
Definition: ModuleCondition.h:36
Belle2::ModuleCondition::c_GT
@ c_GT
Greater than: ">"
Definition: ModuleCondition.h:33
Belle2::ModuleCondition::c_NE
@ c_NE
Not equal: "!=".
Definition: ModuleCondition.h:38
Belle2::ModuleCondition::c_EQ
@ c_EQ
Equal: "=" or "=="
Definition: ModuleCondition.h:37
Belle2::ModuleCondition::c_ST
@ c_ST
Smaller than: "<"
Definition: ModuleCondition.h:34
Belle2::Module
Base class for Modules.
Definition: Module.h:72
Belle2::Module::getLogConfig
LogConfig & getLogConfig()
Returns the log system configuration.
Definition: Module.h:225
Belle2::Module::if_value
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
Belle2::Module::if_true
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
Belle2::Module::setReturnValue
void setReturnValue(int value)
Sets the return value for this module as integer.
Definition: Module.cc:220
Belle2::Module::setLogConfig
void setLogConfig(const LogConfig &logConfig)
Set the log system configuration.
Definition: Module.h:230
Belle2::Module::getDescription
const std::string & getDescription() const
Returns the description of the module.
Definition: Module.h:202
Belle2::Module::if_false
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
Belle2::Module::hasCondition
bool hasCondition() const
Returns true if at least one condition was set for the module.
Definition: Module.h:311
Belle2::Module::getPackage
const std::string & getPackage() const
Returns the package this module is in.
Definition: Module.h:197
Belle2::Module::setName
void setName(const std::string &name)
Set the name of the module.
Definition: Module.h:214
Belle2::Module::hasProperties
bool hasProperties(unsigned int propertyFlags) const
Returns true if all specified property flags are available in this module.
Definition: Module.cc:160
Belle2::Module::getPathString
std::string getPathString() const override
return the module name.
Definition: Module.cc:192

◆ fillHWPlots()

void fillHWPlots ( )
private

Definition at line 279 of file CDCTriggerNeuroDQMOnlineModule.cc.

280{
281
282 unsigned valtrackcount = 0;
283
284 // first, fill the tsid plots and the cdcfe plot:
285
286 for (const CDCTriggerSegmentHit& hit : m_unpackedNeuroInputAllSegmentHits) {
287 m_neuroHWInTSID->Fill(hit.getSegmentID());
288 m_neuroHWInCDCFE->Fill((int)(std::roundf(hit.getSegmentID()) * 2 + 8));
289 m_neuroHWInCDCFE->Fill((int)(std::roundf(hit.getSegmentID()) * 2 + 9));
290 }
291 for (const CDCTriggerSegmentHit& hit : m_unpackedNeuroInputSegmentHits) {
292 m_neuroHWInTSIDSel->Fill(hit.getSegmentID());
293 }
294
295 // now, we loop over the hardware neurotracks and fill the
296 // corresponding histograms
297
298 bool firsttrack = true;
299 for (CDCTriggerTrack& neuroHWTrack : m_unpackedNeuroTracks) {
300 bool valtrack = false;
301 try {
302 valtrack = neuroHWTrack.getValidStereoBit();
303 } catch (...) {
304 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
305 valtrack = isValidPattern(getPattern(&neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
306 }
307 if (valtrack) {
308 int nTsAx = 0;
309 int nTsSt = 0;
310 for (auto ts : neuroHWTrack.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentHitsName)) {
311 if (ts.getISuperLayer() % 2 == 0) {
312 nTsAx ++;
313 } else {
314 nTsSt ++;
315 }
316 }
317 m_neuroHWValTSCountAx->Fill(nTsAx);
318 m_neuroHWValTSCountSt->Fill(nTsSt);
319 if (nTsAx < 4) {
320 neuroHWTrack.setQualityVector(256);
321 }
322 if (nTsSt < 3) {
323 neuroHWTrack.setQualityVector(512);
324 }
325 valtrackcount ++;
326 m_neuroHWOutZ->Fill(neuroHWTrack.getZ0());
327 m_neuroHWOutCosTheta->Fill(copysign(1.0,
328 neuroHWTrack.getCotTheta()) / sqrt(1. / (neuroHWTrack.getCotTheta()*neuroHWTrack.getCotTheta())));
329 double phinorm = neuroHWTrack.getPhi0() * 180. / M_PI;
330 if (phinorm < 0.) {phinorm += 360.;}
331 m_neuroHWOutPhi0->Fill(phinorm);
332 m_neuroHWOutPt->Fill(neuroHWTrack.getPt());
333 float momentum = neuroHWTrack.getPt() / sin(acos(neuroHWTrack.getCotTheta() / sqrt(1 + neuroHWTrack.getCotTheta() *
334 neuroHWTrack.getCotTheta())));
335 m_neuroHWOutP->Fill(momentum);
336 if (momentum < 0.7 && firsttrack && neuroHWTrack.getFoundOldTrack()[0] == false) {
337 m_neuroHWOutSTTZ->Fill(neuroHWTrack.getZ0());
338 firsttrack = false;
339 }
340
341 m_neuroHWOutm_time->Fill(neuroHWTrack.getTime());
342 m_neuroHWSector->Fill(neuroHWTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector());
343
344
345 CDCTriggerTrack* twodHWTrack = neuroHWTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
346 m_neuroHWInm_time->Fill(twodHWTrack->getTime());
347
348 // fill the error plots here, but only if simtracks are available
349 // first, get the related simtrack
350 if (m_useSimTracks) {
351 CDCTriggerTrack* neuroSimTrack = neuroHWTrack.getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
352 if (!neuroSimTrack) {
353 B2WARNING("No Simtrack related to HWTrack! This should not happen!");
354 continue;
355 }
356 std::vector<float> unpackedInput =
357 neuroHWTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
358 std::vector<float> simInput =
359 neuroSimTrack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
360 bool sameInputId = true;
361 bool sameInputAlpha = true;
362 bool scaleErr = false;
363 bool missingHwTS = false;
364 bool missingSwTS = false;
365 bool timeErr = false;
366 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
367 int hwZero = 0;
368 int hwSimZero = 0;
369 if (unpackedInput[ii] != simInput[ii]) {sameInputId = false;}
370 if (unpackedInput[ii + 2] != simInput[ii + 2]) {sameInputAlpha = false;}
371 if (unpackedInput[ii + 1] != simInput[ii + 1]) {timeErr = true;}
372 if (unpackedInput[ii + 1] == 0 && fabs(simInput[ii + 1] > 0.99)) {scaleErr = true;}
373 if (simInput[ii + 1] == 0 && fabs(unpackedInput[ii + 1] > 0.99)) {scaleErr = true;}
374 if (unpackedInput[ii] == 0 && unpackedInput[ii + 1] == 0 && unpackedInput[ii + 2] == 0) {hwZero = 1;}
375 if (simInput[ii] == 0 && simInput[ii + 1] == 0 && simInput[ii + 2] == 0) {hwSimZero = 1;}
376 if (hwZero > hwSimZero) {missingSwTS = true;}
377 if (hwZero < hwSimZero) {missingHwTS = true;}
378 }
379 double diff = neuroHWTrack.getZ0() - neuroSimTrack->getZ0();
380 if (abs(diff) > 1.) {neuroHWTrack.setQualityVector(2);}
381 if (!sameInputId) {neuroHWTrack.setQualityVector(4);}
382 if (!sameInputAlpha) {neuroHWTrack.setQualityVector(8);}
383 if (scaleErr) {neuroHWTrack.setQualityVector(16);}
384 if (missingSwTS) {neuroHWTrack.setQualityVector(32);}
385 if (missingHwTS) {neuroHWTrack.setQualityVector(64);}
386 if (timeErr) {neuroHWTrack.setQualityVector(1024);}
387
388 }
389 // now fill the error histogram:
390 unsigned qvec = neuroHWTrack.getQualityVector();
391 //m_neuroErrorsRaw->Fill(qvec);
392 m_neuroErrors->Fill(m_errcount - 1);
393 for (unsigned k = 0; k < m_errcount; k++) {
394 if (qvec & (1 << k)) {m_neuroErrors->Fill(k);}
395 }
396 }
397
398 }
399 m_neuroHWIn2DTracksNumber->Fill(m_unpackedNeuroInput2DTracks.getEntries());
400 m_neuroHWValTracksNumber->Fill(valtrackcount);
401}
Belle2::CDCTriggerMLPInput
Class to hold some intermediate information for the monitoring of the neurotrigger.
Definition: CDCTriggerMLPInput.h:20
Belle2::CDCTriggerMLPInput::getSector
unsigned getSector()
get the sector index
Definition: CDCTriggerMLPInput.h:39
Belle2::CDCTriggerSegmentHit
Combination of several CDCHits to a track segment hit for the trigger.
Definition: CDCTriggerSegmentHit.h:23
Belle2::CDCTriggerTrack
Track created by the CDC trigger.
Definition: CDCTriggerTrack.h:21
Belle2::CDCTriggerTrack::getTime
float getTime() const
get the track found time
Definition: CDCTriggerTrack.h:114
Belle2::CDCTriggerTrack::setQualityVector
void setQualityVector(const unsigned newbits)
setter and getter for the quality vector.
Definition: CDCTriggerTrack.h:147
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInput2DTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroInput2DTracks
StoreArray for neuro input 2dfinder tracks.
Definition: CDCTriggerNeuroDQMOnlineModule.h:205
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroTracks
StoreArray for neuro tracks from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:201
CDCTriggerNeuroDQMOnlineModule::m_simNeuroInputVectorName
std::string m_simNeuroInputVectorName
Name for simulated neuro input vector using HW TS, HW 2D.
Definition: CDCTriggerNeuroDQMOnlineModule.h:186
CDCTriggerNeuroDQMOnlineModule::getPattern
unsigned getPattern(CDCTriggerTrack *track, std::string hitCollectionName)
get pattern of the track
Definition: CDCTriggerNeuroDQMOnlineModule.h:72
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputVectorName
std::string m_unpackedNeuroInputVectorName
Name for neuro input vector from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:178
CDCTriggerNeuroDQMOnlineModule::isValidPattern
bool isValidPattern(unsigned pattern)
Validity of the pattern.
Definition: CDCTriggerNeuroDQMOnlineModule.h:82
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputAllSegmentHits
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputAllSegmentHits
StoreArray for all TS hits from neuro unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:197
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28

◆ fillRecoPlots()

void fillRecoPlots ( )
private

Definition at line 790 of file CDCTriggerNeuroDQMOnlineModule.cc.

791{
792 for (RecoTrack& recoTrack : m_RecoTracks) {
793 double zTarget = 0;
794 bool foundValidRep = false;
795 for (genfit::AbsTrackRep* rep : recoTrack.getRepresentations()) {
796 if (!recoTrack.wasFitSuccessful(rep))
797 continue;
798 // get state (position, momentum etc.) from hit closest to IP and
799 // extrapolate to z-axis (may throw an exception -> continue to next representation)
800 try {
801 genfit::MeasuredStateOnPlane state =
802 recoTrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
803 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
804 zTarget = state.getPos().Z();
805 } catch (...) {
806 continue;
807 }
808 // break loop
809 foundValidRep = true;
810 break;
811 }
812 if (!foundValidRep) {
813 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
814 continue;
815 }
816 m_recoZ->Fill(zTarget);
817 // try to find related neurotrack
818
819 CDCTriggerTrack* neuroHWTrack = recoTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroTracksName);
820 if (!neuroHWTrack) {continue;}
821 bool valtrack = false;
822
823 //check valid bit, else continue (valid ^= enough stereo track segments)
824
825 try {
826 valtrack = neuroHWTrack->getValidStereoBit();
827 } catch (...) {
828 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
829 valtrack = isValidPattern(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
830 }
831 if (!valtrack) {continue;}
832 // TODO check after matching
833 // // flip tracks if necessary, such that trigger tracks and reco tracks
834 // // point in the same direction
835 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
836 // state.setPosMom(state.getPos(), -state.getMom());
837 // state.setChargeSign(-state.getCharge());
838 // }
839 m_recoZ_related->Fill(zTarget);
840 m_neuroHWOutdzall->Fill(neuroHWTrack->getZ0() - zTarget);
841 switch (neuroHWTrack->getQuadrant()) {
842 case -1:
843 B2WARNING("Neurotrack quadrant was not set!");
844 break;
845 case 0:
846 m_neuroHWOutdz0->Fill(neuroHWTrack->getZ0() - zTarget);
847 break;
848 case 1:
849 m_neuroHWOutdz1->Fill(neuroHWTrack->getZ0() - zTarget);
850 break;
851 case 2:
852 m_neuroHWOutdz2->Fill(neuroHWTrack->getZ0() - zTarget);
853 break;
854 case 3:
855 m_neuroHWOutdz3->Fill(neuroHWTrack->getZ0() - zTarget);
856 break;
857 }
858 }
859}
Belle2::CDCTriggerTrack::getValidStereoBit
bool getValidStereoBit() const
returns true, if at least 3 stereo ts were found
Definition: CDCTriggerTrack.h:132
Belle2::CDCTriggerTrack::getQuadrant
short getQuadrant() const
get the quadrant
Definition: CDCTriggerTrack.h:124
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:79
CDCTriggerNeuroDQMOnlineModule::m_RecoTracks
StoreArray< RecoTrack > m_RecoTracks
StoreArray for RecoTracks.
Definition: CDCTriggerNeuroDQMOnlineModule.h:213

◆ fillSimPlots()

void fillSimPlots ( )
private

Definition at line 405 of file CDCTriggerNeuroDQMOnlineModule.cc.

406{
407
408 for (CDCTriggerTrack& neuroSimTrack : m_simNeuroTracks) {
409 CDCTriggerTrack* neuroHWTrack = nullptr;
410 bool valtrack = false;
411 try {
412 valtrack = neuroSimTrack.getValidStereoBit();
413 } catch (...) {
414 B2WARNING("SimTrack doesn't have 'valid bit', get it from relations now ...");
415 valtrack = isValidPattern(getPattern(&neuroSimTrack, m_unpackedNeuroInputSegmentHitsName));
416 }
417 if (valtrack) {
418
419 m_neuroHWSimZ->Fill(neuroSimTrack.getZ0());
420 m_neuroHWSimCosTheta->Fill(copysign(1.0,
421 neuroSimTrack.getCotTheta()) / sqrt(1. / (neuroSimTrack.getCotTheta()*neuroSimTrack.getCotTheta())));
422
423 neuroHWTrack = neuroSimTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroTracksName);
424 if (neuroHWTrack) {
425 bool valhwtrack = false;
426 try {
427 valhwtrack = neuroHWTrack->getValidStereoBit();
428 } catch (...) {
429 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
430 valhwtrack = isValidPattern(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
431 }
432 if (valhwtrack) {
433 double diff = neuroHWTrack->getZ0() - neuroSimTrack.getZ0();
434 m_neuroHWOutHwSimdZ->Fill(diff);
435 }
436 }
437
438 // now check for recotracks and fill the delta plot
439
440 if (m_useRecoTracks) {
441
442 // try to find related neurotrack
443
444 RecoTrack* recoTrack = neuroSimTrack.getRelatedFrom<RecoTrack>(m_recoTracksName);
445 if (recoTrack) {
446 double zTarget = 0;
447 bool foundValidRep = false;
448
449 for (genfit::AbsTrackRep* rep : recoTrack->getRepresentations()) {
450 if (!recoTrack->wasFitSuccessful(rep))
451 continue;
452 // get state (position, momentum etc.) from hit closest to IP and
453 // extrapolate to z-axis (may throw an exception -> continue to next representation)
454 try {
455 genfit::MeasuredStateOnPlane state =
456 recoTrack->getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
457 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
458
459 zTarget = state.getPos().Z();
460 } catch (...) {
461 continue;
462 }
463 // break loop
464 foundValidRep = true;
465 break;
466 }
467 if (!foundValidRep) {
468 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
469 } else {
470 //no need to check valid bit again
471 m_neuroHWSimRecodZ->Fill(neuroSimTrack.getZ0() - zTarget);
472 }
473 }
474 }
475 }
476 }
477}
Belle2::RecoTrack::getRepresentations
const std::vector< genfit::AbsTrackRep * > & getRepresentations() const
Return a list of track representations. You are not allowed to modify or delete them!
Definition: RecoTrack.h:638
Belle2::RecoTrack::wasFitSuccessful
bool wasFitSuccessful(const genfit::AbsTrackRep *representation=nullptr) const
Returns true if the last fit with the given representation was successful.
Definition: RecoTrack.cc:336
Belle2::RecoTrack::getMeasuredStateOnPlaneClosestTo
const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneClosestTo(const ROOT::Math::XYZVector &closestPoint, const genfit::AbsTrackRep *representation=nullptr)
Return genfit's MasuredStateOnPlane, that is closest to the given point useful for extrapolation of m...
Definition: RecoTrack.cc:426
Belle2::RelationsInterface::getRelatedFrom
FROM * getRelatedFrom(const std::string &name="", const std::string &namedRelation="") const
Get the object from which this object has a relation.
Definition: RelationsObject.h:263
CDCTriggerNeuroDQMOnlineModule::m_simNeuroTracks
StoreArray< CDCTriggerTrack > m_simNeuroTracks
StoreArray for neuro tracks from TSIM.
Definition: CDCTriggerNeuroDQMOnlineModule.h:209

◆ 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}
Belle2::PathPtr
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;}
Belle2::Module::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, StorageRootOutputModule, 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;}
Belle2::Module::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{
281 return m_moduleParamList.getParamInfoListPython();
282}
Belle2::ModuleParamList::getParamInfoListPython
std::shared_ptr< boost::python::list > getParamInfoListPython() const
Returns a python list of all parameters.
Definition: ModuleParamList.cc:64
Belle2::Module::m_moduleParamList
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}

◆ getPattern()

unsigned getPattern ( CDCTriggerTrack *  track,
std::string  hitCollectionName 
)
inlineprivate

get pattern of the track

Definition at line 72 of file CDCTriggerNeuroDQMOnlineModule.h.

73 {
74 unsigned pattern = 0;
75 for (const CDCTriggerSegmentHit& hit : track->getRelationsTo<CDCTriggerSegmentHit>(hitCollectionName)) {
76 unsigned sl = hit.getISuperLayer();
77 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
78 }
79 return pattern;
80 }

◆ 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}
Belle2::Module::m_type
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{
168 auto missing = m_moduleParamList.getUnsetForcedParams();
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}
Belle2::ModuleParamList::getUnsetForcedParams
std::vector< std::string > getUnsetForcedParams() const
Returns list of unset parameters (if they are required to have a value.
Definition: ModuleParamList.cc:54

◆ have_relation()

bool have_relation ( const CDCTriggerTrack &  track,
const CDCTriggerSegmentHit &  hit,
std::string &  arrayname 
)
inlineprivate

Definition at line 109 of file CDCTriggerNeuroDQMOnlineModule.h.

110 {
111 bool related = false;
112 for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(arrayname)) {
113 if (&ts == &hit) {related = true;}
114 }
115 return related;
116 }

◆ 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://xwiki.desy.de/xwiki/rest/p/a94f2 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 ( void  )
overrideprivatevirtual

Module functions.

Reimplemented from HistoModule.

Definition at line 168 of file CDCTriggerNeuroDQMOnlineModule.cc.

169{
170 // Register histograms (calls back defineHisto)
171
172 REG_HISTOGRAM
173
174 // require event time and hwneuro related arrays:
175
176 m_eventTime.isOptional("CDCTriggerNeuroETFT0");
177 m_unpacked2DTracks.isRequired(m_unpacked2DTracksName);
178
179 m_unpackedNeuroTracks.isRequired(m_unpackedNeuroTracksName);
180 m_unpackedNeuroInput2DTracks.isRequired(m_unpackedNeuroInput2DTracksName);
181 m_unpackedNeuroInputSegmentHits.isRequired(m_unpackedNeuroInputSegmentHitsName);
182 m_unpackedNeuroInputAllSegmentHits.isRequired(m_unpackedNeuroInputAllSegmentHitsName);
183 m_unpackedNeuroInputVectorName = m_unpackedNeuroTracksName + "Input";
184 m_unpackedNeuroInputVector.isRequired(m_unpackedNeuroInputVectorName);
185
186 // require recotracks, if activated:
187
188 if (m_useRecoTracks) {m_RecoTracks.isRequired("RecoTracks");}
189
190 //require hwsimtracks, if activated:
191
192 if (m_useSimTracks) {
193 m_simNeuroTracks.isRequired(m_simNeuroTracksName);
194 m_simNeuroInputVectorName = m_simNeuroTracksName + "Input";
195 m_simNeuroInputVector.isRequired(m_simNeuroInputVectorName);
196 }
197
198 // require certain relations
199
200 m_unpackedNeuroInput2DTracks.requireRelationTo(m_unpackedNeuroTracks);
201 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegmentHits);
202 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputVector);
203 if (m_useSimTracks) {
204 m_unpackedNeuroTracks.requireRelationTo(m_simNeuroTracks);
205 }
206 if (m_useRecoTracks) {
207 m_RecoTracks.requireRelationTo(m_unpackedNeuroTracks);
208 }
209 if (m_useSimTracks && m_useRecoTracks) {
210 m_RecoTracks.requireRelationTo(m_simNeuroTracks);
211 }
212
213
214}
Belle2::StoreAccessorBase::isRequired
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Definition: StoreAccessorBase.h:78
Belle2::StoreAccessorBase::isOptional
bool isOptional(const std::string &name="")
Tell the DataStore about an optional input.
Definition: StoreAccessorBase.h:93
Belle2::StoreArray::requireRelationTo
bool requireRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, const std::string &namedRelation="") const
Produce error if no relation from this array to 'toArray' has been registered.
Definition: StoreArray.h:155
CDCTriggerNeuroDQMOnlineModule::m_simNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVector
StoreArray for neuro input vector from TSIM.
Definition: CDCTriggerNeuroDQMOnlineModule.h:211
CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_unpackedNeuroInputVector
StoreArray for neuro input vector from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:203
CDCTriggerNeuroDQMOnlineModule::m_eventTime
StoreObjPtr< BinnedEventT0 > m_eventTime
storeobjpointer for event time
Definition: CDCTriggerNeuroDQMOnlineModule.h:215
CDCTriggerNeuroDQMOnlineModule::m_unpacked2DTracks
StoreArray< CDCTriggerTrack > m_unpacked2DTracks
StoreArray for 2D finder tracks from unpacker.
Definition: CDCTriggerNeuroDQMOnlineModule.h:199

◆ isValidPattern()

bool isValidPattern ( unsigned  pattern)
inlineprivate

Validity of the pattern.

Definition at line 82 of file CDCTriggerNeuroDQMOnlineModule.h.

83 {
84 bool valid = false;
85 switch (pattern) {
86 case 7:
87 case 11:
88 case 13:
89 case 14:
90 case 15:
91 valid = true;
92 }
93 return valid;
94 }

◆ makeDebugOutput()

void makeDebugOutput ( )
private

Definition at line 479 of file CDCTriggerNeuroDQMOnlineModule.cc.

480{
481 StoreObjPtr<EventMetaData> eventMetaData;
482 static constexpr std::array<int, 9> nWiresInSuperLayer = {
483 160, 160, 192, 224, 256, 288, 320, 352, 384
484 };
485 unsigned axhwts = 0;
486 unsigned sthwts = 0;
487
488 std::vector<TSLine> hwtsoutput;
489 for (const CDCTriggerSegmentHit& xhit : m_unpackedNeuroInputSegmentHits) {
490 if (xhit.getISuperLayer() % 2 == 0) {
491 axhwts ++;
492 } else {
493 sthwts ++;
494 }
495 int iSL = xhit.getISuperLayer();
496 int iTS = xhit.getIWire();
497 int nwires = nWiresInSuperLayer[ iSL ];
498 if (iSL == 8) {
499 iTS += 16;
500 if (iTS > nwires) {
501 iTS -= nwires;
502 }
503 }
504 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
505 if (tsIDInTracker < 0) {
506 tsIDInTracker += nwires;
507 }
508 TSLine l(xhit);
509 l.strline = "("
510 + padto(std::to_string(xhit.getISuperLayer()), 2) + ", "
511 + padto(std::to_string(xhit.getQuadrant()), 1) + ", "
512 + padto(std::to_string(xhit.getSegmentID()), 4) + ", "
513 + padto(std::to_string(xhit.getIWire()), 5) + ", "
514 + padto(std::to_string(xhit.getPriorityPosition()), 2) + ", "
515 + padto(std::to_string(xhit.getLeftRight()), 2) + ", "
516 + padto(std::to_string(xhit.priorityTime()), 4) + ", "
517 + padto(std::to_string(xhit.foundTime()), 3) + ", "
518 + padto(std::to_string(tsIDInTracker), 4) + ") | ";
519
520 unsigned count2d = 0;
521 for (CDCTriggerTrack& track : m_unpackedNeuroInput2DTracks) {
522 count2d++;
523 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
524 l.strline += std::to_string(count2d);
525 } else {
526 l.strline += ".";
527 }
528 }
529 l.strline += " | ";
530 unsigned counthwn = 0;
531 for (CDCTriggerTrack& track : m_unpackedNeuroTracks) {
532 counthwn++;
533 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
534 if (track.getValidStereoBit()) {
535 l.strline += std::to_string(counthwn);
536 } else {
537 l.strline += "x";
538 }
539 } else {
540 l.strline += ".";
541 }
542 }
543 l.strline += " | ";
544
545 unsigned countswn = 0;
546 for (CDCTriggerTrack& track : m_simNeuroTracks) {
547 countswn++;
548 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
549 if (track.getValidStereoBit()) {
550 l.strline += std::to_string(countswn);
551 } else {
552 l.strline += "x";
553 }
554 } else {
555 l.strline += ".";
556 }
557 }
558 l.strline += " | ";
559
560 if (m_useRecoTracks) {
561 unsigned countreco = 0;
562 for (const auto& track : m_RecoTracks) {
563 countreco++;
564 bool related = false;
565 for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentHitsName)) {
566 if (&ts == &xhit) {related = true;}
567 }
568 if (related) {
569 l.strline += std::to_string(countreco);
570 } else {
571 l.strline += ".";
572 }
573 }
574 l.strline += " | ";
575 }
576 sorted_insert(hwtsoutput, l, m_unpackedNeuroInputSegmentHitsName, m_unpackedNeuroInput2DTracksName, m_unpackedNeuroTracksName);
577 }
578
579 std::string axhw = std::to_string(axhwts) + " / " + std::to_string(sthwts);
580 std::string hwtsstring = "(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | HWNNIn2D | HWNeuro | SWNeuro | ";
581 if (m_useRecoTracks) {hwtsstring += "Reco | ";}
582 B2DEBUG(10, padright(" ", 100));
583 B2DEBUG(10, "----------------------------------------------------------------------------------------------------");
584 B2DEBUG(10, padright(" ", 100));
585 std::string experimentstring = "Experiment " + std::to_string(eventMetaData->getExperiment()) + " Run " +
586 std::to_string(eventMetaData->getRun()) + " Event " + std::to_string(eventMetaData->getEvent());
587 B2DEBUG(10, padright(experimentstring, 100));
588 B2DEBUG(10, padright(" ", 100));
589 B2DEBUG(10, padright(" ", 100));
590 B2DEBUG(10, padright("Number of NN HW TS (Axial/Stereo): ", 40) << padright(axhw, 60));
591 B2DEBUG(10, padright("Number of HW 2DFinderTracks: ", 40) << padright(std::to_string(m_unpacked2DTracks.getEntries()),
592 60));
593 unsigned f2dtrn = 0;
594 for (CDCTriggerTrack& ltrack : m_unpacked2DTracks) {
595 f2dtrn++;
596 std::stringstream strpt;
597 std::stringstream stromega;
598 std::stringstream strphi;
599 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
600 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
601 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
602 std::string trs = " HW2DFinderTrack Nr. " + std::to_string(f2dtrn) + " (pt, omega, phi) = ";
603 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ")";
604 B2DEBUG(15, padright(trs, 100));
605 }
606 B2DEBUG(10, padright("Number of HW NNInput2DFinderTracks: ",
607 40) << padright(std::to_string(m_unpackedNeuroInput2DTracks.getEntries()), 60));
608 unsigned n2dtrn = 0;
609 for (CDCTriggerTrack& ltrack : m_unpackedNeuroInput2DTracks) {
610 n2dtrn++;
611 std::stringstream strpt;
612 std::stringstream stromega;
613 std::stringstream strphi;
614 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
615 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
616 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
617 std::string trs = " HWNeuroInput2DTrack Nr. " + std::to_string(n2dtrn) + " (pt, omega, phi) = ";
618 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + ")";
619 B2DEBUG(15, padright(trs, 100));
620 }
621 B2DEBUG(10, padright("Number of HW NeuroTracks: ",
622 40) << padright(std::to_string(m_unpackedNeuroTracks.getEntries()), 60));
623 unsigned hwntrn = 0;
624 for (CDCTriggerTrack& ltrack : m_unpackedNeuroTracks) {
625 hwntrn++;
626 std::stringstream strpt;
627 std::stringstream stromega;
628 std::stringstream strphi;
629 std::stringstream strtheta;
630 std::stringstream strz;
631 std::stringstream hwomega;
632 std::stringstream hwphi;
633 std::stringstream hwtheta;
634 std::stringstream hwz;
635 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
636 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
637 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
638 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
639 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
640 hwomega << std::fixed << std::setprecision(0) << ltrack.getRawOmega();
641 hwphi << std::fixed << std::setprecision(0) << ltrack.getRawPhi0();
642 hwtheta << std::fixed << std::setprecision(0) << ltrack.getRawTheta();
643 hwz << std::fixed << std::setprecision(0) << ltrack.getRawZ();
644 std::string trs = " HWNeuroTrack Nr. " + std::to_string(hwntrn) + " (pt,om,phi,theta,z)=(";
645 trs += padto(strpt.str(), 4) + "," + padto(stromega.str(), 6) + "," + padto(strphi.str(), 6) + "," + padto(strtheta.str(),
646 6) + "," + padto(strz.str(), 6) + "),(x," + padto(hwomega.str(), 3) + "," + padto(hwphi.str(), 3) + "," + padto(hwtheta.str(),
647 3) + "," + padto(hwz.str(), 3) + ")";
648 B2DEBUG(15, padright(trs, 100));
649 std::string infostr = ", Found old track: ( ";
650 for (bool x : ltrack.getFoundOldTrack()) {
651 infostr += std::to_string(x);
652 }
653 infostr += "), ";
654 infostr = padright(infostr, 50);
655 infostr += "Drift threshold: ( ";
656 for (bool x : ltrack.getDriftThreshold()) {
657 infostr += std::to_string(x);
658 }
659 infostr += ")";
660 infostr += (ltrack.getValidStereoBit()) ? " valid" : " NOT valid";
661 B2DEBUG(15, padright(infostr, 100));
662 std::string infostr2 = " std. ETF vld:";
663 infostr2 += std::to_string(m_eventTime.isValid());
664 infostr2 += ", ETFT0: ";
665 if (m_eventTime.isValid()) {
666 infostr2 += std::to_string(m_eventTime->getBinnedEventT0(Const::CDC));
667 } else {
668 infostr2 += " ";
669 }
670 infostr2 += ", ETF in CC: ";
671 infostr2 += std::to_string(ltrack.getETF_unpacked());
672 infostr2 += ", ETF recalculated: ";
673 infostr2 += std::to_string(ltrack.getETF_recalced());
674 B2DEBUG(15, padright(infostr2, 100));
675 std::string info2str = " Expert Network Number: " + std::to_string(ltrack.getExpert());
676 info2str += ", TSVector: (";
677 for (unsigned x : ltrack.getTSVector()) {
678 info2str += std::to_string(x) + " ";
679 }
680 info2str += ")";
681 info2str += ", Quality=";
682 info2str += std::to_string(ltrack.getQualityVector());
683 B2DEBUG(15, padright(info2str, 100));
684 CDCTriggerTrack* ftrack = ltrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
685 CDCTriggerTrack* strack = ftrack->getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
686 if (strack) {
687 std::vector<float> unpackedInput =
688 ltrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
689 std::vector<float> simInput =
690 strack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
691 B2DEBUG(20, padright(" Input Vector unpacked (id, t, alpha), sim (id, t, alpha), delta (id, t, alpha):", 100));
692 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
693 std::string lla = " " + std::to_string(ii / 3) + ")";
694 std::string llb = " " + std::to_string(ii / 3) + ")";
695 lla += "(" + padright(std::to_string(unpackedInput[ii]), 8) + " " + padright(std::to_string(unpackedInput[ii + 1]),
696 8) + " " + padright(std::to_string(unpackedInput[ii + 2]), 8) + "),(" + padright(std::to_string(simInput[ii]),
697 8) + " " + padright(std::to_string(simInput[ii + 1]), 8) + " " + padright(std::to_string(simInput[ii + 2]),
698 8) + "),(" + padright(std::to_string(unpackedInput[ii] - simInput[ii]),
699 8) + " " + padright(std::to_string(unpackedInput[ii + 1] - simInput[ii + 1]),
700 8) + " " + padright(std::to_string(unpackedInput[ii + 2] - simInput[ii + 2]), 8) + ")";
701 llb += " (" + padright(std::to_string(int(unpackedInput[ii] * 4096)),
702 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096)),
703 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096)),
704 8) + "),(" + padright(std::to_string(int(simInput[ii] * 4096)), 8) + " " + padright(std::to_string(int(simInput[ii + 1] * 4096)),
705 8) + " " + padright(std::to_string(int(simInput[ii + 2] * 4096)),
706 8) + "),(" + padright(std::to_string(int(unpackedInput[ii] * 4096 - simInput[ii] * 4096)),
707 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096 - simInput[ii + 1] * 4096)),
708 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096 - simInput[ii + 2] * 4096)), 8) + ")";
709
710 B2DEBUG(30, padright(lla, 100));
711 B2DEBUG(20, padright(llb, 100));
712 }
713 }
714 }
715 if (m_useRecoTracks) {
716 B2DEBUG(10, padright("Number of RecoTracks: ", 40) << padright(std::to_string(m_RecoTracks.getEntries()), 60));
717 unsigned recotrn = 0;
718 for (RecoTrack& ltrack : m_RecoTracks) {
719 double phi0Target = 0;
720 double invptTarget = 0;
721 double thetaTarget = 0;
722 double zTarget = 0;
723 double d0Target = 0;
724 bool foundValidRep = false;
725 for (genfit::AbsTrackRep* rep : ltrack.getRepresentations()) {
726 if (!ltrack.wasFitSuccessful(rep))
727 continue;
728 // get state (position, momentum etc.) from hit closest to IP and
729 // extrapolate to z-axis (may throw an exception -> continue to next representation)
730 try {
731 genfit::MeasuredStateOnPlane state =
732 ltrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
733 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
734 // TODO check after matching
735 // // flip tracks if necessary, such that trigger tracks and reco tracks
736 // // point in the same direction
737 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
738 // state.setPosMom(state.getPos(), -state.getMom());
739 // state.setChargeSign(-state.getCharge());
740 // }
741 // get track parameters
742 phi0Target = state.getMom().Phi() * 180. / M_PI ;
743 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
744 invptTarget = state.getCharge() * state.getMom().Pt();
745 thetaTarget = acos(state.getMom().CosTheta()) * 180 / M_PI;
746 zTarget = state.getPos().Z();
747 d0Target = state.getPos().Perp();
748 } catch (...) {
749 continue;
750 }
751 // break loop
752 foundValidRep = true;
753 break;
754 }
755 if (!foundValidRep) {
756 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
757 continue;
758 }
759 recotrn++;
760 std::stringstream strpt;
761 std::stringstream stromega;
762 std::stringstream strphi;
763 std::stringstream strtheta;
764 std::stringstream strz;
765 strpt << std::fixed << std::setprecision(2) << invptTarget;
766 stromega << std::fixed << std::setprecision(2) << d0Target;
767 strphi << std::fixed << std::setprecision(2) << phi0Target;
768 strtheta << std::fixed << std::setprecision(2) << thetaTarget;
769 strz << std::fixed << std::setprecision(2) << zTarget;
770 std::string trs = " RecoTrack Nr. " + std::to_string(recotrn) + " (invpt, d0, phi, theta, z) = ";
771 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + padto(strtheta.str(),
772 6) + ", " + padto(strz.str(), 6) + ")";
773 B2DEBUG(15, padright(trs, 100));
774 }
775 }
776 B2DEBUG(10, padright(" ", 100));
777 B2DEBUG(10, padright(" ", 100));
778 B2DEBUG(15, padright("Detailed information about HW TS ", 100));
779 B2DEBUG(15, padright(" ", 100));
780 B2DEBUG(15, padright(hwtsstring, 100));
781 for (auto x : hwtsoutput) {
782 B2DEBUG(15, padright(x.strline, 100));
783 }
784 B2DEBUG(15, padright(" ", 100));
785
786
787}
Belle2::BinnedEventT0::getBinnedEventT0
int getBinnedEventT0(const Const::EDetector detector) const
Return the stored binned event t0 for the given detector or 0 if nothing stored.
Definition: BinnedEventT0.cc:13
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:111

◆ padright()

std::string padright ( std::string  s,
unsigned  l 
)
inlineprivate

Definition at line 102 of file CDCTriggerNeuroDQMOnlineModule.h.

103 {
104 if (s.size() < l) {
105 s.insert(s.end(), l - s.size(), ' ');
106 }
107 return s;
108 }

◆ padto()

std::string padto ( std::string  s,
unsigned  l 
)
inlineprivate

Definition at line 95 of file CDCTriggerNeuroDQMOnlineModule.h.

96 {
97 if (s.size() < l) {
98 s.insert(s.begin(), l - s.size(), ' ');
99 }
100 return s;
101 }

◆ 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}
Belle2::LogConfig::ELogLevel
ELogLevel
Definition of the supported log levels.
Definition: LogConfig.h:26
Belle2::LogConfig::setAbortLevel
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}
Belle2::LogConfig::setDebugLevel
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}
Belle2::LogConfig::setLogInfo
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}
Belle2::LogConfig::setLogLevel
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 {
239 m_moduleParamList.setParamPython(name, pyObj);
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}
Belle2::LogSystem
Class for logging debug, info and error messages.
Definition: LogSystem.h:46
Belle2::LogSystem::updateModule
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
Belle2::LogSystem::Instance
static LogSystem & Instance()
Static method to get a reference to the LogSystem instance.
Definition: LogSystem.cc:31
Belle2::ModuleParamList::setParamPython
void setParamPython(const std::string &name, const PythonObject &pyObj)
Implements a method for setting boost::python objects.
Definition: ModuleParamList.templateDetails.h:104

◆ 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}
Belle2::Module::setParamPython
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}

◆ sorted_insert()

void sorted_insert ( TSLines &  lines,
TSLine &  line,
std::string &  arrayname,
std::string &  firstsortarray,
std::string &  secondsortarray 
)
inlineprivate

Definition at line 117 of file CDCTriggerNeuroDQMOnlineModule.h.

118 {
119 bool inserted = false;
120 bool related = false;
121 TSLines::iterator it = lines.begin();
122 for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(firstsortarray)) {
123 if (!inserted) {
124 for (TSLines::iterator i = lines.begin(); i < lines.end(); ++i) {
125 if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
126 continue;
127 }
128 if (have_relation(track, *(i->hit), arrayname)) {
129 it = i;
130 related = true;
131 if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
132 inserted = true;
133 break;
134 }
135 }
136 }
137 } else { break; }
138 }
139 if (related) {
140 if (!inserted) {++it; }
141 lines.insert(it, line);
142 } else {
143 for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(secondsortarray)) {
144 if (!inserted) {
145 for (TSLines::iterator i = it; i < lines.end(); ++i) {
146 if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
147 continue;
148 }
149 if (have_relation(track, *(i->hit), arrayname)) {
150 it = i;
151 related = true;
152 if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
153 inserted = true;
154 break;
155 }
156 }
157 }
158 } else { break; }
159 }
160 if (related) {
161 if (!inserted) {++it; }
162 lines.insert(it, line);
163 } else {
164 lines.push_back(line);
165 }
166 }
167 }

◆ terminate()

void terminate ( void  )
overrideprivatevirtual

Function to terminate module.

Reimplemented from HistoModule.

Definition at line 865 of file CDCTriggerNeuroDQMOnlineModule.cc.

866{
867}

Member Data Documentation

◆ m_conditions

std::vector<ModuleCondition> m_conditions
privateinherited

Module condition, only non-null if set.

Definition at line 521 of file Module.h.

◆ m_description

std::string m_description
privateinherited

The description of the module.

Definition at line 511 of file Module.h.

◆ m_errcount

unsigned m_errcount = 0
private

Definition at line 251 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_errdict

std::vector<std::string> m_errdict {"Not All HWTrack ATS in 2DInTrack", "|HW-SW| > 1cm", "Delta Input IDs not all 0", "Delta Input Alphas not all 0", "Drifttime Overflow / Scaling Error", "TS only in HW", "TS only in SW", "Multiple ET per Track", "<4 related Axial TS", "<3 related Stereo TS", "Drift Time diff", "Eventcounter"}
private

Definition at line 252 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_eventTime

StoreObjPtr<BinnedEventT0> m_eventTime
private

storeobjpointer for event time

Definition at line 215 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_hasReturnValue

bool m_hasReturnValue
privateinherited

True, if the return value is set.

Definition at line 518 of file Module.h.

◆ m_histogramDirectoryName

std::string m_histogramDirectoryName
private

Name of the histogram directory in ROOT file.

Definition at line 169 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_logConfig

LogConfig m_logConfig
privateinherited

The log system configuration of the module.

Definition at line 514 of file Module.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_neuroErrors

TH1F* m_neuroErrors = nullptr
private

Definition at line 247 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWIn2DTracksNumber

TH1F* m_neuroHWIn2DTracksNumber = nullptr
private

Definition at line 242 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWInCDCFE

TH1F* m_neuroHWInCDCFE = nullptr
private

Definition at line 240 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWInm_time

TH1F* m_neuroHWInm_time = nullptr
private

Definition at line 241 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWInTSID

TH1F* m_neuroHWInTSID = nullptr
private

Definition at line 238 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWInTSIDSel

TH1F* m_neuroHWInTSIDSel = nullptr
private

Definition at line 239 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutCosTheta

TH1F* m_neuroHWOutCosTheta = nullptr
private

Definition at line 231 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutdz0

TH1F* m_neuroHWOutdz0 = nullptr
private

Definition at line 221 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutdz1

TH1F* m_neuroHWOutdz1 = nullptr
private

Definition at line 222 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutdz2

TH1F* m_neuroHWOutdz2 = nullptr
private

Definition at line 223 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutdz3

TH1F* m_neuroHWOutdz3 = nullptr
private

Definition at line 224 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutdzall

TH1F* m_neuroHWOutdzall = nullptr
private

Definition at line 220 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutHwSimdZ

TH1F* m_neuroHWOutHwSimdZ = nullptr
private

Definition at line 244 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutm_time

TH1F* m_neuroHWOutm_time = nullptr
private

Definition at line 235 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutP

TH1F* m_neuroHWOutP = nullptr
private

Definition at line 234 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutPhi0

TH1F* m_neuroHWOutPhi0 = nullptr
private

Definition at line 232 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutPt

TH1F* m_neuroHWOutPt = nullptr
private

Definition at line 233 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutSTTZ

TH1F* m_neuroHWOutSTTZ = nullptr
private

Definition at line 230 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWOutZ

TH1F* m_neuroHWOutZ = nullptr
private

Definition at line 227 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWSector

TH1F* m_neuroHWSector = nullptr
private

Definition at line 237 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWSimCosTheta

TH1F* m_neuroHWSimCosTheta = nullptr
private

Definition at line 246 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWSimRecodZ

TH1F* m_neuroHWSimRecodZ = nullptr
private

Definition at line 225 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWSimZ

TH1F* m_neuroHWSimZ = nullptr
private

Definition at line 245 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWValTracksNumber

TH1F* m_neuroHWValTracksNumber = nullptr
private

Definition at line 236 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWValTSCountAx

TH1F* m_neuroHWValTSCountAx = nullptr
private

Definition at line 248 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_neuroHWValTSCountSt

TH1F* m_neuroHWValTSCountSt = nullptr
private

Definition at line 249 of file CDCTriggerNeuroDQMOnlineModule.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_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_RecoTracks

StoreArray<RecoTrack> m_RecoTracks
private

StoreArray for RecoTracks.

Definition at line 213 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_recoTracksName

std::string m_recoTracksName
private

Name for the RecoTrack array name.

Definition at line 188 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_recoZ

TH1F* m_recoZ = nullptr
private

Definition at line 228 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_recoZ_related

TH1F* m_recoZ_related = nullptr
private

Definition at line 229 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_returnValue

int m_returnValue
privateinherited

The return value.

Definition at line 519 of file Module.h.

◆ m_simNeuroInputVector

StoreArray<CDCTriggerMLPInput> m_simNeuroInputVector
private

StoreArray for neuro input vector from TSIM.

Definition at line 211 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_simNeuroInputVectorName

std::string m_simNeuroInputVectorName
private

Name for simulated neuro input vector using HW TS, HW 2D.

Definition at line 186 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_simNeuroTracks

StoreArray<CDCTriggerTrack> m_simNeuroTracks
private

StoreArray for neuro tracks from TSIM.

Definition at line 209 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_simNeuroTracksName

std::string m_simNeuroTracksName
private

name of the storearray for hwsim tracks

Definition at line 184 of file CDCTriggerNeuroDQMOnlineModule.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_unpacked2DTracks

StoreArray<CDCTriggerTrack> m_unpacked2DTracks
private

StoreArray for 2D finder tracks from unpacker.

Definition at line 199 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpacked2DTracksName

std::string m_unpacked2DTracksName
private

Name for 2D finder tracks from unpacker.

Definition at line 174 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInput2DTracks

StoreArray<CDCTriggerTrack> m_unpackedNeuroInput2DTracks
private

StoreArray for neuro input 2dfinder tracks.

Definition at line 205 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInput2DTracksName

std::string m_unpackedNeuroInput2DTracksName
private

Name for neuro input 2d finder tracks.

Definition at line 180 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputAllSegmentHits

StoreArray<CDCTriggerSegmentHit> m_unpackedNeuroInputAllSegmentHits
private

StoreArray for all TS hits from neuro unpacker.

Definition at line 197 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputAllSegmentHitsName

std::string m_unpackedNeuroInputAllSegmentHitsName
private

Name for TS hits from unpacker.

Definition at line 172 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputSegmentHits

StoreArray<CDCTriggerSegmentHit> m_unpackedNeuroInputSegmentHits
private

StoreArray for neuro input Track segments.

Definition at line 207 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputSegmentHitsName

std::string m_unpackedNeuroInputSegmentHitsName
private

Name for neuro input Track segments.

Definition at line 182 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputVector

StoreArray<CDCTriggerMLPInput> m_unpackedNeuroInputVector
private

StoreArray for neuro input vector from unpacker.

Definition at line 203 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroInputVectorName

std::string m_unpackedNeuroInputVectorName
private

Name for neuro input vector from unpacker.

Definition at line 178 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroTracks

StoreArray<CDCTriggerTrack> m_unpackedNeuroTracks
private

StoreArray for neuro tracks from unpacker.

Definition at line 201 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_unpackedNeuroTracksName

std::string m_unpackedNeuroTracksName
private

Name for neuro tracks from unpacker.

Definition at line 176 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_useRecoTracks

bool m_useRecoTracks
private

Switch to turn on use of recotracks.

Definition at line 191 of file CDCTriggerNeuroDQMOnlineModule.h.

◆ m_useSimTracks

bool m_useSimTracks
private

Switch to turn on use of hw sim tracks.

Definition at line 193 of file CDCTriggerNeuroDQMOnlineModule.h.

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