Produces the pat::GenericParticle. More...

Inheritance diagram for pat::PATGenericParticleProducer:

Public Member Functions
	PATGenericParticleProducer (const edm::ParameterSet &iConfig)

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

	~PATGenericParticleProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
bool	addEfficiencies_

bool	addGenMatch_

bool	addQuality_

bool	addResolutions_

pat::helper::EfficiencyLoader	efficiencyLoader_

bool	embedCaloTower_

bool	embedCombined_

bool	embedGenMatch_

bool	embedGsfTrack_

bool	embedStandalone_

bool	embedSuperCluster_

bool	embedTrack_

bool	embedTracks_

GreaterByEt< GenericParticle >	eTComparator_

std::vector< edm::EDGetTokenT < edm::Association < reco::GenParticleCollection > > >	genMatchTokens_

std::vector< std::pair < pat::IsolationKeys, edm::InputTag > >	isoDepositLabels_

std::vector< edm::EDGetTokenT < edm::ValueMap< IsoDeposit > > >	isoDepositTokens_

pat::helper::MultiIsolator	isolator_

pat::helper::MultiIsolator::IsolationValuePairs	isolatorTmpStorage_

edm::EDGetTokenT < edm::ValueMap< float > >	qualitySrcToken_

pat::helper::KinResolutionsLoader	resolutionLoader_

edm::EDGetTokenT< edm::View < reco::Candidate > >	srcToken_

pat::PATUserDataHelper < pat::GenericParticle >	userDataHelper_

bool	useUserData_

pat::helper::VertexingHelper	vertexingHelper_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Produces the pat::GenericParticle.

The PATGenericParticleProducer produces the analysis-level pat::GenericParticle starting from any collection of Candidates

Author: Giovanni Petrucciani

Version

Id:: PATGenericParticleProducer.h,v 1.9 2009/06/25 23:49:35 gpetrucc Exp

Definition at line 35 of file PATGenericParticleProducer.cc.

Constructor & Destructor Documentation

PATGenericParticleProducer::PATGenericParticleProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 81 of file PATGenericParticleProducer.cc.

References addGenMatch_, embedCaloTower_, embedCombined_, embedGenMatch_, embedGsfTrack_, embedStandalone_, embedSuperCluster_, embedTrack_, embedTracks_, edm::ParameterSet::existsAs(), genMatchTokens_, edm::ParameterSet::getParameter(), srcToken_, GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

     : isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation")
                                                 : edm::ParameterSet(),
                 consumesCollector(),
                 false),
       userDataHelper_(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector()) {
   // initialize the configurables
   srcToken_ = consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("src"));
 
   // RECO embedding
   embedTrack_ = iConfig.getParameter<bool>("embedTrack");
   embedGsfTrack_ = iConfig.getParameter<bool>("embedGsfTrack");
   embedStandalone_ = iConfig.getParameter<bool>("embedStandAloneMuon");
   embedCombined_ = iConfig.getParameter<bool>("embedCombinedMuon");
   embedSuperCluster_ = iConfig.getParameter<bool>("embedSuperCluster");
   embedTracks_ = iConfig.getParameter<bool>("embedMultipleTracks");
   embedCaloTower_ = iConfig.getParameter<bool>("embedCaloTower");
 
   // MC matching configurables
   addGenMatch_ = iConfig.getParameter<bool>("addGenMatch");
   if (addGenMatch_) {
     embedGenMatch_ = iConfig.getParameter<bool>("embedGenMatch");
     if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
       genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection> >(
           iConfig.getParameter<edm::InputTag>("genParticleMatch")));
     } else {
       genMatchTokens_ = edm::vector_transform(
           iConfig.getParameter<std::vector<edm::InputTag> >("genParticleMatch"),
           [this](edm::InputTag const& tag) { return consumes<edm::Association<reco::GenParticleCollection> >(tag); });
     }
   }
 
   // quality
   addQuality_ = iConfig.getParameter<bool>("addQuality");
   qualitySrcToken_ = mayConsume<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("qualitySource"));
 
   // produces vector of particles
   produces<std::vector<GenericParticle> >();
 
   if (iConfig.exists("isoDeposits")) {
     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>("isoDeposits");
     if (depconf.exists("tracker"))
       isoDepositLabels_.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
     if (depconf.exists("ecal"))
       isoDepositLabels_.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
     if (depconf.exists("hcal"))
       isoDepositLabels_.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
     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));
       }
     }
   }
   isoDepositTokens_ =
       edm::vector_transform(isoDepositLabels_, [this](std::pair<IsolationKeys, edm::InputTag> const& label) {
         return consumes<edm::ValueMap<IsoDeposit> >(label.second);
       });
 
   // Efficiency configurables
   addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
   if (addEfficiencies_) {
     efficiencyLoader_ =
         pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
   }
 
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
     resolutionLoader_ =
         pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
 
   if (iConfig.exists("vertexing")) {
     vertexingHelper_ =
         pat::helper::VertexingHelper(iConfig.getParameter<edm::ParameterSet>("vertexing"), consumesCollector());
   }
 
   // Check to see if the user wants to add user data
   useUserData_ = false;
   if (iConfig.exists("userData")) {
     useUserData_ = true;
   }
 }

PATGenericParticleProducer::~PATGenericParticleProducer ( )

override

Definition at line 168 of file PATGenericParticleProducer.cc.

168 {}

Member Function Documentation

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

override

Definition at line 170 of file PATGenericParticleProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), addQuality_, pat::helper::MultiIsolator::beginEvent(), HLT_FULL_cff::cands, efficiencyLoader_, pat::GenericParticle::embedCaloTower(), embedCaloTower_, pat::GenericParticle::embedCombined(), embedCombined_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::GenericParticle::embedGsfTrack(), embedGsfTrack_, pat::GenericParticle::embedStandalone(), embedStandalone_, pat::GenericParticle::embedSuperCluster(), embedSuperCluster_, pat::GenericParticle::embedTrack(), embedTrack_, pat::GenericParticle::embedTracks(), embedTracks_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), pat::helper::MultiIsolator::enabled(), pat::helper::VertexingHelper::enabled(), pat::helper::MultiIsolator::endEvent(), eTComparator_, pat::helper::MultiIsolator::fill(), first, genMatchTokens_, edm::Event::getByToken(), mps_fire::i, isoDepositLabels_, isoDepositTokens_, isolator_, isolatorTmpStorage_, dqmiolumiharvest::j, eostools::move(), dqmiodumpmetadata::n, pat::helper::EfficiencyLoader::newEvent(), pat::helper::KinResolutionsLoader::newEvent(), pat::helper::VertexingHelper::newEvent(), edm::Event::put(), qualities, qualitySrcToken_, resolutionLoader_, pat::helper::EfficiencyLoader::setEfficiencies(), pat::GenericParticle::setIsoDeposit(), pat::GenericParticle::setIsolation(), pat::GenericParticle::setQuality(), pat::helper::KinResolutionsLoader::setResolutions(), pat::GenericParticle::setVertexAssociation(), srcToken_, userDataHelper_, useUserData_, and vertexingHelper_.

                                                                                       {
   // Get the vector of GenericParticle's from the event
   edm::Handle<edm::View<reco::Candidate> > cands;
   iEvent.getByToken(srcToken_, cands);
 
   // prepare isolation
   if (isolator_.enabled())
     isolator_.beginEvent(iEvent, iSetup);
 
   if (efficiencyLoader_.enabled())
     efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled())
     resolutionLoader_.newEvent(iEvent, iSetup);
   if (vertexingHelper_.enabled())
     vertexingHelper_.newEvent(iEvent, iSetup);
 
   // prepare IsoDeposits
   std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > deposits(isoDepositTokens_.size());
   for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
     iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
   }
 
   // prepare the MC matching
   std::vector<edm::Handle<edm::Association<reco::GenParticleCollection> > > genMatches(genMatchTokens_.size());
   if (addGenMatch_) {
     for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
       iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
     }
   }
 
   // prepare the quality
   edm::Handle<edm::ValueMap<float> > qualities;
   if (addQuality_)
     iEvent.getByToken(qualitySrcToken_, qualities);
 
   // loop over cands
   std::vector<GenericParticle>* PATGenericParticles = new std::vector<GenericParticle>();
   for (edm::View<reco::Candidate>::const_iterator itGenericParticle = cands->begin(); itGenericParticle != cands->end();
        itGenericParticle++) {
     // construct the GenericParticle from the ref -> save ref to original object
     unsigned int idx = itGenericParticle - cands->begin();
     edm::RefToBase<reco::Candidate> candRef = cands->refAt(idx);
 
     PATGenericParticles->push_back(GenericParticle(candRef));
     GenericParticle& aGenericParticle = PATGenericParticles->back();
 
     // embed RECO
     if (embedTrack_)
       aGenericParticle.embedTrack();
     if (embedGsfTrack_)
       aGenericParticle.embedGsfTrack();
     if (embedTracks_)
       aGenericParticle.embedTracks();
     if (embedStandalone_)
       aGenericParticle.embedStandalone();
     if (embedCombined_)
       aGenericParticle.embedCombined();
     if (embedSuperCluster_)
       aGenericParticle.embedSuperCluster();
     if (embedCaloTower_)
       aGenericParticle.embedCaloTower();
 
     // isolation
     if (isolator_.enabled()) {
       isolator_.fill(*cands, 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) {
         aGenericParticle.setIsolation(it->first, it->second);
       }
     }
 
     // isodeposit
     for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
       aGenericParticle.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[candRef]);
     }
 
     // store the match to the generated final state muons
     if (addGenMatch_) {
       for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
         reco::GenParticleRef genGenericParticle = (*genMatches[i])[candRef];
         aGenericParticle.addGenParticleRef(genGenericParticle);
       }
       if (embedGenMatch_)
         aGenericParticle.embedGenParticle();
     }
 
     if (addQuality_) {
       aGenericParticle.setQuality((*qualities)[candRef]);
     }
 
     if (efficiencyLoader_.enabled()) {
       efficiencyLoader_.setEfficiencies(aGenericParticle, candRef);
     }
 
     if (resolutionLoader_.enabled()) {
       resolutionLoader_.setResolutions(aGenericParticle);
     }
 
     if (vertexingHelper_.enabled()) {
       aGenericParticle.setVertexAssociation(vertexingHelper_(candRef));
     }
 
     if (useUserData_) {
       userDataHelper_.add(aGenericParticle, iEvent, iSetup);
     }
 
     // PATGenericParticles->push_back(aGenericParticle); // NOOOOO!!!!
     // We have already pushed_back this generic particle in the collection
     // (we first push an empty particle and then fill it, to avoid useless copies)
   }
 
   // sort GenericParticles in ET
   std::sort(PATGenericParticles->begin(), PATGenericParticles->end(), eTComparator_);
 
   // put genEvt object in Event
   std::unique_ptr<std::vector<GenericParticle> > myGenericParticles(PATGenericParticles);
   iEvent.put(std::move(myGenericParticles));
   if (isolator_.enabled())
     isolator_.endEvent();
 }