#include <TruthTauDecayModeProducer.cc>

Inheritance diagram for TruthTauDecayModeProducer:

Classes
struct	tauObjectsHolder

Public Member Functions
	TruthTauDecayModeProducer (const edm::ParameterSet &)

	~TruthTauDecayModeProducer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob () override

void	endJob () override

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

Private Attributes
AddFourMomenta	addP4

bool	iAmSignal_

edm::InputTag	inputTag_

double	leadTrackEtaCut_

double	leadTrackPtCut_

double	totalEtaCut_

double	totalPtCut_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: Produces reco::PFTauDecayModes corresponding to MonteCarlo objects For signal, it uses decayed MC taus For background, it uses GenJets

Implementation: <Notes on="" implementation>="">

Definition at line 43 of file TruthTauDecayModeProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 68 of file TruthTauDecayModeProducer.cc.

References edm::ParameterSet::getParameter(), iAmSignal_, inputTag_, leadTrackEtaCut_, leadTrackPtCut_, totalEtaCut_, and totalPtCut_.

 {
    edm::LogInfo("TruthTauDecayModeProducer") << "Initializing ctor of TruthTauDecayModeProducer";
    iAmSignal_           = iConfig.getParameter<bool>("iAmSignal");
    inputTag_            = iConfig.getParameter<edm::InputTag>("inputTag");
    leadTrackPtCut_      = iConfig.getParameter<double>("leadTrackPtCut");
    leadTrackEtaCut_     = iConfig.getParameter<double>("leadTrackEtaCut");
    totalPtCut_          = iConfig.getParameter<double>("totalPtCut");
    totalEtaCut_         = iConfig.getParameter<double>("totalEtaCut");
    //register your products
    edm::LogInfo("TruthTauDecayModeProducer") << "Registering products";
    produces<std::vector<reco::PFTauDecayMode> >();
    edm::LogInfo("TruthTauDecayModeProducer") << "TruthTauDecayModeProducer initialized";
 }

TruthTauDecayModeProducer::~TruthTauDecayModeProducer ( )

override

Definition at line 84 of file TruthTauDecayModeProducer.cc.

85 {

86 }

Member Function Documentation

void TruthTauDecayModeProducer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 212 of file TruthTauDecayModeProducer.cc.

213 {

214 }

void TruthTauDecayModeProducer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 218 of file TruthTauDecayModeProducer.cc.

References DEFINE_FWK_MODULE.

218 {

219 }

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

overrideprivate

Definition at line 89 of file TruthTauDecayModeProducer.cc.

References funct::abs(), reco::CompositeCandidate::addDaughter(), addP4, TruthTauDecayModeProducer::tauObjectsHolder::chargedObjects, ttbarCategorization_cff::genJets, edm::Event::getByLabel(), GeneratorTau::getGenChargedPions(), GeneratorTau::getGenNeutralPions(), iAmSignal_, GeneratorTau::init(), inputTag_, GeneratorTau::isFinalStateTau(), leadTrackEtaCut_, jets_cff::leadTrackPt, leadTrackPtCut_, eostools::move(), TruthTauDecayModeProducer::tauObjectsHolder::neutralObjects, reco::LeafCandidate::p4(), common_cff::pdgId, edm::Event::put(), AddFourMomenta::set(), reco::PFTauDecayMode::setPFTauRef(), totalEtaCut_, totalPtCut_, and listHistos::trackPt.

 {
    using namespace edm;
    using namespace std;
    using namespace reco;
 
    std::vector<tauObjectsHolder> tausToAdd_;
 
    /* **********************************************
     * **********  True Tau Case          ***********
     * ********************************************** */
    if (iAmSignal_)
    {
       edm::Handle<RefToBaseVector<reco::Candidate> > decayedMCTaus;
       iEvent.getByLabel(inputTag_, decayedMCTaus);
       for(edm::RefToBaseVector<reco::Candidate>::const_iterator iterGen = decayedMCTaus->begin();
             iterGen != decayedMCTaus->end();
             ++iterGen)
       {
          //copy into custom format (this casting is bullshit)
          GeneratorTau tempTau = static_cast<const GenParticle&>(*(*iterGen));
          //LogInfo("MCTauCandidateProducer") << "Generator tau produced, initializing.. ";
          tempTau.init();
          //LogInfo("MCTauCandidateProducer") << "GenTau initialization done";
          if (tempTau.isFinalStateTau())
          {
             // Build a Tau Candidate from the information contained in the parsing class
             tauObjectsHolder tempTauHolder;
             tempTauHolder.chargedObjects = tempTau.getGenChargedPions();
             tempTauHolder.neutralObjects = tempTau.getGenNeutralPions();
             tausToAdd_.push_back(tempTauHolder);
          }
       }
    } else
    {
    /* **********************************************
     * **********  QCD Case               ***********
     * ********************************************** */
       edm::Handle<GenJetCollection> genJets;
       iEvent.getByLabel(inputTag_, genJets);
       for(GenJetCollection::const_iterator aGenJet = genJets->begin(); aGenJet != genJets->end(); ++aGenJet)
       {
          // get all constituents
          std::vector<const GenParticle*> theJetConstituents = aGenJet->getGenConstituents();
 
          tauObjectsHolder tempTauHolder;
          // filter the constituents
          for( std::vector<const GenParticle*>::const_iterator aCandidate = theJetConstituents.begin();
                aCandidate != theJetConstituents.end();
                ++aCandidate)
          {
             int pdgId = std::abs((*aCandidate)->pdgId());
             const Candidate* theCandidate = static_cast<const Candidate*>(*aCandidate);
             //filter nus
             if (pdgId == 16 || pdgId == 12 || pdgId == 14)
             {
                //do nothing
             } else 
             {
                // call everything charged a pion
                // call everything neutral a neutral pion
                if (theCandidate->charge() != 0)
                   tempTauHolder.chargedObjects.push_back(theCandidate);
                else
                   tempTauHolder.neutralObjects.push_back(theCandidate);
             }
          }
          tausToAdd_.push_back(tempTauHolder);
       }
    }
 
    //output collection
    auto pOut = std::make_unique<std::vector<PFTauDecayMode>>();
    for(std::vector<tauObjectsHolder>::const_iterator iTempTau  = tausToAdd_.begin();
                                                 iTempTau != tausToAdd_.end();
                                               ++iTempTau)
    {
       double leadTrackPt  = 0.;
       double leadTrackEta = 0.;
       VertexCompositeCandidate chargedObjectsToAdd;
       const std::vector<const Candidate*>* chargedObjects = &(iTempTau->chargedObjects);
       for(std::vector<const Candidate*>::const_iterator iCharged  = chargedObjects->begin();
                                                    iCharged != chargedObjects->end();
                                                  ++iCharged)
       {
          chargedObjectsToAdd.addDaughter(**iCharged);
          double trackPt = (*iCharged)->pt();
          if (trackPt > leadTrackPt)
          {
             leadTrackPt  = trackPt;
             leadTrackEta = (*iCharged)->eta();
          }
       }
       //update the composite four vector
       addP4.set(chargedObjectsToAdd);
 
       CompositeCandidate neutralPionsToAdd;
       const std::vector<const Candidate*>* neutralObjects = &(iTempTau->neutralObjects);
       for(std::vector<const Candidate*>::const_iterator iNeutral  = neutralObjects->begin();
                                                    iNeutral != neutralObjects->end();
                                                  ++iNeutral)
       {
          neutralPionsToAdd.addDaughter(**iNeutral);
       }
       addP4.set(neutralPionsToAdd);
 
       Particle::LorentzVector myFourVector = chargedObjectsToAdd.p4();
       myFourVector += neutralPionsToAdd.p4();
 
       if(leadTrackPt > leadTrackPtCut_ && std::abs(leadTrackEta) < leadTrackEtaCut_ && myFourVector.pt() > totalPtCut_ && std::abs(myFourVector.eta()) < totalEtaCut_)
       {
          //TODO: add vertex fitting
          CompositeCandidate theOutliers;
          PFTauRef             noPFTau;     //empty REF to PFTau
          PFTauDecayMode decayModeToAdd(chargedObjectsToAdd, neutralPionsToAdd, theOutliers);
          decayModeToAdd.setPFTauRef(noPFTau);
          pOut->push_back(decayModeToAdd);
       }
    }
    iEvent.put(std::move(pOut));
 }