Inheritance diagram for TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >:

Classes
struct	DiscriminantCutEntry

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

reco::SingleTauDiscriminatorContainer	discriminate (const TauTypeRef &) const override

	TauDiscriminantCutMultiplexerT (const edm::ParameterSet &pset)

	~TauDiscriminantCutMultiplexerT () override

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

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

Private Attributes
DiscriminantCutMap	cuts_

edm::ESGetToken< PhysicsTFormulaPayload, PhysicsTFormulaPayloadRcd >	formulaToken_

edm::FileInPath	inputFileName_

bool	isInitialized_

bool	loadMVAfromDB_

std::string	moduleLabel_

std::unique_ptr< const TFormula >	mvaOutput_normalization_

std::string	mvaOutputNormalizationName_

uint	n_raws_

int	raw_category_idx_ = -1

int	raw_discriminator_idx_ = -1

edm::InputTag	toMultiplex_

edm::EDGetTokenT< reco::TauDiscriminatorContainer >	toMultiplex_token

edm::Handle< reco::TauDiscriminatorContainer >	toMultiplexHandle_

int	verbosity_

Detailed Description

template<class TauType, class TauTypeRef, class ParentClass>
class TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >

Definition at line 38 of file TauDiscriminantCutMultiplexer.cc.

Member Typedef Documentation

◆ DiscriminantCutMap

template<class TauType , class TauTypeRef , class ParentClass >

typedef std::map<int, std::vector<std::unique_ptr<DiscriminantCutEntry> > > TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::DiscriminantCutMap

private

Definition at line 65 of file TauDiscriminantCutMultiplexer.cc.

Constructor & Destructor Documentation

◆ TauDiscriminantCutMultiplexerT()

template<class TauType , class TauTypeRef , class ParentClass >

TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::TauDiscriminantCutMultiplexerT ( const edm::ParameterSet & pset )

explicit

Definition at line 138 of file TauDiscriminantCutMultiplexer.cc.

     : ParentClass(cfg),
       moduleLabel_(cfg.getParameter<std::string>("@module_label")),
       mvaOutput_normalization_(),
       isInitialized_(false) {
   toMultiplex_ = cfg.getParameter<edm::InputTag>("toMultiplex");
   toMultiplex_token = this->template consumes<reco::TauDiscriminatorContainer>(toMultiplex_);
 
   verbosity_ = cfg.getParameter<int>("verbosity");
 
   mvaOutputNormalizationName_ = cfg.getParameter<std::string>("mvaOutput_normalization");
 
   loadMVAfromDB_ = cfg.getParameter<bool>("loadMVAfromDB");
   if (!loadMVAfromDB_) {
     inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
   } else if (not mvaOutputNormalizationName_.empty()) {
     formulaToken_ = this->esConsumes(edm::ESInputTag{"", mvaOutputNormalizationName_});
   }
   if (verbosity_)
     std::cout << moduleLabel_ << " loadMVA = " << loadMVAfromDB_ << std::endl;
 
   // Setup our cut map, first raw values then working points
   typedef std::vector<edm::ParameterSet> VPSet;
   typedef std::vector<std::string> VString;
   typedef std::vector<double> VDouble;
   VString rawValueConfig = cfg.getParameter<VString>("rawValues");
   for (uint i = 0; i < rawValueConfig.size(); i++) {
     if (rawValueConfig[i] == "discriminator")
       raw_discriminator_idx_ = i;
     else if (rawValueConfig[i] == "category")
       raw_category_idx_ = i;
     else
       throw cms::Exception("TauDiscriminantCutMultiplexerT")
           << " Configuration Parameter 'rawValues' containes unknown values. Must be 'discriminator' or 'category'!!\n";
   }
   n_raws_ = rawValueConfig.size();
   VPSet mapping = cfg.getParameter<VPSet>("mapping");
   for (auto const& mappingEntry : mapping) {
     unsigned category = mappingEntry.getParameter<uint32_t>("category");
     std::vector<std::unique_ptr<DiscriminantCutEntry>> cutWPs;
     std::string categoryname = mappingEntry.getParameter<std::string>("cut");
     bool localWPs = false;
     bool wpsAsDouble = false;
     if (mappingEntry.exists("workingPoints")) {
       localWPs = true;
       if (mappingEntry.existsAs<VDouble>("workingPoints")) {
         wpsAsDouble = true;
       } else if (mappingEntry.existsAs<VString>("workingPoints")) {
         wpsAsDouble = false;
       } else {
         throw cms::Exception("TauDiscriminantCutMultiplexerT")
             << " Configuration Parameter 'workingPoints' must be filled with cms.string or cms.double!!\n";
       }
     } else if (cfg.exists("workingPoints")) {
       localWPs = false;
       if (cfg.existsAs<VDouble>("workingPoints")) {
         wpsAsDouble = true;
       } else if (cfg.existsAs<VString>("workingPoints")) {
         wpsAsDouble = false;
       } else {
         throw cms::Exception("TauDiscriminantCutMultiplexerT")
             << " Configuration Parameter 'workingPoints' must be filled with cms.string or cms.double!!\n";
       }
     } else {
       throw cms::Exception("TauDiscriminantCutMultiplexerT")
           << " Undefined Configuration Parameter 'workingPoints' !!\n";
     }
     if (wpsAsDouble) {
       VDouble workingPoints;
       if (localWPs)
         workingPoints = mappingEntry.getParameter<VDouble>("workingPoints");
       else
         workingPoints = cfg.getParameter<VDouble>("workingPoints");
       for (auto const& wp : workingPoints) {
         std::unique_ptr<DiscriminantCutEntry> cut{new DiscriminantCutEntry()};
         cut->cutValue_ = wp;
         cut->mode_ = DiscriminantCutEntry::kFixedCut;
         cutWPs.push_back(std::move(cut));
       }
     } else {
       VString workingPoints;
       if (localWPs)
         workingPoints = mappingEntry.getParameter<VString>("workingPoints");
       else
         workingPoints = cfg.getParameter<VString>("workingPoints");
       for (auto const& wp : workingPoints) {
         std::unique_ptr<DiscriminantCutEntry> cut{new DiscriminantCutEntry()};
         cut->cutName_ = categoryname + wp;
         if (loadMVAfromDB_) {
           cut->cutToken_ = this->esConsumes(edm::ESInputTag{"", cut->cutName_});
         }
         std::string cutVariable_string = mappingEntry.getParameter<std::string>("variable");
         cut->cutVariable_.reset(new StringObjectFunction<TauType>(cutVariable_string));
         cut->mode_ = DiscriminantCutEntry::kVariableCut;
         cutWPs.push_back(std::move(cut));
       }
     }
     cuts_[category] = std::move(cutWPs);
   }
 
   verbosity_ = cfg.getParameter<int>("verbosity");
   if (verbosity_)
     std::cout << "constructed " << moduleLabel_ << std::endl;
 }

◆ ~TauDiscriminantCutMultiplexerT()

template<class TauType , class TauTypeRef , class ParentClass >

TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::~TauDiscriminantCutMultiplexerT ( )

override

Definition at line 245 of file TauDiscriminantCutMultiplexer.cc.

245 {}

Member Function Documentation

◆ beginEvent()

template<class TauType , class TauTypeRef , class ParentClass >

void TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::beginEvent	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 248 of file TauDiscriminantCutMultiplexer.cc.

References gather_cfg::cout, DMR_cfg::cut, edm::Event::getByToken(), makeListRunsInFiles::inputFile, eostools::move(), and groupFilesInBlocks::temp.

                                                                                                            {
   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_,
                                        formulaToken_,
                                        Form("%s_mvaOutput_normalization", moduleLabel_.data()),
                                        verbosity_);
         mvaOutput_normalization_ = std::move(temp);
       }
     }
     for (auto const& cutWPs : cuts_) {
       for (auto const& cut : cutWPs.second) {
         if (cut->mode_ == DiscriminantCutEntry::kVariableCut) {
           if (!loadMVAfromDB_) {
             if (not inputFile) {
               inputFile = openInputFile(inputFileName_);
             }
             if (verbosity_)
               std::cout << "Loading from file" << inputFileName_ << std::endl;
             cut->cutFunction_ = loadObjectFromFile<TGraph>(*inputFile, cut->cutName_);
           } else {
             if (verbosity_)
               std::cout << "Loading from DB" << std::endl;
             cut->cutFunction_ = loadTGraphFromDB(es, cut->cutName_, cut->cutToken_, verbosity_);
           }
         }
       }
     }
     isInitialized_ = true;
   }
 
   evt.getByToken(toMultiplex_token, toMultiplexHandle_);
 }

◆ discriminate()

template<class TauType , class TauTypeRef , class ParentClass >

reco::SingleTauDiscriminatorContainer TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::discriminate ( const TauTypeRef & tau ) const

override

Definition at line 294 of file TauDiscriminantCutMultiplexer.cc.

References gather_cfg::cout, geometryDiff::epsilon, PDWG_TauSkim_cff::rawValues, mps_fire::result, metsig::tau, multiplicitycorr_cfi::xMax, and photonAnalyzer_cfi::xMin.

                                  {
   if (verbosity_) {
     std::cout << "<TauDiscriminantCutMultiplexerT::discriminate>:" << std::endl;
     std::cout << " moduleLabel = " << moduleLabel_ << std::endl;
   }
 
   reco::SingleTauDiscriminatorContainer result;
   result.rawValues.resize(n_raws_);
   double disc_result = (*toMultiplexHandle_)[tau].rawValues.at(0);
   if (verbosity_) {
     std::cout << "disc_result = " << disc_result << std::endl;
   }
   if (raw_discriminator_idx_ >= 0)
     result.rawValues[raw_discriminator_idx_] = disc_result;
   if (mvaOutput_normalization_) {
     disc_result = mvaOutput_normalization_->Eval(disc_result);
     if (verbosity_) {
       std::cout << "disc_result (normalized) = " << disc_result << std::endl;
     }
   }
   double key_result = 0.0;
   if ((*toMultiplexHandle_)[tau].rawValues.size() == 2) {
     key_result = (*toMultiplexHandle_)[tau].rawValues.at(1);
     if (raw_category_idx_ >= 0)
       result.rawValues[raw_category_idx_] = key_result;
   }
   typename DiscriminantCutMap::const_iterator cutWPsIter = cuts_.find(std::round(key_result));
 
   // Return null if it doesn't exist
   if (cutWPsIter == cuts_.end()) {
     return result;
   }
   // See if the discriminator passes our cuts
   for (auto const& cutIter : cutWPsIter->second) {
     bool passesCuts = false;
     if (cutIter->mode_ == DiscriminantCutEntry::kFixedCut) {
       passesCuts = (disc_result > cutIter->cutValue_);
       if (verbosity_) {
         std::cout << "cutValue (fixed) = " << cutIter->cutValue_ << " --> passesCuts = " << passesCuts << std::endl;
       }
     } else if (cutIter->mode_ == DiscriminantCutEntry::kVariableCut) {
       double cutVariable = (*cutIter->cutVariable_)(*tau);
       double xMin, xMax, dummy;
       cutIter->cutFunction_->GetPoint(0, xMin, dummy);
       cutIter->cutFunction_->GetPoint(cutIter->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->cutFunction_->Eval(cutVariable);
       passesCuts = (disc_result > cutValue);
       if (verbosity_) {
         std::cout << "cutValue (@" << cutVariable << ") = " << cutValue << " --> passesCuts = " << passesCuts
                   << std::endl;
       }
     }
     result.workingPoints.push_back(passesCuts);
   }
   return result;
 }

◆ fillDescriptions()

template<class TauType , class TauTypeRef , class ParentClass >

void TauDiscriminantCutMultiplexerT< TauType, TauTypeRef, ParentClass >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 376 of file TauDiscriminantCutMultiplexer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), submitPVResolutionJobs::desc, ProducerED_cfi::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<std::string>("cut", "fixme");
     edm::ParameterSetDescription desc_mapping;
     desc_mapping.add<unsigned int>("category", 0);
     desc_mapping.add<std::string>("cut");
     // it seems the parameter string "variable" exists only when workingPoints are string
     // see hpsPFTauDiscriminationByVLooseIsolationMVArun2v1DBdR03oldDMwLT in RecoTauTag/Configuration/python/HPSPFTaus_cff.py
     desc_mapping.addOptional<std::string>("variable")
         ->setComment("the parameter is required when \"workingPoints\" are string");
     std::vector<edm::ParameterSet> vpsd_mapping;
     vpsd_mapping.push_back(pset_mapping);
     desc.addVPSet("mapping", desc_mapping, vpsd_mapping);
   }
 
   std::vector<std::string> defaultRaws{"discriminator"};
   desc.add<std::vector<std::string>>("rawValues", defaultRaws);
   std::vector<double> defaultWP{0.0};
   desc.addNode(edm::ParameterDescription<std::vector<double>>("workingPoints", defaultWP, true) xor
                edm::ParameterDescription<std::vector<std::string>>("workingPoints", true));
   desc.add<edm::FileInPath>("inputFileName", edm::FileInPath("RecoTauTag/RecoTau/data/emptyMVAinputFile"));
   desc.add<bool>("loadMVAfromDB", true);
   ParentClass::fillProducerDescriptions(desc);  // inherited from the base
   desc.add<std::string>("mvaOutput_normalization", "");
   descriptions.add(getDefaultConfigString<TauType>(), desc);
 }