Analysis::JpsiFinder Class Reference

#include <JpsiFinder.h>

Inheritance diagram for Analysis::JpsiFinder:

Collaboration diagram for Analysis::JpsiFinder:

Public Member Functions
	JpsiFinder (const std::string &t, const std::string &n, const IInterface *p)
	~JpsiFinder ()
virtual StatusCode	initialize () override
virtual StatusCode	performSearch (const EventContext &ctx, xAOD::VertexContainer &vxContainer) const override
std::vector< JpsiCandidate >	getPairs (const std::vector< const xAOD::TrackParticle * > &) const
std::vector< JpsiCandidate >	getPairs (const std::vector< const xAOD::Muon * > &) const
std::vector< JpsiCandidate >	getPairs2Colls (const std::vector< const xAOD::TrackParticle * > &, const std::vector< const xAOD::Muon * > &, bool) const
double	getInvariantMass (const JpsiCandidate &, std::span< const double >) const
std::vector< JpsiCandidate >	selectCharges (const std::vector< JpsiCandidate > &) const
xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &, const xAOD::TrackParticleContainer *importedTrackCollection) const
bool	passesMCPCuts (const xAOD::Muon *) const
bool	isContainedIn (const xAOD::TrackParticle *, const xAOD::TrackParticleContainer *) const
TVector3	trackMomentum (const xAOD::Vertex *vxCandidate, int trkIndex) const

Private Attributes
bool	m_mumu
bool	m_mutrk
bool	m_trktrk
bool	m_allMuons
bool	m_combOnly
bool	m_atLeastOneComb
bool	m_useCombMeasurement
bool	m_useV0Fitter
bool	m_diMuons
double	m_trk1M
double	m_trk2M
double	m_thresholdPt
double	m_higherPt
double	m_trkThresholdPt
double	m_invMassUpper
double	m_invMassLower
double	m_collAngleTheta
double	m_collAnglePhi
double	m_Chi2Cut
bool	m_oppChOnly
bool	m_sameChOnly
bool	m_allChCombs
SG::ReadHandleKey< xAOD::MuonContainer >	m_muonCollectionKey {this, "muonCollectionKey", "Muons"}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_TrkParticleCollection {this, "TrackParticleCollection", "InDetTrackParticles" }
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer >	m_MuonTrackKeys {this, "MuonTrackKeys", {}}
PublicToolHandle< Trk::IVertexFitter >	m_iVertexFitter {this, "TrkVertexFitterTool", "Trk::TrkVKalVrtFitter"}
PublicToolHandle< Trk::IVertexFitter >	m_iV0VertexFitter {this, "V0VertexFitterTool", "Trk::V0VertexFitter"}
PublicToolHandle< Trk::ITrackSelectorTool >	m_trkSelector {this, "TrackSelectorTool", "InDet::TrackSelectorTool"}
PublicToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator {this, "VertexPointEstimator", "InDet::VertexPointEstimator"}
ServiceHandle< IPartPropSvc >	m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}
bool	m_mcpCuts
bool	m_doTagAndProbe
bool	m_forceTagAndProbe

Detailed Description

Definition at line 47 of file JpsiFinder.h.

Constructor & Destructor Documentation

JpsiFinder()

Analysis::JpsiFinder::JpsiFinder	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 102 of file JpsiFinder.cxx.

                                                                                       : base_class(t,n,p),
    m_mumu(true),
    m_mutrk(false),
    m_trktrk(false),
    m_allMuons(false),
    m_combOnly(false),
    m_atLeastOneComb(true),
    m_useCombMeasurement(false),
    m_useV0Fitter(false),
    m_diMuons(true),
    m_trk1M(ParticleConstants::muonMassInMeV),
    m_trk2M(ParticleConstants::muonMassInMeV),
    m_thresholdPt(0.0),
    m_higherPt(0.0),
    m_trkThresholdPt(0.0),
    m_invMassUpper(100000.0),
    m_invMassLower(0.0),
    m_collAngleTheta(0.0),
    m_collAnglePhi(0.0),
    m_Chi2Cut(50.),
    m_oppChOnly(true),
    m_sameChOnly(false),
    m_allChCombs(false),
    m_mcpCuts(true),
    m_doTagAndProbe(false),
    m_forceTagAndProbe(false) //forcing T&P method for any charge combinations
    
    {
        declareProperty("muAndMu",m_mumu);
        declareProperty("muAndTrack",m_mutrk);
        declareProperty("TrackAndTrack",m_trktrk);
        declareProperty("allMuons",m_allMuons);
        declareProperty("combOnly",m_combOnly);
        declareProperty("atLeastOneComb",m_atLeastOneComb);
        declareProperty("useCombinedMeasurement",m_useCombMeasurement);
        declareProperty("useV0Fitter",m_useV0Fitter);
        declareProperty("assumeDiMuons",m_diMuons);
        declareProperty("track1Mass",m_trk1M);
        declareProperty("track2Mass",m_trk2M);
        declareProperty("muonThresholdPt",m_thresholdPt);
        declareProperty("higherPt",m_higherPt);
        declareProperty("trackThresholdPt",m_trkThresholdPt);
        declareProperty("invMassUpper",m_invMassUpper);
        declareProperty("invMassLower",m_invMassLower);
        declareProperty("collAngleTheta",m_collAngleTheta);
        declareProperty("collAnglePhi",m_collAnglePhi);
        declareProperty("Chi2Cut",m_Chi2Cut);
        declareProperty("oppChargesOnly",m_oppChOnly);
        declareProperty("sameChargesOnly",m_sameChOnly);
        declareProperty("allChargeCombinations",m_allChCombs);
        declareProperty("useMCPCuts",m_mcpCuts);
        declareProperty("doTagAndProbe",m_doTagAndProbe);
        declareProperty("forceTagAndProbe",m_forceTagAndProbe);
    }

~JpsiFinder()

Analysis::JpsiFinder::~JpsiFinder

(

)

Definition at line 157 of file JpsiFinder.cxx.

{ }

Member Function Documentation

fit()

xAOD::Vertex * Analysis::JpsiFinder::fit	(	const std::vector< const xAOD::TrackParticle * > &	inputTracks,
		const xAOD::TrackParticleContainer *	importedTrackCollection ) const

Definition at line 410 of file JpsiFinder.cxx.

                                                                                                                                                      {
        
        const Trk::TrkV0VertexFitter* concreteVertexFitter=0;
        if (m_useV0Fitter) {
            // making a concrete fitter for the V0Fitter
            concreteVertexFitter = dynamic_cast<const Trk::TrkV0VertexFitter * >(m_iV0VertexFitter.get());
            if(concreteVertexFitter == 0) {
                ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
                return NULL;
            }
        }
        
        const Trk::Perigee& aPerigee1 = inputTracks[0]->perigeeParameters();
        const Trk::Perigee& aPerigee2 = inputTracks[1]->perigeeParameters();
        int sflag = 0;
        int errorcode = 0;
        Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
        if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
        if (m_useV0Fitter) {
            xAOD::Vertex* myVxCandidate = concreteVertexFitter->fit(inputTracks, startingPoint);
 
            // Added by ASC
            if(myVxCandidate != 0){
            std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
            for(unsigned int i=0; i< myVxCandidate->trackParticleLinks().size(); i++)
            { ElementLink<DataVector<xAOD::TrackParticle> > mylink=myVxCandidate->trackParticleLinks()[i]; //makes a copy (non-const) 
            mylink.setStorableObject(*importedTrackCollection, true); 
            newLinkVector.push_back( mylink ); }
            
            myVxCandidate->clearTracks();
            myVxCandidate->setTrackParticleLinks( newLinkVector );
            }
            
 
 
            return myVxCandidate;
        } else {
            xAOD::Vertex* myVxCandidate = m_iVertexFitter->fit(inputTracks, startingPoint);
 
            // Added by ASC
            if(myVxCandidate != 0){
            std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
            for(unsigned int i=0; i< myVxCandidate->trackParticleLinks().size(); i++)
            { ElementLink<DataVector<xAOD::TrackParticle> > mylink=myVxCandidate->trackParticleLinks()[i]; //makes a copy (non-const) 
            mylink.setStorableObject(*importedTrackCollection, true); 
            newLinkVector.push_back( mylink ); }
            
            myVxCandidate->clearTracks();
            myVxCandidate->setTrackParticleLinks( newLinkVector );
            }
 
 
            return myVxCandidate;
        }
      
 
 
        return NULL;
        
    } // End of fit method

getInvariantMass()

double Analysis::JpsiFinder::getInvariantMass	(	const JpsiCandidate &	jpsiIn,
		std::span< const double >	massHypotheses ) const

Definition at line 582 of file JpsiFinder.cxx.

                                                                                                               {
      
      // construct 4-vectors from track perigee parameters using given mass hypotheses.
      // NOTE: in new data model (xAOD) the defining parameters are expressed as perigee parameters w.r.t. the beamspot
      // NOTE2: TrackParticle::p4() method already returns TLorentzVector, however, we want to enforce our own mass hypothesis
      TLorentzVector mu1;
      TLorentzVector mu2;
      mu1.SetVectM(jpsiIn.trackParticle1->p4().Vect(), massHypotheses[0]);
      mu2.SetVectM(jpsiIn.trackParticle2->p4().Vect(), massHypotheses[1]);
      
      return (mu1+mu2).M();
        
    }

getPairs() [1/2]

std::vector< JpsiCandidate > Analysis::JpsiFinder::getPairs

(

const std::vector< const xAOD::Muon * > &

)

const

getPairs() [2/2]

std::vector< JpsiCandidate > Analysis::JpsiFinder::getPairs

(

const std::vector< const xAOD::TrackParticle * > &

TracksIn

)

const

Definition at line 478 of file JpsiFinder.cxx.

                                                                                                           {
        
        std::vector<JpsiCandidate> myPairs;
        JpsiCandidate pair;
        std::vector<const xAOD::TrackParticle*>::const_iterator outerItr;
        std::vector<const xAOD::TrackParticle*>::const_iterator innerItr;
        
        if(TracksIn.size()>=2){
            for(outerItr=TracksIn.begin();outerItr<TracksIn.end();++outerItr){
                for(innerItr=(outerItr+1);innerItr!=TracksIn.end();++innerItr){
                    pair.trackParticle1 = *innerItr;
                    pair.trackParticle2 = *outerItr;
                    pair.pairType = TRKTRK;
                    myPairs.push_back(pair);
                }
            }
        }
        
        return(myPairs);
    }

getPairs2Colls()

std::vector< JpsiCandidate > Analysis::JpsiFinder::getPairs2Colls	(	const std::vector< const xAOD::TrackParticle * > &	tracks,
		const std::vector< const xAOD::Muon * > &	muons,
		bool	tagAndProbe ) const

Definition at line 535 of file JpsiFinder.cxx.

                                                                                                                                                                          {
        
        std::vector<JpsiCandidate> myPairs;
        JpsiCandidate pair;
        
        // Unless user is running in tag and probe mode, remove tracks which are also identified as muons
        std::vector<const xAOD::TrackParticle*> tracksToKeep;
        if (!tagAndProbe) {
            if(tracks.size()>=1 && muons.size()>=1){
                for (const xAOD::TrackParticle* trk : tracks) {
                    bool trackIsMuon(false);
                    for (const xAOD::Muon* mu : muons) {
                      auto& link = mu->inDetTrackParticleLink();
                      if ( link.isValid() &&  *link == trk ) {
                          trackIsMuon=true; 
                          break;
                        }
                    }
                    if (!trackIsMuon) tracksToKeep.push_back(trk);
                }
            }
        } else {tracksToKeep = tracks;}
        
        if(tracksToKeep.size()>=1 && muons.size()>=1){
            for (const xAOD::TrackParticle* trk : tracksToKeep) {
                for (const xAOD::Muon* mu : muons) {
                    pair.muon1 = mu;
                    // Muon track 1st
                    pair.trackParticle1 = mu->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                    pair.trackParticle2 = trk;
                    pair.pairType = MUTRK;
                    myPairs.push_back(pair);
                }
            }
        }
        
        return(myPairs);
    }

initialize()

StatusCode Analysis::JpsiFinder::initialize ( )

overridevirtual

Definition at line 29 of file JpsiFinder.cxx.

                                      {
        
        // retrieving vertex Fitter
        ATH_CHECK(m_iVertexFitter.retrieve());
        
        // retrieving V0 Fitter
        ATH_CHECK(m_iV0VertexFitter.retrieve(DisableTool{!m_useV0Fitter }));
        
        // Get the track selector tool from ToolSvc
        ATH_CHECK(m_trkSelector.retrieve());
        
        // Get the vertex point estimator tool from ToolSvc
        ATH_CHECK(m_vertexEstimator.retrieve());
 
 
        ATH_CHECK(m_muonCollectionKey.initialize());
        ATH_CHECK(m_TrkParticleCollection.initialize());
        ATH_CHECK(m_MuonTrackKeys.initialize(m_MuonTrackKeys.size() != 0));
 
        if (m_diMuons) {
          // Get the Particle Properties Service
          ATH_CHECK(m_partPropSvc.retrieve());
          auto particleDataTable = m_partPropSvc->PDT();
          const HepPDT::ParticleData* pd_mu = particleDataTable->particle(MC::MUON);
          m_trk1M = pd_mu->mass();
          m_trk2M = pd_mu->mass();
        }
 
        if (m_doTagAndProbe) ATH_MSG_WARNING("You have requested tag and probe mode. Duplicate mu+trk pairs WILL be allowed, charge ordering WILL NOT be done. Tag track will be first in each candidate");
 
 
//        // Check that the user's settings are sensible
        bool illogicalOptions(false);
        if ( (m_mumu && m_mutrk) || (m_mumu && m_trktrk) || (m_mutrk && m_trktrk) ) {
            ATH_MSG_WARNING("You are requesting incompatible combinations of muons and tracks in the pairs. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if ( (m_doTagAndProbe && m_mumu) || (m_doTagAndProbe && m_trktrk) ) {
            ATH_MSG_WARNING("You are requesting Tag and Probe analysis but have not requested mu+trk mode. This is impossible. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if ( (m_mutrk ||  m_trktrk ) && m_useCombMeasurement ) {
            ATH_MSG_WARNING("You are requesting a combined muon measurement to be used with pairs involving non-muon tracks. Not permitted. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if ( (m_allMuons && m_combOnly) || (m_allMuons && m_atLeastOneComb) || (m_combOnly && m_atLeastOneComb) ) {
            ATH_MSG_WARNING("You are requesting incompatible combinations of combined muons non-combined muons in the pairs. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if (m_atLeastOneComb && m_doTagAndProbe) {
            ATH_MSG_WARNING("You are requesting at least one muon to be combined in a tag and probe analysis. This doesn't make sense. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if ( (m_oppChOnly && m_sameChOnly) || (m_oppChOnly && m_allChCombs) || (m_sameChOnly && m_allChCombs) ) {
            ATH_MSG_WARNING("You are requesting incompatible combinations of charges in the pairs. JpsiCandidates will be EMPTY!");
            illogicalOptions=true;
        };
        if ( (m_sameChOnly && m_doTagAndProbe) || (m_allChCombs && m_doTagAndProbe) ) {
            if (!m_forceTagAndProbe){ //if m_forceTagAndProbe=TRUE then T&P will work with any charge combinations
                ATH_MSG_WARNING("You are requesting same-sign or all-sign combinations in a tag and probe analysis. This doesn't make sense. JpsiCandidates will be EMPTY!");
                illogicalOptions=true;
            }
        }
        if (illogicalOptions) return StatusCode::FAILURE;;
 
 
        ATH_MSG_DEBUG("Initialize successful");
        
        return StatusCode::SUCCESS;
        
    }

isContainedIn()

bool Analysis::JpsiFinder::isContainedIn	(	const xAOD::TrackParticle *	theTrack,
		const xAOD::TrackParticleContainer *	theCollection ) const

Definition at line 652 of file JpsiFinder.cxx.

                                                                                                                           {
        return std::find(theCollection->begin(), theCollection->end(), theTrack) != theCollection->end();
    }

passesMCPCuts()

bool Analysis::JpsiFinder::passesMCPCuts

(

const xAOD::Muon *

muon

)

const

Definition at line 642 of file JpsiFinder.cxx.

                                                             {
    
      return muon->passesIDCuts();
        
    }

performSearch()

StatusCode Analysis::JpsiFinder::performSearch ( const EventContext & ctx, xAOD::VertexContainer & vxContainer ) const

overridevirtual

Definition at line 162 of file JpsiFinder.cxx.

    {
        ATH_MSG_DEBUG( "JpsiFinder::performSearch" );
        
        SG::ReadHandle<xAOD::MuonContainer> muonhandle(m_muonCollectionKey,ctx);
        if(!muonhandle.isValid()){
            ATH_MSG_ERROR("Could not retrieve " << m_muonCollectionKey.key());
            return StatusCode::FAILURE;
        }
        // Get the muons from StoreGate
        const xAOD::MuonContainer* importedMuonCollection = muonhandle.cptr();
        ATH_MSG_DEBUG("Muon container size "<<importedMuonCollection->size());
        
        // Get muon tracks if combined measurement requested
        std::vector<const xAOD::TrackParticleContainer*> importedMuonTrackCollections;
        if (m_useCombMeasurement) {
 
            for (SG::ReadHandle<xAOD::TrackParticleContainer>& handle: m_MuonTrackKeys.makeHandles(ctx)) {
                if(!handle.isValid()){
                    ATH_MSG_WARNING("No muon TrackParticle collection with name " << handle.key()  << " found in StoreGate!");
                    return StatusCode::FAILURE;
                } else {
                    ATH_MSG_DEBUG("Found muon TrackParticle collection " << handle.key() << " in StoreGate!");
                    ATH_MSG_DEBUG("Muon TrackParticle container size "<< handle->size());
                    importedMuonTrackCollections.push_back(handle.cptr());
                }
            }
        }
        
        // Get ID tracks
        SG::ReadHandle<xAOD::TrackParticleContainer> handle(m_TrkParticleCollection,ctx);
        const xAOD::TrackParticleContainer* importedTrackCollection{nullptr};
        if(!handle.isValid()){
            ATH_MSG_WARNING("No TrackParticle collection with name " << handle.key() << " found in StoreGate!");
            return StatusCode::FAILURE;
        } else {
            importedTrackCollection = handle.cptr();
            ATH_MSG_DEBUG("Found TrackParticle collection " << handle.key() << " in StoreGate!");
        }
        ATH_MSG_DEBUG("ID TrackParticle container size "<< handle->size());
        
        // Typedef for vectors of tracks and muons
        typedef std::vector<const xAOD::TrackParticle*> TrackBag;
        typedef std::vector<const xAOD::Muon*> MuonBag;
        
        // Select the inner detector tracks
        const xAOD::Vertex* vx = nullptr;
        TrackBag theIDTracksAfterSelection;
        if (m_trktrk || m_mutrk) {
            xAOD::TrackParticleContainer::const_iterator trkCItr;
            for (trkCItr=importedTrackCollection->begin(); trkCItr!=importedTrackCollection->end(); ++trkCItr) {
                const xAOD::TrackParticle* TP = (*trkCItr);
                if ( fabs(TP->pt())<m_trkThresholdPt ) continue;
                if ( !m_trkSelector->decision(*TP, vx) ) continue;
                theIDTracksAfterSelection.push_back(TP);
            }
            if (theIDTracksAfterSelection.size() == 0) return StatusCode::SUCCESS;;
            ATH_MSG_DEBUG("Number of tracks after ID track selection: " << theIDTracksAfterSelection.size());
        }
        
        // Select the muons
        MuonBag theMuonsAfterSelection;
        if (m_mumu || m_mutrk) {
            for (auto muItr=importedMuonCollection->begin(); muItr!=importedMuonCollection->end(); ++muItr) {
                if ( *muItr == NULL ) continue;
                if (!(*muItr)->inDetTrackParticleLink().isValid()) continue; // No muons without ID tracks
                const xAOD::TrackParticle* muonTrk = *((*muItr)->inDetTrackParticleLink());
                if ( muonTrk==NULL) continue;
                if ( !m_trkSelector->decision(*muonTrk, vx) ) continue; // all ID tracks must pass basic tracking cuts
                if ( fabs(muonTrk->pt())<m_thresholdPt ) continue; // higher pt cut if needed
                if ( m_mcpCuts && !passesMCPCuts(*muItr)) continue; // MCP cuts
                if ( m_combOnly && (*muItr)->muonType() != xAOD::Muon::Combined ) continue; // require combined muons
                if ( (*muItr)->muonType() == xAOD::Muon::SiliconAssociatedForwardMuon && !m_useCombMeasurement) continue;
                theMuonsAfterSelection.push_back(*muItr);
            }
            if (theMuonsAfterSelection.size() == 0) return StatusCode::SUCCESS;;
            ATH_MSG_DEBUG("Number of muons after selection: " << theMuonsAfterSelection.size());
        }
        
        // Sort into pairs - end result will be a vector of JpsiCandidate structs
        std::vector<JpsiCandidate> jpsiCandidates;
        if (m_mumu) jpsiCandidates = getPairs(theMuonsAfterSelection);
        if (m_trktrk) jpsiCandidates = getPairs(theIDTracksAfterSelection);
        if (m_mutrk) jpsiCandidates = getPairs2Colls(theIDTracksAfterSelection,theMuonsAfterSelection,m_doTagAndProbe);
 
        
        // (1) Enforce one combined muon
        if (m_atLeastOneComb) {
            std::vector<JpsiCandidate> selectCandidates;
            for(auto &cand : jpsiCandidates) { if(cand.muonTypes!=TT) selectCandidates.push_back(cand); }
            selectCandidates.swap(jpsiCandidates);
            ATH_MSG_DEBUG("Number of candidates after requirement of at least 1 combined muon: " << jpsiCandidates.size() );
        }
        
        // (2) Establish track content for candidates
        // and set the appropriate track collections for the combined muon tracks where appropriate (for saving to persistency later)
        
        // mu+trk or trk+trk - always ID track collection
        if (m_mutrk || m_trktrk) {
            for (auto jpsiItr=jpsiCandidates.begin(); jpsiItr!=jpsiCandidates.end(); ++jpsiItr) {
                (*jpsiItr).collection1 = importedTrackCollection;
                (*jpsiItr).collection2 = importedTrackCollection;
            }
        }
        
        if (m_mumu) {
            for (auto jpsiItr=jpsiCandidates.begin(); jpsiItr!=jpsiCandidates.end(); ++jpsiItr) {
                if ( (m_combOnly && !m_useCombMeasurement) || m_atLeastOneComb || m_allMuons) {
                  (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                  (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                  (*jpsiItr).collection1 = importedTrackCollection;
                  (*jpsiItr).collection2 = importedTrackCollection;
                }
                if (m_combOnly && m_useCombMeasurement) {
                    if (!(*jpsiItr).muon1->combinedTrackParticleLink().isValid()) {
                      (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                      (*jpsiItr).collection1 = importedTrackCollection;
                    }
                    
                    if (!(*jpsiItr).muon2->combinedTrackParticleLink().isValid()) {
                      (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                      (*jpsiItr).collection2 = importedTrackCollection;
                    }
                    
                    if ((*jpsiItr).muon1->combinedTrackParticleLink().isValid()) {
                        (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::CombinedTrackParticle );
                        bool foundCollection(false);
                        // Look for correct muon track container
                        for (auto muTrkCollItr=importedMuonTrackCollections.begin(); muTrkCollItr!=importedMuonTrackCollections.end(); ++muTrkCollItr) {
                            if (isContainedIn((*jpsiItr).trackParticle1,*muTrkCollItr)) { (*jpsiItr).collection1 = *muTrkCollItr; foundCollection=true; break;}
                        }
                        if (!foundCollection) { // didn't find the correct muon track container so go back to ID
                            (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                            (*jpsiItr).collection1 = importedTrackCollection;
                            ATH_MSG_WARNING("Muon track from muon of author " << (*jpsiItr).muon1->author() << " not found in muon track collections you have provided.");
                            ATH_MSG_WARNING("Defaulting to ID track collection - combined measurement will not be used");
                        }
                    }
                    
                    if ((*jpsiItr).muon2->combinedTrackParticleLink().isValid()) {
                        (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::CombinedTrackParticle );
                        bool foundCollection(false);
                        // Look for correct muon track container
                        for (auto muTrkCollItr=importedMuonTrackCollections.begin(); muTrkCollItr!=importedMuonTrackCollections.end(); ++muTrkCollItr) {
                            if (isContainedIn((*jpsiItr).trackParticle2,*muTrkCollItr)) { (*jpsiItr).collection2 = *muTrkCollItr; foundCollection=true; break;}
                        }
                        if (!foundCollection) { // didn't find the correct muon track container so go back to ID
                            (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
                            (*jpsiItr).collection2 = importedTrackCollection;
                            ATH_MSG_WARNING("Muon track from muon of author " << (*jpsiItr).muon2->author() << " not found in muon track collections you have provided.");
                            ATH_MSG_WARNING("Defaulting to ID track collection - combined measurement will not be used");
                        }
                    }
                } // combined measurement
            } // iteration over candidates
        }
        
        
        // (3) Enforce higher track pt if requested
        if (m_higherPt>0.0) {
            std::vector<JpsiCandidate> selectCandidates;
            for(auto& cand : jpsiCandidates){
                bool reject = (fabs(cand.trackParticle1->pt()) < m_higherPt) && (fabs(cand.trackParticle2->pt()) < m_higherPt);
                if(!reject) selectCandidates.push_back(cand);
            }
            selectCandidates.swap(jpsiCandidates);
            ATH_MSG_DEBUG("Number of candidates after higherPt cut: " << jpsiCandidates.size() );
        }
        
        // (4) Select all opp/same charged track pairs
        std::vector<JpsiCandidate> sortedJpsiCandidates;
        sortedJpsiCandidates = selectCharges(jpsiCandidates);
 
        ATH_MSG_DEBUG("Number of candidates after charge selection: " << sortedJpsiCandidates.size() );
        
        // (5) Select for decay angle, if requested
        if (m_collAnglePhi>0.0 && m_collAngleTheta>0.0) {
            std::vector<JpsiCandidate> selectCandidates;
            for(auto& cand : sortedJpsiCandidates){
                double deltatheta = fabs( cand.trackParticle1->theta() - cand.trackParticle2->theta() );
                double deltaphi = std::abs(xAOD::P4Helpers::deltaPhi(cand.trackParticle1->phi0() , cand.trackParticle2->phi0()));
                bool reject = (deltatheta > m_collAngleTheta) || (deltaphi > m_collAnglePhi);
                if(!reject) selectCandidates.push_back(cand);
            }
            sortedJpsiCandidates.swap(selectCandidates);
            ATH_MSG_DEBUG("Number of collimated candidates: " << sortedJpsiCandidates.size() );
        }
        
        // (6) Select for invariant mass, if requested
        std::array<double,2> trkMasses{m_trk1M, m_trk2M};
        if ( (m_invMassLower > 0.0) || (m_invMassUpper > 0.0) ) {
            std::vector<JpsiCandidate> selectCandidates;
            for(auto& cand : sortedJpsiCandidates){
                double invMass = getInvariantMass(cand,trkMasses);
                bool reject = invMass < m_invMassLower || invMass > m_invMassUpper;
                if(!reject) selectCandidates.push_back(cand);
            }
            selectCandidates.swap(sortedJpsiCandidates);
            ATH_MSG_DEBUG("Number of candidates passing invariant mass selection: " << sortedJpsiCandidates.size() );
        }
        
        ATH_MSG_DEBUG("Number of pairs passing all selections and going to vertexing: " << sortedJpsiCandidates.size() );
        if (sortedJpsiCandidates.size() == 0) return StatusCode::SUCCESS;;
        std::vector<const xAOD::TrackParticle*> theTracks;
        std::vector<const xAOD::Muon*> theStoredMuons;
        // Fit each pair of tracks to a vertex
        for(auto jpsiItr=sortedJpsiCandidates.begin(); jpsiItr!=sortedJpsiCandidates.end(); ++jpsiItr) {
            theTracks.clear();
            theTracks.push_back((*jpsiItr).trackParticle1);
            theTracks.push_back((*jpsiItr).trackParticle2);
            std::unique_ptr<xAOD::Vertex> myVxCandidate {fit(theTracks,importedTrackCollection)}; // This line actually does the fitting and object making
            if (myVxCandidate) {
                // Chi2 cut if requested
                double chi2 = myVxCandidate->chiSquared();
                ATH_MSG_DEBUG("chi2 is: " << chi2);
                if (m_Chi2Cut <= 0.0 || chi2 <= m_Chi2Cut) {             
                    // decorate the candidate with refitted tracks and muons via the BPhysHelper
                    xAOD::BPhysHelper jpsiHelper(myVxCandidate.get());
                    bool validtrk = jpsiHelper.setRefTrks();
                    if(!validtrk) ATH_MSG_WARNING("Problem setting tracks " << __FILE__ << ':' << __LINE__);
                    if (m_mumu || m_mutrk) {
                         theStoredMuons.clear();
                         theStoredMuons.push_back((*jpsiItr).muon1);
                         if (m_mumu) theStoredMuons.push_back((*jpsiItr).muon2);
                         bool valid = jpsiHelper.setMuons(theStoredMuons,importedMuonCollection);
                         if(!valid) ATH_MSG_WARNING("Problem setting muons " << __FILE__ << ':' << __LINE__);
                    }
                    // Retain the vertex
                    vxContainer.push_back(std::move(myVxCandidate));       
                } 
            } else { // fit failed
                ATH_MSG_DEBUG("Fitter failed!");
                // Don't try to delete the object, since we arrived here,
                // because this pointer is null...
                //delete myVxCandidate;
            }
        }
        ATH_MSG_DEBUG("vxContainer size " << vxContainer.size());
        
        return StatusCode::SUCCESS;;
    }

selectCharges()

std::vector< JpsiCandidate > Analysis::JpsiFinder::selectCharges

(

const std::vector< JpsiCandidate > &

jpsisIn

)

const

Definition at line 602 of file JpsiFinder.cxx.

                                                                                                    {
        
        bool opposite(false),same(false),all(false);
        opposite=m_oppChOnly;
        same=m_sameChOnly;
        all=m_allChCombs;
        
        JpsiCandidate tmpJpsi;
        std::vector<JpsiCandidate> jpsis;
        double qOverP1=0.;
        double qOverP2=0.;
        for(auto jpsiItr=jpsisIn.cbegin();jpsiItr!=jpsisIn.cend();jpsiItr++){
            bool oppCh(false),sameCh(false);
            tmpJpsi = *jpsiItr;
            qOverP1=(*jpsiItr).trackParticle1->qOverP();
            qOverP2=(*jpsiItr).trackParticle2->qOverP();
            if(qOverP1*qOverP2<0.0) oppCh=true; // product charge < 0
            if(qOverP1*qOverP2>0.0) sameCh=true; // product charge > 0
            // +ve should be first so swap
            // Don't do it for tag and probe analyses (because tag muon must not change position)
            if (oppCh && qOverP1<0.0 && !m_doTagAndProbe && !m_mutrk) {
                tmpJpsi.trackParticle1 = (*jpsiItr).trackParticle2;
                tmpJpsi.trackParticle2 = (*jpsiItr).trackParticle1;
                tmpJpsi.muon1 = (*jpsiItr).muon2;
                tmpJpsi.muon2 = (*jpsiItr).muon1;
                tmpJpsi.collection1 = (*jpsiItr).collection2;
                tmpJpsi.collection2 = (*jpsiItr).collection1;
            }
            if (oppCh && (opposite || all) ) jpsis.push_back(tmpJpsi);
            if (sameCh && (same || all) ) jpsis.push_back(tmpJpsi);
            
        } // end of for loop
        
        return(jpsis);
    }

trackMomentum()

TVector3 Analysis::JpsiFinder::trackMomentum	(	const xAOD::Vertex *	vxCandidate,
		int	trkIndex ) const

Definition at line 660 of file JpsiFinder.cxx.

    {
      double px = 0., py = 0., pz = 0.;
      if (0 != vxCandidate) {
        const Trk::TrackParameters* aPerigee = vxCandidate->vxTrackAtVertex()[trkIndex].perigeeAtVertex();
        px = aPerigee->momentum()[Trk::px];
        py = aPerigee->momentum()[Trk::py];
        pz = aPerigee->momentum()[Trk::pz];
      }
      TVector3 mom(px,py,pz);
      return mom;
    }

Member Data Documentation

m_allChCombs

bool Analysis::JpsiFinder::m_allChCombs

private

Definition at line 91 of file JpsiFinder.h.

m_allMuons

bool Analysis::JpsiFinder::m_allMuons

private

Definition at line 73 of file JpsiFinder.h.

m_atLeastOneComb

bool Analysis::JpsiFinder::m_atLeastOneComb

private

Definition at line 75 of file JpsiFinder.h.

m_Chi2Cut

double Analysis::JpsiFinder::m_Chi2Cut

private

Definition at line 88 of file JpsiFinder.h.

m_collAnglePhi

double Analysis::JpsiFinder::m_collAnglePhi

private

Definition at line 87 of file JpsiFinder.h.

m_collAngleTheta

double Analysis::JpsiFinder::m_collAngleTheta

private

Definition at line 86 of file JpsiFinder.h.

m_combOnly

bool Analysis::JpsiFinder::m_combOnly

private

Definition at line 74 of file JpsiFinder.h.

m_diMuons

bool Analysis::JpsiFinder::m_diMuons

private

Definition at line 78 of file JpsiFinder.h.

m_doTagAndProbe

bool Analysis::JpsiFinder::m_doTagAndProbe

private

Definition at line 101 of file JpsiFinder.h.

m_forceTagAndProbe

bool Analysis::JpsiFinder::m_forceTagAndProbe

private

Definition at line 102 of file JpsiFinder.h.

m_higherPt

double Analysis::JpsiFinder::m_higherPt

private

Definition at line 82 of file JpsiFinder.h.

m_invMassLower

double Analysis::JpsiFinder::m_invMassLower

private

Definition at line 85 of file JpsiFinder.h.

m_invMassUpper

double Analysis::JpsiFinder::m_invMassUpper

private

Definition at line 84 of file JpsiFinder.h.

m_iV0VertexFitter

PublicToolHandle< Trk::IVertexFitter > Analysis::JpsiFinder::m_iV0VertexFitter {this, "V0VertexFitterTool", "Trk::V0VertexFitter"}

private

Definition at line 96 of file JpsiFinder.h.

{this, "V0VertexFitterTool", "Trk::V0VertexFitter"};

m_iVertexFitter

PublicToolHandle< Trk::IVertexFitter > Analysis::JpsiFinder::m_iVertexFitter {this, "TrkVertexFitterTool", "Trk::TrkVKalVrtFitter"}

private

Definition at line 95 of file JpsiFinder.h.

{this, "TrkVertexFitterTool", "Trk::TrkVKalVrtFitter"};

m_mcpCuts

bool Analysis::JpsiFinder::m_mcpCuts

private

Definition at line 100 of file JpsiFinder.h.

m_mumu

bool Analysis::JpsiFinder::m_mumu

private

Definition at line 70 of file JpsiFinder.h.

m_muonCollectionKey

SG::ReadHandleKey<xAOD::MuonContainer> Analysis::JpsiFinder::m_muonCollectionKey {this, "muonCollectionKey", "Muons"}

private

Definition at line 92 of file JpsiFinder.h.

{this, "muonCollectionKey", "Muons"};

m_MuonTrackKeys

SG::ReadHandleKeyArray<xAOD::TrackParticleContainer> Analysis::JpsiFinder::m_MuonTrackKeys {this, "MuonTrackKeys", {}}

private

Definition at line 94 of file JpsiFinder.h.

{this, "MuonTrackKeys", {}};

m_mutrk

bool Analysis::JpsiFinder::m_mutrk

private

Definition at line 71 of file JpsiFinder.h.

m_oppChOnly

bool Analysis::JpsiFinder::m_oppChOnly

private

Definition at line 89 of file JpsiFinder.h.

m_partPropSvc

ServiceHandle<IPartPropSvc> Analysis::JpsiFinder::m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}

private

Definition at line 99 of file JpsiFinder.h.

{this, "PartPropSvc", "PartPropSvc"};

m_sameChOnly

bool Analysis::JpsiFinder::m_sameChOnly

private

Definition at line 90 of file JpsiFinder.h.

m_thresholdPt

double Analysis::JpsiFinder::m_thresholdPt

private

Definition at line 81 of file JpsiFinder.h.

m_trk1M

double Analysis::JpsiFinder::m_trk1M

private

Definition at line 79 of file JpsiFinder.h.

m_trk2M

double Analysis::JpsiFinder::m_trk2M

private

Definition at line 80 of file JpsiFinder.h.

m_TrkParticleCollection

SG::ReadHandleKey<xAOD::TrackParticleContainer> Analysis::JpsiFinder::m_TrkParticleCollection {this, "TrackParticleCollection", "InDetTrackParticles" }

private

Definition at line 93 of file JpsiFinder.h.

{this, "TrackParticleCollection", "InDetTrackParticles" };

m_trkSelector

PublicToolHandle< Trk::ITrackSelectorTool > Analysis::JpsiFinder::m_trkSelector {this, "TrackSelectorTool", "InDet::TrackSelectorTool"}

private

Definition at line 97 of file JpsiFinder.h.

{this, "TrackSelectorTool", "InDet::TrackSelectorTool"};

m_trkThresholdPt

double Analysis::JpsiFinder::m_trkThresholdPt

private

Definition at line 83 of file JpsiFinder.h.

m_trktrk

bool Analysis::JpsiFinder::m_trktrk

private

Definition at line 72 of file JpsiFinder.h.

m_useCombMeasurement

bool Analysis::JpsiFinder::m_useCombMeasurement

private

Definition at line 76 of file JpsiFinder.h.

m_useV0Fitter

bool Analysis::JpsiFinder::m_useV0Fitter

private

Definition at line 77 of file JpsiFinder.h.

m_vertexEstimator

PublicToolHandle< InDet::VertexPointEstimator > Analysis::JpsiFinder::m_vertexEstimator {this, "VertexPointEstimator", "InDet::VertexPointEstimator"}

private

Definition at line 98 of file JpsiFinder.h.

{this, "VertexPointEstimator", "InDet::VertexPointEstimator"};

---

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

• JpsiFinder.h
• JpsiFinder.cxx