#include <BPhysConversionFinder.h>

Inheritance diagram for DerivationFramework::BPhysConversionFinder:

Collaboration diagram for DerivationFramework::BPhysConversionFinder:

Public Member Functions
	BPhysConversionFinder (const std::string &t, const std::string &n, const IInterface *p)

StatusCode	initialize () override

StatusCode	finalize () override

virtual StatusCode	addBranches () const override
	Pass the thinning service 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 ()
	AlgTool interface methods. More...

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
StatusCode	doCascadeFit (const xAOD::Vertex diMuonVertex, const xAOD::Vertex convVertex, const double diMuonMassConstraint, TLorentzVector &fitMom, float &chiSq) 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
std::string	m_diMuonCollectionToCheck

std::vector< std::string >	m_passFlagsToCheck

ToolHandle< Trk::V0Tools >	m_v0Tools

ToolHandle< Trk::IVertexFitter >	m_vertexFitter

ToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator

ToolHandle< Trk::ITrkDistanceFinder >	m_distanceTool

ToolHandle< InDet::ConversionPostSelector >	m_postSelector

ToolHandle< Trk::TrkVKalVrtFitter >	m_cascadeFitter

std::string	m_inputTrackParticleContainerName

std::string	m_conversionContainerName

float	m_maxDistBetweenTracks

float	m_maxDeltaCotTheta

bool	m_requireDeltaM

float	m_maxDeltaM

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 33 of file BPhysConversionFinder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ BPhysConversionFinder()

DerivationFramework::BPhysConversionFinder::BPhysConversionFinder	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 22 of file BPhysConversionFinder.cxx.

                            :
     AthAlgTool(t,n,p),
     m_v0Tools("Trk::V0Tools"),
     m_vertexFitter("Trk::TrkVKalVrtFitter"),
     m_vertexEstimator("InDet::VertexPointEstimator"),
     m_distanceTool("Trk::SeedNewtonTrkDistanceFinder/InDetConversionTrkDistanceFinder"),
     m_postSelector("InDet::ConversionPostSelector"),
     m_cascadeFitter("Trk::TrkVKalVrtFitter"),
     m_inputTrackParticleContainerName("InDetTrackParticles"),
     m_conversionContainerName("BPhysConversionCandidates"),
     m_maxDistBetweenTracks(10.0),
     m_maxDeltaCotTheta(0.3),
     m_requireDeltaM(true),
     m_maxDeltaM(3000.0)
   {
     declareInterface<DerivationFramework::IAugmentationTool>(this);
  
     // Declare user-defined properties
     declareProperty("DiMuonVertexContainer", m_diMuonCollectionToCheck);
     declareProperty("PassFlagsToCheck", m_passFlagsToCheck);
     declareProperty("V0Tools", m_v0Tools);
     declareProperty("VertexFitterTool", m_vertexFitter);
     declareProperty("VertexEstimator", m_vertexEstimator);
     declareProperty("DistanceTool", m_distanceTool);
     declareProperty("ConversionPostSelector", m_postSelector);
     declareProperty("CascadeFitter", m_cascadeFitter);
     declareProperty("InputTrackParticleContainerName", m_inputTrackParticleContainerName);
     declareProperty("ConversionContainerName", m_conversionContainerName);
     declareProperty("MaxDistBetweenTracks", m_maxDistBetweenTracks = 10.0); // Maximum allowed distance of minimum approach
     declareProperty("MaxDeltaCotTheta", m_maxDeltaCotTheta = 0.3); // Maximum allowed dCotTheta between tracks
     declareProperty("RequireDeltaM", m_requireDeltaM = true); // Only save a conversions if it's a chi_c,b candidate (must then pass "MaxDeltaM" requirement), if "False" all conversions in the event will be saved
     declareProperty("MaxDeltaM", m_maxDeltaM = 3000.0); // Maximum mass difference between di-muon+conversion and di-muon
  
   }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::BPhysConversionFinder::addBranches ( ) const

overridevirtual

Pass the thinning service

Implements DerivationFramework::IAugmentationTool.

Definition at line 87 of file BPhysConversionFinder.cxx.

   {
  
     int nTrackPairs_Init = 0;
     int nTrackPairs_Selected = 0;
     int nConv_VertexFit = 0;
     int nConv_Selected = 0;
     int nConv_Selected_DeltaM = 0;
  
     std::vector<const xAOD::Vertex*> oniaVertices;
     oniaVertices.clear();
  
     //------------------------------------
     // Look for di-muons
     //------------------------------------
     const xAOD::VertexContainer* diMuonContainer = NULL;
     ATH_CHECK( evtStore()->retrieve(diMuonContainer, m_diMuonCollectionToCheck) );
  
     if(diMuonContainer->size() == 0) {
  
         ATH_MSG_DEBUG("Vertex Container (" << m_diMuonCollectionToCheck << ") is empty");
  
     } else {
  
         ATH_MSG_DEBUG("Vertex Container (" << m_diMuonCollectionToCheck << ") contains " << diMuonContainer->size() << " vertices");
  
         for(xAOD::VertexContainer::const_iterator vtxItr = diMuonContainer->begin(); vtxItr != diMuonContainer->end(); ++vtxItr) {
  
             const xAOD::Vertex* vertex = (*vtxItr);
  
             bool passedHypothesis = false;
  
             for(const auto &flag : m_passFlagsToCheck) {
                 SG::ConstAccessor<Char_t> acc(flag);
                 bool pass = acc(*vertex);
                 if(pass) passedHypothesis = true;
             }
  
             if(passedHypothesis) {
                 oniaVertices.push_back(vertex);
             }
  
         }
      }
     //------------------------------------
  
     // Output conversion container
     std::unique_ptr<xAOD::VertexContainer> conversionContainer( new xAOD::VertexContainer() );
     std::unique_ptr<xAOD::VertexAuxContainer> conversionAuxContainer( new xAOD::VertexAuxContainer() );
     conversionContainer->setStore(conversionAuxContainer.get());
  
     // Only call conversion finder if we've found a di-muon candidate or
     // we really want to look for conversions independently
     const bool callConvFinder = !m_requireDeltaM || oniaVertices.size() > 0;
  
     if(callConvFinder) {
  
       // Retrieve track particles from StoreGate
       const xAOD::TrackParticleContainer* inputTrackParticles = NULL;
       ATH_CHECK( evtStore()->retrieve(inputTrackParticles,m_inputTrackParticleContainerName) );
  
       ATH_MSG_DEBUG("Track particle container size " <<  inputTrackParticles->size());
  
       // Track Selection
       std::vector<const xAOD::TrackParticle*> posTracks; posTracks.clear();
       std::vector<const xAOD::TrackParticle*> negTracks; negTracks.clear();
  
       // Track Loop
       for(xAOD::TrackParticleContainer::const_iterator trkItr = inputTrackParticles->begin(); trkItr != inputTrackParticles->end(); ++trkItr) {
  
           const xAOD::TrackParticle* track = (*trkItr);
  
           uint8_t nSCT(0);
           uint8_t nPIX(0);
  
           track->summaryValue(nPIX,xAOD::numberOfPixelHits);
           track->summaryValue(nSCT,xAOD::numberOfSCTHits);
  
           // Don't want TRT-only tracks
           // Require Si hits on all tracks
           if( nSCT + nPIX < 1 ) continue;
  
           if( track->charge() > 0.0) {
               posTracks.push_back(track);
           } else {
               negTracks.push_back(track);
           }
  
       } // Track Loop
  
       ATH_MSG_DEBUG(posTracks.size() + negTracks.size() << " tracks pass pre-selection");
  
       std::vector<const xAOD::TrackParticle*>::const_iterator tpIt1;
       std::vector<const xAOD::TrackParticle*>::const_iterator tpIt2;
  
       // Pos Track Loop
       for(tpIt1 = posTracks.begin(); tpIt1 != posTracks.end(); ++tpIt1) {
  
           const xAOD::TrackParticle* trackParticle1 = (*tpIt1);
  
           const Trk::Perigee& trackPerigee1 = trackParticle1->perigeeParameters();
  
           // Neg Track Loop
           for(tpIt2 = negTracks.begin(); tpIt2 != negTracks.end(); ++tpIt2) {
  
               if (*tpIt1 == *tpIt2) continue;
  
               const xAOD::TrackParticle* trackParticle2 = (*tpIt2);
  
               const Trk::Perigee& trackPerigee2 = trackParticle2->perigeeParameters();
  
               nTrackPairs_Init++;
  
               //------------------------------------
               // Track pair selection
               //------------------------------------
               const double deltaCotTheta = fabs(1./tan(trackPerigee1.parameters()[Trk::theta]) - 1./tan(trackPerigee2.parameters()[Trk::theta]));
               if(deltaCotTheta > m_maxDeltaCotTheta) continue;
  
               double distance = 1000000.;
               std::optional<std::pair<Amg::Vector3D,Amg::Vector3D>> result = m_distanceTool->CalculateMinimumDistance(trackParticle1->perigeeParameters(),trackParticle2->perigeeParameters() );
               bool gotDistance = result.has_value();
               if(gotDistance) distance = Amg::distance (result->first, result->second);
               if(!gotDistance || (distance > m_maxDistBetweenTracks)) continue;
               //------------------------------------
  
               //------------------------------------
               // Estimate starting point + cuts on compatiblity of tracks
               //------------------------------------
               int sflag = 0;
               int errorcode = 0;
               std::map<std::string, float> vertexOutput;
               Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&trackPerigee1,&trackPerigee2,sflag,errorcode, vertexOutput);
               if(errorcode != 0) continue;
               //------------------------------------
  
               nTrackPairs_Selected++;
  
               std::vector<const xAOD::TrackParticle*> trackPair;
               trackPair.clear();
               trackPair.push_back(trackParticle1);
               trackPair.push_back(trackParticle2);
  
               // Do the vertex fit
               std::unique_ptr<xAOD::Vertex> convVertexCandidate( m_vertexFitter->fit(trackPair, startingPoint) );
  
               // Check for successful fit
               if(convVertexCandidate != NULL) {
  
                   ATH_MSG_DEBUG("Vertex Fit Succeeded");
  
                   convVertexCandidate->clearTracks();
                   ElementLink<xAOD::TrackParticleContainer> newLink1;
                   newLink1.setElement(*tpIt1);
                   newLink1.setStorableObject(*inputTrackParticles);
                   ElementLink<xAOD::TrackParticleContainer> newLink2;
                   newLink2.setElement(*tpIt2);
                   newLink2.setStorableObject(*inputTrackParticles);
                   convVertexCandidate->addTrackAtVertex(newLink1);
                   convVertexCandidate->addTrackAtVertex(newLink2);
  
                   nConv_VertexFit++;
  
                   //------------------------------------
                   // Post-vertexing cuts
                   //------------------------------------
  
                   // This is empty and only present for compatiblity.
                   // The cut this informtion pertains to is not used for Si-Si conversions so this is OK
                   std::vector<Amg::Vector3D> positionList;
  
                   // Apply Si-Si converion post-selection
                   if( !m_postSelector->selectConversionCandidate(convVertexCandidate.get(),0,positionList) ) {
                       convVertexCandidate.reset();
                       continue;
                   }
                   //------------------------------------
  
                   nConv_Selected++;
  
                   // Get photon momentum 3-vector
                   const xAOD::Vertex * constConvVertex = convVertexCandidate.get();
                   Amg::Vector3D momentum = m_v0Tools->V0Momentum(constConvVertex);
  
                   TLorentzVector photon;
                   photon.SetXYZM(momentum.x(),momentum.y(),momentum.z(),0.0);
  
                   //------------------------------------
                   // Check if conversion is consistent with a chi_c,b candidate
                   // by requiring a small mass difference w.r.t. any di-muon in event
                   //------------------------------------
                   bool passDeltaM = false;
  
                   // Use to keep track of which dimuon(s) gave a chi_c/b candidate
                   std::vector<const xAOD::Vertex*> candidateOniaVertices;
                   candidateOniaVertices.clear();
  
                   for ( std::vector<const xAOD::Vertex*>::const_iterator vtxItr = oniaVertices.begin(); vtxItr != oniaVertices.end(); ++vtxItr ) {
  
                       const xAOD::Vertex* oniaVertex = (*vtxItr);
  
                       static const SG::ConstAccessor<std::vector<float> > RefTrackPxAcc("RefTrackPx");
                       static const SG::ConstAccessor<std::vector<float> > RefTrackPyAcc("RefTrackPy");
                       static const SG::ConstAccessor<std::vector<float> > RefTrackPzAcc("RefTrackPz");
                       std::vector<float> diMuon_Px = RefTrackPxAcc(*oniaVertex);
                       std::vector<float> diMuon_Py = RefTrackPyAcc(*oniaVertex);
                       std::vector<float> diMuon_Pz = RefTrackPzAcc(*oniaVertex);
  
                       TLorentzVector muon1, muon2;
                       muon1.SetXYZM(diMuon_Px.at(0),diMuon_Py.at(0),diMuon_Pz.at(0),105.658);
                       muon2.SetXYZM(diMuon_Px.at(1),diMuon_Py.at(1),diMuon_Pz.at(1),105.658);
  
                       TLorentzVector diMuon = muon1 + muon2;
  
                       const double deltaM = (diMuon+photon).M() - diMuon.M();
  
                       ATH_MSG_DEBUG("Candidate DeltaM = " << deltaM << " MeV DiMuon " << oniaVertex->index() << " ( Mass = " << diMuon.M() << " MeV )");
  
                       // Did we find a one di-muon + photon candidate with a mass diff. consistent with chi_c/b?
                       if(deltaM < m_maxDeltaM) {
                           passDeltaM = true;
                           candidateOniaVertices.push_back(oniaVertex);
                       }
  
                   }
  
                   // Only keep the conversion candidate if it's consistent with a chi_c,b decay
                   if(m_requireDeltaM && !passDeltaM) {
                       convVertexCandidate.reset();
                       continue;
                   }
                   //------------------------------------
  
                   //------------------------------------
                   // Final conversion candidates
                   //------------------------------------
                   nConv_Selected_DeltaM++;
  
                   // Keep track of which dimuon(s) gave a chi_c/b candidate
                   std::vector< ElementLink<xAOD::VertexContainer> > diMuonLinks;
                   diMuonLinks.clear();
  
                   // Output of cascade fits with various di-muon mass hypotheses
                   std::vector<float> fit_Psi1S_Px, fit_Psi1S_Py, fit_Psi1S_Pz, fit_Psi1S_M, fit_Psi1S_ChiSq;
                   std::vector<float> fit_Psi2S_Px, fit_Psi2S_Py, fit_Psi2S_Pz, fit_Psi2S_M, fit_Psi2S_ChiSq;
                   std::vector<float> fit_Upsi1S_Px, fit_Upsi1S_Py, fit_Upsi1S_Pz, fit_Upsi1S_M, fit_Upsi1S_ChiSq;
                   std::vector<float> fit_Upsi2S_Px, fit_Upsi2S_Py, fit_Upsi2S_Pz, fit_Upsi2S_M, fit_Upsi2S_ChiSq;
                   std::vector<float> fit_Upsi3S_Px, fit_Upsi3S_Py, fit_Upsi3S_Pz, fit_Upsi3S_M, fit_Upsi3S_ChiSq;
  
                   // Loop over di-muon vertices associated with a candidate
                   for(std::vector<const xAOD::Vertex*>::const_iterator vtxItr = candidateOniaVertices.begin(); vtxItr != candidateOniaVertices.end(); ++vtxItr ) {
  
                       //------------------------------------
                       // Add an element link to each dimuon which formed a
                       // candidate, leading to the decision to save this conversion
                       //------------------------------------
                       ElementLink<xAOD::VertexContainer> myLink;
                       myLink.setElement(*vtxItr);
                       myLink.setStorableObject(*diMuonContainer);
  
                        if(!myLink.isValid()) {
                            ATH_MSG_WARNING("Invalid DiMuon ElementLink!");
                        }
  
                       diMuonLinks.push_back(myLink);
                       //------------------------------------
  
                       // Check which mass window this di-muon passed
                       static const SG::ConstAccessor<Char_t> passed_PsiAcc("passed_Psi");
                       static const SG::ConstAccessor<Char_t> passed_UpsiAcc("passed_Upsi");
                       bool passed_Psi = passed_PsiAcc(**vtxItr);
                       bool passed_Upsi = passed_UpsiAcc(**vtxItr);
  
                       //------------------------------------
                       // Cascade fit with J/psi mass hypothesis
                       //------------------------------------
                       float fitChiSq_Psi1S = 99999;
                       TLorentzVector fitResult_Psi1S;
  
                       // Only bother with the fit if di-muon mass is within the relveant range,
                       // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
                       if(passed_Psi) {
                           ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,3096.916,fitResult_Psi1S,fitChiSq_Psi1S) );
                       }
  
                       fit_Psi1S_Px.push_back(fitResult_Psi1S.Px());
                       fit_Psi1S_Py.push_back(fitResult_Psi1S.Py());
                       fit_Psi1S_Pz.push_back(fitResult_Psi1S.Pz());
                       fit_Psi1S_M.push_back(fitResult_Psi1S.M());
                       fit_Psi1S_ChiSq.push_back(fitChiSq_Psi1S);
  
                       //------------------------------------
                       // Cascade fit with psi(2S) mass hypothesis
                       //------------------------------------
                       float fitChiSq_Psi2S = 99999;
                       TLorentzVector fitResult_Psi2S;
  
                       // Only bother with the fit if di-muon mass is within the relveant range,
                       // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
                       if(passed_Psi) {
                           ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,3686.097,fitResult_Psi2S,fitChiSq_Psi2S) );
                       }
  
                       fit_Psi2S_Px.push_back(fitResult_Psi2S.Px());
                       fit_Psi2S_Py.push_back(fitResult_Psi2S.Py());
                       fit_Psi2S_Pz.push_back(fitResult_Psi2S.Pz());
                       fit_Psi2S_M.push_back(fitResult_Psi2S.M());
                       fit_Psi2S_ChiSq.push_back(fitChiSq_Psi2S);
  
                       //------------------------------------
                       // Cascade fit with Upsi(1S) mass hypothesis
                       //------------------------------------
                       float fitChiSq_Upsi1S = 99999;
                       TLorentzVector fitResult_Upsi1S;
  
                       // Only bother with the fit if di-muon mass is within the relveant range,
                       // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
                       if(passed_Upsi) {
                           ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,9460.30,fitResult_Upsi1S,fitChiSq_Upsi1S) );
                       }
  
                       fit_Upsi1S_Px.push_back(fitResult_Upsi1S.Px());
                       fit_Upsi1S_Py.push_back(fitResult_Upsi1S.Py());
                       fit_Upsi1S_Pz.push_back(fitResult_Upsi1S.Pz());
                       fit_Upsi1S_M.push_back(fitResult_Upsi1S.M());
                       fit_Upsi1S_ChiSq.push_back(fitChiSq_Upsi1S);
  
                       //------------------------------------
                       // Cascade fit with Upsi(2S) mass hypothesis
                       //------------------------------------
                       float fitChiSq_Upsi2S = 99999;
                       TLorentzVector fitResult_Upsi2S;
  
                       // Only bother with the fit if di-muon mass is within the relveant range,
                       // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
                       if(passed_Upsi) {
                           ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,10023.26,fitResult_Upsi2S,fitChiSq_Upsi2S) );
                       }
  
                       fit_Upsi2S_Px.push_back(fitResult_Upsi2S.Px());
                       fit_Upsi2S_Py.push_back(fitResult_Upsi2S.Py());
                       fit_Upsi2S_Pz.push_back(fitResult_Upsi2S.Pz());
                       fit_Upsi2S_M.push_back(fitResult_Upsi2S.M());
                       fit_Upsi2S_ChiSq.push_back(fitChiSq_Upsi2S);
  
                       //------------------------------------
                       // Cascade fit with Upsi(3S) mass hypothesis
                       //------------------------------------
                       float fitChiSq_Upsi3S = 99999;
                       TLorentzVector fitResult_Upsi3S;
  
                       // Only bother with the fit if di-muon mass is within the relveant range,
                       // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
                       if(passed_Upsi) {
                           ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,10355.2,fitResult_Upsi3S,fitChiSq_Upsi3S) );
                       }
  
                       fit_Upsi3S_Px.push_back(fitResult_Upsi3S.Px());
                       fit_Upsi3S_Py.push_back(fitResult_Upsi3S.Py());
                       fit_Upsi3S_Pz.push_back(fitResult_Upsi3S.Pz());
                       fit_Upsi3S_M.push_back(fitResult_Upsi3S.M());
                       fit_Upsi3S_ChiSq.push_back(fitChiSq_Upsi3S);
  
                   }
  
                   //------------------------------------
                   // Decorate selected conversions
                   //------------------------------------
                   ATH_MSG_DEBUG("Decorating conversion vertices");
  
                   static const SG::Accessor< std::vector< ElementLink<xAOD::VertexContainer> > > DiMuonLinksAcc("DiMuonLinks");
                   DiMuonLinksAcc(*convVertexCandidate) = diMuonLinks;
  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi1S_PxAcc("CascadeFit_Psi1S_Px");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi1S_PyAcc("CascadeFit_Psi1S_Py");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi1S_PzAcc("CascadeFit_Psi1S_Pz");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi1S_MAcc("CascadeFit_Psi1S_M");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi1S_ChiSqAcc("CascadeFit_Psi1S_ChiSq");
                   CascadeFit_Psi1S_PxAcc(*convVertexCandidate) = fit_Psi1S_Px;
                   CascadeFit_Psi1S_PyAcc(*convVertexCandidate) = fit_Psi1S_Py;
                   CascadeFit_Psi1S_PzAcc(*convVertexCandidate) = fit_Psi1S_Pz;
                   CascadeFit_Psi1S_MAcc(*convVertexCandidate) = fit_Psi1S_M;
                   CascadeFit_Psi1S_ChiSqAcc(*convVertexCandidate) = fit_Psi1S_ChiSq;
  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi2S_PxAcc("CascadeFit_Psi2S_Px");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi2S_PyAcc("CascadeFit_Psi2S_Py");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi2S_PzAcc("CascadeFit_Psi2S_Pz");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi2S_MAcc("CascadeFit_Psi2S_M");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Psi2S_ChiSqAcc("CascadeFit_Psi2S_ChiSq");
                   CascadeFit_Psi2S_PxAcc(*convVertexCandidate) = fit_Psi2S_Px;
                   CascadeFit_Psi2S_PyAcc(*convVertexCandidate) = fit_Psi2S_Py;
                   CascadeFit_Psi2S_PzAcc(*convVertexCandidate) = fit_Psi2S_Pz;
                   CascadeFit_Psi2S_MAcc(*convVertexCandidate) = fit_Psi2S_M;
                   CascadeFit_Psi2S_ChiSqAcc(*convVertexCandidate) = fit_Psi2S_ChiSq;
  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi1S_PxAcc("CascadeFit_Upsi1S_Px");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi1S_PyAcc("CascadeFit_Upsi1S_Py");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi1S_PzAcc("CascadeFit_Upsi1S_Pz");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi1S_MAcc("CascadeFit_Upsi1S_M");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi1S_ChiSqAcc("CascadeFit_Upsi1S_ChiSq");
                   CascadeFit_Upsi1S_PxAcc(*convVertexCandidate) = fit_Upsi1S_Px;
                   CascadeFit_Upsi1S_PyAcc(*convVertexCandidate) = fit_Upsi1S_Py;
                   CascadeFit_Upsi1S_PzAcc(*convVertexCandidate) = fit_Upsi1S_Pz;
                   CascadeFit_Upsi1S_MAcc(*convVertexCandidate) = fit_Upsi1S_M;
                   CascadeFit_Upsi1S_ChiSqAcc(*convVertexCandidate) = fit_Upsi1S_ChiSq;
  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi2S_PxAcc("CascadeFit_Upsi2S_Px");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi2S_PyAcc("CascadeFit_Upsi2S_Py");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi2S_PzAcc("CascadeFit_Upsi2S_Pz");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi2S_MAcc("CascadeFit_Upsi2S_M");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi2S_ChiSqAcc("CascadeFit_Upsi2S_ChiSq");
                   CascadeFit_Upsi2S_PxAcc(*convVertexCandidate) = fit_Upsi2S_Px;
                   CascadeFit_Upsi2S_PyAcc(*convVertexCandidate) = fit_Upsi2S_Py;
                   CascadeFit_Upsi2S_PzAcc(*convVertexCandidate) = fit_Upsi2S_Pz;
                   CascadeFit_Upsi2S_MAcc(*convVertexCandidate) = fit_Upsi2S_M;
                   CascadeFit_Upsi2S_ChiSqAcc(*convVertexCandidate) = fit_Upsi2S_ChiSq;
  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi3S_PxAcc("CascadeFit_Upsi3S_Px");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi3S_PyAcc("CascadeFit_Upsi3S_Py");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi3S_PzAcc("CascadeFit_Upsi3S_Pz");
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi3S_MAcc("CascadeFit_Upsi3S_M");  
                   static const SG::Accessor< std::vector<float> > CascadeFit_Upsi3S_ChiSqAcc("CascadeFit_Upsi3S_ChiSq");
                   CascadeFit_Upsi3S_PxAcc(*convVertexCandidate) = fit_Upsi3S_Px;
                   CascadeFit_Upsi3S_PyAcc(*convVertexCandidate) = fit_Upsi3S_Py;
                   CascadeFit_Upsi3S_PzAcc(*convVertexCandidate) = fit_Upsi3S_Pz;
                   CascadeFit_Upsi3S_MAcc(*convVertexCandidate) = fit_Upsi3S_M;
                   CascadeFit_Upsi3S_ChiSqAcc(*convVertexCandidate) = fit_Upsi3S_ChiSq;
  
                   static const SG::Accessor<float> pxAcc("px");
                   static const SG::Accessor<float> pyAcc("py");
                   static const SG::Accessor<float> pzAcc("pz");
                   pxAcc(*convVertexCandidate) = momentum.x();
                   pyAcc(*convVertexCandidate) = momentum.y();
                   pzAcc(*convVertexCandidate) = momentum.z();
  
                   static const SG::Accessor<float> deltaCotThetaTrkAcc("deltaCotThetaTrk");
                   static const SG::Accessor<float> minimumDistanceTrkAcc("minimumDistanceTrk");
                   deltaCotThetaTrkAcc(*convVertexCandidate) = deltaCotTheta;
                   minimumDistanceTrkAcc(*convVertexCandidate) = distance;
  
                   static const SG::Accessor<float> deltaPhiTracksAcc("deltaPhiTracks");
                   static const SG::Accessor<float> DR1R2Acc("DR1R2");
                   deltaPhiTracksAcc(*convVertexCandidate) = vertexOutput["deltaPhiTracks"];
                   DR1R2Acc(*convVertexCandidate) = vertexOutput["DR1R2"];
  
                   static const SG::Accessor<Char_t> passedAcc("passed");
                   passedAcc(*convVertexCandidate) = true; // Used in event skimming
  
                   conversionContainer->push_back(convVertexCandidate.release());
  
               } else {
                   ATH_MSG_DEBUG("Vertex Fit Failed");
               }
  
           } // Neg Track Loop
  
       } // Pos Track Loop
  
     } // callConvFinder
  
     // Write the results to StoreGate
     CHECK(evtStore()->record(conversionContainer.release(), m_conversionContainerName));
     CHECK(evtStore()->record(conversionAuxContainer.release(), m_conversionContainerName+"Aux."));
  
     ATH_MSG_DEBUG("-------------------------");
     ATH_MSG_DEBUG("Number of track pairs: " << nTrackPairs_Init);
     ATH_MSG_DEBUG("Number of track pairs selected: " << nTrackPairs_Selected);
     ATH_MSG_DEBUG("Number of successful vertex fits: " << nConv_VertexFit);
     ATH_MSG_DEBUG("Number of selected vertices: " << nConv_Selected);
     ATH_MSG_DEBUG("Number of selected vertices (after DeltaM req.): " << nConv_Selected_DeltaM);
  
     return StatusCode::SUCCESS;
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

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

   {
     return PBASE::declareProperty(t);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

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

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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

◆ doCascadeFit()

StatusCode DerivationFramework::BPhysConversionFinder::doCascadeFit	(	const xAOD::Vertex *	diMuonVertex,
		const xAOD::Vertex *	convVertex,
		const double	diMuonMassConstraint,
		TLorentzVector &	fitMom,
		float &	chiSq
	)		const

private

Definition at line 561 of file BPhysConversionFinder.cxx.

                                                                                                                                                                                                 {
  
       std::vector<const xAOD::TrackParticle*> diMuonTracks;
       diMuonTracks.push_back(diMuonVertex->trackParticle(0));
       diMuonTracks.push_back(diMuonVertex->trackParticle(1));
  
       std::vector<double> diMuonTrackMasses;
       diMuonTrackMasses.push_back(105.658);
       diMuonTrackMasses.push_back(105.658);
  
       std::vector<const xAOD::TrackParticle*> convTracks;
       convTracks.push_back(convVertex->trackParticle(0));
       convTracks.push_back(convVertex->trackParticle(1));
  
       std::vector<double> convTrackMasses;
       convTrackMasses.push_back(0.511);
       convTrackMasses.push_back(0.511);
  
       // Reset
       std::unique_ptr<Trk::IVKalState> state = m_cascadeFitter->makeState();
  
       // Set Robustness
       m_cascadeFitter->setRobustness(0, *state);
  
       // Build up the topology
       
       // Vertex list
       std::vector<Trk::VertexID> vrtList;
       // V0 vertex
       Trk::VertexID vID;
       vID = m_cascadeFitter->startVertex(convTracks,convTrackMasses,*state,0.0); // Constrain converision mass to zero
  
       vrtList.push_back(vID);
  
       // chi_c/b vertex
       Trk::VertexID vID2 = m_cascadeFitter->nextVertex(diMuonTracks,diMuonTrackMasses,vrtList,*state);
  
       std::vector<Trk::VertexID> cnstV;
       cnstV.clear();
       if ( !m_cascadeFitter->addMassConstraint(vID2,diMuonTracks,cnstV,*state,diMuonMassConstraint).isSuccess() ) {
         ATH_MSG_WARNING("addMassConstraint failed");
       }
  
       // Do the fit
       std::unique_ptr<Trk::VxCascadeInfo> result(m_cascadeFitter->fitCascade(*state));
  
       const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
  
       {
  
           if(moms.size() > 2) ATH_MSG_WARNING("DoCascadeFit - More than two output momentum!?");
  
           TLorentzVector conv_Fit = moms.at(0).at(0) + moms.at(0).at(1);
           TLorentzVector diMuon_Fit = moms.at(1).at(0) + moms.at(1).at(1);
  
           // Momentum of DiMuon + photon system
           fitMom = diMuon_Fit + conv_Fit;
  
           chiSq = result->fitChi2()/result->nDoF();
  
           // Done with the fit result
           result.reset();
  
       }
  
       return StatusCode::SUCCESS;
  
   }

◆ 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

◆ finalize()

StatusCode DerivationFramework::BPhysConversionFinder::finalize ( )

override

Definition at line 79 of file BPhysConversionFinder.cxx.

   {
     // everything all right
     return StatusCode::SUCCESS;
   }

◆ initialize()

StatusCode DerivationFramework::BPhysConversionFinder::initialize ( )

override

Definition at line 61 of file BPhysConversionFinder.cxx.

   {
  
     ATH_MSG_DEBUG("in initialize()");
  
     ATH_CHECK( m_v0Tools.retrieve() );
     ATH_CHECK( m_vertexFitter.retrieve() );
     ATH_CHECK( m_vertexEstimator.retrieve() );
     ATH_CHECK( m_distanceTool.retrieve() );
     ATH_CHECK( m_postSelector.retrieve() );
     ATH_CHECK( m_cascadeFitter.retrieve() );
  
     return StatusCode::SUCCESS;
  
   }

◆ 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& DerivationFramework::IAugmentationTool::interfaceID ( )

inlinestaticinherited

AlgTool interface methods.

Definition at line 31 of file IAugmentationTool.h.

31 { return IID_IAugmentationTool; }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

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

   {
     h.renounce();
     PBASE::renounce (h);
   }

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

                                                           {
     handlesArray.renounce();
   }

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

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ m_cascadeFitter

ToolHandle<Trk::TrkVKalVrtFitter > DerivationFramework::BPhysConversionFinder::m_cascadeFitter

private

Definition at line 56 of file BPhysConversionFinder.h.

◆ m_conversionContainerName

std::string DerivationFramework::BPhysConversionFinder::m_conversionContainerName

private

Definition at line 59 of file BPhysConversionFinder.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_diMuonCollectionToCheck

std::string DerivationFramework::BPhysConversionFinder::m_diMuonCollectionToCheck

private

Definition at line 48 of file BPhysConversionFinder.h.

◆ m_distanceTool

ToolHandle<Trk::ITrkDistanceFinder> DerivationFramework::BPhysConversionFinder::m_distanceTool

private

Definition at line 54 of file BPhysConversionFinder.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_inputTrackParticleContainerName

std::string DerivationFramework::BPhysConversionFinder::m_inputTrackParticleContainerName

private

Definition at line 58 of file BPhysConversionFinder.h.

◆ m_maxDeltaCotTheta

float DerivationFramework::BPhysConversionFinder::m_maxDeltaCotTheta

private

Definition at line 62 of file BPhysConversionFinder.h.

◆ m_maxDeltaM

float DerivationFramework::BPhysConversionFinder::m_maxDeltaM

private

Definition at line 65 of file BPhysConversionFinder.h.

◆ m_maxDistBetweenTracks

float DerivationFramework::BPhysConversionFinder::m_maxDistBetweenTracks

private

Definition at line 61 of file BPhysConversionFinder.h.

◆ m_passFlagsToCheck

std::vector<std::string> DerivationFramework::BPhysConversionFinder::m_passFlagsToCheck

private

Definition at line 49 of file BPhysConversionFinder.h.

◆ m_postSelector

ToolHandle<InDet::ConversionPostSelector> DerivationFramework::BPhysConversionFinder::m_postSelector

private

Definition at line 55 of file BPhysConversionFinder.h.

◆ m_requireDeltaM

bool DerivationFramework::BPhysConversionFinder::m_requireDeltaM

private

Definition at line 64 of file BPhysConversionFinder.h.

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::BPhysConversionFinder::m_v0Tools

private

Definition at line 51 of file BPhysConversionFinder.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexEstimator

ToolHandle<InDet::VertexPointEstimator> DerivationFramework::BPhysConversionFinder::m_vertexEstimator

private

Definition at line 53 of file BPhysConversionFinder.h.

◆ m_vertexFitter

ToolHandle<Trk::IVertexFitter> DerivationFramework::BPhysConversionFinder::m_vertexFitter

private

Definition at line 52 of file BPhysConversionFinder.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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ BPhysConversionFinder()

Member Function Documentation

◆ addBranches()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ doCascadeFit()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_cascadeFitter

◆ m_conversionContainerName

◆ m_detStore

◆ m_diMuonCollectionToCheck

◆ m_distanceTool

◆ m_evtStore

◆ m_inputTrackParticleContainerName

◆ m_maxDeltaCotTheta

◆ m_maxDeltaM

◆ m_maxDistBetweenTracks

◆ m_passFlagsToCheck

◆ m_postSelector

◆ m_requireDeltaM

◆ m_v0Tools

◆ m_varHandleArraysDeclared

◆ m_vertexEstimator

◆ m_vertexFitter

◆ m_vhka