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, V, H > &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 EventContext &ctx, 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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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 {this, "InDetTRTStrawStatusSummaryTool", "TRT_StrawStatusSummaryTool",""}
 
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc {this, "NeighbourSvc", "TRT_StrawNeighbourSvc", ""}
 
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool {this, "ITRT_CalDbTool", "TRT_CalDbTool", ""}
 
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 {this, "DriftFunctionTool", "TRT_DriftFunctionTool", ""}
 
const TRT_ID * m_pTRTHelper {}
 
const InDetDD::TRT_DetectorManager * m_mgr {}
 
Gaudi::Property< bool > m_doTracksMon {this, "DoTracksMon", true, ""}
 
Gaudi::Property< bool > m_doStraws {this, "doStraws", true, ""}
 
Gaudi::Property< bool > m_doChips {this, "doChips", true, ""}
 
Gaudi::Property< bool > m_doShift {this, "doShift", true, ""}
 
Gaudi::Property< bool > m_doExpert {this, "doExpert", false, ""}
 
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)}
 
Gaudi::Property< float > m_DistToStraw {this, "DistanceToStraw", 0.4f, ""}
 
bool m_isCosmics {false}
 
Gaudi::Property< int > m_min_si_hits {this, "min_si_hits", 1, ""}
 
Gaudi::Property< int > m_min_pixel_hits {this, "min_pixel_hits", 0, ""}
 
Gaudi::Property< int > m_min_sct_hits {this, "min_sct_hits", 0, ""}
 
Gaudi::Property< int > m_min_trt_hits {this, "min_trt_hits", 10, ""}
 
Gaudi::Property< int > m_minTRThits {this, "MinTRTHitCut", 10, ""}
 
Gaudi::Property< float > m_minP {this, "MinTrackP", 0.0 * CLHEP::GeV}
 
Gaudi::Property< float > m_min_pT {this, "min_pT", 0.5 * CLHEP::GeV}
 
int m_EventBurstCut {-1}
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool {this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", ""}
 
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 61 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 143 of file TRTMonitoringRun3ESD_Alg.h.

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

Constructor & Destructor Documentation

◆ TRTMonitoringRun3ESD_Alg()

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

Definition at line 40 of file TRTMonitoringRun3ESD_Alg.cxx.

41 :AthMonitorAlgorithm(name,pSvcLocator)
42 {
43 }

◆ ~TRTMonitoringRun3ESD_Alg()

TRTMonitoringRun3ESD_Alg::~TRTMonitoringRun3ESD_Alg ( )
virtual

Definition at line 45 of file TRTMonitoringRun3ESD_Alg.cxx.

45 {}

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ checkEventBurst()

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

Definition at line 351 of file TRTMonitoringRun3ESD_Alg.cxx.

351  {
352 //----------------------------------------------------------------------------------//
353  if (m_EventBurstCut <= 0) return true;
354 
355  int nHLHits = 0;
356  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
357  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
358 
359  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
360  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
361 
362  if (!TRT_Collection) continue;
363  else {
364  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
365 
366  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
367  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
368 
369  if (!p_lolum) continue;
370 
371  if (p_lolum->highLevel()) nHLHits++;
372  }
373  }
374  }
375 
376  if (nHLHits > m_EventBurstCut) return false;
377  else return true;
378 }

◆ 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, V, H > &  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, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

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

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

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ fillHistograms()

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

1431  {
1432  using namespace Monitored;
1433  bool passEventBurst = true;
1434 
1435  // Declare the quantities which should be monitored
1436 
1437  // Set the values of the monitored variables for the event
1438 
1439  ATH_MSG_VERBOSE("Monitoring Histograms being filled");
1440 
1441  SG::ReadHandle<xAOD::TrackParticleContainer> trackCollection(m_trackCollectionKey, ctx);
1442  SG::ReadHandle<xAOD::EventInfo> xAODEventInfo(m_xAODEventInfoKey, ctx);
1443  SG::ReadHandle<InDetTimeCollection> trtBCIDCollection(m_TRT_BCIDCollectionKey, ctx);
1444 
1445  if (!xAODEventInfo.isValid()) {
1446  ATH_MSG_ERROR("Could not find event info object " << m_xAODEventInfoKey.key() <<
1447  " in store");
1448  return StatusCode::FAILURE;
1449  }
1450 
1451  if (m_doTracksMon) {
1452  if (!trackCollection.isValid()) {
1453  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1454  " in store");
1455  return StatusCode::FAILURE;
1456  }
1457  const xAOD::TrigDecision* trigDecision = nullptr;
1458  if (! m_trigDecisionKey.empty()) {
1459  trigDecision = SG::get(m_trigDecisionKey, ctx);
1460  if (!trigDecision) {
1461  ATH_MSG_INFO("Could not find trigger decision object " << m_trigDecisionKey.key() <<
1462  " in store");
1463  }
1464  }
1465  const ComTime *comTimeObject=nullptr;
1466  if (!m_comTimeObjectKey.empty()) {
1467  SG::ReadHandle<ComTime> tmp_comTimeObject(m_comTimeObjectKey, ctx);
1468  if (!tmp_comTimeObject.isValid()) {
1469  // NOTE: failing to retrieve ComTime from store for some reason
1470  ATH_MSG_DEBUG("Could not find com time object " << m_comTimeObjectKey.key() << " in store" );
1471  }
1472  else {
1473  comTimeObject = tmp_comTimeObject.cptr();
1474  }
1475  }
1476  ATH_CHECK( fillTRTTracks(ctx, *trackCollection, trigDecision, comTimeObject, *xAODEventInfo) );
1477  }
1478 
1479  if (!m_doTracksMon) {
1480  if (!trackCollection.isValid()) {
1481  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1482  " in store");
1483  return StatusCode::FAILURE;
1484  }
1485  }
1486 
1487  if (passEventBurst) { // ESD files does not have an RDO container to pass event burst, what to do?
1488  ATH_CHECK( fillTRTHighThreshold(*trackCollection, *xAODEventInfo, ctx) );
1489  }
1490 
1491 
1492 
1493  return StatusCode::SUCCESS;
1494 }

◆ fillTRTHighThreshold()

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

Definition at line 1206 of file TRTMonitoringRun3ESD_Alg.cxx.

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

◆ fillTRTTracks()

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

Definition at line 383 of file TRTMonitoringRun3ESD_Alg.cxx.

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

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ GetEventInfo()

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

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

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

Definition at line 107 of file AthMonitorAlgorithm.cxx.

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 164 of file AthMonitorAlgorithm.cxx.

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

◆ getTrigDecisionTool()

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

Get the trigger decision tool member.

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

Returns
m_trigDecTool

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ initialize()

StatusCode TRTMonitoringRun3ESD_Alg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 47 of file TRTMonitoringRun3ESD_Alg.cxx.

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

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

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ parseList()

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

Parse a string into a vector.

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

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

Definition at line 341 of file AthMonitorAlgorithm.cxx.

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

◆ radToDegrees()

float TRTMonitoringRun3ESD_Alg::radToDegrees ( float  radValue) const
private

Definition at line 338 of file TRTMonitoringRun3ESD_Alg.cxx.

338  {
339 //----------------------------------------------------------------------------------//
340  float degreeValue = radValue / M_PI * 180;
341 
342  if (degreeValue < 0) degreeValue += 360;
343 
344  return degreeValue;
345 }

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ Straw_Gastype()

GasType TRTMonitoringRun3ESD_Alg::Straw_Gastype ( int  stat) const
inlineprivate

Definition at line 145 of file TRTMonitoringRun3ESD_Alg.h.

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

◆ strawLayerNumber()

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

Definition at line 194 of file TRTMonitoringRun3ESD_Alg.cxx.

194  {
195 //----------------------------------------------------------------------------------//
196  switch (LayerNumber) {
197  case 0:
198  return strawLayerNumber;
199 
200  case 1:
201  return strawLayerNumber + 19;
202 
203  case 2:
204  return strawLayerNumber + 43;
205 
206  default:
207  return strawLayerNumber;
208  }
209 }

◆ 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 212 of file TRTMonitoringRun3ESD_Alg.cxx.

212  {
213 //----------------------------------------------------------------------------------//
214  int addToStrawNumber = 0;
215  int addToStrawNumberNext = 0;
216  int i = 0;
217  const int numberOfStraws[75] = {
218  0,
219  15,
220  16, 16, 16, 16,
221  17, 17, 17, 17, 17,
222  18, 18, 18, 18, 18,
223  19, 19, 19,
224  18,
225  19,
226  20, 20, 20, 20, 20,
227  21, 21, 21, 21, 21,
228  22, 22, 22, 22, 22,
229  23, 23, 23, 23, 23,
230  24, 24,
231  23, 23,
232  24, 24, 24, 24,
233  25, 25, 25, 25, 25,
234  26, 26, 26, 26, 26,
235  27, 27, 27, 27, 27,
236  28, 28, 28, 28, 28,
237  29, 29, 29, 29,
238  28,
239  0
240  };
241 
242  do {
243  i++;
244  addToStrawNumber += numberOfStraws[i - 1];
245  addToStrawNumberNext = addToStrawNumber + numberOfStraws[i];
246  } while (strawLayerNumber(strawlayerNumber, LayerNumber) != i - 1);
247 
248  strawNumber = addToStrawNumberNext - strawNumber - 1;
249 
250  if (strawNumber < 0 || strawNumber > s_Straw_max[0] - 1) {
251  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
252  strawNumber = 0;
253  }
254 
255  return strawNumber;
256 }

◆ 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 260 of file TRTMonitoringRun3ESD_Alg.cxx.

260  {
261 //----------------------------------------------------------------------------------//
262  // Before perfoming map, corrections need to be perfomed.
263  // apply special rotations for endcap mappings
264  // for eca, rotate triplets by 180 for stacks 9-16, and 25-32.
265  static const int TripletOrientation[2][32] = {
266  {
267  1, 1, 1, 1, 1, 1, 1, 1,
268  0, 0, 0, 0, 0, 0, 0, 0,
269  1, 1, 1, 1, 1, 1, 1, 1,
270  0, 0, 0, 0, 0, 0, 0, 0
271  },
272  {
273  1, 1, 1, 1, 1, 1, 1, 1,
274  0, 0, 0, 0, 0, 0, 0, 0,
275  1, 1, 1, 1, 1, 1, 1, 1,
276  0, 0, 0, 0, 0, 0, 0, 0
277  }
278  };
279  int phi1 = -1;
280 
281  if (side == 2) phi1 = phi_stack, side = 1;
282  else if (side == -2) phi1 = 31 - phi_stack, side = 0;
283 
284  if (phi1 > -1) {
285  if (TripletOrientation[side][phi1]) {
286  // Change straw number from 0-23 in straw layer to 0-192
287  if (strawLayerNumber < 8)strawNumber = strawNumber + 24 * strawLayerNumber;
288 
289  if (strawLayerNumber > 7)strawNumber = strawNumber + 24 * (strawLayerNumber - 8);
290 
291  strawNumber = (192 - 1) * TripletOrientation[side][phi1] + strawNumber * (1 - 2 * TripletOrientation[side][phi1]); //actual rotation
292 
293  // Take strawNumber back to 0-23
294  if (strawLayerNumber < 8) strawLayerNumber = int(strawNumber / 24);
295 
296  if (strawLayerNumber > 7) strawLayerNumber = int(strawNumber / 24) + 8;
297 
298  strawNumber = strawNumber % 24;
299  }
300 
301  // Finish rotation
302  // Flip straw in layer.
303 
304  if (side == 0) strawNumber = 23 - strawNumber;
305 
306  // Finish Flipping
307  }
308 
309  // Done with corrections
310  // Start mapping from athena identifiers to TRTViewer maps
311  int strawNumberNew = 0;
312 
313  if (LayerNumber < 6 && strawLayerNumber > 7) {
314  strawNumberNew = strawNumberNew + (384 * LayerNumber);
315  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (strawNumber * 8);
316  } else if (LayerNumber < 6 && strawLayerNumber < 8) {
317  strawNumberNew = strawNumberNew + (384 * LayerNumber);
318  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (strawNumber * 8);
319  } else if (LayerNumber > 5 && strawLayerNumber > 7) {
320  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
321  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (8 * strawNumber);
322  } else if (LayerNumber > 5 && strawLayerNumber < 8) {
323  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
324  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (8 * strawNumber);
325  }
326 
327  strawNumber = strawNumberNew;
328 
329  if (strawNumber < 0 || strawNumber > s_Straw_max[1] - 1) {
330  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
331  strawNumber = 0;
332  }
333 
334  return strawNumber;
335 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ cfg

TRTMonitoringRun3ESD_Alg.cfg = MainServicesCfg(flags)

Definition at line 263 of file TRTMonitoringRun3ESD_Alg.py.

◆ Dynamic

TRTMonitoringRun3ESD_Alg.Dynamic

Definition at line 253 of file TRTMonitoringRun3ESD_Alg.py.

◆ Files

TRTMonitoringRun3ESD_Alg.Files

Definition at line 250 of file TRTMonitoringRun3ESD_Alg.py.

◆ flags

TRTMonitoringRun3ESD_Alg.flags = initConfigFlags()

Definition at line 249 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometryPixel

TRTMonitoringRun3ESD_Alg.GeometryPixel

Definition at line 254 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometrySCT

TRTMonitoringRun3ESD_Alg.GeometrySCT

Definition at line 255 of file TRTMonitoringRun3ESD_Alg.py.

◆ GeometryTRT

TRTMonitoringRun3ESD_Alg.GeometryTRT

Definition at line 256 of file TRTMonitoringRun3ESD_Alg.py.

◆ GlobalTag

TRTMonitoringRun3ESD_Alg.GlobalTag

Definition at line 257 of file TRTMonitoringRun3ESD_Alg.py.

◆ HISTFileName

TRTMonitoringRun3ESD_Alg.HISTFileName

Definition at line 252 of file TRTMonitoringRun3ESD_Alg.py.

◆ isMC

TRTMonitoringRun3ESD_Alg.isMC

Definition at line 251 of file TRTMonitoringRun3ESD_Alg.py.

◆ m_ArgonXenonSplitter

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

Definition at line 101 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 113 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

Gaudi::Property<float> TRTMonitoringRun3ESD_Alg::m_DistToStraw {this, "DistanceToStraw", 0.4f, ""}
private

Definition at line 132 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doChips

Gaudi::Property<bool> TRTMonitoringRun3ESD_Alg::m_doChips {this, "doChips", true, ""}
private

Definition at line 125 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doExpert

Gaudi::Property<bool> TRTMonitoringRun3ESD_Alg::m_doExpert {this, "doExpert", false, ""}
private

Definition at line 127 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doShift

Gaudi::Property<bool> TRTMonitoringRun3ESD_Alg::m_doShift {this, "doShift", true, ""}
private

Definition at line 126 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doStraws

Gaudi::Property<bool> TRTMonitoringRun3ESD_Alg::m_doStraws {this, "doStraws", true, ""}
private

Definition at line 124 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_doTracksMon

Gaudi::Property<bool> TRTMonitoringRun3ESD_Alg::m_doTracksMon {this, "DoTracksMon", true, ""}
private

Definition at line 123 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 {this, "DriftFunctionTool", "TRT_DriftFunctionTool", ""}
private

Definition at line 118 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 {-1}
private

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

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 358 of file AthMonitorAlgorithm.h.

◆ m_idHelper

const AtlasDetectorID* TRTMonitoringRun3ESD_Alg::m_idHelper {}
private

Definition at line 102 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_isCosmics

bool TRTMonitoringRun3ESD_Alg::m_isCosmics {false}
private

Definition at line 133 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 129 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 130 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_mgr

const InDetDD::TRT_DetectorManager* TRTMonitoringRun3ESD_Alg::m_mgr {}
private

Definition at line 121 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_pixel_hits

Gaudi::Property<int> TRTMonitoringRun3ESD_Alg::m_min_pixel_hits {this, "min_pixel_hits", 0, ""}
private

Definition at line 136 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_pT

Gaudi::Property<float> TRTMonitoringRun3ESD_Alg::m_min_pT {this, "min_pT", 0.5 * CLHEP::GeV}
private

Definition at line 141 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_sct_hits

Gaudi::Property<int> TRTMonitoringRun3ESD_Alg::m_min_sct_hits {this, "min_sct_hits", 0, ""}
private

Definition at line 137 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_si_hits

Gaudi::Property<int> TRTMonitoringRun3ESD_Alg::m_min_si_hits {this, "min_si_hits", 1, ""}
private

Definition at line 135 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_min_trt_hits

Gaudi::Property<int> TRTMonitoringRun3ESD_Alg::m_min_trt_hits {this, "min_trt_hits", 10, ""}
private

Definition at line 138 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_minP

Gaudi::Property<float> TRTMonitoringRun3ESD_Alg::m_minP {this, "MinTrackP", 0.0 * CLHEP::GeV}
private

Definition at line 140 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_minTRThits

Gaudi::Property<int> TRTMonitoringRun3ESD_Alg::m_minTRThits {this, "MinTRTHitCut", 10, ""}
private

Definition at line 139 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 120 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_sumTool

ToolHandle<ITRT_StrawStatusSummaryTool> TRTMonitoringRun3ESD_Alg::m_sumTool {this, "InDetTRTStrawStatusSummaryTool", "TRT_StrawStatusSummaryTool",""}
private

Definition at line 105 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 110 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_trackSelTool

ToolHandle<InDet::IInDetTrackSelectionTool> TRTMonitoringRun3ESD_Alg::m_trackSelTool {this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", ""}
private

Definition at line 164 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 117 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 114 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 112 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_TRTCalDbTool

ToolHandle<ITRT_CalDbTool> TRTMonitoringRun3ESD_Alg::m_TRTCalDbTool {this, "ITRT_CalDbTool", "TRT_CalDbTool", ""}
private

Definition at line 107 of file TRTMonitoringRun3ESD_Alg.h.

◆ m_TRTStrawNeighbourSvc

ServiceHandle<ITRT_StrawNeighbourSvc> TRTMonitoringRun3ESD_Alg::m_TRTStrawNeighbourSvc {this, "NeighbourSvc", "TRT_StrawNeighbourSvc", ""}
private

Definition at line 106 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 111 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_iChip_max

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

Definition at line 97 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_iStack_max

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

Definition at line 96 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_moduleNum

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

Definition at line 99 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfBarrelStacks

const int TRTMonitoringRun3ESD_Alg::s_numberOfBarrelStacks = 32
staticprivate

Definition at line 93 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfEndCapStacks

const int TRTMonitoringRun3ESD_Alg::s_numberOfEndCapStacks = 32
staticprivate

Definition at line 94 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_numberOfStacks

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

Definition at line 98 of file TRTMonitoringRun3ESD_Alg.h.

◆ s_Straw_max

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

Definition at line 95 of file TRTMonitoringRun3ESD_Alg.h.

◆ TRTMonitoringRun3Acc

def TRTMonitoringRun3ESD_Alg.TRTMonitoringRun3Acc = TRTMonitoringRun3ESD_AlgConfig(flags)

Definition at line 271 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
TRTMonitoringRun3ESD_Alg::m_minTRThits
Gaudi::Property< int > m_minTRThits
Definition: TRTMonitoringRun3ESD_Alg.h:139
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TRTMonitoringRun3ESD_Alg::m_min_pT
Gaudi::Property< float > m_min_pT
Definition: TRTMonitoringRun3ESD_Alg.h:141
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:494
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:260
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
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
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
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:255
get_generator_info.result
result
Definition: get_generator_info.py:21
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:112
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
Trk::locX
@ locX
Definition: ParamDefs.h:37
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
ComTime::getTime
double getTime() const
Definition: ComTime.h:44
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:67
TRT_LoLumRawData
Definition: TRT_LoLumRawData.h:25
index
Definition: index.py:1
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:100
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
InDetDD::TRT_BaseElement::nStraws
unsigned int nStraws() const
Number of straws in the element.
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
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
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
cosmics
Definition: cosmics.py:1
Trk::locR
@ locR
Definition: ParamDefs.h:44
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:777
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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:338
TRTMonitoringRun3ESD_Alg::m_sumTool
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
Definition: TRTMonitoringRun3ESD_Alg.h:105
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
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
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
TRTMonitoringRun3ESD_Alg::m_doExpert
Gaudi::Property< bool > m_doExpert
Definition: TRTMonitoringRun3ESD_Alg.h:127
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TRTMonitoringRun3ESD_Alg::m_pTRTHelper
const TRT_ID * m_pTRTHelper
Definition: TRTMonitoringRun3ESD_Alg.h:120
TRTMonitoringRun3ESD_Alg::m_doTracksMon
Gaudi::Property< bool > m_doTracksMon
Definition: TRTMonitoringRun3ESD_Alg.h:123
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TRTMonitoringRun3ESD_Alg::m_ArgonXenonSplitter
BooleanProperty m_ArgonXenonSplitter
Definition: TRTMonitoringRun3ESD_Alg.h:101
TRTMonitoringRun3ESD_Alg::m_mgr
const InDetDD::TRT_DetectorManager * m_mgr
Definition: TRTMonitoringRun3ESD_Alg.h:121
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TRTCond::RtRelation
Definition: RtRelation.h:27
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
TRT_ID::straw
int straw(const Identifier &id) const
Definition: TRT_ID.h:896
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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.
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:85
TRTMonitoringRun3ESD_Alg::Straw_Gastype
GasType Straw_Gastype(int stat) const
Definition: TRTMonitoringRun3ESD_Alg.h:145
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:287
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
TRTCond::RtRelation::drifttime
virtual float drifttime(float radius) const =0
drifttime for given radius
IDTPM::nTRTHits
float nTRTHits(const U &p)
Definition: TrackParametersHelper.h:446
Trk::theta
@ theta
Definition: ParamDefs.h:66
TRTMonitoringRun3ESD_Alg::m_doStraws
Gaudi::Property< bool > m_doStraws
Definition: TRTMonitoringRun3ESD_Alg.h:124
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:111
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:53
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
TRTMonitoringRun3ESD_Alg::m_TRTStrawNeighbourSvc
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
Definition: TRTMonitoringRun3ESD_Alg.h:106
SignEnum::LE
@ LE
Definition: SignEnums.h:23
calibdata.exception
exception
Definition: calibdata.py:495
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::GasType
GasType
Definition: TRTMonitoringRun3ESD_Alg.h:143
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:239
TRTMonitoringRun3ESD_Alg::strawNumber
int strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:212
TRTMonitoringRun3ESD_Alg::m_isCosmics
bool m_isCosmics
Definition: TRTMonitoringRun3ESD_Alg.h:133
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
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:233
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:860
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:887
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:878
beamspotman.stat
stat
Definition: beamspotman.py:262
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
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:116
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:102
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TRTMonitoringRun3ESD_Alg::m_minP
Gaudi::Property< float > m_minP
Definition: TRTMonitoringRun3ESD_Alg.h:140
TRTMonitoringRun3ESD_Alg::fillTRTHighThreshold
StatusCode fillTRTHighThreshold(const xAOD::TrackParticleContainer &trackCollection, const xAOD::EventInfo &eventInfo, const EventContext &ctx) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:1206
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
TRTMonitoringRun3ESD_Alg::m_doChips
Gaudi::Property< bool > m_doChips
Definition: TRTMonitoringRun3ESD_Alg.h:125
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:114
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
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
TRT::Hit::ident
@ ident
Definition: HitInfo.h:77
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:869
TRTMonitoringRun3ESD_Alg::m_min_trt_hits
Gaudi::Property< int > m_min_trt_hits
Definition: TRTMonitoringRun3ESD_Alg.h:138
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
TRTMonitoringRun3ESD_Alg::m_DistToStraw
Gaudi::Property< float > m_DistToStraw
Definition: TRTMonitoringRun3ESD_Alg.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:164
DeMoScan.index
string index
Definition: DeMoScan.py:362
TRTMonitoringRun3ESD_Alg::Kr
@ Kr
Definition: TRTMonitoringRun3ESD_Alg.h:143
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
TRTMonitoringRun3ESD_Alg::m_mat_chip_E
std::vector< std::vector< unsigned char > > m_mat_chip_E
Definition: TRTMonitoringRun3ESD_Alg.h:130
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:851
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
lumiFormat.fill
fill
Definition: lumiFormat.py:104
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:118
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
TRTMonitoringRun3ESD_Alg::m_mat_chip_B
std::vector< std::vector< unsigned char > > m_mat_chip_B
Definition: TRTMonitoringRun3ESD_Alg.h:129
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:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
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:107
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
TRTMonitoringRun3ESD_Alg::strawLayerNumber
int strawLayerNumber(int strawLayerNumber, int LayerNumber) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:194
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
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
TRT_ID::straw_layer_hash_max
size_type straw_layer_hash_max() const
Definition: TRT_ID.h:914
AthMonitorAlgorithm::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the duration of the luminosity block (in seconds)
Definition: AthMonitorAlgorithm.cxx:324
TRTMonitoringRun3ESD_Alg::Xe
@ Xe
Definition: TRTMonitoringRun3ESD_Alg.h:143
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:328
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
TRTMonitoringRun3ESD_Alg::m_doShift
Gaudi::Property< bool > m_doShift
Definition: TRTMonitoringRun3ESD_Alg.h:126
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TRTMonitoringRun3ESD_Alg::Ar
@ Ar
Definition: TRTMonitoringRun3ESD_Alg.h:143
trailingEdge
int trailingEdge(unsigned int m_word)
Definition: driftCircle.h:64
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
InDet::TRT_DriftCircle::firstBinHigh
bool firstBinHigh() const
returns true if the first bin is high
xAOD::TrigDecision_v1
Interface to the raw trigger decision information of the event.
Definition: TrigDecision_v1.h:44
TRTMonitoringRun3ESD_Alg::fillTRTTracks
StatusCode fillTRTTracks(const EventContext &ctx, const xAOD::TrackParticleContainer &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject, const xAOD::EventInfo &eventInfo) const
Definition: TRTMonitoringRun3ESD_Alg.cxx:383
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:95
TRTMonitoringRun3ESD_Alg::m_TrackSummaryTool
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool
Definition: TRTMonitoringRun3ESD_Alg.h:117
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:52
TRTMonitoringRun3ESD_Alg::m_EventBurstCut
int m_EventBurstCut
Definition: TRTMonitoringRun3ESD_Alg.h:163
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:575
TRTMonitoringRun3ESD_Alg::m_comTimeObjectKey
SG::ReadHandleKey< ComTime > m_comTimeObjectKey
Definition: TRTMonitoringRun3ESD_Alg.h:113
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
ServiceHandle< ICondSvc >
driftTimeBin
int driftTimeBin(unsigned int m_word)
Definition: driftCircle.h:50
collisions
Definition: collisions.py:1
Identifier
Definition: IdentifierFieldParser.cxx:14
TRTMonitoringRun3ESD_Alg::m_trackCollectionKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackCollectionKey
Definition: TRTMonitoringRun3ESD_Alg.h:110
Generated on Mon Sep 29 2025 21:56:55 for ATLAS Offline Software by   doxygen 1.8.18