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

#include <MdtRawDataMonAlg.h>

Inheritance diagram for MdtRawDataMonAlg:
Collaboration diagram for MdtRawDataMonAlg:

Public Types

enum  Environment_t {
  Environment_t::user = 0, Environment_t::online, Environment_t::tier0, Environment_t::tier0Raw,
  Environment_t::tier0ESD, Environment_t::AOD, Environment_t::altprod
}
 Specifies the processing environment. More...
 
enum  DataType_t {
  DataType_t::userDefined = 0, DataType_t::monteCarlo, DataType_t::collisions, DataType_t::cosmics,
  DataType_t::heavyIonCollisions
}
 Specifies what type of input data is being monitored. More...
 

Public Member Functions

 MdtRawDataMonAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~MdtRawDataMonAlg ()
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms More...
 
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by reference. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by reference. More...
 
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference. More...
 
void fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by name. More...
 
void fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by name. More...
 
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name. More...
 
Environment_t environment () const
 Accessor functions for the environment. More...
 
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object. More...
 
DataType_t dataType () const
 Accessor functions for the data type. More...
 
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object. More...
 
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array. More...
 
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member. More...
 
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed. More...
 
SG::ReadHandle< xAOD::EventInfo > GetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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 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
 

Protected Member Functions

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

ToolHandleArray< GenericMonitoringTool > m_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
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"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

virtual void fillMDTOverviewVects (const Muon::MdtPrepData *, bool &isNoiseBurstCandidate, MDTOverviewHistogramStruct &vects) const
 
virtual void fillMDTOverviewHistograms (const MDTOverviewHistogramStruct &vects) const
 
virtual StatusCode fillMDTSummaryVects (const Muon::MdtPrepData *, const std::set< std::string > &, bool &isNoiseBurstCandidate, bool trig_barrel, bool trig_endcap, std::array< MDTSummaryHistogramStruct, 4096 > *) const
 
virtual StatusCode fillMDTSummaryHistograms (std::array< MDTSummaryHistogramStruct, 4096 > *vects, int lb) const
 
virtual StatusCode fillMDTHistograms (const Muon::MdtPrepData *) const
 
StatusCode handleEvent_effCalc_fillVects (const Trk::SegmentCollection *segms, MDTSegmentHistogramStruct(&vects)[4][4][16]) const
 
virtual StatusCode fillMDTSegmentHistograms (const MDTSegmentHistogramStruct(&vects)[4][4][16]) const
 
virtual StatusCode binMdtGlobal (TH2 *, char ecap)
 
virtual StatusCode binMdtRegional (TH2 *, std::string_view xAxis)
 
virtual StatusCode binMdtGlobal_byLayer (TH2 *, TH2 *, TH2 *)
 
virtual StatusCode binMdtOccVsLB (TH2 *&h, int region, int layer)
 
virtual StatusCode binMdtOccVsLB_Crate (TH2 *&h, int region, int crate)
 
virtual StatusCode fillMDTMaskedTubes (IdentifierHash, const std::string &, TH1F_LW *&h)
 
int get_bin_for_LB_hist (int region, int layer, int phi, int eta, bool isBIM) const
 
int get_bin_for_LB_crate_hist (int region, int layer, int phi, int eta, std::string_view chamber) const
 
void mdtchamberId ()
 
int mezzmdt (const Identifier &id) const
 
int GetTubeMax (const Identifier &digcoll_id, std::string_view hardware_name)
 
StatusCode GetTimingInfo ()
 
void initDeadChannels (const MuonGM::MdtReadoutElement *mydetEl)
 
std::string getChamberName (const Muon::MdtPrepData *) const
 
std::string getChamberName (const Identifier &) const
 
StatusCode getChamber (const IdentifierHash &id, MDTChamber *&chamber) const
 
bool isATLASReady () const
 
void setIsATLASReady ()
 
int cachedTubeMax (const Identifier &id) const
 
int cachedTubeLayerMax (const Identifier &id) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static bool AinB (int A, std::vector< int > &B)
 
static void ChamberTubeNumberCorrection (int &tubeNum, std::string_view hardware_name, int tubePos, int numLayers)
 
static void CorrectTubeMax (const std::string &hardware_name, int &numTubes)
 
static void CorrectLayerMax (const std::string &hardware_name, int &numLayers)
 

Private Attributes

std::unique_ptr< MDTNoisyTubes > m_masked_tubes {nullptr}
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
 
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
 
SG::ReadHandleKeyArray< Trk::SegmentCollection > m_segm_type
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muon_type {this, "Muon_type", "ExtrapolatedMuonTrackParticles", "extrapolated muons"}
 
std::vector< Identifier > m_chambersId
 
std::vector< IdentifierHash > m_chambersIdHash
 
std::map< std::string, int > m_tubesperchamber_map
 
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}
 
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
 
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_l1RoiKey {this, "L1RoiKey", "LVL1MuonRoIs", "L1 muon ROIs"}
 
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey {this, "MuonKey", "Muons", "muons"}
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo {this, "EventInfo", "EventInfo", "event info"}
 
std::vector< std::unique_ptr< MDTChamber > > m_hist_hash_list {}
 
Gaudi::Property< bool > m_doMdtESD {this, "DoMdtEsd", false}
 
Gaudi::Property< bool > m_doChamberHists {this, "DoChamberHist", true}
 
Gaudi::Property< bool > m_maskNoisyTubes {this, "maskNoisyTubes", true}
 
Gaudi::Property< size_t > m_ADCCut {this, "ADCCut", 50}
 
Gaudi::Property< size_t > m_nb_hits {this, "Eff_nHits", 5}
 
Gaudi::Property< bool > m_chi2_cut {this, "Eff_chi2Cut", 10}
 
Gaudi::Property< bool > m_do_mdtChamberHits {this, "do_mdtChamberHits", true}
 
Gaudi::Property< bool > m_do_mdttdccut_sector {this, "do_mdttdccut_sector", true}
 
Gaudi::Property< bool > m_do_mdtchamberstatphislice {this, "do_mdtchamberstatphislice", true}
 
Gaudi::Property< bool > m_do_run3Geometry {this, "do_Run3Geometry", false}
 
Gaudi::Property< size_t > m_HighOccThreshold {this, "nHits_NoiseThreshold", 16000}
 
Gaudi::Property< size_t > m_adcScale {this, "ADCScale", 1}
 
bool m_BMGpresent {false}
 
int m_BMGid {-1}
 
std::map< Identifier, std::set< Identifier > > m_DeadChannels {}
 
std::atomic< int > m_firstEvent {-1}
 
bool m_atlas_ready {false}
 
const MuonGM::MuonDetectorManager * m_detMgr {nullptr}
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringTool > m_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static constexpr Identifier::value_type s_detectorElementMask = 0xFFFFC00000000000
 

Detailed Description

Definition at line 97 of file MdtRawDataMonAlg.h.

Member Typedef Documentation

◆ MonVarVec_t

typedef std::vector<std::reference_wrapper<Monitored::IMonitoredVariable> > AthMonitorAlgorithm::MonVarVec_t
privateinherited

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

An enumeration of the different types of data the monitoring application may be running over. This can be used to select which histograms to produce, e.g. to prevent the production of colliding-beam histograms when running on cosmic-ray data. Strings of the same names may be given as jobOptions.

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

191  {
192  userDefined = 0,
193  monteCarlo,
194  collisions,
195  cosmics,
196  heavyIonCollisions,
197  };

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

The running environment may be used to select which histograms are produced, and where they are located in the output. For example, the output paths of the histograms are different for the "user", "online" and the various offline flags. Strings of the same names may be given as jobOptions.

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

172  {
173  user = 0,
174  online,
175  tier0,
176  tier0Raw,
177  tier0ESD,
178  AOD,
179  altprod,
180  };

Constructor & Destructor Documentation

◆ MdtRawDataMonAlg()

MdtRawDataMonAlg::MdtRawDataMonAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 127 of file MdtRawDataMonAlg.cxx.

127 : AthMonitorAlgorithm(name, pSvcLocator) {}

◆ ~MdtRawDataMonAlg()

MdtRawDataMonAlg::~MdtRawDataMonAlg ( )
virtualdefault

Member Function Documentation

◆ AinB()

bool MdtRawDataMonAlg::AinB ( int  A,
std::vector< int > &  B 
)
staticprivate

Definition at line 454 of file MDTRawDataUtilsRun3.cxx.

454  {
455  for (int i : B) {
456  if (i == A) return true;
457  }
458  return false;
459 }

◆ binMdtGlobal()

StatusCode MdtRawDataMonAlg::binMdtGlobal ( TH2 *  h,
char  ecap 
)
privatevirtual

Definition at line 28 of file MDTRawDataUtilsRun3.cxx.

28  {
29  // Set x-axis labels
30  int LowerEta = 0;
31  int UpperEta = 0;
32  if (ecap == 'B') {
33  LowerEta = -8;
34  UpperEta = 8;
35  } else {
36  LowerEta = -6;
37  UpperEta = 6;
38  }
39  TString eta_s;
40  for (int ieta = LowerEta; ieta != UpperEta + 1; ++ieta) {
41  if (ieta == 0 && ecap == 'E') continue;
42  eta_s = ecap;
43  (ieta < 0) ? eta_s += "C" : ((ieta > 0) ? eta_s += "A" : eta_s += "B");
44  eta_s += std::to_string(std::abs(ieta));
45  h->Fill(eta_s, 1, 0);
46  }
47 
48  // Set y-axis labels
49  TString phi_s;
50  for (int iphi = 1; iphi <= 16; iphi++) {
51  if (iphi < 10)
52  phi_s = "0" + std::to_string(iphi);
53  else
54  phi_s = std::to_string(iphi);
55  if (ecap == 'B' && (iphi == 11 || iphi == 15)) {
56  h->Fill(eta_s, "I," + phi_s + ",R", 0);
57  h->Fill(eta_s, "I," + phi_s + ",M", 0);
58  h->Fill(eta_s, "M," + phi_s, 0);
59  h->Fill(eta_s, "O," + phi_s, 0);
60  } else {
61  h->Fill(eta_s, "I," + phi_s, 0);
62  h->Fill(eta_s, "M," + phi_s, 0);
63  h->Fill(eta_s, "O," + phi_s, 0);
64  if (iphi % 2 == 0 && ecap == 'B')
65  h->Fill(eta_s, "E," + phi_s, 0);
66  else if (ecap == 'E')
67  h->Fill(eta_s, "E," + phi_s, 0);
68  }
69  }
70 
71  h->LabelsDeflate("X");
72  h->LabelsDeflate("Y");
73  h->LabelsOption("a", "Y");
74  h->Reset();
75 
76  return StatusCode::SUCCESS;
77 }

◆ binMdtGlobal_byLayer()

StatusCode MdtRawDataMonAlg::binMdtGlobal_byLayer ( TH2 *  nHits_In,
TH2 *  nHits_Mid,
TH2 *  nHits_Out 
)
privatevirtual

Definition at line 142 of file MDTRawDataUtilsRun3.cxx.

142  {
143  for (int iPhi = 1; iPhi != 17; ++iPhi) {
144  TString phiString = "";
145  if (iPhi < 10)
146  phiString = "0" + std::to_string(iPhi);
147  else
148  phiString = std::to_string(iPhi);
149  TString phiString_ml1 = phiString + ",1";
150  TString phiString_ml2 = phiString + ",2";
151  if (iPhi == 11 || iPhi == 15) {
152  TString phiString_ml1_BIR = phiString + ",1,R";
153  TString phiString_ml2_BIR = phiString + ",2,R";
154  nHits_In->Fill("EIC5", phiString_ml1_BIR, 0.);
155  nHits_In->Fill("EIC5", phiString_ml2_BIR, 0.);
156  TString phiString_ml1_BIM = phiString + ",1,M";
157  TString phiString_ml2_BIM = phiString + ",2,M";
158  nHits_In->Fill("EIC5", phiString_ml1_BIM, 0.);
159  nHits_In->Fill("EIC5", phiString_ml2_BIM, 0.);
160  } else {
161  nHits_In->Fill("EIC5", phiString_ml1, 0.);
162  nHits_In->Fill("EIC5", phiString_ml2, 0.);
163  }
164  nHits_Mid->Fill("EMC5", phiString_ml1, 0.);
165  nHits_Mid->Fill("EMC5", phiString_ml2, 0.);
166  nHits_Out->Fill("EOC6", phiString_ml1, 0.);
167  nHits_Out->Fill("EOC6", phiString_ml2, 0.);
168  }
169  for (int iEta = 6; iEta != -2; --iEta) {
170  TString etaIn = "EIC" + std::to_string(iEta);
171  TString etaMid = "EMC" + std::to_string(iEta);
172  TString etaOut = "EOC" + std::to_string(iEta);
173  if (iEta > 0) {
174  if (iEta < 6) {
175  nHits_In->Fill(etaIn, "01,1", 0);
176  nHits_Mid->Fill(etaMid, "01,1", 0);
177  }
178  nHits_Out->Fill(etaOut, "01,1", 0);
179  } else {
180  nHits_In->Fill("", "01,1", 0);
181  nHits_Mid->Fill("", "01,1", 0);
182  nHits_Out->Fill("", "01,1", 0);
183  }
184  }
185  // Add BIR11/15 separately at a higher eta station
186 
187  // BEE, EE chambers on inner plots
188  for (int iEta = -4; iEta != 1; ++iEta) {
189  TString etaIn = "";
190  if (iEta < -2) {
191  etaIn = "EEC" + std::to_string(std::abs(iEta + 2));
192  nHits_In->Fill(etaIn, "01,1", 0);
193  } else if (iEta < 0) {
194  etaIn = "BEC" + std::to_string(std::abs(iEta));
195  nHits_In->Fill(etaIn, "01,1", 0);
196  } else
197  nHits_In->Fill(" ", "01,1", 0);
198  }
199 
200  for (int iEta = -8; iEta != 11; ++iEta) {
201  TString etaIn = "";
202  TString etaMid = "";
203  TString etaOut = "";
204  if (iEta < 0) {
205  etaIn = "BIC" + std::to_string(std::abs(iEta));
206  etaOut = "BOC" + std::to_string(std::abs(iEta));
207  if (iEta > -7) { etaMid = "BMC" + std::to_string(std::abs(iEta)); }
208  } else if (iEta == 0) {
209  etaOut = "BOB" + std::to_string(iEta);
210  } else if (iEta < 9) {
211  etaIn = "BIA" + std::to_string(iEta);
212  etaOut = "BOA" + std::to_string(iEta);
213  if (iEta < 7) { etaMid = "BMA" + std::to_string(iEta); }
214  }
215  if (iEta < 9) {
216  nHits_In->Fill(etaIn, "01,1", 0);
217  nHits_Mid->Fill(etaMid, "01,1", 0);
218  nHits_Out->Fill(etaOut, "01,1", 0);
219  } else {
220  nHits_In->Fill(" ", "01,1", 0);
221  nHits_Mid->Fill(" ", "01,1", 0);
222  nHits_Out->Fill(" ", "01,1", 0);
223  }
224  }
225 
226  // BEE, EE chambers on inner plots
227  for (int iEta = 1; iEta != 6; ++iEta) {
228  TString etaIn = "";
229  if (iEta < 3) {
230  etaIn = "BEA" + std::to_string(std::abs(iEta));
231  nHits_In->Fill(etaIn, "01,1", 0);
232  } else if (iEta < 5) {
233  etaIn = "EEA" + std::to_string(std::abs(iEta - 2));
234  nHits_In->Fill(etaIn, "01,1", 0);
235  } else
236  nHits_In->Fill(" ", "01,1", 0);
237  }
238 
239  for (int iEta = 1; iEta != 7; ++iEta) {
240  TString etaIn = "EIA" + std::to_string(iEta);
241  TString etaMid = "EMA" + std::to_string(iEta);
242  TString etaOut = "EOA" + std::to_string(iEta);
243  if (iEta < 6) {
244  nHits_In->Fill(etaIn, "01,1", 0);
245  nHits_Mid->Fill(etaMid, "01,1", 0);
246  }
247  nHits_Out->Fill(etaOut, "01,1", 0);
248  }
249 
250  nHits_In->LabelsDeflate("X");
251  nHits_In->LabelsDeflate("Y");
252  nHits_In->LabelsOption("v", "x");
253  nHits_In->Reset();
254  nHits_Mid->LabelsDeflate("X");
255  nHits_Mid->LabelsDeflate("Y");
256  nHits_Mid->LabelsOption("v", "x");
257  nHits_Mid->Reset();
258  nHits_Out->LabelsDeflate("X");
259  nHits_Out->LabelsDeflate("Y");
260  nHits_Out->LabelsOption("v", "x");
261  nHits_Out->Reset();
262 
263  return StatusCode::SUCCESS;
264 }

◆ binMdtOccVsLB()

StatusCode MdtRawDataMonAlg::binMdtOccVsLB ( TH2 *&  h,
int  region,
int  layer 
)
privatevirtual

Definition at line 596 of file MDTRawDataUtilsRun3.cxx.

596  {
597  if (region == 0 || region == 1) { // Barrel
598  if (layer == 0) { // Inner
599  // Add Labels
600  h->SetBins(834, 1, 2502, 122, 0, 122);
601  h->GetYaxis()->SetBinLabel(1, "BI1");
602  h->GetYaxis()->SetBinLabel(19, "BI2");
603  h->GetYaxis()->SetBinLabel(37, "BI3");
604  h->GetYaxis()->SetBinLabel(55, "BI4");
605  h->GetYaxis()->SetBinLabel(73, "BI5");
606  h->GetYaxis()->SetBinLabel(91, "BI6");
607  h->GetYaxis()->SetBinLabel(107, "BI7");
608  h->GetYaxis()->SetBinLabel(115, "BI8");
609  // Add lines
610  h->GetYaxis()->SetTickLength(0);
611  for (int i = 0; i < 6; i++) {
612  TLine* l = new TLine(1, 18 * i, 50, 18 * i);
613  h->GetListOfFunctions()->Add(l);
614  }
615  TLine* l2 = new TLine(1, 106, 50, 106);
616  h->GetListOfFunctions()->Add(l2);
617  TLine* l3 = new TLine(1, 114, 50, 114);
618  h->GetListOfFunctions()->Add(l3);
619  for (int i = 1; i < 122; i++) {
620  if (i < 90 && (i % 18 == 11 || i % 18 == 16)) {
621  TLine* l = new TLine(1, i, 10, i);
622  h->GetListOfFunctions()->Add(l);
623  } else {
624  TLine* l = new TLine(1, i, 20, i);
625  h->GetListOfFunctions()->Add(l);
626  }
627  }
628  }
629 
630  else if (layer == 1) { // Middle
631  h->SetBins(834, 1, 2502, 95, 0, 95); // 95 = 1 + 16 + 16 + 16 + 16 + 16 + 14 total number of phi sectors (+1)
632  // in the last eta-sector (6) there is no phi-sector 13; ie there arent chambers BML6A13
633  // and BML6C13 so there are only 14 phi sectors
634  // Add Labels
635  h->GetYaxis()->SetBinLabel(1, "BM1");
636  h->GetYaxis()->SetBinLabel(17, "BM2");
637  h->GetYaxis()->SetBinLabel(33, "BM3");
638  h->GetYaxis()->SetBinLabel(49, "BM4");
639  h->GetYaxis()->SetBinLabel(65, "BM5");
640  h->GetYaxis()->SetBinLabel(81, "BM6");
641  // Add lines
642  h->GetYaxis()->SetTickLength(0);
643  for (int i = 1; i < 95; i++) {
644  TLine* l = new TLine(1, i, 20, i);
645  h->GetListOfFunctions()->Add(l);
646  }
647  TLine* l1 = new TLine(1, 16, 50, 16);
648  h->GetListOfFunctions()->Add(l1);
649  TLine* l2 = new TLine(1, 32, 50, 32);
650  h->GetListOfFunctions()->Add(l2);
651  TLine* l3 = new TLine(1, 48, 50, 48);
652  h->GetListOfFunctions()->Add(l3);
653  TLine* l4 = new TLine(1, 64, 50, 64);
654  h->GetListOfFunctions()->Add(l4);
655  TLine* l5 = new TLine(1, 80, 50, 80);
656  h->GetListOfFunctions()->Add(l5);
657  }
658 
659  else if (layer == 2 && region == 0) { // Outer, side A
660  h->SetBins(834, 1, 2502, 118, 0, 118);
661  // Add labels
662  h->GetYaxis()->SetBinLabel(1, "BO0");
663  h->GetYaxis()->SetBinLabel(4, "BO1");
664  h->GetYaxis()->SetBinLabel(19, "BO2");
665  h->GetYaxis()->SetBinLabel(35, "BO3");
666  h->GetYaxis()->SetBinLabel(51, "BO4");
667  h->GetYaxis()->SetBinLabel(67, "BO5");
668  h->GetYaxis()->SetBinLabel(83, "BO6");
669  h->GetYaxis()->SetBinLabel(99, "BO7,8");
670  // h->GetYaxis()->SetBinLabel(101,"BO8");
671  h->GetYaxis()->SetBinLabel(103, "BE1");
672  h->GetYaxis()->SetBinLabel(111, "BE2");
673  // Add lines
674  h->GetYaxis()->SetTickLength(0);
675  for (int i = 1; i < 118; i++) {
676  TLine* l = new TLine(1, i, 20, i);
677  h->GetListOfFunctions()->Add(l);
678  }
679  TLine* l1 = new TLine(1, 2, 50, 2);
680  h->GetListOfFunctions()->Add(l1);
681  TLine* l2 = new TLine(1, 18, 50, 18);
682  h->GetListOfFunctions()->Add(l2);
683  TLine* l3 = new TLine(1, 34, 50, 34);
684  h->GetListOfFunctions()->Add(l3);
685  TLine* l4 = new TLine(1, 50, 50, 50);
686  h->GetListOfFunctions()->Add(l4);
687  TLine* l5 = new TLine(1, 66, 50, 66);
688  h->GetListOfFunctions()->Add(l5);
689  TLine* l6 = new TLine(1, 82, 50, 82);
690  h->GetListOfFunctions()->Add(l6);
691  TLine* l7 = new TLine(1, 98, 50, 98);
692  h->GetListOfFunctions()->Add(l7);
693  TLine* l8 = new TLine(1, 100, 50, 100);
694  h->GetListOfFunctions()->Add(l8);
695  TLine* l9 = new TLine(1, 102, 50, 102);
696  h->GetListOfFunctions()->Add(l9);
697  TLine* l10 = new TLine(1, 110, 50, 110);
698  h->GetListOfFunctions()->Add(l10);
699  }
700 
701  else if (layer == 2 && region == 1) { // Outer, side C (no eta = 0)
702  h->SetBins(834, 1, 2502, 116, 0, 116);
703  // Add labels
704  h->GetYaxis()->SetBinLabel(1, "BO1");
705  h->GetYaxis()->SetBinLabel(17, "BO2");
706  h->GetYaxis()->SetBinLabel(33, "BO3");
707  h->GetYaxis()->SetBinLabel(49, "BO4");
708  h->GetYaxis()->SetBinLabel(65, "BO5");
709  h->GetYaxis()->SetBinLabel(81, "BO6");
710  h->GetYaxis()->SetBinLabel(97, "BO7,8");
711  // h->GetYaxis()->SetBinLabel(101,"BO8");
712  h->GetYaxis()->SetBinLabel(101, "BE1");
713  h->GetYaxis()->SetBinLabel(109, "BE2");
714  // Add lines
715  h->GetYaxis()->SetTickLength(0);
716  for (int i = 1; i < 116; i++) {
717  TLine* l = new TLine(1, i, 20, i);
718  h->GetListOfFunctions()->Add(l);
719  }
720  TLine* l1 = new TLine(1, 16, 50, 16);
721  h->GetListOfFunctions()->Add(l1);
722  TLine* l2 = new TLine(1, 32, 50, 32);
723  h->GetListOfFunctions()->Add(l2);
724  TLine* l3 = new TLine(1, 48, 50, 48);
725  h->GetListOfFunctions()->Add(l3);
726  TLine* l4 = new TLine(1, 64, 50, 64);
727  h->GetListOfFunctions()->Add(l4);
728  TLine* l5 = new TLine(1, 80, 50, 80);
729  h->GetListOfFunctions()->Add(l5);
730  TLine* l6 = new TLine(1, 96, 50, 96);
731  h->GetListOfFunctions()->Add(l6);
732  TLine* l7 = new TLine(1, 98, 50, 98);
733  h->GetListOfFunctions()->Add(l7);
734  TLine* l8 = new TLine(1, 100, 50, 100);
735  h->GetListOfFunctions()->Add(l8);
736  TLine* l9 = new TLine(1, 108, 50, 108);
737  h->GetListOfFunctions()->Add(l9);
738  }
739  }
740 
741  else { // Endcap
742  if (layer == 0) { // Inner
743  h->SetBins(834, 1, 2502, 50, 0, 50);
744  // Add labels
745  h->GetYaxis()->SetBinLabel(1, "EI1");
746  h->GetYaxis()->SetBinLabel(17, "EI2");
747  h->GetYaxis()->SetBinLabel(33, "EI3");
748  h->GetYaxis()->SetBinLabel(41, "EI4");
749  h->GetYaxis()->SetBinLabel(49, "EI5");
750  // Add lines
751  h->GetYaxis()->SetTickLength(0);
752  for (int i = 1; i < 50; i++) {
753  TLine* l = new TLine(1, i, 20, i);
754  h->GetListOfFunctions()->Add(l);
755  }
756  TLine* l1 = new TLine(1, 16, 50, 16);
757  h->GetListOfFunctions()->Add(l1);
758  TLine* l2 = new TLine(1, 32, 50, 32);
759  h->GetListOfFunctions()->Add(l2);
760  TLine* l3 = new TLine(1, 40, 50, 40);
761  h->GetListOfFunctions()->Add(l3);
762  TLine* l4 = new TLine(1, 48, 50, 48);
763  h->GetListOfFunctions()->Add(l4);
764  }
765 
766  else if (layer == 1) { // Middle
767  h->SetBins(834, 1, 2502, 80, 0, 80);
768  // Add labels
769  h->GetYaxis()->SetBinLabel(1, "EM1");
770  h->GetYaxis()->SetBinLabel(17, "EM2");
771  h->GetYaxis()->SetBinLabel(33, "EM3");
772  h->GetYaxis()->SetBinLabel(49, "EM4");
773  h->GetYaxis()->SetBinLabel(65, "EM5");
774  // Add lines
775  h->GetYaxis()->SetTickLength(0);
776  for (int i = 1; i < 80; i++) {
777  TLine* l = new TLine(1, i, 20, i);
778  h->GetListOfFunctions()->Add(l);
779  }
780  TLine* l1 = new TLine(1, 16, 50, 16);
781  h->GetListOfFunctions()->Add(l1);
782  TLine* l2 = new TLine(1, 32, 50, 32);
783  h->GetListOfFunctions()->Add(l2);
784  TLine* l3 = new TLine(1, 48, 50, 48);
785  h->GetListOfFunctions()->Add(l3);
786  TLine* l4 = new TLine(1, 64, 50, 64);
787  h->GetListOfFunctions()->Add(l4);
788  }
789 
790  else if (layer == 2) { // Outer + extra
791 
792  if (region == 2) { // side A
793  h->SetBins(834, 1, 2502, 103, 0, 103);
794  // Add labels
795  h->GetYaxis()->SetBinLabel(1, "EO1");
796  h->GetYaxis()->SetBinLabel(17, "EO2");
797  h->GetYaxis()->SetBinLabel(33, "EO3");
798  h->GetYaxis()->SetBinLabel(49, "EO4");
799  h->GetYaxis()->SetBinLabel(65, "EO5");
800  h->GetYaxis()->SetBinLabel(81, "EO6");
801  h->GetYaxis()->SetBinLabel(97, "EE1,2");
802  // Add lines
803  h->GetYaxis()->SetTickLength(0);
804  for (int i = 1; i < 103; i++) {
805  TLine* l = new TLine(1, i, 20, i);
806  h->GetListOfFunctions()->Add(l);
807  }
808  TLine* l1 = new TLine(1, 16, 50, 16);
809  h->GetListOfFunctions()->Add(l1);
810  TLine* l2 = new TLine(1, 32, 50, 32);
811  h->GetListOfFunctions()->Add(l2);
812  TLine* l3 = new TLine(1, 48, 50, 48);
813  h->GetListOfFunctions()->Add(l3);
814  TLine* l4 = new TLine(1, 64, 50, 64);
815  h->GetListOfFunctions()->Add(l4);
816  TLine* l5 = new TLine(1, 80, 50, 80);
817  h->GetListOfFunctions()->Add(l5);
818  TLine* l6 = new TLine(1, 96, 50, 96);
819  h->GetListOfFunctions()->Add(l6);
820  TLine* l7 = new TLine(1, 100, 50, 100);
821  h->GetListOfFunctions()->Add(l7);
822  } else if (region == 3) { // side C
823  h->SetBins(834, 1, 2502, 127, 0, 127);
824  // Add labels
825  h->GetYaxis()->SetBinLabel(1, "EO1");
826  h->GetYaxis()->SetBinLabel(17, "EO2");
827  h->GetYaxis()->SetBinLabel(33, "EO3");
828  h->GetYaxis()->SetBinLabel(49, "EO4");
829  h->GetYaxis()->SetBinLabel(65, "EO5");
830  h->GetYaxis()->SetBinLabel(81, "EO6");
831  h->GetYaxis()->SetBinLabel(97, "EE1");
832  h->GetYaxis()->SetBinLabel(113, "EE2");
833  // Add lines
834  h->GetYaxis()->SetTickLength(0);
835  for (int i = 1; i < 127; i++) {
836  TLine* l = new TLine(1, i, 20, i);
837  h->GetListOfFunctions()->Add(l);
838  }
839  TLine* l1 = new TLine(1, 16, 50, 16);
840  h->GetListOfFunctions()->Add(l1);
841  TLine* l2 = new TLine(1, 32, 50, 32);
842  h->GetListOfFunctions()->Add(l2);
843  TLine* l3 = new TLine(1, 48, 50, 48);
844  h->GetListOfFunctions()->Add(l3);
845  TLine* l4 = new TLine(1, 64, 50, 64);
846  h->GetListOfFunctions()->Add(l4);
847  TLine* l5 = new TLine(1, 80, 50, 80);
848  h->GetListOfFunctions()->Add(l5);
849  TLine* l6 = new TLine(1, 96, 50, 96);
850  h->GetListOfFunctions()->Add(l6);
851  TLine* l7 = new TLine(1, 112, 50, 112);
852  h->GetListOfFunctions()->Add(l7);
853  }
854  }
855  }
856 
857  return StatusCode::SUCCESS;
858 }

◆ binMdtOccVsLB_Crate()

StatusCode MdtRawDataMonAlg::binMdtOccVsLB_Crate ( TH2 *&  h,
int  region,
int  crate 
)
privatevirtual

Definition at line 860 of file MDTRawDataUtilsRun3.cxx.

860  {
861  if (region == 0 || region == 1) { // Barrel
862  if (crate == 0) { // Crate BA01 or BC01
863  // Add Labels
864  h->SetBins(834, 1, 2502, 73, 0, 73);
865  h->GetYaxis()->SetBinLabel(1, "BIL");
866  h->GetYaxis()->SetBinLabel(13, "BIS");
867  h->GetYaxis()->SetBinLabel(25, "BME");
868  h->GetYaxis()->SetBinLabel(26, "BML");
869  h->GetYaxis()->SetBinLabel(38, "BMS");
870  h->GetYaxis()->SetBinLabel(50, "BOL");
871  h->GetYaxis()->SetBinLabel(62, "BOS");
872  // Add lines
873  h->GetYaxis()->SetTickLength(0);
874  for (int i = 0; i < 73; i++) {
875  TLine* l = new TLine(1, i, 20, i);
876  h->GetListOfFunctions()->Add(l);
877  }
878  TLine* l2 = new TLine(1, 0, 50, 0);
879  h->GetListOfFunctions()->Add(l2);
880  TLine* l3 = new TLine(1, 12, 50, 12);
881  h->GetListOfFunctions()->Add(l3);
882  TLine* l4 = new TLine(1, 24, 50, 24);
883  h->GetListOfFunctions()->Add(l4);
884  TLine* l5 = new TLine(1, 25, 50, 25);
885  h->GetListOfFunctions()->Add(l5);
886  TLine* l6 = new TLine(1, 37, 50, 37);
887  h->GetListOfFunctions()->Add(l6);
888  TLine* l8 = new TLine(1, 49, 50, 49);
889  h->GetListOfFunctions()->Add(l8);
890  TLine* l9 = new TLine(1, 61, 50, 61);
891  h->GetListOfFunctions()->Add(l9);
892  }
893 
894  else if (crate == 1) { // BA02, BC02
895  h->SetBins(834, 1, 2502, 73, 0, 73);
896  // Add Labels
897  h->GetYaxis()->SetBinLabel(1, "BIL");
898  h->GetYaxis()->SetBinLabel(13, "BIS");
899  h->GetYaxis()->SetBinLabel(25, "BME");
900  h->GetYaxis()->SetBinLabel(37, "BMS");
901  h->GetYaxis()->SetBinLabel(49, "BOL");
902  h->GetYaxis()->SetBinLabel(61, "BOS");
903  // Add lines
904  h->GetYaxis()->SetTickLength(0);
905  for (int i = 1; i < 73; i++) {
906  TLine* l = new TLine(1, i, 20, i);
907  h->GetListOfFunctions()->Add(l);
908  }
909  TLine* l1 = new TLine(1, 12, 50, 12);
910  h->GetListOfFunctions()->Add(l1);
911  TLine* l2 = new TLine(1, 24, 50, 24);
912  h->GetListOfFunctions()->Add(l2);
913  TLine* l3 = new TLine(1, 36, 50, 36);
914  h->GetListOfFunctions()->Add(l3);
915  TLine* l4 = new TLine(1, 48, 50, 48);
916  h->GetListOfFunctions()->Add(l4);
917  TLine* l6 = new TLine(1, 60, 50, 60);
918  h->GetListOfFunctions()->Add(l6);
919 
920  } else if (crate == 2) { // BA03, BC03
921  // Add Labels
922  h->SetBins(834, 1, 2502, 80, 0, 80);
923  h->GetYaxis()->SetBinLabel(1, "BIL");
924  h->GetYaxis()->SetBinLabel(7, "BIM");
925  h->GetYaxis()->SetBinLabel(12, "BIR");
926  h->GetYaxis()->SetBinLabel(18, "BIS");
927  h->GetYaxis()->SetBinLabel(30, "BMF");
928  h->GetYaxis()->SetBinLabel(33, "BMG");
929  h->GetYaxis()->SetBinLabel(36, "BML");
930  h->GetYaxis()->SetBinLabel(48, "BMS");
931  h->GetYaxis()->SetBinLabel(54, "BOF");
932  h->GetYaxis()->SetBinLabel(58, "BOG");
933  if (region == 0) {
934  h->GetYaxis()->SetBinLabel(63, "BOL");
935  h->GetYaxis()->SetBinLabel(75, "BOS");
936  } else if (region == 1) {
937  h->GetYaxis()->SetBinLabel(62, "BOL");
938  h->GetYaxis()->SetBinLabel(74, "BOS");
939  }
940  // Add lines
941  h->GetYaxis()->SetTickLength(0);
942  for (int i = 0; i < 80; i++) {
943  TLine* l = new TLine(1, i, 20, i);
944  h->GetListOfFunctions()->Add(l);
945  }
946  TLine* l2 = new TLine(1, 6, 50, 6);
947  h->GetListOfFunctions()->Add(l2);
948  TLine* l3 = new TLine(1, 11, 50, 11);
949  h->GetListOfFunctions()->Add(l3);
950  TLine* l3b = new TLine(1, 17, 50, 17);
951  h->GetListOfFunctions()->Add(l3b);
952  // TLine* l4 = new TLine(1,26,50,26); h->GetListOfFunctions()->Add(l4); //removed this line because it doesnt correspond to
953  // anything
954  TLine* l5 = new TLine(1, 29, 50, 29);
955  h->GetListOfFunctions()->Add(l5);
956  TLine* l6 = new TLine(1, 32, 50, 32);
957  h->GetListOfFunctions()->Add(l6);
958  TLine* l7 = new TLine(1, 35, 50, 35);
959  h->GetListOfFunctions()->Add(l7);
960  TLine* l8 = new TLine(1, 47, 50, 47);
961  h->GetListOfFunctions()->Add(l8);
962  TLine* l9 = new TLine(1, 53, 50, 53);
963  h->GetListOfFunctions()->Add(l9);
964  TLine* l9b = new TLine(1, 57, 50, 57);
965  h->GetListOfFunctions()->Add(l9b);
966  if (region == 0) {
967  TLine* l10 = new TLine(1, 62, 50, 62);
968  h->GetListOfFunctions()->Add(l10);
969  TLine* l11 = new TLine(1, 74, 50, 74);
970  h->GetListOfFunctions()->Add(l11);
971  } else if (region == 1) {
972  TLine* l10 = new TLine(1, 61, 50, 61);
973  h->GetListOfFunctions()->Add(l10);
974  TLine* l11 = new TLine(1, 73, 50, 73);
975  h->GetListOfFunctions()->Add(l11);
976  }
977  }
978 
979  else if (crate == 3) { // BA04, BC04
980  // Add Labels
981  h->SetBins(834, 1, 2502, 79, 0, 79);
982  h->GetYaxis()->SetBinLabel(1, "BIL");
983  h->GetYaxis()->SetBinLabel(7, "BIM");
984  h->GetYaxis()->SetBinLabel(12, "BIR");
985  h->GetYaxis()->SetBinLabel(18, "BIS");
986  h->GetYaxis()->SetBinLabel(30, "BMF");
987  h->GetYaxis()->SetBinLabel(33, "BMG");
988  h->GetYaxis()->SetBinLabel(36, "BML");
989  h->GetYaxis()->SetBinLabel(47, "BMS");
990  h->GetYaxis()->SetBinLabel(53, "BOF");
991  h->GetYaxis()->SetBinLabel(57, "BOG");
992  if (region == 0) {
993  h->GetYaxis()->SetBinLabel(62, "BOL");
994  h->GetYaxis()->SetBinLabel(75, "BOS");
995  } else if (region == 1) {
996  h->GetYaxis()->SetBinLabel(61, "BOL");
997  h->GetYaxis()->SetBinLabel(74, "BOS");
998  }
999 
1000  // Add lines
1001  h->GetYaxis()->SetTickLength(0);
1002  for (int i = 0; i < 79; i++) {
1003  TLine* l = new TLine(1, i, 20, i);
1004  h->GetListOfFunctions()->Add(l);
1005  }
1006  TLine* l2 = new TLine(1, 6, 50, 6);
1007  h->GetListOfFunctions()->Add(l2);
1008  TLine* l3 = new TLine(1, 11, 50, 11);
1009  h->GetListOfFunctions()->Add(l3);
1010  TLine* l3b = new TLine(1, 17, 50, 17);
1011  h->GetListOfFunctions()->Add(l3b);
1012  // TLine* l4 = new TLine(1,26,50,26); h->GetListOfFunctions()->Add(l4);//removed this line because it doesnt correspond to
1013  // anything
1014  TLine* l5 = new TLine(1, 29, 50, 29);
1015  h->GetListOfFunctions()->Add(l5);
1016  TLine* l6 = new TLine(1, 32, 50, 32);
1017  h->GetListOfFunctions()->Add(l6);
1018  TLine* l7 = new TLine(1, 35, 50, 35);
1019  h->GetListOfFunctions()->Add(l7);
1020  TLine* l8 = new TLine(1, 46, 50, 46);
1021  h->GetListOfFunctions()->Add(l8);
1022  TLine* l9 = new TLine(1, 52, 50, 52);
1023  h->GetListOfFunctions()->Add(l9);
1024  TLine* l9b = new TLine(1, 56, 50, 56);
1025  h->GetListOfFunctions()->Add(l9b);
1026  if (region == 0) {
1027  TLine* l10 = new TLine(1, 61, 50, 61);
1028  h->GetListOfFunctions()->Add(l10);
1029  TLine* l11 = new TLine(1, 74, 50, 74);
1030  h->GetListOfFunctions()->Add(l11);
1031  } else if (region == 1) {
1032  TLine* l10 = new TLine(1, 60, 50, 60);
1033  h->GetListOfFunctions()->Add(l10);
1034  TLine* l11 = new TLine(1, 73, 50, 73);
1035  h->GetListOfFunctions()->Add(l11);
1036  }
1037  }
1038  }
1039 
1040  else { // Endcap
1041  if (crate == 0 || crate == 2) { // EA01, EC01 and EA03, EC03 are the same
1042  h->SetBins(834, 1, 2502, 73, 0, 73);
1043  // Add labels
1044  h->GetYaxis()->SetBinLabel(1, "BEE");
1045  h->GetYaxis()->SetBinLabel(5, "BIS");
1046  h->GetYaxis()->SetBinLabel(9, "EEL");
1047  h->GetYaxis()->SetBinLabel(13, "EES");
1048  h->GetYaxis()->SetBinLabel(17, "EIL");
1049  h->GetYaxis()->SetBinLabel(26, "EIS");
1050  h->GetYaxis()->SetBinLabel(30, "EML");
1051  h->GetYaxis()->SetBinLabel(40, "EMS");
1052  h->GetYaxis()->SetBinLabel(50, "EOL");
1053  h->GetYaxis()->SetBinLabel(62, "EOS");
1054  // Add lines
1055  h->GetYaxis()->SetTickLength(0);
1056  for (int i = 1; i < 73; i++) {
1057  TLine* l = new TLine(1, i, 20, i);
1058  h->GetListOfFunctions()->Add(l);
1059  }
1060  TLine* l2 = new TLine(1, 4, 50, 4);
1061  h->GetListOfFunctions()->Add(l2);
1062  TLine* l3 = new TLine(1, 8, 50, 8);
1063  h->GetListOfFunctions()->Add(l3);
1064  TLine* l4 = new TLine(1, 12, 50, 12);
1065  h->GetListOfFunctions()->Add(l4);
1066  TLine* l5 = new TLine(1, 16, 50, 16);
1067  h->GetListOfFunctions()->Add(l5);
1068  TLine* l6 = new TLine(1, 25, 50, 25);
1069  h->GetListOfFunctions()->Add(l6);
1070  TLine* l7 = new TLine(1, 29, 50, 29);
1071  h->GetListOfFunctions()->Add(l7);
1072  TLine* l8 = new TLine(1, 39, 50, 39);
1073  h->GetListOfFunctions()->Add(l8);
1074  TLine* l9 = new TLine(1, 49, 50, 49);
1075  h->GetListOfFunctions()->Add(l9);
1076  TLine* l10 = new TLine(1, 61, 50, 61);
1077  h->GetListOfFunctions()->Add(l10);
1078  } else if (crate == 1) { // EA02, EC02
1079  h->SetBins(834, 1, 2502, 71, 0, 71);
1080  // Add labels
1081  h->GetYaxis()->SetBinLabel(1, "BEE");
1082  h->GetYaxis()->SetBinLabel(5, "BIS");
1083  h->GetYaxis()->SetBinLabel(9, "EEL");
1084  h->GetYaxis()->SetBinLabel(12, "EES");
1085  h->GetYaxis()->SetBinLabel(16, "EIL");
1086  h->GetYaxis()->SetBinLabel(24, "EIS");
1087  h->GetYaxis()->SetBinLabel(28, "EML");
1088  h->GetYaxis()->SetBinLabel(38, "EMS");
1089  h->GetYaxis()->SetBinLabel(48, "EOL");
1090  h->GetYaxis()->SetBinLabel(60, "EOS");
1091  // Add lines
1092  h->GetYaxis()->SetTickLength(0);
1093  for (int i = 1; i < 71; i++) {
1094  TLine* l = new TLine(1, i, 20, i);
1095  h->GetListOfFunctions()->Add(l);
1096  }
1097  TLine* l2 = new TLine(1, 4, 50, 4);
1098  h->GetListOfFunctions()->Add(l2);
1099  TLine* l3 = new TLine(1, 8, 50, 8);
1100  h->GetListOfFunctions()->Add(l3);
1101  TLine* l4 = new TLine(1, 11, 50, 11);
1102  h->GetListOfFunctions()->Add(l4);
1103  TLine* l5 = new TLine(1, 15, 50, 15);
1104  h->GetListOfFunctions()->Add(l5);
1105  TLine* l6 = new TLine(1, 23, 50, 23);
1106  h->GetListOfFunctions()->Add(l6);
1107  TLine* l7 = new TLine(1, 27, 50, 27);
1108  h->GetListOfFunctions()->Add(l7);
1109  TLine* l8 = new TLine(1, 37, 50, 37);
1110  h->GetListOfFunctions()->Add(l8);
1111  TLine* l9 = new TLine(1, 47, 50, 47);
1112  h->GetListOfFunctions()->Add(l9);
1113  TLine* l10 = new TLine(1, 59, 50, 59);
1114  h->GetListOfFunctions()->Add(l10);
1115  } else if (crate == 3) { // EA04, EC04
1116  h->SetBins(834, 1, 2502, 72, 0, 72);
1117  // Add labels
1118  h->GetYaxis()->SetBinLabel(1, "BEE");
1119  h->GetYaxis()->SetBinLabel(5, "BIS");
1120  h->GetYaxis()->SetBinLabel(9, "EEL");
1121  h->GetYaxis()->SetBinLabel(13, "EES");
1122  h->GetYaxis()->SetBinLabel(17, "EIL");
1123  h->GetYaxis()->SetBinLabel(25, "EIS");
1124  h->GetYaxis()->SetBinLabel(29, "EML");
1125  h->GetYaxis()->SetBinLabel(39, "EMS");
1126  h->GetYaxis()->SetBinLabel(49, "EOL");
1127  h->GetYaxis()->SetBinLabel(61, "EOS");
1128  // Add lines
1129  h->GetYaxis()->SetTickLength(0);
1130  for (int i = 1; i < 72; i++) {
1131  TLine* l = new TLine(1, i, 20, i);
1132  h->GetListOfFunctions()->Add(l);
1133  }
1134  TLine* l2 = new TLine(1, 4, 50, 4);
1135  h->GetListOfFunctions()->Add(l2);
1136  TLine* l3 = new TLine(1, 8, 50, 8);
1137  h->GetListOfFunctions()->Add(l3);
1138  TLine* l4 = new TLine(1, 12, 50, 12);
1139  h->GetListOfFunctions()->Add(l4);
1140  TLine* l5 = new TLine(1, 16, 50, 16);
1141  h->GetListOfFunctions()->Add(l5);
1142  TLine* l6 = new TLine(1, 24, 50, 24);
1143  h->GetListOfFunctions()->Add(l6);
1144  TLine* l7 = new TLine(1, 28, 50, 28);
1145  h->GetListOfFunctions()->Add(l7);
1146  TLine* l8 = new TLine(1, 38, 50, 38);
1147  h->GetListOfFunctions()->Add(l8);
1148  TLine* l9 = new TLine(1, 48, 50, 48);
1149  h->GetListOfFunctions()->Add(l9);
1150  TLine* l10 = new TLine(1, 60, 50, 60);
1151  h->GetListOfFunctions()->Add(l10);
1152  }
1153  }
1154 
1155  return StatusCode::SUCCESS;
1156 }

◆ binMdtRegional()

StatusCode MdtRawDataMonAlg::binMdtRegional ( TH2 *  h,
std::string_view  xAxis 
)
privatevirtual

SET Ghost Entries

Definition at line 79 of file MDTRawDataUtilsRun3.cxx.

79  {
81  int LowerEta = -0;
82  int UpperEta = 0;
83  if (xAxis.substr(0, 2) == "BO" || xAxis.substr(0, 2) == "BI") { // Barrel Hit Mutltiplicities
84  LowerEta = -8;
85  UpperEta = 8;
86  } else if (xAxis.substr(0, 2) == "BM" || xAxis.substr(0, 2) == "EO") {
87  LowerEta = -6;
88  UpperEta = 6;
89  } else if (xAxis.substr(0, 2) == "EM" || xAxis.substr(0, 2) == "EI") {
90  LowerEta = -5;
91  UpperEta = 5;
92  } else {
93  LowerEta = -2;
94  UpperEta = 2;
95  }
96 
97  // Set x-axis labels
98  TString eta_s;
99  for (int ieta = LowerEta; ieta != UpperEta + 1; ++ieta) {
100  if (xAxis.substr(2, 1) == "A" && ieta < 0) continue; // A side goes from 1-...
101  if (xAxis.substr(2, 1) == "C" && ieta == 0) break; // C side goes from ...-1
102  if (ieta == 0 && xAxis.substr(0, 2) == "BO")
103  eta_s = "BOB";
104  else if (ieta == 0)
105  continue;
106  else
107  eta_s = xAxis.substr(0, 3);
108  eta_s += std::to_string(std::abs(ieta));
109  h->Fill(eta_s, 1, 0);
110  }
111 
112  bool barrelExtra = (xAxis == "BEA" || xAxis == "BEC");
113  // Set y-axis labels
114  TString phi_s;
115  for (int iphi = 1; iphi <= 16; iphi++) {
116  if (iphi < 10)
117  phi_s = "0" + std::to_string(iphi);
118  else
119  phi_s = std::to_string(iphi);
120  if (!barrelExtra) {
121  // Also uncomment lines in MdtRawDataValAlg.cxx in fillMDTSummaryHistograms() that actually fill these values
122  if (xAxis.substr(0, 2) == "BI" && (iphi == 11 || iphi == 15)) {
123  h->Fill(eta_s, phi_s + ",1,R", 0);
124  h->Fill(eta_s, phi_s + ",2,R", 0);
125  h->Fill(eta_s, phi_s + ",1,M", 0);
126  h->Fill(eta_s, phi_s + ",2,M", 0);
127  } else {
128  h->Fill(eta_s, phi_s + ",1", 0);
129  h->Fill(eta_s, phi_s + ",2", 0);
130  }
131  } else if (iphi % 2 == 0)
132  h->Fill(eta_s, phi_s + ",1", 0);
133  } // loop over phi
134 
135  h->LabelsDeflate("X");
136  h->LabelsDeflate("Y");
137  h->Reset();
138 
139  return StatusCode::SUCCESS;
140 }

◆ cachedTubeLayerMax()

int MdtRawDataMonAlg::cachedTubeLayerMax ( const Identifier &  id) const
private

Definition at line 1436 of file MDTRawDataUtilsRun3.cxx.

1436  {
1437  const MuonGM::MdtReadoutElement* roe = m_detMgr->getMdtReadoutElement(id);
1438  return roe ? roe->getNLayers() : -1;
1439 }

◆ cachedTubeMax()

int MdtRawDataMonAlg::cachedTubeMax ( const Identifier &  id) const
private

Definition at line 1432 of file MDTRawDataUtilsRun3.cxx.

1432  {
1433  const MuonGM::MdtReadoutElement* roe = m_detMgr->getMdtReadoutElement(id);
1434  return roe ? roe->getNtubesperlayer() : -1;
1435 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ ChamberTubeNumberCorrection()

void MdtRawDataMonAlg::ChamberTubeNumberCorrection ( int &  tubeNum,
std::string_view  hardware_name,
int  tubePos,
int  numLayers 
)
staticprivate

Definition at line 267 of file MDTRawDataUtilsRun3.cxx.

267  {
268  // numLayers should be mdt_layer-1 so numLayers = 0 implies layer 1 ML 1 or mdt_layer==1
269  if (hardware_name.substr(0, 4) == "BMS4" || hardware_name.substr(0, 4) == "BMS6") { // layer 1-4 tubeId 41-48 cut out
270  if (numLayers <= 2) tubeNum = tubePos + numLayers * 48;
271  }
272  if (hardware_name.substr(0, 3) == "BIR" && numLayers <= 3) {
273  if (hardware_name.substr(5, 2) == "11" || hardware_name.substr(5, 2) == "15") {
274  if (hardware_name.substr(3, 1) == "1") tubeNum = tubePos + 6 + numLayers * 30; // layer 1-4 tube id 1-6 cut out
275  if (hardware_name.substr(3, 1) == "2") tubeNum = tubePos + numLayers * 30; // layer 1-4 tube id 28-30 cut out
276  if (hardware_name.substr(3, 1) == "4") tubeNum = tubePos + 3 + numLayers * 30; // layer 1-4 tube id 1-3 cut out
277  if (hardware_name.substr(3, 1) == "5") tubeNum = tubePos + numLayers * 24; // layer 1-4 tube id 22-24 cut out
278  }
279  }
280  if (hardware_name.substr(0, 3) == "BIR" && hardware_name.substr(3, 1) == "3") tubeNum = tubePos + numLayers * 36; // cut out on both ML
281  if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05")
282  tubeNum = tubePos + numLayers * 48; // mdtIdHelper gives wrong #tubes/layer (incidentally also wrong #layers)
283 }

◆ CorrectLayerMax()

void MdtRawDataMonAlg::CorrectLayerMax ( const std::string &  hardware_name,
int &  numLayers 
)
staticprivate

Definition at line 291 of file MDTRawDataUtilsRun3.cxx.

291  {
292  if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") numLayers = 3;
293 }

◆ CorrectTubeMax()

void MdtRawDataMonAlg::CorrectTubeMax ( const std::string &  hardware_name,
int &  numTubes 
)
staticprivate

Definition at line 286 of file MDTRawDataUtilsRun3.cxx.

286  {
287  if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") numTubes = 48;
288 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

Returns
the current value of the class's DataType_t instance.

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::dataTypeStringToEnum ( const std::string &  str) const
inherited

Convert the data type string from the python configuration to an enum object.

Returns
a value in the DataType_t enumeration which matches the input string.

Definition at line 140 of file AthMonitorAlgorithm.cxx.

140  {
141  // convert the string to all lowercase
142  std::string lowerCaseStr = str;
143  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
144 
145  // check if it matches one of the enum choices
146  if( lowerCaseStr == "userdefined" ) {
147  return DataType_t::userDefined;
148  } else if( lowerCaseStr == "montecarlo" ) {
149  return DataType_t::monteCarlo;
150  } else if( lowerCaseStr == "collisions" ) {
151  return DataType_t::collisions;
152  } else if( lowerCaseStr == "cosmics" ) {
153  return DataType_t::cosmics;
154  } else if( lowerCaseStr == "heavyioncollisions" ) {
155  return DataType_t::heavyIonCollisions;
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning userDefined.");
159  return DataType_t::userDefined;
160  }
161 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

Returns
the current value of the class's Environment_t instance.

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::envStringToEnum ( const std::string &  str) const
inherited

Convert the environment string from the python configuration to an enum object.

Returns
a value in the Environment_t enumeration which matches the input string.

Definition at line 112 of file AthMonitorAlgorithm.cxx.

112  {
113  // convert the string to all lowercase
114  std::string lowerCaseStr = str;
115  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
116 
117  // check if it matches one of the enum choices
118  if( lowerCaseStr == "user" ) {
119  return Environment_t::user;
120  } else if( lowerCaseStr == "online" ) {
121  return Environment_t::online;
122  } else if( lowerCaseStr == "tier0" ) {
123  return Environment_t::tier0;
124  } else if( lowerCaseStr == "tier0raw" ) {
125  return Environment_t::tier0Raw;
126  } else if( lowerCaseStr == "tier0esd" ) {
127  return Environment_t::tier0ESD;
128  } else if( lowerCaseStr == "aod" ) {
129  return Environment_t::AOD;
130  } else if( lowerCaseStr == "altprod" ) {
131  return Environment_t::altprod;
132  } else { // otherwise, warn the user and return "user"
133  ATH_MSG_WARNING("AthMonitorAlgorithm::envStringToEnum(): Unknown environment "
134  <<str<<", returning user.");
135  return Environment_t::user;
136  }
137 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

◆ execute()

StatusCode AthMonitorAlgorithm::execute ( const EventContext &  ctx) const
overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

73  {
74 
75  // Checks that all of the DQ filters are passed. If any one of the filters
76  // fails, return SUCCESS code and do not fill the histograms with the event.
77  for ( const auto& filterItr : m_DQFilterTools ) {
78  if (!filterItr->accept()) {
79  ATH_MSG_DEBUG("Event rejected due to filter tool.");
80  return StatusCode::SUCCESS;
81  }
82  }
83 
84  // Trigger: If there is a decision tool and the chains fail, skip the event.
85  if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
86  ATH_MSG_DEBUG("Event rejected due to trigger filter.");
87  return StatusCode::SUCCESS;
88  }
89 
90  ATH_MSG_DEBUG("Event accepted!");
91  return fillHistograms(ctx);
92 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ fillHistograms()

StatusCode MdtRawDataMonAlg::fillHistograms ( const EventContext &  ctx) const
overridevirtual

adds event to the monitoring histograms

User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 255 of file MdtRawDataMonAlg.cxx.

257 {
258  int lumiblock = -1;
259  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo, ctx);
260  lumiblock = evt->lumiBlock();
261 
262  ATH_MSG_DEBUG("MdtRawDataMonAlg::MDT RawData Monitoring Histograms being filled");
263 
264  // Making an histo to store the Run3 geo flag
265  auto run3geo = Monitored::Scalar<int>("run3geo", m_do_run3Geometry);
266  auto firstEvent = Monitored::Scalar<int>("firstEvent", (int)(m_firstEvent));
267  fill("MdtMonitor", run3geo, firstEvent);
268  m_firstEvent = 0;
269 
270  // Retrieve the LVL1 Muon RoIs:
271  bool trig_BARREL = false;
272  bool trig_ENDCAP = false;
273  if (!m_l1RoiKey.empty()) {
274  SG::ReadHandle<xAOD::MuonRoIContainer> muonRoIs(m_l1RoiKey, ctx);
275  if (!muonRoIs.isValid()) { ATH_MSG_ERROR("evtStore() does not contain muon L1 ROI Collection with name " << m_l1RoiKey); }
276  // DEV still needed ? does not compile
277  if (muonRoIs.isPresent() && muonRoIs.isValid()) {
278  ATH_MSG_VERBOSE("Retrieved LVL1MuonRoIs object with key: " << m_l1RoiKey.key());
279  trig_BARREL = std::any_of(muonRoIs->begin(), muonRoIs->end(),
280  [](const auto& i) { return i->getSource() == xAOD::MuonRoI::RoISource::Barrel; });
281  trig_ENDCAP = std::any_of(muonRoIs->begin(), muonRoIs->end(),
282  [](const auto& i) { return i->getSource() == xAOD::MuonRoI::RoISource::Endcap; });
283  }
284  }
285 
286  // declare MDT stuff
287  SG::ReadHandle<Muon::MdtPrepDataContainer> mdt_container(m_key_mdt, ctx);
288  if (!mdt_container.isValid()) {
289  ATH_MSG_ERROR("evtStore() does not contain mdt prd Collection with name " << m_key_mdt);
290  return StatusCode::FAILURE;
291  }
292 
293  ATH_MSG_DEBUG("****** mdtContainer->size() : " << mdt_container->size());
294 
295  int nColl = 0; // Number of MDT chambers with hits
296  int nColl_ADCCut = 0; // Number of MDT chambers with hits above ADC cut
297  int nPrd = 0; // Total number of MDT prd digits
298  int nPrdcut = 0; // Total number of MDT prd digits with a cut on ADC>50.
299 
300  // declare RPC stuff
301  SG::ReadHandle<Muon::RpcPrepDataContainer> rpc_container(m_key_rpc, ctx);
302  if (!rpc_container.isValid()) {
303  ATH_MSG_ERROR("evtStore() does not contain rpc prd Collection with name " << m_key_rpc);
304  return StatusCode::FAILURE;
305  }
306 
307  ATH_MSG_DEBUG("****** rpc->size() : " << rpc_container->size());
308 
309  Muon::RpcPrepDataContainer::const_iterator containerIt;
310 
312  float Nhitsrpc = 0;
313  for (containerIt = rpc_container->begin(); containerIt != rpc_container->end(); ++containerIt) {
314  for (Muon::RpcPrepDataCollection::const_iterator rpcPrd = (*containerIt)->begin(); rpcPrd != (*containerIt)->end(); ++rpcPrd) {
315  ++Nhitsrpc;
316  }
317  }
318  float Nhitsmdt = 0;
319  bool isNoiseBurstCandidate = false;
320  Muon::MdtPrepDataContainer::const_iterator MdtcontainerIt;
321  for (MdtcontainerIt = mdt_container->begin(); MdtcontainerIt != mdt_container->end(); ++MdtcontainerIt) {
322  for (Muon::MdtPrepDataCollection::const_iterator mdtCollection = (*MdtcontainerIt)->begin();
323  mdtCollection != (*MdtcontainerIt)->end(); ++mdtCollection) {
324  ++Nhitsmdt;
325  }
326  }
327 
328  if (Nhitsmdt > m_HighOccThreshold) isNoiseBurstCandidate = true;
329  std::string type = "MDT";
330  std::string hardware_name;
331 
332  std::map<std::string, int> evnt_hitsperchamber_map;
333  std::set<std::string> chambers_from_tracks;
334 
335  if (m_doMdtESD == true) {
336  // DEV this shouls be done in some other way, in AthenaMonManager there is
337  // Gaudi::Property<std::string> m_environmentStr {this,"Environment","user"}; ///< Environment string pulled from the job option
338  // and converted to enum
339  // commented out for the time being
340  // if(m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD || m_environment ==
341  // AthenaMonManager::online) {
342  if (true) { // DEV to be updated
343 
344  SG::ReadHandle<xAOD::TrackParticleContainer> muons(m_muon_type, ctx);
345 
346  // ATH_CHECK(muons.isValid());
347 
348  for (const auto* const mu : *muons) {
349  // add quality selection here
350  if (mu) {
351  const Trk::Track* trk = mu->track();
352  // this work only if tp are available
353  if (!trk) continue;
354 
355  uint8_t ntri_eta = 0;
356  uint8_t n_phi = 0;
357  mu->summaryValue(ntri_eta, xAOD::numberOfTriggerEtaLayers);
358  mu->summaryValue(n_phi, xAOD::numberOfPhiLayers);
359  if (ntri_eta + n_phi == 0) continue;
360 
361  for (const Trk::MeasurementBase* hit : *trk->measurementsOnTrack()) {
362  const Trk::RIO_OnTrack* rot_from_track = dynamic_cast<const Trk::RIO_OnTrack*>(hit);
363  if (!rot_from_track) continue;
364  Identifier rotId = rot_from_track->identify();
365  if (!m_idHelperSvc->isMdt(rotId)) continue;
366  IdentifierHash mdt_idHash;
367  MDTChamber* mdt_chamber = nullptr;
368  m_idHelperSvc->mdtIdHelper().get_module_hash(rotId, mdt_idHash);
369  ATH_CHECK(getChamber(mdt_idHash, mdt_chamber));
370  std::string mdt_chambername = mdt_chamber->getName();
371  chambers_from_tracks.insert(mdt_chambername);
372  }
373  }
374  }
375 
376  MDTOverviewHistogramStruct overviewPlots;
377  auto summaryPlots = std::make_unique<std::array<MDTSummaryHistogramStruct, 4096>>();
378  // loop in MdtPrepDataContainer
379  std::vector<std::string> v_hit_in_chamber_allphi;
380  std::map<std::string, std::vector<std::string>> v_hit_in_chamber;
381  for (Muon::MdtPrepDataContainer::const_iterator containerIt = mdt_container->begin(); containerIt != mdt_container->end();
382  ++containerIt) {
383  if (containerIt == mdt_container->end() || containerIt->empty()) continue; // check if there are counts
384  nColl++;
385 
386  bool isHit_above_ADCCut = false;
387  // loop over hits
388  for (const auto* mdtCollection : **containerIt) {
389  nPrd++;
390 
391  float adc = mdtCollection->adc();
392  hardware_name = getChamberName(mdtCollection);
393 
394  if (hardware_name.substr(0, 3) == "BMG") adc /= m_adcScale;
395  if (adc > m_ADCCut) {
396  nPrdcut++;
397  isHit_above_ADCCut = true;
398  if (m_do_mdtchamberstatphislice) {
399  std::string phi = hardware_name.substr(hardware_name.length() - 2);
400  v_hit_in_chamber[phi].push_back(hardware_name);
401  }
402  v_hit_in_chamber_allphi.push_back(hardware_name);
403  }
404  fillMDTOverviewVects(mdtCollection, isNoiseBurstCandidate, overviewPlots);
405  //=======================================================================
406  //=======================================================================
407  //=======================================================================
408  ATH_CHECK(fillMDTSummaryVects(mdtCollection, chambers_from_tracks, isNoiseBurstCandidate, trig_BARREL, trig_ENDCAP,
409  summaryPlots.get()));
410  //=======================================================================
411  //=======================================================================
412  //=======================================================================
413  if (m_doChamberHists) { ATH_CHECK(fillMDTHistograms(mdtCollection)); }
414 
415  std::map<std::string, int>::iterator iter_hitsperchamber = evnt_hitsperchamber_map.find(hardware_name);
416  if (iter_hitsperchamber == evnt_hitsperchamber_map.end()) {
417  evnt_hitsperchamber_map.insert(make_pair(hardware_name, 1));
418  } else {
419  iter_hitsperchamber->second += 1;
420  }
421 
422  } // for loop over hits mdtcollection
423  nColl_ADCCut += isHit_above_ADCCut;
424  } // loop in MdtPrepDataContainer
425  if (m_do_mdtchamberstatphislice) {
426  for (const auto& phiitem : v_hit_in_chamber) {
427  auto hit_in_chamber = Monitored::Collection("hits_phi_" + phiitem.first, phiitem.second);
428  fill("MdtMonitor", hit_in_chamber);
429  }
430  }
431  auto hit_in_chamber_allphi = Monitored::Collection("hits_allphi", v_hit_in_chamber_allphi);
432  fill("MdtMonitor", hit_in_chamber_allphi);
433 
434  fillMDTOverviewHistograms(overviewPlots);
435  ATH_CHECK(fillMDTSummaryHistograms(summaryPlots.get(), lumiblock));
436 
437  int nHighOccChambers = 0;
438  for (const auto& iterstat : evnt_hitsperchamber_map) {
439  const auto iter_tubesperchamber = m_tubesperchamber_map.find(iterstat.first);
440  if (ATH_UNLIKELY(iter_tubesperchamber == m_tubesperchamber_map.end())) { // indicates software error
441  ATH_MSG_ERROR("Unable to find chamber " << iterstat.first);
442  continue;
443  }
444  float nTubes = iter_tubesperchamber->second;
445  float hits = iterstat.second;
446  float occ = hits / nTubes;
447  if (occ > 0.1) nHighOccChambers++;
448  }
449 
450  auto nHighOccChambers_mon = Monitored::Scalar<float>("nHighOccChambers_mon", nHighOccChambers);
451 
452  auto nPrd_mon = Monitored::Scalar<int>("nPrd_mon", nPrd);
453  auto nPrdcut_mon = Monitored::Scalar<int>("nPrdcut_mon", nPrdcut);
454  auto Nhitsrpc_mon = Monitored::Scalar<int>("Nhitsrpc_mon", Nhitsrpc);
455  auto nColl_mon = Monitored::Scalar<int>("nColl_mon", nColl);
456  auto nColl_ADCCut_mon = Monitored::Scalar<int>("nColl_ADCCut_mon", nColl_ADCCut);
457 
458  fill("MdtMonitor", nHighOccChambers_mon, nPrd_mon, Nhitsrpc_mon, nPrdcut_mon, nColl_mon, nColl_ADCCut_mon);
459 
460  // if (m_mdtglobalhitstime) m_mdtglobalhitstime->Fill(m_time - m_firstTime);
461 
462  } // m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD
463  } // m_doMdtESD==true
464 
465  for (const auto& key : m_segm_type) {
466  SG::ReadHandle<Trk::SegmentCollection> segms(key, ctx);
467  if (!segms.isValid()) {
468  ATH_MSG_ERROR("evtStore() does not contain mdt segms Collection with name " << key);
469  return StatusCode::FAILURE;
470  }
471 
472  MDTSegmentHistogramStruct segsPlots[4][4][16]; // [region][layer][phi]
473 
474  ATH_CHECK(handleEvent_effCalc_fillVects(segms.cptr(), segsPlots));
475 
476  ATH_CHECK(fillMDTSegmentHistograms(segsPlots));
477  }
478  return StatusCode::SUCCESS;
479 }

◆ fillMDTHistograms()

StatusCode MdtRawDataMonAlg::fillMDTHistograms ( const Muon::MdtPrepData *  mdtCollection) const
privatevirtual

Definition at line 854 of file MdtRawDataMonAlg.cxx.

854  {
855  // fill chamber by chamber histos
856  StatusCode sc = StatusCode::SUCCESS;
857  Identifier digcoll_id = (mdtCollection)->identify();
858  IdentifierHash digcoll_idHash = (mdtCollection)->collectionHash();
859 
860  MDTChamber* chamber{nullptr};
861  ATH_CHECK(getChamber(digcoll_idHash, chamber));
862 
863  std::string hardware_name = chamber->getName();
864  //
865 
866  // //convert layer numbering from 1->4 to 1->8
867  // //check if we are in 2nd multilayer
868  // //then add 4 if large chamber, 3 if small chamber
869  int mdtlayer = m_idHelperSvc->mdtIdHelper().tubeLayer(digcoll_id);
870  if (m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id) == 2) {
871  if (hardware_name.at(1) == 'I' && hardware_name.at(3) != '8')
872  mdtlayer += 4;
873  else
874  mdtlayer += 3;
875  }
876 
877  int mdttube = m_idHelperSvc->mdtIdHelper().tube(digcoll_id) + (mdtlayer - 1) * cachedTubeMax(digcoll_id);
878 
879  ChamberTubeNumberCorrection(mdttube, hardware_name, m_idHelperSvc->mdtIdHelper().tube(digcoll_id), mdtlayer - 1);
880  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
881 
882  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
883  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
884  if (hardware_name.substr(0, 3) == "BMG") tdc = mdtCollection->tdc() * 0.2;
885  float adc = mdtCollection->adc();
886  if (hardware_name.substr(0, 3) == "BMG") adc /= m_adcScale;
887 
888  int iregion = chamber->GetRegionEnum();
889 
890  int mezz = mezzmdt(digcoll_id);
891 
892  std::string monPerCh = "MdtMonPerChamber";
893  if (iregion == 0) monPerCh += "BA";
894  if (iregion == 1) monPerCh += "BC";
895  if (iregion == 2) monPerCh += "EA";
896  if (iregion == 3) monPerCh += "EC";
897 
898  int mdtMultLayer = m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id);
899 
900  auto tdc_perch = Monitored::Scalar<float>("tdc_perch_" + hardware_name, tdc);
901  auto adc_perch = Monitored::Scalar<float>("adc_perch_" + hardware_name, adc);
902  auto layer_perch = Monitored::Scalar<int>("layer_perch_" + hardware_name, mdtlayer);
903  auto tube_perch = Monitored::Scalar<int>("tube_perch_" + hardware_name, mdttube);
904  auto mezz_perch = Monitored::Scalar<int>("mezz_perch_" + hardware_name, mezz);
905  auto ml1_adccut = Monitored::Scalar<int>("ml1_adccut", (int)(adc > m_ADCCut && !isNoisy && mdtMultLayer == 1));
906  auto ml2_adccut = Monitored::Scalar<int>("ml2_adccut", (int)(adc > m_ADCCut && !isNoisy && mdtMultLayer == 2));
907  auto adccut_nonoise = Monitored::Scalar<int>("adccut_nonoise", (int)(adc > m_ADCCut && !isNoisy));
908  auto adccut = Monitored::Scalar<int>("adccut", (int)(adc > m_ADCCut));
909 
910  fill(monPerCh, tdc_perch, adc_perch, layer_perch, tube_perch, mezz_perch, ml1_adccut, ml2_adccut, adccut_nonoise, adccut);
911 
912  return sc;
913 }

◆ fillMDTMaskedTubes()

StatusCode MdtRawDataMonAlg::fillMDTMaskedTubes ( IdentifierHash  idHash,
const std::string &  hardware_name,
TH1F_LW *&  h 
)
privatevirtual

Definition at line 357 of file MDTRawDataUtilsRun3.cxx.

357  {
358  // Loop Over all mdt identifiers
359  if (!m_masked_tubes) {
360  ATH_MSG_WARNING("Could Not Fill masked tubes noise map not set!");
361  return StatusCode::SUCCESS;
362  }
363 
364  std::set<Identifier> noisyTubes = m_masked_tubes->getNoiseList(idHash);
365  for (auto digcoll_id : noisyTubes) {
366  int mdtlayer = m_idHelperSvc->mdtIdHelper().tubeLayer(digcoll_id);
367  if (m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id) == 2) {
368  if (hardware_name.at(1) == 'I' && hardware_name.at(3) != '8')
369  mdtlayer += 4;
370  else
371  mdtlayer += 3;
372  }
373  int tubeMax = m_idHelperSvc->mdtIdHelper().tubeMax(digcoll_id);
374  int mdttube = m_idHelperSvc->mdtIdHelper().tube(digcoll_id) + (mdtlayer - 1) * tubeMax;
375  ChamberTubeNumberCorrection(mdttube, hardware_name, m_idHelperSvc->mdtIdHelper().tube(digcoll_id), mdtlayer - 1);
376  h->Fill(mdttube, 1);
377  }
378  return StatusCode::SUCCESS;
379 }

◆ fillMDTOverviewHistograms()

void MdtRawDataMonAlg::fillMDTOverviewHistograms ( const MDTOverviewHistogramStruct &  vects) const
privatevirtual

Definition at line 550 of file MdtRawDataMonAlg.cxx.

550  {
551  auto mdt_tube_x_barrel = Monitored::Collection("mdt_tube_x_barrel", vects.mdt_tube_x_barrel);
552  auto mdt_tube_y_barrel = Monitored::Collection("mdt_tube_y_barrel", vects.mdt_tube_y_barrel);
553  auto mdt_tube_z_barrel = Monitored::Collection("mdt_tube_z_barrel", vects.mdt_tube_z_barrel);
554  auto mdt_tube_perp_barrel = Monitored::Collection("mdt_tube_perp_barrel", vects.mdt_tube_perp_barrel);
555  fill("MdtMonitor", mdt_tube_z_barrel, mdt_tube_perp_barrel, mdt_tube_x_barrel, mdt_tube_y_barrel);
556 
557  auto mdt_tube_x_ovl = Monitored::Collection("mdt_tube_x_ovl", vects.mdt_tube_x_ovl);
558  auto mdt_tube_y_ovl = Monitored::Collection("mdt_tube_y_ovl", vects.mdt_tube_y_ovl);
559  auto mdt_tube_z_ovl = Monitored::Collection("mdt_tube_z_ovl", vects.mdt_tube_z_ovl);
560  auto mdt_tube_perp_ovl = Monitored::Collection("mdt_tube_perp_ovl", vects.mdt_tube_perp_ovl);
561  fill("MdtMonitor", mdt_tube_z_ovl, mdt_tube_perp_ovl, mdt_tube_x_ovl, mdt_tube_y_ovl);
562 
563  auto mdt_tube_x_endcap = Monitored::Collection("mdt_tube_x_endcap", vects.mdt_tube_x_endcap);
564  auto mdt_tube_y_endcap = Monitored::Collection("mdt_tube_y_endcap", vects.mdt_tube_y_endcap);
565  auto mdt_tube_z_endcap = Monitored::Collection("mdt_tube_z_endcap", vects.mdt_tube_z_endcap);
566  auto mdt_tube_perp_endcap = Monitored::Collection("mdt_tube_perp_endcap", vects.mdt_tube_perp_endcap);
567  fill("MdtMonitor", mdt_tube_z_endcap, mdt_tube_perp_endcap, mdt_tube_x_endcap, mdt_tube_y_endcap);
568 
569  auto adc_mon_nosel = Monitored::Collection("adc_mon_nosel", vects.adc_mon_nosel);
570  auto tdc_mon_nosel = Monitored::Collection("tdc_mon_nosel", vects.tdc_mon_nosel);
571  auto noiseBurst = Monitored::Collection("noiseBurst", vects.noiseBurst);
572  fill("MdtMonitor", adc_mon_nosel, tdc_mon_nosel, noiseBurst);
573 
574  auto tdc_mon = Monitored::Collection("tdc_mon", vects.tdc_mon);
575  auto adc_mon = Monitored::Collection("adc_mon", vects.adc_mon);
576  fill("MdtMonitor", tdc_mon, adc_mon);
577 
578  auto adc_mon_noiseBurst_notNoisy = Monitored::Collection("adc_mon_noiseBurst_notNoisy", vects.adc_mon_noiseBurst_notNoisy);
579  fill("MdtMonitor", adc_mon_noiseBurst_notNoisy);
580 
581  auto tdc_mon_noiseBurst_adcCut = Monitored::Collection("tdc_mon_noiseBurst_adcCut", vects.tdc_mon_noiseBurst_adcCut);
582  fill("MdtMonitor", tdc_mon_noiseBurst_adcCut);
583 
584  auto tdc_mon_adcCut = Monitored::Collection("tdc_mon_adcCut", vects.tdc_mon_adcCut);
585  fill("MdtMonitor", tdc_mon_adcCut);
586 }

◆ fillMDTOverviewVects()

void MdtRawDataMonAlg::fillMDTOverviewVects ( const Muon::MdtPrepData *  mdtCollection,
bool &  isNoiseBurstCandidate,
MDTOverviewHistogramStruct &  vects 
) const
privatevirtual

Definition at line 482 of file MdtRawDataMonAlg.cxx.

483  {
484  Identifier digcoll_id = mdtCollection->identify();
485 
486  std::string hardware_name = getChamberName(mdtCollection);
487  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
488 
489  // MuonDetectorManager from the conditions store
490  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
491  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
492  if (!MuonDetMgr) {
493  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
494  return;
495  }
496 
497  const MuonGM::MdtReadoutElement* pReadoutElementMDT = MuonDetMgr->getMdtReadoutElement(digcoll_id);
498  const Amg::Vector3D mdtgPos = pReadoutElementMDT->tubePos(digcoll_id); // global position of the wire
499  float mdt_tube_eta = mdtgPos.eta();
500 
501  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
502  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
503  if (hardware_name.substr(0, 3) == "BMG") tdc = mdtCollection->tdc() * 0.2;
504 
505  float adc = mdtCollection->adc();
506  if (hardware_name.substr(0, 3) == "BMG") adc /= m_adcScale;
507 
508  if (adc > m_ADCCut) {
509  // barrel
510  if (std::abs(mdt_tube_eta) > 0. && std::abs(mdt_tube_eta) < 0.9) {
511  vects.mdt_tube_x_barrel.push_back(mdtgPos.x());
512  vects.mdt_tube_y_barrel.push_back(mdtgPos.y());
513  vects.mdt_tube_z_barrel.push_back(mdtgPos.z());
514  vects.mdt_tube_perp_barrel.push_back(mdtgPos.perp());
515  }
516  // OverLap -->Fill MDT Global RZ and YX
517  if (std::abs(mdt_tube_eta) > 0.9 && std::abs(mdt_tube_eta) < 1.2) {
518  vects.mdt_tube_x_ovl.push_back(mdtgPos.x());
519  vects.mdt_tube_y_ovl.push_back(mdtgPos.y());
520  vects.mdt_tube_z_ovl.push_back(mdtgPos.z());
521  vects.mdt_tube_perp_ovl.push_back(mdtgPos.perp());
522  }
523  // EndCap -->Fill MDT Global RZ and YX
524  if (std::abs(mdt_tube_eta) > 1.2 && std::abs(mdt_tube_eta) < 2.7) {
525  vects.mdt_tube_x_endcap.push_back(mdtgPos.x());
526  vects.mdt_tube_y_endcap.push_back(mdtgPos.y());
527  vects.mdt_tube_z_endcap.push_back(mdtgPos.z());
528  vects.mdt_tube_perp_endcap.push_back(mdtgPos.perp());
529  }
530  }
531 
532  vects.adc_mon_nosel.push_back(adc);
533  vects.tdc_mon_nosel.push_back(tdc);
534  if (!isNoisy && adc > 0) {
535  vects.tdc_mon.push_back(tdc);
536  vects.adc_mon.push_back(adc);
537  }
538 
539  vects.noiseBurst.push_back((int)isNoiseBurstCandidate);
540  if (isNoiseBurstCandidate) {
541  vects.tdc_mon_noiseBurst.push_back(tdc);
542  vects.adc_mon_noiseBurst.push_back(adc);
543  if (!isNoisy) { vects.adc_mon_noiseBurst_notNoisy.push_back(adc); }
544  if (adc > m_ADCCut) { vects.tdc_mon_noiseBurst_adcCut.push_back(tdc); }
545  }
546 
547  if (adc > m_ADCCut) { vects.tdc_mon_adcCut.push_back(tdc); }
548 }

◆ fillMDTSegmentHistograms()

StatusCode MdtRawDataMonAlg::fillMDTSegmentHistograms ( const MDTSegmentHistogramStruct(&)  vects[4][4][16]) const
privatevirtual

Definition at line 1203 of file MdtRawDataMonAlg.cxx.

1203  {
1204  std::string region[4] = {"BA", "BC", "EA", "EC"};
1205  std::string layer[4] = {"Inner", "Middle", "Outer", "Extra"};
1206 
1207  for (int iregion = 0; iregion < 4; ++iregion) {
1208  std::string MDT_regionGroup = "MDT_regionGroup" + region[iregion]; // MDTXX/Overview, 4 gruppi
1209  for (int ilayer = 0; ilayer < 4; ++ilayer) {
1210  for (int stationPhi = 0; stationPhi < 16; ++stationPhi) {
1211  const auto& thisVects = vects[iregion][ilayer][stationPhi];
1212 
1213  auto adc_segs_mon = Monitored::Collection("adc_segs_mon", thisVects.adc_segs_mon);
1214  auto adc_segs_overall_mon = Monitored::Collection("adc_segs_overall_mon", thisVects.adc_segs_mon);
1215  std::string tdc_var = "tdc_segs_" + region[iregion] + "_" + layer[ilayer] + "_phi" + std::to_string(stationPhi + 1);
1216  auto tdc_segs_mon = Monitored::Collection(tdc_var, thisVects.tdc_segs_mon);
1217  if (m_do_mdttdccut_sector) fill(MDT_regionGroup, tdc_segs_mon);
1218 
1219  auto tdc_segs_overall_mon = Monitored::Collection("tdc_segs_overall_mon", thisVects.tdc_segs_mon);
1220  auto tdc_segs_region_mon = Monitored::Collection("tdc_segs_region_mon", thisVects.tdc_segs_mon);
1221 
1222  fill(MDT_regionGroup, adc_segs_mon, tdc_segs_region_mon);
1223 
1224  std::string varx = iregion < 2 ? "x_segs_mon_barrel" : "x_segs_mon_endcap";
1225  std::string vary = iregion < 2 ? "y_segs_mon_barrel" : "y_segs_mon_endcap";
1226  auto x_segs_mon = Monitored::Collection(varx, thisVects.x_segs_mon);
1227  auto y_segs_mon = Monitored::Collection(vary, thisVects.y_segs_mon);
1228 
1229  fill("MdtMonitor", tdc_segs_overall_mon, adc_segs_overall_mon, x_segs_mon, y_segs_mon);
1230  }
1231  }
1232  }
1233  return StatusCode::SUCCESS;
1234 }

◆ fillMDTSummaryHistograms()

StatusCode MdtRawDataMonAlg::fillMDTSummaryHistograms ( std::array< MDTSummaryHistogramStruct, 4096 > *  vects,
int  lb 
) const
privatevirtual

Definition at line 739 of file MdtRawDataMonAlg.cxx.

739  {
740  std::string region[4] = {"BA", "BC", "EA", "EC"};
741  std::string layer[4] = {"Inner", "Middle", "Outer", "Extra"};
742  std::string crate[4] = {"01", "02", "03", "04"};
743  // std::string slayer[4]={"inner","middle","outer","extra"};
744 
745  auto lb_mon = Monitored::Scalar<int>("lb_mon", lb);
746 
747  for (int iregion = 0; iregion < 4; ++iregion) {
748  std::string MDT_regionGroup = "MDT_regionGroup" + region[iregion]; // MDTXX/Overview
749  for (int crate_region = 0; crate_region < 4; ++crate_region) {
750  std::string MDT_regionGroup_bycrate = "MDT_regionGroup_bycrate" + region[crate_region]; // MDTXX/Overview
751  for (int ilayer = 0; ilayer < 4; ++ilayer) {
752  for (int stationPhi = 0; stationPhi < 16; ++stationPhi) {
753  for (int icrate = 0; icrate < 4; ++icrate) {
754  uint16_t v = MdtHistCoder::encode(iregion, ilayer, stationPhi, crate_region, icrate);
755 
756  std::array<MDTSummaryHistogramStruct, 4096>& array = *(vects);
757  auto& thisVects = array[v];
758 
759  auto sector = Monitored::Collection("sector", thisVects.sector);
760 
761  fill("MdtMonitor", lb_mon, sector);
762 
763  auto stationEta = Monitored::Collection(
764  "stEta_" + region[iregion] + "_" + layer[ilayer] + "_phi" + std::to_string(stationPhi + 1),
765  thisVects.stationEta);
766 
767  if (m_do_mdtChamberHits) { fill(MDT_regionGroup, stationEta); }
768 
769  auto adc_mon = Monitored::Collection("adc_mon", thisVects.adc_mon);
770  auto tdc_mon = Monitored::Collection("tdc_mon", thisVects.tdc_mon);
771 
772  auto tdc_mon_nb2 = Monitored::Collection("tdc_mon_nb2", thisVects.tdc_mon_nb2);
773  auto adc_mon_nb2 = Monitored::Collection("adc_mon_nb2", thisVects.adc_mon_nb2);
774 
775  auto tdc_mon_nb1 = Monitored::Collection("tdc_mon_nb1", thisVects.tdc_mon_nb1);
776  auto adc_mon_nb1 = Monitored::Collection("adc_mon_nb1", thisVects.adc_mon_nb1);
777 
778  auto adc_mon_adccut = Monitored::Collection("adc_mon_adccut", thisVects.adc_mon_adccut);
779 
780  auto tdc_mon_adccut = Monitored::Collection("tdc_mon_adccut", thisVects.tdc_mon_adccut);
781 
782  std::string varx = iregion < 2 ? "x_mon_barrel" : "x_mon_endcap";
783  std::string vary = iregion < 2 ? "y_mon_barrel" : "y_mon_endcap";
784  std::string varx_noise = iregion < 2 ? "x_mon_barrel_noise" : "x_mon_endcap_noise";
785  std::string vary_noise = iregion < 2 ? "y_mon_barrel_noise" : "y_mon_endcap_noise";
786 
787  auto x_mon = Monitored::Collection(varx, thisVects.x_mon);
788  auto y_mon = Monitored::Collection(vary, thisVects.y_mon);
789  auto x_mon_noise = Monitored::Collection(varx_noise, thisVects.x_mon_noise);
790  auto y_mon_noise = Monitored::Collection(vary_noise, thisVects.y_mon_noise);
791  fill("MdtMonitor", x_mon, y_mon, x_mon_noise, y_mon_noise);
792  auto tdc_mon_nb3 = Monitored::Collection("tdc_mon_nb3", thisVects.tdc_mon_nb3);
793 
794  varx = "x_mon_" + region[iregion] + "_" + layer[ilayer];
795  vary = "y_mon_" + region[iregion] + "_" + layer[ilayer];
796 
797  auto x_bin_perML = Monitored::Collection(varx, thisVects.x_bin_perML); // get the right bin!!!!
798  auto y_bin_perML = Monitored::Collection(vary, thisVects.y_bin_perML);
799 
800  if (layer[ilayer] != "Extra") {
801  varx = "x_mon_" + layer[ilayer];
802  vary = "y_mon_" + layer[ilayer];
803  auto bin_byLayer_x = Monitored::Collection(varx, thisVects.bin_byLayer_x);
804  auto bin_byLayer_y = Monitored::Collection(vary, thisVects.bin_byLayer_y);
805 
806  fill("MdtMonitor", bin_byLayer_x, bin_byLayer_y);
807  }
808 
809  auto tdc_mon_rpc = Monitored::Collection("tdc_mon_rpc", thisVects.tdc_mon_rpc);
810  auto tdc_mon_tgc = Monitored::Collection("tdc_mon_tgc", thisVects.tdc_mon_tgc);
811 
812  auto biny_name = "y_mon_bin_" + region[iregion] + "_" + layer[ilayer];
813  if (layer[ilayer] == "Extra" || layer[ilayer] == "Outer")
814  biny_name = "y_mon_bin_" + region[iregion] + "_OuterPlusExtra";
815 
816  auto biny_var = Monitored::Collection(biny_name, thisVects.biny_vslb);
817 
818  std::vector<int> sum_biny_vslb_bycrate;
819  sum_biny_vslb_bycrate.reserve(thisVects.biny_vslb_bycrate.size() + thisVects.biny_vslb_bycrate_bis_bee.size());
820  sum_biny_vslb_bycrate.insert(sum_biny_vslb_bycrate.end(), thisVects.biny_vslb_bycrate_bis_bee.begin(),
821  thisVects.biny_vslb_bycrate_bis_bee.end());
822  sum_biny_vslb_bycrate.insert(sum_biny_vslb_bycrate.end(), thisVects.biny_vslb_bycrate.begin(),
823  thisVects.biny_vslb_bycrate.end());
824 
825  auto biny_name_bycrate = "y_mon_bin_bycrate_" + region[crate_region] + "_" + crate[icrate];
826  auto biny_var_bycrate = Monitored::Collection(biny_name_bycrate, sum_biny_vslb_bycrate);
827 
828  std::vector<int> sum_biny_vslb_bycrate_ontrack;
829  sum_biny_vslb_bycrate_ontrack.reserve(thisVects.biny_vslb_bycrate_ontrack.size() +
830  thisVects.biny_vslb_bycrate_bis_bee_ontrack.size());
831  sum_biny_vslb_bycrate_ontrack.insert(sum_biny_vslb_bycrate_ontrack.end(),
832  thisVects.biny_vslb_bycrate_bis_bee_ontrack.begin(),
833  thisVects.biny_vslb_bycrate_bis_bee_ontrack.end());
834  sum_biny_vslb_bycrate_ontrack.insert(sum_biny_vslb_bycrate_ontrack.end(),
835  thisVects.biny_vslb_bycrate_ontrack.begin(),
836  thisVects.biny_vslb_bycrate_ontrack.end());
837 
838  auto biny_name_bycrate_ontrack = "y_mon_bin_bycrate_ontrack_" + region[crate_region] + "_" + crate[icrate];
839  auto biny_var_bycrate_ontrack = Monitored::Collection(biny_name_bycrate_ontrack, sum_biny_vslb_bycrate_ontrack);
840 
841  fill(MDT_regionGroup, adc_mon, tdc_mon, tdc_mon_nb2, adc_mon_nb2, tdc_mon_adccut, adc_mon_adccut, tdc_mon_adccut,
842  adc_mon_adccut, tdc_mon_nb3, x_bin_perML, y_bin_perML, tdc_mon_rpc, tdc_mon_tgc, biny_var, lb_mon, biny_var);
843 
844  fill(MDT_regionGroup_bycrate, lb_mon, biny_var_bycrate, biny_var_bycrate_ontrack);
845  }
846  }
847  }
848  }
849  }
850 
851  return StatusCode::SUCCESS;
852 }

◆ fillMDTSummaryVects()

StatusCode MdtRawDataMonAlg::fillMDTSummaryVects ( const Muon::MdtPrepData *  mdtCollection,
const std::set< std::string > &  chambers_from_tracks,
bool &  isNoiseBurstCandidate,
bool  trig_barrel,
bool  trig_endcap,
std::array< MDTSummaryHistogramStruct, 4096 > *  vects 
) const
privatevirtual

Definition at line 588 of file MdtRawDataMonAlg.cxx.

590  {
591  StatusCode sc = StatusCode::SUCCESS;
592  Identifier digcoll_id = (mdtCollection)->identify();
593  IdentifierHash digcoll_idHash = (mdtCollection)->collectionHash();
594 
595  MDTChamber* chamber{nullptr};
596  ATH_CHECK(getChamber(digcoll_idHash, chamber));
597  bool isNoisy = m_masked_tubes->isNoisy(mdtCollection);
598 
599  std::string region[4] = {"BA", "BC", "EA", "EC"};
600  std::string layer[4] = {"Inner", "Middle", "Outer", "Extra"};
601  std::string crate[4] = {"01", "02", "03", "04"};
602  // std::string slayer[4]={"inner","middle","outer","extra"};
603 
604  // int ibarrel = chamber->GetBarrelEndcapEnum();
605  int iregion = chamber->GetRegionEnum();
606  int ilayer = chamber->GetLayerEnum();
607  int icrate = chamber->GetCrate();
608  //
609  int stationPhi = chamber->GetStationPhi();
610  std::string chambername = chamber->getName();
611  int thisStationEta = chamber->GetStationEta();
612 
613  int crate_region = iregion;
614  // correct readout crate info for BEE,BIS7/8
615  if (chambername.substr(0, 3) == "BEE" || (chambername.substr(0, 3) == "BIS" && (thisStationEta == 7 || thisStationEta == 8))) {
616  if (iregion == 0) crate_region = 2;
617  if (iregion == 1) crate_region = 3;
618  }
619 
620  uint16_t v = MdtHistCoder::encode(iregion, ilayer, stationPhi, crate_region, icrate - 1);
621  std::array<MDTSummaryHistogramStruct, 4096>& array = *(vects);
622  auto& thisVects = array[v];
623 
624  bool is_on_track = false;
625  for (const auto& ch : chambers_from_tracks) {
626  if (chambername == ch) is_on_track = true;
627  }
628 
629  bool isBIM = (chambername.at(2) == 'M');
630  float tdc = mdtCollection->tdc() * 25.0 / 32.0;
631  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
632  if (chambername.substr(0, 3) == "BMG") tdc = mdtCollection->tdc() * 0.2;
633  float adc = mdtCollection->adc();
634  if (chambername.substr(0, 3) == "BMG") adc /= m_adcScale;
635 
636  thisVects.sector.push_back(stationPhi + iregion * 16); // here valgrind complains
637 
638  // mdtoccvslb_summaryPerSector->Fill(lumiblock, stationPhi+iregion*16 );
639  // MDTBA/Overview/Hits
640  // iregion = BA/BC/EA/EC --> 4
641  // ilayer = //inner, middle, outer, extra --> 4
642  // stationPhi --> 16 ====> 256
643  // std::string mon="MDTHits_ADCCut_"+region[iregion]+"_Mon_"+layer[ilayer]+"_Phi_"+std::to_string(stationPhi+1);;
644  // int mlayer_n = m_mdtIdHelper->multilayer(digcoll_id);
645  int mlayer_n = m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id);
646 
647  if (!isNoisy && adc > 0) {
648  thisVects.adc_mon.push_back(adc);
649  thisVects.tdc_mon.push_back(tdc);
650  if (isNoiseBurstCandidate) {
651  thisVects.tdc_mon_nb2.push_back(tdc);
652  thisVects.adc_mon_nb2.push_back(adc);
653  }
654  }
655 
656  if (!isNoisy) {
657  // fill(MDT_regionGroup, adc_mon);
658  if (isNoiseBurstCandidate) {
659  thisVects.tdc_mon_nb1.push_back(tdc);
660  thisVects.adc_mon_nb1.push_back(adc);
661  }
662  }
663  if (adc > m_ADCCut && !isNoisy) {
664  thisVects.adc_mon_adccut.push_back(adc);
665  thisVects.tdc_mon_adccut.push_back(tdc);
666  int thisStationEta = chamber->GetStationEta();
667  thisVects.stationEta.push_back(thisStationEta);
668 
669  int binx = chamber->GetMDTHitsPerChamber_IMO_BinX();
670  if (iregion < 2)
671  binx = binx - 9;
672  else
673  binx = binx - 7;
674  int biny = chamber->GetMDTHitsPerChamber_IMO_BinY();
675 
676  std::string varx = " ";
677  std::string vary = " ";
678  std::string varx_noise = " ";
679  std::string vary_noise = " ";
680  if (iregion < 2) {
681  varx = "x_mon_barrel";
682  vary = "y_mon_barrel";
683  varx_noise = "x_mon_barrel_noise";
684  vary_noise = "y_mon_barrel_noise";
685  } else {
686  varx = "x_mon_endcap";
687  vary = "y_mon_endcap";
688  varx_noise = "x_mon_endcap_noise";
689  vary_noise = "y_mon_endcap_noise";
690  }
691 
692  thisVects.x_mon.push_back(binx);
693  thisVects.y_mon.push_back(biny - 1);
694  if (isNoiseBurstCandidate) {
695  thisVects.x_mon_noise.push_back(binx);
696  thisVects.y_mon_noise.push_back(biny - 1);
697  thisVects.tdc_mon_nb3.push_back(tdc);
698  }
699 
700  thisVects.x_bin_perML.push_back(chamber->GetMDTHitsPerML_Binx() - 1); // get the right bin!!!!
701  int biny_ml = 0;
702  if (mlayer_n == 1)
703  biny_ml = chamber->GetMDTHitsPerML_m1_Biny();
704  else if (mlayer_n == 2)
705  biny_ml = chamber->GetMDTHitsPerML_m2_Biny();
706  thisVects.y_bin_perML.push_back(biny_ml - 1);
707 
708  if (layer[ilayer] != "Extra") {
709  thisVects.bin_byLayer_x.push_back(chamber->GetMDTHitsPerML_byLayer_BinX() - 1);
710  thisVects.bin_byLayer_y.push_back(chamber->GetMDTHitsPerML_byLayer_BinY(mlayer_n) - 1);
711  }
712  if (trig_barrel) { thisVects.tdc_mon_rpc.push_back(tdc); }
713  if (trig_endcap) { thisVects.tdc_mon_tgc.push_back(tdc); }
714 
715  // Fill occupancy vs. Lumiblock
716  thisVects.biny_vslb.push_back(get_bin_for_LB_hist(iregion, ilayer, stationPhi, thisStationEta, isBIM));
717  if (chambername.substr(0, 3) == "BEE" || (chambername.substr(0, 3) == "BIS" && (thisStationEta == 7 || thisStationEta == 8))) {
718  thisVects.biny_vslb_bycrate_bis_bee.push_back(
719  get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, thisStationEta, chambername));
720  } else {
721  thisVects.biny_vslb_bycrate.push_back(
722  get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, thisStationEta, chambername));
723  }
724 
725  if (is_on_track) {
726  if (chambername.substr(0, 3) == "BEE" || (chambername.substr(0, 3) == "BIS" && (thisStationEta == 7 || thisStationEta == 8))) {
727  thisVects.biny_vslb_bycrate_bis_bee_ontrack.push_back(
728  get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, thisStationEta, chambername));
729  } else {
730  thisVects.biny_vslb_bycrate_ontrack.push_back(
731  get_bin_for_LB_crate_hist(crate_region, icrate, stationPhi + 1, thisStationEta, chambername));
732  }
733  }
734  }
735 
736  return sc;
737 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ get_bin_for_LB_crate_hist()

int MdtRawDataMonAlg::get_bin_for_LB_crate_hist ( int  region,
int  layer,
int  phi,
int  eta,
std::string_view  chamber 
) const
private

Definition at line 1158 of file MDTRawDataUtilsRun3.cxx.

1158  {
1159  int binNum = 999;
1160  std::string_view stName = chamber.substr(0, 3);
1161  if (region == 0 || region == 1) { // Barrel
1162  if (crate == 1) { // BA01, BC01
1163  if (stName == "BIL")
1164  binNum = 2 * eta + (phi - 1) / 2 - 1;
1165  else if (stName == "BIS")
1166  binNum = 12 + 2 * eta + (phi - 2) / 2 - 1;
1167  else if (stName == "BME")
1168  binNum = 25;
1169  else if (stName == "BML")
1170  binNum = 25 + 2 * eta + (phi - 1) / 2 - 1;
1171  else if (stName == "BMS")
1172  binNum = 37 + 2 * eta + (phi - 2) / 2 - 1;
1173  else if (stName == "BOL")
1174  binNum = 49 + 2 * eta + (phi - 1) / 2 - 1;
1175  else if (stName == "BOS")
1176  binNum = 61 + 2 * eta + (phi - 2) / 2 - 1;
1177  else
1178  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx01");
1179  return binNum - 1;
1180  } else if (crate == 2) { // BA02, BC02
1181 
1182  if (stName == "BIL")
1183  binNum = 2 * eta + (phi - 5) / 2 - 1;
1184  else if (stName == "BIS")
1185  binNum = 12 + 2 * eta + (phi - 6) / 2 - 1;
1186  else if (stName == "BML")
1187  binNum = 24 + 2 * eta + (phi - 5) / 2 - 1;
1188  else if (stName == "BMS")
1189  binNum = 36 + 2 * eta + (phi - 6) / 2 - 1;
1190  else if (stName == "BOL")
1191  binNum = 48 + 2 * eta + (phi - 5) / 2 - 1;
1192  else if (stName == "BOS")
1193  binNum = 60 + 2 * eta + (phi - 6) / 2 - 1;
1194  else
1195  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx02");
1196  return binNum - 1;
1197  } else if (crate == 3) { // BA03,BC03
1198  if (stName == "BIL")
1199  binNum = eta;
1200  else if (stName == "BIM")
1201  binNum = 6 + eta;
1202  else if (stName == "BIR")
1203  binNum = 11 + eta;
1204  else if (stName == "BIS")
1205  binNum = 17 + 2 * eta + (phi - 10) / 2 - 1;
1206  else if (stName == "BMF")
1207  binNum = 29 + (eta + 1) / 2;
1208  else if (stName == "BMG")
1209  binNum = 32 + eta / 2;
1210  else if (stName == "BML")
1211  binNum = 35 + 2 * eta + (phi - 9) / 2 - 1;
1212  else if (stName == "BMS")
1213  binNum = 47 + eta;
1214  else if (stName == "BOF")
1215  binNum = 53 + (eta + 1) / 2;
1216  else if (chamber.substr(0, 4) == "BOG0" && region == 0)
1217  binNum = 58;
1218  else if (stName == "BOG")
1219  binNum = 58 + eta / 2 - region;
1220  else if (stName == "BOL")
1221  binNum = 62 + 2 * eta + (phi - 9) / 2 - 1 - region;
1222  else if (stName == "BOS")
1223  binNum = 74 + eta - region;
1224  else
1225  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx03");
1226  return binNum - 1;
1227  } else if (crate == 4) { // BA04, BC04
1228 
1229  if (stName == "BIL")
1230  binNum = eta;
1231  else if (stName == "BIM")
1232  binNum = 6 + eta;
1233  else if (stName == "BIR")
1234  binNum = 11 + eta;
1235  else if (stName == "BIS")
1236  binNum = 17 + 2 * eta + (phi - 14) / 2 - 1;
1237  else if (stName == "BMF")
1238  binNum = 29 + (eta + 1) / 2;
1239  else if (stName == "BMG")
1240  binNum = 32 + eta / 2;
1241  else if (stName == "BML" && eta < 6)
1242  binNum = 35 + 2 * eta + (phi - 13) / 2 - 1;
1243  else if (chamber.substr(0, 7) == "BML6A15" || chamber.substr(0, 7) == "BML6C15")
1244  binNum = 46;
1245  else if (stName == "BMS")
1246  binNum = 46 + eta;
1247  else if (stName == "BOF")
1248  binNum = 52 + (eta + 1) / 2;
1249  else if (chamber.substr(0, 4) == "BOG0" && region == 0)
1250  binNum = 57;
1251  else if (stName == "BOG")
1252  binNum = 57 + eta / 2 - region;
1253  else if (stName == "BOL")
1254  binNum = 61 + 2 * eta + (phi - 13) / 2 - 1 - region;
1255  else if (stName == "BOS")
1256  binNum = 74 + eta - region;
1257  else
1258  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx04");
1259  return binNum - 1;
1260  }
1261  } else if (region == 2 || region == 3) {
1262  if (crate == 1) { // EA01, EC01
1263  if (stName == "BEE")
1264  binNum = 2 * eta + (phi - 2) / 2 - 1;
1265  else if (stName == "BIS")
1266  binNum = 4 + 2 * (eta - 6) + (phi - 2) / 2 - 1;
1267  else if (stName == "EEL")
1268  binNum = 8 + 2 * eta + (phi - 1) / 2 - 1;
1269  else if (stName == "EES")
1270  binNum = 12 + 2 * eta + (phi - 2) / 2 - 1;
1271  else if (stName == "EIL" && eta < 5)
1272  binNum = 16 + 2 * eta + (phi - 1) / 2 - 1;
1273  else if (stName == "EIL" && eta == 5)
1274  binNum = 25;
1275  else if (stName == "EIS")
1276  binNum = 25 + 2 * eta + (phi - 2) / 2 - 1;
1277  else if (stName == "EML")
1278  binNum = 29 + 2 * eta + (phi - 1) / 2 - 1;
1279  else if (stName == "EMS")
1280  binNum = 39 + 2 * eta + (phi - 2) / 2 - 1;
1281  else if (stName == "EOL")
1282  binNum = 49 + 2 * eta + (phi - 1) / 2 - 1;
1283  else if (stName == "EOS")
1284  binNum = 61 + 2 * eta + (phi - 2) / 2 - 1;
1285  else
1286  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex01");
1287  if (m_do_run3Geometry) {
1288  if (region == 2) {
1289  if (binNum > 8 && binNum < 23)
1290  binNum = binNum - 2;
1291  else if (binNum > 22 && binNum < 30)
1292  binNum = binNum - 8;
1293  else if (binNum > 29)
1294  binNum = binNum - 12;
1295  } else if (region == 3) {
1296  if (binNum > 22 && binNum < 30)
1297  binNum = binNum - 6;
1298  else if (binNum > 29)
1299  binNum = binNum - 10;
1300  }
1301  }
1302  return binNum - 1;
1303  } else if (crate == 2) { // EA02, EC02
1304  if (stName == "BEE")
1305  binNum = 2 * eta + (phi - 6) / 2 - 1;
1306  else if (stName == "BIS")
1307  binNum = 4 + 2 * (eta - 6) + (phi - 6) / 2 - 1;
1308  else if (chamber.substr(0, 4) == "EEL1")
1309  binNum = 9 + (phi - 3) / 2 - 1;
1310  else if (chamber.substr(0, 4) == "EEL2")
1311  binNum = 11;
1312  else if (stName == "EES")
1313  binNum = 11 + 2 * eta + (phi - 6) / 2 - 1;
1314  else if (stName == "EIL")
1315  binNum = 15 + 2 * eta + (phi - 5) / 2 - 1;
1316  else if (stName == "EIS")
1317  binNum = 23 + 2 * eta + (phi - 6) / 2 - 1;
1318  else if (stName == "EML")
1319  binNum = 27 + 2 * eta + (phi - 5) / 2 - 1;
1320  else if (stName == "EMS")
1321  binNum = 37 + 2 * eta + (phi - 6) / 2 - 1;
1322  else if (stName == "EOL")
1323  binNum = 47 + 2 * eta + (phi - 5) / 2 - 1;
1324  else if (stName == "EOS")
1325  binNum = 59 + 2 * eta + (phi - 6) / 2 - 1;
1326  else
1327  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex02");
1328  if (m_do_run3Geometry) {
1329  if (region == 2) {
1330  if (binNum > 8 && binNum < 22)
1331  binNum = binNum - 2;
1332  else if (binNum > 21 && binNum < 28)
1333  binNum = binNum - 8;
1334  else if (binNum > 27)
1335  binNum = binNum - 12;
1336  } else if (region == 3) {
1337  if (binNum > 21 && binNum < 28)
1338  binNum = binNum - 6;
1339  else if (binNum > 27)
1340  binNum = binNum - 10;
1341  }
1342  }
1343  return binNum - 1;
1344  } else if (crate == 3) { // EA03, EC03
1345 
1346  if (stName == "BEE")
1347  binNum = 2 * eta + (phi - 10) / 2 - 1;
1348  else if (stName == "BIS")
1349  binNum = 4 + 2 * (eta - 6) + (phi - 10) / 2 - 1;
1350  else if (stName == "EEL")
1351  binNum = 8 + 2 * eta + (phi - 9) / 2 - 1;
1352  else if (stName == "EES")
1353  binNum = 12 + 2 * eta + (phi - 10) / 2 - 1;
1354  else if (stName == "EIL" && eta < 5)
1355  binNum = 16 + 2 * eta + (phi - 9) / 2 - 1;
1356  else if (chamber.substr(0, 4) == "EIL5")
1357  binNum = 25;
1358  else if (stName == "EIS")
1359  binNum = 25 + 2 * eta + (phi - 10) / 2 - 1;
1360  else if (stName == "EML")
1361  binNum = 29 + 2 * eta + (phi - 9) / 2 - 1;
1362  else if (stName == "EMS")
1363  binNum = 39 + 2 * eta + (phi - 10) / 2 - 1;
1364  else if (stName == "EOL")
1365  binNum = 49 + 2 * eta + (phi - 9) / 2 - 1;
1366  else if (stName == "EOS")
1367  binNum = 61 + 2 * eta + (phi - 10) / 2 - 1;
1368  else
1369  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex03");
1370  if (m_do_run3Geometry) {
1371  if (region == 2) {
1372  if (binNum > 8 && binNum < 23)
1373  binNum = binNum - 2;
1374  else if (binNum > 22 && binNum < 30)
1375  binNum = binNum - 8;
1376  else if (binNum > 29)
1377  binNum = binNum - 12;
1378  }
1379  if (region == 3) {
1380  if (binNum > 22 && binNum < 30)
1381  binNum = binNum - 6;
1382  else if (binNum > 29)
1383  binNum = binNum - 10;
1384  }
1385  }
1386  return binNum - 1;
1387  } else if (crate == 4) { // EA04, EC04
1388  if (stName == "BEE")
1389  binNum = 2 * eta + (phi - 14) / 2 - 1;
1390  else if (stName == "BIS")
1391  binNum = 4 + 2 * (eta - 6) + (phi - 14) / 2 - 1;
1392  else if (stName == "EEL")
1393  binNum = 8 + 2 * eta + (phi - 13) / 2 - 1;
1394  else if (stName == "EES")
1395  binNum = 12 + 2 * eta + (phi - 14) / 2 - 1;
1396  else if (stName == "EIL")
1397  binNum = 16 + 2 * eta + (phi - 13) / 2 - 1;
1398  else if (stName == "EIS")
1399  binNum = 24 + 2 * eta + (phi - 14) / 2 - 1;
1400  else if (stName == "EML")
1401  binNum = 28 + 2 * eta + (phi - 13) / 2 - 1;
1402  else if (stName == "EMS")
1403  binNum = 38 + 2 * eta + (phi - 14) / 2 - 1;
1404  else if (stName == "EOL")
1405  binNum = 48 + 2 * eta + (phi - 13) / 2 - 1;
1406  else if (stName == "EOS")
1407  binNum = 60 + 2 * eta + (phi - 14) / 2 - 1;
1408  else
1409  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex04");
1410  if (m_do_run3Geometry) {
1411  if (region == 2) {
1412  if (binNum > 8 && binNum < 23)
1413  binNum = binNum - 2;
1414  else if (binNum > 22 && binNum < 29)
1415  binNum = binNum - 8;
1416  else if (binNum > 28)
1417  binNum = binNum - 12;
1418  }
1419  if (region == 3) {
1420  if (binNum > 22 && binNum < 28)
1421  binNum = binNum - 6;
1422  else if (binNum > 28)
1423  binNum = binNum - 10;
1424  }
1425  }
1426 
1427  return binNum - 1;
1428  }
1429  }
1430  return -1;
1431 }

◆ get_bin_for_LB_hist()

int MdtRawDataMonAlg::get_bin_for_LB_hist ( int  region,
int  layer,
int  phi,
int  eta,
bool  isBIM 
) const
private

Definition at line 498 of file MDTRawDataUtilsRun3.cxx.

498  {
499  if (region == 0 || region == 1) { // Barrel
500 
501  if (layer == 0) { // Inner
502  if (eta < 6) {
503  if (phi < 11 && !isBIM)
504  return 18 * (eta - 1) + phi;
505  else if ((phi == 10 && isBIM) || (phi < 15 && !isBIM))
506  return 18 * (eta - 1) + phi + 1;
507  else
508  return 18 * (eta - 1) + phi + 2;
509  } else if (eta == 6)
510  return 90 + phi;
511  else if (eta == 7)
512  return 106 + (phi / 2);
513  else if (eta == 8)
514  return 114 + (phi / 2);
515  }
516 
517  else if (layer == 1) { // Middle
518  // 95 = 1 + 16 + 16 + 16 + 16 + 16 + 14 total number of phi sectors (+1)
519  // in the last eta-sector (6) there is no phi-sector 13; ie there are no chambers BML6A13 and BML6C13, so there are only 14 phi
520  // sectos we move the bin of phi=14 directly above phi=12 so there is no white line in the histogram
521  if (eta == 6 && phi > 11)
522  return 16 * (eta - 1) + phi - 1;
523  else
524  return 16 * (eta - 1) + phi;
525 
526  } else if (layer == 2 && region == 0) { // Outer, side A (must be separated due to presence of eta=0 chambers)
527  if (eta == 0 && phi == 11)
528  return 0;
529  else if (eta == 0 && phi == 13)
530  return 1;
531  else if (eta < 7)
532  return 16 * (eta - 1) + phi + 2;
533  else if (eta == 7 && phi == 11)
534  return 98;
535  else if (eta == 7 && phi == 13)
536  return 99;
537  else if (eta == 8 && phi == 11)
538  return 100;
539  else if (eta == 8 && phi == 13)
540  return 101;
541  } else if (layer == 3 && region == 0) { // Extra: put with outer
542  return 102 + 8 * (eta - 1) + (phi - 1) / 2;
543  } else if (layer == 2 && region == 1) { // Outer, side C
544  if (eta < 7)
545  return 16 * (eta - 1) + phi;
546  else if (eta == 7 && phi == 11)
547  return 96;
548  else if (eta == 7 && phi == 13)
549  return 97;
550  else if (eta == 8 && phi == 11)
551  return 98;
552  else if (eta == 8 && phi == 13)
553  return 99;
554  } else if (layer == 3 && region == 1) { // Extra: put with outer
555  return 100 + 8 * (eta - 1) + (phi - 1) / 2;
556  }
557 
558  }
559 
560  else { // Endcap
561  if (layer == 0) { // Inner
562  int run3_offset = 0;
563  if (m_do_run3Geometry) run3_offset = 40;
564  if (eta < 3)
565  return 16 * (eta - 1) + phi - run3_offset;
566  else if (eta == 3)
567  return 32 + phi / 2 - run3_offset;
568  else if (eta == 4)
569  return 40 + phi / 2 - run3_offset;
570  else if (eta == 5)
571  return 48 + phi / 8 - run3_offset;
572 
573  } else if (layer == 1) { // Middle
574  return 16 * (eta - 1) + phi;
575  } else if (layer == 2) { // Outer
576  return 16 * (eta - 1) + phi;
577  } else if (layer == 3 && region == 2) { // Extra A: put with outer. Asymmetry between A and C
578  if (eta == 1 && phi == 2) return 96;
579  if (eta == 1 && phi == 4) return 97;
580  if (eta == 1 && phi == 10) return 98;
581  if (eta == 1 && phi == 12) return 99;
582  if (eta == 2 && phi == 2) return 100;
583  if (eta == 2 && phi == 10) return 101;
584  if (eta == 2 && phi == 12) return 102;
585  } else if (layer == 3 && region == 3) { // Extra C: put with outer.
586  if (eta == 1 || phi < 5)
587  return 80 + 16 * eta + phi;
588  else
589  return 79 + 16 * eta + phi; //(missing eta = 2, phi = 5)
590  }
591  }
592 
593  return -1;
594 }

◆ getChamber()

StatusCode MdtRawDataMonAlg::getChamber ( const IdentifierHash &  id,
MDTChamber *&  chamber 
) const
private

Definition at line 490 of file MDTRawDataUtilsRun3.cxx.

490  {
491  if (id >= m_hist_hash_list.size()) return StatusCode::FAILURE;
492  chamber = m_hist_hash_list[id].get();
493  if (!chamber) return StatusCode::FAILURE;
494 
495  return StatusCode::SUCCESS;
496 }

◆ getChamberName() [1/2]

std::string MdtRawDataMonAlg::getChamberName ( const Identifier &  id) const
private

Definition at line 481 of file MDTRawDataUtilsRun3.cxx.

481  {
482  IdentifierHash idHash{0};
483  const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
484  id_helper.get_module_hash(id, idHash);
485  MDTChamber* chamber{nullptr};
486  if (getChamber(idHash, chamber).isSuccess()) return chamber->getName();
487  return convertChamberName(id_helper.stationName(id), id_helper.stationEta(id), id_helper.stationPhi(id), "MDT");
488 }

◆ getChamberName() [2/2]

std::string MdtRawDataMonAlg::getChamberName ( const Muon::MdtPrepData *  hit) const
private

Definition at line 479 of file MDTRawDataUtilsRun3.cxx.

479 { return getChamberName(hit->identify()); }

◆ GetEventInfo()

SG::ReadHandle< xAOD::EventInfo > AthMonitorAlgorithm::GetEventInfo ( const EventContext &  ctx) const
inherited

Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)

Parameters
ctxEventContext for the event
Returns
a SG::ReadHandle<xAOD::EventInfo>

Definition at line 107 of file AthMonitorAlgorithm.cxx.

107  {
108  return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
109 }

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( const std::string &  name) const
inherited

Get a specific monitoring tool from the tool handle array.

Finds a specific GenericMonitoringTool instance from the list of monitoring tools (a ToolHandleArray). Throws a FATAL warning if the object found is empty.

Parameters
namestring name of the desired tool
Returns
reference to the desired monitoring tool

Definition at line 164 of file AthMonitorAlgorithm.cxx.

164  {
165  // get the pointer to the tool, and check that it exists
166  auto idx = m_toolLookupMap.find(name);
167  if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
168  return m_tools[idx->second];
169  }
170  else {
171  if (!isInitialized()) {
172  ATH_MSG_FATAL(
173  "It seems that the AthMonitorAlgorithm::initialize was not called "
174  "in derived class initialize method");
175  } else {
176  std::string available = std::accumulate(
177  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
178  [](const std::string& s, auto h) { return s + "," + h.first; });
179  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
180  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
181  << "your python configuration and c++ filling code. Note: your available groups are {"
182  << available << "}.");
183  }
184  }
185  return m_dummy;
186 }

◆ GetTimingInfo()

StatusCode MdtRawDataMonAlg::GetTimingInfo ( )
private

◆ getTrigDecisionTool()

const ToolHandle< Trig::TrigDecisionTool > & AthMonitorAlgorithm::getTrigDecisionTool ( ) const
inherited

Get the trigger decision tool member.

The trigger decision tool is used to check whether a specific trigger is passed by an event.

Returns
m_trigDecTool

Definition at line 189 of file AthMonitorAlgorithm.cxx.

189  {
190  return m_trigDecTool;
191 }

◆ GetTubeMax()

int MdtRawDataMonAlg::GetTubeMax ( const Identifier &  digcoll_id,
std::string_view  hardware_name 
)
private

Definition at line 423 of file MDTRawDataUtilsRun3.cxx.

423  {
424  int tubeMax(0);
425  if (hardware_name.substr(0, 4) == "BIS8") { // Why does mdtIdHelper get this one wrong?
426  tubeMax = 16 * 3;
427  } else if (hardware_name.substr(0, 4) == "BIR5") {
428  // tubeMax = 21*4 + 24*4;
429  tubeMax = 24 * 4 + 24 * 4;
430  } else if (hardware_name.substr(0, 4) == "BIR2" || hardware_name.substr(0, 4) == "BIR4") {
431  // tubeMax = 27*4 + 30*4;
432  tubeMax = 30 * 4 + 30 * 4;
433  } else if (hardware_name.substr(0, 4) == "BIR3") {
434  tubeMax = 36 * 4 + 36 * 4;
435  } else if (hardware_name.substr(0, 4) == "BIR1") {
436  // tubeMax = 24*4 + 30*4;
437  tubeMax = 30 * 4 + 30 * 4;
438  } else if (hardware_name.substr(0, 4) == "BMS4" || hardware_name.substr(0, 4) == "BMS6") {
439  // tubeMax = 40*3 + 48*3;
440  tubeMax = 48 * 3 + 48 * 3;
441  } else if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") {
442  tubeMax = 48 * 3 + 48 * 3;
443  } else if (hardware_name.substr(0, 3) == "BME") {
444  tubeMax = 546;
445  } else {
446  int numtubes = m_idHelperSvc->mdtIdHelper().tubeMax(digcoll_id);
447  int numlayers = m_idHelperSvc->mdtIdHelper().tubeLayerMax(digcoll_id);
448  int numML = m_idHelperSvc->mdtIdHelper().numberOfMultilayers(digcoll_id);
449  tubeMax = numtubes * numlayers * numML;
450  }
451  return tubeMax;
452 }

◆ handleEvent_effCalc_fillVects()

StatusCode MdtRawDataMonAlg::handleEvent_effCalc_fillVects ( const Trk::SegmentCollection *  segms,
MDTSegmentHistogramStruct(&)  vects[4][4][16] 
) const
private

Definition at line 928 of file MdtRawDataMonAlg.cxx.

929  {
930  std::string type = "MDT";
931  const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
932  std::set<monAlg::TubeTraversedBySegment, monAlg::TubeTraversedBySegment_cmp> store_effTubes;
933  std::set<Identifier> store_ROTs;
934 
935  // MuonDetectorManager from the conditions store
936 
937  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
938  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
939  if (!MuonDetMgr) {
940  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
941  return StatusCode::FAILURE;
942  }
943 
944  // LOOP OVER SEGMENTS
945  for (const Trk::Segment* trk_seg : *segms) {
946  const Muon::MuonSegment* segment = dynamic_cast<const Muon::MuonSegment*>(trk_seg);
947  if (!segment) {
948  ATH_MSG_DEBUG("no pointer to segment!!!");
949  break;
950  }
951  if (segment->numberOfContainedROTs() < std::max(0lu, m_nb_hits.value()) ||
952  segment->fitQuality()->chiSquared() / segment->fitQuality()->doubleNumberDoF() > m_chi2_cut) {
953  continue;
954  }
955 
956  std::vector<Identifier> ROTs_chamber;
957  std::vector<int> ROTs_tube;
958  std::vector<int> ROTs_L;
959  std::vector<int> ROTs_ML;
960  for (unsigned int irot = 0; irot < segment->numberOfContainedROTs(); irot++) {
961  const Trk::RIO_OnTrack* rot = segment->rioOnTrack(irot);
962  const Muon::MdtDriftCircleOnTrack* mrot = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(rot);
963  if (!mrot) continue;
964  Identifier tmpid = rot->identify();
965  // This information needs to be stored fully for each segment (for calculations below), so deal with these duplicates later
966  // (otherwise we may not check a traversed ML for a differently pointing overlapping segment, for example)
967 
968  IdentifierHash idHash{0};
969  MDTChamber* chamber = nullptr;
970  id_helper.get_module_hash(tmpid, idHash);
971  ATH_CHECK(getChamber(idHash, chamber));
972  const std::string& chambername = chamber->getName();
973  float adc = mrot->prepRawData()->adc();
974 
975  if (m_idHelperSvc->hasHPTDC(tmpid)) adc /= m_adcScale;
976 
977  if (store_ROTs.count(tmpid)) { continue; }
978  store_ROTs.insert(tmpid);
979 
980  double tdc = mrot->prepRawData()->tdc() * 25.0 / 32.0;
981  // Note: the BMG is digitized with 200ps which is not same as other MDT chambers with 25/32=781.25ps
982  if (m_idHelperSvc->hasHPTDC(tmpid)) tdc = mrot->prepRawData()->tdc() * 0.2;
983  int iregion = chamber->GetRegionEnum();
984  int ilayer = chamber->GetLayerEnum();
985  int statphi = chamber->GetStationPhi();
986 
987  auto& thisVects = vects[iregion][ilayer][statphi];
988  thisVects.adc_segs_mon.push_back(adc);
989 
990  if (adc > m_ADCCut) { // This is somewhat redundant because this is usual cut for segment-reconstruction, but that's OK
991 
992  thisVects.tdc_segs_mon.push_back(tdc);
993 
994  int binx = chamber->GetMDTHitsPerChamber_IMO_BinX();
995  if (iregion < 2)
996  binx = binx - 9;
997  else
998  binx = binx - 7;
999  int biny = chamber->GetMDTHitsPerChamber_IMO_BinY();
1000  thisVects.x_segs_mon.push_back(binx);
1001  thisVects.y_segs_mon.push_back(biny - 1);
1002 
1003  } // adc cut
1004 
1005  int mdtMultLayer = m_idHelperSvc->mdtIdHelper().multilayer(tmpid);
1006  auto adc_perch = Monitored::Scalar<float>("adc_segs_perch_" + chambername, adc);
1007  auto adc_ml1 = Monitored::Scalar<int>("adc_ml1", (int)(mdtMultLayer == 1));
1008  auto adc_ml2 = Monitored::Scalar<int>("adc_ml2", (int)(mdtMultLayer == 2));
1009 
1010  std::string monPerCh = "MdtMonPerChamber";
1011  if (iregion == 0)
1012  monPerCh += "BA";
1013  else if (iregion == 1)
1014  monPerCh += "BC";
1015  else if (iregion == 2)
1016  monPerCh += "EA";
1017  else if (iregion == 3)
1018  monPerCh += "EC";
1019 
1020  ROTs_chamber.push_back(tmpid);
1021  ROTs_ML.push_back(mdtMultLayer);
1022  ROTs_tube.push_back(m_idHelperSvc->mdtIdHelper().tube(tmpid));
1023  ROTs_L.push_back(m_idHelperSvc->mdtIdHelper().tubeLayer(tmpid));
1024 
1025 
1026  fill(monPerCh, adc_perch, adc_ml1, adc_ml2);
1027  }
1028  // Finished gathering hits used in segment
1029 
1030  if (m_doChamberHists) {
1031  // Find unique chambers (since above we stored one chamber for every tube)
1032  // Also store the MLs affected by the ROTs, since we don't necessarily want to look for traversed tubes in entire chamber
1033  std::vector<Identifier> unique_chambers;
1034  std::vector<std::vector<int>> unique_chambers_ML;
1035 
1036  for (unsigned i = 0; i < ROTs_chamber.size(); i++) {
1037  bool isUnique = true;
1038  for (unsigned j = 0; j < unique_chambers.size(); j++) {
1039  if (getChamberName(ROTs_chamber.at(i)) == getChamberName(unique_chambers.at(j))) {
1040  isUnique = false;
1041  if (!AinB(ROTs_ML.at(i), unique_chambers_ML.at(j))) unique_chambers_ML.at(j).push_back(ROTs_ML.at(i));
1042  break;
1043  }
1044  }
1045  if (isUnique) {
1046  unique_chambers.push_back(ROTs_chamber.at(i));
1047  std::vector<int> tmp_ML;
1048  tmp_ML.push_back(ROTs_ML.at(i));
1049  unique_chambers_ML.push_back(tmp_ML);
1050  }
1051  }
1052  // Done finding unique chambers
1053  // Loop over the unique chambers
1054  // Here we store the tubes in each chamber that were traversed by the segment
1055  std::vector<Identifier> traversed_station_id;
1056  std::vector<int> traversed_tube;
1057  std::vector<int> traversed_L;
1058  std::vector<int> traversed_ML;
1059 
1060  for (const Identifier& station_id : unique_chambers) {
1061  const std::string hardware_name = getChamberName(station_id);
1062  // SEGMENT track
1063  const MuonGM::MdtReadoutElement* detEl = MuonDetMgr->getMdtReadoutElement(station_id);
1064  const Amg::Transform3D& gToStation = detEl->GlobalToAmdbLRSTransform();
1065  const Amg::Vector3D segPosL = gToStation * segment->globalPosition();
1066  const Amg::Vector3D segDirL = gToStation.linear() * segment->globalDirection();
1067  MuonCalib::MTStraightLine segment_track =
1068  MuonCalib::MTStraightLine(segPosL, segDirL, Amg::Vector3D(0, 0, 0), Amg::Vector3D(0, 0, 0));
1069 
1070  // Loop over tubes in chamber, find those along segment
1071  for (int ML : {1, 2}) {
1072 
1073  Identifier newId = id_helper.channelID(station_id, ML, 1, 1);
1074  const MuonGM::MdtReadoutElement* MdtRoEl = MuonDetMgr->getMdtReadoutElement(newId);
1075  int tubeMax = cachedTubeMax(newId);
1076  int tubeLayerMax = cachedTubeLayerMax(newId);
1077  CorrectTubeMax(hardware_name, tubeMax);
1078  CorrectLayerMax(hardware_name, tubeLayerMax);
1079 
1080  int tubeMin = id_helper.tubeMin(newId);
1081  int tubeLayerMin = id_helper.tubeLayerMin(newId);
1082  for (int i_tube = tubeMin; i_tube <= tubeMax; ++i_tube) {
1083  for (int i_layer = tubeLayerMin; i_layer <= tubeLayerMax; ++i_layer) {
1084  Identifier tubeId = id_helper.channelID(newId, ML, i_layer, i_tube);
1085 
1086  if (m_BMGpresent && m_idHelperSvc->mdtIdHelper().stationName(newId) == m_BMGid) {
1087  std::map<Identifier, std::set<Identifier>>::const_iterator myIt = m_DeadChannels.find(MdtRoEl->identify());
1088  if (myIt != m_DeadChannels.end()) {
1089  if (myIt->second.count(tubeId)) {
1090  ATH_MSG_DEBUG("Skipping tube with identifier " << m_idHelperSvc->toString(tubeId));
1091  continue;
1092  }
1093  }
1094  }
1095 
1096  Amg::Vector3D TubePos = MdtRoEl->GlobalToAmdbLRSCoords(MdtRoEl->tubePos(tubeId));
1097  Amg::Vector3D tube_position = Amg::Vector3D(TubePos.x(), TubePos.y(), TubePos.z());
1098  static const Amg::Vector3D tube_direction{1, 0, 0};
1099  MuonCalib::MTStraightLine tube_track =
1100  MuonCalib::MTStraightLine(tube_position, tube_direction, Amg::Vector3D(0, 0, 0), Amg::Vector3D(0, 0, 0));
1101  double distance = std::abs(segment_track.signDistFrom(tube_track));
1102 
1103  if (distance < (MdtRoEl->innerTubeRadius())) {
1104  traversed_tube.push_back(i_tube);
1105  traversed_L.push_back(i_layer);
1106  traversed_ML.push_back(ML);
1107  traversed_station_id.push_back(station_id);
1108  }
1109 
1110  }
1111  }
1112  }
1113  }
1114 
1115  // Done looping over the unqiue chambers
1116 
1117  // Loop over traversed tubes that were stored above
1118  // Here we fill the DRvsDT/DRvsSegD histos, as well is unique hits and traversed tubes to calculate efficiencies
1119  if (traversed_tube.size() < 20) { // quality cut here -- 20 traversed tubes is ridiculous and generates low efficiencies (these
1120  // are due to non-pointing segments)
1121 
1122  for (unsigned k = 0; k < traversed_tube.size(); k++) {
1123 
1124  std::string hardware_name = getChamberName(traversed_station_id.at(k));
1125 
1126  // GET HISTS
1127  IdentifierHash idHash{0};
1128  id_helper.get_module_hash(traversed_station_id.at(k), idHash);
1129 
1130  MDTChamber* chamber{nullptr};
1131  ATH_CHECK(getChamber(idHash, chamber));
1132 
1133  bool hit_flag = false;
1134  for (unsigned j = 0; j < ROTs_tube.size(); j++) {
1135  if ((getChamberName(ROTs_chamber.at(j)) == hardware_name) && (traversed_tube.at(k) == ROTs_tube.at(j)) &&
1136  (traversed_L.at(k) == ROTs_L.at(j)) &&
1137  (traversed_ML.at(k) == ROTs_ML.at(j))) { // found traversed tube with hit used in segment
1138  hit_flag = true;
1139  break;
1140  }
1141  }
1142 
1143  const Identifier& trav_id = traversed_station_id.at(k);
1144  Identifier newId = id_helper.channelID(trav_id, traversed_ML.at(k), 1, 1);
1145 
1146 
1147  int tubeLayerMax = cachedTubeLayerMax(newId);
1148  id_helper.get_module_hash(newId, idHash);
1149  CorrectLayerMax(hardware_name, tubeLayerMax); // ChamberTubeNumberCorrection handles the tubeMax problem
1150 
1151 
1152  int mdtlayer = ((traversed_L.at(k) - 1) + (traversed_ML.at(k) - 1) * tubeLayerMax);
1153  int ibin = traversed_tube.at(k) + mdtlayer * cachedTubeMax(newId);
1154 
1155 
1156  ChamberTubeNumberCorrection(ibin, hardware_name, traversed_tube.at(k), mdtlayer);
1157  // Store info for eff calc
1158  // (Here we make sure we are removing duplicates from overlapping segments by using sets)
1159  std::set<monAlg::TubeTraversedBySegment, monAlg::TubeTraversedBySegment_cmp>::iterator it;
1160  monAlg::TubeTraversedBySegment tmp_effTube = monAlg::TubeTraversedBySegment(hardware_name, ibin, hit_flag, idHash);
1161  monAlg::TubeTraversedBySegment tmp_effTube_Hit = monAlg::TubeTraversedBySegment(hardware_name, ibin, true, idHash);
1162  monAlg::TubeTraversedBySegment tmp_effTube_noHit = monAlg::TubeTraversedBySegment(hardware_name, ibin, false, idHash);
1163  it = store_effTubes.find(tmp_effTube_Hit);
1164  if (hit_flag || (it == store_effTubes.end()))
1165  store_effTubes.insert(tmp_effTube); // Insert if w/hit, but if w/o hit then only insert if no already stored w/ h
1166 
1167  it = store_effTubes.find(tmp_effTube_noHit);
1168  if (hit_flag && (it != store_effTubes.end()))
1169  store_effTubes.erase(it); // If w/ hit, and the same tube is stored w/o hit, remove duplicate w/o hit
1170  }
1171  }
1172  // Done looping over traversed tubes
1173 
1174  } // m_doChamberHists
1175  }
1176 
1177  // Fill effentries/effcounts hists for efficiency calculation
1178  if (m_doChamberHists) { // Don't perform this block if not doing chamber by chamber hists
1179  for (const monAlg::TubeTraversedBySegment& it : store_effTubes) {
1180  // GET HISTS
1181  MDTChamber* chamber{nullptr};
1182  ATH_CHECK(getChamber(it.idHash, chamber));
1183  int tubebin = it.tubeBin;
1184 
1185  int iregion = chamber->GetRegionEnum();
1186  std::string monPerCh = "MdtMonPerChamber";
1187  if (iregion == 0) monPerCh += "BA";
1188  if (iregion == 1) monPerCh += "BC";
1189  if (iregion == 2) monPerCh += "EA";
1190  if (iregion == 3) monPerCh += "EC";
1191 
1192  std::string chambername = chamber->getName();
1193  auto tube_perch_segs = Monitored::Scalar<int>("tube_perch_segs_" + chambername, tubebin);
1194  auto hitcut = Monitored::Scalar<int>("hitcut", (int)(it.isHit));
1195 
1196  fill(monPerCh, tube_perch_segs, hitcut);
1197  }
1198  }
1199  return StatusCode::SUCCESS;
1200 
1201 }

◆ initDeadChannels()

void MdtRawDataMonAlg::initDeadChannels ( const MuonGM::MdtReadoutElement *  mydetEl)
private

Definition at line 1236 of file MdtRawDataMonAlg.cxx.

1236  {
1237  PVConstLink cv = mydetEl->getMaterialGeom(); // it is "Multilayer"
1238  int nGrandchildren = cv->getNChildVols();
1239  if (nGrandchildren <= 0) return;
1240 
1241  Identifier detElId = mydetEl->identify();
1242 
1243  std::set<Identifier>& deadTubes = m_DeadChannels[detElId];
1244 
1245  for (int layer = 1; layer <= mydetEl->getNLayers(); ++layer) {
1246  for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); ++tube) {
1247  bool tubefound = false;
1248  for (unsigned int kk = 0; kk < cv->getNChildVols(); ++kk) {
1249  int tubegeo = cv->getIdOfChildVol(kk) % maxNTubesPerLayer;
1250  int layergeo = (cv->getIdOfChildVol(kk) - tubegeo) / maxNTubesPerLayer;
1251  if (tubegeo == tube && layergeo == layer) {
1252  tubefound = true;
1253  break;
1254  }
1255  if (layergeo > layer) break; // don't loop any longer if you cannot find tube anyway anymore
1256  }
1257  if (!tubefound) {
1258  Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(detElId, mydetEl->getMultilayer(), layer, tube);
1259  deadTubes.insert(deadTubeId);
1260  ATH_MSG_VERBOSE("adding dead tube " << m_idHelperSvc->toString(deadTubeId));
1261  }
1262  }
1263  }
1264 }

◆ initialize()

StatusCode MdtRawDataMonAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 131 of file MdtRawDataMonAlg.cxx.

133 {
134  // init message stream
135  ATH_MSG_DEBUG("initialize MdtRawDataMonAlg");
136 
137  ATH_MSG_DEBUG("******************");
138  ATH_MSG_DEBUG("doMdtESD: " << m_doMdtESD);
139  ATH_MSG_DEBUG("******************");
140 
141  // MuonDetectorManager from the conditions store
142  ATH_CHECK(m_DetectorManagerKey.initialize());
143  ATH_CHECK(detStore()->retrieve(m_detMgr));
144 
145  ATH_CHECK(m_idHelperSvc.retrieve());
146 
147  if (m_maskNoisyTubes)
148  m_masked_tubes = std::make_unique<MDTNoisyTubes>();
149  else
150  m_masked_tubes = std::make_unique<MDTNoisyTubes>(false);
151  mdtchamberId();
152 
153  ATH_CHECK(m_l1RoiKey.initialize(SG::AllowEmpty));
154  ATH_CHECK(m_muonKey.initialize());
155  ATH_CHECK(m_segm_type.initialize());
156  ATH_CHECK(m_key_mdt.initialize());
157  ATH_CHECK(m_key_rpc.initialize());
158  ATH_CHECK(m_eventInfo.initialize());
159  ATH_CHECK(m_muon_type.initialize());
160  m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
161  if (m_BMGid != -1) {
162  ATH_MSG_DEBUG("Processing configuration for layouts with BMG chambers.");
163  m_BMGpresent = true;
164  // MuonDetectorManager from the Detector Store
165  const MuonGM::MuonDetectorManager* MuonDetMgrDS{nullptr};
166  ATH_CHECK(detStore()->retrieve(MuonDetMgrDS));
167 
168  for (int phi = 6; phi < 8; phi++) { // phi sectors
169  for (int eta = 1; eta < 4; eta++) { // eta sectors
170  for (int side = -1; side < 2; side += 2) { // side
171  if (!MuonDetMgrDS->getMuonStation("BMG", side * eta, phi)) continue;
172  for (int roe = 1; roe <= (MuonDetMgrDS->getMuonStation("BMG", side * eta, phi))->nMuonReadoutElements();
173  roe++) { // iterate on readout elemets
174  const MuonGM::MdtReadoutElement* mdtRE = dynamic_cast<const MuonGM::MdtReadoutElement*>(
175  (MuonDetMgrDS->getMuonStation("BMG", side * eta, phi))->getMuonReadoutElement(roe)); // has to be an MDT
176  if (mdtRE) initDeadChannels(mdtRE);
177  }
178  }
179  }
180  }
181  }
182 
183  /* It seems as if a bunch of histograms are created below on the heap
184  * Then these are filled in the binMdtFooBar methods
185  * Later these are passed onto relevant methods of MDTChamber where internals are filled
186  * The original histograms are transient and not needed past initialize here
187  * The logic is a little too convoluted but left as is
188  */
189  unsigned int counter{0};
190  std::string s{""}, xAxis{""};
191 
192  // Create Inner/Middle/Outer/Extra histograms per BA/BC/EA/EC
193  std::vector<std::string> ecap{"BA", "BC", "EA", "EC"};
194  std::vector<std::string> layer{"Inner", "Middle", "Outer", "Extra"};
195  std::vector<std::unique_ptr<TH2F>> mdtHitsPerMultiLayerLumi;
196  mdtHitsPerMultiLayerLumi.reserve(ecap.size() * layer.size());
197 
198  for (const auto& iecap : ecap) {
199  for (const auto& ilayer : layer) {
200  s = "NumberOfHitsIn" + iecap + ilayer + "PerMultiLayer_ADCCut";
201  mdtHitsPerMultiLayerLumi.push_back(std::make_unique<TH2F>(s.c_str(), s.c_str(), 1, 0, 1, 1, 0, 1));
202  xAxis = iecap.substr(0, 1) + ilayer.substr(0, 1) + iecap.substr(1, 1);
203  ATH_CHECK(binMdtRegional(mdtHitsPerMultiLayerLumi[counter].get(), xAxis));
204  counter++;
205  } // end of iecap
206  } // end of ilayer
207  counter = 0;
208 
209  // Create Barrel/EndCap histrograms here
210  std::vector<std::string> mdtHitsBE{"Barrel", "EndCap"};
211  std::vector<std::unique_ptr<TH2F>> mdtHitsPerChamberIMOLumi;
212  mdtHitsPerChamberIMOLumi.reserve(mdtHitsBE.size());
213 
214  for (const auto& imdt : mdtHitsBE) {
215  s = "NumberOfHits" + imdt;
216  mdtHitsPerChamberIMOLumi.push_back(std::make_unique<TH2F>(s.c_str(), s.c_str(), 1, 0, 1, 1, 0, 1));
217  ATH_CHECK(binMdtGlobal(mdtHitsPerChamberIMOLumi[counter].get(), imdt.at(0)));
218  counter++;
219  } // end of imdt
220  counter = 0;
221 
222  // Create Inner/Middle/Outer histograms here
223  std::vector<std::unique_ptr<TH2F>> mdtHitsPerMLByLayer;
224  mdtHitsPerMLByLayer.reserve(layer.size() - 1);
225 
226  for (const auto& ilayer : layer) {
227  if (ilayer == "Extra") continue;
228  s = "NumberOfHitsInMDT" + ilayer + "_ADCCut";
229  mdtHitsPerMLByLayer.push_back(std::make_unique<TH2F>(s.c_str(), s.c_str(), 1, 0, 1, 1, 0, 1));
230  } // end of ilayer
231  ATH_CHECK(binMdtGlobal_byLayer(mdtHitsPerMLByLayer[0].get(), mdtHitsPerMLByLayer[1].get(), mdtHitsPerMLByLayer[2].get()));
232 
233  for (std::vector<Identifier>::const_iterator itr = m_chambersId.begin(); itr != m_chambersId.end(); ++itr, ++counter) {
234  std::string hardware_name =
235  convertChamberName(m_idHelperSvc->mdtIdHelper().stationName(*itr), m_idHelperSvc->mdtIdHelper().stationEta(*itr),
236  m_idHelperSvc->mdtIdHelper().stationPhi(*itr), "MDT");
237  // Skip Chambers That Do NOT Exist
238  if (hardware_name == "BML6A13" || hardware_name == "BML6C13") continue;
239  std::unique_ptr<MDTChamber>& chamber = m_hist_hash_list[m_chambersIdHash.at(counter)];
240  chamber = std::make_unique<MDTChamber>(hardware_name);
241 
242  chamber->SetMDTHitsPerChamber_IMO_Bin(mdtHitsPerChamberIMOLumi[chamber->GetBarrelEndcapEnum()].get());
243  chamber->SetMDTHitsPerML_byLayer_Bins(
244  mdtHitsPerMultiLayerLumi[chamber->GetRegionEnum() * layer.size() + chamber->GetLayerEnum()].get(),
245  mdtHitsPerMLByLayer[(chamber->GetLayerEnum() < 3 ? chamber->GetLayerEnum() : 0)].get());
246 
247  m_tubesperchamber_map[hardware_name] = GetTubeMax(*itr, hardware_name); // total number of tubes in chamber
248  }
249 
250  ATH_MSG_DEBUG(" end of initialize ");
251  return AthMonitorAlgorithm::initialize();
252 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isATLASReady()

bool MdtRawDataMonAlg::isATLASReady ( ) const
inlineprivate

Definition at line 190 of file MdtRawDataMonAlg.h.

190 { return m_atlas_ready; }

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ mdtchamberId()

void MdtRawDataMonAlg::mdtchamberId ( )
private

Definition at line 384 of file MDTRawDataUtilsRun3.cxx.

384  {
385  ATH_MSG_DEBUG("in MDT ChambersIDvector");
386 
387  std::vector<Identifier>::const_iterator idfirst = m_idHelperSvc->mdtIdHelper().module_begin();
388  std::vector<Identifier>::const_iterator idlast = m_idHelperSvc->mdtIdHelper().module_end();
389 
390  IdContext mdtModuleContext = m_idHelperSvc->mdtIdHelper().module_context();
391  Identifier Id;
392  IdentifierHash Idhash;
393  for (std::vector<Identifier>::const_iterator i = idfirst; i != idlast; ++i) {
394  Id = *i;
395  int gethash_code = m_idHelperSvc->mdtIdHelper().get_hash(Id, Idhash, &mdtModuleContext);
396  m_chambersId.push_back(Id);
397  m_chambersIdHash.push_back(Idhash);
398 
399  std::string extid = m_idHelperSvc->mdtIdHelper().show_to_string(Id);
400  ATH_MSG_DEBUG("Adding the chamber Identifier: " << extid);
401  if (gethash_code == 0) {
402  ATH_MSG_VERBOSE(" its hash Id is " << Idhash);
403  } else {
404  ATH_MSG_VERBOSE(" hash Id NOT computed " << Idhash);
405  }
406  }
407  m_hist_hash_list.resize(m_chambersIdHash.size());
408 }

◆ mezzmdt()

int MdtRawDataMonAlg::mezzmdt ( const Identifier &  id) const
private

Definition at line 411 of file MDTRawDataUtilsRun3.cxx.

411  {
412  int TotmezzTubes = 8;
413  if (cachedTubeLayerMax(digcoll_id) == 4) TotmezzTubes = 6;
414  int Imezz = (int)((m_idHelperSvc->mdtIdHelper().tube(digcoll_id) - 1) / TotmezzTubes) +
415  (int)((m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id) - 1) * ((cachedTubeMax(digcoll_id)) / TotmezzTubes));
416 
417  return Imezz;
418 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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 AthMonitorAlgorithm::parseList ( const std::string &  line,
std::vector< std::string > &  result 
) const
virtualinherited

Parse a string into a vector.

The input string is a single long string of all of the trigger names. It parses this string and turns it into a vector, where each element is one trigger or trigger category.

Parameters
lineThe input string.
resultThe parsed output vector of strings.
Returns
StatusCode

Definition at line 336 of file AthMonitorAlgorithm.cxx.

336  {
337  std::string item;
338  std::stringstream ss(line);
339 
340  ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
341 
342  while ( std::getline(ss, item, ',') ) {
343  std::stringstream iss(item); // remove whitespace
344  iss >> item;
345  result.push_back(item);
346  }
347 
348  return StatusCode::SUCCESS;
349 }

◆ 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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ setIsATLASReady()

void MdtRawDataMonAlg::setIsATLASReady ( )
private

Definition at line 470 of file MDTRawDataUtilsRun3.cxx.

470  {
471  bool filterresult(true);
472  if (!m_DQFilterTools.empty()) {
473  ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
474  for (; filterresult && (ifilter != filterend); ++ifilter) { filterresult = (filterresult && (*ifilter)->accept()); }
475  }
476  m_atlas_ready = filterresult;
477 }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ trigChainsArePassed()

bool AthMonitorAlgorithm::trigChainsArePassed ( const std::vector< std::string > &  vTrigNames) const
inherited

Check whether triggers are passed.

For the event, use the trigger decision tool to check that at least one of the triggers listed in the supplied vector is passed.

Parameters
vTrigNamesList of trigger names.
Returns
If empty input, default to true. If at least one trigger is specified, returns whether at least one trigger was passed.

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195 
196 
197  // If no triggers were given, return true.
198  if (vTrigNames.empty()) return true;
199 
200 
201  // Trigger: Check if this Algorithm is being run as an Express Stream job.
202  // Events are entering the express stream are chosen randomly, and by chain,
203  // Hence an additional check should be aplied to see if the chain(s)
204  // monitored here are responsible for the event being selected for
205  // the express stream.
206 
207  const auto group = m_trigDecTool->getChainGroup(vTrigNames);
208  if (m_enforceExpressTriggers){
209  const auto passedBits = m_trigDecTool->isPassedBits(group);
210  bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
211  if(!expressPass) {
212  return false;
213  }
214  }
215 
216  // monitor the event if any of the chains in the chain group passes the event.
217  return group->isPassed();
218 
219 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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  }

Member Data Documentation

◆ m_ADCCut

Gaudi::Property<size_t> MdtRawDataMonAlg::m_ADCCut {this, "ADCCut", 50}
private

Definition at line 174 of file MdtRawDataMonAlg.h.

◆ m_adcScale

Gaudi::Property<size_t> MdtRawDataMonAlg::m_adcScale {this, "ADCScale", 1}
private

Definition at line 182 of file MdtRawDataMonAlg.h.

◆ m_atlas_ready

bool MdtRawDataMonAlg::m_atlas_ready {false}
private

Definition at line 189 of file MdtRawDataMonAlg.h.

◆ m_BMGid

int MdtRawDataMonAlg::m_BMGid {-1}
private

Definition at line 185 of file MdtRawDataMonAlg.h.

◆ m_BMGpresent

bool MdtRawDataMonAlg::m_BMGpresent {false}
private

Definition at line 184 of file MdtRawDataMonAlg.h.

◆ m_chambersId

std::vector<Identifier> MdtRawDataMonAlg::m_chambersId
private

Definition at line 153 of file MdtRawDataMonAlg.h.

◆ m_chambersIdHash

std::vector<IdentifierHash> MdtRawDataMonAlg::m_chambersIdHash
private

Definition at line 154 of file MdtRawDataMonAlg.h.

◆ m_chi2_cut

Gaudi::Property<bool> MdtRawDataMonAlg::m_chi2_cut {this, "Eff_chi2Cut", 10}
private

Definition at line 176 of file MdtRawDataMonAlg.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_dataTypeStr {this,"DataType","userDefined"}
protectedinherited

DataType string pulled from the job option and converted to enum.

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_DeadChannels

std::map<Identifier, std::set<Identifier> > MdtRawDataMonAlg::m_DeadChannels {}
private

Definition at line 186 of file MdtRawDataMonAlg.h.

◆ m_defaultLBDuration

Gaudi::Property<float> AthMonitorAlgorithm::m_defaultLBDuration {this,"DefaultLBDuration",60.}
protectedinherited

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

Gaudi::Property<int> AthMonitorAlgorithm::m_detailLevel {this,"DetailLevel",0}
protectedinherited

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_DetectorManagerKey

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

Definition at line 114 of file MdtRawDataMonAlg.h.

◆ m_detMgr

const MuonGM::MuonDetectorManager* MdtRawDataMonAlg::m_detMgr {nullptr}
private

Definition at line 195 of file MdtRawDataMonAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_do_mdtChamberHits

Gaudi::Property<bool> MdtRawDataMonAlg::m_do_mdtChamberHits {this, "do_mdtChamberHits", true}
private

Definition at line 177 of file MdtRawDataMonAlg.h.

◆ m_do_mdtchamberstatphislice

Gaudi::Property<bool> MdtRawDataMonAlg::m_do_mdtchamberstatphislice {this, "do_mdtchamberstatphislice", true}
private

Definition at line 179 of file MdtRawDataMonAlg.h.

◆ m_do_mdttdccut_sector

Gaudi::Property<bool> MdtRawDataMonAlg::m_do_mdttdccut_sector {this, "do_mdttdccut_sector", true}
private

Definition at line 178 of file MdtRawDataMonAlg.h.

◆ m_do_run3Geometry

Gaudi::Property<bool> MdtRawDataMonAlg::m_do_run3Geometry {this, "do_Run3Geometry", false}
private

Definition at line 180 of file MdtRawDataMonAlg.h.

◆ m_doChamberHists

Gaudi::Property<bool> MdtRawDataMonAlg::m_doChamberHists {this, "DoChamberHist", true}
private

Definition at line 172 of file MdtRawDataMonAlg.h.

◆ m_doMdtESD

Gaudi::Property<bool> MdtRawDataMonAlg::m_doMdtESD {this, "DoMdtEsd", false}
private

Definition at line 171 of file MdtRawDataMonAlg.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

Gaudi::Property<bool> AthMonitorAlgorithm::m_enforceExpressTriggers
privateinherited
Initial value:
{this,
"EnforceExpressTriggers", false,
"Requires that matched triggers made the event enter the express stream"}

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_environmentStr {this,"Environment","user"}
protectedinherited

Environment string pulled from the job option and converted to enum.

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> MdtRawDataMonAlg::m_eventInfo {this, "EventInfo", "EventInfo", "event info"}
private

Definition at line 162 of file MdtRawDataMonAlg.h.

◆ m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AthMonitorAlgorithm::m_EventInfoKey {this,"EventInfoKey","EventInfo"}
protectedinherited

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_fileKey

Gaudi::Property<std::string> AthMonitorAlgorithm::m_fileKey {this,"FileKey",""}
protectedinherited

Internal Athena name for file.

Definition at line 358 of file AthMonitorAlgorithm.h.

◆ m_firstEvent

std::atomic<int> MdtRawDataMonAlg::m_firstEvent {-1}
mutableprivate

Definition at line 187 of file MdtRawDataMonAlg.h.

◆ m_HighOccThreshold

Gaudi::Property<size_t> MdtRawDataMonAlg::m_HighOccThreshold {this, "nHits_NoiseThreshold", 16000}
private

Definition at line 181 of file MdtRawDataMonAlg.h.

◆ m_hist_hash_list

std::vector<std::unique_ptr<MDTChamber> > MdtRawDataMonAlg::m_hist_hash_list {}
private

Definition at line 165 of file MdtRawDataMonAlg.h.

◆ m_idHelperSvc

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

Definition at line 110 of file MdtRawDataMonAlg.h.

◆ m_key_mdt

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

Definition at line 158 of file MdtRawDataMonAlg.h.

◆ m_key_rpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> MdtRawDataMonAlg::m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
private

Definition at line 159 of file MdtRawDataMonAlg.h.

◆ m_l1RoiKey

SG::ReadHandleKey<xAOD::MuonRoIContainer> MdtRawDataMonAlg::m_l1RoiKey {this, "L1RoiKey", "LVL1MuonRoIs", "L1 muon ROIs"}
private

Definition at line 160 of file MdtRawDataMonAlg.h.

◆ m_lbDurationDataKey

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

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_lumiDataKey

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

Definition at line 343 of file AthMonitorAlgorithm.h.

◆ m_masked_tubes

std::unique_ptr<MDTNoisyTubes> MdtRawDataMonAlg::m_masked_tubes {nullptr}
private

Definition at line 108 of file MdtRawDataMonAlg.h.

◆ m_maskNoisyTubes

Gaudi::Property<bool> MdtRawDataMonAlg::m_maskNoisyTubes {this, "maskNoisyTubes", true}
private

Definition at line 173 of file MdtRawDataMonAlg.h.

◆ m_muon_type

SG::ReadHandleKey<xAOD::TrackParticleContainer> MdtRawDataMonAlg::m_muon_type {this, "Muon_type", "ExtrapolatedMuonTrackParticles", "extrapolated muons"}
private

Definition at line 151 of file MdtRawDataMonAlg.h.

◆ m_muonKey

SG::ReadHandleKey<xAOD::MuonContainer> MdtRawDataMonAlg::m_muonKey {this, "MuonKey", "Muons", "muons"}
private

Definition at line 161 of file MdtRawDataMonAlg.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> MdtRawDataMonAlg::m_muonSelectionTool
private

Definition at line 111 of file MdtRawDataMonAlg.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_nb_hits

Gaudi::Property<size_t> MdtRawDataMonAlg::m_nb_hits {this, "Eff_nHits", 5}
private

Definition at line 175 of file MdtRawDataMonAlg.h.

◆ m_segm_type

SG::ReadHandleKeyArray<Trk::SegmentCollection> MdtRawDataMonAlg::m_segm_type
private
Initial value:
{
this, "SegmentKey", {"TrkMuonSegments", "UnAssocMuonTrkSegments"}, "muon segments"}

Definition at line 149 of file MdtRawDataMonAlg.h.

◆ m_toolLookupMap

std::unordered_map<std::string, size_t> AthMonitorAlgorithm::m_toolLookupMap
privateinherited

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

ToolHandleArray<GenericMonitoringTool> AthMonitorAlgorithm::m_tools {this,"GMTools",{}}
protectedinherited

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

Gaudi::Property<std::string> AthMonitorAlgorithm::m_triggerChainString {this,"TriggerChain",""}
protectedinherited

Trigger chain string pulled from the job option and parsed into a vector.

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_tubesperchamber_map

std::map<std::string, int> MdtRawDataMonAlg::m_tubesperchamber_map
private

Definition at line 156 of file MdtRawDataMonAlg.h.

◆ m_useLumi

Gaudi::Property<bool> AthMonitorAlgorithm::m_useLumi {this,"EnableLumi",false}
protectedinherited

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ s_detectorElementMask

constexpr Identifier::value_type MdtRawDataMonAlg::s_detectorElementMask = 0xFFFFC00000000000
staticconstexprprivate

Definition at line 106 of file MdtRawDataMonAlg.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TH2::Fill
int Fill(double, double)
Definition: rootspy.cxx:382
MdtRawDataMonAlg::cachedTubeMax
int cachedTubeMax(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:1432
convertChamberName
std::string convertChamberName(int, int, int, const std::string &)
Definition: MuonDQA/MuonDQAUtils/src/MuonChamberNameConverter.cxx:10
MdtRawDataMonAlg::m_nb_hits
Gaudi::Property< size_t > m_nb_hits
Definition: MdtRawDataMonAlg.h:175
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:129
MdtRawDataMonAlg::m_key_rpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc
Definition: MdtRawDataMonAlg.h:159
MdtRawDataMonAlg::m_detMgr
const MuonGM::MuonDetectorManager * m_detMgr
Definition: MdtRawDataMonAlg.h:195
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
MDTOverviewHistogramStruct::tdc_mon_noiseBurst
std::vector< float > tdc_mon_noiseBurst
Definition: MdtRawDataMonAlg.cxx:79
max
#define max(a, b)
Definition: cfImp.cxx:41
MDTOverviewHistogramStruct::mdt_tube_perp_endcap
std::vector< float > mdt_tube_perp_endcap
Definition: MdtRawDataMonAlg.cxx:71
MdtRawDataMonAlg::m_firstEvent
std::atomic< int > m_firstEvent
Definition: MdtRawDataMonAlg.h:187
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
MDTOverviewHistogramStruct::mdt_tube_z_ovl
std::vector< float > mdt_tube_z_ovl
Definition: MdtRawDataMonAlg.cxx:65
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
Muon::MdtDriftCircleOnTrack::prepRawData
virtual const MdtPrepData * prepRawData() const override final
Returns the PrepRawData used to create this corrected measurement.
Definition: MdtDriftCircleOnTrack.h:257
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
MdtRawDataMonAlg::fillMDTHistograms
virtual StatusCode fillMDTHistograms(const Muon::MdtPrepData *) const
Definition: MdtRawDataMonAlg.cxx:854
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:188
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
MdtRawDataMonAlg::mdtchamberId
void mdtchamberId()
Definition: MDTRawDataUtilsRun3.cxx:384
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
calibdata.chamber
chamber
Definition: calibdata.py:32
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
MdtRawDataMonAlg::m_do_mdtchamberstatphislice
Gaudi::Property< bool > m_do_mdtchamberstatphislice
Definition: MdtRawDataMonAlg.h:179
MDTOverviewHistogramStruct
Definition: MdtRawDataMonAlg.cxx:57
MdtRawDataMonAlg::m_do_mdtChamberHits
Gaudi::Property< bool > m_do_mdtChamberHits
Definition: MdtRawDataMonAlg.h:177
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
MDTOverviewHistogramStruct::mdt_tube_y_endcap
std::vector< float > mdt_tube_y_endcap
Definition: MdtRawDataMonAlg.cxx:69
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
MuonGM::MuonReadoutElement::GlobalToAmdbLRSTransform
virtual Amg::Transform3D GlobalToAmdbLRSTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:153
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
skel.it
it
Definition: skel.GENtoEVGEN.py:423
MdtRawDataMonAlg::get_bin_for_LB_hist
int get_bin_for_LB_hist(int region, int layer, int phi, int eta, bool isBIM) const
Definition: MDTRawDataUtilsRun3.cxx:498
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
MdtHistCoder::encode
static uint16_t encode(const uint16_t regionIn, const uint16_t layerIn, const uint16_t phiIn, const uint16_t crate_regionIn, const uint16_t crateIn)
Definition: MdtHistCoder.h:19
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MdtRawDataMonAlg::fillMDTSegmentHistograms
virtual StatusCode fillMDTSegmentHistograms(const MDTSegmentHistogramStruct(&vects)[4][4][16]) const
Definition: MdtRawDataMonAlg.cxx:1203
MdtRawDataMonAlg::get_bin_for_LB_crate_hist
int get_bin_for_LB_crate_hist(int region, int layer, int phi, int eta, std::string_view chamber) const
Definition: MDTRawDataUtilsRun3.cxx:1158
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
MdtRawDataMonAlg::m_chi2_cut
Gaudi::Property< bool > m_chi2_cut
Definition: MdtRawDataMonAlg.h:176
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
MdtRawDataMonAlg::ChamberTubeNumberCorrection
static void ChamberTubeNumberCorrection(int &tubeNum, std::string_view hardware_name, int tubePos, int numLayers)
Definition: MDTRawDataUtilsRun3.cxx:267
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
cosmics
Definition: cosmics.py:1
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MuonIdHelper::stationName
int stationName(const Identifier &id) const
Definition: MuonIdHelper.cxx:804
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MDTOverviewHistogramStruct::tdc_mon
std::vector< float > tdc_mon
Definition: MdtRawDataMonAlg.cxx:75
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition: MdtPrepData.h:166
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
MdtRawDataMonAlg::fillMDTOverviewVects
virtual void fillMDTOverviewVects(const Muon::MdtPrepData *, bool &isNoiseBurstCandidate, MDTOverviewHistogramStruct &vects) const
Definition: MdtRawDataMonAlg.cxx:482
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
MdtRawDataMonAlg::m_tubesperchamber_map
std::map< std::string, int > m_tubesperchamber_map
Definition: MdtRawDataMonAlg.h:156
TRT::Hit::side
@ side
Definition: HitInfo.h:83
MdtRawDataMonAlg::binMdtRegional
virtual StatusCode binMdtRegional(TH2 *, std::string_view xAxis)
Definition: MDTRawDataUtilsRun3.cxx:79
MdtRawDataMonAlg::GetTubeMax
int GetTubeMax(const Identifier &digcoll_id, std::string_view hardware_name)
Definition: MDTRawDataUtilsRun3.cxx:423
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
MDTOverviewHistogramStruct::mdt_tube_perp_barrel
std::vector< float > mdt_tube_perp_barrel
Definition: MdtRawDataMonAlg.cxx:61
MDTOverviewHistogramStruct::tdc_mon_noiseBurst_adcCut
std::vector< float > tdc_mon_noiseBurst_adcCut
Definition: MdtRawDataMonAlg.cxx:82
MDTOverviewHistogramStruct::adc_mon
std::vector< float > adc_mon
Definition: MdtRawDataMonAlg.cxx:76
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
python.changerun.kk
list kk
Definition: changerun.py:41
MdtRawDataMonAlg::m_HighOccThreshold
Gaudi::Property< size_t > m_HighOccThreshold
Definition: MdtRawDataMonAlg.h:181
tubeMax
double tubeMax
Definition: MDT_ResponseTest.cxx:31
MDTOverviewHistogramStruct::mdt_tube_y_ovl
std::vector< float > mdt_tube_y_ovl
Definition: MdtRawDataMonAlg.cxx:64
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
skel.l2
l2
Definition: skel.GENtoEVGEN.py:426
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
MdtRawDataMonAlg::m_chambersIdHash
std::vector< IdentifierHash > m_chambersIdHash
Definition: MdtRawDataMonAlg.h:154
MdtRawDataMonAlg::getChamber
StatusCode getChamber(const IdentifierHash &id, MDTChamber *&chamber) const
Definition: MDTRawDataUtilsRun3.cxx:490
MDTChamber
Definition: MDTChamber.h:22
MuonGM::MuonReadoutElement::GlobalToAmdbLRSCoords
virtual Amg::Vector3D GlobalToAmdbLRSCoords(const Amg::Vector3D &x) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:149
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MdtRawDataMonAlg::m_do_mdttdccut_sector
Gaudi::Property< bool > m_do_mdttdccut_sector
Definition: MdtRawDataMonAlg.h:178
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:88
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
xAOD::numberOfTriggerEtaLayers
@ numberOfTriggerEtaLayers
layers with trigger eta hits [unit8_t].
Definition: TrackingPrimitives.h:292
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
sim_rttUpdate.user
def user
Definition: sim_rttUpdate.py:662
MDTOverviewHistogramStruct::mdt_tube_x_barrel
std::vector< float > mdt_tube_x_barrel
Definition: MdtRawDataMonAlg.cxx:58
lumiFormat.i
int i
Definition: lumiFormat.py:92
MDTOverviewHistogramStruct::mdt_tube_z_barrel
std::vector< float > mdt_tube_z_barrel
Definition: MdtRawDataMonAlg.cxx:60
MdtRawDataMonAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MdtRawDataMonAlg.h:114
MDTOverviewHistogramStruct::adc_mon_noiseBurst_notNoisy
std::vector< float > adc_mon_noiseBurst_notNoisy
Definition: MdtRawDataMonAlg.cxx:81
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
MDTOverviewHistogramStruct::adc_mon_nosel
std::vector< float > adc_mon_nosel
Definition: MdtRawDataMonAlg.cxx:73
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MdtRawDataMonAlg::m_doMdtESD
Gaudi::Property< bool > m_doMdtESD
Definition: MdtRawDataMonAlg.h:171
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:113
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::Segment
Definition: TrkEvent/TrkSegment/TrkSegment/Segment.h:56
MDTOverviewHistogramStruct::mdt_tube_x_ovl
std::vector< float > mdt_tube_x_ovl
Definition: MdtRawDataMonAlg.cxx:63
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
MdtIdHelper
Definition: MdtIdHelper.h:61
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
MuonGM::MdtReadoutElement::getMultilayer
int getMultilayer() const
Returns the multilayer represented by the readout element.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
MdtRawDataMonAlg::m_atlas_ready
bool m_atlas_ready
Definition: MdtRawDataMonAlg.h:189
MdtRawDataMonAlg::m_ADCCut
Gaudi::Property< size_t > m_ADCCut
Definition: MdtRawDataMonAlg.h:174
MdtRawDataMonAlg::m_hist_hash_list
std::vector< std::unique_ptr< MDTChamber > > m_hist_hash_list
Definition: MdtRawDataMonAlg.h:165
MdtRawDataMonAlg::m_muon_type
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muon_type
Definition: MdtRawDataMonAlg.h:151
MDTOverviewHistogramStruct::mdt_tube_perp_ovl
std::vector< float > mdt_tube_perp_ovl
Definition: MdtRawDataMonAlg.cxx:66
MdtRawDataMonAlg::cachedTubeLayerMax
int cachedTubeLayerMax(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:1436
MDTOverviewHistogramStruct::tdc_mon_adcCut
std::vector< float > tdc_mon_adcCut
Definition: MdtRawDataMonAlg.cxx:84
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
MdtRawDataMonAlg::m_muonKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey
Definition: MdtRawDataMonAlg.h:161
MdtIdHelper::tubeMin
static int tubeMin()
Definition: MdtIdHelper.cxx:768
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AthMonitorAlgorithm::DataType_t::cosmics
@ cosmics
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition: MuonIdHelper.cxx:814
lumiFormat.array
array
Definition: lumiFormat.py:98
Trk::MeasurementBase
Definition: MeasurementBase.h:58
MdtRawDataMonAlg::binMdtGlobal
virtual StatusCode binMdtGlobal(TH2 *, char ecap)
Definition: MDTRawDataUtilsRun3.cxx:28
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
MdtRawDataMonAlg::m_maskNoisyTubes
Gaudi::Property< bool > m_maskNoisyTubes
Definition: MdtRawDataMonAlg.h:173
AthMonitorAlgorithm::Environment_t::online
@ online
Muon::MdtPrepData::tdc
int tdc() const
Returns the TDC (typically range is 0 to 2500).
Definition: MdtPrepData.h:161
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:194
MdtRawDataMonAlg::m_DeadChannels
std::map< Identifier, std::set< Identifier > > m_DeadChannels
Definition: MdtRawDataMonAlg.h:186
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
MdtIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int multilayer, int tubeLayer, int tube) const
Definition: MdtIdHelper.cxx:659
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
MdtRawDataMonAlg::AinB
static bool AinB(int A, std::vector< int > &B)
Definition: MDTRawDataUtilsRun3.cxx:454
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
MuonCalib::MTStraightLine::signDistFrom
double signDistFrom(const MTStraightLine &h) const
get the signed distance of two lines (if both are parallel, dist>0)
Definition: MTStraightLine.cxx:89
MdtRawDataMonAlg::m_chambersId
std::vector< Identifier > m_chambersId
Definition: MdtRawDataMonAlg.h:153
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
MdtRawDataMonAlg::mezzmdt
int mezzmdt(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:411
MdtRawDataMonAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtRawDataMonAlg.h:110
MDTOverviewHistogramStruct::tdc_mon_nosel
std::vector< float > tdc_mon_nosel
Definition: MdtRawDataMonAlg.cxx:74
MdtRawDataMonAlg::m_adcScale
Gaudi::Property< size_t > m_adcScale
Definition: MdtRawDataMonAlg.h:182
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
HI::TowerBins::numLayers
constexpr unsigned int numLayers()
Definition: HIEventDefs.h:23
MuonIdHelper::stationEta
int stationEta(const Identifier &id) const
Definition: MuonIdHelper.cxx:809
item
Definition: ItemListSvc.h:43
MdtRawDataMonAlg::CorrectTubeMax
static void CorrectTubeMax(const std::string &hardware_name, int &numTubes)
Definition: MDTRawDataUtilsRun3.cxx:286
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::iPhi
@ iPhi
Definition: ParamDefs.h:53
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
MdtRawDataMonAlg::CorrectLayerMax
static void CorrectLayerMax(const std::string &hardware_name, int &numLayers)
Definition: MDTRawDataUtilsRun3.cxx:291
Trk::Track::measurementsOnTrack
const DataVector< const MeasurementBase > * measurementsOnTrack() const
return a pointer to a vector of MeasurementBase (NOT including any that come from outliers).
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:178
python.PyAthena.v
v
Definition: PyAthena.py:157
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
MdtRawDataMonAlg::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MdtRawDataMonAlg.h:162
MdtRawDataMonAlg::m_segm_type
SG::ReadHandleKeyArray< Trk::SegmentCollection > m_segm_type
Definition: MdtRawDataMonAlg.h:149
MDTOverviewHistogramStruct::mdt_tube_y_barrel
std::vector< float > mdt_tube_y_barrel
Definition: MdtRawDataMonAlg.cxx:59
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
h
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
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
MdtRawDataMonAlg::fillMDTSummaryHistograms
virtual StatusCode fillMDTSummaryHistograms(std::array< MDTSummaryHistogramStruct, 4096 > *vects, int lb) const
Definition: MdtRawDataMonAlg.cxx:739
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
MDTOverviewHistogramStruct::noiseBurst
std::vector< int > noiseBurst
Definition: MdtRawDataMonAlg.cxx:77
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
MuonCalib::MTStraightLine
Definition: MTStraightLine.h:16
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
MdtRawDataMonAlg::m_key_mdt
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt
Definition: MdtRawDataMonAlg.h:158
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
MDTChamber::getName
const std::string & getName() const
Definition: MDTChamber.h:67
MdtRawDataMonAlg::m_do_run3Geometry
Gaudi::Property< bool > m_do_run3Geometry
Definition: MdtRawDataMonAlg.h:180
MDTOverviewHistogramStruct::mdt_tube_z_endcap
std::vector< float > mdt_tube_z_endcap
Definition: MdtRawDataMonAlg.cxx:70
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
skel.l1
l1
Definition: skel.GENtoEVGEN.py:425
MdtIdHelper::get_module_hash
virtual int get_module_hash(const Identifier &id, IdentifierHash &hash_id) const override
Definition: MdtIdHelper.cxx:318
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MdtRawDataMonAlg::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition: MdtRawDataMonAlg.cxx:1236
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:127
IdentifierHash
Definition: IdentifierHash.h:38
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
MuonGM::MdtReadoutElement::getNtubesperlayer
int getNtubesperlayer() const
Returns the number of tubes in each tube layer.
test_pyathena.counter
counter
Definition: test_pyathena.py:15
MdtRawDataMonAlg::fillMDTSummaryVects
virtual StatusCode fillMDTSummaryVects(const Muon::MdtPrepData *, const std::set< std::string > &, bool &isNoiseBurstCandidate, bool trig_barrel, bool trig_endcap, std::array< MDTSummaryHistogramStruct, 4096 > *) const
Definition: MdtRawDataMonAlg.cxx:588
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
MdtRawDataMonAlg::m_doChamberHists
Gaudi::Property< bool > m_doChamberHists
Definition: MdtRawDataMonAlg.h:172
xAOD::iEta
setScale setgFexType iEta
Definition: gFexJetRoI_v1.cxx:74
MdtRawDataMonAlg::m_masked_tubes
std::unique_ptr< MDTNoisyTubes > m_masked_tubes
Definition: MdtRawDataMonAlg.h:108
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
xAOD::numberOfPhiLayers
@ numberOfPhiLayers
layers with a trigger phi hit [unit8_t].
Definition: TrackingPrimitives.h:290
MdtRawDataMonAlg::binMdtGlobal_byLayer
virtual StatusCode binMdtGlobal_byLayer(TH2 *, TH2 *, TH2 *)
Definition: MDTRawDataUtilsRun3.cxx:142
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
IdContext
class IdContext
Definition: IdContext.h:34
MDTSegmentHistogramStruct
Definition: MdtRawDataMonAlg.cxx:116
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MdtRawDataMonAlg::m_BMGpresent
bool m_BMGpresent
Definition: MdtRawDataMonAlg.h:184
MdtRawDataMonAlg::handleEvent_effCalc_fillVects
StatusCode handleEvent_effCalc_fillVects(const Trk::SegmentCollection *segms, MDTSegmentHistogramStruct(&vects)[4][4][16]) const
Definition: MdtRawDataMonAlg.cxx:928
MdtRawDataMonAlg::m_l1RoiKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_l1RoiKey
Definition: MdtRawDataMonAlg.h:160
MdtRawDataMonAlg::fillMDTOverviewHistograms
virtual void fillMDTOverviewHistograms(const MDTOverviewHistogramStruct &vects) const
Definition: MdtRawDataMonAlg.cxx:550
calibdata.tube
tube
Definition: calibdata.py:31
MdtIdHelper::tubeLayerMin
static int tubeLayerMin()
Definition: MdtIdHelper.cxx:764
MDTOverviewHistogramStruct::adc_mon_noiseBurst
std::vector< float > adc_mon_noiseBurst
Definition: MdtRawDataMonAlg.cxx:80
monAlg::TubeTraversedBySegment
Definition: MdtRawDataMonAlg.h:68
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
MdtRawDataMonAlg::m_BMGid
int m_BMGid
Definition: MdtRawDataMonAlg.h:185
NSWL1::PadTriggerAdapter::segment
Muon::NSW_PadTriggerSegment segment(const NSWL1::PadTrigger &data)
Definition: PadTriggerAdapter.cxx:5
ServiceHandle< ICondSvc >
MDTOverviewHistogramStruct::mdt_tube_x_endcap
std::vector< float > mdt_tube_x_endcap
Definition: MdtRawDataMonAlg.cxx:68
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
MdtRawDataMonAlg::getChamberName
std::string getChamberName(const Muon::MdtPrepData *) const
Definition: MDTRawDataUtilsRun3.cxx:479
collisions
Definition: collisions.py:1
Generated on Tue Jul 2 2024 21:53:11 for ATLAS Offline Software by   doxygen 1.8.18