ATLAS Offline Software
Loading...
Searching...
No Matches
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:

Public Types

enum class  Environment_t {
  user = 0 , online , tier0 , tier0Raw ,
  tier0ESD , AOD , altprod
}
 Specifies the processing environment. More...
enum class  DataType_t {
  userDefined = 0 , monteCarlo , collisions , cosmics ,
  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
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements.
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.
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.
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference.
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.
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.
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name.
Environment_t environment () const
 Accessor functions for the environment.
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object.
DataType_t dataType () const
 Accessor functions for the data type.
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object.
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array.
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member.
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed.
SG::ReadHandle< xAOD::EventInfo > GetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing.
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds)
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction.
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector.
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
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.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

Protected Attributes

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

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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

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.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
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 370 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 class 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 194 of file AthMonitorAlgorithm.h.

194 {
195 userDefined = 0,
196 monteCarlo,
197 collisions,
198 cosmics,
199 heavyIonCollisions,
200 };
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:561

◆ Environment_t

enum class 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 175 of file AthMonitorAlgorithm.h.

175 {
176 user = 0,
177 online,
178 tier0,
179 tier0Raw,
180 tier0ESD,
181 AOD,
182 altprod,
183 };

Constructor & Destructor Documentation

◆ MdtRawDataMonAlg()

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

Definition at line 125 of file MdtRawDataMonAlg.cxx.

125: AthMonitorAlgorithm(name, pSvcLocator) {}
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthMonitorAlgorithm.cxx:8

◆ ~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}
Trk::iPhi
@ iPhi
Definition ParamDefs.h:47
xAOD::iEta
setScale setgFexType iEta
Definition gFexJetRoI_v1.cxx:77

◆ 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}
PrintTrkAnaSummary.l
l
Printing final latex table to .tex output file.
Definition PrintTrkAnaSummary.py:370

◆ 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}
MdtRawDataMonAlg::m_detMgr
const MuonGM::MuonDetectorManager * m_detMgr
Definition MdtRawDataMonAlg.h:193
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.

◆ 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}
MuonGM::MdtReadoutElement::getNtubesperlayer
int getNtubesperlayer() const
Returns the number of tubes in each tube layer.

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

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}
HI::TowerBins::numLayers
constexpr unsigned int numLayers()
Definition HIEventDefs.h:23

◆ 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 224 of file AthMonitorAlgorithm.h.

224{ return m_dataType; }
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition AthMonitorAlgorithm.h:356

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

144 {
145 // convert the string to all lowercase
146 std::string lowerCaseStr = str;
147 std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
148
149 // check if it matches one of the enum choices
150 if( lowerCaseStr == "userdefined" ) {
151 return DataType_t::userDefined;
152 } else if( lowerCaseStr == "montecarlo" ) {
153 return DataType_t::monteCarlo;
154 } else if( lowerCaseStr == "collisions" ) {
155 return DataType_t::collisions;
156 } else if( lowerCaseStr == "cosmics" ) {
157 return DataType_t::cosmics;
158 } else if( lowerCaseStr == "heavyioncollisions" ) {
159 return DataType_t::heavyIonCollisions;
160 } else { // otherwise, warn the user and return "userDefined"
161 ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
162 <<str<<", returning userDefined.");
163 return DataType_t::userDefined;
164 }
165}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
tolower
void tolower(std::string &s)
Definition AthenaSummarySvc.cxx:108

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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 208 of file AthMonitorAlgorithm.h.

208{ return m_environment; }
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition AthMonitorAlgorithm.h:355

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

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

◆ evtStore()

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

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

77 {
78
79 // Checks that all of the DQ filters are passed. If any one of the filters
80 // fails, return SUCCESS code and do not fill the histograms with the event.
81 for ( const auto& filterItr : m_DQFilterTools ) {
82 if (!filterItr->accept()) {
83 ATH_MSG_DEBUG("Event rejected due to filter tool.");
84 return StatusCode::SUCCESS;
85 }
86 }
87
88 // Trigger: If there is a decision tool and the chains fail, skip the event.
89 if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
90 ATH_MSG_DEBUG("Event rejected due to trigger filter.");
91 return StatusCode::SUCCESS;
92 }
93
94 ATH_MSG_DEBUG("Event accepted!");
95 return fillHistograms(ctx);
96}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition AthMonitorAlgorithm.cxx:203
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition AthMonitorAlgorithm.h:361
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition AthMonitorAlgorithm.h:345
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition AthMonitorAlgorithm.h:346

◆ 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 ( ) const
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}
AthCommonReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition AthCommonReentrantAlgorithm.h:40

◆ 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}
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition AthUnlikelyMacros.h:17
Muon::MuonPrepDataCollection< RpcPrepData >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
MDTChamber::getName
const std::string & getName() const
Definition MDTChamber.h:67
MdtRawDataMonAlg::fillMDTHistograms
virtual StatusCode fillMDTHistograms(const Muon::MdtPrepData *) const
Definition MdtRawDataMonAlg.cxx:852
MdtRawDataMonAlg::getChamber
StatusCode getChamber(const IdentifierHash &id, MDTChamber *&chamber) const
Definition MDTRawDataUtilsRun3.cxx:400
MdtRawDataMonAlg::m_muon_type
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muon_type
Definition MdtRawDataMonAlg.h:149
MdtRawDataMonAlg::handleEvent_effCalc_fillVects
StatusCode handleEvent_effCalc_fillVects(const Trk::SegmentCollection *segms, MDTSegmentHistogramStruct(&vects)[4][4][16]) const
Definition MdtRawDataMonAlg.cxx:926
MdtRawDataMonAlg::getChamberName
std::string getChamberName(const Muon::MdtPrepData *) const
Definition MDTRawDataUtilsRun3.cxx:389
MdtRawDataMonAlg::m_key_rpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc
Definition MdtRawDataMonAlg.h:157
MdtRawDataMonAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition MdtRawDataMonAlg.h:109
MdtRawDataMonAlg::m_ADCCut
Gaudi::Property< size_t > m_ADCCut
Definition MdtRawDataMonAlg.h:172
MdtRawDataMonAlg::m_key_mdt
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt
Definition MdtRawDataMonAlg.h:156
MdtRawDataMonAlg::m_do_run3Geometry
Gaudi::Property< bool > m_do_run3Geometry
Definition MdtRawDataMonAlg.h:178
MdtRawDataMonAlg::m_doMdtESD
Gaudi::Property< bool > m_doMdtESD
Definition MdtRawDataMonAlg.h:169
MdtRawDataMonAlg::fillMDTSummaryHistograms
virtual StatusCode fillMDTSummaryHistograms(std::array< MDTSummaryHistogramStruct, 4096 > *vects, int lb) const
Definition MdtRawDataMonAlg.cxx:737
MdtRawDataMonAlg::m_do_mdtchamberstatphislice
Gaudi::Property< bool > m_do_mdtchamberstatphislice
Definition MdtRawDataMonAlg.h:177
MdtRawDataMonAlg::m_adcScale
Gaudi::Property< size_t > m_adcScale
Definition MdtRawDataMonAlg.h:180
MdtRawDataMonAlg::m_HighOccThreshold
Gaudi::Property< size_t > m_HighOccThreshold
Definition MdtRawDataMonAlg.h:179
MdtRawDataMonAlg::fillMDTOverviewHistograms
virtual void fillMDTOverviewHistograms(const MDTOverviewHistogramStruct &vects) const
Definition MdtRawDataMonAlg.cxx:548
MdtRawDataMonAlg::m_segm_type
SG::ReadHandleKeyArray< Trk::SegmentCollection > m_segm_type
Definition MdtRawDataMonAlg.h:147
MdtRawDataMonAlg::m_l1RoiKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_l1RoiKey
Definition MdtRawDataMonAlg.h:158
MdtRawDataMonAlg::fillMDTSegmentHistograms
virtual StatusCode fillMDTSegmentHistograms(const MDTSegmentHistogramStruct(&vects)[4][4][16]) const
Definition MdtRawDataMonAlg.cxx:1201
MdtRawDataMonAlg::m_tubesperchamber_map
std::map< std::string, int > m_tubesperchamber_map
Definition MdtRawDataMonAlg.h:154
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
MdtRawDataMonAlg::m_doChamberHists
Gaudi::Property< bool > m_doChamberHists
Definition MdtRawDataMonAlg.h:170
MdtRawDataMonAlg::m_firstEvent
std::atomic< int > m_firstEvent
Definition MdtRawDataMonAlg.h:185
MdtRawDataMonAlg::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition MdtRawDataMonAlg.h:160
MdtRawDataMonAlg::fillMDTOverviewVects
virtual void fillMDTOverviewVects(const Muon::MdtPrepData *, bool &isNoiseBurstCandidate, MDTOverviewHistogramStruct &vects) const
Definition MdtRawDataMonAlg.cxx:480
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition RIO_OnTrack.h:152
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
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.
Definition AthMonitorAlgorithm.cxx:99
CaloNoise_fillDB.mu
mu
Definition CaloNoise_fillDB.py:51
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition MonitoredCollection.h:38
TRTCalib_Extractor.hits
hits
Definition TRTCalib_Extractor.py:35
xAOD::numberOfTriggerEtaLayers
@ numberOfTriggerEtaLayers
layers with trigger eta hits [unit8_t].
Definition TrackingPrimitives.h:293
xAOD::numberOfPhiLayers
@ numberOfPhiLayers
layers with a trigger phi hit [unit8_t].
Definition TrackingPrimitives.h:291

◆ 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}
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
MdtRawDataMonAlg::mezzmdt
int mezzmdt(const Identifier &id) const
Definition MDTRawDataUtilsRun3.cxx:321
MdtRawDataMonAlg::cachedTubeMax
int cachedTubeMax(const Identifier &id) const
Definition MDTRawDataUtilsRun3.cxx:1342
MdtRawDataMonAlg::m_masked_tubes
std::unique_ptr< MDTNoisyTubes > m_masked_tubes
Definition MdtRawDataMonAlg.h:107
MdtRawDataMonAlg::ChamberTubeNumberCorrection
static void ChamberTubeNumberCorrection(int &tubeNum, std::string_view hardware_name, int tubePos, int numLayers)
Definition MDTRawDataUtilsRun3.cxx:263
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition MdtPrepData.h:146
Muon::MdtPrepData::tdc
int tdc() const
Returns the TDC (typically range is 0 to 2500).
Definition MdtPrepData.h:145
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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:95

◆ 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}
MDTOverviewHistogramStruct::adc_mon_nosel
std::vector< float > adc_mon_nosel
Definition MdtRawDataMonAlg.cxx:71
MDTOverviewHistogramStruct::mdt_tube_z_barrel
std::vector< float > mdt_tube_z_barrel
Definition MdtRawDataMonAlg.cxx:58
MDTOverviewHistogramStruct::tdc_mon_adcCut
std::vector< float > tdc_mon_adcCut
Definition MdtRawDataMonAlg.cxx:82
MDTOverviewHistogramStruct::mdt_tube_x_ovl
std::vector< float > mdt_tube_x_ovl
Definition MdtRawDataMonAlg.cxx:61
MDTOverviewHistogramStruct::mdt_tube_perp_ovl
std::vector< float > mdt_tube_perp_ovl
Definition MdtRawDataMonAlg.cxx:64
MDTOverviewHistogramStruct::mdt_tube_x_endcap
std::vector< float > mdt_tube_x_endcap
Definition MdtRawDataMonAlg.cxx:66
MDTOverviewHistogramStruct::tdc_mon_nosel
std::vector< float > tdc_mon_nosel
Definition MdtRawDataMonAlg.cxx:72
MDTOverviewHistogramStruct::mdt_tube_x_barrel
std::vector< float > mdt_tube_x_barrel
Definition MdtRawDataMonAlg.cxx:56
MDTOverviewHistogramStruct::mdt_tube_y_ovl
std::vector< float > mdt_tube_y_ovl
Definition MdtRawDataMonAlg.cxx:62
MDTOverviewHistogramStruct::adc_mon_noiseBurst_notNoisy
std::vector< float > adc_mon_noiseBurst_notNoisy
Definition MdtRawDataMonAlg.cxx:79
MDTOverviewHistogramStruct::mdt_tube_y_barrel
std::vector< float > mdt_tube_y_barrel
Definition MdtRawDataMonAlg.cxx:57
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::mdt_tube_z_endcap
std::vector< float > mdt_tube_z_endcap
Definition MdtRawDataMonAlg.cxx:68
MDTOverviewHistogramStruct::tdc_mon
std::vector< float > tdc_mon
Definition MdtRawDataMonAlg.cxx:73
MDTOverviewHistogramStruct::mdt_tube_perp_endcap
std::vector< float > mdt_tube_perp_endcap
Definition MdtRawDataMonAlg.cxx:69
MDTOverviewHistogramStruct::mdt_tube_z_ovl
std::vector< float > mdt_tube_z_ovl
Definition MdtRawDataMonAlg.cxx:63
MDTOverviewHistogramStruct::adc_mon
std::vector< float > adc_mon
Definition MdtRawDataMonAlg.cxx:74
MDTOverviewHistogramStruct::mdt_tube_y_endcap
std::vector< float > mdt_tube_y_endcap
Definition MdtRawDataMonAlg.cxx:67

◆ 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}
MdtRawDataMonAlg::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition MdtRawDataMonAlg.h:113
MuonGM::MdtReadoutElement::tubePos
Amg::Vector3D tubePos(const Identifier &id) const
Returns the global position of the given tube.
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:206
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition ReadCondHandle.h:67
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
MDTOverviewHistogramStruct::adc_mon_noiseBurst
std::vector< float > adc_mon_noiseBurst
Definition MdtRawDataMonAlg.cxx:78
MDTOverviewHistogramStruct::tdc_mon_noiseBurst
std::vector< float > tdc_mon_noiseBurst
Definition MdtRawDataMonAlg.cxx:77

◆ 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}
MdtRawDataMonAlg::m_do_mdttdccut_sector
Gaudi::Property< bool > m_do_mdttdccut_sector
Definition MdtRawDataMonAlg.h:176
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition NSWSTGTPDecodeBitmaps.h:161
TRT::Hit::layer
@ layer
Definition HitInfo.h:79

◆ 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}
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
MdtRawDataMonAlg::m_do_mdtChamberHits
Gaudi::Property< bool > m_do_mdtChamberHits
Definition MdtRawDataMonAlg.h:175
lb
int lb
Definition globals.cxx:23
xAOD::uint16_t
setWord1 uint16_t
Definition eFexEMRoI_v1.cxx:93

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

◆ 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 }
AthCommonReentrantAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:96

◆ 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}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition MuonStationIndex.cxx:104

◆ 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}
MdtRawDataMonAlg::m_hist_hash_list
std::vector< std::unique_ptr< MDTChamber > > m_hist_hash_list
Definition MdtRawDataMonAlg.h:163
Base_Fragment.id
id
Definition Sherpa_i/share/common/Base_Fragment.py:59

◆ 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}
convertChamberName
std::string convertChamberName(int, int, int, const std::string &)
Definition MuonChamberNameConverter.cxx:13
MdtIdHelper::get_module_hash
virtual int get_module_hash(const Identifier &id, IdentifierHash &hash_id) const override
Definition MdtIdHelper.cxx:324
MuonIdHelper::stationEta
int stationEta(const Identifier &id) const
Definition MuonIdHelper.cxx:815
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition MuonIdHelper.cxx:820
MuonIdHelper::stationName
int stationName(const Identifier &id) const
Definition MuonIdHelper.cxx:810

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

111 {
112 return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
113}
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition AthMonitorAlgorithm.h:367

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

168 {
169 // get the pointer to the tool, and check that it exists
170 auto idx = m_toolLookupMap.find(name);
171 if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
172 return m_tools[idx->second];
173 }
174 else {
175 // treat empty tool handle case as in Monitored::Group
176 if (m_toolLookupMap.empty()) {
177 return m_dummy;
178 }
179
180 if (!isInitialized()) {
181 ATH_MSG_FATAL(
182 "It seems that the AthMonitorAlgorithm::initialize was not called "
183 "in derived class initialize method");
184 } else {
185 std::string available = std::accumulate(
186 m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
187 [](const std::string& s, auto h) { return s + "," + h.first; });
188 ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
189 << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
190 << "your python configuration and c++ filling code. Note: your available groups are {"
191 << available << "}.");
192 }
193 }
194 return m_dummy;
195}
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_LIKELY
#define ATH_LIKELY(x)
Definition AthUnlikelyMacros.h:16
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition AthMonitorAlgorithm.h:372
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition AthMonitorAlgorithm.h:374
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition AthMonitorAlgorithm.h:341
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69

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

198 {
199 return m_trigDecTool;
200}

◆ 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}
tubeMax
double tubeMax
Definition MDT_ResponseTest.cxx:31

◆ 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}
MdtIdHelper::tubeLayerMin
static int tubeLayerMin()
Definition MdtIdHelper.cxx:769
MdtIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int multilayer, int tubeLayer, int tube) const
Definition MdtIdHelper.cxx:664
MdtIdHelper::tubeMin
static int tubeMin()
Definition MdtIdHelper.cxx:773
MdtRawDataMonAlg::m_DeadChannels
std::map< Identifier, std::set< Identifier > > m_DeadChannels
Definition MdtRawDataMonAlg.h:184
MdtRawDataMonAlg::CorrectLayerMax
static void CorrectLayerMax(const std::string &hardware_name, int &numLayers)
Definition MDTRawDataUtilsRun3.cxx:287
MdtRawDataMonAlg::cachedTubeLayerMax
int cachedTubeLayerMax(const Identifier &id) const
Definition MDTRawDataUtilsRun3.cxx:1346
MdtRawDataMonAlg::m_chi2_cut
Gaudi::Property< bool > m_chi2_cut
Definition MdtRawDataMonAlg.h:174
MdtRawDataMonAlg::m_nb_hits
Gaudi::Property< size_t > m_nb_hits
Definition MdtRawDataMonAlg.h:173
MdtRawDataMonAlg::AinB
static bool AinB(int A, std::vector< int > &B)
Definition MDTRawDataUtilsRun3.cxx:364
MdtRawDataMonAlg::CorrectTubeMax
static void CorrectTubeMax(const std::string &hardware_name, int &numTubes)
Definition MDTRawDataUtilsRun3.cxx:282
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
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
MuonGM::MuonReadoutElement::GlobalToAmdbLRSCoords
virtual Amg::Vector3D GlobalToAmdbLRSCoords(const Amg::Vector3D &x) const
Definition MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:94
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:173
Muon::MdtDriftCircleOnTrack::prepRawData
virtual const MdtPrepData * prepRawData() const override final
Returns the PrepRawData used to create this corrected measurement.
Definition MdtDriftCircleOnTrack.h:257
Muon::MuonSegment::rioOnTrack
const Trk::RIO_OnTrack * rioOnTrack(unsigned int) const
returns the RIO_OnTrack (also known as ROT) objects depending on the integer
Definition MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:187
Muon::MuonSegment::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
global position
Definition MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:157
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition FitQuality.h:56
Trk::FitQuality::doubleNumberDoF
double doubleNumberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as double
Definition FitQuality.h:68
Trk::Segment::fitQuality
const FitQuality * fitQuality() const
return the FitQuality object, returns NULL if no FitQuality is defined
Definition Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:160
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition GeoPrimitives.h:46
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

◆ 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}
MuonGM::MdtReadoutElement::getMultilayer
int getMultilayer() const
Returns the multilayer represented by the readout element.

◆ 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}
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition AthMonitorAlgorithm.cxx:22
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
MdtRawDataMonAlg::binMdtGlobal_byLayer
virtual StatusCode binMdtGlobal_byLayer(TH2 *, TH2 *, TH2 *)
Definition MDTRawDataUtilsRun3.cxx:138
MdtRawDataMonAlg::m_chambersId
std::vector< Identifier > m_chambersId
Definition MdtRawDataMonAlg.h:151
MdtRawDataMonAlg::binMdtGlobal
virtual StatusCode binMdtGlobal(TH2 *, char ecap)
Definition MDTRawDataUtilsRun3.cxx:24
MdtRawDataMonAlg::m_chambersIdHash
std::vector< IdentifierHash > m_chambersIdHash
Definition MdtRawDataMonAlg.h:152
MdtRawDataMonAlg::m_maskNoisyTubes
Gaudi::Property< bool > m_maskNoisyTubes
Definition MdtRawDataMonAlg.h:171
MdtRawDataMonAlg::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition MdtRawDataMonAlg.cxx:1234
MdtRawDataMonAlg::m_muonKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonKey
Definition MdtRawDataMonAlg.h:159
MuonGM::MuonDetectorManager::getMuonStation
const MuonStation * getMuonStation(const std::string &stName, int eta, int phi) const
Definition MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:139
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:130
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
test_pyathena.counter
counter
Definition test_pyathena.py:15

◆ 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 ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

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()

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

Definition at line 24 of file AthCommonMsg.h.

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

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

345 {
346 std::string item;
347 std::stringstream ss(line);
348
349 ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
350
351 while ( std::getline(ss, item, ',') ) {
352 std::stringstream iss(item); // remove whitespace
353 iss >> item;
354 result.push_back(item);
355 }
356
357 return StatusCode::SUCCESS;
358}
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37
get_generator_info.result
result
Definition get_generator_info.py:21

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

◆ 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 }
AthCommonReentrantAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:100

◆ 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 HypoBase, and InputMakerBase.

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}
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

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

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

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

172{this, "ADCCut", 50};

◆ m_adcScale

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

Definition at line 180 of file MdtRawDataMonAlg.h.

180{this, "ADCScale", 1};

◆ m_atlas_ready

bool MdtRawDataMonAlg::m_atlas_ready {false}
private

Definition at line 187 of file MdtRawDataMonAlg.h.

187{false};

◆ m_BMGid

int MdtRawDataMonAlg::m_BMGid {-1}
private

Definition at line 183 of file MdtRawDataMonAlg.h.

183{-1};

◆ m_BMGpresent

bool MdtRawDataMonAlg::m_BMGpresent {false}
private

Definition at line 182 of file MdtRawDataMonAlg.h.

182{false};

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

174{this, "Eff_chi2Cut", 10};

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 356 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 358 of file AthMonitorAlgorithm.h.

358{this,"DataType","userDefined"};

◆ m_DeadChannels

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

Definition at line 184 of file MdtRawDataMonAlg.h.

184{};

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 365 of file AthMonitorAlgorithm.h.

365{this,"DefaultLBDuration",60.};

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 366 of file AthMonitorAlgorithm.h.

366{this,"DetailLevel",0};

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

113 {this, "DetectorManagerKey", "MuonDetectorManager",
114 "Key of input MuonDetectorManager condition data"};

◆ m_detMgr

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

Definition at line 193 of file MdtRawDataMonAlg.h.

193{nullptr};

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

175{this, "do_mdtChamberHits", true};

◆ m_do_mdtchamberstatphislice

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

Definition at line 177 of file MdtRawDataMonAlg.h.

177{this, "do_mdtchamberstatphislice", true};

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

176{this, "do_mdttdccut_sector", true};

◆ m_do_run3Geometry

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

Definition at line 178 of file MdtRawDataMonAlg.h.

178{this, "do_Run3Geometry", false};

◆ m_doChamberHists

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

Definition at line 170 of file MdtRawDataMonAlg.h.

170{this, "DoChamberHist", true};

◆ m_doMdtESD

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

Definition at line 169 of file MdtRawDataMonAlg.h.

169{this, "DoMdtEsd", false};

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 346 of file AthMonitorAlgorithm.h.

346{this,"FilterTools",{}};

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 374 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 377 of file AthMonitorAlgorithm.h.

377 {this,
378 "EnforceExpressTriggers", false,
379 "Requires that matched triggers made the event enter the express stream"};

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 355 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 357 of file AthMonitorAlgorithm.h.

357{this,"Environment","user"};

◆ m_eventInfo

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

Definition at line 160 of file MdtRawDataMonAlg.h.

160{this, "EventInfo", "EventInfo", "event info"};

◆ m_EventInfoKey

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

Key for retrieving EventInfo from StoreGate.

Definition at line 367 of file AthMonitorAlgorithm.h.

367{this,"EventInfoKey","EventInfo"};

◆ 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 363 of file AthMonitorAlgorithm.h.

363{this,"FileKey",""};

◆ m_firstEvent

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

Definition at line 185 of file MdtRawDataMonAlg.h.

185{-1};

◆ m_HighOccThreshold

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

Definition at line 179 of file MdtRawDataMonAlg.h.

179{this, "nHits_NoiseThreshold", 16000};

◆ m_hist_hash_list

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

Definition at line 163 of file MdtRawDataMonAlg.h.

163{};

◆ m_idHelperSvc

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

Definition at line 109 of file MdtRawDataMonAlg.h.

109{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

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

156{this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"};

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

157{this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"};

◆ m_l1RoiKey

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

Definition at line 158 of file MdtRawDataMonAlg.h.

158{this, "L1RoiKey", "LVL1MuonRoIs", "L1 muon ROIs"};

◆ m_lbDurationDataKey

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

Definition at line 350 of file AthMonitorAlgorithm.h.

351{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

◆ m_lumiDataKey

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

Definition at line 348 of file AthMonitorAlgorithm.h.

349{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

◆ m_masked_tubes

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

Definition at line 107 of file MdtRawDataMonAlg.h.

107{nullptr};

◆ m_maskNoisyTubes

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

Definition at line 171 of file MdtRawDataMonAlg.h.

171{this, "maskNoisyTubes", true};

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

149{this, "Muon_type", "ExtrapolatedMuonTrackParticles", "extrapolated muons"};

◆ m_muonKey

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

Definition at line 159 of file MdtRawDataMonAlg.h.

159{this, "MuonKey", "Muons", "muons"};

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

173{this, "Eff_nHits", 5};

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

147 {
148 this, "SegmentKey", {"TrkMuonSegments", "UnAssocMuonTrkSegments"}, "muon segments"};

◆ m_toolLookupMap

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

341{this,"GMTools",{}};

◆ m_trigDecTool

PublicToolHandle<Trig::TrigDecisionTool> AthMonitorAlgorithm::m_trigDecTool
protectedinherited

Tool to tell whether a specific trigger is passed.

Definition at line 345 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 360 of file AthMonitorAlgorithm.h.

360{this,"TriggerChain",""};

◆ m_trigLiveFractionDataKey

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

Definition at line 352 of file AthMonitorAlgorithm.h.

353{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"};

◆ 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 364 of file AthMonitorAlgorithm.h.

364{this,"EnableLumi",false};

◆ 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 361 of file AthMonitorAlgorithm.h.

◆ s_detectorElementMask

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:
Generated on for ATLAS Offline Software by doxygen 1.14.0