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 (std::string_view 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) const
 Calculate the average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx) const
 Calculate instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float lbLuminosityPerBCID (const EventContext &ctx) const
 Calculate the instantaneous luminosity per bunch crossing.
virtual double lbDuration (const EventContext &ctx) const
 Calculate the duration of the luminosity block (in seconds).
virtual float lbAverageLivefraction (const EventContext &ctx) const
 Calculate the average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx) const
 Calculate the live fraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx) 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 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
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
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 (const EventContext &ctx)
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, CxxUtils::TransparentStringHash, std::equal_to<> > 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 373 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 197 of file AthMonitorAlgorithm.h.

197 {
198 userDefined = 0,
199 monteCarlo,
200 collisions,
201 cosmics,
202 heavyIonCollisions,
203 };
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:597

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

178 {
179 user = 0,
180 online,
181 tier0,
182 tier0Raw,
183 tier0ESD,
184 AOD,
185 altprod,
186 };

Constructor & Destructor Documentation

◆ MdtRawDataMonAlg()

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

Definition at line 124 of file MdtRawDataMonAlg.cxx.

124: 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.

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

227{ return m_dataType; }
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition AthMonitorAlgorithm.h:359

◆ 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:100

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

211{ return m_environment; }
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition AthMonitorAlgorithm.h:358

◆ 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(ctx)) {
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:208
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition AthMonitorAlgorithm.h:364
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition AthMonitorAlgorithm.h:348
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition AthMonitorAlgorithm.h:349

◆ 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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
58 return m_extendedExtraObjects;
59 }
60 return BaseAlg::extraOutputDeps();
61}
AthCommonAlgorithm
Common base class for algorithms.
Definition AthCommonAlgorithm.h:38

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

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

◆ fillMDTHistograms()

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

Definition at line 851 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTOverviewHistograms()

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

Definition at line 547 of file MdtRawDataMonAlg.cxx.

547 {
548 auto mdt_tube_x_barrel = Monitored::Collection("mdt_tube_x_barrel", vects.mdt_tube_x_barrel);
549 auto mdt_tube_y_barrel = Monitored::Collection("mdt_tube_y_barrel", vects.mdt_tube_y_barrel);
550 auto mdt_tube_z_barrel = Monitored::Collection("mdt_tube_z_barrel", vects.mdt_tube_z_barrel);
551 auto mdt_tube_perp_barrel = Monitored::Collection("mdt_tube_perp_barrel", vects.mdt_tube_perp_barrel);
552 fill("MdtMonitor", mdt_tube_z_barrel, mdt_tube_perp_barrel, mdt_tube_x_barrel, mdt_tube_y_barrel);
553
554 auto mdt_tube_x_ovl = Monitored::Collection("mdt_tube_x_ovl", vects.mdt_tube_x_ovl);
555 auto mdt_tube_y_ovl = Monitored::Collection("mdt_tube_y_ovl", vects.mdt_tube_y_ovl);
556 auto mdt_tube_z_ovl = Monitored::Collection("mdt_tube_z_ovl", vects.mdt_tube_z_ovl);
557 auto mdt_tube_perp_ovl = Monitored::Collection("mdt_tube_perp_ovl", vects.mdt_tube_perp_ovl);
558 fill("MdtMonitor", mdt_tube_z_ovl, mdt_tube_perp_ovl, mdt_tube_x_ovl, mdt_tube_y_ovl);
559
560 auto mdt_tube_x_endcap = Monitored::Collection("mdt_tube_x_endcap", vects.mdt_tube_x_endcap);
561 auto mdt_tube_y_endcap = Monitored::Collection("mdt_tube_y_endcap", vects.mdt_tube_y_endcap);
562 auto mdt_tube_z_endcap = Monitored::Collection("mdt_tube_z_endcap", vects.mdt_tube_z_endcap);
563 auto mdt_tube_perp_endcap = Monitored::Collection("mdt_tube_perp_endcap", vects.mdt_tube_perp_endcap);
564 fill("MdtMonitor", mdt_tube_z_endcap, mdt_tube_perp_endcap, mdt_tube_x_endcap, mdt_tube_y_endcap);
565
566 auto adc_mon_nosel = Monitored::Collection("adc_mon_nosel", vects.adc_mon_nosel);
567 auto tdc_mon_nosel = Monitored::Collection("tdc_mon_nosel", vects.tdc_mon_nosel);
568 auto noiseBurst = Monitored::Collection("noiseBurst", vects.noiseBurst);
569 fill("MdtMonitor", adc_mon_nosel, tdc_mon_nosel, noiseBurst);
570
571 auto tdc_mon = Monitored::Collection("tdc_mon", vects.tdc_mon);
572 auto adc_mon = Monitored::Collection("adc_mon", vects.adc_mon);
573 fill("MdtMonitor", tdc_mon, adc_mon);
574
575 auto adc_mon_noiseBurst_notNoisy = Monitored::Collection("adc_mon_noiseBurst_notNoisy", vects.adc_mon_noiseBurst_notNoisy);
576 fill("MdtMonitor", adc_mon_noiseBurst_notNoisy);
577
578 auto tdc_mon_noiseBurst_adcCut = Monitored::Collection("tdc_mon_noiseBurst_adcCut", vects.tdc_mon_noiseBurst_adcCut);
579 fill("MdtMonitor", tdc_mon_noiseBurst_adcCut);
580
581 auto tdc_mon_adcCut = Monitored::Collection("tdc_mon_adcCut", vects.tdc_mon_adcCut);
582 fill("MdtMonitor", tdc_mon_adcCut);
583}
MDTOverviewHistogramStruct::adc_mon_nosel
std::vector< float > adc_mon_nosel
Definition MdtRawDataMonAlg.cxx:70
MDTOverviewHistogramStruct::mdt_tube_z_barrel
std::vector< float > mdt_tube_z_barrel
Definition MdtRawDataMonAlg.cxx:57
MDTOverviewHistogramStruct::tdc_mon_adcCut
std::vector< float > tdc_mon_adcCut
Definition MdtRawDataMonAlg.cxx:81
MDTOverviewHistogramStruct::mdt_tube_x_ovl
std::vector< float > mdt_tube_x_ovl
Definition MdtRawDataMonAlg.cxx:60
MDTOverviewHistogramStruct::mdt_tube_perp_ovl
std::vector< float > mdt_tube_perp_ovl
Definition MdtRawDataMonAlg.cxx:63
MDTOverviewHistogramStruct::mdt_tube_x_endcap
std::vector< float > mdt_tube_x_endcap
Definition MdtRawDataMonAlg.cxx:65
MDTOverviewHistogramStruct::tdc_mon_nosel
std::vector< float > tdc_mon_nosel
Definition MdtRawDataMonAlg.cxx:71
MDTOverviewHistogramStruct::mdt_tube_x_barrel
std::vector< float > mdt_tube_x_barrel
Definition MdtRawDataMonAlg.cxx:55
MDTOverviewHistogramStruct::mdt_tube_y_ovl
std::vector< float > mdt_tube_y_ovl
Definition MdtRawDataMonAlg.cxx:61
MDTOverviewHistogramStruct::adc_mon_noiseBurst_notNoisy
std::vector< float > adc_mon_noiseBurst_notNoisy
Definition MdtRawDataMonAlg.cxx:78
MDTOverviewHistogramStruct::mdt_tube_y_barrel
std::vector< float > mdt_tube_y_barrel
Definition MdtRawDataMonAlg.cxx:56
MDTOverviewHistogramStruct::mdt_tube_perp_barrel
std::vector< float > mdt_tube_perp_barrel
Definition MdtRawDataMonAlg.cxx:58
MDTOverviewHistogramStruct::tdc_mon_noiseBurst_adcCut
std::vector< float > tdc_mon_noiseBurst_adcCut
Definition MdtRawDataMonAlg.cxx:79
MDTOverviewHistogramStruct::mdt_tube_z_endcap
std::vector< float > mdt_tube_z_endcap
Definition MdtRawDataMonAlg.cxx:67
MDTOverviewHistogramStruct::tdc_mon
std::vector< float > tdc_mon
Definition MdtRawDataMonAlg.cxx:72
MDTOverviewHistogramStruct::mdt_tube_perp_endcap
std::vector< float > mdt_tube_perp_endcap
Definition MdtRawDataMonAlg.cxx:68
MDTOverviewHistogramStruct::mdt_tube_z_ovl
std::vector< float > mdt_tube_z_ovl
Definition MdtRawDataMonAlg.cxx:62
MDTOverviewHistogramStruct::adc_mon
std::vector< float > adc_mon
Definition MdtRawDataMonAlg.cxx:73
MDTOverviewHistogramStruct::mdt_tube_y_endcap
std::vector< float > mdt_tube_y_endcap
Definition MdtRawDataMonAlg.cxx:66

◆ fillMDTOverviewVects()

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

Definition at line 479 of file MdtRawDataMonAlg.cxx.

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

◆ fillMDTSegmentHistograms()

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

Definition at line 1200 of file MdtRawDataMonAlg.cxx.

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

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

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
AthCommonAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:
Definition AthCommonAlgorithm.h:93

◆ 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:105

◆ 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:61

◆ 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:323
MuonIdHelper::stationEta
int stationEta(const Identifier &id) const
Definition MuonIdHelper.cxx:790
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition MuonIdHelper.cxx:795
MuonIdHelper::stationName
int stationName(const Identifier &id) const
Definition MuonIdHelper.cxx:785

◆ 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:370

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( std::string_view 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 //Check if the tool exists in the map
172 if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
173 return m_tools[idx->second];
174 }
175 else {
176 //Check if the map is empty
177 if (m_toolLookupMap.empty()) {
178 ATH_MSG_FATAL("The m_toolLookupMap is empty. The tool " << name << " cannot be found in an empty map.");
179 return m_dummy;
180 }
181 //If the map is not empty and the tool was not found, print a fatal error
182 if (!m_toolLookupMap.empty()) {
183 std::string available = std::accumulate(
184 m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
185 [](const std::string& s, auto h) { return s + "," + h.first; });
186 ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
187 << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
188 << "your python configuration and c++ filling code. Note: your available groups are {"
189 << available << "}.");
190
191 return m_dummy;
192 }
193 if (!isInitialized()) {
194 ATH_MSG_FATAL(
195 "It seems that the AthMonitorAlgorithm::initialize was not called "
196 "in derived class initialize method, group name: " << name);
197 }
198 }
199 return m_dummy;
200}
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_LIKELY
#define ATH_LIKELY(x)
Definition AthUnlikelyMacros.h:16
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition AthMonitorAlgorithm.h:377
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t, CxxUtils::TransparentStringHash, std::equal_to<> > m_toolLookupMap
Definition AthMonitorAlgorithm.h:375
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition AthMonitorAlgorithm.h:344
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 203 of file AthMonitorAlgorithm.cxx.

203 {
204 return m_trigDecTool;
205}

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

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

◆ initDeadChannels()

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

Definition at line 1233 of file MdtRawDataMonAlg.cxx.

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

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

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, 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, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

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

350 {
351 std::string item;
352 std::stringstream ss(line);
353
354 ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
355
356 while ( std::getline(ss, item, ',') ) {
357 std::stringstream iss(item); // remove whitespace
358 iss >> item;
359 result.push_back(item);
360 }
361
362 return StatusCode::SUCCESS;
363}
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 AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
100 execState( ctx ).setFilterPassed( state );
101 }
AthCommonAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:
Definition AthCommonAlgorithm.h:99

◆ setIsATLASReady()

void MdtRawDataMonAlg::setIsATLASReady ( const EventContext & ctx)
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(ctx)); }
385 }
386 m_atlas_ready = filterresult;
387}

◆ sysExecute()

StatusCode AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
72 StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
84 return StatusCode::SUCCESS;
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
87 sc = StatusCode::FAILURE;
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Definition AthCommonAlgorithm.cxx:71
AthCommonAlgorithm< 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 208 of file AthMonitorAlgorithm.cxx.

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

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

368{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 369 of file AthMonitorAlgorithm.h.

369{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 349 of file AthMonitorAlgorithm.h.

349{this,"FilterTools",{}};

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

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

380 {this,
381 "EnforceExpressTriggers", false,
382 "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 358 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 360 of file AthMonitorAlgorithm.h.

360{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 370 of file AthMonitorAlgorithm.h.

370{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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 366 of file AthMonitorAlgorithm.h.

366{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 353 of file AthMonitorAlgorithm.h.

354{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 351 of file AthMonitorAlgorithm.h.

352{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 374 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, CxxUtils::TransparentStringHash, std::equal_to<> > AthMonitorAlgorithm::m_toolLookupMap
privateinherited

Definition at line 375 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 344 of file AthMonitorAlgorithm.h.

344{this,"GMTools",{}};

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

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

363{this,"TriggerChain",""};

◆ m_trigLiveFractionDataKey

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

Definition at line 355 of file AthMonitorAlgorithm.h.

356{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 367 of file AthMonitorAlgorithm.h.

367{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 364 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.17.0