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

#include <TRTMonitoringRun3ESD_Alg.h>

Inheritance diagram for TRTMonitoringRun3ESD_Alg:
Collaboration diagram for TRTMonitoringRun3ESD_Alg:

Public Types

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

Public Member Functions

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

Public Attributes

 flags = initConfigFlags()
 
 Files
 
 isMC
 
 HISTFileName
 
 Dynamic
 
 GeometryPixel
 
 GeometrySCT
 
 GeometryTRT
 
 GlobalTag
 
 cfg = MainServicesCfg(flags)
 
def TRTMonitoringRun3Acc = TRTMonitoringRun3ESD_AlgConfig(flags)
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

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

Private Types

enum  GasType { Xe = 0, Ar = 1, Kr = 2 }
 
typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode fillTRTTracks (const xAOD::TrackParticleContainer &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject, const xAOD::EventInfo &eventInfo) const
 
StatusCode fillTRTHighThreshold (const xAOD::TrackParticleContainer &trackCollection, const xAOD::EventInfo &eventInfo, const EventContext &ctx) const
 
int strawLayerNumber (int strawLayerNumber, int LayerNumber) const
 
int strawNumber (int strawNumber, int strawlayerNumber, int LayerNumber) const
 
int chipToBoard (int chip) const
 
int chipToBoard_EndCap (int chip) const
 
float radToDegrees (float radValue) const
 
int strawNumber_reverse (int inp_strawnumber, int *strawNumber, int *strawlayerNumber, int *LayerNumber) const
 
int strawLayerNumber_reverse (int strawLayerNumInp, int *strawLayerNumber, int *LayerNumber) const
 
int strawNumberEndCap (int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side) const
 
bool checkEventBurst (const TRT_RDO_Container &rdoContainer) const
 
GasType Straw_Gastype (int stat) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

BooleanProperty m_ArgonXenonSplitter {this, "doArgonXenonSeparation", true}
 
const AtlasDetectorID * m_idHelper
 
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
 
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
 
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackCollectionKey {this, "TrackParticleContainerKeys", "InDetTrackParticles", "Keys for TrackParticle Container"}
 
SG::ReadHandleKey< xAOD::EventInfo > m_xAODEventInfoKey {this, "xAODEventInfo", "EventInfo", "Name of EventInfo object"}
 
SG::ReadHandleKey< InDetTimeCollection > m_TRT_BCIDCollectionKey {this, "TRTBCIDCollectionName", "TRT_BCID", "Name of TRT BCID collection"}
 
SG::ReadHandleKey< ComTime > m_comTimeObjectKey {this, "ComTimeObjectName", "TRT_Phase", "Name of ComTime object"}
 
SG::ReadHandleKey< xAOD::TrigDecision > m_trigDecisionKey {this, "TrigDecisionObjectName", "xTrigDecision", "Name of trigger decision object"}
 
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryTool", "Track summary tool name"}
 
ToolHandle< ITRT_DriftFunctionTool > m_drifttool
 
const TRT_ID * m_pTRTHelper
 
const InDetDD::TRT_DetectorManager * m_mgr
 
bool m_doTracksMon
 
bool m_doStraws
 
bool m_doChips
 
bool m_doShift
 
bool m_doExpert
 
std::vector< std::vector< unsigned char > > m_mat_chip_B {64, std::vector<unsigned char>(1642)}
 
std::vector< std::vector< unsigned char > > m_mat_chip_E {64, std::vector<unsigned char>(3840)}
 
float m_DistToStraw
 
bool m_isCosmics
 
int m_min_si_hits
 
int m_min_pixel_hits
 
int m_min_sct_hits
 
int m_min_trt_hits
 
int m_minTRThits
 
float m_minP
 
float m_min_pT
 
int m_EventBurstCut
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringTool > m_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static const int s_numberOfBarrelStacks = 32
 
static const int s_numberOfEndCapStacks = 32
 
static const int s_Straw_max [2] = {1642, 3840}
 
static const int s_iStack_max [2] = {32, 64}
 
static const int s_iChip_max [2] = {104, 240}
 
static const int s_numberOfStacks [2] = {32, 32}
 
static const int s_moduleNum [2] = {96, 64}
 

Detailed Description

Definition at line 65 of file TRTMonitoringRun3ESD_Alg.h.

Member Typedef Documentation

◆ MonVarVec_t

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

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

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

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

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

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

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

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

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

◆ GasType

enum TRTMonitoringRun3ESD_Alg::GasType
private
Enumerator
Xe 
Ar 
Kr 

Definition at line 73 of file TRTMonitoringRun3ESD_Alg.h.

73 { Xe = 0, Ar = 1, Kr = 2 };

Constructor & Destructor Documentation

◆ TRTMonitoringRun3ESD_Alg()

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

Definition at line 41 of file TRTMonitoringRun3ESD_Alg.cxx.

42 :AthMonitorAlgorithm(name,pSvcLocator)
43 ,m_idHelper(nullptr)
44 ,m_sumTool("TRT_StrawStatusSummaryTool", this)
45 ,m_TRTStrawNeighbourSvc("TRT_StrawNeighbourSvc", name)
46 ,m_TRTCalDbTool("TRT_CalDbTool", this)
47 ,m_drifttool("TRT_DriftFunctionTool")
48 ,m_pTRTHelper(nullptr)
49 ,m_mgr(nullptr)
50 ,m_isCosmics(false)
51 ,m_minTRThits(10)
52 ,m_minP(0)
53 ,m_EventBurstCut(-1)
54 ,m_trackSelTool("InDet::InDetTrackSelectionTool/TrackSelectionTool", this)
55 {
56  declareProperty("InDetTRTStrawStatusSummaryTool", m_sumTool);
57  declareProperty("ITRT_CalDbTool", m_TRTCalDbTool);
58  declareProperty("DriftFunctionTool", m_drifttool);
59  declareProperty("TrackSelectionTool", m_trackSelTool);
60  declareProperty("doExpert", m_doExpert = false);
61  declareProperty("DoTracksMon", m_doTracksMon = true);
62  declareProperty("doStraws", m_doStraws = true);
63  declareProperty("doChips", m_doChips = true);
64  declareProperty("doShift", m_doShift = true);
65  declareProperty("DistanceToStraw", m_DistToStraw = 0.4);
66  declareProperty("min_si_hits", m_min_si_hits = 1);
67  declareProperty("min_pixel_hits", m_min_pixel_hits = 0);
68  declareProperty("min_sct_hits", m_min_sct_hits = 0);
69  declareProperty("min_trt_hits", m_min_trt_hits = 10);
70  declareProperty("MinTRTHitCut", m_minTRThits = 10);
71  declareProperty("MinTrackP", m_minP = 0.0 * CLHEP::GeV);
72  declareProperty("min_pT", m_min_pT = 0.5 * CLHEP::GeV);
73 }

◆ ~TRTMonitoringRun3ESD_Alg()

TRTMonitoringRun3ESD_Alg::~TRTMonitoringRun3ESD_Alg ( )
virtual

Definition at line 75 of file TRTMonitoringRun3ESD_Alg.cxx.

75 {}

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ checkEventBurst()

bool TRTMonitoringRun3ESD_Alg::checkEventBurst ( const TRT_RDO_Container &  rdoContainer) const
private

Definition at line 381 of file TRTMonitoringRun3ESD_Alg.cxx.

381  {
382 //----------------------------------------------------------------------------------//
383  if (m_EventBurstCut <= 0) return true;
384 
385  int nHLHits = 0;
386  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
387  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
388 
389  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
390  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
391 
392  if (!TRT_Collection) continue;
393  else {
394  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
395 
396  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
397  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
398 
399  if (!p_lolum) continue;
400 
401  if (p_lolum->highLevel()) nHLHits++;
402  }
403  }
404  }
405 
406  if (nHLHits > m_EventBurstCut) return false;
407  else return true;
408 }

◆ chipToBoard()

int TRTMonitoringRun3ESD_Alg::chipToBoard ( int  chip) const
private

◆ chipToBoard_EndCap()

int TRTMonitoringRun3ESD_Alg::chipToBoard_EndCap ( int  chip) const
private

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

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

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

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

Definition at line 140 of file AthMonitorAlgorithm.cxx.

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

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

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

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

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

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

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

◆ fillHistograms()

StatusCode TRTMonitoringRun3ESD_Alg::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 1460 of file TRTMonitoringRun3ESD_Alg.cxx.

1460  {
1461  using namespace Monitored;
1462  bool passEventBurst = true;
1463 
1464  // Declare the quantities which should be monitored
1465 
1466  // Set the values of the monitored variables for the event
1467 
1468  ATH_MSG_VERBOSE("Monitoring Histograms being filled");
1469 
1470  SG::ReadHandle<xAOD::TrackParticleContainer> trackCollection(m_trackCollectionKey, ctx);
1471  SG::ReadHandle<xAOD::EventInfo> xAODEventInfo(m_xAODEventInfoKey, ctx);
1472  SG::ReadHandle<InDetTimeCollection> trtBCIDCollection(m_TRT_BCIDCollectionKey, ctx);
1473 
1474  if (!xAODEventInfo.isValid()) {
1475  ATH_MSG_ERROR("Could not find event info object " << m_xAODEventInfoKey.key() <<
1476  " in store");
1477  return StatusCode::FAILURE;
1478  }
1479 
1480  if (m_doTracksMon) {
1481  if (!trackCollection.isValid()) {
1482  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1483  " in store");
1484  return StatusCode::FAILURE;
1485  }
1486  const xAOD::TrigDecision* trigDecision = nullptr;
1487  if (! m_trigDecisionKey.empty()) {
1488  trigDecision = SG::get(m_trigDecisionKey, ctx);
1489  if (!trigDecision) {
1490  ATH_MSG_INFO("Could not find trigger decision object " << m_trigDecisionKey.key() <<
1491  " in store");
1492  }
1493  }
1494  const ComTime *comTimeObject=nullptr;
1495  if (!m_comTimeObjectKey.empty()) {
1496  SG::ReadHandle<ComTime> tmp_comTimeObject(m_comTimeObjectKey, ctx);
1497  if (!tmp_comTimeObject.isValid()) {
1498  // NOTE: failing to retrieve ComTime from store for some reason
1499  ATH_MSG_DEBUG("Could not find com time object " << m_comTimeObjectKey.key() << " in store" );
1500  }
1501  else {
1502  comTimeObject = tmp_comTimeObject.cptr();
1503  }
1504  }
1505  ATH_CHECK( fillTRTTracks(*trackCollection, trigDecision, comTimeObject, *xAODEventInfo) );
1506  }
1507 
1508  if (!m_doTracksMon) {
1509  if (!trackCollection.isValid()) {
1510  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1511  " in store");
1512  return StatusCode::FAILURE;
1513  }
1514  }
1515 
1516  if (passEventBurst) { // ESD files does not have an RDO container to pass event burst, what to do?
1517  ATH_CHECK( fillTRTHighThreshold(*trackCollection, *xAODEventInfo, ctx) );
1518  }
1519 
1520 
1521 
1522  return StatusCode::SUCCESS;
1523 }

◆ fillTRTHighThreshold()

StatusCode TRTMonitoringRun3ESD_Alg::fillTRTHighThreshold ( const xAOD::TrackParticleContainer &  trackCollection,
const xAOD::EventInfo &  eventInfo,
const EventContext &  ctx 
) const
private

Definition at line 1235 of file TRTMonitoringRun3ESD_Alg.cxx.

1236  {
1237 //----------------------------------------------------------------------------------//
1238 
1239  auto IntLum = Monitored::Scalar<float>("IntLum", 0.0);
1240  auto LBvsLum = Monitored::Scalar<float>("LBvsLum", 0.0);
1241  auto LBvsTime_x = Monitored::Scalar<float>("LBvsTime_x", 0.0);
1242  auto LBvsTime_y = Monitored::Scalar<float>("LBvsTime_y", 0.0);
1243  auto IntLumWeight = Monitored::Scalar<float>("IntLumWeight", 0.0);
1244  auto LBvsLumWeight = Monitored::Scalar<float>("LBvsLumWeight", 0.0);
1245 
1246  int lumiBlockNumber;
1247  int timeStamp;
1248  lumiBlockNumber = eventInfo.lumiBlock();
1249  timeStamp = eventInfo.timeStamp();
1250 
1251  int runNumber;
1252  runNumber = eventInfo.runNumber();
1253  // get Online Luminosity
1254  double intLum = (lbDuration(ctx) * lbAverageLuminosity(ctx));
1255  IntLum = 0.5;
1256  IntLumWeight = intLum;
1257  fill("SmryHistograms", IntLumWeight, IntLum);
1258  LBvsLum = lumiBlockNumber;
1259  LBvsLumWeight = intLum;
1260  fill("SmryHistograms", LBvsLumWeight, LBvsLum);
1261  LBvsTime_x = lumiBlockNumber;
1262  LBvsTime_y = timeStamp;
1263  fill("SmryHistograms", LBvsTime_x, LBvsTime_y);
1264 
1265  ATH_MSG_VERBOSE("Filling TRT Aging Histos");
1266 
1267  auto Trackr_HT = Monitored::Scalar<float>("Trackr_HT", 0.0);
1268  auto Trackr_All = Monitored::Scalar<float>("Trackr_All", 0.0);
1269  auto Trackz_HT = Monitored::Scalar<float>("Trackz_HT", 0.0);
1270  auto Trackz_All = Monitored::Scalar<float>("Trackz_All", 0.0);
1271 
1272  auto p_trk = trackCollection.begin();
1273  const Trk::Perigee *perigee = nullptr;
1274  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
1275  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
1276 
1277  for (; p_trk != trackCollection.end(); ++p_trk) {
1278  AllTrkPar = ((*p_trk)->track())->trackParameters();
1279 
1280  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
1281  if ((perigee = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
1282  }
1283 
1284  // If you went through all of the track parameters and found no perigee mearsurement
1285  // then something is wrong with the track and so don't use the track.
1286  // i.e. continue to the next track.
1287  if (!perigee) {
1288  ATH_MSG_DEBUG("No perigee mearsurement found for the track. This entry will not be propogated to aging histograms.");
1289  continue;
1290  }
1291 
1292  float track_eta = perigee->eta();
1293  float track_p = (perigee->parameters()[Trk::qOverP] != 0.) ? std::abs(1. / (perigee->parameters()[Trk::qOverP])) : 10e7;
1294  const Trk::TrackStates *trackStates = ((*p_trk)->track())->trackStateOnSurfaces();
1295 
1296  if (trackStates == nullptr) continue;
1297 
1298  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
1299  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
1300 
1301  uint8_t tempHitsVariable = 0;
1302  (*p_trk)->summaryValue(tempHitsVariable, xAOD::SummaryType::numberOfTRTHits);
1303  int trt_hits = unsigned(tempHitsVariable);
1304 
1305  const bool passed_track_preselection = (static_cast<bool>(m_trackSelTool->accept(**p_trk)) || m_isCosmics) &&
1306  trt_hits >= 6. &&
1307  std::abs(track_p) >= 5000.;
1308 
1309  if (!passed_track_preselection) continue;
1310 
1311  // Now we have hit informations
1312  const Trk::TrackStates *track_states = ((*p_trk)->track())->trackStateOnSurfaces();
1313 
1314  if (track_states) {
1315  ATH_MSG_DEBUG("This track has " << track_states->size() << " track states on surface.");
1316  } else {
1317  ATH_MSG_DEBUG("This track has null track states on surface.");
1318  continue;
1319  }
1320 
1321  int barrel_ec_side = 0;
1322  int layer_or_wheel = 0;
1323  int phi_module = 0;
1324  int straw_layer = 0;
1325 
1326  for (; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
1327  if ((*TSOSItBegin) == nullptr) continue;
1328  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
1329 
1330  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
1331  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
1332 
1333  if (!trtCircle) continue;
1334  if (!aTrackParam) continue;
1335 
1336 
1337  Identifier DCoTId = trtCircle->identify();
1338  barrel_ec_side = m_pTRTHelper->barrel_ec(DCoTId);
1339  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
1340  phi_module = m_pTRTHelper->phi_module(DCoTId);
1341  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
1342  int Ba_Ec = abs(barrel_ec_side) - 1; // Ba_Ec: 0 is barrel, 1 is Endcap
1343  int Side = barrel_ec_side > 0 ? 0 : 1; // Side : 0 is side_A, 1 is side_C
1344  double xPos = trtCircle->globalPosition().x(); // Global x coordinate
1345  double yPos = trtCircle->globalPosition().y(); // Global y coordinate
1346  double zPos = trtCircle->globalPosition().z(); // Global z coordinate
1347  double RPos = sqrt(xPos * xPos + yPos * yPos);
1348  Identifier surfaceID;
1349  surfaceID = trtCircle->identify();
1350  // Assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
1351  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
1352 
1353  if (!RawDriftCircle) { //coverity 25097
1354  // This shouldn't happen in normal conditions because trtCircle is a TRT_DriftCircleOnTrack object
1355  ATH_MSG_WARNING("RawDriftCircle object returned null");
1356  continue;
1357  }
1358 
1359  int middleHTbit = RawDriftCircle->getWord() & 0x00020000;
1360  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
1361  bool is_middleHTbit_high = (middleHTbit != 0);
1362  // bool isHighLevel= RawDriftCircle->highLevel();
1363  bool isHighLevel = is_middleHTbit_high; // Hardcoded HT Middle Bit
1364  bool shortStraw = false;
1365  int InputBar = 0;
1366 
1367  if (std::abs(track_eta) < 2. && Ba_Ec == 0.) {
1368  if ((layer_or_wheel == 0) && (phi_module < 4 || (phi_module > 7 && phi_module < 12) || (phi_module > 15 && phi_module < 20) || (phi_module > 23 && phi_module < 28))) InputBar = 1;
1369  else if ((runNumber >= 296939) && (layer_or_wheel == 0) && (phi_module > 27)) InputBar = 1;
1370  else if (layer_or_wheel == 0)
1371  InputBar = 0;
1372  else if ((layer_or_wheel == 1) && ((phi_module > 1 && phi_module < 6) || (phi_module > 9 && phi_module < 14) || (phi_module > 17 && phi_module < 22) || (phi_module > 25 && phi_module < 30)))
1373  InputBar = 1;
1374  else if (layer_or_wheel == 1)
1375  InputBar = 0;
1376  else if (layer_or_wheel == 2 && phi_module % 2 != 0)
1377  InputBar = 1;
1378  else if (layer_or_wheel == 2)
1379  InputBar = 0;
1380  else {
1381  ATH_MSG_WARNING("Should not pass here");
1382  continue;
1383  }
1384 
1385  if ((layer_or_wheel == 0) && straw_layer < 9.)
1386  shortStraw = true;
1387  }
1388 
1389  // Fill Barrel Plots
1390  if ((!shortStraw) && (Ba_Ec == 0)) {
1391  Trackz_All = zPos;
1392  fill("TRTAgingHistograms0"+std::to_string(layer_or_wheel)+std::to_string(InputBar), Trackz_All);
1393  if (isHighLevel) {
1394  Trackz_HT = zPos;
1395  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+std::to_string(layer_or_wheel)+std::to_string(InputBar), Trackz_HT);
1396  }
1397  }
1398 
1399  if (shortStraw) {
1400  if (zPos > 0.) {
1401  Trackz_All = zPos;
1402  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+"3"+std::to_string(InputBar), Trackz_All);
1403  if (isHighLevel) {
1404  Trackz_HT = zPos;
1405  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+"3"+std::to_string(InputBar), Trackz_HT);
1406  }
1407  } else {
1408  Trackz_All = zPos;
1409  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+"4"+std::to_string(InputBar), Trackz_All);
1410 
1411  if (isHighLevel) {
1412  Trackz_HT = zPos;
1413  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+"4"+std::to_string(InputBar), Trackz_HT);
1414  }
1415  }
1416  }
1417 
1418  // End of Barrel plots, moving to Endcap plots
1419  int WType = -1;
1420 
1421  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
1422  ((straw_layer > 3 && straw_layer < 8) ||
1423  (straw_layer > 11))) {
1424  WType = 0;
1425  }
1426  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
1427  (straw_layer > 3)) {
1428  WType = 3;
1429  }
1430  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
1431  ((straw_layer > -1 && straw_layer < 4) ||
1432  (straw_layer > 7 && straw_layer < 12))) {
1433  WType = 2;
1434  }
1435  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
1436  ((straw_layer > -1 && straw_layer < 4))) {
1437  WType = 1;
1438  }
1439 
1440  if (WType < 0 && Ba_Ec == 1) { // Coverity CID 25096
1441  ATH_MSG_WARNING("The variable \"WType\" is less than zero!.");
1442  continue;
1443  }
1444 
1445  if (Ba_Ec == 1) {
1446  Trackr_All = RPos;
1447  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+std::to_string(WType)+std::to_string(Side), Trackr_All);
1448  if (isHighLevel) {
1449  Trackr_HT = RPos;
1450  fill("TRTAgingHistograms"+std::to_string(Ba_Ec)+std::to_string(WType)+std::to_string(Side), Trackr_HT);
1451  }
1452  }
1453  }
1454  }
1455 
1456  return StatusCode::SUCCESS;
1457 }

◆ fillTRTTracks()

StatusCode TRTMonitoringRun3ESD_Alg::fillTRTTracks ( const xAOD::TrackParticleContainer &  trackCollection,
const xAOD::TrigDecision *  trigDecision,
const ComTime *  comTimeObject,
const xAOD::EventInfo &  eventInfo 
) const
private

Definition at line 413 of file TRTMonitoringRun3ESD_Alg.cxx.

416  {
417 //----------------------------------------------------------------------------------//
418  ATH_MSG_VERBOSE("Filling TRT Tracks Histos");
419 
420  // TProfile
421  auto ValidRawDriftTimeonTrkS_x = Monitored::Scalar<float>("ValidRawDriftTimeonTrkS_x", 0.0);
422  auto ValidRawDriftTimeonTrkS_y = Monitored::Scalar<float>("ValidRawDriftTimeonTrkS_y", 0.0);
423  auto ValidRawDriftTimeonTrkC_x = Monitored::Scalar<float>("ValidRawDriftTimeonTrkC_x", 0.0);
424  auto ValidRawDriftTimeonTrkC_y = Monitored::Scalar<float>("ValidRawDriftTimeonTrkC_y", 0.0);
425  auto HitTronTMapC_x = Monitored::Scalar<float>("HitTronTMapC_x", 0.0);
426  auto HitTronTMapC_y = Monitored::Scalar<float>("HitTronTMapC_y", 0.0);
427  auto HitTronTwEPCMapS_x = Monitored::Scalar<float>("HitTronTwEPCMapS_x", 0.0);
428  auto HitTronTwEPCMapS_y = Monitored::Scalar<float>("HitTronTwEPCMapS_y", 0.0);
429  auto HitTronTwEPCMapC_x = Monitored::Scalar<float>("HitTronTwEPCMapC_x", 0.0);
430  auto HitTronTwEPCMapC_y = Monitored::Scalar<float>("HitTronTwEPCMapC_y", 0.0);
431  auto AvgTroTDetPhi_B_Ar_x = Monitored::Scalar<float>("AvgTroTDetPhi_B_Ar_x", 0.0);
432  auto AvgTroTDetPhi_B_Ar_y = Monitored::Scalar<float>("AvgTroTDetPhi_B_Ar_y", 0.0);
433  auto AvgTroTDetPhi_B_x = Monitored::Scalar<float>("AvgTroTDetPhi_B_x", 0.0);
434  auto AvgTroTDetPhi_B_y = Monitored::Scalar<float>("AvgTroTDetPhi_B_y", 0.0);
435  auto AvgTroTDetPhi_E_Ar_x = Monitored::Scalar<float>("AvgTroTDetPhi_E_Ar_x", 0.0);
436  auto AvgTroTDetPhi_E_Ar_y = Monitored::Scalar<float>("AvgTroTDetPhi_E_Ar_y", 0.0);
437  auto AvgTroTDetPhi_E_x = Monitored::Scalar<float>("AvgTroTDetPhi_E_x", 0.0);
438  auto AvgTroTDetPhi_E_y = Monitored::Scalar<float>("AvgTroTDetPhi_E_y", 0.0);
439  auto NumHoTDetPhi_B_x = Monitored::Scalar<float>("NumHoTDetPhi_B_x", 0.0);
440  auto NumHoTDetPhi_B_y = Monitored::Scalar<float>("NumHoTDetPhi_B_y", 0.0);
441  auto NumHoTDetPhi_E_x = Monitored::Scalar<float>("NumHoTDetPhi_E_x", 0.0);
442  auto NumHoTDetPhi_E_y = Monitored::Scalar<float>("NumHoTDetPhi_E_y", 0.0);
443  auto EvtPhaseDetPhi_B_x = Monitored::Scalar<float>("EvtPhaseDetPhi_B_x", 0.0);
444  auto EvtPhaseDetPhi_B_y = Monitored::Scalar<float>("EvtPhaseDetPhi_B_y", 0.0);
445  auto EvtPhaseDetPhi_E_x = Monitored::Scalar<float>("EvtPhaseDetPhi_E_x", 0.0);
446  auto EvtPhaseDetPhi_E_y = Monitored::Scalar<float>("EvtPhaseDetPhi_E_y", 0.0);
447  auto NTrksperLB_x = Monitored::Scalar<float>("NTrksperLB_x", 0.0);
448  auto NTrksperLB_y = Monitored::Scalar<float>("NTrksperLB_y", 0.0);
449 
450 
451  // TH1F
452  auto DriftTimeonTrkDist_B = Monitored::Scalar<float>("DriftTimeonTrkDist_B", 0.0);
453  auto DriftTimeonTrkDist_B_Ar = Monitored::Scalar<float>("DriftTimeonTrkDist_B_Ar", 0.0);
454  auto DriftTimeonTrkDist_E_Ar = Monitored::Scalar<float>("DriftTimeonTrkDist_E_Ar", 0.0);
455  auto DriftTimeonTrkDist_E = Monitored::Scalar<float>("DriftTimeonTrkDist_E", 0.0);
456  auto NumTrksDetPhi_B = Monitored::Scalar<float>("NumTrksDetPhi_B", 0.0);
457  auto NumTrksDetPhi_E = Monitored::Scalar<float>("NumTrksDetPhi_E", 0.0);
458  auto Pull_Biased_Barrel = Monitored::Scalar<float>("Pull_Biased_Barrel", 0.0);
459  auto Pull_Biased_EndCap = Monitored::Scalar<float>("Pull_Biased_EndCap", 0.0);
460  auto Residual_B = Monitored::Scalar<float>("Residual_B", 0.0);
461  auto Residual_B_Ar = Monitored::Scalar<float>("Residual_B_Ar", 0.0);
462  auto Residual_B_20GeV = Monitored::Scalar<float>("Residual_B_20GeV", 0.0);
463  auto Residual_B_Ar_20GeV = Monitored::Scalar<float>("Residual_B_Ar_20GeV", 0.0);
464  auto Residual_E = Monitored::Scalar<float>("Residual_E", 0.0);
465  auto Residual_E_Ar = Monitored::Scalar<float>("Residual_E_Ar", 0.0);
466  auto Residual_E_20GeV = Monitored::Scalar<float>("Residual_E_20GeV", 0.0);
467  auto Residual_E_Ar_20GeV = Monitored::Scalar<float>("Residual_E_Ar_20GeV", 0.0);
468  auto Residual_noTubeHits_B = Monitored::Scalar<float>("Residual_noTubeHits_B", 0.0);
469  auto Residual_noTubeHits_B_Ar = Monitored::Scalar<float>("Residual_noTubeHits_B_Ar", 0.0);
470  auto Residual_noTubeHits_B_20GeV = Monitored::Scalar<float>("Residual_noTubeHits_B_20GeV", 0.0);
471  auto Residual_noTubeHits_B_Ar_20GeV = Monitored::Scalar<float>("Residual_noTubeHits_B_Ar_20GeV", 0.0);
472  auto Residual_noTubeHits_E = Monitored::Scalar<float>("Residual_noTubeHits_E", 0.0);
473  auto Residual_noTubeHits_E_Ar = Monitored::Scalar<float>("Residual_noTubeHits_E_Ar", 0.0);
474  auto Residual_noTubeHits_E_20GeV = Monitored::Scalar<float>("Residual_noTubeHits_E_20GeV", 0.0);
475  auto Residual_noTubeHits_E_Ar_20GeV = Monitored::Scalar<float>("Residual_noTubeHits_E_Ar_20GeV", 0.0);
476  auto TimeResidual_B = Monitored::Scalar<float>("TimeResidual_B", 0.0);
477  auto TimeResidual_B_Ar = Monitored::Scalar<float>("TimeResidual_B_Ar", 0.0);
478  auto TimeResidual_E = Monitored::Scalar<float>("TimeResidual_E", 0.0);
479  auto TimeResidual_E_Ar = Monitored::Scalar<float>("TimeResidual_E_Ar", 0.0);
480  auto TimeResidual_noTubeHits_B = Monitored::Scalar<float>("TimeResidual_noTubeHits_B", 0.0);
481  auto TimeResidual_noTubeHits_B_Ar = Monitored::Scalar<float>("TimeResidual_noTubeHits_B_Ar", 0.0);
482  auto TimeResidual_noTubeHits_E = Monitored::Scalar<float>("TimeResidual_noTubeHits_E", 0.0);
483  auto TimeResidual_noTubeHits_E_Ar = Monitored::Scalar<float>("TimeResidual_noTubeHits_E_Ar", 0.0);
484  auto TronTDist_E = Monitored::Scalar<float>("TronTDist_E", 0.0);
485  auto TronTDist_B = Monitored::Scalar<float>("TronTDist_B", 0.0);
486  auto TronTDist_B_Ar = Monitored::Scalar<float>("TronTDist_B_Ar", 0.0);
487  auto TronTDist_E_Ar = Monitored::Scalar<float>("TronTDist_E_Ar", 0.0);
488  auto WireToTrkPosition_B_Ar = Monitored::Scalar<float>("WireToTrkPosition_B_Ar", 0.0);
489  auto WireToTrkPosition_B = Monitored::Scalar<float>("WireToTrkPosition_B", 0.0);
490  auto WireToTrkPosition_E_Ar = Monitored::Scalar<float>("WireToTrkPosition_E_Ar", 0.0);
491  auto WireToTrkPosition_E = Monitored::Scalar<float>("WireToTrkPosition_E", 0.0);
492  auto EvtPhase = Monitored::Scalar<float>("EvtPhase", 0.0);
493  auto Summary = Monitored::Scalar<float>("Summary", 0.0);
494  auto SummaryWeight = Monitored::Scalar<float>("SummaryWeight", 0.0);
495 
496  // TH2F
497  auto RtRelation_B_Ar_x = Monitored::Scalar<float>("RtRelation_B_Ar_x", 0.0);
498  auto RtRelation_B_Ar_y = Monitored::Scalar<float>("RtRelation_B_Ar_y", 0.0);
499  auto RtRelation_B_x = Monitored::Scalar<float>("RtRelation_B_x", 0.0);
500  auto RtRelation_B_y = Monitored::Scalar<float>("RtRelation_B_y", 0.0);
501  auto RtRelation_E_Ar_x = Monitored::Scalar<float>("RtRelation_E_Ar_x", 0.0);
502  auto RtRelation_E_Ar_y = Monitored::Scalar<float>("RtRelation_E_Ar_y", 0.0);
503  auto RtRelation_E_x = Monitored::Scalar<float>("RtRelation_E_x", 0.0);
504  auto RtRelation_E_y = Monitored::Scalar<float>("RtRelation_E_y", 0.0);
505  auto EvtPhaseVsTrig_x = Monitored::Scalar<float>("EvtPhaseVsTrig_x", 0.0);
506  auto EvtPhaseVsTrig_y = Monitored::Scalar<float>("EvtPhaseVsTrig_y", 0.0);
507 
508  // Initialize a bunch of stuff before looping over the track collection. Fill some basic histograms.
509  const float timeCor = comTimeObject ? comTimeObject->getTime() : 0;
510 
511  auto p_trk = trackCollection.begin();
512 
513  const Trk::Perigee *mPer = nullptr;
514  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
515  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
516 
517  int ntrackstack[2][64];
518  int nTotalTracks = 0;
519  int nTracksB[2] = {0, 0};
520  int nTracksEC[2] = {0, 0};
521  int nTracksEC_B[2] = {0, 0};
522  int nTrksperLB_B = 0;
523  int nTrksperLB_E[2] = {0, 0};
524 
525  for (int ibe = 0; ibe < 2; ibe++) {
526  std::fill(ntrackstack[ibe], ntrackstack[ibe] + 64, 0);
527  }
528 
529 for (; p_trk != trackCollection.end(); ++p_trk) {
530 
531  uint8_t tempHitsVariable(0);
532  (*p_trk)->summaryValue(tempHitsVariable, xAOD::SummaryType::numberOfTRTHits);
533  int nTRTHits = unsigned(tempHitsVariable);
534 
535 
536  if (nTRTHits < m_minTRThits) continue;
537 
538  AllTrkPar = ((*p_trk)->track())->trackParameters();
539 
540  // Search of MeasuredPerigee in TrackParameters
541  // The following algorithm only finds the First perigee measurement.
542  // As there should be one and only one perigee measurement then this assumption should be valid.
543  // But no check is done to see if there is more than one perigee measurement.
544  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
545  // If track parameter does have a measured perigee then the track parameter is a keeper and break out of the loop
546  if ((mPer = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
547  }
548 
549  if (!mPer) continue;
550 
551  float theta = mPer->parameters()[Trk::theta];
552  float p = (mPer->parameters()[Trk::qOverP] != 0.) ? std::abs(1. / (mPer->parameters()[Trk::qOverP])) : 10e7;
553  float pT = (p * std::sin(theta));
554  pT = pT * 1e-3; // GeV
555 
556  if (p < m_minP) continue;
557 
558  const Trk::TrackStates *trackStates = ((*p_trk)->track())->trackStateOnSurfaces();
559 
560  if (trackStates == nullptr) continue;
561 
562  Trk::TrackStates::const_iterator TSOSItBegin0 = trackStates->begin();
563  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
564  Trk::TrackStates::const_iterator TSOSItBeginTemp = trackStates->begin();
565  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
566 
567  (*p_trk)->summaryValue(tempHitsVariable, xAOD::SummaryType::numberOfTRTHits);
568  int n_trt_hits = unsigned(tempHitsVariable);
569 
570  bool is_pT_over_20GeV = false;
571 
572  if (mPer->pT() > 20 * CLHEP::GeV) {
573  is_pT_over_20GeV = true;
574  } else {
575  is_pT_over_20GeV = false;
576  }
577 
578  const bool cnst_is_pT_over_20GeV = is_pT_over_20GeV;
579 
580  const bool passed_track_preselection = (static_cast<bool>(m_trackSelTool->accept(**p_trk)) || m_isCosmics) &&
581  n_trt_hits >= m_min_trt_hits &&
582  mPer->pT() > (m_isCosmics?m_min_pT : 2.0 * CLHEP::GeV); // Hardcoded cut for pT 2.0 GeV for collision setup
583  if (!passed_track_preselection) continue;
584 
585  nTotalTracks++;
586  int checkB[2] = {0, 0};
587  int checkEC[2] = {0, 0};
588  int checkEC_B[2] = {0, 0};
589  int nTRTHitsW[2][2];
590  int nTRTHits_side[2][2];
591  int nTRTHitsW_perwheel[2][18];
592  int hitontrack[2] = {0, 0};
593  int hitontrack_E_side[2] = {0, 0};
594 
595  for (int ibe = 0; ibe < 2; ibe++) {
596  for (int iside = 0; iside < 2; iside++) {
597  nTRTHits_side[ibe][iside] = -1;
598  nTRTHitsW[ibe][iside] = 0;
599  }
600  std::fill(nTRTHitsW_perwheel[ibe], nTRTHitsW_perwheel[ibe] + 18, 0);
601  }
602 
603  int barrel_ec = 0;
604  int layer_or_wheel = 0;
605  int phi_module = 0;
606  int straw_layer = 0;
607  int straw = 0;
608  int nearest_straw_layer[2] = {100, 100};
609  int nearest_straw[2] = {0, 0};
610  int testLayer[2] = {100, 100};
611  float phi2D[2] = {-100, -100};
612 
613  for (TSOSItBeginTemp = TSOSItBegin0; TSOSItBeginTemp != TSOSItEnd; ++TSOSItBeginTemp) {
614  if ((*TSOSItBeginTemp) == nullptr) continue;
615 
616  if (! ((*TSOSItBeginTemp)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
617  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBeginTemp)->measurementOnTrack());
618 
619  if (!trtCircle) continue;
620  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBeginTemp)->trackParameters());
621 
622  if (!aTrackParam) continue;
623  Identifier DCoTId = trtCircle->identify();
624  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
625  int ibe = std::abs(barrel_ec) - 1;
626  layer_or_wheel = m_pTRTHelper->layer_or_wheel (DCoTId);
627  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
628  straw = m_pTRTHelper->straw(DCoTId);
629 
630  // Restrict ourselves to the inner most TRT layers To get detector phi.
631  if (layer_or_wheel >= testLayer[ibe]) continue;
632  testLayer[ibe] = layer_or_wheel;
633 
634  if (straw_layer < nearest_straw_layer[ibe]) {
635  nearest_straw_layer[ibe] = straw_layer;
636  nearest_straw[ibe] = straw;
637  const InDetDD::TRT_BaseElement *circleElement = nullptr;
638  circleElement = trtCircle->detectorElement();
639  phi2D[ibe] = radToDegrees(circleElement->strawCenter(nearest_straw[ibe]).phi());
640  circleElement = nullptr;
641  }
642  }
643 
644  if (phi2D[0] == -999) {
645  ATH_MSG_DEBUG("Track did not go through inner layer of Barrel.");
646  } else {
647  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
648  testLayer[0] << " m_straw_layer: " <<
649  nearest_straw_layer[0] << " (in the Barrel).");
650  }
651 
652  if (phi2D[1] == -999) {
653  ATH_MSG_DEBUG("Track did not go through any inner layer of EndCap A or C.");
654  } else {
655  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
656  testLayer[1] << " m_straw_layer: " <<
657  nearest_straw_layer[1] << " (in the EndCaps).");
658  }
659 
660  bool trackfound[2][64];
661 
662  for (int i = 0; i < 2; i++) {
663  std::fill(trackfound[i], trackfound[i] + 64, false);
664  }
665 
666  for (TSOSItBegin = TSOSItBegin0; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
667  // Select a TSOS which is non-empty, measurement type and contains both drift circle and track parameters informations
668  if ((*TSOSItBegin) == nullptr) continue;
669 
670  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
671 
672  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
673 
674  if (!trtCircle) continue;
675 
676  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
677 
678  if (!aTrackParam) continue;
679 
680  Identifier DCoTId = trtCircle->identify();
681  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
682  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
683  phi_module = m_pTRTHelper->phi_module(DCoTId);
684  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
685  straw = m_pTRTHelper->straw(DCoTId);
686  int ibe = std::abs(barrel_ec) - 1; // ibe = 0 (Barrel), ibe = 1 (Endcap)
687  int iside = barrel_ec > 0 ? 0 : 1; // iside = 0 (Side A), iside = 1 (Side C)
688  int thisStrawNumber[2] = {-1, -1};
689  int chip[2] = {0, 0};
690 
691  if (ibe == 0) {
692  thisStrawNumber[ibe] = strawNumber(straw, straw_layer, layer_or_wheel);
693 
694  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
695  chip[ibe] = m_mat_chip_B.at(phi_module).at(thisStrawNumber[ibe]);
696  }
697  } else if (ibe == 1) {
698  thisStrawNumber[ibe] = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
699 
700  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
701  chip[ibe] = m_mat_chip_E.at(phi_module).at(thisStrawNumber[ibe]);
702  }
703  } else {
704  thisStrawNumber[ibe] = -1;
705  }
706 
707  if (thisStrawNumber[ibe] < 0 || thisStrawNumber[ibe] >= s_Straw_max[ibe]) continue;
708 
709  if (checkB[iside] == 0 && ibe == 0) {
710  nTracksB[iside]++;
711  checkB[iside] = 1;
712  }
713 
714  if (checkEC[iside] == 0 && ibe == 1) {
715  nTracksEC[iside]++;
716  checkEC[iside] = 1;
717  }
718 
719  if (checkEC_B[iside] == 0 && checkB[iside] == 1 && ibe == 1 ) {
720  nTracksEC_B[iside]++;
721  checkEC_B[iside] = 1;
722  }
723 
724  Identifier surfaceID;
725  const Trk::MeasurementBase *mesb = (*TSOSItBegin)->measurementOnTrack();
726  surfaceID = trtCircle->identify();
727  const bool isArgonStraw = ( Straw_Gastype( m_sumTool->getStatusHT(surfaceID) ) == GasType::Ar );
728  // Assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
729  float temp_locr = aTrackParam->parameters()[Trk::driftRadius];
730  TRTCond::RtRelation const *rtr = m_TRTCalDbTool->getRtRelation(surfaceID);
731  int iphi_module = -9999;
732 
733  if (iside == 0) iphi_module = phi_module;
734  else if (iside == 1) iphi_module = phi_module + 32;
735 
736  if (iphi_module >= 0 && iphi_module < 64) trackfound[ibe][iphi_module] = true;
737  else ATH_MSG_ERROR("Variable iphi_module is out of range!");
738 
739  if (((ibe == 0) && (temp_locr < m_DistToStraw)) ||
740  ((ibe == 1) && ((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement) ||
741  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Outlier) ||
742  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Hole)) &&
743  (temp_locr < m_DistToStraw))) {
744  if (m_idHelper->is_trt(DCoTId)) {
745  if (ibe == 0) {
746  hitontrack[ibe]++;
747  } else if (ibe == 1) {
748  hitontrack[ibe]++;
749  hitontrack_E_side[iside]++;
750  }
751  }
752  }
753  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
754  bool isTubeHit = (mesb->localCovariance()(Trk::locX, Trk::locX) > 1.0) ? 1 : 0;
755  if (RawDriftCircle) {
756  nTRTHits_side[ibe][iside]++;
757  double t0 = m_TRTCalDbTool->getT0(DCoTId, TRTCond::ExpandedIdentifier::STRAW);
758 
759  const bool driftTimeValid = RawDriftCircle->driftTimeValid();
760 
761  if (driftTimeValid) {
762  const float validRawDriftTime = RawDriftCircle->rawDriftTime();
763 
764  if (m_doExpert && m_doStraws) {
765  ValidRawDriftTimeonTrkS_x = thisStrawNumber[ibe];
766  ValidRawDriftTimeonTrkS_y = validRawDriftTime;
767  fill("TRTTrackHistograms"+std::to_string(ibe)+std::to_string(iphi_module), ValidRawDriftTimeonTrkS_x, ValidRawDriftTimeonTrkS_y);
768  }
769 
770  if (m_doExpert && m_doChips) {
771  ValidRawDriftTimeonTrkC_x = chip[ibe] - 1;
772  ValidRawDriftTimeonTrkC_y = validRawDriftTime;
773  fill("TRTTrackHistograms"+std::to_string(ibe)+std::to_string(iphi_module), ValidRawDriftTimeonTrkC_x, ValidRawDriftTimeonTrkC_y);
774  }
775  }
776 
777  if (m_doShift && m_doStraws) {
778  if (ibe == 0) {
779  if (isArgonStraw) {
780  DriftTimeonTrkDist_B_Ar = RawDriftCircle->rawDriftTime();
781  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), DriftTimeonTrkDist_B_Ar);
782  }
783  else {
784  DriftTimeonTrkDist_B = RawDriftCircle->rawDriftTime();
785  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), DriftTimeonTrkDist_B);
786  }
787  } else if (ibe == 1) {
788  if (isArgonStraw) {
789  DriftTimeonTrkDist_E_Ar = RawDriftCircle->rawDriftTime();
790  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), DriftTimeonTrkDist_E_Ar);
791  }
792  else {
793  DriftTimeonTrkDist_E = RawDriftCircle->rawDriftTime();
794  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), DriftTimeonTrkDist_E);
795  }
796  }
797  }
798 
799  float locR_err = 0.0;
800  const AmgSymMatrix(5)* b_err = aTrackParam->covariance();
801 
802  if (b_err) {
803  if (!Amg::hasPositiveDiagElems(*b_err)) {
804  ATH_MSG_WARNING("Some diagonal element(s) of the covariance matrix is (are) infinite or smaller than / too close to zero or above the covariance cutoff");
805  }
806  else {
807  locR_err = Amg::error(*b_err, Trk::locR);
808  }
809  } else {
810  ATH_MSG_ERROR("Track parameters have no covariance attached.");
811  }
812 
813  float loc_err = sqrt(Amg::error(trtCircle->localCovariance(), Trk::driftRadius));
814  float locR = aTrackParam->parameters()[Trk::driftRadius];
815  float loc = trtCircle->localParameters()[Trk::driftRadius];
816 
817  if (isTubeHit) {
818  bool isOK = false;
819  loc = m_drifttool->driftRadius(RawDriftCircle->rawDriftTime(), DCoTId, t0, isOK);
820 
821  if ((loc * locR) < 0) loc = -loc;
822  }
823 
824  // Calculate Residuals for hit
825  if (m_doShift && m_doStraws) {
826  bool pull_b_fill;
827  double pull_b = -999.;
828  const double diff_loc_err = (loc_err * loc_err * loc_err * loc_err) - (locR_err * locR_err * locR_err * locR_err);
829  if ( diff_loc_err > 0 ) {
830  pull_b = (loc - locR) / sqrt(diff_loc_err);
831  pull_b_fill = true;
832  }
833  else pull_b_fill = false;
834  const double thist0 = m_TRTCalDbTool->getT0(surfaceID);
835  const double trkdrifttime = (!rtr) ? 0 : rtr->drifttime(std::abs(locR));
836  const double timeresidual = RawDriftCircle->rawDriftTime() - thist0 - trkdrifttime;
837 
838  if (ibe == 0) {
839  if (!isTubeHit) {
840  if (pull_b_fill) {
841  Pull_Biased_Barrel = pull_b;
842  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Pull_Biased_Barrel);
843  }
844  }
845 
846  if (isArgonStraw) {
847  Residual_B_Ar = loc - locR;
848  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_B_Ar);
849  Residual_noTubeHits_B_Ar = loc - locR;
850  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_noTubeHits_B_Ar);
851 
852  if (cnst_is_pT_over_20GeV) {
853  Residual_B_Ar_20GeV = loc - locR;
854  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_B_Ar_20GeV);
855  Residual_noTubeHits_B_Ar_20GeV = loc - locR;
856  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_noTubeHits_B_Ar_20GeV);
857  }
858  TimeResidual_B_Ar = timeresidual;
859  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TimeResidual_B_Ar);
860  TimeResidual_noTubeHits_B_Ar = timeresidual;
861  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TimeResidual_noTubeHits_B_Ar);
862  } else {
863  Residual_B = loc - locR;
864  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_B);
865  Residual_noTubeHits_B = loc - locR;
866  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_noTubeHits_B);
867  TimeResidual_B = timeresidual;
868  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TimeResidual_B);
869  TimeResidual_noTubeHits_B = timeresidual;
870  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TimeResidual_noTubeHits_B);
871 
872  if (cnst_is_pT_over_20GeV) {
873  Residual_B_20GeV = loc - locR;
874  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_B_20GeV);
875  Residual_noTubeHits_B_20GeV = loc - locR;
876  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Residual_noTubeHits_B_20GeV);
877  }
878  }
879  } else if (ibe == 1) {
880  if (!isTubeHit) {
881  if (pull_b_fill) {
882  Pull_Biased_EndCap = pull_b;
883  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), Pull_Biased_EndCap);
884  }
885  }
886 
887  if (isArgonStraw) {
888  Residual_E_Ar = loc - locR;
889  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_E_Ar);
890  Residual_noTubeHits_E_Ar = loc - locR;
891  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_noTubeHits_E_Ar);
892  TimeResidual_E_Ar = timeresidual;
893  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TimeResidual_E_Ar);
894  TimeResidual_noTubeHits_E_Ar = timeresidual;
895  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TimeResidual_noTubeHits_E_Ar);
896 
897  if (cnst_is_pT_over_20GeV) {
898  Residual_E_Ar_20GeV = loc - locR;
899  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_E_Ar_20GeV);
900  Residual_noTubeHits_E_Ar_20GeV = loc - locR;
901  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_noTubeHits_E_Ar_20GeV);
902  }
903  } else {
904  Residual_E = loc - locR;
905  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_E);
906  Residual_noTubeHits_E = loc - locR;
907  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_noTubeHits_E);
908  TimeResidual_E = timeresidual;
909  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TimeResidual_E);
910  TimeResidual_noTubeHits_E = timeresidual;
911  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TimeResidual_noTubeHits_E);
912 
913  if (cnst_is_pT_over_20GeV) {
914  Residual_E_20GeV = loc - locR;
915  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_E_20GeV);
916  Residual_noTubeHits_E_20GeV = loc - locR;
917  if (!isTubeHit) fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), Residual_noTubeHits_E_20GeV);
918  }
919  }
920  }
921  }
922 
923  if (m_doShift) {
924  if (ibe == 0) {
925  if (isArgonStraw) {
926  WireToTrkPosition_B_Ar = locR;
927  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), WireToTrkPosition_B_Ar);
928  } else {
929  WireToTrkPosition_B = locR;
930  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), WireToTrkPosition_B);
931  }
932  } else if (ibe == 1) {
933  if (isArgonStraw) {
934  WireToTrkPosition_E_Ar = locR;
935  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), WireToTrkPosition_E_Ar);
936  } else {
937  WireToTrkPosition_E = locR;
938  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), WireToTrkPosition_E);
939  }
940  }
941  }
942 
943  const float LE = (RawDriftCircle->driftTimeBin()) * 3.125;
944  const float EP = timeCor;
945 
946  if (m_doShift && m_doStraws) {
947  if (ibe == 0) {
948  if (isArgonStraw) {
949  if (m_isCosmics) {
950  RtRelation_B_Ar_x = LE - EP - t0;
951  RtRelation_B_Ar_y = std::abs(locR);
952  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), RtRelation_B_Ar_x, RtRelation_B_Ar_y);
953  } else {
954  RtRelation_B_Ar_x = LE - t0;
955  RtRelation_B_Ar_y = std::abs(locR);
956  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), RtRelation_B_Ar_x, RtRelation_B_Ar_y);
957  }
958  } else {
959  if (m_isCosmics) {
960  RtRelation_B_x = LE - EP - t0;
961  RtRelation_B_y = std::abs(locR);
962  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), RtRelation_B_x, RtRelation_B_y);
963  } else {
964  RtRelation_B_x = LE - t0;
965  RtRelation_B_y = std::abs(locR);
966  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), RtRelation_B_x, RtRelation_B_y);
967  }
968  }
969  } else if (ibe == 1) {
970  if (isArgonStraw) {
971  if (m_isCosmics) {
972  RtRelation_E_Ar_x = LE - EP - t0;
973  RtRelation_E_Ar_y = std::abs(locR);
974  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), RtRelation_E_Ar_x, RtRelation_E_Ar_y);
975  } else {
976  RtRelation_E_Ar_x = LE - t0;
977  RtRelation_E_Ar_y = std::abs(locR);
978  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), RtRelation_E_Ar_x, RtRelation_E_Ar_y);
979  }
980  } else {
981  if (m_isCosmics) {
982  RtRelation_E_x = LE - EP - t0;
983  RtRelation_E_y = std::abs(locR);
984  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), RtRelation_E_x, RtRelation_E_y);
985  } else {
986  RtRelation_E_x = LE - t0;
987  RtRelation_E_y = std::abs(locR);
988  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), RtRelation_E_x, RtRelation_E_y);
989  }
990  }
991  }
992  }
993 
994  const int driftTimeBin = RawDriftCircle->driftTimeBin();
995  const int firstBinHigh = RawDriftCircle->firstBinHigh();
996  const int lastBinHigh = RawDriftCircle->lastBinHigh();
997  const int trailingEdge = RawDriftCircle->trailingEdge();
998  float trailingEdgeScaled = (trailingEdge + 1) * 3.125;
999 
1000  if (firstBinHigh || lastBinHigh || driftTimeBin > 0 || trailingEdge < 23) nTRTHitsW[ibe][iside]++;
1001 
1002  if ((trailingEdge < 23) &&
1003  !(RawDriftCircle->lastBinHigh()) &&
1004  !(RawDriftCircle->firstBinHigh())) {
1005 
1006  if (m_doExpert && m_doChips) {
1007  HitTronTMapC_x = chip[ibe] - 1;
1008  HitTronTMapC_y = trailingEdgeScaled;
1009  fill("TRTTrackHistograms"+std::to_string(ibe)+std::to_string(iphi_module), HitTronTMapC_x, HitTronTMapC_y);
1010  }
1011 
1012  if (m_doExpert && m_doStraws) {
1013  HitTronTwEPCMapS_x = thisStrawNumber[ibe];
1014  HitTronTwEPCMapS_y = trailingEdgeScaled - timeCor;
1015  fill("TRTTrackHistograms"+std::to_string(ibe)+std::to_string(iphi_module), HitTronTwEPCMapS_x, HitTronTwEPCMapS_y);
1016  }
1017 
1018  if (m_doExpert && m_doChips) {
1019  HitTronTwEPCMapC_x = chip[ibe] - 1;
1020  HitTronTwEPCMapC_y = trailingEdgeScaled - timeCor;
1021  fill("TRTTrackHistograms"+std::to_string(ibe)+std::to_string(iphi_module), HitTronTwEPCMapC_x, HitTronTwEPCMapC_y);
1022  }
1023 
1024  if (m_doShift && m_doStraws) {
1025  if (RawDriftCircle->driftTimeValid()) {
1026  if (ibe == 0) {
1027  if (isArgonStraw) {
1028  TronTDist_B_Ar = trailingEdgeScaled;
1029  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TronTDist_B_Ar);
1030  AvgTroTDetPhi_B_Ar_x = phi2D[ibe];
1031  AvgTroTDetPhi_B_Ar_y = trailingEdgeScaled;
1032  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), AvgTroTDetPhi_B_Ar_x, AvgTroTDetPhi_B_Ar_y);
1033  } else {
1034  TronTDist_B = trailingEdgeScaled;
1035  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), TronTDist_B);
1036  AvgTroTDetPhi_B_x = phi2D[ibe];
1037  AvgTroTDetPhi_B_y = trailingEdgeScaled;
1038  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), AvgTroTDetPhi_B_x, AvgTroTDetPhi_B_y);
1039  }
1040  } else if (ibe == 1) {
1041  if (isArgonStraw) {
1042  TronTDist_E_Ar = trailingEdgeScaled;
1043  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TronTDist_E_Ar);
1044  AvgTroTDetPhi_E_Ar_x = phi2D[ibe];
1045  AvgTroTDetPhi_E_Ar_y = trailingEdgeScaled;
1046  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), AvgTroTDetPhi_E_Ar_x, AvgTroTDetPhi_E_Ar_y);
1047  } else {
1048  TronTDist_E = trailingEdgeScaled;
1049  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), TronTDist_E);
1050  AvgTroTDetPhi_E_x = phi2D[ibe];
1051  AvgTroTDetPhi_E_y = trailingEdgeScaled;
1052  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), AvgTroTDetPhi_E_x, AvgTroTDetPhi_E_y);
1053  }
1054  }
1055  }
1056  }
1057  }
1058  }
1059  }
1060 
1061  // ToDo: work on the part below
1062  for (int ibe = 0; ibe < 2; ibe++) {
1063  for (int i = 0; i < 64; i++)
1064  if (trackfound[ibe][i])
1065  ntrackstack[ibe][i]++;
1066 
1067  if (m_doShift) {
1068  if (ibe == 0) {
1069  if (hitontrack[ibe] >= m_minTRThits) {
1070  NumHoTDetPhi_B_x = phi2D[ibe];
1071  NumHoTDetPhi_B_y = hitontrack[ibe];
1072  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), NumHoTDetPhi_B_x, NumHoTDetPhi_B_y);
1073  }
1074  }
1075 
1076  if (ibe == 1) {
1077  if (hitontrack_E_side[0] >= m_minTRThits) {
1078  NumHoTDetPhi_E_x = phi2D[ibe];
1079  NumHoTDetPhi_E_y = hitontrack_E_side[0];
1080  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+"0", NumHoTDetPhi_E_x, NumHoTDetPhi_E_y);
1081  }
1082 
1083  if (hitontrack_E_side[1] >= m_minTRThits) {
1084  NumHoTDetPhi_E_x = phi2D[ibe];
1085  NumHoTDetPhi_E_y = hitontrack_E_side[1];
1086  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+"1", NumHoTDetPhi_E_x, NumHoTDetPhi_E_y);
1087  }
1088  }
1089  }
1090 
1091  if (phi2D[ibe] < 0) continue;
1092 
1093  if (m_doShift) {
1094  if (ibe == 0) {
1095  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0) {
1096  NumTrksDetPhi_B = phi2D[ibe];
1097  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), NumTrksDetPhi_B);
1098  }
1099  } else if (ibe == 1) {
1100  if (nTRTHitsW[ibe][0] > 0) {
1101  NumTrksDetPhi_E = phi2D[ibe];
1102  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+"0", NumTrksDetPhi_E);
1103  }
1104 
1105  if (nTRTHitsW[ibe][1] > 0) {
1106  NumTrksDetPhi_E = phi2D[ibe];
1107  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+"1", NumTrksDetPhi_E);
1108  }
1109  }
1110  }
1111 
1112  if (ibe == 0) {
1113  if ((nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]) > 0) {
1114  nTrksperLB_B++;
1115  }
1116  if (comTimeObject) {
1117  if (m_doShift && (phi2D[ibe] > 0) && (std::abs(timeCor) > 1e-8)) {
1118  EvtPhaseDetPhi_B_x = phi2D[ibe];
1119  EvtPhaseDetPhi_B_y = timeCor;
1120  fill("ShiftTRTTrackHistograms"+std::to_string(ibe), EvtPhaseDetPhi_B_x, EvtPhaseDetPhi_B_y);
1121  }
1122  }
1123  } else if (ibe == 1) {
1124  for (int iside = 0; iside < 2; iside++) {
1125  if (nTRTHitsW[ibe][iside] > 0) nTrksperLB_E[iside]++;
1126  if (comTimeObject) {
1127  if (nTRTHits_side[ibe][iside] > 5 && (std::abs(timeCor)
1128  > 1e-8)) {
1129  if (m_doShift) {
1130  EvtPhaseDetPhi_E_x = phi2D[ibe];
1131  EvtPhaseDetPhi_E_y = timeCor;
1132  fill("ShiftTRTTrackHistograms"+std::to_string(ibe)+std::to_string(iside), EvtPhaseDetPhi_E_x, EvtPhaseDetPhi_E_y);
1133  }
1134  }
1135  }
1136  }
1137  }
1138  }
1139  }
1140 
1141  if (comTimeObject) {
1142  if (std::abs(timeCor) > 1e-8) {
1143  if (m_doShift) {
1144  EvtPhase = timeCor;
1145  fill("ShiftTRTTrackHistograms0", EvtPhase);
1146  }
1147 
1148  if (m_doShift && trigDecision) {
1149  std::vector<int> trigid;
1150  trigid.clear(); // Trigger ID
1151  // Get bits for trigger after veto
1152  std::vector<unsigned int> level1TAV = trigDecision->tav();
1153 
1154  for (unsigned int j = 0; j < 8 && j < level1TAV.size(); ++j) {
1155  for (unsigned int i = 0; i < 32; ++i) {
1156  if ((level1TAV[j] >> i) & 0x1) {
1157  trigid.push_back(i + (j % 8) * 32); // Found the ID
1158  }
1159  }
1160  }
1161 
1162  for (unsigned int j = 0; j < trigid.size(); ++j) {
1163  EvtPhaseVsTrig_x = timeCor;
1164  EvtPhaseVsTrig_y = trigid[j];
1165  fill("ShiftTRTTrackHistograms0", EvtPhaseVsTrig_x, EvtPhaseVsTrig_y);
1166  }
1167  }
1168  }
1169  }
1170 
1171  if (m_doShift) {
1172  Summary = 0;
1173  SummaryWeight = 1.;
1174  fill("SmryHistograms", SummaryWeight, Summary);
1175 
1176  if (m_doTracksMon) {
1177  Summary = 1;
1178  SummaryWeight = nTotalTracks;
1179  fill("SmryHistograms", SummaryWeight, Summary);
1180  Summary = 2;
1181  SummaryWeight = nTracksB[0];
1182  fill("SmryHistograms", SummaryWeight, Summary);
1183  Summary = 3;
1184  SummaryWeight = nTracksB[1];
1185  fill("SmryHistograms", SummaryWeight, Summary);
1186  Summary = 4;
1187  SummaryWeight = nTracksEC[0];
1188  fill("SmryHistograms", SummaryWeight, Summary);
1189  Summary = 5;
1190  SummaryWeight = nTracksEC[1];
1191  fill("SmryHistograms", SummaryWeight, Summary);
1192  Summary = 6;
1193  SummaryWeight = nTracksEC_B[0];
1194  fill("SmryHistograms", SummaryWeight, Summary);
1195  Summary = 7;
1196  SummaryWeight = nTracksEC_B[1];
1197  fill("SmryHistograms", SummaryWeight, Summary);
1198  }
1199 
1200  const unsigned int lumiBlock = eventInfo.lumiBlock();
1201  ATH_MSG_VERBOSE("This is lumiblock : " << lumiBlock);
1202  int lastLumiBlock = -99; // ToDo - last lumiblock calculation is not correct
1203  if ((int)lumiBlock != lastLumiBlock) {
1204  lastLumiBlock = lumiBlock;
1205  }
1206  float evtLumiBlock = 1.;
1207  float lumiBlockScale = (evtLumiBlock > 0) ? (1. / evtLumiBlock) : 0;
1208 
1209  if (m_doTracksMon && evtLumiBlock > 0) {
1210  NTrksperLB_x = lastLumiBlock;
1211  NTrksperLB_y = (float)nTrksperLB_B * lumiBlockScale;
1212  fill("ShiftTRTTrackHistograms0", NTrksperLB_x, NTrksperLB_y);
1213 
1214  for (int iside = 0; iside < 2; iside++) {
1215  NTrksperLB_x = lastLumiBlock;
1216  NTrksperLB_y = (float)nTrksperLB_E[iside] * lumiBlockScale;
1217  fill("ShiftTRTTrackHistograms1"+std::to_string(iside), NTrksperLB_x, NTrksperLB_y);
1218  }
1219 
1220  nTrksperLB_B = 0;
1221 
1222  for (int iside = 0; iside < 2; iside++) {
1223  nTrksperLB_E[iside] = 0;
1224  }
1225  }
1226  }
1227 
1228  ATH_MSG_DEBUG("end of event and lumi block");
1229  //number of events in lumiblock counter setted to zero since it is end of the run or the lumiblock
1230 
1231  return StatusCode::SUCCESS;
1232 }

◆ filterPassed()

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

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ GetEventInfo()

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

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

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

Definition at line 107 of file AthMonitorAlgorithm.cxx.

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 164 of file AthMonitorAlgorithm.cxx.

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

◆ getTrigDecisionTool()

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

Get the trigger decision tool member.

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

Returns
m_trigDecTool

Definition at line 189 of file AthMonitorAlgorithm.cxx.

189  {
190  return m_trigDecTool;
191 }

◆ initialize()

StatusCode TRTMonitoringRun3ESD_Alg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 77 of file TRTMonitoringRun3ESD_Alg.cxx.

77  {
78  using namespace Monitored;
79 
80  ATH_MSG_VERBOSE("Initializing TRT Monitoring");
81 
82  // Initialize superclass
83  ATH_CHECK( AthMonitorAlgorithm::initialize() );
84 
85  // Retrieve detector manager
86  ATH_CHECK( detStore()->retrieve(m_mgr, "TRT") );
87  // Get ID helper for TRT to access various detector components like straw, straw_layer, layer_or_wheel, phi_module, etc.
88  ATH_CHECK( detStore()->retrieve(m_pTRTHelper, "TRT_ID") );
89  ATH_CHECK( detStore()->retrieve(m_idHelper, "AtlasID") );
90 
91  // InDetTrackSelectionTools initialization:
92  ATH_CHECK( m_trackSelTool.retrieve() );
93 
94  if (m_doExpert) {
95  // Retrieve the TRT_Straw Status Service
96  if (m_sumTool.name().empty()) {
97  ATH_MSG_WARNING("TRT_StrawStatusTool not given.");
98  } else {
99  ATH_CHECK( m_sumTool.retrieve() );
100  }
101 
102  Identifier ident;
103 
104  if (m_sumTool.name() != "") {
105  ATH_MSG_VERBOSE("Trying " << m_sumTool << " isGood");
106  ATH_MSG_VERBOSE("TRT_StrawStatusTool reports status = " << m_sumTool->getStatus(ident));
107  }
108  } //If do expert
109 
110  // Retrieve TRT_StrawNeighbourService
111  if (m_TRTStrawNeighbourSvc.name().empty()) {
112  ATH_MSG_WARNING("TRT_StrawNeighbourSvc not given.");
113  } else {
114  if (m_TRTStrawNeighbourSvc.retrieve().isFailure()) {
115  ATH_MSG_FATAL("Could not get StrawNeighbourSvc.");
116  }
117  }
118 
119  // Get Track summary tool
120  if (m_TrackSummaryTool.retrieve().isFailure())
121  ATH_MSG_ERROR("Cannot get TrackSummaryTool");
122  else
123  ATH_MSG_DEBUG("Retrieved succesfully the track summary tool" << m_TrackSummaryTool);
124 
125  //Get TRTCalDbTool
126  if (m_TRTCalDbTool.name().empty()) {
127  ATH_MSG_WARNING("TRT_CalDbTool not given.");
128  } else {
129  if (m_TRTCalDbTool.retrieve().isFailure()) {
130  ATH_MSG_ERROR("Cannot get TRTCalDBTool.");
131  }
132  }
133 
134  ATH_CHECK(m_drifttool.retrieve());
135 
136  // Initialize arrays
137  // These arrays store information about each entry to the HitMap histograms
138 
139  if (true) {
140  //loop over straw hash index to create straw number mapping for TRTViewer
141  unsigned int maxHash = m_pTRTHelper->straw_layer_hash_max();
142 
143  for (int ibe = 0; ibe < 2; ibe++) { // ibe=0(barrel), ibe=1(endcap)
144  for (unsigned int index = 0; index < maxHash; index++) {
145  IdentifierHash idHash = index;
146  Identifier id = m_pTRTHelper->layer_id(idHash);
147  int idBarrelEndcap = m_pTRTHelper->barrel_ec(id);
148  int idLayerWheel = m_pTRTHelper->layer_or_wheel(id);
149  int idPhiModule = m_pTRTHelper->phi_module(id);
150  int idStrawLayer = m_pTRTHelper->straw_layer(id);
151  bool isBarrel = m_pTRTHelper->is_barrel(id);
152  int idSide;
153  int sectorflag = 0;
154  const InDetDD::TRT_BaseElement *element = nullptr;
155 
156  if (ibe == 0) { // barrel
157  idSide = idBarrelEndcap ? 1 : -1;
158 
159  if (isBarrel && (idBarrelEndcap == -1)) {
160  sectorflag = 1;
161  element = m_mgr->getBarrelElement(idSide, idLayerWheel, idPhiModule, idStrawLayer);
162  }
163  } else if (ibe == 1) { // endcap
164  idSide = idBarrelEndcap ? 1 : 0;
165 
166  if (!isBarrel && ((idBarrelEndcap == -2) || (idBarrelEndcap == 2))) {
167  sectorflag = 1;
168  element = m_mgr->getEndcapElement(idSide, idLayerWheel, idStrawLayer, idPhiModule);//, idStrawLayer_ec);
169  }
170  }
171 
172  if (sectorflag == 1) {
173  if (!element) continue;
174 
175  for (unsigned int istraw = 0; istraw < element->nStraws(); istraw++) {
176  std::vector<Identifier> neighbourIDs;
177  Identifier strawID = m_pTRTHelper->straw_id(id, int(istraw));
178  int i_chip, i_pad;
179  m_TRTStrawNeighbourSvc->getChip(strawID, i_chip);
180  m_TRTStrawNeighbourSvc->getPad(id, i_pad);
181 
182  if (ibe == 0) { //barrel
183  if (idLayerWheel == 1) i_chip += 21;
184 
185  if (idLayerWheel == 2) i_chip += 54;
186 
187  int tempStrawNumber = strawNumber(istraw, idStrawLayer, idLayerWheel);
188 
189  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
190  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
191  } else {
192  m_mat_chip_B.at(idPhiModule).at(tempStrawNumber) = i_chip;
193  m_mat_chip_B.at(idPhiModule + 32).at(tempStrawNumber) = i_chip;
194  }
195  } else if (ibe == 1) { //endcap
196  ++i_chip -= 104;
197  int tempStrawNumber = strawNumberEndCap(istraw, idStrawLayer, idLayerWheel, idPhiModule, idSide);
198 
199  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
200  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
201  } else {
202  m_mat_chip_E.at(idPhiModule).at(tempStrawNumber) = i_chip;
203  m_mat_chip_E.at(idPhiModule + 32).at(tempStrawNumber) = i_chip;
204  }
205  }
206  }
207  }
208  }
209  }
210  }
211 
212  // Initialization of VarHandleKeys
213  ATH_CHECK( m_trackCollectionKey.initialize() );
214  ATH_CHECK( m_xAODEventInfoKey.initialize() );
215  ATH_CHECK( m_TRT_BCIDCollectionKey.initialize() );
216  ATH_CHECK( m_comTimeObjectKey.initialize(!m_comTimeObjectKey.empty() && m_doTracksMon) );
217  ATH_CHECK( m_trigDecisionKey.initialize(SG::AllowEmpty) );
218 
219  return StatusCode::SUCCESS;
220 }

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

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ parseList()

StatusCode AthMonitorAlgorithm::parseList ( const std::string &  line,
std::vector< std::string > &  result 
) const
virtualinherited

Parse a string into a vector.

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

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

Definition at line 336 of file AthMonitorAlgorithm.cxx.

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

◆ radToDegrees()

float TRTMonitoringRun3ESD_Alg::radToDegrees ( float  radValue) const
private

Definition at line 368 of file TRTMonitoringRun3ESD_Alg.cxx.

368  {
369 //----------------------------------------------------------------------------------//
370  float degreeValue = radValue / M_PI * 180;
371 
372  if (degreeValue < 0) degreeValue += 360;
373 
374  return degreeValue;
375 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ Straw_Gastype()

GasType TRTMonitoringRun3ESD_Alg::Straw_Gastype ( int  stat) const
inlineprivate

Definition at line 149 of file TRTMonitoringRun3ESD_Alg.h.

149  {
150  // getStatusHT returns enum {Undefined, Dead, Good, Xenon, Argon, Krypton}.
151  // Our representation of 'GasType' is 0:Xenon, 1:Argon, 2:Krypton
152  GasType Gas = Xe; // Xenon is default
153  if (m_ArgonXenonSplitter) {
154  // int stat=m_sumSvc->getStatusHT(TRT_Identifier);
155  if ( stat==2 || stat==3 ) { Gas = Xe; } // Xe
156  else if ( stat==1 || stat==4 ) { Gas = Ar; } // Ar
157  else if ( stat==5 ) { Gas = Kr; } // Kr
158  else if ( stat==6 ) { Gas = Xe; } // Emulate Ar (so treat as Xe here)
159  else if ( stat==7 ) { Gas = Xe; } // Emulate Kr (so treat as Xe here)
160  else { ATH_MSG_FATAL ("getStatusHT = " << stat << ", must be 'Good(2)||Xenon(3)' or 'Dead(1)||Argon(4)' or 'Krypton(5)!' or 6 or 7 for emulated types!");
161  throw std::exception();
162  }
163  }
164  return Gas;
165  }

◆ strawLayerNumber()

int TRTMonitoringRun3ESD_Alg::strawLayerNumber ( int  strawLayerNumber,
int  LayerNumber 
) const
private

Definition at line 224 of file TRTMonitoringRun3ESD_Alg.cxx.

224  {
225 //----------------------------------------------------------------------------------//
226  switch (LayerNumber) {
227  case 0:
228  return strawLayerNumber;
229 
230  case 1:
231  return strawLayerNumber + 19;
232 
233  case 2:
234  return strawLayerNumber + 43;
235 
236  default:
237  return strawLayerNumber;
238  }
239 }

◆ strawLayerNumber_reverse()

int TRTMonitoringRun3ESD_Alg::strawLayerNumber_reverse ( int  strawLayerNumInp,
int *  strawLayerNumber,
int *  LayerNumber 
) const
private

◆ strawNumber()

int TRTMonitoringRun3ESD_Alg::strawNumber ( int  strawNumber,
int  strawlayerNumber,
int  LayerNumber 
) const
private

Definition at line 242 of file TRTMonitoringRun3ESD_Alg.cxx.

242  {
243 //----------------------------------------------------------------------------------//
244  int addToStrawNumber = 0;
245  int addToStrawNumberNext = 0;
246  int i = 0;
247  const int numberOfStraws[75] = {
248  0,
249  15,
250  16, 16, 16, 16,
251  17, 17, 17, 17, 17,
252  18, 18, 18, 18, 18,
253  19, 19, 19,
254  18,
255  19,
256  20, 20, 20, 20, 20,
257  21, 21, 21, 21, 21,
258  22, 22, 22, 22, 22,
259  23, 23, 23, 23, 23,
260  24, 24,
261  23, 23,
262  24, 24, 24, 24,
263  25, 25, 25, 25, 25,
264  26, 26, 26, 26, 26,
265  27, 27, 27, 27, 27,
266  28, 28, 28, 28, 28,
267  29, 29, 29, 29,
268  28,
269  0
270  };
271 
272  do {
273  i++;
274  addToStrawNumber += numberOfStraws[i - 1];
275  addToStrawNumberNext = addToStrawNumber + numberOfStraws[i];
276  } while (strawLayerNumber(strawlayerNumber, LayerNumber) != i - 1);
277 
278  strawNumber = addToStrawNumberNext - strawNumber - 1;
279 
280  if (strawNumber < 0 || strawNumber > s_Straw_max[0] - 1) {
281  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
282  strawNumber = 0;
283  }
284 
285  return strawNumber;
286 }

◆ strawNumber_reverse()

int TRTMonitoringRun3ESD_Alg::strawNumber_reverse ( int  inp_strawnumber,
int *  strawNumber,
int *  strawlayerNumber,
int *  LayerNumber 
) const
private

◆ strawNumberEndCap()

int TRTMonitoringRun3ESD_Alg::strawNumberEndCap ( int  strawNumber,
int  strawLayerNumber,
int  LayerNumber,
int  phi_stack,
int  side 
) const
private

Definition at line 290 of file TRTMonitoringRun3ESD_Alg.cxx.

290  {
291 //----------------------------------------------------------------------------------//
292  // Before perfoming map, corrections need to be perfomed.
293  // apply special rotations for endcap mappings
294  // for eca, rotate triplets by 180 for stacks 9-16, and 25-32.
295  static const int TripletOrientation[2][32] = {
296  {
297  1, 1, 1, 1, 1, 1, 1, 1,
298  0, 0, 0, 0, 0, 0, 0, 0,
299  1, 1, 1, 1, 1, 1, 1, 1,
300  0, 0, 0, 0, 0, 0, 0, 0
301  },
302  {
303  1, 1, 1, 1, 1, 1, 1, 1,
304  0, 0, 0, 0, 0, 0, 0, 0,
305  1, 1, 1, 1, 1, 1, 1, 1,
306  0, 0, 0, 0, 0, 0, 0, 0
307  }
308  };
309  int phi1 = -1;
310 
311  if (side == 2) phi1 = phi_stack, side = 1;
312  else if (side == -2) phi1 = 31 - phi_stack, side = 0;
313 
314  if (phi1 > -1) {
315  if (TripletOrientation[side][phi1]) {
316  // Change straw number from 0-23 in straw layer to 0-192
317  if (strawLayerNumber < 8)strawNumber = strawNumber + 24 * strawLayerNumber;
318 
319  if (strawLayerNumber > 7)strawNumber = strawNumber + 24 * (strawLayerNumber - 8);
320 
321  strawNumber = (192 - 1) * TripletOrientation[side][phi1] + strawNumber * (1 - 2 * TripletOrientation[side][phi1]); //actual rotation
322 
323  // Take strawNumber back to 0-23
324  if (strawLayerNumber < 8) strawLayerNumber = int(strawNumber / 24);
325 
326  if (strawLayerNumber > 7) strawLayerNumber = int(strawNumber / 24) + 8;
327 
328  strawNumber = strawNumber % 24;
329  }
330 
331  // Finish rotation
332  // Flip straw in layer.
333 
334  if (side == 0) strawNumber = 23 - strawNumber;
335 
336  // Finish Flipping
337  }
338 
339  // Done with corrections
340  // Start mapping from athena identifiers to TRTViewer maps
341  int strawNumberNew = 0;
342 
343  if (LayerNumber < 6 && strawLayerNumber > 7) {
344  strawNumberNew = strawNumberNew + (384 * LayerNumber);
345  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (strawNumber * 8);
346  } else if (LayerNumber < 6 && strawLayerNumber < 8) {
347  strawNumberNew = strawNumberNew + (384 * LayerNumber);
348  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (strawNumber * 8);
349  } else if (LayerNumber > 5 && strawLayerNumber > 7) {
350  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
351  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (8 * strawNumber);
352  } else if (LayerNumber > 5 && strawLayerNumber < 8) {
353  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
354  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (8 * strawNumber);
355  }
356 
357  strawNumber = strawNumberNew;
358 
359  if (strawNumber < 0 || strawNumber > s_Straw_max[1] - 1) {
360  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
361  strawNumber = 0;
362  }
363 
364  return strawNumber;
365 }

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 194 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ cfg

TRTMonitoringRun3ESD_Alg.cfg = MainServicesCfg(flags)

Definition at line 238 of file TRTMonitoringRun3ESD_Alg.py.

◆ Dynamic

TRTMonitoringRun3ESD_Alg.Dynamic

Definition at line 228 of file TRTMonitoringRun3ESD_Alg.py.

◆ Files

TRTMonitoringRun3ESD_Alg.Files

Definition at line 225 of file TRTMonitoringRun3ESD_Alg.py.

◆ flags

TRTMonitoringRun3ESD_Alg.flags = initConfigFlags()

Definition at line 224 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometryPixel

TRTMonitoringRun3ESD_Alg.GeometryPixel

Definition at line 229 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometrySCT

TRTMonitoringRun3ESD_Alg.GeometrySCT

Definition at line 230 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometryTRT

TRTMonitoringRun3ESD_Alg.GeometryTRT

Definition at line 231 of file TRTMonitoringRun3ESD_Alg.py.

◆ GlobalTag

TRTMonitoringRun3ESD_Alg.GlobalTag

Definition at line 232 of file TRTMonitoringRun3ESD_Alg.py.

◆ HISTFileName

TRTMonitoringRun3ESD_Alg.HISTFileName

Definition at line 227 of file TRTMonitoringRun3ESD_Alg.py.

◆ isMC

TRTMonitoringRun3ESD_Alg.isMC

Definition at line 226 of file TRTMonitoringRun3ESD_Alg.py.

◆ m_ArgonXenonSplitter

BooleanProperty TRTMonitoringRun3ESD_Alg::m_ArgonXenonSplitter {this, "doArgonXenonSeparation", true}
private

Definition at line 72 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_comTimeObjectKey

SG::ReadHandleKey<ComTime> TRTMonitoringRun3ESD_Alg::m_comTimeObjectKey {this, "ComTimeObjectName", "TRT_Phase", "Name of ComTime object"}
private

Definition at line 118 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_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_DistToStraw

float TRTMonitoringRun3ESD_Alg::m_DistToStraw
private

Definition at line 137 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doChips

bool TRTMonitoringRun3ESD_Alg::m_doChips
private

Definition at line 130 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doExpert

bool TRTMonitoringRun3ESD_Alg::m_doExpert
private

Definition at line 132 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doShift

bool TRTMonitoringRun3ESD_Alg::m_doShift
private

Definition at line 131 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doStraws

bool TRTMonitoringRun3ESD_Alg::m_doStraws
private

Definition at line 129 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doTracksMon

bool TRTMonitoringRun3ESD_Alg::m_doTracksMon
private

Definition at line 128 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_drifttool

ToolHandle<ITRT_DriftFunctionTool> TRTMonitoringRun3ESD_Alg::m_drifttool
private

Definition at line 123 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_EventBurstCut

int TRTMonitoringRun3ESD_Alg::m_EventBurstCut
private

Definition at line 167 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_EventInfoKey

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

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 358 of file AthMonitorAlgorithm.h.

◆ m_idHelper

const AtlasDetectorID* TRTMonitoringRun3ESD_Alg::m_idHelper
private

Definition at line 75 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_isCosmics

bool TRTMonitoringRun3ESD_Alg::m_isCosmics
private

Definition at line 138 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_lbDurationDataKey

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

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_lumiDataKey

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

Definition at line 343 of file AthMonitorAlgorithm.h.

◆ m_mat_chip_B

std::vector<std::vector<unsigned char> > TRTMonitoringRun3ESD_Alg::m_mat_chip_B {64, std::vector<unsigned char>(1642)}
private

Definition at line 134 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_mat_chip_E

std::vector<std::vector<unsigned char> > TRTMonitoringRun3ESD_Alg::m_mat_chip_E {64, std::vector<unsigned char>(3840)}
private

Definition at line 135 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_mgr

const InDetDD::TRT_DetectorManager* TRTMonitoringRun3ESD_Alg::m_mgr
private

Definition at line 126 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_pixel_hits

int TRTMonitoringRun3ESD_Alg::m_min_pixel_hits
private

Definition at line 141 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_pT

float TRTMonitoringRun3ESD_Alg::m_min_pT
private

Definition at line 146 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_sct_hits

int TRTMonitoringRun3ESD_Alg::m_min_sct_hits
private

Definition at line 142 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_si_hits

int TRTMonitoringRun3ESD_Alg::m_min_si_hits
private

Definition at line 140 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_trt_hits

int TRTMonitoringRun3ESD_Alg::m_min_trt_hits
private

Definition at line 143 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_minP

float TRTMonitoringRun3ESD_Alg::m_minP
private

Definition at line 145 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_minTRThits

int TRTMonitoringRun3ESD_Alg::m_minTRThits
private

Definition at line 144 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_pTRTHelper

const TRT_ID* TRTMonitoringRun3ESD_Alg::m_pTRTHelper
private

Definition at line 125 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_sumTool

ToolHandle<ITRT_StrawStatusSummaryTool> TRTMonitoringRun3ESD_Alg::m_sumTool
private

Definition at line 110 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_toolLookupMap

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

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trackCollectionKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> TRTMonitoringRun3ESD_Alg::m_trackCollectionKey {this, "TrackParticleContainerKeys", "InDetTrackParticles", "Keys for TrackParticle Container"}
private

Definition at line 115 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_trackSelTool

ToolHandle<InDet::IInDetTrackSelectionTool> TRTMonitoringRun3ESD_Alg::m_trackSelTool
private

Definition at line 168 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_TrackSummaryTool

ToolHandle<Trk::ITrackSummaryTool> TRTMonitoringRun3ESD_Alg::m_TrackSummaryTool {this, "TrackSummaryTool", "InDetTrackSummaryTool", "Track summary tool name"}
private

Definition at line 122 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_trigDecisionKey

SG::ReadHandleKey<xAOD::TrigDecision> TRTMonitoringRun3ESD_Alg::m_trigDecisionKey {this, "TrigDecisionObjectName", "xTrigDecision", "Name of trigger decision object"}
private

Definition at line 119 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

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

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

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_TRT_BCIDCollectionKey

SG::ReadHandleKey<InDetTimeCollection> TRTMonitoringRun3ESD_Alg::m_TRT_BCIDCollectionKey {this, "TRTBCIDCollectionName", "TRT_BCID", "Name of TRT BCID collection"}
private

Definition at line 117 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_TRTCalDbTool

ToolHandle<ITRT_CalDbTool> TRTMonitoringRun3ESD_Alg::m_TRTCalDbTool
private

Definition at line 112 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_TRTStrawNeighbourSvc

ServiceHandle<ITRT_StrawNeighbourSvc> TRTMonitoringRun3ESD_Alg::m_TRTStrawNeighbourSvc
private

Definition at line 111 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ m_xAODEventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TRTMonitoringRun3ESD_Alg::m_xAODEventInfoKey {this, "xAODEventInfo", "EventInfo", "Name of EventInfo object"}
private

Definition at line 116 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_iChip_max

const int TRTMonitoringRun3ESD_Alg::s_iChip_max = {104, 240}
staticprivate

Definition at line 105 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_iStack_max

const int TRTMonitoringRun3ESD_Alg::s_iStack_max = {32, 64}
staticprivate

Definition at line 104 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_moduleNum

const int TRTMonitoringRun3ESD_Alg::s_moduleNum = {96, 64}
staticprivate

Definition at line 107 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfBarrelStacks

const int TRTMonitoringRun3ESD_Alg::s_numberOfBarrelStacks = 32
staticprivate

Definition at line 101 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfEndCapStacks

const int TRTMonitoringRun3ESD_Alg::s_numberOfEndCapStacks = 32
staticprivate

Definition at line 102 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfStacks

const int TRTMonitoringRun3ESD_Alg::s_numberOfStacks = {32, 32}
staticprivate

Definition at line 106 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_Straw_max

const int TRTMonitoringRun3ESD_Alg::s_Straw_max = {1642, 3840}
staticprivate

Definition at line 103 of file TRTMonitoringRun3ESD_Alg.h.

◆ TRTMonitoringRun3Acc

def TRTMonitoringRun3ESD_Alg.TRTMonitoringRun3Acc = TRTMonitoringRun3ESD_AlgConfig(flags)

Definition at line 246 of file TRTMonitoringRun3ESD_Alg.py.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TRTMonitoringRun3ESD_Alg::m_min_pixel_hits
int m_min_pixel_hits
Definition: TRTMonitoringRun3ESD_Alg.h:141
TRTMonitoringRun3ESD_Alg::m_minP
float m_minP
Definition: TRTMonitoringRun3ESD_Alg.h:145
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TRT_ID::layer_id
Identifier layer_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer) const
For an individual straw layer.
Definition: TRT_ID.h:500
lastBinHigh
bool lastBinHigh(unsigned int m_word)
Definition: driftCircle.h:108
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
TRTMonitoringRun3ESD_Alg::strawNumberEndCap
int strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:290
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
TRT::Hit::straw
@ straw
Definition: HitInfo.h:82
InDet::TRT_DriftCircleOnTrack::prepRawData
virtual const TRT_DriftCircle * prepRawData() const override final
returns the PrepRawData - is a TRT_DriftCircle in this scope
Definition: TRT_DriftCircleOnTrack.h:202
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Amg::hasPositiveDiagElems
bool hasPositiveDiagElems(const AmgSymMatrix(N) &mat)
Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above defin...
Definition: EventPrimitivesCovarianceHelpers.h:96
AthMonitorAlgorithm::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
Definition: AthMonitorAlgorithm.cxx:250
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
TRTMonitoringRun3ESD_Alg::m_TRT_BCIDCollectionKey
SG::ReadHandleKey< InDetTimeCollection > m_TRT_BCIDCollectionKey
Definition: TRTMonitoringRun3ESD_Alg.h:117
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
Trk::locX
@ locX
Definition: ParamDefs.h:43
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
TRTMonitoringRun3ESD_Alg::fillTRTTracks
StatusCode fillTRTTracks(const xAOD::TrackParticleContainer &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject, const xAOD::EventInfo &eventInfo) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:413
ComTime::getTime
double getTime() const
Definition: ComTime.h:44
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
TRT_LoLumRawData::highLevel
virtual bool highLevel() const override final
Definition: TRT_LoLumRawData.h:128
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TRT_LoLumRawData
Definition: TRT_LoLumRawData.h:25
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
InDetDD::TRT_DetectorManager::getBarrelElement
const TRT_BarrelElement * getBarrelElement(unsigned int positive, unsigned int moduleIndex, unsigned int phiIndex, unsigned int strawLayerIndex) const
Access Barrel Elements:---------------—(Fast)-------------------------—.
Definition: TRT_DetectorManager.cxx:113
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
TRT_ID::straw_layer_hash_max
size_type straw_layer_hash_max(void) const
Definition: TRT_ID.h:920
InDetDD::TRT_BaseElement::nStraws
unsigned int nStraws() const
Number of straws in the element.
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDetDD::TRT_BaseElement::strawCenter
const Amg::Vector3D & strawCenter(int straw) const
Straw Surface: Local -> global transform of the straw via integer.
Definition: TRT_BaseElement.cxx:143
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
xAOD::TrigDecision_v1::tav
const std::vector< uint32_t > & tav() const
Get the Trigger After Veto bits.
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
TRTMonitoringRun3ESD_Alg::m_min_si_hits
int m_min_si_hits
Definition: TRTMonitoringRun3ESD_Alg.h:140
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
cosmics
Definition: cosmics.py:1
Trk::locR
@ locR
Definition: ParamDefs.h:50
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TRTMonitoringRun3ESD_Alg::m_DistToStraw
float m_DistToStraw
Definition: TRTMonitoringRun3ESD_Alg.h:137
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
InDet::TRT_DriftCircle::driftTimeBin
int driftTimeBin() const
returns the leading edge bin defined as in TRT_LoLumRawData to be the first 0-1 transition
MuonValidation_CreateSlides_config.Summary
list Summary
Definition: MuonValidation_CreateSlides_config.py:34
InDet::TRT_DriftCircleOnTrack
Definition: TRT_DriftCircleOnTrack.h:53
ComTime
Definition: ComTime.h:17
TRTMonitoringRun3ESD_Alg::radToDegrees
float radToDegrees(float radValue) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:368
TRTMonitoringRun3ESD_Alg::m_sumTool
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
Definition: TRTMonitoringRun3ESD_Alg.h:110
InDet::TRT_DriftCircleOnTrack::detectorElement
virtual const InDetDD::TRT_BaseElement * detectorElement() const override final
returns the detector element, assoicated with the PRD of this class
Definition: TRT_DriftCircleOnTrack.h:224
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
InDet::TRT_DriftCircle
Definition: TRT_DriftCircle.h:32
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TRTMonitoringRun3ESD_Alg::m_pTRTHelper
const TRT_ID * m_pTRTHelper
Definition: TRTMonitoringRun3ESD_Alg.h:125
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TRTMonitoringRun3ESD_Alg::m_ArgonXenonSplitter
BooleanProperty m_ArgonXenonSplitter
Definition: TRTMonitoringRun3ESD_Alg.h:72
TRTMonitoringRun3ESD_Alg::m_mgr
const InDetDD::TRT_DetectorManager * m_mgr
Definition: TRTMonitoringRun3ESD_Alg.h:126
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TRTCond::RtRelation
Definition: RtRelation.h:27
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
TRT_ID::straw
int straw(const Identifier &id) const
Definition: TRT_ID.h:902
TRTMonitoringRun3ESD_Alg::m_doStraws
bool m_doStraws
Definition: TRTMonitoringRun3ESD_Alg.h:129
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
sim_rttUpdate.user
def user
Definition: sim_rttUpdate.py:662
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
lumiFormat.i
int i
Definition: lumiFormat.py:92
TRTMonitoringRun3ESD_Alg::Straw_Gastype
GasType Straw_Gastype(int stat) const
Definition: TRTMonitoringRun3ESD_Alg.h:149
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
TRTCond::RtRelation::drifttime
virtual float drifttime(float radius) const =0
drifttime for given radius
Trk::theta
@ theta
Definition: ParamDefs.h:72
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRTMonitoringRun3ESD_Alg::m_xAODEventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_xAODEventInfoKey
Definition: TRTMonitoringRun3ESD_Alg.h:116
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:59
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:113
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
TRTMonitoringRun3ESD_Alg::m_TRTStrawNeighbourSvc
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
Definition: TRTMonitoringRun3ESD_Alg.h:111
SignEnum::LE
@ LE
Definition: SignEnums.h:21
calibdata.exception
exception
Definition: calibdata.py:496
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
InDetRawDataCollection
Definition: InDetRawDataCollection.h:31
Side
Definition: WaferTree.h:36
TRTMonitoringRun3ESD_Alg::m_doTracksMon
bool m_doTracksMon
Definition: TRTMonitoringRun3ESD_Alg.h:128
TRTMonitoringRun3ESD_Alg::GasType
GasType
Definition: TRTMonitoringRun3ESD_Alg.h:73
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
TRTMonitoringRun3ESD_Alg::m_doExpert
bool m_doExpert
Definition: TRTMonitoringRun3ESD_Alg.h:132
TRTMonitoringRun3ESD_Alg::strawNumber
int strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:242
TRTMonitoringRun3ESD_Alg::m_isCosmics
bool m_isCosmics
Definition: TRTMonitoringRun3ESD_Alg.h:138
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
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.
InDet::TRT_DriftCircle::trailingEdge
int trailingEdge() const
returns the trailing edge bin
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:866
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:893
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:884
beamspotman.stat
stat
Definition: beamspotman.py:266
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AthMonitorAlgorithm::DataType_t::cosmics
@ cosmics
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
firstBinHigh
bool firstBinHigh(unsigned int m_word)
Definition: driftCircle.h:104
InDetDD::TRT_DetectorManager::getEndcapElement
const TRT_EndcapElement * getEndcapElement(unsigned int positive, unsigned int wheelIndex, unsigned int strawLayerIndex, unsigned int phiIndex) const
Access Endcap Elements:---------------—(Fast)--------------------------—.
Definition: TRT_DetectorManager.cxx:129
Trk::MeasurementBase
Definition: MeasurementBase.h:58
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
AthMonitorAlgorithm::Environment_t::online
@ online
TRTMonitoringRun3ESD_Alg::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TRTMonitoringRun3ESD_Alg.h:75
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TRTMonitoringRun3ESD_Alg::fillTRTHighThreshold
StatusCode fillTRTHighThreshold(const xAOD::TrackParticleContainer &trackCollection, const xAOD::EventInfo &eventInfo, const EventContext &ctx) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:1235
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
TRTCond::ExpandedIdentifier::STRAW
@ STRAW
Definition: InnerDetector/InDetConditions/TRT_ConditionsData/TRT_ConditionsData/ExpandedIdentifier.h:37
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
TRTMonitoringRun3ESD_Alg::m_trigDecisionKey
SG::ReadHandleKey< xAOD::TrigDecision > m_trigDecisionKey
Definition: TRTMonitoringRun3ESD_Alg.h:119
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
InDet::TRT_DriftCircle::lastBinHigh
bool lastBinHigh() const
returns true if the last bin is high
TRTMonitoringRun3ESD_Alg::m_minTRThits
int m_minTRThits
Definition: TRTMonitoringRun3ESD_Alg.h:144
item
Definition: ItemListSvc.h:43
TRT::Hit::ident
@ ident
Definition: HitInfo.h:77
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:875
xAOD::timeStamp
setEventNumber timeStamp
Definition: EventInfo_v1.cxx:128
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
TRTMonitoringRun3ESD_Alg::m_trackSelTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool
Definition: TRTMonitoringRun3ESD_Alg.h:168
DeMoScan.index
string index
Definition: DeMoScan.py:362
TRTMonitoringRun3ESD_Alg::Kr
@ Kr
Definition: TRTMonitoringRun3ESD_Alg.h:73
TRTMonitoringRun3ESD_Alg::m_mat_chip_E
std::vector< std::vector< unsigned char > > m_mat_chip_E
Definition: TRTMonitoringRun3ESD_Alg.h:135
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:857
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
lumiFormat.fill
fill
Definition: lumiFormat.py:111
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
TRTMonitoringRun3ESD_Alg::m_drifttool
ToolHandle< ITRT_DriftFunctionTool > m_drifttool
Definition: TRTMonitoringRun3ESD_Alg.h:123
TRTMonitoringRun3ESD_Alg::m_min_sct_hits
int m_min_sct_hits
Definition: TRTMonitoringRun3ESD_Alg.h:142
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
TRTMonitoringRun3ESD_Alg::m_mat_chip_B
std::vector< std::vector< unsigned char > > m_mat_chip_B
Definition: TRTMonitoringRun3ESD_Alg.h:134
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
InDet::TRT_DriftCircle::driftTimeValid
bool driftTimeValid() const
return true if the corrected drift time is OK
TRTMonitoringRun3ESD_Alg::m_TRTCalDbTool
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool
Definition: TRTMonitoringRun3ESD_Alg.h:112
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TRTMonitoringRun3ESD_Alg::m_doChips
bool m_doChips
Definition: TRTMonitoringRun3ESD_Alg.h:130
TRTMonitoringRun3ESD_Alg::strawLayerNumber
int strawLayerNumber(int strawLayerNumber, int LayerNumber) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:224
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
InDet::TRT_DriftCircle::rawDriftTime
double rawDriftTime() const
returns the raw driftTime
InDet::TRT_DriftCircleOnTrack::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
return the global position of this RIO_OnTrack
Definition: TRT_DriftCircleOnTrack.cxx:160
InDet::TRT_DriftCircle::getWord
unsigned int getWord() const
returns the TRT dataword
TRTMonitoringRun3ESD_Alg::m_min_trt_hits
int m_min_trt_hits
Definition: TRTMonitoringRun3ESD_Alg.h:143
AthMonitorAlgorithm::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the duration of the luminosity block (in seconds)
Definition: AthMonitorAlgorithm.cxx:319
TRTMonitoringRun3ESD_Alg::Xe
@ Xe
Definition: TRTMonitoringRun3ESD_Alg.h:73
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
TRTMonitoringRun3ESD_Alg::m_doShift
bool m_doShift
Definition: TRTMonitoringRun3ESD_Alg.h:131
SG::get
const T * get(const ReadHandleKey< T > &key)
Convenience function to retrieve an object given a ReadHandleKey.
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TRTMonitoringRun3ESD_Alg::Ar
@ Ar
Definition: TRTMonitoringRun3ESD_Alg.h:73
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
trailingEdge
int trailingEdge(unsigned int m_word)
Definition: driftCircle.h:64
TRTMonitoringRun3ESD_Alg::m_min_pT
float m_min_pT
Definition: TRTMonitoringRun3ESD_Alg.h:146
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDet::TRT_DriftCircle::firstBinHigh
bool firstBinHigh() const
returns true if the first bin is high
readCCLHist.float
float
Definition: readCCLHist.py:83
xAOD::TrigDecision_v1
Interface to the raw trigger decision information of the event.
Definition: TrigDecision_v1.h:44
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
TRTMonitoringRun3ESD_Alg::s_Straw_max
static const int s_Straw_max[2]
Definition: TRTMonitoringRun3ESD_Alg.h:103
TRTMonitoringRun3ESD_Alg::m_TrackSummaryTool
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool
Definition: TRTMonitoringRun3ESD_Alg.h:122
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:57
TRTMonitoringRun3ESD_Alg::m_EventBurstCut
int m_EventBurstCut
Definition: TRTMonitoringRun3ESD_Alg.h:167
TRT_ID::straw_id
Identifier straw_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer, int straw) const
Three ways of getting id for a single straw:
Definition: TRT_ID.h:581
TRTMonitoringRun3ESD_Alg::m_comTimeObjectKey
SG::ReadHandleKey< ComTime > m_comTimeObjectKey
Definition: TRTMonitoringRun3ESD_Alg.h:118
ServiceHandle< ICondSvc >
driftTimeBin
int driftTimeBin(unsigned int m_word)
Definition: driftCircle.h:50
collisions
Definition: collisions.py:1
TRTMonitoringRun3ESD_Alg::m_trackCollectionKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackCollectionKey
Definition: TRTMonitoringRun3ESD_Alg.h:115
Generated on Tue Jul 2 2024 22:09:04 for ATLAS Offline Software by   doxygen 1.8.18