Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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)
 
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 96 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 125 of file MdtRawDataMonAlg.cxx.

125 : AthMonitorAlgorithm(name, pSvcLocator) {}

◆ ~MdtRawDataMonAlg()

MdtRawDataMonAlg::~MdtRawDataMonAlg ( )
virtualdefault

Member Function Documentation

◆ AinB()

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

Definition at line 364 of file MDTRawDataUtilsRun3.cxx.

364  {
365  for (int i : B) {
366  if (i == A) return true;
367  }
368  return false;
369 }

◆ binMdtGlobal()

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

Definition at line 24 of file MDTRawDataUtilsRun3.cxx.

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

◆ binMdtGlobal_byLayer()

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

Definition at line 138 of file MDTRawDataUtilsRun3.cxx.

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

◆ binMdtOccVsLB()

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

Definition at line 506 of file MDTRawDataUtilsRun3.cxx.

506  {
507  if (region == 0 || region == 1) { // Barrel
508  if (layer == 0) { // Inner
509  // Add Labels
510  h->SetBins(834, 1, 2502, 122, 0, 122);
511  h->GetYaxis()->SetBinLabel(1, "BI1");
512  h->GetYaxis()->SetBinLabel(19, "BI2");
513  h->GetYaxis()->SetBinLabel(37, "BI3");
514  h->GetYaxis()->SetBinLabel(55, "BI4");
515  h->GetYaxis()->SetBinLabel(73, "BI5");
516  h->GetYaxis()->SetBinLabel(91, "BI6");
517  h->GetYaxis()->SetBinLabel(107, "BI7");
518  h->GetYaxis()->SetBinLabel(115, "BI8");
519  // Add lines
520  h->GetYaxis()->SetTickLength(0);
521  for (int i = 0; i < 6; i++) {
522  TLine* l = new TLine(1, 18 * i, 50, 18 * i);
523  h->GetListOfFunctions()->Add(l);
524  }
525  TLine* l2 = new TLine(1, 106, 50, 106);
526  h->GetListOfFunctions()->Add(l2);
527  TLine* l3 = new TLine(1, 114, 50, 114);
528  h->GetListOfFunctions()->Add(l3);
529  for (int i = 1; i < 122; i++) {
530  if (i < 90 && (i % 18 == 11 || i % 18 == 16)) {
531  TLine* l = new TLine(1, i, 10, i);
532  h->GetListOfFunctions()->Add(l);
533  } else {
534  TLine* l = new TLine(1, i, 20, i);
535  h->GetListOfFunctions()->Add(l);
536  }
537  }
538  }
539 
540  else if (layer == 1) { // Middle
541  h->SetBins(834, 1, 2502, 95, 0, 95); // 95 = 1 + 16 + 16 + 16 + 16 + 16 + 14 total number of phi sectors (+1)
542  // in the last eta-sector (6) there is no phi-sector 13; ie there arent chambers BML6A13
543  // and BML6C13 so there are only 14 phi sectors
544  // Add Labels
545  h->GetYaxis()->SetBinLabel(1, "BM1");
546  h->GetYaxis()->SetBinLabel(17, "BM2");
547  h->GetYaxis()->SetBinLabel(33, "BM3");
548  h->GetYaxis()->SetBinLabel(49, "BM4");
549  h->GetYaxis()->SetBinLabel(65, "BM5");
550  h->GetYaxis()->SetBinLabel(81, "BM6");
551  // Add lines
552  h->GetYaxis()->SetTickLength(0);
553  for (int i = 1; i < 95; i++) {
554  TLine* l = new TLine(1, i, 20, i);
555  h->GetListOfFunctions()->Add(l);
556  }
557  TLine* l1 = new TLine(1, 16, 50, 16);
558  h->GetListOfFunctions()->Add(l1);
559  TLine* l2 = new TLine(1, 32, 50, 32);
560  h->GetListOfFunctions()->Add(l2);
561  TLine* l3 = new TLine(1, 48, 50, 48);
562  h->GetListOfFunctions()->Add(l3);
563  TLine* l4 = new TLine(1, 64, 50, 64);
564  h->GetListOfFunctions()->Add(l4);
565  TLine* l5 = new TLine(1, 80, 50, 80);
566  h->GetListOfFunctions()->Add(l5);
567  }
568 
569  else if (layer == 2 && region == 0) { // Outer, side A
570  h->SetBins(834, 1, 2502, 118, 0, 118);
571  // Add labels
572  h->GetYaxis()->SetBinLabel(1, "BO0");
573  h->GetYaxis()->SetBinLabel(4, "BO1");
574  h->GetYaxis()->SetBinLabel(19, "BO2");
575  h->GetYaxis()->SetBinLabel(35, "BO3");
576  h->GetYaxis()->SetBinLabel(51, "BO4");
577  h->GetYaxis()->SetBinLabel(67, "BO5");
578  h->GetYaxis()->SetBinLabel(83, "BO6");
579  h->GetYaxis()->SetBinLabel(99, "BO7,8");
580  // h->GetYaxis()->SetBinLabel(101,"BO8");
581  h->GetYaxis()->SetBinLabel(103, "BE1");
582  h->GetYaxis()->SetBinLabel(111, "BE2");
583  // Add lines
584  h->GetYaxis()->SetTickLength(0);
585  for (int i = 1; i < 118; i++) {
586  TLine* l = new TLine(1, i, 20, i);
587  h->GetListOfFunctions()->Add(l);
588  }
589  TLine* l1 = new TLine(1, 2, 50, 2);
590  h->GetListOfFunctions()->Add(l1);
591  TLine* l2 = new TLine(1, 18, 50, 18);
592  h->GetListOfFunctions()->Add(l2);
593  TLine* l3 = new TLine(1, 34, 50, 34);
594  h->GetListOfFunctions()->Add(l3);
595  TLine* l4 = new TLine(1, 50, 50, 50);
596  h->GetListOfFunctions()->Add(l4);
597  TLine* l5 = new TLine(1, 66, 50, 66);
598  h->GetListOfFunctions()->Add(l5);
599  TLine* l6 = new TLine(1, 82, 50, 82);
600  h->GetListOfFunctions()->Add(l6);
601  TLine* l7 = new TLine(1, 98, 50, 98);
602  h->GetListOfFunctions()->Add(l7);
603  TLine* l8 = new TLine(1, 100, 50, 100);
604  h->GetListOfFunctions()->Add(l8);
605  TLine* l9 = new TLine(1, 102, 50, 102);
606  h->GetListOfFunctions()->Add(l9);
607  TLine* l10 = new TLine(1, 110, 50, 110);
608  h->GetListOfFunctions()->Add(l10);
609  }
610 
611  else if (layer == 2 && region == 1) { // Outer, side C (no eta = 0)
612  h->SetBins(834, 1, 2502, 116, 0, 116);
613  // Add labels
614  h->GetYaxis()->SetBinLabel(1, "BO1");
615  h->GetYaxis()->SetBinLabel(17, "BO2");
616  h->GetYaxis()->SetBinLabel(33, "BO3");
617  h->GetYaxis()->SetBinLabel(49, "BO4");
618  h->GetYaxis()->SetBinLabel(65, "BO5");
619  h->GetYaxis()->SetBinLabel(81, "BO6");
620  h->GetYaxis()->SetBinLabel(97, "BO7,8");
621  // h->GetYaxis()->SetBinLabel(101,"BO8");
622  h->GetYaxis()->SetBinLabel(101, "BE1");
623  h->GetYaxis()->SetBinLabel(109, "BE2");
624  // Add lines
625  h->GetYaxis()->SetTickLength(0);
626  for (int i = 1; i < 116; i++) {
627  TLine* l = new TLine(1, i, 20, i);
628  h->GetListOfFunctions()->Add(l);
629  }
630  TLine* l1 = new TLine(1, 16, 50, 16);
631  h->GetListOfFunctions()->Add(l1);
632  TLine* l2 = new TLine(1, 32, 50, 32);
633  h->GetListOfFunctions()->Add(l2);
634  TLine* l3 = new TLine(1, 48, 50, 48);
635  h->GetListOfFunctions()->Add(l3);
636  TLine* l4 = new TLine(1, 64, 50, 64);
637  h->GetListOfFunctions()->Add(l4);
638  TLine* l5 = new TLine(1, 80, 50, 80);
639  h->GetListOfFunctions()->Add(l5);
640  TLine* l6 = new TLine(1, 96, 50, 96);
641  h->GetListOfFunctions()->Add(l6);
642  TLine* l7 = new TLine(1, 98, 50, 98);
643  h->GetListOfFunctions()->Add(l7);
644  TLine* l8 = new TLine(1, 100, 50, 100);
645  h->GetListOfFunctions()->Add(l8);
646  TLine* l9 = new TLine(1, 108, 50, 108);
647  h->GetListOfFunctions()->Add(l9);
648  }
649  }
650 
651  else { // Endcap
652  if (layer == 0) { // Inner
653  h->SetBins(834, 1, 2502, 50, 0, 50);
654  // Add labels
655  h->GetYaxis()->SetBinLabel(1, "EI1");
656  h->GetYaxis()->SetBinLabel(17, "EI2");
657  h->GetYaxis()->SetBinLabel(33, "EI3");
658  h->GetYaxis()->SetBinLabel(41, "EI4");
659  h->GetYaxis()->SetBinLabel(49, "EI5");
660  // Add lines
661  h->GetYaxis()->SetTickLength(0);
662  for (int i = 1; i < 50; i++) {
663  TLine* l = new TLine(1, i, 20, i);
664  h->GetListOfFunctions()->Add(l);
665  }
666  TLine* l1 = new TLine(1, 16, 50, 16);
667  h->GetListOfFunctions()->Add(l1);
668  TLine* l2 = new TLine(1, 32, 50, 32);
669  h->GetListOfFunctions()->Add(l2);
670  TLine* l3 = new TLine(1, 40, 50, 40);
671  h->GetListOfFunctions()->Add(l3);
672  TLine* l4 = new TLine(1, 48, 50, 48);
673  h->GetListOfFunctions()->Add(l4);
674  }
675 
676  else if (layer == 1) { // Middle
677  h->SetBins(834, 1, 2502, 80, 0, 80);
678  // Add labels
679  h->GetYaxis()->SetBinLabel(1, "EM1");
680  h->GetYaxis()->SetBinLabel(17, "EM2");
681  h->GetYaxis()->SetBinLabel(33, "EM3");
682  h->GetYaxis()->SetBinLabel(49, "EM4");
683  h->GetYaxis()->SetBinLabel(65, "EM5");
684  // Add lines
685  h->GetYaxis()->SetTickLength(0);
686  for (int i = 1; i < 80; i++) {
687  TLine* l = new TLine(1, i, 20, i);
688  h->GetListOfFunctions()->Add(l);
689  }
690  TLine* l1 = new TLine(1, 16, 50, 16);
691  h->GetListOfFunctions()->Add(l1);
692  TLine* l2 = new TLine(1, 32, 50, 32);
693  h->GetListOfFunctions()->Add(l2);
694  TLine* l3 = new TLine(1, 48, 50, 48);
695  h->GetListOfFunctions()->Add(l3);
696  TLine* l4 = new TLine(1, 64, 50, 64);
697  h->GetListOfFunctions()->Add(l4);
698  }
699 
700  else if (layer == 2) { // Outer + extra
701 
702  if (region == 2) { // side A
703  h->SetBins(834, 1, 2502, 103, 0, 103);
704  // Add labels
705  h->GetYaxis()->SetBinLabel(1, "EO1");
706  h->GetYaxis()->SetBinLabel(17, "EO2");
707  h->GetYaxis()->SetBinLabel(33, "EO3");
708  h->GetYaxis()->SetBinLabel(49, "EO4");
709  h->GetYaxis()->SetBinLabel(65, "EO5");
710  h->GetYaxis()->SetBinLabel(81, "EO6");
711  h->GetYaxis()->SetBinLabel(97, "EE1,2");
712  // Add lines
713  h->GetYaxis()->SetTickLength(0);
714  for (int i = 1; i < 103; i++) {
715  TLine* l = new TLine(1, i, 20, i);
716  h->GetListOfFunctions()->Add(l);
717  }
718  TLine* l1 = new TLine(1, 16, 50, 16);
719  h->GetListOfFunctions()->Add(l1);
720  TLine* l2 = new TLine(1, 32, 50, 32);
721  h->GetListOfFunctions()->Add(l2);
722  TLine* l3 = new TLine(1, 48, 50, 48);
723  h->GetListOfFunctions()->Add(l3);
724  TLine* l4 = new TLine(1, 64, 50, 64);
725  h->GetListOfFunctions()->Add(l4);
726  TLine* l5 = new TLine(1, 80, 50, 80);
727  h->GetListOfFunctions()->Add(l5);
728  TLine* l6 = new TLine(1, 96, 50, 96);
729  h->GetListOfFunctions()->Add(l6);
730  TLine* l7 = new TLine(1, 100, 50, 100);
731  h->GetListOfFunctions()->Add(l7);
732  } else if (region == 3) { // side C
733  h->SetBins(834, 1, 2502, 127, 0, 127);
734  // Add labels
735  h->GetYaxis()->SetBinLabel(1, "EO1");
736  h->GetYaxis()->SetBinLabel(17, "EO2");
737  h->GetYaxis()->SetBinLabel(33, "EO3");
738  h->GetYaxis()->SetBinLabel(49, "EO4");
739  h->GetYaxis()->SetBinLabel(65, "EO5");
740  h->GetYaxis()->SetBinLabel(81, "EO6");
741  h->GetYaxis()->SetBinLabel(97, "EE1");
742  h->GetYaxis()->SetBinLabel(113, "EE2");
743  // Add lines
744  h->GetYaxis()->SetTickLength(0);
745  for (int i = 1; i < 127; i++) {
746  TLine* l = new TLine(1, i, 20, i);
747  h->GetListOfFunctions()->Add(l);
748  }
749  TLine* l1 = new TLine(1, 16, 50, 16);
750  h->GetListOfFunctions()->Add(l1);
751  TLine* l2 = new TLine(1, 32, 50, 32);
752  h->GetListOfFunctions()->Add(l2);
753  TLine* l3 = new TLine(1, 48, 50, 48);
754  h->GetListOfFunctions()->Add(l3);
755  TLine* l4 = new TLine(1, 64, 50, 64);
756  h->GetListOfFunctions()->Add(l4);
757  TLine* l5 = new TLine(1, 80, 50, 80);
758  h->GetListOfFunctions()->Add(l5);
759  TLine* l6 = new TLine(1, 96, 50, 96);
760  h->GetListOfFunctions()->Add(l6);
761  TLine* l7 = new TLine(1, 112, 50, 112);
762  h->GetListOfFunctions()->Add(l7);
763  }
764  }
765  }
766 
767  return StatusCode::SUCCESS;
768 }

◆ binMdtOccVsLB_Crate()

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

Definition at line 770 of file MDTRawDataUtilsRun3.cxx.

770  {
771  if (region == 0 || region == 1) { // Barrel
772  if (crate == 0) { // Crate BA01 or BC01
773  // Add Labels
774  h->SetBins(834, 1, 2502, 73, 0, 73);
775  h->GetYaxis()->SetBinLabel(1, "BIL");
776  h->GetYaxis()->SetBinLabel(13, "BIS");
777  h->GetYaxis()->SetBinLabel(25, "BME");
778  h->GetYaxis()->SetBinLabel(26, "BML");
779  h->GetYaxis()->SetBinLabel(38, "BMS");
780  h->GetYaxis()->SetBinLabel(50, "BOL");
781  h->GetYaxis()->SetBinLabel(62, "BOS");
782  // Add lines
783  h->GetYaxis()->SetTickLength(0);
784  for (int i = 0; i < 73; i++) {
785  TLine* l = new TLine(1, i, 20, i);
786  h->GetListOfFunctions()->Add(l);
787  }
788  TLine* l2 = new TLine(1, 0, 50, 0);
789  h->GetListOfFunctions()->Add(l2);
790  TLine* l3 = new TLine(1, 12, 50, 12);
791  h->GetListOfFunctions()->Add(l3);
792  TLine* l4 = new TLine(1, 24, 50, 24);
793  h->GetListOfFunctions()->Add(l4);
794  TLine* l5 = new TLine(1, 25, 50, 25);
795  h->GetListOfFunctions()->Add(l5);
796  TLine* l6 = new TLine(1, 37, 50, 37);
797  h->GetListOfFunctions()->Add(l6);
798  TLine* l8 = new TLine(1, 49, 50, 49);
799  h->GetListOfFunctions()->Add(l8);
800  TLine* l9 = new TLine(1, 61, 50, 61);
801  h->GetListOfFunctions()->Add(l9);
802  }
803 
804  else if (crate == 1) { // BA02, BC02
805  h->SetBins(834, 1, 2502, 73, 0, 73);
806  // Add Labels
807  h->GetYaxis()->SetBinLabel(1, "BIL");
808  h->GetYaxis()->SetBinLabel(13, "BIS");
809  h->GetYaxis()->SetBinLabel(25, "BME");
810  h->GetYaxis()->SetBinLabel(37, "BMS");
811  h->GetYaxis()->SetBinLabel(49, "BOL");
812  h->GetYaxis()->SetBinLabel(61, "BOS");
813  // Add lines
814  h->GetYaxis()->SetTickLength(0);
815  for (int i = 1; i < 73; i++) {
816  TLine* l = new TLine(1, i, 20, i);
817  h->GetListOfFunctions()->Add(l);
818  }
819  TLine* l1 = new TLine(1, 12, 50, 12);
820  h->GetListOfFunctions()->Add(l1);
821  TLine* l2 = new TLine(1, 24, 50, 24);
822  h->GetListOfFunctions()->Add(l2);
823  TLine* l3 = new TLine(1, 36, 50, 36);
824  h->GetListOfFunctions()->Add(l3);
825  TLine* l4 = new TLine(1, 48, 50, 48);
826  h->GetListOfFunctions()->Add(l4);
827  TLine* l6 = new TLine(1, 60, 50, 60);
828  h->GetListOfFunctions()->Add(l6);
829 
830  } else if (crate == 2) { // BA03, BC03
831  // Add Labels
832  h->SetBins(834, 1, 2502, 80, 0, 80);
833  h->GetYaxis()->SetBinLabel(1, "BIL");
834  h->GetYaxis()->SetBinLabel(7, "BIM");
835  h->GetYaxis()->SetBinLabel(12, "BIR");
836  h->GetYaxis()->SetBinLabel(18, "BIS");
837  h->GetYaxis()->SetBinLabel(30, "BMF");
838  h->GetYaxis()->SetBinLabel(33, "BMG");
839  h->GetYaxis()->SetBinLabel(36, "BML");
840  h->GetYaxis()->SetBinLabel(48, "BMS");
841  h->GetYaxis()->SetBinLabel(54, "BOF");
842  h->GetYaxis()->SetBinLabel(58, "BOG");
843  if (region == 0) {
844  h->GetYaxis()->SetBinLabel(63, "BOL");
845  h->GetYaxis()->SetBinLabel(75, "BOS");
846  } else if (region == 1) {
847  h->GetYaxis()->SetBinLabel(62, "BOL");
848  h->GetYaxis()->SetBinLabel(74, "BOS");
849  }
850  // Add lines
851  h->GetYaxis()->SetTickLength(0);
852  for (int i = 0; i < 80; i++) {
853  TLine* l = new TLine(1, i, 20, i);
854  h->GetListOfFunctions()->Add(l);
855  }
856  TLine* l2 = new TLine(1, 6, 50, 6);
857  h->GetListOfFunctions()->Add(l2);
858  TLine* l3 = new TLine(1, 11, 50, 11);
859  h->GetListOfFunctions()->Add(l3);
860  TLine* l3b = new TLine(1, 17, 50, 17);
861  h->GetListOfFunctions()->Add(l3b);
862  // TLine* l4 = new TLine(1,26,50,26); h->GetListOfFunctions()->Add(l4); //removed this line because it doesnt correspond to
863  // anything
864  TLine* l5 = new TLine(1, 29, 50, 29);
865  h->GetListOfFunctions()->Add(l5);
866  TLine* l6 = new TLine(1, 32, 50, 32);
867  h->GetListOfFunctions()->Add(l6);
868  TLine* l7 = new TLine(1, 35, 50, 35);
869  h->GetListOfFunctions()->Add(l7);
870  TLine* l8 = new TLine(1, 47, 50, 47);
871  h->GetListOfFunctions()->Add(l8);
872  TLine* l9 = new TLine(1, 53, 50, 53);
873  h->GetListOfFunctions()->Add(l9);
874  TLine* l9b = new TLine(1, 57, 50, 57);
875  h->GetListOfFunctions()->Add(l9b);
876  if (region == 0) {
877  TLine* l10 = new TLine(1, 62, 50, 62);
878  h->GetListOfFunctions()->Add(l10);
879  TLine* l11 = new TLine(1, 74, 50, 74);
880  h->GetListOfFunctions()->Add(l11);
881  } else if (region == 1) {
882  TLine* l10 = new TLine(1, 61, 50, 61);
883  h->GetListOfFunctions()->Add(l10);
884  TLine* l11 = new TLine(1, 73, 50, 73);
885  h->GetListOfFunctions()->Add(l11);
886  }
887  }
888 
889  else if (crate == 3) { // BA04, BC04
890  // Add Labels
891  h->SetBins(834, 1, 2502, 79, 0, 79);
892  h->GetYaxis()->SetBinLabel(1, "BIL");
893  h->GetYaxis()->SetBinLabel(7, "BIM");
894  h->GetYaxis()->SetBinLabel(12, "BIR");
895  h->GetYaxis()->SetBinLabel(18, "BIS");
896  h->GetYaxis()->SetBinLabel(30, "BMF");
897  h->GetYaxis()->SetBinLabel(33, "BMG");
898  h->GetYaxis()->SetBinLabel(36, "BML");
899  h->GetYaxis()->SetBinLabel(47, "BMS");
900  h->GetYaxis()->SetBinLabel(53, "BOF");
901  h->GetYaxis()->SetBinLabel(57, "BOG");
902  if (region == 0) {
903  h->GetYaxis()->SetBinLabel(62, "BOL");
904  h->GetYaxis()->SetBinLabel(75, "BOS");
905  } else if (region == 1) {
906  h->GetYaxis()->SetBinLabel(61, "BOL");
907  h->GetYaxis()->SetBinLabel(74, "BOS");
908  }
909 
910  // Add lines
911  h->GetYaxis()->SetTickLength(0);
912  for (int i = 0; i < 79; i++) {
913  TLine* l = new TLine(1, i, 20, i);
914  h->GetListOfFunctions()->Add(l);
915  }
916  TLine* l2 = new TLine(1, 6, 50, 6);
917  h->GetListOfFunctions()->Add(l2);
918  TLine* l3 = new TLine(1, 11, 50, 11);
919  h->GetListOfFunctions()->Add(l3);
920  TLine* l3b = new TLine(1, 17, 50, 17);
921  h->GetListOfFunctions()->Add(l3b);
922  // TLine* l4 = new TLine(1,26,50,26); h->GetListOfFunctions()->Add(l4);//removed this line because it doesnt correspond to
923  // anything
924  TLine* l5 = new TLine(1, 29, 50, 29);
925  h->GetListOfFunctions()->Add(l5);
926  TLine* l6 = new TLine(1, 32, 50, 32);
927  h->GetListOfFunctions()->Add(l6);
928  TLine* l7 = new TLine(1, 35, 50, 35);
929  h->GetListOfFunctions()->Add(l7);
930  TLine* l8 = new TLine(1, 46, 50, 46);
931  h->GetListOfFunctions()->Add(l8);
932  TLine* l9 = new TLine(1, 52, 50, 52);
933  h->GetListOfFunctions()->Add(l9);
934  TLine* l9b = new TLine(1, 56, 50, 56);
935  h->GetListOfFunctions()->Add(l9b);
936  if (region == 0) {
937  TLine* l10 = new TLine(1, 61, 50, 61);
938  h->GetListOfFunctions()->Add(l10);
939  TLine* l11 = new TLine(1, 74, 50, 74);
940  h->GetListOfFunctions()->Add(l11);
941  } else if (region == 1) {
942  TLine* l10 = new TLine(1, 60, 50, 60);
943  h->GetListOfFunctions()->Add(l10);
944  TLine* l11 = new TLine(1, 73, 50, 73);
945  h->GetListOfFunctions()->Add(l11);
946  }
947  }
948  }
949 
950  else { // Endcap
951  if (crate == 0 || crate == 2) { // EA01, EC01 and EA03, EC03 are the same
952  h->SetBins(834, 1, 2502, 73, 0, 73);
953  // Add labels
954  h->GetYaxis()->SetBinLabel(1, "BEE");
955  h->GetYaxis()->SetBinLabel(5, "BIS");
956  h->GetYaxis()->SetBinLabel(9, "EEL");
957  h->GetYaxis()->SetBinLabel(13, "EES");
958  h->GetYaxis()->SetBinLabel(17, "EIL");
959  h->GetYaxis()->SetBinLabel(26, "EIS");
960  h->GetYaxis()->SetBinLabel(30, "EML");
961  h->GetYaxis()->SetBinLabel(40, "EMS");
962  h->GetYaxis()->SetBinLabel(50, "EOL");
963  h->GetYaxis()->SetBinLabel(62, "EOS");
964  // Add lines
965  h->GetYaxis()->SetTickLength(0);
966  for (int i = 1; i < 73; i++) {
967  TLine* l = new TLine(1, i, 20, i);
968  h->GetListOfFunctions()->Add(l);
969  }
970  TLine* l2 = new TLine(1, 4, 50, 4);
971  h->GetListOfFunctions()->Add(l2);
972  TLine* l3 = new TLine(1, 8, 50, 8);
973  h->GetListOfFunctions()->Add(l3);
974  TLine* l4 = new TLine(1, 12, 50, 12);
975  h->GetListOfFunctions()->Add(l4);
976  TLine* l5 = new TLine(1, 16, 50, 16);
977  h->GetListOfFunctions()->Add(l5);
978  TLine* l6 = new TLine(1, 25, 50, 25);
979  h->GetListOfFunctions()->Add(l6);
980  TLine* l7 = new TLine(1, 29, 50, 29);
981  h->GetListOfFunctions()->Add(l7);
982  TLine* l8 = new TLine(1, 39, 50, 39);
983  h->GetListOfFunctions()->Add(l8);
984  TLine* l9 = new TLine(1, 49, 50, 49);
985  h->GetListOfFunctions()->Add(l9);
986  TLine* l10 = new TLine(1, 61, 50, 61);
987  h->GetListOfFunctions()->Add(l10);
988  } else if (crate == 1) { // EA02, EC02
989  h->SetBins(834, 1, 2502, 71, 0, 71);
990  // Add labels
991  h->GetYaxis()->SetBinLabel(1, "BEE");
992  h->GetYaxis()->SetBinLabel(5, "BIS");
993  h->GetYaxis()->SetBinLabel(9, "EEL");
994  h->GetYaxis()->SetBinLabel(12, "EES");
995  h->GetYaxis()->SetBinLabel(16, "EIL");
996  h->GetYaxis()->SetBinLabel(24, "EIS");
997  h->GetYaxis()->SetBinLabel(28, "EML");
998  h->GetYaxis()->SetBinLabel(38, "EMS");
999  h->GetYaxis()->SetBinLabel(48, "EOL");
1000  h->GetYaxis()->SetBinLabel(60, "EOS");
1001  // Add lines
1002  h->GetYaxis()->SetTickLength(0);
1003  for (int i = 1; i < 71; i++) {
1004  TLine* l = new TLine(1, i, 20, i);
1005  h->GetListOfFunctions()->Add(l);
1006  }
1007  TLine* l2 = new TLine(1, 4, 50, 4);
1008  h->GetListOfFunctions()->Add(l2);
1009  TLine* l3 = new TLine(1, 8, 50, 8);
1010  h->GetListOfFunctions()->Add(l3);
1011  TLine* l4 = new TLine(1, 11, 50, 11);
1012  h->GetListOfFunctions()->Add(l4);
1013  TLine* l5 = new TLine(1, 15, 50, 15);
1014  h->GetListOfFunctions()->Add(l5);
1015  TLine* l6 = new TLine(1, 23, 50, 23);
1016  h->GetListOfFunctions()->Add(l6);
1017  TLine* l7 = new TLine(1, 27, 50, 27);
1018  h->GetListOfFunctions()->Add(l7);
1019  TLine* l8 = new TLine(1, 37, 50, 37);
1020  h->GetListOfFunctions()->Add(l8);
1021  TLine* l9 = new TLine(1, 47, 50, 47);
1022  h->GetListOfFunctions()->Add(l9);
1023  TLine* l10 = new TLine(1, 59, 50, 59);
1024  h->GetListOfFunctions()->Add(l10);
1025  } else if (crate == 3) { // EA04, EC04
1026  h->SetBins(834, 1, 2502, 72, 0, 72);
1027  // Add labels
1028  h->GetYaxis()->SetBinLabel(1, "BEE");
1029  h->GetYaxis()->SetBinLabel(5, "BIS");
1030  h->GetYaxis()->SetBinLabel(9, "EEL");
1031  h->GetYaxis()->SetBinLabel(13, "EES");
1032  h->GetYaxis()->SetBinLabel(17, "EIL");
1033  h->GetYaxis()->SetBinLabel(25, "EIS");
1034  h->GetYaxis()->SetBinLabel(29, "EML");
1035  h->GetYaxis()->SetBinLabel(39, "EMS");
1036  h->GetYaxis()->SetBinLabel(49, "EOL");
1037  h->GetYaxis()->SetBinLabel(61, "EOS");
1038  // Add lines
1039  h->GetYaxis()->SetTickLength(0);
1040  for (int i = 1; i < 72; i++) {
1041  TLine* l = new TLine(1, i, 20, i);
1042  h->GetListOfFunctions()->Add(l);
1043  }
1044  TLine* l2 = new TLine(1, 4, 50, 4);
1045  h->GetListOfFunctions()->Add(l2);
1046  TLine* l3 = new TLine(1, 8, 50, 8);
1047  h->GetListOfFunctions()->Add(l3);
1048  TLine* l4 = new TLine(1, 12, 50, 12);
1049  h->GetListOfFunctions()->Add(l4);
1050  TLine* l5 = new TLine(1, 16, 50, 16);
1051  h->GetListOfFunctions()->Add(l5);
1052  TLine* l6 = new TLine(1, 24, 50, 24);
1053  h->GetListOfFunctions()->Add(l6);
1054  TLine* l7 = new TLine(1, 28, 50, 28);
1055  h->GetListOfFunctions()->Add(l7);
1056  TLine* l8 = new TLine(1, 38, 50, 38);
1057  h->GetListOfFunctions()->Add(l8);
1058  TLine* l9 = new TLine(1, 48, 50, 48);
1059  h->GetListOfFunctions()->Add(l9);
1060  TLine* l10 = new TLine(1, 60, 50, 60);
1061  h->GetListOfFunctions()->Add(l10);
1062  }
1063  }
1064 
1065  return StatusCode::SUCCESS;
1066 }

◆ binMdtRegional()

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

SET Ghost Entries

Definition at line 75 of file MDTRawDataUtilsRun3.cxx.

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

◆ cachedTubeLayerMax()

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

Definition at line 1346 of file MDTRawDataUtilsRun3.cxx.

1346  {
1347  const MuonGM::MdtReadoutElement* roe = m_detMgr->getMdtReadoutElement(id);
1348  return roe ? roe->getNLayers() : -1;
1349 }

◆ cachedTubeMax()

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

Definition at line 1342 of file MDTRawDataUtilsRun3.cxx.

1342  {
1343  const MuonGM::MdtReadoutElement* roe = m_detMgr->getMdtReadoutElement(id);
1344  return roe ? roe->getNtubesperlayer() : -1;
1345 }

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ ChamberTubeNumberCorrection()

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

Definition at line 263 of file MDTRawDataUtilsRun3.cxx.

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

◆ CorrectLayerMax()

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

Definition at line 287 of file MDTRawDataUtilsRun3.cxx.

287  {
288  if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") numLayers = 3;
289 }

◆ CorrectTubeMax()

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

Definition at line 282 of file MDTRawDataUtilsRun3.cxx.

282  {
283  if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") numTubes = 48;
284 }

◆ 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ 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 253 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTHistograms()

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

Definition at line 852 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTOverviewHistograms()

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

Definition at line 548 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTOverviewVects()

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

Definition at line 480 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTSegmentHistograms()

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

Definition at line 1201 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTSummaryHistograms()

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

Definition at line 737 of file MdtRawDataMonAlg.cxx.

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

◆ 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 586 of file MdtRawDataMonAlg.cxx.

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

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ 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 1068 of file MDTRawDataUtilsRun3.cxx.

1068  {
1069  int binNum = 999;
1070  std::string_view stName = chamber.substr(0, 3);
1071  if (region == 0 || region == 1) { // Barrel
1072  if (crate == 1) { // BA01, BC01
1073  if (stName == "BIL")
1074  binNum = 2 * eta + (phi - 1) / 2 - 1;
1075  else if (stName == "BIS")
1076  binNum = 12 + 2 * eta + (phi - 2) / 2 - 1;
1077  else if (stName == "BME")
1078  binNum = 25;
1079  else if (stName == "BML")
1080  binNum = 25 + 2 * eta + (phi - 1) / 2 - 1;
1081  else if (stName == "BMS")
1082  binNum = 37 + 2 * eta + (phi - 2) / 2 - 1;
1083  else if (stName == "BOL")
1084  binNum = 49 + 2 * eta + (phi - 1) / 2 - 1;
1085  else if (stName == "BOS")
1086  binNum = 61 + 2 * eta + (phi - 2) / 2 - 1;
1087  else
1088  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx01");
1089  return binNum - 1;
1090  } else if (crate == 2) { // BA02, BC02
1091 
1092  if (stName == "BIL")
1093  binNum = 2 * eta + (phi - 5) / 2 - 1;
1094  else if (stName == "BIS")
1095  binNum = 12 + 2 * eta + (phi - 6) / 2 - 1;
1096  else if (stName == "BML")
1097  binNum = 24 + 2 * eta + (phi - 5) / 2 - 1;
1098  else if (stName == "BMS")
1099  binNum = 36 + 2 * eta + (phi - 6) / 2 - 1;
1100  else if (stName == "BOL")
1101  binNum = 48 + 2 * eta + (phi - 5) / 2 - 1;
1102  else if (stName == "BOS")
1103  binNum = 60 + 2 * eta + (phi - 6) / 2 - 1;
1104  else
1105  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx02");
1106  return binNum - 1;
1107  } else if (crate == 3) { // BA03,BC03
1108  if (stName == "BIL")
1109  binNum = eta;
1110  else if (stName == "BIM")
1111  binNum = 6 + eta;
1112  else if (stName == "BIR")
1113  binNum = 11 + eta;
1114  else if (stName == "BIS")
1115  binNum = 17 + 2 * eta + (phi - 10) / 2 - 1;
1116  else if (stName == "BMF")
1117  binNum = 29 + (eta + 1) / 2;
1118  else if (stName == "BMG")
1119  binNum = 32 + eta / 2;
1120  else if (stName == "BML")
1121  binNum = 35 + 2 * eta + (phi - 9) / 2 - 1;
1122  else if (stName == "BMS")
1123  binNum = 47 + eta;
1124  else if (stName == "BOF")
1125  binNum = 53 + (eta + 1) / 2;
1126  else if (chamber.substr(0, 4) == "BOG0" && region == 0)
1127  binNum = 58;
1128  else if (stName == "BOG")
1129  binNum = 58 + eta / 2 - region;
1130  else if (stName == "BOL")
1131  binNum = 62 + 2 * eta + (phi - 9) / 2 - 1 - region;
1132  else if (stName == "BOS")
1133  binNum = 74 + eta - region;
1134  else
1135  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx03");
1136  return binNum - 1;
1137  } else if (crate == 4) { // BA04, BC04
1138 
1139  if (stName == "BIL")
1140  binNum = eta;
1141  else if (stName == "BIM")
1142  binNum = 6 + eta;
1143  else if (stName == "BIR")
1144  binNum = 11 + eta;
1145  else if (stName == "BIS")
1146  binNum = 17 + 2 * eta + (phi - 14) / 2 - 1;
1147  else if (stName == "BMF")
1148  binNum = 29 + (eta + 1) / 2;
1149  else if (stName == "BMG")
1150  binNum = 32 + eta / 2;
1151  else if (stName == "BML" && eta < 6)
1152  binNum = 35 + 2 * eta + (phi - 13) / 2 - 1;
1153  else if (chamber.substr(0, 7) == "BML6A15" || chamber.substr(0, 7) == "BML6C15")
1154  binNum = 46;
1155  else if (stName == "BMS")
1156  binNum = 46 + eta;
1157  else if (stName == "BOF")
1158  binNum = 52 + (eta + 1) / 2;
1159  else if (chamber.substr(0, 4) == "BOG0" && region == 0)
1160  binNum = 57;
1161  else if (stName == "BOG")
1162  binNum = 57 + eta / 2 - region;
1163  else if (stName == "BOL")
1164  binNum = 61 + 2 * eta + (phi - 13) / 2 - 1 - region;
1165  else if (stName == "BOS")
1166  binNum = 74 + eta - region;
1167  else
1168  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Bx04");
1169  return binNum - 1;
1170  }
1171  } else if (region == 2 || region == 3) {
1172  if (crate == 1) { // EA01, EC01
1173  if (stName == "BEE")
1174  binNum = 2 * eta + (phi - 2) / 2 - 1;
1175  else if (stName == "BIS")
1176  binNum = 4 + 2 * (eta - 6) + (phi - 2) / 2 - 1;
1177  else if (stName == "EEL")
1178  binNum = 8 + 2 * eta + (phi - 1) / 2 - 1;
1179  else if (stName == "EES")
1180  binNum = 12 + 2 * eta + (phi - 2) / 2 - 1;
1181  else if (stName == "EIL" && eta < 5)
1182  binNum = 16 + 2 * eta + (phi - 1) / 2 - 1;
1183  else if (stName == "EIL" && eta == 5)
1184  binNum = 25;
1185  else if (stName == "EIS")
1186  binNum = 25 + 2 * eta + (phi - 2) / 2 - 1;
1187  else if (stName == "EML")
1188  binNum = 29 + 2 * eta + (phi - 1) / 2 - 1;
1189  else if (stName == "EMS")
1190  binNum = 39 + 2 * eta + (phi - 2) / 2 - 1;
1191  else if (stName == "EOL")
1192  binNum = 49 + 2 * eta + (phi - 1) / 2 - 1;
1193  else if (stName == "EOS")
1194  binNum = 61 + 2 * eta + (phi - 2) / 2 - 1;
1195  else
1196  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex01");
1197  if (m_do_run3Geometry) {
1198  if (region == 2) {
1199  if (binNum > 8 && binNum < 23)
1200  binNum = binNum - 2;
1201  else if (binNum > 22 && binNum < 30)
1202  binNum = binNum - 8;
1203  else if (binNum > 29)
1204  binNum = binNum - 12;
1205  } else if (region == 3) {
1206  if (binNum > 22 && binNum < 30)
1207  binNum = binNum - 6;
1208  else if (binNum > 29)
1209  binNum = binNum - 10;
1210  }
1211  }
1212  return binNum - 1;
1213  } else if (crate == 2) { // EA02, EC02
1214  if (stName == "BEE")
1215  binNum = 2 * eta + (phi - 6) / 2 - 1;
1216  else if (stName == "BIS")
1217  binNum = 4 + 2 * (eta - 6) + (phi - 6) / 2 - 1;
1218  else if (chamber.substr(0, 4) == "EEL1")
1219  binNum = 9 + (phi - 3) / 2 - 1;
1220  else if (chamber.substr(0, 4) == "EEL2")
1221  binNum = 11;
1222  else if (stName == "EES")
1223  binNum = 11 + 2 * eta + (phi - 6) / 2 - 1;
1224  else if (stName == "EIL")
1225  binNum = 15 + 2 * eta + (phi - 5) / 2 - 1;
1226  else if (stName == "EIS")
1227  binNum = 23 + 2 * eta + (phi - 6) / 2 - 1;
1228  else if (stName == "EML")
1229  binNum = 27 + 2 * eta + (phi - 5) / 2 - 1;
1230  else if (stName == "EMS")
1231  binNum = 37 + 2 * eta + (phi - 6) / 2 - 1;
1232  else if (stName == "EOL")
1233  binNum = 47 + 2 * eta + (phi - 5) / 2 - 1;
1234  else if (stName == "EOS")
1235  binNum = 59 + 2 * eta + (phi - 6) / 2 - 1;
1236  else
1237  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex02");
1238  if (m_do_run3Geometry) {
1239  if (region == 2) {
1240  if (binNum > 8 && binNum < 22)
1241  binNum = binNum - 2;
1242  else if (binNum > 21 && binNum < 28)
1243  binNum = binNum - 8;
1244  else if (binNum > 27)
1245  binNum = binNum - 12;
1246  } else if (region == 3) {
1247  if (binNum > 21 && binNum < 28)
1248  binNum = binNum - 6;
1249  else if (binNum > 27)
1250  binNum = binNum - 10;
1251  }
1252  }
1253  return binNum - 1;
1254  } else if (crate == 3) { // EA03, EC03
1255 
1256  if (stName == "BEE")
1257  binNum = 2 * eta + (phi - 10) / 2 - 1;
1258  else if (stName == "BIS")
1259  binNum = 4 + 2 * (eta - 6) + (phi - 10) / 2 - 1;
1260  else if (stName == "EEL")
1261  binNum = 8 + 2 * eta + (phi - 9) / 2 - 1;
1262  else if (stName == "EES")
1263  binNum = 12 + 2 * eta + (phi - 10) / 2 - 1;
1264  else if (stName == "EIL" && eta < 5)
1265  binNum = 16 + 2 * eta + (phi - 9) / 2 - 1;
1266  else if (chamber.substr(0, 4) == "EIL5")
1267  binNum = 25;
1268  else if (stName == "EIS")
1269  binNum = 25 + 2 * eta + (phi - 10) / 2 - 1;
1270  else if (stName == "EML")
1271  binNum = 29 + 2 * eta + (phi - 9) / 2 - 1;
1272  else if (stName == "EMS")
1273  binNum = 39 + 2 * eta + (phi - 10) / 2 - 1;
1274  else if (stName == "EOL")
1275  binNum = 49 + 2 * eta + (phi - 9) / 2 - 1;
1276  else if (stName == "EOS")
1277  binNum = 61 + 2 * eta + (phi - 10) / 2 - 1;
1278  else
1279  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex03");
1280  if (m_do_run3Geometry) {
1281  if (region == 2) {
1282  if (binNum > 8 && binNum < 23)
1283  binNum = binNum - 2;
1284  else if (binNum > 22 && binNum < 30)
1285  binNum = binNum - 8;
1286  else if (binNum > 29)
1287  binNum = binNum - 12;
1288  }
1289  if (region == 3) {
1290  if (binNum > 22 && binNum < 30)
1291  binNum = binNum - 6;
1292  else if (binNum > 29)
1293  binNum = binNum - 10;
1294  }
1295  }
1296  return binNum - 1;
1297  } else if (crate == 4) { // EA04, EC04
1298  if (stName == "BEE")
1299  binNum = 2 * eta + (phi - 14) / 2 - 1;
1300  else if (stName == "BIS")
1301  binNum = 4 + 2 * (eta - 6) + (phi - 14) / 2 - 1;
1302  else if (stName == "EEL")
1303  binNum = 8 + 2 * eta + (phi - 13) / 2 - 1;
1304  else if (stName == "EES")
1305  binNum = 12 + 2 * eta + (phi - 14) / 2 - 1;
1306  else if (stName == "EIL")
1307  binNum = 16 + 2 * eta + (phi - 13) / 2 - 1;
1308  else if (stName == "EIS")
1309  binNum = 24 + 2 * eta + (phi - 14) / 2 - 1;
1310  else if (stName == "EML")
1311  binNum = 28 + 2 * eta + (phi - 13) / 2 - 1;
1312  else if (stName == "EMS")
1313  binNum = 38 + 2 * eta + (phi - 14) / 2 - 1;
1314  else if (stName == "EOL")
1315  binNum = 48 + 2 * eta + (phi - 13) / 2 - 1;
1316  else if (stName == "EOS")
1317  binNum = 60 + 2 * eta + (phi - 14) / 2 - 1;
1318  else
1319  ATH_MSG_INFO("chamber " << chamber << " didn't exist in crate Ex04");
1320  if (m_do_run3Geometry) {
1321  if (region == 2) {
1322  if (binNum > 8 && binNum < 23)
1323  binNum = binNum - 2;
1324  else if (binNum > 22 && binNum < 29)
1325  binNum = binNum - 8;
1326  else if (binNum > 28)
1327  binNum = binNum - 12;
1328  }
1329  if (region == 3) {
1330  if (binNum > 22 && binNum < 28)
1331  binNum = binNum - 6;
1332  else if (binNum > 28)
1333  binNum = binNum - 10;
1334  }
1335  }
1336 
1337  return binNum - 1;
1338  }
1339  }
1340  return -1;
1341 }

◆ 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 408 of file MDTRawDataUtilsRun3.cxx.

408  {
409  if (region == 0 || region == 1) { // Barrel
410 
411  if (layer == 0) { // Inner
412  if (eta < 6) {
413  if (phi < 11 && !isBIM)
414  return 18 * (eta - 1) + phi;
415  else if ((phi == 10 && isBIM) || (phi < 15 && !isBIM))
416  return 18 * (eta - 1) + phi + 1;
417  else
418  return 18 * (eta - 1) + phi + 2;
419  } else if (eta == 6)
420  return 90 + phi;
421  else if (eta == 7)
422  return 106 + (phi / 2);
423  else if (eta == 8)
424  return 114 + (phi / 2);
425  }
426 
427  else if (layer == 1) { // Middle
428  // 95 = 1 + 16 + 16 + 16 + 16 + 16 + 14 total number of phi sectors (+1)
429  // 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
430  // sectos we move the bin of phi=14 directly above phi=12 so there is no white line in the histogram
431  if (eta == 6 && phi > 11)
432  return 16 * (eta - 1) + phi - 1;
433  else
434  return 16 * (eta - 1) + phi;
435 
436  } else if (layer == 2 && region == 0) { // Outer, side A (must be separated due to presence of eta=0 chambers)
437  if (eta == 0 && phi == 11)
438  return 0;
439  else if (eta == 0 && phi == 13)
440  return 1;
441  else if (eta < 7)
442  return 16 * (eta - 1) + phi + 2;
443  else if (eta == 7 && phi == 11)
444  return 98;
445  else if (eta == 7 && phi == 13)
446  return 99;
447  else if (eta == 8 && phi == 11)
448  return 100;
449  else if (eta == 8 && phi == 13)
450  return 101;
451  } else if (layer == 3 && region == 0) { // Extra: put with outer
452  return 102 + 8 * (eta - 1) + (phi - 1) / 2;
453  } else if (layer == 2 && region == 1) { // Outer, side C
454  if (eta < 7)
455  return 16 * (eta - 1) + phi;
456  else if (eta == 7 && phi == 11)
457  return 96;
458  else if (eta == 7 && phi == 13)
459  return 97;
460  else if (eta == 8 && phi == 11)
461  return 98;
462  else if (eta == 8 && phi == 13)
463  return 99;
464  } else if (layer == 3 && region == 1) { // Extra: put with outer
465  return 100 + 8 * (eta - 1) + (phi - 1) / 2;
466  }
467 
468  }
469 
470  else { // Endcap
471  if (layer == 0) { // Inner
472  int run3_offset = 0;
473  if (m_do_run3Geometry) run3_offset = 40;
474  if (eta < 3)
475  return 16 * (eta - 1) + phi - run3_offset;
476  else if (eta == 3)
477  return 32 + phi / 2 - run3_offset;
478  else if (eta == 4)
479  return 40 + phi / 2 - run3_offset;
480  else if (eta == 5)
481  return 48 + phi / 8 - run3_offset;
482 
483  } else if (layer == 1) { // Middle
484  return 16 * (eta - 1) + phi;
485  } else if (layer == 2) { // Outer
486  return 16 * (eta - 1) + phi;
487  } else if (layer == 3 && region == 2) { // Extra A: put with outer. Asymmetry between A and C
488  if (eta == 1 && phi == 2) return 96;
489  if (eta == 1 && phi == 4) return 97;
490  if (eta == 1 && phi == 10) return 98;
491  if (eta == 1 && phi == 12) return 99;
492  if (eta == 2 && phi == 2) return 100;
493  if (eta == 2 && phi == 10) return 101;
494  if (eta == 2 && phi == 12) return 102;
495  } else if (layer == 3 && region == 3) { // Extra C: put with outer.
496  if (eta == 1 || phi < 5)
497  return 80 + 16 * eta + phi;
498  else
499  return 79 + 16 * eta + phi; //(missing eta = 2, phi = 5)
500  }
501  }
502 
503  return -1;
504 }

◆ getChamber()

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

Definition at line 400 of file MDTRawDataUtilsRun3.cxx.

400  {
401  if (id >= m_hist_hash_list.size()) return StatusCode::FAILURE;
402  chamber = m_hist_hash_list[id].get();
403  if (!chamber) return StatusCode::FAILURE;
404 
405  return StatusCode::SUCCESS;
406 }

◆ getChamberName() [1/2]

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

Definition at line 391 of file MDTRawDataUtilsRun3.cxx.

391  {
392  IdentifierHash idHash{0};
393  const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
394  id_helper.get_module_hash(id, idHash);
395  MDTChamber* chamber{nullptr};
396  if (getChamber(idHash, chamber).isSuccess()) return chamber->getName();
397  return convertChamberName(id_helper.stationName(id), id_helper.stationEta(id), id_helper.stationPhi(id), "MDT");
398 }

◆ getChamberName() [2/2]

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

Definition at line 389 of file MDTRawDataUtilsRun3.cxx.

389 { 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  // treat empty tool handle case as in Monitored::Group
172  if (m_toolLookupMap.empty()) {
173  return m_dummy;
174  }
175 
176  if (!isInitialized()) {
177  ATH_MSG_FATAL(
178  "It seems that the AthMonitorAlgorithm::initialize was not called "
179  "in derived class initialize method");
180  } else {
181  std::string available = std::accumulate(
182  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
183  [](const std::string& s, auto h) { return s + "," + h.first; });
184  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
185  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
186  << "your python configuration and c++ filling code. Note: your available groups are {"
187  << available << "}.");
188  }
189  }
190  return m_dummy;
191 }

◆ 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 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ GetTubeMax()

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

Definition at line 333 of file MDTRawDataUtilsRun3.cxx.

333  {
334  int tubeMax(0);
335  if (hardware_name.substr(0, 4) == "BIS8") { // Why does mdtIdHelper get this one wrong?
336  tubeMax = 16 * 3;
337  } else if (hardware_name.substr(0, 4) == "BIR5") {
338  // tubeMax = 21*4 + 24*4;
339  tubeMax = 24 * 4 + 24 * 4;
340  } else if (hardware_name.substr(0, 4) == "BIR2" || hardware_name.substr(0, 4) == "BIR4") {
341  // tubeMax = 27*4 + 30*4;
342  tubeMax = 30 * 4 + 30 * 4;
343  } else if (hardware_name.substr(0, 4) == "BIR3") {
344  tubeMax = 36 * 4 + 36 * 4;
345  } else if (hardware_name.substr(0, 4) == "BIR1") {
346  // tubeMax = 24*4 + 30*4;
347  tubeMax = 30 * 4 + 30 * 4;
348  } else if (hardware_name.substr(0, 4) == "BMS4" || hardware_name.substr(0, 4) == "BMS6") {
349  // tubeMax = 40*3 + 48*3;
350  tubeMax = 48 * 3 + 48 * 3;
351  } else if (hardware_name == "EEL1A05" || hardware_name == "EEL1C05") {
352  tubeMax = 48 * 3 + 48 * 3;
353  } else if (hardware_name.substr(0, 3) == "BME") {
354  tubeMax = 546;
355  } else {
356  int numtubes = m_idHelperSvc->mdtIdHelper().tubeMax(digcoll_id);
357  int numlayers = m_idHelperSvc->mdtIdHelper().tubeLayerMax(digcoll_id);
358  int numML = m_idHelperSvc->mdtIdHelper().numberOfMultilayers(digcoll_id);
359  tubeMax = numtubes * numlayers * numML;
360  }
361  return tubeMax;
362 }

◆ handleEvent_effCalc_fillVects()

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

Definition at line 926 of file MdtRawDataMonAlg.cxx.

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

◆ initDeadChannels()

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

Definition at line 1234 of file MdtRawDataMonAlg.cxx.

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

◆ initialize()

StatusCode MdtRawDataMonAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 129 of file MdtRawDataMonAlg.cxx.

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

◆ 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 188 of file MdtRawDataMonAlg.h.

188 { return m_atlas_ready; }

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ mdtchamberId()

void MdtRawDataMonAlg::mdtchamberId ( )
private

Definition at line 294 of file MDTRawDataUtilsRun3.cxx.

294  {
295  ATH_MSG_DEBUG("in MDT ChambersIDvector");
296 
297  std::vector<Identifier>::const_iterator idfirst = m_idHelperSvc->mdtIdHelper().module_begin();
298  std::vector<Identifier>::const_iterator idlast = m_idHelperSvc->mdtIdHelper().module_end();
299 
300  IdContext mdtModuleContext = m_idHelperSvc->mdtIdHelper().module_context();
301  Identifier Id;
302  IdentifierHash Idhash;
303  for (std::vector<Identifier>::const_iterator i = idfirst; i != idlast; ++i) {
304  Id = *i;
305  int gethash_code = m_idHelperSvc->mdtIdHelper().get_hash(Id, Idhash, &mdtModuleContext);
306  m_chambersId.push_back(Id);
307  m_chambersIdHash.push_back(Idhash);
308 
309  std::string extid = m_idHelperSvc->mdtIdHelper().show_to_string(Id);
310  ATH_MSG_DEBUG("Adding the chamber Identifier: " << extid);
311  if (gethash_code == 0) {
312  ATH_MSG_VERBOSE(" its hash Id is " << Idhash);
313  } else {
314  ATH_MSG_VERBOSE(" hash Id NOT computed " << Idhash);
315  }
316  }
317  m_hist_hash_list.resize(m_chambersIdHash.size());
318 }

◆ mezzmdt()

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

Definition at line 321 of file MDTRawDataUtilsRun3.cxx.

321  {
322  int TotmezzTubes = 8;
323  if (cachedTubeLayerMax(digcoll_id) == 4) TotmezzTubes = 6;
324  int Imezz = (int)((m_idHelperSvc->mdtIdHelper().tube(digcoll_id) - 1) / TotmezzTubes) +
325  (int)((m_idHelperSvc->mdtIdHelper().multilayer(digcoll_id) - 1) * ((cachedTubeMax(digcoll_id)) / TotmezzTubes));
326 
327  return Imezz;
328 }

◆ 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 341 of file AthMonitorAlgorithm.cxx.

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

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ setIsATLASReady()

void MdtRawDataMonAlg::setIsATLASReady ( )
private

Definition at line 380 of file MDTRawDataUtilsRun3.cxx.

380  {
381  bool filterresult(true);
382  if (!m_DQFilterTools.empty()) {
383  ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
384  for (; filterresult && (ifilter != filterend); ++ifilter) { filterresult = (filterresult && (*ifilter)->accept()); }
385  }
386  m_atlas_ready = filterresult;
387 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ 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 199 of file AthMonitorAlgorithm.cxx.

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

◆ 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 172 of file MdtRawDataMonAlg.h.

◆ m_adcScale

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

Definition at line 180 of file MdtRawDataMonAlg.h.

◆ m_atlas_ready

bool MdtRawDataMonAlg::m_atlas_ready {false}
private

Definition at line 187 of file MdtRawDataMonAlg.h.

◆ m_BMGid

int MdtRawDataMonAlg::m_BMGid {-1}
private

Definition at line 183 of file MdtRawDataMonAlg.h.

◆ m_BMGpresent

bool MdtRawDataMonAlg::m_BMGpresent {false}
private

Definition at line 182 of file MdtRawDataMonAlg.h.

◆ m_chambersId

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

Definition at line 151 of file MdtRawDataMonAlg.h.

◆ m_chambersIdHash

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

Definition at line 152 of file MdtRawDataMonAlg.h.

◆ m_chi2_cut

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

Definition at line 174 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 184 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 113 of file MdtRawDataMonAlg.h.

◆ m_detMgr

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

Definition at line 193 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 175 of file MdtRawDataMonAlg.h.

◆ m_do_mdtchamberstatphislice

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

Definition at line 177 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 176 of file MdtRawDataMonAlg.h.

◆ m_do_run3Geometry

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

Definition at line 178 of file MdtRawDataMonAlg.h.

◆ m_doChamberHists

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

Definition at line 170 of file MdtRawDataMonAlg.h.

◆ m_doMdtESD

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

Definition at line 169 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 160 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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 185 of file MdtRawDataMonAlg.h.

◆ m_HighOccThreshold

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

Definition at line 179 of file MdtRawDataMonAlg.h.

◆ m_hist_hash_list

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

Definition at line 163 of file MdtRawDataMonAlg.h.

◆ m_idHelperSvc

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

Definition at line 109 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 156 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 157 of file MdtRawDataMonAlg.h.

◆ m_l1RoiKey

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

Definition at line 158 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 107 of file MdtRawDataMonAlg.h.

◆ m_maskNoisyTubes

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

Definition at line 171 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 149 of file MdtRawDataMonAlg.h.

◆ m_muonKey

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

Definition at line 159 of file MdtRawDataMonAlg.h.

◆ m_muonSelectionTool

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

Definition at line 110 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 173 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 147 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 154 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 105 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
MdtRawDataMonAlg::cachedTubeMax
int cachedTubeMax(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:1342
MdtRawDataMonAlg::m_nb_hits
Gaudi::Property< size_t > m_nb_hits
Definition: MdtRawDataMonAlg.h:173
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
MdtRawDataMonAlg::m_key_rpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc
Definition: MdtRawDataMonAlg.h:157
xAOD::identify
const Identifier & identify(const UncalibratedMeasurement *meas)
Returns the associated identifier from the muon measurement.
Definition: MuonSpectrometer/MuonPhaseII/Event/xAOD/xAODMuonPrepData/Root/UtilFunctions.cxx:61
MdtRawDataMonAlg::m_detMgr
const MuonGM::MuonDetectorManager * m_detMgr
Definition: MdtRawDataMonAlg.h:193
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
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
get_generator_info.result
result
Definition: get_generator_info.py:21
MDTOverviewHistogramStruct::tdc_mon_noiseBurst
std::vector< float > tdc_mon_noiseBurst
Definition: MdtRawDataMonAlg.cxx:77
MDTOverviewHistogramStruct::mdt_tube_perp_endcap
std::vector< float > mdt_tube_perp_endcap
Definition: MdtRawDataMonAlg.cxx:69
MdtRawDataMonAlg::m_firstEvent
std::atomic< int > m_firstEvent
Definition: MdtRawDataMonAlg.h:185
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:63
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
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:557
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:852
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:188
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
collListGuids.line
string line
Definition: collListGuids.py:77
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
MdtRawDataMonAlg::mdtchamberId
void mdtchamberId()
Definition: MDTRawDataUtilsRun3.cxx:294
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
calibdata.chamber
chamber
Definition: calibdata.py:32
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
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:177
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
MDTOverviewHistogramStruct
Definition: MdtRawDataMonAlg.cxx:55
MdtRawDataMonAlg::m_do_mdtChamberHits
Gaudi::Property< bool > m_do_mdtChamberHits
Definition: MdtRawDataMonAlg.h:175
MDTOverviewHistogramStruct::mdt_tube_y_endcap
std::vector< float > mdt_tube_y_endcap
Definition: MdtRawDataMonAlg.cxx:67
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:154
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:407
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:408
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:1201
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:1068
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:174
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:263
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:800
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
MDTOverviewHistogramStruct::tdc_mon
std::vector< float > tdc_mon
Definition: MdtRawDataMonAlg.cxx:73
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition: MdtPrepData.h:146
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
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:480
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:154
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
MdtRawDataMonAlg::binMdtRegional
virtual StatusCode binMdtRegional(TH2 *, std::string_view xAxis)
Definition: MDTRawDataUtilsRun3.cxx:75
MdtRawDataMonAlg::GetTubeMax
int GetTubeMax(const Identifier &digcoll_id, std::string_view hardware_name)
Definition: MDTRawDataUtilsRun3.cxx:333
MDTOverviewHistogramStruct::mdt_tube_perp_barrel
std::vector< float > mdt_tube_perp_barrel
Definition: MdtRawDataMonAlg.cxx:59
MDTOverviewHistogramStruct::tdc_mon_noiseBurst_adcCut
std::vector< float > tdc_mon_noiseBurst_adcCut
Definition: MdtRawDataMonAlg.cxx:80
MDTOverviewHistogramStruct::adc_mon
std::vector< float > adc_mon
Definition: MdtRawDataMonAlg.cxx:74
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:179
tubeMax
double tubeMax
Definition: MDT_ResponseTest.cxx:31
MDTOverviewHistogramStruct::mdt_tube_y_ovl
std::vector< float > mdt_tube_y_ovl
Definition: MdtRawDataMonAlg.cxx:62
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
A
skel.l2
l2
Definition: skel.GENtoEVGEN.py:410
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:152
MdtRawDataMonAlg::getChamber
StatusCode getChamber(const IdentifierHash &id, MDTChamber *&chamber) const
Definition: MDTRawDataUtilsRun3.cxx:400
MDTChamber
Definition: MDTChamber.h:22
MuonGM::MuonReadoutElement::GlobalToAmdbLRSCoords
virtual Amg::Vector3D GlobalToAmdbLRSCoords(const Amg::Vector3D &x) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:150
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:176
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:293
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
MDTOverviewHistogramStruct::mdt_tube_x_barrel
std::vector< float > mdt_tube_x_barrel
Definition: MdtRawDataMonAlg.cxx:56
lumiFormat.i
int i
Definition: lumiFormat.py:85
MDTOverviewHistogramStruct::mdt_tube_z_barrel
std::vector< float > mdt_tube_z_barrel
Definition: MdtRawDataMonAlg.cxx:58
MdtRawDataMonAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MdtRawDataMonAlg.h:113
MDTOverviewHistogramStruct::adc_mon_noiseBurst_notNoisy
std::vector< float > adc_mon_noiseBurst_notNoisy
Definition: MdtRawDataMonAlg.cxx:79
MDTOverviewHistogramStruct::adc_mon_nosel
std::vector< float > adc_mon_nosel
Definition: MdtRawDataMonAlg.cxx:71
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:169
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:111
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Trk::Segment
Definition: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:56
MDTOverviewHistogramStruct::mdt_tube_x_ovl
std::vector< float > mdt_tube_x_ovl
Definition: MdtRawDataMonAlg.cxx:61
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:79
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:187
MdtRawDataMonAlg::m_ADCCut
Gaudi::Property< size_t > m_ADCCut
Definition: MdtRawDataMonAlg.h:172
MdtRawDataMonAlg::m_hist_hash_list
std::vector< std::unique_ptr< MDTChamber > > m_hist_hash_list
Definition: MdtRawDataMonAlg.h:163
MdtRawDataMonAlg::m_muon_type
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muon_type
Definition: MdtRawDataMonAlg.h:149
convertChamberName
std::string convertChamberName(int, int, int, const std::string &)
Definition: MuonChamberNameConverter.cxx:10
MDTOverviewHistogramStruct::mdt_tube_perp_ovl
std::vector< float > mdt_tube_perp_ovl
Definition: MdtRawDataMonAlg.cxx:64
MdtRawDataMonAlg::cachedTubeLayerMax
int cachedTubeLayerMax(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:1346
MDTOverviewHistogramStruct::tdc_mon_adcCut
std::vector< float > tdc_mon_adcCut
Definition: MdtRawDataMonAlg.cxx:82
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
MdtRawDataMonAlg::m_muonKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey
Definition: MdtRawDataMonAlg.h:159
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:810
lumiFormat.array
array
Definition: lumiFormat.py:91
Trk::MeasurementBase
Definition: MeasurementBase.h:58
MdtRawDataMonAlg::binMdtGlobal
virtual StatusCode binMdtGlobal(TH2 *, char ecap)
Definition: MDTRawDataUtilsRun3.cxx:24
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:171
AthMonitorAlgorithm::Environment_t::online
@ online
Muon::MdtPrepData::tdc
int tdc() const
Returns the TDC (typically range is 0 to 2500).
Definition: MdtPrepData.h:145
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
MdtRawDataMonAlg::m_DeadChannels
std::map< Identifier, std::set< Identifier > > m_DeadChannels
Definition: MdtRawDataMonAlg.h:184
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
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:364
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
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:151
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
MdtRawDataMonAlg::mezzmdt
int mezzmdt(const Identifier &id) const
Definition: MDTRawDataUtilsRun3.cxx:321
MdtRawDataMonAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtRawDataMonAlg.h:109
MDTOverviewHistogramStruct::tdc_mon_nosel
std::vector< float > tdc_mon_nosel
Definition: MdtRawDataMonAlg.cxx:72
MdtRawDataMonAlg::m_adcScale
Gaudi::Property< size_t > m_adcScale
Definition: MdtRawDataMonAlg.h:180
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:805
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
MdtRawDataMonAlg::CorrectTubeMax
static void CorrectTubeMax(const std::string &hardware_name, int &numTubes)
Definition: MDTRawDataUtilsRun3.cxx:282
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::iPhi
@ iPhi
Definition: ParamDefs.h:47
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:287
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:154
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
MdtRawDataMonAlg::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MdtRawDataMonAlg.h:160
MdtRawDataMonAlg::m_segm_type
SG::ReadHandleKeyArray< Trk::SegmentCollection > m_segm_type
Definition: MdtRawDataMonAlg.h:147
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:63
MDTOverviewHistogramStruct::mdt_tube_y_barrel
std::vector< float > mdt_tube_y_barrel
Definition: MdtRawDataMonAlg.cxx:57
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
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:50
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:737
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
MDTOverviewHistogramStruct::noiseBurst
std::vector< int > noiseBurst
Definition: MdtRawDataMonAlg.cxx:75
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
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:156
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
MDTChamber::getName
const std::string & getName() const
Definition: MDTChamber.h:67
MdtRawDataMonAlg::m_do_run3Geometry
Gaudi::Property< bool > m_do_run3Geometry
Definition: MdtRawDataMonAlg.h:178
MDTOverviewHistogramStruct::mdt_tube_z_endcap
std::vector< float > mdt_tube_z_endcap
Definition: MdtRawDataMonAlg.cxx:68
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
skel.l1
l1
Definition: skel.GENtoEVGEN.py:409
MdtIdHelper::get_module_hash
virtual int get_module_hash(const Identifier &id, IdentifierHash &hash_id) const override
Definition: MdtIdHelper.cxx:319
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MdtRawDataMonAlg::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition: MdtRawDataMonAlg.cxx:1234
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:159
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
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
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
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:586
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
MdtRawDataMonAlg::m_doChamberHists
Gaudi::Property< bool > m_doChamberHists
Definition: MdtRawDataMonAlg.h:170
xAOD::iEta
setScale setgFexType iEta
Definition: gFexJetRoI_v1.cxx:77
MdtRawDataMonAlg::m_masked_tubes
std::unique_ptr< MDTNoisyTubes > m_masked_tubes
Definition: MdtRawDataMonAlg.h:107
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
xAOD::numberOfPhiLayers
@ numberOfPhiLayers
layers with a trigger phi hit [unit8_t].
Definition: TrackingPrimitives.h:291
MdtRawDataMonAlg::binMdtGlobal_byLayer
virtual StatusCode binMdtGlobal_byLayer(TH2 *, TH2 *, TH2 *)
Definition: MDTRawDataUtilsRun3.cxx:138
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
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
MDTSegmentHistogramStruct
Definition: MdtRawDataMonAlg.cxx:114
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:182
MdtRawDataMonAlg::handleEvent_effCalc_fillVects
StatusCode handleEvent_effCalc_fillVects(const Trk::SegmentCollection *segms, MDTSegmentHistogramStruct(&vects)[4][4][16]) const
Definition: MdtRawDataMonAlg.cxx:926
MdtRawDataMonAlg::m_l1RoiKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_l1RoiKey
Definition: MdtRawDataMonAlg.h:158
MdtRawDataMonAlg::fillMDTOverviewHistograms
virtual void fillMDTOverviewHistograms(const MDTOverviewHistogramStruct &vects) const
Definition: MdtRawDataMonAlg.cxx:548
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:78
monAlg::TubeTraversedBySegment
Definition: MdtRawDataMonAlg.h:67
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
MdtRawDataMonAlg::m_BMGid
int m_BMGid
Definition: MdtRawDataMonAlg.h:183
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:66
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
MdtRawDataMonAlg::getChamberName
std::string getChamberName(const Muon::MdtPrepData *) const
Definition: MDTRawDataUtilsRun3.cxx:389
collisions
Definition: collisions.py:1
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Apr 14 2025 21:38:39 for ATLAS Offline Software by   doxygen 1.8.18