Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
RpcTrackAnaAlg Class Reference

#include <RpcTrackAnaAlg.h>

Inheritance diagram for RpcTrackAnaAlg:
Collaboration diagram for RpcTrackAnaAlg:

Public Types

typedef std::map< Identifier, std::shared_ptr< RpcPanel > > RpcPanelMap
 
typedef std::pair< ExResult, const std::shared_ptr< GasGapData > > GasGapResult
 
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

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

Protected Member Functions

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

Protected Attributes

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

Private Types

enum  BarrelDL {
  BI = 1, BM1, BM2, BO1,
  BO2, OUT
}
 
enum  MuonSource { AllMuon = 0, ZCand }
 
typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode readElIndexFromXML ()
 
StatusCode initRpcPanel ()
 
StatusCode setPanelIndex (std::shared_ptr< RpcPanel > panel)
 
StatusCode initTrigTag ()
 
StatusCode initArrayHistosMap ()
 
StatusCode fillMuonExtrapolateEff (const EventContext &ctx) const
 
StatusCode fillHistPRD (const EventContext &ctx) const
 
StatusCode triggerMatching (const xAOD::Muon *, const std::vector< TagDef > &) const
 
StatusCode extrapolate2RPC (const xAOD::TrackParticle *track, const Trk::PropDirection direction, std::vector< GasGapResult > &results, BarrelDL barrelDL) const
 
std::unique_ptr< Trk::TrackParameters > computeTrackIntersectionWithGasGap (ExResult &result, const xAOD::TrackParticle *track_particle, const std::shared_ptr< GasGapData > &gap) const
 
StatusCode extrapolate2RPC (std::unique_ptr< Trk::TrackParameters > trackParam, const Trk::PropDirection direction, std::vector< GasGapResult > &results, BarrelDL barrelDL) const
 
std::unique_ptr< Trk::TrackParameters > computeTrackIntersectionWithGasGap (ExResult &result, const Trk::TrackParameters *trackParam, const std::shared_ptr< GasGapData > &gap) const
 
StatusCode readHitsPerGasgap (const EventContext &ctx, std::vector< GasGapResult > &results, MuonSource muon_source) const
 
StatusCode fillClusterSize (std::vector< const Muon::RpcPrepData * > &view_hits, const int panel_index, int LB, int phiSector, int isPhi) const
 
bool IsNearbyHit (const std::vector< const Muon::RpcPrepData * > &cluster_hits, const Muon::RpcPrepData *hit) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

BooleanProperty m_plotMuonEff
 
BooleanProperty m_plotPRD
 
BooleanProperty m_useAODParticle
 
FloatProperty m_lbDuraThr
 
StringProperty m_packageName
 
StringProperty m_elementsFileName
 
StringProperty m_trigTagList
 
FloatProperty m_trigMatchWindow
 
BooleanProperty m_TagAndProbe
 
BooleanProperty m_TagAndProbeZmumu
 
FloatProperty m_minPt {this, "minPt", 25.0e3, "minmum pT of muon"}
 
FloatProperty m_maxEta
 
FloatProperty m_barrelMinPt {this, "barrelMinPt", 2.0e3}
 
FloatProperty m_barrelMinEta {this, "barrelMinEta", 0.1}
 
FloatProperty m_barrelMaxEta {this, "barrelMaxEta", 1.05}
 
FloatProperty m_muonMass
 
FloatProperty m_zMass_lowLimit
 
FloatProperty m_zMass_upLimit
 
FloatProperty m_isolationWindow
 
FloatProperty m_l1trigMatchWindow
 
FloatProperty m_minDRTrackToGasGap
 
FloatProperty m_boundsToleranceReadoutElement
 
FloatProperty m_boundsToleranceReadoutElementTight
 
FloatProperty m_diffHitTrackPostion
 
FloatProperty m_outtime {this, "outtime", 12.5, "the out-time time"}
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
const RpcIdHelper * m_rpcIdHelper {nullptr}
 
ToolHandle< Trk::IExtrapolator > m_extrapolator
 
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_MuonRoIContainerKey
 
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
 
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_rpcPrdKey
 
SG::ReadHandleKey< xAOD::VertexContainer > m_PrimaryVertexContainerKey
 
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaX
 
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaY
 
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaXY
 
RpcPanelMap m_rpcPanelMap {}
 
std::vector< TagDef > m_trigTagDefs {}
 
std::map< std::pair< int, int >, std::vector< std::shared_ptr< GasGapData > > > m_gasGapData {}
 
std::map< BarrelDL, std::vector< int > > m_StationNames {}
 
std::map< std::string, int > m_elementIndex {}
 
std::map< std::string, int > m_SectorGroup {}
 
std::map< std::string, int > m_TriggerThrGroup {}
 
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
 

Detailed Description

Definition at line 38 of file RpcTrackAnaAlg.h.

Member Typedef Documentation

◆ GasGapResult

typedef std::pair<ExResult, const std::shared_ptr<GasGapData> > RpcTrackAnaAlg::GasGapResult

Definition at line 47 of file RpcTrackAnaAlg.h.

◆ MonVarVec_t

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

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ RpcPanelMap

typedef std::map<Identifier, std::shared_ptr<RpcPanel> > RpcTrackAnaAlg::RpcPanelMap

Definition at line 46 of file RpcTrackAnaAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ BarrelDL

enum RpcTrackAnaAlg::BarrelDL
private
Enumerator
BI 
BM1 
BM2 
BO1 
BO2 
OUT 

Definition at line 50 of file RpcTrackAnaAlg.h.

50  {
51  BI = 1,
52  BM1,
53  BM2,
54  BO1,
55  BO2,
56  OUT
57  }; // Barrel doublet: BM_dbR

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

◆ MuonSource

enum RpcTrackAnaAlg::MuonSource
private
Enumerator
AllMuon 
ZCand 

Definition at line 58 of file RpcTrackAnaAlg.h.

58 { AllMuon = 0, ZCand };

Constructor & Destructor Documentation

◆ RpcTrackAnaAlg()

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

Definition at line 30 of file RpcTrackAnaAlg.cxx.

32  : AthMonitorAlgorithm(name, pSvcLocator) {}

◆ ~RpcTrackAnaAlg()

RpcTrackAnaAlg::~RpcTrackAnaAlg ( )
virtual

Definition at line 35 of file RpcTrackAnaAlg.cxx.

35 {}

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 }

◆ computeTrackIntersectionWithGasGap() [1/2]

std::unique_ptr< Trk::TrackParameters > RpcTrackAnaAlg::computeTrackIntersectionWithGasGap ( ExResult &  result,
const Trk::TrackParameters *  trackParam,
const std::shared_ptr< GasGapData > &  gap 
) const
private

Definition at line 1035 of file RpcTrackAnaAlg.cxx.

1037  {
1038  const EventContext& ctx = Gaudi::Hive::currentContext();
1039  /*
1040  This function:
1041  - constructs Identifier for specific gasgap
1042  - extrapolates muon to this gas gap
1043  */
1044 
1045  // Get surface of this gas gap and extrapolate track to this surface
1046  const Trk::SurfaceBounds& bounds = gap->readoutEl->bounds(gap->gapid);
1047  const Trk::PlaneSurface& gapSurface = gap->readoutEl->surface(gap->gapid);
1048  auto detParameters = m_extrapolator->extrapolate(
1049  ctx, *trackParam, gapSurface, result.direction, true, Trk::muon);
1050 
1051  if (!detParameters) {
1052  return detParameters;
1053  }
1054 
1055  //
1056  // Transform global extrapolated track position on surface to local
1057  // coordinates
1058  //
1059  const Amg::Vector3D local3dTrackPosition =
1060  gap->readoutEl->globalToLocalCoords(detParameters->position(),
1061  gap->gapid);
1062  const Amg::Vector2D local2dTrackPosition(local3dTrackPosition.y(),
1063  local3dTrackPosition.z());
1064 
1065  //
1066  // Check if the track position on surface is within tolerable bounds
1067  //
1068  const bool inbounds =
1069  bounds.inside(local2dTrackPosition, m_boundsToleranceReadoutElement,
1070  m_boundsToleranceReadoutElement);
1071  const bool inbounds_tight = bounds.inside(
1072  local2dTrackPosition, m_boundsToleranceReadoutElementTight,
1073  m_boundsToleranceReadoutElementTight);
1074 
1075  result.localTrackPosInBounds = inbounds;
1076  result.localTrackPosInBoundsTight = inbounds_tight;
1077  result.localPos = local3dTrackPosition;
1078  result.globalPos = detParameters->position();
1079 
1080  return detParameters;
1081 }

◆ computeTrackIntersectionWithGasGap() [2/2]

std::unique_ptr< Trk::TrackParameters > RpcTrackAnaAlg::computeTrackIntersectionWithGasGap ( ExResult &  result,
const xAOD::TrackParticle *  track_particle,
const std::shared_ptr< GasGapData > &  gap 
) const
private

Definition at line 866 of file RpcTrackAnaAlg.cxx.

868  {
869  const EventContext& ctx = Gaudi::Hive::currentContext();
870  /*
871  This function:
872  - constructs Identifier for specific gasgap
873  - extrapolates muon to this gas gap
874  */
875 
876  // Get surface of this gas gap and extrapolate track to this surface
877  const Trk::SurfaceBounds& bounds = gap->readoutEl->bounds(gap->gapid);
878  const Trk::PlaneSurface& gapSurface = gap->readoutEl->surface(gap->gapid);
879  std::unique_ptr<Trk::TrackParameters> detParameters{};
880 
881  if (m_useAODParticle) {
882  detParameters = m_extrapolator->extrapolate(
883  ctx, track_particle->perigeeParameters(), gapSurface,
884  result.direction, false, Trk::muon);
885  } else if (track_particle->track()) {
886  detParameters = m_extrapolator->extrapolateTrack(
887  ctx, *(track_particle->track()), gapSurface, result.direction, true,
888  Trk::muon);
889  } else {
890  return detParameters;
891  }
892 
893  if (!detParameters) {
894  return detParameters;
895  }
896 
897  //
898  // Transform global extrapolated track position on surface to local
899  // coordinates
900  //
901  const Amg::Vector3D local3dTrackPosition =
902  gap->readoutEl->globalToLocalCoords(detParameters->position(),
903  gap->gapid);
904  const Amg::Vector2D local2dTrackPosition(local3dTrackPosition.y(),
905  local3dTrackPosition.z());
906 
907  //
908  // Check if the track position on surface is within tolerable bounds
909  //
910  const bool inbounds =
911  bounds.inside(local2dTrackPosition, m_boundsToleranceReadoutElement,
912  m_boundsToleranceReadoutElement);
913  const bool inbounds_tight = bounds.inside(
914  local2dTrackPosition, m_boundsToleranceReadoutElementTight,
915  m_boundsToleranceReadoutElementTight);
916 
917  result.localTrackPosInBounds = inbounds;
918  result.localTrackPosInBoundsTight = inbounds_tight;
919  result.localPos = local3dTrackPosition;
920  result.globalPos = detParameters->position();
921 
922  return detParameters;
923 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

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

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

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

Definition at line 140 of file AthMonitorAlgorithm.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

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

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

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & 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 }

◆ extrapolate2RPC() [1/2]

StatusCode RpcTrackAnaAlg::extrapolate2RPC ( const xAOD::TrackParticle *  track,
const Trk::PropDirection  direction,
std::vector< GasGapResult > &  results,
BarrelDL  barrelDL 
) const
private

Definition at line 756 of file RpcTrackAnaAlg.cxx.

759  {
760  /*
761  get intersections of the muon with the RPC planes
762 
763  Iterate over all valid RPCDetectorElements and RPCReadoutElements:
764  1) compute DR distance between track and center of ReadoutElement
765  if this distance within tolerance - proceed
766  2) Next, compute:
767  -- min DR distance between track and strips within this gas gap
768  -- number of valid eta and phi strips within this gas gap
769  if both results within their tolerances - proceed
770  3) Extrapolate track to the surface of this gas gap:
771  -- Check that extrapolation result valid
772  -- Check that extrapolated position is in the gas gap surface bounds
773  if both within checks valid - then save RPC extrapolation result
774  */
775  int doubletR = 1;
776  if (barrelDL >= OUT) {
777  return StatusCode::SUCCESS;
778  } else if (barrelDL == BM2 || barrelDL == BO2) {
779  doubletR = 2;
780  }
781 
782  using namespace Monitored;
783  auto tool = getGroup(m_packageName);
784 
785  if (!track) {
786  return StatusCode::FAILURE;
787  }
788 
789  std::map<BarrelDL, std::vector<int>>::const_iterator dl_vec_it =
790  m_StationNames.find(barrelDL);
791  if (dl_vec_it == m_StationNames.end()) {
792  return StatusCode::FAILURE;
793  }
794 
795  std::unique_ptr<Trk::TrackParameters> trackParamLayer{};
796  double minDR = 1.0; // A intial value
797 
798  const std::vector<int> dl_vec = dl_vec_it->second;
799  std::vector<int>::const_iterator it_dl = dl_vec.begin();
800  for (; it_dl != dl_vec.end(); ++it_dl) {
801  int stName = *it_dl;
802  std::pair<int, int> st_dbR = std::make_pair(stName, doubletR);
803  std::map<std::pair<int, int>,
804  std::vector<std::shared_ptr<GasGapData>>>::const_iterator
805  gasgapIt = m_gasGapData.find(st_dbR);
806  if (gasgapIt == m_gasGapData.end()) {
807  continue;
808  }
809 
810  //
811  // Iterate over RPC readout elements and compute intersections with each
812  // gas gap
813  //
814  for (const std::shared_ptr<GasGapData>& gap : gasgapIt->second) {
815  ExResult result(gap->gapid, direction);
816 
817  // Compute track distance to the gas gap surface
818  gap->computeTrackDistanceToGasGap(result, *track);
819 
820  if (result.minTrackGasGapDR > m_minDRTrackToGasGap) {
821  continue;
822  }
823 
824  //
825  // Extrapolate track to the gas gap surface and check whether the
826  // track position is in bounds returns new object
827  auto trackParamInGap =
828  computeTrackIntersectionWithGasGap(result, track, gap);
829 
830  if (!trackParamInGap) {
831  continue;
832  }
833 
834  if (!result.localTrackPosInBoundsTight) {
835  continue;
836  }
837 
838  if (result.minTrackGasGapDR < minDR) {
839  minDR = result.minTrackGasGapDR;
840  // new object moved to trackParamLayer; previous trackParamLayer
841  // gets destroyed
842  trackParamLayer = std::move(trackParamInGap);
843  }
844  ATH_MSG_DEBUG(name() << " extrapolated gasgap: " << gap->gapid_str);
845 
846  results.push_back(std::make_pair(result, gap));
847  }
848  }
849 
850  // Go to next layer of doublet
851  BarrelDL nextDL = BarrelDL(barrelDL + 1);
852 
853  // propgate the track parameter of the last doublet
854  // if no track paramater, use the input track
855  if (trackParamLayer != nullptr) {
856  // trackParamLayer used and then goes out of scope to destroy the object
857  return extrapolate2RPC(std::move(trackParamLayer), direction, results,
858  nextDL);
859  } else {
860  return extrapolate2RPC(track, direction, results, nextDL);
861  }
862 }

◆ extrapolate2RPC() [2/2]

StatusCode RpcTrackAnaAlg::extrapolate2RPC ( std::unique_ptr< Trk::TrackParameters >  trackParam,
const Trk::PropDirection  direction,
std::vector< GasGapResult > &  results,
BarrelDL  barrelDL 
) const
private

Definition at line 926 of file RpcTrackAnaAlg.cxx.

929  {
930  /*
931  get intersections of the muon with the RPC planes
932 
933  Iterate over all valid RPCDetectorElements and RPCReadoutElements:
934  1) compute DR distance between track and center of ReadoutElement
935  if this distance within tolerance - proceed
936  2) Next, compute:
937  -- min DR distance between track and strips within this gas gap
938  -- number of valid eta and phi strips within this gas gap
939  if both results within their tolerances - proceed
940  3) Extrapolate track to the surface of this gas gap:
941  -- Check that extrapolation result valid
942  -- Check that extrapolated position is in the gas gap surface bounds
943  if both within checks valid - then save RPC extrapolation result
944  */
945  int doubletR = 1;
946  if (barrelDL >= OUT) {
947  return StatusCode::SUCCESS;
948  } else if (barrelDL == BM2 || barrelDL == BO2) {
949  doubletR = 2;
950  }
951 
952  using namespace Monitored;
953  auto tool = getGroup(m_packageName);
954 
955  if (!trackParam) {
956  return StatusCode::FAILURE;
957  }
958 
959  std::map<BarrelDL, std::vector<int>>::const_iterator dl_vec_it =
960  m_StationNames.find(barrelDL);
961  if (dl_vec_it == m_StationNames.end()) {
962  return StatusCode::FAILURE;
963  }
964 
965  std::unique_ptr<Trk::TrackParameters> trackParamLayer{};
966  double minDR = 1.0; // A intial value
967 
968  const std::vector<int> dl_vec = dl_vec_it->second;
969 
970  std::vector<int>::const_iterator it_dl = dl_vec.begin();
971  for (; it_dl != dl_vec.end(); ++it_dl) {
972  int stName = *it_dl;
973  std::pair<int, int> st_dbR = std::make_pair(stName, doubletR);
974  std::map<std::pair<int, int>,
975  std::vector<std::shared_ptr<GasGapData>>>::const_iterator
976  gasgapIt = m_gasGapData.find(st_dbR);
977 
978  if (gasgapIt == m_gasGapData.end()) {
979  continue;
980  }
981 
982  //
983  // Iterate over RPC readout elements and compute intersections with each
984  // gas gap
985  //
986  for (const std::shared_ptr<GasGapData>& gap : gasgapIt->second) {
987  ExResult result(gap->gapid, direction);
988 
989  // Compute track distance to the gas gap surface; doesnt take
990  // ownership
991  gap->computeTrackDistanceToGasGap(result, trackParam.get());
992 
993  if (result.minTrackGasGapDR > m_minDRTrackToGasGap) {
994  continue;
995  }
996 
997  //
998  // Extrapolate track to the gas gap surface and check whether the
999  // track position is in bounds; doesnt take ownership but returns a
1000  // new object
1001  auto trackParamInGap = computeTrackIntersectionWithGasGap(
1002  result, trackParam.get(), gap);
1003  if (trackParamInGap == nullptr) {
1004  continue;
1005  }
1006 
1007  if (!result.localTrackPosInBoundsTight) {
1008  continue;
1009  }
1010 
1011  ATH_MSG_DEBUG(name() << " extrapolated gasgap: " << gap->gapid_str);
1012 
1013  if (result.minTrackGasGapDR < minDR) {
1014  minDR = result.minTrackGasGapDR;
1015  // previously created trackParamInGap moved to trackParamLayer;
1016  // previous trackParamLayer deleted
1017  trackParamLayer = std::move(trackParamInGap);
1018  }
1019 
1020  results.push_back(std::make_pair(result, gap));
1021  }
1022  }
1023 
1024  if (trackParamLayer == nullptr) {
1025  trackParamLayer = std::move(trackParam);
1026  }
1027  BarrelDL nextDL = BarrelDL(barrelDL + 1);
1028  // trackParamLayer used and then goes out of scope, destroying the object
1029  return extrapolate2RPC(std::move(trackParamLayer), direction, results,
1030  nextDL);
1031 }

◆ fillClusterSize()

StatusCode RpcTrackAnaAlg::fillClusterSize ( std::vector< const Muon::RpcPrepData * > &  view_hits,
const int  panel_index,
int  LB,
int  phiSector,
int  isPhi 
) const
private

Definition at line 1343 of file RpcTrackAnaAlg.cxx.

1345  {
1346  using namespace Monitored;
1347 
1348  auto tool = getGroup(m_packageName);
1349  auto i_LB = Scalar<int>("LB_nrpchit", LB);
1350 
1351  // Make clusters from hits that are close together in space and time
1352  std::vector<const Muon::RpcPrepData*> cluster_hits;
1353  while (!view_hits.empty()) {
1354  cluster_hits.clear();
1355 
1356  // Seed cluster with first (random) hit
1357  cluster_hits.push_back(view_hits.back());
1358 
1359  // Erase the selected first hit from the list
1360  view_hits.pop_back();
1361 
1362  // Collect all other hits which are close to the selected hit in time
1363  // and space
1364  std::vector<const Muon::RpcPrepData*>::const_iterator hit =
1365  view_hits.begin();
1366 
1367  while (hit != view_hits.end()) {
1368  const Muon::RpcPrepData* hit_ptr = *hit;
1369 
1370  if (IsNearbyHit(cluster_hits, hit_ptr)) {
1371  cluster_hits.push_back(*hit);
1372  view_hits.erase(hit);
1373 
1374  // Start loop from the beginning since we have increased cluster
1375  // size
1376  hit = view_hits.begin();
1377  } else {
1378  ++hit;
1379  }
1380  }
1381 
1382  int cluster_size = cluster_hits.size();
1383  for (int i_hit = 0; i_hit < cluster_size; i_hit++) {
1384  auto i_phiSector = Scalar<int>("PhiSector", phiSector);
1385  fill(tool, i_LB, i_phiSector);
1386  }
1387 
1388  auto i_panelIndex = Scalar<int>("panelInd_clust", panel_index);
1389  auto i_clusterSize = Scalar<int>("clusterSize", cluster_size);
1390  fill(tool, i_panelIndex, i_clusterSize);
1391 
1392  auto i_cs_sec = Scalar<int>("cs_sec", cluster_size);
1393  fill(m_tools[m_SectorGroup.at("sector" +
1394  std::to_string(std::abs(phiSector)))],
1395  i_cs_sec);
1396 
1397  if (isPhi == 1) {
1398  auto i_clusterSize_view =
1399  Scalar<int>("clusterSize_phi", cluster_size);
1400  fill(tool, i_clusterSize_view);
1401  } else {
1402  auto i_clusterSize_view =
1403  Scalar<int>("clusterSize_eta", cluster_size);
1404  fill(tool, i_clusterSize_view);
1405  }
1406  }
1407 
1408  return StatusCode::SUCCESS;
1409 }

◆ fillHistograms()

StatusCode RpcTrackAnaAlg::fillHistograms ( const EventContext &  ctx) const
overridevirtual

adds event to the monitoring histograms

User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 306 of file RpcTrackAnaAlg.cxx.

306  {
307  using namespace Monitored;
308 
309  if (m_plotMuonEff) {
310  ATH_CHECK(fillMuonExtrapolateEff(ctx));
311  }
312 
313  if (m_plotPRD) {
314  ATH_CHECK(fillHistPRD(ctx));
315  }
316 
317  auto tool = getGroup(m_packageName);
318  auto evtLB = Scalar<int>("evtLB", ctx.eventID().lumi_block());
319  auto run = Scalar<int>("run", ctx.eventID().run_number());
320  fill(tool, evtLB, run);
321 
322  return StatusCode::SUCCESS;
323 }

◆ fillHistPRD()

StatusCode RpcTrackAnaAlg::fillHistPRD ( const EventContext &  ctx) const
private

Definition at line 616 of file RpcTrackAnaAlg.cxx.

616  {
617  using namespace Monitored;
618  //
619  // Read RPC Prepare data
620  //
621 
622  SG::ReadHandle<Muon::RpcPrepDataContainer> rpcContainer(m_rpcPrdKey, ctx);
623  const RpcIdHelper& rpcIdHelper = m_idHelperSvc->rpcIdHelper();
624 
625  const int i_lb = ctx.eventID().lumi_block();
626  std::vector<double> v_prdTime = {};
627 
628  auto prd_sec_all = Scalar<int>("prd_sec", 0);
629  auto prd_layer_all = Scalar<int>("prd_layer", 0);
630  auto prd_sec_1214 = Scalar<int>("prd_sec_1214", 0);
631  auto prd_layer_1214 = Scalar<int>("prd_layer_1214", 0);
632 
633  auto prd_sec_all_eta = Scalar<int>("prd_sec_eta", 0);
634  auto prd_layer_all_eta = Scalar<int>("prd_layer_eta", 0);
635  auto prd_sec_all_phi = Scalar<int>("prd_sec_phi", 0);
636  auto prd_layer_all_phi = Scalar<int>("prd_layer_phi", 0);
637 
638  auto i_prd_LB = Scalar<int>("LB", i_lb);
639  auto i_panelIndex = Scalar<int>("panelInd", -1);
640 
641  auto tool = getGroup(m_packageName);
642 
643  int panel_index;
644  std::pair<int, int> sec_layer;
645 
646  //
647  // loop on RpcPrepData container
648  //
649  for (const Muon::RpcPrepDataCollection* rpcCollection : *rpcContainer) {
650  //
651  // loop on RpcPrepData
652  //
653  for (const Muon::RpcPrepData* rpcData : *rpcCollection) {
654 
655  Identifier id = rpcData->identify();
656  const int measphi = rpcIdHelper.measuresPhi(id);
657 
658  auto temp_panel = std::make_unique<RpcPanel>(
659  *m_idHelperSvc, rpcData->detectorElement(),
660  rpcIdHelper.doubletZ(id), rpcIdHelper.doubletPhi(id),
661  rpcIdHelper.gasGap(id), rpcIdHelper.measuresPhi(id));
662 
663  std::map<Identifier, std::shared_ptr<RpcPanel>>::const_iterator
664  i_panel = m_rpcPanelMap.find(temp_panel->panelId);
665  if (i_panel == m_rpcPanelMap.end()) {
666  ATH_MSG_WARNING(
667  "The panelID corresponding prd hit does NOT link to a "
668  "known Panel "
669  << m_idHelperSvc->toString(id) << " <"
670  << m_idHelperSvc->toString(
671  rpcData->detectorElement()->identify())
672  << "> !!!");
673  continue;
674  } else {
675  panel_index = i_panel->second->panel_index;
676  }
677 
678  sec_layer = temp_panel->getSectorLayer();
679  prd_sec_all = sec_layer.first;
680  prd_layer_all = sec_layer.second;
681 
682  if (std::abs(sec_layer.first) == 12 ||
683  std::abs(sec_layer.first) == 14) {
684  prd_sec_1214 = sec_layer.first;
685  prd_layer_1214 = sec_layer.second;
686  }
687 
688  fill(tool, prd_sec_all, prd_layer_all, prd_sec_1214,
689  prd_layer_1214);
690 
691  if (measphi == 0) {
692  prd_sec_all_eta = sec_layer.first;
693  prd_layer_all_eta = sec_layer.second;
694  fill(tool, prd_sec_all_eta, prd_layer_all_eta);
695  } else {
696  prd_sec_all_phi = sec_layer.first;
697  prd_layer_all_phi = sec_layer.second;
698  fill(tool, prd_sec_all_phi, prd_layer_all_phi);
699  }
700 
701  i_panelIndex = panel_index;
702  fill(tool, i_prd_LB, i_panelIndex);
703 
704  v_prdTime.push_back(rpcData->time());
705  } // loop on RpcPrepData
706  } // loop on RpcPrepData container
707 
708  auto prdTimeCollection = Collection("prdTime", v_prdTime);
709  fill(tool, prdTimeCollection);
710 
711  ATH_MSG_DEBUG(" fillHistPRD finished ");
712  return StatusCode::SUCCESS;
713 }

◆ fillMuonExtrapolateEff()

StatusCode RpcTrackAnaAlg::fillMuonExtrapolateEff ( const EventContext &  ctx) const
private

Definition at line 326 of file RpcTrackAnaAlg.cxx.

327  {
328  using namespace Monitored;
329  auto tool = getGroup(m_packageName);
330 
331  //
332  // read PrimaryVertex Z
333  //
334  const xAOD::Vertex* primVertex = nullptr;
335  if (!m_PrimaryVertexContainerKey.empty()) {
336  SG::ReadHandle<xAOD::VertexContainer> primVtxContainer(
337  m_PrimaryVertexContainerKey, ctx);
338  if (primVtxContainer.isValid()) {
339  for (const auto vtx : *primVtxContainer) {
340  if (vtx->vertexType() == xAOD::VxType::VertexType::PriVtx) {
341  primVertex = vtx;
342  break;
343  }
344  }
345  }
346  }
347  const double primaryVertexZ = primVertex ? (primVertex->z()) : (-999);
348 
349  //
350  // read beam position sigma from eventinfo
351  //
352  SG::ReadDecorHandle<xAOD::EventInfo, float> beamSigmaX(m_beamSigmaX, ctx);
353  SG::ReadDecorHandle<xAOD::EventInfo, float> beamSigmaY(m_beamSigmaY, ctx);
354  SG::ReadDecorHandle<xAOD::EventInfo, float> beamSigmaXY(m_beamSigmaXY, ctx);
355 
356  const float beamPosSigmaX = beamSigmaX(0);
357  const float beamPosSigmaY = beamSigmaY(0);
358  const float beamPosSigmaXY = beamSigmaXY(0);
359 
360  //
361  // read muon
362  //
363  SG::ReadHandle<xAOD::MuonContainer> muons(m_MuonContainerKey, ctx);
364  ATH_MSG_DEBUG(" muons size = " << muons->size());
365 
366  if (!muons.isValid()) {
367  ATH_MSG_ERROR("evtStore() does not contain muon Collection with name "
368  << m_MuonContainerKey);
369  return StatusCode::FAILURE;
370  }
371 
372  //
373  // select out tag and probe muons
374  //
375  std::vector<std::shared_ptr<MyMuon>> tagmuons;
376  std::vector<std::shared_ptr<MyMuon>> probemuons;
377  for (const xAOD::Muon* muon : *muons) {
378  if (std::abs(muon->eta()) > m_maxEta)
379  continue;
380 
381  auto mymuon = std::make_shared<MyMuon>();
382  mymuon->muon = muon;
383  mymuon->fourvec.SetPtEtaPhiM(muon->pt(), muon->eta(), muon->phi(),
384  m_muonMass.value());
385  mymuon->tagged =
386  triggerMatching(muon, m_trigTagDefs) == StatusCode::SUCCESS;
387 
388  // muon quality
389  if (muon->quality() > xAOD::Muon::Medium)
390  continue;
391 
392  //
393  // calculate muon z0sin(\theta) and d0significance
394  auto track = muon->primaryTrackParticle();
395  const double z0 = track->z0() + track->vz() - primaryVertexZ;
396 
397  double z0sin = z0 * std::sin(track->theta());
398  double d0sig = xAOD::TrackingHelpers::d0significance(
399  track, beamPosSigmaX, beamPosSigmaY, beamPosSigmaXY);
400 
401  // select probe muons
402  if (std::abs(z0sin) < 0.5 && std::abs(d0sig) < 3.0) {
403  mymuon->tagProbeOK = true;
404  }
405  probemuons.push_back(mymuon);
406 
407  // select tag muons
408  if (muon->pt() > 27.0e3 && std::abs(z0sin) < 1.0 &&
409  std::abs(d0sig) < 5.0) {
410  tagmuons.push_back(mymuon);
411  }
412  }
413 
414  //
415  // Z tag & probe
416  //
417  for (const auto& tag_muon : tagmuons) {
418  if (!(tag_muon->tagged))
419  continue;
420 
421  for (const auto& probe_muon : probemuons) {
422  if (tag_muon->muon == probe_muon->muon)
423  continue;
424 
425  // probe muon
426  if (!probe_muon->tagProbeOK)
427  continue;
428 
429  // Opposite charge
430  if (tag_muon->muon->charge() == probe_muon->muon->charge())
431  continue;
432 
433  // Z mass window
434  float dimuon_mass = (tag_muon->fourvec + probe_muon->fourvec).M();
435  if (dimuon_mass < m_zMass_lowLimit || dimuon_mass > m_zMass_upLimit)
436  continue;
437 
438  // angular separation
439  float dr = (tag_muon->fourvec).DeltaR(probe_muon->fourvec);
440  if (dr < m_isolationWindow)
441  continue;
442 
443  probe_muon->tagProbeAndZmumuOK = true;
444  }
445  }
446 
447  //
448  // read rois: raw LVL1MuonRoIs
449  //
450  std::vector<const xAOD::MuonRoI*> roisBarrel;
451  if (!m_MuonRoIContainerKey.empty()) {
452  SG::ReadHandle<xAOD::MuonRoIContainer> muonRoIs(m_MuonRoIContainerKey,
453  ctx);
454 
455  if (!muonRoIs.isValid()) {
456  ATH_MSG_ERROR(
457  "evtStore() does not contain muon L1 ROI Collection with name "
458  << m_MuonRoIContainerKey);
459  return StatusCode::FAILURE;
460  }
461  const xAOD::MuonRoIContainer* rois = muonRoIs.cptr();
462 
463  std::vector<float> roiEtaVec{}, roiBarrelEtaVec{};
464  std::vector<int> roiBarrelThrVec{};
465 
466  roiEtaVec.reserve(muonRoIs->size());
467  roiBarrelEtaVec.reserve(muonRoIs->size());
468  roiBarrelThrVec.reserve(muonRoIs->size());
469  roisBarrel.reserve(muonRoIs->size());
470  for (const xAOD::MuonRoI* roi : *rois) {
471  roiEtaVec.push_back(roi->eta());
472  if (roi->getSource() != xAOD::MuonRoI::RoISource::Barrel)
473  continue;
474 
475  roiBarrelEtaVec.push_back(roi->eta());
476  roiBarrelThrVec.push_back(roi->getThrNumber());
477  roisBarrel.push_back(roi);
478  }
479 
480  auto roiEtaCollection = Collection("roiEta", roiEtaVec);
481  auto roiBarrelEtaCollection =
482  Collection("roiBarrelEta", roiBarrelEtaVec);
483  auto roiBarrelThrCollection =
484  Collection("roiBarrelThr", roiBarrelThrVec);
485  fill(tool, roiEtaCollection);
486  fill(tool, roiBarrelEtaCollection);
487  fill(tool, roiBarrelThrCollection);
488  }
489 
490  //
491  // Fill Lv1 trigger efficiency
492  // Fill muon detection efficiency
493  auto i_pt_allMu = Scalar<double>("muPt_allMu", 0.);
494  auto i_eta_allMu = Scalar<double>("muEta_allMu", 0.);
495  auto i_phi_allMu = Scalar<double>("muPhi_allMu", 0.);
496  auto i_pt_zMu = Scalar<double>("muPt_MuonFromZ", 0.);
497  auto i_eta_zMu = Scalar<double>("muEta_MuonFromZ", 0.);
498  auto i_phi_zMu = Scalar<double>("muPhi_MuonFromZ", 0.);
499  auto i_eta_zMu_p =
500  Scalar<double>("muEta_p_MuonFromZ",
501  0.); // kine variable at the plateau of pt turn-on curve
502  auto i_phi_zMu_p =
503  Scalar<double>("muPhi_p_MuonFromZ",
504  0.); // kine variable at the plateau of pt turn-on curve
505 
506  std::vector<GasGapResult> results;
507  int nmuon{0}, nmuon_barrel{0};
508  for (const auto& probe_muon : probemuons) {
509  nmuon++;
510  double pt = probe_muon->muon->pt();
511  double eta = probe_muon->muon->eta();
512  double phi = probe_muon->muon->phi();
513 
514  // barrel muon
515  if (std::abs(eta) < m_barrelMinEta || std::abs(eta) > m_barrelMaxEta)
516  continue;
517  nmuon_barrel++;
518 
519  // has MuonSpectrometerTrackParticle
520  const xAOD::TrackParticle* track = probe_muon->muon->trackParticle(
521  xAOD::Muon::MuonSpectrometerTrackParticle);
522  if (track) {
523  results.clear();
524 
525  ATH_CHECK(extrapolate2RPC(track, Trk::anyDirection, results, BI));
526  ATH_CHECK(readHitsPerGasgap(ctx, results, AllMuon));
527  }
528 
529  // fill kine variables for probe muons
530  i_pt_allMu = pt;
531  i_eta_allMu = eta;
532  i_phi_allMu = phi;
533  fill(tool, i_pt_allMu, i_eta_allMu, i_phi_allMu);
534 
535  //
536  // Probe muons with Z tag&probe method
537  // 1) Plot L1 trigger efficiency use probe muons
538  // 2) Plot muon detection efficiency use probe muons
539  if (probe_muon->tagProbeAndZmumuOK) {
540  //
541  // do match muon with ROI
542  std::vector<bool> isMatcheds(6, 0);
543  for (const xAOD::MuonRoI* roi : roisBarrel) {
544  const double dphi = TVector2::Phi_mpi_pi(roi->phi() - phi);
545  const double deta = roi->eta() - eta;
546  const double dr = std::hypot(dphi, deta);
547 
548  if (dr > m_l1trigMatchWindow)
549  continue;
550 
551  int thr = std::min(7, roi->getThrNumber());
552  for (int i_thr = 1; i_thr <= thr; i_thr++) {
553  isMatcheds[i_thr - 1] = true;
554  }
555  }
556 
557  //
558  // fill L1 trigger Efficiency
559  auto i_pt = Scalar<double>("muPt_l1", pt);
560  auto i_eta = Scalar<double>("muEta_l1", eta);
561  auto i_phi = Scalar<double>("muPhi_l1", phi);
562  auto i_passTrigger = Scalar<bool>("passTrigger", false);
563  auto i_passTrigger_1 = Scalar<bool>("passTrigger_plateau", false);
564 
565  for (int i_thr = 1; i_thr < 7; i_thr++) {
566  i_passTrigger = isMatcheds[i_thr - 1];
567  i_passTrigger_1 = isMatcheds[i_thr - 1];
568 
569  // plot L1 trigger pt turn-on curve
570  fill(m_tools[m_TriggerThrGroup.at("thr" +
571  std::to_string(i_thr))],
572  i_pt, i_passTrigger);
573 
574  // plot L1 trigger efficiency on the plateau of pt turn-on curve
575  if (std::abs(pt) > m_minPt) {
576  fill(m_tools[m_TriggerThrGroup.at("thr" +
577  std::to_string(i_thr))],
578  i_eta, i_phi, i_passTrigger_1);
579  }
580  }
581 
582  //
583  // muon track
584  // fill muon detection Efficiency
585  //
586  if (track) {
587  ATH_CHECK(readHitsPerGasgap(ctx, results, ZCand));
588  }
589 
590  // fill kine variables for probe muons in ZTP
591  i_pt_zMu = pt;
592  i_eta_zMu = eta;
593  i_phi_zMu = phi;
594  fill(tool, i_pt_zMu, i_eta_zMu, i_phi_zMu);
595 
596  if (std::abs(pt) > m_minPt) {
597  i_eta_zMu_p = eta;
598  i_phi_zMu_p = phi;
599  fill(tool, i_eta_zMu_p, i_phi_zMu_p);
600  }
601  } // tagProbeAndZmumuOK
602  } // probemuons
603 
604  auto Nmuon = Scalar<int>("nMu", nmuon);
605  auto Nmuon_barrel = Scalar<int>("nMuBarrel", nmuon_barrel);
606 
607  //
608  // Fill histograms
609  //
610  fill(tool, Nmuon, Nmuon_barrel);
611 
612  return StatusCode::SUCCESS;
613 }

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ GetEventInfo()

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

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

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

Definition at line 107 of file AthMonitorAlgorithm.cxx.

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 164 of file AthMonitorAlgorithm.cxx.

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

◆ getTrigDecisionTool()

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

Get the trigger decision tool member.

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

Returns
m_trigDecTool

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ initArrayHistosMap()

StatusCode RpcTrackAnaAlg::initArrayHistosMap ( )
private

◆ initialize()

StatusCode RpcTrackAnaAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 38 of file RpcTrackAnaAlg.cxx.

38  {
39  ATH_MSG_INFO(" RpcTrackAnaAlg initialize begin ");
40  ATH_CHECK(AthMonitorAlgorithm::initialize());
41 
42  ATH_CHECK(m_idHelperSvc.retrieve());
43  ATH_CHECK(m_beamSigmaX.initialize());
44  ATH_CHECK(m_beamSigmaY.initialize());
45  ATH_CHECK(m_beamSigmaXY.initialize());
46 
47  ATH_CHECK(m_MuonRoIContainerKey.initialize(SG::AllowEmpty));
48  ATH_CHECK(m_MuonContainerKey.initialize());
49  ATH_CHECK(m_rpcPrdKey.initialize());
50  ATH_CHECK(m_PrimaryVertexContainerKey.initialize(SG::AllowEmpty));
51 
52  ATH_CHECK(readElIndexFromXML());
53  ATH_CHECK(initRpcPanel());
54 
55  ATH_CHECK(initTrigTag());
56 
57  std::vector<std::string> sectorStr = {
58  "sector1", "sector2", "sector3", "sector4", "sector5", "sector6",
59  "sector7", "sector8", "sector9", "sector10", "sector11", "sector12",
60  "sector13", "sector14", "sector15", "sector16"};
61  m_SectorGroup =
62  Monitored::buildToolMap<int>(m_tools, "RpcTrackAnaAlg", sectorStr);
63 
64  std::vector<std::string> triggerThrs = {"thr1", "thr2", "thr3",
65  "thr4", "thr5", "thr6"};
66  m_TriggerThrGroup =
67  Monitored::buildToolMap<int>(m_tools, "RpcTrackAnaAlg", triggerThrs);
68 
69  ATH_MSG_INFO(" initialize extrapolator ");
70  ATH_CHECK(m_extrapolator.retrieve());
71 
72  ATH_MSG_INFO(" RpcTrackAnaAlg initialize END ");
73  return StatusCode::SUCCESS;
74 }

◆ initRpcPanel()

StatusCode RpcTrackAnaAlg::initRpcPanel ( )
private

Definition at line 77 of file RpcTrackAnaAlg.cxx.

77  {
78  /*
79  Iterate over all RpcDetectorElements and RpcReadoutElements
80  and cache locally all panel
81  */
82  ATH_MSG_INFO(name() << " - RpcTrackAnaAlg::initRpcPanel - start");
83 
84  unsigned int nValidPanel = 0, nTriedPanel{0};
85  const RpcIdHelper& rpcIdHelper = m_idHelperSvc->rpcIdHelper();
86  const MuonGM::MuonDetectorManager* muonMgr{nullptr};
87  ATH_CHECK(detStore()->retrieve(muonMgr));
88 
89  ATH_MSG_INFO("MuonGM::MuonDetectorManager::RpcDetElMaxHash= "
90  << rpcIdHelper.module_hash_max());
91 
92  m_StationNames[BI] = {};
93  m_StationNames[BM1] = {2, 3, 8, 53}; // doubletR = 1
94  m_StationNames[BM2] = {2, 3, 8, 53}; // doubletR = 2
95  m_StationNames[BO1] = {4, 5, 9, 10}; // doubletR = 1
96  m_StationNames[BO2] = {4, 5, 9, 10}; // doubletR = 2
97 
98  std::vector<int> BMBO_StationNames = {2, 3, 4, 5, 8, 9, 10, 53};
99  for (auto idetEl = rpcIdHelper.detectorElement_begin();
100  idetEl != rpcIdHelper.detectorElement_end(); ++idetEl) {
101  const MuonGM::RpcReadoutElement* readoutEl = muonMgr->getRpcReadoutElement(*idetEl);
102  if (!readoutEl)
103  continue;
104 
105  const unsigned int ngasgap = 2;
106  const unsigned int doubletZ = readoutEl->getDoubletZ();
107  if (readoutEl->getDoubletPhi() != 1) {
108  continue;
109  }
110 
111  const Identifier readEl_id = readoutEl->identify();
112 
113  int stName = rpcIdHelper.stationName(readEl_id);
114 
115  if (!std::count(BMBO_StationNames.begin(), BMBO_StationNames.end(),
116  stName)) {
117  continue; // Will be changed to include BIS
118  }
119 
120  if (!std::count(BMBO_StationNames.begin(), BMBO_StationNames.end(),
121  stName)) {
122  continue; // Will be changed to include BIS
123  }
124 
125  for (unsigned doubletPhi = 1; doubletPhi <= 2; ++doubletPhi) {
126  for (unsigned gasgap = 1; gasgap <= ngasgap; ++gasgap) {
127  std::shared_ptr<GasGapData> gap = std::make_shared<GasGapData>(
128  *m_idHelperSvc, readoutEl, doubletZ, doubletPhi, gasgap);
129 
130  std::pair<int, int> st_dbR = std::make_pair(stName, gap->doubletR);
131  m_gasGapData[st_dbR].push_back(gap);
132 
133  std::shared_ptr<RpcPanel> rpcPanel_eta = std::make_shared<RpcPanel>(
134  *m_idHelperSvc, readoutEl, doubletZ, doubletPhi, gasgap, 0);
135  ATH_CHECK(setPanelIndex(rpcPanel_eta));
136 
137  std::shared_ptr<RpcPanel> rpcPanel_phi = std::make_shared<RpcPanel>(
138  *m_idHelperSvc, readoutEl, doubletZ, doubletPhi, gasgap, 1);
139  ATH_CHECK(setPanelIndex(rpcPanel_phi));
140 
141  if (rpcPanel_eta->panel_valid) {
142  ATH_MSG_DEBUG(" Panel stationName:"
143  << rpcPanel_eta->stationName
144  << " stationEta:" << rpcPanel_eta->stationEta
145  << " stationPhi:" << rpcPanel_eta->stationPhi
146  << " doubletR:" << rpcPanel_eta->doubletR
147  << "doubletZ:" << rpcPanel_eta->doubletZ
148  << " doubletPhi:" << rpcPanel_eta->doubletPhi
149  << " gasGap:" << rpcPanel_eta->gasGap
150  << " measPhi:" << rpcPanel_eta->measPhi);
151 
152  m_rpcPanelMap.insert(
153  std::map<Identifier, std::shared_ptr<RpcPanel>>::value_type(
154  rpcPanel_eta->panelId, rpcPanel_eta));
155  nValidPanel++;
156  }
157 
158  if (rpcPanel_phi->panel_valid) {
159  ATH_MSG_DEBUG(" Panel stationName:"
160  << rpcPanel_phi->stationName
161  << " stationEta:" << rpcPanel_phi->stationEta
162  << " stationPhi:" << rpcPanel_phi->stationPhi
163  << " doubletR:" << rpcPanel_phi->doubletR
164  << "doubletZ:" << rpcPanel_phi->doubletZ
165  << " doubletPhi:" << rpcPanel_phi->doubletPhi
166  << " gasGap:" << rpcPanel_phi->gasGap
167  << " measPhi:" << rpcPanel_phi->measPhi);
168 
169  m_rpcPanelMap.insert(
170  std::map<Identifier, std::shared_ptr<RpcPanel>>::value_type(
171  rpcPanel_phi->panelId, rpcPanel_phi));
172  nValidPanel++;
173  }
174 
175  gap->RpcPanel_eta_phi = std::make_pair(rpcPanel_eta, rpcPanel_phi);
176  ++nTriedPanel;
177  }
178  }
179  }
180 
181  ATH_MSG_INFO("Number of valid panels = " << nValidPanel << " tried panels "
182  << nTriedPanel);
183  return StatusCode::SUCCESS;
184 }

◆ initTrigTag()

StatusCode RpcTrackAnaAlg::initTrigTag ( )
private

Definition at line 280 of file RpcTrackAnaAlg.cxx.

280  {
281  TString trigStr = m_trigTagList.value();
282  std::unique_ptr<TObjArray> tagList(trigStr.Tokenize(";"));
283 
284  // TObjArray* tagList = TString(m_trigTagList.value()).Tokenize(",");
285  std::set<TString> alllist;
286  for (int i = 0; i < tagList->GetEntries(); i++) {
287  TString tagTrig = tagList->At(i)->GetName();
288  if (alllist.find(tagTrig) != alllist.end())
289  continue;
290  alllist.insert(tagTrig);
291  std::unique_ptr<TObjArray> arr(tagTrig.Tokenize(";"));
292  if (arr->GetEntries() == 0)
293  continue;
294  TagDef def;
295  def.eventTrig = TString(arr->At(0)->GetName());
296  def.tagTrig = def.eventTrig;
297  if (arr->GetEntries() == 2)
298  def.tagTrig = TString(arr->At(1)->GetName());
299  m_trigTagDefs.push_back(def);
300  }
301 
302  return StatusCode::SUCCESS;
303 }

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

◆ IsNearbyHit()

bool RpcTrackAnaAlg::IsNearbyHit ( const std::vector< const Muon::RpcPrepData * > &  cluster_hits,
const Muon::RpcPrepData *  hit 
) const
private

Definition at line 1412 of file RpcTrackAnaAlg.cxx.

1414  {
1415  const RpcIdHelper& rpcIdHelper = m_idHelperSvc->rpcIdHelper();
1416 
1417  // Check whether this hit is close to any hits in the cluster
1418  for (const Muon::RpcPrepData* it_hit : cluster_hits) {
1419  if (abs(rpcIdHelper.strip(it_hit->identify()) -
1420  rpcIdHelper.strip(hit->identify())) < 2 &&
1421  std::abs(it_hit->time() - hit->time()) < 6.5) {
1422  return true;
1423  }
1424  }
1425 
1426  return false;
1427 }

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

◆ readElIndexFromXML()

StatusCode RpcTrackAnaAlg::readElIndexFromXML ( )
private

Definition at line 216 of file RpcTrackAnaAlg.cxx.

216  {
217  /*
218  Read xml file in share/Element.xml to give each element(in the afterwards,
219  for panel) a index
220  */
221  ATH_MSG_INFO(name() << " - read element index ");
222 
223  //
224  // Read xml file
225  //
226  const std::string xml_file =
227  PathResolver::find_file(m_elementsFileName, "DATAPATH");
228  if (xml_file.empty()) {
229  ATH_MSG_ERROR(m_elementsFileName << " not found!");
230  return StatusCode::FAILURE;
231  }
232 
233  ATH_MSG_INFO(name() << " - read xml file: " << xml_file);
234 
235  boost::property_tree::ptree pt;
236  read_xml(xml_file, pt);
237 
238  for (boost::property_tree::ptree::value_type& child:
239  pt.get_child("Elements")) {
240  if (child.first == "Element") {
241  int index = child.second.get<int>("<xmlattr>.index");
242  int stName = child.second.get<int>("<xmlattr>.stationName");
243  int stEta = child.second.get<int>("<xmlattr>.stationEta");
244  int stPhi = child.second.get<int>("<xmlattr>.stationPhi");
245  int dbR = child.second.get<int>("<xmlattr>.doubletR");
246  int dbZ = child.second.get<int>("<xmlattr>.doubletZ");
247 
248  ATH_MSG_DEBUG(" index = " << index << ", stationName = " << stName
249  << ", stationEta = " << stEta
250  << ", stationPhi = " << stPhi
251  << ", doubletR = " << dbR
252  << ", doubletZ = " << dbZ);
253  std::ostringstream ele_key;
254 
255  ele_key << stName << "_" << stEta << "_" << stPhi << "_" << dbR
256  << "_" << dbZ;
257 
258  std::map<std::string, int>::iterator it_eleInd =
259  m_elementIndex.find(ele_key.str());
260  if (it_eleInd == m_elementIndex.end()) {
261  m_elementIndex.insert(std::map<std::string, int>::value_type(
262  ele_key.str(), index));
263  } else {
264  ATH_MSG_ERROR("These is duplicated elements");
265  }
266  } else {
267  ATH_MSG_ERROR(" node key != Element");
268  }
269  }
270 
271  ATH_MSG_INFO(
272  "Total number of elements: "
273  << m_elementIndex.size()
274  << ", should be consistent with the number of elements in xml file!");
275 
276  return StatusCode::SUCCESS;
277 }

◆ readHitsPerGasgap()

StatusCode RpcTrackAnaAlg::readHitsPerGasgap ( const EventContext &  ctx,
std::vector< GasGapResult > &  results,
MuonSource  muon_source 
) const
private

Definition at line 1084 of file RpcTrackAnaAlg.cxx.

1086  {
1087  using namespace Monitored;
1088  auto tool = getGroup(m_packageName);
1089 
1090  int lumiBlock = ctx.eventID().lumi_block();
1091 
1092  SG::ReadHandle<Muon::RpcPrepDataContainer> rpcContainer(m_rpcPrdKey, ctx);
1093  const RpcIdHelper& rpcIdHelper = m_idHelperSvc->rpcIdHelper();
1094 
1095  ATH_MSG_DEBUG(" RpcPrepDataContainer size = " << rpcContainer->size());
1096  ATH_MSG_DEBUG(" results size = " << results.size());
1097 
1098  auto i_hitTime_sec = Scalar<int>("hitTime_sec", 0);
1099 
1100  auto isOutTime_prd = Scalar<bool>("isOutTime_prd", false);
1101  auto isOutTime_onTrack = Scalar<bool>("isOutTime_prd_onTrack", false);
1102  auto i_panelIndex = Scalar<int>("panelInd_prd", -1);
1103  auto i_panelIndex_onTrack = Scalar<int>("panelInd_prd_onTrack", -1);
1104 
1105  auto res_eta = Scalar<int>("residual_eta", 0);
1106  auto res_phi = Scalar<int>("residual_phi", 0);
1107  auto closest_res_eta = Scalar<int>("closest_residual_eta", 0);
1108  auto closest_res_phi = Scalar<int>("closest_residual_phi", 0);
1109 
1110  auto res_panel = Scalar<int>("residual_panel", 0);
1111  auto i_panelInd_res = Scalar<int>("panelInd_res_inTime", -1);
1112 
1113  for (GasGapResult& exr : results) {
1114  const std::shared_ptr<GasGapData> gap = exr.second;
1115 
1116  int sector = (gap->RpcPanel_eta_phi.first->getSectorLayer()).first;
1117 
1118  float clo_res_eta = 1001.; // initial value; no sense
1119  float clo_res_phi = 1001.;
1120  int NHitwithCut_perMuon_eta = 0;
1121  int NHitwithCut_perMuon_phi = 0;
1122  int NHitnoCut_perMuon_eta = 0;
1123  int NHitnoCut_perMuon_phi = 0;
1124  std::vector<const Muon::RpcPrepData*> view_hits_eta;
1125  std::vector<const Muon::RpcPrepData*> view_hits_phi;
1126 
1127  // loop on RpcPrepDataCollection
1128  for (const Muon::RpcPrepDataCollection* rpcCollection : *rpcContainer) {
1129  if (!rpcCollection) {
1130  continue;
1131  }
1132 
1133  // loop on RpcPrepData
1134  for (const Muon::RpcPrepData* rpcData : *rpcCollection) {
1135  if (!rpcData) {
1136  continue;
1137  }
1138 
1139  const Identifier id = rpcData->identify();
1140  const int stationName = rpcIdHelper.stationName(id);
1141  const int stationEta = rpcIdHelper.stationEta(id);
1142  const int stationPhi = rpcIdHelper.stationPhi(id);
1143 
1144  const int doubletR = rpcIdHelper.doubletR(id);
1145  const int doubletZ = rpcIdHelper.doubletZ(id);
1146  const int doubletPhi = rpcIdHelper.doubletPhi(id);
1147  const unsigned gasGap = rpcIdHelper.gasGap(id);
1148  const int measuresPhi = rpcIdHelper.measuresPhi(id);
1149 
1150  // match hit to the gasgap
1151  if (stationName == gap->stationName &&
1152  stationPhi == gap->stationPhi &&
1153  stationEta == gap->stationEta &&
1154  doubletR == gap->doubletR && gasGap == gap->gasgap &&
1155  doubletPhi == gap->doubletPhi &&
1156  doubletZ == gap->doubletZ) {
1157 
1158 
1159  i_hitTime_sec = rpcData->time();
1160  fill(m_tools[m_SectorGroup.at(
1161  "sector" + std::to_string(std::abs(sector)))],
1162  i_hitTime_sec);
1163 
1164  // ---------------------------------
1165  // Calculate distance between extrapolated muon track position and hit
1166  float hit_local_x = rpcData->localPosition().x();
1167  float trackPos_localY = exr.first.localPos.y();
1168  float trackPos_localZ = exr.first.localPos.z();
1169 
1170  float residual_phi = trackPos_localY-hit_local_x;
1171  float residual_eta = trackPos_localZ-hit_local_x;
1172 
1173  // If hit is out-of-time
1174  bool isOutTime = (std::abs(i_hitTime_sec+50.) > m_outtime); // for run 3
1175  int i_panel = measuresPhi ? gap->RpcPanel_eta_phi.second->panel_index :
1176  gap->RpcPanel_eta_phi.first->panel_index;
1177 
1178  // Fill histograms of out-of-time hit fraction
1179  if (muon_source == ZCand) {
1180 
1181  isOutTime_prd = isOutTime;
1182  isOutTime_onTrack = isOutTime;
1183 
1184  if (measuresPhi) {
1185  i_panelIndex = i_panel;
1186  fill(tool, i_panelIndex, isOutTime_prd);
1187  if (std::abs(residual_phi) < m_diffHitTrackPostion) {
1188  i_panelIndex_onTrack = i_panel;
1189  fill(tool, i_panelIndex_onTrack, isOutTime_onTrack);
1190  }
1191  } else {
1192  i_panelIndex = i_panel;
1193  fill(tool, i_panelIndex, isOutTime_prd);
1194  if (std::abs(residual_eta) < m_diffHitTrackPostion) {
1195  i_panelIndex_onTrack = i_panel;
1196  fill(tool, i_panelIndex_onTrack, isOutTime_onTrack);
1197  }
1198  }
1199  }
1200 
1201  if (measuresPhi) {
1202  NHitnoCut_perMuon_phi++;
1203  } else {
1204  NHitnoCut_perMuon_eta++;
1205  }
1206 
1207  // process hit within |time| < 12.5 ns && on Track
1208  if (isOutTime){
1209  continue;
1210  }
1211  i_panelInd_res = i_panel;
1212 
1213  if (measuresPhi) {
1214  res_phi = residual_phi;
1215  res_panel = residual_phi;
1216  clo_res_phi = std::min(clo_res_phi, residual_phi);
1217 
1218  fill(tool, res_phi, res_panel, i_panelInd_res);
1219 
1220  if (std::abs(residual_phi) < m_diffHitTrackPostion) {
1221  NHitwithCut_perMuon_phi++;
1222  view_hits_phi.push_back(rpcData);
1223  }
1224  } else {
1225  res_eta = residual_eta;
1226  res_panel = residual_eta;
1227  clo_res_eta = std::min(clo_res_eta, residual_eta);
1228 
1229  fill(tool, res_eta, res_panel, i_panelInd_res);
1230 
1231  if (std::abs(residual_eta) < m_diffHitTrackPostion){
1232  NHitwithCut_perMuon_eta++;
1233  view_hits_eta.push_back(rpcData);
1234  }
1235  }
1236  }
1237  }
1238  }
1239 
1240  int etaPanel_ind = -1;
1241  int phiPanel_ind = -1;
1242 
1243  etaPanel_ind = gap->RpcPanel_eta_phi.first->panel_index;
1244  phiPanel_ind = gap->RpcPanel_eta_phi.second->panel_index;
1245 
1246  // Declare the quantities which should be monitored
1247  if (muon_source == ZCand) {
1248  auto hitMulti_eta = Scalar<int>("hitMulti_eta", NHitwithCut_perMuon_eta);
1249  auto hitMulti_phi = Scalar<int>("hitMulti_phi", NHitwithCut_perMuon_phi);
1250  auto hitMulti = Scalar<int>("hitMulti", 0);
1251  auto i_panelIndex = Scalar<int>("panelInd_hM", -1);
1252  auto i_passExtrap = Scalar<bool>("muon_passExtrap", false);
1253  auto i_passExtrap_or = Scalar<bool>("muon_passExtrap_or", false);
1254  auto i_passExtrap_and = Scalar<bool>("muon_passExtrap_and", false);
1255  auto i_passExtrap_sig_or = Scalar<bool>("muon_passExtrap_signalhit_or", false);
1256  auto i_passExtrap_sig_and = Scalar<bool>("muon_passExtrap_signalhit_and", false);
1257  auto i_passExtrap_sig = Scalar<bool>("muon_passExtrap_signalhit", false);
1258  auto i_LB = Scalar<int>("LB_detEff", lumiBlock);
1259 
1260  fill(tool, hitMulti_eta, hitMulti_phi);
1261 
1262  //
1263  // Eta OR Phi panel
1264  if (NHitnoCut_perMuon_eta > 0 || NHitnoCut_perMuon_phi > 0)
1265  i_passExtrap_or = true;
1266  if (NHitwithCut_perMuon_eta > 0 || NHitwithCut_perMuon_phi > 0)
1267  i_passExtrap_sig_or = true;
1268 
1269  //
1270  // Eta AND Phi panel
1271  if (NHitnoCut_perMuon_eta > 0 && NHitnoCut_perMuon_phi > 0)
1272  i_passExtrap_and = true;
1273  if (NHitwithCut_perMuon_eta > 0 && NHitwithCut_perMuon_phi > 0)
1274  i_passExtrap_sig_and = true;
1275  //
1276  // Eta panel
1277  hitMulti = NHitwithCut_perMuon_eta;
1278  i_panelIndex = etaPanel_ind;
1279 
1280  if (NHitnoCut_perMuon_eta > 0)
1281  i_passExtrap = true;
1282 
1283  if (NHitwithCut_perMuon_eta > 0)
1284  i_passExtrap_sig = true;
1285 
1286  fill(tool, hitMulti, i_panelIndex, i_passExtrap, i_passExtrap_sig,
1287  i_passExtrap_or, i_passExtrap_and, i_passExtrap_sig_or, i_passExtrap_sig_and, i_LB);
1288  ATH_CHECK(fillClusterSize(view_hits_eta, etaPanel_ind, lumiBlock,
1289  sector, 0)); // isPhi = 0
1290 
1291  if (clo_res_eta < 1000.) {
1292  closest_res_eta = clo_res_eta;
1293  fill(tool, closest_res_eta);
1294  }
1295 
1296  //
1297  // Phi panel
1298  hitMulti = NHitwithCut_perMuon_phi;
1299  i_panelIndex = phiPanel_ind;
1300  if (NHitnoCut_perMuon_phi > 0)
1301  i_passExtrap = true;
1302 
1303  if (NHitwithCut_perMuon_phi > 0)
1304  i_passExtrap_sig = true;
1305 
1306  fill(tool, hitMulti, i_panelIndex, i_passExtrap, i_passExtrap_sig,
1307  i_passExtrap_or, i_passExtrap_and, i_passExtrap_sig_or, i_passExtrap_sig_and, i_LB);
1308  ATH_CHECK(fillClusterSize(view_hits_phi, phiPanel_ind, lumiBlock,
1309  sector, 1)); // isPhi = 1
1310 
1311  if (clo_res_phi < 1000.) {
1312  closest_res_phi = clo_res_phi;
1313  fill(tool, closest_res_phi);
1314  }
1315  }
1316 
1317  //
1318  // All muon
1319  //
1320  auto i_panelIndex_allMu = Scalar<int>("panelInd_hM_allMu", -1);
1321  auto i_passExtrap_allMu = Scalar<bool>("muon_passExtrap_allMu", false);
1322 
1323  //
1324  // Eta panel
1325  i_panelIndex_allMu = etaPanel_ind;
1326  if (NHitwithCut_perMuon_eta > 0)
1327  i_passExtrap_allMu = true;
1328  fill(tool, i_panelIndex_allMu, i_passExtrap_allMu);
1329 
1330  //
1331  // Phi panel
1332  i_panelIndex_allMu = phiPanel_ind;
1333  if (NHitwithCut_perMuon_phi > 0)
1334  i_passExtrap_allMu = true;
1335 
1336  fill(tool, i_panelIndex_allMu, i_passExtrap_allMu);
1337  }
1338 
1339  return StatusCode::SUCCESS;
1340 }

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

◆ setPanelIndex()

StatusCode RpcTrackAnaAlg::setPanelIndex ( std::shared_ptr< RpcPanel >  panel)
private

Definition at line 187 of file RpcTrackAnaAlg.cxx.

187  {
188  /*
189  Specify every panel with a unique index according the information in xml
190  */
191  std::string ele_str = panel->getElementStr();
192 
193  std::map<std::string, int>::iterator it_eleInd =
194  m_elementIndex.find(ele_str);
195 
196  if (it_eleInd == m_elementIndex.end()) {
197  ATH_MSG_ERROR("Can not find element: stationName = "
198  << panel->stationName
199  << ", stationEta = " << panel->stationEta
200  << ", stationPhi = " << panel->stationPhi
201  << ", doubletR = " << panel->doubletR
202  << ", doubletZ = " << panel->doubletZ);
203  return StatusCode::FAILURE;
204  }
205 
206  int ele_index = it_eleInd->second;
207  int panel_index = (ele_index - 1) * 8 + (panel->doubletPhi - 1) * 4 +
208  (panel->gasGap - 1) * 2 + panel->measPhi;
209 
210  panel->SetPanelIndex(panel_index);
211 
212  return StatusCode::SUCCESS;
213 }

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ triggerMatching()

StatusCode RpcTrackAnaAlg::triggerMatching ( const xAOD::Muon *  offline_muon,
const std::vector< TagDef > &  list_of_triggers 
) const
private

Definition at line 716 of file RpcTrackAnaAlg.cxx.

718  {
719  if (!m_TagAndProbe.value())
720  return StatusCode::SUCCESS;
721  if (getTrigDecisionTool().empty())
722  return StatusCode::SUCCESS;
723  TVector3 muonvec;
724  muonvec.SetPtEtaPhi(offline_muon->pt(), offline_muon->eta(),
725  offline_muon->phi());
726 
727  for (const auto& tagTrig : list_of_triggers) {
728  if (!getTrigDecisionTool()->isPassed(tagTrig.eventTrig.Data()))
729  continue;
730 
731  ATH_MSG_DEBUG("tagTrig.eventTrig = " << tagTrig.eventTrig
732  << "; tagTrig.tagTrig = "
733  << tagTrig.tagTrig);
734  // ATH_MSG_DEBUG("m_MuonEFContainerName.value() = "<<
735  // m_MuonEFContainerName.value());
736 
737  std::vector<TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>>
738  features = getTrigDecisionTool()->features<xAOD::MuonContainer>(
739  tagTrig.tagTrig.Data(), TrigDefs::Physics);
740 
741  for (const auto& aaa : features) {
742  ATH_CHECK(aaa.isValid());
743  auto trigmuon_link = aaa.link;
744  auto trigmuon = *trigmuon_link;
745  TVector3 trigvec;
746  trigvec.SetPtEtaPhi(trigmuon->pt(), trigmuon->eta(),
747  trigmuon->phi());
748  if (trigvec.DeltaR(muonvec) < m_trigMatchWindow.value())
749  return StatusCode::SUCCESS;
750  }
751  }
752  return StatusCode::FAILURE;
753 }

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

FloatProperty RpcTrackAnaAlg::m_barrelMaxEta {this, "barrelMaxEta", 1.05}
private

Definition at line 135 of file RpcTrackAnaAlg.h.

◆ m_barrelMinEta

FloatProperty RpcTrackAnaAlg::m_barrelMinEta {this, "barrelMinEta", 0.1}
private

Definition at line 134 of file RpcTrackAnaAlg.h.

◆ m_barrelMinPt

FloatProperty RpcTrackAnaAlg::m_barrelMinPt {this, "barrelMinPt", 2.0e3}
private

Definition at line 133 of file RpcTrackAnaAlg.h.

◆ m_beamSigmaX

SG::ReadDecorHandleKey<xAOD::EventInfo> RpcTrackAnaAlg::m_beamSigmaX
private
Initial value:
{
this, "beamPosSigmaX", "EventInfo.beamPosSigmaX",
"Beam spot position sigma in X"}

Definition at line 192 of file RpcTrackAnaAlg.h.

◆ m_beamSigmaXY

SG::ReadDecorHandleKey<xAOD::EventInfo> RpcTrackAnaAlg::m_beamSigmaXY
private
Initial value:
{
this, "beamPosSigmaXY", "EventInfo.beamPosSigmaXY",
"Beam spot covariance in XY"}

Definition at line 200 of file RpcTrackAnaAlg.h.

◆ m_beamSigmaY

SG::ReadDecorHandleKey<xAOD::EventInfo> RpcTrackAnaAlg::m_beamSigmaY
private
Initial value:
{
this, "beamPosSigmaY", "EventInfo.beamPosSigmaY",
"Beam spot position sigma in Y"}

Definition at line 195 of file RpcTrackAnaAlg.h.

◆ m_boundsToleranceReadoutElement

FloatProperty RpcTrackAnaAlg::m_boundsToleranceReadoutElement
private
Initial value:
{
this, "boundsToleranceReadoutElement", 100.0,
"boundsToleranceReadoutElement"}

Definition at line 159 of file RpcTrackAnaAlg.h.

◆ m_boundsToleranceReadoutElementTight

FloatProperty RpcTrackAnaAlg::m_boundsToleranceReadoutElementTight
private
Initial value:
{
this, "boundsToleranceReadoutElementTight", 20.0,
"boundsToleranceReadoutElementTight"}

Definition at line 162 of file RpcTrackAnaAlg.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_diffHitTrackPostion

FloatProperty RpcTrackAnaAlg::m_diffHitTrackPostion
private
Initial value:
{
this, "diffHitTrackPostion", 30.0,
"the largest distance between hit and tracks local postion"}

Definition at line 166 of file RpcTrackAnaAlg.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_elementIndex

std::map<std::string, int> RpcTrackAnaAlg::m_elementIndex {}
private

Definition at line 213 of file RpcTrackAnaAlg.h.

◆ m_elementsFileName

StringProperty RpcTrackAnaAlg::m_elementsFileName
private
Initial value:
{this, "ElementsFileName", "Element.xml",
"Elements xml file"}

Definition at line 113 of file RpcTrackAnaAlg.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_extrapolator

ToolHandle<Trk::IExtrapolator> RpcTrackAnaAlg::m_extrapolator
private
Initial value:
{
this, "TrackExtrapolator", "Trk::Extrapolator/AtlasExtrapolator",
"Track extrapolator"}

Definition at line 177 of file RpcTrackAnaAlg.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_gasGapData

std::map<std::pair<int, int>, std::vector<std::shared_ptr<GasGapData> > > RpcTrackAnaAlg::m_gasGapData {}
private

Definition at line 209 of file RpcTrackAnaAlg.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> RpcTrackAnaAlg::m_idHelperSvc
private
Initial value:
{
this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 172 of file RpcTrackAnaAlg.h.

◆ m_isolationWindow

FloatProperty RpcTrackAnaAlg::m_isolationWindow
private
Initial value:
{
this, "IsolationWindow", 0.1,
"Window size in R for isolation with other muons"}

Definition at line 146 of file RpcTrackAnaAlg.h.

◆ m_l1trigMatchWindow

FloatProperty RpcTrackAnaAlg::m_l1trigMatchWindow
private
Initial value:
{
this, "L1TrigMatchingWindow", 0.3,
"Window size in R for L1 trigger matching"}

Definition at line 149 of file RpcTrackAnaAlg.h.

◆ m_lbDuraThr

FloatProperty RpcTrackAnaAlg::m_lbDuraThr
private
Initial value:
{this, "lbDuraThr", 10.,
"Thrshold of luminosity block deruation"}

Definition at line 108 of file RpcTrackAnaAlg.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_maxEta

FloatProperty RpcTrackAnaAlg::m_maxEta
private
Initial value:
{this, "maxEta", 2.5,
"max eta absolute value of muon"}

Definition at line 129 of file RpcTrackAnaAlg.h.

◆ m_minDRTrackToGasGap

FloatProperty RpcTrackAnaAlg::m_minDRTrackToGasGap
private
Initial value:
{
this, "minDRTrackToGasGap", 0.02,
"minimum of DR between track and gasgap"}

Definition at line 155 of file RpcTrackAnaAlg.h.

◆ m_minPt

FloatProperty RpcTrackAnaAlg::m_minPt {this, "minPt", 25.0e3, "minmum pT of muon"}
private

Definition at line 128 of file RpcTrackAnaAlg.h.

◆ m_MuonContainerKey

SG::ReadHandleKey<xAOD::MuonContainer> RpcTrackAnaAlg::m_MuonContainerKey
private
Initial value:
{
this, "MuonContainerKey", "Muons",
"Key for Offline muon track Containers"}

Definition at line 182 of file RpcTrackAnaAlg.h.

◆ m_muonMass

FloatProperty RpcTrackAnaAlg::m_muonMass
private
Initial value:
{this, "MuonMass", 105.6583755,
"muon invariant mass in MeV"}

Definition at line 137 of file RpcTrackAnaAlg.h.

◆ m_MuonRoIContainerKey

SG::ReadHandleKey<xAOD::MuonRoIContainer> RpcTrackAnaAlg::m_MuonRoIContainerKey
private
Initial value:
{
this, "MuonRoIContainerName", "LVL1MuonRoIs", "Key for L1 ROIs"}

Definition at line 180 of file RpcTrackAnaAlg.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_outtime

FloatProperty RpcTrackAnaAlg::m_outtime {this, "outtime", 12.5, "the out-time time"}
private

Definition at line 169 of file RpcTrackAnaAlg.h.

◆ m_packageName

StringProperty RpcTrackAnaAlg::m_packageName
private
Initial value:
{this, "PackageName", "RpcTrackAnaAlg",
"group name for histograming"}

Definition at line 110 of file RpcTrackAnaAlg.h.

◆ m_plotMuonEff

BooleanProperty RpcTrackAnaAlg::m_plotMuonEff
private
Initial value:
{
this, "plotMuonEff", false,
"switch to plot histograms for Muon Efficiency"}

Definition at line 99 of file RpcTrackAnaAlg.h.

◆ m_plotPRD

BooleanProperty RpcTrackAnaAlg::m_plotPRD
private
Initial value:
{
this, "plotPRD", false,
"switch to plot histograms for Prepare Data objects"}

Definition at line 102 of file RpcTrackAnaAlg.h.

◆ m_PrimaryVertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> RpcTrackAnaAlg::m_PrimaryVertexContainerKey
private
Initial value:
{
this, "PrimaryVertexContainerName", "PrimaryVertices",
"Primary Vertex Container"}

Definition at line 187 of file RpcTrackAnaAlg.h.

◆ m_rpcIdHelper

const RpcIdHelper* RpcTrackAnaAlg::m_rpcIdHelper {nullptr}
private

Definition at line 175 of file RpcTrackAnaAlg.h.

◆ m_rpcPanelMap

RpcPanelMap RpcTrackAnaAlg::m_rpcPanelMap {}
private

Definition at line 204 of file RpcTrackAnaAlg.h.

◆ m_rpcPrdKey

SG::ReadHandleKey<Muon::RpcPrepDataContainer> RpcTrackAnaAlg::m_rpcPrdKey
private
Initial value:
{
this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}

Definition at line 185 of file RpcTrackAnaAlg.h.

◆ m_SectorGroup

std::map<std::string, int> RpcTrackAnaAlg::m_SectorGroup {}
private

Definition at line 215 of file RpcTrackAnaAlg.h.

◆ m_StationNames

std::map<BarrelDL, std::vector<int> > RpcTrackAnaAlg::m_StationNames {}
private

Definition at line 212 of file RpcTrackAnaAlg.h.

◆ m_TagAndProbe

BooleanProperty RpcTrackAnaAlg::m_TagAndProbe
private
Initial value:
{this, "TagAndProbe", false,
"switch to perform tag-and-probe method"}

Definition at line 121 of file RpcTrackAnaAlg.h.

◆ m_TagAndProbeZmumu

BooleanProperty RpcTrackAnaAlg::m_TagAndProbeZmumu
private
Initial value:
{
this, "TagAndProbeZmumu", false,
"switch to perform tag-and-probe method Z->mumu"}

Definition at line 123 of file RpcTrackAnaAlg.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_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_TriggerThrGroup

std::map<std::string, int> RpcTrackAnaAlg::m_TriggerThrGroup {}
private

Definition at line 216 of file RpcTrackAnaAlg.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_trigMatchWindow

FloatProperty RpcTrackAnaAlg::m_trigMatchWindow
private
Initial value:
{this, "TrigMatchingWindow", 0.005,
"Window size in R for trigger matching"}

Definition at line 119 of file RpcTrackAnaAlg.h.

◆ m_trigTagDefs

std::vector<TagDef> RpcTrackAnaAlg::m_trigTagDefs {}
private

Definition at line 206 of file RpcTrackAnaAlg.h.

◆ m_trigTagList

StringProperty RpcTrackAnaAlg::m_trigTagList
private
Initial value:
{
this, "TagTrigList", "HLT_mu_ivarmedium;HLT_mu50",
"list of triggers to be used for trigger matching"}

Definition at line 116 of file RpcTrackAnaAlg.h.

◆ m_useAODParticle

BooleanProperty RpcTrackAnaAlg::m_useAODParticle
private
Initial value:
{this, "useAODParticle", false,
"use AOD Particle"}

Definition at line 105 of file RpcTrackAnaAlg.h.

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ m_zMass_lowLimit

FloatProperty RpcTrackAnaAlg::m_zMass_lowLimit
private
Initial value:
{
this, "zMass_lowLimit", 50000.,
"2 muon invariant mass low limit in Zmumu event"}

Definition at line 139 of file RpcTrackAnaAlg.h.

◆ m_zMass_upLimit

FloatProperty RpcTrackAnaAlg::m_zMass_upLimit
private
Initial value:
{
this, "zMass_upLimit", 150000.,
"2 muon invariant mass up limit in Zmumu event"}

Definition at line 142 of file RpcTrackAnaAlg.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
RpcTrackAnaAlg::computeTrackIntersectionWithGasGap
std::unique_ptr< Trk::TrackParameters > computeTrackIntersectionWithGasGap(ExResult &result, const xAOD::TrackParticle *track_particle, const std::shared_ptr< GasGapData > &gap) const
Definition: RpcTrackAnaAlg.cxx:866
RpcTrackAnaAlg::m_MuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
Definition: RpcTrackAnaAlg.h:182
RpcTrackAnaAlg::m_TriggerThrGroup
std::map< std::string, int > m_TriggerThrGroup
Definition: RpcTrackAnaAlg.h:216
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
RpcTrackAnaAlg::m_plotPRD
BooleanProperty m_plotPRD
Definition: RpcTrackAnaAlg.h:102
RpcPanel::stationPhi
int stationPhi
Definition: RPCDQUtils.h:40
RpcTrackAnaAlg::OUT
@ OUT
Definition: RpcTrackAnaAlg.h:56
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Trk::SurfaceBounds::inside
virtual bool inside(const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const =0
Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds.
RpcTrackAnaAlg::triggerMatching
StatusCode triggerMatching(const xAOD::Muon *, const std::vector< TagDef > &) const
Definition: RpcTrackAnaAlg.cxx:716
RpcTrackAnaAlg::m_beamSigmaXY
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaXY
Definition: RpcTrackAnaAlg.h:200
get_generator_info.result
result
Definition: get_generator_info.py:21
RpcTrackAnaAlg::IsNearbyHit
bool IsNearbyHit(const std::vector< const Muon::RpcPrepData * > &cluster_hits, const Muon::RpcPrepData *hit) const
Definition: RpcTrackAnaAlg.cxx:1412
MuonIdHelper::detectorElement_begin
const_id_iterator detectorElement_begin() const
Iterators over full set of ids.
Definition: MuonIdHelper.cxx:758
RpcTrackAnaAlg::m_barrelMaxEta
FloatProperty m_barrelMaxEta
Definition: RpcTrackAnaAlg.h:135
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CaloCellTimeCorrFiller.LB
LB
Definition: CaloCellTimeCorrFiller.py:37
RpcTrackAnaAlg::m_trigMatchWindow
FloatProperty m_trigMatchWindow
Definition: RpcTrackAnaAlg.h:119
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
ExResult
Definition: RPCDQUtils.h:82
collListGuids.line
string line
Definition: collListGuids.py:77
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
RpcTrackAnaAlg::m_maxEta
FloatProperty m_maxEta
Definition: RpcTrackAnaAlg.h:129
RpcTrackAnaAlg::m_minPt
FloatProperty m_minPt
Definition: RpcTrackAnaAlg.h:128
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
RpcIdHelper::doubletZ
int doubletZ(const Identifier &id) const
Definition: RpcIdHelper.cxx:1053
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
RpcPanel::doubletPhi
int doubletPhi
Definition: RPCDQUtils.h:43
RpcTrackAnaAlg::BarrelDL
BarrelDL
Definition: RpcTrackAnaAlg.h:50
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
RpcTrackAnaAlg::m_plotMuonEff
BooleanProperty m_plotMuonEff
Definition: RpcTrackAnaAlg.h:99
Trk::SurfaceBounds
Definition: SurfaceBounds.h:47
RpcTrackAnaAlg::m_beamSigmaX
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaX
Definition: RpcTrackAnaAlg.h:192
xAOD::Muon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
met::DeltaR
@ DeltaR
Definition: METRecoCommon.h:11
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
RpcTrackAnaAlg::BM2
@ BM2
Definition: RpcTrackAnaAlg.h:53
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
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition: TrackParticlexAODHelpers.cxx:42
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
RpcTrackAnaAlg::m_minDRTrackToGasGap
FloatProperty m_minDRTrackToGasGap
Definition: RpcTrackAnaAlg.h:155
RpcTrackAnaAlg::BI
@ BI
Definition: RpcTrackAnaAlg.h:51
xAOD::Muon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
RpcTrackAnaAlg::m_rpcPrdKey
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_rpcPrdKey
Definition: RpcTrackAnaAlg.h:185
RpcIdHelper::measuresPhi
bool measuresPhi(const Identifier &id) const override
Definition: RpcIdHelper.cxx:1059
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:194
test_pyathena.pt
pt
Definition: test_pyathena.py:11
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
RpcTrackAnaAlg::m_useAODParticle
BooleanProperty m_useAODParticle
Definition: RpcTrackAnaAlg.h:105
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
RpcTrackAnaAlg::m_barrelMinEta
FloatProperty m_barrelMinEta
Definition: RpcTrackAnaAlg.h:134
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
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:55
RpcTrackAnaAlg::m_packageName
StringProperty m_packageName
Definition: RpcTrackAnaAlg.h:110
RpcTrackAnaAlg::m_SectorGroup
std::map< std::string, int > m_SectorGroup
Definition: RpcTrackAnaAlg.h:215
RpcTrackAnaAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: RpcTrackAnaAlg.h:172
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
cosmics
Definition: cosmics.py:1
RpcTrackAnaAlg::m_diffHitTrackPostion
FloatProperty m_diffHitTrackPostion
Definition: RpcTrackAnaAlg.h:166
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MuonIdHelper::stationName
int stationName(const Identifier &id) const
Definition: MuonIdHelper.cxx:800
MuonIdHelper::detectorElement_end
const_id_iterator detectorElement_end() const
Definition: MuonIdHelper.cxx:760
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
RpcTrackAnaAlg::ZCand
@ ZCand
Definition: RpcTrackAnaAlg.h:58
RpcTrackAnaAlg::BO2
@ BO2
Definition: RpcTrackAnaAlg.h:55
RpcTrackAnaAlg::m_isolationWindow
FloatProperty m_isolationWindow
Definition: RpcTrackAnaAlg.h:146
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
RpcTrackAnaAlg::m_StationNames
std::map< BarrelDL, std::vector< int > > m_StationNames
Definition: RpcTrackAnaAlg.h:212
CaloSwCorrections.gap
def gap(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:212
RpcIdHelper
Definition: RpcIdHelper.h:51
RpcTrackAnaAlg::fillHistPRD
StatusCode fillHistPRD(const EventContext &ctx) const
Definition: RpcTrackAnaAlg.cxx:616
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
RpcPanel::gasGap
int gasGap
Definition: RPCDQUtils.h:44
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
DetType::Barrel
@ Barrel
Definition: DetType.h:14
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
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
RpcTrackAnaAlg::m_elementIndex
std::map< std::string, int > m_elementIndex
Definition: RpcTrackAnaAlg.h:213
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
RpcIdHelper::gasGap
int gasGap(const Identifier &id) const override
get the hashes
Definition: RpcIdHelper.cxx:1057
RpcPanel::stationEta
int stationEta
Definition: RPCDQUtils.h:39
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
RpcPanel::SetPanelIndex
void SetPanelIndex(int index)
Definition: RPCDQUtils.cxx:83
RpcTrackAnaAlg::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: RpcTrackAnaAlg.h:177
Muon::RpcPrepData::time
float time() const
Returns the time.
Definition: RpcPrepData.h:197
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
RpcTrackAnaAlg::fillMuonExtrapolateEff
StatusCode fillMuonExtrapolateEff(const EventContext &ctx) const
Definition: RpcTrackAnaAlg.cxx:326
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
RpcTrackAnaAlg::BO1
@ BO1
Definition: RpcTrackAnaAlg.h:54
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:485
RpcTrackAnaAlg::m_l1trigMatchWindow
FloatProperty m_l1trigMatchWindow
Definition: RpcTrackAnaAlg.h:149
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
RpcTrackAnaAlg::extrapolate2RPC
StatusCode extrapolate2RPC(const xAOD::TrackParticle *track, const Trk::PropDirection direction, std::vector< GasGapResult > &results, BarrelDL barrelDL) const
Definition: RpcTrackAnaAlg.cxx:756
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
RpcTrackAnaAlg::m_muonMass
FloatProperty m_muonMass
Definition: RpcTrackAnaAlg.h:137
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
RpcIdHelper::doubletR
int doubletR(const Identifier &id) const
Definition: RpcIdHelper.cxx:1051
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
RpcTrackAnaAlg::m_PrimaryVertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_PrimaryVertexContainerKey
Definition: RpcTrackAnaAlg.h:187
lumiFormat.i
int i
Definition: lumiFormat.py:85
TagDef::eventTrig
TString eventTrig
Definition: RPCDQUtils.h:62
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
RpcTrackAnaAlg::initRpcPanel
StatusCode initRpcPanel()
Definition: RpcTrackAnaAlg.cxx:77
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
RpcTrackAnaAlg::m_boundsToleranceReadoutElementTight
FloatProperty m_boundsToleranceReadoutElementTight
Definition: RpcTrackAnaAlg.h:162
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:111
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
RpcPanel::doubletR
int doubletR
Definition: RPCDQUtils.h:41
RpcTrackAnaAlg::m_zMass_upLimit
FloatProperty m_zMass_upLimit
Definition: RpcTrackAnaAlg.h:142
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
RpcTrackAnaAlg::fillClusterSize
StatusCode fillClusterSize(std::vector< const Muon::RpcPrepData * > &view_hits, const int panel_index, int LB, int phiSector, int isPhi) const
Definition: RpcTrackAnaAlg.cxx:1343
RpcPanel::getElementStr
std::string getElementStr() const
Definition: RPCDQUtils.cxx:88
RpcTrackAnaAlg::m_TagAndProbe
BooleanProperty m_TagAndProbe
Definition: RpcTrackAnaAlg.h:121
xAOD::Muon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
RpcIdHelper::strip
int strip(const Identifier &id) const
Definition: RpcIdHelper.cxx:1061
RpcTrackAnaAlg::m_outtime
FloatProperty m_outtime
Definition: RpcTrackAnaAlg.h:169
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonGM::RpcReadoutElement::getDoubletPhi
int getDoubletPhi() const
return DoubletPhi value for the given readout element, be aware that one RE can contain two DoubletPh...
add-xsec-uncert-quadrature-N.results
dictionary results
Definition: add-xsec-uncert-quadrature-N.py:39
run
Definition: run.py:1
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
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.
LArDSPThresholdTopOptions.tagList
list tagList
Definition: LArDSPThresholdTopOptions.py:3
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
TagDef::tagTrig
TString tagTrig
Definition: RPCDQUtils.h:63
RpcTrackAnaAlg::AllMuon
@ AllMuon
Definition: RpcTrackAnaAlg.h:58
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
RpcTrackAnaAlg::readHitsPerGasgap
StatusCode readHitsPerGasgap(const EventContext &ctx, std::vector< GasGapResult > &results, MuonSource muon_source) const
Definition: RpcTrackAnaAlg.cxx:1084
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
MuonIdHelper::stationPhi
int stationPhi(const Identifier &id) const
Definition: MuonIdHelper.cxx:810
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
ptree
boost::property_tree::ptree ptree
Definition: JsonFileLoader.cxx:16
AthMonitorAlgorithm::Environment_t::online
@ online
RpcTrackAnaAlg::m_elementsFileName
StringProperty m_elementsFileName
Definition: RpcTrackAnaAlg.h:113
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
res_panel
std::string res_panel[4][6]
Definition: default_panels.h:108
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
RpcPanel::doubletZ
int doubletZ
Definition: RPCDQUtils.h:42
TagDef
Definition: RPCDQUtils.h:61
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
RpcPanel::panel_valid
bool panel_valid
Definition: RPCDQUtils.h:30
RpcTrackAnaAlg::setPanelIndex
StatusCode setPanelIndex(std::shared_ptr< RpcPanel > panel)
Definition: RpcTrackAnaAlg.cxx:187
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
RpcTrackAnaAlg::m_MuonRoIContainerKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_MuonRoIContainerKey
Definition: RpcTrackAnaAlg.h:180
RpcPanel::panelId
Identifier panelId
Definition: RPCDQUtils.h:29
MuonIdHelper::stationEta
int stationEta(const Identifier &id) const
Definition: MuonIdHelper.cxx:805
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
RpcTrackAnaAlg::m_beamSigmaY
SG::ReadDecorHandleKey< xAOD::EventInfo > m_beamSigmaY
Definition: RpcTrackAnaAlg.h:195
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonIdHelper::module_hash_max
size_type module_hash_max() const
the maximum hash value
Definition: MuonIdHelper.cxx:748
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
RpcPanel::stationName
int stationName
Definition: RPCDQUtils.h:38
RpcTrackAnaAlg::m_boundsToleranceReadoutElement
FloatProperty m_boundsToleranceReadoutElement
Definition: RpcTrackAnaAlg.h:159
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:63
a
TList * a
Definition: liststreamerinfos.cxx:10
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:129
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RpcTrackAnaAlg::readElIndexFromXML
StatusCode readElIndexFromXML()
Definition: RpcTrackAnaAlg.cxx:216
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
Trk::PlaneSurface
Definition: PlaneSurface.h:64
WriteBchToCool.dbR
dbR
Definition: WriteBchToCool.py:426
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
DeMoScan.first
bool first
Definition: DeMoScan.py:536
TriggerTest.rois
rois
Definition: TriggerTest.py:23
RpcTrackAnaAlg::m_gasGapData
std::map< std::pair< int, int >, std::vector< std::shared_ptr< GasGapData > > > m_gasGapData
Definition: RpcTrackAnaAlg.h:209
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:16
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
RpcTrackAnaAlg::BM1
@ BM1
Definition: RpcTrackAnaAlg.h:52
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:805
RpcTrackAnaAlg::GasGapResult
std::pair< ExResult, const std::shared_ptr< GasGapData > > GasGapResult
Definition: RpcTrackAnaAlg.h:47
RpcTrackAnaAlg::m_trigTagList
StringProperty m_trigTagList
Definition: RpcTrackAnaAlg.h:116
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
MuonGM::RpcReadoutElement::getDoubletZ
int getDoubletZ() const
return DoubletZ value for the given readout element
value_type
Definition: EDM_MasterSearch.h:11
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
RpcTrackAnaAlg::initTrigTag
StatusCode initTrigTag()
Definition: RpcTrackAnaAlg.cxx:280
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
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
RpcPanel::measPhi
int measPhi
Definition: RPCDQUtils.h:45
RpcIdHelper::doubletPhi
int doubletPhi(const Identifier &id) const
Definition: RpcIdHelper.cxx:1055
ServiceHandle< ICondSvc >
RpcTrackAnaAlg::m_trigTagDefs
std::vector< TagDef > m_trigTagDefs
Definition: RpcTrackAnaAlg.h:206
collisions
Definition: collisions.py:1
Identifier
Definition: IdentifierFieldParser.cxx:14
RpcTrackAnaAlg::m_rpcPanelMap
RpcPanelMap m_rpcPanelMap
Definition: RpcTrackAnaAlg.h:204
Generated on Thu Apr 10 2025 21:39:51 for ATLAS Offline Software by   doxygen 1.8.18