Inheritance diagram for RecoTauProducer:

Public Types
typedef reco::tau::RecoTauBuilderPlugin	Builder

typedef std::vector< std::unique_ptr< Builder > >	BuilderList

typedef reco::tau::RecoTauModifierPlugin	Modifier

typedef std::vector< std::unique_ptr< Modifier > >	ModifierList

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

Public Member Functions
void	produce (edm::Event &evt, const edm::EventSetup &es) override

	RecoTauProducer (const edm::ParameterSet &pset)

	~RecoTauProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
BuilderList	builders_

bool	buildNullTaus_

edm::EDGetTokenT< reco::PFJetChargedHadronAssociation >	chargedHadron_token

edm::InputTag	chargedHadronSrc_

edm::EDGetTokenT< reco::JetView >	jet_token

edm::EDGetTokenT< edm::AssociationMap< edm::OneToOne< reco::JetView, reco::JetView > > >	jetRegion_token

edm::InputTag	jetRegionSrc_

edm::InputTag	jetSrc_

double	maxJetAbsEta_

double	minJetPt_

ModifierList	modifiers_

std::unique_ptr< StringCutObjectSelector< reco::PFTau > >	outputSelector_

edm::EDGetTokenT< reco::JetPiZeroAssociation >	piZero_token

edm::InputTag	piZeroSrc_

Detailed Description

Definition at line 46 of file RecoTauProducer.cc.

Member Typedef Documentation

typedef reco::tau::RecoTauBuilderPlugin RecoTauProducer::Builder

Definition at line 49 of file RecoTauProducer.cc.

typedef std::vector<std::unique_ptr<Builder> > RecoTauProducer::BuilderList

Definition at line 51 of file RecoTauProducer.cc.

typedef reco::tau::RecoTauModifierPlugin RecoTauProducer::Modifier

Definition at line 50 of file RecoTauProducer.cc.

typedef std::vector<std::unique_ptr<Modifier> > RecoTauProducer::ModifierList

Definition at line 52 of file RecoTauProducer.cc.

Constructor & Destructor Documentation

RecoTauProducer::RecoTauProducer ( const edm::ParameterSet & pset )

explicit

Definition at line 84 of file RecoTauProducer.cc.

References PFRecoTauChargedHadronProducer_cff::builders, builders_, buildNullTaus_, chargedHadron_token, chargedHadronSrc_, beamerCreator::create(), reco::get(), edm::ParameterSet::getParameter(), jet_token, jetRegion_token, jetRegionSrc_, jetSrc_, maxJetAbsEta_, minJetPt_, modifiers_, outputSelector_, piZero_token, piZeroSrc_, corrVsCorr::selection, AlCaHLTBitMon_QueryRunRegistry::string, and HistogramManager_cfi::VPSet().

 {
   jetSrc_ = pset.getParameter<edm::InputTag>("jetSrc");
   jetRegionSrc_ = pset.getParameter<edm::InputTag>("jetRegionSrc");
   chargedHadronSrc_ = pset.getParameter<edm::InputTag>("chargedHadronSrc");
   piZeroSrc_ = pset.getParameter<edm::InputTag>("piZeroSrc");
   
   minJetPt_ = pset.getParameter<double>("minJetPt");
   maxJetAbsEta_ = pset.getParameter<double>("maxJetAbsEta");
   //consumes definition
   jet_token=consumes<reco::JetView>(jetSrc_);
   jetRegion_token = consumes<edm::AssociationMap<edm::OneToOne<reco::JetView, reco::JetView> > >(jetRegionSrc_);
   chargedHadron_token = consumes<reco::PFJetChargedHadronAssociation>(chargedHadronSrc_); 
   piZero_token = consumes<reco::JetPiZeroAssociation>(piZeroSrc_);
 
   typedef std::vector<edm::ParameterSet> VPSet;
   // Get each of our tau builders
   const VPSet& builders = pset.getParameter<VPSet>("builders");
   for ( VPSet::const_iterator builderPSet = builders.begin();
     builderPSet != builders.end(); ++builderPSet ) {
     // Get plugin name
     const std::string& pluginType = builderPSet->getParameter<std::string>("plugin");
     // Build the plugin
     builders_.emplace_back(RecoTauBuilderPluginFactory::get()->create(pluginType, *builderPSet, consumesCollector()));
   }
 
   const VPSet& modfiers = pset.getParameter<VPSet>("modifiers");
   for ( VPSet::const_iterator modfierPSet = modfiers.begin();
     modfierPSet != modfiers.end(); ++modfierPSet) {
     // Get plugin name
     const std::string& pluginType = modfierPSet->getParameter<std::string>("plugin");
     // Build the plugin
     modifiers_.emplace_back(RecoTauModifierPluginFactory::get()->create(pluginType, *modfierPSet, consumesCollector()));
   }
 
   // Check if we want to apply a final output selection
   std::string selection = pset.getParameter<std::string>("outputSelection");
   if ( !selection.empty() ) {
     outputSelector_.reset(new StringCutObjectSelector<reco::PFTau>(selection));
   }
   buildNullTaus_ = pset.getParameter<bool>("buildNullTaus");
 
   produces<reco::PFTauCollection>();
 }

RecoTauProducer::~RecoTauProducer ( )

inlineoverride

Definition at line 55 of file RecoTauProducer.cc.

References fillDescriptions(), and produce().

55 {}

Member Function Documentation

void RecoTauProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 243 of file RecoTauProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), edm::ParameterSetDescription::addVPSetOptional(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~RecoTauProducer().

                                                                             {
   // combinatoricRecoTaus
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("piZeroSrc", edm::InputTag("ak4PFJetsRecoTauPiZeros"));
 
   edm::ParameterSetDescription pset_signalQualityCuts;
   pset_signalQualityCuts.add<double>("maxDeltaZ", 0.4);
   pset_signalQualityCuts.add<double>("minTrackPt", 0.5);
   pset_signalQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   pset_signalQualityCuts.add<double>("maxTrackChi2", 100.0);
   pset_signalQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   pset_signalQualityCuts.add<double>("minGammaEt", 1.0);
   pset_signalQualityCuts.add<unsigned int>("minTrackHits", 3);
   pset_signalQualityCuts.add<double>("minNeutralHadronEt", 30.0);
   pset_signalQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
   pset_signalQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
   edm::ParameterSetDescription pset_vxAssocQualityCuts;
   pset_vxAssocQualityCuts.add<double>("minTrackPt", 0.5);
   pset_vxAssocQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   pset_vxAssocQualityCuts.add<double>("maxTrackChi2", 100.0);
   pset_vxAssocQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   pset_vxAssocQualityCuts.add<double>("minGammaEt", 1.0);
   pset_vxAssocQualityCuts.add<unsigned int>("minTrackHits", 3);
   pset_vxAssocQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
   pset_vxAssocQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
   edm::ParameterSetDescription pset_isolationQualityCuts;
   pset_isolationQualityCuts.add<double>("maxDeltaZ", 0.2);
   pset_isolationQualityCuts.add<double>("minTrackPt", 1.0);
   pset_isolationQualityCuts.add<double>("minTrackVertexWeight", -1.0);
   pset_isolationQualityCuts.add<double>("maxTrackChi2", 100.0);
   pset_isolationQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
   pset_isolationQualityCuts.add<double>("minGammaEt", 1.5);
   pset_isolationQualityCuts.add<unsigned int>("minTrackHits", 8);
   pset_isolationQualityCuts.add<double>("maxTransverseImpactParameter", 0.03);
   pset_isolationQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
   edm::ParameterSetDescription pset_qualityCuts;
   pset_qualityCuts.add<edm::ParameterSetDescription>("signalQualityCuts",    pset_signalQualityCuts);
   pset_qualityCuts.add<edm::ParameterSetDescription>("vxAssocQualityCuts",   pset_vxAssocQualityCuts);
   pset_qualityCuts.add<edm::ParameterSetDescription>("isolationQualityCuts", pset_isolationQualityCuts);
   pset_qualityCuts.add<std::string>("leadingTrkOrPFCandOption", "leadPFCand");
   pset_qualityCuts.add<std::string>("pvFindingAlgo", "closestInDeltaZ");
   pset_qualityCuts.add<edm::InputTag>("primaryVertexSrc", edm::InputTag("offlinePrimaryVertices"));
   pset_qualityCuts.add<bool>("vertexTrackFiltering", false);
   pset_qualityCuts.add<bool>("recoverLeadingTrk", false);
 
   {
     edm::ParameterSetDescription vpsd_modifiers;
     vpsd_modifiers.add<std::string>("name");
     vpsd_modifiers.add<std::string>("plugin");
     vpsd_modifiers.add<int>("verbosity", 0);
 
     vpsd_modifiers.add<edm::ParameterSetDescription>("qualityCuts", pset_qualityCuts);
     vpsd_modifiers.addOptional<edm::InputTag>("ElectronPreIDProducer");
     vpsd_modifiers.addOptional<std::string>("DataType");
     vpsd_modifiers.addOptional<double>("maximumForElectrionPreIDOutput");
     vpsd_modifiers.addOptional<double>("ElecPreIDLeadTkMatch_maxDR");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_minClusEnergy");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaPhiOverQ_minValue");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaPhiOverQ_maxValue");
     vpsd_modifiers.addOptional<double>("EcalStripSumE_deltaEta");
     vpsd_modifiers.addOptional<double>("dRaddNeutralHadron");
     vpsd_modifiers.addOptional<double>("minGammaEt");
     vpsd_modifiers.addOptional<double>("dRaddPhoton");
     vpsd_modifiers.addOptional<double>("minNeutralHadronEt");
     vpsd_modifiers.addOptional<edm::InputTag>("pfTauTagInfoSrc");
 
     desc.addVPSet("modifiers", vpsd_modifiers);
   }
 
   desc.add<edm::InputTag>("jetRegionSrc", edm::InputTag("recoTauAK4PFJets08Region"));
   desc.add<double>("maxJetAbsEta", 2.5);
   desc.add<std::string>("outputSelection", "leadPFChargedHadrCand().isNonnull()");
   desc.add<edm::InputTag>("chargedHadronSrc", edm::InputTag("ak4PFJetsRecoTauChargedHadrons"));
   desc.add<double>("minJetPt", 14.0);
   desc.add<edm::InputTag>("jetSrc", edm::InputTag("ak4PFJets"));
 
   {
     edm::ParameterSetDescription desc_builders;
     desc_builders.add<std::string>("name");
     desc_builders.add<std::string>("plugin");
     desc_builders.add<int>("verbosity", 0);
 
     desc_builders.add<edm::ParameterSetDescription>("qualityCuts", pset_qualityCuts);
     {
       edm::ParameterSetDescription desc_decayModes;
       desc_decayModes.add<unsigned int>("nPiZeros", 0);
       desc_decayModes.add<unsigned int>("maxPiZeros", 0);
       desc_decayModes.add<unsigned int>("nCharged", 1);
       desc_decayModes.add<unsigned int>("maxTracks", 6);
       desc_builders.addVPSetOptional("decayModes", desc_decayModes);
     }
     desc_builders.add<double>("minAbsPhotonSumPt_insideSignalCone", 2.5);
     desc_builders.add<double>("minRelPhotonSumPt_insideSignalCone", 0.1);
     desc_builders.add<edm::InputTag>("pfCandSrc", edm::InputTag("particleFlow"));
     
     desc_builders.addOptional<std::string>("signalConeSize");
     desc_builders.addOptional<double>("isolationConeSize");
     desc_builders.addOptional<double>("minAbsPhotonSumPt_outsideSignalCone");
     desc_builders.addOptional<double>("minRelPhotonSumPt_outsideSignalCone");
     desc_builders.addOptional<std::string>("isoConeChargedHadrons");
     desc_builders.addOptional<std::string>("isoConeNeutralHadrons");
     desc_builders.addOptional<std::string>("isoConePiZeros");
     desc_builders.addOptional<double>("leadObjectPt");
     desc_builders.addOptional<std::string>("matchingCone");
     desc_builders.addOptional<int>("maxSignalConeChargedHadrons");
     desc_builders.addOptional<std::string>("signalConeChargedHadrons");
     desc_builders.addOptional<std::string>("signalConeNeutralHadrons");
     desc_builders.addOptional<std::string>("signalConePiZeros");
     desc_builders.addOptional<bool>("usePFLeptons");
 
     std::vector<edm::ParameterSet> vpset_default;
     {
       edm::ParameterSet pset_default_builders;
       pset_default_builders.addParameter<std::string>("name","");
       pset_default_builders.addParameter<std::string>("plugin","");
       pset_default_builders.addParameter<int>("verbosity",0);
       pset_default_builders.addParameter<double>("minAbsPhotonSumPt_insideSignalCone", 2.5);
       pset_default_builders.addParameter<double>("minRelPhotonSumPt_insideSignalCone", 0.1);
       pset_default_builders.addParameter<edm::InputTag>("pfCandSrc", edm::InputTag("particleFlow"));
       vpset_default.push_back(pset_default_builders);
     }
     desc.addVPSet("builders", desc_builders, vpset_default);
 
   }
 
   desc.add<bool>("buildNullTaus", false);
   desc.add<int>("verbosity", 0);
   descriptions.add("combinatoricRecoTaus", desc);
 }

void RecoTauProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 129 of file RecoTauProducer.cc.

References funct::abs(), builders_, buildNullTaus_, chargedHadron_token, MillePedeFileConverter_cfg::e, Exception, edm::Event::getByToken(), edm::RefToBase< T >::isNull(), jet_token, jetRegion_token, maxJetAbsEta_, minJetPt_, modifiers_, eostools::move(), convertSQLitetoXML_cfg::output, outputSelector_, piZero_token, edm::Event::put(), edm::View< T >::refAt(), reco::PFTau::setjetRef(), edm::View< T >::size(), jetUpdater_cfi::sort, metsig::tau, and nano_cff::taus.

Referenced by ~RecoTauProducer().

 {
   // Get the jet input collection via a view of Candidates
   edm::Handle<reco::JetView> jetView;
   evt.getByToken(jet_token, jetView);
     
   // Get the jet region producer
   edm::Handle<edm::AssociationMap<edm::OneToOne<reco::JetView, reco::JetView> > > jetRegionHandle;
   evt.getByToken(jetRegion_token, jetRegionHandle);
   
   // Get the charged hadron input collection
   edm::Handle<reco::PFJetChargedHadronAssociation> chargedHadronAssoc;
   evt.getByToken(chargedHadron_token, chargedHadronAssoc);
 
   // Get the pizero input collection
   edm::Handle<reco::JetPiZeroAssociation> piZeroAssoc;
   evt.getByToken(piZero_token, piZeroAssoc);
 
   // Update all our builders and modifiers with the event info
   for (auto& builder: builders_) {
     builder->setup(evt, es);
   }
   for (auto& modifier: modifiers_) {
     modifier->setup(evt, es);
   }
 
   // Create output collection
   auto output = std::make_unique<reco::PFTauCollection>();
   output->reserve(jetView->size());
   
   // Loop over the jets and build the taus for each jet
   for (size_t i_j = 0; i_j < jetView->size(); ++i_j) {
     const auto& jetRef = jetView->refAt(i_j);
     // Get the jet with extra constituents from an area around the jet
     if(jetRef->pt() - minJetPt_ < 1e-5) continue;
     if(std::abs(jetRef->eta()) - maxJetAbsEta_ > -1e-5) continue;
     reco::JetBaseRef jetRegionRef = (*jetRegionHandle)[jetRef];
     if ( jetRegionRef.isNull() ) {
       throw cms::Exception("BadJetRegionRef") 
     << "No jet region can be found for the current jet: " << jetRef.id();
     }
     // Remove all the jet constituents from the jet extras
     std::vector<reco::CandidatePtr> jetCands = jetRef->daughterPtrVector();
     std::vector<reco::CandidatePtr> allRegionalCands = jetRegionRef->daughterPtrVector();
     // Sort both by ref key
     std::sort(jetCands.begin(), jetCands.end());
     std::sort(allRegionalCands.begin(), allRegionalCands.end());
     // Get the regional junk candidates not in the jet.
     std::vector<reco::CandidatePtr> uniqueRegionalCands;
 
     // This can actually be less than zero, if the jet has really crazy soft
     // stuff really far away from the jet axis.
     if ( allRegionalCands.size() > jetCands.size() ) {
       uniqueRegionalCands.reserve(allRegionalCands.size() - jetCands.size());
     }
 
     // Subtract the jet cands from the regional cands
     std::set_difference(allRegionalCands.begin(), allRegionalCands.end(),
             jetCands.begin(), jetCands.end(),
             std::back_inserter(uniqueRegionalCands));
 
     // Get the charged hadrons associated with this jet
     const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = (*chargedHadronAssoc)[jetRef];
 
     // Get the pizeros associated with this jet
     const std::vector<reco::RecoTauPiZero>& piZeros = (*piZeroAssoc)[jetRef];
     // Loop over our builders and create the set of taus for this jet
     unsigned int nTausBuilt = 0;
     for ( const auto& builder: builders_ ) {
       // Get a ptr_vector of taus from the builder
       reco::tau::RecoTauBuilderPlugin::output_type taus((*builder)(jetRef, chargedHadrons, piZeros, uniqueRegionalCands));
 
       // Make sure all taus have their jetref set correctly
       std::for_each(taus.begin(), taus.end(), boost::bind(&reco::PFTau::setjetRef, _1, reco::JetBaseRef(jetRef)));
       // Copy without selection
       if ( !outputSelector_.get() ) {
         output->insert(output->end(), taus.begin(), taus.end());
         nTausBuilt += taus.size();
       } else {
         // Copy only those that pass the selection.
         for(auto const& tau : taus ) {
           if ( (*outputSelector_)(tau) ) {
             nTausBuilt++;
             output->push_back(tau);
           }
         }
       }
     }
     // If we didn't build *any* taus for this jet, build a null tau if desired.
     // The null PFTau has no content, but it's four vector is set to that of the
     // jet.
     if ( !nTausBuilt && buildNullTaus_ ) {
       reco::PFTau nullTau(std::numeric_limits<int>::quiet_NaN(), jetRef->p4());
       nullTau.setjetRef(reco::JetBaseRef(jetRef));
       output->push_back(nullTau);
     }
   }
 
   // Loop over the taus we have created and apply our modifiers to the taus
   for ( reco::PFTauCollection::iterator tau = output->begin();
     tau != output->end(); ++tau ) {
     for ( const auto& modifier: modifiers_ ) {
       (*modifier)(*tau);
     }
   }
   
   for ( auto& modifier: modifiers_ ) {
     modifier->endEvent();
   }
   
   evt.put(std::move(output));
 }