Inheritance diagram for BtoCharmDecayVertexMergerT< VTX >:

Classes
struct	VertexProxy

Public Types
typedef reco::TemplatedSecondaryVertex< VTX >	SecondaryVertex

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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

VertexProxy	buildVertexProxy (const VTX &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<>

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

private

Definition at line 164 of file BtoCharmDecayVertexMerger.cc.

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

References extraflags_cff::vtx.

◆ buildVertexProxy() [2/3]

template<>

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

private

Definition at line 172 of file BtoCharmDecayVertexMerger.cc.

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

References extraflags_cff::vtx, and vtxP4().

◆ buildVertexProxy() [3/3]

template<typename VTX >

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

private

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

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

References reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::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.

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

References reco::LeafCandidate::vertex(), reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::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.

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

References reco::LeafCandidate::vertex().

◆ produce()

template<typename VTX >

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

override

Definition at line 98 of file BtoCharmDecayVertexMerger.cc.

                                                                                            {
   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>>());
   }
 }

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

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

                                                                                 {
   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);
   }
 }

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().

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

                                                                                                      {
   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);
   }
 }

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().

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