Belle II Software  release-05-02-19
CDCTriggerNeuroDQMModule Class Reference

CDC Trigger DQM Module. More...

#include <CDCTriggerNeuroDQMModule.h>

Inheritance diagram for CDCTriggerNeuroDQMModule:
Collaboration diagram for CDCTriggerNeuroDQMModule:

Classes

struct  TSLine
 

Public Types

typedef std::vector< TSLineTSLines
 
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

 CDCTriggerNeuroDQMModule ()
 Constructor.
 
virtual ~CDCTriggerNeuroDQMModule ()
 Destructor.
 
virtual void initialize () override
 Module functions.
 
virtual void beginRun () override
 Function to process begin_run record.
 
virtual void event () override
 Function to process event record.
 
virtual void endRun () override
 Function to process end_run record.
 
virtual void terminate () override
 Function to terminate module.
 
virtual void defineHisto () override
 Histogram definitions such as TH1(), TH2(), TNtuple(), TTree().... More...
 
virtual std::vector< std::string > getFileNames (__attribute__((unused)) bool outputFiles)
 Return a list of output filenames for this modules. More...
 
const std::string & getName () const
 Returns the name of the module. More...
 
const std::string & getType () const
 Returns the type of the module (i.e. More...
 
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. More...
 
void setPropertyFlags (unsigned int propertyFlags)
 Sets the flags for the module properties. More...
 
LogConfiggetLogConfig ()
 Returns the log system configuration.
 
void setLogConfig (const LogConfig &logConfig)
 Set the log system configuration.
 
void setLogLevel (int logLevel)
 Configure the log level.
 
void setDebugLevel (int debugLevel)
 Configure the debug messaging level.
 
void setAbortLevel (int abortLevel)
 Configure the abort log level.
 
void setLogInfo (int logLevel, unsigned int logInfo)
 Configure the printed log information for the given level. More...
 
void if_value (const std::string &expression, const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 Add a condition to the module. More...
 
void if_false (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to add a condition to the module. More...
 
void if_true (const std::shared_ptr< Path > &path, EAfterConditionPath afterConditionPath=EAfterConditionPath::c_End)
 A simplified version to set the condition of the module. More...
 
bool hasCondition () const
 Returns true if at least one condition was set for the module.
 
const ModuleConditiongetCondition () const
 Return a pointer to the first condition (or nullptr, if none was set)
 
const std::vector< ModuleCondition > & getAllConditions () const
 Return all set conditions for this module.
 
bool evalCondition () const
 If at least one condition was set, it is evaluated and true returned if at least one condition returns true. More...
 
std::shared_ptr< PathgetConditionPath () const
 Returns the path of the last true condition (if there is at least one, else reaturn a null pointer). More...
 
Module::EAfterConditionPath getAfterConditionPath () const
 What to do after the conditional path is finished. More...
 
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. More...
 
bool hasUnsetForcedParams () const
 Returns true and prints error message if the module has unset parameters which the user has to set in the steering file.
 
const ModuleParamListgetParamList () const
 Return module param list.
 
template<typename T >
ModuleParam< T > & getParam (const std::string &name) const
 Returns a reference to a parameter. More...
 
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. More...
 
std::shared_ptr< PathElementclone () const override
 Create an independent copy of this module. More...
 
std::shared_ptr< boost::python::list > getParamInfoListPython () const
 Returns a python list of all parameters. More...
 

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. More...
 
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. More...
 
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. More...
 
void setType (const std::string &type)
 Set the module type. More...
 
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. More...
 
template<typename T >
void addParam (const std::string &name, T &paramVariable, const std::string &description)
 Adds a new enforced parameter to the module. More...
 
void setReturnValue (int value)
 Sets the return value for this module as integer. More...
 
void setReturnValue (bool value)
 Sets the return value for this module as bool. More...
 
void setParamList (const ModuleParamList &params)
 Replace existing parameter list.
 

Private Member Functions

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< ModulePtrgetModules () const override
 no submodules, return empty list
 
std::string getPathString () const override
 return the module name.
 
void setParamPython (const std::string &name, const boost::python::object &pyObj)
 Implements a method for setting boost::python objects. More...
 
void setParamPythonDict (const boost::python::dict &dictionary)
 Implements a method for reading the parameter values from a boost::python dictionary. More...
 

Private Attributes

std::string m_histogramDirectoryName
 Name of the histogram directory in ROOT file.
 
bool m_limitedoutput
 Switch to supress output for dqm online module.
 
int m_nsamets
 Number of identical track segments to be required for matching between HW and SW Neurotrigger.
 
std::string m_unpackedSegmentHitsName
 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_unpackedNeuroInputSegmentsName
 Name for neuro input Track segments.
 
std::string m_simNeuroTracksName
 Name for neuro tracks from TSIM using HW TS, HW 2D.
 
std::string m_simNeuroInputVectorName
 Name for simulated neuro input vector using HW TS, HW 2D.
 
bool m_showRecoTracks
 Switch to turn on a comparison with the reconstruction.
 
int m_recoTrackMultiplicity
 Select events with a specific RecoTrack track multiplicity. More...
 
bool m_skipWithoutHWTS
 Switch to skip events without unpacked TS.
 
double m_maxRecoZDist
 Select only RecoTracks with a maximum z distance to the IP. More...
 
double m_maxRecoD0Dist
 Select only RecoTracks with a maximum d0 distance to the z axis. More...
 
std::string m_simSegmentHitsName
 Name for simulated TS hits.
 
std::string m_sim2DTracksSWTSName
 Name for simulated 2D finder tracks using simulated TS.
 
std::string m_simNeuroTracksSWTSSW2DName
 Name for neuro tracks using simulated TS and simulated 2D.
 
std::string m_simNeuroInputVectorSWTSSW2DName
 Name for neuro input vector using simulated TS and simulated 2D.
 
std::string m_recoTracksName
 Name for the RecoTrack array name.
 
StoreArray< CDCTriggerSegmentHitm_unpackedSegmentHits
 StoreArray for TS hits from unpacker.
 
StoreArray< CDCTriggerTrackm_unpacked2DTracks
 StoreArray for 2D finder tracks from unpacker.
 
StoreArray< CDCTriggerTrackm_unpackedNeuroTracks
 StoreArray for neuro tracks from unpacker.
 
StoreArray< CDCTriggerMLPInputm_unpackedNeuroInputVector
 StoreArray for neuro input vector from unpacker.
 
StoreArray< CDCTriggerTrackm_unpackedNeuroInput2DTracks
 StoreArray for neuro input 2dfinder tracks.
 
StoreArray< CDCTriggerSegmentHitm_unpackedNeuroInputSegments
 StoreArray for neuro input Track segments.
 
StoreArray< CDCTriggerTrackm_simNeuroTracks
 StoreArray for neuro tracks from TSIM.
 
StoreArray< CDCTriggerMLPInputm_simNeuroInputVector
 StoreArray for neuro input vector from TSIM.
 
StoreArray< RecoTrackm_RecoTracks
 StoreArray for RecoTracks.
 
StoreArray< CDCTriggerSegmentHitm_simSegmentHits
 StoreArray for simulated TS hits.
 
StoreArray< CDCTriggerTrackm_sim2DTracksSWTS
 StoreArray for simulated 2D finder tracks using simulated TS.
 
StoreArray< CDCTriggerMLPInputm_simNeuroInputVectorSWTSSW2D
 StoreArray for neuro input vector using simulated TS and simulated 2D.
 
StoreArray< CDCTriggerTrackm_simNeuroTracksSWTSSW2D
 StoreArray for neuro tracks using simulated TS and simulated 2D.
 
TH1F * m_neuroHWOutZ = nullptr
 z distribution of unpacked neuro tracks
 
TH1F * m_neuroHWOutCosTheta = nullptr
 cos theta distribution of unpacked neuro tracks
 
TH1F * m_neuroHWOutInvPt = nullptr
 Inverse Pt distribution of unpacked neuro tracks.
 
TH1F * m_neuroHWOutPt = nullptr
 Pt distribution of unpacked neuro tracks.
 
TH1F * m_neuroHWOutPhi0 = nullptr
 phi distribution of unpacked neuro tracks
 
TH1F * m_neuroHWOutHitPattern = nullptr
 stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
 
TH1F * m_neuroHWOutm_time = nullptr
 m_time distribution of unpacked neuro tracks
 
TH1F * m_neuroHWOutTrackCount = nullptr
 number of unpacked tracks per event
 
TH1F * m_neuroHWSector = nullptr
 sector of unpacked neuro tracks
 
TH1F * m_neuroHWInInvPt = nullptr
 Inverse Pt distribution from incoming 2dtrack.
 
TH1F * m_neuroHWInPhi0 = nullptr
 Phi0 of incoming 2dtrack.
 
TH1F * m_neuroHWInm_time = nullptr
 m_time distribution from incoming 2dtracks
 
TH1F * m_neuroHWInTrackCount = nullptr
 number of neuro input 2dtracks per event
 
TH1F * m_neuroHWOutVsInTrackCount = nullptr
 neuroHWOutTracks - neuroHWInTrackCount
 
TH1F * m_2DHWOutInvPt = nullptr
 Inverse Pt of 2dtracks.
 
TH1F * m_2DHWOutPhi0 = nullptr
 Phi0 of 2dtracks.
 
TH1F * m_2DHWOutm_time = nullptr
 m_time 2dtracks
 
TH1F * m_2DHWOutTrackCount = nullptr
 number of 2dtracks per event
 
TH1F * m_neuroHWInVs2DOutTrackCount = nullptr
 neuroHWInTrackCount - 2DHWOutTrackCountput
 
TH1F * m_neuroSWOutZ = nullptr
 z distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWOutCosTheta = nullptr
 cos theta distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWOutInvPt = nullptr
 Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWOutPhi0 = nullptr
 phi distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWOutHitPattern = nullptr
 stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWOutTrackCount = nullptr
 number of simulated tracks per event (hw TS hw 2D sw NN)
 
TH1F * m_neuroSWSector = nullptr
 NN sector from simulation (hw TS hw 2D sw NN)
 
TH1F * m_2DSWOutInvPt = nullptr
 Inverse Pt of 2dtracks (sw TS sw 2D)
 
TH1F * m_2DSWOutPhi0 = nullptr
 Phi0 of 2dtracks (sw TS sw 2D)
 
TH1F * m_2DSWOutm_time = nullptr
 m_time 2dtracks (sw TS sw 2D)
 
TH1F * m_2DSWOutTrackCount = nullptr
 number of 2dtracks per event (sw TS sw 2D)
 
TH1F * m_neuroSWTSSW2DOutZ = nullptr
 z distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DOutCosTheta = nullptr
 cos theta distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DOutInvPt = nullptr
 Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DOutPhi0 = nullptr
 phi distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DOutHitPattern = nullptr
 stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DOutTrackCount = nullptr
 number of simulated tracks per event (sw TS sw 2D sw NN)
 
TH1F * m_neuroSWTSSW2DSector = nullptr
 NN sector from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroDeltaZ = nullptr
 unpacked z - TSIM z
 
TH1F * m_neuroDeltaTheta = nullptr
 unpacked theta - TSIM theta
 
TH2F * m_neuroScatterZ = nullptr
 unpacked z vs TSIM z, scatter plot
 
TH2F * m_neuroScatterTheta = nullptr
 unpacked theta vs TSIM theta, scatter plot
 
TH1F * m_neuroDeltaInputID = nullptr
 unpacked ID input - TSIM ID input
 
TH1F * m_neuroDeltaInputT = nullptr
 unpacked time input - TSIM time input
 
TH1F * m_neuroDeltaInputAlpha = nullptr
 unpacked alpha input - TSIM alpha input
 
TH1F * m_neuroDeltaTSID = nullptr
 unpacked selected TSID - TSIM selected TSID
 
TH1F * m_neuroDeltaSector = nullptr
 unpacked sector - TSIM sector
 
TH1F * m_simSameTS = nullptr
 number of TS selected in both, unpacked and TSIM tracks
 
TH1F * m_simDiffTS = nullptr
 number of TS selcted in TSIM but not in unpacked
 
TH1F * m_neuroHWOutQuad5Z = nullptr
 z distribution from unpacker (no quadrant set)
 
TH1F * m_neuroHWOutQuad5CosTheta = nullptr
 cos theta distribution from unpacker (no quadrant set)
 
TH1F * m_neuroHWOutQuad5Phi0 = nullptr
 phi distribution from unpacker (no quadrant set)
 
TH1F * m_neuroHWOutQuad5InvPt = nullptr
 Inverse Pt distribution from unpacker (no quadrant set)
 
TH1F * m_neuroHWOutQuad0Z = nullptr
 z distribution from unpacker (quadrant 0)
 
TH1F * m_neuroHWOutQuad0CosTheta = nullptr
 cos theta distribution from unpacker (quadrant 0)
 
TH1F * m_neuroHWOutQuad0Phi0 = nullptr
 phi distribution from unpacker (quadrant 0)
 
TH1F * m_neuroHWOutQuad0InvPt = nullptr
 Inverse Pt distribution from unpacker (quadrant 0)
 
TH1F * m_neuroHWOutQuad1Z = nullptr
 z distribution from unpacker (quadrant 1)
 
TH1F * m_neuroHWOutQuad1CosTheta = nullptr
 cos theta distribution from unpacker (quadrant 1)
 
TH1F * m_neuroHWOutQuad1Phi0 = nullptr
 phi distribution from unpacker (quadrant 1)
 
TH1F * m_neuroHWOutQuad1InvPt = nullptr
 Inverse Pt distribution from unpacker (quadrant 1)
 
TH1F * m_neuroHWOutQuad2Z = nullptr
 z distribution from unpacker (quadrant 2)
 
TH1F * m_neuroHWOutQuad2CosTheta = nullptr
 cos theta distribution from unpacker (quadrant 2)
 
TH1F * m_neuroHWOutQuad2Phi0 = nullptr
 phi distribution from unpacker (quadrant 2)
 
TH1F * m_neuroHWOutQuad2InvPt = nullptr
 Inverse Pt distribution from unpacker (quadrant 2)
 
TH1F * m_neuroHWOutQuad3Z = nullptr
 z distribution from unpacker (quadrant 3)
 
TH1F * m_neuroHWOutQuad3CosTheta = nullptr
 cos theta distribution from unpacker (quadrant 3)
 
TH1F * m_neuroHWOutQuad3Phi0 = nullptr
 phi distribution from unpacker (quadrant 3)
 
TH1F * m_neuroHWOutQuad3InvPt = nullptr
 Inverse Pt distribution from unpacker (quadrant 3)
 
TH1F * m_neuroHWInTSID = nullptr
 ID of incoming track segments.
 
TH1F * m_neuroHWInTSCount = nullptr
 number of TS per track
 
TH1F * m_neuroHWInTSPrioT_Layer0 = nullptr
 Priority time of track segments in layer 0.
 
TH1F * m_neuroHWInTSPrioT_Layer1 = nullptr
 Priority time of track segments in layer 1.
 
TH1F * m_neuroHWInTSPrioT_Layer2 = nullptr
 Priority time of track segments in layer 2.
 
TH1F * m_neuroHWInTSPrioT_Layer3 = nullptr
 Priority time of track segments in layer 3.
 
TH1F * m_neuroHWInTSPrioT_Layer4 = nullptr
 Priority time of track segments in layer 4.
 
TH1F * m_neuroHWInTSPrioT_Layer5 = nullptr
 Priority time of track segments in layer 5.
 
TH1F * m_neuroHWInTSPrioT_Layer6 = nullptr
 Priority time of track segments in layer 6.
 
TH1F * m_neuroHWInTSPrioT_Layer7 = nullptr
 Priority time of track segments in layer 7.
 
TH1F * m_neuroHWInTSPrioT_Layer8 = nullptr
 Priority time of track segments in layer 8.
 
TH1F * m_neuroHWInTSFoundT_Layer0 = nullptr
 Found time of track segments in layer 0.
 
TH1F * m_neuroHWInTSFoundT_Layer1 = nullptr
 Found time of track segments in layer 1.
 
TH1F * m_neuroHWInTSFoundT_Layer2 = nullptr
 Found time of track segments in layer 2.
 
TH1F * m_neuroHWInTSFoundT_Layer3 = nullptr
 Found time of track segments in layer 3.
 
TH1F * m_neuroHWInTSFoundT_Layer4 = nullptr
 Found time of track segments in layer 4.
 
TH1F * m_neuroHWInTSFoundT_Layer5 = nullptr
 Found time of track segments in layer 5.
 
TH1F * m_neuroHWInTSFoundT_Layer6 = nullptr
 Found time of track segments in layer 6.
 
TH1F * m_neuroHWInTSFoundT_Layer7 = nullptr
 Found time of track segments in layer 7.
 
TH1F * m_neuroHWInTSFoundT_Layer8 = nullptr
 Found time of track segments in layer 8.
 
TH1F * m_neuroHWInTSPrioB_Layer0 = nullptr
 Priority bits of track segments in layer 0.
 
TH1F * m_neuroHWInTSPrioB_Layer1 = nullptr
 Priority bits of track segments in layer 1.
 
TH1F * m_neuroHWInTSPrioB_Layer2 = nullptr
 Priority bits of track segments in layer 2.
 
TH1F * m_neuroHWInTSPrioB_Layer3 = nullptr
 Priority bits of track segments in layer 3.
 
TH1F * m_neuroHWInTSPrioB_Layer4 = nullptr
 Priority bits of track segments in layer 4.
 
TH1F * m_neuroHWInTSPrioB_Layer5 = nullptr
 Priority bits of track segments in layer 5.
 
TH1F * m_neuroHWInTSPrioB_Layer6 = nullptr
 Priority bits of track segments in layer 6.
 
TH1F * m_neuroHWInTSPrioB_Layer7 = nullptr
 Priority bits of track segments in layer 7.
 
TH1F * m_neuroHWInTSPrioB_Layer8 = nullptr
 Priority bits of track segments in layer 8.
 
TH1F * m_neuroHWInTSLR_Layer0 = nullptr
 Left/Right of track segments in layer 0.
 
TH1F * m_neuroHWInTSLR_Layer1 = nullptr
 Left/Right of track segments in layer 1.
 
TH1F * m_neuroHWInTSLR_Layer2 = nullptr
 Left/Right of track segments in layer 2.
 
TH1F * m_neuroHWInTSLR_Layer3 = nullptr
 Left/Right of track segments in layer 3.
 
TH1F * m_neuroHWInTSLR_Layer4 = nullptr
 Left/Right of track segments in layer 4.
 
TH1F * m_neuroHWInTSLR_Layer5 = nullptr
 Left/Right of track segments in layer 5.
 
TH1F * m_neuroHWInTSLR_Layer6 = nullptr
 Left/Right of track segments in layer 6.
 
TH1F * m_neuroHWInTSLR_Layer7 = nullptr
 Left/Right of track segments in layer 7.
 
TH1F * m_neuroHWInTSLR_Layer8 = nullptr
 Left/Right of track segments in layer 8.
 
TH1F * m_neuroHWSelTSID = nullptr
 ID of selected track segments.
 
TH1F * m_neuroHWSelTSCount = nullptr
 number of selected TS per SL
 
TH1F * m_neuroHWSelTSPrioT_Layer0 = nullptr
 Priority time of selected track segments in layer 0.
 
TH1F * m_neuroHWSelTSPrioT_Layer1 = nullptr
 Priority time of selected track segments in layer 1.
 
TH1F * m_neuroHWSelTSPrioT_Layer2 = nullptr
 Priority time of selected track segments in layer 2.
 
TH1F * m_neuroHWSelTSPrioT_Layer3 = nullptr
 Priority time of selected track segments in layer 3.
 
TH1F * m_neuroHWSelTSPrioT_Layer4 = nullptr
 Priority time of selected track segments in layer 4.
 
TH1F * m_neuroHWSelTSPrioT_Layer5 = nullptr
 Priority time of selected track segments in layer 5.
 
TH1F * m_neuroHWSelTSPrioT_Layer6 = nullptr
 Priority time of selected track segments in layer 6.
 
TH1F * m_neuroHWSelTSPrioT_Layer7 = nullptr
 Priority time of selected track segments in layer 7.
 
TH1F * m_neuroHWSelTSPrioT_Layer8 = nullptr
 Priority time of selected track segments in layer 8.
 
TH1F * m_neuroHWSelTSFoundT_Layer0 = nullptr
 Found time of selected track segments in layer 0.
 
TH1F * m_neuroHWSelTSFoundT_Layer1 = nullptr
 Found time of selected track segments in layer 1.
 
TH1F * m_neuroHWSelTSFoundT_Layer2 = nullptr
 Found time of selected track segments in layer 2.
 
TH1F * m_neuroHWSelTSFoundT_Layer3 = nullptr
 Found time of selected track segments in layer 3.
 
TH1F * m_neuroHWSelTSFoundT_Layer4 = nullptr
 Found time of selected track segments in layer 4.
 
TH1F * m_neuroHWSelTSFoundT_Layer5 = nullptr
 Found time of selected track segments in layer 5.
 
TH1F * m_neuroHWSelTSFoundT_Layer6 = nullptr
 Found time of selected track segments in layer 6.
 
TH1F * m_neuroHWSelTSFoundT_Layer7 = nullptr
 Found time of selected track segments in layer 7.
 
TH1F * m_neuroHWSelTSFoundT_Layer8 = nullptr
 Found time of selected track segments in layer 8.
 
TH1F * m_neuroHWSelTSPrioB_Layer0 = nullptr
 Priority bits of track segments in layer 0.
 
TH1F * m_neuroHWSelTSPrioB_Layer1 = nullptr
 Priority bits of track segments in layer 1.
 
TH1F * m_neuroHWSelTSPrioB_Layer2 = nullptr
 Priority bits of track segments in layer 2.
 
TH1F * m_neuroHWSelTSPrioB_Layer3 = nullptr
 Priority bits of track segments in layer 3.
 
TH1F * m_neuroHWSelTSPrioB_Layer4 = nullptr
 Priority bits of track segments in layer 4.
 
TH1F * m_neuroHWSelTSPrioB_Layer5 = nullptr
 Priority bits of track segments in layer 5.
 
TH1F * m_neuroHWSelTSPrioB_Layer6 = nullptr
 Priority bits of track segments in layer 6.
 
TH1F * m_neuroHWSelTSPrioB_Layer7 = nullptr
 Priority bits of track segments in layer 7.
 
TH1F * m_neuroHWSelTSPrioB_Layer8 = nullptr
 Priority bits of track segments in layer 8.
 
TH1F * m_neuroHWSelTSLR_Layer0 = nullptr
 Left/Right of track segments in layer 0.
 
TH1F * m_neuroHWSelTSLR_Layer1 = nullptr
 Left/Right of track segments in layer 1.
 
TH1F * m_neuroHWSelTSLR_Layer2 = nullptr
 Left/Right of track segments in layer 2.
 
TH1F * m_neuroHWSelTSLR_Layer3 = nullptr
 Left/Right of track segments in layer 3.
 
TH1F * m_neuroHWSelTSLR_Layer4 = nullptr
 Left/Right of track segments in layer 4.
 
TH1F * m_neuroHWSelTSLR_Layer5 = nullptr
 Left/Right of track segments in layer 5.
 
TH1F * m_neuroHWSelTSLR_Layer6 = nullptr
 Left/Right of track segments in layer 6.
 
TH1F * m_neuroHWSelTSLR_Layer7 = nullptr
 Left/Right of track segments in layer 7.
 
TH1F * m_neuroHWSelTSLR_Layer8 = nullptr
 Left/Right of track segments in layer 8.
 
TH1F * m_2DHWInTSID = nullptr
 ID of 2D incoming axial track segments.
 
TH1F * m_2DHWInTSCount = nullptr
 number of 2D incoming TS per event
 
TH1F * m_2DHWInTSPrioT_Layer0 = nullptr
 Priority time of 2D track segments in layer 0.
 
TH1F * m_2DHWInTSPrioT_Layer2 = nullptr
 Priority time of 2D track segments in layer 2.
 
TH1F * m_2DHWInTSPrioT_Layer4 = nullptr
 Priority time of 2D track segments in layer 4.
 
TH1F * m_2DHWInTSPrioT_Layer6 = nullptr
 Priority time of 2D track segments in layer 6.
 
TH1F * m_2DHWInTSPrioT_Layer8 = nullptr
 Priority time of 2D track segments in layer 8.
 
TH1F * m_2DHWInTSFoundT_Layer0 = nullptr
 Found time of 2D track segments in layer 0.
 
TH1F * m_2DHWInTSFoundT_Layer2 = nullptr
 Found time of 2D track segments in layer 2.
 
TH1F * m_2DHWInTSFoundT_Layer4 = nullptr
 Found time of 2D track segments in layer 4.
 
TH1F * m_2DHWInTSFoundT_Layer6 = nullptr
 Found time of 2D track segments in layer 6.
 
TH1F * m_2DHWInTSFoundT_Layer8 = nullptr
 Found time of 2D track segments in layer 8.
 
TH1F * m_2DHWInTSPrioB_Layer0 = nullptr
 Priority bits of 2D track segments in layer 0.
 
TH1F * m_2DHWInTSPrioB_Layer2 = nullptr
 Priority bits of 2D track segments in layer 2.
 
TH1F * m_2DHWInTSPrioB_Layer4 = nullptr
 Priority bits of 2D track segments in layer 4.
 
TH1F * m_2DHWInTSPrioB_Layer6 = nullptr
 Priority bits of 2D track segments in layer 6.
 
TH1F * m_2DHWInTSPrioB_Layer8 = nullptr
 Priority bits of 2D track segments in layer 8.
 
TH1F * m_2DHWInTSLR_Layer0 = nullptr
 Left/Right of 2D track segments in layer 0.
 
TH1F * m_2DHWInTSLR_Layer2 = nullptr
 Left/Right of 2D track segments in layer 2.
 
TH1F * m_2DHWInTSLR_Layer4 = nullptr
 Left/Right of 2D track segments in layer 4.
 
TH1F * m_2DHWInTSLR_Layer6 = nullptr
 Left/Right of 2D track segments in layer 6.
 
TH1F * m_2DHWInTSLR_Layer8 = nullptr
 Left/Right of 2D track segments in layer 8.
 
TH1F * m_neuroSWSelTSID = nullptr
 ID of incoming track segments.
 
TH1F * m_neuroSWSelTSCount = nullptr
 number of TS per SL
 
TH1F * m_neuroSWSelTSPrioT_Layer0 = nullptr
 Priority time of track segments in layer 0.
 
TH1F * m_neuroSWSelTSPrioT_Layer1 = nullptr
 Priority time of track segments in layer 1.
 
TH1F * m_neuroSWSelTSPrioT_Layer2 = nullptr
 Priority time of track segments in layer 2.
 
TH1F * m_neuroSWSelTSPrioT_Layer3 = nullptr
 Priority time of track segments in layer 3.
 
TH1F * m_neuroSWSelTSPrioT_Layer4 = nullptr
 Priority time of track segments in layer 4.
 
TH1F * m_neuroSWSelTSPrioT_Layer5 = nullptr
 Priority time of track segments in layer 5.
 
TH1F * m_neuroSWSelTSPrioT_Layer6 = nullptr
 Priority time of track segments in layer 6.
 
TH1F * m_neuroSWSelTSPrioT_Layer7 = nullptr
 Priority time of track segments in layer 7.
 
TH1F * m_neuroSWSelTSPrioT_Layer8 = nullptr
 Priority time of track segments in layer 8.
 
TH1F * m_neuroSWSelTSFoundT_Layer0 = nullptr
 Found time of track segments in layer 0.
 
TH1F * m_neuroSWSelTSFoundT_Layer1 = nullptr
 Found time of track segments in layer 1.
 
TH1F * m_neuroSWSelTSFoundT_Layer2 = nullptr
 Found time of track segments in layer 2.
 
TH1F * m_neuroSWSelTSFoundT_Layer3 = nullptr
 Found time of track segments in layer 3.
 
TH1F * m_neuroSWSelTSFoundT_Layer4 = nullptr
 Found time of track segments in layer 4.
 
TH1F * m_neuroSWSelTSFoundT_Layer5 = nullptr
 Found time of track segments in layer 5.
 
TH1F * m_neuroSWSelTSFoundT_Layer6 = nullptr
 Found time of track segments in layer 6.
 
TH1F * m_neuroSWSelTSFoundT_Layer7 = nullptr
 Found time of track segments in layer 7.
 
TH1F * m_neuroSWSelTSFoundT_Layer8 = nullptr
 Found time of track segments in layer 8.
 
TH1F * m_neuroSWSelTSPrioB_Layer0 = nullptr
 Priority bits of track segments in layer 0.
 
TH1F * m_neuroSWSelTSPrioB_Layer1 = nullptr
 Priority bits of track segments in layer 1.
 
TH1F * m_neuroSWSelTSPrioB_Layer2 = nullptr
 Priority bits of track segments in layer 2.
 
TH1F * m_neuroSWSelTSPrioB_Layer3 = nullptr
 Priority bits of track segments in layer 3.
 
TH1F * m_neuroSWSelTSPrioB_Layer4 = nullptr
 Priority bits of track segments in layer 4.
 
TH1F * m_neuroSWSelTSPrioB_Layer5 = nullptr
 Priority bits of track segments in layer 5.
 
TH1F * m_neuroSWSelTSPrioB_Layer6 = nullptr
 Priority bits of track segments in layer 6.
 
TH1F * m_neuroSWSelTSPrioB_Layer7 = nullptr
 Priority bits of track segments in layer 7.
 
TH1F * m_neuroSWSelTSPrioB_Layer8 = nullptr
 Priority bits of track segments in layer 8.
 
TH1F * m_neuroSWSelTSLR_Layer0 = nullptr
 Left/Right of track segments in layer 0.
 
TH1F * m_neuroSWSelTSLR_Layer1 = nullptr
 Left/Right of track segments in layer 1.
 
TH1F * m_neuroSWSelTSLR_Layer2 = nullptr
 Left/Right of track segments in layer 2.
 
TH1F * m_neuroSWSelTSLR_Layer3 = nullptr
 Left/Right of track segments in layer 3.
 
TH1F * m_neuroSWSelTSLR_Layer4 = nullptr
 Left/Right of track segments in layer 4.
 
TH1F * m_neuroSWSelTSLR_Layer5 = nullptr
 Left/Right of track segments in layer 5.
 
TH1F * m_neuroSWSelTSLR_Layer6 = nullptr
 Left/Right of track segments in layer 6.
 
TH1F * m_neuroSWSelTSLR_Layer7 = nullptr
 Left/Right of track segments in layer 7.
 
TH1F * m_neuroSWSelTSLR_Layer8 = nullptr
 Left/Right of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DInTSID = nullptr
 ID of incoming track segments.
 
TH1F * m_neuroSWTSSW2DInTSCount = nullptr
 number of TS per event
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer0 = nullptr
 Priority time of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer1 = nullptr
 Priority time of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer2 = nullptr
 Priority time of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer3 = nullptr
 Priority time of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer4 = nullptr
 Priority time of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer5 = nullptr
 Priority time of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer6 = nullptr
 Priority time of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer7 = nullptr
 Priority time of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer8 = nullptr
 Priority time of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer0 = nullptr
 Found time of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer1 = nullptr
 Found time of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer2 = nullptr
 Found time of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer3 = nullptr
 Found time of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer4 = nullptr
 Found time of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer5 = nullptr
 Found time of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer6 = nullptr
 Found time of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer7 = nullptr
 Found time of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer8 = nullptr
 Found time of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer0 = nullptr
 Priority bits of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer1 = nullptr
 Priority bits of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer2 = nullptr
 Priority bits of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer3 = nullptr
 Priority bits of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer4 = nullptr
 Priority bits of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer5 = nullptr
 Priority bits of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer6 = nullptr
 Priority bits of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer7 = nullptr
 Priority bits of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer8 = nullptr
 Priority bits of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer0 = nullptr
 Left/Right of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer1 = nullptr
 Left/Right of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer2 = nullptr
 Left/Right of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer3 = nullptr
 Left/Right of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer4 = nullptr
 Left/Right of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer5 = nullptr
 Left/Right of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer6 = nullptr
 Left/Right of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer7 = nullptr
 Left/Right of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DInTSLR_Layer8 = nullptr
 Left/Right of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DSelTSID = nullptr
 ID of incoming track segments.
 
TH1F * m_neuroSWTSSW2DSelTSCount = nullptr
 number of TS per SL
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer0 = nullptr
 Priority time of selected track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer1 = nullptr
 Priority time of selected track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer2 = nullptr
 Priority time of selected track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer3 = nullptr
 Priority time of selected track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer4 = nullptr
 Priority time of selected track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer5 = nullptr
 Priority time of selected track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer6 = nullptr
 Priority time of selected track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer7 = nullptr
 Priority time of selected track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer8 = nullptr
 Priority time of selected track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer0 = nullptr
 Found time of selected track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer1 = nullptr
 Found time of selected track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer2 = nullptr
 Found time of selected track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer3 = nullptr
 Found time of selected track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer4 = nullptr
 Found time of selected track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer5 = nullptr
 Found time of selected track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer6 = nullptr
 Found time of selected track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer7 = nullptr
 Found time of selected track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer8 = nullptr
 Found time of selected track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer0 = nullptr
 Priority bits of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer1 = nullptr
 Priority bits of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer2 = nullptr
 Priority bits of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer3 = nullptr
 Priority bits of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer4 = nullptr
 Priority bits of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer5 = nullptr
 Priority bits of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer6 = nullptr
 Priority bits of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer7 = nullptr
 Priority bits of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer8 = nullptr
 Priority bits of track segments in layer 8.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer0 = nullptr
 Left/Right of track segments in layer 0.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer1 = nullptr
 Left/Right of track segments in layer 1.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer2 = nullptr
 Left/Right of track segments in layer 2.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer3 = nullptr
 Left/Right of track segments in layer 3.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer4 = nullptr
 Left/Right of track segments in layer 4.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer5 = nullptr
 Left/Right of track segments in layer 5.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer6 = nullptr
 Left/Right of track segments in layer 6.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer7 = nullptr
 Left/Right of track segments in layer 7.
 
TH1F * m_neuroSWTSSW2DSelTSLR_Layer8 = nullptr
 Left/Right of track segments in layer 8.
 
TH1F * m_neuroHWInputID_Layer0 = nullptr
 unpacked id input in layer 0
 
TH1F * m_neuroHWInputT_Layer0 = nullptr
 unpacked time input in layer 0
 
TH1F * m_neuroHWInputAlpha_Layer0 = nullptr
 unpacked alpha input in layer 0
 
TH1F * m_neuroHWInputID_Layer1 = nullptr
 unpacked id input in layer 1
 
TH1F * m_neuroHWInputT_Layer1 = nullptr
 unpacked time input in layer 1
 
TH1F * m_neuroHWInputAlpha_Layer1 = nullptr
 unpacked alpha input in layer 1
 
TH1F * m_neuroHWInputID_Layer2 = nullptr
 unpacked id input in layer 2
 
TH1F * m_neuroHWInputT_Layer2 = nullptr
 unpacked time input in layer 2
 
TH1F * m_neuroHWInputAlpha_Layer2 = nullptr
 unpacked alpha input in layer 2
 
TH1F * m_neuroHWInputID_Layer3 = nullptr
 unpacked id input in layer 3
 
TH1F * m_neuroHWInputT_Layer3 = nullptr
 unpacked time input in layer 3
 
TH1F * m_neuroHWInputAlpha_Layer3 = nullptr
 unpacked alpha input in layer 3
 
TH1F * m_neuroHWInputID_Layer4 = nullptr
 unpacked id input in layer 4
 
TH1F * m_neuroHWInputT_Layer4 = nullptr
 unpacked time input in layer 4
 
TH1F * m_neuroHWInputAlpha_Layer4 = nullptr
 unpacked alpha input in layer 4
 
TH1F * m_neuroHWInputID_Layer5 = nullptr
 unpacked id input in layer 5
 
TH1F * m_neuroHWInputT_Layer5 = nullptr
 unpacked time input in layer 5
 
TH1F * m_neuroHWInputAlpha_Layer5 = nullptr
 unpacked alpha input in layer 5
 
TH1F * m_neuroHWInputID_Layer6 = nullptr
 unpacked id input in layer 6
 
TH1F * m_neuroHWInputT_Layer6 = nullptr
 unpacked time input in layer 6
 
TH1F * m_neuroHWInputAlpha_Layer6 = nullptr
 unpacked alpha input in layer 6
 
TH1F * m_neuroHWInputID_Layer7 = nullptr
 unpacked id input in layer 7
 
TH1F * m_neuroHWInputT_Layer7 = nullptr
 unpacked time input in layer 7
 
TH1F * m_neuroHWInputAlpha_Layer7 = nullptr
 unpacked alpha input in layer 7
 
TH1F * m_neuroHWInputID_Layer8 = nullptr
 unpacked id input in layer 8
 
TH1F * m_neuroHWInputT_Layer8 = nullptr
 unpacked time input in layer 8
 
TH1F * m_neuroHWInputAlpha_Layer8 = nullptr
 unpacked alpha input in layer 8
 
TH1F * m_neuroSWInputID_Layer0 = nullptr
 simulated id input in layer 0
 
TH1F * m_neuroSWInputT_Layer0 = nullptr
 simulated time input in layer 0
 
TH1F * m_neuroSWInputAlpha_Layer0 = nullptr
 simulated alpha input in layer 0
 
TH1F * m_neuroSWInputID_Layer1 = nullptr
 simulated id input in layer 1
 
TH1F * m_neuroSWInputT_Layer1 = nullptr
 simulated time input in layer 1
 
TH1F * m_neuroSWInputAlpha_Layer1 = nullptr
 simulated alpha input in layer 1
 
TH1F * m_neuroSWInputID_Layer2 = nullptr
 simulated id input in layer 2
 
TH1F * m_neuroSWInputT_Layer2 = nullptr
 simulated time input in layer 2
 
TH1F * m_neuroSWInputAlpha_Layer2 = nullptr
 simulated alpha input in layer 2
 
TH1F * m_neuroSWInputID_Layer3 = nullptr
 simulated id input in layer 3
 
TH1F * m_neuroSWInputT_Layer3 = nullptr
 simulated time input in layer 3
 
TH1F * m_neuroSWInputAlpha_Layer3 = nullptr
 simulated alpha input in layer 3
 
TH1F * m_neuroSWInputID_Layer4 = nullptr
 simulated id input in layer 4
 
TH1F * m_neuroSWInputT_Layer4 = nullptr
 simulated time input in layer 4
 
TH1F * m_neuroSWInputAlpha_Layer4 = nullptr
 simulated alpha input in layer 4
 
TH1F * m_neuroSWInputID_Layer5 = nullptr
 simulated id input in layer 5
 
TH1F * m_neuroSWInputT_Layer5 = nullptr
 simulated time input in layer 5
 
TH1F * m_neuroSWInputAlpha_Layer5 = nullptr
 simulated alpha input in layer 5
 
TH1F * m_neuroSWInputID_Layer6 = nullptr
 simulated id input in layer 6
 
TH1F * m_neuroSWInputT_Layer6 = nullptr
 simulated time input in layer 6
 
TH1F * m_neuroSWInputAlpha_Layer6 = nullptr
 simulated alpha input in layer 6
 
TH1F * m_neuroSWInputID_Layer7 = nullptr
 simulated id input in layer 7
 
TH1F * m_neuroSWInputT_Layer7 = nullptr
 simulated time input in layer 7
 
TH1F * m_neuroSWInputAlpha_Layer7 = nullptr
 simulated alpha input in layer 7
 
TH1F * m_neuroSWInputID_Layer8 = nullptr
 simulated id input in layer 8
 
TH1F * m_neuroSWInputT_Layer8 = nullptr
 simulated time input in layer 8
 
TH1F * m_neuroSWInputAlpha_Layer8 = nullptr
 simulated alpha input in layer 8
 
TH1F * m_neuroSWTSSW2DInputID_Layer0 = nullptr
 simulated id input in layer 0
 
TH1F * m_neuroSWTSSW2DInputT_Layer0 = nullptr
 simulated time input in layer 0
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer0 = nullptr
 simulated alpha input in layer 0
 
TH1F * m_neuroSWTSSW2DInputID_Layer1 = nullptr
 simulated id input in layer 1
 
TH1F * m_neuroSWTSSW2DInputT_Layer1 = nullptr
 simulated time input in layer 1
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer1 = nullptr
 simulated alpha input in layer 1
 
TH1F * m_neuroSWTSSW2DInputID_Layer2 = nullptr
 simulated id input in layer 2
 
TH1F * m_neuroSWTSSW2DInputT_Layer2 = nullptr
 simulated time input in layer 2
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer2 = nullptr
 simulated alpha input in layer 2
 
TH1F * m_neuroSWTSSW2DInputID_Layer3 = nullptr
 simulated id input in layer 3
 
TH1F * m_neuroSWTSSW2DInputT_Layer3 = nullptr
 simulated time input in layer 3
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer3 = nullptr
 simulated alpha input in layer 3
 
TH1F * m_neuroSWTSSW2DInputID_Layer4 = nullptr
 simulated id input in layer 4
 
TH1F * m_neuroSWTSSW2DInputT_Layer4 = nullptr
 simulated time input in layer 4
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer4 = nullptr
 simulated alpha input in layer 4
 
TH1F * m_neuroSWTSSW2DInputID_Layer5 = nullptr
 simulated id input in layer 5
 
TH1F * m_neuroSWTSSW2DInputT_Layer5 = nullptr
 simulated time input in layer 5
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer5 = nullptr
 simulated alpha input in layer 5
 
TH1F * m_neuroSWTSSW2DInputID_Layer6 = nullptr
 simulated id input in layer 6
 
TH1F * m_neuroSWTSSW2DInputT_Layer6 = nullptr
 simulated time input in layer 6
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer6 = nullptr
 simulated alpha input in layer 6
 
TH1F * m_neuroSWTSSW2DInputID_Layer7 = nullptr
 simulated id input in layer 7
 
TH1F * m_neuroSWTSSW2DInputT_Layer7 = nullptr
 simulated time input in layer 7
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer7 = nullptr
 simulated alpha input in layer 7
 
TH1F * m_neuroSWTSSW2DInputID_Layer8 = nullptr
 simulated id input in layer 8
 
TH1F * m_neuroSWTSSW2DInputT_Layer8 = nullptr
 simulated time input in layer 8
 
TH1F * m_neuroSWTSSW2DInputAlpha_Layer8 = nullptr
 simulated alpha input in layer 8
 
TH1F * m_RecoZ = nullptr
 reconstructed z
 
TH1F * m_RecoCosTheta = nullptr
 reconstructed cos(theta)
 
TH1F * m_RecoInvPt = nullptr
 reconstructed inverse Pt
 
TH1F * m_RecoPhi = nullptr
 reconstructed phi
 
TH1F * m_RecoD0 = nullptr
 reconstructed d0
 
TH1F * m_RecoTrackCount = nullptr
 number of reconstructed tracks per event
 
TH1F * m_RecoHWZ = nullptr
 matched to HW reconstructed z
 
TH1F * m_RecoHWCosTheta = nullptr
 matched to HW reconstructed cos(theta)
 
TH1F * m_RecoHWInvPt = nullptr
 matched to HW reconstructed inverse Pt
 
TH1F * m_RecoHWPhi = nullptr
 matched to HW reconstructed phi
 
TH1F * m_RecoHWD0 = nullptr
 matched to HW reconstructed d0
 
TH2F * m_RecoHWZScatter = nullptr
 matched to HW reconstructed z scatter plot
 
TH1F * m_neuroRecoHWOutZ = nullptr
 reco matched z distribution from unpacker
 
TH1F * m_neuroRecoHWOutCosTheta = nullptr
 reco matched cos theta distribution from unpacker
 
TH1F * m_neuroRecoHWOutInvPt = nullptr
 reco matched Inverse Pt distribution from unpacker
 
TH1F * m_neuroRecoHWOutPhi0 = nullptr
 reco matched phi distribution from unpacker
 
TH1F * m_neuroRecoHWOutHitPattern = nullptr
 reco matched stereo hit pattern from unpacker
 
TH1F * m_neuroRecoHWOutTrackCount = nullptr
 reco matched number of unpacked and matched tracks per event
 
TH1F * m_neuroRecoHWSector = nullptr
 reco matched NN sector from unpacker
 
TH1F * m_DeltaRecoHWZ = nullptr
 matched to HW reconstructed z
 
TH1F * m_DeltaRecoHWCosTheta = nullptr
 matched to HW reconstructed cos(theta)
 
TH1F * m_DeltaRecoHWInvPt = nullptr
 matched to HW reconstructed inverse Pt
 
TH1F * m_DeltaRecoHWPhi = nullptr
 matched to HW reconstructed phi
 
TH1F * m_RecoSWZ = nullptr
 matched to SW reconstructed z
 
TH1F * m_RecoSWCosTheta = nullptr
 matched to SW reconstructed cos(theta)
 
TH1F * m_RecoSWInvPt = nullptr
 matched to SW reconstructed inverse Pt
 
TH1F * m_RecoSWPhi = nullptr
 matched to SW reconstructed phi
 
TH1F * m_RecoSWD0 = nullptr
 matched to SW reconstructed d0
 
TH2F * m_RecoSWZScatter = nullptr
 matched to SW reconstructed z scatter plot
 
TH1F * m_neuroRecoSWOutZ = nullptr
 reco matched z distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWOutCosTheta = nullptr
 reco matched cos theta distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWOutInvPt = nullptr
 reco matched Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWOutPhi0 = nullptr
 reco matched phi distribution from simulation (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWOutHitPattern = nullptr
 reco matched stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWOutTrackCount = nullptr
 reco matched number of simulated tracks per event (hw TS hw 2D sw NN)
 
TH1F * m_neuroRecoSWSector = nullptr
 reco matched NN sector from simulation (hw TS hw 2D sw NN)
 
TH1F * m_DeltaRecoSWZ = nullptr
 matched to SW reconstructed z
 
TH1F * m_DeltaRecoSWCosTheta = nullptr
 matched to SW reconstructed cos(theta)
 
TH1F * m_DeltaRecoSWInvPt = nullptr
 matched to SW reconstructed inverse Pt
 
TH1F * m_DeltaRecoSWPhi = nullptr
 matched to SW reconstructed phi
 
TH1F * m_RecoSWTSSW2DZ = nullptr
 matched to SWTSSW2DSWNN reconstructed z
 
TH1F * m_RecoSWTSSW2DCosTheta = nullptr
 matched to SWTSSW2DSWNN reconstructed cos(theta)
 
TH1F * m_RecoSWTSSW2DInvPt = nullptr
 matched to SWTSSW2DSWNN reconstructed inverse Pt
 
TH1F * m_RecoSWTSSW2DPhi = nullptr
 matched to SWTSSW2DSWNN reconstructed phi
 
TH1F * m_RecoSWTSSW2DD0 = nullptr
 matched to SWTSSW2DSWNN reconstructed d0
 
TH2F * m_RecoSWTSSW2DZScatter = nullptr
 matched to SWTSSW2DSWNN reconstructed z scatter plot
 
TH1F * m_neuroRecoSWTSSW2DOutZ = nullptr
 reco matched z distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroRecoSWTSSW2DOutCosTheta = nullptr
 reco matched cos theta distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroRecoSWTSSW2DOutInvPt = nullptr
 reco matched Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroRecoSWTSSW2DOutPhi0 = nullptr
 reco matched phi distribution from simulation (sw TS sw 2D sw NN)
 
TH1F * m_neuroRecoSWTSSW2DOutHitPattern
 reco matched stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN) More...
 
TH1F * m_neuroRecoSWTSSW2DOutTrackCount = nullptr
 reco matched number of simulated tracks per event (sw TS sw 2D sw NN)
 
TH1F * m_neuroRecoSWTSSW2DSector = nullptr
 reco matched NN sector from simulation (sw TS sw 2D sw NN)
 
TH1F * m_DeltaRecoSWTSSW2DZ = nullptr
 matched to SWTSSW2DSWNN reconstructed z
 
TH1F * m_DeltaRecoSWTSSW2DCosTheta = nullptr
 matched to SWTSSW2DSWNN reconstructed cos(theta)
 
TH1F * m_DeltaRecoSWTSSW2DInvPt = nullptr
 matched to SWTSSW2DSWNN reconstructed inverse Pt
 
TH1F * m_DeltaRecoSWTSSW2DPhi = nullptr
 matched to SWTSSW2DSWNN reconstructed phi
 
std::string m_name
 The name of the module, saved as a string (user-modifiable)
 
std::string m_type
 The type of the module, saved as a string.
 
std::string m_package
 Package this module is found in (may be empty).
 
std::string m_description
 The description of the module.
 
unsigned int m_propertyFlags
 The properties of the module as bitwise or (with |) of EModulePropFlags.
 
LogConfig m_logConfig
 The log system configuration of the module.
 
ModuleParamList m_moduleParamList
 List storing and managing all parameter of the module.
 
bool m_hasReturnValue
 True, if the return value is set.
 
int m_returnValue
 The return value.
 
std::vector< ModuleConditionm_conditions
 Module condition, only non-null if set.
 

Detailed Description

CDC Trigger DQM Module.

Definition at line 42 of file CDCTriggerNeuroDQMModule.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 79 of file Module.h.

Member Function Documentation

◆ 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 181 of file Module.cc.

◆ 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 441 of file Module.h.

◆ 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 422 of file Module.h.

◆ defineHisto()

void defineHisto ( )
overridevirtual

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

are supposed to be placed in this function.

Reimplemented from HistoModule.

Definition at line 98 of file CDCTriggerNeuroDQMModule.cc.

99 {
100  // Create a separate histogram directory and cd into it.
101  TDirectory* oldDir = gDirectory;
102  if (m_histogramDirectoryName != "") {
103  oldDir->mkdir(m_histogramDirectoryName.c_str());
104  oldDir->cd(m_histogramDirectoryName.c_str());
105  }
106  //----------------------------------------------------------------
107 
108  // define neurotrigger histograms
109  if (m_unpackedNeuroTracksName != "") {
110  m_neuroHWOutZ = new TH1F("NeuroHWOutZ",
111  "z distribution of unpacked neuro tracks; z [cm]",
112  100, -100, 100);
113  m_neuroHWOutCosTheta = new TH1F("NeuroHWOutCosTheta",
114  "cos theta distribution of unpacked neuro tracks; cos(#theta) ",
115  100, -1, 1);
116  m_neuroHWOutPhi0 = new TH1F("NeuroHWOutPhi0",
117  "phi distribution of unpacked neuro tracks; #phi [#circ]",
118  80, 0, 360); // shift to reduce the binning error
119  m_neuroHWOutInvPt = new TH1F("NeuroHWOutInvPt",
120  "Inverse Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
121  50, 0, 5);
122  m_neuroHWOutPt = new TH1F("NeuroHWOutPt",
123  "Pt distribution of unpacked neuro tracks; p_{T} [GeV]",
124  340, 0, 11);
125  m_neuroHWOutHitPattern = new TH1F("NeuroUnpackedHitPattern",
126  "stereo hit pattern of unpacked neuro tracks; pattern",
127  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
128  m_neuroHWOutm_time = new TH1F("NeuroHWOutM_time", "m_time distribution of unpacked neuro tracks; clock cycle",
129  48, 0, 48);
130  m_neuroHWOutTrackCount = new TH1F("NeuroHWOutTrackCount",
131  "number of unpacked neuro tracks per event",
132  20, 0, 20);
133  m_neuroHWSector = new TH1F("NeuroHWSector",
134  "sector of unpacked neuro tracks; sector",
135  10, 0, 10);
136 
137 
138  m_neuroHWInInvPt = new TH1F("NeuroHWInInvPt",
139  "Inverse Pt distribution from incoming 2dtrack; p_{T}^{-1} [GeV^{-1}]",
140  50, 0, 5);
141  m_neuroHWInPhi0 = new TH1F("NeuroHWInPhi0", "Phi0 of incoming 2dtrack; #phi [#circ]",
142  80, 0, 360);
143  m_neuroHWInm_time = new TH1F("NeuroHWInM_time", "m_time distribution from incoming 2dtracks; clock cycle",
144  48, 0, 48);
145  m_neuroHWInTrackCount = new TH1F("NeuroHWInTrackCount", "number of neuro input 2dtracks per event",
146  20, 0, 20);
147  m_neuroHWOutVsInTrackCount = new TH1F("NeuroHWOutVsInTrackCount",
148  "number of neuroHWOutTracks - number of 2dinTracks",
149  20, -10, 10);
150  m_neuroHWInTSID = new TH1F("NeuroHWInTSID", "ID of incoming track segments",
151  2336, 0, 2335);
152  m_neuroHWInTSCount = new TH1F("NeuroHWInTSCount", " number of TS per event",
153  200, 0, 200);
154  m_neuroHWSelTSID = new TH1F("NeuroHWSelTSID", "ID of selected track segments",
155  2336, 0, 2335);
156  m_neuroHWSelTSCount = new TH1F("NeuroHWSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
157  }
158  if (!m_limitedoutput && m_unpacked2DTracksName != "") {
159  m_2DHWInTSPrioT_Layer0 = new TH1F("2DHWInTSPrioT_Layer0", "Priority time of track segments in layer 0",
160  512, 0, 511);
161  m_2DHWInTSPrioT_Layer2 = new TH1F("2DHWInTSPrioT_Layer2", "Priority time of track segments in layer 2",
162  512, 0, 511);
163  m_2DHWInTSPrioT_Layer4 = new TH1F("2DHWInTSPrioT_Layer4", "Priority time of track segments in layer 4",
164  512, 0, 511);
165  m_2DHWInTSPrioT_Layer6 = new TH1F("2DHWInTSPrioT_Layer6", "Priority time of track segments in layer 6",
166  512, 0, 511);
167  m_2DHWInTSPrioT_Layer8 = new TH1F("2DHWInTSPrioT_Layer8", "Priority time of track segments in layer 8",
168  512, 0, 511);
169  m_2DHWInTSFoundT_Layer0 = new TH1F("2DHWInTSFoundT_Layer0", "Found time of track segments in layer 0",
170  96, -48, 48);
171  m_2DHWInTSFoundT_Layer2 = new TH1F("2DHWInTSFoundT_Layer2", "Found time of track segments in layer 2",
172  96, -48, 48);
173  m_2DHWInTSFoundT_Layer4 = new TH1F("2DHWInTSFoundT_Layer4", "Found time of track segments in layer 4",
174  96, -48, 48);
175  m_2DHWInTSFoundT_Layer6 = new TH1F("2DHWInTSFoundT_Layer6", "Found time of track segments in layer 6",
176  96, -48, 48);
177  m_2DHWInTSFoundT_Layer8 = new TH1F("2DHWInTSFoundT_Layer8", "Found time of track segments in layer 8",
178  96, -48, 48);
179 
180 
181  m_2DHWInTSPrioB_Layer0 = new TH1F("2DHWInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
182  4, 0, 4);
183  m_2DHWInTSPrioB_Layer2 = new TH1F("2DHWInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
184  4, 0, 4);
185  m_2DHWInTSPrioB_Layer4 = new TH1F("2DHWInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
186  4, 0, 4);
187  m_2DHWInTSPrioB_Layer6 = new TH1F("2DHWInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
188  4, 0, 4);
189  m_2DHWInTSPrioB_Layer8 = new TH1F("2DHWInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
190  4, 0, 4);
191  m_2DHWInTSLR_Layer0 = new TH1F("2DHWInTSLR_Layer0", "Left/Right of track segments in layer 0",
192  4, 0, 4);
193  m_2DHWInTSLR_Layer2 = new TH1F("2DHWInTSLR_Layer2", "Left/Right of track segments in layer 2",
194  4, 0, 4);
195  m_2DHWInTSLR_Layer4 = new TH1F("2DHWInTSLR_Layer4", "Left/Right of track segments in layer 4",
196  4, 0, 4);
197  m_2DHWInTSLR_Layer6 = new TH1F("2DHWInTSLR_Layer6", "Left/Right of track segments in layer 6",
198  4, 0, 4);
199  m_2DHWInTSLR_Layer8 = new TH1F("2DHWInTSLR_Layer8", "Left/Right of track segments in layer 8",
200  4, 0, 4);
201  }
203 
204  m_neuroHWOutQuad5Z = new TH1F("NeuroHWOutQuad5Z",
205  "z distribution of neuro tracks; z [cm]",
206  100, -100, 100);
207  m_neuroHWOutQuad5CosTheta = new TH1F("NeuroHWOutQuad5CosTheta",
208  "cos theta distribution of neuro tracks; cos(#theta) ",
209  100, -1, 1);
210  m_neuroHWOutQuad5InvPt = new TH1F("NeuroHWOutQuad5InvPt",
211  "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
212  50, 0, 5);
213  m_neuroHWOutQuad5Phi0 = new TH1F("NeuroHWOutQuad5Phi0",
214  "phi distribution from unpacker; #phi [#circ]",
215  80, 0, 360);
216 
217  m_neuroHWOutQuad0Z = new TH1F("NeuroHWOutQuad0Z",
218  "z distribution of neuro tracks; z [cm]",
219  100, -100, 100);
220  m_neuroHWOutQuad0CosTheta = new TH1F("NeuroHWOutQuad0CosTheta",
221  "cos theta distribution of neuro tracks; cos(#theta) ",
222  100, -1, 1);
223  m_neuroHWOutQuad0InvPt = new TH1F("NeuroHWOutQuad0InvPt",
224  "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
225  50, 0, 5);
226  m_neuroHWOutQuad0Phi0 = new TH1F("NeuroHWOutQuad0Phi0",
227  "phi distribution from unpacker; #phi [#circ]",
228  80, 0, 360);
229 
230  m_neuroHWOutQuad1Z = new TH1F("NeuroHWOutQuad1Z",
231  "z distribution of neuro tracks; z [cm]",
232  100, -100, 100);
233  m_neuroHWOutQuad1CosTheta = new TH1F("NeuroHWOutQuad1CosTheta",
234  "cos theta distribution of neuro tracks; cos(#theta) ",
235  100, -1, 1);
236  m_neuroHWOutQuad1Phi0 = new TH1F("NeuroHWOutQuad1Phi0",
237  "phi distribution from unpacker; #phi [#circ]",
238  80, 0, 360);
239  m_neuroHWOutQuad1InvPt = new TH1F("NeuroHWOutQuad1InvPt",
240  "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
241  50, 0, 5);
242 
243  m_neuroHWOutQuad2Z = new TH1F("NeuroHWOutQuad2Z",
244  "z distribution of neuro tracks; z [cm]",
245  100, -100, 100);
246  m_neuroHWOutQuad2CosTheta = new TH1F("NeuroHWOutQuad2CosTheta",
247  "cos theta distribution of neuro tracks; cos(#theta) ",
248  100, -1, 1);
249  m_neuroHWOutQuad2Phi0 = new TH1F("NeuroHWOutQuad2Phi0",
250  "phi distribution from unpacker; #phi [#circ]",
251  80, 0, 360);
252  m_neuroHWOutQuad2InvPt = new TH1F("NeuroHWOutQuad2InvPt",
253  "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
254  50, 0, 5);
255 
256  m_neuroHWOutQuad3Z = new TH1F("NeuroHWOutQuad3Z",
257  "z distribution of neuro tracks; z [cm]",
258  100, -100, 100);
259  m_neuroHWOutQuad3CosTheta = new TH1F("NeuroHWOutQuad3CosTheta",
260  "cos theta distribution of neuro tracks; cos(#theta) ",
261  100, -1, 1);
262  m_neuroHWOutQuad3Phi0 = new TH1F("NeuroHWOutQuad3Phi0",
263  "phi distribution from unpacker; #phi [#circ]",
264  80, 0, 360);
265  m_neuroHWOutQuad3InvPt = new TH1F("NeuroHWOutQuad3InvPt",
266  "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
267  50, 0, 5);
268  m_neuroHWInTSPrioT_Layer0 = new TH1F("NeuroHWInTSPrioT_Layer0", "Priority time of track segments in layer 0",
269  512, 0, 511);
270  m_neuroHWInTSPrioT_Layer1 = new TH1F("NeuroHWInTSPrioT_Layer1", "Priority time of track segments in layer 1",
271  512, 0, 511);
272  m_neuroHWInTSPrioT_Layer2 = new TH1F("NeuroHWInTSPrioT_Layer2", "Priority time of track segments in layer 2",
273  512, 0, 511);
274  m_neuroHWInTSPrioT_Layer3 = new TH1F("NeuroHWInTSPrioT_Layer3", "Priority time of track segments in layer 3",
275  512, 0, 511);
276  m_neuroHWInTSPrioT_Layer4 = new TH1F("NeuroHWInTSPrioT_Layer4", "Priority time of track segments in layer 4",
277  512, 0, 511);
278  m_neuroHWInTSPrioT_Layer5 = new TH1F("NeuroHWInTSPrioT_Layer5", "Priority time of track segments in layer 5",
279  512, 0, 511);
280  m_neuroHWInTSPrioT_Layer6 = new TH1F("NeuroHWInTSPrioT_Layer6", "Priority time of track segments in layer 6",
281  512, 0, 511);
282  m_neuroHWInTSPrioT_Layer7 = new TH1F("NeuroHWInTSPrioT_Layer7", "Priority time of track segments in layer 7",
283  512, 0, 511);
284  m_neuroHWInTSPrioT_Layer8 = new TH1F("NeuroHWInTSPrioT_Layer8", "Priority time of track segments in layer 8",
285  512, 0, 511);
286  m_neuroHWInTSFoundT_Layer0 = new TH1F("NeuroHWInTSFoundT_Layer0", "Found time of track segments in layer 0",
287  48, 0, 48);
288  m_neuroHWInTSFoundT_Layer1 = new TH1F("NeuroHWInTSFoundT_Layer1", "Found time of track segments in layer 1",
289  48, 0, 48);
290  m_neuroHWInTSFoundT_Layer2 = new TH1F("NeuroHWInTSFoundT_Layer2", "Found time of track segments in layer 2",
291  48, 0, 48);
292  m_neuroHWInTSFoundT_Layer3 = new TH1F("NeuroHWInTSFoundT_Layer3", "Found time of track segments in layer 3",
293  48, 0, 48);
294  m_neuroHWInTSFoundT_Layer4 = new TH1F("NeuroHWInTSFoundT_Layer4", "Found time of track segments in layer 4",
295  48, 0, 48);
296  m_neuroHWInTSFoundT_Layer5 = new TH1F("NeuroHWInTSFoundT_Layer5", "Found time of track segments in layer 5",
297  48, 0, 48);
298  m_neuroHWInTSFoundT_Layer6 = new TH1F("NeuroHWInTSFoundT_Layer6", "Found time of track segments in layer 6",
299  48, 0, 48);
300  m_neuroHWInTSFoundT_Layer7 = new TH1F("NeuroHWInTSFoundT_Layer7", "Found time of track segments in layer 7",
301  48, 0, 48);
302  m_neuroHWInTSFoundT_Layer8 = new TH1F("NeuroHWInTSFoundT_Layer8", "Found time of track segments in layer 8",
303  48, 0, 48);
304 
305 
306  m_neuroHWInTSPrioB_Layer0 = new TH1F("NeuroHWInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
307  4, 0, 4);
308  m_neuroHWInTSPrioB_Layer1 = new TH1F("NeuroHWInTSPrioB_Layer1", "Priority bits of track segments in layer 1",
309  4, 0, 4);
310  m_neuroHWInTSPrioB_Layer2 = new TH1F("NeuroHWInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
311  4, 0, 4);
312  m_neuroHWInTSPrioB_Layer3 = new TH1F("NeuroHWInTSPrioB_Layer3", "Priority bits of track segments in layer 3",
313  4, 0, 4);
314  m_neuroHWInTSPrioB_Layer4 = new TH1F("NeuroHWInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
315  4, 0, 4);
316  m_neuroHWInTSPrioB_Layer5 = new TH1F("NeuroHWInTSPrioB_Layer5", "Priority bits of track segments in layer 5",
317  4, 0, 4);
318  m_neuroHWInTSPrioB_Layer6 = new TH1F("NeuroHWInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
319  4, 0, 4);
320  m_neuroHWInTSPrioB_Layer7 = new TH1F("NeuroHWInTSPrioB_Layer7", "Priority bits of track segments in layer 7",
321  4, 0, 4);
322  m_neuroHWInTSPrioB_Layer8 = new TH1F("NeuroHWInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
323  4, 0, 4);
324 
325 
326  m_neuroHWInTSLR_Layer0 = new TH1F("NeuroHWInTSLR_Layer0", "Left/Right of track segments in layer 0",
327  4, 0, 4);
328  m_neuroHWInTSLR_Layer1 = new TH1F("NeuroHWInTSLR_Layer1", "Left/Right of track segments in layer 1",
329  4, 0, 4);
330  m_neuroHWInTSLR_Layer2 = new TH1F("NeuroHWInTSLR_Layer2", "Left/Right of track segments in layer 2",
331  4, 0, 4);
332  m_neuroHWInTSLR_Layer3 = new TH1F("NeuroHWInTSLR_Layer3", "Left/Right of track segments in layer 3",
333  4, 0, 4);
334  m_neuroHWInTSLR_Layer4 = new TH1F("NeuroHWInTSLR_Layer4", "Left/Right of track segments in layer 4",
335  4, 0, 4);
336  m_neuroHWInTSLR_Layer5 = new TH1F("NeuroHWInTSLR_Layer5", "Left/Right of track segments in layer 5",
337  4, 0, 4);
338  m_neuroHWInTSLR_Layer6 = new TH1F("NeuroHWInTSLR_Layer6", "Left/Right of track segments in layer 6",
339  4, 0, 4);
340  m_neuroHWInTSLR_Layer7 = new TH1F("NeuroHWInTSLR_Layer7", "Left/Right of track segments in layer 7",
341  4, 0, 4);
342  m_neuroHWInTSLR_Layer8 = new TH1F("NeuroHWInTSLR_Layer8", "Left/Right of track segments in layer 8",
343  4, 0, 4);
344  m_neuroHWSelTSPrioT_Layer0 = new TH1F("NeuroHWSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
345  512, 0, 511);
346  m_neuroHWSelTSPrioT_Layer1 = new TH1F("NeuroHWSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
347  512, 0, 511);
348  m_neuroHWSelTSPrioT_Layer2 = new TH1F("NeuroHWSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
349  512, 0, 511);
350  m_neuroHWSelTSPrioT_Layer3 = new TH1F("NeuroHWSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
351  512, 0, 511);
352  m_neuroHWSelTSPrioT_Layer4 = new TH1F("NeuroHWSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
353  512, 0, 511);
354  m_neuroHWSelTSPrioT_Layer5 = new TH1F("NeuroHWSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
355  512, 0, 511);
356  m_neuroHWSelTSPrioT_Layer6 = new TH1F("NeuroHWSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
357  512, 0, 511);
358  m_neuroHWSelTSPrioT_Layer7 = new TH1F("NeuroHWSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
359  512, 0, 511);
360  m_neuroHWSelTSPrioT_Layer8 = new TH1F("NeuroHWSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
361  512, 0, 511);
362  m_neuroHWSelTSFoundT_Layer0 = new TH1F("NeuroHWSelTSFoundT_Layer0",
363  "First found time of selected TS - found time of Neuro Track in SL 0",
364  96, -47.99, 48.01);
365  m_neuroHWSelTSFoundT_Layer1 = new TH1F("NeuroHWSelTSFoundT_Layer1",
366  "First found time of selected TS - found time of Neuro Track in SL 1",
367  96, -47.99, 48.01);
368  m_neuroHWSelTSFoundT_Layer2 = new TH1F("NeuroHWSelTSFoundT_Layer2",
369  "First found time of selected TS - found time of Neuro Track in SL 2",
370  96, -47.99, 48.01);
371  m_neuroHWSelTSFoundT_Layer3 = new TH1F("NeuroHWSelTSFoundT_Layer3",
372  "First found time of selected TS - found time of Neuro Track in SL 3",
373  96, -47.99, 48.01);
374  m_neuroHWSelTSFoundT_Layer4 = new TH1F("NeuroHWSelTSFoundT_Layer4",
375  "First found time of selected TS - found time of Neuro Track in SL 4",
376  96, -47.99, 48.01);
377  m_neuroHWSelTSFoundT_Layer5 = new TH1F("NeuroHWSelTSFoundT_Layer5",
378  "First found time of selected TS - found time of Neuro Track in SL 5",
379  96, -47.99, 48.01);
380  m_neuroHWSelTSFoundT_Layer6 = new TH1F("NeuroHWSelTSFoundT_Layer6",
381  "First found time of selected TS - found time of Neuro Track in SL 6",
382  96, -47.99, 48.01);
383  m_neuroHWSelTSFoundT_Layer7 = new TH1F("NeuroHWSelTSFoundT_Layer7",
384  "First found time of selected TS - found time of Neuro Track in SL 7",
385  96, -47.99, 48.01);
386  m_neuroHWSelTSFoundT_Layer8 = new TH1F("NeuroHWSelTSFoundT_Layer8",
387  "First found time of selected TS - found time of Neuro Track in SL 8",
388  96, -47.99, 48.01);
389 
390 
391  m_neuroHWSelTSPrioB_Layer0 = new TH1F("NeuroHWSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
392  4, 0, 4);
393  m_neuroHWSelTSPrioB_Layer1 = new TH1F("NeuroHWSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
394  4, 0, 4);
395  m_neuroHWSelTSPrioB_Layer2 = new TH1F("NeuroHWSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
396  4, 0, 4);
397  m_neuroHWSelTSPrioB_Layer3 = new TH1F("NeuroHWSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
398  4, 0, 4);
399  m_neuroHWSelTSPrioB_Layer4 = new TH1F("NeuroHWSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
400  4, 0, 4);
401  m_neuroHWSelTSPrioB_Layer5 = new TH1F("NeuroHWSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
402  4, 0, 4);
403  m_neuroHWSelTSPrioB_Layer6 = new TH1F("NeuroHWSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
404  4, 0, 4);
405  m_neuroHWSelTSPrioB_Layer7 = new TH1F("NeuroHWSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
406  4, 0, 4);
407  m_neuroHWSelTSPrioB_Layer8 = new TH1F("NeuroHWSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
408  4, 0, 4);
409 
410 
411  m_neuroHWSelTSLR_Layer0 = new TH1F("NeuroHWSelTSLR_Layer0", "Left/Right of track segments in layer 0",
412  4, 0, 4);
413  m_neuroHWSelTSLR_Layer1 = new TH1F("NeuroHWSelTSLR_Layer1", "Left/Right of track segments in layer 1",
414  4, 0, 4);
415  m_neuroHWSelTSLR_Layer2 = new TH1F("NeuroHWSelTSLR_Layer2", "Left/Right of track segments in layer 2",
416  4, 0, 4);
417  m_neuroHWSelTSLR_Layer3 = new TH1F("NeuroHWSelTSLR_Layer3", "Left/Right of track segments in layer 3",
418  4, 0, 4);
419  m_neuroHWSelTSLR_Layer4 = new TH1F("NeuroHWSelTSLR_Layer4", "Left/Right of track segments in layer 4",
420  4, 0, 4);
421  m_neuroHWSelTSLR_Layer5 = new TH1F("NeuroHWSelTSLR_Layer5", "Left/Right of track segments in layer 5",
422  4, 0, 4);
423  m_neuroHWSelTSLR_Layer6 = new TH1F("NeuroHWSelTSLR_Layer6", "Left/Right of track segments in layer 6",
424  4, 0, 4);
425  m_neuroHWSelTSLR_Layer7 = new TH1F("NeuroHWSelTSLR_Layer7", "Left/Right of track segments in layer 7",
426  4, 0, 4);
427  m_neuroHWSelTSLR_Layer8 = new TH1F("NeuroHWSelTSLR_Layer8", "Left/Right of track segments in layer 8",
428  4, 0, 4);
429  m_neuroHWInputID_Layer0 = new TH1F("NeuroHWInputID_Layer0",
430  "unpacked id input in layer 0; id",
431  100, -1, 1);
432  m_neuroHWInputT_Layer0 = new TH1F("NeuroHWInputT_Layer0",
433  "unpacked time input in layer 0; time",
434  100, -1, 1);
435  m_neuroHWInputAlpha_Layer0 = new TH1F("NeuroHWInputAlpha_Layer0",
436  "unpacked alpha input in layer 0; alpha",
437  100, -1, 1);
438  m_neuroHWInputID_Layer1 = new TH1F("NeuroHWInputID_Layer1",
439  "unpacked id input in layer 1; id",
440  100, -1, 1);
441  m_neuroHWInputT_Layer1 = new TH1F("NeuroHWInputT_Layer1",
442  "unpacked time input in layer 1; time",
443  100, -1, 1);
444  m_neuroHWInputAlpha_Layer1 = new TH1F("NeuroHWInputAlpha_Layer1",
445  "unpacked alpha input in layer 1; alpha",
446  100, -1, 1);
447  m_neuroHWInputID_Layer2 = new TH1F("NeuroHWInputID_Layer2",
448  "unpacked id input in layer 2; id",
449  100, -1, 1);
450  m_neuroHWInputT_Layer2 = new TH1F("NeuroHWInputT_Layer2",
451  "unpacked time input in layer 2; time",
452  100, -1, 1);
453  m_neuroHWInputAlpha_Layer2 = new TH1F("NeuroHWInputAlpha_Layer2",
454  "unpacked alpha input in layer 2; alpha",
455  100, -1, 1);
456  m_neuroHWInputID_Layer3 = new TH1F("NeuroHWInputID_Layer3",
457  "unpacked id input in layer 3; id",
458  100, -1, 1);
459  m_neuroHWInputT_Layer3 = new TH1F("NeuroHWInputT_Layer3",
460  "unpacked time input in layer 3; time",
461  100, -1, 1);
462  m_neuroHWInputAlpha_Layer3 = new TH1F("NeuroHWInputAlpha_Layer3",
463  "unpacked alpha input in layer 3; alpha",
464  100, -1, 1);
465  m_neuroHWInputID_Layer4 = new TH1F("NeuroHWInputID_Layer4",
466  "unpacked id input in layer 4; id",
467  100, -1, 1);
468  m_neuroHWInputT_Layer4 = new TH1F("NeuroHWInputT_Layer4",
469  "unpacked time input in layer 4; time",
470  100, -1, 1);
471  m_neuroHWInputAlpha_Layer4 = new TH1F("NeuroHWInputAlpha_Layer4",
472  "unpacked alpha input in layer 4; alpha",
473  100, -1, 1);
474  m_neuroHWInputID_Layer5 = new TH1F("NeuroHWInputID_Layer5",
475  "unpacked id input in layer 5; id",
476  100, -1, 1);
477  m_neuroHWInputT_Layer5 = new TH1F("NeuroHWInputT_Layer5",
478  "unpacked time input in layer 5; time",
479  100, -1, 1);
480  m_neuroHWInputAlpha_Layer5 = new TH1F("NeuroHWInputAlpha_Layer5",
481  "unpacked alpha input in layer 5; alpha",
482  100, -1, 1);
483  m_neuroHWInputID_Layer6 = new TH1F("NeuroHWInputID_Layer6",
484  "unpacked id input in layer 6; id",
485  100, -1, 1);
486  m_neuroHWInputT_Layer6 = new TH1F("NeuroHWInputT_Layer6",
487  "unpacked time input in layer 6; time",
488  100, -1, 1);
489  m_neuroHWInputAlpha_Layer6 = new TH1F("NeuroHWInputAlpha_Layer6",
490  "unpacked alpha input in layer 6; alpha",
491  100, -1, 1);
492  m_neuroHWInputID_Layer7 = new TH1F("NeuroHWInputID_Layer7",
493  "unpacked id input in layer 7; id",
494  100, -1, 1);
495  m_neuroHWInputT_Layer7 = new TH1F("NeuroHWInputT_Layer7",
496  "unpacked time input in layer 7; time",
497  100, -1, 1);
498  m_neuroHWInputAlpha_Layer7 = new TH1F("NeuroHWInputAlpha_Layer7",
499  "unpacked alpha input in layer 7; alpha",
500  100, -1, 1);
501  m_neuroHWInputID_Layer8 = new TH1F("NeuroHWInputID_Layer8",
502  "unpacked id input in layer 8; id",
503  100, -1, 1);
504  m_neuroHWInputT_Layer8 = new TH1F("NeuroHWInputT_Layer8",
505  "unpacked time input in layer 8; time",
506  100, -1, 1);
507  m_neuroHWInputAlpha_Layer8 = new TH1F("NeuroHWInputAlpha_Layer8",
508  "unpacked alpha input in layer 8; alpha",
509  100, -1, 1);
510  }
511  if (m_unpacked2DTracksName != "") {
512  m_2DHWOutInvPt = new TH1F("2DHWOutInvPt",
513  "Inverse Pt of 2dtracks; p_{T}^{-1} [GeV^{-1}]",
514  50, 0, 5);
515  m_2DHWOutPhi0 = new TH1F("2DHWOutPhi0", "Phi0 of 2dtracks; #phi [#circ]",
516  80, 0, 360);
517  m_2DHWOutm_time = new TH1F("2DHWOutM_time", "m_time of 2dtracks; clock cycle",
518  96, -48, 48);
519  m_2DHWOutTrackCount = new TH1F("2DHWOutTrackCount", "number of 2dtracks per event", 20, 0, 20);
520  m_neuroHWInVs2DOutTrackCount = new TH1F("NeuroHWInVs2DOutTrackCount", "neuro in tracks - 2d out tracks",
521  20, -10, 10);
522  }
523 
524  if (!m_limitedoutput && m_simNeuroTracksName != "") {
525  m_neuroSWOutZ = new TH1F("NeuroSWOutZ",
526  "z distribution from simulation, hw TS hw 2D; z [cm]",
527  100, -100, 100);
528  m_neuroSWOutCosTheta = new TH1F("NeuroSWOutCosTheta",
529  "cos theta distribution from simulation, hw TS hw 2D; cos(#theta) ",
530  100, -1, 1);
531  m_neuroSWOutInvPt = new TH1F("NeuroSWOutInvPt",
532  "Inverse Pt distribution from simulation, hw TS hw 2D; p_{T}^{-1} [GeV^{-1}]",
533  50, 0, 5);
534  m_neuroSWOutPhi0 = new TH1F("NeuroSWOutPhi0",
535  "phi distribution from simulation, hw TS hw 2D; #phi [#circ]",
536  80, 0, 360); // shift to reduce the binning error
537  m_neuroSWOutHitPattern = new TH1F("NeuroSWOutHitPattern",
538  "stereo hit pattern of simulated neuro tracks, hw TS hw 2D; pattern",
539  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
540  m_neuroSWOutTrackCount = new TH1F("NeuroSWOutTrackCount",
541  "number of neuro tracks per event from simulation, hw TS hw 2D",
542  20, 0, 20);
543  m_neuroSWSector = new TH1F("NeuroSWSector",
544  "sector of simulated neuro tracks, hw TS hw 2D; sector",
545  10, 0, 10);
546  // hw TS selected by sw NN
547  m_neuroSWSelTSID = new TH1F("NeuroSWSelTSID", "ID of selected track segments",
548  2336, 0, 2335);
549  m_neuroSWSelTSCount = new TH1F("NeuroSWSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
550  m_neuroSWSelTSPrioT_Layer0 = new TH1F("NeuroSWSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
551  512, 0, 511);
552  m_neuroSWSelTSPrioT_Layer1 = new TH1F("NeuroSWSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
553  512, 0, 511);
554  m_neuroSWSelTSPrioT_Layer2 = new TH1F("NeuroSWSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
555  512, 0, 511);
556  m_neuroSWSelTSPrioT_Layer3 = new TH1F("NeuroSWSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
557  512, 0, 511);
558  m_neuroSWSelTSPrioT_Layer4 = new TH1F("NeuroSWSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
559  512, 0, 511);
560  m_neuroSWSelTSPrioT_Layer5 = new TH1F("NeuroSWSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
561  512, 0, 511);
562  m_neuroSWSelTSPrioT_Layer6 = new TH1F("NeuroSWSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
563  512, 0, 511);
564  m_neuroSWSelTSPrioT_Layer7 = new TH1F("NeuroSWSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
565  512, 0, 511);
566  m_neuroSWSelTSPrioT_Layer8 = new TH1F("NeuroSWSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
567  512, 0, 511);
568  m_neuroSWSelTSFoundT_Layer0 = new TH1F("NeuroSWSelTSFoundT_Layer0",
569  "First found time of selected TS - found time of Neuro Track in SL 0",
570  96, -47.99, 48.01);
571  m_neuroSWSelTSFoundT_Layer1 = new TH1F("NeuroSWSelTSFoundT_Layer1",
572  "First found time of selected TS - found time of Neuro Track in SL 1",
573  96, -47.99, 48.01);
574  m_neuroSWSelTSFoundT_Layer2 = new TH1F("NeuroSWSelTSFoundT_Layer2",
575  "First found time of selected TS - found time of Neuro Track in SL 2",
576  96, -47.99, 48.01);
577  m_neuroSWSelTSFoundT_Layer3 = new TH1F("NeuroSWSelTSFoundT_Layer3",
578  "First found time of selected TS - found time of Neuro Track in SL 3",
579  96, -47.99, 48.01);
580  m_neuroSWSelTSFoundT_Layer4 = new TH1F("NeuroSWSelTSFoundT_Layer4",
581  "First found time of selected TS - found time of Neuro Track in SL 4",
582  96, -47.99, 48.01);
583  m_neuroSWSelTSFoundT_Layer5 = new TH1F("NeuroSWSelTSFoundT_Layer5",
584  "First found time of selected TS - found time of Neuro Track in SL 5",
585  96, -47.99, 48.01);
586  m_neuroSWSelTSFoundT_Layer6 = new TH1F("NeuroSWSelTSFoundT_Layer6",
587  "First found time of selected TS - found time of Neuro Track in SL 6",
588  96, -47.99, 48.01);
589  m_neuroSWSelTSFoundT_Layer7 = new TH1F("NeuroSWSelTSFoundT_Layer7",
590  "First found time of selected TS - found time of Neuro Track in SL 7",
591  96, -47.99, 48.01);
592  m_neuroSWSelTSFoundT_Layer8 = new TH1F("NeuroSWSelTSFoundT_Layer8",
593  "First found time of selected TS - found time of Neuro Track in SL 8",
594  96, -47.99, 48.01);
595 
596 
597  m_neuroSWSelTSPrioB_Layer0 = new TH1F("NeuroSWSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
598  4, 0, 4);
599  m_neuroSWSelTSPrioB_Layer1 = new TH1F("NeuroSWSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
600  4, 0, 4);
601  m_neuroSWSelTSPrioB_Layer2 = new TH1F("NeuroSWSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
602  4, 0, 4);
603  m_neuroSWSelTSPrioB_Layer3 = new TH1F("NeuroSWSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
604  4, 0, 4);
605  m_neuroSWSelTSPrioB_Layer4 = new TH1F("NeuroSWSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
606  4, 0, 4);
607  m_neuroSWSelTSPrioB_Layer5 = new TH1F("NeuroSWSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
608  4, 0, 4);
609  m_neuroSWSelTSPrioB_Layer6 = new TH1F("NeuroSWSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
610  4, 0, 4);
611  m_neuroSWSelTSPrioB_Layer7 = new TH1F("NeuroSWSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
612  4, 0, 4);
613  m_neuroSWSelTSPrioB_Layer8 = new TH1F("NeuroSWSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
614  4, 0, 4);
615 
616 
617  m_neuroSWSelTSLR_Layer0 = new TH1F("NeuroSWSelTSLR_Layer0", "Left/Right of track segments in layer 0",
618  4, 0, 4);
619  m_neuroSWSelTSLR_Layer1 = new TH1F("NeuroSWSelTSLR_Layer1", "Left/Right of track segments in layer 1",
620  4, 0, 4);
621  m_neuroSWSelTSLR_Layer2 = new TH1F("NeuroSWSelTSLR_Layer2", "Left/Right of track segments in layer 2",
622  4, 0, 4);
623  m_neuroSWSelTSLR_Layer3 = new TH1F("NeuroSWSelTSLR_Layer3", "Left/Right of track segments in layer 3",
624  4, 0, 4);
625  m_neuroSWSelTSLR_Layer4 = new TH1F("NeuroSWSelTSLR_Layer4", "Left/Right of track segments in layer 4",
626  4, 0, 4);
627  m_neuroSWSelTSLR_Layer5 = new TH1F("NeuroSWSelTSLR_Layer5", "Left/Right of track segments in layer 5",
628  4, 0, 4);
629  m_neuroSWSelTSLR_Layer6 = new TH1F("NeuroSWSelTSLR_Layer6", "Left/Right of track segments in layer 6",
630  4, 0, 4);
631  m_neuroSWSelTSLR_Layer7 = new TH1F("NeuroSWSelTSLR_Layer7", "Left/Right of track segments in layer 7",
632  4, 0, 4);
633  m_neuroSWSelTSLR_Layer8 = new TH1F("NeuroSWSelTSLR_Layer8", "Left/Right of track segments in layer 8",
634  4, 0, 4);
635 
636  m_neuroSWInputID_Layer0 = new TH1F("NeuroSWInputID_Layer0",
637  "simulated id input in layer 0; id",
638  100, -1, 1);
639  m_neuroSWInputT_Layer0 = new TH1F("NeuroSWInputT_Layer0",
640  "simulated time input in layer 0; time",
641  100, -1, 1);
642  m_neuroSWInputAlpha_Layer0 = new TH1F("NeuroSWInputAlpha_Layer0",
643  "simulated alpha input in layer 0; alpha",
644  100, -1, 1);
645  m_neuroSWInputID_Layer1 = new TH1F("NeuroSWInputID_Layer1",
646  "simulated id input in layer 1; id",
647  100, -1, 1);
648  m_neuroSWInputT_Layer1 = new TH1F("NeuroSWInputT_Layer1",
649  "simulated time input in layer 1; time",
650  100, -1, 1);
651  m_neuroSWInputAlpha_Layer1 = new TH1F("NeuroSWInputAlpha_Layer1",
652  "simulated alpha input in layer 1; alpha",
653  100, -1, 1);
654  m_neuroSWInputID_Layer2 = new TH1F("NeuroSWInputID_Layer2",
655  "simulated id input in layer 2; id",
656  100, -1, 1);
657  m_neuroSWInputT_Layer2 = new TH1F("NeuroSWInputT_Layer2",
658  "simulated time input in layer 2; time",
659  100, -1, 1);
660  m_neuroSWInputAlpha_Layer2 = new TH1F("NeuroSWInputAlpha_Layer2",
661  "simulated alpha input in layer 2; alpha",
662  100, -1, 1);
663  m_neuroSWInputID_Layer3 = new TH1F("NeuroSWInputID_Layer3",
664  "simulated id input in layer 3; id",
665  100, -1, 1);
666  m_neuroSWInputT_Layer3 = new TH1F("NeuroSWInputT_Layer3",
667  "simulated time input in layer 3; time",
668  100, -1, 1);
669  m_neuroSWInputAlpha_Layer3 = new TH1F("NeuroSWInputAlpha_Layer3",
670  "simulated alpha input in layer 3; alpha",
671  100, -1, 1);
672  m_neuroSWInputID_Layer4 = new TH1F("NeuroSWInputID_Layer4",
673  "simulated id input in layer 4; id",
674  100, -1, 1);
675  m_neuroSWInputT_Layer4 = new TH1F("NeuroSWInputT_Layer4",
676  "simulated time input in layer 4; time",
677  100, -1, 1);
678  m_neuroSWInputAlpha_Layer4 = new TH1F("NeuroSWInputAlpha_Layer4",
679  "simulated alpha input in layer 4; alpha",
680  100, -1, 1);
681  m_neuroSWInputID_Layer5 = new TH1F("NeuroSWInputID_Layer5",
682  "simulated id input in layer 5; id",
683  100, -1, 1);
684  m_neuroSWInputT_Layer5 = new TH1F("NeuroSWInputT_Layer5",
685  "simulated time input in layer 5; time",
686  100, -1, 1);
687  m_neuroSWInputAlpha_Layer5 = new TH1F("NeuroSWInputAlpha_Layer5",
688  "simulated alpha input in layer 5; alpha",
689  100, -1, 1);
690  m_neuroSWInputID_Layer6 = new TH1F("NeuroSWInputID_Layer6",
691  "simulated id input in layer 6; id",
692  100, -1, 1);
693  m_neuroSWInputT_Layer6 = new TH1F("NeuroSWInputT_Layer6",
694  "simulated time input in layer 6; time",
695  100, -1, 1);
696  m_neuroSWInputAlpha_Layer6 = new TH1F("NeuroSWInputAlpha_Layer6",
697  "simulated alpha input in layer 6; alpha",
698  100, -1, 1);
699  m_neuroSWInputID_Layer7 = new TH1F("NeuroSWInputID_Layer7",
700  "simulated id input in layer 7; id",
701  100, -1, 1);
702  m_neuroSWInputT_Layer7 = new TH1F("NeuroSWInputT_Layer7",
703  "simulated time input in layer 7; time",
704  100, -1, 1);
705  m_neuroSWInputAlpha_Layer7 = new TH1F("NeuroSWInputAlpha_Layer7",
706  "simulated alpha input in layer 7; alpha",
707  100, -1, 1);
708  m_neuroSWInputID_Layer8 = new TH1F("NeuroSWInputID_Layer8",
709  "simulated id input in layer 8; id",
710  100, -1, 1);
711  m_neuroSWInputT_Layer8 = new TH1F("NeuroSWInputT_Layer8",
712  "simulated time input in layer 8; time",
713  100, -1, 1);
714  m_neuroSWInputAlpha_Layer8 = new TH1F("NeuroSWInputAlpha_Layer8",
715  "simulated alpha input in layer 8; alpha",
716  100, -1, 1);
717  }
718 
719  if (!m_limitedoutput && m_sim2DTracksSWTSName != "") {
720 
721  m_2DSWOutInvPt = new TH1F("2DSWOutInvPt",
722  "Inverse Pt of 2dtracks from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
723  50, 0, 5);
724  m_2DSWOutPhi0 = new TH1F("2DSWOutPhi0", "Phi0 of 2dtracks from simulation, sw TS sw 2D; #phi [#circ]",
725  80, 0, 360);
726  m_2DSWOutm_time = new TH1F("2DSWOutM_time", "m_time of 2dtracks from simulation, sw TS sw 2D; clock cycle",
727  96, -48, 48);
728  m_2DSWOutTrackCount = new TH1F("2DSWOutTrackCount", "number of 2dtracks per event from simulation, sw TS sw 2D", 20, 0, 20);
729 
730  }
732 
733  m_neuroSWTSSW2DOutZ = new TH1F("NeuroSWTSSW2DOutZ",
734  "z distribution from simulation, sw TS sw 2D; z [cm]",
735  100, -100, 100);
736  m_neuroSWTSSW2DOutCosTheta = new TH1F("NeuroSWTSSW2DOutCosTheta",
737  "cos theta distribution from simulation, sw TS sw 2D; cos(#theta) ",
738  100, -1, 1);
739  m_neuroSWTSSW2DOutInvPt = new TH1F("NeuroSWTSSW2DOutInvPt",
740  "Inverse Pt distribution from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
741  50, 0, 5);
742  m_neuroSWTSSW2DOutPhi0 = new TH1F("NeuroSWTSSW2DOutPhi0",
743  "phi distribution from simulation, sw TS sw 2D; #phi [#circ]",
744  80, 0, 360);
745  m_neuroSWTSSW2DOutHitPattern = new TH1F("NeuroSWTSSW2DOutHitPattern",
746  "stereo hit pattern of simulated neuro tracks, sw TS sw 2D; pattern",
747  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
748  m_neuroSWTSSW2DOutTrackCount = new TH1F("NeuroSWTSSW2DOutTrackCount",
749  "number of simulated neuro tracks per event, sw TS sw 2D",
750  20, 0, 20);
751  m_neuroSWTSSW2DSector = new TH1F("NeuroSWTSSW2DSector",
752  "sector of simulated neuro tracks, sw TS sw 2D; sector",
753  10, 0, 10);
754  // sw TS incoming
755  m_neuroSWTSSW2DInTSID = new TH1F("NeuroSWTSSW2DInTSID", "ID of simulated track segments",
756  2336, 0, 2335);
757  m_neuroSWTSSW2DInTSCount = new TH1F("NeuroSWTSSW2DInTSCount", "number of simulated TS per event", 200, 0, 800);
758  m_neuroSWTSSW2DInTSPrioT_Layer0 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer0", "Priority time of track segments in layer 0",
759  512, 0, 511);
760  m_neuroSWTSSW2DInTSPrioT_Layer1 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer1", "Priority time of track segments in layer 1",
761  512, 0, 511);
762  m_neuroSWTSSW2DInTSPrioT_Layer2 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer2", "Priority time of track segments in layer 2",
763  512, 0, 511);
764  m_neuroSWTSSW2DInTSPrioT_Layer3 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer3", "Priority time of track segments in layer 3",
765  512, 0, 511);
766  m_neuroSWTSSW2DInTSPrioT_Layer4 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer4", "Priority time of track segments in layer 4",
767  512, 0, 511);
768  m_neuroSWTSSW2DInTSPrioT_Layer5 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer5", "Priority time of track segments in layer 5",
769  512, 0, 511);
770  m_neuroSWTSSW2DInTSPrioT_Layer6 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer6", "Priority time of track segments in layer 6",
771  512, 0, 511);
772  m_neuroSWTSSW2DInTSPrioT_Layer7 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer7", "Priority time of track segments in layer 7",
773  512, 0, 511);
774  m_neuroSWTSSW2DInTSPrioT_Layer8 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer8", "Priority time of track segments in layer 8",
775  512, 0, 511);
776  m_neuroSWTSSW2DInTSFoundT_Layer0 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer0",
777  "First found time of selected TS - found time of Neuro Track in SL 0",
778  96, -47.99, 48.01);
779  m_neuroSWTSSW2DInTSFoundT_Layer1 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer1",
780  "First found time of selected TS - found time of Neuro Track in SL 1",
781  96, -47.99, 48.01);
782  m_neuroSWTSSW2DInTSFoundT_Layer2 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer2",
783  "First found time of selected TS - found time of Neuro Track in SL 2",
784  96, -47.99, 48.01);
785  m_neuroSWTSSW2DInTSFoundT_Layer3 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer3",
786  "First found time of selected TS - found time of Neuro Track in SL 3",
787  96, -47.99, 48.01);
788  m_neuroSWTSSW2DInTSFoundT_Layer4 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer4",
789  "First found time of selected TS - found time of Neuro Track in SL 4",
790  96, -47.99, 48.01);
791  m_neuroSWTSSW2DInTSFoundT_Layer5 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer5",
792  "First found time of selected TS - found time of Neuro Track in SL 5",
793  96, -47.99, 48.01);
794  m_neuroSWTSSW2DInTSFoundT_Layer6 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer6",
795  "First found time of selected TS - found time of Neuro Track in SL 6",
796  96, -47.99, 48.01);
797  m_neuroSWTSSW2DInTSFoundT_Layer7 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer7",
798  "First found time of selected TS - found time of Neuro Track in SL 7",
799  96, -47.99, 48.01);
800  m_neuroSWTSSW2DInTSFoundT_Layer8 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer8",
801  "First found time of selected TS - found time of Neuro Track in SL 8",
802  96, -47.99, 48.01);
803 
804 
805  m_neuroSWTSSW2DInTSPrioB_Layer0 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
806  4, 0, 4);
807  m_neuroSWTSSW2DInTSPrioB_Layer1 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer1", "Priority bits of track segments in layer 1",
808  4, 0, 4);
809  m_neuroSWTSSW2DInTSPrioB_Layer2 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
810  4, 0, 4);
811  m_neuroSWTSSW2DInTSPrioB_Layer3 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer3", "Priority bits of track segments in layer 3",
812  4, 0, 4);
813  m_neuroSWTSSW2DInTSPrioB_Layer4 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
814  4, 0, 4);
815  m_neuroSWTSSW2DInTSPrioB_Layer5 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer5", "Priority bits of track segments in layer 5",
816  4, 0, 4);
817  m_neuroSWTSSW2DInTSPrioB_Layer6 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
818  4, 0, 4);
819  m_neuroSWTSSW2DInTSPrioB_Layer7 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer7", "Priority bits of track segments in layer 7",
820  4, 0, 4);
821  m_neuroSWTSSW2DInTSPrioB_Layer8 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
822  4, 0, 4);
823 
824 
825  m_neuroSWTSSW2DInTSLR_Layer0 = new TH1F("NeuroSWTSSW2DInTSLR_Layer0", "Left/Right of track segments in layer 0",
826  4, 0, 4);
827  m_neuroSWTSSW2DInTSLR_Layer1 = new TH1F("NeuroSWTSSW2DInTSLR_Layer1", "Left/Right of track segments in layer 1",
828  4, 0, 4);
829  m_neuroSWTSSW2DInTSLR_Layer2 = new TH1F("NeuroSWTSSW2DInTSLR_Layer2", "Left/Right of track segments in layer 2",
830  4, 0, 4);
831  m_neuroSWTSSW2DInTSLR_Layer3 = new TH1F("NeuroSWTSSW2DInTSLR_Layer3", "Left/Right of track segments in layer 3",
832  4, 0, 4);
833  m_neuroSWTSSW2DInTSLR_Layer4 = new TH1F("NeuroSWTSSW2DInTSLR_Layer4", "Left/Right of track segments in layer 4",
834  4, 0, 4);
835  m_neuroSWTSSW2DInTSLR_Layer5 = new TH1F("NeuroSWTSSW2DInTSLR_Layer5", "Left/Right of track segments in layer 5",
836  4, 0, 4);
837  m_neuroSWTSSW2DInTSLR_Layer6 = new TH1F("NeuroSWTSSW2DInTSLR_Layer6", "Left/Right of track segments in layer 6",
838  4, 0, 4);
839  m_neuroSWTSSW2DInTSLR_Layer7 = new TH1F("NeuroSWTSSW2DInTSLR_Layer7", "Left/Right of track segments in layer 7",
840  4, 0, 4);
841  m_neuroSWTSSW2DInTSLR_Layer8 = new TH1F("NeuroSWTSSW2DInTSLR_Layer8", "Left/Right of track segments in layer 8",
842  4, 0, 4);
843 
844 
845  // sw TS selected
846  m_neuroSWTSSW2DSelTSID = new TH1F("NeuroSWTSSW2DSelTSID", "ID of selected track segments",
847  2336, 0, 2335);
848  m_neuroSWTSSW2DSelTSCount = new TH1F("NeuroSWTSSW2DSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
849  m_neuroSWTSSW2DSelTSPrioT_Layer0 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
850  512, 0, 511);
851  m_neuroSWTSSW2DSelTSPrioT_Layer1 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
852  512, 0, 511);
853  m_neuroSWTSSW2DSelTSPrioT_Layer2 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
854  512, 0, 511);
855  m_neuroSWTSSW2DSelTSPrioT_Layer3 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
856  512, 0, 511);
857  m_neuroSWTSSW2DSelTSPrioT_Layer4 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
858  512, 0, 511);
859  m_neuroSWTSSW2DSelTSPrioT_Layer5 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
860  512, 0, 511);
861  m_neuroSWTSSW2DSelTSPrioT_Layer6 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
862  512, 0, 511);
863  m_neuroSWTSSW2DSelTSPrioT_Layer7 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
864  512, 0, 511);
865  m_neuroSWTSSW2DSelTSPrioT_Layer8 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
866  512, 0, 511);
867  m_neuroSWTSSW2DSelTSFoundT_Layer0 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer0",
868  "First found time of selected TS - found time of Neuro Track in SL 0",
869  96, -47.99, 48.01);
870  m_neuroSWTSSW2DSelTSFoundT_Layer1 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer1",
871  "First found time of selected TS - found time of Neuro Track in SL 1",
872  96, -47.99, 48.01);
873  m_neuroSWTSSW2DSelTSFoundT_Layer2 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer2",
874  "First found time of selected TS - found time of Neuro Track in SL 2",
875  96, -47.99, 48.01);
876  m_neuroSWTSSW2DSelTSFoundT_Layer3 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer3",
877  "First found time of selected TS - found time of Neuro Track in SL 3",
878  96, -47.99, 48.01);
879  m_neuroSWTSSW2DSelTSFoundT_Layer4 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer4",
880  "First found time of selected TS - found time of Neuro Track in SL 4",
881  96, -47.99, 48.01);
882  m_neuroSWTSSW2DSelTSFoundT_Layer5 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer5",
883  "First found time of selected TS - found time of Neuro Track in SL 5",
884  96, -47.99, 48.01);
885  m_neuroSWTSSW2DSelTSFoundT_Layer6 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer6",
886  "First found time of selected TS - found time of Neuro Track in SL 6",
887  96, -47.99, 48.01);
888  m_neuroSWTSSW2DSelTSFoundT_Layer7 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer7",
889  "First found time of selected TS - found time of Neuro Track in SL 7",
890  96, -47.99, 48.01);
891  m_neuroSWTSSW2DSelTSFoundT_Layer8 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer8",
892  "First found time of selected TS - found time of Neuro Track in SL 8",
893  96, -47.99, 48.01);
894 
895 
896  m_neuroSWTSSW2DSelTSPrioB_Layer0 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
897  4, 0, 4);
898  m_neuroSWTSSW2DSelTSPrioB_Layer1 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
899  4, 0, 4);
900  m_neuroSWTSSW2DSelTSPrioB_Layer2 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
901  4, 0, 4);
902  m_neuroSWTSSW2DSelTSPrioB_Layer3 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
903  4, 0, 4);
904  m_neuroSWTSSW2DSelTSPrioB_Layer4 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
905  4, 0, 4);
906  m_neuroSWTSSW2DSelTSPrioB_Layer5 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
907  4, 0, 4);
908  m_neuroSWTSSW2DSelTSPrioB_Layer6 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
909  4, 0, 4);
910  m_neuroSWTSSW2DSelTSPrioB_Layer7 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
911  4, 0, 4);
912  m_neuroSWTSSW2DSelTSPrioB_Layer8 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
913  4, 0, 4);
914 
915 
916  m_neuroSWTSSW2DSelTSLR_Layer0 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer0", "Left/Right of track segments in layer 0",
917  4, 0, 4);
918  m_neuroSWTSSW2DSelTSLR_Layer1 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer1", "Left/Right of track segments in layer 1",
919  4, 0, 4);
920  m_neuroSWTSSW2DSelTSLR_Layer2 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer2", "Left/Right of track segments in layer 2",
921  4, 0, 4);
922  m_neuroSWTSSW2DSelTSLR_Layer3 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer3", "Left/Right of track segments in layer 3",
923  4, 0, 4);
924  m_neuroSWTSSW2DSelTSLR_Layer4 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer4", "Left/Right of track segments in layer 4",
925  4, 0, 4);
926  m_neuroSWTSSW2DSelTSLR_Layer5 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer5", "Left/Right of track segments in layer 5",
927  4, 0, 4);
928  m_neuroSWTSSW2DSelTSLR_Layer6 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer6", "Left/Right of track segments in layer 6",
929  4, 0, 4);
930  m_neuroSWTSSW2DSelTSLR_Layer7 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer7", "Left/Right of track segments in layer 7",
931  4, 0, 4);
932  m_neuroSWTSSW2DSelTSLR_Layer8 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer8", "Left/Right of track segments in layer 8",
933  4, 0, 4);
934  m_neuroSWTSSW2DInputID_Layer0 = new TH1F("NeuroSWTSSW2DInputID_Layer0",
935  "simulated id input in layer 0; id",
936  100, -1, 1);
937  m_neuroSWTSSW2DInputT_Layer0 = new TH1F("NeuroSWTSSW2DInputT_Layer0",
938  "simulated time input in layer 0; time",
939  100, -1, 1);
940  m_neuroSWTSSW2DInputAlpha_Layer0 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer0",
941  "simulated alpha input in layer 0; alpha",
942  100, -1, 1);
943  m_neuroSWTSSW2DInputID_Layer1 = new TH1F("NeuroSWTSSW2DInputID_Layer1",
944  "simulated id input in layer 1; id",
945  100, -1, 1);
946  m_neuroSWTSSW2DInputT_Layer1 = new TH1F("NeuroSWTSSW2DInputT_Layer1",
947  "simulated time input in layer 1; time",
948  100, -1, 1);
949  m_neuroSWTSSW2DInputAlpha_Layer1 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer1",
950  "simulated alpha input in layer 1; alpha",
951  100, -1, 1);
952  m_neuroSWTSSW2DInputID_Layer2 = new TH1F("NeuroSWTSSW2DInputID_Layer2",
953  "simulated id input in layer 2; id",
954  100, -1, 1);
955  m_neuroSWTSSW2DInputT_Layer2 = new TH1F("NeuroSWTSSW2DInputT_Layer2",
956  "simulated time input in layer 2; time",
957  100, -1, 1);
958  m_neuroSWTSSW2DInputAlpha_Layer2 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer2",
959  "simulated alpha input in layer 2; alpha",
960  100, -1, 1);
961  m_neuroSWTSSW2DInputID_Layer3 = new TH1F("NeuroSWTSSW2DInputID_Layer3",
962  "simulated id input in layer 3; id",
963  100, -1, 1);
964  m_neuroSWTSSW2DInputT_Layer3 = new TH1F("NeuroSWTSSW2DInputT_Layer3",
965  "simulated time input in layer 3; time",
966  100, -1, 1);
967  m_neuroSWTSSW2DInputAlpha_Layer3 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer3",
968  "simulated alpha input in layer 3; alpha",
969  100, -1, 1);
970  m_neuroSWTSSW2DInputID_Layer4 = new TH1F("NeuroSWTSSW2DInputID_Layer4",
971  "simulated id input in layer 4; id",
972  100, -1, 1);
973  m_neuroSWTSSW2DInputT_Layer4 = new TH1F("NeuroSWTSSW2DInputT_Layer4",
974  "simulated time input in layer 4; time",
975  100, -1, 1);
976  m_neuroSWTSSW2DInputAlpha_Layer4 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer4",
977  "simulated alpha input in layer 4; alpha",
978  100, -1, 1);
979  m_neuroSWTSSW2DInputID_Layer5 = new TH1F("NeuroSWTSSW2DInputID_Layer5",
980  "simulated id input in layer 5; id",
981  100, -1, 1);
982  m_neuroSWTSSW2DInputT_Layer5 = new TH1F("NeuroSWTSSW2DInputT_Layer5",
983  "simulated time input in layer 5; time",
984  100, -1, 1);
985  m_neuroSWTSSW2DInputAlpha_Layer5 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer5",
986  "simulated alpha input in layer 5; alpha",
987  100, -1, 1);
988  m_neuroSWTSSW2DInputID_Layer6 = new TH1F("NeuroSWTSSW2DInputID_Layer6",
989  "simulated id input in layer 6; id",
990  100, -1, 1);
991  m_neuroSWTSSW2DInputT_Layer6 = new TH1F("NeuroSWTSSW2DInputT_Layer6",
992  "simulated time input in layer 6; time",
993  100, -1, 1);
994  m_neuroSWTSSW2DInputAlpha_Layer6 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer6",
995  "simulated alpha input in layer 6; alpha",
996  100, -1, 1);
997  m_neuroSWTSSW2DInputID_Layer7 = new TH1F("NeuroSWTSSW2DInputID_Layer7",
998  "simulated id input in layer 7; id",
999  100, -1, 1);
1000  m_neuroSWTSSW2DInputT_Layer7 = new TH1F("NeuroSWTSSW2DInputT_Layer7",
1001  "simulated time input in layer 7; time",
1002  100, -1, 1);
1003  m_neuroSWTSSW2DInputAlpha_Layer7 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer7",
1004  "simulated alpha input in layer 7; alpha",
1005  100, -1, 1);
1006  m_neuroSWTSSW2DInputID_Layer8 = new TH1F("NeuroSWTSSW2DInputID_Layer8",
1007  "simulated id input in layer 8; id",
1008  100, -1, 1);
1009  m_neuroSWTSSW2DInputT_Layer8 = new TH1F("NeuroSWTSSW2DInputT_Layer8",
1010  "simulated time input in layer 8; time",
1011  100, -1, 1);
1012  m_neuroSWTSSW2DInputAlpha_Layer8 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer8",
1013  "simulated alpha input in layer 8; alpha",
1014  100, -1, 1);
1015  }
1016 
1017 
1018 
1020  m_neuroDeltaZ = new TH1F("NeuroDeltaZ",
1021  "difference between unpacked and simulated neuro z; #Delta z [cm]",
1022  100, -100, 100); // should be bit-precise, so look at very small range
1023  m_neuroDeltaTheta = new TH1F("NeuroDeltaTheta",
1024  "difference between unpacked and simulated neuro theta; #Delta #theta [#circ]",
1025  100, -180, 180); // should be bit-precise, so look at very small range
1026  m_neuroScatterZ = new TH2F("NeuroScatterZ",
1027  "unpacked z vs TSIM; hw z [cm]; sw z [cm]",
1028  100, -150, 150, 100, -150, 150);
1029  m_neuroScatterTheta = new TH2F("NeuroScatterTheta",
1030  "unpacked theta vs TSIM; hw #theta [#circ]; sw #theta [#circ]",
1031  100, 0, 270, 100, 0, 270);
1032 
1033  m_neuroDeltaInputID = new TH1F("NeuroDeltaInputID",
1034  "difference between unpacked and simulated ID input; #Delta ID",
1035  100, -0.5, 0.5); // should be bit-precise, so look at very small range
1036  m_neuroDeltaInputT = new TH1F("NeuroDeltaInputT",
1037  "difference between unpacked and simulated time input; #Delta t",
1038  100, -0.5, 0.5); // should be bit-precise, so look at very small range
1039  m_neuroDeltaInputAlpha = new TH1F("NeuroDeltaInputAlpha",
1040  "difference between unpacked and simulated alpha input; #Delta alpha",
1041  100, -0.1, 0.1); // should be bit-precise, so look at very small range
1042  m_neuroDeltaTSID = new TH1F("NeuroDeltaTSID",
1043  "difference between unpacked and simulated tsid; #Delta TSID",
1044  100, -50, 50);
1045  m_neuroDeltaSector = new TH1F("NeuroDeltaSector",
1046  "difference between unpacked and simulated sector; #Delta sector",
1047  20, -10, 10);
1048  m_simSameTS = new TH1F("NeuroSimSameTS",
1049  "number of TS selected in both, unpacked and TSIM tracks",
1050  20, 0, 20);
1051  m_simDiffTS = new TH1F("NeuroSimDiffTS",
1052  "number of TS selcted in TSIM but not in unpacker",
1053  20, 0, 20);
1054  }
1055 
1056  if (m_recoTracksName != "") {
1057  //RecoTracks
1058  m_RecoZ = new TH1F("RecoZ",
1059  "z distribution of reconstructed tracks;z [cm]",
1060  100, -150, 150);
1061  m_RecoCosTheta = new TH1F("RecoCosTheta",
1062  "cos theta distribution of reconstructed tracks; cos(#theta) ",
1063  100, -1, 1);
1064  m_RecoInvPt = new TH1F("RecoInvPt",
1065  "Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1066  50, 0, 5);
1067  m_RecoPhi = new TH1F("RecoPhi",
1068  "phi distribution of reconstructed tracks ; #phi [#circ]",
1069  80, 0, 360);
1070  m_RecoD0 = new TH1F("RecoD0",
1071  "d0 distribution of reconstructed tracks ; d_{0} [cm]",
1072  100, 0, 10);
1073  m_RecoTrackCount = new TH1F("RecoTrackCount",
1074  "number of reconstructed tracks per event",
1075  20, 0, 20);
1076  }
1077  if (m_recoTracksName != "" && m_unpackedNeuroTracksName != "") {
1078  //RecoTracks matched to unpacked neuro tracks
1079  m_RecoHWZ = new TH1F("RecoHWZ",
1080  "hw matched z distribution of reconstructed tracks; z [cm]",
1081  100, -150, 150);
1082  m_RecoHWCosTheta = new TH1F("RecoHWCosTheta",
1083  "hw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1084  100, -1, 1);
1085  m_RecoHWInvPt = new TH1F("RecoHWInvPt",
1086  "hw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1087  50, 0, 5);
1088  m_RecoHWPhi = new TH1F("RecoHWPhi",
1089  "hw matched phi distribution of reconstructed tracks; #phi [#circ]",
1090  80, 0, 360);
1091  m_RecoHWD0 = new TH1F("RecoHWD0",
1092  "hw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1093  100, 0, 10);
1094  // hw neuro values for tracks matched to reco tracks
1095  m_neuroRecoHWOutZ = new TH1F("NeuroRecoHWOutZ",
1096  "reco matched z distribution of unpacked neuro tracks; z [cm]",
1097  100, -100, 100);
1098  m_neuroRecoHWOutCosTheta = new TH1F("NeuroRecoHWOutCosTheta",
1099  "reco matched cos theta distribution of unpacked neuro tracks; cos(#theta) ",
1100  100, -1, 1);
1101  m_neuroRecoHWOutInvPt = new TH1F("NeuroRecoHWOutInvPt",
1102  "reco matched Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
1103  50, 0, 5);
1104  m_neuroRecoHWOutPhi0 = new TH1F("NeuroRecoHWOutPhi0",
1105  "reco matched phi distribution of unpacked neuro tracks; #phi [#circ]",
1106  80, 0, 360); // shift to reduce the binning error
1107  m_neuroRecoHWOutHitPattern = new TH1F("NeuroRecoUnpackedHitPattern",
1108  "reco matched stereo hit pattern of unpacked neuro tracks; pattern",
1109  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1110  m_neuroRecoHWOutTrackCount = new TH1F("NeuroRecoHWOutTrackCount",
1111  "reco matched number of unpacked neuro tracks per event",
1112  20, 0, 20);
1113  m_neuroRecoHWSector = new TH1F("NeuroRecoHWSector",
1114  "reco matched sector of unpacked neuro tracks; sector",
1115  10, 0, 10);
1116 
1117 
1118  m_DeltaRecoHWZ = new TH1F("DeltaRecoHWZ",
1119  "difference between reconstructed and unpacked neuro z; #Delta z [cm]",
1120  100, -100, 100);
1121  m_DeltaRecoHWCosTheta = new TH1F("DeltaRecoHWCosTheta",
1122  "difference between reconstructed and unpacked neuro cos(theta); #Delta cos(#theta)",
1123  100, -1, 1);
1124  m_DeltaRecoHWInvPt = new TH1F("DeltaRecoHWInvPt",
1125  "difference between reconstructed and unpacked neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1126  100, -10, 10);
1127  m_DeltaRecoHWPhi = new TH1F("DeltaRecoHWPhi",
1128  "difference between reconstructed and unpacked neuro phi; #Delta #phi [#circ]",
1129  80, -180, 180);
1130  }
1132  m_RecoHWZScatter = new TH2F("RecoHWZScatter",
1133  "hw matched reconstruction; reco z [cm]; hw z [cm]",
1134  100, -150, 150, 100, -150, 150);
1135  }
1136 
1137 
1138 
1139  if (!m_limitedoutput && m_simNeuroTracksName != "") {
1140  //RecoTracks matched to simulated neuro tracks (hw TS hw 2D sw NN)
1141  m_RecoSWZ = new TH1F("RecoSWZ",
1142  "sw matched z distribution of reconstructed tracks; z [cm]",
1143  100, -150, 150); // 1cm bins from -50cm to 50cm
1144  m_RecoSWCosTheta = new TH1F("RecoSWCosTheta",
1145  "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1146  100, -1, 1);
1147  m_RecoSWInvPt = new TH1F("RecoSWInvPt",
1148  "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1149  50, 0, 5);
1150  m_RecoSWPhi = new TH1F("RecoSWPhi",
1151  "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1152  80, 0, 360);
1153  m_RecoSWD0 = new TH1F("RecoSWD0",
1154  "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1155  100, 0, 10);
1156  m_RecoSWZScatter = new TH2F("RecoSWZScatter",
1157  "sw matched reconstruction; reco z [cm]; sw z [cm]",
1158  100, -150, 150, 100, -150, 150);
1159 
1160 
1161  // sw neuro values for tracks matched to reco tracks
1162  m_neuroRecoSWOutZ = new TH1F("NeuroRecoSWOutZ",
1163  "reco matched z distribution from simulation; z [cm]",
1164  100, -100, 100);
1165  m_neuroRecoSWOutCosTheta = new TH1F("NeuroRecoSWOutCosTheta",
1166  "reco matched cos theta distribution from simulation; cos(#theta) ",
1167  100, -1, 1);
1168  m_neuroRecoSWOutInvPt = new TH1F("NeuroRecoSWOutInvPt",
1169  "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1170  50, 0, 5);
1171  m_neuroRecoSWOutPhi0 = new TH1F("NeuroRecoSWOutPhi0",
1172  "reco matched phi distribution from simulation; #phi [#circ]",
1173  80, 0, 360); // shift to reduce the binning error
1174  m_neuroRecoSWOutHitPattern = new TH1F("NeuroRecoSWHitPattern",
1175  "reco matched stereo hit pattern from simulation; pattern",
1176  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1177  m_neuroRecoSWOutTrackCount = new TH1F("NeuroRecoSWOutTrackCount",
1178  "reco matched number of SW neuro tracks per event",
1179  20, 0, 20);
1180  m_neuroRecoSWSector = new TH1F("NeuroRecoSWSector",
1181  "reco matched sector from simulation; sector",
1182  10, 0, 10);
1183 
1184 
1185  m_DeltaRecoSWZ = new TH1F("DeltaRecoSWZ",
1186  "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1187  100, -100, 100);
1188  m_DeltaRecoSWCosTheta = new TH1F("DeltaRecoSWCosTheta",
1189  "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1190  100, -1, 1);
1191  m_DeltaRecoSWInvPt = new TH1F("DeltaRecoSWInvPt",
1192  "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1193  100, -10, 10);
1194  m_DeltaRecoSWPhi = new TH1F("DeltaRecoSWPhi",
1195  "difference between reconstructed and simulated neuro phi; #Delta #phi [#circ]",
1196  80, -180, 180);
1197  }
1198 
1199 
1201  //RecoTracks matched to simulated neuro tracks (sw TS sw 2D sw NN)
1202  m_RecoSWTSSW2DZ = new TH1F("RecoSWTSSW2DZ",
1203  "sw matched z distribution of reconstructed tracks; z [cm]",
1204  100, -150, 150); // 1cm bins from -50cm to 50cm
1205  m_RecoSWTSSW2DCosTheta = new TH1F("RecoSWTSSW2DCosTheta",
1206  "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1207  100, -1, 1);
1208  m_RecoSWTSSW2DInvPt = new TH1F("RecoSWTSSW2DInvPt",
1209  "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1210  50, 0, 5);
1211  m_RecoSWTSSW2DPhi = new TH1F("RecoSWTSSW2DPhi",
1212  "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1213  80, 0, 360);
1214  m_RecoSWTSSW2DD0 = new TH1F("RecoSWTSSW2DD0",
1215  "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1216  100, 0, 10);
1217  m_RecoSWTSSW2DZScatter = new TH2F("RecoSWTSSW2DZScatter",
1218  "sw matched reconstruction; reco z [cm]; sw z [cm]",
1219  100, -150, 150, 100, -150, 150);
1220 
1221 
1222  // sw neuro values for tracks matched to reco tracks (sw TS, sw 2D)
1223  m_neuroRecoSWTSSW2DOutZ = new TH1F("NeuroRecoSWTSSW2DOutZ",
1224  "reco matched z distribution from simulation; z [cm]",
1225  100, -100, 100);
1226  m_neuroRecoSWTSSW2DOutCosTheta = new TH1F("NeuroRecoSWTSSW2DOutCosTheta",
1227  "reco matched cos theta distribution from simulation; cos(#theta) ",
1228  100, -1, 1);
1229  m_neuroRecoSWTSSW2DOutInvPt = new TH1F("NeuroRecoSWTSSW2DOutInvPt",
1230  "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1231  50, 0, 5);
1232  m_neuroRecoSWTSSW2DOutPhi0 = new TH1F("NeuroRecoSWTSSW2DOutPhi0",
1233  "reco matched phi distribution from simulation; #phi [#circ]",
1234  80, 0, 360); // shift to reduce the binning error
1235  m_neuroRecoSWTSSW2DOutHitPattern = new TH1F("NeuroRecoSWTSSW2DHitPattern",
1236  "reco matched stereo hit pattern from simulation; pattern",
1237  16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1238  m_neuroRecoSWTSSW2DOutTrackCount = new TH1F("NeuroRecoSWTSSW2DOutTrackCount",
1239  "reco matched number of SW neuro tracks per event",
1240  20, 0, 20);
1241  m_neuroRecoSWTSSW2DSector = new TH1F("NeuroRecoSWTSSW2DSector",
1242  "reco matched sector from simulation; sector",
1243  10, 0, 10);
1244 
1245 
1246  m_DeltaRecoSWTSSW2DZ = new TH1F("DeltaRecoSWTSSW2DZ",
1247  "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1248  100, -100, 100);
1249  m_DeltaRecoSWTSSW2DCosTheta = new TH1F("DeltaRecoSWTSSW2DCosTheta",
1250  "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1251  100, -1, 1);
1252  m_DeltaRecoSWTSSW2DInvPt = new TH1F("DeltaRecoSWTSSW2DInvPt",
1253  "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1254  100, -10, 10);
1255  m_DeltaRecoSWTSSW2DPhi = new TH1F("DeltaRecoSWTSSW2DPhi",
1256  "difference between reconstructed and simulated neuro phi;#Delta #phi [#circ]",
1257  80, -180, 180);
1258  }
1259 
1260  // cd back to root directory
1261  oldDir->cd();
1262 }

◆ 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 98 of file Module.cc.

◆ 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 135 of file Module.cc.

◆ 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 115 of file Module.cc.

◆ getFileNames()

virtual std::vector<std::string> getFileNames ( __attribute__((unused)) 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.

Definition at line 136 of file Module.h.

◆ 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 189 of file Module.h.

◆ 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 281 of file Module.cc.

◆ 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 383 of file Module.h.

◆ getType()

const std::string & getType ( ) const
inherited

Returns the type of the module (i.e.

class name minus 'Module')

Definition at line 43 of file Module.cc.

◆ 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 162 of file Module.cc.

◆ 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 87 of file Module.cc.

◆ 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 92 of file Module.cc.

◆ if_value()

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

Add a condition to the module.

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

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

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

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

Definition at line 81 of file Module.cc.

◆ setDescription()

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

Sets the description of the module.

Parameters
descriptionA description of the module.

Definition at line 216 of file Module.cc.

◆ 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 75 of file Module.cc.

◆ 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 216 of file Module.h.

◆ 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 236 of file Module.cc.

◆ 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 251 of file Module.cc.

◆ setPropertyFlags()

void setPropertyFlags ( unsigned int  propertyFlags)
inherited

Sets the flags for the module properties.

Parameters
propertyFlagsbitwise OR of EModulePropFlags

Definition at line 210 of file Module.cc.

◆ 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 229 of file Module.cc.

◆ 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 222 of file Module.cc.

◆ 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 50 of file Module.cc.

Member Data Documentation

◆ m_maxRecoD0Dist

double m_maxRecoD0Dist
private

Select only RecoTracks with a maximum d0 distance to the z axis.

-1 for all tracks

Definition at line 214 of file CDCTriggerNeuroDQMModule.h.

◆ m_maxRecoZDist

double m_maxRecoZDist
private

Select only RecoTracks with a maximum z distance to the IP.

-1 for all tracks

Definition at line 212 of file CDCTriggerNeuroDQMModule.h.

◆ m_neuroRecoSWTSSW2DOutHitPattern

TH1F* m_neuroRecoSWTSSW2DOutHitPattern
private
Initial value:
=
nullptr

reco matched stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)

Definition at line 736 of file CDCTriggerNeuroDQMModule.h.

◆ m_recoTrackMultiplicity

int m_recoTrackMultiplicity
private

Select events with a specific RecoTrack track multiplicity.

-1 for all events

Definition at line 208 of file CDCTriggerNeuroDQMModule.h.


The documentation for this class was generated from the following files:
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSID
TH1F * m_neuroHWInTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:342
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DSector
TH1F * m_neuroRecoSWTSSW2DSector
reco matched NN sector from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:739
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer5
TH1F * m_neuroHWInTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:349
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracksName
std::string m_simNeuroTracksName
Name for neuro tracks from TSIM using HW TS, HW 2D.
Definition: CDCTriggerNeuroDQMModule.h:202
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer1
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer1
Priority time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:542
Belle2::CDCTriggerNeuroDQMModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
Name of the histogram directory in ROOT file.
Definition: CDCTriggerNeuroDQMModule.h:181
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer5
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:512
Belle2::CDCTriggerNeuroDQMModule::m_neuroScatterTheta
TH2F * m_neuroScatterTheta
unpacked theta vs TSIM theta, scatter plot
Definition: CDCTriggerNeuroDQMModule.h:309
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutHitPattern
TH1F * m_neuroSWTSSW2DOutHitPattern
stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:301
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer4
TH1F * m_neuroHWInTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:377
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer1
TH1F * m_neuroSWTSSW2DInTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:528
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer3
TH1F * m_neuroSWSelTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:467
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutCosTheta
TH1F * m_neuroRecoHWOutCosTheta
reco matched cos theta distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:687
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer6
TH1F * m_neuroHWInputT_Layer6
unpacked time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:601
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer0
TH1F * m_neuroSWTSSW2DInputT_Layer0
simulated time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:641
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer2
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer2
Found time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:552
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer0
TH1F * m_neuroSWSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:484
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer0
TH1F * m_2DHWInTSPrioT_Layer0
Priority time of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:429
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSID
TH1F * m_neuroSWTSSW2DSelTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:539
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutPhi0
TH1F * m_neuroRecoSWTSSW2DOutPhi0
reco matched phi distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:735
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer8
TH1F * m_neuroSWSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:492
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer7
TH1F * m_neuroHWSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:422
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer1
TH1F * m_neuroSWTSSW2DInputT_Layer1
simulated time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:644
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer8
TH1F * m_2DHWInTSPrioB_Layer8
Priority bits of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:444
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer7
TH1F * m_neuroHWInTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:360
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer2
TH1F * m_neuroHWSelTSPrioT_Layer2
Priority time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:388
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer8
TH1F * m_neuroSWTSSW2DInputT_Layer8
simulated time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:665
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer2
TH1F * m_neuroHWSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:407
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutHitPattern
TH1F * m_neuroHWOutHitPattern
stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:264
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer0
TH1F * m_neuroHWInTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:373
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutInvPt
TH1F * m_2DHWOutInvPt
Inverse Pt of 2dtracks.
Definition: CDCTriggerNeuroDQMModule.h:275
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5InvPt
TH1F * m_neuroHWOutQuad5InvPt
Inverse Pt distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:323
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInm_time
TH1F * m_neuroHWInm_time
m_time distribution from incoming 2dtracks
Definition: CDCTriggerNeuroDQMModule.h:271
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutPt
TH1F * m_neuroHWOutPt
Pt distribution of unpacked neuro tracks.
Definition: CDCTriggerNeuroDQMModule.h:262
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer1
TH1F * m_neuroHWInputAlpha_Layer1
unpacked alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:587
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutInvPt
TH1F * m_neuroSWTSSW2DOutInvPt
Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:299
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer6
TH1F * m_neuroHWSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:411
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer3
TH1F * m_neuroHWInTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:376
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer0
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:560
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSCount
TH1F * m_neuroHWInTSCount
number of TS per track
Definition: CDCTriggerNeuroDQMModule.h:343
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer7
TH1F * m_neuroSWTSSW2DInTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:534
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer1
TH1F * m_neuroSWTSSW2DInputID_Layer1
simulated id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:643
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1CosTheta
TH1F * m_neuroHWOutQuad1CosTheta
cos theta distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:329
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DInvPt
TH1F * m_DeltaRecoSWTSSW2DInvPt
matched to SWTSSW2DSWNN reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:744
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer1
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:561
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer0
TH1F * m_2DHWInTSLR_Layer0
Left/Right of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:445
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWD0
TH1F * m_RecoSWD0
matched to SW reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:705
Belle2::CDCTriggerNeuroDQMModule::m_neuroScatterZ
TH2F * m_neuroScatterZ
unpacked z vs TSIM z, scatter plot
Definition: CDCTriggerNeuroDQMModule.h:308
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutPhi0
TH1F * m_neuroHWOutPhi0
phi distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:263
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer1
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:508
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer0
TH1F * m_neuroSWSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:474
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5CosTheta
TH1F * m_neuroHWOutQuad5CosTheta
cos theta distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:321
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer5
TH1F * m_neuroHWInTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:378
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer5
TH1F * m_neuroSWSelTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:460
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer5
TH1F * m_neuroHWSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:420
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer2
TH1F * m_neuroSWTSSW2DSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:572
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer0
TH1F * m_neuroSWTSSW2DInputID_Layer0
simulated id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:640
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer1
TH1F * m_neuroHWInTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:374
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer2
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:562
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer4
TH1F * m_neuroSWInputID_Layer4
simulated id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:623
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutInvPt
TH1F * m_neuroSWOutInvPt
Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:284
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer4
TH1F * m_neuroSWSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:478
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWZScatter
TH2F * m_RecoSWZScatter
matched to SW reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:706
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer6
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:513
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer6
TH1F * m_neuroHWSelTSPrioT_Layer6
Priority time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:392
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DCosTheta
TH1F * m_RecoSWTSSW2DCosTheta
matched to SWTSSW2DSWNN reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:725
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer6
TH1F * m_neuroHWInputAlpha_Layer6
unpacked alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:602
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer0
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:507
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer8
TH1F * m_neuroHWSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:423
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutPhi0
TH1F * m_2DHWOutPhi0
Phi0 of 2dtracks.
Definition: CDCTriggerNeuroDQMModule.h:276
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer6
TH1F * m_neuroHWInTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:379
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer7
TH1F * m_neuroHWSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:412
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DInvPt
TH1F * m_RecoSWTSSW2DInvPt
matched to SWTSSW2DSWNN reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:726
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer0
TH1F * m_neuroHWInTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:363
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer1
TH1F * m_neuroSWSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:475
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer1
TH1F * m_neuroHWSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:416
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer1
TH1F * m_neuroHWSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:406
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer6
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:566
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutTrackCount
TH1F * m_2DHWOutTrackCount
number of 2dtracks per event
Definition: CDCTriggerNeuroDQMModule.h:278
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DD0
TH1F * m_RecoSWTSSW2DD0
matched to SWTSSW2DSWNN reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:728
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer7
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer7
Priority time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:548
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaSector
TH1F * m_neuroDeltaSector
unpacked sector - TSIM sector
Definition: CDCTriggerNeuroDQMModule.h:315
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer1
TH1F * m_neuroSWInputID_Layer1
simulated id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:614
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer5
TH1F * m_neuroHWInputAlpha_Layer5
unpacked alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:599
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer3
TH1F * m_neuroHWSelTSFoundT_Layer3
Found time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:398
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutCosTheta
TH1F * m_neuroSWOutCosTheta
cos theta distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:283
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer2
TH1F * m_neuroSWSelTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:457
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer8
TH1F * m_neuroHWInputAlpha_Layer8
unpacked alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:608
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer0
TH1F * m_neuroSWSelTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:464
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer8
TH1F * m_2DHWInTSFoundT_Layer8
Found time of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:438
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer2
TH1F * m_neuroSWSelTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:466
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer8
TH1F * m_neuroSWSelTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:463
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2InvPt
TH1F * m_neuroHWOutQuad2InvPt
Inverse Pt distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:335
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer4
TH1F * m_neuroSWTSSW2DInputID_Layer4
simulated id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:652
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer0
TH1F * m_neuroHWInputAlpha_Layer0
unpacked alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:584
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer5
TH1F * m_neuroSWTSSW2DInputAlpha_Layer5
simulated alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:657
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer4
TH1F * m_neuroSWTSSW2DInputAlpha_Layer4
simulated alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:654
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer6
TH1F * m_neuroSWSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:490
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer2
TH1F * m_neuroHWSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:417
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer7
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer7
Found time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:557
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWCosTheta
TH1F * m_RecoSWCosTheta
matched to SW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:702
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer8
TH1F * m_neuroHWSelTSPrioT_Layer8
Priority time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:394
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer6
TH1F * m_neuroHWSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:421
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer6
TH1F * m_2DHWInTSPrioB_Layer6
Priority bits of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:443
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0Z
TH1F * m_neuroHWOutQuad0Z
z distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:324
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputAlpha
TH1F * m_neuroDeltaInputAlpha
unpacked alpha input - TSIM alpha input
Definition: CDCTriggerNeuroDQMModule.h:313
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer3
TH1F * m_neuroSWInputID_Layer3
simulated id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:620
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer1
TH1F * m_neuroHWInTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:354
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5Phi0
TH1F * m_neuroHWOutQuad5Phi0
phi distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:322
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DPhi
TH1F * m_RecoSWTSSW2DPhi
matched to SWTSSW2DSWNN reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:727
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer2
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer2
Priority time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:543
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer2
TH1F * m_neuroHWInTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:355
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3InvPt
TH1F * m_neuroHWOutQuad3InvPt
Inverse Pt distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:339
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0InvPt
TH1F * m_neuroHWOutQuad0InvPt
Inverse Pt distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:327
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer3
TH1F * m_neuroHWInputID_Layer3
unpacked id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:591
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer8
TH1F * m_neuroSWTSSW2DInTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:535
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer7
TH1F * m_neuroSWSelTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:462
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutTrackCount
TH1F * m_neuroRecoHWOutTrackCount
reco matched number of unpacked and matched tracks per event
Definition: CDCTriggerNeuroDQMModule.h:691
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer3
TH1F * m_neuroSWTSSW2DInputID_Layer3
simulated id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:649
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer5
TH1F * m_neuroHWSelTSPrioT_Layer5
Priority time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:391
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaZ
TH1F * m_neuroDeltaZ
unpacked z - TSIM z
Definition: CDCTriggerNeuroDQMModule.h:306
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer7
TH1F * m_neuroHWInTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:380
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer4
TH1F * m_neuroSWTSSW2DInputT_Layer4
simulated time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:653
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWCosTheta
TH1F * m_RecoHWCosTheta
matched to HW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:679
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWInvPt
TH1F * m_RecoHWInvPt
matched to HW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:680
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer0
TH1F * m_neuroSWTSSW2DSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:570
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutInvPt
TH1F * m_neuroHWOutInvPt
Inverse Pt distribution of unpacked neuro tracks.
Definition: CDCTriggerNeuroDQMModule.h:261
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer2
TH1F * m_neuroSWInputAlpha_Layer2
simulated alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:619
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer5
TH1F * m_neuroSWSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:489
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWInvPt
TH1F * m_DeltaRecoSWInvPt
matched to SW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:720
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer2
TH1F * m_neuroHWInputAlpha_Layer2
unpacked alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:590
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer5
TH1F * m_neuroHWSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:410
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DZScatter
TH2F * m_RecoSWTSSW2DZScatter
matched to SWTSSW2DSWNN reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:729
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer4
TH1F * m_neuroHWInTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:348
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer1
TH1F * m_neuroHWInTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:345
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWZ
TH1F * m_RecoHWZ
matched to HW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:678
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer0
TH1F * m_neuroHWInputT_Layer0
unpacked time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:583
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer0
TH1F * m_neuroSWTSSW2DInTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:527
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer7
TH1F * m_neuroSWInputAlpha_Layer7
simulated alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:634
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer1
TH1F * m_neuroSWInputT_Layer1
simulated time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:615
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer2
TH1F * m_neuroHWInputT_Layer2
unpacked time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:589
Belle2::CDCTriggerNeuroDQMModule::m_RecoCosTheta
TH1F * m_RecoCosTheta
reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:671
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer0
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:517
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer2
TH1F * m_2DHWInTSPrioB_Layer2
Priority bits of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:441
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer5
TH1F * m_neuroHWSelTSFoundT_Layer5
Found time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:400
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer8
TH1F * m_neuroSWTSSW2DSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:578
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer6
TH1F * m_neuroHWInputID_Layer6
unpacked id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:600
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer5
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer5
Found time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:555
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer1
TH1F * m_neuroSWSelTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:456
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer6
TH1F * m_2DHWInTSLR_Layer6
Left/Right of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:448
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer6
TH1F * m_neuroHWInTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:369
Belle2::CDCTriggerNeuroDQMModule::m_RecoPhi
TH1F * m_RecoPhi
reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:673
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer2
TH1F * m_neuroHWSelTSFoundT_Layer2
Found time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:397
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer7
TH1F * m_neuroSWTSSW2DInputID_Layer7
simulated id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:661
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer0
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer0
Found time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:550
Belle2::CDCTriggerNeuroDQMModule::m_sim2DTracksSWTSName
std::string m_sim2DTracksSWTSName
Name for simulated 2D finder tracks using simulated TS.
Definition: CDCTriggerNeuroDQMModule.h:219
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutPhi0
TH1F * m_neuroRecoSWOutPhi0
reco matched phi distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:712
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer3
TH1F * m_neuroSWInputT_Layer3
simulated time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:621
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer3
TH1F * m_neuroSWTSSW2DInputT_Layer3
simulated time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:650
Belle2::CDCTriggerNeuroDQMModule::m_recoTracksName
std::string m_recoTracksName
Name for the RecoTrack array name.
Definition: CDCTriggerNeuroDQMModule.h:226
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DPhi
TH1F * m_DeltaRecoSWTSSW2DPhi
matched to SWTSSW2DSWNN reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:745
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer8
TH1F * m_neuroHWInputID_Layer8
unpacked id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:606
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutm_time
TH1F * m_2DHWOutm_time
m_time 2dtracks
Definition: CDCTriggerNeuroDQMModule.h:277
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWCosTheta
TH1F * m_DeltaRecoHWCosTheta
matched to HW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:696
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer2
TH1F * m_neuroSWTSSW2DInTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:529
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer4
TH1F * m_2DHWInTSPrioB_Layer4
Priority bits of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:442
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer2
TH1F * m_2DHWInTSLR_Layer2
Left/Right of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:446
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer0
TH1F * m_neuroSWTSSW2DInputAlpha_Layer0
simulated alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:642
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSCount
TH1F * m_neuroHWSelTSCount
number of selected TS per SL
Definition: CDCTriggerNeuroDQMModule.h:385
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer8
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer8
Found time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:558
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer7
TH1F * m_neuroSWTSSW2DSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:577
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer2
TH1F * m_neuroHWInputID_Layer2
unpacked id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:588
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer2
TH1F * m_neuroSWSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:486
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer1
TH1F * m_neuroSWSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:485
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer0
TH1F * m_2DHWInTSFoundT_Layer0
Found time of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:434
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer6
TH1F * m_2DHWInTSFoundT_Layer6
Found time of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:437
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer4
TH1F * m_neuroHWSelTSFoundT_Layer4
Found time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:399
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWPhi
TH1F * m_RecoSWPhi
matched to SW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:704
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer6
TH1F * m_neuroSWTSSW2DInputID_Layer6
simulated id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:658
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer2
TH1F * m_neuroSWTSSW2DInputAlpha_Layer2
simulated alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:648
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5Z
TH1F * m_neuroHWOutQuad5Z
z distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:320
Belle2::CDCTriggerNeuroDQMModule::m_simSameTS
TH1F * m_simSameTS
number of TS selected in both, unpacked and TSIM tracks
Definition: CDCTriggerNeuroDQMModule.h:316
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer4
TH1F * m_neuroSWSelTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:468
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutHitPattern
TH1F * m_neuroRecoHWOutHitPattern
reco matched stereo hit pattern from unpacker
Definition: CDCTriggerNeuroDQMModule.h:690
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer8
TH1F * m_neuroSWSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:482
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutHitPattern
TH1F * m_neuroSWOutHitPattern
stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:286
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer7
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:524
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer5
TH1F * m_neuroSWTSSW2DInTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:532
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer0
TH1F * m_neuroHWSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:415
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer3
TH1F * m_neuroHWInTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:347
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1Phi0
TH1F * m_neuroHWOutQuad1Phi0
phi distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:330
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer4
TH1F * m_2DHWInTSLR_Layer4
Left/Right of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:447
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputT
TH1F * m_neuroDeltaInputT
unpacked time input - TSIM time input
Definition: CDCTriggerNeuroDQMModule.h:312
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer0
TH1F * m_neuroSWInputID_Layer0
simulated id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:611
Belle2::CDCTriggerNeuroDQMModule::m_unpacked2DTracksName
std::string m_unpacked2DTracksName
Name for 2D finder tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:190
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSID
TH1F * m_neuroSWTSSW2DInTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:496
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWCosTheta
TH1F * m_DeltaRecoSWCosTheta
matched to SW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:719
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutm_time
TH1F * m_neuroHWOutm_time
m_time distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:265
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer2
TH1F * m_neuroHWInTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:365
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer3
TH1F * m_neuroHWSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:408
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer1
TH1F * m_neuroSWTSSW2DInputAlpha_Layer1
simulated alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:645
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer8
TH1F * m_neuroHWInTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:361
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer2
TH1F * m_neuroHWInTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:375
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer7
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:514
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer3
TH1F * m_neuroSWSelTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:458
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutInvPt
TH1F * m_neuroRecoSWOutInvPt
reco matched Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:711
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer1
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer1
Found time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:551
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutZ
TH1F * m_neuroRecoHWOutZ
reco matched z distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:686
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DCosTheta
TH1F * m_DeltaRecoSWTSSW2DCosTheta
matched to SWTSSW2DSWNN reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:743
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer8
TH1F * m_neuroSWTSSW2DInputAlpha_Layer8
simulated alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:666
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer4
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer4
Priority time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:545
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutVsInTrackCount
TH1F * m_neuroHWOutVsInTrackCount
neuroHWOutTracks - neuroHWInTrackCount
Definition: CDCTriggerNeuroDQMModule.h:273
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer4
TH1F * m_neuroSWTSSW2DSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:574
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DZ
TH1F * m_DeltaRecoSWTSSW2DZ
matched to SWTSSW2DSWNN reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:742
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWSector
TH1F * m_neuroRecoSWSector
reco matched NN sector from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:715
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer0
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:498
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutCosTheta
TH1F * m_neuroSWTSSW2DOutCosTheta
cos theta distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:298
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutZ
TH1F * m_neuroSWOutZ
z distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:282
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer3
TH1F * m_neuroHWInTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:356
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer3
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:501
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer6
TH1F * m_neuroSWSelTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:470
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracksSWTSSW2DName
std::string m_simNeuroTracksSWTSSW2DName
Name for neuro tracks using simulated TS and simulated 2D.
Definition: CDCTriggerNeuroDQMModule.h:221
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer1
TH1F * m_neuroHWSelTSFoundT_Layer1
Found time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:396
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer8
TH1F * m_neuroHWInTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:381
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer4
TH1F * m_neuroHWInputAlpha_Layer4
unpacked alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:596
Belle2::CDCTriggerNeuroDQMModule::m_RecoInvPt
TH1F * m_RecoInvPt
reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:672
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer7
TH1F * m_neuroHWInTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:351
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer7
TH1F * m_neuroHWInputAlpha_Layer7
unpacked alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:605
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutPhi0
TH1F * m_neuroRecoHWOutPhi0
reco matched phi distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:689
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWZ
TH1F * m_DeltaRecoSWZ
matched to SW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:718
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer2
TH1F * m_neuroSWTSSW2DInputID_Layer2
simulated id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:646
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer0
TH1F * m_neuroHWSelTSPrioT_Layer0
Priority time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:386
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWInvPt
TH1F * m_RecoSWInvPt
matched to SW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:703
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer8
TH1F * m_neuroSWInputT_Layer8
simulated time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:636
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutm_time
TH1F * m_2DSWOutm_time
m_time 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:293
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2CosTheta
TH1F * m_neuroHWOutQuad2CosTheta
cos theta distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:333
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer0
TH1F * m_neuroHWSelTSFoundT_Layer0
Found time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:395
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSID
TH1F * m_neuroSWSelTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:453
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0CosTheta
TH1F * m_neuroHWOutQuad0CosTheta
cos theta distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:325
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutInvPt
TH1F * m_neuroRecoSWTSSW2DOutInvPt
reco matched Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:734
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer2
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:519
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutTrackCount
TH1F * m_neuroSWOutTrackCount
number of simulated tracks per event (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:287
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputID
TH1F * m_neuroDeltaInputID
unpacked ID input - TSIM ID input
Definition: CDCTriggerNeuroDQMModule.h:311
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer5
TH1F * m_neuroSWInputT_Layer5
simulated time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:627
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer4
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer4
Found time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:554
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutZ
TH1F * m_neuroRecoSWTSSW2DOutZ
reco matched z distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:732
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer5
TH1F * m_neuroHWInputT_Layer5
unpacked time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:598
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer0
TH1F * m_neuroSWInputT_Layer0
simulated time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:612
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer8
TH1F * m_neuroHWInTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:352
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer1
TH1F * m_neuroHWSelTSPrioT_Layer1
Priority time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:387
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer1
TH1F * m_neuroSWSelTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:465
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer7
TH1F * m_neuroSWSelTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:471
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer2
TH1F * m_2DHWInTSFoundT_Layer2
Found time of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:435
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer5
TH1F * m_neuroHWInTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:358
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer5
TH1F * m_neuroSWSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:479
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer4
TH1F * m_neuroSWInputT_Layer4
simulated time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:624
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2Phi0
TH1F * m_neuroHWOutQuad2Phi0
phi distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:334
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3Phi0
TH1F * m_neuroHWOutQuad3Phi0
phi distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:338
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer4
TH1F * m_neuroSWSelTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:459
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutCosTheta
TH1F * m_neuroRecoSWOutCosTheta
reco matched cos theta distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:710
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer4
TH1F * m_neuroHWInputID_Layer4
unpacked id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:594
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer6
TH1F * m_neuroSWTSSW2DInTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:533
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer8
TH1F * m_neuroHWSelTSFoundT_Layer8
Found time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:403
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer6
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer6
Found time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:556
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSector
TH1F * m_neuroHWSector
sector of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:267
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSCount
TH1F * m_neuroSWTSSW2DInTSCount
number of TS per event
Definition: CDCTriggerNeuroDQMModule.h:497
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutPhi0
TH1F * m_neuroSWOutPhi0
phi distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:285
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer4
TH1F * m_neuroHWInTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:357
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer5
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:522
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer6
TH1F * m_neuroSWTSSW2DInputAlpha_Layer6
simulated alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:660
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer4
TH1F * m_neuroSWSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:488
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWD0
TH1F * m_RecoHWD0
matched to HW reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:682
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutZ
TH1F * m_neuroSWTSSW2DOutZ
z distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:297
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWPhi
TH1F * m_DeltaRecoSWPhi
matched to SW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:721
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutPhi0
TH1F * m_neuroSWTSSW2DOutPhi0
phi distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:300
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer6
TH1F * m_neuroSWTSSW2DInputT_Layer6
simulated time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:659
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer7
TH1F * m_neuroHWSelTSFoundT_Layer7
Found time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:402
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1InvPt
TH1F * m_neuroHWOutQuad1InvPt
Inverse Pt distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:331
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutTrackCount
TH1F * m_2DSWOutTrackCount
number of 2dtracks per event (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:294
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer0
TH1F * m_neuroSWInputAlpha_Layer0
simulated alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:613
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer7
TH1F * m_neuroSWSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:481
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3CosTheta
TH1F * m_neuroHWOutQuad3CosTheta
cos theta distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:337
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer3
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer3
Priority time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:544
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer7
TH1F * m_neuroSWInputT_Layer7
simulated time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:633
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutZ
TH1F * m_neuroHWOutZ
z distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:259
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer1
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:499
Belle2::CDCTriggerNeuroDQMModule::m_RecoTrackCount
TH1F * m_RecoTrackCount
number of reconstructed tracks per event
Definition: CDCTriggerNeuroDQMModule.h:675
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer8
TH1F * m_2DHWInTSLR_Layer8
Left/Right of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:449
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutCosTheta
TH1F * m_neuroRecoSWTSSW2DOutCosTheta
reco matched cos theta distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:733
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer6
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:504
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer3
TH1F * m_neuroHWInTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:366
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer0
TH1F * m_neuroSWSelTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:455
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer8
TH1F * m_neuroHWSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:413
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer6
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer6
Priority time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:547
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer5
TH1F * m_neuroSWTSSW2DInputID_Layer5
simulated id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:655
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer3
TH1F * m_neuroSWTSSW2DInTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:530
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer2
TH1F * m_neuroHWInTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:346
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTrackCount
TH1F * m_neuroHWInTrackCount
number of neuro input 2dtracks per event
Definition: CDCTriggerNeuroDQMModule.h:272
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer5
TH1F * m_neuroSWSelTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:469
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer6
TH1F * m_neuroHWInTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:359
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaTSID
TH1F * m_neuroDeltaTSID
unpacked selected TSID - TSIM selected TSID
Definition: CDCTriggerNeuroDQMModule.h:314
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer6
TH1F * m_neuroSWInputAlpha_Layer6
simulated alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:631
Belle2::CDCTriggerNeuroDQMModule::m_RecoD0
TH1F * m_RecoD0
reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:674
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer6
TH1F * m_neuroSWInputT_Layer6
simulated time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:630
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer5
TH1F * m_neuroHWInTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:368
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer6
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:523
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer0
TH1F * m_neuroHWInputID_Layer0
unpacked id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:582
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer7
TH1F * m_neuroSWInputID_Layer7
simulated id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:632
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSID
TH1F * m_neuroHWSelTSID
ID of selected track segments.
Definition: CDCTriggerNeuroDQMModule.h:384
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutInvPt
TH1F * m_neuroRecoHWOutInvPt
reco matched Inverse Pt distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:688
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer3
TH1F * m_neuroHWSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:418
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer7
TH1F * m_neuroHWSelTSPrioT_Layer7
Priority time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:393
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer5
TH1F * m_neuroSWInputAlpha_Layer5
simulated alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:628
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer3
TH1F * m_neuroHWInputAlpha_Layer3
unpacked alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:593
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer2
TH1F * m_2DHWInTSPrioT_Layer2
Priority time of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:430
Belle2::CDCTriggerNeuroDQMModule::m_simDiffTS
TH1F * m_simDiffTS
number of TS selcted in TSIM but not in unpacked
Definition: CDCTriggerNeuroDQMModule.h:317
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DZ
TH1F * m_RecoSWTSSW2DZ
matched to SWTSSW2DSWNN reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:724
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer8
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:525
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer8
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer8
Priority time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:549
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer7
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:505
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer8
TH1F * m_neuroSWTSSW2DInputID_Layer8
simulated id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:664
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWZ
TH1F * m_RecoSWZ
matched to SW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:701
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer8
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:506
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer4
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:502
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSector
TH1F * m_neuroSWSector
NN sector from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:288
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWInvPt
TH1F * m_DeltaRecoHWInvPt
matched to HW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:697
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer3
TH1F * m_neuroSWTSSW2DSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:573
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInVs2DOutTrackCount
TH1F * m_neuroHWInVs2DOutTrackCount
neuroHWInTrackCount - 2DHWOutTrackCountput
Definition: CDCTriggerNeuroDQMModule.h:279
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer5
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer5
Priority time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:546
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer7
TH1F * m_neuroSWTSSW2DInputT_Layer7
simulated time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:662
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer2
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:500
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer8
TH1F * m_neuroSWInputAlpha_Layer8
simulated alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:637
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer2
TH1F * m_neuroSWInputID_Layer2
simulated id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:617
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1Z
TH1F * m_neuroHWOutQuad1Z
z distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:328
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer2
TH1F * m_neuroSWInputT_Layer2
simulated time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:618
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer3
TH1F * m_neuroSWSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:477
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInInvPt
TH1F * m_neuroHWInInvPt
Inverse Pt distribution from incoming 2dtrack.
Definition: CDCTriggerNeuroDQMModule.h:269
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutTrackCount
TH1F * m_neuroHWOutTrackCount
number of unpacked tracks per event
Definition: CDCTriggerNeuroDQMModule.h:266
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer3
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:510
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer6
TH1F * m_neuroSWSelTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:461
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3Z
TH1F * m_neuroHWOutQuad3Z
z distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:336
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer0
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer0
Priority time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:541
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer8
TH1F * m_2DHWInTSPrioT_Layer8
Priority time of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:433
Belle2::CDCTriggerNeuroDQMModule::m_limitedoutput
bool m_limitedoutput
Switch to supress output for dqm online module.
Definition: CDCTriggerNeuroDQMModule.h:183
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutCosTheta
TH1F * m_neuroHWOutCosTheta
cos theta distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:260
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer4
TH1F * m_2DHWInTSPrioT_Layer4
Priority time of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:431
Belle2::CDCTriggerNeuroDQMModule::m_RecoZ
TH1F * m_RecoZ
reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:670
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutHitPattern
TH1F * m_neuroRecoSWTSSW2DOutHitPattern
reco matched stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:736
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer4
TH1F * m_neuroHWSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:419
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer7
TH1F * m_neuroSWTSSW2DInputAlpha_Layer7
simulated alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:663
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer6
TH1F * m_neuroSWTSSW2DSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:576
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutTrackCount
TH1F * m_neuroRecoSWOutTrackCount
reco matched number of simulated tracks per event (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:714
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaTheta
TH1F * m_neuroDeltaTheta
unpacked theta - TSIM theta
Definition: CDCTriggerNeuroDQMModule.h:307
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer4
TH1F * m_neuroHWInTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:367
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutInvPt
TH1F * m_2DSWOutInvPt
Inverse Pt of 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:291
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer8
TH1F * m_neuroHWInTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:371
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer0
TH1F * m_neuroHWSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:405
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer5
TH1F * m_neuroHWInputID_Layer5
unpacked id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:597
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer2
TH1F * m_neuroSWTSSW2DInputT_Layer2
simulated time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:647
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWPhi
TH1F * m_DeltaRecoHWPhi
matched to HW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:698
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer7
TH1F * m_neuroHWInputT_Layer7
unpacked time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:604
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer4
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:521
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutTrackCount
TH1F * m_neuroSWTSSW2DOutTrackCount
number of simulated tracks per event (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:302
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer3
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:520
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer5
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:565
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer4
TH1F * m_neuroHWInputT_Layer4
unpacked time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:595
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer7
TH1F * m_neuroHWInTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:370
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer6
TH1F * m_neuroHWSelTSFoundT_Layer6
Found time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:401
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer5
TH1F * m_neuroSWTSSW2DInputT_Layer5
simulated time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:656
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer1
TH1F * m_neuroSWTSSW2DSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:571
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer4
TH1F * m_neuroSWInputAlpha_Layer4
simulated alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:625
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer7
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:567
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer4
TH1F * m_neuroSWTSSW2DInTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:531
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer3
TH1F * m_neuroSWTSSW2DInputAlpha_Layer3
simulated alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:651
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer5
TH1F * m_neuroSWInputID_Layer5
simulated id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:626
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInPhi0
TH1F * m_neuroHWInPhi0
Phi0 of incoming 2dtrack.
Definition: CDCTriggerNeuroDQMModule.h:270
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWSector
TH1F * m_neuroRecoHWSector
reco matched NN sector from unpacker
Definition: CDCTriggerNeuroDQMModule.h:692
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWPhi
TH1F * m_RecoHWPhi
matched to HW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:681
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer6
TH1F * m_neuroSWSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:480
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer0
TH1F * m_neuroHWInTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:344
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer7
TH1F * m_neuroHWInputID_Layer7
unpacked id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:603
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer6
TH1F * m_neuroSWInputID_Layer6
simulated id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:629
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer5
TH1F * m_neuroSWTSSW2DSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:575
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer0
TH1F * m_neuroHWInTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:353
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer5
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:503
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer3
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:563
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer8
TH1F * m_neuroSWSelTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:472
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer8
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:515
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWZ
TH1F * m_DeltaRecoHWZ
matched to HW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:695
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer8
TH1F * m_neuroSWInputID_Layer8
simulated id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:635
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer4
TH1F * m_neuroHWSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:409
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer6
TH1F * m_2DHWInTSPrioT_Layer6
Priority time of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:432
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer6
TH1F * m_neuroHWInTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:350
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer0
TH1F * m_2DHWInTSPrioB_Layer0
Priority bits of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:440
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer1
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:518
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer2
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:509
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer2
TH1F * m_neuroSWSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:476
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0Phi0
TH1F * m_neuroHWOutQuad0Phi0
phi distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:326
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer1
TH1F * m_neuroHWInTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:364
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer3
TH1F * m_neuroHWSelTSPrioT_Layer3
Priority time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:389
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer7
TH1F * m_neuroSWSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:491
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer8
TH1F * m_neuroHWInputT_Layer8
unpacked time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:607
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSector
TH1F * m_neuroSWTSSW2DSector
NN sector from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:303
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2Z
TH1F * m_neuroHWOutQuad2Z
z distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:332
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroTracksName
std::string m_unpackedNeuroTracksName
Name for neuro tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:192
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer4
TH1F * m_neuroHWSelTSPrioT_Layer4
Priority time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:390
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer3
TH1F * m_neuroSWSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:487
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer4
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:511
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutZ
TH1F * m_neuroRecoSWOutZ
reco matched z distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:709
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSCount
TH1F * m_neuroSWTSSW2DSelTSCount
number of TS per SL
Definition: CDCTriggerNeuroDQMModule.h:540
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSCount
TH1F * m_neuroSWSelTSCount
number of TS per SL
Definition: CDCTriggerNeuroDQMModule.h:454
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutPhi0
TH1F * m_2DSWOutPhi0
Phi0 of 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:292
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWZScatter
TH2F * m_RecoHWZScatter
matched to HW reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:683
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer8
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:568
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer1
TH1F * m_neuroHWInputT_Layer1
unpacked time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:586
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer1
TH1F * m_neuroSWInputAlpha_Layer1
simulated alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:616
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutTrackCount
TH1F * m_neuroRecoSWTSSW2DOutTrackCount
reco matched number of simulated tracks per event (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:738
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer3
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer3
Found time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:553
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer1
TH1F * m_neuroHWInputID_Layer1
unpacked id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:585
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer4
TH1F * m_2DHWInTSFoundT_Layer4
Found time of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:436
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer4
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:564
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer3
TH1F * m_neuroSWInputAlpha_Layer3
simulated alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:622
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutHitPattern
TH1F * m_neuroRecoSWOutHitPattern
reco matched stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:713
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer3
TH1F * m_neuroHWInputT_Layer3
unpacked time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:592