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

#include <MdtVsTgcRawDataValAlg.h>

Inheritance diagram for MdtVsTgcRawDataValAlg:
Collaboration diagram for MdtVsTgcRawDataValAlg:

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

 MdtVsTgcRawDataValAlg (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~MdtVsTgcRawDataValAlg ()
 
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

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void correlation (const Muon::MdtPrepDataContainer *mdt_hit_container, const Muon::TgcCoinDataContainer *tgc_trigger_container)
 
int numberOfSL (const Muon::TgcCoinDataContainer *tgctrgcontainer)
 
void roi2etaphi (const Muon::TgcCoinData &cd, int &eta, int &phi)
 
int phi2sector (int phi, int ef)
 
int roiphi2mdtSector (int roiphi, int ef)
 
int roitotalphi2sectorphi (int phi)
 
int stationGasGap2layer (int station, int GasGap)
 
void prepareTREarray (const MuonGM::MuonDetectorManager *MuonDetMgrDS)
 
int TGCgetlayer (int stationName, int g)
 
int TGClayer2stationindex (int l)
 
int TGCstationname2stationindex (int stationName)
 
StatusCode bookmaphists (MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
 
void maphists (const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
 
void maphistsfinalize ()
 
StatusCode bookeffhists (MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
 
void tgceffcalc (const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
 
void SortMDTSegments (const xAOD::MuonSegmentContainer *m_newsegment, std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4])
 
void DQCheckMDTSegments (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4])
 
void MatchMDTSegments (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], std::vector< SegmTrack >(&matchedSegments)[2])
 
void CheckTGConTrack (std::vector< SegmTrack >(&matchedSegments)[2], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
 
void MidstationOnlyCheck (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
 
void tgceffcalcfinalize ()
 
int getStationMapIndex (int x, int l, int stationFE, int stationEta, int stationPhi)
 
void labelStationMap (TH2 *h2, int i=-1, int k=-1)
 
void putBox (TH2 *h2, float x1, float y1, float x2, float y2)
 
void BlankPhi24 (TH2 *h2, int binx)
 
void BlankStationMap (TH2 *h2, int ws)
 
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...
 

Private Attributes

MuonDQAHistMap m_stationHists
 
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
bool m_checkCabling
 
bool m_tgclv1file
 
std::string m_chamberName
 
std::string m_StationSize
 
int m_sector
 
int m_side
 
int m_lastEvent
 
int m_cosmicStation
 
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_tgc_PrepDataContainerName {this,"TgcPrepDataContainer","TGC_Measurements","TGC PRDs"}
 
SG::ReadHandleKey< Muon::TgcCoinDataContainer > m_tgc_CoinContainerName {this,"OutputCoinCollection","TrigT1CoinDataCollection","TGC coincidences"}
 
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_mdt_PrepDataContainerName {this,"MdtPrepDataContainer","MDT_DriftCircles","MDT PRDs"}
 
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_mdt_SegmentCollectionName {this,"MdtSegmentCollection","MuonSegments","muon segments"}
 
int m_MdtAdcCut
 
int m_MdtTdcCut
 
const MuonGM::TgcReadoutElement * m_TREarray [8][2][9][49] {}
 
TH1 * m_mvt_cutspassed [2] {}
 
TH2 * m_mdt_segmmap [2][4] {}
 
TH2 * m_eff_stationmapbase [2][2][4] {}
 
TH2 * m_eff_stationmapmid [2][2][4] {}
 
TH2 * m_eff_stationmap [2][2][4] {}
 
TH1 * m_mvt_extrprdsag [2][4][2][2][4] {}
 
TH1 * m_mvt_extrprdsag2 [2][4][2][2][4] {}
 
TH1 * m_tgc_prdcompsag [2][2][4] {}
 
TH1 * m_mdt_segmmatchsag [2][4][4][4] {}
 
TH1 * m_mdt_segmposdirsag [2][4][4] {}
 
TH1 * m_mdt_trackdirdirsag [2][4][4][4] {}
 
TH1 * m_mdt_trackchecksag [2][4][4][4][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
 

Detailed Description

Definition at line 38 of file MdtVsTgcRawDataValAlg.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

◆ 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

◆ MdtVsTgcRawDataValAlg()

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

Definition at line 34 of file MdtVsTgcRawDataValAlg.cxx.

35  :ManagedMonitorToolBase( type, name, parent )
36 {
37  // Declare the properties
38  declareProperty("CheckCabling", m_checkCabling=false);
39  declareProperty("TgcLv1File", m_tgclv1file=true);
40  declareProperty("ChamberName", m_chamberName="XXX");
41  declareProperty("StationSize", m_StationSize="XXX");
42  declareProperty("Sector", m_sector=0);
43  declareProperty("Side", m_side=0);
44  declareProperty("LastEvent", m_lastEvent=0);
45  declareProperty("CosmicStation", m_cosmicStation=0);
46  declareProperty("MdtAdcCut", m_MdtAdcCut=50);
47  declareProperty("MdtTdcCut", m_MdtTdcCut=1600);
48 
49  // initialize class members
50 
51  for(int ac=0; ac<2; ac++){
52  m_mvt_cutspassed[ac] = nullptr;
53  for(int jMDT=0; jMDT<4; jMDT++){
54  m_mdt_segmmap[ac][jMDT] = nullptr;
55  for(int sMDT=0; sMDT<4; sMDT++){
56  m_mdt_segmposdirsag[ac][jMDT][sMDT] = nullptr;
57  for(int iREPT=0; iREPT<4; iREPT++){
58  m_mdt_segmmatchsag[ac][jMDT][sMDT][iREPT] = nullptr;
59  m_mdt_trackdirdirsag[ac][jMDT][sMDT][iREPT] = nullptr;
60  m_mdt_trackchecksag[ac][jMDT][sMDT][iREPT][0] = nullptr;
61  m_mdt_trackchecksag[ac][jMDT][sMDT][iREPT][1] = nullptr;
62  }
63  }
64  }
65  for(int WS=0; WS<2; WS++){
66  for(int EffNDE=0; EffNDE<4; EffNDE++){
67  m_eff_stationmapbase[ac][WS][EffNDE] = nullptr;
68  m_eff_stationmapmid[ac][WS][EffNDE] = nullptr;
69  m_eff_stationmap[ac][WS][EffNDE] = nullptr;
70  }
71  }
72  }
73 
74  // Initialize to zero
75  for(int i=0;i<2;i++)// AC
76  for(int jTGC=0;jTGC<4;jTGC++)// TGC Station
77  for(int f=0;f<2;f++)// FE
78  for(int k=0;k<2;k++)// WireStrip
79  for(int x=0;x<4;x++){
80  m_mvt_extrprdsag[i][jTGC][f][k][x]=nullptr;
81  m_mvt_extrprdsag2[i][jTGC][f][k][x]=nullptr;
82  }
83  for(int k=0;k<2;k++)
84  for(int i=0;i<2;i++)
85  for(int x=0;x<4;x++){
86  m_tgc_prdcompsag[i][k][x]=nullptr;
87  }
88 
89 }

◆ ~MdtVsTgcRawDataValAlg()

MdtVsTgcRawDataValAlg::~MdtVsTgcRawDataValAlg ( )
virtual

Definition at line 91 of file MdtVsTgcRawDataValAlg.cxx.

91  {
92  ATH_MSG_INFO( " deleting MdtVsTgcRawDataValAlg " );
93 }

Member Function Documentation

◆ BlankPhi24()

void MdtVsTgcRawDataValAlg::BlankPhi24 ( TH2 *  h2,
int  binx 
)
private

Definition at line 144 of file MdtVsTgcRawData_functions.cxx.

144  {
145  float x1=h->GetXaxis()->GetBinLowEdge(binx);
146  float x2=h->GetXaxis()->GetBinUpEdge(binx);
147  for(int i=0;i<24;i++){
148  int biny = (i+1)*2;
149  float y1=h->GetYaxis()->GetBinLowEdge(biny);
150  float y2=h->GetYaxis()->GetBinUpEdge(biny);
151  putBox(h, x1, y1, x2, y2);
152  }
153 }

◆ BlankStationMap()

void MdtVsTgcRawDataValAlg::BlankStationMap ( TH2 *  h2,
int  ws 
)
private

Definition at line 155 of file MdtVsTgcRawData_functions.cxx.

155  {
156  bool rebin=true;
157  if(rebin){//use new bin
158  for(int i=33; i<44;i++)BlankPhi24(h,i);
159  int x1=h->GetXaxis()->GetBinLowEdge(40);
160  int x2=h->GetXaxis()->GetBinUpEdge(40);
161  int x3=h->GetXaxis()->GetBinLowEdge(41);
162  int x4=h->GetXaxis()->GetBinUpEdge(41);
163  int y1=h->GetYaxis()->GetBinLowEdge(19);
164  int y2=h->GetYaxis()->GetBinUpEdge(19);
165  putBox(h, x1, y1, x2, y2);
166  putBox(h, x3, y1, x4, y2);
167  y1=h->GetYaxis()->GetBinLowEdge(35);
168  y2=h->GetYaxis()->GetBinUpEdge(35);
169  putBox(h, x1, y1, x2, y2);
170  putBox(h, x3, y1, x4, y2);
171  y1=h->GetYaxis()->GetBinLowEdge(43);
172  y2=h->GetYaxis()->GetBinUpEdge(43);
173  putBox(h, x1, y1, x2, y2);
174  putBox(h, x3, y1, x4, y2);
175 
176  if(ws==1){//Strip
177  x1=h->GetXaxis()->GetBinLowEdge(2);
178  y1=h->GetYaxis()->GetBinLowEdge(1);
179  x2=h->GetXaxis()->GetBinUpEdge(2);
180  y2=h->GetYaxis()->GetBinUpEdge(48);
181  putBox(h, x1, y1, x2, y2);
182  x1=h->GetXaxis()->GetBinLowEdge(9);
183  x2=h->GetXaxis()->GetBinUpEdge(9);
184  putBox(h, x1, y1, x2, y2);
185  x1=h->GetXaxis()->GetBinLowEdge(16);
186  x2=h->GetXaxis()->GetBinUpEdge(16);
187  putBox(h, x1, y1, x2, y2);
188  x1=h->GetXaxis()->GetBinLowEdge(23);
189  x2=h->GetXaxis()->GetBinUpEdge(23);
190  putBox(h, x1, y1, x2, y2);
191  x1=h->GetXaxis()->GetBinLowEdge(34);
192  x2=h->GetXaxis()->GetBinUpEdge(34);
193  putBox(h, x1, y1, x2, y2);
194  }
195  }else{//use old bin, logically dead code, comment out
196 // BlankPhi24(h, 5);
197 // BlankPhi24(h, 10);
198 // BlankPhi24(h, 15);
199 // BlankPhi24(h, 21);
200 // BlankPhi24(h, 27);
201 // BlankPhi24(h, 33);
202 // BlankPhi24(h, 39);
203 // BlankPhi24(h, 40);
204 // BlankPhi24(h, 41);
205 // BlankPhi24(h, 42);
206 // BlankPhi24(h, 43);
207 // int x1=h->GetXaxis()->GetBinLowEdge(40);
208 // int x2=h->GetXaxis()->GetBinUpEdge(40);
209 // int x3=h->GetXaxis()->GetBinLowEdge(42);
210 // int x4=h->GetXaxis()->GetBinUpEdge(42);
211 // int y1=h->GetYaxis()->GetBinLowEdge(19);
212 // int y2=h->GetYaxis()->GetBinUpEdge(19);
213 // putBox(h, x1, y1, x2, y2);
214 // putBox(h, x3, y1, x4, y2);
215 // y1=h->GetYaxis()->GetBinLowEdge(35);
216 // y2=h->GetYaxis()->GetBinUpEdge(35);
217 // putBox(h, x1, y1, x2, y2);
218 // putBox(h, x3, y1, x4, y2);
219 // y1=h->GetYaxis()->GetBinLowEdge(43);
220 // y2=h->GetYaxis()->GetBinUpEdge(43);
221 // putBox(h, x1, y1, x2, y2);
222 // putBox(h, x3, y1, x4, y2);
223  }
224 }

◆ bookeffhists()

StatusCode MdtVsTgcRawDataValAlg::bookeffhists ( MonGroup &  mdtvstgclv1_expert_a,
MonGroup &  mdtvstgclv1_expert_c 
)
private

Definition at line 100 of file MdtVsTgcRawData_bookhistograms.cxx.

101  {
102 
103  std::stringstream sst;
104  std::string AC[2]= {"A","C"};
105  std::string RhoEtaPhiThe[4]={"Rho","Eta","Phi","Theta"};
106  std::string RhoEtaPhiZ[4]= {"Rho","Eta","Phi","Z"};
107  std::string FE[2]= {"F","E"};// Forward, Endcap
108  std::string EffNumDenom[4]= {"","num","denom","error"};
109  std::string WireStrip[2]= {"Wire","Strip"};
110  int nbins3D_1[4]= { 0, 0, 0, 0};
111  float fGlobalCoords3Dlo[4]= { 0, 0, 0, 0};
112  float fGlobalCoords3Dup[4]= { 0, 0, 0, 0};
113  // **************************************************************
114  // ** EffCheck
115  // **************************************************************
117  // Efficiencies
118  nbins3D_1[0]= 100; nbins3D_1[1]= 8; nbins3D_1[2]= 48; nbins3D_1[3]= 100;
119  fGlobalCoords3Dlo[0]= -1000; fGlobalCoords3Dlo[1]= -1; fGlobalCoords3Dlo[2]= -M_PI; fGlobalCoords3Dlo[3]= 0;
120  fGlobalCoords3Dup[0]= 1000; fGlobalCoords3Dup[1]= 1; fGlobalCoords3Dup[2]= M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
121  for(int i=0;i<2;i++){// AC
122  for(int k=0;k<2;k++){// WireStrip
123  for(int e=0;e<4;e++){// EffNumDenom
124  // Station Efficiency Map Segm Track
125  sst<<WireStrip[k];
126  sst<<"_EfficiencyAgainstMDT";
127  sst<<"_MapSegmTrack"<<EffNumDenom[e];
128  sst<<"_"<<AC[i];
129  ATH_MSG_DEBUG("Eff_StationMapBase "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
130  m_eff_stationmapbase[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
131  if(i==0){
132  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmapbase[i][k][e]) );
133  }else{
134  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmapbase[i][k][e]) );
135  }
136 
137  labelStationMap(m_eff_stationmapbase[i][k][e], i,k);
138  sst.str("");
139 
140  // Station Efficiency Map Midstation Segments
141  sst<<WireStrip[k];
142  sst<<"_EfficiencyAgainstMDT";
143  sst<<"_MapMidOnly"<<EffNumDenom[e];
144  sst<<"_"<<AC[i];
145  ATH_MSG_DEBUG("Eff_StationMapMid "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
146  m_eff_stationmapmid[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
147  if(i==0){
148  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmapmid[i][k][e]) );
149  }else{
150  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmapmid[i][k][e]) );
151  }
152 
153  labelStationMap(m_eff_stationmapmid[i][k][e], i,k);
154  sst.str("");
155 
156  // Station Efficiency Map Total
157  sst<<WireStrip[k];
158  sst<<"_EfficiencyAgainstMDT";
159  sst<<"_Map"<<EffNumDenom[e];
160  sst<<"_"<<AC[i];
161  ATH_MSG_DEBUG("Eff_StationMap "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
162  m_eff_stationmap[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
163  if(i==0){
164  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmap[i][k][e]) );
165  }else{
166  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmap[i][k][e]) );
167  }
168 
169  labelStationMap(m_eff_stationmap[i][k][e], i,k);
170  sst.str("");
171  }// EffNumDenom
172  }// WireStrip
173  }// AC
174 
176  // Sagittas
177 
178 
179  nbins3D_1[0]= 8000; nbins3D_1[1]= 200; nbins3D_1[2]= 4096; nbins3D_1[3]= 40000;
180  fGlobalCoords3Dlo[0]= -8000; fGlobalCoords3Dlo[1]= -1; fGlobalCoords3Dlo[2]= -M_PI; fGlobalCoords3Dlo[3]= -200000;
181  fGlobalCoords3Dup[0]= 8000; fGlobalCoords3Dup[1]= 1; fGlobalCoords3Dup[2]= M_PI; fGlobalCoords3Dup[3]= 200000;
182  for(int i=0;i<2;i++){// AC
183  for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
184  for(int f=0;f<2;f++){// FE
185  for(int k=0;k<2;k++){// WireStrip
186  for(int x=0;x<4;x++){// RhoEtaPhi
187  if(x==0||x==2){ // Only interested in Rho and Phi
188  // TGC EIFI vs MDT extrapolated position, Sagitta
189  sst<<"TGC_SegmTrack_"<<RhoEtaPhiZ[x];
190  sst<<"Sagitta_T"<<jTGC+1;
191  sst<<FE[f];
192  sst<<WireStrip[k];
193  sst<<"_"<<AC[i];
194  ATH_MSG_DEBUG("TGC_Sagitta "<<i<<" "<<jTGC<<" "<<f<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
195  m_mvt_extrprdsag[i][jTGC][f][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
196  if(i==0){
197  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_extrprdsag[i][jTGC][f][k][x]) );
198  }else{
199  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_extrprdsag[i][jTGC][f][k][x]) );
200  }
201 
202  m_mvt_extrprdsag[i][jTGC][f][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
203  sst.str("");
204 
205  // TGC EIFI vs MDT extrapolated position, Sagitta
206  sst<<"TGC_MidSegm_"<<RhoEtaPhiZ[x];
207  sst<<"Sagitta_T"<<jTGC+1;
208  sst<<FE[f];
209  sst<<WireStrip[k];
210  sst<<"_"<<AC[i];
211  ATH_MSG_DEBUG("TGC_Sagitta "<<i<<" "<<jTGC<<" "<<f<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
212  m_mvt_extrprdsag2[i][jTGC][f][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
213  if(i==0){
214  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_extrprdsag2[i][jTGC][f][k][x]) );
215  }else{
216  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_extrprdsag2[i][jTGC][f][k][x]) );
217  }
218 
219  m_mvt_extrprdsag2[i][jTGC][f][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
220  sst.str("");
221  }
222  }// RhoEtaPhi
223  }// WireStrip
224  }// FE
225  }// TGC Station
226  }// AC
227 
228 
229  for(int k=0;k<2;k++){// WireStrip
230  if(k==0){
231  nbins3D_1[0]= 10000; nbins3D_1[1]= 1200; nbins3D_1[2]= 8192; nbins3D_1[3]= 40000;
232  fGlobalCoords3Dlo[0]= -1000; fGlobalCoords3Dlo[1]= -3; fGlobalCoords3Dlo[2]=-1*M_PI/8; fGlobalCoords3Dlo[3]= -200000;
233  fGlobalCoords3Dup[0]= 1000; fGlobalCoords3Dup[1]= 3; fGlobalCoords3Dup[2]= M_PI/8; fGlobalCoords3Dup[3]= 200000;
234  }
235  else{
236  nbins3D_1[0]= 10000; nbins3D_1[1]= 1200; nbins3D_1[2]= 8192; nbins3D_1[3]= 40000;
237  fGlobalCoords3Dlo[0]= -5000; fGlobalCoords3Dlo[1]= -3; fGlobalCoords3Dlo[2]=-1*M_PI/8; fGlobalCoords3Dlo[3]= -200000;
238  fGlobalCoords3Dup[0]= 5000; fGlobalCoords3Dup[1]= 3; fGlobalCoords3Dup[2]= M_PI/8; fGlobalCoords3Dup[3]= 200000;
239  }
240  for(int i=0;i<2;i++){// AC
241  for(int x=0;x<4;x++){// RhoEtaPhiZ
242  if(x==0||x==2){ // Only interested in Rho and Phi
243  // TGC PRD comparison for Mid Only Check
244  sst<<"TGC_MidStationPRD_"<<RhoEtaPhiZ[x];
245  sst<<"Sagitta_"<<WireStrip[k];
246  sst<<"_"<<AC[i];
247  ATH_MSG_DEBUG("TGC_PRDonly_Sagitta "<<i<<" "<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
248  m_tgc_prdcompsag[i][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
249  if(i==0){
250  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_tgc_prdcompsag[i][k][x]) );
251  }else{
252  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_tgc_prdcompsag[i][k][x]) );
253  }
254 
255  m_tgc_prdcompsag[i][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
256  sst.str("");
257  }
258  }// WireStrip
259  }// RhoEtaPhiThe
260  }// AC
261 
262 
264  // Segment Positions
265 
266  // Initialize to zero
267  for(int i=0;i<2;i++)// AC
268  for(int jMDT1=0;jMDT1<4;jMDT1++)// MDT Station1
269  for(int jMDT2=0;jMDT2<4;jMDT2++)// MDT Station2
270  for(int x=0;x<4;x++){
271  m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]=nullptr;
272  }
273 
274  nbins3D_1[0]= 2000; nbins3D_1[1]= 200; nbins3D_1[2]= 4096; nbins3D_1[3]= 1024;
275  fGlobalCoords3Dlo[0]= -1000; fGlobalCoords3Dlo[1]= -1; fGlobalCoords3Dlo[2]= -M_PI/8; fGlobalCoords3Dlo[3]= 0;
276  fGlobalCoords3Dup[0]= 1000; fGlobalCoords3Dup[1]= 1; fGlobalCoords3Dup[2]= M_PI/8; fGlobalCoords3Dup[3]= 0.5*M_PI;
277  for(int i=0;i<2;i++){// AC
278  for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station1
279  for(int jMDT2=0;jMDT2<4;jMDT2++){// MDT Station2
280  //if(jMDT1==jMDT2)continue;
281  for(int x=0;x<4;x++){// RhoEtaPhiThe
282  if(x==0||x==2||x==3){// Not interested in Eta
283  // Segm Matching Sag
284  sst<<"MDT_Matching_"<<RhoEtaPhiThe[x];
285  sst<<"Sagitta_MDT"<<jMDT1+1;
286  sst<<"vsMDT"<<jMDT2+1;
287  sst<<"_"<<AC[i];
288  ATH_MSG_DEBUG("MDT_MatchingSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
289  m_mdt_segmmatchsag[i][jMDT1][jMDT2][x] =new TH1F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
290  if(i==0){
291  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]) );
292  }else{
293  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]) );
294  }
295 
296  m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
297  sst.str("");
298  }
299  }
300  }
301  }
302  }
303 
304 
306  // Segment Directions
307 
308  for(int i=0;i<2;i++)// AC
309  for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station2
310  for(int x=0;x<4;x++){// RhoEtaPhiThe
311  m_mdt_segmposdirsag[i][jMDT1][x]=nullptr;
312  }
313  for(int jMDT2=0;jMDT2<4;jMDT2++){
314  for(int x=0;x<4;x++){
315  m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]=nullptr;
316  for(int v=0;v<2;v++){
317  m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]=nullptr;
318  }
319  }
320  }
321  }
322 
323  nbins3D_1[0]= 2000; nbins3D_1[1]= 200; nbins3D_1[2]= 8192; nbins3D_1[3]= 2048;
324  fGlobalCoords3Dlo[0]= -1000; fGlobalCoords3Dlo[1]= -1; fGlobalCoords3Dlo[2]= -2*M_PI; fGlobalCoords3Dlo[3]=-0.5*M_PI;
325  fGlobalCoords3Dup[0]= 1000; fGlobalCoords3Dup[1]= 1; fGlobalCoords3Dup[2]= 2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
326  for(int i=0;i<2;i++){// AC
327  for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station2
328  for(int x=0;x<4;x++){// RhoEtaPhiThe
329  if(x==2||x==3){ // Only interested in Phi & Theta
330  // Segm Pos-Dir Sag
331  sst<<"MDT_PosDir_"<<RhoEtaPhiThe[x];
332  sst<<"Sagitta_MDT"<<jMDT1+1;
333  sst<<"_"<<AC[i];
334  ATH_MSG_DEBUG("MDT_PosDirSagitta "<<i<<" "<<jMDT1<<" "<<x<<" "<<sst.str().c_str() );
335  m_mdt_segmposdirsag[i][jMDT1][x] =new TH1F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
336  if(i==0){
337  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmposdirsag[i][jMDT1][x]) );
338  }else{
339  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmposdirsag[i][jMDT1][x]) );
340  }
341  m_mdt_segmposdirsag[i][jMDT1][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
342  sst.str("");
343  }
344  }// RhoEtaPhiThe
345 
346  for(int jMDT2=0;jMDT2<4;jMDT2++){// MDT Station2
347  //if(jMDT1==jMDT2)continue;// Cut same station comparison
348  for(int x=0;x<4;x++){// RhoEtaPhiThe
349  if(x==2||x==3){ // Only interested in Phi & Theta
350  // Track Dir-Dir Sag
351  sst<<"MDT_DirDir_"<<RhoEtaPhiThe[x];
352  sst<<"Sagitta_MDT"<<jMDT1+1;
353  sst<<"vsMDT"<<jMDT2+1;
354  sst<<"_"<<AC[i];
355  ATH_MSG_DEBUG("MDT_DirDirSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
356  m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x] =new TH1F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
357  if(i==0){
358  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]) );
359  }else{
360  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]) );
361  }
362 
363  m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
364  sst.str("");
365 
366  for(int v=0;v<2;v++){
367  if(jMDT1>=jMDT2)continue;// Regard vector comparison between two stations as
368  // Track Direction Check
369  sst<<"MDT_TrackCheck_"<<RhoEtaPhiThe[x];
370  sst<<"Sagitta_MDT"<<jMDT1+1;
371  sst<<"vs"<<jMDT2+1;
372  sst<<"_MDT";
373  if(v==0)sst<<jMDT1+1;
374  else sst<<jMDT2+1;
375  sst<<"_"<<AC[i];
376  ATH_MSG_DEBUG("MDT_TrackCheckSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
377  m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v] =new TH1F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
378  if(i==0){
379  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]) );
380  }else{
381  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]) );
382  }
383  m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
384  sst.str("");
385  }
386  }
387  }// RhoEtaPhiThe
388  }// MDT Station2
389  }// MDT Station1
390  }// AC
391 
392  return StatusCode::SUCCESS;
393 }

◆ 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 MdtVsTgcRawDataValAlg::bookHistogramsRecurrent ( )
virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 134 of file MdtVsTgcRawDataValAlg.cxx.

134  {
135 /*----------------------------------------------------------------------------------*/
136  ATH_MSG_DEBUG( "TGC RawData Monitoring Histograms being booked" );
137 
138  //declare a group of histograms
139  std::string generic_path_mdtvstgclv1 = "Muon/MuonRawDataMonitoring/MDTvsTGC";
140  //MonGroup mdtvstgclv1_expert( this, generic_path_mdtvstgclv1+"/Global", expert, run );
141  MonGroup mdtvstgclv1_expert_a( this, generic_path_mdtvstgclv1+"/TGCEA", run, ATTRIB_UNMANAGED );
142  MonGroup mdtvstgclv1_expert_c( this, generic_path_mdtvstgclv1+"/TGCEC", run, ATTRIB_UNMANAGED );
143 
144  if(newRunFlag()){
145  ATH_MSG_INFO( "MdtVsTgc RawData Monitoring : begin of run" );
146 
147  ATH_CHECK( bookmaphists(mdtvstgclv1_expert_a, mdtvstgclv1_expert_c) );
148  ATH_CHECK( bookeffhists(mdtvstgclv1_expert_a, mdtvstgclv1_expert_c) );
149  }//isNewRun
150  return StatusCode::SUCCESS;
151 }

◆ 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 }

◆ bookmaphists()

StatusCode MdtVsTgcRawDataValAlg::bookmaphists ( MonGroup &  mdtvstgclv1_expert_a,
MonGroup &  mdtvstgclv1_expert_c 
)
private

Definition at line 27 of file MdtVsTgcRawData_bookhistograms.cxx.

28  {
29 
30  std::stringstream sst;
31  std::string AC[2]= {"A","C"};
32  int nbins3D_1[4]= { 0, 0, 0, 0};
33  float fGlobalCoords3Dlo[4]= { 0, 0, 0, 0};
34  float fGlobalCoords3Dup[4]= { 0, 0, 0, 0};
35  // **************************************************************
36  // ** maphists
37  // **************************************************************
39  // Number of~ hists
40  nbins3D_1[0]= 480; nbins3D_1[1]= 120; nbins3D_1[2]= 128; nbins3D_1[3]= 100;
41  fGlobalCoords3Dlo[0]= 0; fGlobalCoords3Dlo[1]= 0; fGlobalCoords3Dlo[2]= 0; fGlobalCoords3Dlo[3]= 0;
42  fGlobalCoords3Dup[0]= 12000; fGlobalCoords3Dup[1]= 3; fGlobalCoords3Dup[2]= 2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
43  for(int i=0;i<2;i++){// AC
44  // nEvents passing cut criteria
45  sst<<"EffCheck_CutsPassed_"<<AC[i];
46  ATH_MSG_DEBUG("EffCheck_CutsPassed "<<i<<" "<<sst.str().c_str() );
47  m_mvt_cutspassed[i] =new TH1I(sst.str().c_str(), sst.str().c_str(), 14, 1, 15);
48  if(i==0){
49  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_cutspassed[i]) );
50  }else{
51  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_cutspassed[i]) );
52  }
53 
54  m_mvt_cutspassed[i]->GetYaxis()->SetTitle("nEvents");
55  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(1, "Events");
56  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(2, "matchedSegm=0");
57  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(3, "matchedSegm>1");
58  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(4, "matchedSegm=1");
59  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(5, "+HasEIFI");
60  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(6, "EIFIMatch");
61  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(7, "+HasT1");
62  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(8, "T1Match");
63  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(9,"+HasT2");
64  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(10,"T2Match");
65  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(11,"+HasT3");
66  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(12,"T3Match");
67  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(13,"AllStationsMatch");
68  m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(14,"AllLayersMatch");
69  sst.str("");
70  }// AC
71 
72 
74  // Distributions
75  nbins3D_1[0]= 600; nbins3D_1[1]= 120; nbins3D_1[2]= 128; nbins3D_1[3]= 128;
76  fGlobalCoords3Dlo[0]= 0; fGlobalCoords3Dlo[1]= 0; fGlobalCoords3Dlo[2]= 0; fGlobalCoords3Dlo[3]= 0;
77  fGlobalCoords3Dup[0]= 12000; fGlobalCoords3Dup[1]= 3; fGlobalCoords3Dup[2]= 2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
78  for(int i=0;i<2;i++){// AC
79  for(int jMDT=0;jMDT<4;jMDT++){// MDT Station
80  // MDT Segm Eta vs Phi
81  sst<<"MDT_SegmMap_MDT"<<jMDT+1;
82  sst<<"_"<<AC[i];
83  ATH_MSG_DEBUG("MDT_SegmMap "<<i<<" "<<jMDT<<" "<<sst.str().c_str() );
84  m_mdt_segmmap[i][jMDT] =new TH2F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[2], fGlobalCoords3Dlo[2], fGlobalCoords3Dup[2], nbins3D_1[1], fGlobalCoords3Dlo[1], fGlobalCoords3Dup[1]);
85  if(i==0){
86  ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmmap[i][jMDT]) );
87  }else{
88  ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmmap[i][jMDT]) );
89  }
90 
91  m_mdt_segmmap[i][jMDT]->GetXaxis()->SetTitle("MDT Phi");
92  m_mdt_segmmap[i][jMDT]->GetYaxis()->SetTitle("MDT Eta");
93  sst.str("");
94  }// MDT Station
95  }// AC
96  return StatusCode::SUCCESS;
97 }

◆ 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 }

◆ CheckTGConTrack()

void MdtVsTgcRawDataValAlg::CheckTGConTrack ( std::vector< SegmTrack >(&)  matchedSegments[2],
const Muon::TgcPrepDataContainer *  tgc_prepcontainer 
)
private

Definition at line 36 of file MdtVsTgcRawData_PRDonTrack.cxx.

37  {
38  // Define Cuts:
39  // Loose cut for PRD and Extrapolated
40  const float dPhiCut_Loose = M_PI/8;
41  // Cut for Global Position Efficiencies
42  const float dPhiCutGlobal[2] = {static_cast<float>(M_PI/24),static_cast<float>(M_PI/12)}; //[WireStrip]
43  const float dRhoCutGlobal[2] = { 0.08, 0.5}; //[WireStrip]
44  // Cut for Sector Efficiencies
45  const float dPhiCutSector[2] = { 0.2, 0.1}; //[WireStrip]
46  const float dRhoCutSector[2] = { 200, 2000}; //[WireStrip]
47 
48  // Loop over sides
49  for(int i=0;i<2;i++){// AC
50  // Get number of tracks
51  unsigned int nTrack=matchedSegments[i].size();
52 
53  // Fill nEvents histograms
54  m_mvt_cutspassed[i]->Fill(1);
55  if(nTrack==0)m_mvt_cutspassed[i]->Fill(2);
56  if(nTrack>1)m_mvt_cutspassed[i]->Fill(3);
57  if(nTrack==1)m_mvt_cutspassed[i]->Fill(4);
58 
59  // Cut events without exactly one set of matched Segments
60  if(nTrack!=1)continue;
61 
62  // Declare Position variables for inner
63  //Trk::GlobalPosition innerSegmPos;
64  Amg::Vector3D innerSegmPos = {0, 0, 0};
65 
66  // float innerSegmEta=0;
67  float innerSegmRho=0; float innerSegmPhi=0; float innerSegmZ=0;
68  //Trk::GlobalDirection innerSegmDirzunit;
69  Amg::Vector3D innerSegmDirzunit = {0, 0, 0};
70 
71  // Declare Position variables for midstation
72  //Trk::GlobalPosition midSegmPos;
73  Amg::Vector3D midSegmPos = {0, 0, 0};
74 
75  // float midSegmRho =0; float midSegmEta =0;
76  float midSegmPhi =0; float midSegmZ =0;
77  //Trk::GlobalDirection midSegmDirzunit;
78  Amg::Vector3D midSegmDirzunit = {0, 0, 0};
79 
80  // Check which layers have sufficienct segments to operate on for global coordinates
81  bool canCheckGlobal[4] = {0, 0, 0, 0};// [TGCStation]
82  if(matchedSegments[i].at(0).at(2)!=nullptr){
83  // Check Midstation
84  canCheckGlobal[0]=true; canCheckGlobal[1]=true; canCheckGlobal[2]=true;
85  // Read Midstation Segment Values into variables
86  midSegmPos = Amg::Vector3D(matchedSegments[i].at(0).at(2)->globalPosition());
87  midSegmPhi = midSegmPos.phi();
88  midSegmZ = midSegmPos.z();
89  if(midSegmPhi<0)midSegmPhi+=2*M_PI;
90  midSegmDirzunit = Amg::Vector3D(midSegmPos/std::abs(midSegmZ));
91  }
92  if((matchedSegments[i].at(0).at(0)!=nullptr)&&(matchedSegments[i].at(0).at(2)!=nullptr)){
93  // Check EIFI
94  canCheckGlobal[3]=true;
95  // Read Inner Segment Values
96  innerSegmPos = Amg::Vector3D(matchedSegments[i].at(0).at(0)->globalPosition());
97  innerSegmRho = std::abs(innerSegmPos.perp());
98  innerSegmZ = std::abs(innerSegmPos.z());
99  // Modify position
100  innerSegmPhi = midSegmPhi;
101 
102  innerSegmPos = Amg::Vector3D(innerSegmRho*std::cos(innerSegmPhi), innerSegmRho*std::sin(innerSegmPhi), innerSegmZ);
103  innerSegmDirzunit = Amg::Vector3D(innerSegmPos/std::abs(innerSegmZ));
104  }
105 
106  // If no layers can be checked (i.e. no midstation segment matched) skip side
107  bool skipSide = true;
108  for(int jTGC=0;jTGC<4;jTGC++)if(canCheckGlobal[jTGC]==true)skipSide=false;
109  if(skipSide==true)continue;
110 
111  // Initialize variables for TRE array search
112  int TGCStationNames[8] ={41, 42, 43, 44, 45, 46, 47, 48};
113  int TGCstation_StationFE[4] ={-1,-1,-1,-1};// [TGCStation]
114  int TGCstation_StationEta[4]={ 0, 0, 0, 0};// [TGCStation]
115  int TGCstation_StationPhi[4]={ 0, 0, 0, 0};// [TGCStation]
116  int nStationMatch[4] ={ 0, 0, 0, 0};// [TGCStation]
117  bool canCheckSector[4] ={ true, true, true, true};// [TGCStation]
118 
119  // Loop through TRE array, finding sectors which match the track in each layer
120  for(int stationnameindex=0; stationnameindex<8; stationnameindex++){// Station {T1F,T1E,T2F,T2E,T3F,T3E,T4F,T4E}
121  // Skip stations which don't have sufficient Segments to run efficiency check
122  int stationName = TGCStationNames[stationnameindex];
123  int stationIndex= TGCstationname2stationindex(stationName);
124  if(stationIndex<0) continue;
125  if(!canCheckGlobal[stationIndex])continue;
126 
127  // Loop over StationEta&StationPhi
128  for(int stationeta=1; stationeta<=8; stationeta++){// AbsStationEta
129  for(int stationphi=1; stationphi<=48; stationphi++){// StationPhi
130  // Cut Station EtaPhi combinations with no TGC element
131  if(m_TREarray[stationnameindex][i][stationeta][stationphi]==nullptr)continue;
132  const MuonGM::TgcReadoutElement *tre=m_TREarray[stationnameindex][i][stationeta][stationphi];
133 
134  // Extrapolate position from nearest Station's Segment to Sector's Z
135  float sectorZ=tre->globalPosition().z();
136  //Trk::GlobalPosition sectorExtrapolatedPos;
137  Amg::Vector3D sectorExtrapolatedPos;
138 
139  if(stationIndex==3){// Inner
140  float dZ_sector=std::abs(sectorZ)-std::abs(innerSegmZ);
141  //sectorExtrapolatedPos = Trk::GlobalPosition(innerSegmPos+(innerSegmDirzunit*dZ_sector));
142  sectorExtrapolatedPos = Amg::Vector3D(innerSegmPos+(innerSegmDirzunit*dZ_sector));
143  }
144  else{// Midstation
145  float dZ_sector=std::abs(sectorZ)-std::abs(midSegmZ);
146  sectorExtrapolatedPos = Amg::Vector3D(midSegmPos+(midSegmDirzunit*dZ_sector));
147  }
148 
149  // Convert extrapolated position to local position on the Sector
150  Identifier sector_id=tre->identify();
151  const Amg::Vector3D sectorLocalPos3D=tre->globalToLocalTransf(sector_id)*sectorExtrapolatedPos;
152  Amg::Vector2D sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
153 
154  double avWidth = (tre->getLongSsize()+tre->getSsize())/2;
155  //double dWidth = (tre->longWidth()-tre->shortWidth());
156  double length = tre->length();
157 
158  // Cut sectors which the track does not go through the central 80% of (avoids double counts)
159  double tol1=-0.1*(avWidth/2);
160  double tol2=-0.1*(length/2);
161 
162  bool insideSectorBounds=tre->bounds().inside(sectorLocalPos2D,tol1,tol2);
163  if(!insideSectorBounds)continue;
164 
165  // Assign values to matching station variables
166  TGCstation_StationFE[stationIndex]= (tre->isForward()==false);
167  TGCstation_StationEta[stationIndex]=stationeta;
168  TGCstation_StationPhi[stationIndex]=stationphi;
169  nStationMatch[stationIndex]++;
170  }// StationPhi
171  }// StationEta
172  }// StationName
173 
174  // Don't check stations that don't have exactly 1 match for this track
175  for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
176  if(nStationMatch[jTGC]==0){
177  canCheckSector[jTGC]=false;
178  }
179  else if(nStationMatch[jTGC]>1){
180  canCheckSector[jTGC]=false;
181  // Should be impossible, but happens due a problem with the bounds().inside function
182  // commenting out until this bug is resolved
183  //m_log << MSG::WARNING << "SegmTrack: Number of matches for TGC" << jTGC+1 << " is " << nStationMatch[jTGC] << endl;
184  }
185  }// TGC Station
186 
187  // Loop through segments to check number of TGC Strips in each
188  int nTGCStrips[4] = {0, 0, 0, 0};//[TGCStation]
189  for(int jMDT=0;jMDT<4;jMDT++){// MDT Station
190  if(matchedSegments[i].at(0).at(jMDT)==nullptr)continue;
191  const Muon::MuonSegment *segm=matchedSegments[i].at(0).at(jMDT);
192  // Loop through contained ROTs and identify used stations
193  const std::vector<const Trk::MeasurementBase*> mMeasTrk = segm->containedMeasurements();
194  ATH_MSG_DEBUG( "number of MeasurementBase: "<<mMeasTrk.size() );
195  for (unsigned int i=0; i<mMeasTrk.size(); i++) {
196  const Trk::MeasurementBase* m = mMeasTrk[i];
197  //const Trk::RIO_OnTrack* rio = dynamic_cast<const Trk::RIO_OnTrack*>(m);
198  const Muon::CompetingMuonClustersOnTrack* crot = dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>(m);
199  if(crot) {
200  const std::vector<const Muon::MuonClusterOnTrack*> mc_list = crot->containedROTs();
201  for(unsigned int iROT=0; iROT< mc_list.size(); iROT++){
202  const Muon::MuonClusterOnTrack * rio = mc_list[iROT];
203  //const Trk::RIO_OnTrack* rio = crot->rioOnTrack(iROT);
204  Identifier id = rio->identify();
205  int stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
206  // 41=T1F 42=T1E 43=T2F 44=T2E 45=T3F 46=T3E 47=T4F 48=T4E
207  if(m_idHelperSvc->tgcIdHelper().isStrip(id)){
208  if((jMDT==2)&&((stationName==41)||(stationName==42)))nTGCStrips[0]++;// TGC
209  if((jMDT==2)&&((stationName==43)||(stationName==44)))nTGCStrips[1]++;// TGC
210  if((jMDT==2)&&((stationName==45)||(stationName==46)))nTGCStrips[2]++;// TGC
211  if((jMDT==0)&&((stationName==47)||(stationName==48)))nTGCStrips[3]++;// TGC
212  }
213 
214  ATH_MSG_DEBUG( " check if TGC strip: "<<m_idHelperSvc->tgcIdHelper().isStrip(id)<<" StationName: "<<stationName );
215  }
216  }
217  }
218  }// MDT Station
219 
220 
221  // Don't check mid-stations when there are no strips in other mid-stations
222  if((nTGCStrips[1]==0)&&(nTGCStrips[2]==0)){canCheckSector[0]=false;canCheckGlobal[0]=false;}
223  if((nTGCStrips[0]==0)&&(nTGCStrips[2]==0)){canCheckSector[1]=false;canCheckGlobal[1]=false;}
224  if((nTGCStrips[0]==0)&&(nTGCStrips[1]==0)){canCheckSector[2]=false;canCheckGlobal[2]=false;}
225 
226  // Initialise hit registered arrays
227  // bool hitregistered[9][2];
228  bool sectorhitregistered[9][2];
229  for(int l=0;l<9;l++){// Layer
230  for(int k=0;k<2;k++){// WireStrip
231  // hitregistered[l][k]=false;
232  sectorhitregistered[l][k]=false;
233  }// WireStrip
234  }// Layer
235 
236  // Initialise flags for whether a layer in this event has PRD and PRD which matched the current track
237  bool HasPRD[9] ={false,false,false,false,false,false,false,false,false};
238  bool PRDMatch[9]={false,false,false,false,false,false,false,false,false};
239 
240  // Loop over TGC Prep Data container
241  Muon::TgcPrepDataContainer::const_iterator prepit_end=tgc_prepcontainer->end();
242  for( Muon::TgcPrepDataContainer::const_iterator prepit=tgc_prepcontainer->begin();
243  prepit!=prepit_end;
244  ++prepit){
245 
246  //loop over TGC Prep Data collection
247  Muon::TgcPrepDataCollection::const_iterator prepitc_end=(*prepit)->end();
248  for( Muon::TgcPrepDataCollection::const_iterator prepitc=(*prepit)->begin();
249  prepitc!= prepitc_end;
250  ++prepitc){
251  // Get PRD and variables
252  const Muon::TgcPrepData* tpd=*prepitc;
253  const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
254  const std::string stationType = tre->getStationType();
255 
256  // Get id values
257  Identifier tgcid=(*prepitc)->identify();
258  int tgcAC=(tre->sideA()==false);//isNotAside a:0, c:1
259  int tgcFE=(tre->isForward()==false);//isNotForward f:0, e:1
260  int tgcWS=(m_idHelperSvc->tgcIdHelper().isStrip(tgcid));//isStrip w=0, s=1
261  int stationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
262  int stationEta = std::abs(tre->getStationEta());
263  int stationPhi = tre->getStationPhi();
264  int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(tgcid);
265 
266  // Cut hits except those from same side EIFI & Midstation
267  if(tgcAC!=i) continue;
268  if(stationName>48 || stationName<41) continue;
269 
270  // Get layer number and stationIndex
271  int layer = TGCgetlayer(stationName,gasGap);
272  int stationIndex = TGCstationname2stationindex(stationName);
273 
274  // Skip PRD in stations which can't be checked
275  if(stationIndex<0) continue;
276  if(!(canCheckGlobal[stationIndex]||canCheckSector[stationIndex]))continue;
277  if(layer<0) continue;
278  HasPRD[layer]=true;
279 
280  // Get position variables
281  // const Trk::GlobalPosition prdPos = tpd->globalPosition();
282  const Amg::Vector3D prdPos = tpd->globalPosition();
283  float tgcRho = std::abs(prdPos.perp());
284  float tgcPhi = prdPos.phi();
285  float tgcZ = prdPos.z();
286  if(tgcPhi<0)tgcPhi+=2*M_PI;
287 
288  // Run Extrapolation
289  // Trk::GlobalPosition tgcExtrapolatedPos;
290  Amg::Vector3D tgcExtrapolatedPos;
291  if(stationIndex==3){// Extrapolate position from Inner Position to PRD Z position
292  //if(innerSegmPos=0)m_log << MSG::WARNING << "MidstationOnly: innerSegmPos=0 but passed canCheckGlobal" );
293  float dZ = std::abs(tgcZ) - std::abs(innerSegmZ);
294  //tgcExtrapolatedPos = Trk::GlobalPosition(innerSegmPos+(innerSegmDirzunit*dZ));
295  tgcExtrapolatedPos = Amg::Vector3D(innerSegmPos+(innerSegmDirzunit*dZ));
296  }
297  else{// Extrapolate position from Midstation Position to PRD Z position
298  float dZ = std::abs(tgcZ) - std::abs(midSegmZ);
299  //tgcExtrapolatedPos = Trk::GlobalPosition(midSegmPos+(midSegmDirzunit*dZ));
300  tgcExtrapolatedPos = Amg::Vector3D(midSegmPos+(midSegmDirzunit*dZ));
301  }
302  float tgcExtrRho = std::abs(tgcExtrapolatedPos.perp());
303  float tgcExtrPhi = tgcExtrapolatedPos.phi();
304  if(tgcExtrPhi<0)tgcExtrPhi+=2*M_PI;
305 
306  // Get differences between extrapolated and segm2 positions
307  float dRho = tgcRho-tgcExtrRho;
308  float dPhi = tgcPhi-tgcExtrPhi;
309  if(dPhi<-M_PI)dPhi+=2*M_PI;
310  if(dPhi> M_PI)dPhi-=2*M_PI;
311 
312  // Pass through loose phi cut to eliminate some noise
313  if(std::abs(dPhi)<dPhiCut_Loose){
314  // Fill PRD sagitta histograms
315  if(m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][0]) m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][0]->Fill(dRho);
316  if(m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][2]) m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][2]->Fill(dPhi);
317 
318  // Global efficiency check
319  if(canCheckGlobal[stationIndex]){
320  // Do check
321  float dRhoCut = dRhoCutGlobal[tgcWS]*tgcExtrRho;
322  if(std::abs(dPhi)<dPhiCutGlobal[tgcWS] && std::abs(dRho)<dRhoCut){
323  }
324  }
325 
326  // Sector Efficiency Check
327  if(canCheckSector[stationIndex]){// If this station can be checked
328  if((stationEta==TGCstation_StationEta[stationIndex])&&
329  (stationPhi==TGCstation_StationPhi[stationIndex])&&
330  (tgcFE==TGCstation_StationFE[stationIndex])){// If Station FE&Eta&Phi match
331  if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
332  sectorhitregistered[layer][tgcWS]=true;
333  }
334  }// Station EtaPhi
335  }
336 
337  }// dPhi Loose Cut
338  }// TGC PRD Collection
339  }// TGC PRD Container
340 
341  // Fill Efficiency Histograms
342  for(int l=0;l<9;l++){// Layer
343  // Get Station Number
344  int stationIndex=TGClayer2stationindex(l);
345  if(stationIndex<0) continue;
346  for(int k=0;k<2;k++){// WireStrip
347  // If Segment Track matches a Sector
348  if(canCheckSector[stationIndex]){
349  if((TGCstation_StationFE[stationIndex]<0)||(TGCstation_StationEta[stationIndex]==0)||(TGCstation_StationPhi[stationIndex]==0)){
350  ATH_MSG_WARNING( "SegmTrack: canCheckSector passed for jTGC=" << stationIndex
351  << " but, FE=" << TGCstation_StationFE[stationIndex]
352  << " Eta=" << TGCstation_StationEta[stationIndex]
353  << " Phi=" << TGCstation_StationPhi[stationIndex] );
354  continue;
355  }
356  // Get Sector histogram indexes
357  int stationMap_EtaIndex=getStationMapIndex(1, l, TGCstation_StationFE[stationIndex], TGCstation_StationEta[stationIndex], TGCstation_StationPhi[stationIndex]);
358  int stationMap_PhiIndex=getStationMapIndex(2, l, TGCstation_StationFE[stationIndex], TGCstation_StationEta[stationIndex], TGCstation_StationPhi[stationIndex]);
359  // Fill Sector efficiency histograms
360  if(sectorhitregistered[l][k]){// Hit in Sector matches extrapolated track
361  m_eff_stationmapbase[i][k][1]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
362  }
363  m_eff_stationmapbase[i][k][2]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
364  }
365  }// WireStrip
366  }// Layer
367 
368  // Fill +Has Station bins of histogram
369  if(HasPRD[0]||HasPRD[1]||HasPRD[2])m_mvt_cutspassed[i]->Fill(7);
370  if(HasPRD[3]||HasPRD[4])m_mvt_cutspassed[i]->Fill(9);
371  if(HasPRD[5]||HasPRD[6])m_mvt_cutspassed[i]->Fill(11);
372  if(HasPRD[7]||HasPRD[8])m_mvt_cutspassed[i]->Fill(5);
373 
374  // Fill Match Station bins of histogram
375  if(PRDMatch[0]||PRDMatch[1]||PRDMatch[2])m_mvt_cutspassed[i]->Fill(8);
376  if(PRDMatch[3]||PRDMatch[4])m_mvt_cutspassed[i]->Fill(10);
377  if(PRDMatch[5]||PRDMatch[6])m_mvt_cutspassed[i]->Fill(12);
378  if(PRDMatch[7]||PRDMatch[8])m_mvt_cutspassed[i]->Fill(6);
379  if((PRDMatch[0]||PRDMatch[1]||PRDMatch[2])&&
380  (PRDMatch[3]||PRDMatch[4])&&
381  (PRDMatch[5]||PRDMatch[6])&&
382  (PRDMatch[7]||PRDMatch[8]))m_mvt_cutspassed[i]->Fill(13);
383  if((PRDMatch[0]&&PRDMatch[1]&&PRDMatch[2])&&
384  (PRDMatch[3]&&PRDMatch[4])&&
385  (PRDMatch[5]&&PRDMatch[6])&&
386  (PRDMatch[7]&&PRDMatch[8]))m_mvt_cutspassed[i]->Fill(14);
387 
388 
389  }// AC
390 }// End of function

◆ 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 }

◆ correlation()

void MdtVsTgcRawDataValAlg::correlation ( const Muon::MdtPrepDataContainer *  mdt_hit_container,
const Muon::TgcCoinDataContainer *  tgc_trigger_container 
)
private

<<"mmdtStationName "<<mdtStationName

Definition at line 27 of file MdtVsTgcRawData_correlation.cxx.

28  {
29 
30  ATH_MSG_DEBUG("inside correlation" );
31  //StatusCode sc=StatusCode::SUCCESS;
32 
33  // MuonDetectorManager from the conditions store
34  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
35  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
36  if(MuonDetMgr==nullptr){
37  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
38  return;
39  }
40 
41  //loop over TGC RoI container
42  Muon::TgcCoinDataContainer::const_iterator it_end=tgccontainer->end();
43  for( Muon::TgcCoinDataContainer::const_iterator it=tgccontainer->begin();
44  it!=it_end;
45  ++it){
46 
47 
48  ATH_MSG_DEBUG( "size of tgc collection is " << (*it) -> size() );
49 
50  //loop over TGC RoI collection
51  Muon::TgcCoinDataCollection::const_iterator itc_end=(*it)->end();
52  for( Muon::TgcCoinDataCollection::const_iterator itc=(*it)->begin();
53  itc!= itc_end;
54  ++itc){
55 
56  const Muon::TgcCoinData* tcd=*itc;
57  Identifier tgcid=(*itc)->identify();
58 
59  if( tcd->type() != Muon::TgcCoinData::TYPE_SL )continue;
60 
61  int ac=(tcd->isAside()==false);//isNotAside a:0, c:1
62  int ef=(tcd->isForward()==false);//isNotForward f:0, e:1
63  int phi48=tcd->phi();//48(24)
64  int roi=tcd->roi();
65  int roieta;//1-53
66  int roiphi;//1-192
67 
68  roi2etaphi(*tcd, roieta, roiphi);
69 
70  //int tgcMdtSector=roiphi2mdtSector(roiphi,ef);
71 
72  const MuonGM::TgcReadoutElement* pReadoutElementTGC = MuonDetMgr->getTgcReadoutElement(tgcid);
73  const Amg::Vector3D pos = pReadoutElementTGC->channelPos(tgcid);
74 
75  float tgcEta = std::abs(pos.eta());
76  float tgcPhi = pos.phi();
77  if(tgcPhi<0)tgcPhi+=2*M_PI;
78 
79 
80  ATH_MSG_DEBUG("ac "<<ac
81  <<" ef "<<ef
82  <<" phi48 "<<phi48
83  <<" roi "<<roi
84  <<" roieta "<<roieta
85  <<" roiphi "<<roiphi
86  <<" tgcEta "<<tgcEta
87  <<" tgcPhi "<<tgcPhi );
88 
89 
90  //loop over MDT container
91  Muon::MdtPrepDataContainer::const_iterator containerIt;
92  Muon::MdtPrepDataContainer::const_iterator container_end=mdt_hit_container->end();
93  for (containerIt = mdt_hit_container->begin() ;
94  containerIt != container_end ;
95  ++containerIt){
96 
97  Identifier mdt_id = (*containerIt)->identify();
98  // Field Range Notes
99  // ==============================================================================
100  // StationName unsigned integer maps to "BIL", "EMS" ,etc.
101  // StationEta [-6,-1] backward endcap (-1 at lowest R)
102  // [-8,8] barrel (increases with Z)
103  // [-6,-1]+[1,6] forward endcap (1 at lowest R)
104  // StationPhi [1,8] increases with phi
105  // Technology [0] maps to "MDT"
106  // Multilayer [1,2] barrel: increases with R
107  // endcap: increases with |Z|
108  // TubeLayer [1,4] barrel: increases with R
109  // endcap: increases with |Z|
110  // Tube [1,n] barrel: increases with |Z|
111  // endcap: increases with R
112  // ==============================================================================
113 
114  int mdtStationName = int(m_idHelperSvc->mdtIdHelper().stationName(mdt_id)) ;
115 
116  //SN Layer Tube Radial
117  //13:EIL 2x4 x54 x4
118  //49:EIS 2x4 x36 x2
119  //17:EML 2x3 x64 x5
120  //18:EMS 2x3 x64 x5
121  //20:EOL 2x3 x48 x6
122  //21:EOS 2x3 x48 x6
123 
124  //only Endcap MDT
125  //if(mdtStationName!=13 && mdtStationName!=49 && mdtStationName!=17 && mdtStationName!=18 && mdtStationName!=20 && mdtStationName!=21 )continue;
126 
127  //if (m_debuglevel){
128  //m_log<<MSG::DEBUG
130  // <<endmsg;
131  //}
132 
133  //only Endcap middle MDT
134  if(mdtStationName!=17 && mdtStationName!=18 )continue;
135 
136  int mdtStationEta = int(m_idHelperSvc->mdtIdHelper().stationEta(mdt_id)) ;//backward:[-6,-1], forward:[1,6], (1 or -1 at lowest R)
137  int mdtStationPhi = int(m_idHelperSvc->mdtIdHelper().stationPhi(mdt_id)) ;//[1:8]
138  int mdtAC = (mdtStationEta<0);//a:0, c:1
139 
140  float mdtSector=mdtStationPhi*2.-1.;
141  if(mdtStationName==18)mdtSector+=1;
142  double mdtSectorPhi = (mdtSector-1.)*M_PI/8.;
143 
144  //same Side
145  if(ac!=mdtAC)continue;
146  ATH_MSG_DEBUG( "size of mdt collection is " << (*containerIt) -> size() );
147 
148  ATH_MSG_DEBUG("mdtStationName "<<mdtStationName
149  <<" mdtStationEta "<<mdtStationEta
150  <<" mdtStationPhi "<<mdtStationPhi
151  <<" mdtSectorPhi "<<mdtSectorPhi );
152 
153  //loop over MDT PRD Collection
154  Muon::MdtPrepDataCollection::const_iterator collection_it_end=(*containerIt)->end();
155 
156 
157  int tmp[2][4][64];
158  for(int i=0;i<2;i++)
159  for(int j=0;j<4;j++)
160  for(int k=0;k<64;k++)
161  tmp[i][j][k]=0;
162 
163  for(Muon::MdtPrepDataCollection::const_iterator mdtCollection=(*containerIt)->begin();
164  mdtCollection!= collection_it_end;
165  ++mdtCollection){
166 
167  Identifier mdt_id2 = (*mdtCollection)->identify();
168 
169  int mdtMultiLayer = int(m_idHelperSvc->mdtIdHelper().multilayer(mdt_id2));
170  int mdtTubeLayer = int(m_idHelperSvc->mdtIdHelper().tubeLayer(mdt_id2));
171  int mdtTube = int(m_idHelperSvc->mdtIdHelper().tube(mdt_id2));
172  int mdtTubeIdForEM = (std::abs(mdtStationEta)-1)*64 + mdtTube -1;
173 
174  ATH_MSG_DEBUG("mdtMultiLayer "<<mdtMultiLayer
175  <<" mdtTubeLayer "<<mdtTubeLayer
176  <<" mdtTube "<<mdtTube
177  <<" mdtTubeIdForEM "<<mdtTubeIdForEM );
178 
179  if(tmp[mdtMultiLayer-1][mdtTubeLayer-1][mdtTube-1]==1)continue;
180  tmp[mdtMultiLayer-1][mdtTubeLayer-1][mdtTube-1]=1;
181 
182  int adc = (*mdtCollection)->adc();
183  int tdc = (*mdtCollection)->tdc();
184 
185  if(adc < m_MdtAdcCut )continue;
186 
187  const MuonGM::MdtReadoutElement* pReadoutElementMDT = MuonDetMgr->getMdtReadoutElement(mdt_id2);
188  const Amg::Vector3D mdtgPos = pReadoutElementMDT->tubePos(mdt_id2); //global position of the wire
189  float mdtEta = std::abs(mdtgPos.eta());
190  float mdtPhi = mdtgPos.phi();
191  float mdtr = mdtgPos.perp();
192  float mdtz = mdtgPos.z();
193  if(mdtPhi<0)mdtPhi+=2*M_PI;
194 
195  ATH_MSG_DEBUG(" Name "<<mdtStationName
196  <<" Eta "<<mdtStationEta
197  <<" Phi "<<mdtStationPhi
198  <<" MultiLayer "<<mdtMultiLayer
199  <<" TubeLayer "<<mdtTubeLayer
200  <<" Tube "<<mdtTube
201  <<" TubeIdForEM "<<mdtTubeIdForEM
202  <<" Eta "<<mdtEta
203  <<" Phi "<<mdtPhi
204  <<" r "<<mdtr
205  <<" z "<<mdtz
206  <<" Sec "<<mdtSector
207  <<" SecPhi "<<mdtSectorPhi
208  <<" ADC "<<adc
209  <<" TDC "<<tdc );
210 
211  }//MDT collection
212  }//MDT container
213  }//TGC collection
214  }//TGC container
215 }

◆ 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; }

◆ DQCheckMDTSegments()

void MdtVsTgcRawDataValAlg::DQCheckMDTSegments ( std::vector< const Muon::MuonSegment * >(&)  sortedSegments[2][4],
std::vector< const Muon::MuonSegment * >(&)  disqualifiedSegments[2][4] 
)
private

Definition at line 34 of file MdtVsTgcRawData_SegmDQ.cxx.

35  {
36  // Define Cuts:
37  // Cut for miniumum number of measurements necessary to use Segments
38  const int nMeasCutMdt[4] = { 4, 2, 4, 5}; //[MDTStation]
39  const int nMeasCutTgcStrip[4] = { 0, 0, 1, 0}; //[MDTStation]
40  // Cut for differences between direction and position vectors
41  const float dPhiCutPosDir[4] = {0.05,0.05,0.08,0.1 };
42  const float dTheCutPosDir[4] = { 0.2, 0.4, 0.6,0.5 };
43 
44  // Loop over sides
45  for(int i=0;i<2;i++){// AC
46  bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
47  bool segmDisqual; // used to flag a segment which has been found DQ insufficient
48  //bool HasStationDQSegm[4] = {false, false, false, false};// flags for whether the there are segments in each MDT station with sufficienct DQ
49 
50  for(int jMDT=0;jMDT<4;jMDT++){// MDT Stations
51  // Get number of segments
52  int nSegm=sortedSegments[i][jMDT].size();
53 
54  // Loop over segments in this MDT Station
55  for(int n=0; n<nSegm;n++){
56  segmDisqual = false;// set disqualified flag to false
57  // Get segment
58  const Muon::MuonSegment *segm=sortedSegments[i][jMDT].at(n);
59  if(segm==nullptr)continue;// Cut empty entries
60 
61  // Check disqualifiedSegments for current segment
62  skipSegm=false;
63  nDisqualifiedSegm=disqualifiedSegments[i][jMDT].size();
64  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm==disqualifiedSegments[i][jMDT].at(ndis))skipSegm=true;
65  if(skipSegm)continue;
66 
68  // Apply nHits cuts to segments
70  int stationName=0;
71  int nMdtMeas = 0; // nMDTHits in this Segment
72  int nTgcMeas[2] = {0,0};// [WireStrip] nTGCHits in this Segment
73 
74  // Loop through contained ROTs and identify used stations
75  for(unsigned int iROT=0; iROT<segm->numberOfContainedROTs(); ++iROT) {
76  const Trk::RIO_OnTrack* rio = segm->rioOnTrack(iROT);
77  if(!rio){
78  ATH_MSG_DEBUG("no RIO");
79  continue;
80  }
81  Identifier id = rio->identify();
82  stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
83  int isStrip = m_idHelperSvc->tgcIdHelper().isStrip(id);
84 
85  if((stationName==41)||(stationName==42))nTgcMeas[isStrip]++;// TGC
86  if((stationName==43)||(stationName==44))nTgcMeas[isStrip]++;// TGC
87  if((stationName==45)||(stationName==46))nTgcMeas[isStrip]++;// TGC
88  if((stationName==47)||(stationName==48))nTgcMeas[isStrip]++;// TGC
89 
90  if((stationName==13)||(stationName==49))nMdtMeas++;// MDT
91  if((stationName==14)||(stationName==15))nMdtMeas++;// MDT
92  if((stationName==17)||(stationName==18))nMdtMeas++;// MDT
93  if((stationName==20)||(stationName==21))nMdtMeas++;// MDT
94  }
95 
96  // Cut Segments with insufficient numbers of hits in the stations
97  if(nMdtMeas<nMeasCutMdt[jMDT]||nTgcMeas[1]<nMeasCutTgcStrip[jMDT]){
98  segmDisqual = true;
99  }
100 
102  // Apply Direction-Position cuts to segments
104  // Get Position and Direction Variables
105  // const Trk::GlobalPosition segmGlobalPos = segm->globalPosition();
106  const Amg::Vector3D segmGlobalPos = segm->globalPosition();
107 
108  float segmPosPhi = segmGlobalPos.phi();
109  float segmPosThe = segmGlobalPos.theta();
110  if(segmPosPhi<0) segmPosPhi+=2*M_PI;
111  if(segmPosThe>M_PI/2) segmPosThe=M_PI-segmPosThe;
112  //const Trk::GlobalDirection segmGlobalDir = segm->globalDirection();
113  const Amg::Vector3D segmGlobalDir = segm->globalDirection();
114 
115  float segmDirPhi = segmGlobalDir.phi();
116  float segmDirThe = segmGlobalDir.theta();
117  if(segmDirPhi<0) segmDirPhi+=2*M_PI;
118  if(segmDirThe>M_PI/2) segmDirThe=M_PI-segmDirThe;
119 
120  // Get Differences between Position and Direction vectors
121  float dPhi_Pos_Dir = segmPosPhi-segmDirPhi;
122  float dThe_Pos_Dir = segmPosThe-segmDirThe;
123  if(dPhi_Pos_Dir<-M_PI)dPhi_Pos_Dir+=2*M_PI;
124  if(dPhi_Pos_Dir> M_PI)dPhi_Pos_Dir-=2*M_PI;
125 
126  if(!segmDisqual){
127  if(m_mdt_segmposdirsag[i][jMDT][2]) m_mdt_segmposdirsag[i][jMDT][2]->Fill(dPhi_Pos_Dir);
128  if(m_mdt_segmposdirsag[i][jMDT][3]) m_mdt_segmposdirsag[i][jMDT][3]->Fill(dThe_Pos_Dir);
129  }
130 
131  // Cut Segments with too great a difference between position and direction vectors
132  if(std::abs(dPhi_Pos_Dir)>dPhiCutPosDir[jMDT]||std::abs(dThe_Pos_Dir)>dTheCutPosDir[jMDT]){
133  segmDisqual = true;
134  }
135 
137  // Add disqualified segments to the disqualified list
139  if(segmDisqual){
140  disqualifiedSegments[i][jMDT].push_back(segm);
141  }
142  else{
143  //HasStationDQSegm[jMDT]=true;// Flag event as having a DQ sufficient segment in the current station
144  }
145  }// Segments in station
146  }// MDT Stations
147  }// AC
148 
149  return;
150 }// End of function

◆ 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 MdtVsTgcRawDataValAlg::fillHistograms ( )
virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 155 of file MdtVsTgcRawDataValAlg.cxx.

155  {
156 /*----------------------------------------------------------------------------------*/
157  ATH_MSG_DEBUG( "MdtVsTgcRawDataValAlg::TGC RawData Monitoring Histograms being filled" );
158 
159  //TGC PRD
160  SG::ReadHandle<Muon::TgcPrepDataContainer> tgc_prd_container(m_tgc_PrepDataContainerName);
161 
162  //TGC Coincidence
163  SG::ReadHandle<Muon::TgcCoinDataContainer> tgc_coin_container(m_tgc_CoinContainerName);
164 
165  ATH_MSG_DEBUG( "size of tgc container is " << tgc_coin_container -> size() );
166 
167  //MDT PRD
168  SG::ReadHandle<Muon::MdtPrepDataContainer> mdt_prd_container(m_mdt_PrepDataContainerName);
169 
170  SG::ReadHandle<xAOD::MuonSegmentContainer> mdt_segment_collection(m_mdt_SegmentCollectionName) ;
171  tgceffcalc(mdt_segment_collection.cptr(), tgc_prd_container.cptr());
172  maphists(mdt_segment_collection.cptr(), tgc_prd_container.cptr());
173 
174  //only analyze nSL==1
175  int nSL = numberOfSL(tgc_coin_container.cptr());
176 
177  if(nSL==1){
178  //fill MDT hit vs TGC RoI
179  correlation(mdt_prd_container.cptr(), tgc_coin_container.cptr());
180  }
181 
182 
183  return StatusCode::SUCCESS; // statuscode check
184 }

◆ 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 }

◆ 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 }

◆ getStationMapIndex()

int MdtVsTgcRawDataValAlg::getStationMapIndex ( int  x,
int  l,
int  stationFE,
int  stationEta,
int  stationPhi 
)
private

Definition at line 259 of file MdtVsTgcRawData_TGCEffCheck.cxx.

259  {
260  // Display error messages if invalid TRE variables are passed in
261  if((stationFE!=0)&&(stationFE!=1)) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationFE=" << stationFE );
262  if((l<0)||(l>8)) ATH_MSG_WARNING( "getStationMapIndex passed invalid layer index l=" << l );
263  if(stationEta<1) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationEta=" << stationEta );
264  if(stationPhi<1) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationPhi=" << stationPhi );
265  int index=0;
266  switch(x){
267  case 1:// Getting Eta Index //use old eta bin
268  if(l==0||l==1||l==2){// T1
269  if(stationEta>4) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta );
270  if(stationFE==0)index=32+l;
271  else{
272  index=4-stationEta;
273  index=index*7+l;
274  }
275  }
276  else if(l==3||l==4){// T2
277  if(stationEta>5) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta );
278  if(stationFE==0)index=32+l;
279  else {
280  index=5-stationEta;
281  index=index*7+l;
282  if(stationEta==1)index=25+l;
283  }
284  }
285  else if(l==5||l==6){// T3
286  if(stationEta>5) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta );
287  if(stationFE==0)index=32+l;
288  else{
289  index=5-stationEta;
290  index=index*7+l;
291  if(stationEta==1)index=25+l;
292  }
293  }
294  else if(l==7||l==8){// T4
295  if(stationEta>1) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta );
296  if(stationFE==0){
297  if(l==7){index=41;}
298  else if(l==8){index=42;}
299  }else{
300  if(l==7){index=39;}
301  else if(l==8){index=40;}
302  }
303  }
304  break;
305  case 2:// Getting Phi Index
306  if(stationFE==0){// Forward
307  if((l==7)||(l==8)){// FI
308  if(stationPhi>24) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi );
309  index=(stationPhi-1)*2;
310  }
311  else{// Forward Midstation
312  if(stationPhi>24) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi );
313  index=(stationPhi-1)*2;
314  }
315  }
316  else{// Endcap
317  if((l==7)||(l==8)){// EI
318  if(stationPhi>21) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi );
319  index=(stationPhi-1);
320  if(index>7)index++;
321  if(index>15)index++;
322  if(index>19)index++;
323  index*=2;
324  }
325  else{// Endcap Midstation
326  if(stationPhi>48) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi );
327  index=stationPhi-1;
328  }
329  }
330  // Adjust to set A01phi0(stationPhi=47 for Midstation)at 0
331  index+=2;
332  if(index>47)index-=48;
333  break;
334  default:
335  ATH_MSG_WARNING( "getStationMapIndex(" << x << ") is invalid" );
336  break;
337  }
338  return index;
339 }// End of function

◆ initialize()

StatusCode MdtVsTgcRawDataValAlg::initialize ( )
virtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 98 of file MdtVsTgcRawDataValAlg.cxx.

98  {
99  ATH_CHECK(ManagedMonitorToolBase::initialize());
100  ATH_MSG_INFO( "in initializing MdtVsTgcRawDataValAlg" );
101  // MuonDetectorManager from the conditions store
102  ATH_CHECK(m_DetectorManagerKey.initialize());
103  ATH_CHECK(m_idHelperSvc.retrieve());
104 
105  //MDT z position
106  //Name MultiLayer TubeLayer z
107  //17 1 1 14142.5
108  //17 1 2 14168.5
109  //17 1 3 14194.5
110  //17 2 1 14394.6
111  //17 2 2 14420.6
112  //17 2 3 14446.6
113  //18 1 1 13726.5
114  //18 1 2 13752.5
115  //18 1 3 13778.5
116  //18 2 1 13978.6
117  //18 2 2 14004.6
118  //18 2 3 14030.6
119 
120  // Retrieve the MuonDetectorManager
121  const MuonGM::MuonDetectorManager* MuonDetMgrDS=nullptr;
122  ATH_CHECK( detStore()->retrieve(MuonDetMgrDS) );
123  ATH_MSG_DEBUG( " Found the MuonDetectorManager from detector store. " );
124  prepareTREarray(MuonDetMgrDS);
125  ATH_CHECK(m_tgc_PrepDataContainerName.initialize());
126  ATH_CHECK(m_tgc_CoinContainerName.initialize());
127  ATH_CHECK(m_mdt_PrepDataContainerName.initialize());
128  ATH_CHECK(m_mdt_SegmentCollectionName.initialize());
129  return StatusCode::SUCCESS;
130 }

◆ 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 }

◆ labelStationMap()

void MdtVsTgcRawDataValAlg::labelStationMap ( TH2 *  h2,
int  i = -1,
int  k = -1 
)
private

Definition at line 397 of file MdtVsTgcRawData_bookhistograms.cxx.

397  {
398  // Blank non-existent chambers
399  BlankStationMap(h2,ws);
400 
401  std::stringstream sst;
402  std::string AC[2]={"A","C"};
403  int nChambers[9]={5,5,5,6,6,6,6,2,2};
404  std::string chamber1[6]={"E1", "E2", "E3", "E4", "F"};
405  std::string chamber3[6]={"E1", "E2", "E3", "E4", "E5", "F"};
406  std::string chamberE[2]={"EI", "FI"};
407 
408  bool rebin=true;
409  // Name StationEtas/Layers
410  int ibin=1;
411  if(rebin){//use new bin
412  for(int l=0 ; l<9 ; l++ ){// Layer
413  //cppcheck-suppress negativeIndex
414  for( int c=0 ; c<nChambers[l] ; c++ ){// Chamber
415  sst << "L" << l+1 << "_";
416  if(nChambers[l]==5)sst<<chamber1[c];
417  else if(nChambers[l]==6)sst<<chamber3[c];
418  else if(nChambers[l]==2)sst<<chamberE[c];
419  if(l+1>0 && l+1<=3 && c+1<5)ibin=7*c+(l+1);
420  else if(l+1>3 && l+1<=7 && c+1<5)ibin=7*c+(l+1);
421  else if(l+1>3 && l+1<=7 && c+1==5)ibin=25+(l+1);
422  else if(l+1==1 && c+1==5)ibin=33;
423  else if(l+1==2 && c+1==5)ibin=34;
424  else if(l+1==3 && c+1==5)ibin=35;
425  else if(l+1==4 && c+1==6)ibin=36;
426  else if(l+1==5 && c+1==6)ibin=37;
427  else if(l+1==6 && c+1==6)ibin=38;
428  else if(l+1==7 && c+1==6)ibin=39;
429  else if(l+1==8 && c+1==1)ibin=40;
430  else if(l+1==8 && c+1==2)ibin=42;
431  else if(l+1==9 && c+1==1)ibin=41;
432  else if(l+1==9 && c+1==2)ibin=43;
433  h2->GetXaxis()->SetBinLabel(ibin, sst.str().c_str());
434  h2->GetXaxis()->SetBit(TAxis::kLabelsVert);
435  sst.str("");
436  }// Chamber
437  }// Layer
438  }else{//use old bin logically dead code, comment out
439 // for(int l=0 ; l<9 ; l++ ){// Layer
440 // for( int c=0 ; c<nChambers[l] ; c++ ){// Chamber
441 // sst << "L" << l+1 << "_";
442 // if(nChambers[l]==5)sst<<chamber1[c];
443 // else if(nChambers[l]==6)sst<<chamber3[c];
444 // else if(nChambers[l]==2)sst<<chamberE[c];
445 // h2->GetXaxis()->SetBinLabel(ibin, sst.str().c_str());
446 // sst.str(""); ibin++;
447 // }// Chamber
448 // }// Layer
449 // h2->GetXaxis()->LabelsOption("v");
450  }
451  // Name Phi Sectors
452  for(int isec=1;isec<=12;isec++){// Sector
453  for(int iphi=0;iphi<=3;iphi+=4){// Phi number
454  if(ac==0||ac==1)sst << AC[ac];
455  if(isec<10)sst << "0";
456  sst << isec << "phi" << iphi;
457  ibin=(isec-1)*4+iphi+1;
458  h2->GetYaxis()->SetBinLabel(ibin, sst.str().c_str());
459  sst.str("");
460  }// Phi number
461  }// Sector
462 }// End of function

◆ 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 }

◆ maphists()

void MdtVsTgcRawDataValAlg::maphists ( const xAOD::MuonSegmentContainer *  m_newsegment,
const Muon::TgcPrepDataContainer *  tgc_prepcontainer 
)
private

Definition at line 38 of file MdtVsTgcRawData_maptgchits.cxx.

39  {//use new mdt segment
40  ATH_MSG_DEBUG("inside maptgchits" );
41 
43  // loop over MDT Segment Collection
44  xAOD::MuonSegmentContainer::const_iterator mdtseg_itr = newsegment->begin();
45  xAOD::MuonSegmentContainer::const_iterator mdtseg_end = newsegment->end();
46  for(; mdtseg_itr!=mdtseg_end; ++mdtseg_itr){
47  if(!(*mdtseg_itr)->muonSegment().isValid())continue;
48  // Get segm
49  const Muon::MuonSegment* segm = dynamic_cast<const Muon::MuonSegment*>(*(*mdtseg_itr)->muonSegment());
50  if (segm == nullptr) {
51  ATH_MSG_ERROR( "no pointer to segm!!!" );
52  break;
53  }
54  // Initialize variables
55  int stationName=0;
56  int nMdtMeas[4] = {0,0,0,0};
57  bool isMdt=false, isEndcap=false;
58 
59  // Loop through contained ROTs and count used MDT and TGC stations
60  for(unsigned int i=0;i<segm->numberOfContainedROTs();++i){
61  // Get station information
62  const Trk::RIO_OnTrack* rio = segm->rioOnTrack(i);
63  if(!rio) continue;
64  Identifier id = rio->identify();
65  stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
66  // Flag Segments with ROTs in the MDT & Endcap
67  if(m_idHelperSvc->isMdt(id))isMdt=true;
68  if(m_idHelperSvc->isEndcap(id))isEndcap=true;
69  // If ROT is MDT
70  if((stationName==13)||(stationName==49)){nMdtMeas[0]++;}
71  if((stationName==14)||(stationName==15)){nMdtMeas[1]++;}
72  if((stationName==17)||(stationName==18)){nMdtMeas[2]++;}
73  if((stationName==20)||(stationName==21)){nMdtMeas[3]++;}
74  }
75  if(!isMdt)continue;
76  if(!isEndcap)continue;
77 
78  // Establish which MDT stations the Segment is in
79  int nStations = 0;
80  for(int jMDT=0;jMDT<4;jMDT++){
81  if(nMdtMeas[jMDT]){
82  nStations++;
83  }
84  }
85  // Check that the Segment only occupies one Station
86  if(nStations!=1)continue;
87 
88  // Get Position pointer and segmAC index
89  const Amg::Vector3D segmGlobalPos = segm->globalPosition();
90  int segmAC = (segmGlobalPos.z()<0);// a:0, c:1
91 
92  // Fill MDT data
93  for(int jMDT=0;jMDT<4;jMDT++){// jMDT
94  if(nMdtMeas[jMDT]){// If hits in this Station
95  // Get position variables
96  float segmGlobalEta = std::abs(segmGlobalPos.eta());
97  float segmGlobalPhi = segmGlobalPos.phi();
98  if(segmGlobalPhi<0) segmGlobalPhi+=2*M_PI;
99  // Fill position histogram
100  m_mdt_segmmap[segmAC][jMDT]->Fill(segmGlobalPhi, segmGlobalEta);
101  }// If hits in Station
102  }// jMDT
103  }// MDT Segment Collection
104 
106  //loop over TGC Prep Data container
107  Muon::TgcPrepDataContainer::const_iterator tgc_it_end=tgc_prepcontainer->end();
108  for( Muon::TgcPrepDataContainer::const_iterator tgc_it=tgc_prepcontainer->begin();
109  tgc_it!=tgc_it_end;
110  ++tgc_it){
111 
112  //loop over TGC Prep Data collection
113  Muon::TgcPrepDataCollection::const_iterator tgc_itc_end=(*tgc_it)->end();
114  for( Muon::TgcPrepDataCollection::const_iterator tgc_itc=(*tgc_it)->begin();
115  tgc_itc!= tgc_itc_end;
116  ++tgc_itc){
117  const Muon::TgcPrepData* tpd=*tgc_itc;
118 
119  // Get detector information
120  const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
121  const std::string tgcStationType = tre->getStationType();
122 
123  // Get detector variables
124  Identifier tgcid=(*tgc_itc)->identify();
125  int tgcStationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
126 
127  // Get position variables
128  const Amg::Vector3D tgcGlobalPos = tpd->globalPosition();
129  float tgcGlobalPhi = tgcGlobalPos.phi();
130  if(tgcGlobalPhi<0)tgcGlobalPhi+=2*M_PI;
131 
132  // Cut non-TGC-Endcap
133  if(tgcStationName<41 || tgcStationName>48)continue;
134  }// TGC PRD Collection
135  }// TGC PRD Container
136 
137  return;
138 }// End of function

◆ maphistsfinalize()

void MdtVsTgcRawDataValAlg::maphistsfinalize ( )
private

Definition at line 141 of file MdtVsTgcRawData_maptgchits.cxx.

141  {
142 
143 }// End of function

◆ MatchMDTSegments()

void MdtVsTgcRawDataValAlg::MatchMDTSegments ( std::vector< const Muon::MuonSegment * >(&)  sortedSegments[2][4],
std::vector< const Muon::MuonSegment * >(&)  disqualifiedSegments[2][4],
std::vector< SegmTrack >(&)  matchedSegments[2] 
)
private

Definition at line 33 of file MdtVsTgcRawData_SegmMatching.cxx.

35  {// Define Cuts:
36  // Cut for matching Segments
37  const float dRhoCutSegmentMatching = 1000;
38  const float dPhiCutSegmentMatching = M_PI/8;
39  const float dPhiCutSegmentDirectionChecking[4][4]={{ 0,M_PI/8, 0.1, 0.01},
40  {M_PI/8, 0,M_PI/8,M_PI/8},
41  { 0.06,M_PI/8, 0, 0.01},
42  { 0.05,M_PI/8, 0.05, 0}};
43  const float dTheCutSegmentDirectionChecking[4][4]={{ 0,M_PI/8, 0.05, 0.06},
44  {M_PI/8, 0,M_PI/8,M_PI/8},
45  { 0.04,M_PI/8, 0, 0.005},
46  { 0.02,M_PI/8, 0.005, 0}};
47  // Loop over sides
48  for(int i=0;i<2;i++){// AC
49  bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
50  //bool HasStationMatchSegm[4] = {false, false, false, false};// flags for whether the there are segments in each MDT station which were included in tracks
51  //bool HasMatchedTrack = false;// flag for whether a track was found on current side
52 
53  for(int jMDT1=3;jMDT1>=0;jMDT1--){// MDT Stations in reverse]
54  // Get number of segments
55  int nSegm1=sortedSegments[i][jMDT1].size();
56 
57  // Loop over Segments in Station
58  for(int n1=0; n1<nSegm1;n1++){
59  // Get segment
60  const Muon::MuonSegment *segm1 = sortedSegments[i][jMDT1].at(n1);
61 
62  // Check disqualifiedSegments for current segment
63  skipSegm=false;
64  nDisqualifiedSegm=disqualifiedSegments[i][jMDT1].size();
65  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][jMDT1].at(ndis))skipSegm=true;
66  if(skipSegm)continue;
67 
68  // Get position variables
69  const Amg::Vector3D segm1Pos = segm1->globalPosition();
70 
71  float segm1PosPhi = segm1Pos.phi();
72  float segm1PosZ = segm1Pos.z();
73  if(segm1PosPhi<0)segm1PosPhi+=2*M_PI;
74  Amg::Vector3D segm1PosZunit(segm1Pos/std::abs(segm1PosZ));
75  Amg::Vector3D segm1Dir = segm1->globalDirection();
76 
77  float segm1DirThe = segm1Dir.theta();
78  float segm1DirPhi = segm1Dir.phi();
79  if(segm1DirThe>M_PI/2) segm1DirThe=M_PI-segm1DirThe;
80  if(segm1DirPhi<0) segm1DirPhi+=2*M_PI;
81 
82  // Initialise segment matching variables
83  bool stationMatchFound[4] = {false,false,false,false};
84  std::vector<const Muon::MuonSegment*> matchingSegments[4];
85  for(int jMDT2=0;jMDT2<4;jMDT2++)matchingSegments[jMDT2] = std::vector<const Muon::MuonSegment*>();
86  matchingSegments[jMDT1].push_back(segm1);
87  int nStationMatch=0;
88 
89  for(int jMDT2=3;jMDT2>=0;jMDT2--){// MDT Station in reverse
90  // Get number of segments
91  int nSegm2=sortedSegments[i][jMDT2].size();
92 
93  // Loop over Segments in Station
94  for(int n2=0; n2<nSegm2;n2++){
95  // Get segment
96  const Muon::MuonSegment *segm2 = sortedSegments[i][jMDT2].at(n2);
97  if(segm1==segm2)continue; //do not compare same segments
98 
99  // Check disqualifiedSegments for current segment
100  skipSegm = false;
101  nDisqualifiedSegm=disqualifiedSegments[i][jMDT2].size();
102  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][jMDT2].at(ndis))skipSegm=true;
103  if(skipSegm)continue;
104 
106  // Position Cut
107  // Fill position variables
108  const Amg::Vector3D segm2Pos = segm2->globalPosition();
109 
110  float segm2PosRho = std::abs(segm2Pos.perp());
111  float segm2PosPhi = segm2Pos.phi();
112  float segm2PosThe = segm2Pos.theta();
113  float segm2PosZ = segm2Pos.z();
114  if(segm2PosThe>M_PI/2) segm2PosThe=M_PI-segm2PosThe;
115  if(segm2PosPhi<0)segm2PosPhi+=2*M_PI;
116  Amg::Vector3D segm2PosZunit(segm2Pos/std::abs(segm2PosZ));
117 
118  // Apply preliminary phi cut between segm1 and segm2 positions
119  float dPhi_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
120  if(dPhi_Segm1_Segm2<-M_PI)dPhi_Segm1_Segm2+=2*M_PI;
121  if(dPhi_Segm1_Segm2> M_PI)dPhi_Segm1_Segm2-=2*M_PI;
122  if(std::abs(dPhi_Segm1_Segm2)>dPhiCutSegmentMatching)continue;
123 
124  // Extrapolate segm1 position to segm2's Z position
125  float dZ = std::abs(segm2PosZ)-std::abs(segm1PosZ);
126  Amg::Vector3D extrPos(segm1Pos+(segm1PosZunit*dZ));
127 
128  float extrPosRho = std::abs(extrPos.perp());
129  float extrPosThe = extrPos.theta();
130  float extrPosPhi = extrPos.phi();
131  if(extrPosThe>M_PI/2) extrPosThe=M_PI-extrPosThe;
132  if(extrPosPhi<0)extrPosPhi+=2*M_PI;
133 
134  // Get differences between extrapolated and segm2 positions
135  float dRho_Extr_Segm2 = extrPosRho-segm2PosRho;
136  float dPhi_Extr_Segm2 = extrPosPhi-segm2PosPhi;
137  float dThe_Extr_Segm2 = extrPosThe-segm2PosThe;
138  if(dPhi_Extr_Segm2<-M_PI)dPhi_Extr_Segm2+=2*M_PI;
139  if(dPhi_Extr_Segm2> M_PI)dPhi_Extr_Segm2-=2*M_PI;
140 
141  // Fill difference histograms
142  if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][0]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][0]->Fill(dRho_Extr_Segm2);
143  if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][2]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][2]->Fill(dPhi_Extr_Segm2);
144  if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][3]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][3]->Fill(dThe_Extr_Segm2);
145 
146  // Cut segments (segm2) which are outside difference cuts
147  if(std::abs(dPhi_Extr_Segm2)>dPhiCutSegmentMatching)continue;
148  if(std::abs(dRho_Extr_Segm2)>dRhoCutSegmentMatching)continue;
149 
151  // Direction Cut
152  // Fill direction variables
153  //const Trk::GlobalDirection segm2Dir = segm2->globalDirection();
154  const Amg::Vector3D segm2Dir = segm2->globalDirection();
155 
156  float segm2DirThe = segm2Dir.theta();
157  float segm2DirPhi = segm2Dir.phi();
158  if(segm2DirThe>M_PI/2) segm2DirThe=M_PI-segm2DirThe;
159  if(segm2DirPhi<0) segm2DirPhi+=2*M_PI;
160 
161  // Vector Method
162  // Make vector between segment positions
163  //Trk::GlobalDirection segmVector;
164  Amg::Vector3D segmVector;
165 
166  if(jMDT2>jMDT1)segmVector = segm2Pos-segm1Pos;
167  else segmVector = segm1Pos-segm2Pos;
168  float segmVecThe = segmVector.theta();
169  float segmVecPhi = segmVector.phi();
170  if(segmVecThe>M_PI/2) segmVecThe=M_PI-segmVecThe;
171  if(segmVecPhi<0) segmVecPhi+=2*M_PI;
172 
173  // Get difference between vector direction and segment directions
174  float dThe_Vec_Segm1 = segmVecThe-segm1DirThe;
175  float dPhi_Vec_Segm1 = segmVecPhi-segm1DirPhi;
176  if(dPhi_Vec_Segm1<-M_PI)dPhi_Vec_Segm1+=2*M_PI;
177  if(dPhi_Vec_Segm1> M_PI)dPhi_Vec_Segm1-=2*M_PI;
178  float dThe_Vec_Segm2 = segmVecThe-segm2DirThe;
179  float dPhi_Vec_Segm2 = segmVecPhi-segm2DirPhi;
180  if(dPhi_Vec_Segm2<-M_PI)dPhi_Vec_Segm2+=2*M_PI;
181  if(dPhi_Vec_Segm2> M_PI)dPhi_Vec_Segm2-=2*M_PI;
182 
183  // Fill histograms
184  if(jMDT1>jMDT2){
185  if(m_mdt_trackchecksag[i][jMDT2][jMDT1][2][0]) m_mdt_trackchecksag[i][jMDT2][jMDT1][2][0]->Fill(dPhi_Vec_Segm2);
186  if(m_mdt_trackchecksag[i][jMDT2][jMDT1][3][0]) m_mdt_trackchecksag[i][jMDT2][jMDT1][3][0]->Fill(dThe_Vec_Segm2);
187  if(m_mdt_trackchecksag[i][jMDT2][jMDT1][2][1]) m_mdt_trackchecksag[i][jMDT2][jMDT1][2][1]->Fill(dPhi_Vec_Segm1);
188  if(m_mdt_trackchecksag[i][jMDT2][jMDT1][3][1]) m_mdt_trackchecksag[i][jMDT2][jMDT1][3][1]->Fill(dThe_Vec_Segm1);
189  }
190  else if(jMDT1<jMDT2){
191  if(m_mdt_trackchecksag[i][jMDT1][jMDT2][2][0]) m_mdt_trackchecksag[i][jMDT1][jMDT2][2][0]->Fill(dPhi_Vec_Segm1);
192  if(m_mdt_trackchecksag[i][jMDT1][jMDT2][3][0]) m_mdt_trackchecksag[i][jMDT1][jMDT2][3][0]->Fill(dThe_Vec_Segm1);
193  if(m_mdt_trackchecksag[i][jMDT1][jMDT2][2][1]) m_mdt_trackchecksag[i][jMDT1][jMDT2][2][1]->Fill(dPhi_Vec_Segm2);
194  if(m_mdt_trackchecksag[i][jMDT1][jMDT2][3][1]) m_mdt_trackchecksag[i][jMDT1][jMDT2][3][1]->Fill(dThe_Vec_Segm2);
195  }
196 
197  // Direction Comparison Method
198  float dTheDir_Segm1_Segm2 = segm1DirThe-segm2DirThe;
199  float dPhiDir_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
200  if(dPhiDir_Segm1_Segm2<-M_PI)dPhiDir_Segm1_Segm2+=2*M_PI;
201  if(dPhiDir_Segm1_Segm2> M_PI)dPhiDir_Segm1_Segm2-=2*M_PI;
202  if(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][2]) m_mdt_trackdirdirsag[i][jMDT1][jMDT2][2]->Fill(dTheDir_Segm1_Segm2);
203  if(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][3]) m_mdt_trackdirdirsag[i][jMDT1][jMDT2][3]->Fill(dPhiDir_Segm1_Segm2);
204  // Cut using Vector Method
205  if(dPhi_Vec_Segm1>dPhiCutSegmentDirectionChecking[jMDT1][jMDT2] ||
206  dThe_Vec_Segm1>dTheCutSegmentDirectionChecking[jMDT1][jMDT2] ||
207  dPhi_Vec_Segm2>dPhiCutSegmentDirectionChecking[jMDT2][jMDT1] ||
208  dThe_Vec_Segm2>dTheCutSegmentDirectionChecking[jMDT2][jMDT1]) continue;
209 
210  // Match is found, increment counter and assign segm2 to match found array
211  matchingSegments[jMDT2].push_back(segm2);
212  }// nSegms2
213 
214  if(matchingSegments[jMDT2].size()==1){
215  stationMatchFound[jMDT2]=true;
216  nStationMatch++;
217  }
218  }// Reverse MDT Stations2
219 
220  // If matches found add to matchedSegments and disqualify all segments in array
221  if(nStationMatch>1){
222  //HasMatchedTrack=true;
223  const Muon::MuonSegment *segmArray[4] = {nullptr,nullptr,nullptr,nullptr};
224  for(int jMDT2=0;jMDT2<4;jMDT2++){
225  if(stationMatchFound[jMDT2]){
226  segmArray[jMDT2]=matchingSegments[jMDT2].at(0);
227  //HasStationMatchSegm[jMDT2]=true;
228  disqualifiedSegments[i][jMDT2].push_back(matchingSegments[jMDT2].at(0));
229  }
230  }
231  SegmTrack newTrack(segmArray);
232  matchedSegments[i].push_back(newTrack);
233  }// If Matched Track Found
234 
235  }// nSegms1
236  }// Reverse MDT Stations1
237 
238  }// AC
239 
240  return;
241 }// End of function

◆ MidstationOnlyCheck()

void MdtVsTgcRawDataValAlg::MidstationOnlyCheck ( std::vector< const Muon::MuonSegment * >(&)  sortedSegments[2][4],
std::vector< const Muon::MuonSegment * >(&)  disqualifiedSegments[2][4],
const Muon::TgcPrepDataContainer *  tgc_prepcontainer 
)
private

Definition at line 34 of file MdtVsTgcRawData_MidstationMatching.cxx.

36  {
37  // Define Cuts:
38  // Cut for matching Segments
39  const float dRhoCutSegmentMatching = 1000;
40  const float dPhiCutSegmentMatching = M_PI/8;
41 
42  // Cuts for number of Mdt Measurements required for Midstation only track
43  const int nMeasCutMdtMidstation = 5;
44  const int nMeasCutTGCMidPRD[2] = {2,2};
45 
46  // Loose cut for PRD and Extrapolated
47  const float dPhiCut_Loose = M_PI/8;
48  // Cut for Global Position Efficiencies
49  const float dPhiCutGlobal[2] = {static_cast<float>(M_PI/24),static_cast<float>(M_PI/12)};//[WireStrip]
50  const float dRhoCutGlobal[2] = { 0.08, 0.5};//[WireStrip]
51  // Cut for Sector Efficiencies
52  const float dPhiCutSector[2] = { 0.2, 0.1};//[WireStrip]
53  const float dRhoCutSector[2] = { 300, 3000};//[WireStrip]
54  // Cut for TgcPrepData comparison
55  const float dPhiCutTPD[2] = { 0.15, 0.02};//[WireStrip]
56  const float dRhoCutTPD[2] = { 150, 3000};//[WireStrip]
57 
58  // Loop over sides
59  for(int i=0;i<2;i++){// AC
60  // Number of Segments found which passed all cuts
61  int nValidatedSegm = 0;
62 
63  // Following "Fill" variables are only used if one segment passed all cuts
64  // Flags for whether different stations can be checked by the segment
65  //bool canCheckGlobalFill[4] = {0, 0, 0, 0};
66  bool canCheckSectorFill[4] = {0, 0, 0, 0};
67  // Segment Global Position variables
68  // float posThetaFill = 0;
69  // float posPhiFill = 0;
70  // Segment Sector Position
71  int TGCstation_StationFEFill[4] = {-1,-1,-1,-1};// [TGCStation]
72  int TGCstation_StationEtaFill[4] = { 0, 0, 0, 0};// [TGCStation]
73  int TGCstation_StationPhiFill[4] = { 0, 0, 0, 0};// [TGCStation]
74  // Hit registered arrays
75  // bool hitregisteredFill[9][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
76  bool sectorhitregisteredFill[9][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
77 
78  bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
79 
80  // Make copy of disqualifiedSegment vector array
81  std::vector<const Muon::MuonSegment*> copyDisqualifiedSegments;
82  nDisqualifiedSegm=disqualifiedSegments[i][2].size();
83  copyDisqualifiedSegments.reserve(nDisqualifiedSegm);
84 for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)copyDisqualifiedSegments.push_back(disqualifiedSegments[i][2].at(ndis));
85 
87  // Apply preliminary nMdtMeas Cut
88  int nSegm = sortedSegments[i][2].size();
89  for(int n0=0; n0<nSegm;n0++){
90  // Get segment
91  const Muon::MuonSegment *segm0 = sortedSegments[i][2].at(n0);
92 
93  // Check copyDisqualifiedSegments for current segment
94  skipSegm=false;
95  nDisqualifiedSegm=copyDisqualifiedSegments.size();
96  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm0==copyDisqualifiedSegments.at(ndis))skipSegm=true;
97  if(skipSegm)continue;
98 
99  // Apply nMDTMeasurements Cut to Segment Collection
100  int stationName = 0;
101  int nMdtMeas = 0;
102  // Loop through contained ROTs and identify used stations
103  for(unsigned int iROT=0; iROT<segm0->numberOfContainedROTs(); ++iROT) {
104  const Trk::RIO_OnTrack* rio = segm0->rioOnTrack(iROT);
105  if(!rio) continue;
106  Identifier id = rio->identify();
107  stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
108 
109  if((stationName==17)||(stationName==18))nMdtMeas++;// MDT
110  }
111  // Cut Segments with insufficient numbers of hits in the stations
112  if(nMdtMeas<nMeasCutMdtMidstation){
113  copyDisqualifiedSegments.push_back(segm0);
114  }
115  }
116 
117  // Loop over Segments in MidStation
118  for(int n1=0; n1<nSegm;n1++){
120  // Start operation on Segment
121  // Get segment
122  const Muon::MuonSegment *segm1 = sortedSegments[i][2].at(n1);
123 
124  // Check copyDisqualifiedSegments for current segment
125  skipSegm=false;
126  nDisqualifiedSegm=copyDisqualifiedSegments.size();
127  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==copyDisqualifiedSegments.at(ndis))skipSegm=true;
128  if(skipSegm)continue;
129 
130  // Flag for Grouping cut
131  bool failedGroupingCut = false;
132  // Flags for whether different stations can be checked by the segment
133  bool canCheckGlobal[4] = {true, true, true, false};
134  bool canCheckSector[4] = {true, true, true, false};
135 
136  // Get position variables
137  //const Trk::GlobalPosition segm1Pos = segm1->globalPosition();
138  const Amg::Vector3D segm1Pos = segm1->globalPosition();
139 
140  float segm1PosPhi = segm1Pos.phi();
141  float segm1PosThe = segm1Pos.theta();
142  float segm1PosZ = segm1Pos.z();
143  if(segm1PosPhi<0)segm1PosPhi+=2*M_PI;
144  if(segm1PosThe>M_PI/2) segm1PosThe=M_PI-segm1PosThe;
145  Amg::Vector3D segm1PosZunit(segm1Pos/std::abs(segm1PosZ));
146 
147 
149  // Apply nTGCStripMeasurements Cut to canCheck arrays
150  int stationName = 0;
151  int nTGCStrips[4] = { 0, 0, 0, 0};
152  // Loop through contained ROTs and identify used stations
153  for(unsigned int iROT=0; iROT<segm1->numberOfContainedROTs(); ++iROT){
154  const Trk::RIO_OnTrack* rio = segm1->rioOnTrack(iROT);
155  if(!rio) continue;
156  Identifier id = rio->identify();
157  stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
158  bool isStrip = m_idHelperSvc->tgcIdHelper().isStrip(id);
159 
160  if(((stationName==41)||(stationName==42))&&isStrip)nTGCStrips[0]++;// TGC
161  if(((stationName==43)||(stationName==44))&&isStrip)nTGCStrips[1]++;// TGC
162  if(((stationName==45)||(stationName==46))&&isStrip)nTGCStrips[2]++;// TGC
163  if(((stationName==47)||(stationName==48))&&isStrip)nTGCStrips[3]++;// TGC
164  }
165 
166  // Don't check mid-stations when there are no strips in other mid-stations
167  if((nTGCStrips[1]==0)&&(nTGCStrips[2]==0)){canCheckSector[0]=false;canCheckGlobal[0]=false;}
168  if((nTGCStrips[0]==0)&&(nTGCStrips[2]==0)){canCheckSector[1]=false;canCheckGlobal[1]=false;}
169  if((nTGCStrips[0]==0)&&(nTGCStrips[1]==0)){canCheckSector[2]=false;canCheckGlobal[2]=false;}
170 
171 
173  // Do Grouping Cut
174  // Ignore any segments which are too close to any other segments not in the original disqualified list
175  for(int n2=0; n2<nSegm;n2++){
176  if(n1==n2)continue; // don't compare segment to itself
177  // Get segment
178  const Muon::MuonSegment *segm2 = sortedSegments[i][2].at(n2);
179 
180  // Check disqualifiedSegments for current segment
181  skipSegm=false;
182  nDisqualifiedSegm=disqualifiedSegments[i][2].size();
183  for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][2].at(ndis))skipSegm=true;
184  if(skipSegm)continue;
185 
186  // Get position variables
187  const Amg::Vector3D segm2Pos = segm2->globalPosition();
188  float segm2PosRho = std::abs(segm2Pos.perp());
189  float segm2PosPhi = segm2Pos.phi();
190  float segm2PosZ = segm2Pos.z();
191  if(segm2PosPhi<0)segm2PosPhi+=2*M_PI;
192  Amg::Vector3D segm2PosZunit(segm2Pos/std::abs(segm2PosZ));
193 
194  // Apply preliminary phi cut between segm1 and segm2 positions
195  float dPhi_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
196  if(dPhi_Segm1_Segm2<-M_PI)dPhi_Segm1_Segm2+=2*M_PI;
197  if(dPhi_Segm1_Segm2> M_PI)dPhi_Segm1_Segm2-=2*M_PI;
198  if(std::abs(dPhi_Segm1_Segm2)<dPhiCutSegmentMatching){
199  failedGroupingCut=true;
200  break;
201  }
202 
203  // Extrapolate segm1 position to segm2's Z position
204  float dZ = std::abs(segm2PosZ)-std::abs(segm1PosZ);
205  Amg::Vector3D extrPos(segm1Pos+(segm1PosZunit*dZ));
206  float extrPosRho = std::abs(extrPos.perp());
207  float extrPosThe = extrPos.theta();
208  float extrPosPhi = extrPos.phi();
209  if(extrPosThe>M_PI/2) extrPosThe=M_PI-extrPosThe;
210  if(extrPosPhi<0)extrPosPhi+=2*M_PI;
211 
212  // Get differences between extrapolated and segm2 positions
213  float dRho_Extr_Segm2 = extrPosRho-segm2PosRho;
214  float dPhi_Extr_Segm2 = extrPosPhi-segm2PosPhi;
215  if(dPhi_Extr_Segm2<-M_PI)dPhi_Extr_Segm2+=2*M_PI;
216  if(dPhi_Extr_Segm2> M_PI)dPhi_Extr_Segm2-=2*M_PI;
217 
218  // Cut segments (segm1) which are inside difference cuts
219  if((std::abs(dPhi_Extr_Segm2)<dPhiCutSegmentMatching)||
220  (std::abs(dRho_Extr_Segm2)<dRhoCutSegmentMatching)){
221  failedGroupingCut=true;
222  break;
223  }
224  }// nSegm2
225  if(failedGroupingCut)continue;
226 
228  // Check track against TGC Sectors to find which it passes
229  // Initialize variables for TRE array search
230  int TGCStationNames[8] ={41, 42, 43, 44, 45, 46, 47, 48};
231  int TGCstation_StationFE[4] ={-1,-1,-1,-1};// [TGCStation]
232  int TGCstation_StationEta[4]={ 0, 0, 0, 0};// [TGCStation]
233  int TGCstation_StationPhi[4]={ 0, 0, 0, 0};// [TGCStation]
234  int nStationMatch[4] ={ 0, 0, 0, 0};// [TGCStation]
235 
236  // Loop through TRE array, finding sectors which match the track in each layer
237  for(int stationnameindex=0; stationnameindex<6; stationnameindex++){// Station {T1F,T1E,T2F,T2E,T3F,T3E}
238  // Skip stations which don't have sufficient Segments to run efficiency check
239  int stationName = TGCStationNames[stationnameindex];
240  int stationIndex= TGCstationname2stationindex(stationName);
241 
242  // Loop over StationEta&StationPhi
243  for(int stationeta=1; stationeta<=8; stationeta++){// AbsStationEta
244  for(int stationphi=1; stationphi<=48; stationphi++){// StationPhi
245  // Cut Station EtaPhi combinations with no TGC element
246  if(m_TREarray[stationnameindex][i][stationeta][stationphi]==nullptr)continue;
247  const MuonGM::TgcReadoutElement *tre=m_TREarray[stationnameindex][i][stationeta][stationphi];
248 
249  // Extrapolate position from nearest Station's Segment to Sector's Z
250  float sectorZ=tre->globalPosition().z();
251  float dZ_sector=std::abs(sectorZ)-std::abs(segm1PosZ);
252  //Trk::GlobalPosition sectorExtrapolatedPos = segm1Pos+(segm1PosZunit*dZ_sector);
253  Amg::Vector3D sectorExtrapolatedPos = segm1Pos+(segm1PosZunit*dZ_sector);
254 
255  // Convert extrapolated position to local position on the Sector
256  Identifier sector_id=tre->identify();
257  //const HepGeom::Point3D<double> sectorLocalPos3D=tre->globalToLocalCoords(sectorExtrapolatedPos, sector_id);
258  const Amg::Vector3D sectorLocalPos3D=tre->globalToLocalTransf(sector_id) * sectorExtrapolatedPos;
259  //Trk::LocalPosition sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
260  Amg::Vector2D sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
261 
262  double avWidth = (tre->getLongSsize()+tre->getSsize())/2;
263  //double dWidth = (tre->longWidth()-tre->shortWidth());
264  double length = tre->length();
265 
266  // Cut sectors which the track does not go through the central 80% of (avoids double counts)
267  double tol1=-0.1*(avWidth/2);
268  double tol2=-0.1*(length/2);
269 
270  bool insideSectorBounds=tre->bounds().inside(sectorLocalPos2D,tol1,tol2);
271  if(!insideSectorBounds)continue;
272  // Assign values to matching station variables
273  if(stationIndex<0) continue;
274  TGCstation_StationFE[stationIndex]= (tre->isForward()==false);
275  TGCstation_StationEta[stationIndex]=stationeta;
276  TGCstation_StationPhi[stationIndex]=stationphi;
277  nStationMatch[stationIndex]++;
278  }// StationPhi
279  }// StationEta
280  }// StationName
281 
282  // Don't check stations that don't have exactly 1 match for this track
283  for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
284  if(nStationMatch[jTGC]==0){
285  canCheckSector[jTGC]=false;
286  }
287  else if(nStationMatch[jTGC]>1){
288  canCheckSector[jTGC]=false;
289  // Should be impossible, but happens due a problem with the bounds().inside function
290  // commenting out until this bug is resolved
291  //m_log << MSG::WARNING << "MidstationOnly: Number of matches for TGC" << jTGC+1 << " is " << nStationMatch[jTGC] << endl;
292  }
293  }// TGC Station
294 
295  // Cut Segment if no stations can be checked
296  if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
298  // Check which PRD matches Segm1
299  // Initialise hit registered arrays
300  bool sectorhitregistered[9][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
301  std::vector<const Muon::TgcPrepData*> tpdVector[2];
302 
303  // Loop over TGC Prep Data container
304  Muon::TgcPrepDataContainer::const_iterator prepit_end=tgc_prepcontainer->end();
305  for( Muon::TgcPrepDataContainer::const_iterator prepit=tgc_prepcontainer->begin();
306  prepit!=prepit_end;
307  ++prepit){
308 
309  //loop over TGC Prep Data collection
310  Muon::TgcPrepDataCollection::const_iterator prepitc_end=(*prepit)->end();
311  for( Muon::TgcPrepDataCollection::const_iterator prepitc=(*prepit)->begin();
312  prepitc!= prepitc_end;
313  ++prepitc){
314  // Get PRD and variables
315  const Muon::TgcPrepData* tpd=*prepitc;
316  const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
317  const std::string stationType = tre->getStationType();
318 
319  // Get id values
320  Identifier tgcid=(*prepitc)->identify();
321  int tgcAC=(tre->sideA()==false);//isNotAside a:0, c:1
322  int tgcFE=(tre->isForward()==false);//isNotForward f:0, e:1
323  int tgcWS=(m_idHelperSvc->tgcIdHelper().isStrip(tgcid));//isStrip w=0, s=1
324  int stationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
325  int stationEta = std::abs(tre->getStationEta());
326  int stationPhi = tre->getStationPhi();
327  int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(tgcid);
328 
329  // Cut hits except those from same side Midstation
330  if(tgcAC!=i) continue;
331  if(stationName>46 || stationName<41) continue;
332 
333  // Get layer number and stationIndex
334  int layer = TGCgetlayer(stationName,gasGap);
335  int stationIndex = TGCstationname2stationindex(stationName);
336  if(stationIndex==3)continue;
337 
338  // Get position variables
339  const Amg::Vector3D prdPos = tpd->globalPosition();
340  float tgcRho = std::abs(prdPos.perp());
341  float tgcPhi = prdPos.phi();
342  float tgcZ = prdPos.z();
343  if(tgcPhi<0)tgcPhi+=2*M_PI;
344 
345  // Extrapolate Segm1 to PRD Z position
346  float dZ = std::abs(tgcZ) - std::abs(segm1PosZ);
347  Amg::Vector3D tgcExtrapolatedPos = ((segm1Pos)+((segm1PosZunit)*dZ));
348 
349  // Get extrapolated variables
350  float tgcExtrRho = std::abs(tgcExtrapolatedPos.perp());
351  float tgcExtrPhi = tgcExtrapolatedPos.phi();
352  if(tgcExtrPhi<0)tgcExtrPhi+=2*M_PI;
353 
354  // Get differences between extrapolated and segm2 positions
355  float dRho = tgcRho-tgcExtrRho;
356  float dPhi = tgcPhi-tgcExtrPhi;
357  if(dPhi<-M_PI)dPhi+=2*M_PI;
358  if(dPhi> M_PI)dPhi-=2*M_PI;
359 
360  // Pass through loose phi cut to eliminate some noise
361  if(std::abs(dPhi)<dPhiCut_Loose){
362  // Fill PRD sagitta histograms
363  if(m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][0]) m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][0]->Fill(dRho);
364  if(m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][2]) m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][2]->Fill(dPhi);
365 
366  // Do Global check
367  if(canCheckGlobal[stationIndex]){
368  float dRhoCut = dRhoCutGlobal[tgcWS]*tgcExtrRho;
369  if(std::abs(dPhi)<dPhiCutGlobal[tgcWS] && std::abs(dRho)<dRhoCut){
370  }
371  }// global
372 
373  // Add PRD which matches Segm1 position to vector for further analysis
374  if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
375  tpdVector[tgcWS].push_back(tpd);
376  }
377  // Do Sector Efficiency Check
378  if(canCheckSector[stationIndex]){
379  // Do check against PRD from matching Sectors
380  if((stationEta==TGCstation_StationEta[stationIndex])&&
381  (stationPhi==TGCstation_StationPhi[stationIndex])&&
382  (tgcFE==TGCstation_StationFE[stationIndex])){
383  // Do check
384  if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
385  if(layer>=0)sectorhitregistered[layer][tgcWS]=true;// Sector hit
386  }
387  }
388  }// sector
389 
390  }// dPhi Loose Cut
391  }// TGC PRD Collection
392  }// TGC PRD Container
393 
394  // Cut Segment if no stations can be checked
395  if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
397  // Do PRD checks
398  // Find vector of PRD which forms a coherent line in the vicinity of Segm1
399 
400  // Variables to hold best PRD matching results
401  std::vector<const Muon::TgcPrepData*> *bestTPDmatches[2];
402  bestTPDmatches[0] = nullptr;
403  bestTPDmatches[1] = nullptr;
404  if(bestTPDmatches[0]->size()>0) bestTPDmatches[0]->clear();
405  if(bestTPDmatches[1]->size()>0) bestTPDmatches[1]->clear();
406  int bestTPDlayerMatches[2][9] = {{0,0,0,0,0,0,0,0,0},
407  {0,0,0,0,0,0,0,0,0}};
408 
409  for(int k=0;k<2;k++){// WireStrip
410  // Variables to record quality of best match found
411  int nPRDMax = 0;
412  int nlayerMax = 0;
413 
414  // Loop over PRD vector
415  int nTPD = tpdVector[k].size();
416  for(int iTPD1=0;iTPD1<nTPD;iTPD1++){
417  // Variables to hold matches found for this PRD
418  std::vector<const Muon::TgcPrepData*> thisTPDmatches;
419  int thisTPDlayerMatches[9] = {0,0,0,0,0,0,0,0,0};
420 
421  // Get position variables
422  const Amg::Vector3D prdPos1 = tpdVector[k].at(iTPD1)->globalPosition();
423 
424  float prd1Phi = prdPos1.phi();
425  float prd1Z = prdPos1.z();
426  if(prd1Phi<0)prd1Phi+=2*M_PI;
427  Amg::Vector3D prd1PosZunit(prdPos1/std::abs(prd1Z));
428 
429  // Get id values
430  Identifier tgcid1=(tpdVector[k].at(iTPD1))->identify();
431  int stationName1 = m_idHelperSvc->tgcIdHelper().stationName(tgcid1);
432  int gasGap1 = m_idHelperSvc->tgcIdHelper().gasGap(tgcid1);
433  int layer1 = TGCgetlayer(stationName1,gasGap1);
434  if(layer1>=0)thisTPDlayerMatches[layer1]++;
435 
436  // Loop over PRD
437  for(int iTPD2=0;iTPD2<nTPD;iTPD2++){
438  if(iTPD2==iTPD1)continue;// do not check PRD against itself
439 
440  // Get position variables
441  const Amg::Vector3D prdPos2 = tpdVector[k].at(iTPD2)->globalPosition();
442  float prd2Rho = std::abs(prdPos2.perp());
443  float prd2Phi = prdPos2.phi();
444  float prd2Z = prdPos2.z();
445  if(prd2Phi<0)prd2Phi+=2*M_PI;
446 
447  // Extrapolate PRD1 to PRD2 Z position
448  float dZ = std::abs(prd2Z)- std::abs(prd1Z);
449  Amg::Vector3D prdExtrPos = ((prdPos1)+((prd1PosZunit)*dZ));
450 
451  // Get extrapolated variables
452  float prdExtrRho = std::abs(prdExtrPos.perp());
453  float prdExtrPhi = prdExtrPos.phi();
454  if(prdExtrPhi<0)prdExtrPhi+=2*M_PI;
455 
456  // Get differences between extrapolated and PRD2 positions
457  float dRho = prd2Rho-prdExtrRho;
458  float dPhi = prd2Phi-prdExtrPhi;
459  if(dPhi<-M_PI)dPhi+=2*M_PI;
460  if(dPhi> M_PI)dPhi-=2*M_PI;
461 
462  // Fill PRD comparison sagitta histograms
463  if(m_tgc_prdcompsag[i][k][0]) m_tgc_prdcompsag[i][k][0]->Fill(dRho);
464  if(m_tgc_prdcompsag[i][k][2]) m_tgc_prdcompsag[i][k][2]->Fill(dPhi);
465 
466  // Do check
467  if(std::abs(dPhi)<dPhiCutTPD[k] && std::abs(dRho)<dRhoCutTPD[k]){
468  // Get id values
469  Identifier tgcid2=(tpdVector[k].at(iTPD2))->identify();
470  int stationName2 = m_idHelperSvc->tgcIdHelper().stationName(tgcid2);
471  int gasGap2 = m_idHelperSvc->tgcIdHelper().gasGap(tgcid2);
472  int layer2 = TGCgetlayer(stationName2,gasGap2);
473 
474  // Add PRD2 to matches for PRD1
475  if(layer2>=0)thisTPDlayerMatches[layer2]++;
476  thisTPDmatches.push_back(tpdVector[k].at(iTPD2));
477  }
478  }// nTPD2
479 
480  // Get quality of matching array produced
481  int nPRDCurrent = 0;
482  int nlayerCurrent = 0;
483  for(int l=0;l<9;l++){
484  if(thisTPDlayerMatches[l]>0)nlayerCurrent++;
485  nPRDCurrent+=thisTPDlayerMatches[l];
486  }
487 
488  // Check quality variables against maximum found
489  if(nlayerMax <= nlayerCurrent){
490  if(nPRDMax < nPRDCurrent){
491  // Set maximum values to current segment's values
492  nlayerMax = nlayerCurrent;
493  nPRDMax = nPRDCurrent;
494  bestTPDmatches[k] = &thisTPDmatches;
495  for(int l=0;l<9;l++){
496  bestTPDlayerMatches[k][l] = thisTPDlayerMatches[l];
497  }
498  }
499  }
500  }// nTPD1
501 
502  // If matching array was somehow empty (should be impossible)
503  if(nlayerMax==0)continue;
504  if(bestTPDmatches[k]->size()==0){
505  ATH_MSG_WARNING( "MidstationOnly: empty bestTPDmatches["<<k<<"] passed" );
506  continue;
507  }
508 
509  // Set canCheck variables based on contents of matched PRD array
510  for(int jTGC1=0;jTGC1<3;jTGC1++){// TGC Stations
511  // Number of matched PRD found in other Stations
512  int nMatchOther = 0;
513  for(int l=0;l<9;l++){
514  int jTGC2 = TGClayer2stationindex(l);
515  if(jTGC1==jTGC2)continue;
516  nMatchOther+=bestTPDlayerMatches[k][l];
517  }
518 
519  // Check against cut
520  if(nMatchOther<nMeasCutTGCMidPRD[k]){
521  canCheckGlobal[jTGC1]=false;
522  canCheckSector[jTGC1]=false;
523  }
524  }// TGC Stations
525  }// WireStrip
526 
527  // Cut Segment if no stations can be checked
528  if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
530  // Segment has passed all global cuts, fill histogram variables
531  // If no segments have already passed all cuts
532  if(nValidatedSegm==0){
533  for(int jTGC=0;jTGC<4;jTGC++){// TGC Stations
534  // Assign values of variables to fill histograms
535  // posThetaFill = segm1PosThe;
536  // posPhiFill = segm1PosPhi;
537 
538  //canCheckGlobalFill[jTGC] = canCheckGlobal[jTGC];
539  canCheckSectorFill[jTGC] = canCheckSector[jTGC];
540 
541  TGCstation_StationFEFill[jTGC] = TGCstation_StationFE[jTGC];
542  TGCstation_StationEtaFill[jTGC] = TGCstation_StationEta[jTGC];
543  TGCstation_StationPhiFill[jTGC] = TGCstation_StationPhi[jTGC];
544  }
545  for(int l=0;l<9;l++){
546  for(int k=0;k<2;k++){
547  sectorhitregisteredFill[l][k] = sectorhitregistered[l][k];
548  // hitregisteredFill[l][k] = hitregistered[l][k];
549  }
550  }
551  }// TGC Stations
552  nValidatedSegm++;
553  }// nSegm1
554 
555  // If only one Segment was validated on this side
556  if(nValidatedSegm==1){
557  for(int l=0;l<9;l++){//Layer
558  int stationIndex = TGClayer2stationindex(l);
559  for(int k=0;k<2;k++){// WireStrip
560  // If this station can be checked
561  if(canCheckSectorFill[stationIndex]){
562  if((TGCstation_StationFEFill[stationIndex]<0)||(TGCstation_StationEtaFill[stationIndex]==0)||(TGCstation_StationPhiFill[stationIndex]==0)){
563  ATH_MSG_WARNING( "MidstationOnly: canCheckSector passed for jTGC=" << stationIndex
564  << " but, FE="<<TGCstation_StationFEFill[stationIndex]
565  << " Eta="<<TGCstation_StationEtaFill[stationIndex]
566  << " Phi=" << TGCstation_StationPhiFill[stationIndex] );
567  continue;
568  }
569  // Get Sector histogram indexes
570  int stationMap_EtaIndex=getStationMapIndex(1, l, TGCstation_StationFEFill[stationIndex], TGCstation_StationEtaFill[stationIndex], TGCstation_StationPhiFill[stationIndex]);
571  int stationMap_PhiIndex=getStationMapIndex(2, l, TGCstation_StationFEFill[stationIndex], TGCstation_StationEtaFill[stationIndex], TGCstation_StationPhiFill[stationIndex]);
572 
573  // Fill Sector efficiency histograms
574  if(sectorhitregisteredFill[l][k]){// Hit in Sector matches extrapolated track
575  m_eff_stationmapmid[i][k][1]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
576  }
577  m_eff_stationmapmid[i][k][2]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
578  }
579  }// WireStrip
580  }// layer
581  }
582 
583  }// AC
584 
585 }// End of Function

◆ 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; }

◆ numberOfSL()

int MdtVsTgcRawDataValAlg::numberOfSL ( const Muon::TgcCoinDataContainer *  tgctrgcontainer)
private

Definition at line 83 of file MdtVsTgcRawData_functions.cxx.

83  {
84 
85  int nSL=0;
86 
87  //loop over TGC RoI container
88  Muon::TgcCoinDataContainer::const_iterator it_end=tgctrgcontainer->end();
89  for( Muon::TgcCoinDataContainer::const_iterator it=tgctrgcontainer->begin();
90  it!=it_end;
91  ++it){
92 
93 
94  ATH_MSG_DEBUG( "size of tgc collection is " << (*it) -> size() );
95 
96  //loop over TGC RoI collection
97  Muon::TgcCoinDataCollection::const_iterator itc_end=(*it)->end();
98  for( Muon::TgcCoinDataCollection::const_iterator itc=(*it)->begin();
99  itc!= itc_end;
100  ++itc){
101 
102  const Muon::TgcCoinData* tcd=*itc;
103 
104  if( tcd->type() != Muon::TgcCoinData::TYPE_SL )continue;
105  ATH_MSG_DEBUG("pt"<<tcd->pt() );
106  nSL++;
107  }
108  }
109 
110  return nSL;
111 }

◆ 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 }

◆ phi2sector()

int MdtVsTgcRawDataValAlg::phi2sector ( int  phi,
int  ef 
)
private

Definition at line 57 of file MdtVsTgcRawData_functions.cxx.

57  {
58  int sector=-1;
59  if(ef==0){//forward
60  sector=phi/2+1;//(phi,sector)= (1,1), (2,2), (3,2), (4,3)
61  }else{//endcap
62  sector=(phi+1)/4+1;//(phi,sector)= (1,1), (2,1), (3,2), (4,2)
63  }
64  if(sector>12)sector=1;
65 
66  return sector;
67 }

◆ prepareTREarray()

void MdtVsTgcRawDataValAlg::prepareTREarray ( const MuonGM::MuonDetectorManager *  MuonDetMgrDS)
private

Definition at line 86 of file MdtVsTgcRawData_TGCEffCheck.cxx.

86  {
87  int TGCStationNames[8]={41, 42, 43, 44, 45, 46, 47, 48};
88 
89  // Make array of TGC Readout Element pointers
90  for(int stationNameIndex=0; stationNameIndex<8; stationNameIndex++){// Station Name
91  int stationName = TGCStationNames[stationNameIndex];
92  for(int stationEta=-8; stationEta<=8; stationEta++){// Station Eta
93  int tgcAC(stationEta<0);
94  int absStationEta = std::abs(stationEta);
95  for(int stationPhi=0; stationPhi<=48; stationPhi++){// Station Phi
96  // Exclude non-existent "zero" sectors included in the array for ease of use
97  if(stationEta==0){
98  m_TREarray[stationNameIndex][0][absStationEta][stationPhi]=nullptr;
99  m_TREarray[stationNameIndex][1][absStationEta][stationPhi]=nullptr;
100  continue;
101  }
102  m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi]=nullptr;
103  if(stationPhi==0)continue;
104 
105  // Exclude sectors known not to exist
106  if(stationNameIndex==6){ // Inner Forward
107  if(std::abs(stationEta)>1)continue;
108  if(stationPhi>24)continue;
109  }
110  else if(stationNameIndex==7){ // Inner Endcap
111  if(std::abs(stationEta)>1)continue;
112  if(stationPhi>21)continue;
113  }
114  else if((stationNameIndex==0)|| // Midstation Forward
115  (stationNameIndex==2)||
116  (stationNameIndex==4)){
117  if(std::abs(stationEta)>1)continue;
118  if(stationPhi>24)continue;
119  }
120  else{ // Midstation Endcap
121  if(std::abs(stationEta)>5)continue;
122  if((stationNameIndex==1)&&
123  (std::abs(stationEta)>4))continue;
124  }
125 
126  // Get identifier of TRE at this set of indexes
127  bool isValid{false};
128  Identifier tgc_testId = m_idHelperSvc->tgcIdHelper().elementID(stationName, stationEta, stationPhi, isValid);
129  if(!isValid){continue;}
130 
131  // Get TRE and put into to array
132  m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi] = MuonDetMgrDS->getTgcReadoutElement(tgc_testId);
133  if(m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi]==nullptr){
134  ATH_MSG_WARNING( "prepareTREarray: TgcReadoutElement==0 passed checks" );
135  continue;
136  }
137  }// Station Phi
138  }// Station Eta
139  }// Station Name
140  return;
141 }// End of function

◆ 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 MdtVsTgcRawDataValAlg::procHistograms ( )
virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 186 of file MdtVsTgcRawDataValAlg.cxx.

186  {
187 /*----------------------------------------------------------------------------------*/
188 
189  ATH_MSG_DEBUG( "MdtVsTgcRawDataValAlg finalize()" );
190  if(endOfRunFlag()){
191  tgceffcalcfinalize();
192  maphistsfinalize();
193  }
194  return StatusCode::SUCCESS;
195 }

◆ putBox()

void MdtVsTgcRawDataValAlg::putBox ( TH2 *  h2,
float  x1,
float  y1,
float  x2,
float  y2 
)
private

Definition at line 129 of file MdtVsTgcRawData_functions.cxx.

129  {
130  TBox* box = new TBox(x1, y1, x2, y2);
131 // box->SetFillColor(kGray+1);
132 // box->SetLineColor(kGray+1);
133 // box->SetFillStyle(3013);
134 // box->SetFillStyle(3004);
135 
136  box->SetFillColor(kGray);
137  box->SetLineColor(kGray);
138 
139 // box->SetLineStyle(3);
140 
141  (h->GetListOfFunctions())->Add(box);
142 }

◆ 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  }

◆ roi2etaphi()

void MdtVsTgcRawDataValAlg::roi2etaphi ( const Muon::TgcCoinData &  cd,
int &  eta,
int &  phi 
)
private

Definition at line 28 of file MdtVsTgcRawData_functions.cxx.

28  {
29 
30  int roiphi=cd.phi();//phi in 1/48(24) sector for endcap(forward)
31  int roi=cd.roi();//0-147(0-63)
32 
33  //int localeta=roi/4;
34 
35  if(cd.isForward()){//forward
36 
37  int localphi=roi%4;
38 
39  //eta=roi/4;
40  eta=roi/4+36;
41  phi=(localphi+roiphi*4)*2;
42 
43  }else{//endcap
44 
45  int sector=phi2sector(roiphi,1);
46 
47  phi=roiphi*4 + ( sector%2==0 ? roi%4 : 3-(roi%4) );
48  eta=roi/4;
49  }
50 
51  //eta=52-eta;
52  return;
53 
54 }

◆ roiphi2mdtSector()

int MdtVsTgcRawDataValAlg::roiphi2mdtSector ( int  roiphi,
int  ef 
)
private

Definition at line 70 of file MdtVsTgcRawData_functions.cxx.

70  {
71  int mdtSector=-1;
72  if(ef==0){//forward phi1-24
73  mdtSector=roiphi/2+1;//(phi,sector)= (1,1), (2,2), (3,2), (4,3)
74  }else{//endcap
75  mdtSector=(roiphi+1)/4+1;//(phi,sector)= (1,1), (2,1), (3,2), (4,2)
76  }
77  if(mdtSector>8)mdtSector=1;
78 
79  return mdtSector;
80 }

◆ roitotalphi2sectorphi()

int MdtVsTgcRawDataValAlg::roitotalphi2sectorphi ( int  phi)
private

◆ 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 }

◆ 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 }

◆ SortMDTSegments()

void MdtVsTgcRawDataValAlg::SortMDTSegments ( const xAOD::MuonSegmentContainer *  m_newsegment,
std::vector< const Muon::MuonSegment * >(&)  sortedSegments[2][4] 
)
private

Definition at line 29 of file MdtVsTgcRawData_SegmSorting.cxx.

30  {
31 
32  // Loop over all segments in event
33  xAOD::MuonSegmentContainer::const_iterator mdtseg_itr = newsegment->begin();
34  xAOD::MuonSegmentContainer::const_iterator mdtseg_end = newsegment->end();
35  for(; mdtseg_itr!=mdtseg_end; ++mdtseg_itr){
36  if(!(*mdtseg_itr)->muonSegment().isValid())continue;
37  // Get segm
38  const Muon::MuonSegment* segm = dynamic_cast<const Muon::MuonSegment*>(*(*mdtseg_itr)->muonSegment());
39  if (segm == nullptr) {
40  ATH_MSG_ERROR( "no pointer to segm!!!" );
41  break;
42  }
43 
44  bool isMdt=false, isEndcap=false; // Flags for whether the Segment has hits from the MDT/Endcap
45  int nMdtMeas[4]={0,0,0,0}; // int array to count number of MDT hits in different stations
46 
47  // Loop through contained ROTs and identify used stations
48  for(unsigned int iROT=0; iROT<segm->numberOfContainedROTs(); ++iROT){
49  const Trk::RIO_OnTrack* rio = segm->rioOnTrack(iROT);
50  if(!rio){
51  ATH_MSG_DEBUG("No RIO");
52  continue;
53  }
54  Identifier id = rio->identify();
55 
56  // Identify MDT Endcap Segments
57  if(m_idHelperSvc->isMdt(id))isMdt=true;
58  if(m_idHelperSvc->isEndcap(id))isEndcap=true;
59 
60  int stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
61  // Large (L) = odd, greater r, Small (S) = even, lower r
62  // 13=EIL 49=EIS 14=EEL 15=EES 17=EML 18=EMS 20=EOL 21=EOS
63  if((stationName==13)||(stationName==49))nMdtMeas[0]++;// MDT
64  if((stationName==14)||(stationName==15))nMdtMeas[1]++;// MDT
65  if((stationName==17)||(stationName==18))nMdtMeas[2]++;// MDT
66  if((stationName==20)||(stationName==21))nMdtMeas[3]++;// MDT
67  }
68 
69  // If not Endcap and does not contain MDT hits
70  if(!isMdt||!isEndcap)continue;
71 
72  // Get Side
73  int segmAC = (segm->globalPosition().eta()<0);// a:0, c:1
74 
75  // Check MDT Stations included in this Segment
76  int nMDTStations=0; int MDTStationj=-1;
77  for(int jMDT=0;jMDT<4;jMDT++){
78  if(nMdtMeas[jMDT]!=0){
79  nMDTStations++;
80  MDTStationj=jMDT;
81  }
82  }
83 
84  // MC data has an odd channel set always triggering segments, this cuts them
85  if((segmAC==0)&&(MDTStationj==0)&&
86  (segm->globalPosition().eta()>1.815)&&(segm->globalPosition().eta()<1.82)&&
87  (segm->globalPosition().phi()>2.857)&&(segm->globalPosition().phi()<2.862))continue;
88 
89  // If there is only one station pass the segment data on to the variables
90  if(nMDTStations==1){
91  //HasStationSegm[segmAC][MDTStationj]=true;
92  sortedSegments[segmAC][MDTStationj].push_back(segm);
93  }
94  }// Loop over segments
95 }// End of function

◆ stationGasGap2layer()

int MdtVsTgcRawDataValAlg::stationGasGap2layer ( int  station,
int  GasGap 
)
private

Definition at line 114 of file MdtVsTgcRawData_functions.cxx.

114  {
115  int layer=0;
116  if(station==41||station==42){
117  layer += GasGap;
118  }else if(station==43||station==44){
119  layer = 3+GasGap;
120  }else if(station==45||station==46){
121  layer = 5+GasGap;
122  }
123  return layer;
124 }

◆ 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.

◆ tgceffcalc()

void MdtVsTgcRawDataValAlg::tgceffcalc ( const xAOD::MuonSegmentContainer *  m_newsegment,
const Muon::TgcPrepDataContainer *  tgc_prepcontainer 
)
private

Definition at line 36 of file MdtVsTgcRawData_TGCEffCheck.cxx.

37  {
38  ATH_MSG_DEBUG("inside tgcEIFIeffcalc" );
40  // Declare vector arrays to hold segment pointers
41 
42  // Holds Segments sorted into MDT Stations on each side
43  std::vector<const Muon::MuonSegment*> sortedSegments[2][4]; //[AC][MDTStation]
44 
45  // Holds Segments which have been disqualified, any segments in this array are ignored when looping through sortedSegments
46  std::vector<const Muon::MuonSegment*> DQdisqualifiedSegments[2][4]; //[AC][MDTStation] // Segments which have been disqualified by DQ
47  std::vector<const Muon::MuonSegment*> MATCHdisqualifiedSegments[2][4];//[AC][MDTStation] // Segments which have been disqualified by DQ or already been included in a track
48 
49  // Holds Segments which have been matched into a track
50  std::vector<SegmTrack> matchedSegments[2]; //[AC]
51 
52 
54  // Sort and filter Segments
55 
56  // Sort Segments from segmcollection into correct bin in sortedSegments array
57  SortMDTSegments(newmdtsegment, sortedSegments);
58  // Disqualify Segments with bad DQ
59  DQCheckMDTSegments(sortedSegments, DQdisqualifiedSegments);
60  for(int i=0;i<2;i++){
61  for(int jMDT=0;jMDT<4;jMDT++){
62  MATCHdisqualifiedSegments[i][jMDT] = DQdisqualifiedSegments[i][jMDT];
63  }
64  }
65 
66 
68  // Segment Track Method
69  // Match up Segments into tracks
70  MatchMDTSegments(sortedSegments, MATCHdisqualifiedSegments, matchedSegments);
71  // Use tracks to look for TGC hits
72  CheckTGConTrack(matchedSegments, tgc_prepcontainer);
73 
74 
76  // Midstation-only Method
77 
78  // Use segments to check Midstation again
79  MidstationOnlyCheck(sortedSegments, DQdisqualifiedSegments, tgc_prepcontainer);
80 
81  return;
82 }// End of function

◆ tgceffcalcfinalize()

void MdtVsTgcRawDataValAlg::tgceffcalcfinalize ( )
private

Definition at line 145 of file MdtVsTgcRawData_TGCEffCheck.cxx.

145  {
146  int beff, bdenom, berror;
147  float feff, fdenom;
148  for(int i=0;i<2;i++){// AC
149  // Station Coordinate Efficiency Histograms
150  for(int k=0;k<2;k++){// WireStrip
151  // Loop Numerator and Denominator, total up histograms
152  for(int e=1;e<3;e++){
153  TList histlist;
154  histlist.Add(m_eff_stationmapbase[i][k][e]);
155  histlist.Add(m_eff_stationmapmid[i][k][e]);
156  m_eff_stationmap[i][k][e]->Merge(&histlist);
157  }
158 
159  const int nhtypes = 3;
160  // Make array of pointers to different efficiency histogram types
161  TH2 *histarray[nhtypes][4] = {{ m_eff_stationmapbase[i][k][0], m_eff_stationmapbase[i][k][1], m_eff_stationmapbase[i][k][2], m_eff_stationmapbase[i][k][3]},
162  { m_eff_stationmapmid[i][k][0], m_eff_stationmapmid[i][k][1], m_eff_stationmapmid[i][k][2], m_eff_stationmapmid[i][k][3]},
163  { m_eff_stationmap[i][k][0], m_eff_stationmap[i][k][1], m_eff_stationmap[i][k][2], m_eff_stationmap[i][k][3]}};
164  for(int h=0;h<nhtypes;h++){
165  // Calculate Efficiency
166  histarray[h][0]->Divide(histarray[h][1], histarray[h][2]);
167 
168  // Calculate Error
169  int nX=histarray[h][3]->GetNbinsX();
170  int nY=histarray[h][3]->GetNbinsY();
171  for(int x=1;x<=nX;x++){
172  for(int y=1;y<=nY;y++){
173  beff =histarray[h][0]->GetBin(x,y);
174  bdenom=histarray[h][2]->GetBin(x,y);
175  berror=histarray[h][3]->GetBin(x,y);
176 
177  feff =histarray[h][0]->GetBinContent(beff);
178  fdenom=histarray[h][2]->GetBinContent(bdenom);
179 
180  float result = 0;
181  if(fdenom>0){
182  result=sqrt(feff*(1-feff)/fdenom);
183  }
184  histarray[h][3]->SetBinContent(berror,result);
185  }// nY Bins
186  }// nX Bins
187  }
188  }// WireStrip
189  }// AC
190 
191  return;
192 }// End of function

◆ TGCgetlayer()

int MdtVsTgcRawDataValAlg::TGCgetlayer ( int  stationName,
int  g 
)
private

Definition at line 196 of file MdtVsTgcRawData_TGCEffCheck.cxx.

196  {
197  if(g<1){
198  ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap g=" << g );
199  return -1;
200  }
201  int l = g-1;
202  if(stationName==41||stationName==42){
203  if(g>3){
204  ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g );
205  return -1;
206  }
207  }else if(stationName==43||stationName==44){
208  if(g>2){
209  ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g );
210  return -1;
211  }
212  l+=3;
213  }else if(stationName==45||stationName==46){
214  if(g>2){
215  ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g );
216  return -1;
217  }
218  l+=5;
219  }else if(stationName==47||stationName==48){
220  if(g>2){
221  ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g );
222  return -1;
223  }
224  l+=7;
225  }else{
226  ATH_MSG_WARNING( "TGCgetlayer passed invalid stationName n=" << stationName );
227  return -1;
228  }
229  return l;
230 }// End of function

◆ TGClayer2stationindex()

int MdtVsTgcRawDataValAlg::TGClayer2stationindex ( int  l)
private

Definition at line 234 of file MdtVsTgcRawData_TGCEffCheck.cxx.

234  {
235  if(l==0||l==1||l==2)return 0;
236  else if(l==3||l==4)return 1;
237  else if(l==5||l==6)return 2;
238  else if(l==7||l==8)return 3;
239  else{
240  ATH_MSG_WARNING( "TGClayer2Station passed invalid layer number:" << l );
241  return -1;
242  }
243 }// End of function

◆ TGCstationname2stationindex()

int MdtVsTgcRawDataValAlg::TGCstationname2stationindex ( int  stationName)
private

Definition at line 246 of file MdtVsTgcRawData_TGCEffCheck.cxx.

246  {
247  if(stationName==41||stationName==42)return 0;
248  else if(stationName==43||stationName==44)return 1;
249  else if(stationName==45||stationName==46)return 2;
250  else if(stationName==47||stationName==48)return 3;
251  else{
252  ATH_MSG_WARNING( "TGCstationname2stationindex passed invalid stationName n=" << stationName );
253  return -1;
254  }
255 }// End of function

◆ 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 }

◆ 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_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 956 of file ManagedMonitorToolBase.h.

◆ m_chamberName

std::string MdtVsTgcRawDataValAlg::m_chamberName
private

Definition at line 75 of file MdtVsTgcRawDataValAlg.h.

◆ m_checkCabling

bool MdtVsTgcRawDataValAlg::m_checkCabling
private

Definition at line 72 of file MdtVsTgcRawDataValAlg.h.

◆ m_cosmicStation

int MdtVsTgcRawDataValAlg::m_cosmicStation
private

Definition at line 80 of file MdtVsTgcRawDataValAlg.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 963 of file ManagedMonitorToolBase.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_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_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MdtVsTgcRawDataValAlg::m_DetectorManagerKey
private
Initial value:
{this, "DetectorManagerKey",
"MuonDetectorManager",
"Key of input MuonDetectorManager condition data"}

Definition at line 66 of file MdtVsTgcRawDataValAlg.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_DQFilterTools

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

Definition at line 912 of file ManagedMonitorToolBase.h.

◆ m_eff_stationmap

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmap[2][2][4] {}
private

Definition at line 145 of file MdtVsTgcRawDataValAlg.h.

◆ m_eff_stationmapbase

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmapbase[2][2][4] {}
private

Definition at line 143 of file MdtVsTgcRawDataValAlg.h.

◆ m_eff_stationmapmid

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmapmid[2][2][4] {}
private

Definition at line 144 of file MdtVsTgcRawDataValAlg.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_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_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 929 of file ManagedMonitorToolBase.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MdtVsTgcRawDataValAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 69 of file MdtVsTgcRawDataValAlg.h.

◆ m_lastEvent

int MdtVsTgcRawDataValAlg::m_lastEvent
private

Definition at line 79 of file MdtVsTgcRawDataValAlg.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_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_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_mdt_PrepDataContainerName

SG::ReadHandleKey<Muon::MdtPrepDataContainer> MdtVsTgcRawDataValAlg::m_mdt_PrepDataContainerName {this,"MdtPrepDataContainer","MDT_DriftCircles","MDT PRDs"}
private

Definition at line 83 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_SegmentCollectionName

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MdtVsTgcRawDataValAlg::m_mdt_SegmentCollectionName {this,"MdtSegmentCollection","MuonSegments","muon segments"}
private

Definition at line 84 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_segmmap

TH2* MdtVsTgcRawDataValAlg::m_mdt_segmmap[2][4] {}
private

Definition at line 111 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_segmmatchsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_segmmatchsag[2][4][4][4] {}
private

Definition at line 150 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_segmposdirsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_segmposdirsag[2][4][4] {}
private

Definition at line 151 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_trackchecksag

TH1* MdtVsTgcRawDataValAlg::m_mdt_trackchecksag[2][4][4][4][2] {}
private

Definition at line 153 of file MdtVsTgcRawDataValAlg.h.

◆ m_mdt_trackdirdirsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_trackdirdirsag[2][4][4][4] {}
private

Definition at line 152 of file MdtVsTgcRawDataValAlg.h.

◆ m_MdtAdcCut

int MdtVsTgcRawDataValAlg::m_MdtAdcCut
private

Definition at line 86 of file MdtVsTgcRawDataValAlg.h.

◆ m_MdtTdcCut

int MdtVsTgcRawDataValAlg::m_MdtTdcCut
private

Definition at line 87 of file MdtVsTgcRawDataValAlg.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 889 of file ManagedMonitorToolBase.h.

◆ m_mvt_cutspassed

TH1* MdtVsTgcRawDataValAlg::m_mvt_cutspassed[2] {}
private

Definition at line 109 of file MdtVsTgcRawDataValAlg.h.

◆ m_mvt_extrprdsag

TH1* MdtVsTgcRawDataValAlg::m_mvt_extrprdsag[2][4][2][2][4] {}
private

Definition at line 147 of file MdtVsTgcRawDataValAlg.h.

◆ m_mvt_extrprdsag2

TH1* MdtVsTgcRawDataValAlg::m_mvt_extrprdsag2[2][4][2][2][4] {}
private

Definition at line 148 of file MdtVsTgcRawDataValAlg.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_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 928 of file ManagedMonitorToolBase.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_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 914 of file ManagedMonitorToolBase.h.

◆ m_sector

int MdtVsTgcRawDataValAlg::m_sector
private

Definition at line 77 of file MdtVsTgcRawDataValAlg.h.

◆ m_side

int MdtVsTgcRawDataValAlg::m_side
private

Definition at line 78 of file MdtVsTgcRawDataValAlg.h.

◆ m_stationHists

MuonDQAHistMap MdtVsTgcRawDataValAlg::m_stationHists
private

Definition at line 63 of file MdtVsTgcRawDataValAlg.h.

◆ m_StationSize

std::string MdtVsTgcRawDataValAlg::m_StationSize
private

Definition at line 76 of file MdtVsTgcRawDataValAlg.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 904 of file ManagedMonitorToolBase.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_tgc_CoinContainerName

SG::ReadHandleKey<Muon::TgcCoinDataContainer> MdtVsTgcRawDataValAlg::m_tgc_CoinContainerName {this,"OutputCoinCollection","TrigT1CoinDataCollection","TGC coincidences"}
private

Definition at line 82 of file MdtVsTgcRawDataValAlg.h.

◆ m_tgc_prdcompsag

TH1* MdtVsTgcRawDataValAlg::m_tgc_prdcompsag[2][2][4] {}
private

Definition at line 149 of file MdtVsTgcRawDataValAlg.h.

◆ m_tgc_PrepDataContainerName

SG::ReadHandleKey<Muon::TgcPrepDataContainer> MdtVsTgcRawDataValAlg::m_tgc_PrepDataContainerName {this,"TgcPrepDataContainer","TGC_Measurements","TGC PRDs"}
private

Definition at line 81 of file MdtVsTgcRawDataValAlg.h.

◆ m_tgclv1file

bool MdtVsTgcRawDataValAlg::m_tgclv1file
private

Definition at line 73 of file MdtVsTgcRawDataValAlg.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 906 of file ManagedMonitorToolBase.h.

◆ m_TREarray

const MuonGM::TgcReadoutElement* MdtVsTgcRawDataValAlg::m_TREarray[8][2][9][49] {}
private

Definition at line 94 of file MdtVsTgcRawDataValAlg.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_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.

The documentation for this class was generated from the following files:
AthenaMonManager::ownedLWHistOfKey
virtual LWHist * ownedLWHistOfKey(const std::string &key) const
Definition: AthenaMonManager.cxx:726
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
createDCubeDigitHistograms.mdtTubeLayer
mdtTubeLayer
Definition: createDCubeDigitHistograms.py:111
MdtVsTgcRawDataValAlg::m_mdt_trackdirdirsag
TH1 * m_mdt_trackdirdirsag[2][4][4][4]
Definition: MdtVsTgcRawDataValAlg.h:152
LWHist
Definition: LWHist.h:26
TH2::Fill
int Fill(double, double)
Definition: rootspy.cxx:382
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
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
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
ManagedMonitorToolBase::m_newRun
bool m_newRun
Definition: ManagedMonitorToolBase.h:883
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition: ManagedMonitorToolBase.h:959
defineDB.smd
string smd
Definition: JetTagCalibration/share/defineDB.py:44
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
MdtVsTgcRawDataValAlg::m_mdt_segmposdirsag
TH1 * m_mdt_segmposdirsag[2][4][4]
Definition: MdtVsTgcRawDataValAlg.h:151
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
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
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
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
ManagedMonitorToolBase::m_newEventsBlock
bool m_newEventsBlock
Definition: ManagedMonitorToolBase.h:884
Trk::SurfaceBounds::inside
virtual bool inside(const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const =0
Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds.
ManagedMonitorToolBase::Imp::benchPreProcHistograms
void benchPreProcHistograms()
Definition: ManagedMonitorToolBase.cxx:122
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
MdtVsTgcRawDataValAlg::numberOfSL
int numberOfSL(const Muon::TgcCoinDataContainer *tgctrgcontainer)
Definition: MdtVsTgcRawData_functions.cxx:83
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
MdtVsTgcRawDataValAlg::m_eff_stationmapbase
TH2 * m_eff_stationmapbase[2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:143
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MdtVsTgcRawDataValAlg::maphists
void maphists(const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
Definition: MdtVsTgcRawData_maptgchits.cxx:38
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ManagedMonitorToolBase::higStat
@ higStat
Definition: ManagedMonitorToolBase.h:115
MdtVsTgcRawDataValAlg::m_sector
int m_sector
Definition: MdtVsTgcRawDataValAlg.h:77
MdtVsTgcRawDataValAlg::m_chamberName
std::string m_chamberName
Definition: MdtVsTgcRawDataValAlg.h:75
MdtVsTgcRawDataValAlg::tgceffcalcfinalize
void tgceffcalcfinalize()
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:145
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:114
MdtVsTgcRawDataValAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtVsTgcRawDataValAlg.h:69
ManagedMonitorToolBase::m_endOfLumiBlock
bool m_endOfLumiBlock
Definition: ManagedMonitorToolBase.h:885
TH1I
Definition: rootspy.cxx:332
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
MuonGM::TgcReadoutElement::isForward
bool isForward() const
Returns true if the chamber is mounted on the most inner ring, i.e. a TxF chamber.
MdtVsTgcRawDataValAlg::prepareTREarray
void prepareTREarray(const MuonGM::MuonDetectorManager *MuonDetMgrDS)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:86
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
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
MdtVsTgcRawDataValAlg::putBox
void putBox(TH2 *h2, float x1, float y1, float x2, float y2)
Definition: MdtVsTgcRawData_functions.cxx:129
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AthenaMonManager::writeAndResetLWHist
virtual LWHist * writeAndResetLWHist(const std::string &key, const std::string &streamName)
Definition: AthenaMonManager.cxx:802
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
Muon::TgcCoinData::isAside
bool isAside() const
Aside or Cside.
Definition: TgcCoinData.h:348
Muon::TgcCoinData::type
CoinDataType type() const
return the coincidence type (HIPT, LPT, SL)
Definition: TgcCoinData.h:346
AthenaMonManager::runNumber
static unsigned int runNumber()
Definition: AthenaMonManager.cxx:364
Muon::MuonSegment::rioOnTrack
const Trk::RIO_OnTrack * rioOnTrack(unsigned int) const
returns the RIO_OnTrack (also known as ROT) objects depending on the integer
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:187
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:699
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
ManagedMonitorToolBase::Imp::benchPreFillHistograms
void benchPreFillHistograms()
Definition: ManagedMonitorToolBase.cxx:97
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition: ManagedMonitorToolBase.cxx:1130
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
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition: ManagedMonitorToolBase.cxx:1033
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
skel.it
it
Definition: skel.GENtoEVGEN.py:423
M_PI
#define M_PI
Definition: ActiveFraction.h:11
MdtVsTgcRawDataValAlg::m_mdt_SegmentCollectionName
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_mdt_SegmentCollectionName
Definition: MdtVsTgcRawDataValAlg.h:84
TRT_PAI_gasdata::AC
const float AC
Definition: TRT_PAI_gasdata.h:27
MdtVsTgcRawDataValAlg::m_mdt_PrepDataContainerName
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_mdt_PrepDataContainerName
Definition: MdtVsTgcRawDataValAlg.h:83
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ManagedMonitorToolBase::m_d
Imp * m_d
Definition: ManagedMonitorToolBase.h:962
ManagedMonitorToolBase::m_lastLowStatInterval
int m_lastLowStatInterval
Definition: ManagedMonitorToolBase.h:924
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ManagedMonitorToolBase::m_triggerGroupProp
std::string m_triggerGroupProp
Definition: ManagedMonitorToolBase.h:918
LWHistAthMonWrapper::setStreamName
static void setStreamName(LWHist *, const std::string &streamName)
MdtVsTgcRawDataValAlg::BlankPhi24
void BlankPhi24(TH2 *h2, int binx)
Definition: MdtVsTgcRawData_functions.cxx:144
ManagedMonitorToolBase::Imp::benchPostProcHistograms
void benchPostProcHistograms()
Definition: ManagedMonitorToolBase.cxx:130
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:901
Muon::TgcPrepData::detectorElement
virtual const MuonGM::TgcReadoutElement * detectorElement() const override final
Returns the detector element corresponding to this PRD The pointer will be zero if the det el is not ...
Definition: TgcPrepData.h:120
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
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
ManagedMonitorToolBase::fill
@ fill
Definition: ManagedMonitorToolBase.h:116
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
Muon::CompetingMuonClustersOnTrack
Definition: CompetingMuonClustersOnTrack.h:54
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:214
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: ManagedMonitorToolBase.cxx:1423
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
MuonGM::MuonReadoutElement::getLongSsize
double getLongSsize() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:199
MdtVsTgcRawDataValAlg::m_cosmicStation
int m_cosmicStation
Definition: MdtVsTgcRawDataValAlg.h:80
MdtVsTgcRawDataValAlg::m_tgc_prdcompsag
TH1 * m_tgc_prdcompsag[2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:149
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
x
#define x
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
Muon::MuonSegment::numberOfContainedROTs
unsigned int numberOfContainedROTs() const
number of RIO_OnTracks
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:199
ManagedMonitorToolBase::regManagedTrees
StatusCode regManagedTrees(std::vector< MgmtParams< TTree > > &templateTrees)
Definition: ManagedMonitorToolBase.cxx:1261
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
Muon::TgcCoinData
Definition: TgcCoinData.h:37
MdtVsTgcRawDataValAlg::TGClayer2stationindex
int TGClayer2stationindex(int l)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:234
ManagedMonitorToolBase::m_newHigStatInterval
bool m_newHigStatInterval
Definition: ManagedMonitorToolBase.h:882
makeTRTBarrelCans.y1
tuple y1
Definition: makeTRTBarrelCans.py:15
MdtVsTgcRawDataValAlg::m_mvt_cutspassed
TH1 * m_mvt_cutspassed[2]
Definition: MdtVsTgcRawDataValAlg.h:109
ManagedMonitorToolBase::m_newMedStatInterval
bool m_newMedStatInterval
Definition: ManagedMonitorToolBase.h:882
TruthTest.itE
itE
Definition: TruthTest.py:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuonGM::TgcReadoutElement::channelPos
Amg::Vector3D channelPos(const Identifier &id) const
Returns the position of the active channel (wireGang or strip)
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
MdtVsTgcRawDataValAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MdtVsTgcRawDataValAlg.h:66
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
LWHistAthMonWrapper::streamName
static const std::string & streamName(LWHist *)
MdtVsTgcRawDataValAlg::BlankStationMap
void BlankStationMap(TH2 *h2, int ws)
Definition: MdtVsTgcRawData_functions.cxx:155
MdtVsTgcRawDataValAlg::m_tgc_PrepDataContainerName
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_tgc_PrepDataContainerName
Definition: MdtVsTgcRawDataValAlg.h:81
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
MuonGM::MuonDetectorManager::getTgcReadoutElement
const TgcReadoutElement * getTgcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:247
MuonGM::MuonReadoutElement::getSsize
double getSsize() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:196
AthenaMonManager::getLBsMedStat
static unsigned int getLBsMedStat()
Definition: AthenaMonManager.cxx:329
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
ManagedMonitorToolBase::m_bookHistogramsInitial
bool m_bookHistogramsInitial
Definition: ManagedMonitorToolBase.h:956
ManagedMonitorToolBase::Imp::m_warnAboutMissingInitialize
bool m_warnAboutMissingInitialize
Definition: ManagedMonitorToolBase.cxx:51
MdtVsTgcRawDataValAlg::m_mdt_trackchecksag
TH1 * m_mdt_trackchecksag[2][4][4][4][2]
Definition: MdtVsTgcRawDataValAlg.h:153
MdtVsTgcRawDataValAlg::m_TREarray
const MuonGM::TgcReadoutElement * m_TREarray[8][2][9][49]
Definition: MdtVsTgcRawDataValAlg.h:94
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LWHist::usingROOTBackend
bool usingROOTBackend() const
Definition: LWHist.h:73
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition: ManagedMonitorToolBase.cxx:2388
ManagedMonitorToolBase::m_preScaleProp
long m_preScaleProp
Definition: ManagedMonitorToolBase.h:916
LWHistAthMonWrapper::removeCustomData
static void removeCustomData(LWHist *)
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2325
ManagedMonitorToolBase::m_fileKey
std::string m_fileKey
Definition: ManagedMonitorToolBase.h:896
ManagedMonitorToolBase::m_lastLumiBlock
unsigned int m_lastLumiBlock
Definition: ManagedMonitorToolBase.h:922
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition: ManagedMonitorToolBase.h:742
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
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition: ManagedMonitorToolBase.h:726
MdtVsTgcRawDataValAlg::phi2sector
int phi2sector(int phi, int ef)
Definition: MdtVsTgcRawData_functions.cxx:57
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
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
ManagedMonitorToolBase::m_manager
AthenaMonManager * m_manager
Definition: ManagedMonitorToolBase.h:892
MdtVsTgcRawDataValAlg::m_MdtAdcCut
int m_MdtAdcCut
Definition: MdtVsTgcRawDataValAlg.h:86
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
LWHistAthMonWrapper::key
static const std::string & key(LWHist *)
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: ManagedMonitorToolBase.h:950
ManagedMonitorToolBase::m_streamNameFcn
StreamNameFcn * m_streamNameFcn
Definition: ManagedMonitorToolBase.h:904
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
lumiFormat.i
int i
Definition: lumiFormat.py:92
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
MdtVsTgcRawDataValAlg::SortMDTSegments
void SortMDTSegments(const xAOD::MuonSegmentContainer *m_newsegment, std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4])
Definition: MdtVsTgcRawData_SegmSorting.cxx:29
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
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
extractSporadic.h
list h
Definition: extractSporadic.py:97
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
MdtVsTgcRawDataValAlg::m_mvt_extrprdsag
TH1 * m_mvt_extrprdsag[2][4][2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:147
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
makeTRTBarrelCans.y2
tuple y2
Definition: makeTRTBarrelCans.py:18
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:530
MdtVsTgcRawDataValAlg::MatchMDTSegments
void MatchMDTSegments(std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], std::vector< SegmTrack >(&matchedSegments)[2])
Definition: MdtVsTgcRawData_SegmMatching.cxx:33
MdtVsTgcRawDataValAlg::m_tgc_CoinContainerName
SG::ReadHandleKey< Muon::TgcCoinDataContainer > m_tgc_CoinContainerName
Definition: MdtVsTgcRawDataValAlg.h:82
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
MdtVsTgcRawDataValAlg::m_mvt_extrprdsag2
TH1 * m_mvt_extrprdsag2[2][4][2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:148
Trk::Segment::containedMeasurements
const std::vector< const Trk::MeasurementBase * > & containedMeasurements() const
returns the vector of Trk::MeasurementBase objects
Definition: TrkEvent/TrkSegment/TrkSegment/Segment.h:166
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
MuonGM::TgcReadoutElement
A TgcReadoutElement corresponds to a single TGC chamber; therefore typically a TGC station contains s...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/TgcReadoutElement.h:42
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
ManagedMonitorToolBase::Imp::benchPostBookHistograms
void benchPostBookHistograms()
Definition: ManagedMonitorToolBase.cxx:87
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::m_triggerChainProp
std::string m_triggerChainProp
Definition: ManagedMonitorToolBase.h:917
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
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
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.
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
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
ManagedMonitorToolBase::ManagedMonitorToolBase
ManagedMonitorToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: ManagedMonitorToolBase.cxx:389
ManagedMonitorToolBase::medStat
@ medStat
Definition: ManagedMonitorToolBase.h:115
MuonGM::MuonReadoutElement::globalPosition
const Amg::Vector3D globalPosition() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:47
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition: ManagedMonitorToolBase.h:730
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
ManagedMonitorToolBase::m_metadataMap
MDMap_t m_metadataMap
Definition: ManagedMonitorToolBase.h:889
TH1::Fill
int Fill(double)
Definition: rootspy.cxx:285
ManagedMonitorToolBase::m_endOfEventsBlock
bool m_endOfEventsBlock
Definition: ManagedMonitorToolBase.h:885
TH2
Definition: rootspy.cxx:373
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
createDCubeDigitHistograms.mdtStationEta
mdtStationEta
Definition: createDCubeDigitHistograms.py:104
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
beamspotman.dir
string dir
Definition: beamspotman.py:623
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
MdtVsTgcRawDataValAlg::MidstationOnlyCheck
void MidstationOnlyCheck(std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
Definition: MdtVsTgcRawData_MidstationMatching.cxx:34
Trk::MeasurementBase
Definition: MeasurementBase.h:58
ManagedMonitorToolBase::m_lastRun
unsigned int m_lastRun
Definition: ManagedMonitorToolBase.h:923
MdtVsTgcRawDataValAlg::CheckTGConTrack
void CheckTGConTrack(std::vector< SegmTrack >(&matchedSegments)[2], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
Definition: MdtVsTgcRawData_PRDonTrack.cxx:36
ManagedMonitorToolBase::m_newLumiBlock
bool m_newLumiBlock
Definition: ManagedMonitorToolBase.h:883
ManagedMonitorToolBase::m_endOfLowStat
bool m_endOfLowStat
Definition: ManagedMonitorToolBase.h:885
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
python.grid.Add
def Add(name)
Definition: grid.py:41
MdtVsTgcRawDataValAlg::roi2etaphi
void roi2etaphi(const Muon::TgcCoinData &cd, int &eta, int &phi)
Definition: MdtVsTgcRawData_functions.cxx:28
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition: ManagedMonitorToolBase.h:952
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: ManagedMonitorToolBase.cxx:1395
makeegammaturnon.rebin
def rebin(binning, data)
Definition: makeegammaturnon.py:17
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
MdtVsTgcRawDataValAlg::bookeffhists
StatusCode bookeffhists(MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
Definition: MdtVsTgcRawData_bookhistograms.cxx:100
AthenaMonManager::getLBsHigStat
static unsigned int getLBsHigStat()
Definition: AthenaMonManager.cxx:332
SegmTrack
Definition: SegmTrack.h:22
LWHistAthMonWrapper::setKey
static void setKey(LWHist *, const std::string &key)
MdtVsTgcRawDataValAlg::m_MdtTdcCut
int m_MdtTdcCut
Definition: MdtVsTgcRawDataValAlg.h:87
MdtVsTgcRawDataValAlg::m_checkCabling
bool m_checkCabling
Definition: MdtVsTgcRawDataValAlg.h:72
ExtractEBRunDetails.endOfRun
endOfRun
Definition: ExtractEBRunDetails.py:245
MdtVsTgcRawDataValAlg::DQCheckMDTSegments
void DQCheckMDTSegments(std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4])
Definition: MdtVsTgcRawData_SegmDQ.cxx:34
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Muon::TgcCoinData::roi
int roi() const
return ROI number
Definition: TgcCoinData.h:378
MdtVsTgcRawDataValAlg::getStationMapIndex
int getStationMapIndex(int x, int l, int stationFE, int stationEta, int stationPhi)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:259
item
Definition: ItemListSvc.h:43
Muon::CompetingMuonClustersOnTrack::containedROTs
const std::vector< const MuonClusterOnTrack * > & containedROTs() const
returns the vector of SCT_ClusterOnTrack objects .
Definition: CompetingMuonClustersOnTrack.h:184
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
LWHist::setOwnsROOTHisto
void setOwnsROOTHisto(bool b)
Definition: LWHist.h:75
ManagedMonitorToolBase::m_lwhists
std::set< LWHist * > m_lwhists
Definition: ManagedMonitorToolBase.h:891
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
Muon::TgcCoinData::isForward
bool isForward() const
Forward region or Endcap region.
Definition: TgcCoinData.h:354
ManagedMonitorToolBase::m_templateLWHistograms
std::map< Interval_t, std::vector< MgmtParams< LWHist > > > m_templateLWHistograms
Definition: ManagedMonitorToolBase.h:734
MdtVsTgcRawDataValAlg::correlation
void correlation(const Muon::MdtPrepDataContainer *mdt_hit_container, const Muon::TgcCoinDataContainer *tgc_trigger_container)
Definition: MdtVsTgcRawData_correlation.cxx:27
MdtVsTgcRawDataValAlg::m_StationSize
std::string m_StationSize
Definition: MdtVsTgcRawDataValAlg.h:76
MdtVsTgcRawDataValAlg::m_mdt_segmmap
TH2 * m_mdt_segmmap[2][4]
Definition: MdtVsTgcRawDataValAlg.h:111
MdtVsTgcRawDataValAlg::bookmaphists
StatusCode bookmaphists(MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
Definition: MdtVsTgcRawData_bookhistograms.cxx:27
ManagedMonitorToolBase::m_managerNameProp
std::string m_managerNameProp
Definition: ManagedMonitorToolBase.h:894
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
MdtVsTgcRawDataValAlg::TGCstationname2stationindex
int TGCstationname2stationindex(int stationName)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:246
python.PyAthena.v
v
Definition: PyAthena.py:157
ManagedMonitorToolBase::m_nEventsIgnoreTrigger
unsigned int m_nEventsIgnoreTrigger
Definition: ManagedMonitorToolBase.h:927
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:116
ManagedMonitorToolBase::m_endOfRun
bool m_endOfRun
Definition: ManagedMonitorToolBase.h:885
ManagedMonitorToolBase::m_newLowStat
bool m_newLowStat
Definition: ManagedMonitorToolBase.h:883
DeMoScan.index
string index
Definition: DeMoScan.py:362
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
MdtVsTgcRawDataValAlg::maphistsfinalize
void maphistsfinalize()
Definition: MdtVsTgcRawData_maptgchits.cxx:141
lumiFormat.lumi
lumi
Definition: lumiFormat.py:113
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
MuonGM::MdtReadoutElement::tubePos
Amg::Vector3D tubePos(const Identifier &id) const
Returns the global position of the given tube.
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
y
#define y
h
Muon::TgcCoinData::pt
int pt() const
return pt threshold value
Definition: TgcCoinData.h:380
AthenaMonManager::forkedProcess
bool forkedProcess()
Definition: AthenaMonManager.cxx:345
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
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Muon::TgcCoinData::TYPE_SL
@ TYPE_SL
Definition: TgcCoinData.h:52
ManagedMonitorToolBase::Imp::benchPreBookHistograms
void benchPreBookHistograms()
Definition: ManagedMonitorToolBase.cxx:78
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
ManagedMonitorToolBase::m_nLumiBlocks
unsigned int m_nLumiBlocks
Definition: ManagedMonitorToolBase.h:928
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::eventsBlock
@ eventsBlock
Definition: ManagedMonitorToolBase.h:114
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition: envutil.py:152
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
MdtVsTgcRawDataValAlg::TGCgetlayer
int TGCgetlayer(int stationName, int g)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:196
MuonGM::MuonReadoutElement::getStationType
std::string getStationType() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:189
DEBUG
#define DEBUG
Definition: page_access.h:11
MdtVsTgcRawDataValAlg::m_mdt_segmmatchsag
TH1 * m_mdt_segmmatchsag[2][4][4][4]
Definition: MdtVsTgcRawDataValAlg.h:150
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
Muon::TgcPrepData
Class to represent TGC measurements.
Definition: TgcPrepData.h:32
MuonGM::TgcReadoutElement::length
double length() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/TgcReadoutElement.cxx:53
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:116
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
MdtVsTgcRawDataValAlg::labelStationMap
void labelStationMap(TH2 *h2, int i=-1, int k=-1)
Definition: MdtVsTgcRawData_bookhistograms.cxx:397
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...
calibdata.cd
cd
Definition: calibdata.py:51
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: ManagedMonitorToolBase.cxx:1415
MdtVsTgcRawDataValAlg::m_eff_stationmap
TH2 * m_eff_stationmap[2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:145
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
Muon::TgcPrepData::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Returns the global position.
Definition: TgcPrepData.h:125
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
Muon::MuonSegment::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
global position
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:157
ManagedMonitorToolBase::m_useTrigger
bool m_useTrigger
Definition: ManagedMonitorToolBase.h:920
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
ManagedMonitorToolBase::m_haveClearedLastEventBlock
bool m_haveClearedLastEventBlock
Definition: ManagedMonitorToolBase.h:929
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition: AthenaMonManager.cxx:352
MuonGM::MuonReadoutElement::sideA
bool sideA() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:207
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:127
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition: ManagedMonitorToolBase.h:722
MdtVsTgcRawDataValAlg::m_tgclv1file
bool m_tgclv1file
Definition: MdtVsTgcRawDataValAlg.h:73
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
python.PyAthena.obj
obj
Definition: PyAthena.py:135
MuonGM::MuonClusterReadoutElement::bounds
virtual const Trk::SurfaceBounds & bounds() const override
Return the boundaries of the element.
Definition: MuonClusterReadoutElement.h:127
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition: ManagedMonitorToolBase.h:910
LWHist::getROOTHistBase
virtual TH1 * getROOTHistBase()=0
ManagedMonitorToolBase::m_lastMedStatInterval
int m_lastMedStatInterval
Definition: ManagedMonitorToolBase.h:924
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition: ManagedMonitorToolBase.h:742
MuonGM::TgcReadoutElement::globalToLocalTransf
Amg::Transform3D globalToLocalTransf(const Identifier &id) const
Returns the global -> local transformation.
python.compressB64.c
def c
Definition: compressB64.py:93
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MdtVsTgcRawDataValAlg::m_side
int m_side
Definition: MdtVsTgcRawDataValAlg.h:78
MdtVsTgcRawDataValAlg::m_lastEvent
int m_lastEvent
Definition: MdtVsTgcRawDataValAlg.h:79
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
MdtVsTgcRawDataValAlg::m_eff_stationmapmid
TH2 * m_eff_stationmapmid[2][2][4]
Definition: MdtVsTgcRawDataValAlg.h:144
LheEventFiller_Common.ef
ef
Definition: SFGen_i/share/common/LheEventFiller_Common.py:7
MuonGM::MuonReadoutElement::getStationPhi
int getStationPhi() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:194
merge
Definition: merge.py:1
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
MdtVsTgcRawDataValAlg::tgceffcalc
void tgceffcalc(const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
Definition: MdtVsTgcRawData_TGCEffCheck.cxx:36
createDCubeDigitHistograms.mdtTube
mdtTube
Definition: createDCubeDigitHistograms.py:110
MuonGM::MuonReadoutElement::getStationEta
int getStationEta() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:193
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition: ManagedMonitorToolBase.cxx:588
Muon::MuonClusterOnTrack
Base class for Muon cluster RIO_OnTracks.
Definition: MuonClusterOnTrack.h:34
fitman.k
k
Definition: fitman.py:528
Muon::MuonSegment::globalDirection
const Amg::Vector3D & globalDirection() const
global direction
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:163
createDCubeDigitHistograms.mdtStationPhi
mdtStationPhi
Definition: createDCubeDigitHistograms.py:105
ManagedMonitorToolBase::m_defaultLBDuration
float m_defaultLBDuration
Definition: ManagedMonitorToolBase.h:958
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
Muon::TgcCoinData::phi
int phi() const
return phi number of trigger sector
Definition: TgcCoinData.h:350
Generated on Sun Jun 30 2024 21:53:05 for ATLAS Offline Software by   doxygen 1.8.18