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

#include <IDAlignMonResidualsAlg.h>

Inheritance diagram for IDAlignMonResidualsAlg:
Collaboration diagram for IDAlignMonResidualsAlg:

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

 IDAlignMonResidualsAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~IDAlignMonResidualsAlg ()
 
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
 

Protected Member Functions

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

Protected Attributes

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

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void fillTRTHistograms (int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool isTubeHit, float trketa, float qpT) const
 
void fillTRTBarrelHistograms (int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool LRcorrect, bool isTubeHit, float trketa) const
 
void fillTRTEndcapHistograms (int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool LRcorrect, bool isTubeHit, float trketa, float qpT) const
 
StatusCode setupTools ()
 
StatusCode getSiResiduals (const Trk::Track *, const Trk::TrackStateOnSurface *, bool, double *) const
 
std::unique_ptr< Trk::TrackParameters > getUnbiasedTrackParameters (const Trk::Track *, const Trk::TrackStateOnSurface *) const
 
bool trackRequiresRefit (const Trk::Track *) 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

const AtlasDetectorID * m_idHelper {}
 
const InDetDD::PixelDetectorManager * m_PIX_Mgr {}
 
const InDetDD::SCT_DetectorManager * m_SCT_Mgr {}
 
const PixelID * m_pixelID {}
 
const SCT_ID * m_sctID {}
 
const TRT_ID * m_trtID {}
 
SG::ReadHandleKey< TrackCollection > m_tracksKey {this,"TrackName2", "CombinedInDetTracks", "track data key"}
 
SG::ReadHandleKey< TrackCollection > m_tracksName {this,"TrackName","CombinedInDetTracks", "track data key"}
 
ToolHandle< ITRT_CalDbTool > m_trtcaldbTool
 
ToolHandle< Trk::IUpdator > m_iUpdator
 
ToolHandle< Trk::IPropagator > m_propagator
 
ToolHandle< Trk::IResidualPullCalculator > m_residualPullCalculator
 The residual and pull calculator tool handle. More...
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelection
 
ToolHandle< IInDetAlignHitQualSelTool > m_hitQualityTool
 
std::string m_Pixel_Manager
 
std::string m_SCT_Manager
 
bool m_extendedPlots {}
 
bool m_doHitQuality {false}
 
int m_checkrate {}
 
bool m_doPulls {}
 
bool m_applyTrkSel {}
 
std::vector< int > m_pixResidualX
 
std::vector< int > m_pixResidualX_2DProf
 
std::vector< int > m_pixResidualY
 
std::vector< int > m_pixResidualY_2DProf
 
std::vector< int > m_pixPullX
 
std::vector< int > m_pixPullY
 
std::vector< int > m_pixResidualXvsEta
 
std::vector< int > m_pixResidualYvsEta
 
std::vector< int > m_pixResidualXvsPhi
 
std::vector< int > m_pixResidualYvsPhi
 
std::vector< int > m_pixECAResidualX
 
std::vector< int > m_pixECAResidualY
 
std::vector< int > m_pixECResidualX_2DProf
 
std::vector< int > m_pixECResidualY_2DProf
 
std::vector< int > m_pixECCResidualX
 
std::vector< int > m_pixECCResidualY
 
std::vector< int > m_sctResidualX
 
std::vector< int > m_sctResidualX_2DProf
 
std::vector< int > m_sct_s0_ResidualX_2DProf
 
std::vector< int > m_sct_s1_ResidualX_2DProf
 
std::vector< int > m_sctECAResidualX_2DProf
 
std::vector< int > m_sctECA_s0_ResidualX_2DProf
 
std::vector< int > m_sctECA_s1_ResidualX_2DProf
 
std::vector< int > m_sctECCResidualX_2DProf
 
std::vector< int > m_sctECC_s0_ResidualX_2DProf
 
std::vector< int > m_sctECC_s1_ResidualX_2DProf
 
std::vector< int > m_sctPullX
 
std::vector< int > m_sctResidualXvsEta
 
std::vector< int > m_sctResidualXvsPhi
 
std::vector< int > m_trtBPredictedR
 
std::vector< int > m_trtBMeasuredR
 
std::vector< int > m_trtBResidualR
 
std::vector< int > m_trtBPullR
 
std::vector< int > m_trtBResidualRNoTube
 
std::vector< int > m_trtBPullRNoTube
 
std::vector< int > m_trtBLR
 
std::vector< std::vector< int > > m_trtBResVsEta
 
std::vector< std::vector< int > > m_trtBResVsPhiSec
 
std::vector< std::vector< int > > m_trtBLRVsPhiSec
 
std::vector< int > m_trtECPredictedR
 
std::vector< int > m_trtECMeasuredR
 
std::vector< int > m_trtECResidualR
 
std::vector< int > m_trtECPullR
 
std::vector< int > m_trtECResidualRNoTube
 
std::vector< int > m_trtECPullRNoTube
 
std::vector< int > m_trtECLR
 
std::vector< int > m_trtECResVsEta
 
std::vector< int > m_trtECResVsPhiSec
 
std::vector< int > m_trtECLRVsPhiSec
 
std::vector< int > m_trtECResVsPt_2DProf
 
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 m_nSiBlayers {4}
 
static const int m_nPixEClayers {3}
 
static const int m_nSCTEClayers {9}
 
static const int m_nTRTBlayers {3}
 
static const int m_nTRTEClayers {2}
 

Detailed Description

Definition at line 47 of file IDAlignMonResidualsAlg.h.

Member Typedef Documentation

◆ MonVarVec_t

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

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

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

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

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

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

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

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

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

Constructor & Destructor Documentation

◆ IDAlignMonResidualsAlg()

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

Definition at line 47 of file IDAlignMonResidualsAlg.cxx.

47  :
48  AthMonitorAlgorithm(name, pSvcLocator),
49  m_trtcaldbTool("TRT_CalDbTool", this),
50  m_iUpdator ("Trk::KalmanUpdator"),
51  m_propagator ("Trk::RungeKuttaPropagator"),
52  m_residualPullCalculator( "Trk::ResidualPullCalculator/ResidualPullCalculator"),
53  m_trackSelection( "InDet::InDetTrackSelectionTool/TrackSelectionTool", this),
54  m_hitQualityTool(""){
55  declareProperty("CheckRate" , m_checkrate=1000);
56  declareProperty("ITRT_CalDbTool" , m_trtcaldbTool);
57  declareProperty("iUpdator" , m_iUpdator);
58  declareProperty("propagator" , m_propagator);
59  declareProperty("TrackSelectionTool" , m_trackSelection);
60  declareProperty("ResidualPullCalculatorTool", m_residualPullCalculator);
61  declareProperty("HitQualityTool" , m_hitQualityTool);
62  declareProperty("Pixel_Manager" , m_Pixel_Manager);
63  declareProperty("SCT_Manager" , m_SCT_Manager);
64  declareProperty("ApplyTrackSelection" , m_applyTrkSel = true);
65 }

◆ ~IDAlignMonResidualsAlg()

IDAlignMonResidualsAlg::~IDAlignMonResidualsAlg ( )
virtual

Definition at line 69 of file IDAlignMonResidualsAlg.cxx.

69 {}

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 }

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

filling TRT histograms

Implements AthMonitorAlgorithm.

Definition at line 147 of file IDAlignMonResidualsAlg.cxx.

148 {
149  using namespace Monitored;
150 
151  ATH_MSG_DEBUG("fillHistograms() -- dealing with track collection: " << m_tracksName.key());
152 
153  // For histogram naming
154  auto residualGroup = getGroup("Residuals");
155 
156  //counters
157  bool hasBeenCalledThisEvent=false;
158  float mu = 0.;
159  int nTracks = 0;
160 
161  mu = lbAverageInteractionsPerCrossing(ctx);
162  auto mu_m = Monitored::Scalar<float>("mu_m", 0.0);
163  if (!hasBeenCalledThisEvent){
164  mu = lbAverageInteractionsPerCrossing(ctx);
165  mu_m = mu;
166  hasBeenCalledThisEvent=true;
167  }
168  else
169  mu = -999;
170 
171  if (m_extendedPlots){
172  fill("residualGroup", mu_m);
173  }
174 
175  // Retrieving tracks
176  auto tracks = SG::makeHandle(m_tracksName, ctx);
177  if (not tracks.isValid()) {
178  ATH_MSG_ERROR(m_tracksName.key() << " could not be retrieved");
179  return StatusCode::RECOVERABLE;
180  }
181 
182  //looping over tracks
183  ATH_MSG_DEBUG ("IDAlignMonResidual: Start loop on tracks. Number of tracks " << tracks->size());
184  for (const Trk::Track* trksItr: *tracks) {
185 
186  // Found track?!
187  if ( !trksItr || trksItr->perigeeParameters() == nullptr ) {
188  ATH_MSG_DEBUG( "InDetAlignmentMonitoringRun3: NULL track pointer in collection" );
189  continue;
190  }
191 
192  // Select tracks
193  if ( m_applyTrkSel and !m_trackSelection->accept(*trksItr) )
194  continue;
195 
196  nTracks++;
197 
198  //check that all TSOS of track have track parameters defined (required to compute residuals/pulls)
199  if(trackRequiresRefit(trksItr)){
200  ATH_MSG_DEBUG("Not all TSOS contain track parameters - will be missing residuals/pulls");
201  }
202  else
203  ATH_MSG_DEBUG("All TSOS of track " << nTracks << "/" << tracks->size() << " contain track parameters - Good!");
204 
205  //trackStateOnSurfaces is a vector of Trk::TrackStateOnSurface objects which contain information
206  //on track at each (inner)detector surface it crosses eg hit used to fit track
207  ATH_MSG_DEBUG( "** IDAlignMonResiduals::fillHistograms() ** track: " << nTracks << " has " << trksItr->trackStateOnSurfaces()->size() << " TrkSurfaces");
208 
209  int nHits = 0; //counts number of tsos from which we can define residual/pull
210  int nTSOS = -1; //counts all TSOS on the track
211 
212  const Trk::Perigee* measPer = trksItr->perigeeParameters();
213  float charge = 1; if (measPer->charge() < 0) charge = -1;
214  float trkpt = -999;
215  trkpt = measPer->pT()/1000.;
216  float qpT = charge*trkpt;
217 
218  //looping over the hits of the track
219  for (const Trk::TrackStateOnSurface* tsos : *trksItr->trackStateOnSurfaces()) {
220 
221  ++nTSOS;
222 
223  if (tsos == nullptr) {
224  ATH_MSG_DEBUG(" TSOS (hit) = " << nTSOS << " is NULL ");
225  continue;
226  }
227 
228  //skipping outliers
229  ATH_MSG_DEBUG(" --> testing if hit " << nTSOS << "/" << trksItr->trackStateOnSurfaces()->size() << " is a track measurement");
230  if(!tsos->type(Trk::TrackStateOnSurface::Measurement)) {
231  ATH_MSG_DEBUG("Skipping TSOS " << nTSOS << " because it is an outlier (or the first TSOS on the track)");
232  continue;
233  }
234 
235  const Trk::MeasurementBase* mesh =tsos->measurementOnTrack();
236  ATH_MSG_DEBUG(" --> Defined hit measurementOnTrack() for hit: " << nTSOS << "/" << trksItr->trackStateOnSurfaces()->size() << " of track " << nTracks);
237 
238  //Trk::RIO_OnTrack object contains information on the hit used to fit the track at this surface
239  const Trk::RIO_OnTrack* hit = dynamic_cast <const Trk::RIO_OnTrack*>(mesh);
240  ATH_MSG_DEBUG(" --> Going to retrive the Trk::RIO_OnTrack for hit " << nTSOS);
241  if (hit== nullptr) {
242  //for some reason the first tsos has no associated hit - maybe because this contains the defining parameters?
243  if (nHits >0) ATH_MSG_DEBUG("No hit associated with TSOS " << nTSOS);
244  continue;
245  }
246 
247  ATH_MSG_DEBUG(" --> Going to retrive the track parameters of this TSOS: " << nTSOS);
248  const Trk::TrackParameters* trackParameter = tsos->trackParameters();
249  if(trackParameter==nullptr) {
250  //if no TrackParameters for TSOS we cannot define residuals
251  ATH_MSG_DEBUG(" Skipping TSOS " << nTSOS << " because it does not have TrackParameters");
252  continue;
253  }
254 
255  const AmgSymMatrix(5)* TrackParCovariance = trackParameter ? trackParameter->covariance() : nullptr;
256 
257  if(TrackParCovariance==nullptr) {
258  //if no MeasuredTrackParameters the hit will not have associated convariance error matrix and will not
259  //be able to define a pull or unbiased residual (errors needed for propagation)
260  ATH_MSG_DEBUG("Skipping TSOS " << nTSOS << " because does not have MeasuredTrackParameters");
261  continue;
262  }
263 
264  ATH_MSG_DEBUG(
265  " --> going to define residuals and everything of TSOS #" << nTSOS << "/" <<
266  trksItr->trackStateOnSurfaces()->size());
267 
268  float residualX = 9999.0;
269  float residualY = 9999.0;
270  float pullX = 9999.0;
271  float pullY = 9999.0;
272  float biasedResidualX = 9999.0;
273  float biasedResidualY = 9999.0;
274  int detType = 99;
275  int barrelEC = 99;
276  int layerDisk = 99;
277  int barrel_ec = 99;
278  int layer_or_wheel = 99;
279  int sctSide = 99;
280  int modEta = 9999;
281  int modPhi = 9999;
282 
283  const Identifier & hitId = hit->identify();
284  if (m_idHelper->is_trt(hitId)) detType = 2;
285  else if (m_idHelper->is_sct(hitId)) detType = 1;
286  else if (m_idHelper->is_pixel(hitId)) detType = 0;
287  else detType = 99;
288 
289  //hits with detType = 0 are no Inner Detector hits -> skip
290  if ( detType == 99) {
291  ATH_MSG_DEBUG(" --> Hit " << nTSOS << " with detector type " << detType << " is not an Inner Detector hit -> skip this hit");
292  continue;
293  }
294 
295  //TRT hits: detType = 2
296  if (detType == 2) {
297  ATH_MSG_DEBUG("** IDAlignMonResidualsAlg::fillHistograms() ** Hit is from the TRT, finding residuals... ");
298  bool isTubeHit = (mesh->localCovariance()(Trk::locX, Trk::locX) > 1.0);
299  const Trk::TrackParameters* trackParameter = tsos->trackParameters();
300  //finding residuals
301  if (!trackParameter) {
302  ATH_MSG_WARNING("No TrackParameters associated with TRT TrkSurface " << nTSOS);
303  continue;
304  }
305  float hitR = hit->localParameters()[Trk::driftRadius];
306  float trketa = tsos->trackParameters()->eta();
307  float pullR = -9.9;
308 
309  const Identifier& id = m_trtID->layer_id(hitId);
310  barrel_ec = m_trtID->barrel_ec(id);
311  layer_or_wheel = m_trtID->layer_or_wheel(id);
312  int phi_module = m_trtID->phi_module(id);
313 
314 
315  ATH_MSG_DEBUG("Found Trk::TrackParameters for hit " << nTSOS << " --> TRT hit (detType= " << detType << ")" );
316 
317  //getting unbiased track parameters by removing the hit from the track and refitting
318  //std::unique_ptr <Trk::TrackParameters> trackParameterUnbiased;
319  auto trackParameterUnbiased = getUnbiasedTrackParameters(trksItr, tsos);
320 
321  if (!trackParameterUnbiased) {//updator can fail
322  ATH_MSG_WARNING("Cannot define unbiased parameters for hit, skipping it.");
323  continue;
324  }
325  ATH_MSG_DEBUG(" --> TRT UnBiased TrackParameters of hit " << nTSOS << " FOUND");
326 
327  float predictR = trackParameterUnbiased->parameters()[Trk::locR];
328 
329  const Trk::MeasurementBase* mesh = tsos->measurementOnTrack();
330  std::optional<Trk::ResidualPull> residualPull =
331  m_residualPullCalculator->residualPull(mesh,
332  trackParameterUnbiased.get(),
333  Trk::ResidualPull::Unbiased);
334 
335  if (residualPull) {
336  pullR = residualPull->pull()[Trk::locR];
337  }
338  else {
339  ATH_MSG_DEBUG(" no covariance of the track parameters given, can not calculate pull!");
340  }
341 
342  //delete trackParameterUnbiased;
343 
344  float residualR = hitR - predictR;
345 
346  const InDet::TRT_DriftCircleOnTrack* trtCircle =
347  dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(tsos->measurementOnTrack());
348 
349  if (trtCircle != nullptr) {
350  ATH_MSG_DEBUG(" fillHistograms() ** filling TRT histograms for hit/tsos #" << nTSOS
351  << " Barrel/EndCap: " << barrel_ec
352  << " layer/wheel: " << layer_or_wheel
353  << " phi: " << phi_module
354  << " Residual: " << residualR);
356  fillTRTHistograms(barrel_ec
357  , layer_or_wheel
358  , phi_module
359  , predictR
360  , hitR
361  , residualR
362  , pullR
363  , isTubeHit
364  , trketa
365  , qpT);
366  }
367  }//end-TRT hit
368 
369  else { //have identified a PIXEL or SCT hit
370  if(m_doHitQuality) {
371  ATH_MSG_DEBUG("applying hit quality cuts to Silicon hit...");
372  hit = m_hitQualityTool->getGoodHit(tsos);
373  if(hit==nullptr) {
374  ATH_MSG_DEBUG("hit failed quality cuts and is rejected.");
375  continue;
376  }
377  ATH_MSG_DEBUG("hit passed quality cuts");
378  }
379  else ATH_MSG_DEBUG("hit quality cuts NOT APPLIED to Silicon hit.");
380 
381  //determining Si module physical position (can modify residual calculation eg. SCT endcaps)
382  if (detType==0){//pixel
383  const Identifier& id = m_pixelID->wafer_id(hitId);
384  barrelEC = m_pixelID -> barrel_ec(id);
385  layerDisk = m_pixelID -> layer_disk(id);
386  modEta = m_pixelID->eta_module(id); //For the endcaps these are the rings
387  modPhi = m_pixelID->phi_module(id);
388  }
389  else {//sct. Since detType == 0 or detType == 1 here
390  const Identifier& id = m_sctID->wafer_id(hitId);
391  barrelEC = m_sctID->barrel_ec(id);
392  layerDisk = m_sctID->layer_disk(id);
393  modEta = m_sctID->eta_module(id);
394  modPhi = m_sctID->phi_module(id);
395  sctSide = m_sctID->side(id);
396  }
397 
398  //finding residuals
399  if(trackParameter){//should always have TrackParameters since we now skip tracks with no MeasuredTrackParameters
400 
401  ATH_MSG_DEBUG("Found Trk::TrackParameters " << trackParameter);
402 
403  double unbiasedResXY[4] = {9999.0,9999.0,9999.0,9999.0};
404  double biasedResXY[4] = {9999.0,9999.0,9999.0,9999.0};
405 
406  //finding unbiased single residuals
407  StatusCode sc;
408  sc = getSiResiduals(trksItr,tsos,true,unbiasedResXY);
409  if (sc.isFailure()) {
410  ATH_MSG_DEBUG("Problem in determining unbiased residuals! Hit is skipped.");
411  auto detType_m = Monitored::Scalar<int>( "m_detType", detType);
412  fill(residualGroup, detType_m);
413  continue;
414  }
415  else
416  ATH_MSG_DEBUG("unbiased residuals found ok");
417 
418  residualX = (float)unbiasedResXY[0];
419  residualY = (float)unbiasedResXY[1];
420  pullX = (float)unbiasedResXY[2];
421  pullY = (float)unbiasedResXY[3];
422 
423  //finding biased single residuals (for interest)
424  sc = getSiResiduals(trksItr,tsos,false,biasedResXY);
425  if (sc.isFailure()) {
426  ATH_MSG_DEBUG("Problem in determining biased residuals! Hit is skipped.");
427  continue;
428  }
429  else
430  ATH_MSG_DEBUG("biased residuals found ok");
431 
432  biasedResidualX = (float)biasedResXY[0];
433  biasedResidualY = (float)biasedResXY[1];
434 
435  }
436  else {
437  ATH_MSG_DEBUG("No TrackParameters associated with Si TrkSurface "<< nTSOS << " - Hit is probably an outlier");
438  }
439  }//end-Pixel and SCT hits
440 
441  //--------------------------------------------
442  //
443  // Filling Residual Histograms for Pixel and SCT
444  //
445  //--------------------------------------------
446 
447  //Common for Pixel and SCT and other variables used
448  auto si_residualx_m = Monitored::Scalar<float>( "m_si_residualx", 0.0);
449  auto si_b_residualx_m = Monitored::Scalar<float>( "m_si_b_residualx", 0.0);
450  auto si_barrel_resX_m = Monitored::Scalar<float>( "m_si_barrel_resX", 0.0);
451  auto si_barrel_resY_m = Monitored::Scalar<float>( "m_si_barrel_resY", 0.0);
452  auto si_barrel_pullX_m = Monitored::Scalar<float>( "m_si_barrel_pullX", 0.0);
453  auto si_barrel_pullY_m = Monitored::Scalar<float>( "m_si_barrel_pullY", 0.0);
454  auto si_eca_resX_m = Monitored::Scalar<float>( "m_si_eca_resX", 0.0);
455  auto si_eca_resY_m = Monitored::Scalar<float>( "m_si_eca_resY", 0.0);
456  auto si_eca_pullX_m = Monitored::Scalar<float>( "m_si_eca_pullX", 0.0);
457  auto si_eca_pullY_m = Monitored::Scalar<float>( "m_si_eca_pullY", 0.0);
458  auto si_ecc_resX_m = Monitored::Scalar<float>( "m_si_ecc_resX", 0.0);
459  auto si_ecc_resY_m = Monitored::Scalar<float>( "m_si_ecc_resY", 0.0);
460  auto si_ecc_pullX_m = Monitored::Scalar<float>( "m_si_ecc_pullX", 0.0);
461  auto si_ecc_pullY_m = Monitored::Scalar<float>( "m_si_ecc_pullY", 0.0);
462  auto residualX_m = Monitored::Scalar<float>( "m_residualX", residualX);
463  auto residualY_m = Monitored::Scalar<float>( "m_residualY", residualY);
464  auto modEta_m = Monitored::Scalar<int>( "m_modEta", modEta );
465  auto modPhi_m = Monitored::Scalar<int>( "m_modPhi", modPhi );
466  int lb = GetEventInfo(ctx)->lumiBlock();
467  auto lb_m = Monitored::Scalar<int>( "m_lb", lb );
468  auto layerDisk_m = Monitored::Scalar<float>("m_layerDisk", layerDisk);
469  auto layerDisk_si_m = Monitored::Scalar<float>("m_layerDisk_si", 0);
470 
471  if (detType==0) {//filling pixel histograms
472  ATH_MSG_DEBUG(" This is a PIXEL hit " << hitId << " - filling histograms");
473 
474  si_residualx_m = residualX;
475  fill(residualGroup, si_residualx_m);
476 
477  if(barrelEC==0){//filling pixel barrel histograms
478  int ModEtaShift[4] = {0, 30, 53, 76};
479  int ModPhiShift[4] = {0, 24, 56, 104};
480 
481  //common Si plots
482  si_b_residualx_m = residualX;
483  fill(residualGroup, si_b_residualx_m);
484 
485  layerDisk_si_m = layerDisk;
486  si_barrel_resX_m = residualX;
487  si_barrel_resY_m = residualY;
488  si_barrel_pullX_m = pullX;
489  si_barrel_pullY_m = pullY;
490  fill(residualGroup, layerDisk_si_m, si_barrel_resX_m, si_barrel_resY_m, si_barrel_pullX_m, si_barrel_pullY_m);
491 
492  //Pixel Residual plots
493  auto pix_b_residualx_m = Monitored::Scalar<float>( "m_pix_b_residualx", residualX);
494  auto pix_b_biased_residualx_m = Monitored::Scalar<float>( "m_pix_b_biased_residualx", biasedResidualX);
495  auto pix_b_residualy_m = Monitored::Scalar<float>( "m_pix_b_residualy", residualY);
496  auto pix_b_biased_residualy_m = Monitored::Scalar<float>( "m_pix_b_biased_residualy", biasedResidualY);
497  fill(residualGroup, pix_b_residualx_m, pix_b_biased_residualx_m, pix_b_residualy_m, pix_b_biased_residualy_m);
498  auto pix_b_residualsx_m = Monitored::Scalar<float>("m_pix_residualsx", residualX);
499  fill(m_tools[m_pixResidualX[layerDisk]], pix_b_residualsx_m);
500  fill(m_tools[m_pixResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, pix_b_residualsx_m);
501  auto pix_b_residualsy_m = Monitored::Scalar<float>("m_pix_residualsy", residualY);
502  fill(m_tools[m_pixResidualY[layerDisk]], pix_b_residualsy_m);
503  fill(m_tools[m_pixResidualY_2DProf[layerDisk]], modEta_m, modPhi_m, pix_b_residualsy_m);
504  auto pix_b_pullsx_m = Monitored::Scalar<float>("m_pix_pullsx", pullX);
505  fill(m_tools[m_pixPullX[layerDisk]], pix_b_pullsx_m);
506  auto pix_b_pullsy_m = Monitored::Scalar<float>("m_pix_pullsy", pullY);
507  fill(m_tools[m_pixPullY[layerDisk]], pix_b_pullsy_m);
508 
509  //Residuals vs Eta and Phi
510  fill(m_tools[m_pixResidualXvsEta[layerDisk]], modEta_m, residualX_m );
511  fill(m_tools[m_pixResidualYvsEta[layerDisk]], modEta_m, residualY_m );
512  fill(m_tools[m_pixResidualXvsPhi[layerDisk]], modPhi_m, residualX_m );
513  fill(m_tools[m_pixResidualYvsPhi[layerDisk]], modPhi_m, residualY_m );
514 
515  auto residualX_barrel_m = Monitored::Scalar<float>( "m_residualX_barrel", residualX);
516  auto residualY_barrel_m = Monitored::Scalar<float>( "m_residualY_barrel", residualY);
517  auto modPhiShift_barrel_m = Monitored::Scalar<int>( "m_modPhiShift_barrel", modPhi + ModPhiShift[layerDisk] );
518  auto modEtaShift_barrel_m = Monitored::Scalar<int>( "m_modEtaShift_barrel", modEta + ModEtaShift[layerDisk] );
519  fill(residualGroup, modPhiShift_barrel_m, residualX_barrel_m, residualY_barrel_m);
520  fill(residualGroup, modEtaShift_barrel_m, residualX_barrel_m, residualY_barrel_m);
521  }
522  else if(barrelEC==2){//three Pixel endcap disks from 0-2
523  int ModPhiShift[3] = {0, 55, 110};
524 
525  //Common Si plots
526  layerDisk_si_m = layerDisk;
527  si_eca_resX_m = residualX;
528  si_eca_resY_m = residualY;
529  si_eca_pullX_m = pullX;
530  si_eca_pullY_m = pullY;
531  fill(residualGroup, layerDisk_si_m, si_eca_resX_m, si_eca_resY_m, si_eca_pullX_m, si_eca_pullY_m);
532 
533  //Pixel Residual plots
534  auto pix_eca_residualx_m = Monitored::Scalar<float>( "m_pix_eca_residualx", residualX);
535  auto pix_ec_residualx_m = Monitored::Scalar<float>( "m_pix_ec_residualx", residualX);
536  fill(m_tools[m_pixECResidualX_2DProf[0]], layerDisk_m , modPhi_m, pix_ec_residualx_m);
537  auto pix_eca_residualy_m = Monitored::Scalar<float>( "m_pix_eca_residualy", residualY);
538  auto pix_ec_residualy_m = Monitored::Scalar<float>( "m_pix_ec_residualy", residualY);
539  fill(residualGroup, pix_eca_residualx_m, pix_eca_residualy_m);
540  fill(m_tools[m_pixECResidualY_2DProf[0]], layerDisk_m, modPhi_m, pix_ec_residualy_m);
541  auto pix_eca_pullx_m = Monitored::Scalar<float>( "m_pix_eca_pullx", pullX);
542  auto pix_eca_pully_m = Monitored::Scalar<float>( "m_pix_eca_pully", pullY);
543  fill(residualGroup, pix_eca_pullx_m, pix_eca_pully_m);
544 
545  //Residuals vs Eta and Phi
546  auto residualX_eca_m = Monitored::Scalar<float>( "m_residualX_eca", residualX );
547  auto residualY_eca_m = Monitored::Scalar<float>( "m_residualY_eca", residualY );
548  auto modPhiShift_eca_m = Monitored::Scalar<int>( "m_modPhiShift_eca", modPhi + ModPhiShift[layerDisk]);
549  fill(m_tools[m_pixECAResidualX[layerDisk]], modPhi_m, pix_eca_residualx_m);
550  fill(m_tools[m_pixECAResidualY[layerDisk]], modPhi_m, pix_eca_residualy_m);
551  fill(residualGroup, modPhiShift_eca_m, residualX_eca_m, residualY_eca_m);
552  }
553  else if(barrelEC==-2){
554  int ModPhiShift[3] = {0, 55, 110};
555 
556  //Common Si plots
557  layerDisk_si_m = layerDisk;
558  si_ecc_resX_m = residualX;
559  si_ecc_resY_m = residualY;
560  si_ecc_pullX_m = pullX;
561  si_ecc_pullY_m = pullY;
562  fill(residualGroup, layerDisk_si_m, si_ecc_resX_m, si_ecc_resY_m, si_ecc_pullX_m, si_ecc_pullY_m);
563 
564  //Pixel Residual plots
565  auto pix_ecc_residualx_m = Monitored::Scalar<float>( "m_pix_ecc_residualx", residualX);
566  auto pix_ec_residualx_m = Monitored::Scalar<float>( "m_pix_ec_residualx", residualX);
567  fill(m_tools[m_pixECResidualX_2DProf[1]], layerDisk_m , modPhi_m, pix_ec_residualx_m);
568  auto pix_ecc_residualy_m = Monitored::Scalar<float>( "m_pix_ecc_residualy", residualY);
569  auto pix_ec_residualy_m = Monitored::Scalar<float>( "m_pix_ec_residualy", residualY);
570  fill(residualGroup, pix_ecc_residualx_m, pix_ecc_residualy_m);
571  fill(m_tools[m_pixECResidualY_2DProf[1]], layerDisk_m, modPhi_m, pix_ec_residualy_m);
572  auto pix_ecc_pullx_m = Monitored::Scalar<float>( "m_pix_ecc_pullx", pullX);
573  auto pix_ecc_pully_m = Monitored::Scalar<float>( "m_pix_ecc_pully", pullY);
574  fill(residualGroup, pix_ecc_pullx_m, pix_ecc_pully_m);
575 
576  //Residuals vs Eta and Phi
577  auto residualX_ecc_m = Monitored::Scalar<float>( "m_residualX_ecc", residualX);
578  auto residualY_ecc_m = Monitored::Scalar<float>( "m_residualY_ecc", residualY);
579  auto modPhiShift_ecc_m = Monitored::Scalar<int>( "m_modPhiShift_ecc", modPhi + ModPhiShift[layerDisk] );
580  fill(m_tools[m_pixECCResidualX[layerDisk]], modPhi_m, pix_ecc_residualx_m);
581  fill(m_tools[m_pixECCResidualY[layerDisk]], modPhi_m, pix_ecc_residualy_m);
582  fill(residualGroup, modPhiShift_ecc_m, residualX_ecc_m, residualY_ecc_m);
583  }
584  }
585  else if (detType==1) {//filling SCT histograms
586  si_residualx_m = residualX;
587  fill(residualGroup, si_residualx_m);
588 
589  ATH_MSG_DEBUG(" This is a SCT hit " << hitId << " - filling histograms");
590 
591  if(barrelEC==0){//filling SCT barrel histograms
592  int ModPhiShift[4] = {0, 42, 92, 150};
593  int ModEtaShift[4] = {0, 23, 46, 69};
594 
595  //common Si plots
596  si_b_residualx_m = residualX;
597  fill(residualGroup, si_b_residualx_m);
598 
599  layerDisk_si_m = 4 + 2 * layerDisk + sctSide;
600  si_barrel_resX_m = residualX;
601  si_barrel_pullX_m = pullX;
602  fill(residualGroup, layerDisk_si_m, si_barrel_resX_m, si_barrel_pullX_m);
603 
604  //SCT Residual plots
605  auto sct_b_residualx_m = Monitored::Scalar<float>( "m_sct_b_residualx", residualX);
606  fill(residualGroup, sct_b_residualx_m);
607  auto sct_b_biased_residualx_m = Monitored::Scalar<float>( "m_sct_b_biased_residualx", biasedResidualX);
608  auto sct_b_residualsx_m = Monitored::Scalar<float>("m_sct_residualsx", residualX);
609  fill(m_tools[m_sctResidualX[layerDisk]], sct_b_residualsx_m);
610  fill(m_tools[m_sctResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_b_residualsx_m);
611  auto sct_b_pullsx_m = Monitored::Scalar<float>("m_sct_pullsx", pullX);
612  fill(m_tools[m_sctPullX[layerDisk]], sct_b_pullsx_m);
613  if (sctSide == 0) {
614  fill(m_tools[m_sct_s0_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_b_residualsx_m);
615  } else {
616  fill(m_tools[m_sct_s1_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_b_residualsx_m);
617  }
618 
619  //Residuals vs Eta and Phi
620  fill(m_tools[m_sctResidualXvsEta[layerDisk]], modEta_m, residualX_m);
621  fill(m_tools[m_sctResidualXvsPhi[layerDisk]], modPhi_m, residualX_m);
622 
623  auto residualX_sct_barrel_m = Monitored::Scalar<float>( "m_residualX_sct_barrel", residualX);
624  auto modPhiShift_sct_barrel_m = Monitored::Scalar<int>( "m_modPhiShift_sct_barrel", modPhi + ModPhiShift[layerDisk] );
625  auto modEtaShift_sct_barrel_m = Monitored::Scalar<int>( "m_modEtaShift_sct_barrel", modEta + ModEtaShift[layerDisk] );
626  fill(residualGroup, modPhiShift_sct_barrel_m, modEtaShift_sct_barrel_m, residualX_sct_barrel_m);
627  } // end SCT barrel
628 
629  else if(barrelEC==2){//nine SCT endcap disks from 0-8
630  int Nmods = 52;
631  int gap_sct = 10;
632 
633  //Common Si plots
634  layerDisk_si_m = 3 + 2 * layerDisk + sctSide;
635  si_eca_resX_m = residualX;
636  si_eca_pullX_m = pullX;
637  fill(residualGroup, layerDisk_si_m, si_eca_resX_m, si_eca_pullX_m);
638 
639  //SCT Residual plots
640  auto sct_eca_residualx_m = Monitored::Scalar<float>( "m_sct_eca_residualx", residualX);
641  fill(m_tools[m_sctECAResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_eca_residualx_m);
642  auto sct_eca_pullx_m = Monitored::Scalar<float>( "m_sct_eca_pullx", pullX);
643  fill(residualGroup, sct_eca_residualx_m, sct_eca_pullx_m);
644  if (sctSide == 0) {
645  fill(m_tools[m_sctECA_s0_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_eca_residualx_m);
646  } else {
647  fill(m_tools[m_sctECA_s1_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_eca_residualx_m);
648  }
649 
650  //Residuals vs Eta and Phi
651  auto residualX_sct_eca_m = Monitored::Scalar<float>( "m_residualX_sct_eca", residualX);
652  auto modPhiShift_sct_eca_m = Monitored::Scalar<int>( "m_modPhiShift_sct_eca", modPhi + layerDisk * (gap_sct + Nmods) );
653  fill(residualGroup, modPhiShift_sct_eca_m, residualX_sct_eca_m);
654  } // end SCT end-cap A
655 
656  else if(barrelEC==-2){//start SCT end-cap C
657  int Nmods = 52;
658  int gap_sct = 10;
659 
660  //Common Si plots
661  layerDisk_si_m = 3 + 2 * layerDisk + sctSide;
662  si_ecc_resX_m = residualX;
663  si_ecc_pullX_m = pullX;
664  fill(residualGroup, layerDisk_si_m, si_ecc_resX_m, si_ecc_pullX_m);
665 
666  //SCT Residual plots
667  auto sct_ecc_residualx_m = Monitored::Scalar<float>( "m_sct_ecc_residualx", residualX);
668  fill(m_tools[m_sctECCResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_ecc_residualx_m);
669  auto sct_ecc_pullx_m = Monitored::Scalar<float>( "m_sct_ecc_pullx", pullX);
670  fill(residualGroup, sct_ecc_residualx_m, sct_ecc_pullx_m);
671  if (sctSide == 0) {
672  fill(m_tools[m_sctECC_s0_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_ecc_residualx_m);
673  } else {
674  fill(m_tools[m_sctECC_s1_ResidualX_2DProf[layerDisk]], modEta_m, modPhi_m, sct_ecc_residualx_m);
675  }
676 
677  //Residuals vs Eta and Phi
678  auto residualX_sct_ecc_m = Monitored::Scalar<float>( "m_residualX_sct_ecc", residualX);
679  auto modPhiShift_sct_ecc_m = Monitored::Scalar<int>( "m_modPhiShift_sct_ecc", modPhi + layerDisk * (gap_sct + Nmods) );
680  fill(residualGroup, modPhiShift_sct_ecc_m, residualX_sct_ecc_m);
681  } // end SCT end-cap C
682  }// end of SCT
683  ++nHits;
684  //++nHitsEvent;
685  }//end of loop on track surfaces
686  } // end of loop on tracks
687 
688  ATH_MSG_DEBUG("Number of tracks : "<< nTracks);
689 
690  return StatusCode::SUCCESS;
691 }

◆ fillTRTBarrelHistograms()

void IDAlignMonResidualsAlg::fillTRTBarrelHistograms ( int  barrel_ec,
int  layer_or_wheel,
int  phi_module,
float  predictR,
float  hitR,
float  residualR,
float  pullR,
bool  LRcorrect,
bool  isTubeHit,
float  trketa 
) const
private

Definition at line 822 of file IDAlignMonResidualsAlg.cxx.

822  {
823 
824  //Loop over the barrel sides
825  for (unsigned int side = 0; side < 3; ++side) {
826  bool doFill = false;
827  if (!side) doFill = true;
828  else if (side == 1 && barrel_ec == 1) doFill = true;
829  else if (side == 2 && barrel_ec == -1) doFill = true;
830 
831  if (!doFill) continue;
832 
833  auto trt_b_PredictedR_m = Monitored::Scalar<float>( "m_trt_b_PredictedR", predictR);
834  fill(m_tools[m_trtBPredictedR[side]], trt_b_PredictedR_m);
835  auto trt_b_MeasuredR_m = Monitored::Scalar<float>( "m_trt_b_MeasuredR", hitR);
836  fill(m_tools[m_trtBMeasuredR[side]], trt_b_MeasuredR_m);
837  auto trt_b_residualR_m = Monitored::Scalar<float>( "m_trt_b_residualR", residualR);
838  fill(m_tools[m_trtBResidualR[side]], trt_b_residualR_m);
839  auto trt_b_pullR_m = Monitored::Scalar<float>( "m_trt_b_pullR", pullR);
840  fill(m_tools[m_trtBPullR[side]], trt_b_pullR_m);
841 
842  if (!isTubeHit) {
843  auto trt_b_residualR_notube_m = Monitored::Scalar<float>( "m_trt_b_residualR_notube", residualR);
844  fill(m_tools[m_trtBResidualRNoTube[side]], trt_b_residualR_notube_m);
845  auto trt_b_pullR_notube_m = Monitored::Scalar<float>( "m_trt_b_pullR_notube", pullR);
846  fill(m_tools[m_trtBPullRNoTube[side]], trt_b_pullR_notube_m);
847  }
848 
849  auto trt_b_lr_m = Monitored::Scalar<float>( "m_trt_b_lr", 0.0);
850  if (LRcorrect && !isTubeHit) trt_b_lr_m = 0.5;
851  if (LRcorrect && isTubeHit) trt_b_lr_m = 1.5;
852  if (!LRcorrect && !isTubeHit) trt_b_lr_m = 2.5;
853  if (!LRcorrect && isTubeHit) trt_b_lr_m = 3.5;
854  fill(m_tools[m_trtBLR[side]], trt_b_lr_m);
855 
856  auto trt_b_aveResVsTrackEta_m = Monitored::Scalar<float>( "m_trt_b_aveResVsTrackEta", trketa);
857  auto trt_b_PhiSec_m = Monitored::Scalar<float>( "m_trt_b_PhiSec", phi_module);
858  auto trt_b_lrVsPhiSec_m = Monitored::Scalar<float>( "m_trt_b_lrVsPhiSec", LRcorrect);
859  fill(m_tools[m_trtBResVsEta[side][layer_or_wheel]], trt_b_aveResVsTrackEta_m, trt_b_residualR_m);
860  fill(m_tools[m_trtBResVsPhiSec[side][layer_or_wheel]], trt_b_PhiSec_m, trt_b_residualR_m);
861  trt_b_lrVsPhiSec_m = LRcorrect;
862  fill(m_tools[m_trtBLRVsPhiSec[side][layer_or_wheel]], trt_b_PhiSec_m, trt_b_lrVsPhiSec_m);
863 
864  }//Over sides
865 
866  return;
867 }//fillTRTBarrelHistograms

◆ fillTRTEndcapHistograms()

void IDAlignMonResidualsAlg::fillTRTEndcapHistograms ( int  barrel_ec,
int  layer_or_wheel,
int  phi_module,
float  predictR,
float  hitR,
float  residualR,
float  pullR,
bool  LRcorrect,
bool  isTubeHit,
float  trketa,
float  qpT 
) const
private

Definition at line 869 of file IDAlignMonResidualsAlg.cxx.

869  {
870  for (unsigned int endcap = 0; endcap < 2; ++endcap) {
871  bool doFill = false;
872  if (!endcap && barrel_ec == 2) doFill = true;
873  else if (endcap && barrel_ec == -2) doFill = true;
874 
875  if (!doFill) continue;
876 
877  auto trt_ec_PredictedR_m = Monitored::Scalar<float>( "m_trt_ec_PredictedR", predictR);
878  fill(m_tools[m_trtECPredictedR[endcap]], trt_ec_PredictedR_m);
879  auto trt_ec_MeasuredR_m = Monitored::Scalar<float>( "m_trt_ec_MeasuredR", hitR);
880  fill(m_tools[m_trtECMeasuredR[endcap]], trt_ec_MeasuredR_m);
881  auto trt_ec_residualR_m = Monitored::Scalar<float>( "m_trt_ec_residualR", residualR);
882  fill(m_tools[m_trtECResidualR[endcap]], trt_ec_residualR_m);
883  auto trt_ec_pullR_m = Monitored::Scalar<float>( "m_trt_ec_pullR", pullR);
884  fill(m_tools[m_trtECPullR[endcap]], trt_ec_pullR_m);
885 
886  //Filling TRT 2Dprof histograms
887  auto layer_or_wheel_m = Monitored::Scalar<float>("m_layer_or_wheel", layer_or_wheel);
888  auto pT_m = Monitored::Scalar<float>( "m_pT", qpT );
889  fill(m_tools[m_trtECResVsPt_2DProf[endcap]], layer_or_wheel_m, pT_m, trt_ec_residualR_m);
890 
891  if (!isTubeHit) {
892  auto trt_ec_pullR_notube_m = Monitored::Scalar<float>( "m_trt_ec_pullR_notube", pullR);
893  fill(m_tools[m_trtECPullRNoTube[endcap]], trt_ec_pullR_notube_m);
894  auto trt_ec_residualR_notube_m = Monitored::Scalar<float>( "m_trt_ec_residualR_notube", residualR);
895  fill(m_tools[m_trtECResidualRNoTube[endcap]], trt_ec_residualR_notube_m);
896  }
897 
898  auto trt_ec_lr_m = Monitored::Scalar<float>( "m_trt_ec_lr", 0.0);
899  if (LRcorrect && !isTubeHit) trt_ec_lr_m = 0.5;
900  else if (LRcorrect && isTubeHit) trt_ec_lr_m = 1.5;
901  else if (!LRcorrect && !isTubeHit) trt_ec_lr_m = 2.5;
902  else if (!LRcorrect && isTubeHit) trt_ec_lr_m = 3.5;
903  fill(m_tools[m_trtECLR[endcap]], trt_ec_lr_m);
904 
905  auto trt_ec_aveResVsTrackEta_m = Monitored::Scalar<float>( "m_trt_ec_aveResVsTrackEta", trketa);
906  fill(m_tools[m_trtECResVsEta[endcap]], trt_ec_aveResVsTrackEta_m, trt_ec_residualR_m);
907 
908  auto trt_ec_phi_m = Monitored::Scalar<float>( "m_trt_ec_phi", phi_module);
909  fill(m_tools[m_trtECResVsPhiSec[endcap]], trt_ec_phi_m, trt_ec_residualR_m);
910  auto trt_ec_lrVsPhiSec_m = Monitored::Scalar<float>( "m_trt_ec_lrVsPhiSec", LRcorrect);
911  fill(m_tools[m_trtECLRVsPhiSec[endcap]], trt_ec_phi_m, trt_ec_lrVsPhiSec_m);
912  }
913 
914  return;
915 }

◆ fillTRTHistograms()

void IDAlignMonResidualsAlg::fillTRTHistograms ( int  barrel_ec,
int  layer_or_wheel,
int  phi_module,
float  predictR,
float  hitR,
float  residualR,
float  pullR,
bool  isTubeHit,
float  trketa,
float  qpT 
) const
private

Filling EndCapA histograms

Definition at line 784 of file IDAlignMonResidualsAlg.cxx.

784  {
785  bool LRcorrect = (predictR * hitR > 0);
786 
787  //Need to correct the TRT residual on the C-side.
788  if (barrel_ec == -1) {
789  residualR *= -1;
790  }
791 
792  if (barrel_ec == 1 || barrel_ec == -1)
793  fillTRTBarrelHistograms(barrel_ec
794  , layer_or_wheel
795  , phi_module
796  , predictR
797  , hitR
798  , residualR
799  , pullR
800  , LRcorrect
801  , isTubeHit
802  , trketa);
803 
805  if (barrel_ec == 2 || barrel_ec == -2)
806  fillTRTEndcapHistograms(barrel_ec
807  , layer_or_wheel
808  , phi_module
809  , predictR
810  , hitR
811  , residualR
812  , pullR
813  , LRcorrect
814  , isTubeHit
815  , trketa
816  , qpT);
817 
818  return;
819 }

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

◆ getSiResiduals()

StatusCode IDAlignMonResidualsAlg::getSiResiduals ( const Trk::Track *  track,
const Trk::TrackStateOnSurface *  tsos,
bool  unBias,
double *  results 
) const
private

Definition at line 694 of file IDAlignMonResidualsAlg.cxx.

695 {
696  if (!m_doPulls) return StatusCode::FAILURE;
697 
698  StatusCode sc = StatusCode::SUCCESS;
699 
700  double residualX = -9999.0;
701  double residualY = -9999.0;
702  double pullX = -9999.0;
703  double pullY = -9999.0;
704 
705  //extract the hit object from the tsos
706  const Trk::MeasurementBase* mesh =tsos->measurementOnTrack();
707  const Trk::RIO_OnTrack* hit = dynamic_cast <const Trk::RIO_OnTrack*>(mesh);
708 
709  //get the unbiased track parameters (can fail if no MeasuredTrackParameters exists)
710  std::unique_ptr <Trk::TrackParameters> trackParameterUnbiased{};
711  if(unBias) trackParameterUnbiased = getUnbiasedTrackParameters(track,tsos);
712 
713  //updator can fail in defining unbiased parameters, in which case we use biased
714  std::unique_ptr <Trk::TrackParameters> trackParameterForResiduals{};
715  if(trackParameterUnbiased){
716  trackParameterForResiduals = std:: move(trackParameterUnbiased);
717  }
718  else {
719  //use the original biased track parameters
720  std::unique_ptr <Trk::TrackParameters> uTrkPtr = tsos->trackParameters()->uniqueClone();
721  trackParameterForResiduals = std::move(uTrkPtr);
722  }
723 
724  if (!m_residualPullCalculator.empty()) {
725 
726  if (hit && trackParameterForResiduals) {
727 
728  ATH_MSG_DEBUG(" got hit and track parameters ");
729 
730  std::optional<Trk::ResidualPull> residualPull = std::nullopt;
731  if(unBias) residualPull = m_residualPullCalculator->residualPull(mesh, trackParameterForResiduals.get(), Trk::ResidualPull::Unbiased);
732  else residualPull = m_residualPullCalculator->residualPull(mesh, trackParameterForResiduals.get(), Trk::ResidualPull::Biased);
733 
734  ATH_MSG_DEBUG(" got hit and track parameters...done ");
735  if (residualPull) {
736 
737  ATH_MSG_DEBUG(" got residual pull object");
738  residualX = residualPull->residual()[Trk::loc1];
739  if(residualPull->isPullValid()) pullX = residualPull->pull()[Trk::loc1];
740  else {
741  ATH_MSG_DEBUG("ResidualPullCalculator finds invalid X Pull!!!");
742  sc = StatusCode::FAILURE;
743  }
744 
745  if (residualPull->dimension() >= 2){
746 
747  ATH_MSG_DEBUG(" residualPull dim >= 2");
748  residualY = residualPull->residual()[Trk::loc2];
749 
750  ATH_MSG_DEBUG(" residual Y = " << residualY);
751  if(residualPull->isPullValid()) pullY = residualPull->pull()[Trk::loc2];
752  else {
753  ATH_MSG_DEBUG("ResidualPullCalculator finds invalid Y Pull!!!");
754  sc = StatusCode::FAILURE;
755  }
756  }
757  }
758  else {
759  ATH_MSG_DEBUG("ResidualPullCalculator failed!");
760  sc = StatusCode::FAILURE;
761  }
762  }
763  }
764 
765  // for SCT modules the residual pull calculator only finds the (rotated) Rphi residual
766  // for each of the SCT sides; residualPull->dimension()==1 always.
767 
768  //std::pair <double, double> result(residualX, residualY);
769  results[0] = residualX;
770  results[1] = residualY;
771  results[2] = pullX;
772  results[3] = pullY;
773 
774  if(pullX!=pullX || pullY!=pullY){
775  ATH_MSG_DEBUG("ResidualPullCalculator finds Pull=NAN!!!");
776  sc = StatusCode::FAILURE;
777  }
778 
779  return sc;
780 
781 }

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

◆ getUnbiasedTrackParameters()

std::unique_ptr< Trk::TrackParameters > IDAlignMonResidualsAlg::getUnbiasedTrackParameters ( const Trk::Track *  trkPnt,
const Trk::TrackStateOnSurface *  tsos 
) const
private

Definition at line 918 of file IDAlignMonResidualsAlg.cxx.

919 {
920 
921  std::unique_ptr <Trk::TrackParameters> TrackParams{};
922  std::unique_ptr <Trk::TrackParameters> UnbiasedTrackParams{};
923  std::unique_ptr <Trk::TrackParameters> PropagatedTrackParams{};
924  std::unique_ptr <Trk::TrackParameters> OtherSideUnbiasedTrackParams{};
925 
926  //controls if the SCT residuals will be 'truly' unbiased - removing also the opposite side hit.
927  bool trueUnbiased = true;
928 
929  Identifier surfaceID;
930 
931 
932  ATH_MSG_VERBOSE("original track parameters: " << *(tsos->trackParameters()) );
933  ATH_MSG_VERBOSE("Trying to unbias track parameters.");
934 
935  const Trk::RIO_OnTrack* hitOnTrack = dynamic_cast <const Trk::RIO_OnTrack*>(tsos->measurementOnTrack());
936 
937  if (hitOnTrack != nullptr) surfaceID = hitOnTrack->identify();
938 
939 
940  // if SCT Hit and TrueUnbiased then remove other side hit first
941  if (surfaceID.is_valid() && trueUnbiased && m_idHelper->is_sct(surfaceID)) { //there's no TrueUnbiased for non-SCT (pixel) hits)
942  ATH_MSG_VERBOSE("Entering True Unbiased loop.");
943 
944  // check if other module side was also hit and try to remove other hit as well
945  const Trk::TrackStateOnSurface* OtherModuleSideHit(nullptr);
946  const Identifier waferID = m_sctID->wafer_id(surfaceID);
947  const IdentifierHash waferHash = m_sctID->wafer_hash(waferID);
948  IdentifierHash otherSideHash;
949  m_sctID->get_other_side(waferHash, otherSideHash);
950  const Identifier OtherModuleSideID = m_sctID->wafer_id(otherSideHash);
951 
952  for (const Trk::TrackStateOnSurface* TempTsos : *trkPnt->trackStateOnSurfaces()) {
953 
954  const Trk::RIO_OnTrack* TempHitOnTrack = dynamic_cast <const Trk::RIO_OnTrack*>(TempTsos->measurementOnTrack());
955  if (TempHitOnTrack != nullptr) {
956  if (m_sctID->wafer_id(TempHitOnTrack->identify()) == OtherModuleSideID) {
957  ATH_MSG_VERBOSE("True unbiased residual. Removing OtherModuleSide Hit " << m_idHelper->show_to_string(OtherModuleSideID,nullptr,'/') );
958  OtherModuleSideHit = TempTsos;
959  }
960  }
961  }
962 
963  if (OtherModuleSideHit) {
964  const Trk::TrackParameters* OMSHmeasuredTrackParameter = OtherModuleSideHit->trackParameters();
965  const AmgSymMatrix(5)* OMSHmeasuredTrackParameterCov = OMSHmeasuredTrackParameter ? OMSHmeasuredTrackParameter->covariance() : nullptr;
966 
967  // check that the hit on the other module side has measuredtrackparameters, otherwise it cannot be removed from the track
968  if (OMSHmeasuredTrackParameterCov) {
969  ATH_MSG_VERBOSE("OtherSideTrackParameters: " << *(OtherModuleSideHit->trackParameters()) );
970  OtherSideUnbiasedTrackParams = m_iUpdator->removeFromState(*(OtherModuleSideHit->trackParameters()),
971  OtherModuleSideHit->measurementOnTrack()->localParameters(),
972  OtherModuleSideHit->measurementOnTrack()->localCovariance());
973 
974  if (OtherSideUnbiasedTrackParams) {
975  ATH_MSG_VERBOSE("Unbiased OtherSideTrackParameters: " << *OtherSideUnbiasedTrackParams);
976 
977 
978  const Trk::Surface* TempSurface = &(OtherModuleSideHit->measurementOnTrack()->associatedSurface());
979 
980  const Trk::MagneticFieldProperties* TempField = nullptr;
981  if (TempSurface)
982  {
983  ATH_MSG_VERBOSE("After OtherSide surface call. Surface exists");
984  if (TempSurface->associatedLayer())
985  {
986  ATH_MSG_VERBOSE("TempSurface->associatedLayer() exists");
987  if(TempSurface->associatedLayer()->enclosingTrackingVolume())
988  {
989  ATH_MSG_VERBOSE("TempSurface->associatedLayer()->enclosingTrackingVolume exists");
990 
991  TempField = dynamic_cast <const Trk::MagneticFieldProperties*>(TempSurface->associatedLayer()->enclosingTrackingVolume());
992  ATH_MSG_VERBOSE("After MagneticFieldProperties cast");
993  ATH_MSG_VERBOSE("Before other side unbiased propagation");
994 
995  if (TempSurface->associatedLayer() && TempField) PropagatedTrackParams = m_propagator->propagate(
996  Gaudi::Hive::currentContext(),
997  *OtherSideUnbiasedTrackParams,
998  tsos->measurementOnTrack()->associatedSurface(),
999  Trk::anyDirection, false,
1000  *TempField,
1001  Trk::nonInteracting);
1002 
1003  } else {
1004  ATH_MSG_VERBOSE("TempSurface->associatedLayer()->enclosingTrackingVolume does not exist");
1005  }
1006  } else {
1007  ATH_MSG_VERBOSE("TempSurface->associatedLayer() does not exist");
1008  }
1009  } else {
1010  ATH_MSG_VERBOSE("After OtherSide surface call. Surface does not exist");
1011  }
1012 
1013  ATH_MSG_VERBOSE("After other side unbiased propagation");
1014  if (PropagatedTrackParams) {
1015  ATH_MSG_VERBOSE("Propagated Track Parameters: " << *PropagatedTrackParams);
1016  } else {
1017  ATH_MSG_DEBUG("Propagation of unbiased OtherSideParameters failed");
1018  }
1019  } else {
1020  ATH_MSG_DEBUG("RemoveFromState did not work for OtherSideParameters");
1021  }
1022  } else {
1023  ATH_MSG_VERBOSE("No OtherModuleSideHit Measured Track Parameters found");
1024  }
1025  } else {
1026  ATH_MSG_VERBOSE("No OtherModuleSideHit found");
1027  }
1028  }
1029 
1030  // if propagation failed or no TrueUnbiased or no SCT then use original TrackParams
1031  if (!PropagatedTrackParams) {
1032  std::unique_ptr <Trk::TrackParameters> uTrkPtr = tsos->trackParameters()->uniqueClone();
1033  PropagatedTrackParams = std::move(uTrkPtr);
1034  }
1035 
1036  UnbiasedTrackParams =
1037  m_iUpdator
1038  ->removeFromState(*PropagatedTrackParams,
1039  tsos->measurementOnTrack()->localParameters(),
1040  tsos->measurementOnTrack()->localCovariance());
1041 
1042  if (UnbiasedTrackParams) {
1043  if(surfaceID.is_valid() ) ATH_MSG_VERBOSE("Unbiased residual. Removing original Hit " << m_idHelper->show_to_string(surfaceID,nullptr,'/') );
1044  ATH_MSG_VERBOSE("Unbiased Trackparameters: " << *UnbiasedTrackParams);
1045 
1046  TrackParams = std::move(UnbiasedTrackParams);
1047 
1048  } else { // Unbiasing went awry.
1049  ATH_MSG_WARNING("RemoveFromState did not work, using original TrackParameters");
1050 
1051  std::unique_ptr <Trk::TrackParameters> uTrkPtr = tsos->trackParameters()->uniqueClone();
1052  TrackParams = std::move(uTrkPtr);
1053  }
1054 
1055  return TrackParams;
1056 
1057 }

◆ initialize()

StatusCode IDAlignMonResidualsAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Get TRTCalDbTool

Reimplemented from AthMonitorAlgorithm.

Definition at line 71 of file IDAlignMonResidualsAlg.cxx.

72 {
73  //initialize tools and services
74  ATH_MSG_DEBUG("Calling initialize() to setup tools/services");
75  StatusCode sc = setupTools();
76  if (sc.isFailure()) {
77  ATH_MSG_WARNING("Failed to initialize tools/services!");
78  return StatusCode::SUCCESS;
79  }
80  else
81  ATH_MSG_DEBUG("Successfully initialized tools/services");
82 
84  ATH_CHECK( m_trtcaldbTool.retrieve() );
85 
86  ATH_CHECK( m_tracksName.initialize() );
87  ATH_CHECK( m_tracksKey.initialize() );
88 
89  m_pixResidualX = Monitored::buildToolMap<int>(m_tools, "PixResidualX", m_nSiBlayers);
90  m_pixResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "PixResidualX_2DProf", m_nSiBlayers);
91  m_pixResidualY = Monitored::buildToolMap<int>(m_tools, "PixResidualY", m_nSiBlayers);
92  m_pixResidualY_2DProf = Monitored::buildToolMap<int>(m_tools, "PixResidualY_2DProf", m_nSiBlayers);
93  m_pixPullX = Monitored::buildToolMap<int>(m_tools, "PixPullX", m_nSiBlayers);
94  m_pixPullY = Monitored::buildToolMap<int>(m_tools, "PixPullY", m_nSiBlayers);
95  m_pixResidualXvsEta = Monitored::buildToolMap<int>(m_tools, "PixResidualXvsEta", m_nSiBlayers);
96  m_pixResidualYvsEta = Monitored::buildToolMap<int>(m_tools, "PixResidualYvsEta", m_nSiBlayers);
97  m_pixResidualXvsPhi = Monitored::buildToolMap<int>(m_tools, "PixResidualXvsPhi", m_nSiBlayers);
98  m_pixResidualYvsPhi = Monitored::buildToolMap<int>(m_tools, "PixResidualYvsPhi", m_nSiBlayers);
99  m_pixECAResidualX = Monitored::buildToolMap<int>(m_tools, "PixResidualXECA", m_nPixEClayers);
100  m_pixECAResidualY = Monitored::buildToolMap<int>(m_tools, "PixResidualYECA", m_nPixEClayers);
101  m_pixECResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "PixResidualXEC_2DProf", 2);
102  m_pixECResidualY_2DProf = Monitored::buildToolMap<int>(m_tools, "PixResidualYEC_2DProf", 2);
103  m_pixECCResidualX = Monitored::buildToolMap<int>(m_tools, "PixResidualXECC", m_nPixEClayers);
104  m_pixECCResidualY = Monitored::buildToolMap<int>(m_tools, "PixResidualYECC", m_nPixEClayers);
105  m_sctResidualX = Monitored::buildToolMap<int>(m_tools, "SCTResidualX", m_nSiBlayers);
106  m_sctResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTResidualX_2DProf", m_nSiBlayers);
107  m_sct_s0_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCT_s0_ResidualX_2DProf", m_nSiBlayers);
108  m_sct_s1_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCT_s1_ResidualX_2DProf", m_nSiBlayers);
109  m_sctECAResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECAResidualX_2DProf", m_nSCTEClayers);
110  m_sctECA_s0_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECA_s0_ResidualX_2DProf", m_nSCTEClayers);
111  m_sctECA_s1_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECA_s1_ResidualX_2DProf", m_nSCTEClayers);
112  m_sctECCResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECCResidualX_2DProf", m_nSCTEClayers);
113  m_sctECC_s0_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECC_s0_ResidualX_2DProf", m_nSCTEClayers);
114  m_sctECC_s1_ResidualX_2DProf = Monitored::buildToolMap<int>(m_tools, "SCTECC_s1_ResidualX_2DProf", m_nSCTEClayers);
115  m_sctPullX = Monitored::buildToolMap<int>(m_tools, "SCTPullX", m_nSiBlayers);
116  m_sctResidualXvsEta = Monitored::buildToolMap<int>(m_tools, "SCTResidualXvsEta", m_nSiBlayers);
117  m_sctResidualXvsPhi = Monitored::buildToolMap<int>(m_tools, "SCTResidualXvsPhi", m_nSiBlayers);
118  m_trtBPredictedR = Monitored::buildToolMap<int>(m_tools, "TRTPredictedRB", m_nTRTBlayers);
119  m_trtBMeasuredR = Monitored::buildToolMap<int>(m_tools, "TRTMeasuredRB", m_nTRTBlayers);
120  m_trtBResidualR = Monitored::buildToolMap<int>(m_tools, "TRTResidualRB", m_nTRTBlayers);
121  m_trtBPullR = Monitored::buildToolMap<int>(m_tools, "TRTPullRB", m_nTRTBlayers);
122  m_trtBResidualRNoTube = Monitored::buildToolMap<int>(m_tools, "TRTResidualRNoTubeB", m_nTRTBlayers);
123  m_trtBPullRNoTube = Monitored::buildToolMap<int>(m_tools, "TRTPullRNoTubeB", m_nTRTBlayers);
124  m_trtBLR = Monitored::buildToolMap<int>(m_tools, "TRTLRB", m_nTRTBlayers);
125  m_trtBResVsEta= Monitored::buildToolMap<std::vector<int>>(m_tools, "TRTResVsEtaB", m_nTRTBlayers,m_nTRTBlayers);
126  m_trtBResVsPhiSec= Monitored::buildToolMap<std::vector<int>>(m_tools, "TRTResVsPhiSecB", m_nTRTBlayers,m_nTRTBlayers);
127  m_trtBLRVsPhiSec= Monitored::buildToolMap<std::vector<int>>(m_tools, "TRTLRVsPhiSecB", m_nTRTBlayers,m_nTRTBlayers);
128  m_trtECPredictedR = Monitored::buildToolMap<int>(m_tools, "TRTPredictedREC", m_nTRTEClayers);
129  m_trtECMeasuredR = Monitored::buildToolMap<int>(m_tools, "TRTMeasuredREC", m_nTRTEClayers);
130  m_trtECResidualR = Monitored::buildToolMap<int>(m_tools, "TRTResidualREC", m_nTRTEClayers);
131  m_trtECPullR = Monitored::buildToolMap<int>(m_tools, "TRTPullREC", m_nTRTEClayers);
132  m_trtECResidualRNoTube = Monitored::buildToolMap<int>(m_tools, "TRTResidualRNoTubeEC", m_nTRTEClayers);
133  m_trtECPullRNoTube = Monitored::buildToolMap<int>(m_tools, "TRTPullRNoTubeEC", m_nTRTEClayers);
134  m_trtECLR = Monitored::buildToolMap<int>(m_tools, "TRTLREC", m_nTRTEClayers);
135  m_trtECResVsEta= Monitored::buildToolMap<int>(m_tools, "TRTResVsEtaEC", m_nTRTEClayers);
136  m_trtECResVsPhiSec= Monitored::buildToolMap<int>(m_tools, "TRTResVsPhiEC", m_nTRTEClayers);
137  m_trtECLRVsPhiSec= Monitored::buildToolMap<int>(m_tools, "TRTLRVsPhiEC", m_nTRTEClayers);
138  m_trtECResVsPt_2DProf= Monitored::buildToolMap<int>(m_tools, "TRTResECvspT_2DProf", m_nTRTEClayers);
139 
140  ATH_MSG_DEBUG("initialize() -- completed --");
141  return AthMonitorAlgorithm::initialize();
142 }

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

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

◆ setupTools()

StatusCode IDAlignMonResidualsAlg::setupTools ( )
private

Definition at line 1060 of file IDAlignMonResidualsAlg.cxx.

1061 {
1062  //initializing tools
1063 
1064  ATH_MSG_DEBUG("In setupTools()");
1065 
1066  StatusCode sc;
1067  //Get the PIX manager from the detector store
1068  ATH_CHECK(detStore()->retrieve(m_PIX_Mgr,m_Pixel_Manager));
1069  ATH_MSG_DEBUG("Initialized PixelManager");
1070 
1071  //Get the SCT manager from the detector store
1072  ATH_CHECK(detStore()->retrieve(m_SCT_Mgr, m_SCT_Manager));
1073  ATH_MSG_DEBUG("Initialized SCTManager");
1074 
1075  ATH_CHECK(detStore()->retrieve(m_pixelID, "PixelID"));
1076  ATH_MSG_DEBUG("Initialized PixelIDHelper");
1077 
1078  ATH_CHECK(detStore()->retrieve(m_sctID, "SCT_ID"));
1079  ATH_MSG_DEBUG("Initialized SCTIDHelper");
1080 
1081  ATH_CHECK(detStore()->retrieve(m_trtID, "TRT_ID"));
1082  ATH_MSG_DEBUG("Initialized TRTIDHelper");
1083 
1084  //ID Helper
1085  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
1086 
1087  ATH_CHECK(m_iUpdator.retrieve());
1088  ATH_MSG_DEBUG("Retrieved iUpdator tool " << m_iUpdator);
1089 
1090  if (m_propagator.retrieve().isFailure()) {
1091  ATH_MSG_WARNING("Can not retrieve Propagator tool of type " << m_propagator.typeAndName());
1092  return StatusCode::FAILURE;
1093  } else ATH_MSG_INFO("Retrieved tool " << m_propagator.typeAndName());
1094 
1095  if (m_trackSelection.retrieve().isFailure()) {
1096  ATH_MSG_WARNING("Can not retrieve TrackSelection tool of type " << m_trackSelection.typeAndName());
1097  return StatusCode::FAILURE;
1098  } else ATH_MSG_INFO("Retrieved tool " << m_trackSelection.typeAndName());;
1099 
1100  if (m_residualPullCalculator.empty()) {
1101  ATH_MSG_DEBUG("No residual/pull calculator for general hit residuals configured.");
1102  ATH_MSG_DEBUG("It is recommended to give R/P calculators to the det-specific tool handle lists then.");
1103  m_doPulls = false;
1104  ATH_CHECK(m_residualPullCalculator.retrieve( DisableTool{!m_doPulls} ));
1105  } else if (m_residualPullCalculator.retrieve().isFailure()) {
1106  ATH_MSG_WARNING("Could not retrieve "<< m_residualPullCalculator << " (to calculate residuals and pulls) ");
1107  m_doPulls = false;
1108 
1109  } else {
1110  ATH_MSG_DEBUG("Generic hit residuals&pulls will be calculated in one or both available local coordinates");
1111  m_doPulls = true;
1112  }
1113 
1114  if (m_hitQualityTool.empty()) {
1115  ATH_MSG_DEBUG("No hit quality tool configured - not hit quality cuts will be imposed");
1116  m_doHitQuality = false;
1117  ATH_CHECK(m_hitQualityTool.retrieve( DisableTool{!m_doHitQuality} ));
1118  } else if (m_hitQualityTool.retrieve().isFailure()) {
1119  ATH_MSG_WARNING("Could not retrieve " << m_hitQualityTool << " to apply hit quality cuts to Si hits");
1120  m_doHitQuality = false;
1121  } else {
1122  ATH_MSG_DEBUG("Hit quality tool setup - hit quality cuts will be applied to Si hits");
1123  m_doHitQuality = true;
1124  }
1125 
1126 
1127  return StatusCode::SUCCESS;
1128 }

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

◆ trackRequiresRefit()

bool IDAlignMonResidualsAlg::trackRequiresRefit ( const Trk::Track *  track) const
private

Definition at line 1131 of file IDAlignMonResidualsAlg.cxx.

1132 {
1133 
1134  // Checks to see if any of the measurements on track do not have track parameters associated
1135  // (as happens for certain track collections in e.g. ESD)
1136  // If this is the case we cannot define residuals and track needs to be refitted (return true)
1137 
1138  bool refitTrack = false;
1139 
1140  int nHits = 0;
1141  int nHitsNoParams = 0;
1142 
1143  ATH_MSG_DEBUG("Testing track to see if requires refit...");
1144 
1145  for (const Trk::TrackStateOnSurface* tsos : *track->trackStateOnSurfaces()) {
1146 
1147  if(tsos == nullptr) continue;
1148 
1149  //skipping outliers
1150  if(!tsos->type(Trk::TrackStateOnSurface::Measurement)) continue;
1151 
1152  const Trk::MeasurementBase* mesh =tsos->measurementOnTrack();
1153  if (mesh==nullptr) continue;
1154  const Trk::RIO_OnTrack* hit = dynamic_cast <const Trk::RIO_OnTrack*>(mesh);
1155  if (hit==nullptr) continue;
1156 
1157  ++nHits;
1158 
1159  const Trk::TrackParameters* trackParameter = tsos->trackParameters();
1160  if(trackParameter==nullptr) ++nHitsNoParams; //if no TrackParameters for TSOS we cannot define residuals
1161 
1162  }
1163 
1164  ATH_MSG_DEBUG("Total nhits on track (excluding outliers) = " << nHits << ", nhits without trackparameters = " << nHitsNoParams);
1165 
1166  if(nHitsNoParams>0) {
1167  refitTrack = true;
1168  ATH_MSG_DEBUG("Track Requires refit to get residuals!!!");
1169  }
1170 
1171  return refitTrack;
1172 }

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_applyTrkSel

bool IDAlignMonResidualsAlg::m_applyTrkSel {}
private

Definition at line 91 of file IDAlignMonResidualsAlg.h.

◆ m_checkrate

int IDAlignMonResidualsAlg::m_checkrate {}
private

Definition at line 89 of file IDAlignMonResidualsAlg.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_doHitQuality

bool IDAlignMonResidualsAlg::m_doHitQuality {false}
private

Definition at line 88 of file IDAlignMonResidualsAlg.h.

◆ m_doPulls

bool IDAlignMonResidualsAlg::m_doPulls {}
private

Definition at line 90 of file IDAlignMonResidualsAlg.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 352 of file AthMonitorAlgorithm.h.

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

bool IDAlignMonResidualsAlg::m_extendedPlots {}
private

Definition at line 87 of file IDAlignMonResidualsAlg.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_hitQualityTool

ToolHandle<IInDetAlignHitQualSelTool> IDAlignMonResidualsAlg::m_hitQualityTool
private

Definition at line 83 of file IDAlignMonResidualsAlg.h.

◆ m_idHelper

const AtlasDetectorID* IDAlignMonResidualsAlg::m_idHelper {}
private

Definition at line 68 of file IDAlignMonResidualsAlg.h.

◆ m_iUpdator

ToolHandle<Trk::IUpdator> IDAlignMonResidualsAlg::m_iUpdator
private

Definition at line 79 of file IDAlignMonResidualsAlg.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_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_nPixEClayers

const int IDAlignMonResidualsAlg::m_nPixEClayers {3}
staticprivate

Definition at line 94 of file IDAlignMonResidualsAlg.h.

◆ m_nSCTEClayers

const int IDAlignMonResidualsAlg::m_nSCTEClayers {9}
staticprivate

Definition at line 95 of file IDAlignMonResidualsAlg.h.

◆ m_nSiBlayers

const int IDAlignMonResidualsAlg::m_nSiBlayers {4}
staticprivate

Definition at line 93 of file IDAlignMonResidualsAlg.h.

◆ m_nTRTBlayers

const int IDAlignMonResidualsAlg::m_nTRTBlayers {3}
staticprivate

Definition at line 96 of file IDAlignMonResidualsAlg.h.

◆ m_nTRTEClayers

const int IDAlignMonResidualsAlg::m_nTRTEClayers {2}
staticprivate

Definition at line 97 of file IDAlignMonResidualsAlg.h.

◆ m_PIX_Mgr

const InDetDD::PixelDetectorManager* IDAlignMonResidualsAlg::m_PIX_Mgr {}
private

Definition at line 69 of file IDAlignMonResidualsAlg.h.

◆ m_pixECAResidualX

std::vector<int> IDAlignMonResidualsAlg::m_pixECAResidualX
private

Definition at line 108 of file IDAlignMonResidualsAlg.h.

◆ m_pixECAResidualY

std::vector<int> IDAlignMonResidualsAlg::m_pixECAResidualY
private

Definition at line 109 of file IDAlignMonResidualsAlg.h.

◆ m_pixECCResidualX

std::vector<int> IDAlignMonResidualsAlg::m_pixECCResidualX
private

Definition at line 112 of file IDAlignMonResidualsAlg.h.

◆ m_pixECCResidualY

std::vector<int> IDAlignMonResidualsAlg::m_pixECCResidualY
private

Definition at line 113 of file IDAlignMonResidualsAlg.h.

◆ m_pixECResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_pixECResidualX_2DProf
private

Definition at line 110 of file IDAlignMonResidualsAlg.h.

◆ m_pixECResidualY_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_pixECResidualY_2DProf
private

Definition at line 111 of file IDAlignMonResidualsAlg.h.

◆ m_Pixel_Manager

std::string IDAlignMonResidualsAlg::m_Pixel_Manager
private

Definition at line 85 of file IDAlignMonResidualsAlg.h.

◆ m_pixelID

const PixelID* IDAlignMonResidualsAlg::m_pixelID {}
private

Definition at line 71 of file IDAlignMonResidualsAlg.h.

◆ m_pixPullX

std::vector<int> IDAlignMonResidualsAlg::m_pixPullX
private

Definition at line 102 of file IDAlignMonResidualsAlg.h.

◆ m_pixPullY

std::vector<int> IDAlignMonResidualsAlg::m_pixPullY
private

Definition at line 103 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualX

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualX
private

Definition at line 98 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualX_2DProf
private

Definition at line 99 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualXvsEta

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualXvsEta
private

Definition at line 104 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualXvsPhi

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualXvsPhi
private

Definition at line 106 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualY

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualY
private

Definition at line 100 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualY_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualY_2DProf
private

Definition at line 101 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualYvsEta

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualYvsEta
private

Definition at line 105 of file IDAlignMonResidualsAlg.h.

◆ m_pixResidualYvsPhi

std::vector<int> IDAlignMonResidualsAlg::m_pixResidualYvsPhi
private

Definition at line 107 of file IDAlignMonResidualsAlg.h.

◆ m_propagator

ToolHandle<Trk::IPropagator> IDAlignMonResidualsAlg::m_propagator
private

Definition at line 80 of file IDAlignMonResidualsAlg.h.

◆ m_residualPullCalculator

ToolHandle<Trk::IResidualPullCalculator> IDAlignMonResidualsAlg::m_residualPullCalculator
private

The residual and pull calculator tool handle.

Definition at line 81 of file IDAlignMonResidualsAlg.h.

◆ m_SCT_Manager

std::string IDAlignMonResidualsAlg::m_SCT_Manager
private

Definition at line 86 of file IDAlignMonResidualsAlg.h.

◆ m_SCT_Mgr

const InDetDD::SCT_DetectorManager* IDAlignMonResidualsAlg::m_SCT_Mgr {}
private

Definition at line 70 of file IDAlignMonResidualsAlg.h.

◆ m_sct_s0_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sct_s0_ResidualX_2DProf
private

Definition at line 116 of file IDAlignMonResidualsAlg.h.

◆ m_sct_s1_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sct_s1_ResidualX_2DProf
private

Definition at line 117 of file IDAlignMonResidualsAlg.h.

◆ m_sctECA_s0_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECA_s0_ResidualX_2DProf
private

Definition at line 119 of file IDAlignMonResidualsAlg.h.

◆ m_sctECA_s1_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECA_s1_ResidualX_2DProf
private

Definition at line 120 of file IDAlignMonResidualsAlg.h.

◆ m_sctECAResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECAResidualX_2DProf
private

Definition at line 118 of file IDAlignMonResidualsAlg.h.

◆ m_sctECC_s0_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECC_s0_ResidualX_2DProf
private

Definition at line 122 of file IDAlignMonResidualsAlg.h.

◆ m_sctECC_s1_ResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECC_s1_ResidualX_2DProf
private

Definition at line 123 of file IDAlignMonResidualsAlg.h.

◆ m_sctECCResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctECCResidualX_2DProf
private

Definition at line 121 of file IDAlignMonResidualsAlg.h.

◆ m_sctID

const SCT_ID* IDAlignMonResidualsAlg::m_sctID {}
private

Definition at line 72 of file IDAlignMonResidualsAlg.h.

◆ m_sctPullX

std::vector<int> IDAlignMonResidualsAlg::m_sctPullX
private

Definition at line 124 of file IDAlignMonResidualsAlg.h.

◆ m_sctResidualX

std::vector<int> IDAlignMonResidualsAlg::m_sctResidualX
private

Definition at line 114 of file IDAlignMonResidualsAlg.h.

◆ m_sctResidualX_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_sctResidualX_2DProf
private

Definition at line 115 of file IDAlignMonResidualsAlg.h.

◆ m_sctResidualXvsEta

std::vector<int> IDAlignMonResidualsAlg::m_sctResidualXvsEta
private

Definition at line 125 of file IDAlignMonResidualsAlg.h.

◆ m_sctResidualXvsPhi

std::vector<int> IDAlignMonResidualsAlg::m_sctResidualXvsPhi
private

Definition at line 126 of file IDAlignMonResidualsAlg.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_trackSelection

ToolHandle<InDet::IInDetTrackSelectionTool> IDAlignMonResidualsAlg::m_trackSelection
private

Definition at line 82 of file IDAlignMonResidualsAlg.h.

◆ m_tracksKey

SG::ReadHandleKey<TrackCollection> IDAlignMonResidualsAlg::m_tracksKey {this,"TrackName2", "CombinedInDetTracks", "track data key"}
private

Definition at line 75 of file IDAlignMonResidualsAlg.h.

◆ m_tracksName

SG::ReadHandleKey<TrackCollection> IDAlignMonResidualsAlg::m_tracksName {this,"TrackName","CombinedInDetTracks", "track data key"}
private

Definition at line 76 of file IDAlignMonResidualsAlg.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_trtBLR

std::vector<int> IDAlignMonResidualsAlg::m_trtBLR
private

Definition at line 133 of file IDAlignMonResidualsAlg.h.

◆ m_trtBLRVsPhiSec

std::vector<std::vector<int> > IDAlignMonResidualsAlg::m_trtBLRVsPhiSec
private

Definition at line 136 of file IDAlignMonResidualsAlg.h.

◆ m_trtBMeasuredR

std::vector<int> IDAlignMonResidualsAlg::m_trtBMeasuredR
private

Definition at line 128 of file IDAlignMonResidualsAlg.h.

◆ m_trtBPredictedR

std::vector<int> IDAlignMonResidualsAlg::m_trtBPredictedR
private

Definition at line 127 of file IDAlignMonResidualsAlg.h.

◆ m_trtBPullR

std::vector<int> IDAlignMonResidualsAlg::m_trtBPullR
private

Definition at line 130 of file IDAlignMonResidualsAlg.h.

◆ m_trtBPullRNoTube

std::vector<int> IDAlignMonResidualsAlg::m_trtBPullRNoTube
private

Definition at line 132 of file IDAlignMonResidualsAlg.h.

◆ m_trtBResidualR

std::vector<int> IDAlignMonResidualsAlg::m_trtBResidualR
private

Definition at line 129 of file IDAlignMonResidualsAlg.h.

◆ m_trtBResidualRNoTube

std::vector<int> IDAlignMonResidualsAlg::m_trtBResidualRNoTube
private

Definition at line 131 of file IDAlignMonResidualsAlg.h.

◆ m_trtBResVsEta

std::vector<std::vector<int> > IDAlignMonResidualsAlg::m_trtBResVsEta
private

Definition at line 134 of file IDAlignMonResidualsAlg.h.

◆ m_trtBResVsPhiSec

std::vector<std::vector<int> > IDAlignMonResidualsAlg::m_trtBResVsPhiSec
private

Definition at line 135 of file IDAlignMonResidualsAlg.h.

◆ m_trtcaldbTool

ToolHandle<ITRT_CalDbTool> IDAlignMonResidualsAlg::m_trtcaldbTool
private

Definition at line 78 of file IDAlignMonResidualsAlg.h.

◆ m_trtECLR

std::vector<int> IDAlignMonResidualsAlg::m_trtECLR
private

Definition at line 143 of file IDAlignMonResidualsAlg.h.

◆ m_trtECLRVsPhiSec

std::vector<int> IDAlignMonResidualsAlg::m_trtECLRVsPhiSec
private

Definition at line 146 of file IDAlignMonResidualsAlg.h.

◆ m_trtECMeasuredR

std::vector<int> IDAlignMonResidualsAlg::m_trtECMeasuredR
private

Definition at line 138 of file IDAlignMonResidualsAlg.h.

◆ m_trtECPredictedR

std::vector<int> IDAlignMonResidualsAlg::m_trtECPredictedR
private

Definition at line 137 of file IDAlignMonResidualsAlg.h.

◆ m_trtECPullR

std::vector<int> IDAlignMonResidualsAlg::m_trtECPullR
private

Definition at line 140 of file IDAlignMonResidualsAlg.h.

◆ m_trtECPullRNoTube

std::vector<int> IDAlignMonResidualsAlg::m_trtECPullRNoTube
private

Definition at line 142 of file IDAlignMonResidualsAlg.h.

◆ m_trtECResidualR

std::vector<int> IDAlignMonResidualsAlg::m_trtECResidualR
private

Definition at line 139 of file IDAlignMonResidualsAlg.h.

◆ m_trtECResidualRNoTube

std::vector<int> IDAlignMonResidualsAlg::m_trtECResidualRNoTube
private

Definition at line 141 of file IDAlignMonResidualsAlg.h.

◆ m_trtECResVsEta

std::vector<int> IDAlignMonResidualsAlg::m_trtECResVsEta
private

Definition at line 144 of file IDAlignMonResidualsAlg.h.

◆ m_trtECResVsPhiSec

std::vector<int> IDAlignMonResidualsAlg::m_trtECResVsPhiSec
private

Definition at line 145 of file IDAlignMonResidualsAlg.h.

◆ m_trtECResVsPt_2DProf

std::vector<int> IDAlignMonResidualsAlg::m_trtECResVsPt_2DProf
private

Definition at line 147 of file IDAlignMonResidualsAlg.h.

◆ m_trtID

const TRT_ID* IDAlignMonResidualsAlg::m_trtID {}
private

Definition at line 73 of file IDAlignMonResidualsAlg.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.

The documentation for this class was generated from the following files:
IDAlignMonResidualsAlg::m_trtECResVsEta
std::vector< int > m_trtECResVsEta
Definition: IDAlignMonResidualsAlg.h:144
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
IDAlignMonResidualsAlg::m_Pixel_Manager
std::string m_Pixel_Manager
Definition: IDAlignMonResidualsAlg.h:85
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:755
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
IDAlignMonResidualsAlg::m_trtBPredictedR
std::vector< int > m_trtBPredictedR
Definition: IDAlignMonResidualsAlg.h:127
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
IDAlignMonResidualsAlg::m_pixPullY
std::vector< int > m_pixPullY
Definition: IDAlignMonResidualsAlg.h:103
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
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IDAlignMonResidualsAlg::m_trtECLR
std::vector< int > m_trtECLR
Definition: IDAlignMonResidualsAlg.h:143
IDAlignMonResidualsAlg::m_tracksKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
Definition: IDAlignMonResidualsAlg.h:75
get_generator_info.result
result
Definition: get_generator_info.py:21
IDAlignMonResidualsAlg::m_hitQualityTool
ToolHandle< IInDetAlignHitQualSelTool > m_hitQualityTool
Definition: IDAlignMonResidualsAlg.h:83
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
IDAlignMonResidualsAlg::m_trtBLRVsPhiSec
std::vector< std::vector< int > > m_trtBLRVsPhiSec
Definition: IDAlignMonResidualsAlg.h:136
IDAlignMonResidualsAlg::m_trtBResidualR
std::vector< int > m_trtBResidualR
Definition: IDAlignMonResidualsAlg.h:129
IDAlignMonResidualsAlg::m_pixECCResidualX
std::vector< int > m_pixECCResidualX
Definition: IDAlignMonResidualsAlg.h:112
Trk::MagneticFieldProperties
Definition: MagneticFieldProperties.h:31
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
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
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
IDAlignMonResidualsAlg::m_pixPullX
std::vector< int > m_pixPullX
Definition: IDAlignMonResidualsAlg.h:102
IDAlignMonResidualsAlg::fillTRTHistograms
void fillTRTHistograms(int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool isTubeHit, float trketa, float qpT) const
Definition: IDAlignMonResidualsAlg.cxx:784
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
IDAlignMonResidualsAlg::m_sctECAResidualX_2DProf
std::vector< int > m_sctECAResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:118
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:765
IDAlignMonResidualsAlg::m_nTRTEClayers
static const int m_nTRTEClayers
Definition: IDAlignMonResidualsAlg.h:97
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
IDAlignMonResidualsAlg::m_tracksName
SG::ReadHandleKey< TrackCollection > m_tracksName
Definition: IDAlignMonResidualsAlg.h:76
IDAlignMonResidualsAlg::m_sctECA_s0_ResidualX_2DProf
std::vector< int > m_sctECA_s0_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:119
IDAlignMonResidualsAlg::m_propagator
ToolHandle< Trk::IPropagator > m_propagator
Definition: IDAlignMonResidualsAlg.h:80
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
Trk::ResidualPull::Unbiased
@ Unbiased
RP with track state that has measurement not included.
Definition: ResidualPull.h:57
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
IDAlignMonResidualsAlg::m_trtECResidualRNoTube
std::vector< int > m_trtECResidualRNoTube
Definition: IDAlignMonResidualsAlg.h:141
IDAlignMonResidualsAlg::m_trtECResidualR
std::vector< int > m_trtECResidualR
Definition: IDAlignMonResidualsAlg.h:139
IDAlignMonResidualsAlg::m_nPixEClayers
static const int m_nPixEClayers
Definition: IDAlignMonResidualsAlg.h:94
IDAlignMonResidualsAlg::m_pixECCResidualY
std::vector< int > m_pixECCResidualY
Definition: IDAlignMonResidualsAlg.h:113
IDAlignMonResidualsAlg::m_residualPullCalculator
ToolHandle< Trk::IResidualPullCalculator > m_residualPullCalculator
The residual and pull calculator tool handle.
Definition: IDAlignMonResidualsAlg.h:81
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
Trk::TrackStateOnSurface::measurementOnTrack
const MeasurementBase * measurementOnTrack() const
returns MeasurementBase const overload
Trk::loc2
@ loc2
generic first and second local coordinate
Definition: ParamDefs.h:35
IDAlignMonResidualsAlg::getSiResiduals
StatusCode getSiResiduals(const Trk::Track *, const Trk::TrackStateOnSurface *, bool, double *) const
Definition: IDAlignMonResidualsAlg.cxx:694
IDAlignMonResidualsAlg::m_sctResidualX
std::vector< int > m_sctResidualX
Definition: IDAlignMonResidualsAlg.h:114
IDAlignMonResidualsAlg::m_sctResidualXvsPhi
std::vector< int > m_sctResidualXvsPhi
Definition: IDAlignMonResidualsAlg.h:126
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
IDAlignMonResidualsAlg::m_sctResidualX_2DProf
std::vector< int > m_sctResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:115
IDAlignMonResidualsAlg::m_applyTrkSel
bool m_applyTrkSel
Definition: IDAlignMonResidualsAlg.h:91
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
Trk::locR
@ locR
Definition: ParamDefs.h:44
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:777
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
IDAlignMonResidualsAlg::m_trtBPullR
std::vector< int > m_trtBPullR
Definition: IDAlignMonResidualsAlg.h:130
IDAlignMonResidualsAlg::m_trtECPullRNoTube
std::vector< int > m_trtECPullRNoTube
Definition: IDAlignMonResidualsAlg.h:142
InDet::TRT_DriftCircleOnTrack
Definition: TRT_DriftCircleOnTrack.h:53
IDAlignMonResidualsAlg::m_sct_s1_ResidualX_2DProf
std::vector< int > m_sct_s1_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:117
IDAlignMonResidualsAlg::m_trtECLRVsPhiSec
std::vector< int > m_trtECLRVsPhiSec
Definition: IDAlignMonResidualsAlg.h:146
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
IDAlignMonResidualsAlg::m_trtBResVsEta
std::vector< std::vector< int > > m_trtBResVsEta
Definition: IDAlignMonResidualsAlg.h:134
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:360
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
IDAlignMonResidualsAlg::m_PIX_Mgr
const InDetDD::PixelDetectorManager * m_PIX_Mgr
Definition: IDAlignMonResidualsAlg.h:69
IDAlignMonResidualsAlg::m_SCT_Mgr
const InDetDD::SCT_DetectorManager * m_SCT_Mgr
Definition: IDAlignMonResidualsAlg.h:70
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
IDAlignMonResidualsAlg::m_sctResidualXvsEta
std::vector< int > m_sctResidualXvsEta
Definition: IDAlignMonResidualsAlg.h:125
IDAlignMonResidualsAlg::m_pixResidualX_2DProf
std::vector< int > m_pixResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:99
IDAlignMonResidualsAlg::m_pixECResidualX_2DProf
std::vector< int > m_pixECResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:110
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
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
IDAlignMonResidualsAlg::m_trtBPullRNoTube
std::vector< int > m_trtBPullRNoTube
Definition: IDAlignMonResidualsAlg.h:132
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
IDAlignMonResidualsAlg::m_pixECAResidualX
std::vector< int > m_pixECAResidualX
Definition: IDAlignMonResidualsAlg.h:108
Monitored::detail::doFill
void doFill(H *hist, W weight, size_t i, const M &m1, const Ms &... m)
Perform (arbitrary dimension) histogram fill with weight.
Definition: HistogramFillerUtils.h:164
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
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:86
IDAlignMonResidualsAlg::m_iUpdator
ToolHandle< Trk::IUpdator > m_iUpdator
Definition: IDAlignMonResidualsAlg.h:79
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
IDAlignMonResidualsAlg::m_pixResidualYvsEta
std::vector< int > m_pixResidualYvsEta
Definition: IDAlignMonResidualsAlg.h:105
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
IDAlignMonResidualsAlg::fillTRTEndcapHistograms
void fillTRTEndcapHistograms(int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool LRcorrect, bool isTubeHit, float trketa, float qpT) const
Definition: IDAlignMonResidualsAlg.cxx:869
IDAlignMonResidualsAlg::m_trtECPullR
std::vector< int > m_trtECPullR
Definition: IDAlignMonResidualsAlg.h:140
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
IDAlignMonResidualsAlg::m_trtBMeasuredR
std::vector< int > m_trtBMeasuredR
Definition: IDAlignMonResidualsAlg.h:128
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IDAlignMonResidualsAlg::m_checkrate
int m_checkrate
Definition: IDAlignMonResidualsAlg.h:89
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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
IDAlignMonResidualsAlg::m_trtECResVsPhiSec
std::vector< int > m_trtECResVsPhiSec
Definition: IDAlignMonResidualsAlg.h:145
IDAlignMonResidualsAlg::m_pixECAResidualY
std::vector< int > m_pixECAResidualY
Definition: IDAlignMonResidualsAlg.h:109
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
IDAlignMonResidualsAlg::m_trtBLR
std::vector< int > m_trtBLR
Definition: IDAlignMonResidualsAlg.h:133
IDAlignMonResidualsAlg::m_sctECA_s1_ResidualX_2DProf
std::vector< int > m_sctECA_s1_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:120
IDAlignMonResidualsAlg::m_trtECPredictedR
std::vector< int > m_trtECPredictedR
Definition: IDAlignMonResidualsAlg.h:137
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
add-xsec-uncert-quadrature-N.results
dictionary results
Definition: add-xsec-uncert-quadrature-N.py:39
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
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
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.
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:545
IDAlignMonResidualsAlg::m_SCT_Manager
std::string m_SCT_Manager
Definition: IDAlignMonResidualsAlg.h:86
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:860
SCT_ID::get_other_side
int get_other_side(const IdentifierHash &id, IdentifierHash &other) const
Wafer hash on other side.
Definition: SCT_ID.cxx:444
IDAlignMonResidualsAlg::m_trtECResVsPt_2DProf
std::vector< int > m_trtECResVsPt_2DProf
Definition: IDAlignMonResidualsAlg.h:147
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:878
IDAlignMonResidualsAlg::m_pixECResidualY_2DProf
std::vector< int > m_pixECResidualY_2DProf
Definition: IDAlignMonResidualsAlg.h:111
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
IDAlignMonResidualsAlg::setupTools
StatusCode setupTools()
Definition: IDAlignMonResidualsAlg.cxx:1060
Trk::MeasurementBase
Definition: MeasurementBase.h:58
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
IDAlignMonResidualsAlg::m_pixResidualX
std::vector< int > m_pixResidualX
Definition: IDAlignMonResidualsAlg.h:98
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:647
IDAlignMonResidualsAlg::m_trtECMeasuredR
std::vector< int > m_trtECMeasuredR
Definition: IDAlignMonResidualsAlg.h:138
AthMonitorAlgorithm::Environment_t::online
@ online
IDAlignMonResidualsAlg::getUnbiasedTrackParameters
std::unique_ptr< Trk::TrackParameters > getUnbiasedTrackParameters(const Trk::Track *, const Trk::TrackStateOnSurface *) const
Definition: IDAlignMonResidualsAlg.cxx:918
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::MeasurementBase::associatedSurface
virtual const Surface & associatedSurface() const =0
Interface method to get the associated Surface.
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
Trk::nonInteracting
@ nonInteracting
Definition: ParticleHypothesis.h:28
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
charge
double charge(const T &p)
Definition: AtlasPID.h:991
IDAlignMonResidualsAlg::m_trtcaldbTool
ToolHandle< ITRT_CalDbTool > m_trtcaldbTool
Definition: IDAlignMonResidualsAlg.h:78
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
IDAlignMonResidualsAlg::m_sct_s0_ResidualX_2DProf
std::vector< int > m_sct_s0_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:116
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
IDAlignMonResidualsAlg::m_nSiBlayers
static const int m_nSiBlayers
Definition: IDAlignMonResidualsAlg.h:93
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:869
IDAlignMonResidualsAlg::m_nTRTBlayers
static const int m_nTRTBlayers
Definition: IDAlignMonResidualsAlg.h:96
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:227
IDAlignMonResidualsAlg::m_extendedPlots
bool m_extendedPlots
Definition: IDAlignMonResidualsAlg.h:87
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
IDAlignMonResidualsAlg::fillTRTBarrelHistograms
void fillTRTBarrelHistograms(int barrel_ec, int layer_or_wheel, int phi_module, float predictR, float hitR, float residualR, float pullR, bool LRcorrect, bool isTubeHit, float trketa) const
Definition: IDAlignMonResidualsAlg.cxx:822
Trk::Surface::associatedLayer
const Trk::Layer * associatedLayer() const
return the associated Layer
IDAlignMonResidualsAlg::m_pixResidualYvsPhi
std::vector< int > m_pixResidualYvsPhi
Definition: IDAlignMonResidualsAlg.h:107
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
IDAlignMonResidualsAlg::m_sctPullX
std::vector< int > m_sctPullX
Definition: IDAlignMonResidualsAlg.h:124
IDAlignMonResidualsAlg::trackRequiresRefit
bool trackRequiresRefit(const Trk::Track *) const
Definition: IDAlignMonResidualsAlg.cxx:1131
IDAlignMonResidualsAlg::m_pixResidualXvsPhi
std::vector< int > m_pixResidualXvsPhi
Definition: IDAlignMonResidualsAlg.h:106
IDAlignMonResidualsAlg::m_trtBResVsPhiSec
std::vector< std::vector< int > > m_trtBResVsPhiSec
Definition: IDAlignMonResidualsAlg.h:135
IDAlignMonResidualsAlg::m_pixResidualY_2DProf
std::vector< int > m_pixResidualY_2DProf
Definition: IDAlignMonResidualsAlg.h:101
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
Trk::ResidualPull::Biased
@ Biased
RP with track state including the hit.
Definition: ResidualPull.h:55
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:360
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
IDAlignMonResidualsAlg::m_trtBResidualRNoTube
std::vector< int > m_trtBResidualRNoTube
Definition: IDAlignMonResidualsAlg.h:131
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
IDAlignMonResidualsAlg::m_trackSelection
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelection
Definition: IDAlignMonResidualsAlg.h:82
IDAlignMonResidualsAlg::m_sctECCResidualX_2DProf
std::vector< int > m_sctECCResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:121
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
Trk::Layer::enclosingTrackingVolume
const TrackingVolume * enclosingTrackingVolume() const
get the confining TrackingVolume
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
IDAlignMonResidualsAlg::m_pixelID
const PixelID * m_pixelID
Definition: IDAlignMonResidualsAlg.h:71
IDAlignMonResidualsAlg::m_sctECC_s1_ResidualX_2DProf
std::vector< int > m_sctECC_s1_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:123
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
IDAlignMonResidualsAlg::m_sctECC_s0_ResidualX_2DProf
std::vector< int > m_sctECC_s0_ResidualX_2DProf
Definition: IDAlignMonResidualsAlg.h:122
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
IDAlignMonResidualsAlg::m_trtID
const TRT_ID * m_trtID
Definition: IDAlignMonResidualsAlg.h:73
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
IDAlignMonResidualsAlg::m_doPulls
bool m_doPulls
Definition: IDAlignMonResidualsAlg.h:90
IDAlignMonResidualsAlg::m_pixResidualXvsEta
std::vector< int > m_pixResidualXvsEta
Definition: IDAlignMonResidualsAlg.h:104
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
IDAlignMonResidualsAlg::m_nSCTEClayers
static const int m_nSCTEClayers
Definition: IDAlignMonResidualsAlg.h:95
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:640
Trk::loc1
@ loc1
Definition: ParamDefs.h:34
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
IDAlignMonResidualsAlg::m_sctID
const SCT_ID * m_sctID
Definition: IDAlignMonResidualsAlg.h:72
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
IDAlignMonResidualsAlg::m_pixResidualY
std::vector< int > m_pixResidualY
Definition: IDAlignMonResidualsAlg.h:100
xAOD::refitTrack
@ refitTrack
Definition: TrackingPrimitives.h:464
IDAlignMonResidualsAlg::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: IDAlignMonResidualsAlg.h:68
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
IDAlignMonResidualsAlg::m_doHitQuality
bool m_doHitQuality
Definition: IDAlignMonResidualsAlg.h:88
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
ServiceHandle< ICondSvc >
collisions
Definition: collisions.py:1
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Sep 29 2025 21:35:55 for ATLAS Offline Software by   doxygen 1.8.18