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 | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MuonCombined::MuonCreatorTool Class Reference

#include <MuonCreatorTool.h>

Inheritance diagram for MuonCombined::MuonCreatorTool:
Collaboration diagram for MuonCombined::MuonCreatorTool:

Public Types

using InDetCandidateTagsMap = std::vector< InDetCandidateTags >
 
using InDetCandidateTags = std::pair< const InDetCandidate *, std::vector< const TagBase * > >
 

Public Member Functions

 MuonCreatorTool (const std::string &type, const std::string &name, const IInterface *parent)
 
 ~MuonCreatorTool ()=default
 
virtual StatusCode initialize () override final
 
virtual void create (const EventContext &ctx, const MuonCandidateCollection *muonCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps, OutputData &outputData) const override final
 IMuonCreatorTool interface: build muons from ID and MS candidates. More...
 
virtual xAOD::Muon * create (const EventContext &ctx, const MuonCandidate &candidate, OutputData &outputData) const override final
 IMuonCreatorTool interface: create a muon from a muon candidate. More...
 
virtual xAOD::Muon * create (const EventContext &ctx, InDetCandidateTags &candidate, OutputData &outputData) const override final
 IMuonCreatorTool interface: create a muon from a muon candidate. More...
 
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 sysInitialize () override
 Perform system initialization for an algorithm. 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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void create (const EventContext &ctx, const MuonCandidateCollection *muonCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps, OutputData &outputData, bool select_comissioning) const
 
void decorateDummyValues (const EventContext &ctx, xAOD::Muon &muon, OutputData &outputData) const
 De^corated a bunch of dummy values to the muon to ensure data consistency in the xAOD. More...
 
void addStatisticalCombination (const EventContext &ctx, xAOD::Muon &muon, const InDetCandidate *candidate, const StacoTag *tag, OutputData &outputData) const
 
void addCombinedFit (const EventContext &ctx, xAOD::Muon &muon, const CombinedFitTag *tag, OutputData &outputData) const
 
void addMuGirl (const EventContext &ctx, xAOD::Muon &muon, const MuGirlTag *tag, OutputData &outputData) const
 
void addMuGirlLowBeta (const EventContext &ctx, xAOD::Muon &muon, const MuGirlLowBetaTag *tag, xAOD::SlowMuon *slowMuon, OutputData &outputData) const
 
void addSegmentTag (const EventContext &ctx, xAOD::Muon &muon, const SegmentTag *tag, OutputData &outputData) const
 
void addCaloTag (xAOD::Muon &muon, const CaloTag *tag) const
 
void addMuonCandidate (const EventContext &ctx, const MuonCandidate &candidate, xAOD::Muon &muon, OutputData &outputData, const ElementLink< TrackCollection > &meLink=ElementLink< TrackCollection >()) const
 add muon candidate info to a muon, if an updateExtrapolatedTrack is provided, the routine takes ownership of the track. More...
 
ElementLink< xAOD::TrackParticleContainer > createTrackParticleElementLink (const ElementLink< TrackCollection > &trackLink, xAOD::TrackParticleContainer &trackParticleContainer, TrackCollection *trackCollection=0) const
 function creates an element link to a track particle from the track and the TrackParticle collection. More...
 
ElementLink< xAOD::MuonSegmentContainer > createMuonSegmentElementLink (const EventContext &ctx, const Muon::MuonSegment *segLink, const OutputData &outData) const
 
void resolveOverlaps (const EventContext &ctx, const MuonCandidateCollection *muonCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps, InDetCandidateTagsMap &resolvedInDetCandidates, std::vector< const MuonCombined::MuonCandidate * > &resolvedMuonCandidates, bool select_comissioning=false) const
 
void selectStaus (InDetCandidateTagsMap &resolvedInDetCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps) const
 
std::unique_ptr< Trk::Track > createDummyTrack (const EventContext &ctx, const std::vector< const Muon::MuonSegment * > &segments, const Trk::Track &indetTrack) const
 
void setMuonHitCounts (xAOD::Muon &muon) const
 
bool dressMuon (xAOD::Muon &muon) const
 
void addEnergyLossToMuon (xAOD::Muon &muon) const
 
void fillEnergyLossFromTrack (xAOD::Muon &muon, const std::vector< const Trk::TrackStateOnSurface * > *tsosVector) const
 
void setP4 (xAOD::Muon &muon, const xAOD::TrackParticle &tp) const
 
void collectCells (const EventContext &ctx, xAOD::Muon &muon, xAOD::CaloClusterContainer *clusterContainer, const Trk::CaloExtension *inputCaloExt=nullptr) 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

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
 
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
 
ToolHandle< Rec::IMuonPrintingTool > m_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
 
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtTool
 
ToolHandle< Trk::ITrackParticleCreatorTool > m_particleCreator
 
ToolHandle< Trk::ITrackAmbiguityProcessorTool > m_ambiguityProcessor {this, "AmbiguityProcessor", ""}
 
ToolHandle< Trk::IPropagator > m_propagator {this, "Propagator", "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator"}
 
ToolHandle< xAOD::IMuonDressingTool > m_muonDressingTool {this, "MuonDressingTool", "MuonCombined::MuonDressingTool/MuonDressingTool"}
 
ToolHandle< Rec::IMuonMomentumBalanceSignificance > m_momentumBalanceTool
 
ToolHandle< Rec::IMuonScatteringAngleSignificance > m_scatteringAngleTool
 
ToolHandle< CP::IMuonSelectionTool > m_selectorTool {this, "MuonSelectionTool", "CP::MuonSelectionTool/MuonSelectionTool"}
 
ToolHandle< Rec::IMuonMeanMDTdADCFiller > m_meanMDTdADCTool
 
ToolHandle< Trk::ITrkMaterialProviderTool > m_caloMaterialProvider
 
ToolHandle< Rec::IMuonTrackQuery > m_trackQuery {this, "TrackQuery", "Rec::MuonTrackQuery/MuonTrackQuery"}
 
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
 
Rec::CaloCellCollector m_cellCollector
 
SG::ReadHandleKey< CaloCellContainer > m_cellContainerName {this, "CaloCellContainer", "AllCalo", "calo cells"}
 
SG::ReadCondHandleKey< CaloNoise > m_caloNoiseKey {this, "CaloNoise", "", "CaloNoise object to use, or blank."}
 
Gaudi::Property< bool > m_buildStauContainer {this, "BuildStauContainer", false, "flag to decide whether to build stau or not"}
 
Gaudi::Property< bool > m_addMDTExtrasMuGirlLowBeta {this, "AddMDTExtrasMuGirlLowBeta", false}
 
Gaudi::Property< bool > m_fillEnergyLossFromTrack
 
Gaudi::Property< bool > m_fillExtraELossInfo
 
Gaudi::Property< bool > m_printSummary {this, "PrintSummary", false, "flag to print muon edm"}
 
Gaudi::Property< bool > m_useUpdatedExtrapolatedTrack
 
Gaudi::Property< bool > m_segLowBeta {this, "AssociateSegmentsToLowBetaMuons", false, "associate segments to MuGirlLowBeta muons"}
 
Gaudi::Property< bool > m_useCaloCells {this, "UseCaloCells", true}
 
Gaudi::Property< bool > m_doSA {this, "MakeSAMuons", false}
 
Gaudi::Property< bool > m_requireIDTracks {this, "RequireIDTrack", false}
 In case of running the muon reconstruction with LRT tracks this property removes the overlap of muons in the container in which in any case no ID track is available. More...
 
Gaudi::Property< float > m_sigmaCaloNoiseCut {this, "SigmaCaloNoiseCut", 3.4}
 
Gaudi::Property< std::vector< std::string > > m_copyFloatSummaryKeys
 
Gaudi::Property< std::vector< std::string > > m_copyCharSummaryKeys
 
Gaudi::Property< bool > m_requireMSOEforSA
 
Gaudi::Property< bool > m_requireCaloDepositForSA
 
std::vector< std::unique_ptr< SG::AuxElement::Accessor< float > > > m_copyFloatSummaryAccessors
 
std::vector< std::unique_ptr< SG::AuxElement::Accessor< uint8_t > > > m_copyCharSummaryAccessors
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager"}
 
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 60 of file MuonCreatorTool.h.

Member Typedef Documentation

◆ InDetCandidateTags

using MuonCombined::IMuonCreatorTool::InDetCandidateTags = std::pair<const InDetCandidate*, std::vector<const TagBase*> >
inherited

Definition at line 35 of file IMuonCreatorTool.h.

◆ InDetCandidateTagsMap

using MuonCombined::MuonCreatorTool::InDetCandidateTagsMap = std::vector<InDetCandidateTags>

Definition at line 62 of file MuonCreatorTool.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonCreatorTool()

MuonCombined::MuonCreatorTool::MuonCreatorTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 56 of file MuonCreatorTool.cxx.

56  :
57  AthAlgTool(type, name, parent) {
58  declareInterface<IMuonCreatorTool>(this);
59  }

◆ ~MuonCreatorTool()

MuonCombined::MuonCreatorTool::~MuonCreatorTool ( )
default

Member Function Documentation

◆ addCaloTag()

void MuonCombined::MuonCreatorTool::addCaloTag ( xAOD::Muon &  muon,
const CaloTag *  tag 
) const
private

Definition at line 720 of file MuonCreatorTool.cxx.

720  {
721  static const SG::Accessor<float> acc_ElType("CT_EL_Type"); // FIXME - should be uint
722  static const SG::Accessor<float> acc_ElFSREnergy("CT_ET_FSRCandidateEnergy");
723 
724  if (!tag) {
725  // init variables if necessary.
726 
727  mu.setParameter(0.f, xAOD::Muon::CaloMuonScore);
728  mu.setParameter(static_cast<int>(0xFF), xAOD::Muon::CaloMuonIDTag);
729  if (m_fillExtraELossInfo) {
730  // Here we can make sure that we store the extra calotag information -
731  // just always add it since this is then unambigious for debugging
732  acc_ET_Core(mu) = 0.0;
733  acc_ElType(mu) = -999.0;
734  acc_ElFSREnergy(mu) = -999.0;
735  }
736  return;
737  }
738 
739  ATH_MSG_DEBUG("Adding Calo Muon with author " << tag->author() << ", type " << tag->type() << ", CaloMuonScore "
740  << tag->caloMuonScore());
741  mu.setParameter(static_cast<float>(tag->caloMuonScore()), xAOD::Muon::CaloMuonScore);
742  mu.setParameter(static_cast<int>(tag->caloMuonIdTag()), xAOD::Muon::CaloMuonIDTag);
743 
744  if (m_fillExtraELossInfo) {
745  // Here we can make sure that we store the extra calotag information - just
746  // always add it since this is then unambigious for debugging
747  acc_ET_Core(mu) = tag->etCore();
748  acc_ElType(mu) = tag->energyLossType();
749  acc_ElFSREnergy(mu) = tag->fsrCandidateEnergy();
750  }
751  // FIXME - calo deposits
752  }

◆ addCombinedFit()

void MuonCombined::MuonCreatorTool::addCombinedFit ( const EventContext &  ctx,
xAOD::Muon &  muon,
const CombinedFitTag *  tag,
OutputData &  outputData 
) const
private

Definition at line 486 of file MuonCreatorTool.cxx.

487  {
488  if (!tag) {
489  // init variables if necessary.
490  return;
491  }
492 
493  ATH_MSG_DEBUG("Adding Combined fit Muon " << tag->author() << " type " << tag->type());
494  if (!muon.combinedTrackParticleLink().isValid()) {
495  // if the combined track particle is part of a container set the link
496  if (outputData.combinedTrackParticleContainer) {
497  // create element link from the track
498  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
499  tag->combinedTrackLink(), *outputData.combinedTrackParticleContainer, outputData.combinedTrackCollection);
500 
501  if (link.isValid()) {
502  // link.toPersistent();
503  ATH_MSG_DEBUG("Adding combined fit: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
504  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
505  } else
506  ATH_MSG_WARNING("Creating of Combined TrackParticle Link failed");
507  }
508  }
509  // add muon candidate
510  addMuonCandidate(ctx, tag->muonCandidate(), muon, outputData, tag->updatedExtrapolatedTrackLink());
511 
512  // Add inner match chi^2
513  const float inner_chi2 = tag->matchChi2();
514  muon.setParameter(tag->matchDoF(), xAOD::Muon::msInnerMatchDOF);
515  muon.setParameter(inner_chi2, xAOD::Muon::msInnerMatchChi2);
516 
517  ATH_MSG_DEBUG("Done adding Combined Fit Muon " << tag->author() << " type " << tag->type());
518  }

◆ addEnergyLossToMuon()

void MuonCombined::MuonCreatorTool::addEnergyLossToMuon ( xAOD::Muon &  muon) const
private

Definition at line 1273 of file MuonCreatorTool.cxx.

1273  {
1274  if (!muon.inDetTrackParticleLink().isValid()) {
1275  ATH_MSG_WARNING("Missing ID track particle link in addEnergyLossToMuon!");
1276  return;
1277  }
1278 
1279  // get ID track particle
1280  const Trk::Track* trk = (*(muon.inDetTrackParticleLink()))->track();
1281  if (!trk) {
1282  ATH_MSG_WARNING("Missing ID trk::track in addEnergyLossToMuon!");
1283  return;
1284  }
1285 
1286  // find last ID TSOS with track parameters
1287  const Trk::TrackStateOnSurface* lastID = nullptr;
1288  Trk::TrackStates::const_reverse_iterator it = trk->trackStateOnSurfaces()->rbegin();
1289  Trk::TrackStates::const_reverse_iterator itEnd = trk->trackStateOnSurfaces()->rend();
1290  for (; it != itEnd; ++it) {
1291  if ((*it)->trackParameters()) {
1292  lastID = *it;
1293  break;
1294  }
1295  }
1296  if (!lastID) {
1297  ATH_MSG_WARNING("Missing ID TSOS with track parameters in addEnergyLossToMuon!");
1298  return;
1299  }
1300 
1301  // get calorimeter TSOS
1302  std::vector<const Trk::TrackStateOnSurface*>* caloTSOS = m_caloMaterialProvider->getCaloTSOS(*((*it)->trackParameters()), *trk);
1303 
1304  if (!caloTSOS) {
1305  ATH_MSG_WARNING("Unable to find calo TSOS in addEnergyLossToMuon!");
1306  return;
1307  }
1308 
1309  // fill muon parameters for eloss
1310  fillEnergyLossFromTrack(muon, caloTSOS);
1311 
1312  // delete caloTSOS
1313  std::vector<const Trk::TrackStateOnSurface*>::const_iterator it2 = caloTSOS->begin();
1314  std::vector<const Trk::TrackStateOnSurface*>::const_iterator itEnd2 = caloTSOS->end();
1315  for (; it2 != itEnd2; ++it2) delete *it2;
1316  delete caloTSOS;
1317  }

◆ addMuGirl()

void MuonCombined::MuonCreatorTool::addMuGirl ( const EventContext &  ctx,
xAOD::Muon &  muon,
const MuGirlTag *  tag,
OutputData &  outputData 
) const
private

Definition at line 629 of file MuonCreatorTool.cxx.

629  {
630  if (!tag) {
631  // init variables if necessary.
632  return;
633  }
634 
635  ATH_MSG_DEBUG("Adding MuGirl Muon " << tag->author() << " type " << tag->type());
636 
637  if (!muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()) {
638  // if the combined track particle is part of a container set the link
639  if (outputData.combinedTrackParticleContainer) {
640  // create element link
641  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
642  tag->combinedTrackLink(), *outputData.combinedTrackParticleContainer, outputData.combinedTrackCollection);
643 
644  if (link.isValid()) {
645  // link.toPersistent();
646  ATH_MSG_DEBUG("Adding MuGirl: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
647  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
648  } else
649  ATH_MSG_WARNING("Creating of MuGirl TrackParticle Link failed");
650  }
651 
652  if (outputData.extrapolatedTrackParticleContainer && tag->updatedExtrapolatedTrack()) {
653  // create element link
654  ElementLink<xAOD::TrackParticleContainer> link =
655  createTrackParticleElementLink(tag->updatedExtrapolatedTrackLink(), *outputData.extrapolatedTrackParticleContainer,
656  outputData.extrapolatedTrackCollection);
657 
658  if (link.isValid()) {
659  ATH_MSG_DEBUG("Adding MuGirl: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
660  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
661  } else
662  ATH_MSG_WARNING("Creating of MuGirl TrackParticle Link failed");
663  }
664 
665  if (outputData.xaodSegmentContainer) {
666  ATH_MSG_DEBUG("Adding MuGirl muonSegmentCollection");
667 
668  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
669  for (const Muon::MuonSegment* segLink : tag->associatedSegments()) {
670  ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(ctx, segLink, outputData);
671  if (link.isValid()) {
672  segments.push_back(link);
673  ATH_MSG_DEBUG("Adding MuGirl: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz "
674  << (*link)->pz());
675  } else
676  ATH_MSG_WARNING("Creating of MuGirl segment Link failed");
677  }
678  muon.setMuonSegmentLinks(segments);
679  }
680  }
681  ATH_MSG_DEBUG("Done Adding MuGirl Muon " << tag->author() << " type " << tag->type());
682  }

◆ addMuGirlLowBeta()

void MuonCombined::MuonCreatorTool::addMuGirlLowBeta ( const EventContext &  ctx,
xAOD::Muon &  muon,
const MuGirlLowBetaTag *  tag,
xAOD::SlowMuon *  slowMuon,
OutputData &  outputData 
) const
private

Definition at line 520 of file MuonCreatorTool.cxx.

524  {
525  if (!tag) {
526  // init variables if necessary.
527  return;
528  }
529 
530  ATH_MSG_DEBUG("Adding MuGirlLowBeta Muon " << tag->author() << " type " << tag->type());
531 
532  // get stauExtras and write to slowMuon
533  const MuGirlNS::StauExtras* stauExtras = tag->getStauExtras();
534  if (slowMuon && stauExtras) {
535  ATH_MSG_VERBOSE("StauSummary beta " << stauExtras->betaAll<<" "<<stauExtras->betaAllt);
536  slowMuon->setBeta(stauExtras->betaAll);
537  slowMuon->setBetaT(stauExtras->betaAllt);
538  slowMuon->setAnn(stauExtras->ann);
539  slowMuon->setNRpcHits(stauExtras->numRpcHitsInSeg);
540  slowMuon->setNTileCells(stauExtras->numCaloCells);
541  slowMuon->setRpcInfo(stauExtras->rpcBetaAvg, stauExtras->rpcBetaRms, stauExtras->rpcBetaChi2, stauExtras->rpcBetaDof);
542  slowMuon->setMdtInfo(stauExtras->mdtBetaAvg, stauExtras->mdtBetaRms, stauExtras->mdtBetaChi2, stauExtras->mdtBetaDof);
543  slowMuon->setCaloInfo(stauExtras->caloBetaAvg, stauExtras->caloBetaRms, stauExtras->caloBetaChi2, stauExtras->caloBetaDof);
544  static const SG::Accessor<std::vector<uint8_t> > eTechAcc ("hitTechnology");
545  static const SG::Accessor<std::vector<unsigned int> > idAcc ("hitIdentifier");
546  static const SG::Accessor<std::vector<float> > mToFAcc ("hitTOF");
547  static const SG::Accessor<std::vector<float> > xAcc ("hitPositionX");
548  static const SG::Accessor<std::vector<float> > yAcc ("hitPositionY");
549  static const SG::Accessor<std::vector<float> > zAcc ("hitPositionZ");
550  static const SG::Accessor<std::vector<float> > eAcc ("hitEnergy");
551  static const SG::Accessor<std::vector<float> > errorAcc ("hitError");
552  static const SG::Accessor<std::vector<float> > shiftAcc ("hitShift");
553  static const SG::Accessor<std::vector<float> > propTimeAcc ("hitPropagationTime");
554 
555  std::vector<uint8_t>& eTechVec = eTechAcc(*slowMuon);
556  std::vector<unsigned int>& idVec = idAcc(*slowMuon);
557  std::vector<float>& mToFVec = mToFAcc(*slowMuon);
558  std::vector<float>& xVec = xAcc(*slowMuon);
559  std::vector<float>& yVec = yAcc(*slowMuon);
560  std::vector<float>& zVec = zAcc(*slowMuon);
561  std::vector<float>& eVec = eAcc(*slowMuon);
562  std::vector<float>& errorVec = errorAcc(*slowMuon);
563  std::vector<float>& shiftVec = shiftAcc(*slowMuon);
564  std::vector<float>& propagationTimeVec = propTimeAcc(*slowMuon);
565 
566  for (const auto& hit : stauExtras->hits) {
567  eTechVec.push_back(hit.eTech);
568  idVec.push_back(hit.id.get_identifier32().get_compact());
569  mToFVec.push_back(hit.mToF);
570  xVec.push_back(hit.x);
571  yVec.push_back(hit.y);
572  zVec.push_back(hit.z);
573  eVec.push_back(hit.e);
574  errorVec.push_back(hit.error);
575  shiftVec.push_back(hit.shift);
576  propagationTimeVec.push_back(hit.propagationTime);
577  }
578 
579  // additional MDT hit info (optional)
580  if (m_addMDTExtrasMuGirlLowBeta) {
581  static const SG::Accessor<std::vector<int> > adcAcc ("hitAdc");
582  static const SG::Accessor<std::vector<float> > rdriftAcc ("hitDriftRadius");
583 
584  std::vector<int>& adcVec = adcAcc(*slowMuon);
585  std::vector<float>& rdriftVec = rdriftAcc(*slowMuon);
586 
587  if (stauExtras->extraMDTHitInfo) { // check if extra MDT hit info added
588  for (const auto& extraMDTinfo : *stauExtras->extraMDTHitInfo) {
589  adcVec.push_back(extraMDTinfo.adc);
590  rdriftVec.push_back(extraMDTinfo.rdrift);
591  }
592  }
593  }
594 
595 
596  }
597 
598  if (!muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()) {
599  // if the combined track particle is part of a container set the link
600  if (outputData.combinedTrackParticleContainer) {
601  // create element link
602  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
603  tag->combinedTrackLink(), *outputData.combinedTrackParticleContainer, outputData.combinedTrackCollection);
604 
605  if (link.isValid()) {
606  ATH_MSG_DEBUG("Adding MuGirlLowBeta: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
607  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
608  } else
609  ATH_MSG_WARNING("Creating of MuGirlLowBeta TrackParticle Link failed");
610  }
611  }
612 
613  if (outputData.xaodSegmentContainer) {
614  ATH_MSG_DEBUG("Adding MuGirlLowBeta muonSegmentColection");
615  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
616  for (const ElementLink<Trk::SegmentCollection>& seglink : tag->segments()) {
617  ElementLink<xAOD::MuonSegmentContainer> link{*outputData.xaodSegmentContainer, seglink.index(), ctx};
618  if (link.isValid()) {
619  segments.push_back(link);
620  ATH_MSG_DEBUG("Adding MuGirlLowBeta: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz "
621  << (*link)->pz());
622  } else
623  ATH_MSG_WARNING("Creating of MuGirlLowBeta segment Link failed");
624  }
625  muon.setMuonSegmentLinks(segments);
626  }
627  }

◆ addMuonCandidate()

void MuonCombined::MuonCreatorTool::addMuonCandidate ( const EventContext &  ctx,
const MuonCandidate &  candidate,
xAOD::Muon &  muon,
OutputData &  outputData,
const ElementLink< TrackCollection > &  meLink = ElementLink<TrackCollection>() 
) const
private

add muon candidate info to a muon, if an updateExtrapolatedTrack is provided, the routine takes ownership of the track.

The track will be used instead of the extrapolatedTrack of the MuonCandidate. The extrapolatedTrack of the MuonCandidate will be release during the operation.

Definition at line 797 of file MuonCreatorTool.cxx.

798  {
799  if (!muon.nMuonSegments()) {
800  std::vector< ElementLink<xAOD::MuonSegmentContainer>> segments;
801  for (const Muon::MuonSegment* segLink : candidate.getSegments()) {
802  ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(ctx, segLink, outputData);
803  if (link.isValid()) {
804  segments.push_back(link);
805  ATH_MSG_DEBUG("Adding MuGirl: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz "
806  << (*link)->pz());
807  } else
808  ATH_MSG_WARNING("Creating of Muon candidate segment failed "<<candidate.toString());
809 
810  }
811  muon.setMuonSegmentLinks(segments);
812  }
813  // only set once
814  if (muon.muonSpectrometerTrackParticleLink().isValid()) { return; }
815  // case where we have a MuGirl muon that is also reconstructed by STACO: don't
816  // want to add this track as it is misleading however, we will still keep the
817  // MS-only extrapolated track (see below) for debugging purposes
818  if (muon.author() != xAOD::Muon::MuGirl)
819  muon.setTrackParticleLink(xAOD::Muon::MuonSpectrometerTrackParticle, candidate.muonSpectrometerTrackLink());
820 
821  // we need both the container and the extrapolated muon track to add the link
822  if (!outputData.extrapolatedTrackParticleContainer || (!candidate.extrapolatedTrack() && !meLink.isValid())) { return; }
823 
824  const Trk::Track* extrapolatedTrack = candidate.extrapolatedTrack();
825 
826  if (!extrapolatedTrack || !extrapolatedTrack->perigeeParameters()) {
827  ATH_MSG_DEBUG("There is no extrapolated track associated to the MuonCandidate.");
828  if (muon.author() == xAOD::Muon::MuidCo) { // this can happen for MuidCo muons, though it's
829  // quite rare: in this case just add the ME track
830  if (meLink.isValid()) {
831  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
832  meLink, *outputData.extrapolatedTrackParticleContainer, outputData.extrapolatedTrackCollection);
833  if (link.isValid()) {
834  ATH_MSG_DEBUG("Adding standalone fit (refitted): pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi "
835  << (*link)->phi());
836  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
837  float fieldInt = m_trackQuery->fieldIntegral(**meLink, ctx).betweenSpectrometerMeasurements();
838  muon.setParameter(fieldInt, xAOD::Muon::spectrometerFieldIntegral);
839  int nunspoiled = (*link)->track()->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
840  acc_nUnspoiledCscHits(muon) = nunspoiled;
841  }
842  }
843  } else { // I don't think we should ever get here, but just in case
844  if (!extrapolatedTrack) ATH_MSG_WARNING("Track doesn't have extrapolated track. Skipping");
845  if (extrapolatedTrack && !extrapolatedTrack->perigeeParameters())
846  ATH_MSG_WARNING(
847  "Track doesn't have perigee parameters on extrapolated "
848  "track. Skipping");
849  }
850  } else {
851  // Now we just add the original extrapolated track itself
852  // but not for SA muons, for consistency they will still have
853  // extrapolatedTrackParticle
854  if (muon.muonType() != xAOD::Muon::MuonStandAlone) {
855  if (meLink.isValid()) { // add ME track and MS-only extrapolated track
856  if (outputData.msOnlyExtrapolatedTrackParticleContainer) { // add un-refitted
857  // extrapolated track
858  // as MS-only
859  // extrapolated track
860  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
861  candidate.extrapolatedTrackLink(), *outputData.msOnlyExtrapolatedTrackParticleContainer,
862  outputData.msOnlyExtrapolatedTrackCollection);
863 
864  if (link.isValid()) {
865  ATH_MSG_DEBUG("Adding MS-only extrapolated track: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi "
866  << (*link)->phi());
867  // link.toPersistent();
868  muon.setTrackParticleLink(xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, link);
869  } else
870  ATH_MSG_WARNING("failed to create MS-only extrapolated track particle");
871  }
872  // now add refitted track as ME track
873  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
874  meLink, *outputData.extrapolatedTrackParticleContainer, outputData.extrapolatedTrackCollection);
875  if (link.isValid()) {
876  ATH_MSG_DEBUG("Adding standalone fit (refitted): pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi "
877  << (*link)->phi());
878  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
879  float fieldInt = m_trackQuery->fieldIntegral(**meLink, ctx).betweenSpectrometerMeasurements();
880  muon.setParameter(fieldInt, xAOD::Muon::spectrometerFieldIntegral);
881  int nunspoiled = (*link)->track()->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
882  acc_nUnspoiledCscHits(muon) = nunspoiled;
883  }
884  } else { // no refitted track, so add original un-refitted extrapolated
885  // track as ME track
886  if (muon.author() == xAOD::Muon::MuGirl && muon.extrapolatedMuonSpectrometerTrackParticleLink().isValid()) {
887  // MuGirl case: ME track is already set, but now we have the
888  // extrapolated track from the STACO tag add this as the MS-only
889  // extrapolated track instead
890  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
891  candidate.extrapolatedTrackLink(), *outputData.msOnlyExtrapolatedTrackParticleContainer,
892  outputData.msOnlyExtrapolatedTrackCollection);
893 
894  if (link.isValid()) {
895  ATH_MSG_DEBUG("Adding MS-only extrapolated track to MuGirl muon: pt "
896  << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
897  // link.toPersistent();
898  muon.setTrackParticleLink(xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, link);
899  float fieldInt =
900  m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink(), ctx).betweenSpectrometerMeasurements();
901  muon.setParameter(fieldInt, xAOD::Muon::spectrometerFieldIntegral);
902  }
903  } else {
904  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
905  candidate.extrapolatedTrackLink(), *outputData.extrapolatedTrackParticleContainer,
906  outputData.extrapolatedTrackCollection);
907 
908  if (link.isValid()) {
909  ATH_MSG_DEBUG("Adding standalone fit (un-refitted): pt " << (*link)->pt() << " eta " << (*link)->eta()
910  << " phi " << (*link)->phi());
911  // link.toPersistent();
912  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
913  float fieldInt =
914  m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink(), ctx).betweenSpectrometerMeasurements();
915  muon.setParameter(fieldInt, xAOD::Muon::spectrometerFieldIntegral);
916  }
917  }
918  }
919  } else { // SA tracks only get un-refitted track as ME track
920  // create element link from the track
921  ElementLink<xAOD::TrackParticleContainer> link =
922  createTrackParticleElementLink(candidate.extrapolatedTrackLink(), *outputData.extrapolatedTrackParticleContainer,
923  outputData.extrapolatedTrackCollection);
924 
925  if (link.isValid()) {
926  ATH_MSG_DEBUG("Adding standalone fit: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
927  // link.toPersistent();
928  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
929  float fieldInt =
930  m_trackQuery->fieldIntegral(**candidate.extrapolatedTrackLink(), ctx).betweenSpectrometerMeasurements();
931  muon.setParameter(fieldInt, xAOD::Muon::spectrometerFieldIntegral);
932  int nunspoiled = extrapolatedTrack->trackSummary()->get(Trk::numberOfCscUnspoiltEtaHits);
933  acc_nUnspoiledCscHits(muon) = nunspoiled;
934  } else {
935  ATH_MSG_WARNING("failed to create ME track particle for SA muon");
936  }
937  }
938  }
939  }

◆ addSegmentTag()

void MuonCombined::MuonCreatorTool::addSegmentTag ( const EventContext &  ctx,
xAOD::Muon &  muon,
const SegmentTag *  tag,
OutputData &  outputData 
) const
private

Definition at line 684 of file MuonCreatorTool.cxx.

684  {
685  if (!tag) {
686  // init variables if necessary.
687  muon.setParameter(-1.f, xAOD::Muon::segmentDeltaEta);
688  muon.setParameter(-1.f, xAOD::Muon::segmentDeltaPhi);
689  muon.setParameter(-1.f, xAOD::Muon::segmentChi2OverDoF);
690  return;
691  }
692 
693  ATH_MSG_DEBUG("Adding Segment Tag Muon " << tag->author() << " type " << tag->type());
694 
695  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
696  bool foundseg = false;
697  for (const auto& info : tag->segmentsInfo()) {
698  // this is a bit tricky, as we have here a link to an xAOD segment in the old container
699  // but the new container should have the segments in the same order, plus the MuGirl ones tacked on the end
700  // so we should be able to just make a new link here
701  // note that this only applies to segment-tagged muons, others get their associated segments elsewhere
702  if (muon.author() == xAOD::Muon::MuTagIMO) {
703  ElementLink<xAOD::MuonSegmentContainer> seglink = createMuonSegmentElementLink(ctx, info.segment, outputData);
704  if (seglink.isValid()) segments.push_back(seglink);
705  }
706 
707  if (!foundseg) { // add parameters for the first segment
708  muon.setParameter(static_cast<float>(info.dtheta), xAOD::Muon::segmentDeltaEta);
709  muon.setParameter(static_cast<float>(info.dphi), xAOD::Muon::segmentDeltaPhi);
710  muon.setParameter(static_cast<float>(info.segment->fitQuality()->chiSquared() / info.segment->fitQuality()->numberDoF()),
711  xAOD::Muon::segmentChi2OverDoF);
712  foundseg = true;
713  } else if (muon.author() != xAOD::Muon::MuTagIMO)
714  break; // for non-segment-tagged muons, we only need to set the above
715  // parameters
716  }
717  if (muon.author() == xAOD::Muon::MuTagIMO) muon.setMuonSegmentLinks(segments); // set the associated segments
718  }

◆ addStatisticalCombination()

void MuonCombined::MuonCreatorTool::addStatisticalCombination ( const EventContext &  ctx,
xAOD::Muon &  muon,
const InDetCandidate *  candidate,
const StacoTag *  tag,
OutputData &  outputData 
) const
private

Also add this decoration to maintain data-format consistency to the combined track particles (cf. ATLASRECTS-6454)

Definition at line 389 of file MuonCreatorTool.cxx.

390  {
391  static const SG::Accessor<float> acc_d0("d0_staco");
392  static const SG::Accessor<float> acc_z0("z0_staco");
393  static const SG::Accessor<float> acc_phi0("phi0_staco");
394  static const SG::Accessor<float> acc_theta("theta_staco");
395  static const SG::Accessor<float> acc_qOverP("qOverP_staco");
396  static const SG::Accessor<float> acc_qOverPerr("qOverPErr_staco");
397 
398  if (!tag) {
399  // init variables if necessary.
400  acc_d0(muon) = -999;
401  acc_z0(muon) = -999;
402  acc_phi0(muon) = -999;
403  acc_theta(muon) = -999;
404  acc_qOverP(muon) = -999;
405  acc_qOverPerr(muon) = -999.;
406  return;
407  }
408 
409  ATH_MSG_DEBUG("Adding Staco Muon " << tag->author() << " type " << tag->type());
410 
411  if (!muon.combinedTrackParticleLink().isValid()) {
412  // create primary track particle
413  // get summary
414  const Trk::Track* idTrack = candidate->indetTrackParticle().track();
415  const Trk::Track* msTrack = tag->muonCandidate().extrapolatedTrack() ? tag->muonCandidate().extrapolatedTrack()
416  : &tag->muonCandidate().muonSpectrometerTrack();
417 
418  const Trk::TrackSummary* idSummary = idTrack ? idTrack->trackSummary() : nullptr;
419  const Trk::TrackSummary* msSummary = msTrack->trackSummary();
420 
421  Trk::TrackSummary summary;
422  if (idSummary) summary += *idSummary;
423  if (msSummary) summary += *msSummary;
424 
425  Trk::FitQuality fq(tag->matchChi2(), 5);
426  Trk::TrackInfo info(msTrack->info());
427  // todo update patrec bit set adding ID values
428 
429  if (outputData.combinedTrackParticleContainer) {
430  xAOD::TrackParticle* tp = m_particleCreator->createParticle(ctx, &tag->combinedParameters(), &fq, &info, &summary, {}, {},
431  xAOD::muon, outputData.combinedTrackParticleContainer);
432  if (!tp) {
433  ATH_MSG_WARNING("Failed to create track particle");
434  } else {
437  std::vector<float> dummy_cov(15, 0.);
438  tp->setTrackParameterCovarianceMatrix(0, dummy_cov);
439 
440  ElementLink<xAOD::TrackParticleContainer> link(*outputData.combinedTrackParticleContainer,
441  outputData.combinedTrackParticleContainer->size() - 1);
442  if (link.isValid()) {
443  // link.toPersistent();
444  ATH_MSG_DEBUG("Adding statistical combination: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi "
445  << (*link)->phi());
446  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
447  }
448  // for the purpose of the truth matching, set the track link to point to
449  // the ID track
450  // tp->setTrackLink(candidate.indetTrackParticle().trackLink());
451  tp->setTrackLink(ElementLink<TrackCollection>());
452  std::bitset<xAOD::NumberOfTrackRecoInfo> pattern;
453  pattern.set(xAOD::STACO);
454  tp->setPatternRecognitionInfo(pattern);
455 
456  const xAOD::TrackParticle &id_track_particle = candidate->indetTrackParticle();
457  for (const std::unique_ptr< SG::Accessor<float> > &accessor : m_copyFloatSummaryAccessors ) {
458  (*accessor)( *tp ) = (*accessor)( id_track_particle );
459  }
460  for (const std::unique_ptr< SG::Accessor<uint8_t> > &accessor : m_copyCharSummaryAccessors ) {
461  (*accessor)( *tp ) = (*accessor)( id_track_particle );
462  }
463 
464  }
465  } // endif outputData.combinedTrackParticleContainer
466  }
467 
468  // add muon candidate
469  addMuonCandidate(ctx, tag->muonCandidate(), muon, outputData);
470 
471  // Add inner match chi^2
472  muon.setParameter(5, xAOD::Muon::msInnerMatchDOF);
473  muon.setParameter(static_cast<float>(tag->matchChi2()), xAOD::Muon::msInnerMatchChi2);
474 
475  // STACO parameters added as auxdata
476  acc_d0(muon) = tag->combinedParameters().parameters()[Trk::d0];
477  acc_z0(muon) = tag->combinedParameters().parameters()[Trk::z0];
478  acc_phi0(muon) = tag->combinedParameters().parameters()[Trk::phi0];
479  acc_theta(muon) = tag->combinedParameters().parameters()[Trk::theta];
480  acc_qOverP(muon) = tag->combinedParameters().parameters()[Trk::qOverP];
481  acc_qOverPerr(muon) = Amg::error(*tag->combinedParameters().covariance(), Trk::qOverP);
482 
483  ATH_MSG_DEBUG("Done adding Staco Muon " << tag->author() << " type " << tag->type());
484  }

◆ collectCells()

void MuonCombined::MuonCreatorTool::collectCells ( const EventContext &  ctx,
xAOD::Muon &  muon,
xAOD::CaloClusterContainer *  clusterContainer,
const Trk::CaloExtension *  inputCaloExt = nullptr 
) const
private

Definition at line 1366 of file MuonCreatorTool.cxx.

1367  {
1368  const xAOD::TrackParticle* tp = muon.primaryTrackParticle();
1369  if (!tp || !clusterContainer) {
1370  if (!tp) ATH_MSG_WARNING("Can not get primary track.");
1371  return;
1372  }
1373 
1374  // get ParticleCellAssociation
1375  ATH_MSG_DEBUG(" Selected track: pt " << tp->pt() << " eta " << tp->eta() << " phi " << tp->phi());
1376 
1377  xAOD::CaloCluster* cluster = nullptr;
1378  SG::ReadHandle<CaloCellContainer> container(m_cellContainerName, ctx);
1379 
1380  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
1381  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
1382 
1383  if (!inputCaloExt) { // need to make one
1384  // for some reason, ID tracks need to be extrapolated from the ID exit, and
1385  // combined from the perigee
1386  std::unique_ptr<Trk::CaloExtension> caloExtension = m_caloExtTool->caloExtension(ctx, *tp);
1387  if (!caloExtension) {
1388  ATH_MSG_WARNING("Cannot get caloExtension.");
1389  return;
1390  }
1391  if (caloExtension->caloLayerIntersections().empty())
1392  ATH_MSG_DEBUG("Received a caloExtension object without track extrapolation");
1393 
1394  cluster = m_cellCollector.collectCells(*caloExtension, caloDDMgr, *container, *clusterContainer);
1395  } else
1396  cluster = m_cellCollector.collectCells(*inputCaloExt, caloDDMgr, *container, *clusterContainer);
1397 
1398  if (!cluster) {
1399  ATH_MSG_DEBUG("Failed to create cluster from ParticleCellAssociation");
1400  return;
1401  } else {
1402  ATH_MSG_DEBUG(" New cluster: eta " << cluster->eta() << " phi " << cluster->phi() << " cells " << cluster->size());
1403  }
1404 
1405  // create element links
1406  ElementLink<xAOD::CaloClusterContainer> clusterLink(*clusterContainer, cluster->index(), ctx);
1407  muon.setClusterLink(clusterLink);
1408  const CaloNoise* caloNoise = nullptr;
1409  if (!m_caloNoiseKey.empty()) {
1410  SG::ReadCondHandle<CaloNoise> noiseH(m_caloNoiseKey, ctx);
1411  caloNoise = noiseH.cptr();
1412  }
1413  // collect the core energy
1414  std::vector<float> etcore(4, 0);
1415  m_cellCollector.collectEtCore(*cluster, etcore, caloNoise, m_sigmaCaloNoiseCut);
1416 
1417  acc_ET_Core(muon) = etcore[Rec::CaloCellCollector::ET_Core];
1418  acc_ET_EMCore(muon) = etcore[Rec::CaloCellCollector::ET_EMCore];
1419  acc_ET_TileCore(muon) = etcore[Rec::CaloCellCollector::ET_TileCore];
1420  acc_ET_HECCore(muon) = etcore[Rec::CaloCellCollector::ET_HECCore];
1421  if (m_caloNoiseKey.empty())
1422  ATH_MSG_DEBUG("NO Tool for calo noise,sigma: " << m_sigmaCaloNoiseCut);
1423  else
1424  ATH_MSG_DEBUG("sigma: " << m_sigmaCaloNoiseCut);
1425 
1426  ATH_MSG_DEBUG("Etcore: tot/em/tile/hec "
1427  << etcore[Rec::CaloCellCollector::ET_Core] << "/" << etcore[Rec::CaloCellCollector::ET_EMCore] << "/"
1428  << etcore[Rec::CaloCellCollector::ET_TileCore] << "/" << etcore[Rec::CaloCellCollector::ET_HECCore]);
1429  }

◆ create() [1/4]

xAOD::Muon * MuonCombined::MuonCreatorTool::create ( const EventContext &  ctx,
const MuonCandidate &  candidate,
OutputData &  outputData 
) const
finaloverridevirtual

IMuonCreatorTool interface: create a muon from a muon candidate.

Implements MuonCombined::IMuonCreatorTool.

Definition at line 178 of file MuonCreatorTool.cxx.

178  {
179  // skip all muons without extrapolated track
180  if (m_requireMSOEforSA && !candidate.extrapolatedTrack()) {
181  ATH_MSG_DEBUG("MuonCreatorTool::create(...) No extrapolated track - aborting. Will not create Muon.");
182  return nullptr; // Do we really want to do this?
183  }
184 
185  // Create the xAOD object:
186  xAOD::Muon* muon = new xAOD::Muon();
187  outputData.muonContainer->push_back(muon);
188  decorateDummyValues(ctx, *muon, outputData);
189 
190  muon->setAuthor(xAOD::Muon::MuidSA);
191  muon->setMuonType(xAOD::Muon::MuonStandAlone);
192  muon->addAllAuthor(xAOD::Muon::MuidSA);
193 
194  // create candidate from SA muon only
195  addMuonCandidate(ctx, candidate, *muon, outputData);
196 
197  using TrackParticleType = xAOD::Muon::TrackParticleType;
198  if (m_requireMSOEforSA && !muon->trackParticle(TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle)) {
199  ATH_MSG_DEBUG("Creation of track particle for SA muon failed, removing it");
200  outputData.muonContainer->pop_back();
201  return nullptr;
202  }
203 
204  if (!dressMuon(*muon)) {
205  ATH_MSG_WARNING("Failed to dress muon");
206  outputData.muonContainer->pop_back();
207  return nullptr;
208  }
209 
210  const xAOD::TrackParticle* track = muon->trackParticle(TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
211  if (!track) track = muon->primaryTrackParticle();
212  std::unique_ptr<Trk::CaloExtension> caloExtension = m_caloExtTool->caloExtension(ctx, *track);
213  if (m_requireCaloDepositForSA && !caloExtension) {
214  ATH_MSG_DEBUG("failed to get a calo extension for this SA muon, discard it");
215  outputData.muonContainer->pop_back();
216  return nullptr;
217  }
218  if (m_requireCaloDepositForSA && caloExtension->caloLayerIntersections().empty()) {
219  ATH_MSG_DEBUG("failed to retrieve any calo layers for this SA muon, discard it");
220  outputData.muonContainer->pop_back();
221  return nullptr;
222  }
223  // check if there is a cluster container, if yes collect the cells around the
224  // muon and fill Etcore variables for muon
225  if (caloExtension && m_useCaloCells) collectCells(ctx, *muon, outputData.clusterContainer, caloExtension.get());
226 
227  return muon;
228  }

◆ create() [2/4]

void MuonCombined::MuonCreatorTool::create ( const EventContext &  ctx,
const MuonCandidateCollection *  muonCandidates,
const std::vector< const InDetCandidateToTagMap * > &  tagMaps,
OutputData &  outputData 
) const
finaloverridevirtual

IMuonCreatorTool interface: build muons from ID and MS candidates.

Implements MuonCombined::IMuonCreatorTool.

Definition at line 116 of file MuonCreatorTool.cxx.

117  {
118  create(ctx, muonCandidates, tagMaps, outputData, false);
119  create(ctx, muonCandidates, tagMaps, outputData, true);
120  }

◆ create() [3/4]

void MuonCombined::MuonCreatorTool::create ( const EventContext &  ctx,
const MuonCandidateCollection *  muonCandidates,
const std::vector< const InDetCandidateToTagMap * > &  tagMaps,
OutputData &  outputData,
bool  select_comissioning 
) const
private

Definition at line 121 of file MuonCreatorTool.cxx.

123  {
124  // Create containers for resolved candidates (always of type VIEW_ELEMENTS)
125  InDetCandidateTagsMap resolvedInDetCandidates;
126  // std::vector<const MuonCombined::InDetCandidate*> resolvedInDetCandidates;
127  std::vector<const MuonCombined::MuonCandidate*> resolvedMuonCandidates;
128 
129  // Resolve Overlap
130  if (!m_buildStauContainer)
131  resolveOverlaps(ctx, muonCandidates, tagMaps, resolvedInDetCandidates, resolvedMuonCandidates, select_commissioning);
132  else if (!select_commissioning)
133  selectStaus(resolvedInDetCandidates, tagMaps);
134 
135  unsigned int numIdCan = resolvedInDetCandidates.size();
136  unsigned int numMuCan = muonCandidates ? muonCandidates->size() : 0;
137  ATH_MSG_DEBUG("Creating xAOD::Muons from: " << numIdCan << " indet candidates and " << numMuCan << " muon candidates ");
138 
139  if (!m_buildStauContainer && muonCandidates)
140  ATH_MSG_DEBUG("MuonCandidates : overlap removal " << muonCandidates->size() << " in, " << resolvedMuonCandidates.size()
141  << " out");
142 
143  // Create a container for resolved candidates (always of type VIEW_ELEMENTS)
144  for (InDetCandidateTags& can : resolvedInDetCandidates) {
145  ATH_MSG_DEBUG("New InDetCandidate");
146  xAOD::Muon* muon = create(ctx, can, outputData);
147  if (!muon) {
148  ATH_MSG_DEBUG("no muon found");
149  } else {
150  ATH_MSG_DEBUG("muon found");
151  if (select_commissioning) { muon->addAllAuthor(xAOD::Muon::Author::Commissioning); }
152 
153  if (!muon->primaryTrackParticleLink().isValid()) {
154  ATH_MSG_ERROR("This muon has no valid primaryTrackParticleLink! Author=" << muon->author());
155  }
156  }
157  ATH_MSG_DEBUG("Creation of Muon from InDetCandidates done");
158  }
159  if (!m_requireIDTracks) { // only build SA muons if ID tracks are not required
160  for (const MuonCombined::MuonCandidate* can : resolvedMuonCandidates) {
161  ATH_MSG_DEBUG("New MuonCandidate");
162  xAOD::Muon* muon = create(ctx, *can, outputData);
163  if (muon && select_commissioning) { muon->addAllAuthor(xAOD::Muon::Author::Commissioning); }
164  ATH_MSG_DEBUG("Creation of Muon from MuonCandidates done");
165  }
166  }
167 
168  if (msgLvl(MSG::DEBUG) || m_printSummary) {
169  ATH_MSG_INFO("Printing muon container:");
170  ATH_MSG_INFO(m_muonPrinter->print(*outputData.muonContainer));
171  ATH_MSG_INFO("Done");
172  }
173  if (msgLvl(MSG::VERBOSE) && outputData.clusterContainer) {
174  ATH_MSG_VERBOSE("Associated clusters : " << outputData.clusterContainer->size());
175  }
176  }

◆ create() [4/4]

xAOD::Muon * MuonCombined::MuonCreatorTool::create ( const EventContext &  ctx,
InDetCandidateTags &  candidate,
OutputData &  outputData 
) const
finaloverridevirtual

IMuonCreatorTool interface: create a muon from a muon candidate.

Implements MuonCombined::IMuonCreatorTool.

Definition at line 250 of file MuonCreatorTool.cxx.

250  {
251  // no tags, no muon
252  if (candidate.second.empty()) {
253  ATH_MSG_DEBUG("MuonCreatorTool::create(...) - InDetCandidate with empty combinedDataTags. Aborting. Will not create Muon.");
254  return nullptr;
255  }
256  const std::vector<const TagBase*>& tags = candidate.second;
257  if (tags.size() == 1 && !m_buildStauContainer) {
258  const MuGirlLowBetaTag* muGirlLowBetaTag = dynamic_cast<const MuGirlLowBetaTag*>(tags[0]);
259  if (muGirlLowBetaTag) {
260  ATH_MSG_DEBUG("Track has only a MuGirlLowBetaTag but Staus are not being built, so will not create muon");
261  return nullptr;
262  }
263  }
264 
265  // Create the xAOD object:
266  xAOD::Muon* muon = new xAOD::Muon();
267  outputData.muonContainer->push_back(muon);
268  muon->setMuonSegmentLinks(std::vector<ElementLink<xAOD::MuonSegmentContainer>>{});
269 
270  // now we need to sort the tags to get the best muon
271 
272  // set the link to the ID track particle
273  muon->setTrackParticleLink(xAOD::Muon::InnerDetectorTrackParticle, candidate.first->indetTrackParticleLink());
274  ATH_MSG_DEBUG("Adding InDet Track: pt " << candidate.first->indetTrackParticle().pt() << " eta "
275  << candidate.first->indetTrackParticle().eta() << " phi "
276  << candidate.first->indetTrackParticle().phi());
277 
278  ATH_MSG_DEBUG("creating Muon with " << tags.size() << " tags ");
279  // loop over the tags
280 
281  decorateDummyValues(ctx, *muon, outputData);
282  bool first = true;
283  for (const MuonCombined::TagBase* tag : tags) {
284  ATH_MSG_DEBUG("Handling tag: type " << tag->type());
285 
286  // staus
287  if (m_buildStauContainer) {
288  const MuGirlLowBetaTag* muGirlLowBetaTag = dynamic_cast<const MuGirlLowBetaTag*>(tag);
289 
290  if (muGirlLowBetaTag) {
291  ATH_MSG_DEBUG("MuonCreatorTool MuGirlLowBetaTag ");
292 
293  muon->setAuthor(tag->author());
294  muon->setMuonType(tag->type());
295 
296  if (tag->type() == xAOD::Muon::Combined) {
297  ATH_MSG_DEBUG("MuonCreatorTool MuGirlLowBetaTag combined");
298 
299  // Create the xAOD object:
300  if (outputData.slowMuonContainer) {
301  xAOD::SlowMuon* slowMuon = new xAOD::SlowMuon();
302  outputData.slowMuonContainer->push_back(slowMuon);
303 
304  addMuGirlLowBeta(ctx, *muon, muGirlLowBetaTag, slowMuon,
305  outputData); // CHECK to see what variables are created here.
306 
307  ATH_MSG_DEBUG("slowMuon muonContainer size " << outputData.muonContainer->size());
308  ElementLink<xAOD::MuonContainer> muonLink(*outputData.muonContainer, outputData.muonContainer->size() - 1);
309  if (slowMuon && muonLink.isValid()) {
310  ATH_MSG_DEBUG("slowMuon muonLink valid");
311  slowMuon->setMuonLink(muonLink);
312  }
313  }
314  }
315  }
316  } else {
317  // Don't want staus in muon branch
318  const MuGirlLowBetaTag* muGirlLowBetaTag = dynamic_cast<const MuGirlLowBetaTag*>(tag);
319  if (muGirlLowBetaTag) continue;
320 
321  // set author info
322  if (first) {
323  ATH_MSG_DEBUG("MuonCreatorTool first muon tag: author=" << tag->author() << " type=" << tag->type());
324  muon->setAuthor(tag->author());
325  muon->setMuonType(tag->type());
326  // Overrride type if InDet track is SiAssociated.
327  if (candidate.first->isSiliconAssociated()) { muon->setMuonType(xAOD::Muon::SiliconAssociatedForwardMuon); }
328  first = false;
329  }
330 
331  muon->addAllAuthor(tag->author());
332 
333  // this is not too elegant, maybe rethink implementation
334  xAOD::Muon::MuonType type = tag->type();
335  if (type == xAOD::Muon::Combined) {
336  // work out type of tag
337  const CombinedFitTag* cbFitTag = dynamic_cast<const CombinedFitTag*>(tag);
338  const StacoTag* stacoTag = dynamic_cast<const StacoTag*>(tag);
339  const MuGirlTag* muGirlTag = dynamic_cast<const MuGirlTag*>(tag);
340 
341  addCombinedFit(ctx, *muon, cbFitTag, outputData);
342  addMuGirl(ctx, *muon, muGirlTag, outputData);
343  addStatisticalCombination(ctx, *muon, candidate.first, stacoTag, outputData);
344  if (!(cbFitTag || stacoTag || muGirlTag)) { ATH_MSG_WARNING("Unknown combined tag "); }
345 
346  } else if (type == xAOD::Muon::SegmentTagged) {
347  const SegmentTag* segTag = dynamic_cast<const SegmentTag*>(tag);
348  const MuGirlTag* muGirlTag = dynamic_cast<const MuGirlTag*>(tag);
349 
350  addSegmentTag(ctx, *muon, segTag, outputData);
351  addMuGirl(ctx, *muon, muGirlTag, outputData);
352 
353  if (!(segTag || muGirlTag)) { ATH_MSG_WARNING("Unknown segment-tagged tag "); }
354  } else if (type == xAOD::Muon::CaloTagged) {
355  const CaloTag* caloTag = dynamic_cast<const CaloTag*>(tag);
356  addCaloTag(*muon, caloTag);
357  if (!caloTag) { ATH_MSG_WARNING("Unknown calo tag type "); }
358  } else {
359  ATH_MSG_WARNING("Unknown tag type. Type= " + std::to_string(type));
360  }
361  }
362  } // m_buildStauContainer
363 
364  if (!dressMuon(*muon)) {
365  ATH_MSG_WARNING("Failed to dress muon");
366  outputData.muonContainer->pop_back();
367  // if we are dealing with staus, also need to remove the slowMuon
368  if (m_buildStauContainer) outputData.slowMuonContainer->pop_back();
369  return nullptr;
370  }
371 
372  // If eLoss is not already available then build it
373  float eLoss = -1;
374  bool haveEloss = muon->parameter(eLoss, xAOD::Muon::EnergyLoss);
375  if (!haveEloss || eLoss == 0) {
376  ATH_MSG_DEBUG("Adding Energy Loss to muon" << std::endl << m_muonPrinter->print(*muon));
377  addEnergyLossToMuon(*muon);
378  }
379 
380  // check if there is a cluster container, if yes collect the cells around the
381  // muon and fill Etcore variables for muon
382  if (m_useCaloCells) collectCells(ctx, *muon, outputData.clusterContainer, candidate.first->getCaloExtension());
383 
384  ATH_MSG_DEBUG("Done creating muon with " << acc_nUnspoiledCscHits(*muon) << " unspoiled csc hits");
385 
386  return muon;
387  }

◆ createDummyTrack()

std::unique_ptr< Trk::Track > MuonCombined::MuonCreatorTool::createDummyTrack ( const EventContext &  ctx,
const std::vector< const Muon::MuonSegment * > &  segments,
const Trk::Track &  indetTrack 
) const
private

Definition at line 1165 of file MuonCreatorTool.cxx.

1167  {
1168  ATH_MSG_VERBOSE("Creating dummy tracks from segments...");
1169 
1170  auto trackStateOnSurfaces = std::make_unique<Trk::TrackStates>();
1171 
1172  for (const Muon::MuonSegment* seg : segments) {
1173  // create pars for muon and loop over hits
1174  double momentum{1e8}, charge{0.};
1175  std::unique_ptr<const Trk::TrackParameters> pars{m_edmHelperSvc->createTrackParameters(*seg, momentum, charge)};
1176  for (const Trk::MeasurementBase* meas : seg->containedMeasurements()) {
1177  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern(0);
1178  typePattern.set(Trk::TrackStateOnSurface::Measurement);
1179  // TSoS takes ownership
1180  std::unique_ptr<Trk::TrackParameters> exPars{m_propagator->propagateParameters(
1181  ctx, *pars, meas->associatedSurface(), Trk::anyDirection, false, Trk::MagneticFieldProperties(Trk::NoField))};
1182  if (!exPars) { ATH_MSG_VERBOSE("Could not propagate Track to segment surface"); }
1183  Trk::TrackStateOnSurface* trackState =
1184  new Trk::TrackStateOnSurface(meas->uniqueClone(), std::move(exPars), nullptr, typePattern);
1185  trackStateOnSurfaces->push_back(trackState);
1186  } // end segment loop
1187  }
1188 
1189  Trk::TrackInfo info(Trk::TrackInfo::Unknown, Trk::muon);
1190  Trk::TrackInfo::TrackPatternRecoInfo author = Trk::TrackInfo::MuTag;
1191  info.setPatternRecognitionInfo(author);
1192  std::unique_ptr<Trk::Track> newtrack =
1193  std::make_unique<Trk::Track>(info, std::move(trackStateOnSurfaces), (indetTrack.fitQuality())->uniqueClone());
1194 
1195  // create a track summary for this track
1196  if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*newtrack, false); }
1197 
1198  return newtrack;
1199  }

◆ createMuonSegmentElementLink()

ElementLink< xAOD::MuonSegmentContainer > MuonCombined::MuonCreatorTool::createMuonSegmentElementLink ( const EventContext &  ctx,
const Muon::MuonSegment *  segLink,
const OutputData &  outData 
) const
private

Definition at line 780 of file MuonCreatorTool.cxx.

782  {
783  if (outData.xaodSegmentContainer && outData.tagToSegmentAssocMap) {
784  // if a muon segment collection is provided, duplicate the segment and
785  // create a link to that
786  unsigned int link = outData.tagToSegmentAssocMap->linkIndex(trkSeg);
787  if (link >= outData.xaodSegmentContainer->size()) {
788  ATH_MSG_WARNING("Failed to retrieve a proper link for segment " << m_printer->print(*trkSeg));
789  return {};
790  }
791  ElementLink<xAOD::MuonSegmentContainer> eleLink{*outData.xaodSegmentContainer, link, ctx};
792  return eleLink;
793  }
794  return ElementLink<xAOD::MuonSegmentContainer>();
795  }

◆ createTrackParticleElementLink()

ElementLink< xAOD::TrackParticleContainer > MuonCombined::MuonCreatorTool::createTrackParticleElementLink ( const ElementLink< TrackCollection > &  trackLink,
xAOD::TrackParticleContainer &  trackParticleContainer,
TrackCollection *  trackCollection = 0 
) const
private

function creates an element link to a track particle from the track and the TrackParticle collection.

if a TrackCollection is also provided, the element link to the track will also be set takes ownership of the track

Definition at line 754 of file MuonCreatorTool.cxx.

756  {
757  ATH_MSG_DEBUG("createTrackParticleElementLink");
758  xAOD::TrackParticle* tp = nullptr;
759  if (trackCollection) {
760  trackCollection->push_back(new Trk::Track(**trackLink));
761  // want to link the track particle to this track
762  ElementLink<TrackCollection> link(*trackCollection, trackCollection->size() - 1);
763  if (link.isValid())
764  tp = m_particleCreator->createParticle(link, &trackParticleContainer, nullptr, xAOD::muon);
765  else
766  ATH_MSG_WARNING("new Track Collection link invalid");
767  }
768  if (!tp) {
769  // create track particle without a link to the track
770  tp = m_particleCreator->createParticle(**trackLink, &trackParticleContainer, nullptr, xAOD::muon);
771  }
772 
773  if (tp) {
774  ElementLink<xAOD::TrackParticleContainer> link(trackParticleContainer, trackParticleContainer.size() - 1);
775  return link;
776  }
777  return ElementLink<xAOD::TrackParticleContainer>();
778  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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  }

◆ decorateDummyValues()

void MuonCombined::MuonCreatorTool::decorateDummyValues ( const EventContext &  ctx,
xAOD::Muon &  muon,
OutputData &  outputData 
) const
private

De^corated a bunch of dummy values to the muon to ensure data consistency in the xAOD.

Unspoiled CSC hits

Definition at line 230 of file MuonCreatorTool.cxx.

230  {
231  // Set variables to zero by calling the functions with null pointers.
232  addCaloTag(muon, nullptr);
233  addCombinedFit(ctx, muon, nullptr, outputData);
234  addStatisticalCombination(ctx, muon, nullptr, nullptr, outputData);
235  addMuGirl(ctx, muon, nullptr, outputData);
236  addSegmentTag(ctx, muon, nullptr, outputData);
237 
239  acc_nUnspoiledCscHits(muon) = 0;
240  acc_MuonSpectrometerPt(muon) = -1;
241  acc_InnerDetectorPt(muon) = -1;
242 
243  acc_ET_Core(muon) = 0;
244  acc_ET_EMCore(muon) = 0;
245  acc_ET_TileCore(muon) = 0;
246  acc_ET_HECCore(muon) = 0;
247 
248  fillEnergyLossFromTrack(muon, nullptr);
249  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

◆ dressMuon()

bool MuonCombined::MuonCreatorTool::dressMuon ( xAOD::Muon &  muon) const
private

Definition at line 1201 of file MuonCreatorTool.cxx.

1201  {
1202  if (!muon.primaryTrackParticleLink().isValid()) {
1203  ATH_MSG_DEBUG("No primary track particle set, deleting muon");
1204  return false;
1205  }
1206  const xAOD::TrackParticle* primary = muon.primaryTrackParticle();
1207  // update parameters with primary track particle
1208  setP4(muon, *primary);
1209  const float qOverP = primary->qOverP();
1210  if (qOverP != 0.0) {
1211  muon.setCharge(qOverP > 0 ? 1. : -1.);
1212  } else {
1213  ATH_MSG_WARNING("MuonCreatorTool::dressMuon - trying to set qOverP, but value from muon.primaryTrackParticle ["
1214  << muon.primaryTrackParticleLink().dataID()
1215  << "] is zero. Setting charge=0.0. The eta/phi of the muon is: " << muon.eta() << " / " << muon.phi());
1216  muon.setCharge(0.0);
1217  }
1218 
1219  // add hit summary
1220  m_muonDressingTool->addMuonHitSummary(muon);
1221 
1222  // calculate scattering significance and momentum balance significance
1223  if (!m_scatteringAngleTool.empty()) {
1224  Rec::ScatteringAngleSignificance scatSign = m_scatteringAngleTool->scatteringAngleSignificance(muon);
1225  float curvatureSignificance = scatSign.curvatureSignificance();
1226  muon.setParameter(curvatureSignificance, xAOD::Muon::scatteringCurvatureSignificance);
1227  float neighbourSignificance = scatSign.neighbourSignificance();
1228  muon.setParameter(neighbourSignificance, xAOD::Muon::scatteringNeighbourSignificance);
1229  ATH_MSG_VERBOSE("Got curvatureSignificance " << curvatureSignificance << " and neighbourSignificance "
1230  << neighbourSignificance);
1231  }
1232 
1233  if (!m_momentumBalanceTool.empty()) {
1234  float momentumBalanceSignificance = m_momentumBalanceTool->momentumBalanceSignificance(muon);
1235  muon.setParameter(momentumBalanceSignificance, xAOD::Muon::momentumBalanceSignificance);
1236  ATH_MSG_VERBOSE("Got momentumBalanceSignificance " << momentumBalanceSignificance);
1237  }
1238 
1239  if (!m_meanMDTdADCTool.empty()) {
1240  float meanDeltaADC = float(m_meanMDTdADCTool->meanMDTdADCFiller(muon));
1241  muon.setParameter(meanDeltaADC, xAOD::Muon::meanDeltaADCCountsMDT);
1242  ATH_MSG_VERBOSE("Got meanDeltaADCCountsMDT " << meanDeltaADC);
1243  }
1244 
1245  if (!m_selectorTool.empty()) {
1246  acc_MuonSpectrometerPt(muon) = muon.pt();
1247  acc_InnerDetectorPt(muon) = muon.pt();
1248  // set id cuts
1249  m_selectorTool->setPassesIDCuts(muon);
1250  ATH_MSG_VERBOSE("Setting passesIDCuts " << muon.passesIDCuts());
1251  // set quality
1252  m_selectorTool->setQuality(muon);
1253  ATH_MSG_VERBOSE("Setting Quality " << muon.quality());
1254  }
1255 
1256  if (m_fillEnergyLossFromTrack) {
1257  const Trk::Track* trk = nullptr;
1258  if (muon.trackParticle(xAOD::Muon::CombinedTrackParticle)) {
1259  trk = muon.trackParticle(xAOD::Muon::CombinedTrackParticle)->track();
1260  }
1261  if (!trk && muon.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)) {
1262  trk = muon.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)->track();
1263  }
1264  if (trk) {
1265  fillEnergyLossFromTrack(muon, &(trk->trackStateOnSurfaces()->stdcont()));
1266  } else {
1267  fillEnergyLossFromTrack(muon, nullptr); // Just fill empty variables.
1268  ATH_MSG_VERBOSE("Couldn't find matching track which might have energy loss.");
1269  }
1270  }
1271  return true;
1272  }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ fillEnergyLossFromTrack()

void MuonCombined::MuonCreatorTool::fillEnergyLossFromTrack ( xAOD::Muon &  muon,
const std::vector< const Trk::TrackStateOnSurface * > *  tsosVector 
) const
private

Definition at line 1319 of file MuonCreatorTool.cxx.

1319  {
1320  // Ensure these are set for every muon
1321  if (!tsosVector) {
1322  muon.setParameter(0.f, xAOD::Muon::EnergyLoss);
1323  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLoss);
1324  muon.setParameter(0.f, xAOD::Muon::MeasEnergyLoss);
1325  muon.setParameter(0.f, xAOD::Muon::EnergyLossSigma);
1326  muon.setParameter(0.f, xAOD::Muon::MeasEnergyLossSigma);
1327  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLossSigmaPlus);
1328  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLossSigmaMinus);
1329 
1330  muon.setEnergyLossType(xAOD::Muon::Parametrized); // Not so nice! Add 'unknown' type?
1331  muon.setParameter(0.f, xAOD::Muon::FSR_CandidateEnergy);
1332  if (m_fillExtraELossInfo) acc_numEnergyLossPerTrack(muon) = 0;
1333 
1334  return;
1335  }
1336 
1337  unsigned int numEnergyLossPerTrack = 0;
1338  bool problem = false;
1339  for (const auto* tsos : *tsosVector) {
1340  const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
1341  if (!meot) continue;
1342  const Trk::EnergyLoss* el = meot->energyLoss();
1343  const CaloEnergy* caloEnergy = dynamic_cast<const CaloEnergy*>(el);
1344  if (!caloEnergy) continue;
1345  ++numEnergyLossPerTrack;
1346 
1347  muon.setParameter(static_cast<float>(caloEnergy->deltaE()), xAOD::Muon::EnergyLoss);
1348  muon.setParameter(static_cast<float>(caloEnergy->deltaEParam()), xAOD::Muon::ParamEnergyLoss);
1349  muon.setParameter(static_cast<float>(caloEnergy->deltaEMeas()), xAOD::Muon::MeasEnergyLoss);
1350  muon.setParameter(static_cast<float>(caloEnergy->sigmaDeltaE()), xAOD::Muon::EnergyLossSigma);
1351  muon.setParameter(static_cast<float>(caloEnergy->sigmaDeltaEMeas()), xAOD::Muon::MeasEnergyLossSigma);
1352  muon.setParameter(static_cast<float>(caloEnergy->sigmaPlusDeltaEParam()), xAOD::Muon::ParamEnergyLossSigmaPlus);
1353  muon.setParameter(static_cast<float>(caloEnergy->sigmaMinusDeltaEParam()), xAOD::Muon::ParamEnergyLossSigmaMinus);
1354 
1355  muon.setEnergyLossType(static_cast<xAOD::Muon::EnergyLossType>(caloEnergy->energyLossType()));
1356  muon.setParameter(static_cast<float>(caloEnergy->fsrCandidateEnergy()), xAOD::Muon::FSR_CandidateEnergy);
1357  }
1358  if (numEnergyLossPerTrack > 1) {
1359  ATH_MSG_VERBOSE("More than one e loss per track... ");
1360  problem = true;
1361  }
1362  if (m_fillExtraELossInfo) acc_numEnergyLossPerTrack(muon) = numEnergyLossPerTrack;
1363  if (problem) ATH_MSG_VERBOSE("Dumping problematic muon: " << m_muonPrinter->print(muon));
1364  }

◆ initialize()

StatusCode MuonCombined::MuonCreatorTool::initialize ( )
finaloverridevirtual

Definition at line 61 of file MuonCreatorTool.cxx.

61  {
62  if (m_buildStauContainer) ATH_MSG_DEBUG(" building Stau container ");
63 
64  ATH_CHECK(m_idHelperSvc.retrieve());
65  ATH_CHECK(m_printer.retrieve());
66  ATH_CHECK(m_muonPrinter.retrieve());
67  ATH_CHECK(m_caloExtTool.retrieve());
68  ATH_CHECK(m_edmHelperSvc.retrieve());
69  ATH_CHECK(m_particleCreator.retrieve());
70  ATH_CHECK(m_ambiguityProcessor.retrieve());
71  ATH_CHECK(m_muonDressingTool.retrieve());
72  ATH_CHECK(m_caloMgrKey.initialize());
73  ATH_CHECK(m_trackQuery.retrieve());
74  if (!m_momentumBalanceTool.empty())
75  ATH_CHECK(m_momentumBalanceTool.retrieve());
76  else
77  m_momentumBalanceTool.disable();
78  if (!m_scatteringAngleTool.empty())
79  ATH_CHECK(m_scatteringAngleTool.retrieve());
80  else
81  m_scatteringAngleTool.disable();
82  if (!m_selectorTool.empty())
83  ATH_CHECK(m_selectorTool.retrieve());
84  else
85  m_selectorTool.disable();
86  if (!m_meanMDTdADCTool.empty())
87  ATH_CHECK(m_meanMDTdADCTool.retrieve());
88  else
89  m_meanMDTdADCTool.disable();
90 
91  ATH_CHECK(m_caloNoiseKey.initialize(SG::AllowEmpty));
92 
93  ATH_MSG_INFO("ET_Core calculation: doNoiseCut, sigma - " << !m_caloNoiseKey.empty() << " " << m_sigmaCaloNoiseCut);
94 
95  if (!m_doSA) {
96  ATH_CHECK(m_caloMaterialProvider.retrieve());
97  ATH_CHECK(m_propagator.retrieve());
98  } else {
99  m_caloMaterialProvider.disable();
100  m_propagator.disable();
101  }
102  ATH_CHECK(m_cellContainerName.initialize(m_useCaloCells));
103  ATH_CHECK(m_trackSummaryTool.retrieve());
104 
105  m_copyFloatSummaryAccessors.reserve( m_copyFloatSummaryKeys.size() );
106  for (const std::string &a_key : m_copyFloatSummaryKeys ) {
107  m_copyFloatSummaryAccessors.push_back(std::make_unique< SG::Accessor<float> >(a_key));
108  }
109  m_copyCharSummaryAccessors.reserve( m_copyCharSummaryKeys.size() );
110  for (const std::string &a_key : m_copyCharSummaryKeys ) {
111  m_copyCharSummaryAccessors.push_back(std::make_unique< SG::Accessor<uint8_t> >(a_key));
112  }
113 
114  return StatusCode::SUCCESS;
115  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

static const InterfaceID& MuonCombined::IMuonCreatorTool::interfaceID ( )
inlinestaticinherited

Definition at line 72 of file IMuonCreatorTool.h.

72  {
73  static const InterfaceID IID_IMuonCreatorTool("MuonCombined::IMuonCreatorTool", 1, 0);
74  return IID_IMuonCreatorTool;
75  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::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< AlgTool >::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< AlgTool > >::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.

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

◆ resolveOverlaps()

void MuonCombined::MuonCreatorTool::resolveOverlaps ( const EventContext &  ctx,
const MuonCandidateCollection *  muonCandidates,
const std::vector< const InDetCandidateToTagMap * > &  tagMaps,
InDetCandidateTagsMap &  resolvedInDetCandidates,
std::vector< const MuonCombined::MuonCandidate * > &  resolvedMuonCandidates,
bool  select_comissioning = false 
) const
private

Find all InDetCandidate – Combined tag combinations Be aware that different InDetCandidateMaps could have different InDetCandidate objects but the underlying tracks are always the same

Check whether the author arises from the comissioning chain The maps are filled in dedicated algorithim. So all tags will fail / satisfy this condition

Add the track for the ambiguity reprocessing

Create firs the dummy track

Add it to the list piped to ambiguity solving

Move the candidate into the map to find the resolved tracks

In principle we can include here STACO as well but that is lower ranked as MuidSA

Definition at line 969 of file MuonCreatorTool.cxx.

973  {
974  resolvedMuonCandidates.clear();
975  resolvedInDetCandidates.clear();
976 
977  std::unique_ptr<const TrackCollection> resolvedTracks;
978  std::vector<std::unique_ptr<Trk::Track>> garbage_collection;
979 
983  InDetCandidateTagsMap inDetCandidateMap;
984  for (const InDetCandidateToTagMap* tag_map : tagMaps) {
985  if (!tag_map) continue;
986  for (const auto& comb_tag : *tag_map) {
987  const TagBase* tag = comb_tag.second.get();
991  if (tag->isCommissioning() != select_commissioning) break;
992  InDetCandidateTagsMap::iterator itr =
993  std::find_if(inDetCandidateMap.begin(), inDetCandidateMap.end(),
994  [&comb_tag](const InDetCandidateTags& to_test) { return (*to_test.first) == (*comb_tag.first); });
995  if (itr != inDetCandidateMap.end())
996  itr->second.emplace_back(tag);
997  else
998  inDetCandidateMap.emplace_back(std::make_pair(comb_tag.first, std::vector<const TagBase*>{tag}));
999  }
1000  }
1001 
1002  // Each InDetCandidate corresponds to a different ID track.
1003  // Resolve overlap among InDetCandidates for cases where different
1004  // ID tracks are tagged by the same MS info (track or segment)
1005  if (!inDetCandidateMap.empty()) {
1006  // the muons only found by the calo tagger should always be kept so we can
1007  // filter them out from the start
1008  InDetCandidateTagsMap caloMuons;
1009 
1010  // first loop over ID candidates and select all candidates that have a tag
1011  resolvedInDetCandidates.reserve(inDetCandidateMap.size());
1012  caloMuons.reserve(inDetCandidateMap.size());
1013  for (InDetCandidateTags& comb_tag : inDetCandidateMap) {
1014  std::stable_sort(comb_tag.second.begin(), comb_tag.second.end(), SortTagBasePtr());
1015  if (comb_tag.second.size() == 1 && comb_tag.second.front()->type() == xAOD::Muon::CaloTagged) {
1016  caloMuons.emplace_back(std::move(comb_tag));
1017  } else
1018  resolvedInDetCandidates.emplace_back(std::move(comb_tag));
1019  }
1020  inDetCandidateMap.clear();
1021  // now sort the selected ID candidates
1022  std::stable_sort(resolvedInDetCandidates.begin(), resolvedInDetCandidates.end(), SortInDetCandidates());
1023  if (msgLvl(MSG::DEBUG)) {
1024  ATH_MSG_DEBUG("Found " << resolvedInDetCandidates.size() << " inner detector tags in event "
1025  << ctx.eventID().event_number());
1026  for (const InDetCandidateTags& candidate : resolvedInDetCandidates) {
1027  std::stringstream tags;
1028  for (const TagBase* tag : candidate.second) tags << " " << tag->toString();
1029  ATH_MSG_DEBUG("ID candidate: " << candidate.first->toString() << " " << tags.str());
1030  }
1031  }
1032 
1033  ConstDataVector<TrackCollection> to_resolve{SG::VIEW_ELEMENTS};
1034 
1035  to_resolve.reserve(resolvedInDetCandidates.size());
1036  garbage_collection.reserve(resolvedInDetCandidates.size());
1037 
1038  // a dummy track for segment tagged candidates to be used in the overlap
1039  // check
1040  std::map<const Trk::Track*, InDetCandidateTags> trackInDetCandLinks;
1041 
1042  for (InDetCandidateTags& candidate : resolvedInDetCandidates) {
1043  // retrieve the primary tag
1044  const TagBase* primaryTag = candidate.second[0];
1045 
1046  // check if a track is available
1047  if (primaryTag->primaryTrack()) {
1049  to_resolve.push_back(primaryTag->primaryTrack());
1050  // create a track summary for this track
1051  trackInDetCandLinks[to_resolve.back()] = std::move(candidate);
1052  }
1053  // if not, make a dummy track out of segments, muonTracks takes ownership
1054  // of the memory
1055  else {
1056  std::vector<const Muon::MuonSegment*> segments = primaryTag->associatedSegments();
1057  if (!segments.empty()) {
1059  garbage_collection.emplace_back(
1060  createDummyTrack(ctx, primaryTag->associatedSegments(), *(candidate.first->indetTrackParticle().track())));
1062  to_resolve.push_back(garbage_collection.back().get());
1064  trackInDetCandLinks[garbage_collection.back().get()] = std::move(candidate);
1065  }
1066  }
1067  }
1068  resolvedInDetCandidates.clear();
1069 
1070  // Resolve ambiguity between muon tracks
1071  resolvedTracks.reset(m_ambiguityProcessor->process(to_resolve.asDataVector()));
1072 
1073  // link back to InDet candidates and fill the resolved container
1074  for (const Trk::Track* track : *resolvedTracks) {
1075  std::map<const Trk::Track*, InDetCandidateTags>::iterator trackCandLink = trackInDetCandLinks.find(track);
1076  if (trackCandLink == trackInDetCandLinks.end()) {
1077  ATH_MSG_WARNING("Unable to find internal link between MS track and ID candidate!");
1078  continue;
1079  }
1080  resolvedInDetCandidates.push_back(std::move(trackCandLink->second));
1081  }
1082 
1083  // print-out
1084  if (msgLvl(MSG::VERBOSE)) {
1085  ATH_MSG_DEBUG("ID candidates after ambiguity solving "
1086  << resolvedInDetCandidates.size() << " trackCandLinks: " << trackInDetCandLinks.size()
1087  << " to_resolve: " << to_resolve.size() << " resolvedTracks: " << resolvedTracks->size());
1088  for (const InDetCandidateTags& candidate : resolvedInDetCandidates) {
1089  ATH_MSG_DEBUG("ID candidate: " << candidate.first->toString() << " " << candidate.second[0]->toString());
1090  }
1091  ATH_MSG_DEBUG("Calo muons after ambiguity solving: ");
1092  for (const InDetCandidateTags& candidate : caloMuons) {
1093  ATH_MSG_DEBUG("ID candidate: " << candidate.first->toString() << " " << candidate.second[0]->toString());
1094  }
1095  }
1096  // add muons only found by calo tagger
1097  resolvedInDetCandidates.insert(resolvedInDetCandidates.end(), caloMuons.begin(), caloMuons.end());
1098 
1099  // now sort the selected ID candidates
1100  std::stable_sort(resolvedInDetCandidates.begin(), resolvedInDetCandidates.end(),
1101  [](const InDetCandidateTags& a, const InDetCandidateTags& b) {
1102  return a.first->indetTrackParticle().pt() > b.first->indetTrackParticle().pt();
1103  });
1104  }
1105 
1106  // MuonCandidateCollection contains all muon tracks (SA extrapolated or not)
1107  // Resolve overlap with InDetCandidate collection
1108  if (!muonCandidates) { return; }
1109 
1110  if (msgLvl(MSG::DEBUG)) {
1111  ATH_MSG_DEBUG("Muon candidates: " << muonCandidates->size());
1112  for (const MuonCandidate* candidate : *muonCandidates) { ATH_MSG_DEBUG("Muon candidate: " << candidate->toString()); }
1113  }
1114 
1115  ConstDataVector<TrackCollection> resolvedTracks2{SG::VIEW_ELEMENTS};
1116  if (resolvedTracks) { resolvedTracks2.assign(resolvedTracks->begin(), resolvedTracks->end()); }
1117  // Keep track of the MuonCandidates used by MuidCo
1118  std::set<const MuonCandidate*> used_candidates;
1119  for (const InDetCandidateTags& indet_cand : resolvedInDetCandidates) {
1120  for (const TagBase* tag : indet_cand.second) {
1122  if (tag->author() == xAOD::Muon::MuidCo) {
1123  const CombinedFitTag* cmb_tag = dynamic_cast<const CombinedFitTag*>(tag);
1124  used_candidates.insert(&cmb_tag->muonCandidate());
1125  } else if (tag->author() == xAOD::Muon::STACO && indet_cand.second[0] == tag) {
1126  const StacoTag* staco_tag = dynamic_cast<const StacoTag*>(tag);
1127  used_candidates.insert(&staco_tag->muonCandidate());
1128  }
1129  }
1130  }
1131 
1132  // add MS tracks to resolvedTrack collection and store a link between tracks
1133  // and muon candidates
1134  std::map<const Trk::Track*, const MuonCandidate*> trackMuonCandLinks;
1135  for (const MuonCandidate* candidate : *muonCandidates) {
1136  if (candidate->isCommissioning() != select_commissioning) continue;
1137  const Trk::Track* track = candidate->primaryTrack();
1138  if (used_candidates.count(candidate)) {
1139  ATH_MSG_DEBUG("Duplicate MS track " << m_printer->print(*track));
1140  continue;
1141  }
1142  used_candidates.insert(candidate);
1143  resolvedTracks2.push_back(track); // VIEW_ELEMENTS, pointer only
1144  trackMuonCandLinks[track] = candidate;
1145  }
1146 
1147  // solve ambiguity
1148  resolvedTracks.reset(m_ambiguityProcessor->process(resolvedTracks2.asDataVector()));
1149 
1150  // loop over resolved tracks and fill resolved muon candidates
1151  for (const Trk::Track* track : *resolvedTracks) {
1152  auto trackCandLink = trackMuonCandLinks.find(track);
1153  if (trackCandLink != trackMuonCandLinks.end()) resolvedMuonCandidates.push_back(trackCandLink->second);
1154  }
1155 
1156  // print-out
1157  if (msgLvl(MSG::DEBUG)) {
1158  ATH_MSG_DEBUG("Muon candidates: " << muonCandidates->size() << " after ambiguity solving " << resolvedMuonCandidates.size());
1159  for (const MuonCandidate* candidate : resolvedMuonCandidates) {
1160  msg(MSG::DEBUG) << "Muon candidate: " << candidate->toString() << endmsg;
1161  }
1162  }
1163  }

◆ selectStaus()

void MuonCombined::MuonCreatorTool::selectStaus ( InDetCandidateTagsMap &  resolvedInDetCandidates,
const std::vector< const InDetCandidateToTagMap * > &  tagMaps 
) const
private

Definition at line 941 of file MuonCreatorTool.cxx.

942  {
943  resolvedInDetCandidates.clear();
944  for (const InDetCandidateToTagMap* tag_map : tagMaps) {
945  if (!tag_map) continue;
946  for (const auto& combined_tag : *tag_map) {
947  const TagBase* tag = combined_tag.second.get();
948  const MuGirlLowBetaTag* muGirlLowBetaTag = dynamic_cast<const MuGirlLowBetaTag*>(tag);
949  if (muGirlLowBetaTag) { resolvedInDetCandidates.emplace_back(combined_tag.first, std::vector<const TagBase*>{tag}); }
950  }
951  break;
952  }
953  // print-out
954  if (msgLvl(MSG::DEBUG)) {
955  ATH_MSG_DEBUG("ID candidates: " << tagMaps.size() << " after stau selection " << resolvedInDetCandidates.size());
956  for (const InDetCandidateTags& candidate : resolvedInDetCandidates) {
957  msg(MSG::DEBUG) << "ID candidate staus: " << candidate.first->toString() << endmsg;
958  }
959  }
960 
961  // tag_map above is keyed on a pointer.
962  // So we need to sort in order to get reproducible results.
963  std::stable_sort(resolvedInDetCandidates.begin(), resolvedInDetCandidates.end(),
964  [](const InDetCandidateTags& a, const InDetCandidateTags& b) {
965  return a.first->indetTrackParticle().pt() > b.first->indetTrackParticle().pt();
966  });
967  }

◆ setMuonHitCounts()

void MuonCombined::MuonCreatorTool::setMuonHitCounts ( xAOD::Muon &  muon) const
private

◆ setP4()

void MuonCombined::MuonCreatorTool::setP4 ( xAOD::Muon &  muon,
const xAOD::TrackParticle &  tp 
) const
private

Definition at line 1430 of file MuonCreatorTool.cxx.

1430 { muon.setP4(tp.pt(), tp.eta(), tp.phi()); }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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_addMDTExtrasMuGirlLowBeta

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_addMDTExtrasMuGirlLowBeta {this, "AddMDTExtrasMuGirlLowBeta", false}
private

Definition at line 177 of file MuonCreatorTool.h.

◆ m_ambiguityProcessor

ToolHandle<Trk::ITrackAmbiguityProcessorTool> MuonCombined::MuonCreatorTool::m_ambiguityProcessor {this, "AmbiguityProcessor", ""}
private

Definition at line 152 of file MuonCreatorTool.h.

◆ m_buildStauContainer

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_buildStauContainer {this, "BuildStauContainer", false, "flag to decide whether to build stau or not"}
private

Definition at line 176 of file MuonCreatorTool.h.

◆ m_caloExtTool

ToolHandle<Trk::IParticleCaloExtensionTool> MuonCombined::MuonCreatorTool::m_caloExtTool
private
Initial value:
{this, "ParticleCaloExtensionTool",
"Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool"}

Definition at line 148 of file MuonCreatorTool.h.

◆ m_caloMaterialProvider

ToolHandle<Trk::ITrkMaterialProviderTool> MuonCombined::MuonCreatorTool::m_caloMaterialProvider
private
Initial value:
{this, "CaloMaterialProvider",
"Trk::TrkMaterialProviderTool/TrkMaterialProviderTool"}

Definition at line 165 of file MuonCreatorTool.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> MuonCombined::MuonCreatorTool::m_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager"}
private

Definition at line 216 of file MuonCreatorTool.h.

◆ m_caloNoiseKey

SG::ReadCondHandleKey<CaloNoise> MuonCombined::MuonCreatorTool::m_caloNoiseKey {this, "CaloNoise", "", "CaloNoise object to use, or blank."}
private

Definition at line 174 of file MuonCreatorTool.h.

◆ m_cellCollector

Rec::CaloCellCollector MuonCombined::MuonCreatorTool::m_cellCollector
private

Definition at line 171 of file MuonCreatorTool.h.

◆ m_cellContainerName

SG::ReadHandleKey<CaloCellContainer> MuonCombined::MuonCreatorTool::m_cellContainerName {this, "CaloCellContainer", "AllCalo", "calo cells"}
private

Definition at line 173 of file MuonCreatorTool.h.

◆ m_copyCharSummaryAccessors

std::vector< std::unique_ptr<SG::AuxElement::Accessor<uint8_t> > > MuonCombined::MuonCreatorTool::m_copyCharSummaryAccessors
private

Definition at line 214 of file MuonCreatorTool.h.

◆ m_copyCharSummaryKeys

Gaudi::Property< std::vector<std::string> > MuonCombined::MuonCreatorTool::m_copyCharSummaryKeys
private
Initial value:
{this,"CopyUInt8SummaryKeys",
{"numberOfUsedHitsdEdx","numberOfIBLOverflowsdEdx","TRTdEdxUsedHits",
"expectInnermostPixelLayerHit", "expectNextToInnermostPixelLayerHit",
"numberOfPixelOutliers", "numberOfInnermostPixelLayerOutliers", "numberOfNextToInnermostPixelLayerOutliers", "numberOfSCTOutliers"},
"List of uint8_t aux element names to copy over from ID track particle summaries."}

Definition at line 201 of file MuonCreatorTool.h.

◆ m_copyFloatSummaryAccessors

std::vector< std::unique_ptr<SG::AuxElement::Accessor<float> > > MuonCombined::MuonCreatorTool::m_copyFloatSummaryAccessors
private

Definition at line 213 of file MuonCreatorTool.h.

◆ m_copyFloatSummaryKeys

Gaudi::Property< std::vector<std::string> > MuonCombined::MuonCreatorTool::m_copyFloatSummaryKeys
private
Initial value:
{this,"CopyFloatSummaryKeys",{"TRTTrackOccupancy","eProbabilityComb","eProbabilityHT","pixeldEdx","TRTdEdx","eProbabilityNN"},
"List of float aux element names to copy over from ID track particle summaries."}

Definition at line 198 of file MuonCreatorTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doSA

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_doSA {this, "MakeSAMuons", false}
private

Definition at line 190 of file MuonCreatorTool.h.

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonCombined::MuonCreatorTool::m_edmHelperSvc
private
Initial value:
{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 142 of file MuonCreatorTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fillEnergyLossFromTrack

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_fillEnergyLossFromTrack
private
Initial value:
{this, "FillEnergyLossFromTrack", true,
"Decide whether to try to extract the calo energy loss from tracks "}

Definition at line 178 of file MuonCreatorTool.h.

◆ m_fillExtraELossInfo

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_fillExtraELossInfo
private
Initial value:
{this, "FillExtraELossInfo", true,
"Can enabled this for debugging - will add extra information not for "
"production"}

Definition at line 181 of file MuonCreatorTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonCombined::MuonCreatorTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 141 of file MuonCreatorTool.h.

◆ m_meanMDTdADCTool

ToolHandle<Rec::IMuonMeanMDTdADCFiller> MuonCombined::MuonCreatorTool::m_meanMDTdADCTool
private
Initial value:
{this, "MeanMDTdADCTool",
"Rec::MuonMeanMDTdADCFillerTool/MuonMeanMDTdADCFillerTool"}

Definition at line 163 of file MuonCreatorTool.h.

◆ m_momentumBalanceTool

ToolHandle<Rec::IMuonMomentumBalanceSignificance> MuonCombined::MuonCreatorTool::m_momentumBalanceTool
private
Initial value:
{this, "MomentumBalanceTool",
"Rec::MuonMomentumBalanceSignificanceTool/"
"MuonMomentumBalanceSignificanceTool"}

Definition at line 155 of file MuonCreatorTool.h.

◆ m_muonDressingTool

ToolHandle<xAOD::IMuonDressingTool> MuonCombined::MuonCreatorTool::m_muonDressingTool {this, "MuonDressingTool", "MuonCombined::MuonDressingTool/MuonDressingTool"}
private

Definition at line 154 of file MuonCreatorTool.h.

◆ m_muonPrinter

ToolHandle<Rec::IMuonPrintingTool> MuonCombined::MuonCreatorTool::m_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
private

Definition at line 146 of file MuonCreatorTool.h.

◆ m_particleCreator

ToolHandle<Trk::ITrackParticleCreatorTool> MuonCombined::MuonCreatorTool::m_particleCreator
private
Initial value:
{this, "TrackParticleCreator",
"Trk::TrackParticleCreatorTool/MuonCombinedTrackParticleCreator"}

Definition at line 150 of file MuonCreatorTool.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuonCombined::MuonCreatorTool::m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
private

Definition at line 145 of file MuonCreatorTool.h.

◆ m_printSummary

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_printSummary {this, "PrintSummary", false, "flag to print muon edm"}
private

Definition at line 184 of file MuonCreatorTool.h.

◆ m_propagator

ToolHandle<Trk::IPropagator> MuonCombined::MuonCreatorTool::m_propagator {this, "Propagator", "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator"}
private

Definition at line 153 of file MuonCreatorTool.h.

◆ m_requireCaloDepositForSA

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_requireCaloDepositForSA
private
Initial value:
{this, "RequireCaloForSA", true,
"Flag to discard SA muons that have no calorimeter loss associated."}

Definition at line 211 of file MuonCreatorTool.h.

◆ m_requireIDTracks

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_requireIDTracks {this, "RequireIDTrack", false}
private

In case of running the muon reconstruction with LRT tracks this property removes the overlap of muons in the container in which in any case no ID track is available.

Definition at line 194 of file MuonCreatorTool.h.

◆ m_requireMSOEforSA

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_requireMSOEforSA
private
Initial value:
{this, "RequireMSOEforSA", true,
"Flag to accept muons with SA track only but not MSOE. Interesting for BSM?"}

Definition at line 208 of file MuonCreatorTool.h.

◆ m_scatteringAngleTool

ToolHandle<Rec::IMuonScatteringAngleSignificance> MuonCombined::MuonCreatorTool::m_scatteringAngleTool
private
Initial value:
{this, "ScatteringAngleTool",
"Rec::MuonScatteringAngleSignificanceTool/"
"MuonScatteringAngleSignificanceTool"}

Definition at line 158 of file MuonCreatorTool.h.

◆ m_segLowBeta

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_segLowBeta {this, "AssociateSegmentsToLowBetaMuons", false, "associate segments to MuGirlLowBeta muons"}
private

Definition at line 188 of file MuonCreatorTool.h.

◆ m_selectorTool

ToolHandle<CP::IMuonSelectionTool> MuonCombined::MuonCreatorTool::m_selectorTool {this, "MuonSelectionTool", "CP::MuonSelectionTool/MuonSelectionTool"}
private

Definition at line 161 of file MuonCreatorTool.h.

◆ m_sigmaCaloNoiseCut

Gaudi::Property<float> MuonCombined::MuonCreatorTool::m_sigmaCaloNoiseCut {this, "SigmaCaloNoiseCut", 3.4}
private

Definition at line 196 of file MuonCreatorTool.h.

◆ m_trackQuery

ToolHandle<Rec::IMuonTrackQuery> MuonCombined::MuonCreatorTool::m_trackQuery {this, "TrackQuery", "Rec::MuonTrackQuery/MuonTrackQuery"}
private

Definition at line 168 of file MuonCreatorTool.h.

◆ m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> MuonCombined::MuonCreatorTool::m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
private

Definition at line 169 of file MuonCreatorTool.h.

◆ m_useCaloCells

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_useCaloCells {this, "UseCaloCells", true}
private

Definition at line 189 of file MuonCreatorTool.h.

◆ m_useUpdatedExtrapolatedTrack

Gaudi::Property<bool> MuonCombined::MuonCreatorTool::m_useUpdatedExtrapolatedTrack
private
Initial value:
{this, "UseUpdatedExtrapolatedTrack", true,
"configure whether to use the updated extrapolated track for a combined "
"fit or not"}

Definition at line 185 of file MuonCreatorTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
grepfile.info
info
Definition: grepfile.py:38
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MuonCombined::MuonCreatorTool::createMuonSegmentElementLink
ElementLink< xAOD::MuonSegmentContainer > createMuonSegmentElementLink(const EventContext &ctx, const Muon::MuonSegment *segLink, const OutputData &outData) const
Definition: MuonCreatorTool.cxx:780
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
MuGirlNS::StauExtras::rpcBetaAvg
double rpcBetaAvg
Definition: CandidateSummary.h:91
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
MuonCombined::MuonCreatorTool::m_caloExtTool
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtTool
Definition: MuonCreatorTool.h:148
MuonCombined::MuonCreatorTool::m_caloNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_caloNoiseKey
Definition: MuonCreatorTool.h:174
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
MuGirlNS::StauExtras::caloBetaDof
int caloBetaDof
Definition: CandidateSummary.h:102
Rec::ScatteringAngleSignificance::neighbourSignificance
double neighbourSignificance(void) const
ScatteringAngleSignificance inline accessor: maximum significance of neighbouring scatterers.
Definition: ScatteringAngleSignificance.h:64
Trk::TrackInfo
Contains information about the 'fitter' of this track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:32
MuonCombined::MuonCreatorTool::addSegmentTag
void addSegmentTag(const EventContext &ctx, xAOD::Muon &muon, const SegmentTag *tag, OutputData &outputData) const
Definition: MuonCreatorTool.cxx:684
Trk::Track::fitQuality
const FitQuality * fitQuality() const
return a pointer to the fit quality const-overload
xAOD::SlowMuon_v1
Class describing a SlowMuon.
Definition: SlowMuon_v1.h:26
MuonCombined::MuonCreatorTool::m_requireCaloDepositForSA
Gaudi::Property< bool > m_requireCaloDepositForSA
Definition: MuonCreatorTool.h:211
xAOD::MuGirl
@ MuGirl
MuGirl.
Definition: TrackingPrimitives.h:142
MuGirlNS::StauExtras::mdtBetaAvg
double mdtBetaAvg
Definition: CandidateSummary.h:95
MuGirlNS::StauExtras::betaAll
double betaAll
Definition: CandidateSummary.h:86
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
Trk::MagneticFieldProperties
Definition: MagneticFieldProperties.h:31
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloEnergy
class extending the basic Trk::EnergyLoss to describe the measured or parameterised muon energy loss ...
Definition: CaloEnergy.h:28
Rec::CaloCellCollector::ET_EMCore
@ ET_EMCore
Definition: CaloCellCollector.h:30
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
MuGirlNS::StauExtras::numCaloCells
unsigned int numCaloCells
Definition: CandidateSummary.h:89
MuGirlNS::StauExtras::mdtBetaDof
unsigned int mdtBetaDof
Definition: CandidateSummary.h:98
MuonCombined::MuonCreatorTool::fillEnergyLossFromTrack
void fillEnergyLossFromTrack(xAOD::Muon &muon, const std::vector< const Trk::TrackStateOnSurface * > *tsosVector) const
Definition: MuonCreatorTool.cxx:1319
SG::Accessor< float >
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
MuonCombined::MuonCreatorTool::m_caloMaterialProvider
ToolHandle< Trk::ITrkMaterialProviderTool > m_caloMaterialProvider
Definition: MuonCreatorTool.h:165
MuonCombined::MuonCreatorTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonCreatorTool.h:141
DataVector::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::numberOfCscUnspoiltEtaHits
@ numberOfCscUnspoiltEtaHits
number of unspoilt CSC eta measurements (all CSC phi measurements are by definition spoilt).
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:142
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
MuonCombined::MuonCreatorTool::m_selectorTool
ToolHandle< CP::IMuonSelectionTool > m_selectorTool
Definition: MuonCreatorTool.h:161
MuonCombined::MuonCreatorTool::m_buildStauContainer
Gaudi::Property< bool > m_buildStauContainer
Definition: MuonCreatorTool.h:176
xAOD::SlowMuon_v1::setCaloInfo
void setCaloInfo(float caloBetaAvg, float caloBetaRms, float caloBetaChi2, int caloBetaDof)
Sets.
Definition: SlowMuon_v1.cxx:63
skel.it
it
Definition: skel.GENtoEVGEN.py:407
MuonParameters::scatteringNeighbourSignificance
@ scatteringNeighbourSignificance
Definition: MuonParamDefs.h:135
CaloEnergy::deltaEMeas
double deltaEMeas() const
get measured energy loss
Definition: CaloEnergy.h:127
xAOD::SlowMuon
SlowMuon_v1 SlowMuon
Reference the current persistent version:
Definition: SlowMuon.h:13
Trk::EnergyLoss::sigmaDeltaE
double sigmaDeltaE() const
returns the symmatric error
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Trk::z0
@ z0
Definition: ParamDefs.h:64
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
MuGirlNS::StauExtras::mdtBetaRms
double mdtBetaRms
Definition: CandidateSummary.h:96
MuonCombined::MuonCreatorTool::m_propagator
ToolHandle< Trk::IPropagator > m_propagator
Definition: MuonCreatorTool.h:153
MuonCombined::MuonCreatorTool::m_momentumBalanceTool
ToolHandle< Rec::IMuonMomentumBalanceSignificance > m_momentumBalanceTool
Definition: MuonCreatorTool.h:155
CaloEnergy::deltaEParam
double deltaEParam() const
get parametrised energy loss
Definition: CaloEnergy.h:137
Rec::CaloCellCollector::collectCells
xAOD::CaloCluster * collectCells(const Trk::CaloExtension &extension, const CaloDetDescrManager *caloMgr, const CaloCellContainer &cellContainer, xAOD::CaloClusterContainer &clusterContainer) const
Definition: CaloCellCollector.cxx:151
MuonCombined::MuonCreatorTool::m_muonPrinter
ToolHandle< Rec::IMuonPrintingTool > m_muonPrinter
Definition: MuonCreatorTool.h:146
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Rec::ScatteringAngleSignificance::curvatureSignificance
double curvatureSignificance(void) const
ScatteringAngleSignificance inline accessor: significance of maximum curvature discontinuity.
Definition: ScatteringAngleSignificance.h:54
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
MuonCombined::MuonCreatorTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: MuonCreatorTool.h:142
MuonCombined::MuonCreatorTool::collectCells
void collectCells(const EventContext &ctx, xAOD::Muon &muon, xAOD::CaloClusterContainer *clusterContainer, const Trk::CaloExtension *inputCaloExt=nullptr) const
Definition: MuonCreatorTool.cxx:1366
MuonCombined::MuonCreatorTool::decorateDummyValues
void decorateDummyValues(const EventContext &ctx, xAOD::Muon &muon, OutputData &outputData) const
De^corated a bunch of dummy values to the muon to ensure data consistency in the xAOD.
Definition: MuonCreatorTool.cxx:230
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
MuonParameters::CaloTag
@ CaloTag
Definition: MuonParamDefs.h:64
MuGirlNS::StauExtras::rpcBetaChi2
double rpcBetaChi2
Definition: CandidateSummary.h:93
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
MuonCombined::MuonCreatorTool::m_useCaloCells
Gaudi::Property< bool > m_useCaloCells
Definition: MuonCreatorTool.h:189
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
MuonCombined::MuonCreatorTool::selectStaus
void selectStaus(InDetCandidateTagsMap &resolvedInDetCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps) const
Definition: MuonCreatorTool.cxx:941
MuonCombined::MuonCreatorTool::m_muonDressingTool
ToolHandle< xAOD::IMuonDressingTool > m_muonDressingTool
Definition: MuonCreatorTool.h:154
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
MuonParameters::segmentDeltaPhi
@ segmentDeltaPhi
Definition: MuonParamDefs.h:140
MuonCombined::MuonCreatorTool::m_copyFloatSummaryAccessors
std::vector< std::unique_ptr< SG::AuxElement::Accessor< float > > > m_copyFloatSummaryAccessors
Definition: MuonCreatorTool.h:213
CaloEnergy::sigmaDeltaEMeas
double sigmaDeltaEMeas() const
get measured energy loss error
Definition: CaloEnergy.h:130
MuonParameters::MuTagIMO
@ MuTagIMO
Definition: MuonParamDefs.h:66
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::SlowMuon_v1::setBeta
void setBeta(float beta)
Sets.
MuonCombined::MuonCreatorTool::create
virtual void create(const EventContext &ctx, const MuonCandidateCollection *muonCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps, OutputData &outputData) const override final
IMuonCreatorTool interface: build muons from ID and MS candidates.
Definition: MuonCreatorTool.cxx:116
MuonCombined::MuonCreatorTool::m_copyCharSummaryKeys
Gaudi::Property< std::vector< std::string > > m_copyCharSummaryKeys
Definition: MuonCreatorTool.h:202
MuonParameters::momentumBalanceSignificance
@ momentumBalanceSignificance
Definition: MuonParamDefs.h:136
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuGirlNS::StauExtras::caloBetaAvg
double caloBetaAvg
Definition: CandidateSummary.h:99
Rec::ScatteringAngleSignificance
Definition: ScatteringAngleSignificance.h:22
xAOD::SlowMuon_v1::setMuonLink
void setMuonLink(const ElementLink< MuonContainer > &muonLink)
Sets.
MuGirlNS::StauExtras::ann
double ann
Definition: CandidateSummary.h:85
MuonCombined::MuonCreatorTool::m_printSummary
Gaudi::Property< bool > m_printSummary
Definition: MuonCreatorTool.h:184
Trk::MaterialEffectsOnTrack
represents the full description of deflection and e-loss of a track in material.
Definition: MaterialEffectsOnTrack.h:40
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
MuonCombined::MuonCreatorTool::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: MuonCreatorTool.h:216
tags
std::vector< std::string > tags
Definition: hcg.cxx:102
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
CaloEnergy::energyLossType
CaloEnergy::EnergyLossType energyLossType(void) const
Accessor methods.
Definition: CaloEnergy.h:162
PlotPulseshapeFromCool.can
can
Definition: PlotPulseshapeFromCool.py:91
MuonCombined::MuonCreatorTool::m_trackQuery
ToolHandle< Rec::IMuonTrackQuery > m_trackQuery
Definition: MuonCreatorTool.h:168
xAOD::SlowMuon_v1::setAnn
void setAnn(float ann)
Sets.
MuonCombined::MuonCreatorTool::m_particleCreator
ToolHandle< Trk::ITrackParticleCreatorTool > m_particleCreator
Definition: MuonCreatorTool.h:150
AthCommonDataStore
Definition: AthCommonDataStore.h:52
StateLessPT_NewConfig.primary
primary
Definition: StateLessPT_NewConfig.py:234
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonCombined::MuonCandidate
Definition: Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h:25
columnar::ContainerId::cluster
@ cluster
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
MuonCombined::MuonCreatorTool::m_scatteringAngleTool
ToolHandle< Rec::IMuonScatteringAngleSignificance > m_scatteringAngleTool
Definition: MuonCreatorTool.h:158
MuGirlNS::StauExtras::hits
StauHits hits
Definition: CandidateSummary.h:103
MuonCombined::IMuonCreatorTool::InDetCandidateTags
std::pair< const InDetCandidate *, std::vector< const TagBase * > > InDetCandidateTags
Definition: IMuonCreatorTool.h:35
MuonCombined::MuonCreatorTool::addStatisticalCombination
void addStatisticalCombination(const EventContext &ctx, xAOD::Muon &muon, const InDetCandidate *candidate, const StacoTag *tag, OutputData &outputData) const
Definition: MuonCreatorTool.cxx:389
MuGirlNS::StauExtras::rpcBetaDof
unsigned int rpcBetaDof
Definition: CandidateSummary.h:94
MuGirlNS::StauExtras::mdtBetaChi2
double mdtBetaChi2
Definition: CandidateSummary.h:97
Trk::theta
@ theta
Definition: ParamDefs.h:66
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
MuonCombined::MuonCreatorTool::addMuonCandidate
void addMuonCandidate(const EventContext &ctx, const MuonCandidate &candidate, xAOD::Muon &muon, OutputData &outputData, const ElementLink< TrackCollection > &meLink=ElementLink< TrackCollection >()) const
add muon candidate info to a muon, if an updateExtrapolatedTrack is provided, the routine takes owner...
Definition: MuonCreatorTool.cxx:797
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonCombined::MuonCreatorTool::dressMuon
bool dressMuon(xAOD::Muon &muon) const
Definition: MuonCreatorTool.cxx:1201
MuGirlNS::StauExtras::numRpcHitsInSeg
unsigned int numRpcHitsInSeg
Definition: CandidateSummary.h:88
MuonParameters::segmentDeltaEta
@ segmentDeltaEta
MuTag parameters.
Definition: MuonParamDefs.h:139
Trk::EnergyLoss::deltaE
double deltaE() const
returns the
MuonCombined::MuonCreatorTool::m_fillEnergyLossFromTrack
Gaudi::Property< bool > m_fillEnergyLossFromTrack
Definition: MuonCreatorTool.h:178
test_pyathena.parent
parent
Definition: test_pyathena.py:15
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Rec::CaloCellCollector::ET_Core
@ ET_Core
Definition: CaloCellCollector.h:29
hist_file_dump.f
f
Definition: hist_file_dump.py:141
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
MuGirlNS::StauExtras::betaAllt
double betaAllt
Definition: CandidateSummary.h:87
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
MuonCombined::MuonCreatorTool::InDetCandidateTagsMap
std::vector< InDetCandidateTags > InDetCandidateTagsMap
Definition: MuonCreatorTool.h:62
xAOD::SlowMuon_v1::setRpcInfo
void setRpcInfo(float rpcBetaAvg, float rpcBetaRms, float rpcBetaChi2, int rpcBetaDof)
Sets.
Definition: SlowMuon_v1.cxx:31
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
MuGirlNS::StauExtras::caloBetaRms
double caloBetaRms
Definition: CandidateSummary.h:100
DataVector::rbegin
const_reverse_iterator rbegin() const noexcept
Return a const_reverse_iterator pointing past the end of the collection.
Rec::CaloCellCollector::collectEtCore
void collectEtCore(const xAOD::CaloCluster &cluster, std::vector< float > &et_core, const CaloNoise *caloNoise, float sigmaNoiseCut=3.4) const
Definition: CaloCellCollector.cxx:259
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
xAOD::SlowMuon_v1::setNRpcHits
void setNRpcHits(int nRpcHits)
Sets.
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloNoise
Definition: CaloNoise.h:16
MuonCombined::MuonCreatorTool::m_copyCharSummaryAccessors
std::vector< std::unique_ptr< SG::AuxElement::Accessor< uint8_t > > > m_copyCharSummaryAccessors
Definition: MuonCreatorTool.h:214
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Trk::NoField
@ NoField
Field is set to 0., 0., 0.,.
Definition: MagneticFieldMode.h:18
MuonCombined::MuonCreatorTool::m_doSA
Gaudi::Property< bool > m_doSA
Definition: MuonCreatorTool.h:190
MuonParameters::scatteringCurvatureSignificance
@ scatteringCurvatureSignificance
Definition: MuonParamDefs.h:134
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
MuonCombined::MuonCreatorTool::setP4
void setP4(xAOD::Muon &muon, const xAOD::TrackParticle &tp) const
Definition: MuonCreatorTool.cxx:1430
MuonCombined::MuonCreatorTool::m_requireMSOEforSA
Gaudi::Property< bool > m_requireMSOEforSA
Definition: MuonCreatorTool.h:208
xAOD::Muon
Muon_v1 Muon
Reference the current persistent version:
Definition: Event/xAOD/xAODMuon/xAODMuon/Muon.h:13
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
CaloEnergy::fsrCandidateEnergy
float fsrCandidateEnergy() const
FSR Candidate Energy.
Definition: CaloEnergy.h:94
MuonCombined::MuonCreatorTool::createDummyTrack
std::unique_ptr< Trk::Track > createDummyTrack(const EventContext &ctx, const std::vector< const Muon::MuonSegment * > &segments, const Trk::Track &indetTrack) const
Definition: MuonCreatorTool.cxx:1165
MuonCombined::MuonCreatorTool::m_cellContainerName
SG::ReadHandleKey< CaloCellContainer > m_cellContainerName
Definition: MuonCreatorTool.h:173
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::d0
@ d0
Definition: ParamDefs.h:63
DataVector< const Trk::TrackStateOnSurface >::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Standard const_reverse_iterator.
Definition: DataVector.h:846
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
MuonCombined::MuonCreatorTool::m_ambiguityProcessor
ToolHandle< Trk::ITrackAmbiguityProcessorTool > m_ambiguityProcessor
Definition: MuonCreatorTool.h:152
Trk::EnergyLoss
This class describes energy loss material effects in the ATLAS tracking EDM.
Definition: EnergyLoss.h:34
CaloEnergy::sigmaPlusDeltaEParam
double sigmaPlusDeltaEParam() const
get parametrised energy loss plus error
Definition: CaloEnergy.h:143
charge
double charge(const T &p)
Definition: AtlasPID.h:931
Rec::CaloCellCollector::ET_HECCore
@ ET_HECCore
Definition: CaloCellCollector.h:32
MuonCombined::MuonCreatorTool::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: MuonCreatorTool.h:145
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
MuonParameters::MuidSA
@ MuidSA
Definition: MuonParamDefs.h:59
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuGirlNS::StauExtras::extraMDTHitInfo
std::optional< StauMDTHitExtras > extraMDTHitInfo
Definition: CandidateSummary.h:104
CaloEnergy::sigmaMinusDeltaEParam
double sigmaMinusDeltaEParam() const
get parametrised energy loss minus error
Definition: CaloEnergy.h:140
xAOD::JetAttributeAccessor::accessor
const AccessorWrapper< T > * accessor(xAOD::JetAttribute::AttributeID id)
Returns an attribute accessor corresponding to an AttributeID.
Definition: JetAccessorMap.h:26
DataVector::stdcont
const PtrVector & stdcont() const
Return the underlying std::vector of the container.
MuonParameters::MuidCo
@ MuidCo
Definition: MuonParamDefs.h:60
MuonCombined::MuonCreatorTool::addMuGirl
void addMuGirl(const EventContext &ctx, xAOD::Muon &muon, const MuGirlTag *tag, OutputData &outputData) const
Definition: MuonCreatorTool.cxx:629
a
TList * a
Definition: liststreamerinfos.cxx:10
Trk::MaterialEffectsOnTrack::energyLoss
const EnergyLoss * energyLoss() const
returns the energy loss object.
h
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
MuonCombined::MuonCreatorTool::m_requireIDTracks
Gaudi::Property< bool > m_requireIDTracks
In case of running the muon reconstruction with LRT tracks this property removes the overlap of muons...
Definition: MuonCreatorTool.h:194
MuonCombined::MuonCreatorTool::addMuGirlLowBeta
void addMuGirlLowBeta(const EventContext &ctx, xAOD::Muon &muon, const MuGirlLowBetaTag *tag, xAOD::SlowMuon *slowMuon, OutputData &outputData) const
Definition: MuonCreatorTool.cxx:520
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::Track::trackSummary
const Trk::TrackSummary * trackSummary() const
Returns a pointer to the const Trk::TrackSummary owned by this const track (could be nullptr)
MuonCombined::MuonCreatorTool::addCaloTag
void addCaloTag(xAOD::Muon &muon, const CaloTag *tag) const
Definition: MuonCreatorTool.cxx:720
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
DeMoScan.first
bool first
Definition: DeMoScan.py:536
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:26
MuonCombined::MuonCreatorTool::m_copyFloatSummaryKeys
Gaudi::Property< std::vector< std::string > > m_copyFloatSummaryKeys
Definition: MuonCreatorTool.h:199
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonCombined::MuonCreatorTool::m_fillExtraELossInfo
Gaudi::Property< bool > m_fillExtraELossInfo
Definition: MuonCreatorTool.h:181
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
Trk::TrackInfo::MuTag
@ MuTag
Tracks produced by MuTag.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:129
Rec::CaloCellCollector::ET_TileCore
@ ET_TileCore
Definition: CaloCellCollector.h:31
MuonCombined::MuonCreatorTool::addCombinedFit
void addCombinedFit(const EventContext &ctx, xAOD::Muon &muon, const CombinedFitTag *tag, OutputData &outputData) const
Definition: MuonCreatorTool.cxx:486
MuonCombined::MuonCreatorTool::m_meanMDTdADCTool
ToolHandle< Rec::IMuonMeanMDTdADCFiller > m_meanMDTdADCTool
Definition: MuonCreatorTool.h:163
MuGirlNS::StauExtras::rpcBetaRms
double rpcBetaRms
Definition: CandidateSummary.h:92
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::STACO
@ STACO
Tracks produced by STACO.
Definition: TrackingPrimitives.h:100
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
Trk::TrackSummary::get
int get(const SummaryType &type) const
returns the summary information for the passed SummaryType.
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MuonParameters::segmentChi2OverDoF
@ segmentChi2OverDoF
Definition: MuonParamDefs.h:141
Trk::CaloExtension::caloLayerIntersections
const std::vector< CurvilinearParameters > & caloLayerIntersections() const
access to the intersections with the calorimeter layers.
Definition: CaloExtension.h:59
MuonCombined::MuonCreatorTool::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: MuonCreatorTool.h:169
MuGirlNS::StauExtras
Definition: CandidateSummary.h:84
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
MuonCombined::MuonCreatorTool::m_sigmaCaloNoiseCut
Gaudi::Property< float > m_sigmaCaloNoiseCut
Definition: MuonCreatorTool.h:196
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Trk::TrackInfo::TrackPatternRecoInfo
TrackPatternRecoInfo
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:100
xAOD::SlowMuon_v1::setMdtInfo
void setMdtInfo(float mdtBetaAvg, float mdtBetaRms, float mdtBetaChi2, int mdtBetaDof)
Sets.
Definition: SlowMuon_v1.cxx:47
xAOD::SlowMuon_v1::setNTileCells
void setNTileCells(int nTileCells)
Sets.
Trk::phi0
@ phi0
Definition: ParamDefs.h:65
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
MuonParameters::spectrometerFieldIntegral
@ spectrometerFieldIntegral
Discriminators and further variables.
Definition: MuonParamDefs.h:133
MuonCombined::MuonCreatorTool::createTrackParticleElementLink
ElementLink< xAOD::TrackParticleContainer > createTrackParticleElementLink(const ElementLink< TrackCollection > &trackLink, xAOD::TrackParticleContainer &trackParticleContainer, TrackCollection *trackCollection=0) const
function creates an element link to a track particle from the track and the TrackParticle collection.
Definition: MuonCreatorTool.cxx:754
MuonCombined::TagBase
base-class for combined reconstruction output Provides access to MuonType and Author
Definition: TagBase.h:48
MuGirlNS::StauExtras::caloBetaChi2
double caloBetaChi2
Definition: CandidateSummary.h:101
xAOD::SlowMuon_v1::setBetaT
void setBetaT(float betaT)
Sets.
fitman.k
k
Definition: fitman.py:528
MuonCombined::MuonCreatorTool::addEnergyLossToMuon
void addEnergyLossToMuon(xAOD::Muon &muon) const
Definition: MuonCreatorTool.cxx:1273
MuonCombined::MuonCreatorTool::m_cellCollector
Rec::CaloCellCollector m_cellCollector
Definition: MuonCreatorTool.h:171
MuonCombined::MuonCreatorTool::resolveOverlaps
void resolveOverlaps(const EventContext &ctx, const MuonCandidateCollection *muonCandidates, const std::vector< const InDetCandidateToTagMap * > &tagMaps, InDetCandidateTagsMap &resolvedInDetCandidates, std::vector< const MuonCombined::MuonCandidate * > &resolvedMuonCandidates, bool select_comissioning=false) const
Definition: MuonCreatorTool.cxx:969
MuonCombined::MuonCreatorTool::m_addMDTExtrasMuGirlLowBeta
Gaudi::Property< bool > m_addMDTExtrasMuGirlLowBeta
Definition: MuonCreatorTool.h:177
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Trk::TrackInfo::Unknown
@ Unknown
Track fitter not defined.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:41
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Thu Apr 24 2025 22:02:20 for ATLAS Offline Software by   doxygen 1.8.18