PF_PU_AssoMapAlgos.h

Go to the documentation of this file.

#ifndef PF_PU_AssoMapAlgos_h
#define PF_PU_AssoMapAlgos_h


//
// Original Author:  Matthias Geisler,32 4-B20,+41227676487,
// $Id: PF_PU_AssoMapAlgos.h,v 1.7 2012/11/21 09:45:04 mgeisler Exp $
//
//

#include <string>

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"

#include "DataFormats/Common/interface/Handle.h"

#include "DataFormats/Common/interface/AssociationMap.h"
#include "DataFormats/Common/interface/OneToManyWithQuality.h"
#include "DataFormats/Common/interface/OneToManyWithQualityGeneric.h"

#include "DataFormats/Common/interface/View.h"
#include "DataFormats/Math/interface/Point3D.h"

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/TrackBase.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"

#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"

#include "DataFormats/EgammaCandidates/interface/Conversion.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"

#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertex.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertexFwd.h"

#include "DataFormats/BeamSpot/interface/BeamSpot.h"

#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"

//
// constants, enums and typedefs
//

const double kMass = 0.49765;
const double lamMass = 1.11568;

/*limits for the quality criteria*/

const double tw_90 = 1.e-2;
const double tw_70 = 1.e-1;
const double tw_50 = 2.e-1;

const double sec_70 = 5.;
const double sec_50 = 19.;

const double fin_70 = 1.e-1;
const double fin_50 = 3.e-1;

typedef edm::AssociationMap<edm::OneToManyWithQuality<reco::VertexCollection, reco::TrackCollection, int> > TrackToVertexAssMap;
typedef edm::AssociationMap<edm::OneToManyWithQuality<reco::TrackCollection, reco::VertexCollection, int> > VertexToTrackAssMap;

typedef std::pair<reco::TrackRef, int> TrackQualityPair;
typedef std::vector<TrackQualityPair > TrackQualityPairVector;

typedef std::pair<reco::VertexRef, int> VertexStepPair;

typedef std::pair<reco::VertexRef, TrackQualityPair> VertexTrackQuality;

typedef std::pair <reco::VertexRef, float>  VertexPtsumPair;
typedef std::vector< VertexPtsumPair > VertexPtsumVector;

class PF_PU_AssoMapAlgos{

 public:

   //dedicated constructor for the algorithms
   PF_PU_AssoMapAlgos(const edm::ParameterSet& iConfig, edm::ConsumesCollector && iC) :
     PF_PU_AssoMapAlgos(iConfig, iC) {};
   PF_PU_AssoMapAlgos(const edm::ParameterSet&, edm::ConsumesCollector &);
   // virtual destructor needed when virtual functions declared
   virtual ~PF_PU_AssoMapAlgos() noexcept(false) {};

   //get all needed collections at the beginning
   virtual void GetInputCollections(edm::Event&, const edm::EventSetup&);

   //create the track-to-vertex and vertex-to-track maps in one go
   std::pair<std::unique_ptr<TrackToVertexAssMap>, std::unique_ptr<VertexToTrackAssMap>> 
     createMappings(edm::Handle<reco::TrackCollection> trkcollH, const edm::EventSetup& iSetup);

   //create the track to vertex association map
   std::unique_ptr<TrackToVertexAssMap> CreateTrackToVertexMap(edm::Handle<reco::TrackCollection>, const edm::EventSetup&);

   //create the vertex to track association map
   std::unique_ptr<VertexToTrackAssMap> CreateVertexToTrackMap(edm::Handle<reco::TrackCollection>, const edm::EventSetup&);

   //function to sort the vertices in the AssociationMap by the sum of (pT - pT_Error)**2
   std::unique_ptr<TrackToVertexAssMap> SortAssociationMap(TrackToVertexAssMap*,edm::Handle<reco::TrackCollection>);

 protected:
  //protected functions

   //create helping vertex vector to remove associated vertices
   std::vector<reco::VertexRef> CreateVertexVector(edm::Handle<reco::VertexCollection>);

   //erase one vertex from the vertex vector
   void EraseVertex(std::vector<reco::VertexRef>&, reco::VertexRef);

   //find an association for a certain track
   VertexStepPair FindAssociation(const reco::TrackRef&, const std::vector<reco::VertexRef>&,
                                  edm::ESHandle<MagneticField>, const edm::EventSetup&,
                          edm::Handle<reco::BeamSpot>, int);

   //get the quality for a certain association
   int DefineQuality(int, int, double);

 private:

  // private methods for internal usage

   //function to find the closest vertex in z for a certain track
   static reco::VertexRef FindClosestZ(const reco::TrackRef, const std::vector<reco::VertexRef>&, double tWeight = 0.);

   //function to find the closest vertex in 3D for a certain track
   static reco::VertexRef FindClosest3D(reco::TransientTrack, const std::vector<reco::VertexRef>&, double tWeight = 0.);

   //function to calculate the deltaR between a vector and a vector connecting two points
   static double dR(const math::XYZPoint&, const math::XYZVector&, edm::Handle<reco::BeamSpot>);

   //function to filter the conversion collection
   static std::unique_ptr<reco::ConversionCollection> GetCleanedConversions(edm::Handle<reco::ConversionCollection>,
                                                                          edm::Handle<reco::BeamSpot>, bool);

   //function to find out if the track comes from a gamma conversion
   static bool ComesFromConversion(const reco::TrackRef, const reco::ConversionCollection&, reco::Conversion*);

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

   //function to filter the Kshort collection
   static std::unique_ptr<reco::VertexCompositeCandidateCollection> GetCleanedKshort(edm::Handle<reco::VertexCompositeCandidateCollection>, edm::Handle<reco::BeamSpot>, bool);

   //function to filter the Lambda collection
   static std::unique_ptr<reco::VertexCompositeCandidateCollection> GetCleanedLambda(edm::Handle<reco::VertexCompositeCandidateCollection>, edm::Handle<reco::BeamSpot>, bool);

   //function to find out if the track comes from a V0 decay
   static bool ComesFromV0Decay(const reco::TrackRef, const reco::VertexCompositeCandidateCollection&,
                const reco::VertexCompositeCandidateCollection&, reco::VertexCompositeCandidate*);

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

   //function to filter the nuclear interaction collection
   static std::unique_ptr<reco::PFDisplacedVertexCollection> GetCleanedNI(edm::Handle<reco::PFDisplacedVertexCollection>, edm::Handle<reco::BeamSpot>, bool);

   //function to find out if the track comes from a nuclear interaction
   static bool ComesFromNI(const reco::TrackRef, const reco::PFDisplacedVertexCollection&, reco::PFDisplacedVertex*);

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

   //function to find the vertex with the highest TrackWeight for a certain track
   template<typename TREF> static reco::VertexRef TrackWeightAssociation(const TREF&, const std::vector<reco::VertexRef>&);


  // ----------member data ---------------------------

   int input_MaxNumAssociations_;

   edm::EDGetTokenT<reco::VertexCollection> token_VertexCollection_;
   edm::Handle<reco::VertexCollection> vtxcollH;

   edm::EDGetTokenT<reco::BeamSpot> token_BeamSpot_;
   edm::Handle<reco::BeamSpot> beamspotH;

   edm::ESHandle<MagneticField> bFieldH;

   bool input_doReassociation_;
   bool cleanedColls_;

   edm::EDGetTokenT<reco::ConversionCollection> ConversionsCollectionToken_;
   edm::Handle<reco::ConversionCollection> convCollH;
   std::unique_ptr<reco::ConversionCollection> cleanedConvCollP;

   edm::EDGetTokenT<reco::VertexCompositeCandidateCollection> KshortCollectionToken_;
   edm::Handle<reco::VertexCompositeCandidateCollection> vertCompCandCollKshortH;
   std::unique_ptr<reco::VertexCompositeCandidateCollection> cleanedKshortCollP;

   edm::EDGetTokenT<reco::VertexCompositeCandidateCollection> LambdaCollectionToken_;
   edm::Handle<reco::VertexCompositeCandidateCollection> vertCompCandCollLambdaH;
   std::unique_ptr<reco::VertexCompositeCandidateCollection> cleanedLambdaCollP;

   edm::EDGetTokenT<reco::PFDisplacedVertexCollection> NIVertexCollectionToken_;
   edm::Handle<reco::PFDisplacedVertexCollection> displVertexCollH;
   std::unique_ptr<reco::PFDisplacedVertexCollection> cleanedNICollP;

   int input_FinalAssociation_;

   bool ignoremissingpfcollection_;
   bool missingColls;       // is true if there is a diplaced vertex collection in the event

   double input_nTrack_;

   int maxNumWarnings_;     // CV: print Warning if TrackExtra objects don't exist in input file,
   int numWarnings_;        //     but only a few times

};

#endif