CMS 3D CMS Logo
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<>

Public Member Functions

void beginRun (const edm::Run &, const edm::EventSetup &) override
 
 PFProducer (const edm::ParameterSet &)
 
void produce (edm::Event &, const edm::EventSetup &) override
 
 ~PFProducer () override
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
bool hasAbilityToProduceInLumis () const final
 
bool hasAbilityToProduceInRuns () const final
 

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
 

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 particleFlow_cfi::algoType, particleFlow_cfi::calibHF_a_EMHAD, particleFlow_cfi::calibHF_a_EMonly, particleFlow_cfi::calibHF_b_EMHAD, particleFlow_cfi::calibHF_b_HADonly, particleFlow_cfi::calibHF_eta_step, particleFlow_cfi::calibHF_use, particleFlow_cfi::calibPFSCEle_barrel, particleFlow_cfi::calibPFSCEle_endcap, particleFlow_cfi::calibPFSCEle_Fbrem_barrel, particleFlow_cfi::calibPFSCEle_Fbrem_endcap, particleFlow_cfi::coneEcalIsoForEgammaSC, particleFlow_cfi::coneTrackIsoForEgammaSC, particleFlow_cfi::dptRel_DispVtx, edm::ParameterSet::existsAs(), funct::false, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, particleFlow_cfi::iCfgCandConnector, LogDebug, particleFlow_cfi::maxDeltaPhiPt, particleFlow_cfi::maxSignificance, particleFlow_cfi::minDeltaMet, particleFlow_cfi::minHFCleaningPt, particleFlow_cfi::minSignificance, particleFlow_cfi::minSignificanceReduction, particleFlow_cfi::nTrackIsoForEgammaSC, hltParticleFlowForJets_cfi::rejectTracks_Bad, hltParticleFlowForJets_cfi::rejectTracks_Step45, AlCaHLTBitMon_QueryRunRegistry::string, particleFlow_cfi::sumEtEcalIsoForEgammaSC_barrel, particleFlow_cfi::sumEtEcalIsoForEgammaSC_endcap, particleFlow_cfi::sumPtTrackIsoForEgammaSC_barrel, particleFlow_cfi::sumPtTrackIsoForEgammaSC_endcap, particleFlow_cfi::sumPtTrackIsoForPhoton, particleFlow_cfi::sumPtTrackIsoSlopeForPhoton, hltParticleFlowForJets_cfi::useEGammaSupercluster, Reconstruction_hiPF_cff::usePFConversions, particleFlow_cfi::usePFDecays, hltParticleFlowForJets_cfi::usePFNuclearInteractions, hltParticleFlowForJets_cfi::usePFSCEleCalib, hltParticleFlowForJets_cfi::useProtectionsForJetMET, and particleFlow_cfi::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:503
particleFlow_cfi.sumPtTrackIsoForEgammaSC_barrel
sumPtTrackIsoForEgammaSC_barrel
Definition: particleFlow_cfi.py:119
particleFlow_cfi.iCfgCandConnector
iCfgCandConnector
Definition: particleFlow_cfi.py:138
PFProducer::ReaderRes_
const GBRForest * ReaderRes_
Definition: PFProducer.h:90
particleFlow_cfi.calibHF_eta_step
calibHF_eta_step
Definition: particleFlow_cfi.py:222
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
particleFlow_cfi.calibPFSCEle_barrel
calibPFSCEle_barrel
Definition: particleFlow_cfi.py:103
particleFlow_cfi.sumPtTrackIsoForPhoton
sumPtTrackIsoForPhoton
Definition: particleFlow_cfi.py:42
particleFlow_cfi.maxSignificance
maxSignificance
Definition: particleFlow_cfi.py:194
Reconstruction_hiPF_cff.usePFConversions
usePFConversions
Definition: Reconstruction_hiPF_cff.py:80
PFProducer::inputTagMuons_
edm::EDGetTokenT< reco::MuonCollection > inputTagMuons_
Definition: PFProducer.h:52
mps_fire.i
i
Definition: mps_fire.py:269
particleFlow_cfi.calibHF_use
calibHF_use
Definition: particleFlow_cfi.py:221
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
particleFlow_cfi.sumPtTrackIsoForEgammaSC_endcap
sumPtTrackIsoForEgammaSC_endcap
Definition: particleFlow_cfi.py:120
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
PFProducer::pfAlgo_
std::auto_ptr< PFAlgo > pfAlgo_
particle flow algorithm
Definition: PFProducer.h:112
PFProducer::calibrationsLabel_
std::string calibrationsLabel_
Definition: PFProducer.h:105
particleFlow_cfi.calibHF_a_EMonly
calibHF_a_EMonly
Definition: particleFlow_cfi.py:227
particleFlow_cfi.dptRel_DispVtx
dptRel_DispVtx
Definition: particleFlow_cfi.py:136
hltParticleFlowForJets_cfi.rejectTracks_Bad
rejectTracks_Bad
Definition: hltParticleFlowForJets_cfi.py:71
PFProducer::ReaderLC_
const GBRForest * ReaderLC_
Definition: PFProducer.h:89
particleFlow_cfi.coneTrackIsoForEgammaSC
coneTrackIsoForEgammaSC
Definition: particleFlow_cfi.py:122
particleFlow_cfi.sumEtEcalIsoForEgammaSC_endcap
sumEtEcalIsoForEgammaSC_endcap
Definition: particleFlow_cfi.py:117
particleFlow_cfi.minDeltaMet
minDeltaMet
Definition: particleFlow_cfi.py:204
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
particleFlow_cfi.usePFDecays
usePFDecays
Definition: particleFlow_cfi.py:134
particleFlow_cfi.maxDeltaPhiPt
maxDeltaPhiPt
Definition: particleFlow_cfi.py:201
PFProducer::useVerticesForNeutral_
bool useVerticesForNeutral_
Definition: PFProducer.h:101
particleFlow_cfi.minHFCleaningPt
minHFCleaningPt
Definition: particleFlow_cfi.py:192
particleFlow_cfi.calibHF_b_HADonly
calibHF_b_HADonly
Definition: particleFlow_cfi.py:228
PFProducer::postHFCleaning_
bool postHFCleaning_
Definition: PFProducer.h:107
PFProducer::postMuonCleaning_
bool postMuonCleaning_
Definition: PFProducer.h:77
particleFlow_cfi.calibPFSCEle_Fbrem_endcap
calibPFSCEle_Fbrem_endcap
Definition: particleFlow_cfi.py:99
particleFlow_cfi.calibHF_a_EMHAD
calibHF_a_EMHAD
Definition: particleFlow_cfi.py:229
hltParticleFlowForJets_cfi.usePFSCEleCalib
usePFSCEleCalib
Definition: hltParticleFlowForJets_cfi.py:74
particleFlow_cfi.sumEtEcalIsoForEgammaSC_barrel
sumEtEcalIsoForEgammaSC_barrel
Definition: particleFlow_cfi.py:116
PFProducer::inputTagPFEGammaCandidates_
edm::EDGetTokenT< edm::View< reco::PFCandidate > > inputTagPFEGammaCandidates_
Definition: PFProducer.h:65
hltParticleFlowForJets_cfi.useEGammaSupercluster
useEGammaSupercluster
Definition: hltParticleFlowForJets_cfi.py:62
particleFlow_cfi.calibPFSCEle_endcap
calibPFSCEle_endcap
Definition: particleFlow_cfi.py:108
particleFlow_cfi.minSignificance
minSignificance
Definition: particleFlow_cfi.py:196
PFProducer::inputTagBlocks_
edm::EDGetTokenT< reco::PFBlockCollection > inputTagBlocks_
Definition: PFProducer.h:51
PFProducer::useHO_
bool useHO_
Definition: PFProducer.h:71
PFProducer::useRegressionFromDB_
bool useRegressionFromDB_
Definition: PFProducer.h:87
particleFlow_cfi.X0_Map
X0_Map
Definition: particleFlow_cfi.py:41
PFProducer::usePFElectrons_
bool usePFElectrons_
Definition: PFProducer.h:80
PFProducer::electronOutputCol_
std::string electronOutputCol_
Definition: PFProducer.h:58
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
particleFlow_cfi.calibHF_b_EMHAD
calibHF_b_EMHAD
Definition: particleFlow_cfi.py:230
hltParticleFlowForJets_cfi.usePFNuclearInteractions
usePFNuclearInteractions
Definition: hltParticleFlowForJets_cfi.py:64
PFProducer::inputTagValueMapGedPhotons_
edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > > inputTagValueMapGedPhotons_
Definition: PFProducer.h:64
particleFlow_cfi.algoType
algoType
Definition: particleFlow_cfi.py:17
particleFlow_cfi.coneEcalIsoForEgammaSC
coneEcalIsoForEgammaSC
Definition: particleFlow_cfi.py:118
hltParticleFlowForJets_cfi.useProtectionsForJetMET
useProtectionsForJetMET
Definition: hltParticleFlowForJets_cfi.py:69
particleFlow_cfi.sumPtTrackIsoSlopeForPhoton
sumPtTrackIsoSlopeForPhoton
Definition: particleFlow_cfi.py:43
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
particleFlow_cfi.nTrackIsoForEgammaSC
nTrackIsoForEgammaSC
Definition: particleFlow_cfi.py:121
particleFlow_cfi.calibPFSCEle_Fbrem_barrel
calibPFSCEle_Fbrem_barrel
Definition: particleFlow_cfi.py:95
PFAlgo
Definition: PFAlgo.h:52
PFProducer::inputTagEgammaElectrons_
edm::EDGetTokenT< reco::GsfElectronCollection > inputTagEgammaElectrons_
Definition: PFProducer.h:54
PFProducer::usePhotonReg_
bool usePhotonReg_
Definition: PFProducer.h:86
particleFlow_cfi.minSignificanceReduction
minSignificanceReduction
Definition: particleFlow_cfi.py:198
PFProducer::inputTagValueMapGedElectrons_
edm::EDGetTokenT< edm::ValueMap< reco::GsfElectronRef > > inputTagValueMapGedElectrons_
Definition: PFProducer.h:63
hltParticleFlowForJets_cfi.rejectTracks_Step45
rejectTracks_Step45
Definition: hltParticleFlowForJets_cfi.py:63
PFProducer::ReaderGC_
const GBRForest * ReaderGC_
Definition: PFProducer.h:88
PFProducer::~PFProducer ( )
override

Definition at line 406 of file PFProducer.cc.

406 {}

Member Function Documentation

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

Definition at line 409 of file PFProducer.cc.

References edm::EventSetup::get(), and edm::ESHandle< T >::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:59
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
PFProducer::ReaderGCBarrel_
const GBRForest * ReaderGCBarrel_
Definition: PFProducer.h:93
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
void PFProducer::produce ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
override

Definition at line 493 of file PFProducer.cc.

References gather_cfg::blocks, gather_cfg::cout, edm::EventID::event(), edm::Event::getByToken(), edm::EventBase::id(), ihf, edm::HandleBase::isValid(), LogDebug, eostools::move(), nano_cff::muons, particleBasedIsoProducer_cfi::pfEgammaCandidates, edm::Handle< T >::product(), edm::Event::put(), edm::EventID::run(), harvestTrackValidationPlots::str, and electrons_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  std::unique_ptr<reco::PFCandidateElectronExtraCollection> pOutputElectronCandidateExtraCollection( pfAlgo_->transferElectronExtra() );
576 
577  const edm::OrphanHandle<reco::PFCandidateElectronExtraCollection > electronExtraProd=
578  iEvent.put(std::move(pOutputElectronCandidateExtraCollection),electronExtraOutputCol_);
579  pfAlgo_->setElectronExtraRef(electronExtraProd);
580  }
581 
582  // Daniele 18/05/2011
583  // Save the PFPhoton Extra Collection First as to be able to create valid References
584  if(usePFPhotons_) {
585  std::unique_ptr<reco::PFCandidatePhotonExtraCollection> pOutputPhotonCandidateExtraCollection( pfAlgo_->transferPhotonExtra() );
586 
587  const edm::OrphanHandle<reco::PFCandidatePhotonExtraCollection > photonExtraProd=
588  iEvent.put(std::move(pOutputPhotonCandidateExtraCollection),photonExtraOutputCol_);
589  pfAlgo_->setPhotonExtraRef(photonExtraProd);
590  }
591 
592  // Save cosmic cleaned muon candidates
593  std::unique_ptr<reco::PFCandidateCollection>
594  pCosmicsMuonCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedCosmicCandidates() );
595  // Save tracker/global cleaned muon candidates
596  std::unique_ptr<reco::PFCandidateCollection>
597  pTrackerAndGlobalCleanedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedTrackerAndGlobalCandidates() );
598  // Save fake cleaned muon candidates
599  std::unique_ptr<reco::PFCandidateCollection>
600  pFakeCleanedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferCleanedFakeCandidates() );
601  // Save punch-through cleaned muon candidates
602  std::unique_ptr<reco::PFCandidateCollection>
603  pPunchThroughMuonCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferPunchThroughCleanedMuonCandidates() );
604  // Save punch-through cleaned neutral hadron candidates
605  std::unique_ptr<reco::PFCandidateCollection>
606  pPunchThroughHadronCleanedCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferPunchThroughCleanedHadronCandidates() );
607  // Save added muon candidates
608  std::unique_ptr<reco::PFCandidateCollection>
609  pAddedMuonCandidateCollection( pfAlgo_->getPFMuonAlgo()->transferAddedMuonCandidates() );
610 
611  // Check HF overcleaning
612  reco::PFRecHitCollection hfCopy;
613  for ( unsigned ihf=0; ihf<inputTagCleanedHF_.size(); ++ihf ) {
614  Handle< reco::PFRecHitCollection > hfCleaned;
615  bool foundHF = iEvent.getByToken( inputTagCleanedHF_[ihf], hfCleaned );
616  if (!foundHF) continue;
617  for ( unsigned jhf=0; jhf<(*hfCleaned).size(); ++jhf ) {
618  hfCopy.push_back( (*hfCleaned)[jhf] );
619  }
620  }
621 
622  if (postHFCleaning_)
623  pfAlgo_->checkCleaning( hfCopy );
624 
625  // Save recovered HF candidates
626  std::unique_ptr<reco::PFCandidateCollection> pCleanedCandidateCollection( pfAlgo_->transferCleanedCandidates() );
627 
628 
629  // Save the final PFCandidate collection
630  std::unique_ptr<reco::PFCandidateCollection> pOutputCandidateCollection( pfAlgo_->transferCandidates() );
631 
632 
633 
634  LogDebug("PFProducer")<<"particle flow: putting products in the event"<<endl;
635  if ( verbose_ ) std::cout <<"particle flow: putting products in the event. Here the full list"<<endl;
636  int nC=0;
637  for( reco::PFCandidateCollection::const_iterator itCand = (*pOutputCandidateCollection).begin(); itCand != (*pOutputCandidateCollection).end(); itCand++) {
638  nC++;
639  if (verbose_ ) std::cout << nC << ")" << (*itCand).particleId() << std::endl;
640 
641  }
642 
643 
644 
645  // Write in the event
646  iEvent.put(std::move(pOutputCandidateCollection));
647  iEvent.put(std::move(pCleanedCandidateCollection),"CleanedHF");
648 
649  if ( postMuonCleaning_ ) {
650  iEvent.put(std::move(pCosmicsMuonCleanedCandidateCollection),"CleanedCosmicsMuons");
651  iEvent.put(std::move(pTrackerAndGlobalCleanedMuonCandidateCollection),"CleanedTrackerAndGlobalMuons");
652  iEvent.put(std::move(pFakeCleanedMuonCandidateCollection),"CleanedFakeMuons");
653  iEvent.put(std::move(pPunchThroughMuonCleanedCandidateCollection),"CleanedPunchThroughMuons");
654  iEvent.put(std::move(pPunchThroughHadronCleanedCandidateCollection),"CleanedPunchThroughNeutralHadrons");
655  iEvent.put(std::move(pAddedMuonCandidateCollection),"AddedMuonsAndHadrons");
656  }
657 
658  if(usePFElectrons_)
659  {
660  std::unique_ptr<reco::PFCandidateCollection>
661  pOutputElectronCandidateCollection( pfAlgo_->transferElectronCandidates() );
662  iEvent.put(std::move(pOutputElectronCandidateCollection),electronOutputCol_);
663 
664  }
665 }
PFProducer::inputTagCleanedHF_
std::vector< edm::EDGetTokenT< reco::PFRecHitCollection > > inputTagCleanedHF_
Definition: PFProducer.h:57
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:503
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
edm::Event::put
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:136
PFProducer::inputTagMuons_
edm::EDGetTokenT< reco::MuonCollection > inputTagMuons_
Definition: PFProducer.h:52
ihf
int ihf
Definition: CascadeWrapper.h:31
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:519
PFProducer::pfAlgo_
std::auto_ptr< PFAlgo > pfAlgo_
particle flow algorithm
Definition: PFProducer.h:112
electrons_cff.vertices
vertices
Definition: electrons_cff.py:11
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
gather_cfg.blocks
blocks
Definition: gather_cfg.py:90
particleBasedIsoProducer_cfi.pfEgammaCandidates
pfEgammaCandidates
Definition: particleBasedIsoProducer_cfi.py:12
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:74
PFProducer::inputTagBlocks_
edm::EDGetTokenT< reco::PFBlockCollection > inputTagBlocks_
Definition: PFProducer.h:51
nano_cff.muons
muons
Definition: nano_cff.py:27
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
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:60
PFProducer::inputTagValueMapGedPhotons_
edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > > inputTagValueMapGedPhotons_
Definition: PFProducer.h:64
PFProducer::usePFPhotons_
bool usePFPhotons_
Definition: PFProducer.h:83
gather_cfg.cout
cout
Definition: gather_cfg.py:145
PFProducer::inputTagEgammaElectrons_
edm::EDGetTokenT< reco::GsfElectronCollection > inputTagEgammaElectrons_
Definition: PFProducer.h:54
eostools.move
def move(src, dest)
Definition: eostools.py:510
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.11