ATLAS Offline Software
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_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 702 of file MuonCreatorTool.cxx.

702  {
703  static const SG::Accessor<float> acc_ElType("CT_EL_Type"); // FIXME - should be uint
704  static const SG::Accessor<float> acc_ElFSREnergy("CT_ET_FSRCandidateEnergy");
705 
706  if (!tag) {
707  // init variables if necessary.
708 
709  mu.setParameter(0.f, xAOD::Muon::CaloMuonScore);
710  mu.setParameter(static_cast<int>(0xFF), xAOD::Muon::CaloMuonIDTag);
711  if (m_fillExtraELossInfo) {
712  // Here we can make sure that we store the extra calotag information -
713  // just always add it since this is then unambigious for debugging
714  acc_ET_Core(mu) = 0.0;
715  acc_ElType(mu) = -999.0;
716  acc_ElFSREnergy(mu) = -999.0;
717  }
718  return;
719  }
720 
721  ATH_MSG_DEBUG("Adding Calo Muon with author " << tag->author() << ", type " << tag->type() << ", CaloMuonScore "
722  << tag->caloMuonScore());
723  mu.setParameter(static_cast<float>(tag->caloMuonScore()), xAOD::Muon::CaloMuonScore);
724  mu.setParameter(static_cast<int>(tag->caloMuonIdTag()), xAOD::Muon::CaloMuonIDTag);
725 
726  if (m_fillExtraELossInfo) {
727  // Here we can make sure that we store the extra calotag information - just
728  // always add it since this is then unambigious for debugging
729  acc_ET_Core(mu) = tag->etCore();
730  acc_ElType(mu) = tag->energyLossType();
731  acc_ElFSREnergy(mu) = tag->fsrCandidateEnergy();
732  }
733  // FIXME - calo deposits
734  }

◆ 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 1255 of file MuonCreatorTool.cxx.

1255  {
1256  if (!muon.inDetTrackParticleLink().isValid()) {
1257  ATH_MSG_WARNING("Missing ID track particle link in addEnergyLossToMuon!");
1258  return;
1259  }
1260 
1261  // get ID track particle
1262  const Trk::Track* trk = (*(muon.inDetTrackParticleLink()))->track();
1263  if (!trk) {
1264  ATH_MSG_WARNING("Missing ID trk::track in addEnergyLossToMuon!");
1265  return;
1266  }
1267 
1268  // find last ID TSOS with track parameters
1269  const Trk::TrackStateOnSurface* lastID = nullptr;
1270  Trk::TrackStates::const_reverse_iterator it = trk->trackStateOnSurfaces()->rbegin();
1271  Trk::TrackStates::const_reverse_iterator itEnd = trk->trackStateOnSurfaces()->rend();
1272  for (; it != itEnd; ++it) {
1273  if ((*it)->trackParameters()) {
1274  lastID = *it;
1275  break;
1276  }
1277  }
1278  if (!lastID) {
1279  ATH_MSG_WARNING("Missing ID TSOS with track parameters in addEnergyLossToMuon!");
1280  return;
1281  }
1282 
1283  // get calorimeter TSOS
1284  std::vector<const Trk::TrackStateOnSurface*>* caloTSOS = m_caloMaterialProvider->getCaloTSOS(*((*it)->trackParameters()), *trk);
1285 
1286  if (!caloTSOS) {
1287  ATH_MSG_WARNING("Unable to find calo TSOS in addEnergyLossToMuon!");
1288  return;
1289  }
1290 
1291  // fill muon parameters for eloss
1292  fillEnergyLossFromTrack(muon, caloTSOS);
1293 
1294  // delete caloTSOS
1295  std::vector<const Trk::TrackStateOnSurface*>::const_iterator it2 = caloTSOS->begin();
1296  std::vector<const Trk::TrackStateOnSurface*>::const_iterator itEnd2 = caloTSOS->end();
1297  for (; it2 != itEnd2; ++it2) delete *it2;
1298  delete caloTSOS;
1299  }

◆ addMuGirl()

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

Definition at line 611 of file MuonCreatorTool.cxx.

611  {
612  if (!tag) {
613  // init variables if necessary.
614  return;
615  }
616 
617  ATH_MSG_DEBUG("Adding MuGirl Muon " << tag->author() << " type " << tag->type());
618 
619  if (!muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()) {
620  // if the combined track particle is part of a container set the link
621  if (outputData.combinedTrackParticleContainer) {
622  // create element link
623  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
624  tag->combinedTrackLink(), *outputData.combinedTrackParticleContainer, outputData.combinedTrackCollection);
625 
626  if (link.isValid()) {
627  // link.toPersistent();
628  ATH_MSG_DEBUG("Adding MuGirl: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
629  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
630  } else
631  ATH_MSG_WARNING("Creating of MuGirl TrackParticle Link failed");
632  }
633 
634  if (outputData.extrapolatedTrackParticleContainer && tag->updatedExtrapolatedTrack()) {
635  // create element link
636  ElementLink<xAOD::TrackParticleContainer> link =
637  createTrackParticleElementLink(tag->updatedExtrapolatedTrackLink(), *outputData.extrapolatedTrackParticleContainer,
638  outputData.extrapolatedTrackCollection);
639 
640  if (link.isValid()) {
641  ATH_MSG_DEBUG("Adding MuGirl: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
642  muon.setTrackParticleLink(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, link);
643  } else
644  ATH_MSG_WARNING("Creating of MuGirl TrackParticle Link failed");
645  }
646 
647  if (outputData.xaodSegmentContainer) {
648  ATH_MSG_DEBUG("Adding MuGirl muonSegmentCollection");
649 
650  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
651  for (const Muon::MuonSegment* segLink : tag->associatedSegments()) {
652  ElementLink<xAOD::MuonSegmentContainer> link = createMuonSegmentElementLink(ctx, segLink, outputData);
653  if (link.isValid()) {
654  segments.push_back(link);
655  ATH_MSG_DEBUG("Adding MuGirl: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz "
656  << (*link)->pz());
657  } else
658  ATH_MSG_WARNING("Creating of MuGirl segment Link failed");
659  }
660  muon.setMuonSegmentLinks(segments);
661  }
662  }
663  ATH_MSG_DEBUG("Done Adding MuGirl Muon " << tag->author() << " type " << tag->type());
664  }

◆ 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  std::vector<uint8_t>& eTechVec = eTechAcc(*slowMuon);
555  std::vector<unsigned int>& idVec = idAcc(*slowMuon);
556  std::vector<float>& mToFVec = mToFAcc(*slowMuon);
557  std::vector<float>& xVec = xAcc(*slowMuon);
558  std::vector<float>& yVec = yAcc(*slowMuon);
559  std::vector<float>& zVec = zAcc(*slowMuon);
560  std::vector<float>& eVec = eAcc(*slowMuon);
561 
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 
580  if (!muon.combinedTrackParticleLink().isValid() && tag->combinedTrack()) {
581  // if the combined track particle is part of a container set the link
582  if (outputData.combinedTrackParticleContainer) {
583  // create element link
584  ElementLink<xAOD::TrackParticleContainer> link = createTrackParticleElementLink(
585  tag->combinedTrackLink(), *outputData.combinedTrackParticleContainer, outputData.combinedTrackCollection);
586 
587  if (link.isValid()) {
588  ATH_MSG_DEBUG("Adding MuGirlLowBeta: pt " << (*link)->pt() << " eta " << (*link)->eta() << " phi " << (*link)->phi());
589  muon.setTrackParticleLink(xAOD::Muon::CombinedTrackParticle, link);
590  } else
591  ATH_MSG_WARNING("Creating of MuGirlLowBeta TrackParticle Link failed");
592  }
593  }
594 
595  if (outputData.xaodSegmentContainer) {
596  ATH_MSG_DEBUG("Adding MuGirlLowBeta muonSegmentColection");
597  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
598  for (const ElementLink<Trk::SegmentCollection>& seglink : tag->segments()) {
599  ElementLink<xAOD::MuonSegmentContainer> link{*outputData.xaodSegmentContainer, seglink.index(), ctx};
600  if (link.isValid()) {
601  segments.push_back(link);
602  ATH_MSG_DEBUG("Adding MuGirlLowBeta: xaod::MuonSegment px " << (*link)->px() << " py " << (*link)->py() << " pz "
603  << (*link)->pz());
604  } else
605  ATH_MSG_WARNING("Creating of MuGirlLowBeta segment Link failed");
606  }
607  muon.setMuonSegmentLinks(segments);
608  }
609  }

◆ 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 779 of file MuonCreatorTool.cxx.

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

◆ addSegmentTag()

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

Definition at line 666 of file MuonCreatorTool.cxx.

666  {
667  if (!tag) {
668  // init variables if necessary.
669  muon.setParameter(-1.f, xAOD::Muon::segmentDeltaEta);
670  muon.setParameter(-1.f, xAOD::Muon::segmentDeltaPhi);
671  muon.setParameter(-1.f, xAOD::Muon::segmentChi2OverDoF);
672  return;
673  }
674 
675  ATH_MSG_DEBUG("Adding Segment Tag Muon " << tag->author() << " type " << tag->type());
676 
677  std::vector<ElementLink<xAOD::MuonSegmentContainer>> segments;
678  bool foundseg = false;
679  for (const auto& info : tag->segmentsInfo()) {
680  // this is a bit tricky, as we have here a link to an xAOD segment in the old container
681  // but the new container should have the segments in the same order, plus the MuGirl ones tacked on the end
682  // so we should be able to just make a new link here
683  // note that this only applies to segment-tagged muons, others get their associated segments elsewhere
684  if (muon.author() == xAOD::Muon::MuTagIMO) {
685  ElementLink<xAOD::MuonSegmentContainer> seglink = createMuonSegmentElementLink(ctx, info.segment, outputData);
686  if (seglink.isValid()) segments.push_back(seglink);
687  }
688 
689  if (!foundseg) { // add parameters for the first segment
690  muon.setParameter(static_cast<float>(info.dtheta), xAOD::Muon::segmentDeltaEta);
691  muon.setParameter(static_cast<float>(info.dphi), xAOD::Muon::segmentDeltaPhi);
692  muon.setParameter(static_cast<float>(info.segment->fitQuality()->chiSquared() / info.segment->fitQuality()->numberDoF()),
693  xAOD::Muon::segmentChi2OverDoF);
694  foundseg = true;
695  } else if (muon.author() != xAOD::Muon::MuTagIMO)
696  break; // for non-segment-tagged muons, we only need to set the above
697  // parameters
698  }
699  if (muon.author() == xAOD::Muon::MuTagIMO) muon.setMuonSegmentLinks(segments); // set the associated segments
700  }

◆ 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 1348 of file MuonCreatorTool.cxx.

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

◆ 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 1147 of file MuonCreatorTool.cxx.

1149  {
1150  ATH_MSG_VERBOSE("Creating dummy tracks from segments...");
1151 
1152  auto trackStateOnSurfaces = std::make_unique<Trk::TrackStates>();
1153 
1154  for (const Muon::MuonSegment* seg : segments) {
1155  // create pars for muon and loop over hits
1156  double momentum{1e8}, charge{0.};
1157  std::unique_ptr<const Trk::TrackParameters> pars{m_edmHelperSvc->createTrackParameters(*seg, momentum, charge)};
1158  for (const Trk::MeasurementBase* meas : seg->containedMeasurements()) {
1159  std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern(0);
1160  typePattern.set(Trk::TrackStateOnSurface::Measurement);
1161  // TSoS takes ownership
1162  std::unique_ptr<Trk::TrackParameters> exPars{m_propagator->propagateParameters(
1163  ctx, *pars, meas->associatedSurface(), Trk::anyDirection, false, Trk::MagneticFieldProperties(Trk::NoField))};
1164  if (!exPars) { ATH_MSG_VERBOSE("Could not propagate Track to segment surface"); }
1165  Trk::TrackStateOnSurface* trackState =
1166  new Trk::TrackStateOnSurface(meas->uniqueClone(), std::move(exPars), nullptr, typePattern);
1167  trackStateOnSurfaces->push_back(trackState);
1168  } // end segment loop
1169  }
1170 
1171  Trk::TrackInfo info(Trk::TrackInfo::Unknown, Trk::muon);
1172  Trk::TrackInfo::TrackPatternRecoInfo author = Trk::TrackInfo::MuTag;
1173  info.setPatternRecognitionInfo(author);
1174  std::unique_ptr<Trk::Track> newtrack =
1175  std::make_unique<Trk::Track>(info, std::move(trackStateOnSurfaces), (indetTrack.fitQuality())->uniqueClone());
1176 
1177  // create a track summary for this track
1178  if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*newtrack, false); }
1179 
1180  return newtrack;
1181  }

◆ createMuonSegmentElementLink()

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

Definition at line 762 of file MuonCreatorTool.cxx.

764  {
765  if (outData.xaodSegmentContainer && outData.tagToSegmentAssocMap) {
766  // if a muon segment collection is provided, duplicate the segment and
767  // create a link to that
768  unsigned int link = outData.tagToSegmentAssocMap->linkIndex(trkSeg);
769  if (link >= outData.xaodSegmentContainer->size()) {
770  ATH_MSG_WARNING("Failed to retrieve a proper link for segment " << m_printer->print(*trkSeg));
771  return {};
772  }
773  ElementLink<xAOD::MuonSegmentContainer> eleLink{*outData.xaodSegmentContainer, link, ctx};
774  return eleLink;
775  }
776  return ElementLink<xAOD::MuonSegmentContainer>();
777  }

◆ 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 736 of file MuonCreatorTool.cxx.

738  {
739  ATH_MSG_DEBUG("createTrackParticleElementLink");
740  xAOD::TrackParticle* tp = nullptr;
741  if (trackCollection) {
742  trackCollection->push_back(new Trk::Track(**trackLink));
743  // want to link the track particle to this track
744  ElementLink<TrackCollection> link(*trackCollection, trackCollection->size() - 1);
745  if (link.isValid())
746  tp = m_particleCreator->createParticle(link, &trackParticleContainer, nullptr, xAOD::muon);
747  else
748  ATH_MSG_WARNING("new Track Collection link invalid");
749  }
750  if (!tp) {
751  // create track particle without a link to the track
752  tp = m_particleCreator->createParticle(**trackLink, &trackParticleContainer, nullptr, xAOD::muon);
753  }
754 
755  if (tp) {
756  ElementLink<xAOD::TrackParticleContainer> link(trackParticleContainer, trackParticleContainer.size() - 1);
757  return link;
758  }
759  return ElementLink<xAOD::TrackParticleContainer>();
760  }

◆ 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 1183 of file MuonCreatorTool.cxx.

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

◆ 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 1301 of file MuonCreatorTool.cxx.

1301  {
1302  // Ensure these are set for every muon
1303  if (!tsosVector) {
1304  muon.setParameter(0.f, xAOD::Muon::EnergyLoss);
1305  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLoss);
1306  muon.setParameter(0.f, xAOD::Muon::MeasEnergyLoss);
1307  muon.setParameter(0.f, xAOD::Muon::EnergyLossSigma);
1308  muon.setParameter(0.f, xAOD::Muon::MeasEnergyLossSigma);
1309  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLossSigmaPlus);
1310  muon.setParameter(0.f, xAOD::Muon::ParamEnergyLossSigmaMinus);
1311 
1312  muon.setEnergyLossType(xAOD::Muon::Parametrized); // Not so nice! Add 'unknown' type?
1313  muon.setParameter(0.f, xAOD::Muon::FSR_CandidateEnergy);
1314  if (m_fillExtraELossInfo) acc_numEnergyLossPerTrack(muon) = 0;
1315 
1316  return;
1317  }
1318 
1319  unsigned int numEnergyLossPerTrack = 0;
1320  bool problem = false;
1321  for (const auto* tsos : *tsosVector) {
1322  const Trk::MaterialEffectsOnTrack* meot = dynamic_cast<const Trk::MaterialEffectsOnTrack*>(tsos->materialEffectsOnTrack());
1323  if (!meot) continue;
1324  const Trk::EnergyLoss* el = meot->energyLoss();
1325  const CaloEnergy* caloEnergy = dynamic_cast<const CaloEnergy*>(el);
1326  if (!caloEnergy) continue;
1327  ++numEnergyLossPerTrack;
1328 
1329  muon.setParameter(static_cast<float>(caloEnergy->deltaE()), xAOD::Muon::EnergyLoss);
1330  muon.setParameter(static_cast<float>(caloEnergy->deltaEParam()), xAOD::Muon::ParamEnergyLoss);
1331  muon.setParameter(static_cast<float>(caloEnergy->deltaEMeas()), xAOD::Muon::MeasEnergyLoss);
1332  muon.setParameter(static_cast<float>(caloEnergy->sigmaDeltaE()), xAOD::Muon::EnergyLossSigma);
1333  muon.setParameter(static_cast<float>(caloEnergy->sigmaDeltaEMeas()), xAOD::Muon::MeasEnergyLossSigma);
1334  muon.setParameter(static_cast<float>(caloEnergy->sigmaPlusDeltaEParam()), xAOD::Muon::ParamEnergyLossSigmaPlus);
1335  muon.setParameter(static_cast<float>(caloEnergy->sigmaMinusDeltaEParam()), xAOD::Muon::ParamEnergyLossSigmaMinus);
1336 
1337  muon.setEnergyLossType(static_cast<xAOD::Muon::EnergyLossType>(caloEnergy->energyLossType()));
1338  muon.setParameter(static_cast<float>(caloEnergy->fsrCandidateEnergy()), xAOD::Muon::FSR_CandidateEnergy);
1339  }
1340  if (numEnergyLossPerTrack > 1) {
1341  ATH_MSG_VERBOSE("More than one e loss per track... ");
1342  problem = true;
1343  }
1344  if (m_fillExtraELossInfo) acc_numEnergyLossPerTrack(muon) = numEnergyLossPerTrack;
1345  if (problem) ATH_MSG_VERBOSE("Dumping problematic muon: " << m_muonPrinter->print(muon));
1346  }

◆ 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 951 of file MuonCreatorTool.cxx.

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

◆ selectStaus()

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

Definition at line 923 of file MuonCreatorTool.cxx.

924  {
925  resolvedInDetCandidates.clear();
926  for (const InDetCandidateToTagMap* tag_map : tagMaps) {
927  if (!tag_map) continue;
928  for (const auto& combined_tag : *tag_map) {
929  const TagBase* tag = combined_tag.second.get();
930  const MuGirlLowBetaTag* muGirlLowBetaTag = dynamic_cast<const MuGirlLowBetaTag*>(tag);
931  if (muGirlLowBetaTag) { resolvedInDetCandidates.emplace_back(combined_tag.first, std::vector<const TagBase*>{tag}); }
932  }
933  break;
934  }
935  // print-out
936  if (msgLvl(MSG::DEBUG)) {
937  ATH_MSG_DEBUG("ID candidates: " << tagMaps.size() << " after stau selection " << resolvedInDetCandidates.size());
938  for (const InDetCandidateTags& candidate : resolvedInDetCandidates) {
939  msg(MSG::DEBUG) << "ID candidate staus: " << candidate.first->toString() << endmsg;
940  }
941  }
942 
943  // tag_map above is keyed on a pointer.
944  // So we need to sort in order to get reproducible results.
945  std::stable_sort(resolvedInDetCandidates.begin(), resolvedInDetCandidates.end(),
946  [](const InDetCandidateTags& a, const InDetCandidateTags& b) {
947  return a.first->indetTrackParticle().pt() > b.first->indetTrackParticle().pt();
948  });
949  }

◆ 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 1412 of file MuonCreatorTool.cxx.

1412 { 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_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 215 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 213 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 200 of file MuonCreatorTool.h.

◆ m_copyFloatSummaryAccessors

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

Definition at line 212 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 197 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 189 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 177 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 180 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 183 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 210 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 193 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 207 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 187 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 195 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 188 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 184 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:762
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
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:76
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:195
MuGirlNS::StauExtras::caloBetaDof
int caloBetaDof
Definition: CandidateSummary.h:87
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:666
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:210
xAOD::MuGirl
@ MuGirl
MuGirl.
Definition: TrackingPrimitives.h:141
MuGirlNS::StauExtras::mdtBetaAvg
double mdtBetaAvg
Definition: CandidateSummary.h:80
MuGirlNS::StauExtras::betaAll
double betaAll
Definition: CandidateSummary.h:71
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:74
MuGirlNS::StauExtras::mdtBetaDof
unsigned int mdtBetaDof
Definition: CandidateSummary.h:83
MuonCombined::MuonCreatorTool::fillEnergyLossFromTrack
void fillEnergyLossFromTrack(xAOD::Muon &muon, const std::vector< const Trk::TrackStateOnSurface * > *tsosVector) const
Definition: MuonCreatorTool.cxx:1301
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:70
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:396
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:81
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:1348
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:78
MuonCombined::MuonCreatorTool::m_useCaloCells
Gaudi::Property< bool > m_useCaloCells
Definition: MuonCreatorTool.h:188
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:923
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:212
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:201
MuonParameters::momentumBalanceSignificance
@ momentumBalanceSignificance
Definition: MuonParamDefs.h:136
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
MuGirlNS::StauExtras::caloBetaAvg
double caloBetaAvg
Definition: CandidateSummary.h:84
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:70
MuonCombined::MuonCreatorTool::m_printSummary
Gaudi::Property< bool > m_printSummary
Definition: MuonCreatorTool.h:183
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:59
MuonCombined::MuonCreatorTool::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: MuonCreatorTool.h:215
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:228
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonCombined::MuonCandidate
Definition: Reconstruction/MuonIdentification/MuonCombinedEvent/MuonCombinedEvent/MuonCandidate.h:25
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
MuonCombined::MuonCreatorTool::m_scatteringAngleTool
ToolHandle< Rec::IMuonScatteringAngleSignificance > m_scatteringAngleTool
Definition: MuonCreatorTool.h:158
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
MuGirlNS::StauExtras::hits
StauHits hits
Definition: CandidateSummary.h:88
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:79
MuGirlNS::StauExtras::mdtBetaChi2
double mdtBetaChi2
Definition: CandidateSummary.h:82
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:779
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonCombined::MuonCreatorTool::dressMuon
bool dressMuon(xAOD::Muon &muon) const
Definition: MuonCreatorTool.cxx:1183
MuGirlNS::StauExtras::numRpcHitsInSeg
unsigned int numRpcHitsInSeg
Definition: CandidateSummary.h:73
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:177
test_pyathena.parent
parent
Definition: test_pyathena.py:15
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
xAOD::CaloCluster_v1::size
size_t size() const
size method (forwarded from CaloClusterCellLink obj)
Definition: CaloCluster_v1.cxx:996
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:135
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:72
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
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
MuGirlNS::StauExtras::caloBetaRms
double caloBetaRms
Definition: CandidateSummary.h:85
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:213
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:189
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:1412
MuonCombined::MuonCreatorTool::m_requireMSOEforSA
Gaudi::Property< bool > m_requireMSOEforSA
Definition: MuonCreatorTool.h:207
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:1147
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:221
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:538
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)
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:611
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:193
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:702
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:198
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonCombined::MuonCreatorTool::m_fillExtraELossInfo
Gaudi::Property< bool > m_fillExtraELossInfo
Definition: MuonCreatorTool.h:180
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:623
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:77
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::STACO
@ STACO
Tracks produced by STACO.
Definition: TrackingPrimitives.h:99
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
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:76
MuonCombined::MuonCreatorTool::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: MuonCreatorTool.h:169
MuGirlNS::StauExtras
Definition: CandidateSummary.h:69
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:195
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
readCCLHist.float
float
Definition: readCCLHist.py:83
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:736
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:86
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:1255
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:951
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 Nov 7 2024 22:21:43 for ATLAS Offline Software by   doxygen 1.8.18