PatAlgos/plugins/PATElectronProducer.cc

//
// $Id: PATElectronProducer.cc,v 1.20.2.9 2009/04/30 09:11:45 gpetrucc Exp $
//

#include "PhysicsTools/PatAlgos/plugins/PATElectronProducer.h"

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

#include "DataFormats/Common/interface/Association.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"

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

#include "PhysicsTools/PatUtils/interface/TrackerIsolationPt.h"
#include "PhysicsTools/PatUtils/interface/CaloIsolationEnergy.h"

#include <vector>
#include <memory>


using namespace pat;


PATElectronProducer::PATElectronProducer(const edm::ParameterSet & iConfig) :
  isolator_(iConfig.exists("isolation") ? iConfig.getParameter<edm::ParameterSet>("isolation") : edm::ParameterSet(), false) ,
  userDataHelper_ ( iConfig.getParameter<edm::ParameterSet>("userData") )
{

  // general configurables
  electronSrc_      = iConfig.getParameter<edm::InputTag>( "electronSource" );
  embedGsfTrack_    = iConfig.getParameter<bool>         ( "embedGsfTrack" );
  embedSuperCluster_= iConfig.getParameter<bool>         ( "embedSuperCluster" );
  embedTrack_       = iConfig.getParameter<bool>         ( "embedTrack" );

  // pflow specific
  pfElecSrc_           = iConfig.getParameter<edm::InputTag>( "pfElectronSource" );
  useParticleFlow_        = iConfig.getParameter<bool>( "useParticleFlow" );
  embedPFCandidate_   = iConfig.getParameter<bool>( "embedPFCandidate" );

  
  // MC matching configurables
  addGenMatch_      = iConfig.getParameter<bool>          ( "addGenMatch" );
  if (addGenMatch_) {
      embedGenMatch_ = iConfig.getParameter<bool>         ( "embedGenMatch" );
      if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
          genMatchSrc_.push_back(iConfig.getParameter<edm::InputTag>( "genParticleMatch" ));
      } else {
          genMatchSrc_ = iConfig.getParameter<std::vector<edm::InputTag> >( "genParticleMatch" );
      }
  }
  
  // trigger matching configurables
  addTrigMatch_     = iConfig.getParameter<bool>         ( "addTrigMatch" );
  trigMatchSrc_     = iConfig.getParameter<std::vector<edm::InputTag> >( "trigPrimMatch" );

  // resolution configurables

  // electron ID configurables
  addElecID_        = iConfig.getParameter<bool>         ( "addElectronID" );
  if (addElecID_) {
      // it might be a single electron ID
      if (iConfig.existsAs<edm::InputTag>("electronIDSource")) {
          elecIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("electronIDSource")));
      }
      // or there might be many of them
      if (iConfig.existsAs<edm::ParameterSet>("electronIDSources")) {
          // please don't configure me twice
          if (!elecIDSrcs_.empty()) throw cms::Exception("Configuration") << 
                "PATElectronProducer: you can't specify both 'electronIDSource' and 'electronIDSources'\n";
          // read the different electron ID names
          edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("electronIDSources");
          std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
          for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
              elecIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
          }
      }
      // but in any case at least once
      if (elecIDSrcs_.empty()) throw cms::Exception("Configuration") <<
            "PATElectronProducer: id addElectronID is true, you must specify either:\n" <<
            "\tInputTag electronIDSource = <someTag>\n" << "or\n" <<
            "\tPSet electronIDSources = { \n" <<
            "\t\tInputTag <someName> = <someTag>   // as many as you want \n " <<
            "\t}\n";
  }
  
  // construct resolution calculator

  // IsoDeposit configurables
  if (iConfig.exists("isoDeposits")) {
     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
     if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(TrackerIso, depconf.getParameter<edm::InputTag>("tracker")));
     if (depconf.exists("ecal"))    isoDepositLabels_.push_back(std::make_pair(ECalIso, depconf.getParameter<edm::InputTag>("ecal")));
     if (depconf.exists("hcal"))    isoDepositLabels_.push_back(std::make_pair(HCalIso, depconf.getParameter<edm::InputTag>("hcal")));
     if (depconf.exists("particle"))           isoDepositLabels_.push_back(std::make_pair(ParticleIso, depconf.getParameter<edm::InputTag>("particle")));
     if (depconf.exists("chargedparticle"))    isoDepositLabels_.push_back(std::make_pair(ChargedParticleIso, depconf.getParameter<edm::InputTag>("chargedparticle")));
     if (depconf.exists("neutralparticle")) isoDepositLabels_.push_back(std::make_pair(NeutralParticleIso,depconf.getParameter<edm::InputTag>("neutralparticle")));
     if (depconf.exists("gammaparticle"))    isoDepositLabels_.push_back(std::make_pair(GammaParticleIso, depconf.getParameter<edm::InputTag>("gammaparticle")));


     if (depconf.exists("user")) {
        std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
        std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
        int key = UserBaseIso;
        for ( ; it != ed; ++it, ++key) {
            isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
        }
     }
  }

  // Efficiency configurables
  addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
  if (addEfficiencies_) {
     efficiencyLoader_ = pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"));
  }

  // Resolution configurables
  addResolutions_ = iConfig.getParameter<bool>("addResolutions");
  if (addResolutions_) {
     resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
  }

  // Check to see if the user wants to add user data
  useUserData_ = false;
  if ( iConfig.exists("userData") ) {
    useUserData_ = true;
  }

  // electron ID configurables
  addElecShapes_        = iConfig.getParameter<bool>("addElectronShapes" );
  reducedBarrelRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection") ;
  reducedEndcapRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection") ;
   
  // produces vector of muons
  produces<std::vector<Electron> >();

}


PATElectronProducer::~PATElectronProducer() {
}


void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSetup) {

  // Get the collection of electrons from the event
  edm::Handle<edm::View<ElectronType> > electrons;
  iEvent.getByLabel(electronSrc_, electrons);

  if (isolator_.enabled()) isolator_.beginEvent(iEvent,iSetup);

  if (efficiencyLoader_.enabled()) efficiencyLoader_.newEvent(iEvent);
  if (resolutionLoader_.enabled()) resolutionLoader_.newEvent(iEvent, iSetup);

  std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > deposits(isoDepositLabels_.size());
  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
    iEvent.getByLabel(isoDepositLabels_[j].second, deposits[j]);
  }

  // prepare the MC matching
  GenAssociations  genMatches(genMatchSrc_.size());
  if (addGenMatch_) {
        for (size_t j = 0, nd = genMatchSrc_.size(); j < nd; ++j) {
            iEvent.getByLabel(genMatchSrc_[j], genMatches[j]);
        }
  }


  // prepare the trigger matching
  TrigAssociations  trigMatches(trigMatchSrc_.size());
  if ( addTrigMatch_ ) {
    for ( size_t i = 0; i < trigMatchSrc_.size(); ++i ) {
      iEvent.getByLabel(trigMatchSrc_[i], trigMatches[i]);
    }
  }

  // prepare ID extraction 
  std::vector<edm::Handle<edm::ValueMap<float> > > idhandles;
  std::vector<pat::Electron::IdPair>               ids;
  if (addElecID_) {
     idhandles.resize(elecIDSrcs_.size());
     ids.resize(elecIDSrcs_.size());
     for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
        iEvent.getByLabel(elecIDSrcs_[i].second, idhandles[i]);
        ids[i].first = elecIDSrcs_[i].first;
     }
  }


  if (addElecShapes_) {
    lazyTools_ .reset(new EcalClusterLazyTools( iEvent , iSetup , reducedBarrelRecHitCollection_ , reducedEndcapRecHitCollection_ ));  
  }

  std::vector<Electron> * patElectrons = new std::vector<Electron>();


  if( useParticleFlow_ ) {
    edm::Handle< reco::PFCandidateCollection >  pfElectrons;
    iEvent.getByLabel(pfElecSrc_, pfElectrons);
    unsigned index=0;
  
    for( reco::PFCandidateConstIterator i = pfElectrons->begin(); 
         i != pfElectrons->end(); ++i, ++index) {

      reco::PFCandidateRef pfRef(pfElectrons,index);
      reco::PFCandidatePtr ptrToMother(pfElectrons,index);
      reco::CandidateBaseRef pfBaseRef( pfRef ); 
      
      reco::GsfTrackRef PfTk= i->gsfTrackRef(); 

      bool Matched=false;
      for (edm::View<ElectronType>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end(); ++itElectron) {
        unsigned int idx = itElectron - electrons->begin();
        if (Matched) continue;
        reco::GsfTrackRef EgTk= itElectron->gsfTrack();
        if (itElectron->gsfTrack()==i->gsfTrackRef()){
          const ElectronBaseRef elecsRef = electrons->refAt(idx);
          Electron anElectron(elecsRef);
          FillElectron(anElectron,elecsRef,pfBaseRef, genMatches, trigMatches);
          Matched=true;
          anElectron.setPFCandidateRef( pfRef  );
          if( embedPFCandidate_ ) anElectron.embedPFCandidate();

          if (isolator_.enabled()){
            reco::CandidatePtr mother =  ptrToMother->sourceCandidatePtr(0);
            isolator_.fill(mother, isolatorTmpStorage_);
            typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
            for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(), 
                   ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
              anElectron.setIsolation(it->first, it->second);
            }
            for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
              anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[mother]);
            }
          }
          //Electron Id
          if (addElecID_) {
            //STANDARD EL ID 
            for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
              ids[i].second = (*idhandles[i])[elecsRef];    
            }
            //SPECIFIC PF ID
            ids.push_back(std::make_pair("pf_evspi",pfRef->mva_e_pi()));
            ids.push_back(std::make_pair("pf_evsmu",pfRef->mva_e_mu()));
            anElectron.setElectronIDs(ids);
          }

          patElectrons->push_back(anElectron);

        }

        
      }
 
      
    }
  }

  else{
  for (edm::View<ElectronType>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end(); ++itElectron) {
    // construct the Electron from the ref -> save ref to original object
    unsigned int idx = itElectron - electrons->begin();

    const ElectronBaseRef elecsRef = electrons->refAt(idx);
    reco::CandidateBaseRef elecBaseRef(elecsRef);

    //    const edm::Ptr<ElectronType> electronPtr = electrons->ptrAt(idx);
    Electron anElectron(elecsRef);

    FillElectron(anElectron,elecsRef,elecBaseRef, genMatches, trigMatches);
    

    // add resolution info
    
    // Isolation
    if (isolator_.enabled()) {
        isolator_.fill(*electrons, idx, isolatorTmpStorage_);
        typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
        // better to loop backwards, so the vector is resized less times
        for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(), ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
            anElectron.setIsolation(it->first, it->second);
        }
    }

    for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
        anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecsRef]);
    }

    // add electron ID info
    if (addElecID_) {
        for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
            ids[i].second = (*idhandles[i])[elecsRef];    
        }
        anElectron.setElectronIDs(ids);
    }
    

    if ( useUserData_ ) {
      userDataHelper_.add( anElectron, iEvent, iSetup );
    }
    
    
    // add sel to selected
    patElectrons->push_back(anElectron);
  }
  }
  
  // sort electrons in pt
  std::sort(patElectrons->begin(), patElectrons->end(), pTComparator_);

  // add the electrons to the event output
  std::auto_ptr<std::vector<Electron> > ptr(patElectrons);
  iEvent.put(ptr);

  // clean up
  if (isolator_.enabled()) isolator_.endEvent();

}

void PATElectronProducer::FillElectron(Electron& anElectron,
                                       const ElectronBaseRef& elecsRef,
                                       const reco::CandidateBaseRef& baseRef,
                                       const GenAssociations& genMatches,
                                       const TrigAssociations& trigMatches)const {
  if (embedGsfTrack_) anElectron.embedGsfTrack();
  if (embedSuperCluster_) anElectron.embedSuperCluster();
  if (embedTrack_) anElectron.embedTrack();

  // store the match to the generated final state muons
  if (addGenMatch_) {
    for(size_t i = 0, n = genMatches.size(); i < n; ++i) {
      reco::GenParticleRef genElectron = (*genMatches[i])[elecsRef];
      anElectron.addGenParticleRef(genElectron);
    }
    if (embedGenMatch_) anElectron.embedGenParticle();
  }
    // matches to trigger primitives
    if ( addTrigMatch_ ) {
      for ( size_t i = 0; i < trigMatchSrc_.size(); ++i ) {
        TriggerPrimitiveRef trigPrim = (*trigMatches[i])[elecsRef];
        if ( trigPrim.isNonnull() && trigPrim.isAvailable() ) {
          anElectron.addTriggerMatch(*trigPrim);
        }
      }
    }
    
    if (efficiencyLoader_.enabled()) {
      efficiencyLoader_.setEfficiencies( anElectron, elecsRef );
    }
    
    if (resolutionLoader_.enabled()) {
      resolutionLoader_.setResolutions(anElectron);
    }

    //  add electron shapes info
    if (addElecShapes_) {
        std::vector<float> covariances = lazyTools_->covariances(*(elecsRef->superCluster()->seed())) ;
        std::vector<float> localCovariances = lazyTools_->localCovariances(*(elecsRef->superCluster()->seed())) ;
        float scSigmaEtaEta = sqrt(covariances[0]) ;
        float scSigmaIEtaIEta = sqrt(localCovariances[0]) ;
        float scE1x5 = lazyTools_->e1x5(*(elecsRef->superCluster()->seed()))  ;
        float scE2x5Max = lazyTools_->e2x5Max(*(elecsRef->superCluster()->seed()))  ;
        float scE5x5 = lazyTools_->e5x5(*(elecsRef->superCluster()->seed())) ;
        anElectron.setClusterShapes(scSigmaEtaEta,scSigmaIEtaIEta,scE1x5,scE2x5Max,scE5x5) ;
    }
}


#include "FWCore/Framework/interface/MakerMacros.h"

DEFINE_FWK_MODULE(PATElectronProducer);
Revision:	1.1.1.1 (vendor branch)
Committed:	Tue Oct 20 17:15:14 2009 UTC (15 years, 6 months ago) by dgele
Content type:	text/plain
Branch:	ANA
CVS Tags:	start
Changes since 1.1:	+0 -0 lines
Error occurred while calculating annotation data.
Log Message:	version CMSSW_2_2_10
#	Content
1	//
2	// $Id: PATElectronProducer.cc,v 1.20.2.9 2009/04/30 09:11:45 gpetrucc Exp $
3	//
4
5	#include "PhysicsTools/PatAlgos/plugins/PATElectronProducer.h"
6
7	#include "FWCore/MessageLogger/interface/MessageLogger.h"
8	#include "FWCore/ParameterSet/interface/FileInPath.h"
9
10	#include "DataFormats/Common/interface/Association.h"
11	#include "DataFormats/Common/interface/ValueMap.h"
12	#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
13	#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
14
15	#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
16	#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
17
18	#include "PhysicsTools/PatUtils/interface/TrackerIsolationPt.h"
19	#include "PhysicsTools/PatUtils/interface/CaloIsolationEnergy.h"
20
21	#include <vector>
22	#include <memory>
23
24
25	using namespace pat;
26
27
28	PATElectronProducer::PATElectronProducer(const edm::ParameterSet & iConfig) :
29	isolator_(iConfig.exists("isolation") ? iConfig.getParameter<edm::ParameterSet>("isolation") : edm::ParameterSet(), false) ,
30	userDataHelper_ ( iConfig.getParameter<edm::ParameterSet>("userData") )
31	{
32
33	// general configurables
34	electronSrc_ = iConfig.getParameter<edm::InputTag>( "electronSource" );
35	embedGsfTrack_ = iConfig.getParameter<bool> ( "embedGsfTrack" );
36	embedSuperCluster_= iConfig.getParameter<bool> ( "embedSuperCluster" );
37	embedTrack_ = iConfig.getParameter<bool> ( "embedTrack" );
38
39	// pflow specific
40	pfElecSrc_ = iConfig.getParameter<edm::InputTag>( "pfElectronSource" );
41	useParticleFlow_ = iConfig.getParameter<bool>( "useParticleFlow" );
42	embedPFCandidate_ = iConfig.getParameter<bool>( "embedPFCandidate" );
43
44
45	// MC matching configurables
46	addGenMatch_ = iConfig.getParameter<bool> ( "addGenMatch" );
47	if (addGenMatch_) {
48	embedGenMatch_ = iConfig.getParameter<bool> ( "embedGenMatch" );
49	if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
50	genMatchSrc_.push_back(iConfig.getParameter<edm::InputTag>( "genParticleMatch" ));
51	} else {
52	genMatchSrc_ = iConfig.getParameter<std::vector<edm::InputTag> >( "genParticleMatch" );
53	}
54	}
55
56	// trigger matching configurables
57	addTrigMatch_ = iConfig.getParameter<bool> ( "addTrigMatch" );
58	trigMatchSrc_ = iConfig.getParameter<std::vector<edm::InputTag> >( "trigPrimMatch" );
59
60	// resolution configurables
61
62	// electron ID configurables
63	addElecID_ = iConfig.getParameter<bool> ( "addElectronID" );
64	if (addElecID_) {
65	// it might be a single electron ID
66	if (iConfig.existsAs<edm::InputTag>("electronIDSource")) {
67	elecIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("electronIDSource")));
68	}
69	// or there might be many of them
70	if (iConfig.existsAs<edm::ParameterSet>("electronIDSources")) {
71	// please don't configure me twice
72	if (!elecIDSrcs_.empty()) throw cms::Exception("Configuration") <<
73	"PATElectronProducer: you can't specify both 'electronIDSource' and 'electronIDSources'\n";
74	// read the different electron ID names
75	edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("electronIDSources");
76	std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
77	for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
78	elecIDSrcs_.push_back(NameTag(it, idps.getParameter<edm::InputTag>(it)));
79	}
80	}
81	// but in any case at least once
82	if (elecIDSrcs_.empty()) throw cms::Exception("Configuration") <<
83	"PATElectronProducer: id addElectronID is true, you must specify either:\n" <<
84	"\tInputTag electronIDSource = <someTag>\n" << "or\n" <<
85	"\tPSet electronIDSources = { \n" <<
86	"\t\tInputTag <someName> = <someTag> // as many as you want \n " <<
87	"\t}\n";
88	}
89
90	// construct resolution calculator
91
92	// IsoDeposit configurables
93	if (iConfig.exists("isoDeposits")) {
94	edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
95	if (depconf.exists("tracker")) isoDepositLabels_.push_back(std::make_pair(TrackerIso, depconf.getParameter<edm::InputTag>("tracker")));
96	if (depconf.exists("ecal")) isoDepositLabels_.push_back(std::make_pair(ECalIso, depconf.getParameter<edm::InputTag>("ecal")));
97	if (depconf.exists("hcal")) isoDepositLabels_.push_back(std::make_pair(HCalIso, depconf.getParameter<edm::InputTag>("hcal")));
98	if (depconf.exists("particle")) isoDepositLabels_.push_back(std::make_pair(ParticleIso, depconf.getParameter<edm::InputTag>("particle")));
99	if (depconf.exists("chargedparticle")) isoDepositLabels_.push_back(std::make_pair(ChargedParticleIso, depconf.getParameter<edm::InputTag>("chargedparticle")));
100	if (depconf.exists("neutralparticle")) isoDepositLabels_.push_back(std::make_pair(NeutralParticleIso,depconf.getParameter<edm::InputTag>("neutralparticle")));
101	if (depconf.exists("gammaparticle")) isoDepositLabels_.push_back(std::make_pair(GammaParticleIso, depconf.getParameter<edm::InputTag>("gammaparticle")));
102
103
104	if (depconf.exists("user")) {
105	std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
106	std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
107	int key = UserBaseIso;
108	for ( ; it != ed; ++it, ++key) {
109	isoDepositLabels_.push_back(std::make_pair(IsolationKeys(key), *it));
110	}
111	}
112	}
113
114	// Efficiency configurables
115	addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
116	if (addEfficiencies_) {
117	efficiencyLoader_ = pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"));
118	}
119
120	// Resolution configurables
121	addResolutions_ = iConfig.getParameter<bool>("addResolutions");
122	if (addResolutions_) {
123	resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
124	}
125
126	// Check to see if the user wants to add user data
127	useUserData_ = false;
128	if ( iConfig.exists("userData") ) {
129	useUserData_ = true;
130	}
131
132	// electron ID configurables
133	addElecShapes_ = iConfig.getParameter<bool>("addElectronShapes" );
134	reducedBarrelRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection") ;
135	reducedEndcapRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection") ;
136
137	// produces vector of muons
138	produces<std::vector<Electron> >();
139
140	}
141
142
143	PATElectronProducer::~PATElectronProducer() {
144	}
145
146
147	void PATElectronProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSetup) {
148
149	// Get the collection of electrons from the event
150	edm::Handle<edm::View<ElectronType> > electrons;
151	iEvent.getByLabel(electronSrc_, electrons);
152
153	if (isolator_.enabled()) isolator_.beginEvent(iEvent,iSetup);
154
155	if (efficiencyLoader_.enabled()) efficiencyLoader_.newEvent(iEvent);
156	if (resolutionLoader_.enabled()) resolutionLoader_.newEvent(iEvent, iSetup);
157
158	std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > deposits(isoDepositLabels_.size());
159	for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
160	iEvent.getByLabel(isoDepositLabels_[j].second, deposits[j]);
161	}
162
163	// prepare the MC matching
164	GenAssociations genMatches(genMatchSrc_.size());
165	if (addGenMatch_) {
166	for (size_t j = 0, nd = genMatchSrc_.size(); j < nd; ++j) {
167	iEvent.getByLabel(genMatchSrc_[j], genMatches[j]);
168	}
169	}
170
171
172	// prepare the trigger matching
173	TrigAssociations trigMatches(trigMatchSrc_.size());
174	if ( addTrigMatch_ ) {
175	for ( size_t i = 0; i < trigMatchSrc_.size(); ++i ) {
176	iEvent.getByLabel(trigMatchSrc_[i], trigMatches[i]);
177	}
178	}
179
180	// prepare ID extraction
181	std::vector<edm::Handle<edm::ValueMap<float> > > idhandles;
182	std::vector<pat::Electron::IdPair> ids;
183	if (addElecID_) {
184	idhandles.resize(elecIDSrcs_.size());
185	ids.resize(elecIDSrcs_.size());
186	for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
187	iEvent.getByLabel(elecIDSrcs_[i].second, idhandles[i]);
188	ids[i].first = elecIDSrcs_[i].first;
189	}
190	}
191
192
193	if (addElecShapes_) {
194	lazyTools_ .reset(new EcalClusterLazyTools( iEvent , iSetup , reducedBarrelRecHitCollection_ , reducedEndcapRecHitCollection_ ));
195	}
196
197	std::vector<Electron> * patElectrons = new std::vector<Electron>();
198
199
200	if( useParticleFlow_ ) {
201	edm::Handle< reco::PFCandidateCollection > pfElectrons;
202	iEvent.getByLabel(pfElecSrc_, pfElectrons);
203	unsigned index=0;
204
205	for( reco::PFCandidateConstIterator i = pfElectrons->begin();
206	i != pfElectrons->end(); ++i, ++index) {
207
208	reco::PFCandidateRef pfRef(pfElectrons,index);
209	reco::PFCandidatePtr ptrToMother(pfElectrons,index);
210	reco::CandidateBaseRef pfBaseRef( pfRef );
211
212	reco::GsfTrackRef PfTk= i->gsfTrackRef();
213
214	bool Matched=false;
215	for (edm::View<ElectronType>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end(); ++itElectron) {
216	unsigned int idx = itElectron - electrons->begin();
217	if (Matched) continue;
218	reco::GsfTrackRef EgTk= itElectron->gsfTrack();
219	if (itElectron->gsfTrack()==i->gsfTrackRef()){
220	const ElectronBaseRef elecsRef = electrons->refAt(idx);
221	Electron anElectron(elecsRef);
222	FillElectron(anElectron,elecsRef,pfBaseRef, genMatches, trigMatches);
223	Matched=true;
224	anElectron.setPFCandidateRef( pfRef );
225	if( embedPFCandidate_ ) anElectron.embedPFCandidate();
226
227	if (isolator_.enabled()){
228	reco::CandidatePtr mother = ptrToMother->sourceCandidatePtr(0);
229	isolator_.fill(mother, isolatorTmpStorage_);
230	typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
231	for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
232	ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
233	anElectron.setIsolation(it->first, it->second);
234	}
235	for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
236	anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[mother]);
237	}
238	}
239	//Electron Id
240	if (addElecID_) {
241	//STANDARD EL ID
242	for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
243	ids[i].second = (*idhandles[i])[elecsRef];
244	}
245	//SPECIFIC PF ID
246	ids.push_back(std::make_pair("pf_evspi",pfRef->mva_e_pi()));
247	ids.push_back(std::make_pair("pf_evsmu",pfRef->mva_e_mu()));
248	anElectron.setElectronIDs(ids);
249	}
250
251	patElectrons->push_back(anElectron);
252
253	}
254
255
256	}
257
258
259	}
260	}
261
262	else{
263	for (edm::View<ElectronType>::const_iterator itElectron = electrons->begin(); itElectron != electrons->end(); ++itElectron) {
264	// construct the Electron from the ref -> save ref to original object
265	unsigned int idx = itElectron - electrons->begin();
266
267	const ElectronBaseRef elecsRef = electrons->refAt(idx);
268	reco::CandidateBaseRef elecBaseRef(elecsRef);
269
270	// const edm::Ptr<ElectronType> electronPtr = electrons->ptrAt(idx);
271	Electron anElectron(elecsRef);
272
273	FillElectron(anElectron,elecsRef,elecBaseRef, genMatches, trigMatches);
274
275
276	// add resolution info
277
278	// Isolation
279	if (isolator_.enabled()) {
280	isolator_.fill(*electrons, idx, isolatorTmpStorage_);
281	typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
282	// better to loop backwards, so the vector is resized less times
283	for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(), ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
284	anElectron.setIsolation(it->first, it->second);
285	}
286	}
287
288	for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
289	anElectron.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[elecsRef]);
290	}
291
292	// add electron ID info
293	if (addElecID_) {
294	for (size_t i = 0; i < elecIDSrcs_.size(); ++i) {
295	ids[i].second = (*idhandles[i])[elecsRef];
296	}
297	anElectron.setElectronIDs(ids);
298	}
299
300
301	if ( useUserData_ ) {
302	userDataHelper_.add( anElectron, iEvent, iSetup );
303	}
304
305
306	// add sel to selected
307	patElectrons->push_back(anElectron);
308	}
309	}
310
311	// sort electrons in pt
312	std::sort(patElectrons->begin(), patElectrons->end(), pTComparator_);
313
314	// add the electrons to the event output
315	std::auto_ptr<std::vector<Electron> > ptr(patElectrons);
316	iEvent.put(ptr);
317
318	// clean up
319	if (isolator_.enabled()) isolator_.endEvent();
320
321	}
322
323	void PATElectronProducer::FillElectron(Electron& anElectron,
324	const ElectronBaseRef& elecsRef,
325	const reco::CandidateBaseRef& baseRef,
326	const GenAssociations& genMatches,
327	const TrigAssociations& trigMatches)const {
328	if (embedGsfTrack_) anElectron.embedGsfTrack();
329	if (embedSuperCluster_) anElectron.embedSuperCluster();
330	if (embedTrack_) anElectron.embedTrack();
331
332	// store the match to the generated final state muons
333	if (addGenMatch_) {
334	for(size_t i = 0, n = genMatches.size(); i < n; ++i) {
335	reco::GenParticleRef genElectron = (*genMatches[i])[elecsRef];
336	anElectron.addGenParticleRef(genElectron);
337	}
338	if (embedGenMatch_) anElectron.embedGenParticle();
339	}
340	// matches to trigger primitives
341	if ( addTrigMatch_ ) {
342	for ( size_t i = 0; i < trigMatchSrc_.size(); ++i ) {
343	TriggerPrimitiveRef trigPrim = (*trigMatches[i])[elecsRef];
344	if ( trigPrim.isNonnull() && trigPrim.isAvailable() ) {
345	anElectron.addTriggerMatch(*trigPrim);
346	}
347	}
348	}
349
350	if (efficiencyLoader_.enabled()) {
351	efficiencyLoader_.setEfficiencies( anElectron, elecsRef );
352	}
353
354	if (resolutionLoader_.enabled()) {
355	resolutionLoader_.setResolutions(anElectron);
356	}
357
358	// add electron shapes info
359	if (addElecShapes_) {
360	std::vector<float> covariances = lazyTools_->covariances(*(elecsRef->superCluster()->seed())) ;
361	std::vector<float> localCovariances = lazyTools_->localCovariances(*(elecsRef->superCluster()->seed())) ;
362	float scSigmaEtaEta = sqrt(covariances[0]) ;
363	float scSigmaIEtaIEta = sqrt(localCovariances[0]) ;
364	float scE1x5 = lazyTools_->e1x5(*(elecsRef->superCluster()->seed())) ;
365	float scE2x5Max = lazyTools_->e2x5Max(*(elecsRef->superCluster()->seed())) ;
366	float scE5x5 = lazyTools_->e5x5(*(elecsRef->superCluster()->seed())) ;
367	anElectron.setClusterShapes(scSigmaEtaEta,scSigmaIEtaIEta,scE1x5,scE2x5Max,scE5x5) ;
368	}
369	}
370
371
372	#include "FWCore/Framework/interface/MakerMacros.h"
373
374	DEFINE_FWK_MODULE(PATElectronProducer);