Belle II Software  release-08-01-10
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes | List of all members
CDCTriggerNeuroDQMModule Class Reference
Packages » trg | Modules » trg modules

CDC Trigger DQM Module. More...

#include <CDCTriggerNeuroDQMModule.h>

Inheritance diagram for CDCTriggerNeuroDQMModule:
Inheritance graph
[legend]
Collaboration diagram for CDCTriggerNeuroDQMModule:
Collaboration graph
[legend]

Classes

struct  TSLine
 

Public Types

typedef std::vector< TSLine > TSLines
 
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. More...
 
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 (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...
 
LogConfig & getLogConfig ()
 Returns the log system configuration.
 
void setLogConfig (const LogConfig &logConfig)
 Set the log system configuration.
 
void setLogLevel (int logLevel)
 Configure the log level.
 
void setDebugLevel (int debugLevel)
 Configure the debug messaging level.
 
void setAbortLevel (int abortLevel)
 Configure the abort log level.
 
void setLogInfo (int logLevel, unsigned int logInfo)
 Configure the printed log information for the given level. 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 ModuleCondition * getCondition () const
 Return a pointer to the first condition (or nullptr, if none was set)
 
const std::vector< ModuleCondition > & getAllConditions () const
 Return all set conditions for this module.
 
bool evalCondition () const
 If at least one condition was set, it is evaluated and true returned if at least one condition returns true. More...
 
std::shared_ptr< Path > getConditionPath () const
 Returns the path of the last true condition (if there is at least one, else reaturn a null pointer). 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 ModuleParamList & getParamList () 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< PathElement > clone () 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< ModulePtr > getModules () const override
 no submodules, return empty list
 
std::string getPathString () const override
 return the module name.
 
void setParamPython (const std::string &name, const boost::python::object &pyObj)
 Implements a method for setting boost::python objects. 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< CDCTriggerSegmentHit > m_unpackedSegmentHits
 StoreArray for TS hits from unpacker.
 
StoreArray< CDCTriggerTrack > m_unpacked2DTracks
 StoreArray for 2D finder tracks from unpacker.
 
StoreArray< CDCTriggerTrack > m_unpackedNeuroTracks
 StoreArray for neuro tracks from unpacker.
 
StoreArray< CDCTriggerMLPInput > m_unpackedNeuroInputVector
 StoreArray for neuro input vector from unpacker.
 
StoreArray< CDCTriggerTrack > m_unpackedNeuroInput2DTracks
 StoreArray for neuro input 2dfinder tracks.
 
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputSegments
 StoreArray for neuro input Track segments.
 
StoreArray< CDCTriggerTrack > m_simNeuroTracks
 StoreArray for neuro tracks from TSIM.
 
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVector
 StoreArray for neuro input vector from TSIM.
 
StoreArray< RecoTrack > m_RecoTracks
 StoreArray for RecoTracks.
 
StoreArray< CDCTriggerSegmentHit > m_simSegmentHits
 StoreArray for simulated TS hits.
 
StoreArray< CDCTriggerTrack > m_sim2DTracksSWTS
 StoreArray for simulated 2D finder tracks using simulated TS.
 
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVectorSWTSSW2D
 StoreArray for neuro input vector using simulated TS and simulated 2D.
 
StoreArray< CDCTriggerTrack > m_simNeuroTracksSWTSSW2D
 StoreArray for neuro tracks using simulated TS and simulated 2D.
 
StoreObjPtr< BinnedEventT0 > m_eventTime
 storeobjpointer for event time
 
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_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< ModuleCondition > m_conditions
 Module condition, only non-null if set.
 

Detailed Description

CDC Trigger DQM Module.

Definition at line 34 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 77 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 179 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 439 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 420 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 96 of file CDCTriggerNeuroDQMModule.cc.

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

◆ evalCondition()

bool evalCondition ( ) const
inherited

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

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

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

Definition at line 96 of file Module.cc.

◆ event()

void event ( void  )
overridevirtual

Function to process event record.

,(x," + padto(intomega.str(), 2) + "," + padto(intphi.str(), 3) + "," + padto(inttheta.str(), 3) + "," + padto(intz.str(), 3) + "),

Reimplemented from HistoModule.

Definition at line 1795 of file CDCTriggerNeuroDQMModule.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 133 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 113 of file Module.cc.

◆ getFileNames()

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

Return a list of output filenames for this modules.

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

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

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

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

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

Reimplemented in RootOutputModule, StorageRootOutputModule, and RootInputModule.

Definition at line 134 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 187 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 279 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 381 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 41 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 160 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 85 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 90 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 79 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 214 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 73 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 214 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 234 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 249 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 208 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 227 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 220 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 48 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 205 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 203 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 728 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 199 of file CDCTriggerNeuroDQMModule.h.

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