test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Attributes
PFProducer Class Reference

Producer for particle flow reconstructed particles (PFCandidates) More...

#include <PFProducer.h>

Inheritance diagram for PFProducer:
edm::stream::EDProducer<> edm::stream::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

virtual void beginRun (const edm::Run &, const edm::EventSetup &) override
 
 PFProducer (const edm::ParameterSet &)
 
virtual void produce (edm::Event &, const edm::EventSetup &) override
 
 ~PFProducer ()
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
- Public Member Functions inherited from edm::stream::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDProducerBase ()
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 ProducerBase ()
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription
const &)> 		registrationCallback () const
 used by the fwk to register list of products More...
 
virtual ~ProducerBase ()
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Attributes

std::string calibrationsLabel_
 
std::string electronExtraOutputCol_
 
std::string electronOutputCol_
 
edm::EDGetTokenT
< reco::PFBlockCollection > 		inputTagBlocks_
 
std::vector< edm::EDGetTokenT
< reco::PFRecHitCollection > > 		inputTagCleanedHF_
 
edm::EDGetTokenT
< reco::GsfElectronCollection > 		inputTagEgammaElectrons_
 
edm::EDGetTokenT
< reco::MuonCollection > 		inputTagMuons_
 
edm::EDGetTokenT< edm::View
< reco::PFCandidate > > 		inputTagPFEGammaCandidates_
 
edm::EDGetTokenT
< edm::ValueMap
< reco::GsfElectronRef > > 		inputTagValueMapGedElectrons_
 
edm::EDGetTokenT
< edm::ValueMap
< reco::PhotonRef > > 		inputTagValueMapGedPhotons_
 
std::auto_ptr< PFAlgo > pfAlgo_
 particle flow algorithm More...
 
std::string photonExtraOutputCol_
 
bool postHFCleaning_
 
bool postMuonCleaning_
 
const GBRForest * ReaderEcalRes_
 
const GBRForest * ReaderGC_
 
const GBRForest * ReaderGCBarrel_
 
const GBRForest * ReaderGCEndCapHighr9_
 
const GBRForest * ReaderGCEndCapLowr9_
 
const GBRForest * ReaderLC_
 
const GBRForest * ReaderLCEB_
 
const GBRForest * ReaderLCEE_
 
const GBRForest * ReaderRes_
 
bool use_EGammaFilters_
 
bool useCalibrationsFromDB_
 
bool useEGammaElectrons_
 
bool useHO_
 
bool usePFElectrons_
 
bool usePFPhotons_
 
bool usePhotonReg_
 
bool useRegressionFromDB_
 
bool useVerticesForNeutral_
 
bool verbose_
 verbose ? More...
 
edm::EDGetTokenT
< reco::VertexCollection > 		vertices_
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...> CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T...> HasAbility
 
typedef
CacheTypes::LuminosityBlockCache 		LuminosityBlockCache
 
typedef
LuminosityBlockContextT
< LuminosityBlockCache,
RunCache, GlobalCache > 		LuminosityBlockContext
 
typedef
CacheTypes::LuminosityBlockSummaryCache 		LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache,
GlobalCache > 		RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase ModuleType
 
- Public Types inherited from edm::ProducerBase
typedef
ProductRegistryHelper::TypeLabelList 		TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

Producer for particle flow reconstructed particles (PFCandidates)

This producer makes use of PFAlgo, the particle flow algorithm.

Author
Colin Bernet
Date
July 2006

Definition at line 42 of file PFProducer.h.

Constructor & Destructor Documentation

PFProducer::PFProducer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 26 of file PFProducer.cc.

References HLT_25ns10e33_v2_cff::algoType, assert(), HLT_25ns10e33_v2_cff::calibHF_a_EMHAD, HLT_25ns10e33_v2_cff::calibHF_a_EMonly, HLT_25ns10e33_v2_cff::calibHF_b_EMHAD, HLT_25ns10e33_v2_cff::calibHF_b_HADonly, HLT_25ns10e33_v2_cff::calibHF_eta_step, HLT_25ns10e33_v2_cff::calibHF_use, HLT_25ns10e33_v2_cff::calibPFSCEle_barrel, HLT_25ns10e33_v2_cff::calibPFSCEle_endcap, HLT_25ns10e33_v2_cff::calibPFSCEle_Fbrem_barrel, HLT_25ns10e33_v2_cff::calibPFSCEle_Fbrem_endcap, HLT_25ns10e33_v2_cff::coneEcalIsoForEgammaSC, HLT_25ns10e33_v2_cff::coneTrackIsoForEgammaSC, HLT_25ns10e33_v2_cff::dptRel_DispVtx, edm::ParameterSet::existsAs(), edm::false, contentValuesFiles::fullPath, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), i, HLT_25ns10e33_v2_cff::iCfgCandConnector, LogDebug, HLT_25ns10e33_v2_cff::maxDeltaPhiPt, HLT_25ns10e33_v2_cff::maxSignificance, HLT_25ns10e33_v2_cff::minDeltaMet, HLT_25ns10e33_v2_cff::minHFCleaningPt, HLT_25ns10e33_v2_cff::minSignificance, HLT_25ns10e33_v2_cff::minSignificanceReduction, HLT_25ns10e33_v2_cff::nTrackIsoForEgammaSC, HLT_25ns10e33_v2_cff::rejectTracks_Bad, HLT_25ns10e33_v2_cff::rejectTracks_Step45, AlCaHLTBitMon_QueryRunRegistry::string, HLT_25ns10e33_v2_cff::sumEtEcalIsoForEgammaSC_barrel, HLT_25ns10e33_v2_cff::sumEtEcalIsoForEgammaSC_endcap, HLT_25ns10e33_v2_cff::sumPtTrackIsoForEgammaSC_barrel, HLT_25ns10e33_v2_cff::sumPtTrackIsoForEgammaSC_endcap, HLT_25ns10e33_v2_cff::sumPtTrackIsoForPhoton, HLT_25ns10e33_v2_cff::sumPtTrackIsoSlopeForPhoton, o2o::tags, HLT_25ns10e33_v2_cff::useEGammaSupercluster, HLT_25ns10e33_v2_cff::usePFConversions, HLT_25ns10e33_v2_cff::usePFDecays, HLT_25ns10e33_v2_cff::usePFNuclearInteractions, HLT_25ns10e33_v2_cff::usePFSCEleCalib, HLT_25ns10e33_v2_cff::useProtectionsForJetMET, and HLT_25ns10e33_v2_cff::X0_Map.

26  {
27 
28  //--ab: get calibration factors for HF:
29  bool calibHF_use;
30  std::vector<double> calibHF_eta_step;
31  std::vector<double> calibHF_a_EMonly;
32  std::vector<double> calibHF_b_HADonly;
33  std::vector<double> calibHF_a_EMHAD;
34  std::vector<double> calibHF_b_EMHAD;
35  calibHF_use = iConfig.getParameter<bool>("calibHF_use");
36  calibHF_eta_step = iConfig.getParameter<std::vector<double> >("calibHF_eta_step");
37  calibHF_a_EMonly = iConfig.getParameter<std::vector<double> >("calibHF_a_EMonly");
38  calibHF_b_HADonly = iConfig.getParameter<std::vector<double> >("calibHF_b_HADonly");
39  calibHF_a_EMHAD = iConfig.getParameter<std::vector<double> >("calibHF_a_EMHAD");
40  calibHF_b_EMHAD = iConfig.getParameter<std::vector<double> >("calibHF_b_EMHAD");
41  boost::shared_ptr<PFEnergyCalibrationHF>
42  thepfEnergyCalibrationHF ( new PFEnergyCalibrationHF(calibHF_use,calibHF_eta_step,calibHF_a_EMonly,calibHF_b_HADonly,calibHF_a_EMHAD,calibHF_b_EMHAD) ) ;
43  //-----------------
44 
45  inputTagBlocks_ = consumes<reco::PFBlockCollection>(iConfig.getParameter<InputTag>("blocks"));
46 
47  //Post cleaning of the muons
48  inputTagMuons_ = consumes<reco::MuonCollection>(iConfig.getParameter<InputTag>("muons"));
49  postMuonCleaning_
50  = iConfig.getParameter<bool>("postMuonCleaning");
51 
52  if( iConfig.existsAs<bool>("useEGammaFilters") ) {
53  use_EGammaFilters_ = iConfig.getParameter<bool>("useEGammaFilters");
54  } else {
55  use_EGammaFilters_ = false;
56  }
57 
58  usePFElectrons_
59  = iConfig.getParameter<bool>("usePFElectrons");
60 
61  usePFPhotons_
62  = iConfig.getParameter<bool>("usePFPhotons");
63 
64  // **************************** !! IMPORTANT !! ************************************
65  // When you code is swithed on, automatically turn off the old PFElectrons/PFPhotons.
66  // The two algorithms can not run at the same time
67  // *********************************************************************************
68 
69  if(use_EGammaFilters_) {
70  usePFElectrons_ = false;
71  usePFPhotons_ = false;
72  }
73 
74 
75  usePhotonReg_
76  = (usePFPhotons_) ? iConfig.getParameter<bool>("usePhotonReg") : false ;
77 
78  useRegressionFromDB_
79  = (usePFPhotons_) ? iConfig.getParameter<bool>("useRegressionFromDB") : false;
80 
81  useEGammaElectrons_
82  = iConfig.getParameter<bool>("useEGammaElectrons");
83 
84  if( useEGammaElectrons_) {
85  inputTagEgammaElectrons_ = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("egammaElectrons"));
86  }
87 
88  electronOutputCol_
89  = iConfig.getParameter<std::string>("pf_electron_output_col");
90 
91  bool usePFSCEleCalib;
92  std::vector<double> calibPFSCEle_Fbrem_barrel;
93  std::vector<double> calibPFSCEle_Fbrem_endcap;
94  std::vector<double> calibPFSCEle_barrel;
95  std::vector<double> calibPFSCEle_endcap;
96  usePFSCEleCalib = iConfig.getParameter<bool>("usePFSCEleCalib");
97  calibPFSCEle_Fbrem_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_barrel");
98  calibPFSCEle_Fbrem_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_endcap");
99  calibPFSCEle_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_barrel");
100  calibPFSCEle_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_endcap");
101  boost::shared_ptr<PFSCEnergyCalibration>
102  thePFSCEnergyCalibration ( new PFSCEnergyCalibration(calibPFSCEle_Fbrem_barrel,calibPFSCEle_Fbrem_endcap,
103  calibPFSCEle_barrel,calibPFSCEle_endcap ));
104 
105  bool useEGammaSupercluster = iConfig.getParameter<bool>("useEGammaSupercluster");
106  double sumEtEcalIsoForEgammaSC_barrel = iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_barrel");
107  double sumEtEcalIsoForEgammaSC_endcap = iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_endcap");
108  double coneEcalIsoForEgammaSC = iConfig.getParameter<double>("coneEcalIsoForEgammaSC");
109  double sumPtTrackIsoForEgammaSC_barrel = iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_barrel");
110  double sumPtTrackIsoForEgammaSC_endcap = iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_endcap");
111  double coneTrackIsoForEgammaSC = iConfig.getParameter<double>("coneTrackIsoForEgammaSC");
112  unsigned int nTrackIsoForEgammaSC = iConfig.getParameter<unsigned int>("nTrackIsoForEgammaSC");
113 
114 
115  // register products
116  produces<reco::PFCandidateCollection>();
117  produces<reco::PFCandidateCollection>("CleanedHF");
118  produces<reco::PFCandidateCollection>("CleanedCosmicsMuons");
119  produces<reco::PFCandidateCollection>("CleanedTrackerAndGlobalMuons");
120  produces<reco::PFCandidateCollection>("CleanedFakeMuons");
121  produces<reco::PFCandidateCollection>("CleanedPunchThroughMuons");
122  produces<reco::PFCandidateCollection>("CleanedPunchThroughNeutralHadrons");
123  produces<reco::PFCandidateCollection>("AddedMuonsAndHadrons");
124 
125 
126  if (usePFElectrons_) {
127  produces<reco::PFCandidateCollection>(electronOutputCol_);
128  produces<reco::PFCandidateElectronExtraCollection>(electronExtraOutputCol_);
129  }
130 
131  if (usePFPhotons_) {
132  produces<reco::PFCandidatePhotonExtraCollection>(photonExtraOutputCol_);
133  }
134 
135 
136  double nSigmaECAL
137  = iConfig.getParameter<double>("pf_nsigma_ECAL");
138  double nSigmaHCAL
139  = iConfig.getParameter<double>("pf_nsigma_HCAL");
140 
141  //PFElectrons Configuration
142  double mvaEleCut
143  = iConfig.getParameter<double>("pf_electron_mvaCut");
144 
145 
146  string mvaWeightFileEleID
147  = iConfig.getParameter<string>("pf_electronID_mvaWeightFile");
148 
149  bool applyCrackCorrectionsForElectrons
150  = iConfig.getParameter<bool>("pf_electronID_crackCorrection");
151 
152  string path_mvaWeightFileEleID;
153  if(usePFElectrons_)
154  {
155  path_mvaWeightFileEleID = edm::FileInPath ( mvaWeightFileEleID.c_str() ).fullPath();
156  }
157 
158  //PFPhoton Configuration
159 
160  string path_mvaWeightFileConvID;
161  string mvaWeightFileConvID;
162  string path_mvaWeightFileGCorr;
163  string path_mvaWeightFileLCorr;
164  string path_X0_Map;
165  string path_mvaWeightFileRes;
166  double mvaConvCut=-99.;
167  double sumPtTrackIsoForPhoton = 99.;
168  double sumPtTrackIsoSlopeForPhoton = 99.;
169 
170  if(usePFPhotons_ )
171  {
172  mvaWeightFileConvID =iConfig.getParameter<string>("pf_convID_mvaWeightFile");
173  mvaConvCut = iConfig.getParameter<double>("pf_conv_mvaCut");
174  path_mvaWeightFileConvID = edm::FileInPath ( mvaWeightFileConvID.c_str() ).fullPath();
175  sumPtTrackIsoForPhoton = iConfig.getParameter<double>("sumPtTrackIsoForPhoton");
176  sumPtTrackIsoSlopeForPhoton = iConfig.getParameter<double>("sumPtTrackIsoSlopeForPhoton");
177 
178  string X0_Map=iConfig.getParameter<string>("X0_Map");
179  path_X0_Map = edm::FileInPath( X0_Map.c_str() ).fullPath();
180 
181  if(!useRegressionFromDB_) {
182  string mvaWeightFileLCorr=iConfig.getParameter<string>("pf_locC_mvaWeightFile");
183  path_mvaWeightFileLCorr = edm::FileInPath( mvaWeightFileLCorr.c_str() ).fullPath();
184  string mvaWeightFileGCorr=iConfig.getParameter<string>("pf_GlobC_mvaWeightFile");
185  path_mvaWeightFileGCorr = edm::FileInPath( mvaWeightFileGCorr.c_str() ).fullPath();
186  string mvaWeightFileRes=iConfig.getParameter<string>("pf_Res_mvaWeightFile");
187  path_mvaWeightFileRes=edm::FileInPath(mvaWeightFileRes.c_str()).fullPath();
188 
189  TFile *fgbr = new TFile(path_mvaWeightFileGCorr.c_str(),"READ");
190  ReaderGC_ =(const GBRForest*)fgbr->Get("GBRForest");
191  TFile *fgbr2 = new TFile(path_mvaWeightFileLCorr.c_str(),"READ");
192  ReaderLC_ = (const GBRForest*)fgbr2->Get("GBRForest");
193  TFile *fgbr3 = new TFile(path_mvaWeightFileRes.c_str(),"READ");
194  ReaderRes_ = (const GBRForest*)fgbr3->Get("GBRForest");
195  LogDebug("PFProducer")<<"Will set regressions from binary files " <<endl;
196  }
197 
198  }
199 
200 
201  // Reading new EGamma selection cuts
202  bool useProtectionsForJetMET(false);
203  double ele_iso_pt(0.0), ele_iso_mva_barrel(0.0), ele_iso_mva_endcap(0.0),
204  ele_iso_combIso_barrel(0.0), ele_iso_combIso_endcap(0.0),
205  ele_noniso_mva(0.0);
206  unsigned int ele_missinghits(0);
207  double ph_MinEt(0.0), ph_combIso(0.0), ph_HoE(0.0),
208  ph_sietaieta_eb(0.0),ph_sietaieta_ee(0.0);
209  string ele_iso_mvaWeightFile(""), ele_iso_path_mvaWeightFile("");
210  edm::ParameterSet ele_protectionsForJetMET,ph_protectionsForJetMET;
211 
212  // Reading new EGamma ubiased collections and value maps
213  if(use_EGammaFilters_) {
214  ele_iso_mvaWeightFile = iConfig.getParameter<string>("isolatedElectronID_mvaWeightFile");
215  ele_iso_path_mvaWeightFile = edm::FileInPath ( ele_iso_mvaWeightFile.c_str() ).fullPath();
216  inputTagPFEGammaCandidates_ = consumes<edm::View<reco::PFCandidate> >((iConfig.getParameter<edm::InputTag>("PFEGammaCandidates")));
217  inputTagValueMapGedElectrons_ = consumes<edm::ValueMap<reco::GsfElectronRef>>(iConfig.getParameter<edm::InputTag>("GedElectronValueMap"));
218  inputTagValueMapGedPhotons_ = consumes<edm::ValueMap<reco::PhotonRef> >(iConfig.getParameter<edm::InputTag>("GedPhotonValueMap"));
219  ele_iso_pt = iConfig.getParameter<double>("electron_iso_pt");
220  ele_iso_mva_barrel = iConfig.getParameter<double>("electron_iso_mva_barrel");
221  ele_iso_mva_endcap = iConfig.getParameter<double>("electron_iso_mva_endcap");
222  ele_iso_combIso_barrel = iConfig.getParameter<double>("electron_iso_combIso_barrel");
223  ele_iso_combIso_endcap = iConfig.getParameter<double>("electron_iso_combIso_endcap");
224  ele_noniso_mva = iConfig.getParameter<double>("electron_noniso_mvaCut");
225  ele_missinghits = iConfig.getParameter<unsigned int>("electron_missinghits");
226  ph_MinEt = iConfig.getParameter<double>("photon_MinEt");
227  ph_combIso = iConfig.getParameter<double>("photon_combIso");
228  ph_HoE = iConfig.getParameter<double>("photon_HoE");
229  ph_sietaieta_eb = iConfig.getParameter<double>("photon_SigmaiEtaiEta_barrel");
230  ph_sietaieta_ee = iConfig.getParameter<double>("photon_SigmaiEtaiEta_endcap");
231  useProtectionsForJetMET =
232  iConfig.getParameter<bool>("useProtectionsForJetMET");
233  ele_protectionsForJetMET =
234  iConfig.getParameter<edm::ParameterSet>("electron_protectionsForJetMET");
235  ph_protectionsForJetMET =
236  iConfig.getParameter<edm::ParameterSet>("photon_protectionsForJetMET");
237  }
238 
239  //Secondary tracks and displaced vertices parameters
240 
241  bool rejectTracks_Bad
242  = iConfig.getParameter<bool>("rejectTracks_Bad");
243 
244  bool rejectTracks_Step45
245  = iConfig.getParameter<bool>("rejectTracks_Step45");
246 
247  bool usePFNuclearInteractions
248  = iConfig.getParameter<bool>("usePFNuclearInteractions");
249 
250  bool usePFConversions
251  = iConfig.getParameter<bool>("usePFConversions");
252 
253  bool usePFDecays
254  = iConfig.getParameter<bool>("usePFDecays");
255 
256  double dptRel_DispVtx
257  = iConfig.getParameter<double>("dptRel_DispVtx");
258 
259  edm::ParameterSet iCfgCandConnector
260  = iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector");
261 
262 
263  // fToRead = iConfig.getUntrackedParameter<vector<string> >("toRead");
264 
265  useCalibrationsFromDB_
266  = iConfig.getParameter<bool>("useCalibrationsFromDB");
267 
268  if (useCalibrationsFromDB_)
269  calibrationsLabel_ = iConfig.getParameter<std::string>("calibrationsLabel");
270 
271  boost::shared_ptr<PFEnergyCalibration>
272  calibration( new PFEnergyCalibration() );
273 
274  int algoType
275  = iConfig.getParameter<unsigned>("algoType");
276 
277  switch(algoType) {
278  case 0:
279  pfAlgo_.reset( new PFAlgo);
280  break;
281  default:
282  assert(0);
283  }
284 
285  pfAlgo_->setParameters( nSigmaECAL,
286  nSigmaHCAL,
287  calibration,
288  thepfEnergyCalibrationHF);
289 
290  //PFElectrons: call the method setpfeleparameters
291  pfAlgo_->setPFEleParameters(mvaEleCut,
292  path_mvaWeightFileEleID,
293  usePFElectrons_,
294  thePFSCEnergyCalibration,
295  calibration,
296  sumEtEcalIsoForEgammaSC_barrel,
297  sumEtEcalIsoForEgammaSC_endcap,
298  coneEcalIsoForEgammaSC,
299  sumPtTrackIsoForEgammaSC_barrel,
300  sumPtTrackIsoForEgammaSC_endcap,
301  nTrackIsoForEgammaSC,
302  coneTrackIsoForEgammaSC,
303  applyCrackCorrectionsForElectrons,
304  usePFSCEleCalib,
305  useEGammaElectrons_,
306  useEGammaSupercluster);
307 
308  // pfAlgo_->setPFConversionParameters(usePFConversions);
309 
310  // PFPhotons:
311  pfAlgo_->setPFPhotonParameters(usePFPhotons_,
312  path_mvaWeightFileConvID,
313  mvaConvCut,
314  usePhotonReg_,
315  path_X0_Map,
316  calibration,
317  sumPtTrackIsoForPhoton,
318  sumPtTrackIsoSlopeForPhoton);
319 
320 
321  // NEW EGamma Filters
322  pfAlgo_->setEGammaParameters(use_EGammaFilters_,
323  ele_iso_path_mvaWeightFile,
324  ele_iso_pt,
325  ele_iso_mva_barrel,
326  ele_iso_mva_endcap,
327  ele_iso_combIso_barrel,
328  ele_iso_combIso_endcap,
329  ele_noniso_mva,
330  ele_missinghits,
331  useProtectionsForJetMET,
332  ele_protectionsForJetMET,
333  ph_MinEt,
334  ph_combIso,
335  ph_HoE,
336  ph_sietaieta_eb,
337  ph_sietaieta_ee,
338  ph_protectionsForJetMET);
339 
340  //Secondary tracks and displaced vertices parameters
341 
342  pfAlgo_->setDisplacedVerticesParameters(rejectTracks_Bad,
343  rejectTracks_Step45,
344  usePFNuclearInteractions,
345  usePFConversions,
346  usePFDecays,
347  dptRel_DispVtx);
348 
349  if (usePFNuclearInteractions)
350  pfAlgo_->setCandConnectorParameters( iCfgCandConnector );
351 
352 
353 
354  // Set muon and fake track parameters
355  pfAlgo_->setPFMuonAndFakeParameters(iConfig);
356 
357  //Post cleaning of the HF
358  postHFCleaning_
359  = iConfig.getParameter<bool>("postHFCleaning");
360  double minHFCleaningPt
361  = iConfig.getParameter<double>("minHFCleaningPt");
362  double minSignificance
363  = iConfig.getParameter<double>("minSignificance");
364  double maxSignificance
365  = iConfig.getParameter<double>("maxSignificance");
366  double minSignificanceReduction
367  = iConfig.getParameter<double>("minSignificanceReduction");
368  double maxDeltaPhiPt
369  = iConfig.getParameter<double>("maxDeltaPhiPt");
370  double minDeltaMet
371  = iConfig.getParameter<double>("minDeltaMet");
372 
373  // Set post HF cleaning muon parameters
374  pfAlgo_->setPostHFCleaningParameters(postHFCleaning_,
375  minHFCleaningPt,
376  minSignificance,
377  maxSignificance,
378  minSignificanceReduction,
379  maxDeltaPhiPt,
380  minDeltaMet);
381 
382  // Input tags for HF cleaned rechits
383  std::vector<edm::InputTag> tags =iConfig.getParameter< std::vector<edm::InputTag> >("cleanedHF");
384  for (unsigned int i=0;i<tags.size();++i)
385  inputTagCleanedHF_.push_back(consumes<reco::PFRecHitCollection>(tags[i]));
386  //MIKE: Vertex Parameters
387  vertices_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"));
388  useVerticesForNeutral_ = iConfig.getParameter<bool>("useVerticesForNeutral");
389 
390  // Use HO clusters and links in the PF reconstruction
391  useHO_= iConfig.getParameter<bool>("useHO");
392  pfAlgo_->setHOTag(useHO_);
393 
394  verbose_ =
395  iConfig.getUntrackedParameter<bool>("verbose",false);
396 
397  bool debug_ =
398  iConfig.getUntrackedParameter<bool>("debug",false);
399 
400  pfAlgo_->setDebug( debug_ );
401 
402 }
PFProducer::inputTagCleanedHF_
std::vector< edm::EDGetTokenT< reco::PFRecHitCollection > > inputTagCleanedHF_
Definition: PFProducer.h:57
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
PFProducer::ReaderRes_
const GBRForest * ReaderRes_
Definition: PFProducer.h:90
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
PFProducer::photonExtraOutputCol_
std::string photonExtraOutputCol_
Definition: PFProducer.h:60
i
int i
Definition: DBlmapReader.cc:9
PFProducer::inputTagMuons_
edm::EDGetTokenT< reco::MuonCollection > inputTagMuons_
Definition: PFProducer.h:52
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:186
HLT_25ns10e33_v2_cff.calibPFSCEle_Fbrem_endcap
tuple calibPFSCEle_Fbrem_endcap
Definition: HLT_25ns10e33_v2_cff.py:8163
HLT_25ns10e33_v2_cff.calibHF_a_EMHAD
tuple calibHF_a_EMHAD
Definition: HLT_25ns10e33_v2_cff.py:8199
HLT_25ns10e33_v2_cff.X0_Map
tuple X0_Map
Definition: HLT_25ns10e33_v2_cff.py:8188
HLT_25ns10e33_v2_cff.rejectTracks_Step45
tuple rejectTracks_Step45
Definition: HLT_25ns10e33_v2_cff.py:8090
HLT_25ns10e33_v2_cff.calibPFSCEle_barrel
tuple calibPFSCEle_barrel
Definition: HLT_25ns10e33_v2_cff.py:8169
HLT_25ns10e33_v2_cff.calibHF_a_EMonly
tuple calibHF_a_EMonly
Definition: HLT_25ns10e33_v2_cff.py:8149
PFProducer::pfAlgo_
std::auto_ptr< PFAlgo > pfAlgo_
particle flow algorithm
Definition: PFProducer.h:112
PFProducer::calibrationsLabel_
std::string calibrationsLabel_
Definition: PFProducer.h:105
assert
assert(m_qm.get())
HLT_25ns10e33_v2_cff.iCfgCandConnector
tuple iCfgCandConnector
Definition: HLT_25ns10e33_v2_cff.py:8140
PFProducer::ReaderLC_
const GBRForest * ReaderLC_
Definition: PFProducer.h:89
HLT_25ns10e33_v2_cff.minSignificance
tuple minSignificance
Definition: HLT_25ns10e33_v2_cff.py:8100
HLT_25ns10e33_v2_cff.calibHF_b_EMHAD
tuple calibHF_b_EMHAD
Definition: HLT_25ns10e33_v2_cff.py:8159
HLT_25ns10e33_v2_cff.minHFCleaningPt
tuple minHFCleaningPt
Definition: HLT_25ns10e33_v2_cff.py:8152
PFProducer::useCalibrationsFromDB_
bool useCalibrationsFromDB_
Definition: PFProducer.h:104
PFProducer::use_EGammaFilters_
bool use_EGammaFilters_
Definition: PFProducer.h:67
PFProducer::vertices_
edm::EDGetTokenT< reco::VertexCollection > vertices_
Definition: PFProducer.h:53
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
HLT_25ns10e33_v2_cff.dptRel_DispVtx
tuple dptRel_DispVtx
Definition: HLT_25ns10e33_v2_cff.py:8079
HLT_25ns10e33_v2_cff.maxSignificance
tuple maxSignificance
Definition: HLT_25ns10e33_v2_cff.py:8094
HLT_25ns10e33_v2_cff.sumEtEcalIsoForEgammaSC_barrel
tuple sumEtEcalIsoForEgammaSC_barrel
Definition: HLT_25ns10e33_v2_cff.py:8162
PFProducer::useVerticesForNeutral_
bool useVerticesForNeutral_
Definition: PFProducer.h:101
HLT_25ns10e33_v2_cff.usePFDecays
tuple usePFDecays
Definition: HLT_25ns10e33_v2_cff.py:8089
PFProducer::postHFCleaning_
bool postHFCleaning_
Definition: PFProducer.h:107
HLT_25ns10e33_v2_cff.minSignificanceReduction
tuple minSignificanceReduction
Definition: HLT_25ns10e33_v2_cff.py:8137
PFProducer::postMuonCleaning_
bool postMuonCleaning_
Definition: PFProducer.h:77
HLT_25ns10e33_v2_cff.nTrackIsoForEgammaSC
tuple nTrackIsoForEgammaSC
Definition: HLT_25ns10e33_v2_cff.py:8080
HLT_25ns10e33_v2_cff.sumEtEcalIsoForEgammaSC_endcap
tuple sumEtEcalIsoForEgammaSC_endcap
Definition: HLT_25ns10e33_v2_cff.py:8158
HLT_25ns10e33_v2_cff.minDeltaMet
tuple minDeltaMet
Definition: HLT_25ns10e33_v2_cff.py:8126
HLT_25ns10e33_v2_cff.calibHF_use
tuple calibHF_use
Definition: HLT_25ns10e33_v2_cff.py:8131
HLT_25ns10e33_v2_cff.sumPtTrackIsoForEgammaSC_barrel
tuple sumPtTrackIsoForEgammaSC_barrel
Definition: HLT_25ns10e33_v2_cff.py:8087
HLT_25ns10e33_v2_cff.calibHF_eta_step
tuple calibHF_eta_step
Definition: HLT_25ns10e33_v2_cff.py:8098
HLT_25ns10e33_v2_cff.coneTrackIsoForEgammaSC
tuple coneTrackIsoForEgammaSC
Definition: HLT_25ns10e33_v2_cff.py:8125
PFProducer::inputTagPFEGammaCandidates_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > inputTagPFEGammaCandidates_
Definition: PFProducer.h:65
HLT_25ns10e33_v2_cff.calibPFSCEle_Fbrem_barrel
tuple calibPFSCEle_Fbrem_barrel
Definition: HLT_25ns10e33_v2_cff.py:8189
PFProducer::inputTagBlocks_
edm::EDGetTokenT< reco::PFBlockCollection > inputTagBlocks_
Definition: PFProducer.h:51
HLT_25ns10e33_v2_cff.calibHF_b_HADonly
tuple calibHF_b_HADonly
Definition: HLT_25ns10e33_v2_cff.py:8114
o2o.tags
tuple tags
Definition: o2o.py:248
PFProducer::useHO_
bool useHO_
Definition: PFProducer.h:71
PFProducer::useRegressionFromDB_
bool useRegressionFromDB_
Definition: PFProducer.h:87
HLT_25ns10e33_v2_cff.sumPtTrackIsoForEgammaSC_endcap
tuple sumPtTrackIsoForEgammaSC_endcap
Definition: HLT_25ns10e33_v2_cff.py:8130
HLT_25ns10e33_v2_cff.usePFSCEleCalib
tuple usePFSCEleCalib
Definition: HLT_25ns10e33_v2_cff.py:8202
PFProducer::usePFElectrons_
bool usePFElectrons_
Definition: PFProducer.h:80
PFProducer::electronOutputCol_
std::string electronOutputCol_
Definition: PFProducer.h:58
HLT_25ns10e33_v2_cff.usePFNuclearInteractions
tuple usePFNuclearInteractions
Definition: HLT_25ns10e33_v2_cff.py:8093
PFProducer::verbose_
bool verbose_
verbose ?
Definition: PFProducer.h:74
PFProducer::electronExtraOutputCol_
std::string electronExtraOutputCol_
Definition: PFProducer.h:59
PFProducer::useEGammaElectrons_
bool useEGammaElectrons_
Definition: PFProducer.h:98
HLT_25ns10e33_v2_cff.algoType
tuple algoType
Definition: HLT_25ns10e33_v2_cff.py:8165
HLT_25ns10e33_v2_cff.maxDeltaPhiPt
tuple maxDeltaPhiPt
Definition: HLT_25ns10e33_v2_cff.py:8156
PFProducer::inputTagValueMapGedPhotons_
edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > > inputTagValueMapGedPhotons_
Definition: PFProducer.h:64
HLT_25ns10e33_v2_cff.sumPtTrackIsoSlopeForPhoton
tuple sumPtTrackIsoSlopeForPhoton
Definition: HLT_25ns10e33_v2_cff.py:8124
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
HLT_25ns10e33_v2_cff.rejectTracks_Bad
tuple rejectTracks_Bad
Definition: HLT_25ns10e33_v2_cff.py:8146
HLT_25ns10e33_v2_cff.calibPFSCEle_endcap
tuple calibPFSCEle_endcap
Definition: HLT_25ns10e33_v2_cff.py:8134
PFAlgo
Definition: PFAlgo.h:52
HLT_25ns10e33_v2_cff.sumPtTrackIsoForPhoton
tuple sumPtTrackIsoForPhoton
Definition: HLT_25ns10e33_v2_cff.py:8072
PFProducer::inputTagEgammaElectrons_
edm::EDGetTokenT< reco::GsfElectronCollection > inputTagEgammaElectrons_
Definition: PFProducer.h:54
PFProducer::usePhotonReg_
bool usePhotonReg_
Definition: PFProducer.h:86
HLT_25ns10e33_v2_cff.useEGammaSupercluster
tuple useEGammaSupercluster
Definition: HLT_25ns10e33_v2_cff.py:8086
PFProducer::inputTagValueMapGedElectrons_
edm::EDGetTokenT< edm::ValueMap< reco::GsfElectronRef > > inputTagValueMapGedElectrons_
Definition: PFProducer.h:63
HLT_25ns10e33_v2_cff.coneEcalIsoForEgammaSC
tuple coneEcalIsoForEgammaSC
Definition: HLT_25ns10e33_v2_cff.py:8111
PFProducer::ReaderGC_
const GBRForest * ReaderGC_
Definition: PFProducer.h:88
HLT_25ns10e33_v2_cff.usePFConversions
tuple usePFConversions
Definition: HLT_25ns10e33_v2_cff.py:8133
HLT_25ns10e33_v2_cff.useProtectionsForJetMET
tuple useProtectionsForJetMET
Definition: HLT_25ns10e33_v2_cff.py:8128
PFProducer::~PFProducer ( )

Definition at line 406 of file PFProducer.cc.

406 {}

Member Function Documentation

void PFProducer::beginRun ( const edm::Run &  run,
const edm::EventSetup &  es 
)
overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 409 of file PFProducer.cc.

References edm::EventSetup::get(), and edm::ESHandle< class >::product().

411 {
412 
413 
414  /*
415  static map<string, PerformanceResult::ResultType> functType;
416 
417  functType["PFfa_BARREL"] = PerformanceResult::PFfa_BARREL;
418  functType["PFfa_ENDCAP"] = PerformanceResult::PFfa_ENDCAP;
419  functType["PFfb_BARREL"] = PerformanceResult::PFfb_BARREL;
420  functType["PFfb_ENDCAP"] = PerformanceResult::PFfb_ENDCAP;
421  functType["PFfc_BARREL"] = PerformanceResult::PFfc_BARREL;
422  functType["PFfc_ENDCAP"] = PerformanceResult::PFfc_ENDCAP;
423  functType["PFfaEta_BARREL"] = PerformanceResult::PFfaEta_BARREL;
424  functType["PFfaEta_ENDCAP"] = PerformanceResult::PFfaEta_ENDCAP;
425  functType["PFfbEta_BARREL"] = PerformanceResult::PFfbEta_BARREL;
426  functType["PFfbEta_ENDCAP"] = PerformanceResult::PFfbEta_ENDCAP;
427  */
428 
429  if ( useCalibrationsFromDB_ ) {
430  // read the PFCalibration functions from the global tags
431  edm::ESHandle<PerformancePayload> perfH;
432  es.get<PFCalibrationRcd>().get(calibrationsLabel_, perfH);
433 
434  PerformancePayloadFromTFormula const * pfCalibrations = static_cast< const PerformancePayloadFromTFormula *>(perfH.product());
435 
436  pfAlgo_->thePFEnergyCalibration()->setCalibrationFunctions(pfCalibrations);
437  }
438 
439  /*
440  for(vector<string>::const_iterator name = fToRead.begin(); name != fToRead.end(); ++name) {
441 
442  cout << "Function: " << *name << endl;
443  PerformanceResult::ResultType fType = functType[*name];
444  pfCalibrations->printFormula(fType);
445 
446  // evaluate it @ 10 GeV
447  float energy = 10.;
448 
449  BinningPointByMap point;
450  point.insert(BinningVariables::JetEt, energy);
451 
452  if(pfCalibrations->isInPayload(fType, point)) {
453  float value = pfCalibrations->getResult(fType, point);
454  cout << " Energy before:: " << energy << " after: " << value << endl;
455  } else cout << "outside limits!" << endl;
456 
457  }
458  */
459 
460  if(usePFPhotons_ && useRegressionFromDB_) {
461  edm::ESHandle<GBRForest> readerPFLCEB;
462  edm::ESHandle<GBRForest> readerPFLCEE;
463  edm::ESHandle<GBRForest> readerPFGCEB;
464  edm::ESHandle<GBRForest> readerPFGCEEHR9;
465  edm::ESHandle<GBRForest> readerPFGCEELR9;
466  edm::ESHandle<GBRForest> readerPFRes;
467  es.get<GBRWrapperRcd>().get("PFLCorrectionBar",readerPFLCEB);
468  ReaderLCEB_=readerPFLCEB.product();
469  es.get<GBRWrapperRcd>().get("PFLCorrectionEnd",readerPFLCEE);
470  ReaderLCEE_=readerPFLCEE.product();
471  es.get<GBRWrapperRcd>().get("PFGCorrectionBar",readerPFGCEB);
472  ReaderGCBarrel_=readerPFGCEB.product();
473  es.get<GBRWrapperRcd>().get("PFGCorrectionEndHighR9",readerPFGCEEHR9);
474  ReaderGCEndCapHighr9_=readerPFGCEEHR9.product();
475  es.get<GBRWrapperRcd>().get("PFGCorrectionEndLowR9",readerPFGCEELR9);
476  ReaderGCEndCapLowr9_=readerPFGCEELR9.product();
477  es.get<GBRWrapperRcd>().get("PFEcalResolution",readerPFRes);
478  ReaderEcalRes_=readerPFRes.product();
479 
480  /*
481  LogDebug("PFProducer")<<"setting regressions from DB "<<endl;
482  */
483  }
484 
485  if(usePFPhotons_){
486  //pfAlgo_->setPFPhotonRegWeights(ReaderLC_, ReaderGC_, ReaderRes_);
487  pfAlgo_->setPFPhotonRegWeights(ReaderLCEB_,ReaderLCEE_,ReaderGCBarrel_,ReaderGCEndCapHighr9_, ReaderGCEndCapLowr9_, ReaderEcalRes_ );
488  }
489 }
PFProducer::ReaderEcalRes_
const GBRForest * ReaderEcalRes_
Definition: PFProducer.h:96
PFProducer::ReaderLCEB_
const GBRForest * ReaderLCEB_
Definition: PFProducer.h:91
PFProducer::ReaderGCEndCapHighr9_
const GBRForest * ReaderGCEndCapHighr9_
Definition: PFProducer.h:94
PFProducer::pfAlgo_
std::auto_ptr< PFAlgo > pfAlgo_
particle flow algorithm
Definition: PFProducer.h:112
PFProducer::calibrationsLabel_
std::string calibrationsLabel_
Definition: PFProducer.h:105
PFProducer::useCalibrationsFromDB_
bool useCalibrationsFromDB_
Definition: PFProducer.h:104
PFProducer::ReaderLCEE_
const GBRForest * ReaderLCEE_
Definition: PFProducer.h:92
PFProducer::ReaderGCEndCapLowr9_
const GBRForest * ReaderGCEndCapLowr9_
Definition: PFProducer.h:95
PFProducer::useRegressionFromDB_
bool useRegressionFromDB_
Definition: PFProducer.h:87
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
PFProducer::ReaderGCBarrel_
const GBRForest * ReaderGCBarrel_
Definition: PFProducer.h:93
void PFProducer::produce ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 493 of file PFProducer.cc.

References assert(), gather_cfg::blocks, gather_cfg::cout, edm::EventID::event(), edm::Event::getByToken(), edm::EventBase::id(), ihf, edm::HandleBase::isValid(), LogDebug, patZpeak::muons, edm::Handle< T >::product(), edm::Event::put(), edm::EventID::run(), and HLT_25ns10e33_v2_cff::vertices.

494  {
495 
496  LogDebug("PFProducer")<<"START event: "
497  <<iEvent.id().event()
498  <<" in run "<<iEvent.id().run()<<endl;
499 
500 
501  // Get The vertices from the event
502  // and assign dynamic vertex parameters
503  edm::Handle<reco::VertexCollection> vertices;
504  bool gotVertices = iEvent.getByToken(vertices_,vertices);
505  if(!gotVertices) {
506  ostringstream err;
507  err<<"Cannot find vertices for this event.Continuing Without them ";
508  LogError("PFProducer")<<err.str()<<endl;
509  }
510 
511  //Assign the PFAlgo Parameters
512  pfAlgo_->setPFVertexParameters(useVerticesForNeutral_,vertices.product());
513 
514  // get the collection of blocks
515 
516  Handle< reco::PFBlockCollection > blocks;
517 
518  iEvent.getByToken( inputTagBlocks_, blocks );
519 
520  // get the collection of muons
521 
522  Handle< reco::MuonCollection > muons;
523 
524  if ( postMuonCleaning_ ) {
525 
526  iEvent.getByToken( inputTagMuons_, muons );
527  pfAlgo_->setMuonHandle(muons);
528  }
529 
530  if (useEGammaElectrons_) {
531  Handle < reco::GsfElectronCollection > egelectrons;
532  iEvent.getByToken( inputTagEgammaElectrons_, egelectrons );
533  pfAlgo_->setEGElectronCollection(*egelectrons);
534  }
535 
536  if(use_EGammaFilters_) {
537 
538  // Read PFEGammaCandidates
539 
540  edm::Handle<edm::View<reco::PFCandidate> > pfEgammaCandidates;
541  iEvent.getByToken(inputTagPFEGammaCandidates_,pfEgammaCandidates);
542 
543  // Get the value maps
544 
545  edm::Handle<edm::ValueMap<reco::GsfElectronRef> > valueMapGedElectrons;
546  iEvent.getByToken(inputTagValueMapGedElectrons_,valueMapGedElectrons);
547 
548  edm::Handle<edm::ValueMap<reco::PhotonRef> > valueMapGedPhotons;
549  iEvent.getByToken(inputTagValueMapGedPhotons_,valueMapGedPhotons);
550 
551  pfAlgo_->setEGammaCollections(*pfEgammaCandidates,
552  *valueMapGedElectrons,
553  *valueMapGedPhotons);
554 
555  }
556 
557 
558  LogDebug("PFProducer")<<"particle flow is starting"<<endl;
559 
560  assert( blocks.isValid() );
561 
562  pfAlgo_->reconstructParticles( blocks );
563 
564  if(verbose_) {
565  ostringstream str;
566  str<<(*pfAlgo_)<<endl;
567  // cout << (*pfAlgo_) << endl;
568  LogInfo("PFProducer") <<str.str()<<endl;
569  }
570 
571 
572  // Florian 5/01/2011
573  // Save the PFElectron Extra Collection First as to be able to create valid References
574  if(usePFElectrons_) {
575  auto_ptr< reco::PFCandidateElectronExtraCollection >
576  pOutputElectronCandidateExtraCollection( pfAlgo_->transferElectronExtra() );
577 
578  const edm::OrphanHandle<reco::PFCandidateElectronExtraCollection > electronExtraProd=
579  iEvent.put(pOutputElectronCandidateExtraCollection,electronExtraOutputCol_);
580  pfAlgo_->setElectronExtraRef(electronExtraProd);
581  }
582 
583  // Daniele 18/05/2011
584  // Save the PFPhoton Extra Collection First as to be able to create valid References
585  if(usePFPhotons_) {
586  auto_ptr< reco::PFCandidatePhotonExtraCollection >
587  pOutputPhotonCandidateExtraCollection( pfAlgo_->transferPhotonExtra() );
588 
589  const edm::OrphanHandle<reco::PFCandidatePhotonExtraCollection > photonExtraProd=
590  iEvent.put(pOutputPhotonCandidateExtraCollection,photonExtraOutputCol_);
591  pfAlgo_->setPhotonExtraRef(photonExtraProd);
592  }
593 
594  // Save cosmic cleaned muon candidates
595  auto_ptr< reco::PFCandidateCollection >
596  pCosmicsMuonCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedCosmicCandidates() );
597  // Save tracker/global cleaned muon candidates
598  auto_ptr< reco::PFCandidateCollection >
599  pTrackerAndGlobalCleanedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedTrackerAndGlobalCandidates() );
600  // Save fake cleaned muon candidates
601  auto_ptr< reco::PFCandidateCollection >
602  pFakeCleanedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedFakeCandidates() );
603  // Save punch-through cleaned muon candidates
604  auto_ptr< reco::PFCandidateCollection >
605  pPunchThroughMuonCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferPunchThroughCleanedMuonCandidates() );
606  // Save punch-through cleaned neutral hadron candidates
607  auto_ptr< reco::PFCandidateCollection >
608  pPunchThroughHadronCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferPunchThroughCleanedHadronCandidates() );
609  // Save added muon candidates
610  auto_ptr< reco::PFCandidateCollection >
611  pAddedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferAddedMuonCandidates() );
612 
613  // Check HF overcleaning
614  reco::PFRecHitCollection hfCopy;
615  for ( unsigned ihf=0; ihf<inputTagCleanedHF_.size(); ++ihf ) {
616  Handle< reco::PFRecHitCollection > hfCleaned;
617  bool foundHF = iEvent.getByToken( inputTagCleanedHF_[ihf], hfCleaned );
618  if (!foundHF) continue;
619  for ( unsigned jhf=0; jhf<(*hfCleaned).size(); ++jhf ) {
620  hfCopy.push_back( (*hfCleaned)[jhf] );
621  }
622  }
623 
624  if (postHFCleaning_)
625  pfAlgo_->checkCleaning( hfCopy );
626 
627  // Save recovered HF candidates
628  auto_ptr< reco::PFCandidateCollection >
629  pCleanedCandidateCollection( pfAlgo_->transferCleanedCandidates() );
630 
631 
632  // Save the final PFCandidate collection
633  auto_ptr< reco::PFCandidateCollection >
634  pOutputCandidateCollection( pfAlgo_->transferCandidates() );
635 
636 
637 
638  LogDebug("PFProducer")<<"particle flow: putting products in the event"<<endl;
639  if ( verbose_ ) std::cout <<"particle flow: putting products in the event. Here the full list"<<endl;
640  int nC=0;
641  for( reco::PFCandidateCollection::const_iterator itCand = (*pOutputCandidateCollection).begin(); itCand != (*pOutputCandidateCollection).end(); itCand++) {
642  nC++;
643  if (verbose_ ) std::cout << nC << ")" << (*itCand).particleId() << std::endl;
644 
645  }
646 
647 
648 
649  // Write in the event
650  iEvent.put(pOutputCandidateCollection);
651  iEvent.put(pCleanedCandidateCollection,"CleanedHF");
652 
653  if ( postMuonCleaning_ ) {
654  iEvent.put(pCosmicsMuonCleanedCandidateCollection,"CleanedCosmicsMuons");
655  iEvent.put(pTrackerAndGlobalCleanedMuonCandidateCollection,"CleanedTrackerAndGlobalMuons");
656  iEvent.put(pFakeCleanedMuonCandidateCollection,"CleanedFakeMuons");
657  iEvent.put(pPunchThroughMuonCleanedCandidateCollection,"CleanedPunchThroughMuons");
658  iEvent.put(pPunchThroughHadronCleanedCandidateCollection,"CleanedPunchThroughNeutralHadrons");
659  iEvent.put(pAddedMuonCandidateCollection,"AddedMuonsAndHadrons");
660  }
661 
662  if(usePFElectrons_)
663  {
664  auto_ptr< reco::PFCandidateCollection >
665  pOutputElectronCandidateCollection( pfAlgo_->transferElectronCandidates() );
666  iEvent.put(pOutputElectronCandidateCollection,electronOutputCol_);
667 
668  }
669 }
PFProducer::inputTagCleanedHF_
std::vector< edm::EDGetTokenT< reco::PFRecHitCollection > > inputTagCleanedHF_
Definition: PFProducer.h:57
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:39
edm::EventID::event
EventNumber_t event() const
Definition: EventID.h:41
PFProducer::photonExtraOutputCol_
std::string photonExtraOutputCol_
Definition: PFProducer.h:60
PFProducer::inputTagMuons_
edm::EDGetTokenT< reco::MuonCollection > inputTagMuons_
Definition: PFProducer.h:52
ihf
int ihf
Definition: CascadeWrapper.h:31
HLT_25ns10e33_v2_cff.vertices
tuple vertices
Definition: HLT_25ns10e33_v2_cff.py:6505
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:462
PFProducer::pfAlgo_
std::auto_ptr< PFAlgo > pfAlgo_
particle flow algorithm
Definition: PFProducer.h:112
assert
assert(m_qm.get())
reco::PFRecHitCollection
std::vector< PFRecHit > PFRecHitCollection
collection of PFRecHit objects
Definition: PFRecHitFwd.h:9
PFProducer::use_EGammaFilters_
bool use_EGammaFilters_
Definition: PFProducer.h:67
PFProducer::vertices_
edm::EDGetTokenT< reco::VertexCollection > vertices_
Definition: PFProducer.h:53
PFProducer::useVerticesForNeutral_
bool useVerticesForNeutral_
Definition: PFProducer.h:101
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:121
PFProducer::postHFCleaning_
bool postHFCleaning_
Definition: PFProducer.h:107
PFProducer::postMuonCleaning_
bool postMuonCleaning_
Definition: PFProducer.h:77
PFProducer::inputTagPFEGammaCandidates_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > inputTagPFEGammaCandidates_
Definition: PFProducer.h:65
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
PFProducer::inputTagBlocks_
edm::EDGetTokenT< reco::PFBlockCollection > inputTagBlocks_
Definition: PFProducer.h:51
PFProducer::usePFElectrons_
bool usePFElectrons_
Definition: PFProducer.h:80
edm::Handle::product
T const * product() const
Definition: Handle.h:81
PFProducer::electronOutputCol_
std::string electronOutputCol_
Definition: PFProducer.h:58
PFProducer::verbose_
bool verbose_
verbose ?
Definition: PFProducer.h:74
gather_cfg.blocks
list blocks
Definition: gather_cfg.py:90
PFProducer::electronExtraOutputCol_
std::string electronExtraOutputCol_
Definition: PFProducer.h:59
PFProducer::useEGammaElectrons_
bool useEGammaElectrons_
Definition: PFProducer.h:98
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:59
PFProducer::inputTagValueMapGedPhotons_
edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > > inputTagValueMapGedPhotons_
Definition: PFProducer.h:64
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
PFProducer::inputTagEgammaElectrons_
edm::EDGetTokenT< reco::GsfElectronCollection > inputTagEgammaElectrons_
Definition: PFProducer.h:54
PFProducer::inputTagValueMapGedElectrons_
edm::EDGetTokenT< edm::ValueMap< reco::GsfElectronRef > > inputTagValueMapGedElectrons_
Definition: PFProducer.h:63

Member Data Documentation

std::string PFProducer::calibrationsLabel_
private

Definition at line 105 of file PFProducer.h.

std::string PFProducer::electronExtraOutputCol_
private

Definition at line 59 of file PFProducer.h.

std::string PFProducer::electronOutputCol_
private

Definition at line 58 of file PFProducer.h.

edm::EDGetTokenT<reco::PFBlockCollection> PFProducer::inputTagBlocks_
private

Definition at line 51 of file PFProducer.h.

std::vector<edm::EDGetTokenT<reco::PFRecHitCollection> > PFProducer::inputTagCleanedHF_
private

Definition at line 57 of file PFProducer.h.

edm::EDGetTokenT<reco::GsfElectronCollection> PFProducer::inputTagEgammaElectrons_
private

Definition at line 54 of file PFProducer.h.

edm::EDGetTokenT<reco::MuonCollection> PFProducer::inputTagMuons_
private

Definition at line 52 of file PFProducer.h.

edm::EDGetTokenT<edm::View<reco::PFCandidate> > PFProducer::inputTagPFEGammaCandidates_
private

Definition at line 65 of file PFProducer.h.

edm::EDGetTokenT<edm::ValueMap<reco::GsfElectronRef> > PFProducer::inputTagValueMapGedElectrons_
private

Definition at line 63 of file PFProducer.h.

edm::EDGetTokenT<edm::ValueMap<reco::PhotonRef> > PFProducer::inputTagValueMapGedPhotons_
private

Definition at line 64 of file PFProducer.h.

std::auto_ptr<PFAlgo> PFProducer::pfAlgo_
private

particle flow algorithm

Definition at line 112 of file PFProducer.h.

std::string PFProducer::photonExtraOutputCol_
private

Definition at line 60 of file PFProducer.h.

bool PFProducer::postHFCleaning_
private

Definition at line 107 of file PFProducer.h.

bool PFProducer::postMuonCleaning_
private

Definition at line 77 of file PFProducer.h.

const GBRForest* PFProducer::ReaderEcalRes_
private

Definition at line 96 of file PFProducer.h.

const GBRForest* PFProducer::ReaderGC_
private

Definition at line 88 of file PFProducer.h.

const GBRForest* PFProducer::ReaderGCBarrel_
private

Definition at line 93 of file PFProducer.h.

const GBRForest* PFProducer::ReaderGCEndCapHighr9_
private

Definition at line 94 of file PFProducer.h.

const GBRForest* PFProducer::ReaderGCEndCapLowr9_
private

Definition at line 95 of file PFProducer.h.

const GBRForest* PFProducer::ReaderLC_
private

Definition at line 89 of file PFProducer.h.

const GBRForest* PFProducer::ReaderLCEB_
private

Definition at line 91 of file PFProducer.h.

const GBRForest* PFProducer::ReaderLCEE_
private

Definition at line 92 of file PFProducer.h.

const GBRForest* PFProducer::ReaderRes_
private

Definition at line 90 of file PFProducer.h.

bool PFProducer::use_EGammaFilters_
private

Definition at line 67 of file PFProducer.h.

bool PFProducer::useCalibrationsFromDB_
private

Definition at line 104 of file PFProducer.h.

bool PFProducer::useEGammaElectrons_
private

Definition at line 98 of file PFProducer.h.

bool PFProducer::useHO_
private

Definition at line 71 of file PFProducer.h.

bool PFProducer::usePFElectrons_
private

Definition at line 80 of file PFProducer.h.

bool PFProducer::usePFPhotons_
private

Definition at line 83 of file PFProducer.h.

bool PFProducer::usePhotonReg_
private

Definition at line 86 of file PFProducer.h.

bool PFProducer::useRegressionFromDB_
private

Definition at line 87 of file PFProducer.h.

bool PFProducer::useVerticesForNeutral_
private

Definition at line 101 of file PFProducer.h.

bool PFProducer::verbose_
private

verbose ?

Definition at line 74 of file PFProducer.h.

edm::EDGetTokenT<reco::VertexCollection> PFProducer::vertices_
private

Definition at line 53 of file PFProducer.h.

Generated for CMSSW Reference Manual by doxygen 1.8.5