ATLAS Offline Software
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
TRT_Monitoring_Tool Class Reference

#include <TRT_Monitoring_Tool.h>

Inheritance diagram for TRT_Monitoring_Tool:
Collaboration diagram for TRT_Monitoring_Tool:

Public Types

enum  Interval_t {
  file = 0, eventsBlock, lumiBlock, lowStat,
  medStat, higStat, run, fill,
  all
}
 An enumeration describing how detailed a particular monitoring object is. More...
 
enum  MgmtAttr_t { ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2 }
 An enumeration describing how the class handles the histogram. More...
 

Public Member Functions

 TRT_Monitoring_Tool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~TRT_Monitoring_Tool ()
 
virtual StatusCode initialize ()
 
virtual StatusCode bookHistogramsRecurrent ()
 An inheriting class should either override this function, bookHists() or bookHistograms(). More...
 
virtual StatusCode fillHistograms ()
 An inheriting class should either override this function or fillHists(). More...
 
virtual StatusCode procHistograms ()
 An inheriting class should either override this function or finalHists(). More...
 
virtual StreamNameFcn * streamNameFunction ()
 Returns the function object that converts logical paramters into a physical stream name. More...
 
virtual StatusCode bookHists ()
 Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers. More...
 
virtual StatusCode fillHists ()
 Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ). More...
 
virtual StatusCode finalHists ()
 Calls procHists( true, true, true ). More...
 
virtual StatusCode convertLWHists ()
 Deal with the LW histograms. More...
 
virtual StatusCode bookHistograms ()
 An inheriting class should either override this function or bookHists(). More...
 
virtual void setMonManager (AthenaMonManager *manager)
 Takes a pointer to a managing object to get information from it when needed. More...
 
virtual StatusCode regHist (TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram. More...
 
virtual StatusCode regHist (TH1 *h, const MonGroup &group)
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram. More...
 
virtual StatusCode regHist (LWHist *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Support for lightweight histograms: More...
 
virtual StatusCode regHist (LWHist *h, const MonGroup &group)
 
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
 Returns a TH1 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH1 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const std::string &system, Interval_t interval)
 Returns a TH2 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH2 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (LWHist *&h, const std::string &hName, const std::string &system, Interval_t interval)
 
virtual StatusCode getHist (LWHist *&h, const std::string &hName, const MonGroup &group)
 
virtual StatusCode regEfficiency (TEfficiency *e, const MonGroup &group)
 Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot. More...
 
virtual StatusCode regGraph (TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph. More...
 
virtual StatusCode regGraph (TGraph *g, const MonGroup &group)
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph. More...
 
virtual StatusCode regTree (TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TTree to be included in the output stream using logical parameters that describe it. More...
 
virtual StatusCode regTree (TTree *t, const MonGroup &group)
 Registers a TTree to be included in the output stream using logical parameters that describe it. More...
 
virtual StatusCode deregHist (LWHist *h)
 
virtual StatusCode deregHist (TH1 *h)
 De-registers a TH1 from the THistSvc, but does NOT delete the object. More...
 
virtual StatusCode writeAndDelete (TH1 *h, const MonGroup &group)
 Write out histogram and delete it. More...
 
virtual StatusCode deregGraph (TGraph *g)
 De-registers a TGraph from the THistSvc, but does NOT delete the object. More...
 
virtual StatusCode deregObject (const std::string &objName, const std::string &system, Interval_t interval)
 De-registers a TObject from the THistSvc, but does NOT delete the object. More...
 
virtual StatusCode deregObject (const std::string &objName, const MonGroup &group)
 De-registers a TObject from the THistSvc, but does NOT delete the object. More...
 
virtual StatusCode setupOutputStreams (std::vector< std::string > Mapping=std::vector< std::string >())
 This implementation does nothing—streams in this class should be managed by the AthenaMonManager. More...
 
virtual StatusCode runStat ()
 This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ). More...
 
virtual StatusCode checkHists (bool calledFromFinalize)
 This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments. More...
 
virtual bool preSelector ()
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1) More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous luminosity. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Luminosity block time (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Livefraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average Integrated Luminosity Live Fraction. More...
 
 MMTB_DEPRECATED (newLowStatInterval)
 
 MMTB_DEPRECATED (newMedStatInterval)
 
 MMTB_DEPRECATED (newHigStatInterval)
 
 MMTB_DEPRECATED (newLowStat)
 
 MMTB_DEPRECATED (newLumiBlock)
 
 MMTB_DEPRECATED (newRun)
 
 MMTB_DEPRECATED (newEventsBlock)
 
 MMTB_DEPRECATED (endOfEventsBlock)
 
 MMTB_DEPRECATED (endOfLowStat)
 
 MMTB_DEPRECATED (endOfLumiBlock)
 
 MMTB_DEPRECATED (endOfRun)
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static std::string intervalEnumToString (Interval_t interval)
 Converts a LevelOfDetail_t to a string of the same name. More...
 
static Interval_t intervalStringToEnum (const std::string &str)
 Converts a string to the corresponding Interval_t. More...
 
static const InterfaceID & interfaceID ()
 

Protected Types

typedef std::map< std::string, OutputMetadata * > MDMap_t
 

Protected Member Functions

StatusCode regManagedHistograms (std::vector< MgmtParams< TH1 > > &templateHistograms)
 
StatusCode regManagedGraphs (std::vector< MgmtParams< TGraph > > &templateGraphs)
 
StatusCode regManagedTrees (std::vector< MgmtParams< TTree > > &templateTrees)
 
StatusCode regManagedLWHistograms (std::vector< MgmtParams< LWHist > > &templateLWHistograms)
 
StatusCode regManagedEfficiencies (std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
 
StatusCode parseList (const std::string &, std::vector< std::string > &)
 
void updateTriggersForGroups (std::vector< std::string > &)
 
StatusCode registerMetadata (const std::string &streamName, const std::string &hName, const MonGroup &group)
 
StatusCode THistSvc_deReg_fixTGraph (TFile *file, TGraph *theGraph, std::string &directoryName)
 Fixes THistSvc->deReg(obj) when obj is TGraph instance. More...
 
unsigned int get_nEvents () const
 
long get_procNEventsProp () const
 
virtual bool trigChainsArePassed (std::vector< std::string > &)
 
virtual StreamNameFcn * getNewStreamNameFcn () const
 
bool newLowStatIntervalFlag () const
 Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called. More...
 
bool newMedStatIntervalFlag () const
 
bool newHigStatIntervalFlag () const
 
bool newLowStatFlag () const
 
bool newLumiBlockFlag () const
 
bool newRunFlag () const
 
bool newEventsBlockFlag () const
 
bool endOfEventsBlockFlag () const
 
bool endOfLowStatFlag () const
 
bool endOfLumiBlockFlag () const
 
bool endOfRunFlag () const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
 
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
 
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
 
std::map< Interval_t, std::vector< MgmtParams< LWHist > > > m_templateLWHistograms
 
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
 
std::vector< std::string > m_vTrigChainNames
 
std::vector< std::string > m_vTrigGroupNames
 
MDMap_t m_metadataMap
 
std::set< LWHist * > m_lwhists
 
AthenaMonManager * m_manager
 
std::string m_managerNameProp
 
std::string m_fileKey
 
std::string m_dataTypeStr
 
std::string m_environmentStr
 
unsigned int m_detailLevel
 
AthenaMonManager::DataType_t m_dataType
 
AthenaMonManager::Environment_t m_environment
 
StreamNameFcn * m_streamNameFcn
 
ServiceHandle< ITHistSvc > m_THistSvc
 
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator {this,"TriggerTranslatorTool",""}
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 
long m_procNEventsProp
 
std::string m_path
 
long m_preScaleProp
 
std::string m_triggerChainProp
 
std::string m_triggerGroupProp
 
bool m_useTrigger
 
unsigned int m_lastLumiBlock
 
unsigned int m_lastRun
 
int m_lastLowStatInterval
 
int m_lastMedStatInterval
 
int m_lastHigStatInterval
 
unsigned int m_nEvents
 
unsigned int m_nEventsIgnoreTrigger
 
unsigned int m_nLumiBlocks
 
bool m_haveClearedLastEventBlock
 

Private Types

enum  GasType { Xe = 0, Ar = 1, Kr = 2 }
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode bookTRTRDOs (bool isNewLumiBlock, bool isNewRun)
 
StatusCode bookTRTTracks (bool isNewLumiBlock, bool isNewRun)
 
StatusCode bookTRTShiftTracks (bool isNewLumiBlock, bool isNewRun)
 
StatusCode bookTRTEfficiency (bool isNewLumiBlock, bool isNewRun)
 
StatusCode checkEventBurst (const TRT_RDO_Container &rdoContainer)
 
StatusCode fillTRTRDOs (const TRT_RDO_Container &rdoContainer, const xAOD::EventInfo &eventInfo, const InDetTimeCollection *trtBCIDCollection)
 
StatusCode fillTRTTracks (const TrackCollection &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject)
 
StatusCode fillTRTEfficiency (const TrackCollection &combTrackCollection)
 
StatusCode fillTRTHighThreshold (const TrackCollection &trackCollection, const xAOD::EventInfo &eventInfo)
 
StatusCode checkTRTReadoutIntegrity (const xAOD::EventInfo &eventInfo)
 
int strawNumber (int strawNumber, int strawlayerNumber, int LayerNumber)
 
TH1F_LW * bookTH1F_LW (MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
 
TH2F_LW * bookTH2F_LW (MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int xbins, double lowxbins, double highxbins, int ybins, double lowybins, double highybins, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
 
TProfile_LW * bookTProfile_LW (MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
 
TProfile * bookTProfile (MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
 
TH1D_LW * bookTH1D_LW (MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
 
template<typename T >
StatusCode trtRegHist (T *hist, MonGroup &mongrp, const char *hName)
 
void scale_LWHistWithScaleVector (LWHist1D *hist, const std::vector< float > &scale)
 
int initScaleVectors ()
 
int strawNumberEndCap (int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side)
 
GasType Straw_Gastype (int stat)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static int strawLayerNumber (int strawLayerNumber, int LayerNumber)
 
static int chipToBoard (int chip)
 
static int chipToBoard_EndCap (int chip)
 
static float radToDegrees (float radValue)
 
static int strawNumber_reverse (int inp_strawnumber, int *strawNumber, int *strawlayerNumber, int *LayerNumber)
 
static int strawLayerNumber_reverse (int strawLayerNumInp, int *strawLayerNumber, int *LayerNumber)
 
static void scale_LWHist (LWHist1D *hist, float scale)
 
static void divide_LWHist (TH1F_LW *result, TH1F_LW *a, TH1F_LW *b)
 

Private Attributes

int m_lastTRTLumiBlock
 
int m_evtLumiBlock
 
int m_good_bcid
 
int m_nTotalTracks
 
int m_nTracksB [2] {}
 
int m_nTracksEC [2] {}
 
int m_nTracksEC_B [2] {}
 
std::vector< unsigned int > m_rodMap
 
bool m_passEventBurst
 
bool m_ArgonXenonSplitter
 
const AtlasDetectorID * m_idHelper
 
ServiceHandle< IToolSvc > p_toolSvc
 
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
 
ServiceHandle< ITRT_DAQ_ConditionsSvc > m_DAQSvc
 
ServiceHandle< ITRT_ConditionsSvc > m_condSvc_BS
 
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
 
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool
 
SG::ReadHandleKey< TRT_RDO_Container > m_rdoContainerKey {this, "TRTRawDataObjectName", "TRT_RDOs", "Name of TRT RDOs container"}
 
SG::ReadHandleKey< TrackCollection > m_trackCollectionKey {this, "TRTTracksObjectName", "Tracks", "Name of tracks container"}
 
SG::ReadHandleKey< TrackCollection > m_combTrackCollectionKey {this, "track_collection_hole_finder", "CombinedInDetTracks", "Name of tracks container used for hole finder"}
 
SG::ReadHandleKey< xAOD::EventInfo > m_xAODEventInfoKey {this, "xAODEventInfo", "EventInfo", "Name of EventInfo object"}
 
SG::ReadHandleKey< InDetTimeCollection > m_TRT_BCIDCollectionKey {this, "TRTBCIDCollectionName", "TRT_BCID", "Name of TRT BCID collection"}
 
SG::ReadHandleKey< ComTime > m_comTimeObjectKey {this, "ComTimeObjectName", "TRT_Phase", "Name of ComTime object"}
 
SG::ReadHandleKey< xAOD::TrigDecision > m_trigDecisionKey {this, "TrigDecisionObjectName", "xTrigDecision", "Name of trigger decision object"}
 
SG::ReadHandleKey< TRT_BSErrContainer > m_bsErrContKey {this,"ByteStreamErrors","TRT_ByteStreamErrs","SG key of TRT ByteStream Error container"}
 
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool {this, "TrkSummaryTool", "Trk::TrackSummaryTool/InDetTrackSummaryTool", "Track summary tool name"}
 
ToolHandle< Trk::ITrackHoleSearchTool > m_trt_hole_finder {this, "trt_hole_search", "TRTTrackHoleSearchTool", "Track hole search tool name"}
 
ToolHandle< ITRT_DriftFunctionTool > m_drifttool
 
const TRT_ID * m_pTRTHelper
 
const InDetDD::TRT_DetectorManager * m_mgr
 
std::string m_geo_summary_provider
 
std::string m_mapPath
 
TH1F_LW * m_hSummary
 
TProfile * m_hChipBSErrorsVsLB [2][2] {}
 
TProfile * m_hRobBSErrorsVsLB [2][2] {}
 
TProfile_LW * m_hAvgHLOcc_side [2][2] {}
 
TProfile_LW * m_hAvgLLOcc_side [2][2] {}
 
TH1F_LW * m_hNumTrksDetPhi_B
 
TProfile_LW * m_hNumHoTDetPhi_B
 
TProfile_LW * m_hAvgTroTDetPhi_B
 
TProfile_LW * m_hAvgTroTDetPhi_B_Ar
 
TH1F_LW * m_hNumSwLLWoT_B
 
TProfile_LW * m_hStrawEffDetPhi_B
 
TH1F_LW * m_hHitWMap_B
 
TH1F_LW * m_hHitWonTMap_B
 
TH1F_LW * m_Pull_Biased_Barrel
 
TH1F_LW * m_hResidual_B
 
TH1F_LW * m_hResidual_B_20GeV
 
TH1F_LW * m_hTimeResidual_B
 
TH1F_LW * m_hDriftTimeonTrkDist_B
 
TH1F_LW * m_hTronTDist_B
 
TH2F_LW * m_hrtRelation_B
 
TH1F_LW * m_hHLhitOnTrack_B
 
TH1F_LW * m_hHtoLRatioOnTrack_B
 
TH1F_LW * m_hHtoLRatioOnTrack_B_Ar
 
TH1F_LW * m_hHtoLRatioOnTrack_B_Xe
 
TH1F_LW * m_hWireToTrkPosition_B
 
TH1F_LW * m_hWireToTrkPosition_B_Ar
 
TH1F_LW * m_hResVsDetPhi_B
 
TProfile * m_hNHitsperLB_B
 
TProfile * m_hNTrksperLB_B
 
TProfile * m_hNHLHitsperLB_B
 
TH1F_LW * m_hDriftTimeonTrkDist_B_Ar
 
TH1F_LW * m_hTronTDist_B_Ar
 
TH1F_LW * m_hHitWMap_B_Ar
 
TH1F_LW * m_hResidual_B_Ar
 
TH1F_LW * m_hResidual_B_Ar_20GeV
 
TH1F_LW * m_hTimeResidual_B_Ar
 
TH2F_LW * m_hrtRelation_B_Ar
 
TH1F_LW * m_hNumTrksDetPhi_E [2] {}
 
TProfile_LW * m_hNumHoTDetPhi_E [2] {}
 
TProfile_LW * m_hAvgTroTDetPhi_E [2] {}
 
TProfile_LW * m_hAvgTroTDetPhi_E_Ar [2] {}
 
TH1F_LW * m_hNumSwLLWoT_E [2] {}
 
TProfile_LW * m_hStrawEffDetPhi_E [2] {}
 
TH1F_LW * m_hHitWMap_E [2] {}
 
TH1F_LW * m_hHitWonTMap_E [2] {}
 
TH1F_LW * m_Pull_Biased_EndCap
 
TH1F_LW * m_hResidual_E [2] {}
 
TH1F_LW * m_hResidual_E_20GeV [2] {}
 
TH1F_LW * m_hTimeResidual_E [2] {}
 
TH1F_LW * m_hDriftTimeonTrkDist_E [2] {}
 
TH1F_LW * m_hTronTDist_E [2] {}
 
TH2F_LW * m_hrtRelation_E [2] {}
 
TH1F_LW * m_hHLhitOnTrack_E [2] {}
 
TH1F_LW * m_hHtoLRatioOnTrack_E [2] {}
 
TH1F_LW * m_hHtoLRatioOnTrack_E_Ar [2] {}
 
TH1F_LW * m_hHtoLRatioOnTrack_E_Xe [2] {}
 
TH1F_LW * m_hWireToTrkPosition_E [2] {}
 
TH1F_LW * m_hWireToTrkPosition_E_Ar [2] {}
 
TH1F_LW * m_hResVsDetPhi_E [2] {}
 
TProfile * m_hNHitsperLB_E [2] {}
 
TProfile * m_hNTrksperLB_E [2] {}
 
TProfile * m_hNHLHitsperLB_E [2] {}
 
TH1F_LW * m_hTronTDist_E_Ar [2] {}
 
TH1F_LW * m_hDriftTimeonTrkDist_E_Ar [2] {}
 
TH1F_LW * m_hHitWMap_E_Ar [2] {}
 
TH1F_LW * m_hResidual_E_Ar [2] {}
 
TH1F_LW * m_hResidual_E_Ar_20GeV [2] {}
 
TH1F_LW * m_hTimeResidual_E_Ar [2] {}
 
TH2F_LW * m_hrtRelation_E_Ar [2] {}
 
TProfile_LW * m_hStrawsEff [2][64] {}
 
TProfile_LW * m_hEvtPhaseDetPhi_B
 
TProfile_LW * m_hEvtPhaseDetPhi_E [2] {}
 
TH1F_LW * m_hEvtPhase
 
TH2F_LW * m_hEvtPhaseVsTrig
 
TProfile_LW * m_hChipsEff [2][64] {}
 
TH1F_LW * m_hHitOnTrackVsAllS [2][64] {}
 
TH1F_LW * m_hHitOnTrackVsAllC [2][64] {}
 
TH1F_LW * m_hHitWMapS [2][64] {}
 Leading Edge in time Window: Straws. More...
 
TProfile_LW * m_hHitTrWMapS [2][64] {}
 TE in Time Window: Straws. More...
 
TProfile_LW * m_hHitTrMapS [2][64] {}
 Mean TE: Straws. More...
 
TH1F_LW * m_hHitAMapS [2][64] {}
 Any LL bit on: Straws if any low threshold bit was set. More...
 
TH1F_LW * m_hHitAWMapS [2][64] {}
 LL in time window: Straws Any low level hit in time window by straw. More...
 
TH1F_LW * m_hHtoLMapS [2][64] {}
 HL/LL: Straws The ratio of High Level hits to Low Level hits per straw. More...
 
TProfile_LW * m_hHitToTMapS [2][64] {}
 Mean ToT (ns): Straws. More...
 
TProfile_LW * m_hHitToTLongMapS [2][64] {}
 Mean ToT (ns) for straws with ToT > LongToTCut: Straws. More...
 
TProfile_LW * m_hHitToTLongTrMapS [2][64] {}
 Mean Trailing Edge (ns) for straws with ToT > LongToTCut: Straws. More...
 
TH1F_LW * m_hHitHMapS [2][64] {}
 High Level: Straws If a hit has any of the high threshold time bins up. More...
 
TH1F_LW * m_hHitHWMapS [2][64] {}
 HL in time window: Straws If a hit has any of the high threshold time bins up, and is in the time window. More...
 
TH1F_LW * m_hHitWonTMapS [2][64] {}
 LE in time window on track: Straws. More...
 
TProfile_LW * m_hHitTronTMapS [2][64] {}
 Mean TE on track: Straws Average Trailing Edge(TE) from a hit associated with a track. More...
 
TH1F_LW * m_hHitAonTMapS [2][64] {}
 Any LL bit on track: Straws Any low level bit is set from hit associated with a track. More...
 
TH1F_LW * m_hHitAWonTMapS [2][64] {}
 Any LL bit in time window on track: Straws Any low level (LL) bit set and is in time window from hits associated with tracks This is a track level histogram. More...
 
TH1F_LW * m_hHitHWonTMapS [2][64] {}
 Any HL hit on track: Straws Any straw with a High Threshold (HL) hit associated with a track. More...
 
TH1F_LW * m_hHitHonTMapS [2][64] {}
 
TH1F_LW * m_hHtoLonTMapS [2][64] {}
 HL in time window on track: Straws Straws with a High Threshold hit associated with a track and the hit is in the time window. More...
 
TH1F_LW * m_hHtoLWonTMapS [2][64] {}
 
TProfile_LW * m_hHitToTonTMapS [2][64] {}
 Mean ToT (ns) on Track: Straws Average Time over Threshold (ToT) from a straw hit associated with a track. More...
 
TProfile_LW * m_hHitTronTwEPCMapS [2][64] {}
 Mean TE on track (with Event Phase correction): Straws. More...
 
TProfile_LW * m_hValidRawDriftTimeonTrk [2][64] {}
 Valid Raw Drift Time on Track. More...
 
TProfile_LW * m_hValidRawDriftTimeonTrkC [2][64] {}
 
TH1F_LW * m_hHitWMapC [2][64] {}
 
TProfile_LW * m_hHitTrMapC [2][64] {}
 
TProfile_LW * m_hHitTrWMapC [2][64] {}
 
TH1F_LW * m_hHitAMapC [2][64] {}
 
TH1F_LW * m_hHitAWMapC [2][64] {}
 
TH1F_LW * m_hHtoLMapC [2][64] {}
 
TH2F_LW * m_hHtoBCMapC [2][64] {}
 
TH2F_LW * m_hHtoBCMapB [2][64] {}
 
TProfile_LW * m_hHitToTMapC [2][64] {}
 
TH1F_LW * m_hHitHMapC [2][64] {}
 
TH1F_LW * m_hHitHWMapC [2][64] {}
 
TH1F_LW * m_hHitWonTMapC [2][64] {}
 LE in time window on track: Chips. More...
 
TProfile_LW * m_hHitTronTMapC [2][64] {}
 
TH1F_LW * m_hHitAonTMapC [2][64] {}
 
TH1F_LW * m_hHitAWonTMapC [2][64] {}
 
TH1F_LW * m_hHitHonTMapC [2][64] {}
 
TH1F_LW * m_hHitHWonTMapC [2][64] {}
 
TH1F_LW * m_hHtoLonTMapC [2][64] {}
 
TH1F_LW * m_hHtoLWonTMapC [2][64] {}
 
TProfile_LW * m_hHitToTonTMapC [2][64] {}
 
TProfile_LW * m_hHitTronTwEPCMapC [2][64] {}
 
TProfile_LW * m_hHitToTrkDistanceMapS_E [64] {}
 
TProfile_LW * m_hAvgLLOccMod_side [2][2] {}
 Avg. More...
 
TProfile_LW * m_hAvgHLOccMod_side [2][2] {}
 
TProfile_LW * m_hBCIDvsOcc [2] {}
 
TH1F_LW * m_hChipOcc [2][64] {}
 Avg. More...
 
TH1F_LW * m_hStrawOcc [2][64] {}
 
TH2F_LW * m_hHitsOnTrack_Scatter [2] {}
 Anatoli's "Scatter histograms" ** Monitor quantities as a function of lumi block. More...
 
TH2F_LW * m_hLLOcc_Scatter [2] {}
 
TH2F_LW * m_hHightoLowRatioOnTrack_Scatter [2] {}
 
TH1F_LW * m_hOccAll
 
std::vector< float > m_scale_hHitWMap_B
 
std::vector< float > m_scale_hHitWMap_B_Ar
 
float m_LLOcc [2][64] {}
 
TH1F_LW * m_trackz_All [5][2] {}
 Initialize Aging plots** HT, All, Barrel, EC, In/A, Out/C, etc... More...
 
TH1F_LW * m_trackz_HT [5][2] {}
 
TH1F_LW * m_trackr_All [4][2] {}
 
TH1F_LW * m_trackr_HT [4][2] {}
 
TH1F_LW * m_IntLum
 
TH1F_LW * m_LBvsLum
 
TH1F_LW * m_LBvsTime
 
float m_HTfraconTrack_B [32]
 
float m_LonTrack_B [32]
 
int m_nTrack_B [32]
 
float m_HTfraconTrack_E [64]
 
float m_LonTrack_E [64]
 
int m_nTrack_E [64]
 
bool m_doRDOsMon
 
bool m_doGeoMon
 
bool m_doTracksMon
 
int m_usedEvents
 
int m_nTRTHits [2]
 
int m_totalEvents
 
bool m_doDCS
 
bool m_doASide
 
bool m_doCSide
 
bool m_doStraws
 
bool m_doChips
 
bool m_doShift
 
bool m_doExpert
 
bool m_doMaskStraws
 
bool m_doEfficiency
 
bool m_doDiagnostic
 
bool m_useHoleFinder
 
int m_LE_timeWindow_MIN
 
int m_LE_timeWindow_MAX
 
int m_LL_timeWindow_MIN
 
int m_LL_timeWindow_MAX
 
int m_HL_timeWindow_MIN
 
int m_HL_timeWindow_MAX
 
bool m_NoiseSuppressionLevel_30pc
 
int m_MIN_N_LL_Hits
 
int m_MIN_TOT_Hits
 
bool m_NoiseSuppressionMap
 
float m_EventPhaseScale
 
unsigned char m_mat_chip_B [64][1642] {}
 
int m_nStrawHits_B [1642]
 
unsigned char m_mat_chip_E [64][3840] {}
 
int m_nStrawHits_E [2][3840]
 
float m_DriftTimeonTrkDistScale_B
 
float m_HLhitOnTrackScale_B
 
float m_HtoLRatioOnTrackScale_B
 
float m_HtoLRatioOnTrackScale_B_Ar
 
float m_HtoLRatioOnTrackScale_B_Xe
 
float m_NumSwLLWoTScale_B
 
float m_WireToTrkPositionScale_B
 
float m_WireToTrkPositionScale_B_Ar
 
float m_TronTDistScale_B
 
float m_ResidualScale_B
 
float m_ResidualScale_B_20GeV
 
float m_TimeResidualScale_B
 
float m_DriftTimeonTrkDistScale_B_Ar
 
float m_TronTDistScale_B_Ar
 
float m_ResidualScale_B_Ar
 
float m_ResidualScale_B_Ar_20GeV
 
float m_TimeResidualScale_B_Ar
 
int m_nTrksperLB_B
 
int m_nHitsperLB_B
 
int m_nHLHitsperLB_B
 
float m_DriftTimeonTrkDistScale_E [2]
 
float m_HLhitOnTrackScale_E [2]
 
float m_HtoLRatioOnTrackScale_E [2]
 
float m_HtoLRatioOnTrackScale_E_Ar [2]
 
float m_HtoLRatioOnTrackScale_E_Xe [2]
 
float m_NumSwLLWoTScale_E [2]
 
float m_WireToTrkPositionScale_E [2]
 
float m_WireToTrkPositionScale_E_Ar [2]
 
float m_TronTDistScale_E [2]
 
float m_ResidualScale_E [2]
 
float m_ResidualScale_E_20GeV [2]
 
float m_TimeResidualScale_E [2]
 
float m_DriftTimeonTrkDistScale_E_Ar [2]
 
float m_TronTDistScale_E_Ar [2] {}
 
float m_ResidualScale_E_Ar [2]
 
float m_ResidualScale_E_Ar_20GeV [2]
 
float m_TimeResidualScale_E_Ar [2]
 
int m_nTrksperLB_E [2] {}
 
int m_nHitsperLB_E [2] {}
 
int m_nHLHitsperLB_E [2] {}
 
float m_maxDistToStraw
 
float m_DistToStraw
 
bool m_trt_only_trks
 
bool m_zero_field
 
bool m_DEBUG
 
bool m_printEventInfo = false
 
float m_longToTCut
 
int m_nphi_bins
 
int m_EventBurstCut
 
int m_lumiBlocksToResetOcc
 
bool m_isCosmics
 
int m_minTRThits
 
float m_minP
 
int m_flagforscale
 
std::string m_track_collection_hole_finder
 
float m_max_abs_d0
 
float m_max_abs_z0
 
float m_min_pT
 
float m_max_abs_eta
 
int m_min_si_hits
 
int m_min_pixel_hits
 
int m_min_sct_hits
 
int m_min_trt_hits
 
float m_track_pt
 
float m_track_eta
 
float m_track_phi
 
float m_track_d0
 
float m_track_z0
 
int m_min_tracks_straw
 
int m_every_xth_track
 
std::string m_datatype
 
std::atomic< int > m_maxtimestamp {0}
 
TProfile_LW * m_hefficiency_eta
 
TProfile_LW * m_hefficiency_phi
 
TProfile_LW * m_hefficiency_pt
 
TProfile_LW * m_hefficiency_z0
 
TProfile_LW * m_hefficiencyBarrel_locR
 
TProfile_LW * m_hefficiencyBarrel_locR_Ar
 
TProfile_LW * m_hefficiencyEndCap_locR [2] {}
 
TProfile_LW * m_hefficiencyEndCap_locR_Ar [2] {}
 
TProfile_LW * m_hefficiencyMap [2] {}
 
TProfile_LW * m_hefficiencyS [2][64] {}
 
TProfile_LW * m_hefficiencyC [2][64] {}
 
TH1F_LW * m_hefficiency [2][2] {}
 
TH1F_LW * m_hefficiencyIntegral [2][2] {}
 
bool m_newLowStatInterval
 
bool m_newMedStatInterval
 
bool m_newHigStatInterval
 
bool m_newLowStat
 
bool m_newLumiBlock
 
bool m_newRun
 
bool m_newEventsBlock
 
bool m_endOfEventsBlock
 
bool m_endOfLowStat
 
bool m_endOfLumiBlock
 
bool m_endOfRun
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
 
bool m_bookHistogramsInitial
 
bool m_useLumi
 
float m_defaultLBDuration
 
std::set< Interval_t > m_supportedIntervalsForRebooking
 
Imp * m_d
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static const int s_numberOfBarrelStacks = 32
 
static const int s_numberOfEndCapStacks = 32
 
static const int s_Straw_max [2] = {1642, 3840}
 
static const int s_iStack_max [2] = {32, 64}
 
static const int s_iChip_max [2] = {104, 240}
 
static const int s_numberOfStacks [2] = {32, 32}
 
static const int s_moduleNum [2] = {96, 64}
 

Detailed Description

Definition at line 65 of file TRT_Monitoring_Tool.h.

Member Typedef Documentation

◆ MDMap_t

typedef std::map<std::string,OutputMetadata*> ManagedMonitorToolBase::MDMap_t
protectedinherited

Definition at line 888 of file ManagedMonitorToolBase.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ GasType

enum TRT_Monitoring_Tool::GasType
private
Enumerator
Xe 
Ar 
Kr 

Definition at line 85 of file TRT_Monitoring_Tool.h.

85 { Xe = 0, Ar = 1, Kr = 2 };

◆ Interval_t

enum ManagedMonitorToolBase::Interval_t
inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

expert: essential for diagnosing problems identified by shift-level objects

debug: useful for standalone debugging, but not for routine monitoring; not essential for diagnosing problems during normal running

transient: too detailed to ever be written; always summarized by the user by means of another object An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). This information may be stored with the monitoring object if an application is only able to partially fill the object (i.e., a job sees only part of a run or fill). This information may be ignored in some running Environments. The 'fill' interval corresponds to a fill of the LHC. The 'all' interval corresponds to all available data. The 'lumiBlock' and 'fill' intervals are only valid for the 'collisions' DataType_t.

Enumerator
file 
eventsBlock 
lumiBlock 
lowStat 
medStat 
higStat 
run 
fill 
all 

Definition at line 114 of file ManagedMonitorToolBase.h.

114  { file = 0, eventsBlock, lumiBlock,
115  lowStat, medStat, higStat,
116  run, fill, all };

◆ MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t
inherited

An enumeration describing how the class handles the histogram.

attrib_unmanaged: histograms with this attribute will not be rebooked automatically and must be managed by the user code.

attrib_x_is_lb: indicates that the x-axis of the histogram is the luminosity block number and that the histogram should be rebooked as necessary if the current LB exceeds the range.

Enumerator
ATTRIB_MANAGED 
ATTRIB_UNMANAGED 
ATTRIB_X_VS_LB 

Definition at line 131 of file ManagedMonitorToolBase.h.

131 { ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2};

Constructor & Destructor Documentation

◆ TRT_Monitoring_Tool()

TRT_Monitoring_Tool::TRT_Monitoring_Tool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 55 of file TRT_Monitoring_Tool.cxx.

55  :
56  ManagedMonitorToolBase(type, name, parent),
57  m_lastTRTLumiBlock(-99),
58  m_evtLumiBlock(0),
59  m_good_bcid(0),
60  m_nTotalTracks(0),
61  m_passEventBurst(),
62  m_idHelper(nullptr),
63  p_toolSvc("IToolSvc", name),
64  m_sumTool("TRT_StrawStatusSummaryTool", this),
65  m_DAQSvc("TRT_DAQ_ConditionsSvc", name), // NOTE: not used anywhere?
66  m_condSvc_BS("TRT_ByteStream_ConditionsSvc", name), // NOTE: not used anywhere?
67  m_TRTStrawNeighbourSvc("TRT_StrawNeighbourSvc", name),
68  m_TRTCalDbTool("TRT_CalDbTool", this),
69  m_drifttool("TRT_DriftFunctionTool"),
70  m_pTRTHelper(nullptr),
71  m_mgr(nullptr),
72  m_HTfraconTrack_B(),
73  m_LonTrack_B(),
74  m_nTrack_B(),
75  m_HTfraconTrack_E(),
76  m_LonTrack_E(),
77  m_nTrack_E(),
78  m_nTRTHits(),
79  m_doDCS(false),
80  m_EventPhaseScale(1.0),
81  m_nStrawHits_B(),
82  m_nStrawHits_E(),
83  m_DriftTimeonTrkDistScale_B(),
84  m_HLhitOnTrackScale_B(),
85  m_HtoLRatioOnTrackScale_B(),
86  m_HtoLRatioOnTrackScale_B_Ar(),
87  m_HtoLRatioOnTrackScale_B_Xe(),
88  m_NumSwLLWoTScale_B(),
89  m_WireToTrkPositionScale_B(),
90  m_WireToTrkPositionScale_B_Ar(),
91  m_TronTDistScale_B(),
92  m_ResidualScale_B(),
93  m_ResidualScale_B_20GeV(),
94  m_TimeResidualScale_B(),
95  m_DriftTimeonTrkDistScale_B_Ar(),
96  m_TronTDistScale_B_Ar(),
97  m_ResidualScale_B_Ar(),
98  m_ResidualScale_B_Ar_20GeV(),
99  m_TimeResidualScale_B_Ar(),
100  m_DriftTimeonTrkDistScale_E(),
101  m_HLhitOnTrackScale_E(),
102  m_HtoLRatioOnTrackScale_E(),
103  m_HtoLRatioOnTrackScale_E_Ar(),
104  m_HtoLRatioOnTrackScale_E_Xe(),
105  m_NumSwLLWoTScale_E(),
106  m_WireToTrkPositionScale_E(),
107  m_WireToTrkPositionScale_E_Ar(),
108  m_TronTDistScale_E(),
109  m_ResidualScale_E(),
110  m_ResidualScale_E_20GeV(),
111  m_TimeResidualScale_E(),
112  m_DriftTimeonTrkDistScale_E_Ar(),
113  m_ResidualScale_E_Ar(),
114  m_ResidualScale_E_Ar_20GeV(),
115  m_TimeResidualScale_E_Ar(),
116  m_DEBUG(false),
117  m_longToTCut(9.375),
118  m_EventBurstCut(200),
119  m_lumiBlocksToResetOcc(20),
120  m_isCosmics(false),
121  m_minTRThits(10),
122  m_minP(0),
123  m_track_pt(0),
124  m_track_eta(0),
125  m_track_phi(0),
126  m_track_d0(0),
127  m_track_z0(0),
128  m_min_tracks_straw(10)
129 //-----------------------------------------------------------------------------------------------//
130 // NOTE: check up on obsolete properties
131 {
132  declareProperty("ToolSvc", p_toolSvc);
133  declareProperty("InDetTRTStrawStatusSummaryTool", m_sumTool);
134  declareProperty("InDetTRT_DAQ_ConditionsSvc", m_DAQSvc);
135  declareProperty("TRT_StrawNeighbourSvc", m_TRTStrawNeighbourSvc);
136  declareProperty("DriftFunctionTool", m_drifttool);
137  declareProperty("DoTRT_DCS", m_doDCS);
138  declareProperty("DoRDOsMon", m_doRDOsMon = true);
139  declareProperty("DoGeoMon", m_doGeoMon = false);//obsolete
140  declareProperty("NumberOfEvents", m_usedEvents = -1);
141  declareProperty("DoTracksMon", m_doTracksMon = true);
142  declareProperty("doAside", m_doASide = true);//obsolete
143  declareProperty("doCside", m_doCSide = true);//obsolete
144  declareProperty("doStraws", m_doStraws = true);
145  declareProperty("doChips", m_doChips = false);
146  declareProperty("doExpert", m_doExpert = false);
147  declareProperty("doEfficiency", m_doEfficiency = true);
148  declareProperty("doMaskStraws", m_doMaskStraws = true);
149  declareProperty("doShift", m_doShift = true);
150  declareProperty("doDiagnostic", m_doDiagnostic = false);//obsolete
151  declareProperty("DistanceToStraw", m_DistToStraw = 0.4);
152  declareProperty("Geo_Summary_Provider", m_geo_summary_provider);//probably obsolete
153  declareProperty("Map_Path", m_mapPath); // obsolete
154  declareProperty("maxDistToStraw", m_maxDistToStraw = 2.0);//obsolete
155  declareProperty("is_TRT_only_tracks", m_trt_only_trks = true);//obsolete
156  declareProperty("is_zero_mag_field", m_zero_field = true);//obsolete
157  //
158  // Tunable parameters for TRT monitoring histograms
159  //
160  declareProperty("LE_TimeWindow_MIN", m_LE_timeWindow_MIN = 0);//obsolete
161  declareProperty("LE_TimeWindow_MAX", m_LE_timeWindow_MAX = 24);//obsolete
162  declareProperty("LL_TimeWindow_MIN", m_LL_timeWindow_MIN = 0);//obsolete
163  declareProperty("LL_TimeWindow_MAX", m_LL_timeWindow_MAX = 24);//obsolete
164  declareProperty("HL_TimeWindow_MIN", m_HL_timeWindow_MIN = 0);//obsolete
165  declareProperty("HL_TimeWindow_MAX", m_HL_timeWindow_MAX = 3);//obsolete
166  declareProperty("MIN_N_LL_Hits", m_MIN_N_LL_Hits = 10);//obsolete
167  declareProperty("MIN_TOT_Hits", m_MIN_TOT_Hits = 2);//obsolete
168  declareProperty("NoiseSuppressionLevel_30pc", m_NoiseSuppressionLevel_30pc = false);//obsolete
169  declareProperty("NoiseSuppressionMap", m_NoiseSuppressionMap = false);//obsolete
170  declareProperty("Debug", m_DEBUG);//obsolete
171  declareProperty("PrintEventInfo", m_printEventInfo);//obsolete
172  declareProperty("ITRT_CalDbTool", m_TRTCalDbTool);
173  declareProperty("LongToTCut", m_longToTCut);
174  declareProperty("NPhiBins", m_nphi_bins = 360);
175  declareProperty("EventBurstCut", m_EventBurstCut = 200);
176  declareProperty("LumiBlocksToResetOcc", m_lumiBlocksToResetOcc = 20);
177  declareProperty("IsCosmics", m_isCosmics = false);
178  declareProperty("MinTRTHitCut", m_minTRThits = 10);
179  declareProperty("useHoleFinder", m_useHoleFinder = true);
180  declareProperty("max_abs_d0", m_max_abs_d0 = 10 * CLHEP::mm);
181  declareProperty("max_abs_z0", m_max_abs_z0 = 300 * CLHEP::mm);
182  declareProperty("max_abs_eta", m_max_abs_eta = 2.5);
183  declareProperty("MinTrackP", m_minP = 0.0 * CLHEP::GeV);
184  declareProperty("min_pT", m_min_pT = 0.5 * CLHEP::GeV);
185  declareProperty("min_si_hits", m_min_si_hits = 1);
186  declareProperty("min_pixel_hits", m_min_pixel_hits = 0);
187  declareProperty("min_sct_hits", m_min_sct_hits = 0);
188  declareProperty("min_trt_hits", m_min_trt_hits = 10);
189  declareProperty("min_tracks_straw", m_min_tracks_straw = 10);
190  declareProperty("every_xth_track", m_every_xth_track = 25);
191  declareProperty("whatdatatype", m_datatype);//obsolete
192  declareProperty("doArgonXenonSeparation", m_ArgonXenonSplitter = true); // Argon Histograms won't be created if this is set to false.
193  m_flagforscale = 1; //Added for a fix
194  m_totalEvents = 0;
195  m_hSummary = nullptr;
196  m_IntLum = nullptr;//
197  m_LBvsLum = nullptr; // coverity 25098
198  m_LBvsTime = nullptr; //
199  m_hEvtPhaseDetPhi_B = nullptr;
200  m_hEvtPhase = nullptr;
201  m_hEvtPhaseVsTrig = nullptr;
202  m_hOccAll = nullptr;
203  m_hefficiency_eta = nullptr;
204  m_hefficiency_phi = nullptr;
205  m_hefficiency_pt = nullptr;
206  m_hefficiency_z0 = nullptr;
207 
208  for (int iside = 0; iside < 2; iside++) { // A-side(iside=0), C-side(iside=1)
209  m_nTracksB[iside] = 0;
210  m_nTracksEC[iside] = 0;
211  m_nTracksEC_B[iside] = 0;
212  }
213 
214  for (int ibe = 0; ibe < 2; ibe++) {
215  m_hBCIDvsOcc[ibe] = nullptr;
216  m_hHitsOnTrack_Scatter[ibe] = nullptr;
217  m_hLLOcc_Scatter[ibe] = nullptr;
218  m_hHightoLowRatioOnTrack_Scatter[ibe] = nullptr;
219  m_hefficiencyMap[ibe] = nullptr;
220 
221  for (int iside = 0; iside < 2; iside++) {
222  m_hChipBSErrorsVsLB[ibe][iside] = nullptr;
223  m_hRobBSErrorsVsLB[ibe][iside] = nullptr;
224  m_hAvgHLOcc_side[ibe][iside] = nullptr;
225  m_hAvgLLOcc_side[ibe][iside] = nullptr;
226  m_hAvgLLOccMod_side[ibe][iside] = nullptr;
227  m_hAvgHLOccMod_side[ibe][iside] = nullptr;
228  m_hefficiency[ibe][iside] = nullptr;
229  m_hefficiencyIntegral[ibe][iside] = nullptr;
230  }// for (int iside=0; iside<2; iside++)
231 
232  for (int i = 0; i < 64; i++) {
233  m_hChipOcc[ibe][i] = nullptr;
234  m_hStrawOcc[ibe][i] = nullptr;
235  m_hStrawsEff[ibe][i] = nullptr;
236  m_hChipsEff[ibe][i] = nullptr;
237  m_hHitOnTrackVsAllS[ibe][i] = nullptr;
238  m_hHitOnTrackVsAllC[ibe][i] = nullptr;
239  m_hHitWMapS[ibe][i] = nullptr;
240  m_hHitTrWMapS[ibe][i] = nullptr;
241  m_hHitTrMapS[ibe][i] = nullptr;
242  m_hHitAMapS[ibe][i] = nullptr;
243  m_hHitAWMapS[ibe][i] = nullptr;
244  m_hHtoLMapS[ibe][i] = nullptr;
245  m_hHitToTMapS[ibe][i] = nullptr;
246  m_hHitToTLongMapS[ibe][i] = nullptr;
247  m_hHitToTLongTrMapS[ibe][i] = nullptr;
248  m_hHitHMapS[ibe][i] = nullptr;
249  m_hHitHWMapS[ibe][i] = nullptr;
250  m_hHitWonTMapS[ibe][i] = nullptr;
251  m_hHitTronTMapS[ibe][i] = nullptr;
252  m_hHitAonTMapS[ibe][i] = nullptr;
253  m_hHitAWonTMapS[ibe][i] = nullptr;
254  m_hHitHonTMapS[ibe][i] = nullptr;
255  m_hHitHWonTMapS[ibe][i] = nullptr;
256  m_hHtoLonTMapS[ibe][i] = nullptr;
257  m_hHtoLWonTMapS[ibe][i] = nullptr;
258  m_hHitToTonTMapS[ibe][i] = nullptr;
259  m_hHitTronTwEPCMapS[ibe][i] = nullptr;
260  m_hValidRawDriftTimeonTrk[ibe][i] = nullptr;
261  m_hValidRawDriftTimeonTrkC[ibe][i] = nullptr;
262  m_hHitWMapC[ibe][i] = nullptr;
263  m_hHitTrMapC[ibe][i] = nullptr;
264  m_hHitTrWMapC[ibe][i] = nullptr;
265  m_hHitAMapC[ibe][i] = nullptr;
266  m_hHitAWMapC[ibe][i] = nullptr;
267  m_hHtoLMapC[ibe][i] = nullptr;
268  m_hHtoBCMapC[ibe][i] = nullptr;
269  m_hHtoBCMapB[ibe][i] = nullptr;
270  m_hHitToTMapC[ibe][i] = nullptr;
271  m_hHitHMapC[ibe][i] = nullptr;
272  m_hHitHWMapC[ibe][i] = nullptr;
273  m_hHitWonTMapC[ibe][i] = nullptr;
274  m_hHitTronTMapC[ibe][i] = nullptr;
275  m_hHitAonTMapC[ibe][i] = nullptr;
276  m_hHitAWonTMapC[ibe][i] = nullptr;
277  m_hHitHonTMapC[ibe][i] = nullptr;
278  m_hHitHWonTMapC[ibe][i] = nullptr;
279  m_hHtoLonTMapC[ibe][i] = nullptr;
280  m_hHtoLWonTMapC[ibe][i] = nullptr;
281  m_hHitToTonTMapC[ibe][i] = nullptr;
282  m_hHitTronTwEPCMapC[ibe][i] = nullptr;
283  m_hefficiencyS[ibe][i] = nullptr;
284  m_hefficiencyC[ibe][i] = nullptr;
285 
286  if (ibe == 1) m_hHitToTrkDistanceMapS_E[i] = nullptr;
287  } //for (int i = 0; i < 64; i++)
288  } // for (int ibe=0; ibe<2; ibe++)
289 
290  m_nTrksperLB_B = 0;
291  m_nHitsperLB_B = 0;
292  m_nHLHitsperLB_B = 0;
293  m_hNumTrksDetPhi_B = nullptr;
294  m_hNumHoTDetPhi_B = nullptr;
295  m_hAvgTroTDetPhi_B = nullptr;
296  m_hAvgTroTDetPhi_B_Ar = nullptr;
297  m_hStrawEffDetPhi_B = nullptr;
298  m_hNumSwLLWoT_B = nullptr;
299  m_hHitWMap_B = nullptr;
300  m_hHitWonTMap_B = nullptr;
301  m_Pull_Biased_Barrel = nullptr;
302  m_hResidual_B = nullptr;
303  m_hResidual_B_20GeV = nullptr;
304  m_hTimeResidual_B = nullptr;
305  m_hDriftTimeonTrkDist_B = nullptr;
306  m_hTronTDist_B = nullptr;
307  m_hrtRelation_B = nullptr;
308  m_hHLhitOnTrack_B = nullptr;
309  m_hHtoLRatioOnTrack_B = nullptr;
310  m_hWireToTrkPosition_B = nullptr;
311  m_hWireToTrkPosition_B_Ar = nullptr;
312  m_hHtoLRatioOnTrack_B_Ar = nullptr;
313  m_hHtoLRatioOnTrack_B_Xe = nullptr;
314  m_hResVsDetPhi_B = nullptr;
315  m_hNHitsperLB_B = nullptr;
316  m_hNTrksperLB_B = nullptr;
317  m_hNHLHitsperLB_B = nullptr;
318  m_hefficiencyBarrel_locR = nullptr;
319  m_hefficiencyBarrel_locR_Ar = nullptr;
320  m_hHitWMap_B_Ar = nullptr;
321  m_hResidual_B_Ar = nullptr;
322  m_hResidual_B_Ar_20GeV = nullptr;
323  m_hTimeResidual_B_Ar = nullptr;
324  m_hrtRelation_B_Ar = nullptr;
325  m_hDriftTimeonTrkDist_B_Ar = nullptr;
326  m_hTronTDist_B_Ar = nullptr;
327  m_Pull_Biased_EndCap = nullptr;
328 
329  for (int iside = 0; iside < 2; iside++) {
330  m_nTrksperLB_E[iside] = 0;
331  m_nHitsperLB_E[iside] = 0;
332  m_nHLHitsperLB_E[iside] = 0;
333  m_hNumTrksDetPhi_E[iside] = nullptr;
334  m_hNumHoTDetPhi_E[iside] = nullptr;
335  m_hAvgTroTDetPhi_E[iside] = nullptr;
336  m_hAvgTroTDetPhi_E_Ar[iside] = nullptr;
337  m_hStrawEffDetPhi_E[iside] = nullptr;
338  m_hNumSwLLWoT_E[iside] = nullptr;
339  m_hEvtPhaseDetPhi_E[iside] = nullptr;
340  m_hHitWMap_E[iside] = nullptr;
341  m_hHitWonTMap_E[iside] = nullptr;
342  m_hResidual_E[iside] = nullptr;
343  m_hResidual_E_20GeV[iside] = nullptr;
344  m_hTimeResidual_E[iside] = nullptr;
345  m_hDriftTimeonTrkDist_E[iside] = nullptr;
346  m_hTronTDist_E[iside] = nullptr;
347  m_hrtRelation_E[iside] = nullptr;
348  m_hHLhitOnTrack_E[iside] = nullptr;
349  m_hHtoLRatioOnTrack_E[iside] = nullptr;
350  m_hHtoLRatioOnTrack_E_Ar[iside] = nullptr;
351  m_hHtoLRatioOnTrack_E_Xe[iside] = nullptr;
352  m_hWireToTrkPosition_E[iside] = nullptr;
353  m_hWireToTrkPosition_E_Ar[iside] = nullptr;
354  m_hResVsDetPhi_E[iside] = nullptr;
355  m_hNHitsperLB_E[iside] = nullptr;
356  m_hNTrksperLB_E[iside] = nullptr;
357  m_hNHLHitsperLB_E[iside] = nullptr;
358  m_hefficiencyEndCap_locR[iside] = nullptr;
359  m_hefficiencyEndCap_locR_Ar[iside] = nullptr;
360  m_hHitWMap_E_Ar[iside] = nullptr;
361  m_hResidual_E_Ar[iside] = nullptr;
362  m_hResidual_E_Ar_20GeV[iside] = nullptr;
363  m_hTimeResidual_E_Ar[iside] = nullptr;
364  m_hrtRelation_E_Ar[iside] = nullptr;
365  m_hTronTDist_E_Ar[iside] = nullptr;
366  m_hDriftTimeonTrkDist_E_Ar[iside] = nullptr;
367  }
368 }

◆ ~TRT_Monitoring_Tool()

TRT_Monitoring_Tool::~TRT_Monitoring_Tool ( )
virtual

Definition at line 371 of file TRT_Monitoring_Tool.cxx.

371 {}

Member Function Documentation

◆ bookHistograms()

StatusCode ManagedMonitorToolBase::bookHistograms ( )
virtualinherited

An inheriting class should either override this function or bookHists().

Reimplemented in SCTHitEffMonTool, SCTHitsNoiseMonTool, SCTErrMonTool, SCTTracksMonTool, SCTLorentzMonTool, photonMonTool, egammaMonToolBase, electronMonTool, MuonPhysValMonitoring::MuonPhysValMonitoringTool, LArCellMonTool, AFPHitsMonitorTool, MuonDQA::MuonEventInfoMonTool, DQTDataFlowMonTool, TileCalCellMonTool, ActsTrk::PhysValTool, PhysValSecVtx, LUCID_HitsMoniTool, ZeeTaPMonTool, forwardElectronMonTool, DQTNonCollBkg_ZDC, TRT_Electron_Monitoring_Tool, InDetGlobalTrackMonTool, CscCalibMonToolBase, JetTagMonitoring, InDetPhysValMonitoringTool, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, InDetGlobalSynchMonTool, MissingEtDQA::PhysValMET, CaloTowerVecMon, JetTagDQA::PhysValBTag, CscCalibMonToolSlope, METMonTool, DQTGlobalWZFinderTool, CSCSegmValAlg, PhysVal::PhysValExample, TopPhysVal::TopPhysValMonitoring, DataQualityFatherMonTool, CscCalibMonToolPed, ZeeValidation::ZeeValidationMonitoringTool, CaloClusterVecMon, CaloTransverseBalanceVecMon, DQTDetSynchMonTool, InDetTrackPerfMonTool, IDPerfMonWenu, IDPerfMonZee, TrackCaloClusterRecValidationTool, DQTMuonIDTrackTool, InDetGlobalPixelTool, JetMonitoringTool, TileCellNoiseMonTool, CscClusterValAlg, PhysValTau, PhysValFE, AFPTechnicalMonitorTool, ManagedMonitorToolTest, DiMuMon, InDetVertexMonitoring, CscPrdValAlg, CscRdoValAlg, HIMonitoringEventShapeTool, IDPerfMonKshort, HIMonitoringZdcTool, HIMonitoringElectronsTool, HIMonitoringPhotonsTool, PhysValCluster, and HIMonitoringMuonsTool.

Definition at line 1406 of file ManagedMonitorToolBase.cxx.

1408 {
1409 
1410  return StatusCode::SUCCESS;
1411 }

◆ bookHistogramsRecurrent()

StatusCode TRT_Monitoring_Tool::bookHistogramsRecurrent ( )
virtual

An inheriting class should either override this function, bookHists() or bookHistograms().

Reimplemented from ManagedMonitorToolBase.

Definition at line 590 of file TRT_Monitoring_Tool.cxx.

590  {
591 //------------------------------------------------------------------------------------//
592  ATH_MSG_VERBOSE("Booking TRT histograms");
593 
594  if (newLumiBlockFlag()) ATH_MSG_VERBOSE("newLumiBlock");
595 
596  if (newRunFlag()) ATH_MSG_VERBOSE("newRun");
597 
598  StatusCode sc = StatusCode::SUCCESS;
599 
600  //If it is a new run check rdo and track containers.
601  if (newRunFlag()) {
602  SG::ReadHandle<TRT_RDO_Container> rdoContainer(m_rdoContainerKey);
603  SG::ReadHandle<TrackCollection> trackCollection(m_trackCollectionKey);
604 
605  if (!rdoContainer.isValid()) {
606  ATH_MSG_WARNING("No TRT_RDO_Container by the name of " <<
607  m_rdoContainerKey.key() << " in StoreGate. Skipping TRT RDO Monitoring.");
608  m_doRDOsMon = false;
609  }
610 
611  if (!trackCollection.isValid()) {
612  ATH_MSG_WARNING("No TrackCollection by the name of " <<
613  m_trackCollectionKey.key() << " in StoreGate. Skipping TRT Track Monitoring.");
614  m_doTracksMon = false;
615  }
616  }
617 
618  //Book_TRT_RDOs registers all raw data histograms
619  if (m_doRDOsMon) {
620  ATH_CHECK( bookTRTRDOs(newLumiBlockFlag(), newRunFlag()) );
621  }
622 
623  //Book_TRT_Tracks registers all tracking histograms
624  if (m_doTracksMon) {
625  sc = bookTRTTracks(newLumiBlockFlag(), newRunFlag());
626 
627  if (m_doShift) {
628  sc = bookTRTShiftTracks(newLumiBlockFlag(), newRunFlag());
629 
630  if (sc == StatusCode::FAILURE) {
631  ATH_MSG_ERROR("Unable to book trt shift tracks histograms");
632  }
633  }
634  }
635 
636  if (m_doEfficiency) {
637  sc = bookTRTEfficiency (newLumiBlockFlag(), newRunFlag());
638 
639  if (sc == StatusCode::FAILURE) {
640  ATH_MSG_ERROR("Unable to book trt efficiency");
641  }
642  }
643 
644  if (newRunFlag()) {
645  ATH_MSG_DEBUG("Begin of run");
646  }
647 
648  if (sc == StatusCode::FAILURE) {
649  ATH_MSG_ERROR("No histograms booked");
650  }
651 
652  return StatusCode::SUCCESS;
653 }

◆ bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )
virtualinherited

Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, and TileDigitsMonTool.

Definition at line 782 of file ManagedMonitorToolBase.cxx.

784 {
785  // The Run/LumiBlock numbers are not set when beginRun() is called. Therefore,
786  // book histograms on the first call to fillHists(), which is called from execute().
787  return StatusCode::SUCCESS;
788 }

◆ bookTH1D_LW()

TH1D_LW * TRT_Monitoring_Tool::bookTH1D_LW ( MonGroup &  mongroup,
const std::string &  hName,
const std::string &  hTitle,
int  bins,
double  lowbin,
double  highbin,
const std::string &  xTitle,
const std::string &  yTitle,
StatusCode &  scode 
)
private

Definition at line 4430 of file TRT_Monitoring_Tool.cxx.

4430  {
4431 //----------------------------------------------------------------------------------//
4432  TH1D_LW *hist = TH1D_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin);
4433  scode = trtRegHist<TH1D_LW>(hist, mongroup, hName.c_str());
4434  hist->GetXaxis()->SetLabelSize(0.03);
4435  hist->GetYaxis()->SetLabelSize(0.03);
4436  hist->SetXTitle(xTitle.c_str());
4437  hist->SetYTitle(yTitle.c_str());
4438  return hist;
4439 }

◆ bookTH1F_LW()

TH1F_LW * TRT_Monitoring_Tool::bookTH1F_LW ( MonGroup &  mongroup,
const std::string &  hName,
const std::string &  hTitle,
int  bins,
double  lowbin,
double  highbin,
const std::string &  xTitle,
const std::string &  yTitle,
StatusCode &  scode 
)
private

Definition at line 4417 of file TRT_Monitoring_Tool.cxx.

4417  {
4418 //----------------------------------------------------------------------------------//
4419  TH1F_LW *hist = TH1F_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin);
4420  scode = trtRegHist<TH1F_LW>(hist, mongroup, hName.c_str());
4421  hist->GetXaxis()->SetLabelSize(0.03);
4422  hist->GetYaxis()->SetLabelSize(0.03);
4423  hist->SetXTitle(xTitle.c_str());
4424  hist->SetYTitle(yTitle.c_str());
4425  return hist;
4426 }

◆ bookTH2F_LW()

TH2F_LW * TRT_Monitoring_Tool::bookTH2F_LW ( MonGroup &  mongroup,
const std::string &  hName,
const std::string &  hTitle,
int  xbins,
double  lowxbins,
double  highxbins,
int  ybins,
double  lowybins,
double  highybins,
const std::string &  xTitle,
const std::string &  yTitle,
StatusCode &  scode 
)
private

Definition at line 4473 of file TRT_Monitoring_Tool.cxx.

4473  {
4474 //----------------------------------------------------------------------------------//
4475  TH2F_LW *hist = TH2F_LW::create(hName.c_str(), hTitle.c_str(), xnbins, xfirstbin, xlastbin, ynbins, yfirstbin, ylastbin);
4476  scode = trtRegHist<TH2F_LW>(hist, mongroup, hName.c_str());
4477  hist->GetXaxis()->SetLabelSize(0.03);
4478  hist->GetYaxis()->SetLabelSize(0.03);
4479  hist->SetXTitle(xTitle.c_str());
4480  hist->SetYTitle(yTitle.c_str());
4481  return hist;
4482 }

◆ bookTProfile()

TProfile * TRT_Monitoring_Tool::bookTProfile ( MonGroup &  mongroup,
const std::string &  hName,
const std::string &  hTitle,
int  bins,
double  lowbin,
double  highbin,
double  ymin,
double  ymax,
const std::string &  xTitle,
const std::string &  yTitle,
StatusCode &  scode 
)
private

Definition at line 4443 of file TRT_Monitoring_Tool.cxx.

4443  {
4444 //----------------------------------------------------------------------------------//
4445  TProfile *hist = new TProfile(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin, ymin, ymax);
4446  scode = trtRegHist<TProfile>(hist, mongroup, hName.c_str());
4447  hist->SetMarkerSize(0.5);
4448  hist->SetMarkerStyle(2);
4449  hist->SetMarkerColor(2);
4450  hist->GetXaxis()->SetLabelSize(0.03);
4451  hist->GetYaxis()->SetLabelSize(0.03);
4452  hist->GetXaxis()->SetTitle(xTitle.c_str());
4453  hist->GetYaxis()->SetTitle(yTitle.c_str());
4454  return hist;
4455 }

◆ bookTProfile_LW()

TProfile_LW * TRT_Monitoring_Tool::bookTProfile_LW ( MonGroup &  mongroup,
const std::string &  hName,
const std::string &  hTitle,
int  bins,
double  lowbin,
double  highbin,
double  ymin,
double  ymax,
const std::string &  xTitle,
const std::string &  yTitle,
StatusCode &  scode 
)
private

Definition at line 4458 of file TRT_Monitoring_Tool.cxx.

4458  {
4459 //----------------------------------------------------------------------------------//
4460  TProfile_LW *hist = TProfile_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin, ymin, ymax);
4461  scode = trtRegHist<TProfile_LW>(hist, mongroup, hName.c_str());
4462  hist->SetMarkerSize(0.5);
4463  hist->SetMarkerStyle(2);
4464  hist->SetMarkerColor(2);
4465  hist->GetXaxis()->SetLabelSize(0.03);
4466  hist->GetYaxis()->SetLabelSize(0.03);
4467  hist->GetXaxis()->SetTitle(xTitle.c_str());
4468  hist->GetYaxis()->SetTitle(yTitle.c_str());
4469  return hist;
4470 }

◆ bookTRTEfficiency()

StatusCode TRT_Monitoring_Tool::bookTRTEfficiency ( bool  isNewLumiBlock,
bool  isNewRun 
)
private

Definition at line 893 of file TRT_Monitoring_Tool.cxx.

893  {
894 //----------------------------------------------------------------------------------//
895  StatusCode scode = StatusCode::SUCCESS;
896 
897  if (newLumiBlock) {}
898 
899  if (newRun) {
900  std::string hName, hTitle;
901  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
902  const std::string be_id[2] = { "B", "E" };
903  const std::string side_id[2] = { "A", "C" };
904  MonGroup trackShiftEff(this, "TRT/Efficiency", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
905  m_hefficiency_eta = bookTProfile_LW(trackShiftEff, "hEfficiency_eta", "Efficiency vs #eta", 50, -2.8, 2.8, 0, 1, "#eta", "Efficiency", scode);
906  m_hefficiency_phi = bookTProfile_LW(trackShiftEff, "hEfficiency_phi", "Efficiency vs #phi", 50, -3.2, 3.2, 0, 1, "#phi (deg)", "Efficiency", scode);
907  m_hefficiency_pt = bookTProfile_LW(trackShiftEff, "hEfficiency_pt", "Efficiency vs pT", 50, 0, 10, 0, 1, "pT (GeV)", "Efficiency", scode);
908  m_hefficiency_z0 = bookTProfile_LW(trackShiftEff, "hEfficiency_z0", "Efficiency vs z0", 50, -200, 200, 0, 1, "z0", "Efficiency", scode);
909  m_hefficiencyBarrel_locR = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrel_locR", "Efficiency vs Track-to-Wire Distance for Xenon Straws" " (Barrel)", 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
910  m_hefficiencyBarrel_locR_Ar = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrel_locR_Ar", "Efficiency vs Track-to-Wire Distance for Argon Straws" " (Barrel)", 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
911  m_hefficiencyMap[0] = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrelMap", "Straw Efficiency Map" " (Barrel)", s_Straw_max[0], 0, s_Straw_max[0], 0, 1, "Straw Number", "Efficiency", scode);
912  m_hefficiencyMap[1] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCapMap", "Straw Efficiency Map" " (Endcap)", s_Straw_max[1], 0, s_Straw_max[1], 0, 1, "Straw Number", "Efficiency", scode);
913 
914  for (int iside = 0; iside < 2; iside++) {
915  const std::string regionTag = " (" + be_id[1] + side_id[iside] + ")";
916  m_hefficiencyEndCap_locR[iside] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCap" + side_id[iside] + "_locR", "Efficiency vs Track-to-Wire Distance for Xenon Straws" + regionTag, 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
917  m_hefficiencyEndCap_locR_Ar[iside] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCap" + side_id[iside] + "_locR_Ar", "Efficiency vs Track-to-Wire Distance for Argon Straws" + regionTag, 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
918  }
919 
920  for (int ibe = 0; ibe < 2; ibe++) {
921  for (int iside = 0; iside < 2; iside++) {
922  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
923  MonGroup trackShiftEffWeighted(this, "TRT/Efficiency", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
924  m_hefficiency[ibe][iside] = bookTH1F_LW(trackShiftEffWeighted, "hEfficiency" + barrel_or_endcap[ibe] + side_id[iside], "Straw Efficiency" + regionTag, 500, -0.01, 1.01, "Efficiency", "Number of Straws", scode);
925  m_hefficiencyIntegral[ibe][iside] = bookTH1F_LW(trackShiftEffWeighted, "hEfficiencyIntegral" + barrel_or_endcap[ibe] + side_id[iside], "Straw Efficiency Integral" + regionTag, 500, -0.01, 1.01, "Efficiency", "Fraction of Straws", scode);
926 
927  if (m_doExpert) {
928  int imintmp = s_numberOfBarrelStacks * iside;
929  int imaxtmp = s_numberOfBarrelStacks * (iside + 1);
930 
931  for (int i = imintmp; i < imaxtmp; i++) {
932  std::ostringstream oss;
933 
934  if (ibe == 0) {
935  oss << "TRT/Barrel/Stack" << (i + 1 - 32 * iside) << side_id[iside];
936  } else if (ibe == 1) {
937  oss << "TRT/Endcap" << side_id[iside] << "/Sector" << (i + 1 - 32 * iside);
938  }
939 
940  const std::string hPath = oss.str();
941  MonGroup trackStack(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
942  m_hefficiencyS[ibe][i] = bookTProfile_LW(trackStack, "hHitEfficiencyS", "Straw Efficiency Map", s_Straw_max[ibe], 0.5, s_Straw_max[ibe] + 0.5, 0, 1, "Straw Number", "Efficiency", scode);
943  m_hefficiencyC[ibe][i] = bookTProfile_LW(trackStack, "hHitEfficiencyC", "Chip Efficiency Map", s_iChip_max[ibe], 0.5, s_iChip_max[ibe] + 0.5, 0, 1, "Chip Number", "Efficiency", scode);
944  }
945  }
946  }
947  }
948  }
949 
950  return scode;
951 }

◆ bookTRTRDOs()

StatusCode TRT_Monitoring_Tool::bookTRTRDOs ( bool  isNewLumiBlock,
bool  isNewRun 
)
private

Definition at line 657 of file TRT_Monitoring_Tool.cxx.

657  {
658 //----------------------------------------------------------------------------------//
659  ATH_MSG_VERBOSE("Booking TRT RDO Histograms");
660 
661  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
662 
663  if (newRun) ATH_MSG_VERBOSE("newRun");
664 
665  StatusCode scode = StatusCode::SUCCESS;
666  std::string hName, hTitle;
667  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
668  const std::string be_id[2] = { "B", "E" };
669  const std::string side_id[2] = { "A", "C" };
670 
671  //Booking of some expert monitoring histograms
672  // ibe = 0 (Barrel), ibe = 1 (Endcap)
673  for (int ibe = 0; ibe < 2; ibe++) {
674  for (int i = 0; i < s_numberOfStacks[ibe] * 2; i++) {
675  std::ostringstream oss;
676 
677  if (ibe == 0) {
678  if (i < s_numberOfStacks[ibe]) {
679  oss << "TRT/Barrel/Stack" << i + 1 << "A";
680  } else if (i >= s_numberOfStacks[ibe]) {
681  oss << "TRT/Barrel/Stack" << i + 1 - 32 << "C";
682  }
683  } else if (ibe == 1) {
684  if (i < s_numberOfStacks[ibe]) {
685  oss << "TRT/EndcapA/Sector" << i + 1;
686  } else if (i >= s_numberOfStacks[ibe]) {
687  oss << "TRT/EndcapC/Sector" << i + 1 - 32;
688  }
689  }
690 
691  const std::string hPath = oss.str();
692  MonGroup rdoStackWeighted(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
693 
694  if (newRun && m_doExpert && m_doStraws) {
695  m_hHitWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitWMapS", "Leading Edge in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability per Event", scode);
696  m_hHitTrWMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrWMapS", "Mean Trailing Edge in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
697  m_hHitTrMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrMapS", "Mean Trailing Edge: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
698  m_hHitAWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAWMapS", "LL in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
699  m_hHitAMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAMapS", "Any LL Bit: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
700  m_hStrawOcc[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hOccupancyS", "Straw Occupancy Distribution: Straws", 201, 0, 1.005, "Occupancy", "Number of Straws", scode);
701  m_hHitToTMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTMapS", "Mean ToT: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
702  m_hHitToTLongMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTLongMapS", "Mean ToT for Straws with ToT > LongToTCut: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
703  m_hHitToTLongTrMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTLongTrMapS", "Mean Trailing Edge for Straws with ToT > LongToTCut: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
704  m_hHitHMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHMapS", "Any HL Bit: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
705  m_hHitHWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHWMapS", "HL in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
706  m_hHtoLMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHtoLMapS", "HL/LL Ratio: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
707  }
708 
709  if (newRun && m_doExpert && m_doChips) {
710  m_hHitWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitWMapC", "Leading Edge in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
711  m_hHitTrMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrMapC", "Mean Trailing Edge: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
712  m_hHitTrWMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrWMapC", "Mean Trailing Edge in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
713  m_hHitAWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAWMapC", "LL in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
714  m_hHitAMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAMapC", "Any LL Bit: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
715  m_hChipOcc[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hOccupancyC", "Chip Occupancy Distribution", 201, 0, 1.005, "Occupancy", "Number of Chips", scode);
716  m_hHitToTMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTMapC", "Mean ToT: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
717  m_hHitHMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHMapC", "Any HL Bit: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
718  m_hHitHWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHWMapC", "HL in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
719  m_hHtoLMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHtoLMapC", "HL/LL Ratio: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
720  m_hHtoBCMapC[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapC", "HL in BC: Chips", 3, 0, 3, s_iChip_max[ibe], 0, s_iChip_max[ibe], "Bunch Crossing ID", "Chip Number in Stack", scode);
721 
722  if (ibe == 0) {
723  m_hHtoBCMapB[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapB", "HL in BC: Boards", 3, 0, 3, 9, 0, 9, "Bunch Crossing ID", "Board Number in Stack", scode);
724  } else if (ibe == 1) {
725  m_hHtoBCMapB[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapB", "HL in BC: Boards", 3, 0, 3, 20, -0.5, 19.5, "Bunch Crossing ID", "Board Number in Stack", scode);
726  }
727  }
728  }
729  }
730 
731  //Registering Collisions Histograms
732  if (m_doShift) {
733  MonGroup rdoShiftSmry (this, "TRT/Shift/Summary", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
734  MonGroup rdoShiftSmryRebinned (this, "TRT/Shift/Summary", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "mergeRebinned");
735 
736  if (newRun) {
737  m_hSummary = bookTH1F_LW(rdoShiftSmry, "hSummary", "Run Summary", 8, 0, 8, "", "Entries", scode);
738  m_hSummary->GetXaxis()->SetBinLabel(1, "Events");
739  m_hSummary->GetXaxis()->SetBinLabel(2, "Tracks Total");
740  m_hSummary->GetXaxis()->SetBinLabel(3, "Tracks BA");
741  m_hSummary->GetXaxis()->SetBinLabel(4, "Tracks BC");
742  m_hSummary->GetXaxis()->SetBinLabel(5, "Tracks EA");
743  m_hSummary->GetXaxis()->SetBinLabel(6, "Tracks EC");
744  m_hSummary->GetXaxis()->SetBinLabel(7, "Transition Side A");
745  m_hSummary->GetXaxis()->SetBinLabel(8, "Transition Side C");
746  //lumi summary histograms
747  m_IntLum = bookTH1F_LW(rdoShiftSmry, "hIntLum", "Luminosity", 1, 0., 1., " ", "Luminosity [#mub^{1}]", scode);
748  m_LBvsLum = bookTH1F_LW(rdoShiftSmry, "hLBvsLum", "Luminosity", 2000, 0., 2000., "Luminosity Bin", "Luminosity [#mub^{1}]", scode);
749  m_LBvsTime = bookTH1F_LW(rdoShiftSmry, "hLBvsTime", "Time", 2000, 0., 2000., " Luminosity Bin", "Time [s]", scode);
750  const unsigned int maxLumiBlock = 200;
751 
752  // ibe = 0 (Barrel), ibe = 1 (Endcap)
753  // iside = 0 (A-side), iside = 1 (C-side)
754  for (int ibe = 0; ibe < 2; ibe++) {
755  for (int iside = 0; iside < 2; iside++) {
756  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
757  m_hChipBSErrorsVsLB[ibe][iside] = bookTProfile(rdoShiftSmryRebinned, "hChipBSErrorsVsLB_" + be_id[ibe] + side_id[iside], "Chip Bytestream Errors vs LB" + regionTag, maxLumiBlock + 1, -0.5, maxLumiBlock + 0.5, 0, 150.0, "Luminosity Block", "Fraction of Chips with Errors", scode);
758  m_hChipBSErrorsVsLB[ibe][iside]->SetCanExtend(TH1::kAllAxes);
759  m_hRobBSErrorsVsLB[ibe][iside] = bookTProfile(rdoShiftSmryRebinned, "hRobBSErrorsVsLB_" + be_id[ibe] + side_id[iside], "Rob Bytestream Errors vs LB" + regionTag, maxLumiBlock + 1, -0.5, maxLumiBlock + 0.5, 0, 150.0, "Luminosity Block", "Fraction of RODs with Errors", scode);
760  m_hRobBSErrorsVsLB[ibe][iside]->SetCanExtend(TH1::kAllAxes);
761  }
762  }
763 
764  // Barrel/Endcap Histograms
765  const std::string module_or_wheel[2] = { "Module", "Wheel" };
766  const std::string stack_or_sector[2] = { "Barrel Stack", "Endcap Sector" };
767  const std::string modulenum_assign2[2] = { "Modules Type 1 (1-32), Type 2 (33-64), Type 3 (65-96)", "Wheels A (1-32), B (33-64)" };
768 
769  for (int ibe = 0; ibe < 2; ibe++) {
770  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
771  MonGroup rdo(this, "TRT/" + barrel_or_endcap[ibe] + "/Expert", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
772  MonGroup rdoShift (this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
773  MonGroup rdoShiftTH1(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
774 
775  if (ibe == 0) {
776  m_hHitWMap_B = bookTH1F_LW(rdoShiftTH1, "hHitWMap", "Leading Edge in Time Window: Xenon Straws" " (Barrel)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
777 
778  if (m_ArgonXenonSplitter) {
779  m_hHitWMap_B_Ar = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar", "Leading Edge in Time Window: Argon Straws (Barrel)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
780  }
781 
782  m_hOccAll = bookTH1F_LW(rdoShift, "hOccAll", "Occupancy per Event", 400, 0.0, 1.0, "Occupancy", "Events", scode);
783  } else if (ibe == 1) {
784  m_hHitWMap_E[0] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_A", "Leading Edge in Time Window: Xenon Straws" " (EA)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
785  m_hHitWMap_E[1] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_C", "Leading Edge in Time Window: Xenon Straws" " (EC)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
786 
787  if (m_ArgonXenonSplitter) {
788  m_hHitWMap_E_Ar[0] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar_A", "Leading Edge in Time Window: Argon Straws" " (EA)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
789  m_hHitWMap_E_Ar[1] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar_C", "Leading Edge in Time Window: Argon Straws" " (EC)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
790  }
791  }
792 
793  m_hBCIDvsOcc[ibe] = bookTProfile_LW(rdo, "hBCIDvsOcc", "Avg. Occupancy vs BCID" + regionTag, 3565, 0, 3564, 0, 1, "Bunch Crossing ID", "Occupancy", scode);
794 
795  for (int iside = 0; iside < 2; iside++) {
796  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
797  const std::string regionMarker = (m_environment == AthenaMonManager::online) ? (be_id[ibe] + side_id[iside]) : (side_id[iside]); // for historical reasons ...
798  m_hAvgHLOcc_side[ibe][iside] = bookTProfile_LW(rdoShift, "hAvgHLOcc_" + regionMarker, "Avg. HL Occupancy" + regionTag, 32, 1, 33, 0, 1, stack_or_sector[ibe], "Occupancy", scode);
799  m_hAvgLLOcc_side[ibe][iside] = bookTProfile_LW(rdoShift, "hAvgLLOcc_" + regionMarker, "Avg. LL Occupancy" + regionTag, 32, 1, 33, 0, 1, stack_or_sector[ibe], "Occupancy", scode);
800  m_hAvgLLOccMod_side[ibe][iside] = bookTProfile_LW(rdo, "hAvgLLOccMod_" + regionMarker, "Avg. LL Occupancy: " + module_or_wheel[ibe] + "s" + regionTag, s_moduleNum[ibe], 0, s_moduleNum[ibe], 0, 1, modulenum_assign2[ibe], "Occupancy", scode);
801  m_hAvgHLOccMod_side[ibe][iside] = bookTProfile_LW(rdo, "hAvgHLOccMod_" + regionMarker, "Avg. HL Occupancy: " + module_or_wheel[ibe] + "s" + regionTag, s_moduleNum[ibe], 0, s_moduleNum[ibe], 0, 1, modulenum_assign2[ibe], "Occupancy", scode);
802  }
803  }
804  }
805  }
806 
807  ATH_MSG_VERBOSE("Finished Booking TRT RDO Histograms");
808  return scode;
809 }

◆ bookTRTShiftTracks()

StatusCode TRT_Monitoring_Tool::bookTRTShiftTracks ( bool  isNewLumiBlock,
bool  isNewRun 
)
private

Definition at line 954 of file TRT_Monitoring_Tool.cxx.

954  {
955 //----------------------------------------------------------------------------------//
956  ATH_MSG_VERBOSE("Booking TRT Track Histograms");
957 
958  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
959 
960  if (newRun) ATH_MSG_VERBOSE("newRun");
961 
962  std::string hName, hTitle;
963  std::ostringstream oss_distance;
964  oss_distance << std::setprecision(3) << std::fixed << m_DistToStraw;
965  const std::string distance = oss_distance.str();
966  StatusCode scode = StatusCode::SUCCESS;
967  //create several histogram directories.
968  MonGroup trackBarrelShiftTProf(this, "TRT/Shift/Barrel", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
969  MonGroup trackBarrelDiag(this, "TRT/Barrel/Diagnostics", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
970  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
971  const std::string be_id[2] = { "B", "E" };
972  const std::string side_id[2] = { "A", "C" };
973  const int maxLumiblock = 720;
974  //Arrays for Aging
975  const std::string gas[4] = { "in_A", "in_B", "out_A", "out_B"};
976  const std::string Mod[5] = {"1", "2", "3", "shortP", "shortN"};
977 
978  for (int ibe = 0; ibe < 2; ibe++) {
979  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
980  MonGroup trackShift(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
981  MonGroup trackShiftRebinned(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "mergeRebinned");
982  MonGroup trackShiftTH1(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
983  MonGroup trackShiftTH1_lowStat(this, "TRT/Shift/" + barrel_or_endcap[ibe], lowStat, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
984  MonGroup trackAging(this, "TRT/Aging/" + barrel_or_endcap[ibe], lowStat, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
985 
986  if (newRun && m_doShift) {
987  if (ibe == 0) {
988  m_hEvtPhase = bookTH1F_LW(trackShift, "hEvtPhase", "Event Phase Correction Factor", 200, -50, 50, "Event Phase (ns)", "Entries", scode);
989  m_hEvtPhaseVsTrig = bookTH2F_LW(trackShift, "hEvtPhaseVsTrig", "Event Phase vs L1 Trigger Item", 300, -200, 100, 256, -0.5, 255.5, "Event Phase (ns)", "L1 Trigger Item", scode);
990  m_hEvtPhaseDetPhi_B = bookTProfile_LW(trackShift, "hEvtPhaseDetPhi", "Event Phase vs #phi (2D)" + regionTag, m_nphi_bins, 0, 360, -50, 100., "#phi (deg)", "Event Phase from Tracks per Event", scode);
991  m_hrtRelation_B = bookTH2F_LW(trackShift, "hrtRelation", "R(t) Relation for Xenon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
992  m_hNumHoTDetPhi_B = bookTProfile_LW(trackShift, "hNumHoTDetPhi", "Number of Hits per Track with " + distance + " mm Cut vs #phi" + regionTag, m_nphi_bins, 0., 360, 0, 150, "#phi (deg)", Form("Hits per Track, TRT Hits >= %d", m_minTRThits), scode);
993  m_hTronTDist_B = bookTH1F_LW(trackShiftTH1, "hTronTDist", "Trailing Edge Distribution on Track for Xenon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
994  m_hDriftTimeonTrkDist_B = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist", "Drift Time Distribution on Track for Xenon Straws" + regionTag, 32, 0, 100., "Drift Time (ns)", "Norm. Entries", scode);
995  m_hNumTrksDetPhi_B = bookTH1F_LW(trackShift, "hNumTrksDetPhi", "Number of Reconstructed Tracks vs #phi (2D)" + regionTag, 60, 0, 360, "#phi (deg)", "Number of Tracks", scode);
996 
997  if (m_ArgonXenonSplitter) {
998  m_hDriftTimeonTrkDist_B_Ar = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_Ar", "Drift Time Distribution on Track for Argon Straws" + regionTag, 32, 0, 100., "Drift Time (ns)", "Norm. Entries", scode);
999  m_hTronTDist_B_Ar = bookTH1F_LW(trackShiftTH1, "hTronTDist_Ar", "Trailing Edge Distribution on Track for Argon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1000  m_hrtRelation_B_Ar = bookTH2F_LW(trackShift, "hrtRelation_Ar", "R(t) Relation for Argon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1001  m_Pull_Biased_Barrel = bookTH1F_LW(trackShift, "hPull_Biased_Barrel", "Biased Track Pulls for Barrel Hits", 200, -2.5, 2.5, "Pulls", "Entries", scode);
1002  m_hResidual_B_Ar = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_Ar", "Residuals for Argon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1003  m_hResidual_B_Ar_20GeV = bookTH1F_LW(trackShiftTH1, "hResidual_Ar_20GeV", "Residuals for Argon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1004  m_hAvgTroTDetPhi_B_Ar = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_Ar", "Avg. Trailing Edge on Track vs #phi (2D) for Argon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1005  m_hTimeResidual_B_Ar = bookTH1F_LW(trackShiftTH1, "hTimeResidual_Ar", "Time Residuals for Argon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1006  m_hWireToTrkPosition_B_Ar = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_Ar", "Track-to-Wire Distance for Argon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1007  m_hHtoLRatioOnTrack_B_Ar = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Ar", "HL/LL Ratio per Reconstructed Track for Argon" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode); //for argon
1008  }
1009 
1010  m_hHtoLRatioOnTrack_B_Xe = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Xe", "HL/LL Ratio per Reconstructed Track for Xenon" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode); //for xenon
1011  m_hResidual_B = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual", "Residuals for Xenon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1012  m_hResidual_B_20GeV = bookTH1F_LW(trackShiftTH1, "hResidual_20GeV", "Residuals for Xenon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1013  m_hTimeResidual_B = bookTH1F_LW(trackShiftTH1, "hTimeResidual", "Time Residuals for Xenon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1014  m_hWireToTrkPosition_B = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition", "Track-to-Wire Distance for Xenon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1015  m_hNumSwLLWoT_B = bookTH1F_LW(trackShiftTH1, "hNumSwLLWoT", "Number of Straws with Hits on Track in Time Window" + regionTag, 150, 0, 150, "Number of LL Hits per Track", "Norm. Entries", scode);
1016  m_hAvgTroTDetPhi_B = bookTProfile_LW(trackShift, "hAvgTroTDetPhi", "Avg. Trailing Edge on Track vs #phi (2D) for Xenon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1017  m_hNTrksperLB_B = bookTProfile(trackShiftRebinned, "hNTrksperLB", "Avg. Number of Reconstructed Tracks per Event" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Number of Tracks", scode);
1018  m_hNTrksperLB_B->SetCanExtend(TH1::kAllAxes);
1019  m_hNHitsperLB_B = bookTProfile(trackShiftRebinned, "hNHitsperLB", "Avg. Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1020  m_hNHitsperLB_B->SetCanExtend(TH1::kAllAxes);
1021  m_hNHLHitsperLB_B = bookTProfile(trackShiftRebinned, "hNHLHitsperLB", "Avg. HL Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1022  m_hNHLHitsperLB_B->SetCanExtend(TH1::kAllAxes);
1023  m_hHLhitOnTrack_B = bookTH1F_LW(trackShiftTH1, "hHLhitOnTrack", "Number of HL Hits per Reconstructed Track" + regionTag, 50, 0, 50, "Number of HL Hits per Track", "Norm. Entries", scode);
1024  m_hHtoLRatioOnTrack_B = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack", "HL/LL Ratio per Reconstructed Track for All" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode);
1025  m_hHitWonTMap_B = bookTH1F_LW(trackShiftTH1, "hHitWonTMap", "Leading Edge in Time Window per Reconstructed Track" + regionTag, s_Straw_max[0], 0, s_Straw_max[0], "Straw Number", "Norm. Entries", scode);
1026  m_hStrawEffDetPhi_B = bookTProfile_LW(trackShift, "hStrawEffDetPhi", "Straw Efficiency on Track with " + distance + " mm Cut vs #phi(2D)" + regionTag, 32, 0, 32, 0, 1.2, "Stack", "Avg. Straw Efficiency", scode);
1027  } else if (ibe == 1) {
1028  m_Pull_Biased_EndCap = bookTH1F_LW(trackShift, "hPull_Biased_EndCap", "Biased Track Pulls for EndCap Hits", 200, -2.5, 2.5, "Pulls", "Entries", scode);
1029 
1030  for (int iside = 0; iside < 2; iside++) {
1031  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
1032  m_hEvtPhaseDetPhi_E[iside] = bookTProfile_LW(trackShift, "hEvtPhaseDetPhi_" + side_id[iside], "Event Phase vs #phi (2D)" + regionTag, m_nphi_bins, 0, 360, -50, 100, "#phi (deg)", "Event Phase from Tracks per Event", scode);
1033  m_hrtRelation_E[iside] = bookTH2F_LW(trackShift, "hrtRelation_" + side_id[iside], "R(t) Relation for Xenon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1034  m_hNumHoTDetPhi_E[iside] = bookTProfile_LW(trackShift, "hNumHoTDetPhi_" + side_id[iside], "Number of Hits per Track with " + distance + " mm Cut vs #phi" + regionTag, m_nphi_bins, 0., 360, 0, 150, "#phi (deg)", Form("Hits per Track, TRT Hits> = %d", m_minTRThits), scode);
1035  m_hTronTDist_E[iside] = bookTH1F_LW(trackShiftTH1, "hTronTDist_" + side_id[iside], "Trailing Edge Distribution on Track for Xenon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1036  m_hDriftTimeonTrkDist_E[iside] = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_" + side_id[iside], "Drift Time Distribution on Track for Xenon Straws" + regionTag, 32, 0, 100, "Drift Time (ns)", "Norm. Entries", scode);
1037  m_hNumTrksDetPhi_E[iside] = bookTH1F_LW(trackShift, "hNumTrksDetPhi_" + side_id[iside], "Number of Reconstructed Tracks vs #phi (2D)" + regionTag, 60, 0, 360, "#phi (deg)", "Number of Tracks", scode);
1038  m_hResidual_E[iside] = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_" + side_id[iside], "Residuals for Xenon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1039  m_hResidual_E_20GeV[iside] = bookTH1F_LW(trackShiftTH1, "hResidual_" + side_id[iside] + "_20GeV", "Residuals for Xenon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1040  m_hTimeResidual_E[iside] = bookTH1F_LW(trackShiftTH1, "hTimeResidual_" + side_id[iside], "Time Residuals for Xenon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1041 
1042  if (m_ArgonXenonSplitter) {
1043  m_hTronTDist_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hTronTDist_Ar_" + side_id[iside], "Trailing Edge Distribution on Track for Argon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1044  m_hAvgTroTDetPhi_E_Ar[iside] = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_Ar_" + side_id[iside], "Avg. Trailing Edge on Track vs #phi (2D) for Argon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1045  m_hrtRelation_E_Ar[iside] = bookTH2F_LW(trackShift, "hrtRelation_Ar_" + side_id[iside], "R(t) Relation for Argon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1046  m_hDriftTimeonTrkDist_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_Ar_" + side_id[iside], "Drift Time Distribution on Track for Argon Straws" + regionTag, 32, 0, 100, "Drift Time (ns)", "Norm. Entries", scode);
1047  m_hResidual_E_Ar[iside] = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_Ar_" + side_id[iside], "Residuals for Argon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1048  m_hResidual_E_Ar_20GeV[iside] = bookTH1F_LW(trackShiftTH1, "hResidual_Ar_" + side_id[iside] + "_20GeV", "Residuals for Argon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1049  m_hTimeResidual_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hTimeResidual_Ar_" + side_id[iside], "Time Residuals for Argon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1050  m_hWireToTrkPosition_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_Ar_" + side_id[iside], "Track-to-Wire Distance for Argon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1051  m_hHtoLRatioOnTrack_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Ar_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for Argon" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1052  }
1053 
1054  m_hHtoLRatioOnTrack_E_Xe[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Xe_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for Xenon" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1055  m_hWireToTrkPosition_E[iside] = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_" + side_id[iside], "Track-to-Wire Distance for Xenon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1056  m_hNumSwLLWoT_E[iside] = bookTH1F_LW(trackShiftTH1, "hNumSwLLWoT_" + side_id[iside], "Number of Straws with Hits on Track in Time Window" + regionTag, 150, 0, 150, "Number of LL Hits per Track", "Norm. Entries", scode);
1057  m_hAvgTroTDetPhi_E[iside] = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_" + side_id[iside], "Avg. Trailing Edge on Track vs #phi (2D) for Xenon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1058  m_hNTrksperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNTrksperLB_" + side_id[iside], "Avg. Number of Reconstructed Tracks per Event" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Number of Tracks", scode);
1059  m_hNTrksperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1060  m_hNHitsperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNHitsperLB_" + side_id[iside], "Avg. Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1061  m_hNHitsperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1062  m_hNHLHitsperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNHLHitsperLB_" + side_id[iside], "Avg. HL Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1063  m_hNHLHitsperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1064  m_hHLhitOnTrack_E[iside] = bookTH1F_LW(trackShiftTH1, "hHLhitOnTrack_" + side_id[iside], "Number of HL Hits per Reconstructed Track" + regionTag, 50, 0, 50, "Number of HL Hits per Track", "Norm. Entries", scode);
1065  m_hHtoLRatioOnTrack_E[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for All" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1066  m_hHitWonTMap_E[iside] = bookTH1F_LW(trackShiftTH1, "hHitWonTMap_" + side_id[iside], "Leading Edge in Time Window per Reconstructed Track" + regionTag, s_Straw_max[1], 0, s_Straw_max[1], "Straw Number", "Norm. Entries", scode);
1067  m_hStrawEffDetPhi_E[iside] = bookTProfile_LW(trackShift, "hStrawEffDetPhi_" + side_id[iside], "Straw Efficiency on Track with " + distance + " mm Cut vs #phi(2D)" + regionTag, 32, 0, 32, 0, 1.2, "Stack", "Avg. Straw Efficiency", scode);
1068  }
1069  }
1070 
1071  m_hHitsOnTrack_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hHitsOnTrack_Scatter", "Hits per Track in Time Window in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 80, 0, 80, "Luminosity Block (mod 1440)", "Number of Hits per Track in Stacks", scode);
1072  m_hLLOcc_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hLLOcc_Scatter", "LL Occupancy in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 400, 0.0, 1.0, "Luminosity Block (mod 1440)", "LL Occupancy in Stacks", scode);
1073  m_hHightoLowRatioOnTrack_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hHightoLowRatioOnTrack_Scatter", "HL/LL Ratio on Track in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 40, 0.0, 0.5, "Luminosity Block (mod 1440)", "HL/LL Ratio in Stacks", scode);
1074  }
1075 
1076  //Initialize Aging plots
1077  if (newLumiBlock && m_doShift) {
1078  for (int iL = 0; iL < 5; iL++) {
1079  for (int iSide = 0; iSide < 2; iSide++) {
1080  if (ibe == 0) {
1081  if (iL < 3) {
1082  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m" + Mod[iL] + "_" + side_id[iSide] + "_All", "Number All Hits side " + side_id[iSide] + " Layer " + Mod[iL], 30, -750., 750., "z [mm]", "Number of Hits", scode);
1083  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m" + Mod[iL] + "_" + side_id[iSide] + "_HT", "Number HT Hits side " + side_id[iSide] + " Layer " + Mod[iL], 30, -750., 750., "z [mm]", "Number of HT Hits", scode);
1084  }
1085 
1086  if (iL == 3) {
1087  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_All_" + Mod[iL], "Number All Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, 0., 725., "z [mm]", "Number of Hits", scode);
1088  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_HT_" + Mod[iL], "Number HT Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, 0., 725., "z [mm]", "Number of HT Hits", scode);
1089  }
1090 
1091  if (iL == 4) {
1092  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_All_" + Mod[iL], "Number All Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, -725., 0., "z [mm]", "Number of Hits", scode);
1093  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_HT_" + Mod[iL], "Number HT Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, -725., 0., "z [mm]", "Number of HT Hits", scode);
1094  }
1095  } else if (ibe == 1) {
1096  // prevent double booking of histograms here
1097  if (iL < 4) {
1098  m_trackr_All[iL][iSide] = bookTH1F_LW(trackAging, "trackr_E" + side_id[iSide] + "_" + gas[iL] + "_All", "Number All Hits E" + side_id[iSide] + " " + gas[iL], 30, 644., 1004., "r [mm]", "Number of Hits", scode);
1099  m_trackr_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackr_E" + side_id[iSide] + "_" + gas[iL] + "_HT", "Number HT Hits E" + side_id[iSide] + " " + gas[iL], 30, 644., 1004., "r [mm]", "Number of HT Hits", scode);
1100  }
1101  }
1102  }
1103  }
1104  }
1105  }
1106 
1107  return scode;
1108 }

◆ bookTRTTracks()

StatusCode TRT_Monitoring_Tool::bookTRTTracks ( bool  isNewLumiBlock,
bool  isNewRun 
)
private

Definition at line 813 of file TRT_Monitoring_Tool.cxx.

813  {
814 //----------------------------------------------------------------------------------//
815  ATH_MSG_VERBOSE("Booking TRT Track Histograms");
816 
817  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
818 
819  if (newRun) ATH_MSG_VERBOSE("newRun");
820 
821  StatusCode scode = StatusCode::SUCCESS;
822  std::string hName, hTitle;
823  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
824 
825  for (int ibe = 0; ibe < 2; ibe++) {
826  std::ostringstream oss_distance;
827  oss_distance << std::setprecision(3) << std::fixed << m_DistToStraw;
828  const std::string distance = oss_distance.str();
829  const std::string hPathGen = "TRT/" + barrel_or_endcap[ibe] + "/Expert";
830  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
831 
832  for (int i = 0; i < s_numberOfStacks[ibe] * 2; i++) {
833  std::ostringstream oss;
834 
835  if (ibe == 0) {
836  if (i < s_numberOfStacks[ibe]) {
837  oss << "TRT/Barrel/Stack" << i + 1 << "A";
838  } else if (i >= s_numberOfStacks[ibe]) {
839  oss << "TRT/Barrel/Stack" << i + 1 - 32 << "C";
840  }
841  } else if (ibe == 1) {
842  if (i < s_numberOfStacks[ibe]) {
843  oss << "TRT/EndcapA/Sector" << i + 1;
844  } else if (i >= s_numberOfStacks[ibe]) {
845  oss << "TRT/EndcapC/Sector" << i + 1 - 32;
846  }
847  }
848 
849  const std::string hPath = oss.str();
850  MonGroup trackStackWeighted(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
851 
852  if (newRun && m_doExpert && m_doStraws) {
853  m_hHitWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitWonTMapS", "Leading Edge on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
854  m_hHitTronTMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTMapS", "Mean Trailing Edge on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75.0, "Straw Number in Stack", "Time (ns)", scode);
855  m_hHitAonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAonTMapS", "Any LL Bit on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
856  m_hStrawsEff[ibe][i] = bookTProfile_LW(trackStackWeighted, "hEfficiencyS", "Straw Efficiency with " + distance + " mm Cut", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0.0, 1.0, "Straw Number in Stack", "Efficiency", scode);
857  m_hHitAWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapS", "Any LL Bit on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
858  m_hHitHonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHonTMapS", "HL Hit on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
859  m_hHitHWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHWonTMapS", "HL Hit(In Time Window) on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
860  m_hHitAWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapS", "Any LL Bit on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
861  m_hHitToTonTMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitToTonTMapS", "Mean ToT on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
862  m_hValidRawDriftTimeonTrk[ibe][i] = bookTProfile_LW(trackStackWeighted, "hValidRawDriftTimeonTrkS", "Valid Raw Drift Time on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
863  m_hHtoLonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLonTMapS", "HL/LL Ratio on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
864  m_hHtoLWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLWonTMapS", "HL/LL (In Time Window) Ratio on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
865  m_hHitTronTwEPCMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTwEPCMapS", "Mean Trailing Edge on Track (with Event Phase Correction): Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], -50, 75, "Straw Number in Stack", "Time (ns)", scode);
866  m_hHitOnTrackVsAllS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitonTrackVAllS", "(Hit on Track) / (Any LL Bit): Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Ratio", scode);
867  }
868 
869  if (newRun && m_doExpert && m_doChips) {
870  m_hHitWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitWonTMapC", "Leading Edge on Track in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
871  m_hHitTronTMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTMapC", "Mean Trailing Edge on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
872  m_hHitAonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAonTMapC", "Any LL Bit on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
873  m_hChipsEff[ibe][i] = bookTProfile_LW(trackStackWeighted, "hEfficiencyC", "Chip Efficiency with " + distance + " mm Cut", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0.0, 1.0, "Chip Number in Stack", "Efficiency", scode);
874  m_hHitAWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapC", "Any LL Bit on Track in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
875  m_hHitHonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHonTMapC", "HL Hit on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
876  m_hHitHWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHWonTMapC", "HL Hit(In time Window) on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
877  m_hHitToTonTMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitToTonTMapC", "Mean ToT on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
878  m_hValidRawDriftTimeonTrkC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hValidRawDriftTimeonTrkC", "Valid Raw Drift Time on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
879  m_hHtoLonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLonTMapC", "HL/LL Ratio on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
880  m_hHtoLWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLWonTMapC", "HL/LL(In Time Window) Ratio on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
881  m_hHitTronTwEPCMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTwEPCMapC", "Mean Trailing Edge on Track (with Event Phase Correction): Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], -50, 75, "Chip Number in Stack", "Time (ns)", scode);
882  m_hHitOnTrackVsAllC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitonTrackVAllC", "(Hit on Track) / (Any LL Bit): Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Ratio", scode);
883  }
884  }
885  }
886 
887  ATH_MSG_VERBOSE("Booked TRT Track Histograms successfully");
888  return scode;
889 }

◆ checkEventBurst()

StatusCode TRT_Monitoring_Tool::checkEventBurst ( const TRT_RDO_Container &  rdoContainer)
private

Definition at line 1746 of file TRT_Monitoring_Tool.cxx.

1746  {
1747 //----------------------------------------------------------------------------------//
1748  m_passEventBurst = true;
1749 
1750  if (m_EventBurstCut <= 0) return StatusCode::SUCCESS;
1751 
1752  int nHLHits = 0;
1753  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
1754  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
1755 
1756  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
1757  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
1758 
1759  if (!TRT_Collection) continue;
1760  else {
1761  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
1762 
1763  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
1764  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
1765 
1766  if (!p_lolum) continue;
1767 
1768  if (p_lolum->highLevel()) nHLHits++;
1769  }
1770  }
1771  }
1772 
1773  if (nHLHits > m_EventBurstCut) m_passEventBurst = false;
1774 
1775  return StatusCode::SUCCESS;
1776 }

◆ checkHists()

StatusCode ManagedMonitorToolBase::checkHists ( bool  calledFromFinalize)
virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.

Implements IMonitorToolBase.

Reimplemented in SCTHitsNoiseMonTool, SCTTracksMonTool, SCTLorentzMonTool, TileRawChannelMonTool, TileDigitsMonTool, DQTDataFlowMonTool, DQTNonCollBkg_ZDC, DQTGlobalWZFinderTool, DataQualityFatherMonTool, DQTDetSynchMonTool, DQTMuonIDTrackTool, TileCellNoiseMonTool, CscCalibMonToolBase, CscPrdValAlg, and CscRdoValAlg.

Definition at line 1901 of file ManagedMonitorToolBase.cxx.

1903 {
1904  // Histograms will be checked using the data-quality monitoring framework (DQMF)
1905 
1906  return StatusCode::SUCCESS;
1907 }

◆ checkTRTReadoutIntegrity()

StatusCode TRT_Monitoring_Tool::checkTRTReadoutIntegrity ( const xAOD::EventInfo &  eventInfo)
private

Definition at line 4001 of file TRT_Monitoring_Tool.cxx.

4001  {
4002 //-------------------------------------------------------------------------------------------------//
4003  StatusCode sc = StatusCode::SUCCESS;
4004 
4005  const TRT_BSErrContainer emptyErrCont;//Empty dummy instance for MC
4006  const TRT_BSErrContainer* bsErrCont=&emptyErrCont;
4007 
4008  if (!m_bsErrContKey.empty()) {
4009  //Regular real-data case, get the byte-stream errors from SG
4010  SG::ReadHandle<TRT_BSErrContainer> bsErrContHdl{m_bsErrContKey};
4011  bsErrCont=bsErrContHdl.cptr();
4012  }
4013  else {
4014  ATH_MSG_DEBUG("MC case, using dummy TRT_BSErrContainer");
4015  }
4016 
4017  const unsigned int lumiBlock = eventInfo.lumiBlock();
4018  ATH_MSG_VERBOSE("This is lumiblock : " << lumiBlock);
4019  m_good_bcid = eventInfo.bcid();
4020 
4021  if ((int)lumiBlock != m_lastTRTLumiBlock) {
4022  m_lastTRTLumiBlock = lumiBlock;
4023  }
4025  //Get BSConversion errors
4026  const std::set<std::pair<uint32_t, uint32_t> > &L1IDErrorSet = bsErrCont->getL1ErrorSet();
4027  const std::set<std::pair<uint32_t, uint32_t> > &BCIDErrorSet = bsErrCont->getBCIDErrorSet();
4028  const std::set<uint32_t> &MissingErrorSet = bsErrCont->getMissingErrorSet();
4029  const std::set<uint32_t> &SidErrorSet = bsErrCont->getSidErrorSet();
4030  const std::set<std::pair<uint32_t, uint32_t> > &RobStatusErrorSet = bsErrCont->getRobErrorSet();
4031 
4032  const unsigned int rod_id_base[2][2] = { { 0x310000, 0x320000 }, { 0x330000, 0x340000 } };
4033  const unsigned int nChipsTotal[2][2] = { { 3328, 3328 }, { 7680, 7680 } };
4034  const unsigned int nRobsTotal[2][2] = { { 32, 32 }, { 64, 64 } };
4035  float nBSErrors[2][2] = { { 0, 0 }, { 0, 0 } };
4036  float nRobErrors[2][2] = { { 0, 0 }, { 0, 0 } };
4037  const std::set<std::pair<uint32_t, uint32_t> > *errorset1[2] = { &BCIDErrorSet, &L1IDErrorSet };
4038 
4039  for (int iset = 0; iset < 2; ++iset) {
4040  for (auto setIt = errorset1[iset]->begin(); setIt != errorset1[iset]->end(); ++setIt) {
4041  for (int ibe = 0; ibe < 2; ++ibe) {
4042  for (int iside = 0; iside < 2; ++iside) {
4043  if (((setIt->first >> 8) & 0xFF0000) == rod_id_base[ibe][iside]) {
4044  nBSErrors[ibe][iside] += 1. / nChipsTotal[ibe][iside];
4045  }
4046  }
4047  }
4048  }
4049  }
4050 
4051  const std::set<uint32_t> *errorset2[2] = { &MissingErrorSet, &SidErrorSet };
4052 
4053  for (int iset = 0; iset < 2; ++iset) {
4054  for (auto setIt = errorset2[iset]->begin(); setIt != errorset2[iset]->end(); ++setIt) {
4055  for (int ibe = 0; ibe < 2; ++ibe) {
4056  for (int iside = 0; iside < 2; ++iside) {
4057  if (((*setIt >> 8) & 0xFF0000) == rod_id_base[ibe][iside]) {
4058  nBSErrors[ibe][iside] += 1. / nChipsTotal[ibe][iside];
4059  }
4060  }
4061  }
4062  }
4063  }
4064 
4065  for (int ibe = 0; ibe < 2; ++ibe) {
4066  for (int iside = 0; iside < 2; ++iside) {
4067  m_hChipBSErrorsVsLB[ibe][iside]->Fill(lumiBlock, nBSErrors[ibe][iside]);
4068  m_hChipBSErrorsVsLB[ibe][iside]->SetEntries(lumiBlock); // we need this so the LastBinThreshold algorithm can find the last bin
4069  }
4070  }
4071 
4072  for (auto setIt = RobStatusErrorSet.begin(); setIt != RobStatusErrorSet.end(); ++setIt) {
4073  for (int ibe = 0; ibe < 2; ++ibe) {
4074  for (int iside = 0; iside < 2; ++iside) {
4075  if (setIt->first % rod_id_base[ibe][iside] < 0xffff) {
4076  nRobErrors[ibe][iside] += 1. / nRobsTotal[ibe][iside];
4077  }
4078  }
4079  }
4080  }
4081 
4082  for (int ibe = 0; ibe < 2; ++ibe) {
4083  for (int iside = 0; iside < 2; ++iside) {
4084  m_hRobBSErrorsVsLB[ibe][iside]->Fill(lumiBlock, nRobErrors[ibe][iside]);
4085  m_hRobBSErrorsVsLB[ibe][iside]->SetEntries(lumiBlock); // we need this so the LastBinThreshold algorithm can find the last bin
4086  }
4087  }
4088 
4089  return sc;
4090 }

◆ chipToBoard()

int TRT_Monitoring_Tool::chipToBoard ( int  chip)
staticprivate

Definition at line 4305 of file TRT_Monitoring_Tool.cxx.

4305  {
4306 //----------------------------------------------------------------------------------//
4307  // return logical board index:
4308  // 0 for Board 1S (has 10 chips) 0 - 9
4309  // 1 for 1L (11) 10 - 20
4310  // 2 for 2S (15) 21 - 35
4311  // 3 for 2L, first 9 chips 36 - 44
4312  // 4 for 2L, second 9 chips 45 - 53
4313  // 5 for 3S, first 11 54 - 64
4314  // 6 for 3S, second 12 65 - 76
4315  // 7 for 3L, first 13 77 - 89
4316  // 8 for 3L, second 14 90 - 103
4317  const int list[] = {10, 11, 15, 9, 9, 11, 12, 13, 14};
4318  int count = 0;
4319  chip--;
4320 
4321  for (int i = 0; i < 9; i++) {
4322  count += list[i];
4323 
4324  if (chip < count) return i + 1;
4325  else if (chip == 104) return 9;
4326  }
4327 
4328  assert(count == 104);
4329  assert(false); // should never come this far
4330  return -1;
4331 }

◆ chipToBoard_EndCap()

int TRT_Monitoring_Tool::chipToBoard_EndCap ( int  chip)
staticprivate

Definition at line 4334 of file TRT_Monitoring_Tool.cxx.

4334  {
4335 //----------------------------------------------------------------------------------//
4336  const int remainder = (chip - 1) % 12;
4337  const int Board = int(((chip - 1) - remainder) / 12);
4338  return Board + 1;
4339 }

◆ convertLWHists()

StatusCode ManagedMonitorToolBase::convertLWHists ( )
virtualinherited

Deal with the LW histograms.

Implements IMonitorToolBase.

Definition at line 1377 of file ManagedMonitorToolBase.cxx.

1379 {
1380  // note that managed histograms will be converted by regMonitoredLWHistograms
1381  // hence they are not in m_lwhists
1382  if (m_manager) {
1383  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1384  for (;it!=itE;++it)
1385  m_manager->writeAndDeleteLWHist( *it );
1386  m_lwhists.clear();
1387  }
1388  return StatusCode::SUCCESS;
1389 
1390 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph *  g)
virtualinherited

De-registers a TGraph from the THistSvc, but does NOT delete the object.

Definition at line 1843 of file ManagedMonitorToolBase.cxx.

1845 {
1846  return m_THistSvc->deReg( g );
1847 }

◆ deregHist() [1/2]

StatusCode ManagedMonitorToolBase::deregHist ( LWHist *  h)
virtualinherited

Definition at line 1826 of file ManagedMonitorToolBase.cxx.

1827 {
1828  std::set<LWHist*>::iterator it = m_lwhists.find(h);
1829  if (it==m_lwhists.end())
1830  return StatusCode::FAILURE;
1831  LWHistAthMonWrapper:: removeCustomData(h);
1832  m_lwhists.erase(it);
1833  if (h->usingROOTBackend()) {
1834  h->setOwnsROOTHisto(true);
1835  return m_THistSvc->deReg( h->getROOTHistBase() );
1836  }
1837 
1838  return StatusCode::SUCCESS;
1839 }

◆ deregHist() [2/2]

StatusCode ManagedMonitorToolBase::deregHist ( TH1 *  h)
virtualinherited

De-registers a TH1 from the THistSvc, but does NOT delete the object.

Definition at line 1819 of file ManagedMonitorToolBase.cxx.

1821 {
1822  return m_THistSvc->deReg( h );
1823 }

◆ deregObject() [1/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string &  objName,
const MonGroup &  group 
)
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1861 of file ManagedMonitorToolBase.cxx.

1863 {
1864  std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1865  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1866  for (;it!=itE;++it) {
1867  LWHist * hlw = *it;
1868  if (LWHistAthMonWrapper::key(hlw)==objName) {
1869  m_lwhists.erase(it);
1870  if (hlw->usingROOTBackend()) {
1871  hlw->setOwnsROOTHisto(true);
1872  return m_THistSvc->deReg( hlw->getROOTHistBase() );
1873  }
1874  return StatusCode::SUCCESS;
1875  }
1876  }
1877  return m_THistSvc->deReg( streamName );
1878 }

◆ deregObject() [2/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string &  objName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1851 of file ManagedMonitorToolBase.cxx.

1854 {
1855  MonGroup group( this, system, interval );
1856  return deregObject( objName, group );
1857 }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ divide_LWHist()

void TRT_Monitoring_Tool::divide_LWHist ( TH1F_LW *  result,
TH1F_LW *  a,
TH1F_LW *  b 
)
staticprivate

Definition at line 4392 of file TRT_Monitoring_Tool.cxx.

4392  {
4393 //----------------------------------------------------------------------------------//
4394  if (!result || !a || !b) return;
4395 
4396  if (result->GetXaxis()->GetNbins() != a->GetXaxis()->GetNbins() || b->GetXaxis()->GetNbins() != a->GetXaxis()->GetNbins()) return;
4397 
4398  result->Reset();
4399  unsigned index;
4400  double contentA, errorA;
4401  double contentB, errorB;
4402  a->resetActiveBinLoop();
4403 
4404  while (a->getNextActiveBin(index, contentA, errorA)) {
4405  b->GetBinContentAndError(index, contentB, errorB);
4406 
4407  if (contentB == 0)
4408  result->SetBinContentAndError(index, 0, 0);
4409  else
4410  result->SetBinContentAndError(index, contentA / contentB, 0);
4411  }
4412 
4413  result->SetEntries(a->GetEntries());
4414 }

◆ endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 856 of file ManagedMonitorToolBase.h.

856 { return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 857 of file ManagedMonitorToolBase.h.

857 { return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 858 of file ManagedMonitorToolBase.h.

858 { return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

859 { return m_endOfRun; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fillHistograms()

StatusCode TRT_Monitoring_Tool::fillHistograms ( )
virtual

An inheriting class should either override this function or fillHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 1111 of file TRT_Monitoring_Tool.cxx.

1111  {
1112 //----------------------------------------------------------------------------------//
1113  ATH_MSG_VERBOSE("Monitoring Histograms being filled");
1114 
1115  // Retrieve containers/objects only once per event
1116  // Dereference handles to pass them to methods
1117  SG::ReadHandle<TRT_RDO_Container> rdoContainer(m_rdoContainerKey);
1118  SG::ReadHandle<TrackCollection> trackCollection(m_trackCollectionKey);
1119  SG::ReadHandle<TrackCollection> combTrackCollection(m_combTrackCollectionKey);
1120  SG::ReadHandle<xAOD::EventInfo> xAODEventInfo(m_xAODEventInfoKey);
1121  SG::ReadHandle<InDetTimeCollection> trtBCIDCollection(m_TRT_BCIDCollectionKey);
1122  SG::ReadHandle<ComTime> comTimeObject(m_comTimeObjectKey);
1123  const xAOD::TrigDecision* trigDecision(nullptr);
1124  if (!m_trigDecisionKey.empty()) {
1125  SG::ReadHandle<xAOD::TrigDecision> htrigDecision{m_trigDecisionKey};
1126  if (htrigDecision.isValid()) {
1127  trigDecision = htrigDecision.get();
1128  }
1129  }
1130 
1131  if (!xAODEventInfo.isValid()) {
1132  ATH_MSG_ERROR("Could not find event info object " << m_xAODEventInfoKey.key() <<
1133  " in store");
1134  return StatusCode::FAILURE;
1135  }
1136 
1137  if (m_doRDOsMon) {
1138  if (!rdoContainer.isValid()) {
1139  ATH_MSG_ERROR("Could not find TRT Raw Data Object " << m_rdoContainerKey.key() <<
1140  " in store");
1141  return StatusCode::FAILURE;
1142  }
1143 
1144  ATH_CHECK( checkEventBurst(*rdoContainer) );
1145 
1146  if (m_passEventBurst) {
1147  m_totalEvents++;
1148  m_evtLumiBlock++;
1149  if (!trtBCIDCollection.isValid()) {
1150  ATH_MSG_INFO("Could not find BCID collection " << m_TRT_BCIDCollectionKey.key() <<
1151  " in store");
1152  }
1153 
1154  ATH_CHECK( fillTRTRDOs(*rdoContainer, *xAODEventInfo, trtBCIDCollection.ptr()) );
1155  }
1156  } else {
1157  m_totalEvents++;
1158  m_passEventBurst = true;
1159  m_evtLumiBlock++;
1160  }
1161 
1162  if (m_doTracksMon) {
1163  if (!trackCollection.isValid()) {
1164  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1165  " in store");
1166  return StatusCode::FAILURE;
1167  }
1168  if (!m_trigDecisionKey.empty() && !trigDecision) {
1169  ATH_MSG_INFO("Could not find trigger decision object " << m_trigDecisionKey.key() <<
1170  " in store");
1171  }
1172  // NOTE: failing to retrieve ComTime from store for some reason
1173  if (!comTimeObject.isValid()) {
1174  ATH_MSG_DEBUG("Could not find com time object " << m_comTimeObjectKey.key() <<
1175  " in store");
1176  }
1177  if (m_passEventBurst) {
1178  ATH_CHECK( fillTRTTracks(*trackCollection, trigDecision, comTimeObject.isValid() ? comTimeObject.cptr() : nullptr) );
1179  }
1180  }
1181 
1182  if (m_doEfficiency) {
1183  if (!combTrackCollection.isValid()) {
1184  ATH_MSG_ERROR("Could not find track collection " << m_combTrackCollectionKey.key() <<
1185  " in store");
1186  return StatusCode::FAILURE;
1187  }
1188 
1189  ATH_CHECK( fillTRTEfficiency(*combTrackCollection) );
1190  }
1191 
1192  if (!m_doTracksMon) {
1193  if (!trackCollection.isValid()) {
1194  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1195  " in store");
1196  return StatusCode::FAILURE;
1197  }
1198  }
1199 
1200  if (m_passEventBurst) {
1201  ATH_CHECK( fillTRTHighThreshold(*trackCollection, *xAODEventInfo) );
1202  }
1203 
1204  return StatusCode::SUCCESS;
1205 }

◆ fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( )
virtualinherited

Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, and TileDigitsMonTool.

Definition at line 792 of file ManagedMonitorToolBase.cxx.

794 {
795 
796  if (m_d->m_warnAboutMissingInitialize) {
797  m_d->m_warnAboutMissingInitialize = false;
798  msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
799  }
800 
801 
802  bool isNewEventsBlock = ( m_procNEventsProp > 0 && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
803  if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
804 
805  m_newLowStat = false;
806  m_newLumiBlock = false;
807  m_newRun = false;
808  newLowStat = false;
809  newLumiBlock = false;
810  newRun = false;
811 
812  m_newLowStatInterval = false;
813  m_newMedStatInterval = false;
814  m_newHigStatInterval = false;
815  newLowStatInterval = false;
816  newMedStatInterval = false;
817  newHigStatInterval = false;
818 
819  m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "") && (!m_trigDecTool.empty()) );
820 
821  if( m_manager != 0 ) {
822  m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
823  m_newRun = ( m_lastRun != m_manager->runNumber() );
824  newLumiBlock = m_newLumiBlock;
825  newRun = m_newRun;
826 
827  if(m_newRun) {
828  m_newLumiBlock = true;
829  newLumiBlock = m_newLumiBlock;
830  isNewEventsBlock = true;
831  }
832 
833  m_newEventsBlock = isNewEventsBlock;
834  newEventsBlock = m_newEventsBlock;
835 
836  if( m_newLumiBlock ) {
837  // check if a new LB interval has started
838  // lowest lumiBlockNumber() is 1
839  // m_lastLowStatInterval is -1 initially
840  int currentLB = m_manager->lumiBlockNumber();
841  int LBsLowStat = m_manager->getLBsLowStat();
842  int LBsMedStat = m_manager->getLBsMedStat();
843  int LBsHigStat = m_manager->getLBsHigStat();
844 
845  if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
846  msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
847  }
848  else {
849  if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
850  if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
851  if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
852  newLowStatInterval = m_newLowStatInterval;
853  newMedStatInterval = m_newHigStatInterval;
854  newHigStatInterval = m_newHigStatInterval;
855  }
856  }
857 
858  // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
859  // before updating them
860  }
861 
862 
863  StatusCode sc0( StatusCode::SUCCESS );
864  StatusCode sc1( StatusCode::SUCCESS );
865  StatusCode sc2( StatusCode::SUCCESS );
866  StatusCode sc3( StatusCode::SUCCESS );
867 
868  // Set end of LowStat, LumiBlock and Run variables
869  // These are needed to be used in procHistograms().
870  m_endOfEventsBlock = m_newEventsBlock;
871  m_endOfLowStat = m_newLowStatInterval;
872  m_endOfLumiBlock = m_newLumiBlock;
873  m_endOfRun = m_newRun;
874  endOfEventsBlock = m_newEventsBlock;
875  endOfLowStat = m_newLowStatInterval;
876  endOfLumiBlock = m_newLumiBlock;
877  endOfRun = m_newRun;
878 
879  // just duplicates m_newLowStatInterval
880  m_newLowStat = m_newLowStatInterval;
881  newLowStat = m_newLowStatInterval;
882 
883  if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
884  ATH_MSG_DEBUG("Interval transition processing");
885  // Process histograms from the previous lumiBlock/run
886  if( m_nEvents != 1 ) {
887  m_d->benchPreProcHistograms();
888  sc0 = procHistograms();
889  m_d->benchPostProcHistograms();
890  }
891  // Re-book new histograms
892  m_d->benchPreBookHistograms();
893 
894  if (!m_bookHistogramsInitial) {
895  sc1 = bookHistograms();
896  m_bookHistogramsInitial = true;
897  } else {
898  std::vector<Interval_t> intervals_to_process;
899  if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
900  if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
901  if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
902  if (m_newRun) intervals_to_process.push_back(run);
903  for (const auto interval: intervals_to_process) {
904  sc1 = regManagedHistograms(m_templateHistograms[interval]);
905  sc1 = regManagedGraphs(m_templateGraphs[interval]);
906  sc1 = regManagedTrees(m_templateTrees[interval]);
907  sc1 = regManagedLWHistograms(m_templateLWHistograms[interval]);
908  }
909  }
910  for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
911  for (const auto& it: m_templateHistograms[interval]) {
912  // is histogram too small in x axis for LB range?
913  if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
914  //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
915  while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
916  it.m_templateHist->LabelsInflate("X");
917  }
918  }
919  }
920  for (auto& it: m_templateEfficiencies[interval]) {
921  if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
922  // get the underlying passed and total TH1's from the TEfficiency
923  TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
924  TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
925  // inflate them until they exceed the lumi-block number
926  while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
927  passedHist->LabelsInflate("X");
928  totalHist->LabelsInflate("X");
929  }
930  // Replace them in the TEfficiency. First one has force ("f") option, since the
931  // histograms will not be consistent. This is corrected in the next line, so we
932  // do check for consistency then.
933  it.m_templateHist->SetPassedHistogram(*passedHist, "f");
934  it.m_templateHist->SetTotalHistogram(*totalHist, " ");
935  delete passedHist; // not owned by THistSvc, so need to be deleted.
936  delete totalHist;
937  }
938  }
939  }
940 
941  if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
942  streamname->updateRunLB();
943  }
944 
945  sc3 = bookHistogramsRecurrent( );
946 
947  m_d->benchPostBookHistograms();
948 
949  if (m_manager->forkedProcess()) {
950  ATH_MSG_INFO("Child process: Resetting all " << m_lwhists.size() << " LW Histograms");
951  for (LWHist* h : m_lwhists) {
952  h->Reset();
953  }
954  }
955  }//end if new RUN/LB/Block
956 
957  // check filters
958  bool filterresult(true);
959  if (! m_DQFilterTools.empty()) {
960  ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
961  for (; filterresult && (ifilter != filterend);
962  ++ifilter) {
963  filterresult = (filterresult && (*ifilter)->accept());
964  }
965  }
966 
967 
968  // ...and fill as normal
969  if(filterresult &&
970  (!m_useTrigger
971  || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
972  || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
973  ATH_MSG_DEBUG("Passed trigger, presumably");
974  m_d->benchPreFillHistograms();
975  fillHistograms().ignore();
976  m_haveClearedLastEventBlock = true;
977  m_d->benchPostFillHistograms();
978  ++m_nEvents;
979  } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
980 
981  ++m_nEventsIgnoreTrigger;
982  if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
983  ++m_nLumiBlocks;
984  }
985  if( m_manager != 0 ) {
986  m_lastRun = m_manager->runNumber();
987  if( m_newLumiBlock ) {
988  m_lastLumiBlock = m_manager->lumiBlockNumber();
989 
990  int LBsLowStat = m_manager->getLBsLowStat();
991  int LBsMedStat = m_manager->getLBsMedStat();
992  int LBsHigStat = m_manager->getLBsHigStat();
993  if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
994  if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
995  if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
996  if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
997  }
998  }
999  }
1000 
1001  return StatusCode::SUCCESS;
1002 }

◆ fillTRTEfficiency()

StatusCode TRT_Monitoring_Tool::fillTRTEfficiency ( const TrackCollection &  combTrackCollection)
private

Definition at line 3533 of file TRT_Monitoring_Tool.cxx.

3533  {
3534 //----------------------------------------------------------------------------------//
3535  ATH_MSG_VERBOSE("Filling TRT Eff Histos");
3536  // reduce unnecessary divisions
3537  const float invGeV = 1. / CLHEP::GeV;
3538  const float invmm = 1. / CLHEP::mm;
3539  int itrack = 0;
3540 
3541  for (auto track = combTrackCollection.begin(); track != combTrackCollection.end(); ++track) {
3542  // online: use all tracks, offline: use only every xth track, skip the rest
3543  if (m_environment != AthenaMonManager::online && (itrack % m_every_xth_track) != 0) continue;
3544 
3545  ++itrack;
3546  // get perigee
3547  const Trk::Perigee *perigee = (*track)->perigeeParameters();
3548 
3549  if (perigee) {
3550  m_track_pt = perigee->pT();
3551  m_track_eta = perigee->eta();
3552  m_track_phi = perigee->parameters()[Trk::phi0];
3553  m_track_d0 = perigee->parameters()[Trk::d0];
3554  m_track_z0 = perigee->parameters()[Trk::z0];
3555  ATH_MSG_DEBUG("This track has perigee parameters:\n"
3556  << " pT = " << m_track_pt * invGeV << " GeV" << "\n"
3557  << " eta = " << m_track_eta << "\n"
3558  << " phi0 = " << m_track_phi << "\n"
3559  << " d0 = " << m_track_d0 * invmm << "\n"
3560  << " z0 = " << m_track_z0 * invmm << "\n"
3561  << " theta = " << perigee->parameters()[Trk::theta] << "\n"
3562  << " qOverP = " << perigee->parameters()[Trk::qOverP]);
3563  } else {
3564  ATH_MSG_DEBUG("This track has null perigeeParameters.");
3565  continue;
3566  }
3567 
3568  const Trk::TrackStates *track_states = (*track)->trackStateOnSurfaces();
3569 
3570  if (track_states) {
3571  ATH_MSG_DEBUG("This track has " << track_states->size() << " track states on surface.");
3572  } else {
3573  ATH_MSG_DEBUG("This track has null track states on surface.");
3574  continue;
3575  }
3576 
3577  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*track));
3578  int n_trt_hits = summary->get(Trk::numberOfTRTHits);
3579  int n_sct_hits = summary->get(Trk::numberOfSCTHits);
3580  int n_pixel_hits = summary->get(Trk::numberOfPixelHits);
3581  float p = 1.0e+08;
3582 
3583  if (perigee) {
3584  p = (perigee->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (perigee->parameters()[Trk::qOverP])) : 1.0e+08;
3585  }
3586 
3587  float min_pt_new = m_min_pT;
3588 
3589  if (!m_isCosmics) {
3590  min_pt_new = 2.0 * CLHEP::GeV;
3591  }
3592 
3593  // preselect tracks
3594  const bool passed_track_preselection =
3595  (fabs(perigee->parameters()[Trk::d0]) < m_max_abs_d0) &&
3596  (fabs(perigee->parameters()[Trk::z0]) < m_max_abs_z0) &&
3597  (perigee->pT() > min_pt_new) &&
3598  (p > m_minP) &&
3599  (fabs(perigee->eta()) < m_max_abs_eta) &&
3600  (n_pixel_hits >= m_min_pixel_hits) &&
3601  (n_sct_hits >= m_min_sct_hits) &&
3602  (n_trt_hits >= m_min_trt_hits);
3603  ATH_MSG_DEBUG("track has ntrt = " << n_trt_hits
3604  << " and nsct = " << n_sct_hits
3605  << " and npix = " << n_pixel_hits);
3606 
3607  if (!passed_track_preselection) {
3608  ATH_MSG_DEBUG("This track failed preselection.");
3609  continue;
3610  }
3611 
3612  ATH_MSG_DEBUG("This track passed preselection.");
3613 
3614  for (auto it = track_states->begin(); it != track_states->end(); it++) {
3615  if ( !((*it)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
3616 
3617  const Trk::TrackParameters *track_parameters = (*it)->trackParameters();
3618 
3619  if (!track_parameters) continue;
3620 
3621  Identifier id = track_parameters->associatedSurface().associatedDetectorElementIdentifier();
3622 
3623  if ( !((m_pTRTHelper->is_trt(id)) )) continue;
3624 
3625  float locR = track_parameters->parameters()[Trk::driftRadius];
3626  int barrel_ec = m_pTRTHelper->barrel_ec(id);
3627  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(id);
3628  int phi_module = m_pTRTHelper->phi_module(id);
3629  int straw_layer = m_pTRTHelper->straw_layer(id);
3630  int straw = m_pTRTHelper->straw(id);
3631  const bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(id) ) == GasType::Ar);
3632  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3633  // ibe = 0 (Barrel), ibe = 1 (Endcap)
3634  int ibe = abs(barrel_ec) - 1;
3635  // iside = 0 (Side A), iside = 1 (Side C)
3636  int iside = barrel_ec > 0 ? 0 : 1;
3637 
3638  if (ibe == 0) {
3639  if (isArgonStraw) {
3640  m_hefficiencyBarrel_locR_Ar->Fill(locR, 1.0);
3641  } else {
3642  m_hefficiencyBarrel_locR->Fill(locR, 1.0);
3643  }
3644  } else if (ibe == 1) {
3645  if (isArgonStraw) {
3646  m_hefficiencyEndCap_locR_Ar[iside]->Fill(locR, 1.0);
3647  } else {
3648  m_hefficiencyEndCap_locR[iside]->Fill(locR, 1.0);
3649  }
3650  }
3651 
3652  if (fabs(locR) >= 1.3) continue;
3653 
3654  int thisStrawNumber = 0;
3655  int chip = 0;
3656 
3657  if (ibe == 0) {
3658  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
3659 
3660  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe])
3661  chip = m_mat_chip_B[phi_module][thisStrawNumber];
3662  } else if (ibe == 1) {
3663  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
3664 
3665  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe])
3666  chip = m_mat_chip_E[phi_module][thisStrawNumber];
3667  }
3668 
3669  m_hefficiencyMap[ibe]->Fill(thisStrawNumber, 1.0);
3670 
3671  if (m_doExpert) {
3672  if (iside == 0) {
3673  m_hefficiencyS[ibe][phi_module]->Fill(thisStrawNumber, 1.0);
3674  m_hefficiencyC[ibe][phi_module]->Fill(chip, 1.0);
3675  } else if (iside == 1) {
3676  m_hefficiencyS[ibe][phi_module + 32]->Fill(thisStrawNumber, 1.0);
3677  m_hefficiencyC[ibe][phi_module + 32]->Fill(chip, 1.0);
3678  }
3679  }
3680 
3681  m_hefficiency_eta->Fill(m_track_eta, 1.0);
3682  m_hefficiency_phi->Fill(m_track_phi, 1.0);
3683  m_hefficiency_pt->Fill(m_track_pt * invGeV, 1.0);
3684  m_hefficiency_z0->Fill(m_track_z0, 1.0);
3685  }
3686 
3687  //use hole finder to find holes on this track !
3688 
3689  if (m_useHoleFinder) {
3690  std::unique_ptr<const Trk::TrackStates> holes (m_trt_hole_finder->getHolesOnTrack(**track));
3691 
3692  if (!holes) {
3693  ATH_MSG_WARNING("TRTTrackHoleSearchTool returned null results.");
3694  continue;
3695  } else {
3696  for (auto it = holes->begin(); it != holes->end(); ++it) {
3697  if ( !((*it)->type(Trk::TrackStateOnSurface::Hole)) ) continue;
3698 
3699  const Trk::TrackParameters *track_parameters = (*it)->trackParameters();
3700 
3701  if (!track_parameters) continue;
3702 
3703  Identifier id = track_parameters->associatedSurface().associatedDetectorElementIdentifier();
3704 
3705  if ( !(m_pTRTHelper->is_trt(id)) ) continue;
3706 
3707  float locR = track_parameters->parameters()[Trk::driftRadius];
3708  int barrel_ec = m_pTRTHelper->barrel_ec(id);
3709  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(id);
3710  int phi_module = m_pTRTHelper->phi_module(id);
3711  int straw_layer = m_pTRTHelper->straw_layer(id);
3712  int straw = m_pTRTHelper->straw(id);
3713  const bool isArgonStraw = Straw_Gastype( m_sumTool->getStatusHT(id) ) == GasType::Ar;
3714  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3715  // ibe = 0 (Barrel), ibe = 1 (Endcap)
3716  int ibe = abs(barrel_ec) - 1;
3717  // iside = 0 (Side A), iside = 1 (Side C)
3718  int iside = barrel_ec > 0 ? 0 : 1;
3719 
3720  if (ibe == 0) {
3721  if (isArgonStraw) {
3722  m_hefficiencyBarrel_locR_Ar->Fill(locR, 0.0);
3723  } else {
3724  m_hefficiencyBarrel_locR->Fill(locR, 0.0);
3725  }
3726  } else if (ibe == 1) {
3727  if (isArgonStraw) {
3728  m_hefficiencyEndCap_locR_Ar[iside]->Fill(locR, 0.0);
3729  } else {
3730  m_hefficiencyEndCap_locR[iside]->Fill(locR, 0.0);
3731  }
3732  }
3733 
3734  if (fabs(locR) >= 1.3) continue;
3735 
3736  int thisStrawNumber = 0;
3737  int chip = 0;
3738 
3739  if (ibe == 0) {
3740  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
3741 
3742  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
3743  chip = m_mat_chip_B[phi_module][thisStrawNumber];
3744  }
3745  } else if (ibe == 1) {
3746  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
3747 
3748  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
3749  chip = m_mat_chip_E[phi_module][thisStrawNumber];
3750  }
3751  }
3752 
3753  m_hefficiencyMap[ibe]->Fill(thisStrawNumber, 0.0);
3754 
3755  if (m_doExpert) {
3756  if (iside == 0) {
3757  m_hefficiencyS[ibe][phi_module]->Fill(thisStrawNumber, 0.0);
3758  m_hefficiencyC[ibe][phi_module]->Fill(chip, 0.0);
3759  } else if (iside == 1) {
3760  m_hefficiencyS[ibe][phi_module + 32]->Fill(thisStrawNumber, 0.0);
3761  m_hefficiencyC[ibe][phi_module + 32]->Fill(chip, 0.0);
3762  }
3763  }
3764 
3765  m_hefficiency_eta->Fill(m_track_eta, 0.0);
3766  m_hefficiency_phi->Fill(m_track_phi, 0.0);
3767  m_hefficiency_pt->Fill(m_track_pt * invGeV, 0.0);
3768  m_hefficiency_z0->Fill(m_track_z0, 0.0);
3769  }
3770 
3771  }
3772  }
3773  }
3774 
3775  double n_BorE[2][2];
3776  double total_BorE[2][2];
3777 
3778  for (int ibe = 0; ibe < 2; ibe++) {
3779  for (int iside = 0; iside < 2; iside++) {
3780  m_hefficiency[ibe][iside]->Reset();
3781  m_hefficiencyIntegral[ibe][iside]->Reset();
3782 
3783  for (int i = 0; i < 32; i++) {
3784  for (int ibin = 0; ibin <= s_Straw_max[ibe]; ibin++) {
3785  if (m_doExpert) {
3786  if (m_hefficiencyS[ibe][i + (32 * iside)]->GetBinEntries(ibin) > m_min_tracks_straw)
3787  m_hefficiency[ibe][iside]->Fill(m_hefficiencyS[ibe][i + (32 * iside)]->GetBinContent(ibin));
3788  }
3789  }
3790  }
3791 
3792  n_BorE[ibe][iside] = m_hefficiency[ibe][iside]->GetEntries();
3793  total_BorE[ibe][iside] = 0.0;
3794 
3795  for (UInt_t ibin = 0; ibin <= m_hefficiency[ibe][iside]->GetXaxis()->GetNbins(); ibin++) {
3796  total_BorE[ibe][iside] += m_hefficiency[ibe][iside]->GetBinContent(ibin);
3797  m_hefficiencyIntegral[ibe][iside]->SetBinContent(ibin, n_BorE[ibe][iside] != 0.0 ? total_BorE[ibe][iside] / n_BorE[ibe][iside] : 0.0);
3798  }
3799  }
3800  }
3801 
3802  return StatusCode::SUCCESS;
3803 }

◆ fillTRTHighThreshold()

StatusCode TRT_Monitoring_Tool::fillTRTHighThreshold ( const TrackCollection &  trackCollection,
const xAOD::EventInfo &  eventInfo 
)
private

Definition at line 3807 of file TRT_Monitoring_Tool.cxx.

3808  {
3809 //----------------------------------------------------------------------------------//
3810  ATH_MSG_VERBOSE("");
3811  DataVector<Trk::Track>::const_iterator p_trk;
3812  const Trk::Perigee *perigee = nullptr;
3813  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
3814  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
3815  int lumiBlockNumber;
3816  int timeStamp;
3817  lumiBlockNumber = eventInfo.lumiBlock();
3818  timeStamp = eventInfo.timeStamp();
3819 
3820  if (timeStamp > m_maxtimestamp) {
3821  m_maxtimestamp = timeStamp;
3822  }
3823 
3824  int runNumber;
3825  runNumber = eventInfo.runNumber();
3826  // get Online Luminosity
3827  double intLum = (this->lbDuration() * this->lbAverageLuminosity());
3828  double timeStampAverage = (m_maxtimestamp - 0.5 * this->lbDuration());
3829  m_IntLum->SetBinContent(1, intLum);
3830  m_LBvsLum->SetBinContent(lumiBlockNumber, intLum);
3831  m_LBvsTime->SetBinContent(lumiBlockNumber, timeStampAverage);
3832 
3833  for (p_trk = trackCollection.begin(); p_trk != trackCollection.end(); ++p_trk) {
3834  AllTrkPar = (*p_trk)->trackParameters();
3835 
3836  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
3837  if ((perigee = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
3838  }
3839 
3840  //if you went through all of the track parameters and found no perigee mearsurement
3841  //then something is wrong with the track and so don't use the track.
3842  //i.e. continue to the next track.
3843  if (!perigee) continue;
3844 
3845  float track_eta = perigee->eta();
3846  float track_p = (perigee->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (perigee->parameters()[Trk::qOverP])) : 10e7;
3847  const Trk::TrackStates *trackStates = (**p_trk).trackStateOnSurfaces();
3848 
3849  if (trackStates == nullptr) continue;
3850 
3851  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
3852  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
3853  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*p_trk));
3854  int trt_hits = summary->get(Trk::numberOfTRTHits);
3855  int sct_hits = summary->get(Trk::numberOfSCTHits);
3856  int pixel_hits = summary->get(Trk::numberOfPixelHits);
3857 
3858  if (fabs(track_eta) > 2.5) continue;
3859  if (fabs(track_p) < 5000.) continue;
3860  if (pixel_hits < 1.) continue;
3861  if (sct_hits < 6.) continue;
3862  if (trt_hits < 6.) continue;
3863 
3864  //Now we have hit informations
3865  const Trk::TrackStates *track_states = (*p_trk)->trackStateOnSurfaces();
3866 
3867  if (track_states) {
3868  ATH_MSG_DEBUG("This track has " << track_states->size() << " track states on surface.");
3869  } else {
3870  ATH_MSG_DEBUG("This track has null track states on surface.");
3871  continue;
3872  }
3873 
3874  int barrel_ec_side = 0;
3875  int layer_or_wheel = 0;
3876  int phi_module = 0;
3877  int straw_layer = 0;
3878 
3879  for (; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
3880  if ((*TSOSItBegin) == nullptr) continue;
3881  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
3882 
3883  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
3884  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
3885 
3886  if (!trtCircle) continue;
3887  if (!aTrackParam) continue;
3888 
3889  Identifier DCoTId = trtCircle->identify();
3890  barrel_ec_side = m_pTRTHelper->barrel_ec(DCoTId);
3891  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
3892  phi_module = m_pTRTHelper->phi_module(DCoTId);
3893  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
3894  //Ba_Ec: 0 is barrel 1 is Endcap
3895  //Side : 0 is side_A 1 is side_C
3896  int Ba_Ec = abs(barrel_ec_side) - 1;
3897  int Side = barrel_ec_side > 0 ? 0 : 1;
3898  double xPos = trtCircle->globalPosition().x(); // global x coordinate
3899  double yPos = trtCircle->globalPosition().y(); // global y coordinate
3900  double zPos = trtCircle->globalPosition().z(); // global z coordinate
3901  double RPos = sqrt(xPos * xPos + yPos * yPos);
3902  Identifier surfaceID;
3903  surfaceID = trtCircle->identify();
3904  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3905  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
3906 
3907  if (!RawDriftCircle) { //coverity 25097
3908  //This shouldn't happen in normal conditions because trtCircle is a TRT_DriftCircleOnTrack object
3909  ATH_MSG_WARNING("RawDriftCircle object returned null");
3910  continue;
3911  }
3912 
3913  int middleHTbit = RawDriftCircle->getWord() & 0x00020000;
3914  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
3915  bool is_middleHTbit_high = (middleHTbit != 0);
3916  //bool isHighLevel= RawDriftCircle->highLevel();
3917  bool isHighLevel = is_middleHTbit_high; //Hardcoded HT Middle Bit
3918  bool shortStraw = false;
3919  int InputBar = 0;
3920 
3921  if (fabs(track_eta) < 2. && Ba_Ec == 0.) {
3922  if ((layer_or_wheel == 0) && (phi_module < 4 || (phi_module > 7 && phi_module < 12) || (phi_module > 15 && phi_module < 20) || (phi_module > 23 && phi_module < 28))) InputBar = 1;
3923  else if ((runNumber >= 296939) && (layer_or_wheel == 0) && (phi_module > 27)) InputBar = 1;
3924  else if (layer_or_wheel == 0)
3925  InputBar = 0;
3926  else if ((layer_or_wheel == 1) && ((phi_module > 1 && phi_module < 6) || (phi_module > 9 && phi_module < 14) || (phi_module > 17 && phi_module < 22) || (phi_module > 25 && phi_module < 30)))
3927  InputBar = 1;
3928  else if (layer_or_wheel == 1)
3929  InputBar = 0;
3930  else if (layer_or_wheel == 2 && phi_module % 2 != 0)
3931  InputBar = 1;
3932  else if (layer_or_wheel == 2)
3933  InputBar = 0;
3934  else {
3935  ATH_MSG_WARNING("Should not pass here");
3936  continue;
3937  }
3938 
3939  if ((layer_or_wheel == 0) && straw_layer < 9.)
3940  shortStraw = true;
3941  }
3942 
3943  //Fill Barrel Plots
3944  if ((!shortStraw) && (Ba_Ec == 0)) {
3945  m_trackz_All[layer_or_wheel][InputBar]->Fill(zPos);
3946  if (isHighLevel)
3947  m_trackz_HT[layer_or_wheel][InputBar]->Fill(zPos);
3948  }
3949 
3950  if (shortStraw) {
3951  if (zPos > 0.) {
3952  m_trackz_All[3][InputBar]->Fill(zPos);
3953  if (isHighLevel)
3954  m_trackz_HT[3][InputBar]->Fill(zPos);
3955  } else {
3956  m_trackz_All[4][InputBar]->Fill(zPos);
3957 
3958  if (isHighLevel)m_trackz_HT[4][InputBar]->Fill(zPos);
3959  }
3960  }
3961 
3962  //End of Barrel Plots, begin EC plots
3963  int WType = -1;
3964 
3965  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
3966  ((straw_layer > 3 && straw_layer < 8) ||
3967  (straw_layer > 11))) {
3968  WType = 0;
3969  }
3970  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
3971  (straw_layer > 3)) {
3972  WType = 3;
3973  }
3974  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
3975  ((straw_layer > -1 && straw_layer < 4) ||
3976  (straw_layer > 7 && straw_layer < 12))) {
3977  WType = 2;
3978  }
3979  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
3980  ((straw_layer > -1 && straw_layer < 4))) {
3981  WType = 1;
3982  }
3983 
3984  if (WType < 0 && Ba_Ec == 1) { //Coverity CID 25096
3985  ATH_MSG_WARNING("The variable \"WType\" is less than zero!.");
3986  continue;
3987  }
3988 
3989  if (Ba_Ec == 1) {
3990  m_trackr_All[WType][Side]->Fill(RPos);
3991  if (isHighLevel)m_trackr_HT[WType][Side]->Fill(RPos);
3992  }
3993  }
3994  }
3995 
3996  return StatusCode::SUCCESS;
3997 }

◆ fillTRTRDOs()

StatusCode TRT_Monitoring_Tool::fillTRTRDOs ( const TRT_RDO_Container &  rdoContainer,
const xAOD::EventInfo &  eventInfo,
const InDetTimeCollection *  trtBCIDCollection 
)
private

Definition at line 1780 of file TRT_Monitoring_Tool.cxx.

1782  {
1783 //----------------------------------------------------------------------------------//
1784  ATH_MSG_DEBUG("Filling TRT RDO Histograms");
1785  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
1786  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
1787  //Check readout Integrity of TRT
1788  ATH_CHECK( checkTRTReadoutIntegrity(eventInfo) );
1789  int numberOfStacks_b[2]; //Total stack number of barrel and endcap
1790  numberOfStacks_b[0] = s_numberOfBarrelStacks * 3;
1791  numberOfStacks_b[1] = s_numberOfEndCapStacks * 2;
1792  Identifier TRT_Identifier;
1793  int numberOfStrawsMod[3]; // For barrel(number if straw in module)
1794  numberOfStrawsMod[0] = 329;
1795  numberOfStrawsMod[1] = 520;
1796  numberOfStrawsMod[2] = 793;
1797  int numberOfStrawsWheel[2]; // For endcap
1798  numberOfStrawsWheel[0] = 2304; //6 layers (6*16=96) 96*24=2304 straws in wheel type A
1799  numberOfStrawsWheel[1] = 1536; //8 layers (8*8=64) 64*24=1536 straws in wheel type B
1800  int moduleHits_B[192];
1801  int moduleHits_E[128];
1802  int HLmoduleHits_B[192];
1803  int HLmoduleHits_E[128];
1804 
1805  for (int i = 0; i < 192; i++) {
1806  moduleHits_B[i] = 0;
1807  HLmoduleHits_B[i] = 0;
1808  }
1809 
1810  for (int i = 0; i < 128; i++) {
1811  moduleHits_E[i] = 0;
1812  HLmoduleHits_E[i] = 0;
1813  }
1814 
1815  int goodid_status = 0;
1816  int prev_bcid = 0;
1817 
1818  if (trtBCIDCollection) {
1819  InDetTimeCollection::const_iterator itrt_bcid = trtBCIDCollection->begin();
1820 
1821  while (goodid_status == 0 && itrt_bcid != trtBCIDCollection->end()) {
1822  const unsigned int trt_bcid = (*itrt_bcid).second;
1823 
1824  if (itrt_bcid > trtBCIDCollection->begin() && prev_bcid - trt_bcid == 0) {
1825  goodid_status = 1;
1826  } else if (itrt_bcid > trtBCIDCollection->begin() && prev_bcid - trt_bcid != 0) {
1827  ATH_MSG_WARNING("TRT BCID is not consistent. TRT RODID is " <<
1828  std::hex << (*itrt_bcid).first << " trt bcid from ROD is " <<
1829  std::hex << trt_bcid);
1830  }
1831 
1832  prev_bcid = trt_bcid;
1833  ++itrt_bcid;
1834  }
1835  }
1836 
1837  // Test out the TRT_StrawStatusSummarySvc.
1838  if (!m_sumTool.name().empty() && m_doExpert) {
1839  ATH_MSG_VERBOSE("Trying " << m_sumTool << " isGood");
1840  ATH_MSG_VERBOSE("TRT_StrawStatusTool reports status = " << m_sumTool->getStatus(TRT_Identifier));
1841  }
1842 
1843  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1844  for (int ibe = 0; ibe < 2; ibe++) {
1845  m_nTRTHits[ibe] = 0;
1846 
1847  //Take out normalization from previous event for online environment
1848  //Explanation: While online monitoring running we need to present out histograms repeatedly so we need to pay attention to normalization.
1849  //before adding any information from new event to normalized histograms we need to take out the normalization of the previous event by scaling histograms back.
1850  //After we are done with filling those histograms we will normalize them again
1851  if (m_environment == AthenaMonManager::online && m_totalEvents > 0) {
1852  //Loop over stack histograms and normalize to number of events processed.
1853  if (m_doChips && m_doExpert) {
1854  for (int i = 0; i < 64; i++) {
1855  float scale = (m_totalEvents - 1) * 16;
1856  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
1857  scale_LWHist(m_hHitWMapC[ibe][i], scale);
1858  scale_LWHist(m_hHitAMapC[ibe][i], scale);
1859  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
1860  scale_LWHist(m_hHitHMapC[ibe][i], scale);
1861  }
1862  }
1863 
1864  if (m_doStraws) {
1865  if (ibe == 0) {
1866  initScaleVectors();
1867  vector<float> scalevector;
1868  vector<float> scalevector_Ar;
1869 
1870  for (int k = 0; k < s_Straw_max[0]; k++) {
1871  try {
1872  if (m_scale_hHitWMap_B.at(k) == 0.) {
1873  scalevector.push_back(0.);
1874  } else {
1875  scalevector.push_back((m_totalEvents - 1) * m_scale_hHitWMap_B.at(k));
1876  }
1877  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
1878  scalevector_Ar.push_back(0.);
1879  } else {
1880  scalevector_Ar.push_back((m_totalEvents - 1) * m_scale_hHitWMap_B_Ar.at(k));
1881  }
1882  } catch (out_of_range &e) {
1883  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
1884  }
1885  }
1886 
1887  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
1888 
1889  if (m_ArgonXenonSplitter) {
1890  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
1891  }
1892  } else if (ibe == 1) {
1893  float scale = (m_totalEvents - 1) * 32;
1894  scale_LWHist(m_hHitWMap_E[0], scale);
1895  scale_LWHist(m_hHitWMap_E[1], scale);
1896 
1897  if (m_ArgonXenonSplitter) {
1898  scale_LWHist(m_hHitWMap_E_Ar[0], scale);
1899  scale_LWHist(m_hHitWMap_E_Ar[1], scale);
1900  }
1901  }
1902 
1903  if (m_doExpert) {
1904  for (int i = 0; i < 64; i++) {
1905  float scale = m_totalEvents - 1;
1906  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
1907  scale_LWHist(m_hHitWMapS[ibe][i], scale);
1908  scale_LWHist(m_hHitAMapS[ibe][i], scale);
1909  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
1910  scale_LWHist(m_hHitHMapS[ibe][i], scale);
1911  }
1912  }
1913  }
1914  }
1915  }
1916 
1917  int nhitsall = 0;
1918 
1919  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
1920  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
1921 
1922  if (!TRT_Collection) continue;
1923 
1924  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
1925 
1926  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
1927  int middleHTbit = (*p_rdo)->getWord() & 0x00020000;
1928  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
1929  int hitinvaliditygate = (*p_rdo)->getWord() & 0x000DFE80;
1930  //0x000DFE80 = 0000 0000 0000 0000 0000 1101 1111 1110 1000 0000 //
1931  bool is_middleHTbit_high = (middleHTbit != 0);
1932  bool is_anybininVgate_high = (hitinvaliditygate != 0);
1933  TRT_Identifier = (*p_rdo)->identify();
1934 
1935  if (m_doMaskStraws && m_sumTool->get_status(TRT_Identifier)) continue;
1936 
1937  int barrel_ec = m_pTRTHelper->barrel_ec(TRT_Identifier);
1938  //ToDo: Check TRT_LoLumRawData object
1939  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
1940 
1941  if (!p_lolum) continue;
1942 
1943  nhitsall++;
1944  int ibe = abs(barrel_ec) - 1;
1945  int iside = barrel_ec > 0 ? 0 : 1;
1946 
1947  //if barrel_ec is outof range go to next measurement in rdo_collection
1948  if (ibe != 1 && ibe != 0) {
1949  ATH_MSG_DEBUG("TRT part retrieved from TRT Identifier is not a barrel or an endcap");
1950  continue;
1951  }
1952 
1953  int moduleNumber_barrel1[2];
1954  int moduleNumber_barrel2[2];
1955  int moduleNumber_barrel3[2];
1956  int moduleNumber_endcapA[2];
1957  int moduleNumber_endcapB[2];
1958  // Get TRT Identifier
1959  // Need to know phi module, module layer, straw layer, and straw # within the layer
1960  // To get proper straw numbering
1961  TRT_Identifier = p_lolum->identify();
1962  //inline function checks m_ArgonXenonSplitter
1963  const bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(TRT_Identifier) ) == GasType::Ar);
1964  int phi_module = m_pTRTHelper->phi_module(TRT_Identifier);
1965  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(TRT_Identifier);
1966  int straw_layer = m_pTRTHelper->straw_layer(TRT_Identifier);
1967  int straw = m_pTRTHelper->straw(TRT_Identifier);
1968  int thisStrawNumber;
1969  int chip = 0;
1970  int board = -1;
1971  //ToDo: Check if that is really neccessary
1972  bool is_barrel = m_pTRTHelper->is_barrel(TRT_Identifier);
1973 
1974  //check straw number and find the correct chip and m_ board values
1975  if ( is_barrel && ibe == 0 ) {
1976  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
1977 
1978  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
1979  chip = m_mat_chip_B[phi_module][thisStrawNumber];
1980  }
1981 
1982  board = chipToBoard(chip);
1983  } else if ( !is_barrel && ibe == 1 ) {
1984  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
1985 
1986  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
1987  chip = m_mat_chip_E[phi_module][thisStrawNumber];
1988  }
1989 
1990  board = chipToBoard_EndCap(chip);
1991  } else {
1992  thisStrawNumber = -1;
1993  }
1994 
1995  if (thisStrawNumber < 0 || thisStrawNumber >= s_Straw_max[ibe]) {
1996  ATH_MSG_WARNING("Found m_strawNumber = " << thisStrawNumber << " out of range.");
1997  continue;
1998  }
1999 
2000  const int driftTimeBin = p_lolum->driftTimeBin();
2001  const int trailingEdge = p_lolum->trailingEdge();
2002  const bool highlevel = is_middleHTbit_high;//Hardcoded Middle Bit
2003  const bool firstBinHigh = p_lolum->firstBinHigh(); // if the first time bin is up then the hit is out of time window
2004  const bool lastBinHigh = p_lolum->lastBinHigh(); // if the last bin is up then the hit is out of time window.
2005  const float timeOverThreshold = p_lolum->timeOverThreshold();
2006  moduleNumber_barrel1[0] = phi_module;
2007  moduleNumber_barrel1[1] = phi_module + 96;
2008  moduleNumber_barrel2[0] = phi_module + s_numberOfBarrelStacks;
2009  moduleNumber_barrel2[1] = phi_module + s_numberOfBarrelStacks + 96;
2010  moduleNumber_barrel3[0] = phi_module + 2 * s_numberOfBarrelStacks;
2011  moduleNumber_barrel3[1] = phi_module + 2 * s_numberOfBarrelStacks + 96;
2012  moduleNumber_endcapA[0] = phi_module;
2013  moduleNumber_endcapA[1] = phi_module + 64;
2014  moduleNumber_endcapB[0] = phi_module + s_numberOfEndCapStacks;
2015  moduleNumber_endcapB[1] = phi_module + s_numberOfEndCapStacks + 64;
2016  int iphi_module = -999;
2017 
2018  if (iside == 0) {
2019  iphi_module = phi_module;
2020  } else if (iside == 1) {
2021  iphi_module = phi_module + 32;
2022  }
2023 
2024  if (ibe == 0) {
2025  m_nTRTHits[ibe]++;
2026 
2027  if (m_doStraws) {
2028  if (isArgonStraw) {
2029  m_hHitWMap_B_Ar->Fill(thisStrawNumber);
2030  } else {
2031  m_hHitWMap_B->Fill(thisStrawNumber);
2032  }
2033  }
2034 
2035  if (m_doShift) {
2036  m_nHitsperLB_B++;
2037 
2038  if (highlevel) {
2039  m_nHLHitsperLB_B++;
2040  }
2041  }
2042  } else if (ibe == 1) {
2043  m_nTRTHits[ibe]++;
2044 
2045  if (m_doStraws) {
2046  if (isArgonStraw) {
2047  m_hHitWMap_E_Ar[iside]->Fill(thisStrawNumber);
2048  } else {
2049  m_hHitWMap_E[iside]->Fill(thisStrawNumber);
2050  }
2051  }
2052 
2053  if (m_doShift) {
2054  m_nHitsperLB_E[iside]++;
2055 
2056  if (highlevel) {
2057  m_nHLHitsperLB_E[iside]++;
2058  }
2059  }
2060  }
2061 
2062  if (m_doExpert) {
2063  if ( (driftTimeBin > 2) && (driftTimeBin < 17) ) {
2064  if (m_doStraws) m_hHitWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2065 
2066  if (m_doChips) m_hHitWMapC[ibe][iphi_module]->Fill(chip - 1);
2067  }
2068 
2069  float trailingEdgeScaled = (trailingEdge + 1) * 3.125;
2070 
2071  if ((trailingEdge < 23) && !lastBinHigh && !firstBinHigh) {
2072  if (m_doStraws) m_hHitTrWMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2073 
2074  if (m_doChips) m_hHitTrWMapC[ibe][iphi_module]->Fill((chip - 1), trailingEdgeScaled);
2075  }
2076 
2077  if (m_doStraws) m_hHitTrMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2078 
2079  if (m_doChips) m_hHitTrMapC[ibe][iphi_module]->Fill((chip - 1), trailingEdgeScaled);
2080 
2081  if (highlevel) {
2082  if (m_doStraws) m_hHitHMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2083 
2084  if (m_doChips) m_hHitHMapC[ibe][iphi_module]->Fill(chip - 1);
2085 
2086 
2087  if (m_doStraws) m_hHitHWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2088 
2089  if (m_doChips) m_hHitHWMapC[ibe][iphi_module]->Fill(chip - 1);
2090 
2091  }
2092 
2093  if (firstBinHigh || lastBinHigh || driftTimeBin > 0 || trailingEdge < 23) {
2094  if (m_doStraws) m_hHitAMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2095 
2096  if (m_doChips) m_hHitAMapC[ibe][iphi_module]->Fill(chip - 1);
2097  }
2098 
2099  if ( is_anybininVgate_high) {
2100  if (m_doStraws) m_hHitAWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2101 
2102  if (m_doChips) m_hHitAWMapC[ibe][iphi_module]->Fill(chip - 1);
2103  }
2104 
2105  if (m_doStraws) {
2106  m_hHitToTMapS[ibe][iphi_module]->Fill(thisStrawNumber, timeOverThreshold);
2107 
2108  if (timeOverThreshold > m_longToTCut) {
2109  m_hHitToTLongMapS[ibe][iphi_module]->Fill(thisStrawNumber, timeOverThreshold);
2110  m_hHitToTLongTrMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2111  }
2112  }
2113 
2114  if (m_doChips) m_hHitToTMapC[ibe][iphi_module]->Fill((chip - 1), timeOverThreshold);
2115 
2116  if (m_doChips) {
2117  if (p_lolum->highLevel(1)) {
2118  m_hHtoBCMapC[ibe][iphi_module]->Fill(0., chip - 1);
2119  m_hHtoBCMapB[ibe][iphi_module]->Fill(0., board - 1);
2120  }
2121 
2122  if (p_lolum->highLevel(2)) {
2123  m_hHtoBCMapC[ibe][iphi_module]->Fill(1., chip - 1);
2124  m_hHtoBCMapB[ibe][iphi_module]->Fill(1., board - 1);
2125  }
2126 
2127  if (p_lolum->highLevel(3)) {
2128  m_hHtoBCMapC[ibe][iphi_module]->Fill(2., chip - 1);
2129  m_hHtoBCMapB[ibe][iphi_module]->Fill(2., board - 1);
2130  }
2131  }
2132  }
2133 
2134  //Set Module Numbers.
2135  int moduleNumber = -1;
2136 
2137  if (ibe == 0) {
2138  if (layer_or_wheel == 0) {
2139  moduleNumber = moduleNumber_barrel1[iside];
2140  moduleHits_B[moduleNumber]++;
2141  } else if (layer_or_wheel == 1) {
2142  moduleNumber = moduleNumber_barrel2[iside];
2143  moduleHits_B[moduleNumber]++;
2144  } else if (layer_or_wheel == 2) {
2145  moduleNumber = moduleNumber_barrel3[iside];
2146  moduleHits_B[moduleNumber]++;
2147  }
2148 
2149  if (highlevel) {
2150  if (layer_or_wheel == 0) {
2151  moduleNumber = moduleNumber_barrel1[iside];
2152  HLmoduleHits_B[moduleNumber]++;
2153  } else if (layer_or_wheel == 1) {
2154  moduleNumber = moduleNumber_barrel2[iside];
2155  HLmoduleHits_B[moduleNumber]++;
2156  } else if (layer_or_wheel == 2) {
2157  moduleNumber = moduleNumber_barrel3[iside];
2158  HLmoduleHits_B[moduleNumber]++;
2159  }
2160  }
2161  } else if (ibe == 1) {
2162  if (layer_or_wheel < 6) {
2163  moduleNumber = moduleNumber_endcapA[iside];
2164  moduleHits_E[moduleNumber]++;
2165  } else if (layer_or_wheel > 5) {
2166  moduleNumber = moduleNumber_endcapB[iside];
2167  moduleHits_E[moduleNumber]++;
2168  }
2169 
2170  if (highlevel) {
2171  if (layer_or_wheel < 6) {
2172  moduleNumber = moduleNumber_endcapA[iside];
2173  HLmoduleHits_E[moduleNumber]++;
2174  } else if (layer_or_wheel > 5) {
2175  moduleNumber = moduleNumber_endcapB[iside];
2176  HLmoduleHits_E[moduleNumber]++;
2177  }
2178  }
2179  }
2180  }
2181  }
2182 
2183  m_hOccAll->Fill(nhitsall / 350848.);
2184 
2185  //ToDo Explain this
2186  for (int ibe = 0; ibe < 2; ibe++) {
2187  if (m_doShift) {
2188  if (ibe == 0) {
2189  m_hBCIDvsOcc[ibe]->Fill(m_good_bcid, m_nTRTHits[ibe] / 105088.0);
2190  } else if (ibe == 1) {
2191  m_hBCIDvsOcc[ibe]->Fill(m_good_bcid, m_nTRTHits[ibe] / 245760.0);
2192  }
2193 
2194  for (int iside = 0; iside < 2; iside++) {
2195  for (int i = 1; i <= numberOfStacks_b[ibe]; i++) {
2196  int index_tmp, modulenum_tmp;
2197 
2198  if (iside == 0) {
2199  index_tmp = i - 1;
2200  modulenum_tmp = i - 1;
2201  } else {
2202  index_tmp = i + 31;
2203 
2204  if (ibe == 0) modulenum_tmp = (i - 1) + 96;
2205  else if (ibe == 1) modulenum_tmp = (i - 1) + 64;
2206  }
2207 
2208  int nclass = -1;
2209 
2210  if (i <= s_numberOfBarrelStacks) {
2211  nclass = 0;
2212  } else if (i <= 2 * s_numberOfBarrelStacks && i > s_numberOfBarrelStacks) {
2213  nclass = 1;
2214  } else if (i > 2 * s_numberOfBarrelStacks) {
2215  nclass = 2;
2216  }
2217 
2218  int LLocc_index = index_tmp - 32 * nclass;
2219 
2220  if (nclass >= 0) {
2221  if (ibe == 0) {
2222  float occLL = float(moduleHits_B[modulenum_tmp]) / float(numberOfStrawsMod[nclass]);
2223  float occHL = float(HLmoduleHits_B[modulenum_tmp]) / float(numberOfStrawsMod[nclass]);
2224  m_LLOcc[ibe][LLocc_index] += occLL;
2225  m_hAvgLLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occLL);
2226  m_hAvgHLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occHL);
2227  m_hAvgLLOccMod_side[ibe][iside]->Fill(i, occLL);
2228  m_hAvgHLOccMod_side[ibe][iside]->Fill(i, occHL);
2229  } else if (ibe == 1) {
2230  float occLL = float(moduleHits_E[modulenum_tmp]) / float(numberOfStrawsWheel[nclass]);
2231  float occHL = float(HLmoduleHits_E[modulenum_tmp]) / float(numberOfStrawsWheel[nclass]);
2232 
2233  if (LLocc_index < 64) {
2234  m_LLOcc[ibe][LLocc_index] += occLL;
2235  } else {
2236  ATH_MSG_WARNING("m_LLOcc index out of bounds!"); // To satisfy Coverity defect CID 16514 which we believe is a false report.
2237  }
2238 
2239  m_hAvgLLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occLL);
2240  m_hAvgHLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occHL);
2241  m_hAvgLLOccMod_side[ibe][iside]->Fill(i, occLL);
2242  m_hAvgHLOccMod_side[ibe][iside]->Fill(i, occHL);
2243  }
2244  }
2245  }
2246  }
2247  }
2248 
2249  //Normalization for online environmenmet
2250  if (m_environment == AthenaMonManager::online) {
2251  //Loop over stack histograms and normalize to number of events processed.
2252  if (m_doChips && m_doExpert) {
2253  for (int i = 0; i < 64; i++) {
2254  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2255  m_hChipOcc[ibe][i]->Fill(m_hHitAMapC[ibe][i]->GetBinContent(j + 1));
2256  }
2257 
2258  if (m_totalEvents > 0) {
2259  const float scale = 1. / (16 * m_totalEvents);
2260  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
2261  scale_LWHist(m_hHitWMapC[ibe][i], scale);
2262  scale_LWHist(m_hHitAMapC[ibe][i], scale);
2263  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
2264  scale_LWHist(m_hHitHMapC[ibe][i], scale);
2265  }
2266  }
2267  }
2268 
2269  if (m_doStraws && m_doShift && m_totalEvents > 0) {
2270  if (ibe == 0) {
2271  initScaleVectors();
2272  vector<float> scalevector;
2273  vector<float> scalevector_Ar;
2274 
2275  for (int k = 0; k < s_Straw_max[0]; k++) {
2276  try {
2277  if (m_scale_hHitWMap_B.at(k) == 0.) {
2278  scalevector.push_back(0.);
2279  } else {
2280  scalevector.push_back(1. / (m_totalEvents * m_scale_hHitWMap_B.at(k)));
2281  }
2282 
2283  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
2284  scalevector_Ar.push_back(0.);
2285  } else {
2286  scalevector_Ar.push_back(1. / (m_totalEvents * m_scale_hHitWMap_B_Ar.at(k)));
2287  }
2288  } catch (out_of_range &e) {
2289  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
2290  }
2291  }
2292 
2293  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
2294 
2295  if (m_ArgonXenonSplitter) {
2296  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
2297  }
2298  } else if (ibe == 1) {
2299  float eventScale = 1. / (32 * m_totalEvents);
2300  scale_LWHist(m_hHitWMap_E[0], eventScale);
2301  scale_LWHist(m_hHitWMap_E[1], eventScale);
2302 
2303  if (m_ArgonXenonSplitter) {
2304  scale_LWHist(m_hHitWMap_E_Ar[0], eventScale);
2305  scale_LWHist(m_hHitWMap_E_Ar[1], eventScale);
2306  }
2307  }
2308  }
2309 
2310  if (m_doStraws) {
2311  for (int i = 0; i < 64; i++) {
2312  if (m_doExpert && m_totalEvents > 0) {
2313  const float scale = 1. / m_totalEvents;
2314  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
2315  scale_LWHist(m_hHitWMapS[ibe][i], scale);
2316  scale_LWHist(m_hHitAMapS[ibe][i], scale);
2317  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
2318  scale_LWHist(m_hHitHMapS[ibe][i], scale);
2319  }
2320 
2321  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2322  if (m_doExpert) {
2323  m_hStrawOcc[ibe][i]->Fill(m_hHitAMapS[ibe][i]->GetBinContent(j + 1));
2324  }
2325  }
2326  }
2327  }
2328  }
2329  }
2330 
2331  if (m_environment == AthenaMonManager::online) {
2332  if (m_doShift) m_hSummary->SetBinContent(1, m_totalEvents);
2333  }
2334 
2335  ATH_MSG_VERBOSE("Leaving Fill TRT RDO Histograms");
2336  return StatusCode::SUCCESS;
2337 }

◆ fillTRTTracks()

StatusCode TRT_Monitoring_Tool::fillTRTTracks ( const TrackCollection &  trackCollection,
const xAOD::TrigDecision *  trigDecision,
const ComTime *  comTimeObject 
)
private

hardcoded cut for pT 2.0 GeV for collision setup

Definition at line 2341 of file TRT_Monitoring_Tool.cxx.

2343  {
2344 //----------------------------------------------------------------------------------//
2345  ATH_MSG_VERBOSE("Filling TRT Tracks Histos");
2346  //Initialize a bunch of stuff before looping over the track collection. Fill some basic histograms.
2347  const float timeCor = comTimeObject ? comTimeObject->getTime() : 0;
2348  auto p_trk = trackCollection.begin();
2349  const Trk::Perigee *mPer = nullptr;
2350  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
2351  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
2352 
2353  //Take out normalization of previous event for online environment
2354  //Explanation: While online monitoring running we need to present out histograms repeatedly so we need to pay attention to normalization.
2355  //before adding any information from new event to normalized histograms we need to take out the normalization of the previous event by scaling histograms back.
2356  //After we are done with filling those histograms we will normalize them again
2357  if (m_environment == AthenaMonManager::online) {
2358  // ibe = 0 (Barrel), ibe = 1 (Endcap)
2359  for (int ibe = 0; ibe < 2; ibe++) {
2360  if (m_doChips && m_doExpert) {
2361  for (int i = 0; i < 64; i++) {
2362  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2363  if (m_hChipsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
2364  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2365  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2366  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2367  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2368  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2369  }
2370  }
2371  }
2372  }
2373 
2374  if (m_doStraws) {
2375  for (int i = 0; i < 64; i++) {
2376  for (int j = 0; j < s_Straw_max[ibe]; j++) {
2377  if (ibe == 0) {
2378  if (i == 0 && m_nStrawHits_B[j] > 0) {
2379  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) * m_nStrawHits_B[j]);
2380  }
2381  } else if (ibe == 1) {
2382  for (int iside = 0; iside < 2; iside++) {
2383  if (i == 0 && m_nStrawHits_E[iside][j] > 0) {
2384  m_hHitWonTMap_E[iside]->SetBinContent(j + 1, m_hHitWonTMap_E[iside]->GetBinContent(j + 1) * m_nStrawHits_E[iside][j]);
2385  }
2386  }
2387  }
2388 
2389  if (m_doExpert) {
2390  if (m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
2391  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2392  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2393  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2394  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2395  }
2396  }
2397  }
2398  }
2399  }
2400  }
2401 
2402  if (m_doShift) {
2403  scale_LWHist(m_hEvtPhase, m_EventPhaseScale);
2404  scale_LWHist(m_hDriftTimeonTrkDist_B, m_DriftTimeonTrkDistScale_B);
2405  scale_LWHist(m_hHLhitOnTrack_B, m_HLhitOnTrackScale_B);
2406  scale_LWHist(m_hHtoLRatioOnTrack_B, m_HtoLRatioOnTrackScale_B);
2407  scale_LWHist(m_hNumSwLLWoT_B, m_NumSwLLWoTScale_B);
2408  scale_LWHist(m_hWireToTrkPosition_B, m_WireToTrkPositionScale_B);
2409  scale_LWHist(m_hTronTDist_B, m_TronTDistScale_B);
2410  scale_LWHist(m_hResidual_B, m_ResidualScale_B);
2411  scale_LWHist(m_hResidual_B_20GeV, m_ResidualScale_B_20GeV);
2412  scale_LWHist(m_hTimeResidual_B, m_TimeResidualScale_B);
2413 
2414  if (m_ArgonXenonSplitter) {
2415  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, m_DriftTimeonTrkDistScale_B_Ar);
2416  scale_LWHist(m_hWireToTrkPosition_B_Ar, m_WireToTrkPositionScale_B_Ar);
2417  scale_LWHist(m_hTronTDist_B_Ar, m_TronTDistScale_B_Ar);
2418  scale_LWHist(m_hResidual_B_Ar, m_ResidualScale_B_Ar);
2419  scale_LWHist(m_hResidual_B_Ar_20GeV, m_ResidualScale_B_Ar_20GeV);
2420  scale_LWHist(m_hTimeResidual_B_Ar, m_TimeResidualScale_B_Ar);
2421  }
2422 
2423  for (int iside = 0; iside < 2; iside++) {
2424  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], m_DriftTimeonTrkDistScale_E[iside]);
2425  scale_LWHist(m_hHLhitOnTrack_E[iside], m_HLhitOnTrackScale_E[iside]);
2426  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], m_HtoLRatioOnTrackScale_E[iside]);
2427  scale_LWHist(m_hNumSwLLWoT_E[iside], m_NumSwLLWoTScale_E[iside]);
2428  scale_LWHist(m_hWireToTrkPosition_E[iside], m_WireToTrkPositionScale_E[iside]);
2429  scale_LWHist(m_hTronTDist_E[iside], m_TronTDistScale_E[iside]);
2430  scale_LWHist(m_hResidual_E[iside], m_ResidualScale_E[iside]);
2431  scale_LWHist(m_hResidual_E_20GeV[iside], m_ResidualScale_E_20GeV[iside]);
2432  scale_LWHist(m_hTimeResidual_E[iside], m_TimeResidualScale_E[iside]);
2433 
2434  if (m_ArgonXenonSplitter) {
2435  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], m_DriftTimeonTrkDistScale_E_Ar[iside]);
2436  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], m_WireToTrkPositionScale_E_Ar[iside]);
2437  scale_LWHist(m_hTronTDist_E_Ar[iside], m_TronTDistScale_E_Ar[iside]);
2438  scale_LWHist(m_hResidual_E_Ar[iside], m_ResidualScale_E_Ar[iside]);
2439  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], m_ResidualScale_E_Ar_20GeV[iside]);
2440  scale_LWHist(m_hTimeResidual_E_Ar[iside], m_TimeResidualScale_E_Ar[iside]);
2441  }
2442  }
2443  }
2444  }
2445 
2446  int ntrackstack[2][64];
2447 
2448  for (int ibe = 0; ibe < 2; ibe++) {
2449  std::fill(ntrackstack[ibe], ntrackstack[ibe] + 64, 0);
2450  }
2451 
2452  for (; p_trk != trackCollection.end(); ++p_trk) {
2453  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*p_trk));
2454  int nTRTHits = summary->get(Trk::numberOfTRTHits);
2455 
2456  if (nTRTHits < m_minTRThits) continue;
2457 
2458  AllTrkPar = (*p_trk)->trackParameters();
2459 
2460  // Search of MeasuredPerigee in TrackParameters
2461  // The following algorithm only finds the First perigee measurement.
2462  // As there should be one and only one perigee measurement then this assumption should be valid.
2463  // But no check is done to see if there is more than one perigee measurement.
2464  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
2465  //if track parameter does have a measured perigee then the track parameter is a keeper and break out of the loop
2466  if ((mPer = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
2467  }
2468 
2469  if (!mPer) continue;
2470 
2471  float theta = mPer->parameters()[Trk::theta];
2472  float p = (mPer->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (mPer->parameters()[Trk::qOverP])) : 10e7;
2473  float pT = (p * sin(theta));
2474  pT = pT * 1e-3; // GeV
2475 
2476  if (p < m_minP) continue;
2477 
2478  const Trk::TrackStates *trackStates = (**p_trk).trackStateOnSurfaces();
2479 
2480  if (trackStates == nullptr) continue;
2481 
2482  Trk::TrackStates::const_iterator TSOSItBegin0 = trackStates->begin();
2483  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
2484  Trk::TrackStates::const_iterator TSOSItBeginTemp = trackStates->begin();
2485  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
2486  int n_trt_hits = summary->get(Trk::numberOfTRTHits);
2487  int n_sct_hits = summary->get(Trk::numberOfSCTHits);
2488  int n_pixel_hits = summary->get(Trk::numberOfPixelHits);
2489  const int n_si_hits = n_pixel_hits + n_sct_hits;
2490  bool is_pT_over_20GeV = false;
2491 
2492  is_pT_over_20GeV = mPer->pT() > 20 * CLHEP::GeV;
2493 
2494  const bool cnst_is_pT_over_20GeV = is_pT_over_20GeV;
2496  float min_pt_new = m_min_pT;
2497 
2498  if (!m_isCosmics) {
2499  min_pt_new = 2.0 * CLHEP::GeV;
2500  }
2501 
2502  const bool passed_track_preselection =
2503  (mPer->pT() > min_pt_new) &&
2504  (p > m_minP) &&
2505  (n_si_hits >= m_min_si_hits) &&
2506  (n_pixel_hits >= m_min_pixel_hits) &&
2507  (n_sct_hits >= m_min_sct_hits) &&
2508  (n_trt_hits >= m_min_trt_hits);
2509 
2510  if (!passed_track_preselection) continue;
2511 
2512  m_nTotalTracks++;
2513  int checkB[2] = {0, 0};
2514  int checkEC[2] = {0, 0};
2515  int checkEC_B[2] = {0, 0};
2516  int nTRTHitsW[2][2];
2517  int nTRTHitsW_Ar[2][2];
2518  int nTRTHitsW_Xe[2][2];
2519  int nTRTHLHitsW[2][2];
2520  int nTRTHLHitsW_Ar[2][2];
2521  int nTRTHLHitsW_Xe[2][2];
2522  int nTRTHits_side[2][2];
2523  int nTRTHitsW_perwheel[2][18];
2524  int hitontrack[2] = {0, 0};
2525  int hitontrack_E_side[2] = {0, 0};
2526 
2527  for (int ibe = 0; ibe < 2; ibe++) {
2528  for (int iside = 0; iside < 2; iside++) {
2529  nTRTHits_side[ibe][iside] = -1;
2530  nTRTHitsW[ibe][iside] = 0;
2531  nTRTHitsW_Ar[ibe][iside] = 0;
2532  nTRTHitsW_Xe[ibe][iside] = 0;
2533  nTRTHLHitsW[ibe][iside] = 0;
2534  nTRTHLHitsW_Ar[ibe][iside] = 0;
2535  nTRTHLHitsW_Xe[ibe][iside] = 0;
2536  }
2537 
2538  std::fill(nTRTHitsW_perwheel[ibe], nTRTHitsW_perwheel[ibe] + 18, 0);
2539  }
2540 
2541  bool isBarrelOnly = true;
2542  bool ECAhit = false;
2543  bool ECChit = false;
2544  bool Bhit = false;
2545  int barrel_ec = 0;
2546  int layer_or_wheel = 0;
2547  int phi_module = 0;
2548  int straw_layer = 0;
2549  int straw = 0;
2550  int nearest_straw_layer[2] = {100, 100};
2551  int nearest_straw[2] = {0, 0};
2552  int testLayer[2] = {100, 100};
2553  int innerstack[2] = {-999, -999};
2554  float phi2D[2] = {-100, -100};
2555 
2556  for (TSOSItBeginTemp = TSOSItBegin0; TSOSItBeginTemp != TSOSItEnd; ++TSOSItBeginTemp) {
2557  if ((*TSOSItBeginTemp) == nullptr) continue;
2558 
2559  if (! ((*TSOSItBeginTemp)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
2560 
2561  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBeginTemp)->measurementOnTrack());
2562 
2563  if (!trtCircle) continue;
2564 
2565  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBeginTemp)->trackParameters());
2566 
2567  if (!aTrackParam) continue;
2568 
2569  Identifier DCoTId = trtCircle->identify();
2570  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
2571  int ibe = abs(barrel_ec) - 1;
2572  layer_or_wheel = m_pTRTHelper->layer_or_wheel (DCoTId);
2573  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
2574  straw = m_pTRTHelper->straw(DCoTId);
2575 
2576  //restrict ourselves to the inner most TRT layers To get detector phi.
2577  if (layer_or_wheel >= testLayer[ibe]) continue;
2578 
2579  testLayer[ibe] = layer_or_wheel;
2580 
2581  if (straw_layer < nearest_straw_layer[ibe]) {
2582  nearest_straw_layer[ibe] = straw_layer;
2583  nearest_straw[ibe] = straw;
2584  const InDetDD::TRT_BaseElement *circleElement = nullptr;
2585  circleElement = trtCircle->detectorElement();
2586  phi2D[ibe] = radToDegrees(circleElement->strawCenter(nearest_straw[ibe]).phi());
2587  circleElement = nullptr;
2588  innerstack[ibe] = m_pTRTHelper->phi_module(DCoTId);
2589  }
2590  }
2591 
2592  if (phi2D[0] == -999) {
2593  ATH_MSG_DEBUG("Track did not go through inner layer of Barrel.");
2594  } else {
2595  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
2596  testLayer[0] << " m_straw_layer: " <<
2597  nearest_straw_layer[0] << " (in the Barrel).");
2598  }
2599 
2600  if (phi2D[1] == -999) {
2601  ATH_MSG_DEBUG("Track did not go through any inner layer of EndCap A or C.");
2602  } else {
2603  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
2604  testLayer[1] << " m_straw_layer: " <<
2605  nearest_straw_layer[1] << " (in the EndCaps).");
2606  }
2607 
2608  bool trackfound[2][64];
2609 
2610  for (int i = 0; i < 2; i++) {
2611  std::fill(trackfound[i], trackfound[i] + 64, false);
2612  }
2613 
2614  for (TSOSItBegin = TSOSItBegin0; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
2615  //select a TSOS which is non-empty, measurement type and contains both drift circle and track parameters informations
2616  if ((*TSOSItBegin) == nullptr) continue;
2617 
2618  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
2619 
2620  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
2621 
2622  if (!trtCircle) continue;
2623 
2624  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
2625 
2626  if (!aTrackParam) continue;
2627 
2628  Identifier DCoTId = trtCircle->identify();
2629  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
2630  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
2631  phi_module = m_pTRTHelper->phi_module(DCoTId);
2632  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
2633  straw = m_pTRTHelper->straw(DCoTId);
2634  // ibe = 0 (Barrel), ibe = 1 (Endcap)
2635  int ibe = abs(barrel_ec) - 1;
2636  // iside = 0 (Side A), iside = 1 (Side C)
2637  int iside = barrel_ec > 0 ? 0 : 1;
2638  int thisStrawNumber[2] = {-1, -1};
2639  int chip[2] = {0, 0};
2640 
2641  if (ibe == 0) {
2642  thisStrawNumber[ibe] = strawNumber(straw, straw_layer, layer_or_wheel);
2643 
2644  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
2645  chip[ibe] = m_mat_chip_B[phi_module][thisStrawNumber[ibe]];
2646  }
2647  } else if (ibe == 1) {
2648  thisStrawNumber[ibe] = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
2649 
2650  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
2651  chip[ibe] = m_mat_chip_E[phi_module][thisStrawNumber[ibe]];
2652  }
2653  } else {
2654  thisStrawNumber[ibe] = -1;
2655  }
2656 
2657  if (thisStrawNumber[ibe] < 0 || thisStrawNumber[ibe] >= s_Straw_max[ibe]) continue;
2658 
2659  if (checkB[iside] == 0 && ibe == 0) {
2660  m_nTracksB[iside]++;
2661  checkB[iside] = 1;
2662  }
2663 
2664  if (checkEC[iside] == 0 && ibe == 1) {
2665  m_nTracksEC[iside]++;
2666  checkEC[iside] = 1;
2667  }
2668 
2669  if (checkEC_B[iside] == 0 && checkB[iside] == 1 && ibe == 1 ) {
2670  m_nTracksEC_B[iside]++;
2671  checkEC_B[iside] = 1;
2672  }//ToDo: be sure about this approach
2673 
2674  if (ibe == 0) {
2675  Bhit = true;
2676  } else if (barrel_ec == 2) {
2677  isBarrelOnly = false;
2678  ECAhit = true;
2679  } else if (barrel_ec == -2) {
2680  isBarrelOnly = false;
2681  ECChit = true;
2682  }
2683 
2684  Identifier surfaceID;
2685  const Trk::MeasurementBase *mesb = (*TSOSItBegin)->measurementOnTrack();
2686  surfaceID = trtCircle->identify();
2687  const bool isArgonStraw = ( Straw_Gastype( m_sumTool->getStatusHT(surfaceID) ) == GasType::Ar );
2688  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
2689  float temp_locr = aTrackParam->parameters()[Trk::driftRadius];
2690  TRTCond::RtRelation const *rtr = m_TRTCalDbTool->getRtRelation(surfaceID);
2691  int iphi_module = -9999;
2692 
2693  if (iside == 0) iphi_module = phi_module;
2694  else if (iside == 1) iphi_module = phi_module + 32;
2695 
2696  trackfound[ibe][iphi_module] = true;
2697 
2698  if (((ibe == 0) && (temp_locr < m_DistToStraw)) ||
2699  ((ibe == 1) && ((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement) ||
2700  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Outlier) ||
2701  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Hole)) &&
2702  (temp_locr < m_DistToStraw))) {
2703  if (m_idHelper->is_trt(DCoTId)) {
2704  if (ibe == 0) {
2705  hitontrack[ibe]++;
2706 
2707  if (m_doShift) {
2708  m_hStrawEffDetPhi_B->Fill(phi_module, 1.0);
2709  }
2710 
2711  if (m_doStraws && m_doShift) {
2712  m_nStrawHits_B[thisStrawNumber[ibe]]++;
2713  }
2714  } else if (ibe == 1) {
2715  hitontrack[ibe]++;
2716  hitontrack_E_side[iside]++;
2717 
2718  if (m_doShift) {
2719  m_hStrawEffDetPhi_E[iside]->Fill(phi_module, 1.0);
2720  }
2721 
2722  if (m_doStraws && m_doShift) {
2723  m_nStrawHits_E[iside][thisStrawNumber[ibe]]++;
2724  }
2725  }
2726 
2727  if (m_doStraws && m_doExpert) {
2728  m_hStrawsEff[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2729  }
2730 
2731  if (m_doChips && m_doExpert) {
2732  m_hChipsEff[ibe][iphi_module]->Fill((chip[ibe] - 1), 1.0);
2733  }
2734  }
2735  } else {
2736  if (m_idHelper->is_trt(DCoTId)) { //ToDo:Is this really needed
2737  if (ibe == 0) {
2738  if (m_doShift) {
2739  m_hStrawEffDetPhi_B->Fill(phi_module, 0.0);
2740  }
2741 
2742  if (m_doStraws && m_doShift) {
2743  m_nStrawHits_B[thisStrawNumber[ibe]]++;
2744  }
2745  } else if (ibe == 1) {
2746  if (m_doShift) {
2747  m_hStrawEffDetPhi_E[iside]->Fill(phi_module, 0.0);
2748  }
2749 
2750  if (m_doStraws && m_doShift) {
2751  m_nStrawHits_E[iside][thisStrawNumber[ibe]]++;
2752  }
2753  }
2754 
2755  if (m_doStraws && m_doExpert) {
2756  m_hStrawsEff[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 0.0);
2757  }
2758 
2759  if (m_doChips && m_doExpert) {
2760  m_hChipsEff[ibe][iphi_module]->Fill((chip[ibe] - 1), 0.0);
2761  }
2762  }
2763  }
2764 
2765  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
2766  bool isTubeHit = (mesb->localCovariance()(Trk::locX, Trk::locX) > 1.0) ? 1 : 0;
2767 
2768  if (RawDriftCircle) {
2769  nTRTHits_side[ibe][iside]++;
2770  int middleHTbit = RawDriftCircle->getWord() & 0x00020000;
2771  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
2772  int hitinvaliditygate = RawDriftCircle->getWord() & 0x000DFE80;
2773  //0x000DFE80 = 0000 0000 0000 0000 0000 1101 1111 1110 1000 0000 //
2774  bool is_middleHTbit_high = (middleHTbit != 0);
2775  bool is_anybininVgate_high = (hitinvaliditygate != 0);
2776  float timeOverThreshold = RawDriftCircle->timeOverThreshold();
2777  double t0 = m_TRTCalDbTool->getT0(DCoTId, TRTCond::ExpandedIdentifier::STRAW);
2778 
2779 
2780  if (m_doExpert && m_doStraws) {
2781  m_hHitToTonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], timeOverThreshold);
2782  // NOTE: this looks redundant
2783  m_hHitHonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2784 
2785  if (is_middleHTbit_high) {
2786  m_hHitHonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2787  m_hHitHWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2788  }
2789  }
2790 
2791  if (m_doExpert && m_doChips) {
2792  m_hHitToTonTMapC[ibe][iphi_module]->Fill((chip[ibe] - 1), timeOverThreshold);
2793 
2794  if (is_middleHTbit_high) {
2795  m_hHitHWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
2796  m_hHitHonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
2797  }
2798  }
2799 
2800  const bool driftTimeValid = RawDriftCircle->driftTimeValid();
2801 
2802  if (driftTimeValid) {
2803  const float validRawDriftTime = RawDriftCircle->rawDriftTime();
2804 
2805  if (m_doExpert && m_doStraws)
2806  m_hValidRawDriftTimeonTrk[ibe][iphi_module]->Fill(thisStrawNumber[ibe], validRawDriftTime);
2807 
2808  if (m_doExpert && m_doChips)
2809  m_hValidRawDriftTimeonTrkC[ibe][iphi_module]->Fill((chip[ibe] - 1), validRawDriftTime);
2810  }
2811 
2812  if (m_doShift && m_doStraws) {
2813  if (ibe == 0) {
2814  if (isArgonStraw)
2815  m_hDriftTimeonTrkDist_B_Ar->Fill(RawDriftCircle->rawDriftTime());
2816  else
2817  m_hDriftTimeonTrkDist_B->Fill(RawDriftCircle->rawDriftTime());
2818  } else if (ibe == 1) {
2819  if (isArgonStraw)
2820  m_hDriftTimeonTrkDist_E_Ar[iside]->Fill(RawDriftCircle->rawDriftTime());
2821  else
2822  m_hDriftTimeonTrkDist_E[iside]->Fill(RawDriftCircle->rawDriftTime());
2823  }
2824  }
2825 
2826  float locR_err = 0.0;
2827  const AmgSymMatrix(5)* b_err = aTrackParam->covariance();
2828 
2829  if (b_err) {
2830  locR_err = Amg::error(*b_err, Trk::locR);
2831  } else {
2832  ATH_MSG_ERROR("Track parameters have no covariance attached.");
2833  }
2834 
2835  float loc_err = sqrt(Amg::error(trtCircle->localCovariance(), Trk::driftRadius));
2836  float locR = aTrackParam->parameters()[Trk::driftRadius];
2837  float loc = trtCircle->localParameters()[Trk::driftRadius];
2838 
2839  if (isTubeHit) {
2840  bool isOK = false;
2841  loc = m_drifttool->driftRadius(RawDriftCircle->rawDriftTime(), DCoTId, t0, isOK);
2842 
2843  if ((loc * locR) < 0) loc = -loc;
2844  }
2845 
2846  // Calculate Residuals for hit
2847  if (m_doShift && m_doStraws) {
2848  const double pull_b =
2849  ((loc - locR) /
2850  sqrt((loc_err * loc_err * loc_err * loc_err) -
2851  (locR_err * locR_err * locR_err * locR_err)));
2852  const double thist0 = m_TRTCalDbTool->getT0(surfaceID);
2853  const double trkdrifttime = (!rtr) ? 0 : rtr->drifttime(fabs(locR));
2854  const double timeresidual = RawDriftCircle->rawDriftTime() - thist0 - trkdrifttime;
2855 
2856  if (ibe == 0) {
2857  if (!isTubeHit) {
2858  m_Pull_Biased_Barrel->Fill(pull_b);
2859  }
2860 
2861  if (isArgonStraw) {
2862  m_hResidual_B_Ar->Fill(loc - locR);
2863 
2864  if (cnst_is_pT_over_20GeV) {
2865  m_hResidual_B_Ar_20GeV->Fill(loc - locR);
2866  }
2867 
2868  m_hTimeResidual_B_Ar->Fill(timeresidual);
2869  } else {
2870  m_hResidual_B->Fill(loc - locR);
2871  m_hTimeResidual_B->Fill(timeresidual);
2872 
2873  if (cnst_is_pT_over_20GeV) {
2874  m_hResidual_B_20GeV->Fill(loc - locR);
2875  }
2876  }
2877  } else if (ibe == 1) {
2878  if (!isTubeHit) {
2879  m_Pull_Biased_EndCap->Fill(pull_b);
2880  }
2881 
2882  if (isArgonStraw) {
2883  m_hResidual_E_Ar[iside]->Fill(loc - locR);
2884  m_hTimeResidual_E_Ar[iside]->Fill(timeresidual);
2885 
2886  if (cnst_is_pT_over_20GeV) {
2887  m_hResidual_E_Ar_20GeV[iside]->Fill(loc - locR);
2888  }
2889  } else {
2890  m_hResidual_E[iside]->Fill(loc - locR);
2891  m_hTimeResidual_E[iside]->Fill(timeresidual);
2892 
2893  if (cnst_is_pT_over_20GeV) {
2894  m_hResidual_E_20GeV[iside]->Fill(loc - locR);
2895  }
2896  }
2897  }
2898  }
2899 
2900  if (m_doShift) {
2901  if (ibe == 0) {
2902  if (isArgonStraw) {
2903  m_hWireToTrkPosition_B_Ar->Fill(locR);
2904  } else {
2905  m_hWireToTrkPosition_B->Fill(locR);
2906  }
2907  } else if (ibe == 1) {
2908  if (isArgonStraw) {
2909  m_hWireToTrkPosition_E_Ar[iside]->Fill(locR);
2910  } else {
2911  m_hWireToTrkPosition_E[iside]->Fill(locR);
2912  }
2913  }
2914  }
2915 
2916  const float LE = (RawDriftCircle->driftTimeBin()) * 3.125;
2917  const float EP = timeCor;
2918 
2919  if (m_doShift && m_doStraws) {
2920  if (ibe == 0) {
2921  if (isArgonStraw) {
2922  if (m_isCosmics) {
2923  m_hrtRelation_B_Ar->Fill(LE - EP - t0, fabs(locR));
2924  } else {
2925  m_hrtRelation_B_Ar->Fill(LE - t0, fabs(locR));
2926  }
2927  } else {
2928  if (m_isCosmics) {
2929  m_hrtRelation_B->Fill(LE - EP - t0, fabs(locR));
2930  } else {
2931  m_hrtRelation_B->Fill(LE - t0, fabs(locR));
2932  }
2933  }
2934  } else if (ibe == 1) {
2935  if (isArgonStraw) {
2936  if (m_isCosmics) {
2937  m_hrtRelation_E_Ar[iside]->Fill(LE - EP - t0, fabs(locR));
2938  } else {
2939  m_hrtRelation_E_Ar[iside]->Fill(LE - t0, fabs(locR));
2940  }
2941  } else {
2942  if (m_isCosmics) {
2943  m_hrtRelation_E[iside]->Fill(LE - EP - t0, fabs(locR));
2944  } else {
2945  m_hrtRelation_E[iside]->Fill(LE - t0, fabs(locR));
2946  }
2947  }
2948  }
2949  }
2950 
2951  const int driftTimeBin = RawDriftCircle->driftTimeBin();
2952 
2953  if ( (driftTimeBin < 24) &&
2954  !(RawDriftCircle->lastBinHigh()) &&
2955  !(RawDriftCircle->firstBinHigh()) ) {
2956  if (m_doStraws) {
2957  if (ibe == 0) {
2958  m_hHitWonTMap_B->Fill(thisStrawNumber[ibe]);
2959  } else if (ibe == 1) {
2960  m_hHitWonTMap_E[iside]->Fill(thisStrawNumber[ibe]);
2961  }
2962  }
2963  }
2964 
2965  if ((driftTimeBin > 2) && (driftTimeBin < 17)) {
2966  if (m_doExpert && m_doStraws)
2967  m_hHitWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2968 
2969  if (m_doExpert && m_doChips)
2970  m_hHitWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1, 1.0);
2971  }
2972 
2973  const int trailingEdge = RawDriftCircle->trailingEdge();
2974  float trailingEdgeScaled = (trailingEdge + 1) * 3.125;
2975 
2976  if ((trailingEdge < 23) &&
2977  !(RawDriftCircle->lastBinHigh()) &&
2978  !(RawDriftCircle->firstBinHigh())) {
2979  if (m_doExpert && m_doStraws)
2980  m_hHitTronTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], trailingEdgeScaled);
2981 
2982  if (m_doExpert && m_doChips)
2983  m_hHitTronTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1, trailingEdgeScaled);
2984 
2985  if (m_doExpert && m_doStraws)
2986  m_hHitTronTwEPCMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], trailingEdgeScaled - timeCor);// Mean TE on Track (with Event Phase correction): Straws
2987 
2988  if (m_doExpert && m_doChips)
2989  m_hHitTronTwEPCMapC[ibe][iphi_module]->Fill((chip[ibe] - 1), trailingEdgeScaled - timeCor); // Mean TE on Track (with Event Phase correction): Chips
2990 
2991  if (m_doShift && m_doStraws) {
2992  if (RawDriftCircle->driftTimeValid()) {
2993  if (ibe == 0) {
2994  if (isArgonStraw) {
2995  m_hTronTDist_B_Ar->Fill(trailingEdgeScaled);
2996  m_hAvgTroTDetPhi_B_Ar->Fill(phi2D[ibe], trailingEdgeScaled);
2997  } else {
2998  m_hTronTDist_B->Fill(trailingEdgeScaled);
2999  m_hAvgTroTDetPhi_B->Fill(phi2D[ibe], trailingEdgeScaled);
3000  }
3001  } else if (ibe == 1) {
3002  if (isArgonStraw) {
3003  m_hTronTDist_E_Ar[iside]->Fill(trailingEdgeScaled);
3004  m_hAvgTroTDetPhi_E_Ar[iside]->Fill(phi2D[ibe], trailingEdgeScaled);
3005  } else {
3006  m_hTronTDist_E[iside]->Fill(trailingEdgeScaled);
3007  m_hAvgTroTDetPhi_E[iside]->Fill(phi2D[ibe], trailingEdgeScaled);
3008  }
3009  }
3010  }
3011  }
3012  }
3013 
3014  const bool firstBinHigh = RawDriftCircle->firstBinHigh();
3015  const bool lastBinHigh = RawDriftCircle->lastBinHigh();
3016 
3017  if (firstBinHigh || lastBinHigh || driftTimeBin > 0 || trailingEdge < 23) {
3018  if (m_doExpert && m_doStraws)
3019  m_hHitAonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe]);
3020 
3021  if (m_doExpert && m_doChips)
3022  m_hHitAonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
3023 
3024  nTRTHitsW[ibe][iside]++;
3025 
3026  if (isArgonStraw) {
3027  nTRTHitsW_Ar[ibe][iside]++;
3028  } else {
3029  nTRTHitsW_Xe[ibe][iside]++;
3030  }
3031 
3032  nTRTHitsW_perwheel[iside][layer_or_wheel]++;
3033 
3034  if (is_middleHTbit_high) {
3035  nTRTHLHitsW[ibe][iside]++;
3036 
3037  if (isArgonStraw) {
3038  nTRTHLHitsW_Ar[ibe][iside]++;
3039  } else {
3040  nTRTHLHitsW_Xe[ibe][iside]++;
3041  }
3042  }
3043  }
3044 
3045  if (is_anybininVgate_high) {
3046  if (m_doExpert && m_doStraws)
3047  m_hHitAWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe]);
3048 
3049  if (m_doExpert && m_doChips)
3050  m_hHitAWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
3051  }
3052  }
3053  }
3054 
3055  //ToDo: work on the part below
3056  for (int ibe = 0; ibe < 2; ibe++) {
3057  for (int i = 0; i < 64; i++)
3058  if (trackfound[ibe][i])
3059  ntrackstack[ibe][i]++;
3060 
3061  if (m_doShift) {
3062  if (ibe == 0) {
3063  if (hitontrack[ibe] >= m_minTRThits)
3064  m_hNumHoTDetPhi_B->Fill(phi2D[ibe], hitontrack[ibe]);
3065  }
3066 
3067  if (ibe == 1) {
3068  if (hitontrack_E_side[0] >= m_minTRThits)
3069  m_hNumHoTDetPhi_E[0]->Fill(phi2D[ibe], hitontrack_E_side[0]);
3070 
3071  if (hitontrack_E_side[1] >= m_minTRThits)
3072  m_hNumHoTDetPhi_E[1]->Fill(phi2D[ibe], hitontrack_E_side[1]);
3073  }
3074  }
3075 
3076  if (phi2D[ibe] < 0) continue;
3077 
3078  if (m_doShift) {
3079  if (ibe == 0) {
3080  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0)
3081  m_hNumTrksDetPhi_B->Fill(phi2D[ibe]);
3082  } else if (ibe == 1) {
3083  if (nTRTHitsW[ibe][0] > 0)
3084  m_hNumTrksDetPhi_E[0]->Fill(phi2D[ibe]);
3085 
3086  if (nTRTHitsW[ibe][1] > 0)
3087  m_hNumTrksDetPhi_E[1]->Fill(phi2D[ibe]);
3088  }
3089  }
3090 
3091  if (m_doShift) {
3092  if (innerstack[ibe] >= 0 && innerstack[ibe] < s_iStack_max[ibe]) {
3093  if (ibe == 0) {
3094  m_LonTrack_B[innerstack[ibe]] += nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1];
3095 
3096  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0) {
3097  m_HTfraconTrack_B[innerstack[ibe]] += (float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3098  m_nTrack_B[innerstack[ibe]] = m_nTrack_B[innerstack[ibe]] + 1;
3099  }
3100  } else if (ibe == 1) {
3101  m_LonTrack_E[innerstack[ibe]] += nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1];
3102 
3103  if ((nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]) > 0) {
3104  m_HTfraconTrack_E[innerstack[ibe]] += (float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3105  m_nTrack_E[innerstack[ibe]] = m_nTrack_E[innerstack[ibe]] + 1;
3106  }
3107  }
3108  }
3109  }
3110 
3111  if (m_doShift) {
3112  if (ibe == 0) {
3113  if (isBarrelOnly) {
3114  if (nTRTHitsW[ibe][0] > 0) {
3115  if (nTRTHitsW[ibe][1] > 0) m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3116  else m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][0]);
3117  } else if (nTRTHitsW[ibe][1] > 0) {
3118  m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][1]);
3119  }
3120  }
3121 
3122  if (nTRTHLHitsW[ibe][0] > 0) {
3123  if (nTRTHLHitsW[ibe][1] > 0) {
3124  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]);
3125  } else {
3126  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][0]);
3127  }
3128  } else if (nTRTHLHitsW[ibe][1] > 0) {
3129  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][1]);
3130  }
3131 
3132  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0) {
3133  m_hHtoLRatioOnTrack_B->Fill((float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]));
3134  }
3135 
3136  if (nTRTHitsW_Ar[ibe][0] + nTRTHitsW_Ar[ibe][1] > 0) {
3137  m_hHtoLRatioOnTrack_B_Ar->Fill((float)(nTRTHLHitsW_Ar[ibe][0] + nTRTHLHitsW_Ar[ibe][1]) / (nTRTHitsW_Ar[ibe][0] + nTRTHitsW_Ar[ibe][1]));
3138  }
3139 
3140  if (nTRTHitsW_Xe[ibe][0] + nTRTHitsW_Xe[ibe][1] > 0) {
3141  m_hHtoLRatioOnTrack_B_Xe->Fill((float)(nTRTHLHitsW_Xe[ibe][0] + nTRTHLHitsW_Xe[ibe][1]) / (nTRTHitsW_Xe[ibe][0] + nTRTHitsW_Xe[ibe][1]));
3142  }
3143  } else if (ibe == 1) {
3144  if (nTRTHitsW[ibe][0] > 0) {
3145  if (nTRTHitsW[ibe][1] > 0) {
3146  if (ECAhit && !ECChit && !Bhit) {
3147  m_hNumSwLLWoT_E[0]->Fill(nTRTHitsW[ibe][0]);
3148  }
3149 
3150  if (ECChit && !ECAhit && !Bhit) {
3151  m_hNumSwLLWoT_E[1]->Fill(nTRTHitsW[ibe][1]);
3152  }
3153  }
3154 
3155  if (ECAhit && !ECChit && !Bhit) {
3156  m_hNumSwLLWoT_E[0]->Fill(nTRTHitsW[ibe][0]);
3157  }
3158  } else if (nTRTHitsW[ibe][1] > 0) {
3159  if (ECChit && !ECAhit && !Bhit) {
3160  m_hNumSwLLWoT_E[1]->Fill(nTRTHitsW[ibe][1]);
3161  }
3162  }
3163 
3164  for (int iside = 0; iside < 2; iside++) {
3165  if (nTRTHLHitsW[ibe][iside] > 0) {
3166  m_hHLhitOnTrack_E[iside]->Fill(nTRTHLHitsW[ibe][iside]);
3167  }
3168 
3169  if ((nTRTHitsW[ibe][iside]) > 0) {
3170  m_hHtoLRatioOnTrack_E[iside]->Fill((float)(nTRTHLHitsW[ibe][iside]) / nTRTHitsW[ibe][iside]);
3171 
3172  if ((nTRTHitsW_Ar[ibe][iside]) > 0) {
3173  m_hHtoLRatioOnTrack_E_Ar[iside]->Fill((float)(nTRTHLHitsW_Ar[ibe][iside]) / nTRTHitsW_Ar[ibe][iside]);
3174  }
3175 
3176  if ((nTRTHitsW_Xe[ibe][iside]) > 0) {
3177  m_hHtoLRatioOnTrack_E_Xe[iside]->Fill((float)(nTRTHLHitsW_Xe[ibe][iside]) / nTRTHitsW_Xe[ibe][iside]);
3178  }
3179  }
3180  }
3181  }
3182  }
3183 
3184  if (ibe == 0) {
3185  if ((nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]) > 0) {
3186  m_nTrksperLB_B++;
3187  }
3188  if (comTimeObject) {
3189  if (m_doShift && (phi2D[ibe] > 0) && (std::fabs(timeCor) > 1e-8)) {
3190  m_hEvtPhaseDetPhi_B->Fill(phi2D[ibe], timeCor);
3191  }
3192  }
3193  } else if (ibe == 1) {
3194  for (int iside = 0; iside < 2; iside++) {
3195  if (nTRTHitsW[ibe][iside] > 0) m_nTrksperLB_E[iside]++;
3196  if (comTimeObject) {
3197  if (nTRTHits_side[ibe][iside] > 5 && (std::fabs(timeCor)
3198  > 1e-8)) {
3199  if (m_doShift) m_hEvtPhaseDetPhi_E[iside]->Fill(phi2D[ibe], timeCor);
3200  }
3201  }
3202  }
3203  }
3204  }
3205  }
3206 
3207  if (comTimeObject) {
3208  if (std::fabs(timeCor) > 1e-8) {
3209  if (m_doShift) {
3210  m_hEvtPhase->Fill(timeCor);
3211  }
3212 
3213  if (m_doShift && trigDecision) {
3214  std::vector<int> trigid;
3215  trigid.clear(); // Trigger ID
3216  // get bits for trigger after veto
3217  std::vector<unsigned int> level1TAV = trigDecision->tav();
3218 
3219  for (unsigned int j = 0; j < 8 && j < level1TAV.size(); ++j) {
3220  for (unsigned int i = 0; i < 32; ++i) {
3221  if ((level1TAV[j] >> i) & 0x1) {
3222  trigid.push_back(i + (j % 8) * 32); // Found the ID
3223  }
3224  }
3225  }
3226 
3227  for (unsigned int j = 0; j < trigid.size(); ++j) {
3228  m_hEvtPhaseVsTrig->Fill(timeCor, trigid[j]);// Event Phase vs. Trigger Item
3229  }
3230  }
3231  }
3232  }
3233 
3234  for (int ibe = 0; ibe < 2; ibe++) {
3235  if (m_environment == AthenaMonManager::online && m_totalEvents > 0) {
3236  //Loop over stack histograms and normalize to number of events processed.
3237  if (m_doChips && m_doExpert) {
3238  for (int i = 0; i < 64; i++) {
3239  divide_LWHist(m_hHitOnTrackVsAllC[ibe][i], m_hHitAonTMapC[ibe][i], m_hHitAMapC[ibe][i]);
3240 
3241  for (int j = 0; j < s_iChip_max[ibe]; j++) {
3242  if (m_hChipsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
3243  float effScale = 1. / m_hChipsEff[ibe][i]->GetBinEntries(j + 1);
3244  int binContent = m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1);
3245  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3246  binContent = m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1);
3247  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3248  binContent = m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1);
3249  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3250  binContent = m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1);
3251  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3252  binContent = m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1);
3253  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3254  } else {
3255  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3256  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3257  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3258  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3259  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3260  }
3261  }
3262 
3263  divide_LWHist(m_hHtoLMapC[ibe][i], m_hHitHMapC[ibe][i], m_hHitAMapC[ibe][i]);
3264  divide_LWHist(m_hHtoLonTMapC[ibe][i], m_hHitHonTMapC[ibe][i], m_hHitAonTMapC[ibe][i]);
3265  divide_LWHist(m_hHtoLWonTMapC[ibe][i], m_hHitHWonTMapC[ibe][i], m_hHitAWonTMapC[ibe][i]);
3266  }
3267  }
3268 
3269  if (m_doStraws) {
3270  for (int i = 0; i < 64; i++) {
3271  if (m_doExpert) {
3272  divide_LWHist(m_hHitOnTrackVsAllS[ibe][i], m_hHitAonTMapS[ibe][i], m_hHitAMapS[ibe][i]);
3273  }
3274 
3275  for (int j = 0; j < s_Straw_max[ibe]; j++) {
3276  if (i == 0) {
3277  if (ibe == 0) {
3278  if (m_nStrawHits_B[j] > 0) {
3279  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) / m_nStrawHits_B[j]);
3280  }
3281  } else if (ibe == 1) {
3282  if (m_nStrawHits_E[0][j] > 0) {
3283  m_hHitWonTMap_E[0]->SetBinContent(j + 1, m_hHitWonTMap_E[0]->GetBinContent(j + 1) / m_nStrawHits_E[0][j]);
3284  }
3285 
3286  if (m_nStrawHits_E[1][j] > 0) {
3287  m_hHitWonTMap_E[1]->SetBinContent(j + 1, m_hHitWonTMap_E[1]->GetBinContent(j + 1) / m_nStrawHits_E[1][j]);
3288  }
3289  }
3290  }
3291 
3292  if (m_doExpert) {
3293  if (m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
3294  float effScale = 1. / m_hStrawsEff[ibe][i]->GetBinEntries(j + 1);
3295  int binContent = m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1);
3296  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3297  binContent = m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1);
3298  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3299  binContent = m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1);
3300  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3301  binContent = m_hHitHWonTMapS[ibe][i]->GetBinContent(j + 1);
3302  m_hHitHWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3303  binContent = m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1);
3304  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3305  } else {
3306  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3307  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3308  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3309  m_hHitHWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3310  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3311  }
3312  }
3313  }
3314 
3315  if (m_doExpert) {
3316  divide_LWHist(m_hHtoLMapS[ibe][i], m_hHitHMapS[ibe][i], m_hHitAMapS[ibe][i]);
3317  divide_LWHist(m_hHtoLonTMapS[ibe][i], m_hHitHonTMapS[ibe][i], m_hHitAonTMapS[ibe][i]);
3318  divide_LWHist(m_hHtoLWonTMapS[ibe][i], m_hHitHWonTMapS[ibe][i], m_hHitAWonTMapS[ibe][i]);
3319  }
3320  }
3321  }
3322 
3323  if (m_doShift) {
3324  if (ibe == 0) {
3325  m_hSummary->SetBinContent(2, m_nTotalTracks);
3326  m_hSummary->SetBinContent(3, m_nTracksB[0]);
3327  m_hSummary->SetBinContent(4, m_nTracksB[1]);
3328  m_hSummary->SetBinContent(5, m_nTracksEC[0]);
3329  m_hSummary->SetBinContent(6, m_nTracksEC[1]);
3330  m_hSummary->SetBinContent(7, m_nTracksEC_B[0]);
3331  m_hSummary->SetBinContent(8, m_nTracksEC_B[1]);
3332  m_EventPhaseScale = m_hEvtPhase->GetEntries() * 3.125;
3333 
3334  if (m_EventPhaseScale > 0) {
3335  scale_LWHist(m_hEvtPhase, 1. / m_EventPhaseScale);
3336  }
3337 
3338  m_DriftTimeonTrkDistScale_B = m_hDriftTimeonTrkDist_B->GetEntries() * 3.125;
3339 
3340  if (m_DriftTimeonTrkDistScale_B > 0) {
3341  scale_LWHist(m_hDriftTimeonTrkDist_B, 1. / m_DriftTimeonTrkDistScale_B);
3342  }
3343 
3344  m_HLhitOnTrackScale_B = m_hHLhitOnTrack_B->GetEntries();
3345 
3346  if (m_HLhitOnTrackScale_B > 0) {
3347  scale_LWHist(m_hHLhitOnTrack_B, 1. / m_HLhitOnTrackScale_B);
3348  }
3349 
3350  m_HtoLRatioOnTrackScale_B = m_hHtoLRatioOnTrack_B->GetEntries() * 0.02;
3351 
3352  if (m_HtoLRatioOnTrackScale_B > 0) {
3353  scale_LWHist(m_hHtoLRatioOnTrack_B, 1. / m_HtoLRatioOnTrackScale_B);
3354  }
3355 
3356  m_NumSwLLWoTScale_B = m_hNumSwLLWoT_B->GetEntries();
3357 
3358  if (m_NumSwLLWoTScale_B > 0) {
3359  scale_LWHist(m_hNumSwLLWoT_B, 1. / m_NumSwLLWoTScale_B);
3360  }
3361 
3362  m_WireToTrkPositionScale_B = m_hWireToTrkPosition_B->GetEntries() * 0.1;
3363 
3364  if (m_WireToTrkPositionScale_B > 0) {
3365  scale_LWHist(m_hWireToTrkPosition_B, 1. / m_WireToTrkPositionScale_B);
3366  }
3367 
3368  m_TronTDistScale_B = m_hTronTDist_B->GetEntries() * 3.125;
3369 
3370  if (m_TronTDistScale_B > 0) {
3371  scale_LWHist(m_hTronTDist_B, 1. / m_TronTDistScale_B);
3372  }
3373 
3374  m_ResidualScale_B = m_hResidual_B->GetEntries() * 0.025;
3375 
3376  if (m_ResidualScale_B > 0) {
3377  scale_LWHist(m_hResidual_B, 1. / m_ResidualScale_B);
3378  }
3379 
3380  m_ResidualScale_B_20GeV = m_hResidual_B_20GeV->GetEntries() * 0.025;
3381 
3382  if (m_ResidualScale_B_20GeV > 0) {
3383  scale_LWHist(m_hResidual_B_20GeV, 1. / m_ResidualScale_B_20GeV);
3384  }
3385 
3386  m_TimeResidualScale_B = m_hTimeResidual_B->GetEntries() * 0.2;
3387 
3388  if (m_TimeResidualScale_B > 0) {
3389  scale_LWHist(m_hTimeResidual_B, 1. / m_TimeResidualScale_B);
3390  }
3391 
3392  if (m_ArgonXenonSplitter) {
3393  m_DriftTimeonTrkDistScale_B_Ar = m_hDriftTimeonTrkDist_B_Ar->GetEntries() * 3.125;
3394 
3395  if (m_DriftTimeonTrkDistScale_B_Ar > 0) {
3396  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, 1. / m_DriftTimeonTrkDistScale_B_Ar);
3397  }
3398 
3399  m_WireToTrkPositionScale_B_Ar = m_hWireToTrkPosition_B_Ar->GetEntries() * 0.1;
3400 
3401  if (m_WireToTrkPositionScale_B_Ar > 0) {
3402  scale_LWHist(m_hWireToTrkPosition_B_Ar, 1. / m_WireToTrkPositionScale_B_Ar);
3403  }
3404 
3405  m_TronTDistScale_B_Ar = m_hTronTDist_B_Ar->GetEntries() * 3.125;
3406 
3407  if (m_TronTDistScale_B_Ar > 0) {
3408  scale_LWHist(m_hTronTDist_B_Ar, 1. / m_TronTDistScale_B_Ar);
3409  }
3410 
3411  m_ResidualScale_B_Ar = m_hResidual_B_Ar->GetEntries() * 0.025;
3412 
3413  if (m_ResidualScale_B_Ar > 0) {
3414  scale_LWHist(m_hResidual_B_Ar, 1. / m_ResidualScale_B_Ar);
3415  }
3416 
3417  m_ResidualScale_B_Ar_20GeV = m_hResidual_B_Ar_20GeV->GetEntries() * 0.025;
3418 
3419  if (m_ResidualScale_B_Ar_20GeV > 0) {
3420  scale_LWHist(m_hResidual_B_Ar_20GeV, 1. / m_ResidualScale_B_Ar_20GeV);
3421  }
3422 
3423  m_TimeResidualScale_B_Ar = m_hTimeResidual_B_Ar->GetEntries() * 0.2;
3424 
3425  if (m_TimeResidualScale_B_Ar > 0) {
3426  scale_LWHist(m_hTimeResidual_B_Ar, 1. / m_TimeResidualScale_B_Ar);
3427  }
3428  }
3429  } else if (ibe == 1) {
3430  for (int iside = 0; iside < 2; iside++) {
3431  m_DriftTimeonTrkDistScale_E[iside] = m_hDriftTimeonTrkDist_E[iside]->GetEntries() * 3.125;
3432 
3433  if (m_DriftTimeonTrkDistScale_E[iside] > 0) {
3434  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], 1. / m_DriftTimeonTrkDistScale_E[iside]);
3435  }
3436 
3437  m_HLhitOnTrackScale_E[iside] = m_hHLhitOnTrack_E[iside]->GetEntries();
3438 
3439  if (m_HLhitOnTrackScale_E[iside] > 0) {
3440  scale_LWHist(m_hHLhitOnTrack_E[iside], 1. / m_HLhitOnTrackScale_E[iside]);
3441  }
3442 
3443  m_HtoLRatioOnTrackScale_E[iside] = m_hHtoLRatioOnTrack_E[iside]->GetEntries() * 0.02;
3444 
3445  if (m_HtoLRatioOnTrackScale_E[iside] > 0) {
3446  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], 1. / m_HtoLRatioOnTrackScale_E[iside]);
3447  }
3448 
3449  m_NumSwLLWoTScale_E[iside] = m_hNumSwLLWoT_E[iside]->GetEntries();
3450 
3451  if (m_NumSwLLWoTScale_E[iside] > 0) {
3452  scale_LWHist(m_hNumSwLLWoT_E[iside], 1. / m_NumSwLLWoTScale_E[iside]);
3453  }
3454 
3455  m_WireToTrkPositionScale_E[iside] = m_hWireToTrkPosition_E[iside]->GetEntries() * 0.1;
3456 
3457  if (m_WireToTrkPositionScale_E[iside] > 0) {
3458  scale_LWHist(m_hWireToTrkPosition_E[iside], 1. / m_WireToTrkPositionScale_E[iside]);
3459  }
3460 
3461  m_TronTDistScale_E[iside] = m_hTronTDist_E[iside]->GetEntries() * 3.125;
3462 
3463  if (m_TronTDistScale_E[iside] > 0) {
3464  scale_LWHist(m_hTronTDist_E[iside], 1. / m_TronTDistScale_E[iside]);
3465  }
3466 
3467  m_ResidualScale_E[iside] = m_hResidual_E[iside]->GetEntries() * 0.025;
3468 
3469  if (m_ResidualScale_E[iside] > 0) {
3470  scale_LWHist(m_hResidual_E[iside], 1. / m_ResidualScale_E[iside]);
3471  }
3472 
3473  m_ResidualScale_E_20GeV[iside] = m_hResidual_E_20GeV[iside]->GetEntries() * 0.025;
3474 
3475  if (m_ResidualScale_E_20GeV[iside] > 0) {
3476  scale_LWHist(m_hResidual_E_20GeV[iside], 1. / m_ResidualScale_E_20GeV[iside]);
3477  }
3478 
3479  m_TimeResidualScale_E[iside] = m_hTimeResidual_E[iside]->GetEntries() * 0.2;
3480 
3481  if (m_TimeResidualScale_E[iside] > 0) {
3482  scale_LWHist(m_hTimeResidual_E[iside], 1. / m_TimeResidualScale_E[iside]);
3483  }
3484 
3485  if (m_ArgonXenonSplitter) {
3486  m_DriftTimeonTrkDistScale_E_Ar[iside] = m_hDriftTimeonTrkDist_E_Ar[iside]->GetEntries() * 3.125;
3487 
3488  if (m_DriftTimeonTrkDistScale_E_Ar[iside] > 0) {
3489  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], 1. / m_DriftTimeonTrkDistScale_E_Ar[iside]);
3490  }
3491 
3492  m_WireToTrkPositionScale_E_Ar[iside] = m_hWireToTrkPosition_E_Ar[iside]->GetEntries() * 0.1;
3493 
3494  if (m_WireToTrkPositionScale_E_Ar[iside] > 0) {
3495  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], 1. / m_WireToTrkPositionScale_E_Ar[iside]);
3496  }
3497 
3498  m_TronTDistScale_E_Ar[iside] = m_hTronTDist_E_Ar[iside]->GetEntries() * 3.125;
3499 
3500  if (m_TronTDistScale_E_Ar[iside] > 0) {
3501  scale_LWHist(m_hTronTDist_E_Ar[iside], 1. / m_TronTDistScale_E_Ar[iside]);
3502  }
3503 
3504  m_ResidualScale_E_Ar[iside] = m_hResidual_E_Ar[iside]->GetEntries() * 0.025;
3505 
3506  if (m_ResidualScale_E_Ar[iside] > 0) {
3507  scale_LWHist(m_hResidual_E_Ar[iside], 1. / m_ResidualScale_E_Ar[iside]);
3508  }
3509 
3510  m_ResidualScale_E_Ar_20GeV[iside] = m_hResidual_E_Ar_20GeV[iside]->GetEntries() * 0.025;
3511 
3512  if (m_ResidualScale_E_Ar_20GeV[iside] > 0) {
3513  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], 1. / m_ResidualScale_E_Ar_20GeV[iside]);
3514  }
3515 
3516  m_TimeResidualScale_E_Ar[iside] = m_hTimeResidual_E_Ar[iside]->GetEntries() * 0.2;
3517 
3518  if (m_TimeResidualScale_E_Ar[iside] > 0) {
3519  scale_LWHist(m_hTimeResidual_E_Ar[iside], 1. / m_TimeResidualScale_E_Ar[iside]);
3520  }
3521  }
3522  }
3523  }
3524  }
3525  }
3526  }
3527 
3528  return StatusCode::SUCCESS;
3529 }

◆ finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )
virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, TileDigitsMonTool, and TileCellNoiseMonTool.

Definition at line 1333 of file ManagedMonitorToolBase.cxx.

1335 {
1336 
1337  // This assumes that the end of a file will naturally end a run, which is not always true.
1338  // A merging application run afterwards should be able to put parts of a run together.
1339  if( m_nEvents != 1 ) {
1340  m_d->benchPreProcHistograms();
1341 
1342  // Set end flags for the LowStat, LumiBlock and Run variables.
1343  // This is needed to be used in the procHistograms method below.
1344  m_endOfEventsBlock = true;
1345  m_endOfLowStat = true;
1346  m_endOfLumiBlock = true;
1347  m_endOfRun = true;
1348  endOfEventsBlock = true;
1349  endOfLowStat = true;
1350  endOfLumiBlock = true;
1351  endOfRun = true;
1352 
1353  StatusCode sc = procHistograms();
1354 
1355 /*
1356  StatusCode sc1( StatusCode::SUCCESS );
1357 
1358 #if 0
1359  for (const auto interval: m_supportedIntervalsForRebooking) {
1360  //sc1 = regManagedHistograms(m_templateHistograms[interval], false);
1361  //sc1 = regManagedGraphs(m_templateGraphs[interval], false);
1362  //sc1 = regManagedTrees(m_templateTrees[interval], false);
1363 
1364  // Yura: commented out when fixing online environment
1365  //sc1 = regManagedLWHistograms(m_templateLWHistograms[interval], false, true);
1366  }
1367 */
1368 
1369  m_d->benchPostProcHistograms();
1370  return sc;
1371  }
1372  return StatusCode::SUCCESS;
1373 }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 754 of file ManagedMonitorToolBase.h.

754  {
755  return m_nEvents;
756  }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 758 of file ManagedMonitorToolBase.h.

758  {
759  return m_procNEventsProp;
760  }

◆ getHist() [1/6]

StatusCode ManagedMonitorToolBase::getHist ( LWHist *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Definition at line 1614 of file ManagedMonitorToolBase.cxx.

1615 {
1616  h = 0;
1617  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1618  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1619  for (;it!=itE;++it) {
1620  if (LWHistAthMonWrapper::streamName(*it)==streamName) {
1621  h = *it;
1622  return StatusCode::SUCCESS;
1623  }
1624  }
1625  return StatusCode::FAILURE;
1626 }

◆ getHist() [2/6]

StatusCode ManagedMonitorToolBase::getHist ( LWHist *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Definition at line 1606 of file ManagedMonitorToolBase.cxx.

1608 {
1609  MonGroup group( this, system, interval );
1610  return getHist( h, hName, group );
1611 }

◆ getHist() [3/6]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1598 of file ManagedMonitorToolBase.cxx.

1600 {
1601  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1602  return m_THistSvc->getHist( streamName, h );
1603 }

◆ getHist() [4/6]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1588 of file ManagedMonitorToolBase.cxx.

1591 {
1592  MonGroup group( this, system, interval );
1593  return getHist( h, hName, group );
1594 }

◆ getHist() [5/6]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1640 of file ManagedMonitorToolBase.cxx.

1642 {
1643  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1644  return m_THistSvc->getHist( streamName, h );
1645 }

◆ getHist() [6/6]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1630 of file ManagedMonitorToolBase.cxx.

1633 {
1634  MonGroup group( this, system, interval );
1635  return getHist( h, hName, group );
1636 }

◆ getNewStreamNameFcn()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::getNewStreamNameFcn ( ) const
protectedvirtualinherited

Definition at line 2387 of file ManagedMonitorToolBase.cxx.

2389 {
2390  StreamNameFcn* fcn(0);
2391 
2392  switch( m_environment ) {
2393  case AthenaMonManager::noOutput:
2394  fcn = new NoOutputStream();
2395  break;
2396  case AthenaMonManager::online:
2397  fcn = new OnlineStream();
2398  break;
2399  case AthenaMonManager::user:
2400  fcn = new DefaultStream( m_fileKey );
2401  break;
2402  case AthenaMonManager::tier0:
2403  case AthenaMonManager::tier0Raw:
2404  case AthenaMonManager::tier0ESD:
2405  case AthenaMonManager::AOD:
2406  case AthenaMonManager::altprod:
2407  default:
2408  fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2409  }
2410 
2411  return fcn;
2412 }

◆ initialize()

StatusCode TRT_Monitoring_Tool::initialize ( )
virtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 375 of file TRT_Monitoring_Tool.cxx.

375  {
376 //------------------------------------------------------------------------------------//
377  ATH_MSG_VERBOSE("Initializing TRT Monitoring");
378 
379  ATH_CHECK( ManagedMonitorToolBase::initialize() );
380  ATH_CHECK( ManagedMonitorToolBase::initialize() );
381 
382  IToolSvc *p_toolSvc; // NOTE: recreation of ToolSvc
383 
384  ATH_CHECK( service("ToolSvc", p_toolSvc) );
385  // Retrieve detector manager.
386  ATH_CHECK( detStore()->retrieve(m_mgr, "TRT") );
387  // Get ID helper for TRT to access various detector components like straw, straw_layer, layer_or_wheel, phi_module, etc...
388  ATH_CHECK( detStore()->retrieve(m_pTRTHelper, "TRT_ID") );
389  ATH_CHECK( detStore()->retrieve(m_idHelper, "AtlasID") );
390 
391  if (m_doExpert) {
392  // Retrieve the TRT_Straw Status Service.
393  if (m_sumTool.name().empty()) {
394  ATH_MSG_WARNING("TRT_StrawStatusTool not given.");
395  } else {
396  ATH_CHECK( m_sumTool.retrieve() );
397  }
398 
399 
400  // NOTE: is this used anywhere?
401  // NOTE: This is the same of m_BSSvc
402  // Retrieve the TRT_Conditions Service.
403  if (m_condSvc_BS.name().empty()) {
404  ATH_MSG_WARNING("TRT_ConditionsSvc not given.");
405  } else {
406  ATH_CHECK( m_condSvc_BS.retrieve() );
407  }
408 
409  // NOTE: is this used anywhere?
410  // Retrieve the TRT_DAQConditions Service.
411  if (m_DAQSvc.name().empty()) {
412  ATH_MSG_WARNING("TRT_DAQConditionsSvc not given.");
413  } else {
414  ATH_CHECK( m_DAQSvc.retrieve() );
415  }
416 
417  // Test out the TRT_ConditionsSummaryTool.
418  //Identifier ident = m_trtid->straw_id(1,1,1,1,1);
419  Identifier ident;
420 
421  if (!m_sumTool.name().empty()) {
422  ATH_MSG_VERBOSE("Trying " << m_sumTool << " isGood");
423  ATH_MSG_VERBOSE("TRT_StrawStatusTool reports status = " << m_sumTool->getStatus(ident));
424  }
425  }//If do expert
426 
427  //Retrieve TRT_StrawNeighbourService.
428  if (m_TRTStrawNeighbourSvc.name().empty()) {
429  ATH_MSG_WARNING("TRT_StrawNeighbourSvc not given.");
430  } else {
431  if (m_TRTStrawNeighbourSvc.retrieve().isFailure()) {
432  ATH_MSG_FATAL("Could not get StrawNeighbourSvc.");
433  }
434  }
435 
436  // Get Track summary tool
437  if (m_TrackSummaryTool.retrieve().isFailure())
438  ATH_MSG_ERROR("Cannot get TrackSummaryTool");
439  else
440  ATH_MSG_DEBUG("Retrieved succesfully the track summary tool" << m_TrackSummaryTool);
441 
442  //Get TRTCalDbTool
443  if (m_TRTCalDbTool.name().empty()) {
444  ATH_MSG_WARNING("TRT_CalDbTool not given.");
445  } else {
446  if (m_TRTCalDbTool.retrieve().isFailure()) {
447  ATH_MSG_ERROR("Cannot get TRTCalDBTool.");
448  }
449  }
450 
451  // retrieve TRTTrackHoleSearchTool
452  if (m_doEfficiency || m_doExpert) {
453  ATH_CHECK( m_trt_hole_finder.retrieve() );
454  }
455  else {
456  m_trt_hole_finder.disable();
457  }
458 
459  ATH_CHECK(m_drifttool.retrieve());
460 
461  // Initialize arrays
462  // These arrays store information about each entry to the HitMap histograms
463 
464  // if (m_environment==AthenaMonManager::online)
465  if (true) {
466  //loop over straw hash index to create straw number mapping for TRTViewer
467  unsigned int maxHash = m_pTRTHelper->straw_layer_hash_max();
468 
469  for (int ibe = 0; ibe < 2; ibe++) { // ibe=0(barrel), ibe=1(endcap)
470  for (unsigned int index = 0; index < maxHash; index++) {
471  IdentifierHash idHash = index;
472  Identifier id = m_pTRTHelper->layer_id(idHash);
473  int idBarrelEndcap = m_pTRTHelper->barrel_ec(id);
474  int idLayerWheel = m_pTRTHelper->layer_or_wheel(id);
475  int idPhiModule = m_pTRTHelper->phi_module(id);
476  int idStrawLayer = m_pTRTHelper->straw_layer(id);
477  bool isBarrel = m_pTRTHelper->is_barrel(id);
478  int idSide;
479  int sectorflag = 0;
480  const InDetDD::TRT_BaseElement *element = nullptr;
481 
482  if (ibe == 0) { // barrel
483  idSide = idBarrelEndcap ? 1 : -1;
484 
485  if (isBarrel && (idBarrelEndcap == -1)) {
486  sectorflag = 1;
487  element = m_mgr->getBarrelElement(idSide, idLayerWheel, idPhiModule, idStrawLayer);
488  }
489  } else if (ibe == 1) { // endcap
490  idSide = idBarrelEndcap ? 1 : 0;
491 
492  if (!isBarrel && ((idBarrelEndcap == -2) || (idBarrelEndcap == 2))) {
493  sectorflag = 1;
494  element = m_mgr->getEndcapElement(idSide, idLayerWheel, idStrawLayer, idPhiModule);//, idStrawLayer_ec);
495  }
496  }
497 
498  if (sectorflag == 1) {
499  if (!element) continue;
500 
501  for (unsigned int istraw = 0; istraw < element->nStraws(); istraw++) {
502  std::vector<Identifier> neighbourIDs;
503  Identifier strawID = m_pTRTHelper->straw_id(id, int(istraw));
504  int i_chip, i_pad;
505  m_TRTStrawNeighbourSvc->getChip(strawID, i_chip);
506  m_TRTStrawNeighbourSvc->getPad(id, i_pad);
507 
508  if (ibe == 0) { //barrel
509  if (idLayerWheel == 1) i_chip += 21;
510 
511  if (idLayerWheel == 2) i_chip += 54;
512 
513  int tempStrawNumber = strawNumber(istraw, idStrawLayer, idLayerWheel);
514 
515  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
516  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
517  } else {
518  m_mat_chip_B[idPhiModule][tempStrawNumber] = i_chip;
519  m_mat_chip_B[idPhiModule + 32][tempStrawNumber] = i_chip;
520  }
521  } else if (ibe == 1) { //endcap
522  // i_chip -= 104;
523  ++i_chip -= 104;
524  int tempStrawNumber = strawNumberEndCap(istraw, idStrawLayer, idLayerWheel, idPhiModule, idSide);
525 
526  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
527  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
528  } else {
529  m_mat_chip_E[idPhiModule][tempStrawNumber] = i_chip;
530  m_mat_chip_E[idPhiModule + 32][tempStrawNumber] = i_chip;
531  }
532  }
533  }
534  }
535  }//for (unsigned int index = 0; index < maxHash; index++)
536  } //for (int ibe=0; ibe<2; ibe++)
537  }
538 
539  // some initializaton
540  // TODO: ugly way of doing this, so we probably want to clean it up a bit.
541  if (m_doShift) {
542  // Barrel
543  int ibe = 0;
544 
545  for (int iStack = 0; iStack < s_iStack_max[ibe]; iStack++) {
546  m_LLOcc[ibe][iStack] = 0;
547  m_LLOcc[ibe][iStack + 32] = 0;
548  m_HTfraconTrack_B[iStack] = 0;
549  m_LonTrack_B[iStack] = 0;
550  m_nTrack_B[iStack] = 0;
551  }
552 
553  for (int i = 0; i < s_Straw_max[ibe]; i++) {
554  m_nStrawHits_B[i] = 0;
555  }
556 
557  // Endcap
558  ibe = 1;
559 
560  for (int iStack = 0; iStack < s_iStack_max[ibe]; iStack++) {
561  m_LLOcc[ibe][iStack] = 0;
562  m_HTfraconTrack_E[iStack] = 0;
563  m_LonTrack_E[iStack] = 0;
564  m_nTrack_E[iStack] = 0;
565  }
566 
567  for (int i = 0; i < s_Straw_max[ibe]; i++) {
568  m_nStrawHits_E[0][i] = 0; // A-side
569  m_nStrawHits_E[1][i] = 0; // C-side
570  }
571  } // doshift for phi bin init
572 
573  // Initialization of VarHandleKeys
574  ATH_CHECK( m_rdoContainerKey.initialize() );
575  ATH_CHECK( m_trackCollectionKey.initialize() );
576  ATH_CHECK( m_combTrackCollectionKey.initialize() );
577  ATH_CHECK( m_xAODEventInfoKey.initialize() );
578  ATH_CHECK( m_TRT_BCIDCollectionKey.initialize() );
579  ATH_CHECK( m_comTimeObjectKey.initialize() );
580  ATH_CHECK( m_bsErrContKey.initialize(SG::AllowEmpty) );
581  ATH_CHECK( m_trigDecisionKey.initialize(!m_trigDecisionKey.empty()) );
582 
583  ATH_MSG_INFO("My TRT_DAQ_ConditionsSvc is " << m_DAQSvc);
584 
585  return StatusCode::SUCCESS;
586 }

◆ initScaleVectors()

int TRT_Monitoring_Tool::initScaleVectors ( )
private

Definition at line 4486 of file TRT_Monitoring_Tool.cxx.

4486  {
4487 //----------------------------------------------------------------------------------//
4488  if (m_flagforscale == 0 ) return 0;
4489 
4490  m_scale_hHitWMap_B.clear();
4491  m_scale_hHitWMap_B_Ar.clear();
4492 
4493  for (int i = 0; i < s_Straw_max[0]; i++) {
4494  float countAr = 0;
4495  float countXe = 0;
4496  int sN, sLN, lN;
4497  strawNumber_reverse(i, &sN, &sLN, &lN);
4498 
4499  for (int side = -1 ; side < 2; side += 2 ) {
4500  for (int j = 0; j < 32; j++ ) {
4501  Identifier Dummy_Identifier;
4502  Dummy_Identifier = m_pTRTHelper->straw_id(side, j, lN, sLN, sN);
4503  bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(Dummy_Identifier) ) == GasType::Ar);
4504 
4505  if (isArgonStraw)
4506  countAr += 1.0;
4507  else
4508  countXe += 1.0;
4509  }
4510  }
4511 
4512  m_scale_hHitWMap_B.push_back(countXe);
4513  m_scale_hHitWMap_B_Ar.push_back(countAr);
4514  }
4515 
4516  m_flagforscale = 0;
4517  return 0;
4518 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& IMonitorToolBase::interfaceID ( )
inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

29 { return IID_IMonitorToolBase; }

◆ intervalEnumToString()

std::string ManagedMonitorToolBase::intervalEnumToString ( Interval_t  interval)
staticinherited

Converts a LevelOfDetail_t to a string of the same name.

Converts a string to the corresponding LevelOfDetail_t. Converts a Interval_t to a string of the same name.

Definition at line 587 of file ManagedMonitorToolBase.cxx.

589 {
590  std::string str("file");
591 
592  switch( interval ) {
593  case all:
594  str = "all";
595  break;
596  case fill:
597  str = "fill";
598  break;
599  case run:
600  str = "run";
601  break;
602  case lowStat:
603  str = "lowStat";
604  break;
605  case medStat:
606  str = "medStat";
607  break;
608  case higStat:
609  str = "higStat";
610  break;
611  case lumiBlock:
612  str = "lumiBlock";
613  break;
614  case eventsBlock:
615  str = "eventsBlock";
616  break;
617  case file:
618  str = "file";
619  break;
620  default:
621  str = "unknown";
622  }
623 
624  return str;
625 }

◆ intervalStringToEnum()

ManagedMonitorToolBase::Interval_t ManagedMonitorToolBase::intervalStringToEnum ( const std::string &  str)
staticinherited

Converts a string to the corresponding Interval_t.

Definition at line 629 of file ManagedMonitorToolBase.cxx.

631 {
632  std::string lcstr( strToLower(str) );
633 
634  if( lcstr == "all" )
635  return all;
636  else if( lcstr == "fill" )
637  return fill;
638  else if( lcstr == "run" )
639  return run;
640  else if( lcstr == "lowStat" )
641  return lowStat;
642  else if( lcstr == "medStat" )
643  return medStat;
644  else if( lcstr == "higStat" )
645  return higStat;
646  else if( lcstr == "lumiBlock" )
647  return lumiBlock;
648  else if( lcstr == "eventsBlock" )
649  return eventsBlock;
650  else if( lcstr == "file" )
651  return file;
652 
653  if( Imp::s_svcLocator ) {
654  IMessageSvc* ms(0);
655  StatusCode sc = Imp::s_svcLocator.load()->service( "MessageSvc", ms, true );
656  if( sc.isSuccess() ) {
657  MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
658  log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
659  << str << "\", returning \"file\"" << endmsg;
660  }
661  }
662 
663  return file;
664 }

◆ lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average mu, i.e.

<mu>

Definition at line 1923 of file ManagedMonitorToolBase.cxx.

1925 {
1926  if (!m_lumiDataKey.empty()) {
1927  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1928  return lumi->lbAverageInteractionsPerCrossing();
1929  } else {
1930  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
1931  ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1932  return -1.0;
1933  }
1934  // not reached
1935 }

◆ lbAverageLivefraction()

float ManagedMonitorToolBase::lbAverageLivefraction ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity livefraction.

Definition at line 1992 of file ManagedMonitorToolBase.cxx.

1994 {
1995  if (m_environment == AthenaMonManager::online)
1996  return 1.0;
1997 
1998  if (!m_trigLiveFractionDataKey.empty()) {
1999  SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
2000  return live->lbAverageLiveFraction();
2001  } else {
2002  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
2003  ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
2004  return -1.0;
2005  }
2006  // not reached
2007 }

◆ lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)

Definition at line 1959 of file ManagedMonitorToolBase.cxx.

1961 {
1962  if (!m_lumiDataKey.empty()) {
1963  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1964  return lumi->lbAverageLuminosity();
1965  } else {
1966  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
1967  ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1968  return -1.0;
1969  }
1970  // not reached
1971 }

◆ lbDuration()

double ManagedMonitorToolBase::lbDuration ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Luminosity block time (in seconds)

Definition at line 2046 of file ManagedMonitorToolBase.cxx.

2048 {
2049  if ( m_environment == AthenaMonManager::online ) {
2050  return m_defaultLBDuration;
2051  }
2052  if (!m_lbDurationDataKey.empty()) {
2053  SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
2054  return dur->lbDuration();
2055  } else {
2056  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
2057  ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
2058  return m_defaultLBDuration;
2059  }
2060  // not reached
2061 }

◆ lbInteractionsPerCrossing()

float ManagedMonitorToolBase::lbInteractionsPerCrossing ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1939 of file ManagedMonitorToolBase.cxx.

1941 {
1942  if (!m_lumiDataKey.empty()) {
1943  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1944  float muToLumi = lumi->muToLumi();
1945  if (muToLumi > 0) {
1946  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1947  }
1948  return 0;
1949  } else {
1950  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
1951  ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1952  return -1.0;
1953  }
1954  // not reached
1955 }

◆ lbLuminosityPerBCID()

float ManagedMonitorToolBase::lbLuminosityPerBCID ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous luminosity.

Definition at line 1975 of file ManagedMonitorToolBase.cxx.

1977 {
1978  if (!m_lumiDataKey.empty()) {
1979  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1980  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1981  } else {
1982  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
1983  ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1984  return -1.0;
1985  }
1986  // not reached
1987 }

◆ lbLumiWeight()

double ManagedMonitorToolBase::lbLumiWeight ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 2030 of file ManagedMonitorToolBase.cxx.

2032 {
2033  if (!m_lumiDataKey.empty()) {
2034  return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
2035  } else{
2036  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
2037  ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
2038  return -1.0;
2039  }
2040  // not reached
2041 }

◆ livefractionPerBCID()

float ManagedMonitorToolBase::livefractionPerBCID ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Livefraction per bunch crossing ID.

Definition at line 2011 of file ManagedMonitorToolBase.cxx.

2013 {
2014  if (m_environment == AthenaMonManager::online)
2015  return 1.0;
2016 
2017  if (!m_trigLiveFractionDataKey.empty()) {
2018  SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
2019  return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
2020  } else {
2021  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
2022  ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
2023  return -1.0;
2024  }
2025  // not reached
2026 }

◆ MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat  )
inherited

◆ MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun  )
inherited

◆ MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval  )
inherited

◆ MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat  )
inherited

◆ MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval  )
inherited

◆ MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval  )
inherited

◆ MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun  )
inherited

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

855 { return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

851 { return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

852 { return m_newLowStat; }

◆ newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const
inlineprotectedinherited

Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.

Definition at line 849 of file ManagedMonitorToolBase.h.

849 { return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

853 { return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 850 of file ManagedMonitorToolBase.h.

850 { return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

854 { return m_newRun; }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ parseList()

StatusCode ManagedMonitorToolBase::parseList ( const std::string &  line,
std::vector< std::string > &  result 
)
protectedinherited

Definition at line 2343 of file ManagedMonitorToolBase.cxx.

2344  {
2345  std::string item;
2346  std::stringstream ss(line);
2347 
2348  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2349 
2350  while ( std::getline(ss, item, ',') ) {
2351  std::stringstream iss(item); // remove
2352  iss >> item; // whitespace
2353  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2354  result.push_back(item);
2355  }
2356 
2357  msg(MSG::DEBUG) << endmsg;
2358  return StatusCode::SUCCESS;
2359 }

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )
virtualinherited

Implements IMonitorToolBase.

Definition at line 1911 of file ManagedMonitorToolBase.cxx.

1913 {
1914  if( m_preScaleProp > 1 ) {
1915  return ( (m_nEvents % m_preScaleProp) == 1 );
1916  }
1917  return true;
1918 }

◆ procHistograms()

StatusCode TRT_Monitoring_Tool::procHistograms ( )
virtual

An inheriting class should either override this function or finalHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 1209 of file TRT_Monitoring_Tool.cxx.

1209  {
1210 //----------------------------------------------------------------------------------//
1211  double n_BorE[2][2], total_BorE[2][2];
1212  double nfill[2] = {3.0, 2.0}; // [0]:barrel, [1]:endcap
1213 
1214  //proccesing of online histograms
1215  if (m_environment != AthenaMonManager::online) {
1216  if (m_doShift && m_doRDOsMon) {
1217  m_hSummary->SetBinContent(1, m_totalEvents);
1218 
1219  if (m_doTracksMon) {
1220  m_hSummary->SetBinContent(2, m_nTotalTracks);
1221  m_hSummary->SetBinContent(3, m_nTracksB[0]);
1222  m_hSummary->SetBinContent(4, m_nTracksB[1]);
1223  m_hSummary->SetBinContent(5, m_nTracksEC[0]);
1224  m_hSummary->SetBinContent(6, m_nTracksEC[1]);
1225  m_hSummary->SetBinContent(7, m_nTracksEC_B[0]);
1226  m_hSummary->SetBinContent(8, m_nTracksEC_B[1]);
1227  }
1228  }
1229 
1230  if (m_totalEvents < m_usedEvents || m_usedEvents < 0) {
1231  m_usedEvents = m_totalEvents;
1232  }
1233 
1234  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1235  for (int ibe = 0; ibe < 2; ibe++) {
1236  //Loop over stack histograms and normalize to number of events processed.
1237  if (m_doChips && m_doExpert && endOfRunFlag()) {
1238  for (int i = 0; i < 64; i++) {
1239  if (m_doTracksMon && m_doExpert) {
1240  divide_LWHist(m_hHitOnTrackVsAllC[ibe][i], m_hHitAonTMapC[ibe][i], m_hHitAMapC[ibe][i]);
1241  }
1242 
1243  if (m_doRDOsMon) {
1244  float scale = (float)m_usedEvents * 16;
1245 
1246  if (scale > 0) {
1247  scale = 1. / scale;
1248  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
1249  scale_LWHist(m_hHitWMapC[ibe][i], scale);
1250  scale_LWHist(m_hHitAMapC[ibe][i], scale);
1251  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
1252  scale_LWHist(m_hHitHMapC[ibe][i], scale);
1253  }
1254  }
1255 
1256  for (int j = 0; j < s_iChip_max[ibe]; j++) {
1257  if (m_doRDOsMon) m_hChipOcc[ibe][i]->Fill(m_hHitAMapC[ibe][i]->GetBinContent(j + 1));
1258 
1259  if (m_doTracksMon) {
1260  float scale = m_hChipsEff[ibe][i]->GetBinEntries(j + 1);
1261 
1262  if (scale > 0) {
1263  scale = 1. / scale;
1264  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1265  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1266  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1267  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1268  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1269  } else {
1270  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1271  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1272  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1273  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1274  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1275  }
1276  }
1277  }
1278 
1279  if (m_doRDOsMon && m_doExpert) {
1280  divide_LWHist(m_hHtoLMapC[ibe][i], m_hHitHMapC[ibe][i], m_hHitAMapC[ibe][i]);
1281  }
1282 
1283  if (m_doTracksMon && m_doExpert) {
1284  divide_LWHist(m_hHtoLonTMapC[ibe][i], m_hHitHonTMapC[ibe][i], m_hHitAonTMapC[ibe][i]);
1285  divide_LWHist(m_hHtoLWonTMapC[ibe][i], m_hHitHWonTMapC[ibe][i], m_hHitAWonTMapC[ibe][i]);
1286  }
1287  }
1288  }
1289 
1290  if (m_doStraws && endOfRunFlag()) {
1291  if (m_doRDOsMon && m_usedEvents > 0) {
1292  if (ibe == 0) {
1293  //fix for leading edge in time window probability vs straw number(Barrel) histograms
1294  initScaleVectors();
1295  vector<float> scalevector;
1296  vector<float> scalevector_Ar;
1297 
1298  for (int k = 0; k < s_Straw_max[0]; k++) {
1299  try {
1300  if (m_scale_hHitWMap_B.at(k) == 0.) {
1301  scalevector.push_back(0.);
1302  } else {
1303  scalevector.push_back(1. / (m_usedEvents * m_scale_hHitWMap_B.at(k)));
1304  }
1305 
1306  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
1307  scalevector_Ar.push_back(0.);
1308  } else {
1309  scalevector_Ar.push_back(1. / (m_usedEvents * m_scale_hHitWMap_B_Ar.at(k)));
1310  }
1311  } catch (out_of_range &e) {
1312  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
1313  }
1314  }
1315 
1316  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
1317 
1318  if (m_ArgonXenonSplitter) {
1319  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
1320  }
1321  } else if (ibe == 1) {
1322  float eventScale = 1. / (m_usedEvents * 32);
1323  scale_LWHist(m_hHitWMap_E[0], eventScale);
1324  scale_LWHist(m_hHitWMap_E[1], eventScale);
1325 
1326  if (m_ArgonXenonSplitter) {
1327  scale_LWHist(m_hHitWMap_E_Ar[0], eventScale);
1328  scale_LWHist(m_hHitWMap_E_Ar[1], eventScale);
1329  }
1330  }
1331  }
1332 
1333  for (int i = 0; i < 64; i++) {
1334  if (m_doTracksMon && m_doExpert) {
1335  divide_LWHist(m_hHitOnTrackVsAllS[ibe][i], m_hHitAonTMapS[ibe][i], m_hHitAMapS[ibe][i]);
1336  }
1337 
1338  if (m_doRDOsMon && m_doExpert && m_usedEvents > 0) {
1339  float scale = 1. / m_usedEvents;
1340  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
1341  scale_LWHist(m_hHitWMapS[ibe][i], scale);
1342  scale_LWHist(m_hHitAMapS[ibe][i], scale);
1343  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
1344  scale_LWHist(m_hHitHMapS[ibe][i], scale);
1345  }
1346 
1347  for (int j = 0; j < s_Straw_max[ibe]; j++) {
1348  if (m_doRDOsMon) {
1349  if (m_doExpert) {
1350  m_hStrawOcc[ibe][i]->Fill(m_hHitAMapS[ibe][i]->GetBinContent(j + 1));
1351  }
1352  }
1353 
1354  if (m_doTracksMon) {
1355  if (i == 0) {
1356  if (ibe == 0) {
1357  if (m_nStrawHits_B[j] > 0) {
1358  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) / ((Float_t)m_nStrawHits_B[j]));
1359  }
1360  } else if (ibe == 1) {
1361  if (m_nStrawHits_E[0][j] > 0) {
1362  m_hHitWonTMap_E[0]->SetBinContent(j + 1, (float)m_hHitWonTMap_E[0]->GetBinContent(j + 1) / (m_nStrawHits_E[0][j]));
1363  }
1364 
1365  if (m_nStrawHits_E[1][j] > 0) {
1366  m_hHitWonTMap_E[1]->SetBinContent(j + 1, (float)m_hHitWonTMap_E[1]->GetBinContent(j + 1) / (m_nStrawHits_E[1][j]));
1367  }
1368  }
1369  }
1370 
1371  if (m_doExpert) {
1372  float scale = m_hStrawsEff[ibe][i]->GetBinEntries(j + 1);
1373 
1374  if (scale > 0 && m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
1375  scale = 1. / scale;
1376  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1377  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1378  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1379  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1380  } else {
1381  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1382  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1383  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1384  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1385  }
1386  }
1387  }
1388  }
1389 
1390  if (m_doRDOsMon && m_doExpert) divide_LWHist(m_hHtoLMapS[ibe][i], m_hHitHMapS[ibe][i], m_hHitAMapS[ibe][i]);
1391 
1392  if (m_doTracksMon && m_doExpert) {
1393  divide_LWHist(m_hHtoLonTMapS[ibe][i], m_hHitHonTMapS[ibe][i], m_hHitAonTMapS[ibe][i]);
1394  divide_LWHist(m_hHtoLWonTMapS[ibe][i], m_hHitHWonTMapS[ibe][i], m_hHitAWonTMapS[ibe][i]);
1395  }
1396  }
1397  }
1398 
1399  if (m_doShift && endOfRunFlag()) {
1400  if (m_doTracksMon) {
1401  if (ibe == 0) {
1402  m_EventPhaseScale = m_hEvtPhase->GetEntries() * 3.125;
1403 
1404  if (m_EventPhaseScale > 0) {
1405  scale_LWHist(m_hEvtPhase, 1. / m_EventPhaseScale);
1406  }
1407 
1408  m_DriftTimeonTrkDistScale_B = m_hDriftTimeonTrkDist_B->GetEntries() * 3.125;
1409 
1410  if (m_DriftTimeonTrkDistScale_B > 0) {
1411  scale_LWHist(m_hDriftTimeonTrkDist_B, 1. / m_DriftTimeonTrkDistScale_B);
1412  }
1413 
1414  m_HLhitOnTrackScale_B = m_hHLhitOnTrack_B->GetEntries();
1415 
1416  if (m_HLhitOnTrackScale_B > 0) {
1417  scale_LWHist(m_hHLhitOnTrack_B, 1. / m_HLhitOnTrackScale_B);
1418  }
1419 
1420  m_HtoLRatioOnTrackScale_B = m_hHtoLRatioOnTrack_B->GetEntries() * 0.02;
1421 
1422  if (m_HtoLRatioOnTrackScale_B > 0) {
1423  scale_LWHist(m_hHtoLRatioOnTrack_B, 1. / m_HtoLRatioOnTrackScale_B);
1424  }
1425 
1426  m_NumSwLLWoTScale_B = m_hNumSwLLWoT_B->GetEntries();
1427 
1428  if (m_NumSwLLWoTScale_B > 0) {
1429  scale_LWHist(m_hNumSwLLWoT_B, 1. / m_NumSwLLWoTScale_B);
1430  }
1431 
1432  m_WireToTrkPositionScale_B = m_hWireToTrkPosition_B->GetEntries() * 0.1;
1433 
1434  if (m_WireToTrkPositionScale_B > 0) {
1435  scale_LWHist(m_hWireToTrkPosition_B, 1. / m_WireToTrkPositionScale_B);
1436  }
1437 
1438  m_TronTDistScale_B = m_hTronTDist_B->GetEntries() * 3.125;
1439 
1440  if (m_TronTDistScale_B > 0) {
1441  scale_LWHist(m_hTronTDist_B, 1. / m_TronTDistScale_B);
1442  }
1443 
1444  m_ResidualScale_B = m_hResidual_B->GetEntries() * 0.025;
1445 
1446  if (m_ResidualScale_B > 0) {
1447  scale_LWHist(m_hResidual_B, 1. / m_ResidualScale_B);
1448  }
1449 
1450  m_ResidualScale_B_20GeV = m_hResidual_B_20GeV->GetEntries() * 0.025;
1451 
1452  if (m_ResidualScale_B_20GeV > 0) {
1453  scale_LWHist(m_hResidual_B_20GeV, 1. / m_ResidualScale_B_20GeV);
1454  }
1455 
1456  m_TimeResidualScale_B = m_hTimeResidual_B->GetEntries() * 0.2;
1457 
1458  if (m_TimeResidualScale_B > 0) {
1459  scale_LWHist(m_hTimeResidual_B, 1. / m_TimeResidualScale_B);
1460  }
1461 
1462  if (m_ArgonXenonSplitter) {
1463  m_DriftTimeonTrkDistScale_B_Ar = m_hDriftTimeonTrkDist_B_Ar->GetEntries() * 3.125;
1464 
1465  if (m_DriftTimeonTrkDistScale_B_Ar > 0) {
1466  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, 1. / m_DriftTimeonTrkDistScale_B_Ar);
1467  }
1468 
1469  m_WireToTrkPositionScale_B_Ar = m_hWireToTrkPosition_B_Ar->GetEntries() * 0.1;
1470 
1471  if (m_WireToTrkPositionScale_B_Ar > 0) {
1472  scale_LWHist(m_hWireToTrkPosition_B_Ar, 1. / m_WireToTrkPositionScale_B_Ar);
1473  }
1474 
1475  m_HtoLRatioOnTrackScale_B_Ar = m_hHtoLRatioOnTrack_B_Ar->GetEntries() * 0.02;
1476 
1477  if (m_HtoLRatioOnTrackScale_B_Ar > 0) {
1478  scale_LWHist(m_hHtoLRatioOnTrack_B_Ar, 1. / m_HtoLRatioOnTrackScale_B_Ar);
1479  }
1480 
1481  m_TronTDistScale_B_Ar = m_hTronTDist_B_Ar->GetEntries() * 3.125;
1482 
1483  if (m_TronTDistScale_B_Ar > 0) {
1484  scale_LWHist(m_hTronTDist_B_Ar, 1. / m_TronTDistScale_B_Ar);
1485  }
1486 
1487  m_ResidualScale_B_Ar = m_hResidual_B_Ar->GetEntries() * 0.025;
1488 
1489  if (m_ResidualScale_B_Ar > 0) {
1490  scale_LWHist(m_hResidual_B_Ar, 1. / m_ResidualScale_B_Ar);
1491  }
1492 
1493  m_ResidualScale_B_Ar_20GeV = m_hResidual_B_Ar_20GeV->GetEntries() * 0.025;
1494 
1495  if (m_ResidualScale_B_Ar_20GeV > 0) {
1496  scale_LWHist(m_hResidual_B_Ar_20GeV, 1. / m_ResidualScale_B_Ar_20GeV);
1497  }
1498 
1499  m_TimeResidualScale_B_Ar = m_hTimeResidual_B_Ar->GetEntries() * 0.2;
1500 
1501  if (m_TimeResidualScale_B_Ar > 0) {
1502  scale_LWHist(m_hTimeResidual_B_Ar, 1. / m_TimeResidualScale_B_Ar);
1503  }
1504  }
1505 
1506  m_HtoLRatioOnTrackScale_B_Xe = m_hHtoLRatioOnTrack_B_Xe->GetEntries() * 0.02;
1507 
1508  if (m_HtoLRatioOnTrackScale_B_Xe > 0) {
1509  scale_LWHist(m_hHtoLRatioOnTrack_B_Xe, 1. / m_HtoLRatioOnTrackScale_B_Xe);
1510  }
1511  } else if (ibe == 1) {
1512  for (int iside = 0; iside < 2; iside++) {
1513  m_DriftTimeonTrkDistScale_E[iside] = m_hDriftTimeonTrkDist_E[iside]->GetEntries() * 3.125;
1514 
1515  if (m_DriftTimeonTrkDistScale_E[iside] > 0) {
1516  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], 1. / m_DriftTimeonTrkDistScale_E[iside]);
1517  }
1518 
1519  m_HLhitOnTrackScale_E[iside] = m_hHLhitOnTrack_E[iside]->GetEntries();
1520 
1521  if (m_HLhitOnTrackScale_E[iside] > 0) {
1522  scale_LWHist(m_hHLhitOnTrack_E[iside], 1. / m_HLhitOnTrackScale_E[iside]);
1523  }
1524 
1525  m_HtoLRatioOnTrackScale_E[iside] = m_hHtoLRatioOnTrack_E[iside]->GetEntries() * 0.02;
1526 
1527  if (m_HtoLRatioOnTrackScale_E[iside] > 0) {
1528  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], 1. / m_HtoLRatioOnTrackScale_E[iside]);
1529  }
1530 
1531  m_NumSwLLWoTScale_E[iside] = m_hNumSwLLWoT_E[iside]->GetEntries();
1532 
1533  if (m_NumSwLLWoTScale_E[iside] > 0) {
1534  scale_LWHist(m_hNumSwLLWoT_E[iside], 1. / m_NumSwLLWoTScale_E[iside]);
1535  }
1536 
1537  m_WireToTrkPositionScale_E[iside] = m_hWireToTrkPosition_E[iside]->GetEntries() * 0.1;
1538 
1539  if (m_WireToTrkPositionScale_E[iside] > 0) {
1540  scale_LWHist(m_hWireToTrkPosition_E[iside], 1. / m_WireToTrkPositionScale_E[iside]);
1541  }
1542 
1543  m_TronTDistScale_E[iside] = m_hTronTDist_E[iside]->GetEntries() * 3.125;
1544 
1545  if (m_TronTDistScale_E[iside] > 0) {
1546  scale_LWHist(m_hTronTDist_E[iside], 1. / m_TronTDistScale_E[iside]);
1547  }
1548 
1549  m_ResidualScale_E[iside] = m_hResidual_E[iside]->GetEntries() * 0.025;
1550 
1551  if (m_ResidualScale_E[iside] > 0) {
1552  scale_LWHist(m_hResidual_E[iside], 1. / m_ResidualScale_E[iside]);
1553  }
1554 
1555  m_ResidualScale_E_20GeV[iside] = m_hResidual_E_20GeV[iside]->GetEntries() * 0.025;
1556 
1557  if (m_ResidualScale_E_20GeV[iside] > 0) {
1558  scale_LWHist(m_hResidual_E_20GeV[iside], 1. / m_ResidualScale_E_20GeV[iside]);
1559  }
1560 
1561  m_TimeResidualScale_E[iside] = m_hTimeResidual_E[iside]->GetEntries() * 0.2;
1562 
1563  if (m_TimeResidualScale_E[iside] > 0) {
1564  scale_LWHist(m_hTimeResidual_E[iside], 1. / m_TimeResidualScale_E[iside]);
1565  }
1566 
1567  m_HtoLRatioOnTrackScale_E_Xe[iside] = m_hHtoLRatioOnTrack_E_Xe[iside]->GetEntries() * 0.02;
1568 
1569  if (m_HtoLRatioOnTrackScale_E_Xe[iside] > 0) {
1570  scale_LWHist(m_hHtoLRatioOnTrack_E_Xe[iside], 1. / m_HtoLRatioOnTrackScale_E_Xe[iside]);
1571  }
1572 
1573  if (m_ArgonXenonSplitter) {
1574  m_DriftTimeonTrkDistScale_E_Ar[iside] = m_hDriftTimeonTrkDist_E_Ar[iside]->GetEntries() * 3.125;
1575 
1576  if (m_DriftTimeonTrkDistScale_E_Ar[iside] > 0) {
1577  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], 1. / m_DriftTimeonTrkDistScale_E_Ar[iside]);
1578  }
1579 
1580  m_WireToTrkPositionScale_E_Ar[iside] = m_hWireToTrkPosition_E_Ar[iside]->GetEntries() * 0.1;
1581 
1582  if (m_WireToTrkPositionScale_E_Ar[iside] > 0) {
1583  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], 1. / m_WireToTrkPositionScale_E_Ar[iside]);
1584  }
1585 
1586  m_HtoLRatioOnTrackScale_E_Ar[iside] = m_hHtoLRatioOnTrack_E_Ar[iside]->GetEntries() * 0.02;
1587 
1588  if (m_HtoLRatioOnTrackScale_E_Ar[iside] > 0) {
1589  scale_LWHist(m_hHtoLRatioOnTrack_E_Ar[iside], 1. / m_HtoLRatioOnTrackScale_E_Ar[iside]);
1590  }
1591 
1592  m_TronTDistScale_E_Ar[iside] = m_hTronTDist_E_Ar[iside]->GetEntries() * 3.125;
1593 
1594  if (m_TronTDistScale_E_Ar[iside] > 0) {
1595  scale_LWHist(m_hTronTDist_E_Ar[iside], 1. / m_TronTDistScale_E_Ar[iside]);
1596  }
1597 
1598  m_ResidualScale_E_Ar[iside] = m_hResidual_E_Ar[iside]->GetEntries() * 0.025;
1599 
1600  if (m_ResidualScale_E_Ar[iside] > 0) {
1601  scale_LWHist(m_hResidual_E_Ar[iside], 1. / m_ResidualScale_E_Ar[iside]);
1602  }
1603 
1604  m_ResidualScale_E_Ar_20GeV[iside] = m_hResidual_E_Ar_20GeV[iside]->GetEntries() * 0.025;
1605 
1606  if (m_ResidualScale_E_Ar_20GeV[iside] > 0) {
1607  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], 1. / m_ResidualScale_E_Ar_20GeV[iside]);
1608  }
1609 
1610  m_TimeResidualScale_E_Ar[iside] = m_hTimeResidual_E_Ar[iside]->GetEntries() * 0.2;
1611 
1612  if (m_TimeResidualScale_E_Ar[iside] > 0) {
1613  scale_LWHist(m_hTimeResidual_E_Ar[iside], 1. / m_TimeResidualScale_E_Ar[iside]);
1614  }
1615  }
1616  }
1617  }
1618  }
1619  }
1620 
1621  if (m_doEfficiency && endOfRunFlag()) {
1622  for (int iside = 0; iside < 2; iside++) {
1623  for (int i = 0; i < 32; i++) {
1624  for (int ibin = 0; ibin <= s_Straw_max[ibe]; ibin++) {
1625  if (m_doExpert) {
1626  if (m_hefficiencyS[ibe][i + (32 * iside)]->GetBinEntries(ibin) > m_min_tracks_straw) {
1627  m_hefficiency[ibe][iside]->Fill(m_hefficiencyS[ibe][i + (32 * iside)]->GetBinContent(ibin));
1628  }
1629  }
1630  }
1631  }
1632 
1633  n_BorE[ibe][iside] = m_hefficiency[ibe][iside]->GetEntries();
1634  total_BorE[ibe][iside] = 0.0;
1635 
1636  for (unsigned int ibin = 0; ibin <= m_hefficiency[ibe][iside]->GetXaxis()->GetNbins(); ibin++) {
1637  total_BorE[ibe][iside] += m_hefficiency[ibe][iside]->GetBinContent(ibin);
1638  m_hefficiencyIntegral[ibe][iside]->SetBinContent(ibin, n_BorE[ibe][iside] != 0.0 ? total_BorE[ibe][iside] / n_BorE[ibe][iside] : 0);
1639  }
1640  }
1641  }
1642  }
1643  }
1644 
1645  if (endOfLumiBlockFlag() || endOfRunFlag()) {
1646  if (m_doShift) {
1647  Int_t lumiblock1440 = m_lastTRTLumiBlock % 1440;
1648  float lumiBlockScale = (m_evtLumiBlock > 0) ? (1. / m_evtLumiBlock) : 0;
1649  const float barrelConst = 1. / 105088;
1650  const float endcapConst = 1. / 122880;
1651 
1652  if (m_doTracksMon && m_evtLumiBlock > 0) {
1653  m_hNHitsperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nHitsperLB_B * lumiBlockScale * barrelConst);
1654  m_hNTrksperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nTrksperLB_B * lumiBlockScale);
1655  m_hNHLHitsperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nHLHitsperLB_B * lumiBlockScale * barrelConst);
1656 
1657  for (int iside = 0; iside < 2; iside++) {
1658  m_hNHitsperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nHitsperLB_E[iside] * lumiBlockScale * endcapConst);
1659  m_hNTrksperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nTrksperLB_E[iside] * lumiBlockScale);
1660  m_hNHLHitsperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nHLHitsperLB_E[iside] * lumiBlockScale * endcapConst);
1661  }
1662 
1663  m_nTrksperLB_B = 0;
1664  m_nHitsperLB_B = 0;
1665  m_nHLHitsperLB_B = 0;
1666 
1667  for (int iside = 0; iside < 2; iside++) {
1668  m_nTrksperLB_E[iside] = 0;
1669  m_nHitsperLB_E[iside] = 0;
1670  m_nHLHitsperLB_E[iside] = 0;
1671  }
1672 
1673  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1674  for (int ibe = 0; ibe < 2; ibe++) {
1675  for (int i = 0; i < s_iStack_max[ibe]; i++) {
1676  if (ibe == 0) {
1677  if (m_evtLumiBlock > 0) {
1678  float occ = (m_LLOcc[ibe][i] * lumiBlockScale) / nfill[ibe];
1679  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1680  occ = (m_LLOcc[ibe][i + 32] * lumiBlockScale) / nfill[ibe];
1681  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1682  }
1683 
1684  m_LLOcc[ibe][i] = 0;
1685  m_LLOcc[ibe][i + 32] = 0;
1686 
1687  if (m_nTrack_B[i]) {
1688  float ratio = m_HTfraconTrack_B[i] / m_nTrack_B[i];
1689  m_hHightoLowRatioOnTrack_Scatter[ibe]->Fill(lumiblock1440, ratio);
1690  m_hHitsOnTrack_Scatter[ibe]->Fill(lumiblock1440, m_LonTrack_B[i] / m_nTrack_B[i]);
1691  }
1692 
1693  m_LonTrack_B[i] = 0;
1694  m_HTfraconTrack_B[i] = 0;
1695  m_nTrack_B[i] = 0;
1696  } else if (ibe == 1) {
1697  if (m_evtLumiBlock > 0) {
1698  float occ = (m_LLOcc[ibe][i] * lumiBlockScale) / nfill[ibe];
1699  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1700  }
1701 
1702  m_LLOcc[ibe][i] = 0;
1703 
1704  if (m_nTrack_E[i]) {
1705  float ratio = m_HTfraconTrack_E[i] / m_nTrack_E[i];
1706  m_hHightoLowRatioOnTrack_Scatter[ibe]->Fill(lumiblock1440, ratio);
1707  m_hHitsOnTrack_Scatter[ibe]->Fill(lumiblock1440, m_LonTrack_E[i] / m_nTrack_E[i]);
1708  }
1709 
1710  m_LonTrack_E[i] = 0;
1711  m_HTfraconTrack_E[i] = 0;
1712  m_nTrack_E[i] = 0;
1713  }
1714  }
1715  }
1716  }
1717  }
1718 
1719  //Resetting Occupuncy histograms for online environment
1720  if (m_doShift && m_environment == AthenaMonManager::online &&
1721  (m_lastTRTLumiBlock % m_lumiBlocksToResetOcc) == 0) {
1722  for (int ibe = 0; ibe < 2; ibe++) {
1723  for (int iside = 0; iside < 2; iside++) {
1724  m_hAvgHLOcc_side[ibe][iside]->Reset();
1725  m_hAvgLLOcc_side[ibe][iside]->Reset();
1726  m_hAvgHLOccMod_side[ibe][iside]->Reset();
1727  m_hAvgLLOccMod_side[ibe][iside]->Reset();
1728  }
1729  }
1730  }
1731 
1732  ATH_MSG_DEBUG("end of event and lumi block");
1733  //number of events in lumiblock counter setted to zero since it is end of the run or the lumiblock
1734  m_evtLumiBlock = 0;
1735  }
1736 
1737  if (endOfRunFlag()) {
1738  ATH_MSG_DEBUG("end of run");
1739  }
1740 
1741  return StatusCode::SUCCESS;
1742 }

◆ radToDegrees()

float TRT_Monitoring_Tool::radToDegrees ( float  radValue)
staticprivate

Definition at line 4295 of file TRT_Monitoring_Tool.cxx.

4295  {
4296 //----------------------------------------------------------------------------------//
4297  float degreeValue = radValue / M_PI * 180;
4298 
4299  if (degreeValue < 0) degreeValue += 360;
4300 
4301  return degreeValue;
4302 }

◆ regEfficiency()

StatusCode ManagedMonitorToolBase::regEfficiency ( TEfficiency *  e,
const MonGroup &  group 
)
virtualinherited

Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.

Definition at line 1648 of file ManagedMonitorToolBase.cxx.

1648  {
1649  if (!e)
1650  return StatusCode::FAILURE;
1651 
1652  TGraph* g = reinterpret_cast<TGraph*>(e);
1653  std::string name = e->GetName();
1654 
1655  // MANAGED
1656  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1657  // warn about not using merge algorithms
1658  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1659  ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1660  }
1661  // add the efficiency to rebooking vector
1662  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1663  m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1664  } else {
1665  ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1666  return StatusCode::FAILURE;
1667  }
1668 
1669  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1670  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1671  registerMetadata(streamName, name, group).ignore();
1672  return m_THistSvc->regGraph( streamName, g );
1673  } else {
1674  // UNMANAGED
1675  if( m_manager != 0 ) {
1676  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1677  m_manager->writeAndDelete( genericName );
1678  m_manager->passOwnership( e, genericName );
1679  }
1680 
1681  std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1682  StatusCode smd = registerMetadata(streamName, name, group);
1683  if (smd != StatusCode::SUCCESS)
1684  return StatusCode::FAILURE;
1685 
1686  return m_THistSvc->regGraph( streamName, g );
1687  }
1688 }

◆ regGraph() [1/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph *  g,
const MonGroup &  group 
)
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1702 of file ManagedMonitorToolBase.cxx.

1704 {
1705  if (!g)
1706  return StatusCode::FAILURE;
1707 
1708  // This part of the code deals with MANAGED type
1709  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1710  // Create an unmanaged group based on the original MonGroup instance passed
1711  // This is needed because managed graph is presented as a number of unmanaged
1712  // graphs (one per each interval)
1713  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1714 
1715  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1716  m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1717  } else {
1718  ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1719  return StatusCode::FAILURE;
1720  }
1721 
1722  std::string name = g->GetName();
1723  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1724  registerMetadata(streamName, name, group).ignore();
1725  return m_THistSvc->regGraph( streamName, g );
1726  //return m_THistSvc->regGraph( streamName );
1727  }
1728 
1729  // This part of the code deals with UNMANAGED type
1730  std::string gName = g->GetName();
1731 
1732  if( m_manager != 0 ) {
1733  std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1734  m_manager->writeAndDelete( genericName );
1735  m_manager->passOwnership( g, genericName );
1736  }
1737 
1738  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1739 
1740  StatusCode smd = registerMetadata(streamName, gName, group);
1741  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1742 
1743  return m_THistSvc->regGraph( streamName, g );
1744 }

◆ regGraph() [2/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph *  g,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1692 of file ManagedMonitorToolBase.cxx.

1695 {
1696  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1697  return regGraph( g, group );
1698 }

◆ regHist() [1/4]

StatusCode ManagedMonitorToolBase::regHist ( LWHist *  h,
const MonGroup &  group 
)
virtualinherited

Definition at line 1522 of file ManagedMonitorToolBase.cxx.

1523 {
1524  // You may want to setROOTBackend to true in online environment
1525  //LWHistControls::setROOTBackend(true);
1526 
1527  if (!h)
1528  return StatusCode::FAILURE;
1529 
1530  if (!m_bookHistogramsInitial) {
1531  ATH_MSG_DEBUG("Yura: very first time");
1532  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1533 
1534  ATH_MSG_DEBUG("Yura: we have managed histograms");
1535  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1536  ATH_MSG_DEBUG(" Yura: adding histogram" << h->GetName());
1537  m_templateLWHistograms[group.interval()].push_back( MgmtParams<LWHist>(h, group) );
1538  } else {
1539  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1540  return StatusCode::FAILURE;
1541  }
1542  //return StatusCode::SUCCESS;
1543  }
1544  }
1545 
1546  //FIXME: Code copied more or less verbatim from above. Collect most code (espc. for streamname) in common helpers!!
1547  std::string hName = h->GetName();
1548 
1549  if( m_manager )
1550  {
1551  std::string genericName = NoOutputStream().getStreamName(this, group, hName );
1552  LWHistAthMonWrapper::setKey(h,genericName);
1553  LWHist* prevLWHist = m_manager->ownedLWHistOfKey(genericName);
1554  if (prevLWHist)
1555  {
1556  std::set<LWHist*>::iterator it = m_lwhists.find(prevLWHist);
1557  if (it!=m_lwhists.end())
1558  {
1559  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560  m_manager->writeAndResetLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1561  } else {
1562  m_manager->writeAndDeleteLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1563  }
1564  m_lwhists.erase(it);
1565  }
1566  }
1567  m_manager->passOwnership( h, genericName );
1568  }
1569  m_lwhists.insert(h);
1570 
1571  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1572  LWHistAthMonWrapper::setStreamName(h,streamName);
1573  registerMetadata(streamName, hName, group).ignore();
1574 
1575  //Delay registration with THistSvc (unless root backend):
1576  //m_lwhistMap.insert(std::pair<LWHist*,std::string>(h,streamName));
1577  if (h->usingROOTBackend())
1578  {
1579  h->setOwnsROOTHisto(false);//Since might end up with thist svc
1580  return m_THistSvc->regHist( streamName, h->getROOTHistBase() );
1581  }
1582 
1583  return StatusCode::SUCCESS;
1584 
1585 }

◆ regHist() [2/4]

StatusCode ManagedMonitorToolBase::regHist ( LWHist *  h,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Support for lightweight histograms:

Definition at line 1515 of file ManagedMonitorToolBase.cxx.

1517 {
1518  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1519  return regHist( h, group );
1520 }

◆ regHist() [3/4]

StatusCode ManagedMonitorToolBase::regHist ( TH1 *  h,
const MonGroup &  group 
)
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

A histogram is passed via reference to a pointer.

Definition at line 1462 of file ManagedMonitorToolBase.cxx.

1464 {
1465 // ManagedMonitorToolBase_addHistStatistics(this,h);
1466 
1467  if (!h)
1468  return StatusCode::FAILURE;
1469 
1470  // This part of the code deals with MANAGED type
1471  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1472  /*
1473  Create an unmanaged group based on the original MonGroup instance passed
1474  It is needed because managed histogram is presented as a number of unmanaged
1475  histograms (one per each interval)
1476  Update (PUEO) - I don't think it actually matters, and need to keep
1477  track of "proper" attribute for X_VS_LB
1478  */
1479 
1480  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1481  ATH_MSG_WARNING("HEY! You're attempting to register " << h->GetName() << " as a per-LB histogram, but you're not setting the merge algorithm! This is a SUPER-BAD idea! Use \"merge\", at least.");
1482  }
1483 
1484  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1485  m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1486  } else {
1487  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1488  return StatusCode::FAILURE;
1489  }
1490 
1491  std::string hName = h->GetName();
1492  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1493  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1494  registerMetadata(streamName, hName, group).ignore();
1495  return m_THistSvc->regHist( streamName, h );
1496  }
1497 
1498  // This part of the code deals with UNMANAGED type
1499  std::string hName = h->GetName();
1500 
1501  if( m_manager != 0 ) {
1502  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1503  m_manager->writeAndDelete( genericName );
1504  m_manager->passOwnership( h, genericName );
1505  }
1506 
1507  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1508 
1509  StatusCode smd = registerMetadata(streamName, hName, group);
1510  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1511 
1512  return m_THistSvc->regHist( streamName, h );
1513 }

◆ regHist() [4/4]

StatusCode ManagedMonitorToolBase::regHist ( TH1 *  h,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Definition at line 1453 of file ManagedMonitorToolBase.cxx.

1456 {
1457  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1458  return regHist( h, group );
1459 }

◆ registerMetadata()

StatusCode ManagedMonitorToolBase::registerMetadata ( const std::string &  streamName,
const std::string &  hName,
const MonGroup &  group 
)
protectedinherited

Definition at line 1005 of file ManagedMonitorToolBase.cxx.

1007  {
1008  if( m_environment != AthenaMonManager::online ) {
1009  TTree* metadata(0);
1010  std::string mdStreamName( streamName );
1011  size_t found=mdStreamName.rfind('/');
1012 
1013  if ( found != std::string::npos )
1014  mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
1015 
1016  MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
1017  if( i == m_metadataMap.end() ) {
1018  metadata = new TTree( "metadata", "Monitoring Metadata" );
1019  if (! metadata) return StatusCode::FAILURE;
1020  StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
1021  if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
1022  MDMap_t::value_type valToInsert( mdStreamName, new OutputMetadata(metadata) );
1023  i = m_metadataMap.insert( valToInsert ).first;
1024  }
1025 
1026  i->second->fill( hName, group.interval(), group.chain(), group.merge() );
1027  }
1028  return StatusCode::SUCCESS;
1029 }

◆ regManagedEfficiencies()

StatusCode ManagedMonitorToolBase::regManagedEfficiencies ( std::vector< MgmtParams< TEfficiency > > &  templateEfficiencies)
protectedinherited

Definition at line 1200 of file ManagedMonitorToolBase.cxx.

1200  {
1201  bool allIsOk = true;
1202  for( auto& it : templateEfficiencies ) {
1203  // get components of MgmtParams and copy efficiency
1204  MonGroup group = it.m_group;
1205  TEfficiency* theEfficiency = it.m_templateHist;
1206  TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1207  int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1208  int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1209  int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1210  e->SetBins(nbins,xlow,xhigh); // reset histogram
1211  std::string name = e->GetName();
1212 
1213  // make TGraph casts of TEfficiencies
1214  TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1215  TGraph* g = reinterpret_cast<TGraph*>(e);
1216 
1217  // Get the streamName for the previous interval
1218  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1219 
1220  // RE-REGISTER
1221  // 1) De-register the original graph with the THistSvc
1222  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1223  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1224  // 2) Fix THistSvc->deReg for TGraphs
1225  bool doneCleaning = false;
1226  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1227  TSeqCollection *filelist=gROOT->GetListOfFiles();
1228  for (int i=0; i<filelist->GetEntries(); i++) {
1229  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1230  TFile* file = static_cast<TFile*>(filelist->At(i));
1231  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1232  if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1233  }
1234  // 3) Check if TGraph fix has been applied successfully
1235  if (!doneCleaning) {
1236  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1237  allIsOk = false;
1238  }
1239  // 4) Register cloned histogram under previous interval streamName
1240  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1241  if (sc3 == StatusCode::FAILURE)
1242  allIsOk = false;
1243 
1244  // get streamname for interval
1245  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1246  // store metadata
1247  StatusCode smd = registerMetadata(streamName, name, group);
1248  if (smd != StatusCode::SUCCESS) allIsOk = false;
1249  // Re-register the original graph
1250  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1251  if (sc4 == StatusCode::FAILURE) allIsOk = false;
1252  }
1253 
1254  if (!allIsOk) return StatusCode::FAILURE;
1255  return StatusCode::SUCCESS;
1256 }

◆ regManagedGraphs()

StatusCode ManagedMonitorToolBase::regManagedGraphs ( std::vector< MgmtParams< TGraph > > &  templateGraphs)
protectedinherited

Definition at line 1129 of file ManagedMonitorToolBase.cxx.

1131 {
1132  // See the description for the regManagedHistograms method
1133  bool allIsOk = true;
1134 
1135  for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
1136  MonGroup group = (*it).m_group;
1137 
1138  // Get a handle to the graph
1139  TGraph* theGraph = (*it).m_templateHist;
1140 
1141  // Clone the graph
1142  TGraph* g = static_cast<TGraph*>(theGraph->Clone());
1143  theGraph->Set(0); // equivalent to Reset() for TH1
1144 
1145  // Get name
1146  std::string gName = g->GetName();
1147 
1148  // Get the streamName for the previous interval
1149  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
1150 
1151  // De-register the original graph with the THistSvc
1152  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1153  if (sc1 == StatusCode::FAILURE)
1154  allIsOk = false;
1155 
1156  // *** begin ***
1157  // Fix THistSvc->deReg for TGraphs
1158  bool doneCleaning = false;
1159  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
1160  TSeqCollection *filelist=gROOT->GetListOfFiles();
1161  for (int i=0; i<filelist->GetEntries(); i++) {
1162  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1163  TFile* file = static_cast<TFile*>(filelist->At(i));
1164  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1165  if (sc2 == StatusCode::SUCCESS)
1166  doneCleaning = true;
1167  }
1168 
1169  // Check if TGraph fix has been applied successfully
1170  if (!doneCleaning) {
1171  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1172  allIsOk = false;
1173  }
1174  // *** end ***
1175 
1176  // Register clonned histogram under previous interval streamName
1177  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1178  if (sc3 == StatusCode::FAILURE)
1179  allIsOk = false;
1180 
1181  // Get streamName for the current interval
1182  streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1183  // Register metadata information with the current interval streamname
1184  StatusCode smd = registerMetadata(streamName, gName, group);
1185  if (smd != StatusCode::SUCCESS)
1186  allIsOk = false;
1187 
1188  // Re-register the original graph with the current interval streamName
1189  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1190  if (sc4 == StatusCode::FAILURE)
1191  allIsOk = false;
1192 
1193  }
1194 
1195  if (!allIsOk) return StatusCode::FAILURE;
1196 
1197  return StatusCode::SUCCESS;
1198 }

◆ regManagedHistograms()

StatusCode ManagedMonitorToolBase::regManagedHistograms ( std::vector< MgmtParams< TH1 > > &  templateHistograms)
protectedinherited

Definition at line 1032 of file ManagedMonitorToolBase.cxx.

1034 {
1035  // The method registers histograms with the THistSvc and saves them to file.
1036 
1037  // The funky business with registering and deregistering the histogram is needed
1038  // to get the correct directory when saving histograms. THistSvc deals with ROOT
1039  // to set up proper TDirectory, so we rely on it.
1040  // E.g.
1041  // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
1042  // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
1043  // at the end of execution
1044  // use passownership of the histogram and save it to file
1045  // m_manager->passOwnership( h, genericName );
1046  // m_manager->writeAndDelete( genericName );
1047  bool allIsOk = true;
1048 
1049  for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
1050  MonGroup& group = (*it).m_group;
1051 
1052  // Get a handle to the histogram
1053  TH1* theHist = (*it).m_templateHist;
1054 
1055  // Clone the histogram
1056  TH1* h = static_cast<TH1*>(theHist->Clone());
1057  theHist->Reset();
1058 
1059  // Get name
1060  std::string hName = h->GetName();
1061 
1062  // Get the streamName for the previous interval
1063  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
1064 
1065  // Register the histogram with the THistSvc
1066  StatusCode sc1 = m_THistSvc->deReg( theHist );
1067  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1068 
1069  // Register clonned histogram under previous interval streamName
1070  StatusCode sc2 = m_THistSvc->regHist( streamName, h );
1071  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1072 
1073  if( m_manager != 0 ) {
1074  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1075  m_manager->passOwnership( h, genericName );
1076  m_manager->writeAndDelete( genericName );
1077  }
1078 
1079  // Get streamName for the current interval
1080  streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1081  // Register metadata information with the current interval streamname
1082  StatusCode smd = registerMetadata(streamName, hName, group);
1083  if (smd != StatusCode::SUCCESS) allIsOk = false;
1084 
1085  // Re-register the original histogram with the current interval streamName
1086  StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
1087  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1088 
1089  }
1090 
1091  if (!allIsOk) return StatusCode::FAILURE;
1092 
1093  return StatusCode::SUCCESS;
1094 }

◆ regManagedLWHistograms()

StatusCode ManagedMonitorToolBase::regManagedLWHistograms ( std::vector< MgmtParams< LWHist > > &  templateLWHistograms)
protectedinherited

Definition at line 1314 of file ManagedMonitorToolBase.cxx.

1316 {
1317  StatusCode sc1;
1318 
1319  for( std::vector< MgmtParams<LWHist> >::iterator it = templateLWHistograms.begin(); it != templateLWHistograms.end(); ++it ) {
1320  // Get histogram group
1321  MonGroup group = (*it).m_group;
1322 
1323  // Get handle to the histogram
1324  LWHist* h = (*it).m_templateHist;
1325 
1326  sc1 = regHist(h, group);
1327  }
1328 
1329  return sc1;
1330 }

◆ regManagedTrees()

StatusCode ManagedMonitorToolBase::regManagedTrees ( std::vector< MgmtParams< TTree > > &  templateTrees)
protectedinherited

Definition at line 1260 of file ManagedMonitorToolBase.cxx.

1262 {
1263  // See the description for the regManagedHistograms method
1264  bool allIsOk = true;
1265 
1266  for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1267  MonGroup group = (*it).m_group;
1268 
1269  // Get a handle to the original tree
1270  TTree* theTree = (*it).m_templateHist;
1271 
1272  // Clone the tree
1273  TTree* t = static_cast<TTree*>(theTree->Clone());
1274  theTree->Reset();
1275 
1276  // Dumping the tree
1277  std::string name = t->GetName();
1278 
1279  // Get the streamName for the previous interval
1280  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1281 
1282  // De-register original tree with the THistSvc
1283  StatusCode sc1 = m_THistSvc->deReg( theTree );
1284  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1285 
1286  // Register clonned tree under previous interval streamName
1287  StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1288  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1289 
1290  if( m_manager != 0 ) {
1291  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1292  m_manager->passOwnership( t, genericName );
1293  m_manager->writeAndDelete( genericName );
1294  }
1295 
1296  // Get streamName for the current interval
1297  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1298  // Register metadata information with the current interval streamname
1299  StatusCode smd = registerMetadata(streamName, name, group);
1300  if (smd != StatusCode::SUCCESS) allIsOk = false;
1301 
1302  // Re-register the original graph with the current interval streamName
1303  StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1304  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1305 
1306  }
1307 
1308  if (!allIsOk) return StatusCode::FAILURE;
1309 
1310  return StatusCode::SUCCESS;
1311 }

◆ regTree() [1/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree *  t,
const MonGroup &  group 
)
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1758 of file ManagedMonitorToolBase.cxx.

1760 {
1761 
1762  // This part of the code deals with MANAGED type
1763  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1764  // Create an unmanaged group based on the original MonGroup instance passed
1765  // This is needed because managed tree is presented as a number of unmanaged
1766  // trees (one per each interval)
1767  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1768 
1769  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1770  m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1771  } else {
1772  ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1773  return StatusCode::FAILURE;
1774  }
1775 
1776  std::string name = t->GetName();
1777  std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1778  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1779  registerMetadata(streamName, name, group).ignore();
1780  return m_THistSvc->regTree( streamName, t );
1781  }
1782 
1783 
1784  // This part of the code deals with UNMANAGED type
1785  std::string tName = t->GetName();
1786 
1787  if( m_manager != 0 ) {
1788  std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1789  m_manager->writeAndDelete( genericName );
1790  m_manager->passOwnership( t, genericName );
1791  }
1792 
1793  std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1794 
1795  StatusCode smd = registerMetadata(streamName, tName, group);
1796  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1797 
1798  return m_THistSvc->regTree( streamName, t );
1799 }

◆ regTree() [2/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree *  t,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1748 of file ManagedMonitorToolBase.cxx.

1751 {
1752  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1753  return regTree( t, group );
1754 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1893 of file ManagedMonitorToolBase.cxx.

1895 {
1896  return StatusCode::SUCCESS;
1897 }

◆ scale_LWHist()

void TRT_Monitoring_Tool::scale_LWHist ( LWHist1D *  hist,
float  scale 
)
staticprivate

Definition at line 4344 of file TRT_Monitoring_Tool.cxx.

4344  {
4345 //----------------------------------------------------------------------------------//
4346  if (!hist) return;
4347 
4348  const unsigned int entries = hist->GetEntries();
4349  unsigned int index;
4350  double content, error;
4351  hist->resetActiveBinLoop();
4352 
4353  while (hist->getNextActiveBin(index, content, error)) {
4354  hist->SetBinContentAndError(index, scale * content, scale * error);
4355  }
4356 
4357  hist->SetEntries(entries);
4358 }

◆ scale_LWHistWithScaleVector()

void TRT_Monitoring_Tool::scale_LWHistWithScaleVector ( LWHist1D *  hist,
const std::vector< float > &  scale 
)
private

Definition at line 4363 of file TRT_Monitoring_Tool.cxx.

4363  {
4364 //----------------------------------------------------------------------------------//
4365  if (!hist) return;
4366 
4367  if (hist->GetNbinsX() != scale.size()) return; // Could add an error message here
4368 
4369  const unsigned int entries = hist->GetEntries();
4370  unsigned int index;
4371  double content, error;
4372  hist->resetActiveBinLoop();
4373 
4374  while (hist->getNextActiveBin(index, content, error)) {
4375  // histogram bins run from 1 to n while array runs from 0 ro n-1
4376  try {
4377  hist->SetBinContentAndError(index, scale.at(index - 1) * content, scale.at(index - 1) * error);
4378  } catch (out_of_range &e) {
4379  ATH_MSG_ERROR("Index " << index << " out of range in scale_LWHistWithScaleVector");
4380  }
4381  }
4382 
4383  hist->SetEntries(entries);
4384 }

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager *  manager)
virtualinherited

Takes a pointer to a managing object to get information from it when needed.

Definition at line 1435 of file ManagedMonitorToolBase.cxx.

1437 {
1438  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1439  m_manager = manager;
1440  if( m_manager != 0 ) {
1441  ATH_MSG_DEBUG( " --> Setting manager");
1442  m_managerNameProp = m_manager->name();
1443  m_fileKey = m_manager->fileKey();
1444  m_dataType = m_manager->dataType();
1445  m_environment = m_manager->environment();
1446  delete m_streamNameFcn;
1447  m_streamNameFcn = getNewStreamNameFcn();
1448  }
1449  ATH_MSG_DEBUG( " --> Exiting successfully");
1450 }

◆ setupOutputStreams()

StatusCode ManagedMonitorToolBase::setupOutputStreams ( std::vector< std::string >  Mapping = std::vector<std::string>())
virtualinherited

This implementation does nothing—streams in this class should be managed by the AthenaMonManager.

Consider using MonitorToolBase for user-managed streams.

Implements IMonitorToolBase.

Definition at line 1882 of file ManagedMonitorToolBase.cxx.

1884 {
1885  // All instances should write to the stream(s) defined by the
1886  // AthenaMonManager.
1887 
1888  return StatusCode::SUCCESS;
1889 }

◆ Straw_Gastype()

GasType TRT_Monitoring_Tool::Straw_Gastype ( int  stat)
inlineprivate

Definition at line 633 of file TRT_Monitoring_Tool.h.

633  {
634  // getStatusHT returns enum {Undefined, Dead, Good, Xenon, Argon, Krypton}.
635  // Our representation of 'GasType' is 0:Xenon, 1:Argon, 2:Krypton
636  GasType Gas = Xe; // Xenon is default
637  if (m_ArgonXenonSplitter) {
638  // int stat=m_sumSvc->getStatusHT(TRT_Identifier);
639  if ( stat==2 || stat==3 ) { Gas = Xe; } // Xe
640  else if ( stat==1 || stat==4 ) { Gas = Ar; } // Ar
641  else if ( stat==5 ) { Gas = Kr; } // Kr
642  else if ( stat==6 ) { Gas = Xe; } // emulate Ar (so treat as Xe here)
643  else if ( stat==7 ) { Gas = Xe; } // emulate Kr (so treat as Xe here)
644  else { ATH_MSG_FATAL ("getStatusHT = " << stat << ", must be 'Good(2)||Xenon(3)' or 'Dead(1)||Argon(4)' or 'Krypton(5)!' or 6 or 7 for emulated types!");
645  throw std::exception();
646  }
647  }
648  return Gas;
649  }

◆ strawLayerNumber()

int TRT_Monitoring_Tool::strawLayerNumber ( int  strawLayerNumber,
int  LayerNumber 
)
staticprivate

Definition at line 4258 of file TRT_Monitoring_Tool.cxx.

4258  {
4259 //----------------------------------------------------------------------------------//
4260  switch (LayerNumber) {
4261  case 0:
4262  return strawLayerNumber;
4263 
4264  case 1:
4265  return strawLayerNumber + 19;
4266 
4267  case 2:
4268  return strawLayerNumber + 43;
4269 
4270  default:
4271  return strawLayerNumber;
4272  }
4273 }

◆ strawLayerNumber_reverse()

int TRT_Monitoring_Tool::strawLayerNumber_reverse ( int  strawLayerNumInp,
int *  strawLayerNumber,
int *  LayerNumber 
)
staticprivate

Definition at line 4276 of file TRT_Monitoring_Tool.cxx.

4276  {
4277 //----------------------------------------------------------------------------------//
4278  //Danger? There are no checks on input
4279  //use with care
4280  if (strawLayerNumInp < 19) {
4281  *strawLayerNumber = strawLayerNumInp;
4282  *LayerNumber = 0;
4283  } else if (strawLayerNumInp < 43) {
4284  *strawLayerNumber = strawLayerNumInp - 19;
4285  *LayerNumber = 1;
4286  } else {
4287  *strawLayerNumber = strawLayerNumInp - 43;
4288  *LayerNumber = 2;
4289  }
4290 
4291  return 0;
4292 }

◆ strawNumber()

int TRT_Monitoring_Tool::strawNumber ( int  strawNumber,
int  strawlayerNumber,
int  LayerNumber 
)
private

Definition at line 4093 of file TRT_Monitoring_Tool.cxx.

4093  {
4094 //----------------------------------------------------------------------------------//
4095  int addToStrawNumber = 0;
4096  int addToStrawNumberNext = 0;
4097  int i = 0;
4098  const int numberOfStraws[75] = {
4099  0,
4100  15,
4101  16, 16, 16, 16,
4102  17, 17, 17, 17, 17,
4103  18, 18, 18, 18, 18,
4104  19, 19, 19,
4105  18,
4106  19,
4107  20, 20, 20, 20, 20,
4108  21, 21, 21, 21, 21,
4109  22, 22, 22, 22, 22,
4110  23, 23, 23, 23, 23,
4111  24, 24,
4112  23, 23,
4113  24, 24, 24, 24,
4114  25, 25, 25, 25, 25,
4115  26, 26, 26, 26, 26,
4116  27, 27, 27, 27, 27,
4117  28, 28, 28, 28, 28,
4118  29, 29, 29, 29,
4119  28,
4120  0
4121  };
4122 
4123  do {
4124  i++;
4125  addToStrawNumber += numberOfStraws[i - 1];
4126  addToStrawNumberNext = addToStrawNumber + numberOfStraws[i];
4127  } while (strawLayerNumber(strawlayerNumber, LayerNumber) != i - 1);
4128 
4129  strawNumber = addToStrawNumberNext - strawNumber - 1;
4130 
4131  if (strawNumber < 0 || strawNumber > s_Straw_max[0] - 1) {
4132  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
4133  strawNumber = 0;
4134  }
4135 
4136  return strawNumber;
4137 }

◆ strawNumber_reverse()

int TRT_Monitoring_Tool::strawNumber_reverse ( int  inp_strawnumber,
int *  strawNumber,
int *  strawlayerNumber,
int *  LayerNumber 
)
staticprivate

Definition at line 4140 of file TRT_Monitoring_Tool.cxx.

4140  {
4141 //----------------------------------------------------------------------------------//
4142  const int numberOfStraws[75] = {
4143  0,
4144  15,
4145  16, 16, 16, 16,
4146  17, 17, 17, 17, 17,
4147  18, 18, 18, 18, 18,
4148  19, 19, 19,
4149  18,
4150  19,
4151  20, 20, 20, 20, 20,
4152  21, 21, 21, 21, 21,
4153  22, 22, 22, 22, 22,
4154  23, 23, 23, 23, 23,
4155  24, 24,
4156  23, 23,
4157  24, 24, 24, 24,
4158  25, 25, 25, 25, 25,
4159  26, 26, 26, 26, 26,
4160  27, 27, 27, 27, 27,
4161  28, 28, 28, 28, 28,
4162  29, 29, 29, 29,
4163  28,
4164  0
4165  };
4166  //ToDo check inp_strawnumber
4167  int i = 1;
4168 
4169  for (i = 1; inp_strawnumber >= 0; i++) {
4170  inp_strawnumber -= numberOfStraws[i];
4171  }
4172 
4173  i -= 2;
4174  strawLayerNumber_reverse(i, strawlayerNumber, LayerNumber);
4175  *strawNumber = -inp_strawnumber - 1;
4176  return 0;
4177 }

◆ strawNumberEndCap()

int TRT_Monitoring_Tool::strawNumberEndCap ( int  strawNumber,
int  strawLayerNumber,
int  LayerNumber,
int  phi_stack,
int  side 
)
private

Definition at line 4180 of file TRT_Monitoring_Tool.cxx.

4180  {
4181 //----------------------------------------------------------------------------------//
4182  // Before perfoming map, corrections need to be perfomed.
4183  // apply special rotations for endcap mappings
4184  // for eca, rotate triplets by 180 for stacks 9-16, and 25-32.
4185  static const int TripletOrientation[2][32] = {
4186  {
4187  1, 1, 1, 1, 1, 1, 1, 1,
4188  0, 0, 0, 0, 0, 0, 0, 0,
4189  1, 1, 1, 1, 1, 1, 1, 1,
4190  0, 0, 0, 0, 0, 0, 0, 0
4191  },
4192  {
4193  1, 1, 1, 1, 1, 1, 1, 1,
4194  0, 0, 0, 0, 0, 0, 0, 0,
4195  1, 1, 1, 1, 1, 1, 1, 1,
4196  0, 0, 0, 0, 0, 0, 0, 0
4197  }
4198  };
4199  int phi1 = -1;
4200 
4201  if (side == 2) phi1 = phi_stack, side = 1;
4202  else if (side == -2) phi1 = 31 - phi_stack, side = 0;
4203 
4204  if (phi1 > -1) {
4205  if (TripletOrientation[side][phi1]) {
4206  //Change straw number from 0-23 in straw layer to 0-192
4207  if (strawLayerNumber < 8)strawNumber = strawNumber + 24 * strawLayerNumber;
4208 
4209  if (strawLayerNumber > 7)strawNumber = strawNumber + 24 * (strawLayerNumber - 8);
4210 
4211  strawNumber = (192 - 1) * TripletOrientation[side][phi1] + strawNumber * (1 - 2 * TripletOrientation[side][phi1]); //actual rotation
4212 
4213  //take strawNumber back to 0-23
4214  if (strawLayerNumber < 8) strawLayerNumber = int(strawNumber / 24);
4215 
4216  if (strawLayerNumber > 7) strawLayerNumber = int(strawNumber / 24) + 8;
4217 
4218  strawNumber = strawNumber % 24;
4219  }
4220 
4221  //Finish rotation
4222  //Flip straw in layer.
4223 
4224  if (side == 0) strawNumber = 23 - strawNumber;
4225 
4226  //Finish Flipping
4227  }
4228 
4229  // Done with corrections
4230  // Start mapping from athena identifiers to TRTViewer maps
4231  int strawNumberNew = 0;
4232 
4233  if (LayerNumber < 6 && strawLayerNumber > 7) {
4234  strawNumberNew = strawNumberNew + (384 * LayerNumber);
4235  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (strawNumber * 8);
4236  } else if (LayerNumber < 6 && strawLayerNumber < 8) {
4237  strawNumberNew = strawNumberNew + (384 * LayerNumber);
4238  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (strawNumber * 8);
4239  } else if (LayerNumber > 5 && strawLayerNumber > 7) {
4240  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
4241  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (8 * strawNumber);
4242  } else if (LayerNumber > 5 && strawLayerNumber < 8) {
4243  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
4244  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (8 * strawNumber);
4245  }
4246 
4247  strawNumber = strawNumberNew;
4248 
4249  if (strawNumber < 0 || strawNumber > s_Straw_max[1] - 1) {
4250  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
4251  strawNumber = 0;
4252  }
4253 
4254  return strawNumber;
4255 }

◆ streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )
virtualinherited

Returns the function object that converts logical paramters into a physical stream name.

Definition at line 502 of file ManagedMonitorToolBase.cxx.

504 {
505  if( m_streamNameFcn == 0 ) {
506  msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
507  msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
508  msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
509  msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
510  m_streamNameFcn = getNewStreamNameFcn();
511  }
512  return m_streamNameFcn;
513 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ THistSvc_deReg_fixTGraph()

StatusCode ManagedMonitorToolBase::THistSvc_deReg_fixTGraph ( TFile *  file,
TGraph *  theGraph,
std::string &  directoryName 
)
protectedinherited

Fixes THistSvc->deReg(obj) when obj is TGraph instance.

Read more in source file about this bug.

Definition at line 1097 of file ManagedMonitorToolBase.cxx.

1099 {
1100  // THistSvc employs TDirectory Append method when registering TGraph.
1101  // When deReg is used to de-register TGraph object, THistSvc only removes the object
1102  // from its internal management but forgets to delete from TDirectory.
1103  // The current method fixes this problem by removing the TGraph object manually
1104  // after THistSvc->deReg(TGraph* obj) is called.
1105 
1106  // Saves and restores gFile and gDirectory
1107  GlobalDirectoryRestore restore;
1108 
1109  // This check is true when TGraph object is removed successfully
1110  bool graphRemoved = false;
1111 
1112  file->cd("/");
1113  TDirectory* dir = file->GetDirectory(directoryName.c_str());
1114  if (dir != 0) {
1115  dir->cd();
1116  TObject* obj = dir->Remove(theGraph);
1117  if (obj != 0)
1118  graphRemoved = true;
1119  }
1120 
1121  if (!graphRemoved) {
1122  return StatusCode::FAILURE;
1123  }
1124 
1125  return StatusCode::SUCCESS;
1126 }

◆ trigChainsArePassed()

bool ManagedMonitorToolBase::trigChainsArePassed ( std::vector< std::string > &  vTrigNames)
protectedvirtualinherited

Definition at line 2324 of file ManagedMonitorToolBase.cxx.

2326 {
2327  ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
2328 
2329  for(unsigned int i=0; i<vTrigNames.size(); i++) {
2330  if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
2331  ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
2332  return true;
2333  }
2334  else {
2335  ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
2336  }
2337  }
2338 
2339  return false;
2340 }

◆ trtRegHist()

template<typename T >
StatusCode TRT_Monitoring_Tool::trtRegHist ( T *  hist,
MonGroup &  mongrp,
const char *  hName 
)
inlineprivate

Definition at line 128 of file TRT_Monitoring_Tool.h.

128  {
129  StatusCode scode = mongrp.regHist(hist);
130  if (scode == StatusCode::FAILURE) {
131  ATH_MSG_FATAL("Failed to register histogram " << hName);
132  }
133  return scode;
134  }

◆ updateTriggersForGroups()

void ManagedMonitorToolBase::updateTriggersForGroups ( std::vector< std::string > &  vTrigChainNames)
protectedinherited

Definition at line 2362 of file ManagedMonitorToolBase.cxx.

2363  {
2364  for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2365  std::string& thisName = vTrigChainNames[i];
2366  if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2367  ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2368  std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2369  std::ostringstream oss;
2370  oss << "(";
2371  for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2372  if (itrig != 0) {
2373  oss << "|";
2374  }
2375  oss << triggers[itrig];
2376  }
2377  oss << ")";
2378  // replace with new value
2379  std::string newval = oss.str();
2380  ATH_MSG_DEBUG("Replaced with " << newval);
2381  vTrigChainNames[i] = newval;
2382  }
2383  }
2384 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ writeAndDelete()

StatusCode ManagedMonitorToolBase::writeAndDelete ( TH1 *  h,
const MonGroup &  group 
)
virtualinherited

Write out histogram and delete it.

Definition at line 1803 of file ManagedMonitorToolBase.cxx.

1804  {
1805  if (!h)
1806  return StatusCode::FAILURE;
1807 
1808  std::string hName = h->GetName();
1809 
1810  if( m_manager != 0 ) {
1811  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1812  m_manager->writeAndDelete( genericName );
1813  }
1814  return StatusCode::SUCCESS;
1815 }

Member Data Documentation

◆ m_ArgonXenonSplitter

bool TRT_Monitoring_Tool::m_ArgonXenonSplitter
private

Definition at line 84 of file TRT_Monitoring_Tool.h.

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 956 of file ManagedMonitorToolBase.h.

◆ m_bsErrContKey

SG::ReadHandleKey<TRT_BSErrContainer> TRT_Monitoring_Tool::m_bsErrContKey {this,"ByteStreamErrors","TRT_ByteStreamErrs","SG key of TRT ByteStream Error container"}
private

Definition at line 164 of file TRT_Monitoring_Tool.h.

◆ m_combTrackCollectionKey

SG::ReadHandleKey<TrackCollection> TRT_Monitoring_Tool::m_combTrackCollectionKey {this, "track_collection_hole_finder", "CombinedInDetTracks", "Name of tracks container used for hole finder"}
private

Definition at line 158 of file TRT_Monitoring_Tool.h.

◆ m_comTimeObjectKey

SG::ReadHandleKey<ComTime> TRT_Monitoring_Tool::m_comTimeObjectKey {this, "ComTimeObjectName", "TRT_Phase", "Name of ComTime object"}
private

Definition at line 161 of file TRT_Monitoring_Tool.h.

◆ m_condSvc_BS

ServiceHandle<ITRT_ConditionsSvc> TRT_Monitoring_Tool::m_condSvc_BS
private

Definition at line 150 of file TRT_Monitoring_Tool.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 963 of file ManagedMonitorToolBase.h.

◆ m_DAQSvc

ServiceHandle<ITRT_DAQ_ConditionsSvc> TRT_Monitoring_Tool::m_DAQSvc
private

Definition at line 149 of file TRT_Monitoring_Tool.h.

◆ m_datatype

std::string TRT_Monitoring_Tool::m_datatype
private

Definition at line 606 of file TRT_Monitoring_Tool.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 901 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 897 of file ManagedMonitorToolBase.h.

◆ m_DEBUG

bool TRT_Monitoring_Tool::m_DEBUG
private

Definition at line 571 of file TRT_Monitoring_Tool.h.

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration
privateinherited

Definition at line 958 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 899 of file ManagedMonitorToolBase.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DistToStraw

float TRT_Monitoring_Tool::m_DistToStraw
private

Definition at line 568 of file TRT_Monitoring_Tool.h.

◆ m_doASide

bool TRT_Monitoring_Tool::m_doASide
private

Definition at line 491 of file TRT_Monitoring_Tool.h.

◆ m_doChips

bool TRT_Monitoring_Tool::m_doChips
private

Definition at line 494 of file TRT_Monitoring_Tool.h.

◆ m_doCSide

bool TRT_Monitoring_Tool::m_doCSide
private

Definition at line 492 of file TRT_Monitoring_Tool.h.

◆ m_doDCS

bool TRT_Monitoring_Tool::m_doDCS
private

Definition at line 490 of file TRT_Monitoring_Tool.h.

◆ m_doDiagnostic

bool TRT_Monitoring_Tool::m_doDiagnostic
private

Definition at line 499 of file TRT_Monitoring_Tool.h.

◆ m_doEfficiency

bool TRT_Monitoring_Tool::m_doEfficiency
private

Definition at line 498 of file TRT_Monitoring_Tool.h.

◆ m_doExpert

bool TRT_Monitoring_Tool::m_doExpert
private

Definition at line 496 of file TRT_Monitoring_Tool.h.

◆ m_doGeoMon

bool TRT_Monitoring_Tool::m_doGeoMon
private

Definition at line 484 of file TRT_Monitoring_Tool.h.

◆ m_doMaskStraws

bool TRT_Monitoring_Tool::m_doMaskStraws
private

Definition at line 497 of file TRT_Monitoring_Tool.h.

◆ m_doRDOsMon

bool TRT_Monitoring_Tool::m_doRDOsMon
private

Definition at line 483 of file TRT_Monitoring_Tool.h.

◆ m_doShift

bool TRT_Monitoring_Tool::m_doShift
private

Definition at line 495 of file TRT_Monitoring_Tool.h.

◆ m_doStraws

bool TRT_Monitoring_Tool::m_doStraws
private

Definition at line 493 of file TRT_Monitoring_Tool.h.

◆ m_doTracksMon

bool TRT_Monitoring_Tool::m_doTracksMon
private

Definition at line 485 of file TRT_Monitoring_Tool.h.

◆ m_DQFilterTools

ToolHandleArray<IDQFilterTool> ManagedMonitorToolBase::m_DQFilterTools {this,"FilterTools",{}}
protectedinherited

Definition at line 912 of file ManagedMonitorToolBase.h.

◆ m_DriftTimeonTrkDistScale_B

float TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B
private

Definition at line 525 of file TRT_Monitoring_Tool.h.

◆ m_DriftTimeonTrkDistScale_B_Ar

float TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B_Ar
private

Definition at line 537 of file TRT_Monitoring_Tool.h.

◆ m_DriftTimeonTrkDistScale_E

float TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E[2]
private

Definition at line 546 of file TRT_Monitoring_Tool.h.

◆ m_DriftTimeonTrkDistScale_E_Ar

float TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E_Ar[2]
private

Definition at line 558 of file TRT_Monitoring_Tool.h.

◆ m_drifttool

ToolHandle<ITRT_DriftFunctionTool> TRT_Monitoring_Tool::m_drifttool
private

Definition at line 170 of file TRT_Monitoring_Tool.h.

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 902 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 898 of file ManagedMonitorToolBase.h.

◆ m_EventBurstCut

int TRT_Monitoring_Tool::m_EventBurstCut
private

Definition at line 575 of file TRT_Monitoring_Tool.h.

◆ m_EventPhaseScale

float TRT_Monitoring_Tool::m_EventPhaseScale
private

Definition at line 516 of file TRT_Monitoring_Tool.h.

◆ m_every_xth_track

int TRT_Monitoring_Tool::m_every_xth_track
private

Definition at line 605 of file TRT_Monitoring_Tool.h.

◆ m_evtLumiBlock

int TRT_Monitoring_Tool::m_evtLumiBlock
private

Definition at line 76 of file TRT_Monitoring_Tool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fileKey

std::string ManagedMonitorToolBase::m_fileKey
protectedinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_flagforscale

int TRT_Monitoring_Tool::m_flagforscale
private

Definition at line 583 of file TRT_Monitoring_Tool.h.

◆ m_geo_summary_provider

std::string TRT_Monitoring_Tool::m_geo_summary_provider
private

Definition at line 175 of file TRT_Monitoring_Tool.h.

◆ m_good_bcid

int TRT_Monitoring_Tool::m_good_bcid
private

Definition at line 77 of file TRT_Monitoring_Tool.h.

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 929 of file ManagedMonitorToolBase.h.

◆ m_hAvgHLOcc_side

TProfile_LW* TRT_Monitoring_Tool::m_hAvgHLOcc_side[2][2] {}
private

Definition at line 182 of file TRT_Monitoring_Tool.h.

◆ m_hAvgHLOccMod_side

TProfile_LW* TRT_Monitoring_Tool::m_hAvgHLOccMod_side[2][2] {}
private

Definition at line 437 of file TRT_Monitoring_Tool.h.

◆ m_hAvgLLOcc_side

TProfile_LW* TRT_Monitoring_Tool::m_hAvgLLOcc_side[2][2] {}
private

Definition at line 183 of file TRT_Monitoring_Tool.h.

◆ m_hAvgLLOccMod_side

TProfile_LW* TRT_Monitoring_Tool::m_hAvgLLOccMod_side[2][2] {}
private

Avg.

Occupancy: Modules (Side A&C) Average Occupancy per Phi Module on Side A(&C). This is an RDO level Histogram.

Definition at line 436 of file TRT_Monitoring_Tool.h.

◆ m_hAvgTroTDetPhi_B

TProfile_LW* TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B
private

Definition at line 187 of file TRT_Monitoring_Tool.h.

◆ m_hAvgTroTDetPhi_B_Ar

TProfile_LW* TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B_Ar
private

Definition at line 188 of file TRT_Monitoring_Tool.h.

◆ m_hAvgTroTDetPhi_E

TProfile_LW* TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E[2] {}
private

Definition at line 221 of file TRT_Monitoring_Tool.h.

◆ m_hAvgTroTDetPhi_E_Ar

TProfile_LW* TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E_Ar[2] {}
private

Definition at line 222 of file TRT_Monitoring_Tool.h.

◆ m_hBCIDvsOcc

TProfile_LW* TRT_Monitoring_Tool::m_hBCIDvsOcc[2] {}
private

Definition at line 438 of file TRT_Monitoring_Tool.h.

◆ m_hChipBSErrorsVsLB

TProfile* TRT_Monitoring_Tool::m_hChipBSErrorsVsLB[2][2] {}
private

Definition at line 179 of file TRT_Monitoring_Tool.h.

◆ m_hChipOcc

TH1F_LW* TRT_Monitoring_Tool::m_hChipOcc[2][64] {}
private

Avg.

Occupancy: Modules (Side A and C) Average Occupancy per Phi Module on Side A and C. This is an RDO level Histogram.

Definition at line 444 of file TRT_Monitoring_Tool.h.

◆ m_hChipsEff

TProfile_LW* TRT_Monitoring_Tool::m_hChipsEff[2][64] {}
private

Definition at line 259 of file TRT_Monitoring_Tool.h.

◆ m_hDriftTimeonTrkDist_B

TH1F_LW* TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B
private

Definition at line 197 of file TRT_Monitoring_Tool.h.

◆ m_hDriftTimeonTrkDist_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B_Ar
private

Definition at line 211 of file TRT_Monitoring_Tool.h.

◆ m_hDriftTimeonTrkDist_E

TH1F_LW* TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E[2] {}
private

Definition at line 231 of file TRT_Monitoring_Tool.h.

◆ m_hDriftTimeonTrkDist_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E_Ar[2] {}
private

Definition at line 246 of file TRT_Monitoring_Tool.h.

◆ m_hefficiency

TH1F_LW* TRT_Monitoring_Tool::m_hefficiency[2][2] {}
private

Definition at line 622 of file TRT_Monitoring_Tool.h.

◆ m_hefficiency_eta

TProfile_LW* TRT_Monitoring_Tool::m_hefficiency_eta
private

Definition at line 610 of file TRT_Monitoring_Tool.h.

◆ m_hefficiency_phi

TProfile_LW* TRT_Monitoring_Tool::m_hefficiency_phi
private

Definition at line 611 of file TRT_Monitoring_Tool.h.

◆ m_hefficiency_pt

TProfile_LW* TRT_Monitoring_Tool::m_hefficiency_pt
private

Definition at line 612 of file TRT_Monitoring_Tool.h.

◆ m_hefficiency_z0

TProfile_LW* TRT_Monitoring_Tool::m_hefficiency_z0
private

Definition at line 613 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyBarrel_locR

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyBarrel_locR
private

Definition at line 614 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyBarrel_locR_Ar

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyBarrel_locR_Ar
private

Definition at line 615 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyC

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyC[2][64] {}
private

Definition at line 621 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyEndCap_locR

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyEndCap_locR[2] {}
private

Definition at line 616 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyEndCap_locR_Ar

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyEndCap_locR_Ar[2] {}
private

Definition at line 617 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyIntegral

TH1F_LW* TRT_Monitoring_Tool::m_hefficiencyIntegral[2][2] {}
private

Definition at line 623 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyMap

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyMap[2] {}
private

Definition at line 619 of file TRT_Monitoring_Tool.h.

◆ m_hefficiencyS

TProfile_LW* TRT_Monitoring_Tool::m_hefficiencyS[2][64] {}
private

Definition at line 620 of file TRT_Monitoring_Tool.h.

◆ m_hEvtPhase

TH1F_LW* TRT_Monitoring_Tool::m_hEvtPhase
private

Definition at line 257 of file TRT_Monitoring_Tool.h.

◆ m_hEvtPhaseDetPhi_B

TProfile_LW* TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_B
private

Definition at line 255 of file TRT_Monitoring_Tool.h.

◆ m_hEvtPhaseDetPhi_E

TProfile_LW* TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_E[2] {}
private

Definition at line 256 of file TRT_Monitoring_Tool.h.

◆ m_hEvtPhaseVsTrig

TH2F_LW* TRT_Monitoring_Tool::m_hEvtPhaseVsTrig
private

Definition at line 258 of file TRT_Monitoring_Tool.h.

◆ m_hHightoLowRatioOnTrack_Scatter

TH2F_LW* TRT_Monitoring_Tool::m_hHightoLowRatioOnTrack_Scatter[2] {}
private

Definition at line 452 of file TRT_Monitoring_Tool.h.

◆ m_hHitAMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitAMapC[2][64] {}
private

Definition at line 404 of file TRT_Monitoring_Tool.h.

◆ m_hHitAMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitAMapS[2][64] {}
private

Any LL bit on: Straws if any low threshold bit was set.

if leading edge is > 0, or if trailing edge < 23, or if first bin is high, or if last bin is high This is an RDO level histogram.

Definition at line 289 of file TRT_Monitoring_Tool.h.

◆ m_hHitAonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitAonTMapC[2][64] {}
private

Definition at line 421 of file TRT_Monitoring_Tool.h.

◆ m_hHitAonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitAonTMapS[2][64] {}
private

Any LL bit on track: Straws Any low level bit is set from hit associated with a track.

This is a track level hit

Definition at line 357 of file TRT_Monitoring_Tool.h.

◆ m_hHitAWMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitAWMapC[2][64] {}
private

Definition at line 405 of file TRT_Monitoring_Tool.h.

◆ m_hHitAWMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitAWMapS[2][64] {}
private

LL in time window: Straws Any low level hit in time window by straw.

((m_driftTimeBin>0 || m_trailingEdge<23)&& !m_firstBinHigh && !m_lastBinHigh) This is an RDO level histogram.

Definition at line 296 of file TRT_Monitoring_Tool.h.

◆ m_hHitAWonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitAWonTMapC[2][64] {}
private

Definition at line 422 of file TRT_Monitoring_Tool.h.

◆ m_hHitAWonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitAWonTMapS[2][64] {}
private

Any LL bit in time window on track: Straws Any low level (LL) bit set and is in time window from hits associated with tracks This is a track level histogram.

Definition at line 363 of file TRT_Monitoring_Tool.h.

◆ m_hHitHMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitHMapC[2][64] {}
private

Definition at line 411 of file TRT_Monitoring_Tool.h.

◆ m_hHitHMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitHMapS[2][64] {}
private

High Level: Straws If a hit has any of the high threshold time bins up.

m_hHitHMapS[m_phi_module]->Fill(m_strawNumber); This is an RDO level histogram

Definition at line 333 of file TRT_Monitoring_Tool.h.

◆ m_hHitHonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitHonTMapC[2][64] {}
private

Definition at line 423 of file TRT_Monitoring_Tool.h.

◆ m_hHitHonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitHonTMapS[2][64] {}
private

Definition at line 372 of file TRT_Monitoring_Tool.h.

◆ m_hHitHWMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitHWMapC[2][64] {}
private

Definition at line 412 of file TRT_Monitoring_Tool.h.

◆ m_hHitHWMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitHWMapS[2][64] {}
private

HL in time window: Straws If a hit has any of the high threshold time bins up, and is in the time window.

((m_driftTimeBin<24) && !m_firstBinHight && !m_lastBinHight) This is an RDO level histogram

Definition at line 339 of file TRT_Monitoring_Tool.h.

◆ m_hHitHWonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitHWonTMapC[2][64] {}
private

Definition at line 424 of file TRT_Monitoring_Tool.h.

◆ m_hHitHWonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitHWonTMapS[2][64] {}
private

Any HL hit on track: Straws Any straw with a High Threshold (HL) hit associated with a track.

This is a track level histogram

Definition at line 369 of file TRT_Monitoring_Tool.h.

◆ m_hHitOnTrackVsAllC

TH1F_LW* TRT_Monitoring_Tool::m_hHitOnTrackVsAllC[2][64] {}
private

Definition at line 262 of file TRT_Monitoring_Tool.h.

◆ m_hHitOnTrackVsAllS

TH1F_LW* TRT_Monitoring_Tool::m_hHitOnTrackVsAllS[2][64] {}
private

Definition at line 261 of file TRT_Monitoring_Tool.h.

◆ m_hHitsOnTrack_Scatter

TH2F_LW* TRT_Monitoring_Tool::m_hHitsOnTrack_Scatter[2] {}
private

Anatoli's "Scatter histograms" ** Monitor quantities as a function of lumi block.

Fill per every stack

Definition at line 450 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTLongMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTLongMapS[2][64] {}
private

Mean ToT (ns) for straws with ToT > LongToTCut: Straws.

Average Time over Threshold (ToT) in nano seconds per straw for straws with ToT > LongToTCut. m_hHitToTLongMapS[m_phi_module]->Fill(m_strawNumber, m_timeOverThreshold); m_timeOverThreshold = (p_lolum)->timeOverThreshold(); This is an RDO level histogram.

Definition at line 318 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTLongTrMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTLongTrMapS[2][64] {}
private

Mean Trailing Edge (ns) for straws with ToT > LongToTCut: Straws.

Average Trailing Edge (Tr) in nano seconds per straw for straws with ToT > LongToTCut. m_hHitToTLongTrMapS[m_phi_module]->Fill(m_strawNumber, m_trailingEdge); m_trailingEdge = (p_lolum)->trailingEgde(); This is an RDO level histogram.

Definition at line 326 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTMapC[2][64] {}
private

Definition at line 410 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTMapS[2][64] {}
private

Mean ToT (ns): Straws.

Average Time over Threshold (ToT) in nano seconds per straw. m_hHitToTMapS[m_phi_module]->Fill(m_strawNumber, m_timeOverThreshold); m_timeOverThreshold = (p_lolum)->timeOverThreshold(); This is an RDO level histogram.

Definition at line 310 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTonTMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTonTMapC[2][64] {}
private

Definition at line 427 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTonTMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTonTMapS[2][64] {}
private

Mean ToT (ns) on Track: Straws Average Time over Threshold (ToT) from a straw hit associated with a track.

This is a track level histogram.

Definition at line 387 of file TRT_Monitoring_Tool.h.

◆ m_hHitToTrkDistanceMapS_E

TProfile_LW* TRT_Monitoring_Tool::m_hHitToTrkDistanceMapS_E[64] {}
private

Definition at line 430 of file TRT_Monitoring_Tool.h.

◆ m_hHitTrMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitTrMapC[2][64] {}
private

Definition at line 402 of file TRT_Monitoring_Tool.h.

◆ m_hHitTrMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitTrMapS[2][64] {}
private

Mean TE: Straws.

Average of Trailing Edge bin where the trailing edge (trailingEdge()) is less than 23. This an RDO level histogram.

Definition at line 282 of file TRT_Monitoring_Tool.h.

◆ m_hHitTronTMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitTronTMapC[2][64] {}
private

Definition at line 420 of file TRT_Monitoring_Tool.h.

◆ m_hHitTronTMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitTronTMapS[2][64] {}
private

Mean TE on track: Straws Average Trailing Edge(TE) from a hit associated with a track.

This is a track level histogram.

Definition at line 351 of file TRT_Monitoring_Tool.h.

◆ m_hHitTronTwEPCMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitTronTwEPCMapC[2][64] {}
private

Definition at line 428 of file TRT_Monitoring_Tool.h.

◆ m_hHitTronTwEPCMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitTronTwEPCMapS[2][64] {}
private

Mean TE on track (with Event Phase correction): Straws.

Average trailing edge(TE) on track after correcting for event phase from a hit associated with a track. This is a track level histogram.

Definition at line 393 of file TRT_Monitoring_Tool.h.

◆ m_hHitTrWMapC

TProfile_LW* TRT_Monitoring_Tool::m_hHitTrWMapC[2][64] {}
private

Definition at line 403 of file TRT_Monitoring_Tool.h.

◆ m_hHitTrWMapS

TProfile_LW* TRT_Monitoring_Tool::m_hHitTrWMapS[2][64] {}
private

TE in Time Window: Straws.

If hit trailing edge is in time window. In Time window means ((trailingEdge<23)&& !lastBinHigh && !firstBinHigh) m_hHitTrWMapS[m_phi_module]->Fill(m_strawNumber, ((m_trailingEdge+1)*3.125));

Definition at line 276 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMap_B

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMap_B
private

Definition at line 191 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMap_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMap_B_Ar
private

Definition at line 213 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMap_E

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMap_E[2] {}
private

Definition at line 225 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMap_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMap_E_Ar[2] {}
private

Definition at line 247 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMapC[2][64] {}
private

Definition at line 401 of file TRT_Monitoring_Tool.h.

◆ m_hHitWMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitWMapS[2][64] {}
private

Leading Edge in time Window: Straws.

Any hit where the leading edge (driftTimeBin()) is less than 24. In Time window means ((driftTimeBin<24) && !lastBinHigh && !firstBinHigh) This is an RDO level histogram.

Definition at line 269 of file TRT_Monitoring_Tool.h.

◆ m_hHitWonTMap_B

TH1F_LW* TRT_Monitoring_Tool::m_hHitWonTMap_B
private

Definition at line 192 of file TRT_Monitoring_Tool.h.

◆ m_hHitWonTMap_E

TH1F_LW* TRT_Monitoring_Tool::m_hHitWonTMap_E[2] {}
private

Definition at line 226 of file TRT_Monitoring_Tool.h.

◆ m_hHitWonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHitWonTMapC[2][64] {}
private

LE in time window on track: Chips.

Leading Edge (LE) from a hit associated with a track is within first 23 time bins. Plotted as a function of DTMROC. This is a track level histogram.

Definition at line 419 of file TRT_Monitoring_Tool.h.

◆ m_hHitWonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHitWonTMapS[2][64] {}
private

LE in time window on track: Straws.

Leading Edge (LE) is within first 23 time bins of read out from a hit associated with a track. This is track level histogram.

Definition at line 345 of file TRT_Monitoring_Tool.h.

◆ m_hHLhitOnTrack_B

TH1F_LW* TRT_Monitoring_Tool::m_hHLhitOnTrack_B
private

Definition at line 200 of file TRT_Monitoring_Tool.h.

◆ m_hHLhitOnTrack_E

TH1F_LW* TRT_Monitoring_Tool::m_hHLhitOnTrack_E[2] {}
private

Definition at line 234 of file TRT_Monitoring_Tool.h.

◆ m_hHtoBCMapB

TH2F_LW* TRT_Monitoring_Tool::m_hHtoBCMapB[2][64] {}
private

Definition at line 409 of file TRT_Monitoring_Tool.h.

◆ m_hHtoBCMapC

TH2F_LW* TRT_Monitoring_Tool::m_hHtoBCMapC[2][64] {}
private

Definition at line 408 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLMapC[2][64] {}
private

Definition at line 406 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLMapS[2][64] {}
private

HL/LL: Straws The ratio of High Level hits to Low Level hits per straw.

This is an RDO level histogram.

Definition at line 302 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLonTMapC[2][64] {}
private

Definition at line 425 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLonTMapS[2][64] {}
private

HL in time window on track: Straws Straws with a High Threshold hit associated with a track and the hit is in the time window.

This is a track level histogram.

Definition at line 378 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_B

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B
private

Definition at line 201 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Ar
private

Definition at line 202 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_B_Xe

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Xe
private

Definition at line 203 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_E

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E[2] {}
private

Definition at line 235 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Ar[2] {}
private

Definition at line 236 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLRatioOnTrack_E_Xe

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Xe[2] {}
private

Definition at line 237 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLWonTMapC

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLWonTMapC[2][64] {}
private

Definition at line 426 of file TRT_Monitoring_Tool.h.

◆ m_hHtoLWonTMapS

TH1F_LW* TRT_Monitoring_Tool::m_hHtoLWonTMapS[2][64] {}
private

Definition at line 381 of file TRT_Monitoring_Tool.h.

◆ m_HL_timeWindow_MAX

int TRT_Monitoring_Tool::m_HL_timeWindow_MAX
private

Definition at line 509 of file TRT_Monitoring_Tool.h.

◆ m_HL_timeWindow_MIN

int TRT_Monitoring_Tool::m_HL_timeWindow_MIN
private

Definition at line 508 of file TRT_Monitoring_Tool.h.

◆ m_HLhitOnTrackScale_B

float TRT_Monitoring_Tool::m_HLhitOnTrackScale_B
private

Definition at line 526 of file TRT_Monitoring_Tool.h.

◆ m_HLhitOnTrackScale_E

float TRT_Monitoring_Tool::m_HLhitOnTrackScale_E[2]
private

Definition at line 547 of file TRT_Monitoring_Tool.h.

◆ m_hLLOcc_Scatter

TH2F_LW* TRT_Monitoring_Tool::m_hLLOcc_Scatter[2] {}
private

Definition at line 451 of file TRT_Monitoring_Tool.h.

◆ m_hNHitsperLB_B

TProfile* TRT_Monitoring_Tool::m_hNHitsperLB_B
private

Definition at line 207 of file TRT_Monitoring_Tool.h.

◆ m_hNHitsperLB_E

TProfile* TRT_Monitoring_Tool::m_hNHitsperLB_E[2] {}
private

Definition at line 241 of file TRT_Monitoring_Tool.h.

◆ m_hNHLHitsperLB_B

TProfile* TRT_Monitoring_Tool::m_hNHLHitsperLB_B
private

Definition at line 209 of file TRT_Monitoring_Tool.h.

◆ m_hNHLHitsperLB_E

TProfile* TRT_Monitoring_Tool::m_hNHLHitsperLB_E[2] {}
private

Definition at line 243 of file TRT_Monitoring_Tool.h.

◆ m_hNTrksperLB_B

TProfile* TRT_Monitoring_Tool::m_hNTrksperLB_B
private

Definition at line 208 of file TRT_Monitoring_Tool.h.

◆ m_hNTrksperLB_E

TProfile* TRT_Monitoring_Tool::m_hNTrksperLB_E[2] {}
private

Definition at line 242 of file TRT_Monitoring_Tool.h.

◆ m_hNumHoTDetPhi_B

TProfile_LW* TRT_Monitoring_Tool::m_hNumHoTDetPhi_B
private

Definition at line 186 of file TRT_Monitoring_Tool.h.

◆ m_hNumHoTDetPhi_E

TProfile_LW* TRT_Monitoring_Tool::m_hNumHoTDetPhi_E[2] {}
private

Definition at line 220 of file TRT_Monitoring_Tool.h.

◆ m_hNumSwLLWoT_B

TH1F_LW* TRT_Monitoring_Tool::m_hNumSwLLWoT_B
private

Definition at line 189 of file TRT_Monitoring_Tool.h.

◆ m_hNumSwLLWoT_E

TH1F_LW* TRT_Monitoring_Tool::m_hNumSwLLWoT_E[2] {}
private

Definition at line 223 of file TRT_Monitoring_Tool.h.

◆ m_hNumTrksDetPhi_B

TH1F_LW* TRT_Monitoring_Tool::m_hNumTrksDetPhi_B
private

Definition at line 185 of file TRT_Monitoring_Tool.h.

◆ m_hNumTrksDetPhi_E

TH1F_LW* TRT_Monitoring_Tool::m_hNumTrksDetPhi_E[2] {}
private

Definition at line 219 of file TRT_Monitoring_Tool.h.

◆ m_hOccAll

TH1F_LW* TRT_Monitoring_Tool::m_hOccAll
private

Definition at line 453 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_B

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_B
private

Definition at line 194 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_B_20GeV

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_B_20GeV
private

Definition at line 195 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_B_Ar
private

Definition at line 214 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_B_Ar_20GeV

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_B_Ar_20GeV
private

Definition at line 215 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_E

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_E[2] {}
private

Definition at line 228 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_E_20GeV

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_E_20GeV[2] {}
private

Definition at line 229 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_E_Ar[2] {}
private

Definition at line 248 of file TRT_Monitoring_Tool.h.

◆ m_hResidual_E_Ar_20GeV

TH1F_LW* TRT_Monitoring_Tool::m_hResidual_E_Ar_20GeV[2] {}
private

Definition at line 249 of file TRT_Monitoring_Tool.h.

◆ m_hResVsDetPhi_B

TH1F_LW* TRT_Monitoring_Tool::m_hResVsDetPhi_B
private

Definition at line 206 of file TRT_Monitoring_Tool.h.

◆ m_hResVsDetPhi_E

TH1F_LW* TRT_Monitoring_Tool::m_hResVsDetPhi_E[2] {}
private

Definition at line 240 of file TRT_Monitoring_Tool.h.

◆ m_hRobBSErrorsVsLB

TProfile* TRT_Monitoring_Tool::m_hRobBSErrorsVsLB[2][2] {}
private

Definition at line 180 of file TRT_Monitoring_Tool.h.

◆ m_hrtRelation_B

TH2F_LW* TRT_Monitoring_Tool::m_hrtRelation_B
private

Definition at line 199 of file TRT_Monitoring_Tool.h.

◆ m_hrtRelation_B_Ar

TH2F_LW* TRT_Monitoring_Tool::m_hrtRelation_B_Ar
private

Definition at line 217 of file TRT_Monitoring_Tool.h.

◆ m_hrtRelation_E

TH2F_LW* TRT_Monitoring_Tool::m_hrtRelation_E[2] {}
private

Definition at line 233 of file TRT_Monitoring_Tool.h.

◆ m_hrtRelation_E_Ar

TH2F_LW* TRT_Monitoring_Tool::m_hrtRelation_E_Ar[2] {}
private

Definition at line 251 of file TRT_Monitoring_Tool.h.

◆ m_hStrawEffDetPhi_B

TProfile_LW* TRT_Monitoring_Tool::m_hStrawEffDetPhi_B
private

Definition at line 190 of file TRT_Monitoring_Tool.h.

◆ m_hStrawEffDetPhi_E

TProfile_LW* TRT_Monitoring_Tool::m_hStrawEffDetPhi_E[2] {}
private

Definition at line 224 of file TRT_Monitoring_Tool.h.

◆ m_hStrawOcc

TH1F_LW* TRT_Monitoring_Tool::m_hStrawOcc[2][64] {}
private

Definition at line 445 of file TRT_Monitoring_Tool.h.

◆ m_hStrawsEff

TProfile_LW* TRT_Monitoring_Tool::m_hStrawsEff[2][64] {}
private

Definition at line 253 of file TRT_Monitoring_Tool.h.

◆ m_hSummary

TH1F_LW* TRT_Monitoring_Tool::m_hSummary
private

Definition at line 178 of file TRT_Monitoring_Tool.h.

◆ m_HTfraconTrack_B

float TRT_Monitoring_Tool::m_HTfraconTrack_B[32]
private

Definition at line 473 of file TRT_Monitoring_Tool.h.

◆ m_HTfraconTrack_E

float TRT_Monitoring_Tool::m_HTfraconTrack_E[64]
private

Definition at line 479 of file TRT_Monitoring_Tool.h.

◆ m_hTimeResidual_B

TH1F_LW* TRT_Monitoring_Tool::m_hTimeResidual_B
private

Definition at line 196 of file TRT_Monitoring_Tool.h.

◆ m_hTimeResidual_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hTimeResidual_B_Ar
private

Definition at line 216 of file TRT_Monitoring_Tool.h.

◆ m_hTimeResidual_E

TH1F_LW* TRT_Monitoring_Tool::m_hTimeResidual_E[2] {}
private

Definition at line 230 of file TRT_Monitoring_Tool.h.

◆ m_hTimeResidual_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hTimeResidual_E_Ar[2] {}
private

Definition at line 250 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_B

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B
private

Definition at line 527 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_B_Ar

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Ar
private

Definition at line 528 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_B_Xe

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Xe
private

Definition at line 529 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_E

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E[2]
private

Definition at line 548 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_E_Ar

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Ar[2]
private

Definition at line 549 of file TRT_Monitoring_Tool.h.

◆ m_HtoLRatioOnTrackScale_E_Xe

float TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Xe[2]
private

Definition at line 550 of file TRT_Monitoring_Tool.h.

◆ m_hTronTDist_B

TH1F_LW* TRT_Monitoring_Tool::m_hTronTDist_B
private

Definition at line 198 of file TRT_Monitoring_Tool.h.

◆ m_hTronTDist_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hTronTDist_B_Ar
private

Definition at line 212 of file TRT_Monitoring_Tool.h.

◆ m_hTronTDist_E

TH1F_LW* TRT_Monitoring_Tool::m_hTronTDist_E[2] {}
private

Definition at line 232 of file TRT_Monitoring_Tool.h.

◆ m_hTronTDist_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hTronTDist_E_Ar[2] {}
private

Definition at line 245 of file TRT_Monitoring_Tool.h.

◆ m_hValidRawDriftTimeonTrk

TProfile_LW* TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrk[2][64] {}
private

Valid Raw Drift Time on Track.

Staws with hits that have valid drift times and are associated with a track. This is a track level histogram.

Definition at line 399 of file TRT_Monitoring_Tool.h.

◆ m_hValidRawDriftTimeonTrkC

TProfile_LW* TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrkC[2][64] {}
private

Definition at line 400 of file TRT_Monitoring_Tool.h.

◆ m_hWireToTrkPosition_B

TH1F_LW* TRT_Monitoring_Tool::m_hWireToTrkPosition_B
private

Definition at line 204 of file TRT_Monitoring_Tool.h.

◆ m_hWireToTrkPosition_B_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hWireToTrkPosition_B_Ar
private

Definition at line 205 of file TRT_Monitoring_Tool.h.

◆ m_hWireToTrkPosition_E

TH1F_LW* TRT_Monitoring_Tool::m_hWireToTrkPosition_E[2] {}
private

Definition at line 238 of file TRT_Monitoring_Tool.h.

◆ m_hWireToTrkPosition_E_Ar

TH1F_LW* TRT_Monitoring_Tool::m_hWireToTrkPosition_E_Ar[2] {}
private

Definition at line 239 of file TRT_Monitoring_Tool.h.

◆ m_idHelper

const AtlasDetectorID* TRT_Monitoring_Tool::m_idHelper
private

Definition at line 87 of file TRT_Monitoring_Tool.h.

◆ m_IntLum

TH1F_LW* TRT_Monitoring_Tool::m_IntLum
private

Definition at line 469 of file TRT_Monitoring_Tool.h.

◆ m_isCosmics

bool TRT_Monitoring_Tool::m_isCosmics
private

Definition at line 577 of file TRT_Monitoring_Tool.h.

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 922 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 923 of file ManagedMonitorToolBase.h.

◆ m_lastTRTLumiBlock

int TRT_Monitoring_Tool::m_lastTRTLumiBlock
private

Definition at line 75 of file TRT_Monitoring_Tool.h.

◆ m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> ManagedMonitorToolBase::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
privateinherited

Definition at line 951 of file ManagedMonitorToolBase.h.

◆ m_LBvsLum

TH1F_LW* TRT_Monitoring_Tool::m_LBvsLum
private

Definition at line 470 of file TRT_Monitoring_Tool.h.

◆ m_LBvsTime

TH1F_LW* TRT_Monitoring_Tool::m_LBvsTime
private

Definition at line 471 of file TRT_Monitoring_Tool.h.

◆ m_LE_timeWindow_MAX

int TRT_Monitoring_Tool::m_LE_timeWindow_MAX
private

Definition at line 503 of file TRT_Monitoring_Tool.h.

◆ m_LE_timeWindow_MIN

int TRT_Monitoring_Tool::m_LE_timeWindow_MIN
private

Definition at line 502 of file TRT_Monitoring_Tool.h.

◆ m_LL_timeWindow_MAX

int TRT_Monitoring_Tool::m_LL_timeWindow_MAX
private

Definition at line 506 of file TRT_Monitoring_Tool.h.

◆ m_LL_timeWindow_MIN

int TRT_Monitoring_Tool::m_LL_timeWindow_MIN
private

Definition at line 505 of file TRT_Monitoring_Tool.h.

◆ m_LLOcc

float TRT_Monitoring_Tool::m_LLOcc[2][64] {}
private

Definition at line 458 of file TRT_Monitoring_Tool.h.

◆ m_longToTCut

float TRT_Monitoring_Tool::m_longToTCut
private

Definition at line 573 of file TRT_Monitoring_Tool.h.

◆ m_LonTrack_B

float TRT_Monitoring_Tool::m_LonTrack_B[32]
private

Definition at line 474 of file TRT_Monitoring_Tool.h.

◆ m_LonTrack_E

float TRT_Monitoring_Tool::m_LonTrack_E[64]
private

Definition at line 480 of file TRT_Monitoring_Tool.h.

◆ m_lumiBlocksToResetOcc

int TRT_Monitoring_Tool::m_lumiBlocksToResetOcc
private

Definition at line 576 of file TRT_Monitoring_Tool.h.

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> ManagedMonitorToolBase::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
privateinherited

Definition at line 949 of file ManagedMonitorToolBase.h.

◆ m_lwhists

std::set<LWHist*> ManagedMonitorToolBase::m_lwhists
protectedinherited

Definition at line 891 of file ManagedMonitorToolBase.h.

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 892 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

◆ m_mapPath

std::string TRT_Monitoring_Tool::m_mapPath
private

Definition at line 176 of file TRT_Monitoring_Tool.h.

◆ m_mat_chip_B

unsigned char TRT_Monitoring_Tool::m_mat_chip_B[64][1642] {}
private

Definition at line 519 of file TRT_Monitoring_Tool.h.

◆ m_mat_chip_E

unsigned char TRT_Monitoring_Tool::m_mat_chip_E[64][3840] {}
private

Definition at line 522 of file TRT_Monitoring_Tool.h.

◆ m_max_abs_d0

float TRT_Monitoring_Tool::m_max_abs_d0
private

Definition at line 588 of file TRT_Monitoring_Tool.h.

◆ m_max_abs_eta

float TRT_Monitoring_Tool::m_max_abs_eta
private

Definition at line 591 of file TRT_Monitoring_Tool.h.

◆ m_max_abs_z0

float TRT_Monitoring_Tool::m_max_abs_z0
private

Definition at line 589 of file TRT_Monitoring_Tool.h.

◆ m_maxDistToStraw

float TRT_Monitoring_Tool::m_maxDistToStraw
private

Definition at line 567 of file TRT_Monitoring_Tool.h.

◆ m_maxtimestamp

std::atomic<int> TRT_Monitoring_Tool::m_maxtimestamp {0}
mutableprivate

Definition at line 608 of file TRT_Monitoring_Tool.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 889 of file ManagedMonitorToolBase.h.

◆ m_mgr

const InDetDD::TRT_DetectorManager* TRT_Monitoring_Tool::m_mgr
private

Definition at line 173 of file TRT_Monitoring_Tool.h.

◆ m_MIN_N_LL_Hits

int TRT_Monitoring_Tool::m_MIN_N_LL_Hits
private

Definition at line 512 of file TRT_Monitoring_Tool.h.

◆ m_min_pixel_hits

int TRT_Monitoring_Tool::m_min_pixel_hits
private

Definition at line 594 of file TRT_Monitoring_Tool.h.

◆ m_min_pT

float TRT_Monitoring_Tool::m_min_pT
private

Definition at line 590 of file TRT_Monitoring_Tool.h.

◆ m_min_sct_hits

int TRT_Monitoring_Tool::m_min_sct_hits
private

Definition at line 595 of file TRT_Monitoring_Tool.h.

◆ m_min_si_hits

int TRT_Monitoring_Tool::m_min_si_hits
private

Definition at line 593 of file TRT_Monitoring_Tool.h.

◆ m_MIN_TOT_Hits

int TRT_Monitoring_Tool::m_MIN_TOT_Hits
private

Definition at line 513 of file TRT_Monitoring_Tool.h.

◆ m_min_tracks_straw

int TRT_Monitoring_Tool::m_min_tracks_straw
private

Definition at line 603 of file TRT_Monitoring_Tool.h.

◆ m_min_trt_hits

int TRT_Monitoring_Tool::m_min_trt_hits
private

Definition at line 596 of file TRT_Monitoring_Tool.h.

◆ m_minP

float TRT_Monitoring_Tool::m_minP
private

Definition at line 579 of file TRT_Monitoring_Tool.h.

◆ m_minTRThits

int TRT_Monitoring_Tool::m_minTRThits
private

Definition at line 578 of file TRT_Monitoring_Tool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 926 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 927 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 884 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_nHitsperLB_B

int TRT_Monitoring_Tool::m_nHitsperLB_B
private

Definition at line 543 of file TRT_Monitoring_Tool.h.

◆ m_nHitsperLB_E

int TRT_Monitoring_Tool::m_nHitsperLB_E[2] {}
private

Definition at line 564 of file TRT_Monitoring_Tool.h.

◆ m_nHLHitsperLB_B

int TRT_Monitoring_Tool::m_nHLHitsperLB_B
private

Definition at line 544 of file TRT_Monitoring_Tool.h.

◆ m_nHLHitsperLB_E

int TRT_Monitoring_Tool::m_nHLHitsperLB_E[2] {}
private

Definition at line 565 of file TRT_Monitoring_Tool.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 928 of file ManagedMonitorToolBase.h.

◆ m_NoiseSuppressionLevel_30pc

bool TRT_Monitoring_Tool::m_NoiseSuppressionLevel_30pc
private

Definition at line 511 of file TRT_Monitoring_Tool.h.

◆ m_NoiseSuppressionMap

bool TRT_Monitoring_Tool::m_NoiseSuppressionMap
private

Definition at line 514 of file TRT_Monitoring_Tool.h.

◆ m_nphi_bins

int TRT_Monitoring_Tool::m_nphi_bins
private

Definition at line 574 of file TRT_Monitoring_Tool.h.

◆ m_nStrawHits_B

int TRT_Monitoring_Tool::m_nStrawHits_B[1642]
private

Definition at line 520 of file TRT_Monitoring_Tool.h.

◆ m_nStrawHits_E

int TRT_Monitoring_Tool::m_nStrawHits_E[2][3840]
private

Definition at line 523 of file TRT_Monitoring_Tool.h.

◆ m_nTotalTracks

int TRT_Monitoring_Tool::m_nTotalTracks
private

Definition at line 78 of file TRT_Monitoring_Tool.h.

◆ m_nTrack_B

int TRT_Monitoring_Tool::m_nTrack_B[32]
private

Definition at line 475 of file TRT_Monitoring_Tool.h.

◆ m_nTrack_E

int TRT_Monitoring_Tool::m_nTrack_E[64]
private

Definition at line 481 of file TRT_Monitoring_Tool.h.

◆ m_nTracksB

int TRT_Monitoring_Tool::m_nTracksB[2] {}
private

Definition at line 79 of file TRT_Monitoring_Tool.h.

◆ m_nTracksEC

int TRT_Monitoring_Tool::m_nTracksEC[2] {}
private

Definition at line 80 of file TRT_Monitoring_Tool.h.

◆ m_nTracksEC_B

int TRT_Monitoring_Tool::m_nTracksEC_B[2] {}
private

Definition at line 81 of file TRT_Monitoring_Tool.h.

◆ m_nTrksperLB_B

int TRT_Monitoring_Tool::m_nTrksperLB_B
private

Definition at line 542 of file TRT_Monitoring_Tool.h.

◆ m_nTrksperLB_E

int TRT_Monitoring_Tool::m_nTrksperLB_E[2] {}
private

Definition at line 563 of file TRT_Monitoring_Tool.h.

◆ m_nTRTHits

int TRT_Monitoring_Tool::m_nTRTHits[2]
private

Definition at line 487 of file TRT_Monitoring_Tool.h.

◆ m_NumSwLLWoTScale_B

float TRT_Monitoring_Tool::m_NumSwLLWoTScale_B
private

Definition at line 530 of file TRT_Monitoring_Tool.h.

◆ m_NumSwLLWoTScale_E

float TRT_Monitoring_Tool::m_NumSwLLWoTScale_E[2]
private

Definition at line 551 of file TRT_Monitoring_Tool.h.

◆ m_passEventBurst

bool TRT_Monitoring_Tool::m_passEventBurst
private

Definition at line 83 of file TRT_Monitoring_Tool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 915 of file ManagedMonitorToolBase.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 916 of file ManagedMonitorToolBase.h.

◆ m_printEventInfo

bool TRT_Monitoring_Tool::m_printEventInfo = false
private

Definition at line 572 of file TRT_Monitoring_Tool.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 914 of file ManagedMonitorToolBase.h.

◆ m_pTRTHelper

const TRT_ID* TRT_Monitoring_Tool::m_pTRTHelper
private

Definition at line 172 of file TRT_Monitoring_Tool.h.

◆ m_Pull_Biased_Barrel

TH1F_LW* TRT_Monitoring_Tool::m_Pull_Biased_Barrel
private

Definition at line 193 of file TRT_Monitoring_Tool.h.

◆ m_Pull_Biased_EndCap

TH1F_LW* TRT_Monitoring_Tool::m_Pull_Biased_EndCap
private

Definition at line 227 of file TRT_Monitoring_Tool.h.

◆ m_rdoContainerKey

SG::ReadHandleKey<TRT_RDO_Container> TRT_Monitoring_Tool::m_rdoContainerKey {this, "TRTRawDataObjectName", "TRT_RDOs", "Name of TRT RDOs container"}
private

Definition at line 155 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_B

float TRT_Monitoring_Tool::m_ResidualScale_B
private

Definition at line 534 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_B_20GeV

float TRT_Monitoring_Tool::m_ResidualScale_B_20GeV
private

Definition at line 535 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_B_Ar

float TRT_Monitoring_Tool::m_ResidualScale_B_Ar
private

Definition at line 539 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_B_Ar_20GeV

float TRT_Monitoring_Tool::m_ResidualScale_B_Ar_20GeV
private

Definition at line 540 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_E

float TRT_Monitoring_Tool::m_ResidualScale_E[2]
private

Definition at line 555 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_E_20GeV

float TRT_Monitoring_Tool::m_ResidualScale_E_20GeV[2]
private

Definition at line 556 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_E_Ar

float TRT_Monitoring_Tool::m_ResidualScale_E_Ar[2]
private

Definition at line 560 of file TRT_Monitoring_Tool.h.

◆ m_ResidualScale_E_Ar_20GeV

float TRT_Monitoring_Tool::m_ResidualScale_E_Ar_20GeV[2]
private

Definition at line 561 of file TRT_Monitoring_Tool.h.

◆ m_rodMap

std::vector<unsigned int> TRT_Monitoring_Tool::m_rodMap
private

Definition at line 82 of file TRT_Monitoring_Tool.h.

◆ m_scale_hHitWMap_B

std::vector<float> TRT_Monitoring_Tool::m_scale_hHitWMap_B
private

Definition at line 455 of file TRT_Monitoring_Tool.h.

◆ m_scale_hHitWMap_B_Ar

std::vector<float> TRT_Monitoring_Tool::m_scale_hHitWMap_B_Ar
private

Definition at line 456 of file TRT_Monitoring_Tool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 904 of file ManagedMonitorToolBase.h.

◆ m_sumTool

ToolHandle<ITRT_StrawStatusSummaryTool> TRT_Monitoring_Tool::m_sumTool
private

Definition at line 148 of file TRT_Monitoring_Tool.h.

◆ m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking
privateinherited

Definition at line 959 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

std::map< Interval_t, std::vector< MgmtParams<TEfficiency> > > ManagedMonitorToolBase::m_templateEfficiencies
protectedinherited

Definition at line 738 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

std::map< Interval_t, std::vector< MgmtParams<TGraph> > > ManagedMonitorToolBase::m_templateGraphs
protectedinherited

Definition at line 726 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

std::map< Interval_t, std::vector< MgmtParams<TH1> > > ManagedMonitorToolBase::m_templateHistograms
protectedinherited

Definition at line 722 of file ManagedMonitorToolBase.h.

◆ m_templateLWHistograms

std::map< Interval_t, std::vector< MgmtParams<LWHist> > > ManagedMonitorToolBase::m_templateLWHistograms
protectedinherited

Definition at line 734 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

std::map< Interval_t, std::vector< MgmtParams<TTree> > > ManagedMonitorToolBase::m_templateTrees
protectedinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 906 of file ManagedMonitorToolBase.h.

◆ m_TimeResidualScale_B

float TRT_Monitoring_Tool::m_TimeResidualScale_B
private

Definition at line 536 of file TRT_Monitoring_Tool.h.

◆ m_TimeResidualScale_B_Ar

float TRT_Monitoring_Tool::m_TimeResidualScale_B_Ar
private

Definition at line 541 of file TRT_Monitoring_Tool.h.

◆ m_TimeResidualScale_E

float TRT_Monitoring_Tool::m_TimeResidualScale_E[2]
private

Definition at line 557 of file TRT_Monitoring_Tool.h.

◆ m_TimeResidualScale_E_Ar

float TRT_Monitoring_Tool::m_TimeResidualScale_E_Ar[2]
private

Definition at line 562 of file TRT_Monitoring_Tool.h.

◆ m_totalEvents

int TRT_Monitoring_Tool::m_totalEvents
private

Definition at line 488 of file TRT_Monitoring_Tool.h.

◆ m_track_collection_hole_finder

std::string TRT_Monitoring_Tool::m_track_collection_hole_finder
private

Definition at line 587 of file TRT_Monitoring_Tool.h.

◆ m_track_d0

float TRT_Monitoring_Tool::m_track_d0
private

Definition at line 601 of file TRT_Monitoring_Tool.h.

◆ m_track_eta

float TRT_Monitoring_Tool::m_track_eta
private

Definition at line 599 of file TRT_Monitoring_Tool.h.

◆ m_track_phi

float TRT_Monitoring_Tool::m_track_phi
private

Definition at line 600 of file TRT_Monitoring_Tool.h.

◆ m_track_pt

float TRT_Monitoring_Tool::m_track_pt
private

Definition at line 598 of file TRT_Monitoring_Tool.h.

◆ m_track_z0

float TRT_Monitoring_Tool::m_track_z0
private

Definition at line 602 of file TRT_Monitoring_Tool.h.

◆ m_trackCollectionKey

SG::ReadHandleKey<TrackCollection> TRT_Monitoring_Tool::m_trackCollectionKey {this, "TRTTracksObjectName", "Tracks", "Name of tracks container"}
private

Definition at line 156 of file TRT_Monitoring_Tool.h.

◆ m_trackr_All

TH1F_LW* TRT_Monitoring_Tool::m_trackr_All[4][2] {}
private

Definition at line 467 of file TRT_Monitoring_Tool.h.

◆ m_trackr_HT

TH1F_LW* TRT_Monitoring_Tool::m_trackr_HT[4][2] {}
private

Definition at line 468 of file TRT_Monitoring_Tool.h.

◆ m_TrackSummaryTool

ToolHandle<Trk::ITrackSummaryTool> TRT_Monitoring_Tool::m_TrackSummaryTool {this, "TrkSummaryTool", "Trk::TrackSummaryTool/InDetTrackSummaryTool", "Track summary tool name"}
private

Definition at line 168 of file TRT_Monitoring_Tool.h.

◆ m_trackz_All

TH1F_LW* TRT_Monitoring_Tool::m_trackz_All[5][2] {}
private

Initialize Aging plots** HT, All, Barrel, EC, In/A, Out/C, etc...

Definition at line 464 of file TRT_Monitoring_Tool.h.

◆ m_trackz_HT

TH1F_LW* TRT_Monitoring_Tool::m_trackz_HT[5][2] {}
private

Definition at line 465 of file TRT_Monitoring_Tool.h.

◆ m_trigDecisionKey

SG::ReadHandleKey<xAOD::TrigDecision> TRT_Monitoring_Tool::m_trigDecisionKey {this, "TrigDecisionObjectName", "xTrigDecision", "Name of trigger decision object"}
private

Definition at line 162 of file TRT_Monitoring_Tool.h.

◆ m_trigDecTool

PublicToolHandle<Trig::ITrigDecisionTool> ManagedMonitorToolBase::m_trigDecTool {this, "TrigDecisionTool",""}
protectedinherited

Definition at line 908 of file ManagedMonitorToolBase.h.

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 917 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 918 of file ManagedMonitorToolBase.h.

◆ m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> ManagedMonitorToolBase::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
privateinherited

Definition at line 953 of file ManagedMonitorToolBase.h.

◆ m_trigTranslator

PublicToolHandle<ITriggerTranslatorTool> ManagedMonitorToolBase::m_trigTranslator {this,"TriggerTranslatorTool",""}
protectedinherited

Definition at line 910 of file ManagedMonitorToolBase.h.

◆ m_TronTDistScale_B

float TRT_Monitoring_Tool::m_TronTDistScale_B
private

Definition at line 533 of file TRT_Monitoring_Tool.h.

◆ m_TronTDistScale_B_Ar

float TRT_Monitoring_Tool::m_TronTDistScale_B_Ar
private

Definition at line 538 of file TRT_Monitoring_Tool.h.

◆ m_TronTDistScale_E

float TRT_Monitoring_Tool::m_TronTDistScale_E[2]
private

Definition at line 554 of file TRT_Monitoring_Tool.h.

◆ m_TronTDistScale_E_Ar

float TRT_Monitoring_Tool::m_TronTDistScale_E_Ar[2] {}
private

Definition at line 559 of file TRT_Monitoring_Tool.h.

◆ m_TRT_BCIDCollectionKey

SG::ReadHandleKey<InDetTimeCollection> TRT_Monitoring_Tool::m_TRT_BCIDCollectionKey {this, "TRTBCIDCollectionName", "TRT_BCID", "Name of TRT BCID collection"}
private

Definition at line 160 of file TRT_Monitoring_Tool.h.

◆ m_trt_hole_finder

ToolHandle<Trk::ITrackHoleSearchTool> TRT_Monitoring_Tool::m_trt_hole_finder {this, "trt_hole_search", "TRTTrackHoleSearchTool", "Track hole search tool name"}
private

Definition at line 169 of file TRT_Monitoring_Tool.h.

◆ m_trt_only_trks

bool TRT_Monitoring_Tool::m_trt_only_trks
private

Definition at line 569 of file TRT_Monitoring_Tool.h.

◆ m_TRTCalDbTool

ToolHandle<ITRT_CalDbTool> TRT_Monitoring_Tool::m_TRTCalDbTool
private

Definition at line 152 of file TRT_Monitoring_Tool.h.

◆ m_TRTStrawNeighbourSvc

ServiceHandle<ITRT_StrawNeighbourSvc> TRT_Monitoring_Tool::m_TRTStrawNeighbourSvc
private

Definition at line 151 of file TRT_Monitoring_Tool.h.

◆ m_usedEvents

int TRT_Monitoring_Tool::m_usedEvents
private

Definition at line 486 of file TRT_Monitoring_Tool.h.

◆ m_useHoleFinder

bool TRT_Monitoring_Tool::m_useHoleFinder
private

Definition at line 500 of file TRT_Monitoring_Tool.h.

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 957 of file ManagedMonitorToolBase.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 920 of file ManagedMonitorToolBase.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigChainNames
protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigGroupNames
protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

◆ m_WireToTrkPositionScale_B

float TRT_Monitoring_Tool::m_WireToTrkPositionScale_B
private

Definition at line 531 of file TRT_Monitoring_Tool.h.

◆ m_WireToTrkPositionScale_B_Ar

float TRT_Monitoring_Tool::m_WireToTrkPositionScale_B_Ar
private

Definition at line 532 of file TRT_Monitoring_Tool.h.

◆ m_WireToTrkPositionScale_E

float TRT_Monitoring_Tool::m_WireToTrkPositionScale_E[2]
private

Definition at line 552 of file TRT_Monitoring_Tool.h.

◆ m_WireToTrkPositionScale_E_Ar

float TRT_Monitoring_Tool::m_WireToTrkPositionScale_E_Ar[2]
private

Definition at line 553 of file TRT_Monitoring_Tool.h.

◆ m_xAODEventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TRT_Monitoring_Tool::m_xAODEventInfoKey {this, "xAODEventInfo", "EventInfo", "Name of EventInfo object"}
private

Definition at line 159 of file TRT_Monitoring_Tool.h.

◆ m_zero_field

bool TRT_Monitoring_Tool::m_zero_field
private

Definition at line 570 of file TRT_Monitoring_Tool.h.

◆ p_toolSvc

ServiceHandle<IToolSvc> TRT_Monitoring_Tool::p_toolSvc
private

Definition at line 147 of file TRT_Monitoring_Tool.h.

◆ s_iChip_max

const int TRT_Monitoring_Tool::s_iChip_max = {104, 240}
staticprivate

Definition at line 142 of file TRT_Monitoring_Tool.h.

◆ s_iStack_max

const int TRT_Monitoring_Tool::s_iStack_max = {32, 64}
staticprivate

Definition at line 141 of file TRT_Monitoring_Tool.h.

◆ s_moduleNum

const int TRT_Monitoring_Tool::s_moduleNum = {96, 64}
staticprivate

Definition at line 144 of file TRT_Monitoring_Tool.h.

◆ s_numberOfBarrelStacks

const int TRT_Monitoring_Tool::s_numberOfBarrelStacks = 32
staticprivate

Definition at line 137 of file TRT_Monitoring_Tool.h.

◆ s_numberOfEndCapStacks

const int TRT_Monitoring_Tool::s_numberOfEndCapStacks = 32
staticprivate

Definition at line 138 of file TRT_Monitoring_Tool.h.

◆ s_numberOfStacks

const int TRT_Monitoring_Tool::s_numberOfStacks = {32, 32}
staticprivate

Definition at line 143 of file TRT_Monitoring_Tool.h.

◆ s_Straw_max

const int TRT_Monitoring_Tool::s_Straw_max = {1642, 3840}
staticprivate

Definition at line 140 of file TRT_Monitoring_Tool.h.

The documentation for this class was generated from the following files:
TRT_Monitoring_Tool::m_usedEvents
int m_usedEvents
Definition: TRT_Monitoring_Tool.h:486
AthenaMonManager::ownedLWHistOfKey
virtual LWHist * ownedLWHistOfKey(const std::string &key) const
Definition: AthenaMonManager.cxx:726
TH2F_LW::Fill
virtual void Fill(const double &x, const double &y) override
Definition: TH2F_LW.cxx:329
ManagedMonitorToolBase::m_nEvents
unsigned int m_nEvents
Definition: ManagedMonitorToolBase.h:926
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TRT_Monitoring_Tool::m_ArgonXenonSplitter
bool m_ArgonXenonSplitter
Definition: TRT_Monitoring_Tool.h:84
TRT_Monitoring_Tool::Straw_Gastype
GasType Straw_Gastype(int stat)
Definition: TRT_Monitoring_Tool.h:633
TRT_Monitoring_Tool::m_HL_timeWindow_MIN
int m_HL_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:508
LWHist
Definition: LWHist.h:26
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E
float m_HtoLRatioOnTrackScale_E[2]
Definition: TRT_Monitoring_Tool.h:548
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Xe
TH1F_LW * m_hHtoLRatioOnTrack_B_Xe
Definition: TRT_Monitoring_Tool.h:203
TRT_Monitoring_Tool::bookTProfile
TProfile * bookTProfile(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4443
TRT_Monitoring_Tool::m_mat_chip_E
unsigned char m_mat_chip_E[64][3840]
Definition: TRT_Monitoring_Tool.h:522
TRT_Monitoring_Tool::m_hTronTDist_B_Ar
TH1F_LW * m_hTronTDist_B_Ar
Definition: TRT_Monitoring_Tool.h:212
ManagedMonitorToolBase::THistSvc_deReg_fixTGraph
StatusCode THistSvc_deReg_fixTGraph(TFile *file, TGraph *theGraph, std::string &directoryName)
Fixes THistSvc->deReg(obj) when obj is TGraph instance.
Definition: ManagedMonitorToolBase.cxx:1098
TRT_Monitoring_Tool::bookTProfile_LW
TProfile_LW * bookTProfile_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4458
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition: ManagedMonitorToolBase.h:738
AthenaMonManager::writeAndDeleteLWHist
virtual LWHist * writeAndDeleteLWHist(const std::string &key, const std::string &streamName)
Definition: AthenaMonManager.cxx:743
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition: ManagedMonitorToolBase.cxx:503
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
ManagedMonitorToolBase::m_newRun
bool m_newRun
Definition: ManagedMonitorToolBase.h:883
TRT_Monitoring_Tool::m_ResidualScale_B_20GeV
float m_ResidualScale_B_20GeV
Definition: TRT_Monitoring_Tool.h:535
TRT_Monitoring_Tool::m_hHitHonTMapC
TH1F_LW * m_hHitHonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:423
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition: ManagedMonitorToolBase.h:959
TRT_ID::layer_id
Identifier layer_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer) const
For an individual straw layer.
Definition: TRT_ID.h:500
defineDB.smd
string smd
Definition: JetTagCalibration/share/defineDB.py:44
TRT_BSErrContainer::getMissingErrorSet
const std::set< uint32_t > & getMissingErrorSet(void) const
Definition: TRT_BSErrContainer.h:33
lastBinHigh
bool lastBinHigh(unsigned int m_word)
Definition: driftCircle.h:108
TRT_Monitoring_Tool::m_hHitAonTMapS
TH1F_LW * m_hHitAonTMapS[2][64]
Any LL bit on track: Straws Any low level bit is set from hit associated with a track.
Definition: TRT_Monitoring_Tool.h:357
ForwardTracker::Side
Side
Definition: ForwardTrackerConstants.h:13
TRT_Monitoring_Tool::m_nTRTHits
int m_nTRTHits[2]
Definition: TRT_Monitoring_Tool.h:487
ymin
double ymin
Definition: listroot.cxx:63
TRT_Monitoring_Tool::bookTRTRDOs
StatusCode bookTRTRDOs(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:657
ManagedMonitorToolBase::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: ManagedMonitorToolBase.cxx:1407
ManagedMonitorToolBase::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Definition: ManagedMonitorToolBase.h:912
TRT_Monitoring_Tool::m_hHitsOnTrack_Scatter
TH2F_LW * m_hHitsOnTrack_Scatter[2]
Anatoli's "Scatter histograms" ** Monitor quantities as a function of lumi block.
Definition: TRT_Monitoring_Tool.h:450
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TRT_Monitoring_Tool::m_hHtoLMapC
TH1F_LW * m_hHtoLMapC[2][64]
Definition: TRT_Monitoring_Tool.h:406
checkFileSG.line
line
Definition: checkFileSG.py:75
TRT_Monitoring_Tool::m_nHLHitsperLB_E
int m_nHLHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:565
TRT_Monitoring_Tool::m_trackr_All
TH1F_LW * m_trackr_All[4][2]
Definition: TRT_Monitoring_Tool.h:467
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E_Ar
TProfile_LW * m_hAvgTroTDetPhi_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:222
ManagedMonitorToolBase::getHist
virtual StatusCode getHist(TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
Returns a TH1 via the pointer passed as the first argument.
Definition: ManagedMonitorToolBase.cxx:1589
TRT::Hit::straw
@ straw
Definition: HitInfo.h:82
InDet::TRT_DriftCircleOnTrack::prepRawData
virtual const TRT_DriftCircle * prepRawData() const override final
returns the PrepRawData - is a TRT_DriftCircle in this scope
Definition: TRT_DriftCircleOnTrack.h:202
ManagedMonitorToolBase::m_newEventsBlock
bool m_newEventsBlock
Definition: ManagedMonitorToolBase.h:884
TRT_Monitoring_Tool::m_min_trt_hits
int m_min_trt_hits
Definition: TRT_Monitoring_Tool.h:596
TRT_Monitoring_Tool::m_min_si_hits
int m_min_si_hits
Definition: TRT_Monitoring_Tool.h:593
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E
TH1F_LW * m_hHtoLRatioOnTrack_E[2]
Definition: TRT_Monitoring_Tool.h:235
TRT_Monitoring_Tool::bookTH2F_LW
TH2F_LW * bookTH2F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int xbins, double lowxbins, double highxbins, int ybins, double lowybins, double highybins, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4473
TRT_Monitoring_Tool::fillTRTHighThreshold
StatusCode fillTRTHighThreshold(const TrackCollection &trackCollection, const xAOD::EventInfo &eventInfo)
Definition: TRT_Monitoring_Tool.cxx:3807
TRT_Monitoring_Tool::m_hStrawOcc
TH1F_LW * m_hStrawOcc[2][64]
Definition: TRT_Monitoring_Tool.h:445
TRT_Monitoring_Tool::m_TRTStrawNeighbourSvc
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
Definition: TRT_Monitoring_Tool.h:151
ManagedMonitorToolBase::Imp::benchPreProcHistograms
void benchPreProcHistograms()
Definition: ManagedMonitorToolBase.cxx:122
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TH1D_LW::create
static TH1D_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1D_LW.cxx:33
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Ar
TH1F_LW * m_hHtoLRatioOnTrack_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:236
TRT_Monitoring_Tool::m_hHitTrMapC
TProfile_LW * m_hHitTrMapC[2][64]
Definition: TRT_Monitoring_Tool.h:402
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
TRT_Monitoring_Tool::m_hHitWMapC
TH1F_LW * m_hHitWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:401
TRT_Monitoring_Tool::m_nTrack_E
int m_nTrack_E[64]
Definition: TRT_Monitoring_Tool.h:481
TRT_Monitoring_Tool::m_isCosmics
bool m_isCosmics
Definition: TRT_Monitoring_Tool.h:577
TH1F_LW::Fill
virtual void Fill(const double &x) override
Definition: TH1F_LW.cxx:246
TRT_Monitoring_Tool::chipToBoard_EndCap
static int chipToBoard_EndCap(int chip)
Definition: TRT_Monitoring_Tool.cxx:4334
TRT_Monitoring_Tool::m_min_tracks_straw
int m_min_tracks_straw
Definition: TRT_Monitoring_Tool.h:603
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B_Ar
TH1F_LW * m_hDriftTimeonTrkDist_B_Ar
Definition: TRT_Monitoring_Tool.h:211
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TRT_Monitoring_Tool::m_hHitWMap_B
TH1F_LW * m_hHitWMap_B
Definition: TRT_Monitoring_Tool.h:191
Trk::locX
@ locX
Definition: ParamDefs.h:43
TRT_Monitoring_Tool::p_toolSvc
ServiceHandle< IToolSvc > p_toolSvc
Definition: TRT_Monitoring_Tool.h:147
TRT_Monitoring_Tool::m_DAQSvc
ServiceHandle< ITRT_DAQ_ConditionsSvc > m_DAQSvc
Definition: TRT_Monitoring_Tool.h:149
ComTime::getTime
double getTime() const
Definition: ComTime.h:44
TRT_Monitoring_Tool::m_hHitTronTMapS
TProfile_LW * m_hHitTronTMapS[2][64]
Mean TE on track: Straws Average Trailing Edge(TE) from a hit associated with a track.
Definition: TRT_Monitoring_Tool.h:351
TRT_Monitoring_Tool::m_sumTool
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
Definition: TRT_Monitoring_Tool.h:148
TRT_Monitoring_Tool::fillTRTEfficiency
StatusCode fillTRTEfficiency(const TrackCollection &combTrackCollection)
Definition: TRT_Monitoring_Tool.cxx:3533
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ManagedMonitorToolBase::higStat
@ higStat
Definition: ManagedMonitorToolBase.h:115
TRT_Monitoring_Tool::m_hStrawEffDetPhi_B
TProfile_LW * m_hStrawEffDetPhi_B
Definition: TRT_Monitoring_Tool.h:190
TRT_Monitoring_Tool::m_hHitToTMapS
TProfile_LW * m_hHitToTMapS[2][64]
Mean ToT (ns): Straws.
Definition: TRT_Monitoring_Tool.h:310
TRT_Monitoring_Tool::s_numberOfEndCapStacks
static const int s_numberOfEndCapStacks
Definition: TRT_Monitoring_Tool.h:138
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:114
TRT_LoLumRawData::highLevel
virtual bool highLevel() const override final
Definition: TRT_LoLumRawData.h:128
TRT_Monitoring_Tool::m_hHitTronTMapC
TProfile_LW * m_hHitTronTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:420
TRT_Monitoring_Tool::m_hefficiencyIntegral
TH1F_LW * m_hefficiencyIntegral[2][2]
Definition: TRT_Monitoring_Tool.h:623
TH1F_LW::create
static TH1F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1F_LW.cxx:33
ManagedMonitorToolBase::m_endOfLumiBlock
bool m_endOfLumiBlock
Definition: ManagedMonitorToolBase.h:885
TRT_Monitoring_Tool::m_doASide
bool m_doASide
Definition: TRT_Monitoring_Tool.h:491
TRT_LoLumRawData::lastBinHigh
bool lastBinHigh() const
Definition: TRT_LoLumRawData.h:165
TRT_Monitoring_Tool::m_minTRThits
int m_minTRThits
Definition: TRT_Monitoring_Tool.h:578
TRT_Monitoring_Tool::m_hNumHoTDetPhi_B
TProfile_LW * m_hNumHoTDetPhi_B
Definition: TRT_Monitoring_Tool.h:186
TRT_Monitoring_Tool::m_nTracksB
int m_nTracksB[2]
Definition: TRT_Monitoring_Tool.h:79
TRT_Monitoring_Tool::chipToBoard
static int chipToBoard(int chip)
Definition: TRT_Monitoring_Tool.cxx:4305
TRT_Monitoring_Tool::m_LL_timeWindow_MIN
int m_LL_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:505
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TRT_LoLumRawData
Definition: TRT_LoLumRawData.h:25
index
Definition: index.py:1
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition: ManagedMonitorToolBase.h:906
ManagedMonitorToolBase::m_procNEventsProp
long m_procNEventsProp
Definition: ManagedMonitorToolBase.h:914
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
TRT_Monitoring_Tool::m_doDCS
bool m_doDCS
Definition: TRT_Monitoring_Tool.h:490
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TRT_Monitoring_Tool::m_nphi_bins
int m_nphi_bins
Definition: TRT_Monitoring_Tool.h:574
TRT_Monitoring_Tool::m_hHitWMap_E
TH1F_LW * m_hHitWMap_E[2]
Definition: TRT_Monitoring_Tool.h:225
AthenaMonManager::writeAndResetLWHist
virtual LWHist * writeAndResetLWHist(const std::string &key, const std::string &streamName)
Definition: AthenaMonManager.cxx:802
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
ManagedMonitorToolBase::regTree
virtual StatusCode regTree(TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TTree to be included in the output stream using logical parameters that describe it.
Definition: ManagedMonitorToolBase.cxx:1749
TRT_Monitoring_Tool::m_hHitTrWMapS
TProfile_LW * m_hHitTrWMapS[2][64]
TE in Time Window: Straws.
Definition: TRT_Monitoring_Tool.h:276
InDetDD::TRT_DetectorManager::getBarrelElement
const TRT_BarrelElement * getBarrelElement(unsigned int positive, unsigned int moduleIndex, unsigned int phiIndex, unsigned int strawLayerIndex) const
Access Barrel Elements:---------------—(Fast)-------------------------—.
Definition: TRT_DetectorManager.cxx:113
TRT_Monitoring_Tool::bookTRTEfficiency
StatusCode bookTRTEfficiency(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:893
TRT_Monitoring_Tool::m_ResidualScale_E_Ar_20GeV
float m_ResidualScale_E_Ar_20GeV[2]
Definition: TRT_Monitoring_Tool.h:561
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
ManagedMonitorToolBase::endOfLumiBlockFlag
bool endOfLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:858
TRT_Monitoring_Tool::m_nTrksperLB_E
int m_nTrksperLB_E[2]
Definition: TRT_Monitoring_Tool.h:563
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B
float m_DriftTimeonTrkDistScale_B
Definition: TRT_Monitoring_Tool.h:525
TRT_Monitoring_Tool::m_drifttool
ToolHandle< ITRT_DriftFunctionTool > m_drifttool
Definition: TRT_Monitoring_Tool.h:170
AthenaMonManager::runNumber
static unsigned int runNumber()
Definition: AthenaMonManager.cxx:364
TRT_ID::straw_layer_hash_max
size_type straw_layer_hash_max(void) const
Definition: TRT_ID.h:920
InDet::TRT_DriftCircle::timeOverThreshold
double timeOverThreshold() const
returns Time over threshold in ns
plotmaker.hist
hist
Definition: plotmaker.py:148
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:699
TRT_Monitoring_Tool::s_iStack_max
static const int s_iStack_max[2]
Definition: TRT_Monitoring_Tool.h:141
InDetDD::TRT_BaseElement::nStraws
unsigned int nStraws() const
Number of straws in the element.
TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrk
TProfile_LW * m_hValidRawDriftTimeonTrk[2][64]
Valid Raw Drift Time on Track.
Definition: TRT_Monitoring_Tool.h:399
TRT_Monitoring_Tool::m_good_bcid
int m_good_bcid
Definition: TRT_Monitoring_Tool.h:77
ManagedMonitorToolBase::Imp::benchPreFillHistograms
void benchPreFillHistograms()
Definition: ManagedMonitorToolBase.cxx:97
Trk::Surface::associatedDetectorElementIdentifier
Identifier associatedDetectorElementIdentifier() const
return Identifier of the associated Detector Element
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E
TH1F_LW * m_hDriftTimeonTrkDist_E[2]
Definition: TRT_Monitoring_Tool.h:231
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition: ManagedMonitorToolBase.cxx:1130
TRT_Monitoring_Tool::m_hefficiency_z0
TProfile_LW * m_hefficiency_z0
Definition: TRT_Monitoring_Tool.h:613
AthenaMonManager::passOwnership
virtual void passOwnership(TObject *h, const std::string &key)
Pass ownership of a TObject/LWHist to this manager so that it will be deleted appropriately.
Definition: AthenaMonManager.cxx:707
ManagedMonitorToolBase::Imp::benchPostFillHistograms
void benchPostFillHistograms()
Definition: ManagedMonitorToolBase.cxx:106
TRT_Monitoring_Tool::m_Pull_Biased_Barrel
TH1F_LW * m_Pull_Biased_Barrel
Definition: TRT_Monitoring_Tool.h:193
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition: ManagedMonitorToolBase.cxx:1033
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
TRT_Monitoring_Tool::m_nTracksEC
int m_nTracksEC[2]
Definition: TRT_Monitoring_Tool.h:80
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition: ManagedMonitorToolBase.cxx:2047
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition: ManagedMonitorToolBase.h:908
TRT_Monitoring_Tool::m_hResidual_E_20GeV
TH1F_LW * m_hResidual_E_20GeV[2]
Definition: TRT_Monitoring_Tool.h:229
TH1F_LW::SetBinContent
virtual void SetBinContent(unsigned bin, const double &) override
Definition: TH1F_LW.cxx:267
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
TRT_Monitoring_Tool::m_TronTDistScale_B
float m_TronTDistScale_B
Definition: TRT_Monitoring_Tool.h:533
TRT_Monitoring_Tool::m_mgr
const InDetDD::TRT_DetectorManager * m_mgr
Definition: TRT_Monitoring_Tool.h:173
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TRT_Monitoring_Tool::m_hHitAMapS
TH1F_LW * m_hHitAMapS[2][64]
Any LL bit on: Straws if any low threshold bit was set.
Definition: TRT_Monitoring_Tool.h:289
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TRT_Monitoring_Tool::m_xAODEventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_xAODEventInfoKey
Definition: TRT_Monitoring_Tool.h:159
TRT_Monitoring_Tool::m_HTfraconTrack_B
float m_HTfraconTrack_B[32]
Definition: TRT_Monitoring_Tool.h:473
TRT_Monitoring_Tool::m_hrtRelation_B
TH2F_LW * m_hrtRelation_B
Definition: TRT_Monitoring_Tool.h:199
TRT_Monitoring_Tool::m_doShift
bool m_doShift
Definition: TRT_Monitoring_Tool.h:495
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TRT_Monitoring_Tool::m_TronTDistScale_E_Ar
float m_TronTDistScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:559
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDetDD::TRT_BaseElement::strawCenter
const Amg::Vector3D & strawCenter(int straw) const
Straw Surface: Local -> global transform of the straw via integer.
Definition: TRT_BaseElement.cxx:143
TRT_Monitoring_Tool::m_nTracksEC_B
int m_nTracksEC_B[2]
Definition: TRT_Monitoring_Tool.h:81
ManagedMonitorToolBase::m_d
Imp * m_d
Definition: ManagedMonitorToolBase.h:962
ManagedMonitorToolBase::m_lastLowStatInterval
int m_lastLowStatInterval
Definition: ManagedMonitorToolBase.h:924
TRT_Monitoring_Tool::m_ResidualScale_B_Ar
float m_ResidualScale_B_Ar
Definition: TRT_Monitoring_Tool.h:539
xAOD::TrigDecision_v1::tav
const std::vector< uint32_t > & tav() const
Get the Trigger After Veto bits.
Trk::z0
@ z0
Definition: ParamDefs.h:70
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TRT_Monitoring_Tool::m_useHoleFinder
bool m_useHoleFinder
Definition: TRT_Monitoring_Tool.h:500
TRT_Monitoring_Tool::m_doDiagnostic
bool m_doDiagnostic
Definition: TRT_Monitoring_Tool.h:499
TRT_Monitoring_Tool::m_TronTDistScale_E
float m_TronTDistScale_E[2]
Definition: TRT_Monitoring_Tool.h:554
ManagedMonitorToolBase::m_triggerGroupProp
std::string m_triggerGroupProp
Definition: ManagedMonitorToolBase.h:918
TRT_Monitoring_Tool::m_LBvsTime
TH1F_LW * m_LBvsTime
Definition: TRT_Monitoring_Tool.h:471
LWHistAthMonWrapper::setStreamName
static void setStreamName(LWHist *, const std::string &streamName)
ManagedMonitorToolBase::Imp::benchPostProcHistograms
void benchPostProcHistograms()
Definition: ManagedMonitorToolBase.cxx:130
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:901
TRT_Monitoring_Tool::m_hTronTDist_B
TH1F_LW * m_hTronTDist_B
Definition: TRT_Monitoring_Tool.h:198
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Xe
TH1F_LW * m_hHtoLRatioOnTrack_E_Xe[2]
Definition: TRT_Monitoring_Tool.h:237
TRT_Monitoring_Tool::m_totalEvents
int m_totalEvents
Definition: TRT_Monitoring_Tool.h:488
TH1D_LW
Definition: TH1D_LW.h:23
TRT_Monitoring_Tool::m_maxtimestamp
std::atomic< int > m_maxtimestamp
Definition: TRT_Monitoring_Tool.h:608
TRT_Monitoring_Tool::m_HLhitOnTrackScale_E
float m_HLhitOnTrackScale_E[2]
Definition: TRT_Monitoring_Tool.h:547
TRT_Monitoring_Tool::strawLayerNumber
static int strawLayerNumber(int strawLayerNumber, int LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4258
TRT_Monitoring_Tool::m_hBCIDvsOcc
TProfile_LW * m_hBCIDvsOcc[2]
Definition: TRT_Monitoring_Tool.h:438
ManagedMonitorToolBase::regGraph
virtual StatusCode regGraph(TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TGraph to be included in the output stream using logical parameters that describe the gra...
Definition: ManagedMonitorToolBase.cxx:1693
ManagedMonitorToolBase::m_newLowStatInterval
bool m_newLowStatInterval
Definition: ManagedMonitorToolBase.h:882
TRT_Monitoring_Tool::m_hResVsDetPhi_B
TH1F_LW * m_hResVsDetPhi_B
Definition: TRT_Monitoring_Tool.h:206
TRT_Monitoring_Tool::m_TimeResidualScale_E
float m_TimeResidualScale_E[2]
Definition: TRT_Monitoring_Tool.h:557
TRT_Monitoring_Tool::m_nHitsperLB_E
int m_nHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:564
Trk::locR
@ locR
Definition: ParamDefs.h:50
ManagedMonitorToolBase::fill
@ fill
Definition: ManagedMonitorToolBase.h:116
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
TRT_Monitoring_Tool::scale_LWHistWithScaleVector
void scale_LWHistWithScaleVector(LWHist1D *hist, const std::vector< float > &scale)
Definition: TRT_Monitoring_Tool.cxx:4363
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: ManagedMonitorToolBase.cxx:1423
TRT_Monitoring_Tool::Kr
@ Kr
Definition: TRT_Monitoring_Tool.h:85
TRT_Monitoring_Tool::m_hHtoLWonTMapS
TH1F_LW * m_hHtoLWonTMapS[2][64]
Definition: TRT_Monitoring_Tool.h:381
TRT_Monitoring_Tool::m_WireToTrkPositionScale_E
float m_WireToTrkPositionScale_E[2]
Definition: TRT_Monitoring_Tool.h:552
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
InDet::TRT_DriftCircle::driftTimeBin
int driftTimeBin() const
returns the leading edge bin defined as in TRT_LoLumRawData to be the first 0-1 transition
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
TRT_Monitoring_Tool::m_HTfraconTrack_E
float m_HTfraconTrack_E[64]
Definition: TRT_Monitoring_Tool.h:479
TRT_Monitoring_Tool::m_hResidual_B_20GeV
TH1F_LW * m_hResidual_B_20GeV
Definition: TRT_Monitoring_Tool.h:195
InDet::TRT_DriftCircleOnTrack
Definition: TRT_DriftCircleOnTrack.h:53
TProfile_LW
Definition: TProfile_LW.h:24
TRT_Monitoring_Tool::initScaleVectors
int initScaleVectors()
Definition: TRT_Monitoring_Tool.cxx:4486
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
InDet::TRT_DriftCircleOnTrack::detectorElement
virtual const InDetDD::TRT_BaseElement * detectorElement() const override final
returns the detector element, assoicated with the PRD of this class
Definition: TRT_DriftCircleOnTrack.h:224
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Xe
float m_HtoLRatioOnTrackScale_E_Xe[2]
Definition: TRT_Monitoring_Tool.h:550
TRT_Monitoring_Tool::m_hHitWonTMapC
TH1F_LW * m_hHitWonTMapC[2][64]
LE in time window on track: Chips.
Definition: TRT_Monitoring_Tool.h:419
TRT_Monitoring_Tool::m_LonTrack_B
float m_LonTrack_B[32]
Definition: TRT_Monitoring_Tool.h:474
TRT_Monitoring_Tool::m_maxDistToStraw
float m_maxDistToStraw
Definition: TRT_Monitoring_Tool.h:567
TRT_Monitoring_Tool::m_scale_hHitWMap_B_Ar
std::vector< float > m_scale_hHitWMap_B_Ar
Definition: TRT_Monitoring_Tool.h:456
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
ManagedMonitorToolBase::regManagedTrees
StatusCode regManagedTrees(std::vector< MgmtParams< TTree > > &templateTrees)
Definition: ManagedMonitorToolBase.cxx:1261
TRT_Monitoring_Tool::m_scale_hHitWMap_B
std::vector< float > m_scale_hHitWMap_B
Definition: TRT_Monitoring_Tool.h:455
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition: ManagedMonitorToolBase.cxx:1006
AthenaMonManager::getLBsLowStat
static unsigned int getLBsLowStat()
Definition: AthenaMonManager.cxx:326
TRT_Monitoring_Tool::m_lumiBlocksToResetOcc
int m_lumiBlocksToResetOcc
Definition: TRT_Monitoring_Tool.h:576
InDet::TRT_DriftCircle
Definition: TRT_DriftCircle.h:32
TRT_Monitoring_Tool::m_hResidual_E
TH1F_LW * m_hResidual_E[2]
Definition: TRT_Monitoring_Tool.h:228
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
TRT_Monitoring_Tool::s_Straw_max
static const int s_Straw_max[2]
Definition: TRT_Monitoring_Tool.h:140
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
ManagedMonitorToolBase::m_newHigStatInterval
bool m_newHigStatInterval
Definition: ManagedMonitorToolBase.h:882
TRT_Monitoring_Tool::s_numberOfStacks
static const int s_numberOfStacks[2]
Definition: TRT_Monitoring_Tool.h:143
ManagedMonitorToolBase::m_newMedStatInterval
bool m_newMedStatInterval
Definition: ManagedMonitorToolBase.h:882
TruthTest.itE
itE
Definition: TruthTest.py:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TRT_Monitoring_Tool::m_hEvtPhase
TH1F_LW * m_hEvtPhase
Definition: TRT_Monitoring_Tool.h:257
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TRT_Monitoring_Tool::m_hHitToTMapC
TProfile_LW * m_hHitToTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:410
TRT_Monitoring_Tool::m_evtLumiBlock
int m_evtLumiBlock
Definition: TRT_Monitoring_Tool.h:76
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
TRT_BSErrContainer::getRobErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getRobErrorSet(void) const
Definition: TRT_BSErrContainer.h:31
TRT_Monitoring_Tool::m_NumSwLLWoTScale_B
float m_NumSwLLWoTScale_B
Definition: TRT_Monitoring_Tool.h:530
TRT_Monitoring_Tool::m_ResidualScale_E_Ar
float m_ResidualScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:560
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
TRT_Monitoring_Tool::m_hNHLHitsperLB_B
TProfile * m_hNHLHitsperLB_B
Definition: TRT_Monitoring_Tool.h:209
TProfile_LW::Reset
virtual void Reset() override
Definition: TProfile_LW.cxx:182
LWHistAthMonWrapper::streamName
static const std::string & streamName(LWHist *)
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TRT_Monitoring_Tool::m_hNumHoTDetPhi_E
TProfile_LW * m_hNumHoTDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:220
TRT_Monitoring_Tool::m_hAvgHLOcc_side
TProfile_LW * m_hAvgHLOcc_side[2][2]
Definition: TRT_Monitoring_Tool.h:182
TRT_Monitoring_Tool::m_nTrksperLB_B
int m_nTrksperLB_B
Definition: TRT_Monitoring_Tool.h:542
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
LWHist::GetXaxis
LWHistAxis * GetXaxis()
Definition: LWHist.cxx:309
TRT_Monitoring_Tool::m_hResidual_B_Ar_20GeV
TH1F_LW * m_hResidual_B_Ar_20GeV
Definition: TRT_Monitoring_Tool.h:215
TRT_Monitoring_Tool::m_hChipsEff
TProfile_LW * m_hChipsEff[2][64]
Definition: TRT_Monitoring_Tool.h:259
AthenaMonManager::getLBsMedStat
static unsigned int getLBsMedStat()
Definition: AthenaMonManager.cxx:329
TRT_Monitoring_Tool::m_hNumTrksDetPhi_B
TH1F_LW * m_hNumTrksDetPhi_B
Definition: TRT_Monitoring_Tool.h:185
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
TRT_LoLumRawData::driftTimeBin
virtual int driftTimeBin() const override final
Definition: TRT_LoLumRawData.h:57
ManagedMonitorToolBase::m_bookHistogramsInitial
bool m_bookHistogramsInitial
Definition: ManagedMonitorToolBase.h:956
ManagedMonitorToolBase::Imp::m_warnAboutMissingInitialize
bool m_warnAboutMissingInitialize
Definition: ManagedMonitorToolBase.cxx:51
TRT_BSErrContainer
Definition: TRT_BSErrContainer.h:20
TRT_Monitoring_Tool::m_hTimeResidual_B
TH1F_LW * m_hTimeResidual_B
Definition: TRT_Monitoring_Tool.h:196
grepfile.content
string content
Definition: grepfile.py:56
TRT_Monitoring_Tool::m_hResidual_E_Ar_20GeV
TH1F_LW * m_hResidual_E_Ar_20GeV[2]
Definition: TRT_Monitoring_Tool.h:249
LWHist::usingROOTBackend
bool usingROOTBackend() const
Definition: LWHist.h:73
TRT_LoLumRawData::firstBinHigh
bool firstBinHigh() const
Definition: TRT_LoLumRawData.h:154
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TRT_Monitoring_Tool::m_geo_summary_provider
std::string m_geo_summary_provider
Definition: TRT_Monitoring_Tool.h:175
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition: ManagedMonitorToolBase.cxx:2388
ManagedMonitorToolBase::m_preScaleProp
long m_preScaleProp
Definition: ManagedMonitorToolBase.h:916
TRTCond::RtRelation
Definition: RtRelation.h:27
LWHistAthMonWrapper::removeCustomData
static void removeCustomData(LWHist *)
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2325
TRT_Monitoring_Tool::m_track_d0
float m_track_d0
Definition: TRT_Monitoring_Tool.h:601
TRT_Monitoring_Tool::bookTRTShiftTracks
StatusCode bookTRTShiftTracks(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:954
ManagedMonitorToolBase::m_fileKey
std::string m_fileKey
Definition: ManagedMonitorToolBase.h:896
ManagedMonitorToolBase::m_lastLumiBlock
unsigned int m_lastLumiBlock
Definition: ManagedMonitorToolBase.h:922
TRT_Monitoring_Tool::m_hHitWMap_E_Ar
TH1F_LW * m_hHitWMap_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:247
TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrkC
TProfile_LW * m_hValidRawDriftTimeonTrkC[2][64]
Definition: TRT_Monitoring_Tool.h:400
TRT_Monitoring_Tool::m_hHitTronTwEPCMapS
TProfile_LW * m_hHitTronTwEPCMapS[2][64]
Mean TE on track (with Event Phase correction): Straws.
Definition: TRT_Monitoring_Tool.h:393
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition: ManagedMonitorToolBase.h:742
TRT_Monitoring_Tool::m_hefficiencyBarrel_locR
TProfile_LW * m_hefficiencyBarrel_locR
Definition: TRT_Monitoring_Tool.h:614
TRT_Monitoring_Tool::m_hefficiency_phi
TProfile_LW * m_hefficiency_phi
Definition: TRT_Monitoring_Tool.h:611
TRT_Monitoring_Tool::m_condSvc_BS
ServiceHandle< ITRT_ConditionsSvc > m_condSvc_BS
Definition: TRT_Monitoring_Tool.h:150
TRT_Monitoring_Tool::m_track_phi
float m_track_phi
Definition: TRT_Monitoring_Tool.h:600
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E_Ar
TH1F_LW * m_hDriftTimeonTrkDist_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:246
TRT_Monitoring_Tool::m_nHitsperLB_B
int m_nHitsperLB_B
Definition: TRT_Monitoring_Tool.h:543
TRT_Monitoring_Tool::m_min_pT
float m_min_pT
Definition: TRT_Monitoring_Tool.h:590
TRT_Monitoring_Tool::s_moduleNum
static const int s_moduleNum[2]
Definition: TRT_Monitoring_Tool.h:144
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity livefraction.
Definition: ManagedMonitorToolBase.cxx:1993
TRT_ID::straw
int straw(const Identifier &id) const
Definition: TRT_ID.h:902
TRT_Monitoring_Tool::m_trt_hole_finder
ToolHandle< Trk::ITrackHoleSearchTool > m_trt_hole_finder
Definition: TRT_Monitoring_Tool.h:169
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition: ManagedMonitorToolBase.h:726
TRT_Monitoring_Tool::m_hNHitsperLB_E
TProfile * m_hNHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:241
TH1F_LW
Definition: TH1F_LW.h:23
TRT_Monitoring_Tool::m_trackr_HT
TH1F_LW * m_trackr_HT[4][2]
Definition: TRT_Monitoring_Tool.h:468
TRT_Monitoring_Tool::m_WireToTrkPositionScale_E_Ar
float m_WireToTrkPositionScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:553
TRT_Monitoring_Tool::m_hAvgLLOccMod_side
TProfile_LW * m_hAvgLLOccMod_side[2][2]
Avg.
Definition: TRT_Monitoring_Tool.h:436
TRT_Monitoring_Tool::m_hHitAWMapC
TH1F_LW * m_hHitAWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:405
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthenaMonManager::dataType
static DataType_t dataType()
Returns the data type that the monitoring application is running over to help ManagedMonitorToolBase ...
Definition: AthenaMonManager.cxx:338
TRT_Monitoring_Tool::m_hHitOnTrackVsAllC
TH1F_LW * m_hHitOnTrackVsAllC[2][64]
Definition: TRT_Monitoring_Tool.h:262
TRT_Monitoring_Tool::m_hefficiency
TH1F_LW * m_hefficiency[2][2]
Definition: TRT_Monitoring_Tool.h:622
TRT_Monitoring_Tool::m_hHitHWMapS
TH1F_LW * m_hHitHWMapS[2][64]
HL in time window: Straws If a hit has any of the high threshold time bins up, and is in the time win...
Definition: TRT_Monitoring_Tool.h:339
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TRT_Monitoring_Tool::m_hefficiencyMap
TProfile_LW * m_hefficiencyMap[2]
Definition: TRT_Monitoring_Tool.h:619
TRT_Monitoring_Tool::m_mapPath
std::string m_mapPath
Definition: TRT_Monitoring_Tool.h:176
ManagedMonitorToolBase::m_manager
AthenaMonManager * m_manager
Definition: ManagedMonitorToolBase.h:892
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
TRT_Monitoring_Tool::m_longToTCut
float m_longToTCut
Definition: TRT_Monitoring_Tool.h:573
LWHistAthMonWrapper::key
static const std::string & key(LWHist *)
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E
TProfile_LW * m_hAvgTroTDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:221
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: ManagedMonitorToolBase.h:950
TRT_Monitoring_Tool::m_doRDOsMon
bool m_doRDOsMon
Definition: TRT_Monitoring_Tool.h:483
ManagedMonitorToolBase::m_streamNameFcn
StreamNameFcn * m_streamNameFcn
Definition: ManagedMonitorToolBase.h:904
TRT_Monitoring_Tool::m_hChipOcc
TH1F_LW * m_hChipOcc[2][64]
Avg.
Definition: TRT_Monitoring_Tool.h:444
TRT_Monitoring_Tool::m_zero_field
bool m_zero_field
Definition: TRT_Monitoring_Tool.h:570
TRT_Monitoring_Tool::m_LBvsLum
TH1F_LW * m_LBvsLum
Definition: TRT_Monitoring_Tool.h:470
TRT_Monitoring_Tool::checkTRTReadoutIntegrity
StatusCode checkTRTReadoutIntegrity(const xAOD::EventInfo &eventInfo)
Definition: TRT_Monitoring_Tool.cxx:4001
TRT_Monitoring_Tool::strawNumberEndCap
int strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side)
Definition: TRT_Monitoring_Tool.cxx:4180
TProfile_LW::create
static TProfile_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup, const char *option=" ")
Definition: TProfile_LW.cxx:32
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
lumiFormat.i
int i
Definition: lumiFormat.py:92
TRT_Monitoring_Tool::m_nTotalTracks
int m_nTotalTracks
Definition: TRT_Monitoring_Tool.h:78
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
TRT_Monitoring_Tool::m_DistToStraw
float m_DistToStraw
Definition: TRT_Monitoring_Tool.h:568
TRT_Monitoring_Tool::s_iChip_max
static const int s_iChip_max[2]
Definition: TRT_Monitoring_Tool.h:142
TRT_Monitoring_Tool::m_hHitTrWMapC
TProfile_LW * m_hHitTrWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:403
TRT_Monitoring_Tool::m_doStraws
bool m_doStraws
Definition: TRT_Monitoring_Tool.h:493
TRT_Monitoring_Tool::m_hHitAWonTMapC
TH1F_LW * m_hHitAWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:422
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
TRTCond::RtRelation::drifttime
virtual float drifttime(float radius) const =0
drifttime for given radius
Trk::theta
@ theta
Definition: ParamDefs.h:72
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
TRT_Monitoring_Tool::m_HL_timeWindow_MAX
int m_HL_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:509
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::file
@ file
Definition: ManagedMonitorToolBase.h:114
TRT_Monitoring_Tool::m_hHitTronTwEPCMapC
TProfile_LW * m_hHitTronTwEPCMapC[2][64]
Definition: TRT_Monitoring_Tool.h:428
TRT_Monitoring_Tool::m_doCSide
bool m_doCSide
Definition: TRT_Monitoring_Tool.h:492
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:59
TRT_Monitoring_Tool::Ar
@ Ar
Definition: TRT_Monitoring_Tool.h:85
TRT_Monitoring_Tool::m_max_abs_d0
float m_max_abs_d0
Definition: TRT_Monitoring_Tool.h:588
AthenaMonManager::writeAndDelete
virtual void writeAndDelete(const std::string &key)
If the TObject is owned by this manager, its Write() method is called and it is deleted.
Definition: AthenaMonManager.cxx:870
TRT_Monitoring_Tool::m_hResidual_E_Ar
TH1F_LW * m_hResidual_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:248
TRT_Monitoring_Tool::m_hefficiencyEndCap_locR
TProfile_LW * m_hefficiencyEndCap_locR[2]
Definition: TRT_Monitoring_Tool.h:616
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B
float m_HtoLRatioOnTrackScale_B
Definition: TRT_Monitoring_Tool.h:527
SignEnum::LE
@ LE
Definition: SignEnums.h:21
TRT_Monitoring_Tool::m_passEventBurst
bool m_passEventBurst
Definition: TRT_Monitoring_Tool.h:83
calibdata.exception
exception
Definition: calibdata.py:496
TRT_Monitoring_Tool::m_hHitAonTMapC
TH1F_LW * m_hHitAonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:421
TRT_Monitoring_Tool::m_hWireToTrkPosition_B
TH1F_LW * m_hWireToTrkPosition_B
Definition: TRT_Monitoring_Tool.h:204
InDetRawDataCollection
Definition: InDetRawDataCollection.h:31
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
Side
Definition: WaferTree.h:36
TRT_Monitoring_Tool::m_LE_timeWindow_MIN
int m_LE_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:502
TRT_Monitoring_Tool::m_combTrackCollectionKey
SG::ReadHandleKey< TrackCollection > m_combTrackCollectionKey
Definition: TRT_Monitoring_Tool.h:158
TRT_Monitoring_Tool::m_hHLhitOnTrack_E
TH1F_LW * m_hHLhitOnTrack_E[2]
Definition: TRT_Monitoring_Tool.h:234
ManagedMonitorToolBase::Imp::benchPostBookHistograms
void benchPostBookHistograms()
Definition: ManagedMonitorToolBase.cxx:87
TRT_Monitoring_Tool::m_hHitHMapC
TH1F_LW * m_hHitHMapC[2][64]
Definition: TRT_Monitoring_Tool.h:411
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
TRT_Monitoring_Tool::m_EventPhaseScale
float m_EventPhaseScale
Definition: TRT_Monitoring_Tool.h:516
ManagedMonitorToolBase::m_triggerChainProp
std::string m_triggerChainProp
Definition: ManagedMonitorToolBase.h:917
TRT_Monitoring_Tool::m_hHitHWonTMapC
TH1F_LW * m_hHitHWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:424
TRT_Monitoring_Tool::m_hNTrksperLB_B
TProfile * m_hNTrksperLB_B
Definition: TRT_Monitoring_Tool.h:208
TRT_Monitoring_Tool::m_LL_timeWindow_MAX
int m_LL_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:506
TRT_Monitoring_Tool::m_Pull_Biased_EndCap
TH1F_LW * m_Pull_Biased_EndCap
Definition: TRT_Monitoring_Tool.h:227
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
TRT_Monitoring_Tool::m_trackCollectionKey
SG::ReadHandleKey< TrackCollection > m_trackCollectionKey
Definition: TRT_Monitoring_Tool.h:156
TRT_Monitoring_Tool::m_hHtoLMapS
TH1F_LW * m_hHtoLMapS[2][64]
HL/LL: Straws The ratio of High Level hits to Low Level hits per straw.
Definition: TRT_Monitoring_Tool.h:302
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
TRT_Monitoring_Tool::m_trt_only_trks
bool m_trt_only_trks
Definition: TRT_Monitoring_Tool.h:569
TRT_Monitoring_Tool::Xe
@ Xe
Definition: TRT_Monitoring_Tool.h:85
TRT_Monitoring_Tool::m_lastTRTLumiBlock
int m_lastTRTLumiBlock
Definition: TRT_Monitoring_Tool.h:75
TRT_Monitoring_Tool::m_hWireToTrkPosition_E_Ar
TH1F_LW * m_hWireToTrkPosition_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:239
run
Definition: run.py:1
ManagedMonitorToolBase::ATTRIB_MANAGED
@ ATTRIB_MANAGED
Definition: ManagedMonitorToolBase.h:131
ManagedMonitorToolBase::StreamNameFcn::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)=0
A function that converts a MonGroup of logical parameters into a physical output stream name.
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
TRT_Monitoring_Tool::m_hHitToTonTMapC
TProfile_LW * m_hHitToTonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:427
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
InDet::TRT_DriftCircle::trailingEdge
int trailingEdge() const
returns the trailing edge bin
TRT_Monitoring_Tool::m_hHitToTLongTrMapS
TProfile_LW * m_hHitToTLongTrMapS[2][64]
Mean Trailing Edge (ns) for straws with ToT > LongToTCut: Straws.
Definition: TRT_Monitoring_Tool.h:326
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ManagedMonitorToolBase::ManagedMonitorToolBase
ManagedMonitorToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: ManagedMonitorToolBase.cxx:389
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:866
TRT_Monitoring_Tool::m_hTimeResidual_B_Ar
TH1F_LW * m_hTimeResidual_B_Ar
Definition: TRT_Monitoring_Tool.h:216
TRT_Monitoring_Tool::m_hHitHonTMapS
TH1F_LW * m_hHitHonTMapS[2][64]
Definition: TRT_Monitoring_Tool.h:372
ManagedMonitorToolBase::medStat
@ medStat
Definition: ManagedMonitorToolBase.h:115
TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_B
TProfile_LW * m_hEvtPhaseDetPhi_B
Definition: TRT_Monitoring_Tool.h:255
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:893
TRT_Monitoring_Tool::radToDegrees
static float radToDegrees(float radValue)
Definition: TRT_Monitoring_Tool.cxx:4295
TRT_Monitoring_Tool::strawNumber_reverse
static int strawNumber_reverse(int inp_strawnumber, int *strawNumber, int *strawlayerNumber, int *LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4140
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition: ManagedMonitorToolBase.h:730
ManagedMonitorToolBase::m_metadataMap
MDMap_t m_metadataMap
Definition: ManagedMonitorToolBase.h:889
TRT_Monitoring_Tool::m_hHitWonTMap_E
TH1F_LW * m_hHitWonTMap_E[2]
Definition: TRT_Monitoring_Tool.h:226
TRT_Monitoring_Tool::m_hefficiencyEndCap_locR_Ar
TProfile_LW * m_hefficiencyEndCap_locR_Ar[2]
Definition: TRT_Monitoring_Tool.h:617
DataVector< const Trk::TrackStateOnSurface >
ManagedMonitorToolBase::m_endOfEventsBlock
bool m_endOfEventsBlock
Definition: ManagedMonitorToolBase.h:885
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:884
fcn
void fcn(int &, double *, double &result, double par[], int)
this is where we write out chi2
Definition: Chi2LJets.cxx:183
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition: ManagedMonitorToolBase.h:954
TRT_Monitoring_Tool::m_hNHLHitsperLB_E
TProfile * m_hNHLHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:243
TRT_Monitoring_Tool::m_hRobBSErrorsVsLB
TProfile * m_hRobBSErrorsVsLB[2][2]
Definition: TRT_Monitoring_Tool.h:180
beamspotman.stat
stat
Definition: beamspotman.py:266
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
TRT_Monitoring_Tool::m_track_pt
float m_track_pt
Definition: TRT_Monitoring_Tool.h:598
TRT_Monitoring_Tool::m_pTRTHelper
const TRT_ID * m_pTRTHelper
Definition: TRT_Monitoring_Tool.h:172
TRT_Monitoring_Tool::m_LE_timeWindow_MAX
int m_LE_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:503
TRT_Monitoring_Tool::m_hResidual_B
TH1F_LW * m_hResidual_B
Definition: TRT_Monitoring_Tool.h:194
TProfile_LW::Fill
void Fill(const double &x, const double &y)
Definition: TProfile_LW.cxx:223
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Ar
TH1F_LW * m_hHtoLRatioOnTrack_B_Ar
Definition: TRT_Monitoring_Tool.h:202
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
TRT_Monitoring_Tool::fillTRTTracks
StatusCode fillTRTTracks(const TrackCollection &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject)
Definition: TRT_Monitoring_Tool.cxx:2341
beamspotman.dir
string dir
Definition: beamspotman.py:623
TRT_Monitoring_Tool::m_hOccAll
TH1F_LW * m_hOccAll
Definition: TRT_Monitoring_Tool.h:453
TRT_Monitoring_Tool::s_numberOfBarrelStacks
static const int s_numberOfBarrelStacks
Definition: TRT_Monitoring_Tool.h:137
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TRT_Monitoring_Tool::checkEventBurst
StatusCode checkEventBurst(const TRT_RDO_Container &rdoContainer)
Definition: TRT_Monitoring_Tool.cxx:1746
TRT_Monitoring_Tool::m_hefficiencyBarrel_locR_Ar
TProfile_LW * m_hefficiencyBarrel_locR_Ar
Definition: TRT_Monitoring_Tool.h:615
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TRT_Monitoring_Tool::m_hStrawsEff
TProfile_LW * m_hStrawsEff[2][64]
Definition: TRT_Monitoring_Tool.h:253
firstBinHigh
bool firstBinHigh(unsigned int m_word)
Definition: driftCircle.h:104
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E
float m_DriftTimeonTrkDistScale_E[2]
Definition: TRT_Monitoring_Tool.h:546
InDetDD::TRT_DetectorManager::getEndcapElement
const TRT_EndcapElement * getEndcapElement(unsigned int positive, unsigned int wheelIndex, unsigned int strawLayerIndex, unsigned int phiIndex) const
Access Endcap Elements:---------------—(Fast)--------------------------—.
Definition: TRT_DetectorManager.cxx:129
Trk::MeasurementBase
Definition: MeasurementBase.h:58
TRT_Monitoring_Tool::m_hStrawEffDetPhi_E
TProfile_LW * m_hStrawEffDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:224
ManagedMonitorToolBase::m_lastRun
unsigned int m_lastRun
Definition: ManagedMonitorToolBase.h:923
TRT_Monitoring_Tool::m_NoiseSuppressionLevel_30pc
bool m_NoiseSuppressionLevel_30pc
Definition: TRT_Monitoring_Tool.h:511
TRT_Monitoring_Tool::m_hHitWMap_B_Ar
TH1F_LW * m_hHitWMap_B_Ar
Definition: TRT_Monitoring_Tool.h:213
TRT_Monitoring_Tool::m_nHLHitsperLB_B
int m_nHLHitsperLB_B
Definition: TRT_Monitoring_Tool.h:544
ManagedMonitorToolBase::m_newLumiBlock
bool m_newLumiBlock
Definition: ManagedMonitorToolBase.h:883
TRT_Monitoring_Tool::m_hTronTDist_E_Ar
TH1F_LW * m_hTronTDist_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:245
ManagedMonitorToolBase::m_endOfLowStat
bool m_endOfLowStat
Definition: ManagedMonitorToolBase.h:885
TRT_Monitoring_Tool::m_hNTrksperLB_E
TProfile * m_hNTrksperLB_E[2]
Definition: TRT_Monitoring_Tool.h:242
TRT_Monitoring_Tool::m_nStrawHits_E
int m_nStrawHits_E[2][3840]
Definition: TRT_Monitoring_Tool.h:523
Trk::numberOfTRTHits
@ numberOfTRTHits
number of TRT outliers
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:79
TRT_Monitoring_Tool::m_track_eta
float m_track_eta
Definition: TRT_Monitoring_Tool.h:599
TRT_LoLumRawData::trailingEdge
int trailingEdge() const
Definition: TRT_LoLumRawData.h:66
TRT_Monitoring_Tool::strawNumber
int strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4093
TRT_Monitoring_Tool::fillTRTRDOs
StatusCode fillTRTRDOs(const TRT_RDO_Container &rdoContainer, const xAOD::EventInfo &eventInfo, const InDetTimeCollection *trtBCIDCollection)
Definition: TRT_Monitoring_Tool.cxx:1780
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition: ManagedMonitorToolBase.h:952
TRT_Monitoring_Tool::m_hHitWMapS
TH1F_LW * m_hHitWMapS[2][64]
Leading Edge in time Window: Straws.
Definition: TRT_Monitoring_Tool.h:269
TRT_Monitoring_Tool::m_hHitHMapS
TH1F_LW * m_hHitHMapS[2][64]
High Level: Straws If a hit has any of the high threshold time bins up.
Definition: TRT_Monitoring_Tool.h:333
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TH1F_LW::GetBinContent
virtual double GetBinContent(unsigned bin) const override
Definition: TH1F_LW.cxx:265
TRT_Monitoring_Tool::m_TronTDistScale_B_Ar
float m_TronTDistScale_B_Ar
Definition: TRT_Monitoring_Tool.h:538
remainder
std::vector< std::string > remainder(const std::vector< std::string > &v1, const std::vector< std::string > &v2)
list of entries in a vector that are not in another
Definition: compareFlatTrees.cxx:44
TRT_Monitoring_Tool::m_hLLOcc_Scatter
TH2F_LW * m_hLLOcc_Scatter[2]
Definition: TRT_Monitoring_Tool.h:451
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: ManagedMonitorToolBase.cxx:1395
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Trk::d0
@ d0
Definition: ParamDefs.h:69
TRT_Monitoring_Tool::m_hHtoLonTMapC
TH1F_LW * m_hHtoLonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:425
TRT_LoLumRawData::timeOverThreshold
virtual double timeOverThreshold() const override final
Definition: TRT_LoLumRawData.h:47
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TRT_Monitoring_Tool::m_hHitTrMapS
TProfile_LW * m_hHitTrMapS[2][64]
Mean TE: Straws.
Definition: TRT_Monitoring_Tool.h:282
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
TH2F_LW::create
static TH2F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xmin, const double &xmax, unsigned nbinsy, const double &ymin, const double &ymax)
Definition: TH2F_LW.cxx:33
TRT_Monitoring_Tool::m_hefficiency_eta
TProfile_LW * m_hefficiency_eta
Definition: TRT_Monitoring_Tool.h:610
LWHist::LWHistAxis::SetBinLabel
void SetBinLabel(unsigned bin, const char *label)
Definition: LWHist.cxx:411
AthenaMonManager::getLBsHigStat
static unsigned int getLBsHigStat()
Definition: AthenaMonManager.cxx:332
TRT_Monitoring_Tool::m_doExpert
bool m_doExpert
Definition: TRT_Monitoring_Tool.h:496
TRT_Monitoring_Tool::m_NumSwLLWoTScale_E
float m_NumSwLLWoTScale_E[2]
Definition: TRT_Monitoring_Tool.h:551
TRTCond::ExpandedIdentifier::STRAW
@ STRAW
Definition: InnerDetector/InDetConditions/TRT_ConditionsData/TRT_ConditionsData/ExpandedIdentifier.h:37
LWHistAthMonWrapper::setKey
static void setKey(LWHist *, const std::string &key)
TRT_Monitoring_Tool::m_ResidualScale_E_20GeV
float m_ResidualScale_E_20GeV[2]
Definition: TRT_Monitoring_Tool.h:556
InDet::TRT_DriftCircle::lastBinHigh
bool lastBinHigh() const
returns true if the last bin is high
TRT_Monitoring_Tool::m_hAvgHLOccMod_side
TProfile_LW * m_hAvgHLOccMod_side[2][2]
Definition: TRT_Monitoring_Tool.h:437
TRT_Monitoring_Tool::bookTH1F_LW
TH1F_LW * bookTH1F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4417
ExtractEBRunDetails.endOfRun
endOfRun
Definition: ExtractEBRunDetails.py:245
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E_Ar
float m_DriftTimeonTrkDistScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:558
TRT_Monitoring_Tool::m_track_z0
float m_track_z0
Definition: TRT_Monitoring_Tool.h:602
item
Definition: ItemListSvc.h:43
TRT_BSErrContainer::getSidErrorSet
const std::set< uint32_t > & getSidErrorSet(void) const
Definition: TRT_BSErrContainer.h:39
TRT_Monitoring_Tool::m_hHitWonTMap_B
TH1F_LW * m_hHitWonTMap_B
Definition: TRT_Monitoring_Tool.h:192
TRT_Monitoring_Tool::m_ResidualScale_B_Ar_20GeV
float m_ResidualScale_B_Ar_20GeV
Definition: TRT_Monitoring_Tool.h:540
TRT::Hit::ident
@ ident
Definition: HitInfo.h:77
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:875
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
TRT_Monitoring_Tool::m_hNumTrksDetPhi_E
TH1F_LW * m_hNumTrksDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:219
TRT_Monitoring_Tool::m_WireToTrkPositionScale_B_Ar
float m_WireToTrkPositionScale_B_Ar
Definition: TRT_Monitoring_Tool.h:532
TRT_Monitoring_Tool::m_hHitWonTMapS
TH1F_LW * m_hHitWonTMapS[2][64]
LE in time window on track: Straws.
Definition: TRT_Monitoring_Tool.h:345
TRT_Monitoring_Tool::m_every_xth_track
int m_every_xth_track
Definition: TRT_Monitoring_Tool.h:605
TRT_Monitoring_Tool::m_IntLum
TH1F_LW * m_IntLum
Definition: TRT_Monitoring_Tool.h:469
TRT_Monitoring_Tool::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TRT_Monitoring_Tool.h:87
TRT_Monitoring_Tool::m_min_pixel_hits
int m_min_pixel_hits
Definition: TRT_Monitoring_Tool.h:594
TH1F_LW::GetEntries
virtual unsigned GetEntries() const override
Definition: TH1F_LW.cxx:269
LWHist::setOwnsROOTHisto
void setOwnsROOTHisto(bool b)
Definition: LWHist.h:75
ManagedMonitorToolBase::m_lwhists
std::set< LWHist * > m_lwhists
Definition: ManagedMonitorToolBase.h:891
TRT_Monitoring_Tool::m_hHitToTLongMapS
TProfile_LW * m_hHitToTLongMapS[2][64]
Mean ToT (ns) for straws with ToT > LongToTCut: Straws.
Definition: TRT_Monitoring_Tool.h:318
TRT_Monitoring_Tool::m_hefficiencyC
TProfile_LW * m_hefficiencyC[2][64]
Definition: TRT_Monitoring_Tool.h:621
xAOD::timeStamp
setEventNumber timeStamp
Definition: EventInfo_v1.cxx:128
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
ManagedMonitorToolBase::m_templateLWHistograms
std::map< Interval_t, std::vector< MgmtParams< LWHist > > > m_templateLWHistograms
Definition: ManagedMonitorToolBase.h:734
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B
TProfile_LW * m_hAvgTroTDetPhi_B
Definition: TRT_Monitoring_Tool.h:187
TRT_Monitoring_Tool::m_hHitAWMapS
TH1F_LW * m_hHitAWMapS[2][64]
LL in time window: Straws Any low level hit in time window by straw.
Definition: TRT_Monitoring_Tool.h:296
ManagedMonitorToolBase::m_managerNameProp
std::string m_managerNameProp
Definition: ManagedMonitorToolBase.h:894
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
ManagedMonitorToolBase::m_nEventsIgnoreTrigger
unsigned int m_nEventsIgnoreTrigger
Definition: ManagedMonitorToolBase.h:927
TRT_Monitoring_Tool::m_hResidual_B_Ar
TH1F_LW * m_hResidual_B_Ar
Definition: TRT_Monitoring_Tool.h:214
TRT_Monitoring_Tool::m_hNHitsperLB_B
TProfile * m_hNHitsperLB_B
Definition: TRT_Monitoring_Tool.h:207
TRT_Monitoring_Tool::m_max_abs_eta
float m_max_abs_eta
Definition: TRT_Monitoring_Tool.h:591
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:116
ManagedMonitorToolBase::m_endOfRun
bool m_endOfRun
Definition: ManagedMonitorToolBase.h:885
TRT_Monitoring_Tool::m_EventBurstCut
int m_EventBurstCut
Definition: TRT_Monitoring_Tool.h:575
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ManagedMonitorToolBase::m_newLowStat
bool m_newLowStat
Definition: ManagedMonitorToolBase.h:883
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B_Ar
TProfile_LW * m_hAvgTroTDetPhi_B_Ar
Definition: TRT_Monitoring_Tool.h:188
TProfile_LW::GetBinEntries
double GetBinEntries(unsigned bin) const
Definition: TProfile_LW.cxx:242
DeMoScan.index
string index
Definition: DeMoScan.py:362
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
TRT_Monitoring_Tool::m_hHitAWonTMapS
TH1F_LW * m_hHitAWonTMapS[2][64]
Any LL bit in time window on track: Straws Any low level (LL) bit set and is in time window from hits...
Definition: TRT_Monitoring_Tool.h:363
lumiFormat.lumi
lumi
Definition: lumiFormat.py:113
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:857
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
ManagedMonitorToolBase::regManagedLWHistograms
StatusCode regManagedLWHistograms(std::vector< MgmtParams< LWHist > > &templateLWHistograms)
Definition: ManagedMonitorToolBase.cxx:1315
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
TRT_Monitoring_Tool::m_hEvtPhaseVsTrig
TH2F_LW * m_hEvtPhaseVsTrig
Definition: TRT_Monitoring_Tool.h:258
AthenaMonManager::forkedProcess
bool forkedProcess()
Definition: AthenaMonManager.cxx:345
TRT_Monitoring_Tool::m_hHitOnTrackVsAllS
TH1F_LW * m_hHitOnTrackVsAllS[2][64]
Definition: TRT_Monitoring_Tool.h:261
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
ManagedMonitorToolBase::m_lastHigStatInterval
int m_lastHigStatInterval
Definition: ManagedMonitorToolBase.h:924
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
TRT_Monitoring_Tool::strawLayerNumber_reverse
static int strawLayerNumber_reverse(int strawLayerNumInp, int *strawLayerNumber, int *LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4276
TRT_Monitoring_Tool::m_hrtRelation_E_Ar
TH2F_LW * m_hrtRelation_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:251
TRT_Monitoring_Tool::m_nStrawHits_B
int m_nStrawHits_B[1642]
Definition: TRT_Monitoring_Tool.h:520
lumiFormat.fill
fill
Definition: lumiFormat.py:111
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TRT_Monitoring_Tool::m_hrtRelation_E
TH2F_LW * m_hrtRelation_E[2]
Definition: TRT_Monitoring_Tool.h:233
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B
TH1F_LW * m_hDriftTimeonTrkDist_B
Definition: TRT_Monitoring_Tool.h:197
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B
TH1F_LW * m_hHtoLRatioOnTrack_B
Definition: TRT_Monitoring_Tool.h:201
ManagedMonitorToolBase::Imp::benchPreBookHistograms
void benchPreBookHistograms()
Definition: ManagedMonitorToolBase.cxx:78
TRT_Monitoring_Tool::m_TrackSummaryTool
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool
Definition: TRT_Monitoring_Tool.h:168
TRT_Monitoring_Tool::scale_LWHist
static void scale_LWHist(LWHist1D *hist, float scale)
Definition: TRT_Monitoring_Tool.cxx:4344
TRT_Monitoring_Tool::m_ResidualScale_B
float m_ResidualScale_B
Definition: TRT_Monitoring_Tool.h:534
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_E
TProfile_LW * m_hEvtPhaseDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:256
ManagedMonitorToolBase::m_nLumiBlocks
unsigned int m_nLumiBlocks
Definition: ManagedMonitorToolBase.h:928
TRT_Monitoring_Tool::bookTRTTracks
StatusCode bookTRTTracks(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:813
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
TRT_Monitoring_Tool::m_hHtoBCMapB
TH2F_LW * m_hHtoBCMapB[2][64]
Definition: TRT_Monitoring_Tool.h:409
TRT_Monitoring_Tool::m_trigDecisionKey
SG::ReadHandleKey< xAOD::TrigDecision > m_trigDecisionKey
Definition: TRT_Monitoring_Tool.h:162
ManagedMonitorToolBase::eventsBlock
@ eventsBlock
Definition: ManagedMonitorToolBase.h:114
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition: envutil.py:152
TH1F_LW::Reset
virtual void Reset() override
Definition: TH1F_LW.cxx:183
TRT_Monitoring_Tool::m_doEfficiency
bool m_doEfficiency
Definition: TRT_Monitoring_Tool.h:498
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
TRT_Monitoring_Tool::m_hefficiency_pt
TProfile_LW * m_hefficiency_pt
Definition: TRT_Monitoring_Tool.h:612
TRT_Monitoring_Tool::m_hHitToTonTMapS
TProfile_LW * m_hHitToTonTMapS[2][64]
Mean ToT (ns) on Track: Straws Average Time over Threshold (ToT) from a straw hit associated with a t...
Definition: TRT_Monitoring_Tool.h:387
DEBUG
#define DEBUG
Definition: page_access.h:11
TRT_Monitoring_Tool::m_hHitToTrkDistanceMapS_E
TProfile_LW * m_hHitToTrkDistanceMapS_E[64]
Definition: TRT_Monitoring_Tool.h:430
TRT_Monitoring_Tool::m_TRTCalDbTool
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool
Definition: TRT_Monitoring_Tool.h:152
TRT_Monitoring_Tool::m_hAvgLLOcc_side
TProfile_LW * m_hAvgLLOcc_side[2][2]
Definition: TRT_Monitoring_Tool.h:183
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
TRT_BSErrContainer::getL1ErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getL1ErrorSet() const
Definition: TRT_BSErrContainer.h:42
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:116
TRT_Monitoring_Tool::m_hTimeResidual_E_Ar
TH1F_LW * m_hTimeResidual_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:250
TRT_Monitoring_Tool::m_ResidualScale_E
float m_ResidualScale_E[2]
Definition: TRT_Monitoring_Tool.h:555
TRT_Monitoring_Tool::m_TimeResidualScale_B_Ar
float m_TimeResidualScale_B_Ar
Definition: TRT_Monitoring_Tool.h:541
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
ManagedMonitorToolBase::deregObject
virtual StatusCode deregObject(const std::string &objName, const std::string &system, Interval_t interval)
De-registers a TObject from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:1852
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
entries
double entries
Definition: listroot.cxx:49
ManagedMonitorToolBase::StreamNameFcn::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)=0
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
TRT_Monitoring_Tool::m_doMaskStraws
bool m_doMaskStraws
Definition: TRT_Monitoring_Tool.h:497
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
TRT_Monitoring_Tool::m_hHtoLWonTMapC
TH1F_LW * m_hHtoLWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:426
InDet::TRT_DriftCircle::driftTimeValid
bool driftTimeValid() const
return true if the corrected drift time is OK
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Ar
float m_HtoLRatioOnTrackScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:549
TRT_Monitoring_Tool::m_TRT_BCIDCollectionKey
SG::ReadHandleKey< InDetTimeCollection > m_TRT_BCIDCollectionKey
Definition: TRT_Monitoring_Tool.h:160
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TRT_Monitoring_Tool::m_NoiseSuppressionMap
bool m_NoiseSuppressionMap
Definition: TRT_Monitoring_Tool.h:514
TRT_Monitoring_Tool::m_hTimeResidual_E
TH1F_LW * m_hTimeResidual_E[2]
Definition: TRT_Monitoring_Tool.h:230
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: ManagedMonitorToolBase.cxx:1415
TRT_Monitoring_Tool::m_hResVsDetPhi_E
TH1F_LW * m_hResVsDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:240
TRT_Monitoring_Tool::m_LLOcc
float m_LLOcc[2][64]
Definition: TRT_Monitoring_Tool.h:458
TRT_Monitoring_Tool::GasType
GasType
Definition: TRT_Monitoring_Tool.h:85
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition: ManagedMonitorToolBase.cxx:1960
timeOverThreshold
double timeOverThreshold(unsigned int m_word)
Definition: driftCircle.h:116
TRT_Monitoring_Tool::m_hSummary
TH1F_LW * m_hSummary
Definition: TRT_Monitoring_Tool.h:178
TRT_Monitoring_Tool::m_LonTrack_E
float m_LonTrack_E[64]
Definition: TRT_Monitoring_Tool.h:480
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
InDetRawData::identify
virtual Identifier identify() const override final
Definition: InDetRawData.h:41
TRT_Monitoring_Tool::m_printEventInfo
bool m_printEventInfo
Definition: TRT_Monitoring_Tool.h:572
ManagedMonitorToolBase::m_useTrigger
bool m_useTrigger
Definition: ManagedMonitorToolBase.h:920
TRT_Monitoring_Tool::m_flagforscale
int m_flagforscale
Definition: TRT_Monitoring_Tool.h:583
TRT_Monitoring_Tool::m_TimeResidualScale_B
float m_TimeResidualScale_B
Definition: TRT_Monitoring_Tool.h:536
TH2F_LW
Definition: TH2F_LW.h:23
ManagedMonitorToolBase::m_haveClearedLastEventBlock
bool m_haveClearedLastEventBlock
Definition: ManagedMonitorToolBase.h:929
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition: AthenaMonManager.cxx:352
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
TRT_Monitoring_Tool::m_hWireToTrkPosition_E
TH1F_LW * m_hWireToTrkPosition_E[2]
Definition: TRT_Monitoring_Tool.h:238
TRT_Monitoring_Tool::m_TimeResidualScale_E_Ar
float m_TimeResidualScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:562
TRT_Monitoring_Tool::m_trackz_All
TH1F_LW * m_trackz_All[5][2]
Initialize Aging plots** HT, All, Barrel, EC, In/A, Out/C, etc...
Definition: TRT_Monitoring_Tool.h:464
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B_Ar
float m_DriftTimeonTrkDistScale_B_Ar
Definition: TRT_Monitoring_Tool.h:537
TRT_Monitoring_Tool::m_hWireToTrkPosition_B_Ar
TH1F_LW * m_hWireToTrkPosition_B_Ar
Definition: TRT_Monitoring_Tool.h:205
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
InDet::TRT_DriftCircle::rawDriftTime
double rawDriftTime() const
returns the raw driftTime
TRT_Monitoring_Tool::m_doTracksMon
bool m_doTracksMon
Definition: TRT_Monitoring_Tool.h:485
InDet::TRT_DriftCircleOnTrack::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
return the global position of this RIO_OnTrack
Definition: TRT_DriftCircleOnTrack.cxx:160
TRT_Monitoring_Tool::m_hHtoBCMapC
TH2F_LW * m_hHtoBCMapC[2][64]
Definition: TRT_Monitoring_Tool.h:408
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition: ManagedMonitorToolBase.h:722
TRT_Monitoring_Tool::m_hefficiencyS
TProfile_LW * m_hefficiencyS[2][64]
Definition: TRT_Monitoring_Tool.h:620
TRT_Monitoring_Tool::m_MIN_N_LL_Hits
int m_MIN_N_LL_Hits
Definition: TRT_Monitoring_Tool.h:512
InDet::TRT_DriftCircle::getWord
unsigned int getWord() const
returns the TRT dataword
get_generator_info.error
error
Definition: get_generator_info.py:40
TRT_Monitoring_Tool::m_hHLhitOnTrack_B
TH1F_LW * m_hHLhitOnTrack_B
Definition: TRT_Monitoring_Tool.h:200
ManagedMonitorToolBase::newLumiBlockFlag
bool newLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:853
ManagedMonitorToolBase::ATTRIB_X_VS_LB
@ ATTRIB_X_VS_LB
Definition: ManagedMonitorToolBase.h:131
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition: ManagedMonitorToolBase.cxx:41
TRT_Monitoring_Tool::m_doChips
bool m_doChips
Definition: TRT_Monitoring_Tool.h:494
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
python.PyAthena.obj
obj
Definition: PyAthena.py:135
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition: ManagedMonitorToolBase.h:910
TRT_Monitoring_Tool::m_HLhitOnTrackScale_B
float m_HLhitOnTrackScale_B
Definition: TRT_Monitoring_Tool.h:526
LWHist::getROOTHistBase
virtual TH1 * getROOTHistBase()=0
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TRT_Monitoring_Tool::m_hHitHWMapC
TH1F_LW * m_hHitHWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:412
TRT_Monitoring_Tool::m_doGeoMon
bool m_doGeoMon
Definition: TRT_Monitoring_Tool.h:484
error
Definition: IImpactPoint3dEstimator.h:70
ManagedMonitorToolBase::m_lastMedStatInterval
int m_lastMedStatInterval
Definition: ManagedMonitorToolBase.h:924
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
trailingEdge
int trailingEdge(unsigned int m_word)
Definition: driftCircle.h:64
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
TRT_Monitoring_Tool::m_comTimeObjectKey
SG::ReadHandleKey< ComTime > m_comTimeObjectKey
Definition: TRT_Monitoring_Tool.h:161
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition: ManagedMonitorToolBase.h:742
TRT_Monitoring_Tool::m_MIN_TOT_Hits
int m_MIN_TOT_Hits
Definition: TRT_Monitoring_Tool.h:513
TRT_Monitoring_Tool::m_nTrack_B
int m_nTrack_B[32]
Definition: TRT_Monitoring_Tool.h:475
TRT_Monitoring_Tool::m_DEBUG
bool m_DEBUG
Definition: TRT_Monitoring_Tool.h:571
TRT_Monitoring_Tool::m_hrtRelation_B_Ar
TH2F_LW * m_hrtRelation_B_Ar
Definition: TRT_Monitoring_Tool.h:217
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TRT_Monitoring_Tool::m_hNumSwLLWoT_E
TH1F_LW * m_hNumSwLLWoT_E[2]
Definition: TRT_Monitoring_Tool.h:223
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDet::TRT_DriftCircle::firstBinHigh
bool firstBinHigh() const
returns true if the first bin is high
TRT_Monitoring_Tool::m_trackz_HT
TH1F_LW * m_trackz_HT[5][2]
Definition: TRT_Monitoring_Tool.h:465
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:1454
readCCLHist.float
float
Definition: readCCLHist.py:83
TRT_Monitoring_Tool::divide_LWHist
static void divide_LWHist(TH1F_LW *result, TH1F_LW *a, TH1F_LW *b)
Definition: TRT_Monitoring_Tool.cxx:4392
TRT_Monitoring_Tool::m_hHitHWonTMapS
TH1F_LW * m_hHitHWonTMapS[2][64]
Any HL hit on track: Straws Any straw with a High Threshold (HL) hit associated with a track.
Definition: TRT_Monitoring_Tool.h:369
TRT_Monitoring_Tool::m_max_abs_z0
float m_max_abs_z0
Definition: TRT_Monitoring_Tool.h:589
TRT_Monitoring_Tool::m_hHitAMapC
TH1F_LW * m_hHitAMapC[2][64]
Definition: TRT_Monitoring_Tool.h:404
xAOD::TrigDecision_v1
Interface to the raw trigger decision information of the event.
Definition: TrigDecision_v1.h:44
TRT_Monitoring_Tool::m_WireToTrkPositionScale_B
float m_WireToTrkPositionScale_B
Definition: TRT_Monitoring_Tool.h:531
TRT_Monitoring_Tool::m_datatype
std::string m_datatype
Definition: TRT_Monitoring_Tool.h:606
TRT_Monitoring_Tool::m_min_sct_hits
int m_min_sct_hits
Definition: TRT_Monitoring_Tool.h:595
Trk::phi0
@ phi0
Definition: ParamDefs.h:71
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
merge
Definition: merge.py:1
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition: ManagedMonitorToolBase.cxx:588
TRT_BSErrContainer::getBCIDErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getBCIDErrorSet() const
Definition: TRT_BSErrContainer.h:45
TRT_Monitoring_Tool::m_hHtoLonTMapS
TH1F_LW * m_hHtoLonTMapS[2][64]
HL in time window on track: Straws Straws with a High Threshold hit associated with a track and the h...
Definition: TRT_Monitoring_Tool.h:378
TRT_Monitoring_Tool::m_hHightoLowRatioOnTrack_Scatter
TH2F_LW * m_hHightoLowRatioOnTrack_Scatter[2]
Definition: TRT_Monitoring_Tool.h:452
TRT_Monitoring_Tool::m_rdoContainerKey
SG::ReadHandleKey< TRT_RDO_Container > m_rdoContainerKey
Definition: TRT_Monitoring_Tool.h:155
TRT_Monitoring_Tool::m_hTronTDist_E
TH1F_LW * m_hTronTDist_E[2]
Definition: TRT_Monitoring_Tool.h:232
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:57
invGeV
constexpr float invGeV
Definition: PFTrackSelector.cxx:10
TRT_Monitoring_Tool::m_minP
float m_minP
Definition: TRT_Monitoring_Tool.h:579
TRT_ID::straw_id
Identifier straw_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer, int straw) const
Three ways of getting id for a single straw:
Definition: TRT_ID.h:581
ymax
double ymax
Definition: listroot.cxx:64
TRT_Monitoring_Tool::m_bsErrContKey
SG::ReadHandleKey< TRT_BSErrContainer > m_bsErrContKey
Definition: TRT_Monitoring_Tool.h:164
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Ar
float m_HtoLRatioOnTrackScale_B_Ar
Definition: TRT_Monitoring_Tool.h:528
ManagedMonitorToolBase::m_defaultLBDuration
float m_defaultLBDuration
Definition: ManagedMonitorToolBase.h:958
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Xe
float m_HtoLRatioOnTrackScale_B_Xe
Definition: TRT_Monitoring_Tool.h:529
TRT_Monitoring_Tool::m_hNumSwLLWoT_B
TH1F_LW * m_hNumSwLLWoT_B
Definition: TRT_Monitoring_Tool.h:189
driftTimeBin
int driftTimeBin(unsigned int m_word)
Definition: driftCircle.h:50
TRT_Monitoring_Tool::m_mat_chip_B
unsigned char m_mat_chip_B[64][1642]
Definition: TRT_Monitoring_Tool.h:519
TRT_Monitoring_Tool::m_hChipBSErrorsVsLB
TProfile * m_hChipBSErrorsVsLB[2][2]
Definition: TRT_Monitoring_Tool.h:179
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Sun Jun 30 2024 22:08:39 for ATLAS Offline Software by   doxygen 1.8.18