Inheritance diagram for RecoTauDiscriminantCutMultiplexer:

Classes
struct	DiscriminantCutEntry

Public Member Functions
void	beginEvent (const edm::Event &event, const edm::EventSetup &eventSetup) override

double	discriminate (const reco::PFTauRef &) const override

	RecoTauDiscriminantCutMultiplexer (const edm::ParameterSet &pset)

	~RecoTauDiscriminantCutMultiplexer () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double	discriminate (const TauRef &tau) const =0

virtual void	endEvent (edm::Event &)

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

	~TauDiscriminationProducerBase () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)

Private Types
typedef std::map< int, std::unique_ptr< DiscriminantCutEntry > >	DiscriminantCutMap

Private Attributes
DiscriminantCutMap	cuts_

edm::FileInPath	inputFileName_

bool	isInitialized_

edm::InputTag	key_

edm::EDGetTokenT< reco::PFTauDiscriminator >	key_token

edm::Handle< reco::PFTauDiscriminator >	keyHandle_

bool	loadMVAfromDB_

std::string	moduleLabel_

std::unique_ptr< const TFormula >	mvaOutput_normalization_

std::string	mvaOutputNormalizationName_

edm::InputTag	toMultiplex_

edm::EDGetTokenT< reco::PFTauDiscriminator >	toMultiplex_token

edm::Handle< reco::PFTauDiscriminator >	toMultiplexHandle_

int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd< TauCollection >	TauRefProd

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

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 37 of file RecoTauDiscriminantCutMultiplexer.cc.

Member Typedef Documentation

typedef std::map<int, std::unique_ptr<DiscriminantCutEntry> > RecoTauDiscriminantCutMultiplexer::DiscriminantCutMap

private

Definition at line 63 of file RecoTauDiscriminantCutMultiplexer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 133 of file RecoTauDiscriminantCutMultiplexer.cc.

References taus_updatedMVAIds_cff::category, gather_cfg::cout, TkAlMuonSelectors_cfi::cut, cuts_, Exception, edm::ParameterSet::getParameter(), inputFileName_, key_, key_token, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kFixedCut, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kVariableCut, loadMVAfromDB_, taus_updatedMVAIds_cff::mapping, moduleLabel_, eostools::move(), mvaOutputNormalizationName_, AlCaHLTBitMon_QueryRunRegistry::string, toMultiplex_, toMultiplex_token, verbosity_, and HistogramManager_cfi::VPSet().

     : PFTauDiscriminationProducerBase(cfg),
       moduleLabel_(cfg.getParameter<std::string>("@module_label")),
       mvaOutput_normalization_(),
       isInitialized_(false) {
   toMultiplex_ = cfg.getParameter<edm::InputTag>("toMultiplex");
   toMultiplex_token = consumes<reco::PFTauDiscriminator>(toMultiplex_);
   key_ = cfg.getParameter<edm::InputTag>("key");
   key_token = consumes<reco::PFTauDiscriminator>(key_);
 
   verbosity_ = cfg.getParameter<int>("verbosity");
 
   loadMVAfromDB_ = cfg.getParameter<bool>("loadMVAfromDB");
   if (!loadMVAfromDB_) {
     inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
   }
   if (verbosity_)
     std::cout << moduleLabel_ << " loadMVA = " << loadMVAfromDB_ << std::endl;
   mvaOutputNormalizationName_ = cfg.getParameter<std::string>("mvaOutput_normalization");
 
   // Setup our cut map
   typedef std::vector<edm::ParameterSet> VPSet;
   VPSet mapping = cfg.getParameter<VPSet>("mapping");
   for (VPSet::const_iterator mappingEntry = mapping.begin(); mappingEntry != mapping.end(); ++mappingEntry) {
     unsigned category = mappingEntry->getParameter<uint32_t>("category");
     std::unique_ptr<DiscriminantCutEntry> cut{new DiscriminantCutEntry()};
     if (mappingEntry->existsAs<double>("cut")) {
       cut->cutValue_ = mappingEntry->getParameter<double>("cut");
       cut->mode_ = DiscriminantCutEntry::kFixedCut;
     } else if (mappingEntry->existsAs<std::string>("cut")) {
       cut->cutName_ = mappingEntry->getParameter<std::string>("cut");
       std::string cutVariable_string = mappingEntry->getParameter<std::string>("variable");
       cut->cutVariable_.reset(new StringObjectFunction<reco::PFTau>(cutVariable_string));
       cut->mode_ = DiscriminantCutEntry::kVariableCut;
     } else {
       throw cms::Exception("RecoTauDiscriminantCutMultiplexer") << " Undefined Configuration Parameter 'cut' !!\n";
     }
     cuts_[category] = std::move(cut);
   }
 
   verbosity_ = cfg.getParameter<int>("verbosity");
   if (verbosity_)
     std::cout << "constructed " << moduleLabel_ << std::endl;
 }

RecoTauDiscriminantCutMultiplexer::~RecoTauDiscriminantCutMultiplexer ( )

override

Definition at line 178 of file RecoTauDiscriminantCutMultiplexer.cc.

178 {}

Member Function Documentation

void RecoTauDiscriminantCutMultiplexer::beginEvent	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 180 of file RecoTauDiscriminantCutMultiplexer.cc.

References gather_cfg::cout, TkAlMuonSelectors_cfi::cut, cuts_, edm::Event::getByToken(), dtResolutionTest_cfi::inputFile, inputFileName_, isInitialized_, key_token, keyHandle_, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kVariableCut, loadMVAfromDB_, moduleLabel_, eostools::move(), mvaOutput_normalization_, mvaOutputNormalizationName_, groupFilesInBlocks::temp, toMultiplex_token, toMultiplexHandle_, and verbosity_.

                                                                                                {
   if (verbosity_)
     std::cout << " begin! " << moduleLabel_ << " " << isInitialized_ << std::endl;
   if (!isInitialized_) {
     //Only open the file once and we can close it when this routine is done
     // since all objects gotten from the file will have been copied
     std::unique_ptr<TFile> inputFile;
     if (!mvaOutputNormalizationName_.empty()) {
       if (!loadMVAfromDB_) {
         inputFile = openInputFile(inputFileName_);
         mvaOutput_normalization_ = loadObjectFromFile<TFormula>(*inputFile, mvaOutputNormalizationName_);
       } else {
         auto temp = loadTFormulaFromDB(
             es, mvaOutputNormalizationName_, Form("%s_mvaOutput_normalization", moduleLabel_.data()), verbosity_);
         mvaOutput_normalization_ = std::move(temp);
       }
     }
     for (DiscriminantCutMap::iterator cut = cuts_.begin(); cut != cuts_.end(); ++cut) {
       if (cut->second->mode_ == DiscriminantCutEntry::kVariableCut) {
         if (!loadMVAfromDB_) {
           if (not inputFile) {
             inputFile = openInputFile(inputFileName_);
           }
           if (verbosity_)
             std::cout << "Loading from file" << inputFileName_ << std::endl;
           cut->second->cutFunction_ = loadObjectFromFile<TGraph>(*inputFile, cut->second->cutName_);
         } else {
           if (verbosity_)
             std::cout << "Loading from DB" << std::endl;
           cut->second->cutFunction_ = loadTGraphFromDB(es, cut->second->cutName_, verbosity_);
         }
       }
     }
     isInitialized_ = true;
   }
 
   evt.getByToken(toMultiplex_token, toMultiplexHandle_);
   evt.getByToken(key_token, keyHandle_);
 }

double RecoTauDiscriminantCutMultiplexer::discriminate ( const reco::PFTauRef & tau ) const

override

Definition at line 220 of file RecoTauDiscriminantCutMultiplexer.cc.

References gather_cfg::cout, cuts_, geometryDiff::epsilon, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kFixedCut, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kVariableCut, moduleLabel_, mvaOutput_normalization_, TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_, metsig::tau, verbosity_, multiplicitycorr_cfi::xMax, and photonAnalyzer_cfi::xMin.

                                                                                     {
   if (verbosity_) {
     std::cout << "<RecoTauDiscriminantCutMultiplexer::discriminate>:" << std::endl;
     std::cout << " moduleLabel = " << moduleLabel_ << std::endl;
   }
 
   double disc_result = (*toMultiplexHandle_)[tau];
   if (verbosity_) {
     std::cout << "disc_result = " << disc_result << std::endl;
   }
   if (mvaOutput_normalization_) {
     disc_result = mvaOutput_normalization_->Eval(disc_result);
     //if ( disc_result > 1. ) disc_result = 1.;
     //if ( disc_result < 0. ) disc_result = 0.;
     if (verbosity_) {
       std::cout << "disc_result (normalized) = " << disc_result << std::endl;
     }
   }
   double key_result = (*keyHandle_)[tau];
   DiscriminantCutMap::const_iterator cutIter = cuts_.find(TMath::Nint(key_result));
 
   // Return null if it doesn't exist
   if (cutIter == cuts_.end()) {
     return prediscriminantFailValue_;
   }
   // See if the discriminator passes our cuts
   bool passesCuts = false;
   if (cutIter->second->mode_ == DiscriminantCutEntry::kFixedCut) {
     passesCuts = (disc_result > cutIter->second->cutValue_);
     if (verbosity_) {
       std::cout << "cutValue (fixed) = " << cutIter->second->cutValue_ << " --> passesCuts = " << passesCuts
                 << std::endl;
     }
   } else if (cutIter->second->mode_ == DiscriminantCutEntry::kVariableCut) {
     double cutVariable = (*cutIter->second->cutVariable_)(*tau);
     double xMin, xMax, dummy;
     cutIter->second->cutFunction_->GetPoint(0, xMin, dummy);
     cutIter->second->cutFunction_->GetPoint(cutIter->second->cutFunction_->GetN() - 1, xMax, dummy);
     const double epsilon = 1.e-3;
     if (cutVariable < (xMin + epsilon))
       cutVariable = xMin + epsilon;
     else if (cutVariable > (xMax - epsilon))
       cutVariable = xMax - epsilon;
     double cutValue = cutIter->second->cutFunction_->Eval(cutVariable);
     passesCuts = (disc_result > cutValue);
     if (verbosity_) {
       std::cout << "cutValue (@" << cutVariable << ") = " << cutValue << " --> passesCuts = " << passesCuts
                 << std::endl;
     }
   } else
     assert(0);
 
   return passesCuts;
 }

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

static

Definition at line 275 of file RecoTauDiscriminantCutMultiplexer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, TauDiscriminationProducerBase< TauType, TauDiscriminator >::fillProducerDescriptions(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                    {
   // recoTauDiscriminantCutMultiplexer
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("toMultiplex", edm::InputTag("fixme"));
   desc.add<int>("verbosity", 0);
 
   {
     edm::ParameterSet pset_mapping;
     pset_mapping.addParameter<unsigned int>("category", 0);
     pset_mapping.addParameter<double>("cut", 0.);
     edm::ParameterSetDescription desc_mapping;
     desc_mapping.add<unsigned int>("category", 0);
     desc_mapping.addNode(edm::ParameterDescription<std::string>("cut", true) xor
                          edm::ParameterDescription<double>("cut", true));
     // it seems the parameter string "variable" exists only when "cut" is string
     // see hpsPFTauDiscriminationByVLooseIsolationMVArun2v1DBdR03oldDMwLT in RecoTauTag/Configuration/python/HPSPFTaus_cff.py
     desc_mapping.addOptional<std::string>("variable")->setComment("the parameter is required when \"cut\" is string");
     //  desc_mapping.add<double>("cut",0.);
     std::vector<edm::ParameterSet> vpsd_mapping;
     vpsd_mapping.push_back(pset_mapping);
     desc.addVPSet("mapping", desc_mapping, vpsd_mapping);
   }
 
   desc.add<edm::FileInPath>("inputFileName", edm::FileInPath("RecoTauTag/RecoTau/data/emptyMVAinputFile"));
   desc.add<bool>("loadMVAfromDB", true);
   fillProducerDescriptions(desc);  // inherited from the base
   desc.add<std::string>("mvaOutput_normalization", "");
   desc.add<edm::InputTag>("key", edm::InputTag("fixme"));
   descriptions.add("recoTauDiscriminantCutMultiplexerDefault", desc);
 }