PFCandConnector.h

Go to the documentation of this file.

#ifndef PFProducer_PFCandConnector_H_
#define PFProducer_PFCandConnector_H_

#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h" 

#include "FWCore/ParameterSet/interface/ParameterSet.h"
// \author : M. Gouzevitch
// \date : May 2010


class PFCandConnector {
    
    public :
       
       PFCandConnector( ) { 
     pfC_ = std::make_unique<reco::PFCandidateCollection>(); 
     debug_ = false;
     bCorrect_ = false;
     bCalibPrimary_ =  false;

     fConst_.push_back(1), fConst_.push_back(0);
     fNorm_.push_back(0), fNorm_.push_back(0);
     fExp_.push_back(0);

     dptRel_PrimaryTrack_ = 0.;
         dptRel_MergedTrack_ = 0.;
     ptErrorSecondary_ = 0.;
       }
       
       void setParameters(const edm::ParameterSet& iCfgCandConnector){
     
     bool bCorrect, bCalibPrimary;
     double dptRel_PrimaryTrack, dptRel_MergedTrack, ptErrorSecondary;
     std::vector<double> nuclCalibFactors;

     bCorrect = iCfgCandConnector.getParameter<bool>("bCorrect");
     bCalibPrimary =  iCfgCandConnector.getParameter<bool>("bCalibPrimary");

     if(iCfgCandConnector.exists("dptRel_PrimaryTrack")) dptRel_PrimaryTrack = iCfgCandConnector.getParameter<double>("dptRel_PrimaryTrack");
     else { edm::LogWarning("PFCandConnector")  << "dptRel_PrimaryTrack doesn't exist. Setting a default safe value 0" << std::endl; dptRel_PrimaryTrack = 0;}

     if(iCfgCandConnector.exists("dptRel_MergedTrack"))  dptRel_MergedTrack = iCfgCandConnector.getParameter<double>("dptRel_MergedTrack");
     else { edm::LogWarning("PFCandConnector") << "dptRel_MergedTrack doesn't exist. Setting a default safe value 0" << std::endl; dptRel_MergedTrack = 0;}

     if(iCfgCandConnector.exists("ptErrorSecondary"))    ptErrorSecondary = iCfgCandConnector.getParameter<double>("ptErrorSecondary");
     else { edm::LogWarning("PFCandConnector")  << "ptErrorSecondary doesn't exist. Setting a default safe value 0" << std::endl; ptErrorSecondary = 0;}

     if(iCfgCandConnector.exists("nuclCalibFactors"))    nuclCalibFactors = iCfgCandConnector.getParameter<std::vector<double> >("nuclCalibFactors");  
     else { edm::LogWarning("PFCandConnector")  << "nuclear calib factors doesn't exist the factor would not be applyed" << std::endl; }

     setParameters(bCorrect, bCalibPrimary, dptRel_PrimaryTrack, dptRel_MergedTrack, ptErrorSecondary, nuclCalibFactors);

       }


       void setParameters(bool bCorrect, bool bCalibPrimary, double dptRel_PrimaryTrack, double dptRel_MergedTrack, double ptErrorSecondary, const std::vector<double>& nuclCalibFactors);
       void setDebug( bool debug ) {debug_ = debug;}

       

       std::unique_ptr<reco::PFCandidateCollection> connect(std::unique_ptr<reco::PFCandidateCollection>& pfCand);

       
 
    private :

       void analyseNuclearWPrim(std::unique_ptr<reco::PFCandidateCollection>&, unsigned int);

       void analyseNuclearWSec(std::unique_ptr<reco::PFCandidateCollection>&, unsigned int);

       bool isPrimaryNucl( const reco::PFCandidate& pf ) const;

       bool isSecondaryNucl( const reco::PFCandidate& pf ) const;

       double rescaleFactor( const double pt, const double cFrac ) const;

       std::unique_ptr<reco::PFCandidateCollection> pfC_;
       std::vector<bool> bMask_;

       bool debug_;
       bool bCorrect_;

       bool bCalibPrimary_;
       std::vector< double > fConst_;
       std::vector< double > fNorm_;
       std::vector< double > fExp_;

       // Maximal accepatble uncertainty on primary tracks to usem them as MC truth for calibration
       double dptRel_PrimaryTrack_;
       double dptRel_MergedTrack_;
       double ptErrorSecondary_;

       static const double pion_mass2;
       static const reco::PFCandidate::Flags fT_TO_DISP_;
       static const reco::PFCandidate::Flags fT_FROM_DISP_;
};

#endif