#include <PF_PU_AssoMapAlgos.h>

Inheritance diagram for PF_PU_AssoMapAlgos:

Public Member Functions
std::auto_ptr < TrackToVertexAssMap >	CreateTrackToVertexMap (edm::Handle< reco::TrackCollection >, const edm::EventSetup &)

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

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

	PF_PU_AssoMapAlgos (const edm::ParameterSet &)

std::auto_ptr < TrackToVertexAssMap >	SortAssociationMap (TrackToVertexAssMap *)

virtual	~PF_PU_AssoMapAlgos ()

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

int	DefineQuality (StepDistancePairVector, int, double)

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

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

Private Member Functions
virtual std::auto_ptr < reco::ConversionCollection >	GetCleanedConversions (edm::Handle< reco::ConversionCollection >, bool)

virtual std::auto_ptr < reco::VertexCollection >	GetCleanedIVF (edm::Handle< reco::VertexCollection >, bool)

virtual std::auto_ptr < reco::VertexCompositeCandidateCollection >	GetCleanedKshort (edm::Handle< reco::VertexCompositeCandidateCollection >, bool)

virtual std::auto_ptr < reco::VertexCompositeCandidateCollection >	GetCleanedLambda (edm::Handle< reco::VertexCompositeCandidateCollection >, bool)

virtual std::auto_ptr < reco::PFDisplacedVertexCollection >	GetCleanedNI (edm::Handle< reco::PFDisplacedVertexCollection >, bool)

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

static bool	ComesFromIVF (const reco::TrackRef, const reco::VertexCollection &, reco::Vertex *)

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

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

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

static reco::VertexRef	FindClosestZ (const reco::TrackRef, 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 >, std::vector< reco::VertexRef > *, double)

static reco::VertexRef	FindIVFVertex (const reco::TrackRef, const reco::Vertex &, edm::ESHandle< MagneticField >, const edm::EventSetup &, edm::Handle< reco::BeamSpot >, 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 >, std::vector< reco::VertexRef > *, double, reco::TransientTrack)

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

static reco::VertexRef	TrackWeightAssociation (const reco::TrackBaseRef &, std::vector< reco::VertexRef > *)

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

edm::ESHandle< MagneticField >	bFieldH

VertexState	BSVertexState

bool	cleanedColls_

std::auto_ptr < reco::ConversionCollection >	cleanedConvCollP

std::auto_ptr < reco::VertexCollection >	cleanedIVFCollP

std::auto_ptr < reco::VertexCompositeCandidateCollection >	cleanedKshortCollP

std::auto_ptr < reco::VertexCompositeCandidateCollection >	cleanedLambdaCollP

std::auto_ptr < reco::PFDisplacedVertexCollection >	cleanedNICollP

edm::Handle < reco::ConversionCollection >	convCollH

edm::InputTag	ConversionsCollection_

edm::Handle < reco::PFDisplacedVertexCollection >	displVertexCollH

VertexDistanceXY	distanceComputerXY

edm::InputTag	IFVVertexCollection_

bool	ignoremissingpfcollection_

edm::InputTag	input_BeamSpot_

bool	input_doReassociation_

int	input_FinalAssociation_

int	input_MaxNumAssociations_

double	input_nTrack_3D_

double	input_nTrack_z_

edm::InputTag	input_VertexCollection_

edm::Handle < reco::VertexCollection >	ivfVertexCollH

edm::InputTag	KshortCollection_

edm::InputTag	LambdaCollection_

int	maxNumWarnings_

bool	missingColls

edm::InputTag	NIVertexCollection_

int	numWarnings_

edm::Handle < reco::VertexCompositeCandidateCollection >	vertCompCandCollKshortH

edm::Handle < reco::VertexCompositeCandidateCollection >	vertCompCandCollLambdaH

edm::Handle < reco::VertexCollection >	vtxcollH

Detailed Description

Definition at line 122 of file PF_PU_AssoMapAlgos.h.

Constructor & Destructor Documentation

PF_PU_AssoMapAlgos::PF_PU_AssoMapAlgos ( const edm::ParameterSet & iConfig )

Definition at line 26 of file PF_PU_AssoMapAlgos.cc.

References cleanedColls_, ConversionsCollection_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), IFVVertexCollection_, ignoremissingpfcollection_, input_BeamSpot_, input_doReassociation_, input_FinalAssociation_, input_MaxNumAssociations_, input_nTrack_3D_, input_nTrack_z_, input_VertexCollection_, KshortCollection_, edm::InputTag::label(), LambdaCollection_, missingColls, and NIVertexCollection_.

   : maxNumWarnings_(3),
     numWarnings_(0)
 {
 
   input_MaxNumAssociations_ = iConfig.getParameter<int>("MaxNumberOfAssociations");
 
   input_VertexCollection_= iConfig.getParameter<InputTag>("VertexCollection");
 
   input_BeamSpot_= iConfig.getParameter<InputTag>("BeamSpot");
 
   input_doReassociation_= iConfig.getParameter<bool>("doReassociation");
   cleanedColls_ = iConfig.getParameter<bool>("GetCleanedCollections");
 
   ConversionsCollection_= iConfig.getParameter<InputTag>("ConversionsCollection");
 
   KshortCollection_= iConfig.getParameter<InputTag>("V0KshortCollection");
   LambdaCollection_= iConfig.getParameter<InputTag>("V0LambdaCollection");
 
   NIVertexCollection_= iConfig.getParameter<InputTag>("NIVertexCollection");
 
   IFVVertexCollection_ = iConfig.getParameter<InputTag>("IVFVertexCollection");
   if ( IFVVertexCollection_.label()=="" ) {
     LogWarning("PF_PU_AssoMapAlgos::PF_PU_AssoMapAlgos")  << "No InputTag for IV's given --> skipping reconstruction of inclusive vertices !!" << endl;
   }
 
   input_FinalAssociation_= iConfig.getUntrackedParameter<int>("FinalAssociation", 0);
 
   ignoremissingpfcollection_ = iConfig.getParameter<bool>("ignoreMissingCollection");
 
   input_nTrack_z_ = iConfig.getParameter<double>("nTrackWeight_z");
   input_nTrack_3D_ = iConfig.getParameter<double>("nTrackWeight_3D");
 
   missingColls = false;
 
 }

PF_PU_AssoMapAlgos::~PF_PU_AssoMapAlgos ( )

virtual

Definition at line 67 of file PF_PU_AssoMapAlgos.cc.

 {
   // do anything here that needs to be done at destruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

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

staticprivate

Definition at line 492 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::ComesFromIVF	(	const reco::TrackRef	trackref,
		const reco::VertexCollection &	cleanedIVF,
		reco::Vertex *	ivfVtx
	)

staticprivate

Definition at line 827 of file PF_PU_AssoMapAlgos.cc.

Referenced by FindAssociation().

 {
 
   for(VertexCollection::const_iterator iInclV=cleanedIVF.begin(); iInclV!=cleanedIVF.end(); iInclV++){
 
     if(iInclV->trackWeight(trackref)>1.e-5){
 
       *ivfVtx = *iInclV; 
       return true;
 
     }
 
   }
 
   return false;
   
 }

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

staticprivate

Definition at line 711 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 &	cleanedVCCC,
		reco::VertexCompositeCandidate *	V0
	)

staticprivate

Definition at line 618 of file PF_PU_AssoMapAlgos.cc.

References reco::RecoChargedCandidate::track().

Referenced by FindAssociation().

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

std::auto_ptr< TrackToVertexAssMap > PF_PU_AssoMapAlgos::CreateTrackToVertexMap	(	edm::Handle< reco::TrackCollection >	trkcollH,
		const edm::EventSetup &	iSetup
	)

Definition at line 140 of file PF_PU_AssoMapAlgos.cc.

References IPTools::absoluteImpactParameter3D(), beamspotH, bFieldH, CreateVertexVector(), DefineQuality(), EraseVertex(), FindAssociation(), input_MaxNumAssociations_, edm::second(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setES(), relval_parameters_module::step, and vtxcollH.

Referenced by PF_PU_AssoMap::produce().

 {
 
   auto_ptr<TrackToVertexAssMap> track2vertex(new TrackToVertexAssMap());
 
   int num_associations = input_MaxNumAssociations_;
   int num_vertices = vtxcollH->size();
   if ( num_vertices < num_associations) num_associations = num_vertices;
     
   //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);
 
     vector<VertexRef>* vtxColl_help = CreateVertexVector(vtxcollH);
     StepDistancePairVector distances;
 
     int num_assoc = 0;
 
     for ( int assoc_ite = 0; assoc_ite < num_associations; ++assoc_ite ) {
 
       VertexStepPair assocVtx = FindAssociation(trackref, vtxColl_help, bFieldH, iSetup, beamspotH, assoc_ite);
       VertexRef associatedVertex = assocVtx.first;
       int step = assocVtx.second;
       double distance = ( IPTools::absoluteImpactParameter3D( transtrk, *associatedVertex ) ).second.value();
  
       int quality = DefineQuality(distances, step, distance);
       distances.push_back( make_pair(step, distance) );
 
       // edm::LogInfo("Trck2VtxAssociation") << "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( associatedVertex, make_pair(trackref, quality) );
 
       PF_PU_AssoMapAlgos::EraseVertex(vtxColl_help, associatedVertex);
       num_assoc++;
 
     }
 
     delete vtxColl_help;
 
   }
 
   return track2vertex;
 
 }

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

Definition at line 199 of file PF_PU_AssoMapAlgos.cc.

References IPTools::absoluteImpactParameter3D(), beamspotH, bFieldH, CreateVertexVector(), DefineQuality(), EraseVertex(), FindAssociation(), input_MaxNumAssociations_, edm::second(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setES(), relval_parameters_module::step, and vtxcollH.

Referenced by PF_PU_AssoMap::produce().

 {
 
   auto_ptr<VertexToTrackAssMap> vertex2track(new VertexToTrackAssMap());
 
   int num_associations = input_MaxNumAssociations_;
   int num_vertices = vtxcollH->size();
   if ( num_vertices < num_associations) num_associations = num_vertices;
     
   //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);
 
     vector<VertexRef>* vtxColl_help = CreateVertexVector(vtxcollH);
     StepDistancePairVector distances;
 
     for ( int assoc_ite = 0; assoc_ite < num_associations; ++assoc_ite ) {
 
       VertexStepPair assocVtx = FindAssociation(trackref, vtxColl_help, bFieldH, iSetup, beamspotH, assoc_ite);  
       VertexRef associatedVertex = assocVtx.first;
       int step = assocVtx.second;
       double distance = ( IPTools::absoluteImpactParameter3D( transtrk, *associatedVertex ) ).second.value();
 
       int quality = DefineQuality(distances, step, distance);
       distances.push_back( make_pair(step, distance) );
 
       // edm::LogInfo("Vtx2TrckAssociation") << "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
       vertex2track->insert( trackref, make_pair(associatedVertex, quality) );
  
       PF_PU_AssoMapAlgos::EraseVertex(vtxColl_help, associatedVertex);
 
     }
 
     delete vtxColl_help;
 
   }
 
   return vertex2track;
 
 }

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

protected

Definition at line 341 of file PF_PU_AssoMapAlgos.cc.

References convertSQLitetoXML_cfg::output.

Referenced by PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), and CreateVertexToTrackMap().

 {
 
   vector<VertexRef>* output = new vector<VertexRef>();
 
   for(unsigned int index_vtx=0;  index_vtx<vtxcollH->size(); ++index_vtx){
 
     VertexRef vertexref(vtxcollH,index_vtx);
     output->push_back(vertexref);
 
   }
 
   return output;
 
 }

int PF_PU_AssoMapAlgos::DefineQuality	(	StepDistancePairVector	,
		int	,
		double
	)

protected

Definition at line 1026 of file PF_PU_AssoMapAlgos.cc.

References f1_1st_50_cum, f1_1st_70_cum, f3_1st_50_cum, f3_1st_70_cum, f3_2nd_f3_cum, MinBiasTracking_cff::firstStep, fz_1st_50, fz_1st_50_cum, fz_1st_70_cum, fz_2nd_fz_cum, input_FinalAssociation_, sc_1st_50, sc_1st_70_cum, sc_2nd_f1_0_cum, sc_2nd_f1_1_cum, sc_2nd_f3_0_cum, sc_2nd_f3_1_cum, sc_2nd_fz_0_cum, sc_2nd_fz_1_cum, tw_1st_50, tw_1st_90_cum, tw_2nd_f1_cum, tw_2nd_f3_cum, and tw_2nd_fz_cum.

Referenced by PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), and CreateVertexToTrackMap().

 {
 
   int quality = 0;
   int assoc_ite = distances.size();
     
   if ( assoc_ite >= 2 ) return 0;
 
   switch ( step ) {
         
     case 0:{
 
       //TrackWeight association
       if ( distance <= tw_1st_90_cum ) {
         quality = 6;
       } else {
     quality = 5;
       }
       break;
 
     }
 
     case 1:{
 
       //Secondary association
       if ( distance <= sc_1st_70_cum ) {
         quality = 5;
       } else {
     quality = 4;
       }
       break;
 
     }
 
     case 2:{
 
       //Final association
       if ( input_FinalAssociation_ == 0 ) {
 
         // always first vertex
     if ( assoc_ite == 0 ) {
 
       if ( distance <= f1_1st_70_cum ) {
         quality = 5;
       } else {
         if ( distance <= f1_1st_50_cum ) {
           quality = 4;
         } else {
           quality = 3;
         }
       }
 
     } else {
 
       int firstStep = distances.at(0).first;
       int firstDistance = distances.at(0).second;
 
       switch ( firstStep ) {
 
         case 0:{
 
           if ( ( firstDistance <= tw_1st_50 ) &&
                ( distance <= tw_2nd_f1_cum ) ) {
             quality = 2;
           } else {
             quality = 1;
           }
           break;
 
         }
 
         case 1:{
 
               if ( ( ( firstDistance <= sc_1st_50 ) && ( distance <= sc_2nd_f1_0_cum  ) ) ||
                    ( ( firstDistance > sc_1st_50 )  && ( distance <= sc_2nd_f1_1_cum  ) ) ) {
                 quality = 2;
               } else {
                 quality = 1;
               }
               break;
 
         }
 
         case 2:{
               quality = 1;
         }
 
         default:{
           quality = 1;
         }
 
       }
 
         }
 
       } else {
 
         if ( input_FinalAssociation_ == 1 ) {
 
       // closest in z
       if ( assoc_ite == 0 ) {
 
         if ( distance <= fz_1st_70_cum ) {
           quality = 5;
         } else {
           if ( distance <= fz_1st_50_cum ) {
             quality = 4;
           } else {
         quality = 3;
           }
         }
 
       } else {
 
         int firstStep = distances.at(0).first;
         int firstDistance = distances.at(0).second;
 
             switch ( firstStep ) {
 
           case 0:{
 
             if ( ( firstDistance <= tw_1st_50 ) &&
                  ( distance <= tw_2nd_fz_cum ) ) {
               quality = 2;
             } else {
               quality = 1;
             }
             break;
 
           }
 
           case 1:{
 
             if ( ( ( firstDistance <= sc_1st_50 ) && ( distance <= sc_2nd_fz_0_cum  ) ) ||
                  ( ( firstDistance > sc_1st_50 )  && ( distance <= sc_2nd_fz_1_cum  ) ) ) {
               quality = 2;
             } else {
               quality = 1;
             }
             break;
 
           }
 
           case 2:{
 
                 if ( ( firstDistance <= fz_1st_50 ) &&
                      ( distance <= fz_2nd_fz_cum ) ) {
                   quality = 2;
                 } else {
                   quality = 1;
                 }
                 break;
 
           }
 
           default:{
             quality = 1;
           }
 
             }
 
       }
 
     } else {
 
       // closest in 3D
       if ( assoc_ite == 0 ) {
 
             if ( distance <= f3_1st_70_cum ) {
           quality = 5;
             } else {
           if ( distance <= f3_1st_50_cum ) {
             quality = 4;
           } else {
             quality = 3;
           }
         }
 
       } else {
 
         int firstStep = distances.at(0).first;
         int firstDistance = distances.at(0).second;
 
         switch ( firstStep ) {
 
           case 0:{
 
             if ( ( firstDistance <= tw_1st_50 ) &&
                  ( distance <= tw_2nd_f3_cum ) ) {
               quality = 2;
                 } else {
               quality = 1;
             }
             break;
 
           }
 
           case 1:{
 
             if ( ( ( firstDistance <= sc_1st_50 ) && ( distance <= sc_2nd_f3_0_cum  ) ) ||
                  ( ( firstDistance > sc_1st_50 )  && ( distance <= sc_2nd_f3_1_cum  ) ) ) {
               quality = 2;
             } else {
               quality = 1;
             }
             break;
 
           }
 
           case 2:{
 
             if ( ( firstDistance <= fz_1st_50 ) &&
                  ( distance <= f3_2nd_f3_cum ) ) {
               quality = 2;
             } else {
               quality = 1;
             }
             break;
 
           }
 
           default:{
             quality = 1;
           }
 
         }
 
       }
     }
       }
 
       break;
     }
 
     default:{
       quality = 0;
       break;
     }
 
   }
 
   return quality;
 
 }

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

protected

Definition at line 362 of file PF_PU_AssoMapAlgos.cc.

Referenced by PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), and CreateVertexToTrackMap().

 {
     
   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,
		std::vector< reco::VertexRef > *	vtxColl,
		edm::ESHandle< MagneticField >	bfH,
		const edm::EventSetup &	iSetup,
		edm::Handle< reco::BeamSpot >	bsH,
		int	assocNum
	)

protected

Definition at line 904 of file PF_PU_AssoMapAlgos.cc.

References cleanedConvCollP, cleanedIVFCollP, cleanedKshortCollP, cleanedLambdaCollP, cleanedNICollP, ComesFromConversion(), ComesFromIVF(), ComesFromNI(), ComesFromV0Decay(), displVertexCollH, FindClosest3D(), FindClosestZ(), FindConversionVertex(), FindIVFVertex(), FindNIVertex(), FindV0Vertex(), input_doReassociation_, input_FinalAssociation_, input_nTrack_3D_, input_nTrack_z_, edm::HandleBase::isValid(), ivfVertexCollH, reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setES(), and TrackWeightAssociation().

Referenced by PFCand_AssoMapAlgos::CreatePFCandToVertexMap(), CreateTrackToVertexMap(), PFCand_AssoMapAlgos::CreateVertexToPFCandMap(), and CreateVertexToTrackMap().

 {
 
   const TrackBaseRef& trackbaseRef = TrackBaseRef(trackref);
 
   TransientTrack transtrk(trackref, &(*bfH) );
   transtrk.setBeamSpot(*bsH);
   transtrk.setES(iSetup);
 
   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(trackbaseRef, vtxColl);
 
   if ( foundVertex->trackWeight(trackbaseRef) >= 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 ( PF_PU_AssoMapAlgos::ComesFromConversion(trackref, *cleanedConvCollP, &gamma) ){
       foundVertex = PF_PU_AssoMapAlgos::FindConversionVertex(trackref, gamma, bfH, iSetup, bsH, vtxColl, input_nTrack_3D_);
       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 ( ( PF_PU_AssoMapAlgos::ComesFromV0Decay(trackref, *cleanedKshortCollP, &V0) ) ||
          ( PF_PU_AssoMapAlgos::ComesFromV0Decay(trackref, *cleanedLambdaCollP, &V0) ) ) {
       foundVertex = PF_PU_AssoMapAlgos::FindV0Vertex(trackref, V0, bfH, iSetup, bsH, vtxColl, input_nTrack_3D_);
       return make_pair( foundVertex, 1. );
     }
 
     if ( displVertexCollH.isValid() ) {
 
       // Test if the track comes from a nuclear interaction:
       // If so, reassociate the track to the vertex of the incoming particle 
       PFDisplacedVertex displVtx;
       if ( PF_PU_AssoMapAlgos::ComesFromNI(trackref, *cleanedNICollP, &displVtx) ){
         foundVertex = PF_PU_AssoMapAlgos::FindNIVertex(trackref, displVtx, bfH, iSetup, bsH, vtxColl, input_nTrack_3D_, transtrk);
         return make_pair( foundVertex, 1. );
       }
 
     }
 
     if ( ivfVertexCollH.isValid() ) {
 
       // Test if the track comes from a nuclear interaction:
       // If so, reassociate the track to the vertex of the incoming particle 
       Vertex ivfVtx;
       if ( ComesFromIVF(trackref, *cleanedIVFCollP, &ivfVtx) ){
         foundVertex = FindIVFVertex(trackref, ivfVtx, bfH, iSetup, bsH, vtxColl, input_nTrack_3D_);
         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_z_);
         break;
 
       }
 
       case 2:{
 
         // closest in 3D
         TransientTrack transtrk(trackref, &(*bfH) );
         transtrk.setBeamSpot(*bsH);
         transtrk.setES(iSetup);
 
         foundVertex = FindClosest3D(transtrk, vtxColl, input_nTrack_3D_);
         break;
 
       }
 
       default:{
 
         // allways first vertex
         foundVertex = vtxColl->at(0);
         break;
 
       }
 
     }
 
     return make_pair( foundVertex, 2. );
 
 }

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

staticprivate

Definition at line 422 of file PF_PU_AssoMapAlgos.cc.

References IPTools::absoluteImpactParameter3D().

Referenced by FindAssociation(), FindConversionVertex(), FindIVFVertex(), 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 = 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,
		std::vector< reco::VertexRef > *	vtxcollV,
		double	tWeight = `0.`
	)

staticprivate

Definition at line 384 of file PF_PU_AssoMapAlgos.cc.

References 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() );
 
     //find and store the closest vertex in z
     double distance = fabs(ztrack - vertexref->z());
 
     double weightedDistance = 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,
		std::vector< reco::VertexRef > *	vtxcollV,
		double	tWeight
	)

staticprivate

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

VertexRef PF_PU_AssoMapAlgos::FindIVFVertex	(	const reco::TrackRef	trackref,
		const reco::Vertex &	ivfVtx,
		edm::ESHandle< MagneticField >	bFieldH,
		const edm::EventSetup &	iSetup,
		edm::Handle< reco::BeamSpot >	bsH,
		std::vector< reco::VertexRef > *	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 850 of file PF_PU_AssoMapAlgos.cc.

References FindClosest3D(), reco::Vertex::p4(), and reco::Vertex::position().

Referenced by FindAssociation().

 {
 
   math::XYZPoint iv_pos = ivfVtx.position();
 
   math::XYZVector iv_mom( ivfVtx.p4(0.1, 0.).x(),
                           ivfVtx.p4(0.1, 0.).y(),
                           ivfVtx.p4(0.1, 0.).z() );
   
   Track incom(trackref->chi2(), trackref->ndof(), iv_pos, iv_mom, 0, trackref->covariance());
 
   TransientTrack transIncom(incom, &(*bFieldH) );
   transIncom.setBeamSpot( *bsH );
   transIncom.setES( iSetup );
 
   return FindClosest3D(transIncom, 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,
		std::vector< reco::VertexRef > *	vtxcollV,
		double	tWeight,
		reco::TransientTrack	transhelp
	)

staticprivate

Definition at line 736 of file PF_PU_AssoMapAlgos.cc.

References alignCSCRings::e, FindClosest3D(), reco::PFDisplacedVertex::isIncomingTrack(), reco::PFDisplacedVertex::isThereMergedTracks(), reco::PFDisplacedVertex::isTherePrimaryTracks(), reco::Vertex::originalTrack(), reco::Vertex::refittedTracks(), reco::TransientTrack::setBeamSpot(), reco::TransientTrack::setES(), and histoStyle::weight.

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 bestvertexref = vtxcollV->at(0);
         float bestweight = 0.;
  
         for ( unsigned int index_vtx=0; index_vtx<vtxcollV->size(); ++index_vtx ) {
 
           VertexRef vertexref = vtxcollV->at(index_vtx);
 
           //get the most probable vertex for the track
           float weight = vertexref->trackWeight(retrackbaseref);
           if(weight>bestweight){
             bestweight = weight;
             bestvertexref = vertexref;
           } 
 
         }
 
         if ( bestweight>1.e-5 ) return bestvertexref;
  
         TransientTrack transIncom(*retrackbaseref, &(*bFieldH) );
         transIncom.setBeamSpot( *bsH );
         transIncom.setES( iSetup );
 
         return FindClosest3D(transIncom, vtxcollV, tWeight); 
 
       }
 
     }
 
   }
 
   return FindClosest3D(transhelp, 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,
		std::vector< reco::VertexRef > *	vtxcollV,
		double	tWeight
	)

staticprivate

Definition at line 648 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by FindAssociation().

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

auto_ptr< ConversionCollection > PF_PU_AssoMapAlgos::GetCleanedConversions	(	edm::Handle< reco::ConversionCollection >	convCollH,
		bool	cleanedColl
	)

privatevirtual

Definition at line 460 of file PF_PU_AssoMapAlgos.cc.

Referenced by GetInputCollections().

 {
 
   auto_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->quality( Conversion::highPurity ) ){
 
       cleanedConvColl->push_back(*convref);
 
     }
 
   }
 
   return cleanedConvColl;
 
 }

auto_ptr< VertexCollection > PF_PU_AssoMapAlgos::GetCleanedIVF	(	edm::Handle< reco::VertexCollection >	ifvH,
		bool	cleanedColl
	)

privatevirtual

Definition at line 789 of file PF_PU_AssoMapAlgos.cc.

References BSVertexState, RecoVertex::convertError(), RecoVertex::convertPos(), VertexDistanceXY::distance(), and distanceComputerXY.

Referenced by GetInputCollections().

 {
 
   auto_ptr<VertexCollection> cleanedIVFColl(new VertexCollection() );
  
   for ( VertexCollection::const_iterator ivfref=ifvH->begin(); ivfref!=ifvH->end(); ivfref++ ) {
 
     if ( !cleanedColl ) {
       cleanedIVFColl->push_back(*ivfref);
       continue;
     } 
 
     GlobalPoint iv_pos = RecoVertex::convertPos( ivfref->position() );    
     GlobalError iv_err = RecoVertex::convertError( ivfref->error() );  
     
     double ivf_significance = ( distanceComputerXY.distance( BSVertexState, VertexState( iv_pos, iv_err ))).significance();
     
     if ( ( ivfref->isValid() ) && 
          ( !ivfref->isFake() ) && 
          ( ivfref->chi2()<=10. ) && 
          ( ivfref->nTracks(0.)>=2 ) && 
          ( ivf_significance>=5. ) ) {
          
       cleanedIVFColl->push_back(*ivfref);
  
     }            
  
   }
 
   return cleanedIVFColl;
   
 }

auto_ptr< VertexCompositeCandidateCollection > PF_PU_AssoMapAlgos::GetCleanedKshort	(	edm::Handle< reco::VertexCompositeCandidateCollection >	KshortsH,
		bool	cleanedColl
	)

privatevirtual

Definition at line 540 of file PF_PU_AssoMapAlgos.cc.

References BSVertexState, RecoVertex::convertPos(), VertexDistanceXY::distance(), distanceComputerXY, and kMass.

Referenced by GetInputCollections().

 {
 
   auto_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;
     }
 
     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));  
 
     double kaon_significance = ( distanceComputerXY.distance( BSVertexState, VertexState( dec_pos, decayVertexError ) ) ).significance();
 
     if ( ( ksref->vertexNormalizedChi2()<=7. ) &&
          ( fabs(ksref->mass() - kMass)<=0.06 ) &&
          ( kaon_significance>25. ) ) {
 
       cleanedKaonColl->push_back(*ksref);
 
     }
 
   }
 
   return cleanedKaonColl;
   
 }

auto_ptr< VertexCompositeCandidateCollection > PF_PU_AssoMapAlgos::GetCleanedLambda	(	edm::Handle< reco::VertexCompositeCandidateCollection >	LambdasH,
		bool	cleanedColl
	)

privatevirtual

Definition at line 579 of file PF_PU_AssoMapAlgos.cc.

References BSVertexState, RecoVertex::convertPos(), VertexDistanceXY::distance(), distanceComputerXY, and lamMass.

Referenced by GetInputCollections().

 {
 
   auto_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;
     }
 
     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));  
 
     double lambda_significance = ( distanceComputerXY.distance( BSVertexState, VertexState( dec_pos, decayVertexError ) ) ).significance();
 
     if ( ( lambdaref->vertexNormalizedChi2()<=7. ) &&
          ( fabs(lambdaref->mass() - lamMass)<=0.04 ) &&
          ( lambda_significance>26. ) ){
 
       cleanedLambdaColl->push_back(*lambdaref);
 
     }
 
   }
 
   return cleanedLambdaColl;
   
 }

auto_ptr< PFDisplacedVertexCollection > PF_PU_AssoMapAlgos::GetCleanedNI	(	edm::Handle< reco::PFDisplacedVertexCollection >	NuclIntH,
		bool	cleanedColl
	)

privatevirtual

Definition at line 673 of file PF_PU_AssoMapAlgos.cc.

References BSVertexState, RecoVertex::convertError(), RecoVertex::convertPos(), VertexDistanceXY::distance(), distanceComputerXY, and relativeConstraints::value.

Referenced by GetInputCollections().

 {
 
   auto_ptr<PFDisplacedVertexCollection> cleanedNIColl(new PFDisplacedVertexCollection() );
 
   for ( PFDisplacedVertexCollection::const_iterator niref=NuclIntH->begin(); niref!=NuclIntH->end(); niref++ ) {
 
     if ( !cleanedColl ) {
       cleanedNIColl->push_back(*niref);
       continue;
     }
 
     GlobalPoint ni_pos = RecoVertex::convertPos( niref->position() );    
     GlobalError interactionVertexError = RecoVertex::convertError( niref->error() );
 
     double nuclint_distance = ( distanceComputerXY.distance( BSVertexState, VertexState( ni_pos, interactionVertexError ) ) ).value();
 
     if ( ( !niref->isFake() ) &&
          ( niref->isNucl() ) &&
          ( niref->normalizedChi2()<=2. ) &&
          ( niref->tracksSize()>=2 ) &&
          ( nuclint_distance>3. ) ) {
 
       cleanedNIColl->push_back(*niref);
  
     }
 
   }
 
   return cleanedNIColl;
   
 }

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

virtual

Definition at line 78 of file PF_PU_AssoMapAlgos.cc.

References beamspotH, bFieldH, BSVertexState, cleanedColls_, cleanedConvCollP, cleanedIVFCollP, cleanedKshortCollP, cleanedLambdaCollP, cleanedNICollP, convCollH, ConversionsCollection_, RecoVertex::convertError(), RecoVertex::convertPos(), displVertexCollH, edm::EventSetup::get(), edm::Event::getByLabel(), GetCleanedConversions(), GetCleanedIVF(), GetCleanedKshort(), GetCleanedLambda(), GetCleanedNI(), IFVVertexCollection_, ignoremissingpfcollection_, input_BeamSpot_, input_VertexCollection_, ivfVertexCollH, KshortCollection_, edm::InputTag::label(), LambdaCollection_, maxNumWarnings_, NIVertexCollection_, numWarnings_, vertCompCandCollKshortH, vertCompCandCollLambdaH, and vtxcollH.

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

 {
   
   //get the offline beam spot
   iEvent.getByLabel(input_BeamSpot_, beamspotH);
 
   GlobalPoint bsPosition = RecoVertex::convertPos( beamspotH->position() );
   GlobalError bsError = RecoVertex::convertError( beamspotH->covariance3D() );
 
   BSVertexState = VertexState( bsPosition, bsError );
 
   //get the conversion collection for the gamma conversions
   iEvent.getByLabel(ConversionsCollection_, convCollH);
   cleanedConvCollP = PF_PU_AssoMapAlgos::GetCleanedConversions(convCollH,cleanedColls_);
 
   //get the vertex composite candidate collection for the Kshort's
   iEvent.getByLabel(KshortCollection_, vertCompCandCollKshortH);
   cleanedKshortCollP = PF_PU_AssoMapAlgos::GetCleanedKshort(vertCompCandCollKshortH,cleanedColls_);
 
   //get the vertex composite candidate collection for the Lambda's
   iEvent.getByLabel(LambdaCollection_, vertCompCandCollLambdaH);
   cleanedLambdaCollP = PF_PU_AssoMapAlgos::GetCleanedLambda(vertCompCandCollLambdaH,cleanedColls_);
 
   //get the displaced vertex collection for nuclear interactions
   if ( !iEvent.getByLabel(NIVertexCollection_,displVertexCollH) ) {
     if ( ignoremissingpfcollection_ ){
       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, true);
 
   }
 
   //get the inclusive vertex finder collection 
   if ( !iEvent.getByLabel(IFVVertexCollection_,ivfVertexCollH) ) {
     if ( ( ignoremissingpfcollection_ ) && !( IFVVertexCollection_.label()=="" ) ){
       if ( numWarnings_ < maxNumWarnings_ ) {
         LogWarning("PF_PU_AssoMapAlgos::GetInputCollections")  << "No Extra objects available in input file --> skipping reconstruction of ifv vertices !!" << endl;
         ++numWarnings_;
       }
     }
   } else {
 
     cleanedIVFCollP = PF_PU_AssoMapAlgos::GetCleanedIVF(ivfVertexCollH, true);
 
   }
     
   //get the input vertex collection
   iEvent.getByLabel(input_VertexCollection_, vtxcollH);
 
   iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
 
 }

auto_ptr< TrackToVertexAssMap > PF_PU_AssoMapAlgos::SortAssociationMap ( TrackToVertexAssMap * trackvertexassInput )

Definition at line 254 of file PF_PU_AssoMapAlgos.cc.

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

Referenced by PF_PU_AssoMap::produce().

 {
 
   //create a new TrackVertexAssMap for the Output which will be sorted
   auto_ptr<TrackToVertexAssMap> trackvertexassOutput(new TrackToVertexAssMap() );
 
   //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.size()!=0){
 
     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;
 
 }

VertexRef PF_PU_AssoMapAlgos::TrackWeightAssociation	(	const reco::TrackBaseRef &	trackbaseRef,
		std::vector< reco::VertexRef > *	vtxcollV
	)

staticprivate

Definition at line 875 of file PF_PU_AssoMapAlgos.cc.

References histoStyle::weight.

Referenced by FindAssociation().

 {
 
   VertexRef bestvertexref = vtxcollV->at(0);        
   float bestweight = 0.;
 
   //loop over all vertices in the vertex collection
   for(unsigned int index_vtx=0;  index_vtx<vtxcollV->size(); ++index_vtx){
 
     VertexRef vertexref = vtxcollV->at(index_vtx);
 
     //get the most probable vertex for the track
     float weight = vertexref->trackWeight(trackbaseRef);
     if(weight>bestweight){
       bestweight = weight;
       bestvertexref = vertexref;
     } 
 
   }
  
   return bestvertexref;
 
 }