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,ele_protectionsForBadHcal,ph_protectionsForJetMET,ph_protectionsForBadHcal;
211  // Reading new EGamma ubiased collections and value maps
212  if(use_EGammaFilters_) {
213  ele_iso_mvaWeightFile = iConfig.getParameter<string>("isolatedElectronID_mvaWeightFile");
214  ele_iso_path_mvaWeightFile = edm::FileInPath ( ele_iso_mvaWeightFile.c_str() ).fullPath();
215  inputTagPFEGammaCandidates_ = consumes<edm::View<reco::PFCandidate> >((iConfig.getParameter<edm::InputTag>("PFEGammaCandidates")));
216  inputTagValueMapGedElectrons_ = consumes<edm::ValueMap<reco::GsfElectronRef>>(iConfig.getParameter<edm::InputTag>("GedElectronValueMap"));
217  inputTagValueMapGedPhotons_ = consumes<edm::ValueMap<reco::PhotonRef> >(iConfig.getParameter<edm::InputTag>("GedPhotonValueMap"));
218  ele_iso_pt = iConfig.getParameter<double>("electron_iso_pt");
219  ele_iso_mva_barrel = iConfig.getParameter<double>("electron_iso_mva_barrel");
220  ele_iso_mva_endcap = iConfig.getParameter<double>("electron_iso_mva_endcap");
221  ele_iso_combIso_barrel = iConfig.getParameter<double>("electron_iso_combIso_barrel");
222  ele_iso_combIso_endcap = iConfig.getParameter<double>("electron_iso_combIso_endcap");
223  ele_noniso_mva = iConfig.getParameter<double>("electron_noniso_mvaCut");
224  ele_missinghits = iConfig.getParameter<unsigned int>("electron_missinghits");
225  ph_MinEt = iConfig.getParameter<double>("photon_MinEt");
226  ph_combIso = iConfig.getParameter<double>("photon_combIso");
227  ph_HoE = iConfig.getParameter<double>("photon_HoE");
228  ph_sietaieta_eb = iConfig.getParameter<double>("photon_SigmaiEtaiEta_barrel");
229  ph_sietaieta_ee = iConfig.getParameter<double>("photon_SigmaiEtaiEta_endcap");
230  useProtectionsForJetMET =
231  iConfig.getParameter<bool>("useProtectionsForJetMET");
232  ele_protectionsForJetMET =
233  iConfig.getParameter<edm::ParameterSet>("electron_protectionsForJetMET");
234  ele_protectionsForBadHcal =
235  iConfig.getParameter<edm::ParameterSet>("electron_protectionsForBadHcal");
236  ph_protectionsForJetMET =
237  iConfig.getParameter<edm::ParameterSet>("photon_protectionsForJetMET");
238  ph_protectionsForBadHcal =
239  iConfig.getParameter<edm::ParameterSet>("photon_protectionsForBadHcal");
240  }
241 
242  //Secondary tracks and displaced vertices parameters
243 
244  bool rejectTracks_Bad
245  = iConfig.getParameter<bool>("rejectTracks_Bad");
246 
247  bool rejectTracks_Step45
248  = iConfig.getParameter<bool>("rejectTracks_Step45");
249 
250  bool usePFNuclearInteractions
251  = iConfig.getParameter<bool>("usePFNuclearInteractions");
252 
253  bool usePFConversions
254  = iConfig.getParameter<bool>("usePFConversions");
255 
256  bool usePFDecays
257  = iConfig.getParameter<bool>("usePFDecays");
258 
259  double dptRel_DispVtx
260  = iConfig.getParameter<double>("dptRel_DispVtx");
261 
262  edm::ParameterSet iCfgCandConnector
263  = iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector");
264 
265 
266  // fToRead = iConfig.getUntrackedParameter<vector<string> >("toRead");
267 
268  useCalibrationsFromDB_
269  = iConfig.getParameter<bool>("useCalibrationsFromDB");
270 
271  if (useCalibrationsFromDB_)
272  calibrationsLabel_ = iConfig.getParameter<std::string>("calibrationsLabel");
273 
274  boost::shared_ptr<PFEnergyCalibration>
275  calibration( new PFEnergyCalibration() );
276 
277  int algoType
278  = iConfig.getParameter<unsigned>("algoType");
279 
280  switch(algoType) {
281  case 0:
282  pfAlgo_.reset( new PFAlgo);
283  break;
284  default:
285  assert(0);
286  }
287 
288  pfAlgo_->setParameters( nSigmaECAL,
289  nSigmaHCAL,
290  calibration,
291  thepfEnergyCalibrationHF);
292 
293  //PFElectrons: call the method setpfeleparameters
294  pfAlgo_->setPFEleParameters(mvaEleCut,
295  path_mvaWeightFileEleID,
296  usePFElectrons_,
297  thePFSCEnergyCalibration,
298  calibration,
299  sumEtEcalIsoForEgammaSC_barrel,
300  sumEtEcalIsoForEgammaSC_endcap,
301  coneEcalIsoForEgammaSC,
302  sumPtTrackIsoForEgammaSC_barrel,
303  sumPtTrackIsoForEgammaSC_endcap,
304  nTrackIsoForEgammaSC,
305  coneTrackIsoForEgammaSC,
306  applyCrackCorrectionsForElectrons,
307  usePFSCEleCalib,
308  useEGammaElectrons_,
309  useEGammaSupercluster);
310 
311  // pfAlgo_->setPFConversionParameters(usePFConversions);
312 
313  // PFPhotons:
314  pfAlgo_->setPFPhotonParameters(usePFPhotons_,
315  path_mvaWeightFileConvID,
316  mvaConvCut,
317  usePhotonReg_,
318  path_X0_Map,
319  calibration,
320  sumPtTrackIsoForPhoton,
321  sumPtTrackIsoSlopeForPhoton);
322 
323 
324  // NEW EGamma Filters
325  pfAlgo_->setEGammaParameters(use_EGammaFilters_,
326  ele_iso_path_mvaWeightFile,
327  ele_iso_pt,
328  ele_iso_mva_barrel,
329  ele_iso_mva_endcap,
330  ele_iso_combIso_barrel,
331  ele_iso_combIso_endcap,
332  ele_noniso_mva,
333  ele_missinghits,
334  useProtectionsForJetMET,
335  ele_protectionsForJetMET,
336  ele_protectionsForBadHcal,
337  ph_MinEt,
338  ph_combIso,
339  ph_HoE,
340  ph_sietaieta_eb,
341  ph_sietaieta_ee,
342  ph_protectionsForJetMET,
343  ph_protectionsForBadHcal);
344 
345  //Secondary tracks and displaced vertices parameters
346 
347  pfAlgo_->setDisplacedVerticesParameters(rejectTracks_Bad,
348  rejectTracks_Step45,
349  usePFNuclearInteractions,
350  usePFConversions,
351  usePFDecays,
352  dptRel_DispVtx);
353 
354  if (usePFNuclearInteractions)
355  pfAlgo_->setCandConnectorParameters( iCfgCandConnector );
356 
357 
358 
359  // Set muon and fake track parameters
360  pfAlgo_->setPFMuonAndFakeParameters(iConfig);
361  pfAlgo_->setBadHcalTrackParams(iConfig);
362 
363  //Post cleaning of the HF
364  postHFCleaning_
365  = iConfig.getParameter<bool>("postHFCleaning");
366  double minHFCleaningPt
367  = iConfig.getParameter<double>("minHFCleaningPt");
368  double minSignificance
369  = iConfig.getParameter<double>("minSignificance");
370  double maxSignificance
371  = iConfig.getParameter<double>("maxSignificance");
372  double minSignificanceReduction
373  = iConfig.getParameter<double>("minSignificanceReduction");
374  double maxDeltaPhiPt
375  = iConfig.getParameter<double>("maxDeltaPhiPt");
376  double minDeltaMet
377  = iConfig.getParameter<double>("minDeltaMet");
378 
379  // Set post HF cleaning muon parameters
380  pfAlgo_->setPostHFCleaningParameters(postHFCleaning_,
381  minHFCleaningPt,
382  minSignificance,
383  maxSignificance,
384  minSignificanceReduction,
385  maxDeltaPhiPt,
386  minDeltaMet);
387 
388  // Input tags for HF cleaned rechits
389  std::vector<edm::InputTag> tags =iConfig.getParameter< std::vector<edm::InputTag> >("cleanedHF");
390  for (unsigned int i=0;i<tags.size();++i)
391  inputTagCleanedHF_.push_back(consumes<reco::PFRecHitCollection>(tags[i]));
392  //MIKE: Vertex Parameters
393  vertices_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"));
394  useVerticesForNeutral_ = iConfig.getParameter<bool>("useVerticesForNeutral");
395 
396  // Use HO clusters and links in the PF reconstruction
397  useHO_= iConfig.getParameter<bool>("useHO");
398  pfAlgo_->setHOTag(useHO_);
399 
400  verbose_ =
401  iConfig.getUntrackedParameter<bool>("verbose",false);
402 
403  bool debug_ =
404  iConfig.getUntrackedParameter<bool>("debug",false);
405 
406  pfAlgo_->setDebug( debug_ );
407 
408 }
PFProducer::inputTagCleanedHF_
std::vector< edm::EDGetTokenT< reco::PFRecHitCollection > > inputTagCleanedHF_
Definition: PFProducer.h:57
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:601
particleFlow_cfi.sumPtTrackIsoForEgammaSC_barrel
sumPtTrackIsoForEgammaSC_barrel
Definition: particleFlow_cfi.py:131
particleFlow_cfi.iCfgCandConnector
iCfgCandConnector
Definition: particleFlow_cfi.py:150
PFProducer::ReaderRes_
const GBRForest * ReaderRes_
Definition: PFProducer.h:90
particleFlow_cfi.calibHF_eta_step
calibHF_eta_step
Definition: particleFlow_cfi.py:251
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:115
particleFlow_cfi.sumPtTrackIsoForPhoton
sumPtTrackIsoForPhoton
Definition: particleFlow_cfi.py:42
particleFlow_cfi.maxSignificance
maxSignificance
Definition: particleFlow_cfi.py:223
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:250
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:132
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:256
particleFlow_cfi.dptRel_DispVtx
dptRel_DispVtx
Definition: particleFlow_cfi.py:148
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:134
particleFlow_cfi.sumEtEcalIsoForEgammaSC_endcap
sumEtEcalIsoForEgammaSC_endcap
Definition: particleFlow_cfi.py:129
particleFlow_cfi.minDeltaMet
minDeltaMet
Definition: particleFlow_cfi.py:233
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:146
particleFlow_cfi.maxDeltaPhiPt
maxDeltaPhiPt
Definition: particleFlow_cfi.py:230
PFProducer::useVerticesForNeutral_
bool useVerticesForNeutral_
Definition: PFProducer.h:101
particleFlow_cfi.minHFCleaningPt
minHFCleaningPt
Definition: particleFlow_cfi.py:221
particleFlow_cfi.calibHF_b_HADonly
calibHF_b_HADonly
Definition: particleFlow_cfi.py:257
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:111
particleFlow_cfi.calibHF_a_EMHAD
calibHF_a_EMHAD
Definition: particleFlow_cfi.py:258
hltParticleFlowForJets_cfi.usePFSCEleCalib
usePFSCEleCalib
Definition: hltParticleFlowForJets_cfi.py:74
particleFlow_cfi.sumEtEcalIsoForEgammaSC_barrel
sumEtEcalIsoForEgammaSC_barrel
Definition: particleFlow_cfi.py:128
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:120
particleFlow_cfi.minSignificance
minSignificance
Definition: particleFlow_cfi.py:225
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:259
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:130
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:133
particleFlow_cfi.calibPFSCEle_Fbrem_barrel
calibPFSCEle_Fbrem_barrel
Definition: particleFlow_cfi.py:107
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:227
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 412 of file PFProducer.cc.

412 {}

Member Function Documentation

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

Definition at line 415 of file PFProducer.cc.

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

417 {
418 
419 
420  /*
421  static map<string, PerformanceResult::ResultType> functType;
422 
423  functType["PFfa_BARREL"] = PerformanceResult::PFfa_BARREL;
424  functType["PFfa_ENDCAP"] = PerformanceResult::PFfa_ENDCAP;
425  functType["PFfb_BARREL"] = PerformanceResult::PFfb_BARREL;
426  functType["PFfb_ENDCAP"] = PerformanceResult::PFfb_ENDCAP;
427  functType["PFfc_BARREL"] = PerformanceResult::PFfc_BARREL;
428  functType["PFfc_ENDCAP"] = PerformanceResult::PFfc_ENDCAP;
429  functType["PFfaEta_BARREL"] = PerformanceResult::PFfaEta_BARREL;
430  functType["PFfaEta_ENDCAP"] = PerformanceResult::PFfaEta_ENDCAP;
431  functType["PFfbEta_BARREL"] = PerformanceResult::PFfbEta_BARREL;
432  functType["PFfbEta_ENDCAP"] = PerformanceResult::PFfbEta_ENDCAP;
433  */
434 
435  if ( useCalibrationsFromDB_ ) {
436  // read the PFCalibration functions from the global tags
437  edm::ESHandle<PerformancePayload> perfH;
438  es.get<PFCalibrationRcd>().get(calibrationsLabel_, perfH);
439 
440  PerformancePayloadFromTFormula const * pfCalibrations = static_cast< const PerformancePayloadFromTFormula *>(perfH.product());
441 
442  pfAlgo_->thePFEnergyCalibration()->setCalibrationFunctions(pfCalibrations);
443  }
444 
445  /*
446  for(vector<string>::const_iterator name = fToRead.begin(); name != fToRead.end(); ++name) {
447 
448  cout << "Function: " << *name << endl;
449  PerformanceResult::ResultType fType = functType[*name];
450  pfCalibrations->printFormula(fType);
451 
452  // evaluate it @ 10 GeV
453  float energy = 10.;
454 
455  BinningPointByMap point;
456  point.insert(BinningVariables::JetEt, energy);
457 
458  if(pfCalibrations->isInPayload(fType, point)) {
459  float value = pfCalibrations->getResult(fType, point);
460  cout << " Energy before:: " << energy << " after: " << value << endl;
461  } else cout << "outside limits!" << endl;
462 
463  }
464  */
465 
466  if(usePFPhotons_ && useRegressionFromDB_) {
467  edm::ESHandle<GBRForest> readerPFLCEB;
468  edm::ESHandle<GBRForest> readerPFLCEE;
469  edm::ESHandle<GBRForest> readerPFGCEB;
470  edm::ESHandle<GBRForest> readerPFGCEEHR9;
471  edm::ESHandle<GBRForest> readerPFGCEELR9;
472  edm::ESHandle<GBRForest> readerPFRes;
473  es.get<GBRWrapperRcd>().get("PFLCorrectionBar",readerPFLCEB);
474  ReaderLCEB_=readerPFLCEB.product();
475  es.get<GBRWrapperRcd>().get("PFLCorrectionEnd",readerPFLCEE);
476  ReaderLCEE_=readerPFLCEE.product();
477  es.get<GBRWrapperRcd>().get("PFGCorrectionBar",readerPFGCEB);
478  ReaderGCBarrel_=readerPFGCEB.product();
479  es.get<GBRWrapperRcd>().get("PFGCorrectionEndHighR9",readerPFGCEEHR9);
480  ReaderGCEndCapHighr9_=readerPFGCEEHR9.product();
481  es.get<GBRWrapperRcd>().get("PFGCorrectionEndLowR9",readerPFGCEELR9);
482  ReaderGCEndCapLowr9_=readerPFGCEELR9.product();
483  es.get<GBRWrapperRcd>().get("PFEcalResolution",readerPFRes);
484  ReaderEcalRes_=readerPFRes.product();
485 
486  /*
487  LogDebug("PFProducer")<<"setting regressions from DB "<<endl;
488  */
489  }
490 
491  if(usePFPhotons_){
492  //pfAlgo_->setPFPhotonRegWeights(ReaderLC_, ReaderGC_, ReaderRes_);
493  pfAlgo_->setPFPhotonRegWeights(ReaderLCEB_,ReaderLCEE_,ReaderGCBarrel_,ReaderGCEndCapHighr9_, ReaderGCEndCapLowr9_, ReaderEcalRes_ );
494  }
495 }
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
T get() const
Definition: EventSetup.h:63
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 499 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(), extraflags_cff::muons, particleBasedIsoProducer_cfi::pfEgammaCandidates, edm::Handle< T >::product(), edm::Event::put(), edm::EventID::run(), str, and electrons_cff::vertices.

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