Inheritance diagram for RecoTauMVADiscriminator:

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

double	discriminate (const reco::PFTauRef &)

	RecoTauMVADiscriminator (const edm::ParameterSet &pset)

	~RecoTauMVADiscriminator ()

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

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

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

virtual	~EDProducer ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Private Types
typedef boost::ptr_map < reco::PFTau::hadronicDecayMode, reco::tau::RecoTauMVAHelper >	MVAMap

Private Attributes
std::string	dbLabel_

std::auto_ptr < reco::tau::RecoTauMVAHelper >	defaultMVA_

MVAMap	mvas_

bool	remapOutput_

double	unsupportedDMValue_

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

typedef WorkerT< EDProducer >	WorkerType

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)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
double	prediscriminantFailValue_

Detailed Description

Definition at line 37 of file RecoTauMVADiscriminator.cc.

Member Typedef Documentation

typedef boost::ptr_map<reco::PFTau::hadronicDecayMode, reco::tau::RecoTauMVAHelper> RecoTauMVADiscriminator::MVAMap

private

Definition at line 48 of file RecoTauMVADiscriminator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 58 of file RecoTauMVADiscriminator.cc.

References defaultMVA_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), mvas_, reco::tau::helpers::nCharged(), TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_, remapOutput_, reco::tau::translateDecayMode(), and unsupportedDMValue_.

   :PFTauDiscriminationProducerBase(pset) {
   std::string dbLabel;
   if (pset.exists("dbLabel"))
     dbLabel = pset.getParameter<std::string>("dbLabel");
 
   unsupportedDMValue_ = (pset.exists("unsupportedDecayModeValue")) ?
       pset.getParameter<double>("unsupportedDecayModeValue")
       : prediscriminantFailValue_;
 
   remapOutput_ = pset.getParameter<bool>("remapOutput");
 
   typedef std::vector<edm::ParameterSet> VPSet;
   const VPSet& mvas = pset.getParameter<VPSet>("mvas");
 
   for (VPSet::const_iterator mva = mvas.begin(); mva != mvas.end(); ++mva) {
     unsigned int nCharged = mva->getParameter<unsigned int>("nCharged");
     unsigned int nPiZeros = mva->getParameter<unsigned int>("nPiZeros");
     reco::PFTau::hadronicDecayMode decayMode = reco::tau::translateDecayMode(
         nCharged, nPiZeros);
     // Check to ensure this decay mode is not already added
     if (!mvas_.count(decayMode)) {
       std::string computerName = mva->getParameter<std::string>("mvaLabel");
       // Add it
       mvas_.insert(
           decayMode, new reco::tau::RecoTauMVAHelper(computerName, dbLabel));
     } else {
       edm::LogError("DecayModeNotUnique") << "The tau decay mode with "
         "nCharged/nPiZero = " << nCharged << "/" << nPiZeros << " dm: "
         << decayMode <<
         " is associated to multiple MVA implmentations, "
         "the second instantiation is being ignored!!!";
     }
   }
 
   // Check if we a catch-all MVA is desired.
   if (pset.exists("defaultMVA")) {
     defaultMVA_.reset(new reco::tau::RecoTauMVAHelper(
             pset.getParameter<std::string>("defaultMVA"),
             dbLabel));
   }
 
 }

RecoTauMVADiscriminator::~RecoTauMVADiscriminator ( )

inline

Definition at line 40 of file RecoTauMVADiscriminator.cc.

40 {}

Member Function Documentation

void RecoTauMVADiscriminator::beginEvent	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 102 of file RecoTauMVADiscriminator.cc.

References defaultMVA_, and mvas_.

                                                                   {
   // Pass the event setup so the MVAHelpers can get the MVAs from the DB
   BOOST_FOREACH(MVAMap::value_type mva, mvas_) {
       mva.second->setEvent(evt, es);
   }
   if (defaultMVA_.get())
     defaultMVA_->setEvent(evt, es);
 }

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

Definition at line 113 of file RecoTauMVADiscriminator.cc.

References defaultMVA_, mvas_, convertSQLitetoXML_cfg::output, remapOutput_, metsig::tau, and unsupportedDMValue_.

                                                                     {
   // Find the right MVA for this tau's decay mode
   MVAMap::iterator mva = mvas_.find(tau->decayMode());
   // If this DM has an associated decay mode, get and return the result.
   double output = unsupportedDMValue_;
   if (mva != mvas_.end() || defaultMVA_.get()) {
     if (mva != mvas_.end())
       output = mva->second->operator()(tau);
     else
       output = defaultMVA_->operator()(tau);
     // TMVA produces output from -1 to 1
     if (remapOutput_) {
       output += 1.;
       output /= 2.;
     }
   }
   return output;
 }