Reference Manual

Go to the documentation of this file.
00001 #include "RecoParticleFlow/PFProducer/plugins/PFProducer.h"
00002 #include "RecoParticleFlow/PFProducer/interface/PFAlgo.h"
00003 #include "FWCore/Framework/interface/ESHandle.h"
00004 #include "FWCore/Framework/interface/EventSetup.h"
00005 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00006 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h"
00007 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibrationHF.h"
00008 #include "RecoParticleFlow/PFClusterTools/interface/PFSCEnergyCalibration.h"
00009 #include "CondFormats/PhysicsToolsObjects/interface/PerformancePayloadFromTFormula.h"
00010 #include "CondFormats/DataRecord/interface/PFCalibrationRcd.h"
00011 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
00012 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
00013 #include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"
00014 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
00015 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperClusterFwd.h"
00016 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"
00017 #include <sstream>
00018 
00019 using namespace std;
00020 
00021 using namespace boost;
00022 
00023 using namespace edm;
00024 
00025 
00026 
00027 PFProducer::PFProducer(const edm::ParameterSet& iConfig) {
00028   
00029   //--ab: get calibration factors for HF:
00030   bool calibHF_use;
00031   std::vector<double>  calibHF_eta_step;
00032   std::vector<double>  calibHF_a_EMonly;
00033   std::vector<double>  calibHF_b_HADonly;
00034   std::vector<double>  calibHF_a_EMHAD;
00035   std::vector<double>  calibHF_b_EMHAD;
00036   calibHF_use =     iConfig.getParameter<bool>("calibHF_use");
00037   calibHF_eta_step  = iConfig.getParameter<std::vector<double> >("calibHF_eta_step");
00038   calibHF_a_EMonly  = iConfig.getParameter<std::vector<double> >("calibHF_a_EMonly");
00039   calibHF_b_HADonly = iConfig.getParameter<std::vector<double> >("calibHF_b_HADonly");
00040   calibHF_a_EMHAD   = iConfig.getParameter<std::vector<double> >("calibHF_a_EMHAD");
00041   calibHF_b_EMHAD   = iConfig.getParameter<std::vector<double> >("calibHF_b_EMHAD");
00042   boost::shared_ptr<PFEnergyCalibrationHF>  
00043     thepfEnergyCalibrationHF ( new PFEnergyCalibrationHF(calibHF_use,calibHF_eta_step,calibHF_a_EMonly,calibHF_b_HADonly,calibHF_a_EMHAD,calibHF_b_EMHAD) ) ;
00044   //-----------------
00045 
00046   inputTagBlocks_ 
00047     = iConfig.getParameter<InputTag>("blocks");
00048 
00049   //Post cleaning of the muons
00050   inputTagMuons_ 
00051     = iConfig.getParameter<InputTag>("muons");
00052   postMuonCleaning_
00053     = iConfig.getParameter<bool>("postMuonCleaning");
00054 
00055   usePFElectrons_
00056     = iConfig.getParameter<bool>("usePFElectrons");    
00057 
00058   usePFPhotons_
00059     = iConfig.getParameter<bool>("usePFPhotons");    
00060 
00061   useEGammaElectrons_
00062     = iConfig.getParameter<bool>("useEGammaElectrons");    
00063 
00064   if(  useEGammaElectrons_) {
00065     inputTagEgammaElectrons_ = iConfig.getParameter<edm::InputTag>("egammaElectrons");
00066   }
00067 
00068   electronOutputCol_
00069     = iConfig.getParameter<std::string>("pf_electron_output_col");
00070 
00071   bool usePFSCEleCalib;
00072   std::vector<double>  calibPFSCEle_Fbrem_barrel; 
00073   std::vector<double>  calibPFSCEle_Fbrem_endcap;
00074   std::vector<double>  calibPFSCEle_barrel;
00075   std::vector<double>  calibPFSCEle_endcap;
00076   usePFSCEleCalib =     iConfig.getParameter<bool>("usePFSCEleCalib");
00077   calibPFSCEle_Fbrem_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_barrel");
00078   calibPFSCEle_Fbrem_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_endcap");
00079   calibPFSCEle_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_barrel");
00080   calibPFSCEle_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_endcap");
00081   boost::shared_ptr<PFSCEnergyCalibration>  
00082     thePFSCEnergyCalibration ( new PFSCEnergyCalibration(calibPFSCEle_Fbrem_barrel,calibPFSCEle_Fbrem_endcap,
00083                                                          calibPFSCEle_barrel,calibPFSCEle_endcap )); 
00084                                
00085   bool useEGammaSupercluster = iConfig.getParameter<bool>("useEGammaSupercluster");
00086   double sumEtEcalIsoForEgammaSC_barrel = iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_barrel");
00087   double sumEtEcalIsoForEgammaSC_endcap = iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_endcap");
00088   double coneEcalIsoForEgammaSC = iConfig.getParameter<double>("coneEcalIsoForEgammaSC");
00089   double sumPtTrackIsoForEgammaSC_barrel = iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_barrel");
00090   double sumPtTrackIsoForEgammaSC_endcap = iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_endcap");
00091   double coneTrackIsoForEgammaSC = iConfig.getParameter<double>("coneTrackIsoForEgammaSC");
00092   unsigned int nTrackIsoForEgammaSC  = iConfig.getParameter<unsigned int>("nTrackIsoForEgammaSC");
00093 
00094 
00095   // register products
00096   produces<reco::PFCandidateCollection>();
00097   produces<reco::PFCandidateCollection>("CleanedHF");
00098   produces<reco::PFCandidateCollection>("CleanedCosmicsMuons");
00099   produces<reco::PFCandidateCollection>("CleanedTrackerAndGlobalMuons");
00100   produces<reco::PFCandidateCollection>("CleanedFakeMuons");
00101   produces<reco::PFCandidateCollection>("CleanedPunchThroughMuons");
00102   produces<reco::PFCandidateCollection>("CleanedPunchThroughNeutralHadrons");
00103   produces<reco::PFCandidateCollection>("AddedMuonsAndHadrons");
00104 
00105 
00106   if (usePFElectrons_) {
00107     produces<reco::PFCandidateCollection>(electronOutputCol_);
00108     produces<reco::PFCandidateElectronExtraCollection>(electronExtraOutputCol_);
00109   }
00110 
00111   if (usePFPhotons_) {
00112     produces<reco::PFCandidatePhotonExtraCollection>(photonExtraOutputCol_);
00113   }
00114 
00115 
00116   double nSigmaECAL 
00117     = iConfig.getParameter<double>("pf_nsigma_ECAL");
00118   double nSigmaHCAL 
00119     = iConfig.getParameter<double>("pf_nsigma_HCAL");
00120   
00121   //PFElectrons Configuration
00122   double mvaEleCut
00123     = iConfig.getParameter<double>("pf_electron_mvaCut");
00124 
00125   string mvaWeightFileEleID
00126     = iConfig.getParameter<string>("pf_electronID_mvaWeightFile");
00127 
00128   bool applyCrackCorrectionsForElectrons
00129     = iConfig.getParameter<bool>("pf_electronID_crackCorrection");
00130   
00131   string path_mvaWeightFileEleID;
00132   if(usePFElectrons_)
00133     {
00134       path_mvaWeightFileEleID = edm::FileInPath ( mvaWeightFileEleID.c_str() ).fullPath();
00135      }
00136 
00137   //PFPhoton Configuration
00138 
00139   string path_mvaWeightFileConvID;
00140   string mvaWeightFileConvID;
00141   double mvaConvCut=-99.;
00142   double sumPtTrackIsoForPhoton = 99.;
00143   double sumPtTrackIsoSlopeForPhoton = 99.;
00144   if(usePFPhotons_)
00145     {
00146       mvaWeightFileConvID =iConfig.getParameter<string>("pf_convID_mvaWeightFile");
00147       
00148       mvaConvCut = iConfig.getParameter<double>("pf_conv_mvaCut");
00149       path_mvaWeightFileConvID = edm::FileInPath ( mvaWeightFileConvID.c_str() ).fullPath();  
00150 
00151       sumPtTrackIsoForPhoton = iConfig.getParameter<double>("sumPtTrackIsoForPhoton");
00152       sumPtTrackIsoSlopeForPhoton = iConfig.getParameter<double>("sumPtTrackIsoSlopeForPhoton");
00153     }
00154   
00155 
00156   //Secondary tracks and displaced vertices parameters
00157 
00158   bool rejectTracks_Bad
00159     = iConfig.getParameter<bool>("rejectTracks_Bad");
00160 
00161   bool rejectTracks_Step45
00162     = iConfig.getParameter<bool>("rejectTracks_Step45");
00163 
00164   bool usePFNuclearInteractions
00165     = iConfig.getParameter<bool>("usePFNuclearInteractions");
00166 
00167   bool usePFConversions
00168     = iConfig.getParameter<bool>("usePFConversions");  
00169 
00170   bool usePFDecays
00171     = iConfig.getParameter<bool>("usePFDecays");
00172 
00173   double dptRel_DispVtx
00174     = iConfig.getParameter<double>("dptRel_DispVtx");
00175 
00176   edm::ParameterSet iCfgCandConnector 
00177     = iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector");
00178 
00179 
00180   // fToRead =  iConfig.getUntrackedParameter<vector<string> >("toRead");
00181 
00182   useCalibrationsFromDB_
00183     = iConfig.getParameter<bool>("useCalibrationsFromDB");    
00184 
00185   boost::shared_ptr<PFEnergyCalibration> 
00186     calibration( new PFEnergyCalibration() ); 
00187 
00188   int algoType 
00189     = iConfig.getParameter<unsigned>("algoType");
00190   
00191   switch(algoType) {
00192   case 0:
00193     pfAlgo_.reset( new PFAlgo);
00194     break;
00195    default:
00196     assert(0);
00197   }
00198   
00199   pfAlgo_->setParameters( nSigmaECAL, 
00200                           nSigmaHCAL,
00201                           calibration,
00202                           thepfEnergyCalibrationHF);
00203 
00204   //PFElectrons: call the method setpfeleparameters
00205   pfAlgo_->setPFEleParameters(mvaEleCut,
00206                               path_mvaWeightFileEleID,
00207                               usePFElectrons_,
00208                               thePFSCEnergyCalibration,
00209                               calibration,
00210                               sumEtEcalIsoForEgammaSC_barrel,
00211                               sumEtEcalIsoForEgammaSC_endcap,
00212                               coneEcalIsoForEgammaSC,
00213                               sumPtTrackIsoForEgammaSC_barrel,
00214                               sumPtTrackIsoForEgammaSC_endcap,
00215                               nTrackIsoForEgammaSC,
00216                               coneTrackIsoForEgammaSC,
00217                               applyCrackCorrectionsForElectrons,
00218                               usePFSCEleCalib,
00219                               useEGammaElectrons_,
00220                               useEGammaSupercluster);
00221   
00222   //  pfAlgo_->setPFConversionParameters(usePFConversions);
00223 
00224   // PFPhotons: 
00225   pfAlgo_->setPFPhotonParameters(usePFPhotons_,
00226                                  path_mvaWeightFileConvID,
00227                                  mvaConvCut,
00228                                  calibration,
00229                                  sumPtTrackIsoForPhoton,
00230                                  sumPtTrackIsoSlopeForPhoton);
00231 
00232 
00233   //Secondary tracks and displaced vertices parameters
00234   
00235   pfAlgo_->setDisplacedVerticesParameters(rejectTracks_Bad,
00236                                           rejectTracks_Step45,
00237                                           usePFNuclearInteractions,
00238                                           usePFConversions,
00239                                           usePFDecays,
00240                                           dptRel_DispVtx);
00241   
00242   if (usePFNuclearInteractions)
00243     pfAlgo_->setCandConnectorParameters( iCfgCandConnector );
00244 
00245   // Muon parameters
00246   std::vector<double> muonHCAL
00247     = iConfig.getParameter<std::vector<double> >("muon_HCAL");  
00248   std::vector<double> muonECAL
00249     = iConfig.getParameter<std::vector<double> >("muon_ECAL");  
00250   assert ( muonHCAL.size() == 2 && muonECAL.size() == 2 );
00251   
00252   // Fake track parameters
00253   double nSigmaTRACK
00254     = iConfig.getParameter<double>("nsigma_TRACK");  
00255   
00256   double ptError
00257     = iConfig.getParameter<double>("pt_Error");  
00258   
00259   std::vector<double> factors45
00260     = iConfig.getParameter<std::vector<double> >("factors_45");  
00261   assert ( factors45.size() == 2 );
00262   
00263   bool usePFMuonMomAssign
00264     = iConfig.getParameter<bool>("usePFMuonMomAssign");
00265 
00266   // Set muon and fake track parameters
00267   pfAlgo_->setPFMuonAndFakeParameters(muonHCAL,
00268                                       muonECAL,
00269                                       nSigmaTRACK,
00270                                       ptError,
00271                                       factors45,
00272                                       usePFMuonMomAssign);
00273   
00274   //Post cleaning of the HF
00275   bool postHFCleaning
00276     = iConfig.getParameter<bool>("postHFCleaning");
00277 
00278   double minHFCleaningPt 
00279     = iConfig.getParameter<double>("minHFCleaningPt");
00280   double minSignificance
00281     = iConfig.getParameter<double>("minSignificance");
00282   double maxSignificance
00283     = iConfig.getParameter<double>("maxSignificance");
00284   double minSignificanceReduction
00285     = iConfig.getParameter<double>("minSignificanceReduction");
00286   double maxDeltaPhiPt
00287     = iConfig.getParameter<double>("maxDeltaPhiPt");
00288   double minDeltaMet
00289     = iConfig.getParameter<double>("minDeltaMet");
00290 
00291   // Set post HF cleaning muon parameters
00292   pfAlgo_->setPostHFCleaningParameters(postHFCleaning,
00293                                        minHFCleaningPt,
00294                                        minSignificance,
00295                                        maxSignificance,
00296                                        minSignificanceReduction,
00297                                        maxDeltaPhiPt,
00298                                        minDeltaMet);
00299 
00300   // Input tags for HF cleaned rechits
00301   inputTagCleanedHF_ 
00302     = iConfig.getParameter< std::vector<edm::InputTag> >("cleanedHF");
00303 
00304   //MIKE: Vertex Parameters
00305   vertices_ = iConfig.getParameter<edm::InputTag>("vertexCollection");
00306   useVerticesForNeutral_ = iConfig.getParameter<bool>("useVerticesForNeutral");
00307 
00308 
00309 
00310   verbose_ = 
00311     iConfig.getUntrackedParameter<bool>("verbose",false);
00312 
00313   bool debug_ = 
00314     iConfig.getUntrackedParameter<bool>("debug",false);
00315 
00316   pfAlgo_->setDebug( debug_ );
00317 
00318 }
00319 
00320 
00321 
00322 PFProducer::~PFProducer() {}
00323 
00324 
00325 void 
00326 PFProducer::beginJob() {}
00327 
00328 void 
00329 PFProducer::beginRun(edm::Run & run, 
00330                      const edm::EventSetup & es) 
00331 {
00332 
00333 
00334   /*
00335   static map<string, PerformanceResult::ResultType> functType;
00336 
00337   functType["PFfa_BARREL"] = PerformanceResult::PFfa_BARREL;
00338   functType["PFfa_ENDCAP"] = PerformanceResult::PFfa_ENDCAP;
00339   functType["PFfb_BARREL"] = PerformanceResult::PFfb_BARREL;
00340   functType["PFfb_ENDCAP"] = PerformanceResult::PFfb_ENDCAP;
00341   functType["PFfc_BARREL"] = PerformanceResult::PFfc_BARREL;
00342   functType["PFfc_ENDCAP"] = PerformanceResult::PFfc_ENDCAP;
00343   functType["PFfaEta_BARREL"] = PerformanceResult::PFfaEta_BARREL;
00344   functType["PFfaEta_ENDCAP"] = PerformanceResult::PFfaEta_ENDCAP;
00345   functType["PFfbEta_BARREL"] = PerformanceResult::PFfbEta_BARREL;
00346   functType["PFfbEta_ENDCAP"] = PerformanceResult::PFfbEta_ENDCAP;
00347   */
00348 
00349   if ( useCalibrationsFromDB_ ) { 
00350   // Read the PFCalibration functions from the global tags.
00351     edm::ESHandle<PerformancePayload> perfH;
00352     es.get<PFCalibrationRcd>().get(perfH);
00353     
00354     const PerformancePayloadFromTFormula *pfCalibrations = static_cast< const PerformancePayloadFromTFormula *>(perfH.product());
00355     
00356     pfAlgo_->thePFEnergyCalibration()->setCalibrationFunctions(pfCalibrations);
00357   }
00358   
00359   /*
00360   for(vector<string>::const_iterator name = fToRead.begin(); name != fToRead.end(); ++name) {    
00361     
00362     cout << "Function: " << *name << endl;
00363     PerformanceResult::ResultType fType = functType[*name];
00364     pfCalibrations->printFormula(fType);
00365     
00366     // evaluate it @ 10 GeV
00367     float energy = 10.;
00368     
00369     BinningPointByMap point;
00370     point.insert(BinningVariables::JetEt, energy);
00371     
00372     if(pfCalibrations->isInPayload(fType, point)) {
00373       float value = pfCalibrations->getResult(fType, point);
00374       cout << "   Energy before:: " << energy << " after: " << value << endl;
00375     } else cout <<  "outside limits!" << endl;
00376     
00377   }
00378   */
00379 
00380 }
00381 
00382 
00383 void 
00384 PFProducer::produce(Event& iEvent, 
00385                     const EventSetup& iSetup) {
00386   
00387   LogDebug("PFProducer")<<"START event: "
00388                         <<iEvent.id().event()
00389                         <<" in run "<<iEvent.id().run()<<endl;
00390   
00391 
00392   // Get The vertices from the event
00393   // and assign dynamic vertex parameters
00394   edm::Handle<reco::VertexCollection> vertices;
00395   bool gotVertices = iEvent.getByLabel(vertices_,vertices);
00396   if(!gotVertices) {
00397     ostringstream err;
00398     err<<"Cannot find vertices for this event.Continuing Without them ";
00399     LogError("PFProducer")<<err.str()<<endl;
00400   }
00401 
00402   //Assign the PFAlgo Parameters
00403   pfAlgo_->setPFVertexParameters(useVerticesForNeutral_,*vertices);
00404 
00405   // get the collection of blocks 
00406 
00407   Handle< reco::PFBlockCollection > blocks;
00408 
00409   LogDebug("PFProducer")<<"getting blocks"<<endl;
00410   bool found = iEvent.getByLabel( inputTagBlocks_, blocks );  
00411 
00412   if(!found ) {
00413 
00414     ostringstream err;
00415     err<<"cannot find blocks: "<<inputTagBlocks_;
00416     LogError("PFProducer")<<err.str()<<endl;
00417     
00418     throw cms::Exception( "MissingProduct", err.str());
00419   }
00420 
00421   // get the collection of muons 
00422 
00423   Handle< reco::MuonCollection > muons;
00424 
00425   if ( postMuonCleaning_ ) {
00426 
00427     LogDebug("PFProducer")<<"getting muons"<<endl;
00428     found = iEvent.getByLabel( inputTagMuons_, muons );  
00429 
00430     if(!found) {
00431       ostringstream err;
00432       err<<"cannot find muons: "<<inputTagMuons_;
00433       LogError("PFProducer")<<err.str()<<endl;
00434     
00435       throw cms::Exception( "MissingProduct", err.str());
00436     }
00437 
00438   }
00439 
00440   if (useEGammaElectrons_) {
00441     Handle < reco::GsfElectronCollection > egelectrons;
00442     
00443     LogDebug("PFProducer")<<" Reading e/gamma electrons activated "<<endl;
00444     found = iEvent.getByLabel( inputTagEgammaElectrons_, egelectrons );  
00445     
00446     if(!found) {
00447       ostringstream err;
00448       err<<"cannot find electrons: "<<inputTagEgammaElectrons_;
00449       LogError("PFProducer")<<err.str()<<endl;
00450     
00451       throw cms::Exception( "MissingProduct", err.str());
00452     }
00453     
00454     pfAlgo_->setEGElectronCollection(*egelectrons);
00455   }
00456 
00457   
00458   LogDebug("PFProducer")<<"particle flow is starting"<<endl;
00459 
00460   assert( blocks.isValid() );
00461  
00462   pfAlgo_->reconstructParticles( blocks );
00463 
00464   if(verbose_) {
00465     ostringstream  str;
00466     str<<(*pfAlgo_)<<endl;
00467     //    cout << (*pfAlgo_) << endl;
00468     LogInfo("PFProducer") <<str.str()<<endl;
00469   }  
00470 
00471 
00472   if ( postMuonCleaning_ )
00473     pfAlgo_->postMuonCleaning( muons, *vertices );
00474 
00475   // Florian 5/01/2011
00476   // Save the PFElectron Extra Collection First as to be able to create valid References  
00477   if(usePFElectrons_)   {  
00478     auto_ptr< reco::PFCandidateElectronExtraCollection >
00479       pOutputElectronCandidateExtraCollection( pfAlgo_->transferElectronExtra() ); 
00480 
00481     const edm::OrphanHandle<reco::PFCandidateElectronExtraCollection > electronExtraProd=
00482       iEvent.put(pOutputElectronCandidateExtraCollection,electronExtraOutputCol_);      
00483     pfAlgo_->setElectronExtraRef(electronExtraProd);
00484   }
00485 
00486   // Daniele 18/05/2011
00487   // Save the PFPhoton Extra Collection First as to be able to create valid References  
00488   if(usePFPhotons_)   {  
00489     auto_ptr< reco::PFCandidatePhotonExtraCollection >
00490       pOutputPhotonCandidateExtraCollection( pfAlgo_->transferPhotonExtra() ); 
00491 
00492     const edm::OrphanHandle<reco::PFCandidatePhotonExtraCollection > photonExtraProd=
00493       iEvent.put(pOutputPhotonCandidateExtraCollection,photonExtraOutputCol_);      
00494     pfAlgo_->setPhotonExtraRef(photonExtraProd);
00495   }
00496 
00497 
00498   // Save cosmic cleaned muon candidates
00499   auto_ptr< reco::PFCandidateCollection > 
00500     pCosmicsMuonCleanedCandidateCollection( pfAlgo_->transferCosmicsMuonCleanedCandidates() ); 
00501   // Save tracker/global cleaned muon candidates
00502   auto_ptr< reco::PFCandidateCollection > 
00503     pTrackerAndGlobalCleanedMuonCandidateCollection( pfAlgo_->transferCleanedTrackerAndGlobalMuonCandidates() ); 
00504   // Save fake cleaned muon candidates
00505   auto_ptr< reco::PFCandidateCollection > 
00506     pFakeCleanedMuonCandidateCollection( pfAlgo_->transferFakeMuonCleanedCandidates() ); 
00507   // Save punch-through cleaned muon candidates
00508   auto_ptr< reco::PFCandidateCollection > 
00509     pPunchThroughMuonCleanedCandidateCollection( pfAlgo_->transferPunchThroughMuonCleanedCandidates() ); 
00510   // Save punch-through cleaned neutral hadron candidates
00511   auto_ptr< reco::PFCandidateCollection > 
00512     pPunchThroughHadronCleanedCandidateCollection( pfAlgo_->transferPunchThroughHadronCleanedCandidates() ); 
00513   // Save added muon candidates
00514   auto_ptr< reco::PFCandidateCollection > 
00515     pAddedMuonCandidateCollection( pfAlgo_->transferAddedMuonCandidates() ); 
00516 
00517   // Check HF overcleaning
00518   reco::PFRecHitCollection hfCopy;
00519   for ( unsigned ihf=0; ihf<inputTagCleanedHF_.size(); ++ihf ) {
00520     Handle< reco::PFRecHitCollection > hfCleaned;
00521     bool foundHF = iEvent.getByLabel( inputTagCleanedHF_[ihf], hfCleaned );  
00522     if (!foundHF) continue;
00523     for ( unsigned jhf=0; jhf<(*hfCleaned).size(); ++jhf ) { 
00524       hfCopy.push_back( (*hfCleaned)[jhf] );
00525     }
00526   }
00527   pfAlgo_->checkCleaning( hfCopy );
00528 
00529   // Save recovered HF candidates
00530   auto_ptr< reco::PFCandidateCollection > 
00531     pCleanedCandidateCollection( pfAlgo_->transferCleanedCandidates() ); 
00532 
00533   
00534   // Save the final PFCandidate collection
00535   auto_ptr< reco::PFCandidateCollection > 
00536     pOutputCandidateCollection( pfAlgo_->transferCandidates() ); 
00537   
00538 
00539   
00540   LogDebug("PFProducer")<<"particle flow: putting products in the event"<<endl;
00541   if ( verbose_ ) std::cout <<"particle flow: putting products in the event. Here the full list"<<endl;
00542   int nC=0;
00543   for( reco::PFCandidateCollection::const_iterator  itCand =  (*pOutputCandidateCollection).begin(); itCand !=  (*pOutputCandidateCollection).end(); itCand++) {
00544     nC++;
00545       if (verbose_ ) std::cout << nC << ")" << (*itCand).particleId() << std::endl;
00546 
00547   }
00548 
00549   // Write in the event
00550   iEvent.put(pOutputCandidateCollection);
00551   iEvent.put(pCleanedCandidateCollection,"CleanedHF");
00552 
00553   if ( postMuonCleaning_ ) { 
00554     iEvent.put(pCosmicsMuonCleanedCandidateCollection,"CleanedCosmicsMuons");
00555     iEvent.put(pTrackerAndGlobalCleanedMuonCandidateCollection,"CleanedTrackerAndGlobalMuons");
00556     iEvent.put(pFakeCleanedMuonCandidateCollection,"CleanedFakeMuons");
00557     iEvent.put(pPunchThroughMuonCleanedCandidateCollection,"CleanedPunchThroughMuons");
00558     iEvent.put(pPunchThroughHadronCleanedCandidateCollection,"CleanedPunchThroughNeutralHadrons");
00559     iEvent.put(pAddedMuonCandidateCollection,"AddedMuonsAndHadrons");
00560   }
00561 
00562   if(usePFElectrons_)
00563     {
00564       auto_ptr< reco::PFCandidateCollection >  
00565         pOutputElectronCandidateCollection( pfAlgo_->transferElectronCandidates() ); 
00566       iEvent.put(pOutputElectronCandidateCollection,electronOutputCol_);
00567 
00568     }
00569 }
00570
/data/refman/pasoursint/CMSSW_4_4_5_patch3/src/RecoParticleFlow/PFProducer/plugins/PFProducer.cc
