#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, const edm::EventSetup &iSetup)

std::unique_ptr< TrackToVertexAssMap >	CreateTrackToVertexMap (edm::Handle< reco::TrackCollection >, const edm::EventSetup &)

std::unique_ptr< VertexToTrackAssMap >	CreateVertexToTrackMap (edm::Handle< reco::TrackCollection >, const edm::EventSetup &)

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 ()(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 >, const edm::EventSetup &, 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 >, const edm::EventSetup &, edm::Handle< reco::BeamSpot >, const std::vector< reco::VertexRef > &, double)

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

static reco::VertexRef	FindV0Vertex (const reco::TrackRef, const reco::VertexCompositeCandidate &, edm::ESHandle< MagneticField >, const edm::EventSetup &, 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_

edm::EDGetTokenT< reco::VertexCollection >	token_VertexCollection_

edm::Handle< reco::VertexCompositeCandidateCollection >	vertCompCandCollKshortH

edm::Handle< reco::VertexCompositeCandidateCollection >	vertCompCandCollLambdaH

edm::Handle< reco::VertexCollection >	vtxcollH

Detailed Description

Definition at line 82 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 :

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

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

inlinevirtual

Member Function Documentation

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

staticprivate

Definition at line 441 of file PF_PU_AssoMapAlgos.cc.

References ConversionTools::matchesConversion().

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         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 706 of file PF_PU_AssoMapAlgos.cc.

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         //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 587 of file PF_PU_AssoMapAlgos.cc.

References reco::RecoChargedCandidate::track().

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         //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,
		const edm::EventSetup &	iSetup
	)

Definition at line 110 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         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.setES(iSetup);
 
           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, iSetup, 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,
		const edm::EventSetup &	iSetup
	)

Definition at line 165 of file PF_PU_AssoMapAlgos.cc.

References createMappings().

Referenced by ~PF_PU_AssoMapAlgos().

 {
   return createMappings(trkcollH,iSetup).first;
 }

std::unique_ptr< VertexToTrackAssMap > PF_PU_AssoMapAlgos::CreateVertexToTrackMap	(	edm::Handle< reco::TrackCollection >	trkcollH,
		const edm::EventSetup &	iSetup
	)

Definition at line 175 of file PF_PU_AssoMapAlgos.cc.

References createMappings().

Referenced by ~PF_PU_AssoMapAlgos().

 {
   return createMappings(trkcollH,iSetup).second;
 }

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

protected

Definition at line 271 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         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 915 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         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 383 of file PF_PU_AssoMapAlgos.cc.

References boostedElectronIsolation_cff::deltaR, cmsBatch::log, mathSSE::sqrt(), funct::tan(), reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

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

 {
 
         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 288 of file PF_PU_AssoMapAlgos.cc.

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

 {
 
         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,
		const edm::EventSetup &	iSetup,
		edm::Handle< reco::BeamSpot >	bsH,
		int	assocNum
	)

protected

Definition at line 810 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         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, iSetup, 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, iSetup, 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, iSetup, 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.setES(iSetup);
 
             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 346 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         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 310 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         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,
		const edm::EventSetup &	iSetup,
		edm::Handle< reco::BeamSpot >	bsH,
		const std::vector< reco::VertexRef > &	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 464 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         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.setES(iSetup);
 
         return FindClosest3D(transpho, vtxcollV, tWeight);
 
 }

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

staticprivate

Definition at line 730 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(), reco::Vertex::refittedTracks(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setES(), and TrackWeightAssociation().

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         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.setES(iSetup);
 
               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.setES(iSetup);
 
         return FindClosest3D(transIncom, vtxcollV, tWeight);
 
 }

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

staticprivate

Definition at line 633 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by FindAssociation(), and ~PF_PU_AssoMapAlgos().

 {
 
         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.setES(iSetup);
 
         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 409 of file PF_PU_AssoMapAlgos.cc.

Referenced by GetInputCollections(), and ~PF_PU_AssoMapAlgos().

 {
         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 489 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::BeamSpot::covariance3D(), VertexDistance3D::distance(), dR(), kMass, reco::BeamSpot::position(), and met_cff::significance.

Referenced by GetInputCollections(), and ~PF_PU_AssoMapAlgos().

 {
 
         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 538 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::BeamSpot::covariance3D(), VertexDistance3D::distance(), dR(), lamMass, reco::BeamSpot::position(), and met_cff::significance.

Referenced by GetInputCollections(), and ~PF_PU_AssoMapAlgos().

 {
 
         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 659 of file PF_PU_AssoMapAlgos.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::BeamSpot::covariance3D(), VertexDistance3D::distance(), dR(), reco::BeamSpot::position(), and met_cff::significance.

Referenced by GetInputCollections(), and ~PF_PU_AssoMapAlgos().

 {
 
         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 60 of file PF_PU_AssoMapAlgos.cc.

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

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

 {
 
         //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);
 
         iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
 
 }

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

Definition at line 185 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by PF_PU_AssoMap::produce(), and ~PF_PU_AssoMapAlgos().

 {
         //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(), FindNIVertex(), and ~PF_PU_AssoMapAlgos().

template<typename TREF >

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

Definition at line 783 of file PF_PU_AssoMapAlgos.cc.

References mps_merge::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;
 
 }