DerivationFramework::BPhysConversionFinder Class Reference

#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

Private Member Functions
StatusCode	doCascadeFit (const xAOD::Vertex *diMuonVertex, const xAOD::Vertex *convVertex, const double diMuonMassConstraint, TLorentzVector &fitMom, float &chiSq) const

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

Detailed Description

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

                           :
    base_class(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)
  {
 
    // 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

Definition at line 86 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;
  }

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

finalize()

StatusCode DerivationFramework::BPhysConversionFinder::finalize ( )

override

Definition at line 78 of file BPhysConversionFinder.cxx.

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

initialize()

StatusCode DerivationFramework::BPhysConversionFinder::initialize ( )

override

Definition at line 60 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;
 
  }

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

---

The documentation for this class was generated from the following files:

• BPhysConversionFinder.h
• BPhysConversionFinder.cxx