Inheritance diagram for BtoCharmDecayVertexMergerT< VTX >:

Classes
struct	VertexProxy

Public Types
typedef reco::TemplatedSecondaryVertex< VTX >	SecondaryVertex

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
	BtoCharmDecayVertexMergerT (const edm::ParameterSet &params)

void	produce (edm::Event &event, const edm::EventSetup &es) override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
VertexProxy	buildVertexProxy (const VTX &vtx)

template<>
BtoCharmDecayVertexMergerT< reco::Vertex >::VertexProxy	buildVertexProxy (const reco::Vertex &vtx)

template<>
BtoCharmDecayVertexMergerT< reco::VertexCompositePtrCandidate >::VertexProxy	buildVertexProxy (const reco::VertexCompositePtrCandidate &vtx)

GlobalVector	flightDirection (const reco::Vertex &v1, const reco::Vertex &v2)

GlobalVector	flightDirection (const reco::Vertex &v1, const reco::VertexCompositePtrCandidate &v2)

GlobalVector	flightDirection (const reco::VertexCompositePtrCandidate &v1, const reco::VertexCompositePtrCandidate &v2)

void	resolveBtoDchain (std::vector< VertexProxy > &coll, unsigned int i, unsigned int k)

template<>
void	resolveBtoDchain (std::vector< VertexProxy > &coll, unsigned int i, unsigned int k)

template<>
void	resolveBtoDchain (std::vector< VertexProxy > &coll, unsigned int i, unsigned int k)

Private Attributes
double	maxDRForUnique

double	maxPtreltomerge

double	maxvecSumIMCUTForUnique

double	minCosPAtomerge

reco::Vertex	pv

edm::EDGetTokenT< reco::VertexCollection >	token_primaryVertex

edm::EDGetTokenT< edm::View< VTX > >	token_secondaryVertex

Friends
bool	operator< (VertexProxy v1, VertexProxy v2)

Detailed Description

template<typename VTX>
class BtoCharmDecayVertexMergerT< VTX >

Definition at line 41 of file BtoCharmDecayVertexMerger.cc.

Member Typedef Documentation

◆ SecondaryVertex

template<typename VTX >

typedef reco::TemplatedSecondaryVertex<VTX> BtoCharmDecayVertexMergerT< VTX >::SecondaryVertex

Definition at line 47 of file BtoCharmDecayVertexMerger.cc.

Constructor & Destructor Documentation

◆ BtoCharmDecayVertexMergerT()

template<typename VTX >

BtoCharmDecayVertexMergerT< VTX >::BtoCharmDecayVertexMergerT ( const edm::ParameterSet & params )

Definition at line 84 of file BtoCharmDecayVertexMerger.cc.

     : token_primaryVertex(consumes<reco::VertexCollection>(params.getParameter<edm::InputTag>("primaryVertices"))),
       token_secondaryVertex(consumes<edm::View<VTX>>(params.getParameter<edm::InputTag>("secondaryVertices"))),
       maxDRForUnique(params.getParameter<double>("maxDRUnique")),
       maxvecSumIMCUTForUnique(params.getParameter<double>("maxvecSumIMifsmallDRUnique")),
       minCosPAtomerge(params.getParameter<double>("minCosPAtomerge")),
       maxPtreltomerge(params.getParameter<double>("maxPtreltomerge"))
 // maxFraction(params.getParameter<double>("maxFraction")),
 // minSignificance(params.getParameter<double>("minSignificance"))
 {
   produces<std::vector<VTX>>();
 }

Member Function Documentation

◆ buildVertexProxy() [1/3]

template<typename VTX >

VertexProxy BtoCharmDecayVertexMergerT< VTX >::buildVertexProxy ( const VTX & vtx )

private

◆ buildVertexProxy() [2/3]

template<>

BtoCharmDecayVertexMergerT< reco::Vertex >::VertexProxy BtoCharmDecayVertexMergerT< reco::Vertex >::buildVertexProxy ( const reco::Vertex & vtx )

private

Definition at line 164 of file BtoCharmDecayVertexMerger.cc.

References extraflags_cff::vtx.

                            {
   VertexProxy vtxProxy = {vtx, vtx.p4().M(), vtx.tracksSize()};
   return vtxProxy;
 }

◆ buildVertexProxy() [3/3]

template<>

BtoCharmDecayVertexMergerT< reco::VertexCompositePtrCandidate >::VertexProxy BtoCharmDecayVertexMergerT< reco::VertexCompositePtrCandidate >::buildVertexProxy ( const reco::VertexCompositePtrCandidate & vtx )

private

Definition at line 172 of file BtoCharmDecayVertexMerger.cc.

References extraflags_cff::vtx, and vtxP4().

                                                 {
   VertexProxy vtxProxy = {vtx, vtxP4(vtx).M(), vtx.numberOfSourceCandidatePtrs()};
   return vtxProxy;
 }

◆ flightDirection() [1/3]

template<typename VTX >

GlobalVector BtoCharmDecayVertexMergerT< VTX >::flightDirection	(	const reco::Vertex &	v1,
		const reco::Vertex &	v2
	)

private

Definition at line 144 of file BtoCharmDecayVertexMerger.cc.

References reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

                                                                                                         {
   return GlobalVector(v2.x() - v1.x(), v2.y() - v1.y(), v2.z() - v1.z());
 }

◆ flightDirection() [2/3]

template<typename VTX >

GlobalVector BtoCharmDecayVertexMergerT< VTX >::flightDirection	(	const reco::Vertex &	v1,
		const reco::VertexCompositePtrCandidate &	v2
	)

private

Definition at line 149 of file BtoCharmDecayVertexMerger.cc.

References reco::LeafCandidate::vertex(), reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

                                                                                                          {
   return GlobalVector(v2.vertex().x() - v1.x(), v2.vertex().y() - v1.y(), v2.vertex().z() - v1.z());
 }

◆ flightDirection() [3/3]

template<typename VTX >

GlobalVector BtoCharmDecayVertexMergerT< VTX >::flightDirection	(	const reco::VertexCompositePtrCandidate &	v1,
		const reco::VertexCompositePtrCandidate &	v2
	)

private

Definition at line 155 of file BtoCharmDecayVertexMerger.cc.

References reco::LeafCandidate::vertex().

                                                                                                          {
   return GlobalVector(
       v2.vertex().x() - v1.vertex().x(), v2.vertex().y() - v1.vertex().y(), v2.vertex().z() - v1.vertex().z());
 }

◆ produce()

template<typename VTX >

void BtoCharmDecayVertexMergerT< VTX >::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

override

Definition at line 98 of file BtoCharmDecayVertexMerger.cc.

References iEvent, eostools::move(), edm::Handle< T >::product(), MetAnalyzer::pv(), HLT_2022v12_cff::secondaryVertices, jetUpdater_cfi::sort, and pfDeepBoostedJetPreprocessParams_cfi::sv.

                                                                                            {
   using namespace reco;
   // PV
   edm::Handle<reco::VertexCollection> PVcoll;
   iEvent.getByToken(token_primaryVertex, PVcoll);
 
   if (!PVcoll->empty()) {
     const reco::VertexCollection pvc = *(PVcoll.product());
     pv = pvc[0];
 
     // get the IVF collection
     edm::Handle<edm::View<VTX>> secondaryVertices;
     iEvent.getByToken(token_secondaryVertex, secondaryVertices);
 
     //loop over vertices,  fill into own collection for sorting
     std::vector<VertexProxy> vertexProxyColl;
     for (typename edm::View<VTX>::const_iterator sv = secondaryVertices->begin(); sv != secondaryVertices->end();
          ++sv) {
       vertexProxyColl.push_back(buildVertexProxy(*sv));
     }
 
     // sort the vertices by mass and track multiplicity
     sort(vertexProxyColl.begin(), vertexProxyColl.end());
 
     // loop forward over all vertices
     for (unsigned int iVtx = 0; iVtx < vertexProxyColl.size(); ++iVtx) {
       // nested loop backwards (in order to start from light masses)
       // check all vertices against each other for B->D chain
       for (unsigned int kVtx = vertexProxyColl.size() - 1; kVtx > iVtx; --kVtx) {
         // remove D vertices from the collection and add the tracks to the original one
         resolveBtoDchain(vertexProxyColl, iVtx, kVtx);
       }
     }
 
     // now create new vertex collection and add to event
     auto bvertColl = std::make_unique<std::vector<VTX>>();
     for (typename std::vector<VertexProxy>::const_iterator it = vertexProxyColl.begin(); it != vertexProxyColl.end();
          ++it)
       bvertColl->push_back((*it).vert);
     iEvent.put(std::move(bvertColl));
   } else {
     iEvent.put(std::make_unique<std::vector<VTX>>());
   }
 }

◆ resolveBtoDchain() [1/3]

template<typename VTX >

void BtoCharmDecayVertexMergerT< VTX >::resolveBtoDchain	(	std::vector< VertexProxy > &	coll,
		unsigned int	i,
		unsigned int	k
	)

private

◆ resolveBtoDchain() [2/3]

template<>

void BtoCharmDecayVertexMergerT< reco::Vertex >::resolveBtoDchain	(	std::vector< VertexProxy > &	coll,
		unsigned int	i,
		unsigned int	k
	)

private

Definition at line 180 of file BtoCharmDecayVertexMerger.cc.

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::TemplatedSecondaryVertex< SV >::dist3d(), Vector3DBase< T, FrameTag >::dot(), spr::find(), flightDirection(), mps_fire::i, dqmdumpme::k, PV3DBase< T, PVType, FrameType >::mag(), bToCharmDecayVertexMerger_cfi::maxPtreltomerge, bToCharmDecayVertexMerger_cfi::minCosPAtomerge, reco::ParticleMasses::piPlus, MetAnalyzer::pv(), mathSSE::sqrt(), submitPVValidationJobs::t, groupFilesInBlocks::temp, and Measurement1D::value().

                                                                                 {
   using namespace reco;
 
   GlobalVector momentum1 = GlobalVector(coll[i].vert.p4().X(), coll[i].vert.p4().Y(), coll[i].vert.p4().Z());
   GlobalVector momentum2 = GlobalVector(coll[k].vert.p4().X(), coll[k].vert.p4().Y(), coll[k].vert.p4().Z());
 
   SecondaryVertex sv1(pv, coll[i].vert, momentum1, true);
   SecondaryVertex sv2(pv, coll[k].vert, momentum2, true);
 
   // find out which one is near and far
   SecondaryVertex svNear = sv1;
   SecondaryVertex svFar = sv2;
   GlobalVector momentumNear = momentum1;
   GlobalVector momentumFar = momentum2;
 
   // swap if it is the other way around
   if (sv1.dist3d().value() >= sv2.dist3d().value()) {
     svNear = sv2;
     svFar = sv1;
     momentumNear = momentum2;
     momentumFar = momentum1;
   }
   GlobalVector nearToFar = flightDirection(svNear, svFar);
   GlobalVector pvToNear = flightDirection(pv, svNear);
   GlobalVector pvToFar = flightDirection(pv, svFar);
 
   double cosPA = nearToFar.dot(momentumFar) / momentumFar.mag() / nearToFar.mag();
   double cosa = pvToNear.dot(momentumFar) / pvToNear.mag() / momentumFar.mag();
   double ptrel = sqrt(1.0 - cosa * cosa) * momentumFar.mag();
 
   double vertexDeltaR = Geom::deltaR(pvToNear, pvToFar);
 
   // create a set of all tracks from both vertices, avoid double counting by using a std::set<>
   std::set<reco::TrackRef> trackrefs;
   // first vertex
   for (reco::Vertex::trackRef_iterator ti = sv1.tracks_begin(); ti != sv1.tracks_end(); ++ti) {
     if (sv1.trackWeight(*ti) > 0.5) {
       reco::TrackRef t = ti->castTo<reco::TrackRef>();
       trackrefs.insert(t);
     }
   }
   // second vertex
   for (reco::Vertex::trackRef_iterator ti = sv2.tracks_begin(); ti != sv2.tracks_end(); ++ti) {
     if (sv2.trackWeight(*ti) > 0.5) {
       reco::TrackRef t = ti->castTo<reco::TrackRef>();
       trackrefs.insert(t);
     }
   }
 
   // now calculate one LorentzVector from the track momenta
   ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double>> mother;
   for (std::set<reco::TrackRef>::const_iterator it = trackrefs.begin(); it != trackrefs.end(); ++it) {
     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double>> temp(
         (*it)->px(), (*it)->py(), (*it)->pz(), ParticleMasses::piPlus);
     mother += temp;
   }
 
   //   check if criteria for merging are fulfilled
   if (vertexDeltaR < maxDRForUnique && mother.M() < maxvecSumIMCUTForUnique && cosPA > minCosPAtomerge &&
       std::abs(ptrel) < maxPtreltomerge) {
     // add tracks of second vertex which are missing to first vertex
     // loop over the second
     bool bFoundDuplicate = false;
     for (reco::Vertex::trackRef_iterator ti = sv2.tracks_begin(); ti != sv2.tracks_end(); ++ti) {
       reco::Vertex::trackRef_iterator it = find(sv1.tracks_begin(), sv1.tracks_end(), *ti);
       if (it == sv1.tracks_end())
         coll[i].vert.add(*ti, sv2.refittedTrack(*ti), sv2.trackWeight(*ti));
       else
         bFoundDuplicate = true;
     }
     // in case a duplicate track is found, need to create the full track list in the vertex from scratch because we need to modify the weight.
     // the weight must be the larger one, otherwise we may have outliers which are not real outliers
 
     if (bFoundDuplicate) {
       // create backup track containers from main vertex
       std::vector<TrackBaseRef> tracks_;
       std::vector<Track> refittedTracks_;
       std::vector<float> weights_;
       for (reco::Vertex::trackRef_iterator it = coll[i].vert.tracks_begin(); it != coll[i].vert.tracks_end(); ++it) {
         tracks_.push_back(*it);
         refittedTracks_.push_back(coll[i].vert.refittedTrack(*it));
         weights_.push_back(coll[i].vert.trackWeight(*it));
       }
       // delete tracks and add all tracks back, and check in which vertex the weight is larger
       coll[i].vert.removeTracks();
       std::vector<Track>::iterator it2 = refittedTracks_.begin();
       std::vector<float>::iterator it3 = weights_.begin();
       for (reco::Vertex::trackRef_iterator it = tracks_.begin(); it != tracks_.end(); ++it, ++it2, ++it3) {
         float weight = *it3;
         float weight2 = sv2.trackWeight(*it);
         Track refittedTrackWithLargerWeight = *it2;
         if (weight2 > weight) {
           weight = weight2;
           refittedTrackWithLargerWeight = sv2.refittedTrack(*it);
         }
         coll[i].vert.add(*it, refittedTrackWithLargerWeight, weight);
       }
     }
 
     // remove the second vertex from the collection
     coll.erase(coll.begin() + k);
   }
 }

◆ resolveBtoDchain() [3/3]

template<>

void BtoCharmDecayVertexMergerT< reco::VertexCompositePtrCandidate >::resolveBtoDchain	(	std::vector< VertexProxy > &	coll,
		unsigned int	i,
		unsigned int	k
	)

private

Definition at line 287 of file BtoCharmDecayVertexMerger.cc.

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::TemplatedSecondaryVertex< SV >::dist3d(), Vector3DBase< T, FrameTag >::dot(), spr::find(), flightDirection(), mps_fire::i, dqmdumpme::k, PV3DBase< T, PVType, FrameType >::mag(), bToCharmDecayVertexMerger_cfi::maxPtreltomerge, bToCharmDecayVertexMerger_cfi::minCosPAtomerge, reco::ParticleMasses::piPlus, MetAnalyzer::pv(), mathSSE::sqrt(), groupFilesInBlocks::temp, Measurement1D::value(), and vtxP4().

                                                                                                      {
   using namespace reco;
 
   Candidate::LorentzVector vtx1P4 = vtxP4(coll[i].vert);
   Candidate::LorentzVector vtx2P4 = vtxP4(coll[k].vert);
   GlobalVector momentum1 = GlobalVector(vtx1P4.X(), vtx1P4.Y(), vtx1P4.Z());
   GlobalVector momentum2 = GlobalVector(vtx2P4.X(), vtx2P4.Y(), vtx2P4.Z());
 
   SecondaryVertex sv1(pv, coll[i].vert, momentum1, true);
   SecondaryVertex sv2(pv, coll[k].vert, momentum2, true);
 
   // find out which one is near and far
   SecondaryVertex svNear = sv1;
   SecondaryVertex svFar = sv2;
   GlobalVector momentumNear = momentum1;
   GlobalVector momentumFar = momentum2;
 
   // swap if it is the other way around
   if (sv1.dist3d().value() >= sv2.dist3d().value()) {
     svNear = sv2;
     svFar = sv1;
     momentumNear = momentum2;
     momentumFar = momentum1;
   }
   GlobalVector nearToFar = flightDirection(svNear, svFar);
   GlobalVector pvToNear = flightDirection(pv, svNear);
   GlobalVector pvToFar = flightDirection(pv, svFar);
 
   double cosPA = nearToFar.dot(momentumFar) / momentumFar.mag() / nearToFar.mag();
   double cosa = pvToNear.dot(momentumFar) / pvToNear.mag() / momentumFar.mag();
   double ptrel = sqrt(1.0 - cosa * cosa) * momentumFar.mag();
 
   double vertexDeltaR = Geom::deltaR(pvToNear, pvToFar);
 
   // create a set of all tracks from both vertices, avoid double counting by using a std::set<>
   std::set<reco::CandidatePtr> trackrefs;
   // first vertex
   for (size_t i = 0; i < sv1.numberOfSourceCandidatePtrs(); ++i)
     trackrefs.insert(sv1.daughterPtr(i));
   // second vertex
   for (size_t i = 0; i < sv2.numberOfSourceCandidatePtrs(); ++i)
     trackrefs.insert(sv2.daughterPtr(i));
 
   // now calculate one LorentzVector from the track momenta
   Candidate::LorentzVector mother;
   for (std::set<reco::CandidatePtr>::const_iterator it = trackrefs.begin(); it != trackrefs.end(); ++it) {
     Candidate::LorentzVector temp((*it)->px(), (*it)->py(), (*it)->pz(), ParticleMasses::piPlus);
     mother += temp;
   }
 
   //   check if criteria for merging are fulfilled
   if (vertexDeltaR < maxDRForUnique && mother.M() < maxvecSumIMCUTForUnique && cosPA > minCosPAtomerge &&
       std::abs(ptrel) < maxPtreltomerge) {
     // add tracks of second vertex which are missing to first vertex
     // loop over the second
     const std::vector<reco::CandidatePtr> &tracks1 = sv1.daughterPtrVector();
     const std::vector<reco::CandidatePtr> &tracks2 = sv2.daughterPtrVector();
     for (std::vector<reco::CandidatePtr>::const_iterator ti = tracks2.begin(); ti != tracks2.end(); ++ti) {
       std::vector<reco::CandidatePtr>::const_iterator it = find(tracks1.begin(), tracks1.end(), *ti);
       if (it == tracks1.end()) {
         coll[i].vert.addDaughter(*ti);
         coll[i].vert.setP4((*ti)->p4() + coll[i].vert.p4());
       }
     }
 
     // remove the second vertex from the collection
     coll.erase(coll.begin() + k);
   }
 }

Friends And Related Function Documentation

◆ operator<

template<typename VTX >

bool operator<	(	VertexProxy	v1,
		VertexProxy	v2
	)

friend

Definition at line 66 of file BtoCharmDecayVertexMerger.cc.

                                                         {
     if (v1.ntracks > 2 && v2.ntracks < 3)
       return true;
     if (v1.ntracks < 3 && v2.ntracks > 2)
       return false;
     return (v1.invm > v2.invm);
   }