#include <PF_PU_AssoMapAlgos.h>

Inheritance diagram for PF_PU_AssoMapAlgos:

Public Member Functions
std::pair< std::unique_ptr < TrackToVertexAssMap > , std::unique_ptr < VertexToTrackAssMap > >	createMappings (edm::Handle< reco::TrackCollection > trkcollH)

std::unique_ptr < TrackToVertexAssMap >	CreateTrackToVertexMap (edm::Handle< reco::TrackCollection >)

std::unique_ptr < VertexToTrackAssMap >	CreateVertexToTrackMap (edm::Handle< reco::TrackCollection >)

virtual void	GetInputCollections (edm::Event &, const edm::EventSetup &)

	PF_PU_AssoMapAlgos (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC)

	PF_PU_AssoMapAlgos (const edm::ParameterSet &, edm::ConsumesCollector &)

std::unique_ptr < TrackToVertexAssMap >	SortAssociationMap (TrackToVertexAssMap *, edm::Handle< reco::TrackCollection >)

template<typename TREF >
VertexRef	TrackWeightAssociation (const TREF &trackRef, const std::vector< reco::VertexRef > &vtxcollV)

virtual	~PF_PU_AssoMapAlgos () noexcept(false)

Protected Member Functions
std::vector< reco::VertexRef >	CreateVertexVector (edm::Handle< reco::VertexCollection >)

int	DefineQuality (int, int, double)

void	EraseVertex (std::vector< reco::VertexRef > &, reco::VertexRef)

VertexStepPair	FindAssociation (const reco::TrackRef &, const std::vector< reco::VertexRef > &, edm::ESHandle< MagneticField >, edm::ESHandle< GlobalTrackingGeometry >, edm::Handle< reco::BeamSpot >, int)

Static Private Member Functions
static bool	ComesFromConversion (const reco::TrackRef, const reco::ConversionCollection &, reco::Conversion *)

static bool	ComesFromNI (const reco::TrackRef, const reco::PFDisplacedVertexCollection &, reco::PFDisplacedVertex *)

static bool	ComesFromV0Decay (const reco::TrackRef, const reco::VertexCompositeCandidateCollection &, const reco::VertexCompositeCandidateCollection &, reco::VertexCompositeCandidate *)

static double	dR (const math::XYZPoint &, const math::XYZVector &, edm::Handle< reco::BeamSpot >)

static reco::VertexRef	FindClosest3D (reco::TransientTrack, const std::vector< reco::VertexRef > &, double tWeight=0.)

static reco::VertexRef	FindClosestZ (const reco::TrackRef, const std::vector< reco::VertexRef > &, double tWeight=0.)

static reco::VertexRef	FindConversionVertex (const reco::TrackRef, const reco::Conversion &, edm::ESHandle< MagneticField >, edm::ESHandle< GlobalTrackingGeometry >, edm::Handle< reco::BeamSpot >, const std::vector< reco::VertexRef > &, double)

static reco::VertexRef	FindNIVertex (const reco::TrackRef, const reco::PFDisplacedVertex &, edm::ESHandle< MagneticField >, edm::ESHandle< GlobalTrackingGeometry >, edm::Handle< reco::BeamSpot >, const std::vector< reco::VertexRef > &, double)

static reco::VertexRef	FindV0Vertex (const reco::TrackRef, const reco::VertexCompositeCandidate &, edm::ESHandle< MagneticField >, edm::ESHandle< GlobalTrackingGeometry >, edm::Handle< reco::BeamSpot >, const std::vector< reco::VertexRef > &, double)

static std::unique_ptr < reco::ConversionCollection >	GetCleanedConversions (edm::Handle< reco::ConversionCollection >, edm::Handle< reco::BeamSpot >, bool)

static std::unique_ptr < reco::VertexCompositeCandidateCollection >	GetCleanedKshort (edm::Handle< reco::VertexCompositeCandidateCollection >, edm::Handle< reco::BeamSpot >, bool)

static std::unique_ptr < reco::VertexCompositeCandidateCollection >	GetCleanedLambda (edm::Handle< reco::VertexCompositeCandidateCollection >, edm::Handle< reco::BeamSpot >, bool)

static std::unique_ptr < reco::PFDisplacedVertexCollection >	GetCleanedNI (edm::Handle< reco::PFDisplacedVertexCollection >, edm::Handle< reco::BeamSpot >, bool)

template<typename TREF >
static reco::VertexRef	TrackWeightAssociation (const TREF &, const std::vector< reco::VertexRef > &)

Private Attributes
edm::Handle< reco::BeamSpot >	beamspotH

edm::ESHandle< MagneticField >	bFieldH

bool	cleanedColls_

std::unique_ptr < reco::ConversionCollection >	cleanedConvCollP

std::unique_ptr < reco::VertexCompositeCandidateCollection >	cleanedKshortCollP

std::unique_ptr < reco::VertexCompositeCandidateCollection >	cleanedLambdaCollP

std::unique_ptr < reco::PFDisplacedVertexCollection >	cleanedNICollP

edm::Handle < reco::ConversionCollection >	convCollH

edm::EDGetTokenT < reco::ConversionCollection >	ConversionsCollectionToken_

edm::Handle < reco::PFDisplacedVertexCollection >	displVertexCollH

bool	ignoremissingpfcollection_

bool	input_doReassociation_

int	input_FinalAssociation_

int	input_MaxNumAssociations_

double	input_nTrack_

edm::EDGetTokenT < reco::VertexCompositeCandidateCollection >	KshortCollectionToken_

edm::EDGetTokenT < reco::VertexCompositeCandidateCollection >	LambdaCollectionToken_

int	maxNumWarnings_

bool	missingColls

edm::EDGetTokenT < reco::PFDisplacedVertexCollection >	NIVertexCollectionToken_

int	numWarnings_

edm::EDGetTokenT< reco::BeamSpot >	token_BeamSpot_

const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	token_bField_

const edm::ESGetToken < GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	token_TrackingGeometry_

edm::EDGetTokenT < reco::VertexCollection >	token_VertexCollection_

edm::ESHandle < GlobalTrackingGeometry >	trackingGeometryH

edm::Handle < reco::VertexCompositeCandidateCollection >	vertCompCandCollKshortH

edm::Handle < reco::VertexCompositeCandidateCollection >	vertCompCandCollLambdaH

edm::Handle < reco::VertexCollection >	vtxcollH

Detailed Description

Definition at line 84 of file PF_PU_AssoMapAlgos.h.

Constructor & Destructor Documentation

PF_PU_AssoMapAlgos::PF_PU_AssoMapAlgos	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 87 of file PF_PU_AssoMapAlgos.h.

87 : PF_PU_AssoMapAlgos(iConfig, iC){};

PF_PU_AssoMapAlgos::PF_PU_AssoMapAlgos

PF_PU_AssoMapAlgos(const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC)

Definition: PF_PU_AssoMapAlgos.h:87

PF_PU_AssoMapAlgos::PF_PU_AssoMapAlgos	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &	iC
	)

Definition at line 27 of file PF_PU_AssoMapAlgos.cc.

References cleanedColls_, edm::ConsumesCollector::consumes(), ConversionsCollectionToken_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), ignoremissingpfcollection_, input_doReassociation_, input_FinalAssociation_, input_MaxNumAssociations_, input_nTrack_, KshortCollectionToken_, LambdaCollectionToken_, NIVertexCollectionToken_, token_BeamSpot_, and token_VertexCollection_.

     : token_bField_(iC.esConsumes()),
       token_TrackingGeometry_(iC.esConsumes()),
       maxNumWarnings_(3),
       numWarnings_(0)
 
 {
   input_MaxNumAssociations_ = iConfig.getParameter<int>("MaxNumberOfAssociations");
 
   token_VertexCollection_ = iC.consumes<VertexCollection>(iConfig.getParameter<InputTag>("VertexCollection"));
 
   token_BeamSpot_ = iC.consumes<BeamSpot>(iConfig.getParameter<InputTag>("BeamSpot"));
 
   input_doReassociation_ = iConfig.getParameter<bool>("doReassociation");
   cleanedColls_ = iConfig.getParameter<bool>("GetCleanedCollections");
 
   ConversionsCollectionToken_ =
       iC.consumes<ConversionCollection>(iConfig.getParameter<InputTag>("ConversionsCollection"));
 
   KshortCollectionToken_ =
       iC.consumes<VertexCompositeCandidateCollection>(iConfig.getParameter<InputTag>("V0KshortCollection"));
   LambdaCollectionToken_ =
       iC.consumes<VertexCompositeCandidateCollection>(iConfig.getParameter<InputTag>("V0LambdaCollection"));
 
   NIVertexCollectionToken_ =
       iC.consumes<PFDisplacedVertexCollection>(iConfig.getParameter<InputTag>("NIVertexCollection"));
 
   input_FinalAssociation_ = iConfig.getUntrackedParameter<int>("FinalAssociation", 0);
 
   ignoremissingpfcollection_ = iConfig.getParameter<bool>("ignoreMissingCollection");
 
   input_nTrack_ = iConfig.getParameter<double>("nTrackWeight");
 }

virtual PF_PU_AssoMapAlgos::~PF_PU_AssoMapAlgos ( )

inlinevirtualnoexcept

Definition at line 90 of file PF_PU_AssoMapAlgos.h.

90 {};

Member Function Documentation

bool PF_PU_AssoMapAlgos::ComesFromConversion	(	const reco::TrackRef	trackref,
		const reco::ConversionCollection &	cleanedConvColl,
		reco::Conversion *	gamma
	)

staticprivate

Definition at line 399 of file PF_PU_AssoMapAlgos.cc.

References ConversionTools::matchesConversion().

Referenced by FindAssociation().

                                                                 {
   for (unsigned int convcoll_ite = 0; convcoll_ite < cleanedConvColl.size(); convcoll_ite++) {
     if (ConversionTools::matchesConversion(trackref, cleanedConvColl.at(convcoll_ite))) {
       *gamma = cleanedConvColl.at(convcoll_ite);
       return true;
     }
   }
 
   return false;
 }

bool PF_PU_AssoMapAlgos::ComesFromNI	(	const reco::TrackRef	trackref,
		const reco::PFDisplacedVertexCollection &	cleanedNI,
		reco::PFDisplacedVertex *	displVtx
	)

staticprivate

Definition at line 638 of file PF_PU_AssoMapAlgos.cc.

Referenced by FindAssociation().

                                                                   {
   //the part for the reassociation of particles from nuclear interactions
   for (PFDisplacedVertexCollection::const_iterator iDisplV = cleanedNI.begin(); iDisplV != cleanedNI.end(); iDisplV++) {
     if (iDisplV->trackWeight(trackref) > 1.e-5) {
       *displVtx = *iDisplV;
       return true;
     }
   }
 
   return false;
 }

bool PF_PU_AssoMapAlgos::ComesFromV0Decay	(	const reco::TrackRef	trackref,
		const reco::VertexCompositeCandidateCollection &	cleanedKshort,
		const reco::VertexCompositeCandidateCollection &	cleanedLambda,
		reco::VertexCompositeCandidate *	V0
	)

staticprivate

Definition at line 533 of file PF_PU_AssoMapAlgos.cc.

References reco::RecoChargedCandidate::track().

Referenced by FindAssociation().

                                                                         {
   //the part for the reassociation of particles from Kshort decays
   for (VertexCompositeCandidateCollection::const_iterator iKS = cleanedKshort.begin(); iKS != cleanedKshort.end();
        iKS++) {
     const RecoChargedCandidate* dauCand1 = dynamic_cast<const RecoChargedCandidate*>(iKS->daughter(0));
     TrackRef dauTk1 = dauCand1->track();
     const RecoChargedCandidate* dauCand2 = dynamic_cast<const RecoChargedCandidate*>(iKS->daughter(1));
     TrackRef dauTk2 = dauCand2->track();
 
     if ((trackref == dauTk1) || (trackref == dauTk2)) {
       *V0 = *iKS;
       return true;
     }
   }
 
   //the part for the reassociation of particles from Lambda decays
   for (VertexCompositeCandidateCollection::const_iterator iLambda = cleanedLambda.begin();
        iLambda != cleanedLambda.end();
        iLambda++) {
     const RecoChargedCandidate* dauCand1 = dynamic_cast<const RecoChargedCandidate*>(iLambda->daughter(0));
     TrackRef dauTk1 = dauCand1->track();
     const RecoChargedCandidate* dauCand2 = dynamic_cast<const RecoChargedCandidate*>(iLambda->daughter(1));
     TrackRef dauTk2 = dauCand2->track();
 
     if ((trackref == dauTk1) || (trackref == dauTk2)) {
       *V0 = *iLambda;
       return true;
     }
   }
 
   return false;
 }

std::pair< std::unique_ptr< TrackToVertexAssMap >, std::unique_ptr< VertexToTrackAssMap > > PF_PU_AssoMapAlgos::createMappings ( edm::Handle< reco::TrackCollection > trkcollH )

Definition at line 109 of file PF_PU_AssoMapAlgos.cc.

References IPTools::absoluteImpactParameter3D(), beamspotH, bFieldH, CreateVertexVector(), DefineQuality(), HLT_FULL_cff::distance, EraseVertex(), FindAssociation(), input_MaxNumAssociations_, eostools::move(), quality, edm::second(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setTrackingGeometry(), trackingGeometryH, and vtxcollH.

Referenced by CreateTrackToVertexMap(), CreateVertexToTrackMap(), and PF_PU_AssoMap::produce().

                                                                           {
   unique_ptr<TrackToVertexAssMap> track2vertex(new TrackToVertexAssMap(vtxcollH, trkcollH));
   unique_ptr<VertexToTrackAssMap> vertex2track(new VertexToTrackAssMap(trkcollH, vtxcollH));
 
   int num_vertices = vtxcollH->size();
   if (num_vertices < input_MaxNumAssociations_)
     input_MaxNumAssociations_ = num_vertices;
   vector<VertexRef> vtxColl_help;
   if (input_MaxNumAssociations_ == 1)
     vtxColl_help = CreateVertexVector(vtxcollH);
 
   //loop over all tracks of the track collection
   for (size_t idxTrack = 0; idxTrack < trkcollH->size(); ++idxTrack) {
     TrackRef trackref = TrackRef(trkcollH, idxTrack);
 
     TransientTrack transtrk(trackref, &(*bFieldH));
     transtrk.setBeamSpot(*beamspotH);
     transtrk.setTrackingGeometry(trackingGeometryH);
 
     if (input_MaxNumAssociations_ > 1)
       vtxColl_help = CreateVertexVector(vtxcollH);
 
     for (int assoc_ite = 0; assoc_ite < input_MaxNumAssociations_; ++assoc_ite) {
       VertexStepPair assocVtx =
           FindAssociation(trackref, vtxColl_help, bFieldH, trackingGeometryH, beamspotH, assoc_ite);
       int step = assocVtx.second;
       double distance = (IPTools::absoluteImpactParameter3D(transtrk, *(assocVtx.first))).second.value();
 
       int quality = DefineQuality(assoc_ite, step, distance);
 
       //std::cout << "associating track: Pt = " << trackref->pt() << ","
       //          << " eta = " << trackref->eta() << ", phi = " << trackref->phi()
       //          << " to vertex: z = " << associatedVertex.first->position().z() << " with quality q = " << quality << std::endl;
 
       // Insert the best vertex and the pair of track and the quality of this association in the map
       track2vertex->insert(assocVtx.first, make_pair(trackref, quality));
       vertex2track->insert(trackref, make_pair(assocVtx.first, quality));
 
       //cleanup only if multiple iterations are made
       if (input_MaxNumAssociations_ > 1)
         PF_PU_AssoMapAlgos::EraseVertex(vtxColl_help, assocVtx.first);
     }
   }
 
   return {std::move(track2vertex), std::move(vertex2track)};
 }

std::unique_ptr< TrackToVertexAssMap > PF_PU_AssoMapAlgos::CreateTrackToVertexMap ( edm::Handle< reco::TrackCollection > trkcollH )

Definition at line 160 of file PF_PU_AssoMapAlgos.cc.

References createMappings().

                                              {
   return createMappings(trkcollH).first;
 }

std::unique_ptr< VertexToTrackAssMap > PF_PU_AssoMapAlgos::CreateVertexToTrackMap ( edm::Handle< reco::TrackCollection > trkcollH )

Definition at line 169 of file PF_PU_AssoMapAlgos.cc.

References createMappings().

                                              {
   return createMappings(trkcollH).second;
 }

std::vector< reco::VertexRef > PF_PU_AssoMapAlgos::CreateVertexVector ( edm::Handle< reco::VertexCollection > vtxcollH )

protected

Definition at line 256 of file PF_PU_AssoMapAlgos.cc.

References mps_fire::i, and convertSQLitetoXML_cfg::output.

Referenced by PFCand_AssoMapAlgos::createMappings(), and createMappings().

                                                                                                         {
   vector<VertexRef> output;
   output.reserve(vtxcollH->size());
   auto const nVtx = vtxcollH->size();
   for (unsigned int i = 0; i < nVtx; ++i)
     output.emplace_back(vtxcollH, i);
 
   return output;
 }

int PF_PU_AssoMapAlgos::DefineQuality	(	int	assoc_ite,
		int	step,
		double	distance
	)

protected

Definition at line 819 of file PF_PU_AssoMapAlgos.cc.

References fin_50, fin_70, quality, sec_50, sec_70, tw_50, tw_70, and tw_90.

Referenced by PFCand_AssoMapAlgos::createMappings(), and createMappings().

                                                                               {
   int quality = 0;
 
   switch (step) {
     case 0: {
       //TrackWeight association
       if (distance <= tw_90) {
         quality = 5;
       } else {
         if (distance <= tw_70) {
           quality = 4;
         } else {
           if (distance <= tw_50) {
             quality = 3;
           } else {
             quality = 2;
           }
         }
       }
       break;
     }
 
     case 1: {
       //Secondary association
       if (distance <= sec_70) {
         quality = 4;
       } else {
         if (distance <= sec_50) {
           quality = 3;
         } else {
           quality = 2;
         }
       }
       break;
     }
 
     case 2: {
       //Final association
       if (assoc_ite == 1) {
         quality = 1;
       } else {
         if (assoc_ite >= 2) {
           quality = 0;
         } else {
           if (distance <= fin_70) {
             quality = 4;
           } else {
             if (distance <= fin_50) {
               quality = 3;
             } else {
               quality = 2;
             }
           }
         }
       }
       break;
     }
 
     default: {
       quality = -1;
       break;
     }
   }
 
   return quality;
 }

double PF_PU_AssoMapAlgos::dR	(	const math::XYZPoint &	vtx_pos,
		const math::XYZVector &	vtx_mom,
		edm::Handle< reco::BeamSpot >	bsH
	)

staticprivate

Definition at line 351 of file PF_PU_AssoMapAlgos.cc.

References HLT_FULL_cff::deltaR, log, mathSSE::sqrt(), and funct::tan().

Referenced by GetCleanedKshort(), GetCleanedLambda(), and GetCleanedNI().

                                                            {
   double bs_x = bsH->x0();
   double bs_y = bsH->y0();
   double bs_z = bsH->z0();
 
   double connVec_x = vtx_pos.x() - bs_x;
   double connVec_y = vtx_pos.y() - bs_y;
   double connVec_z = vtx_pos.z() - bs_z;
 
   double connVec_r = sqrt(connVec_x * connVec_x + connVec_y * connVec_y + connVec_z * connVec_z);
   double connVec_theta = acos(connVec_z * 1. / connVec_r);
 
   double connVec_eta = -1. * log(tan(connVec_theta * 1. / 2.));
   double connVec_phi = atan2(connVec_y, connVec_x);
 
   return deltaR(vtx_mom.eta(), vtx_mom.phi(), connVec_eta, connVec_phi);
 }

void PF_PU_AssoMapAlgos::EraseVertex	(	std::vector< reco::VertexRef > &	vtxcollV,
		reco::VertexRef	toErase
	)

protected

Definition at line 270 of file PF_PU_AssoMapAlgos.cc.

Referenced by PFCand_AssoMapAlgos::createMappings(), and createMappings().

                                                                                               {
   for (unsigned int index_vtx = 0; index_vtx < vtxcollV.size(); ++index_vtx) {
     VertexRef vertexref = vtxcollV.at(index_vtx);
 
     if (vertexref == toErase) {
       vtxcollV.erase(vtxcollV.begin() + index_vtx);
       break;
     }
   }
 }

VertexStepPair PF_PU_AssoMapAlgos::FindAssociation	(	const reco::TrackRef &	trackref,
		const std::vector< reco::VertexRef > &	vtxColl,
		edm::ESHandle< MagneticField >	bfH,
		edm::ESHandle< GlobalTrackingGeometry >	tgH,
		edm::Handle< reco::BeamSpot >	bsH,
		int	assocNum
	)

protected

Definition at line 726 of file PF_PU_AssoMapAlgos.cc.

References cleanedConvCollP, cleanedKshortCollP, cleanedLambdaCollP, cleanedNICollP, ComesFromConversion(), ComesFromNI(), ComesFromV0Decay(), FindClosest3D(), FindClosestZ(), FindConversionVertex(), FindNIVertex(), FindV0Vertex(), input_doReassociation_, input_FinalAssociation_, input_nTrack_, missingColls, reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setTrackingGeometry(), trackingGeometryH, and TrackWeightAssociation().

Referenced by PFCand_AssoMapAlgos::createMappings(), and createMappings().

                                                                  {
   VertexRef foundVertex;
 
   //if it is not the first try of an association jump to the final association
   //to avoid multiple (secondary) associations and/or unphysical (primary and secondary) associations
   if (assocNum > 0)
     goto finalStep;
 
   // Step 1: First round of association:
   // Find the vertex with the highest track-to-vertex association weight
   foundVertex = TrackWeightAssociation(trackref, vtxColl);
 
   if (foundVertex->trackWeight(trackref) >= 1.e-5) {
     return make_pair(foundVertex, 0.);
   }
 
   // Step 2: Reassociation
   // Second round of association:
   // In case no vertex with track-to-vertex association weight > 1.e-5 is found,
   // check the track originates from a neutral hadron decay, photon conversion or nuclear interaction
 
   if (input_doReassociation_) {
     // Test if the track comes from a photon conversion:
     // If so, try to find the vertex of the mother particle
     Conversion gamma;
     if (ComesFromConversion(trackref, *cleanedConvCollP, &gamma)) {
       foundVertex = FindConversionVertex(trackref, gamma, bfH, tgH, bsH, vtxColl, input_nTrack_);
       return make_pair(foundVertex, 1.);
     }
 
     // Test if the track comes from a Kshort or Lambda decay:
     // If so, reassociate the track to the vertex of the V0
     VertexCompositeCandidate V0;
     if (ComesFromV0Decay(trackref, *cleanedKshortCollP, *cleanedLambdaCollP, &V0)) {
       foundVertex = FindV0Vertex(trackref, V0, bfH, tgH, bsH, vtxColl, input_nTrack_);
       return make_pair(foundVertex, 1.);
     }
 
     if (!missingColls) {
       // Test if the track comes from a nuclear interaction:
       // If so, reassociate the track to the vertex of the incoming particle
       PFDisplacedVertex displVtx;
       if (ComesFromNI(trackref, *cleanedNICollP, &displVtx)) {
         foundVertex = FindNIVertex(trackref, displVtx, bfH, tgH, bsH, vtxColl, input_nTrack_);
         return make_pair(foundVertex, 1.);
       }
     }
   }
 
   // Step 3: Final association
   // If no vertex is found with track-to-vertex association weight > 1.e-5
   // and no reassociation was done do the final association
   // look for the closest vertex in 3D or in z/longitudinal distance
   // or associate the track always to the first vertex (default)
 
 finalStep:
 
   switch (input_FinalAssociation_) {
     case 1: {
       // closest in z
       foundVertex = FindClosestZ(trackref, vtxColl, input_nTrack_);
       break;
     }
 
     case 2: {
       // closest in 3D
       TransientTrack transtrk(trackref, &(*bfH));
       transtrk.setBeamSpot(*bsH);
       transtrk.setTrackingGeometry(trackingGeometryH);
 
       foundVertex = FindClosest3D(transtrk, vtxColl, input_nTrack_);
       break;
     }
 
     default: {
       // allways first vertex
       foundVertex = vtxColl.at(0);
       break;
     }
   }
 
   return make_pair(foundVertex, 2.);
 }

VertexRef PF_PU_AssoMapAlgos::FindClosest3D	(	reco::TransientTrack	transtrk,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight = `0.`
	)

staticprivate

Definition at line 317 of file PF_PU_AssoMapAlgos.cc.

References IPTools::absoluteImpactParameter3D(), HLT_FULL_cff::distance, BeamSpotPI::nTracks, and mathSSE::sqrt().

Referenced by FindAssociation(), FindConversionVertex(), FindNIVertex(), and FindV0Vertex().

                                                             {
   VertexRef foundVertexRef = vtxcollV.at(0);
 
   double d3min = 1e5;
 
   //loop over all vertices with a good quality in the vertex collection
   for (unsigned int index_vtx = 0; index_vtx < vtxcollV.size(); ++index_vtx) {
     VertexRef vertexref = vtxcollV.at(index_vtx);
 
     double nTracks = sqrt(vertexref->tracksSize());
 
     double distance = 1e5;
     pair<bool, Measurement1D> IpPair = IPTools::absoluteImpactParameter3D(transtrk, *vertexref);
 
     if (IpPair.first)
       distance = IpPair.second.value();
 
     double weightedDistance = distance - tWeight * nTracks;
 
     if (weightedDistance < d3min) {
       d3min = weightedDistance;
       foundVertexRef = vertexref;
     }
   }
 
   return foundVertexRef;
 }

VertexRef PF_PU_AssoMapAlgos::FindClosestZ	(	const reco::TrackRef	trkref,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight = `0.`
	)

staticprivate

Definition at line 285 of file PF_PU_AssoMapAlgos.cc.

References BeamSpotPI::nTracks, and mathSSE::sqrt().

Referenced by FindAssociation().

                                                            {
   double ztrack = trkref->vertex().z();
 
   VertexRef foundVertexRef = vtxcollV.at(0);
 
   double dzmin = 1e5;
 
   //loop over all vertices with a good quality in the vertex collection
   for (unsigned int index_vtx = 0; index_vtx < vtxcollV.size(); ++index_vtx) {
     VertexRef vertexref = vtxcollV.at(index_vtx);
 
     double nTracks = sqrt(vertexref->tracksSize());
 
     double z_distance = fabs(ztrack - vertexref->z());
 
     double weightedDistance = z_distance - tWeight * nTracks;
 
     if (weightedDistance < dzmin) {
       dzmin = weightedDistance;
       foundVertexRef = vertexref;
     }
   }
 
   return foundVertexRef;
 }

VertexRef PF_PU_AssoMapAlgos::FindConversionVertex	(	const reco::TrackRef	trackref,
		const reco::Conversion &	gamma,
		edm::ESHandle< MagneticField >	bfH,
		edm::ESHandle< GlobalTrackingGeometry >	tgH,
		edm::Handle< reco::BeamSpot >	bsH,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 416 of file PF_PU_AssoMapAlgos.cc.

References reco::Conversion::conversionVertex(), FindClosest3D(), reco::Vertex::position(), and reco::Conversion::refittedPair4Momentum().

Referenced by FindAssociation().

                                                                    {
   math::XYZPoint conv_pos = gamma.conversionVertex().position();
 
   math::XYZVector conv_mom(
       gamma.refittedPair4Momentum().x(), gamma.refittedPair4Momentum().y(), gamma.refittedPair4Momentum().z());
 
   Track photon(trackref->chi2(), trackref->ndof(), conv_pos, conv_mom, 0, trackref->covariance());
 
   TransientTrack transpho(photon, &(*bfH));
   transpho.setBeamSpot(*bsH);
   transpho.setTrackingGeometry(tgH);
 
   return FindClosest3D(transpho, vtxcollV, tWeight);
 }

VertexRef PF_PU_AssoMapAlgos::FindNIVertex	(	const reco::TrackRef	trackref,
		const reco::PFDisplacedVertex &	displVtx,
		edm::ESHandle< MagneticField >	bFieldH,
		edm::ESHandle< GlobalTrackingGeometry >	trackingGeometryH,
		edm::Handle< reco::BeamSpot >	bsH,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 656 of file PF_PU_AssoMapAlgos.cc.

References FindClosest3D(), reco::PFDisplacedVertex::isIncomingTrack(), reco::PFDisplacedVertex::isThereMergedTracks(), reco::PFDisplacedVertex::isTherePrimaryTracks(), reco::Vertex::originalTrack(), reco::Vertex::position(), reco::PFDisplacedVertex::primaryMomentum(), tkAlTrackRefitSequence_cff::refittedTracks, reco::Vertex::refittedTracks(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setTrackingGeometry(), and TrackWeightAssociation().

Referenced by FindAssociation().

                                                            {
   TrackCollection refittedTracks = displVtx.refittedTracks();
 
   if ((displVtx.isTherePrimaryTracks()) || (displVtx.isThereMergedTracks())) {
     for (TrackCollection::const_iterator trkcoll_ite = refittedTracks.begin(); trkcoll_ite != refittedTracks.end();
          trkcoll_ite++) {
       const TrackBaseRef retrackbaseref = displVtx.originalTrack(*trkcoll_ite);
 
       if (displVtx.isIncomingTrack(retrackbaseref)) {
         VertexRef VOAssociation = TrackWeightAssociation(retrackbaseref, vtxcollV);
 
         if (VOAssociation->trackWeight(retrackbaseref) >= 1.e-5) {
           return VOAssociation;
         }
 
         TransientTrack transIncom(*retrackbaseref, &(*bFieldH));
         transIncom.setBeamSpot(*bsH);
         transIncom.setTrackingGeometry(trackingGeometryH);
 
         return FindClosest3D(transIncom, vtxcollV, tWeight);
       }
     }
   }
 
   const math::XYZPoint& ni_pos = displVtx.position();
 
   math::XYZVector ni_mom(
       displVtx.primaryMomentum().x(), displVtx.primaryMomentum().y(), displVtx.primaryMomentum().z());
 
   Track incom(trackref->chi2(), trackref->ndof(), ni_pos, ni_mom, 0, trackref->covariance());
 
   TransientTrack transIncom(incom, &(*bFieldH));
   transIncom.setBeamSpot(*bsH);
   transIncom.setTrackingGeometry(trackingGeometryH);
 
   return FindClosest3D(transIncom, vtxcollV, tWeight);
 }

VertexRef PF_PU_AssoMapAlgos::FindV0Vertex	(	const reco::TrackRef	trackref,
		const reco::VertexCompositeCandidate &	V0_vtx,
		edm::ESHandle< MagneticField >	bFieldH,
		edm::ESHandle< GlobalTrackingGeometry >	trackingGeometryH,
		edm::Handle< reco::BeamSpot >	bsH,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 573 of file PF_PU_AssoMapAlgos.cc.

References FindClosest3D(), reco::LeafCandidate::momentum(), and reco::LeafCandidate::vertex().

Referenced by FindAssociation().

                                                            {
   const math::XYZPoint& dec_pos = V0_vtx.vertex();
 
   math::XYZVector dec_mom(V0_vtx.momentum().x(), V0_vtx.momentum().y(), V0_vtx.momentum().z());
 
   Track V0(trackref->chi2(), trackref->ndof(), dec_pos, dec_mom, 0, trackref->covariance());
 
   TransientTrack transV0(V0, &(*bFieldH));
   transV0.setBeamSpot(*bsH);
   transV0.setTrackingGeometry(trackingGeometryH);
 
   return FindClosest3D(transV0, vtxcollV, tWeight);
 }

unique_ptr< ConversionCollection > PF_PU_AssoMapAlgos::GetCleanedConversions	(	edm::Handle< reco::ConversionCollection >	convCollH,
		edm::Handle< reco::BeamSpot >	bsH,
		bool	cleanedColl
	)

staticprivate

Definition at line 375 of file PF_PU_AssoMapAlgos.cc.

Referenced by GetInputCollections().

                                                                                            {
   unique_ptr<ConversionCollection> cleanedConvColl(new ConversionCollection());
 
   for (unsigned int convcoll_idx = 0; convcoll_idx < convCollH->size(); convcoll_idx++) {
     ConversionRef convref(convCollH, convcoll_idx);
 
     if (!cleanedColl) {
       cleanedConvColl->push_back(*convref);
       continue;
     }
 
     if ((convref->nTracks() == 2) && (fabs(convref->pairInvariantMass()) <= 0.1)) {
       cleanedConvColl->push_back(*convref);
     }
   }
 
   return cleanedConvColl;
 }

unique_ptr< VertexCompositeCandidateCollection > PF_PU_AssoMapAlgos::GetCleanedKshort	(	edm::Handle< reco::VertexCompositeCandidateCollection >	KshortsH,
		edm::Handle< reco::BeamSpot >	bsH,
		bool	cleanedColl
	)

staticprivate

Definition at line 441 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), VertexDistance3D::distance(), dR(), and kMass.

Referenced by GetInputCollections().

                                                                                                  {
   unique_ptr<VertexCompositeCandidateCollection> cleanedKaonColl(new VertexCompositeCandidateCollection());
 
   for (unsigned int kscoll_idx = 0; kscoll_idx < KshortsH->size(); kscoll_idx++) {
     VertexCompositeCandidateRef ksref(KshortsH, kscoll_idx);
 
     if (!cleanedColl) {
       cleanedKaonColl->push_back(*ksref);
       continue;
     }
 
     VertexDistance3D distanceComputer;
 
     GlobalPoint dec_pos = RecoVertex::convertPos(ksref->vertex());
 
     GlobalError decayVertexError = GlobalError(ksref->vertexCovariance(0, 0),
                                                ksref->vertexCovariance(0, 1),
                                                ksref->vertexCovariance(1, 1),
                                                ksref->vertexCovariance(0, 2),
                                                ksref->vertexCovariance(1, 2),
                                                ksref->vertexCovariance(2, 2));
 
     math::XYZVector dec_mom(ksref->momentum().x(), ksref->momentum().y(), ksref->momentum().z());
 
     GlobalPoint bsPosition = RecoVertex::convertPos(bsH->position());
     GlobalError bsError = RecoVertex::convertError(bsH->covariance3D());
 
     double kaon_significance =
         (distanceComputer.distance(VertexState(bsPosition, bsError), VertexState(dec_pos, decayVertexError)))
             .significance();
 
     if ((ksref->vertex().rho() >= 3.) && (ksref->vertexNormalizedChi2() <= 3.) &&
         (fabs(ksref->mass() - kMass) <= 0.01) && (kaon_significance > 15.) &&
         (PF_PU_AssoMapAlgos::dR(ksref->vertex(), dec_mom, bsH) <= 0.3)) {
       cleanedKaonColl->push_back(*ksref);
     }
   }
 
   return cleanedKaonColl;
 }

unique_ptr< VertexCompositeCandidateCollection > PF_PU_AssoMapAlgos::GetCleanedLambda	(	edm::Handle< reco::VertexCompositeCandidateCollection >	LambdasH,
		edm::Handle< reco::BeamSpot >	bsH,
		bool	cleanedColl
	)

staticprivate

Definition at line 487 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), VertexDistance3D::distance(), dR(), and lamMass.

Referenced by GetInputCollections().

                                                                                                  {
   unique_ptr<VertexCompositeCandidateCollection> cleanedLambdaColl(new VertexCompositeCandidateCollection());
 
   for (unsigned int lambdacoll_idx = 0; lambdacoll_idx < LambdasH->size(); lambdacoll_idx++) {
     VertexCompositeCandidateRef lambdaref(LambdasH, lambdacoll_idx);
 
     if (!cleanedColl) {
       cleanedLambdaColl->push_back(*lambdaref);
       continue;
     }
 
     VertexDistance3D distanceComputer;
 
     GlobalPoint dec_pos = RecoVertex::convertPos(lambdaref->vertex());
 
     GlobalError decayVertexError = GlobalError(lambdaref->vertexCovariance(0, 0),
                                                lambdaref->vertexCovariance(0, 1),
                                                lambdaref->vertexCovariance(1, 1),
                                                lambdaref->vertexCovariance(0, 2),
                                                lambdaref->vertexCovariance(1, 2),
                                                lambdaref->vertexCovariance(2, 2));
 
     math::XYZVector dec_mom(lambdaref->momentum().x(), lambdaref->momentum().y(), lambdaref->momentum().z());
 
     GlobalPoint bsPosition = RecoVertex::convertPos(bsH->position());
     GlobalError bsError = RecoVertex::convertError(bsH->covariance3D());
 
     double lambda_significance =
         (distanceComputer.distance(VertexState(bsPosition, bsError), VertexState(dec_pos, decayVertexError)))
             .significance();
 
     if ((lambdaref->vertex().rho() >= 3.) && (lambdaref->vertexNormalizedChi2() <= 3.) &&
         (fabs(lambdaref->mass() - lamMass) <= 0.005) && (lambda_significance > 15.) &&
         (PF_PU_AssoMapAlgos::dR(lambdaref->vertex(), dec_mom, bsH) <= 0.3)) {
       cleanedLambdaColl->push_back(*lambdaref);
     }
   }
 
   return cleanedLambdaColl;
 }

unique_ptr< PFDisplacedVertexCollection > PF_PU_AssoMapAlgos::GetCleanedNI	(	edm::Handle< reco::PFDisplacedVertexCollection >	NuclIntH,
		edm::Handle< reco::BeamSpot >	bsH,
		bool	cleanedColl
	)

staticprivate

Definition at line 597 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), VertexDistance3D::distance(), and dR().

Referenced by GetInputCollections().

                                                                                            {
   unique_ptr<PFDisplacedVertexCollection> cleanedNIColl(new PFDisplacedVertexCollection());
 
   for (PFDisplacedVertexCollection::const_iterator niref = NuclIntH->begin(); niref != NuclIntH->end(); niref++) {
     if ((niref->isFake()) || !(niref->isNucl()))
       continue;
 
     if (!cleanedColl) {
       cleanedNIColl->push_back(*niref);
       continue;
     }
 
     VertexDistance3D distanceComputer;
 
     GlobalPoint ni_pos = RecoVertex::convertPos(niref->position());
     GlobalError interactionVertexError = RecoVertex::convertError(niref->error());
 
     math::XYZVector ni_mom(niref->primaryMomentum().x(), niref->primaryMomentum().y(), niref->primaryMomentum().z());
 
     GlobalPoint bsPosition = RecoVertex::convertPos(bsH->position());
     GlobalError bsError = RecoVertex::convertError(bsH->covariance3D());
 
     double nuclint_significance =
         (distanceComputer.distance(VertexState(bsPosition, bsError), VertexState(ni_pos, interactionVertexError)))
             .significance();
 
     if ((niref->position().rho() >= 3.) && (nuclint_significance > 15.) &&
         (PF_PU_AssoMapAlgos::dR(niref->position(), ni_mom, bsH) <= 0.3)) {
       cleanedNIColl->push_back(*niref);
     }
   }
 
   return cleanedNIColl;
 }

void PF_PU_AssoMapAlgos::GetInputCollections	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

virtual

Reimplemented in PFCand_AssoMapAlgos.

Definition at line 65 of file PF_PU_AssoMapAlgos.cc.

References beamspotH, bFieldH, cleanedColls_, cleanedConvCollP, cleanedKshortCollP, cleanedLambdaCollP, cleanedNICollP, convCollH, ConversionsCollectionToken_, displVertexCollH, edm::Event::getByToken(), GetCleanedConversions(), GetCleanedKshort(), GetCleanedLambda(), GetCleanedNI(), edm::EventSetup::getHandle(), ignoremissingpfcollection_, KshortCollectionToken_, LambdaCollectionToken_, maxNumWarnings_, missingColls, NIVertexCollectionToken_, numWarnings_, token_BeamSpot_, token_bField_, token_TrackingGeometry_, token_VertexCollection_, trackingGeometryH, vertCompCandCollKshortH, vertCompCandCollLambdaH, and vtxcollH.

Referenced by PFCand_AssoMapAlgos::GetInputCollections(), and PF_PU_AssoMap::produce().

                                                                                           {
   //get the offline beam spot
   iEvent.getByToken(token_BeamSpot_, beamspotH);
 
   //get the conversion collection for the gamma conversions
   iEvent.getByToken(ConversionsCollectionToken_, convCollH);
   cleanedConvCollP = PF_PU_AssoMapAlgos::GetCleanedConversions(convCollH, beamspotH, cleanedColls_);
 
   //get the vertex composite candidate collection for the Kshort's
   iEvent.getByToken(KshortCollectionToken_, vertCompCandCollKshortH);
   cleanedKshortCollP = PF_PU_AssoMapAlgos::GetCleanedKshort(vertCompCandCollKshortH, beamspotH, cleanedColls_);
 
   //get the vertex composite candidate collection for the Lambda's
   iEvent.getByToken(LambdaCollectionToken_, vertCompCandCollLambdaH);
   cleanedLambdaCollP = PF_PU_AssoMapAlgos::GetCleanedLambda(vertCompCandCollLambdaH, beamspotH, cleanedColls_);
 
   //get the displaced vertex collection for nuclear interactions
   //create a new bool, true if no displaced vertex collection is in the event, mostly for AOD
   missingColls = false;
   if (!iEvent.getByToken(NIVertexCollectionToken_, displVertexCollH)) {
     if (ignoremissingpfcollection_) {
       missingColls = true;
 
       if (numWarnings_ < maxNumWarnings_) {
         LogWarning("PF_PU_AssoMapAlgos::GetInputCollections")
             << "No Extra objects available in input file --> skipping reconstruction of displaced vertices !!" << endl;
         ++numWarnings_;
       }
     }
   } else {
     cleanedNICollP = PF_PU_AssoMapAlgos::GetCleanedNI(displVertexCollH, beamspotH, true);
   }
 
   //get the input vertex collection
   iEvent.getByToken(token_VertexCollection_, vtxcollH);
 
   bFieldH = iSetup.getHandle(token_bField_);
   trackingGeometryH = iSetup.getHandle(token_TrackingGeometry_);
 }

unique_ptr< TrackToVertexAssMap > PF_PU_AssoMapAlgos::SortAssociationMap	(	TrackToVertexAssMap *	trackvertexassInput,
		edm::Handle< reco::TrackCollection >	trkcollH
	)

Definition at line 178 of file PF_PU_AssoMapAlgos.cc.

References edm::AssociationMap< Tag >::begin(), edm::AssociationMap< Tag >::end(), edm::Ref< C, T, F >::key(), quality, edm::second(), and vtxcollH.

Referenced by PF_PU_AssoMap::produce().

                                                                                                                 {
   //create a new TrackVertexAssMap for the Output which will be sorted
   unique_ptr<TrackToVertexAssMap> trackvertexassOutput(new TrackToVertexAssMap(vtxcollH, trkcollH));
 
   //Create and fill a vector of pairs of vertex and the summed (pT-pT_Error)**2 of the tracks associated to the vertex
   VertexPtsumVector vertexptsumvector;
 
   //loop over all vertices in the association map
   for (TrackToVertexAssMap::const_iterator assomap_ite = trackvertexassInput->begin();
        assomap_ite != trackvertexassInput->end();
        assomap_ite++) {
     const VertexRef assomap_vertexref = assomap_ite->key;
     const TrackQualityPairVector trckcoll = assomap_ite->val;
 
     float ptsum = 0;
 
     TrackRef trackref;
 
     //get the tracks associated to the vertex and calculate the manipulated pT**2
     for (unsigned int trckcoll_ite = 0; trckcoll_ite < trckcoll.size(); trckcoll_ite++) {
       trackref = trckcoll[trckcoll_ite].first;
       int quality = trckcoll[trckcoll_ite].second;
 
       if (quality <= 2)
         continue;
 
       double man_pT = trackref->pt() - trackref->ptError();
       if (man_pT > 0.)
         ptsum += man_pT * man_pT;
     }
 
     vertexptsumvector.push_back(make_pair(assomap_vertexref, ptsum));
   }
 
   while (!vertexptsumvector.empty()) {
     VertexRef vertexref_highestpT;
     float highestpT = 0.;
     int highestpT_index = 0;
 
     for (unsigned int vtxptsumvec_ite = 0; vtxptsumvec_ite < vertexptsumvector.size(); vtxptsumvec_ite++) {
       if (vertexptsumvector[vtxptsumvec_ite].second > highestpT) {
         vertexref_highestpT = vertexptsumvector[vtxptsumvec_ite].first;
         highestpT = vertexptsumvector[vtxptsumvec_ite].second;
         highestpT_index = vtxptsumvec_ite;
       }
     }
 
     //loop over all vertices in the association map
     for (TrackToVertexAssMap::const_iterator assomap_ite = trackvertexassInput->begin();
          assomap_ite != trackvertexassInput->end();
          assomap_ite++) {
       const VertexRef assomap_vertexref = assomap_ite->key;
       const TrackQualityPairVector trckcoll = assomap_ite->val;
 
       //if the vertex from the association map the vertex with the highest manipulated pT
       //insert all associated tracks in the output Association Map
       if (assomap_vertexref == vertexref_highestpT)
         for (unsigned int trckcoll_ite = 0; trckcoll_ite < trckcoll.size(); trckcoll_ite++)
           trackvertexassOutput->insert(assomap_vertexref, trckcoll[trckcoll_ite]);
     }
 
     vertexptsumvector.erase(vertexptsumvector.begin() + highestpT_index);
   }
 
   return trackvertexassOutput;
 }

template<typename TREF >

static reco::VertexRef PF_PU_AssoMapAlgos::TrackWeightAssociation	(	const TREF &	,
		const std::vector< reco::VertexRef > &
	)

staticprivate

Referenced by FindAssociation(), and FindNIVertex().

template<typename TREF >

VertexRef PF_PU_AssoMapAlgos::TrackWeightAssociation	(	const TREF &	trackRef,
		const std::vector< reco::VertexRef > &	vtxcollV
	)

Definition at line 704 of file PF_PU_AssoMapAlgos.cc.

References histoStyle::weight.

                                                                                                {
   VertexRef bestvertexref = vtxcollV.at(0);
   float bestweight = 0.;
 
   //loop over all vertices in the vertex collection
   for (auto const& vertexref : vtxcollV) {
     //get the most probable vertex for the track
     float weight = vertexref->trackWeight(trackRef);
     if (weight > bestweight) {
       bestweight = weight;
       bestvertexref = vertexref;
     }
   }
 
   return bestvertexref;
 }