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 &) override

	RecoTauDiscriminantCutMultiplexer (const edm::ParameterSet &pset)

	~RecoTauDiscriminantCutMultiplexer ()

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

virtual void	endEvent (edm::Event &evt)

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Private Attributes
DiscriminantCutMap	cuts_

std::vector< TFile * >	inputFilesToDelete_

edm::InputTag	key_

edm::EDGetTokenT < reco::PFTauDiscriminator >	key_token

edm::Handle < reco::PFTauDiscriminator >	keyHandle_

std::string	moduleLabel_

const TFormula *	mvaOutput_normalization_

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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)

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

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

edm::InputTag	TauProducer_

Detailed Description

Definition at line 29 of file RecoTauDiscriminantCutMultiplexer.cc.

Member Typedef Documentation

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

private

Definition at line 59 of file RecoTauDiscriminantCutMultiplexer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 94 of file RecoTauDiscriminantCutMultiplexer.cc.

References python.rootplot.argparse::category, GOODCOLL_filter_cfg::cut, cuts_, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), PFRecoTauDiscriminationAgainstMuonMVA_cfi::inputFileName, inputFilesToDelete_, key_, key_token, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kFixedCut, RecoTauDiscriminantCutMultiplexer::DiscriminantCutEntry::kVariableCut, mvaOutput_normalization_, AlCaHLTBitMon_QueryRunRegistry::string, toMultiplex_, toMultiplex_token, and verbosity_.

   : PFTauDiscriminationProducerBase(cfg),
     moduleLabel_(cfg.getParameter<std::string>("@module_label")),
     mvaOutput_normalization_(0)
 {
   toMultiplex_ = cfg.getParameter<edm::InputTag>("toMultiplex");
   toMultiplex_token = consumes<reco::PFTauDiscriminator>(toMultiplex_);
   key_ = cfg.getParameter<edm::InputTag>("key");
   key_token = consumes<reco::PFTauDiscriminator>(key_);
 
   if ( cfg.exists("mvaOutput_normalization" ) ) {
     edm::FileInPath inputFileName = cfg.getParameter<edm::FileInPath>("inputFileName"); 
     std::string mvaOutput_normalization_string = cfg.getParameter<std::string>("mvaOutput_normalization");
     mvaOutput_normalization_ = loadObjectFromFile<TFormula>(inputFileName, mvaOutput_normalization_string, inputFilesToDelete_);
   }
 
   // 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");
     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") ) {
       std::string cut_string = mappingEntry->getParameter<std::string>("cut");
       edm::FileInPath inputFileName = cfg.getParameter<edm::FileInPath>("inputFileName");      
       cut->cutFunction_ = loadObjectFromFile<TGraph>(inputFileName, cut_string, inputFilesToDelete_);
       std::string cutVariable_string = mappingEntry->getParameter<std::string>("variable");
       cut->cutVariable_ = new StringObjectFunction<reco::PFTau>(cutVariable_string.data());
       cut->mode_ = DiscriminantCutEntry::kVariableCut;
     } else {
       throw cms::Exception("RecoTauDiscriminantCutMultiplexer") 
         << " Undefined Configuration Parameter 'cut' !!\n";
     }
     cuts_[category] = cut;
   }
 
   verbosity_ = ( cfg.exists("verbosity") ) ?
     cfg.getParameter<int>("verbosity") : 0;
 }

RecoTauDiscriminantCutMultiplexer::~RecoTauDiscriminantCutMultiplexer ( )

Definition at line 138 of file RecoTauDiscriminantCutMultiplexer.cc.

References cuts_, and inputFilesToDelete_.

 {
   for ( std::map<int, DiscriminantCutEntry*>::iterator it = cuts_.begin();
     it != cuts_.end(); ++it ) {
     delete it->second;
   }
   // CV: all entries in inputFilesToDelete list actually refer to the same file
   //    --> delete the first entry only
   if ( inputFilesToDelete_.size() >= 1 ) {
     delete inputFilesToDelete_.front();
   }
 }

Member Function Documentation

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 151 of file RecoTauDiscriminantCutMultiplexer.cc.

References edm::Event::getByToken(), key_token, keyHandle_, toMultiplex_token, and toMultiplexHandle_.

 {
   evt.getByToken(toMultiplex_token, toMultiplexHandle_);
   evt.getByToken(key_token, keyHandle_);
 }

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

override

Definition at line 158 of file RecoTauDiscriminantCutMultiplexer.cc.

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

 {
   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;
 }