#include <TauDiscriminationProducerBase.h>

Inheritance diagram for TauDiscriminationProducerBase< TauType, TauDiscriminator >:

Classes
struct	TauDiscInfo

Public Types
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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Protected Attributes
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Private Attributes
uint8_t	andPrediscriminants_

std::vector< TauDiscInfo >	prediscriminants_

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Detailed Description

template<class TauType, class TauDiscriminator>
class TauDiscriminationProducerBase< TauType, TauDiscriminator >

Definition at line 51 of file TauDiscriminationProducerBase.h.

Member Typedef Documentation

template<class TauType , class TauDiscriminator >

typedef std::vector<TauType> TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauCollection

Definition at line 54 of file TauDiscriminationProducerBase.h.

template<class TauType , class TauDiscriminator >

typedef edm::Ref<TauCollection> TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauRef

Definition at line 55 of file TauDiscriminationProducerBase.h.

template<class TauType , class TauDiscriminator >

typedef edm::RefProd<TauCollection> TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauRefProd

Definition at line 56 of file TauDiscriminationProducerBase.h.

Constructor & Destructor Documentation

template<class TauType , class TauDiscriminator >

TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase ( const edm::ParameterSet & iConfig )

explicit

Definition at line 17 of file TauDiscriminationProducerBase.cc.

References TauDiscriminationProducerBase< TauType, TauDiscriminator >::andPrediscriminants_, TkAlMuonSelectors_cfi::cut, Exception, edm::ParameterSet::getParameter(), diffTwoXMLs::label, TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscInfo::label, TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_, TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminants_, AlCaHLTBitMon_QueryRunRegistry::string, TauDiscriminationProducerBase< TauType, TauDiscriminator >::Tau_token, TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauProducer_, and create_public_lumi_plots::transform.

   : moduleLabel_(iConfig.getParameter<std::string>("@module_label"))
 {
    // tau collection to discriminate
    TauProducer_        = iConfig.getParameter<edm::InputTag>(getProducerString<TauType>());
    Tau_token= consumes<TauCollection>(TauProducer_);
 
    // prediscriminant operator
    // require the tau to pass the following prediscriminants
    const edm::ParameterSet& prediscriminantConfig = iConfig.getParameter<edm::ParameterSet>("Prediscriminants");
 
    // determine boolean operator used on the prediscriminants
    std::string pdBoolOperator = prediscriminantConfig.getParameter<std::string>("BooleanOperator");
    // convert string to lowercase
    transform(pdBoolOperator.begin(), pdBoolOperator.end(), pdBoolOperator.begin(), ::tolower);
 
    if( pdBoolOperator == "and" )
    {
       andPrediscriminants_ = 0x1; //use chars instead of bools so we can do a bitwise trick later
    }
    else if ( pdBoolOperator == "or" )
    {
       andPrediscriminants_ = 0x0;
    }
    else
    {
       throw cms::Exception("TauDiscriminationProducerBase") << "PrediscriminantBooleanOperator defined incorrectly, options are: AND,OR";
    }
 
    // get the list of prediscriminants
    std::vector<std::string> prediscriminantsNames = prediscriminantConfig.getParameterNamesForType<edm::ParameterSet>();
 
    for( std::vector<std::string>::const_iterator iDisc  = prediscriminantsNames.begin();
                                        iDisc != prediscriminantsNames.end(); ++iDisc )
    {
       const edm::ParameterSet& iPredisc = prediscriminantConfig.getParameter<edm::ParameterSet>(*iDisc);
       const edm::InputTag& label        = iPredisc.getParameter<edm::InputTag>("Producer");
       double cut                        = iPredisc.getParameter<double>("cut");
 
       TauDiscInfo thisDiscriminator;
       thisDiscriminator.label = label;
       thisDiscriminator.cut   = cut;
       thisDiscriminator.disc_token = consumes<TauDiscriminator>(label);
       prediscriminants_.push_back(thisDiscriminator);
    }
 
    prediscriminantFailValue_ = 0.;
 
    // register product
    produces<TauDiscriminator>();
 }

template<class TauType , class TauDiscriminator >

TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase ( )

Definition at line 9 of file TauDiscriminationProducerBase.cc.

References Exception.

 {
    throw cms::Exception("TauDiscriminationProducerBase") << " -- default ctor called; derived classes must call " <<
       "TauDiscriminationProducerBase(const ParameterSet&)";
 }

template<class TauType , class TauDiscriminator >

TauDiscriminationProducerBase< TauType, TauDiscriminator >::~TauDiscriminationProducerBase ( )

inlineoverride

Definition at line 65 of file TauDiscriminationProducerBase.h.

References TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce().

65 {}

Member Function Documentation

template<class TauType , class TauDiscriminator >

virtual void TauDiscriminationProducerBase< TauType, TauDiscriminator >::beginEvent	(	const edm::Event &	,
		const edm::EventSetup &
	)

inlinevirtual

Definition at line 70 of file TauDiscriminationProducerBase.h.

References TauDiscriminationProducerBase< TauType, TauDiscriminator >::discriminate(), and metsig::tau.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce().

70 {}

template<class TauType , class TauDiscriminator >

virtual double TauDiscriminationProducerBase< TauType, TauDiscriminator >::discriminate ( const TauRef & tau ) const

pure virtual

Implemented in PATTauDiscriminationByMVAIsolationRun2, PATTauDiscriminationAgainstElectronMVA6, and PATTauDiscriminantCutMultiplexer.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::beginEvent(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce().

template<class TauType , class TauDiscriminator >

virtual void TauDiscriminationProducerBase< TauType, TauDiscriminator >::endEvent ( edm::Event & )

inlinevirtual

Reimplemented in PATTauDiscriminationByMVAIsolationRun2, PFRecoTauDiscriminationByMVAIsolationRun2, PFRecoTauDiscriminationByIsolationMVA2, PFRecoTauDiscriminationAgainstElectronMVA5, PFRecoTauDiscriminationAgainstElectronMVA6, and PATTauDiscriminationAgainstElectronMVA6.

Definition at line 76 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce().

76 {}

template<class TauType , class TauDiscriminator >

void TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 70 of file TauDiscriminationProducerBase.cc.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::~TauDiscriminationProducerBase().

 {
    tauIndex_=0;
    // setup function - does nothing in base, but can be overridden to retrieve PV or other stuff
    beginEvent(event, eventSetup);
 
    // retrieve the tau collection to discriminate
    edm::Handle<TauCollection> taus;
    event.getByToken(Tau_token, taus);
 
    edm::ProductID tauProductID = taus.id();
 
    // output product
    auto output = std::make_unique<TauDiscriminator>(TauRefProd(taus));
 
    size_t nTaus = taus->size();
 
    // load prediscriminators
    size_t nPrediscriminants = prediscriminants_.size();
    for( size_t iDisc = 0; iDisc < nPrediscriminants; ++iDisc )
    {
       prediscriminants_[iDisc].fill(event);
 
       // Check to make sure the product is correct for the discriminator.
       // If not, throw a more informative exception.
       edm::ProductID discKeyId =
         prediscriminants_[iDisc].handle->keyProduct().id();
       if (tauProductID != discKeyId) {
         throw cms::Exception("MisconfiguredPrediscriminant")
           << "The tau collection with input tag " << TauProducer_
           << " has product ID: " << tauProductID
           << " but the pre-discriminator with input tag "
           << prediscriminants_[iDisc].label
           << " is keyed with product ID: " << discKeyId << std::endl;
       }
    }
 
    // loop over taus
    for( size_t iTau = 0; iTau < nTaus; ++iTau )
    {
       // get reference to tau
       TauRef tauRef(taus, iTau);
 
       bool passesPrediscriminants = ( andPrediscriminants_ ? 1 : 0 );
       // check tau passes prediscriminants
       for( size_t iDisc = 0; iDisc < nPrediscriminants; ++iDisc )
       {
          // current discriminant result for this tau
          double discResult  = (*prediscriminants_[iDisc].handle)[tauRef];
          uint8_t thisPasses = ( discResult > prediscriminants_[iDisc].cut ) ? 1 : 0;
 
          // if we are using the AND option, as soon as one fails,
          // the result is FAIL and we can quit looping.
          // if we are using the OR option as soon as one passes,
          // the result is pass and we can quit looping
 
          // truth table
          //        |   result (thisPasses)
          //        |     F     |     T
          //-----------------------------------
          // AND(T) | res=fails |  continue
          //        |  break    |
          //-----------------------------------
          // OR (F) |  continue | res=passes
          //        |           |  break
 
          if( thisPasses ^ andPrediscriminants_ ) //XOR
          {
             passesPrediscriminants = ( andPrediscriminants_ ? 0 : 1 ); //NOR
             break;
          }
       }
 
       double result = prediscriminantFailValue_;
       if( passesPrediscriminants )
       {
          // this tau passes the prereqs, call our implemented discrimination function
          result = discriminate(tauRef); ++tauIndex_;
       }
 
       // store the result of this tau into our new discriminator
       output->setValue(iTau, result);
    }
    event.put(std::move(output));
 
    // function to put additional information into the event - does nothing in base, but can be overridden in derived classes
    endEvent(event);
 }

Member Data Documentation

template<class TauType , class TauDiscriminator >

uint8_t TauDiscriminationProducerBase< TauType, TauDiscriminator >::andPrediscriminants_

private

Definition at line 106 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

template<class TauType , class TauDiscriminator >

std::string TauDiscriminationProducerBase< TauType, TauDiscriminator >::moduleLabel_

protected

Definition at line 97 of file TauDiscriminationProducerBase.h.

Referenced by Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), and Modules.ESProducer::nameInProcessDesc_().

template<class TauType , class TauDiscriminator >

double TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminantFailValue_

protected

Definition at line 93 of file TauDiscriminationProducerBase.h.

Referenced by RecoTauDecayModeCutMultiplexer::discriminate(), PFRecoTauDiscriminationByFlight::discriminate(), RecoTauDiscriminantCutMultiplexer::discriminate(), PATTauDiscriminantCutMultiplexer::discriminate(), RecoTauMVATransform::discriminate(), PFTauDiscriminatorLogicalAndProducer::PFTauDiscriminatorLogicalAndProducer(), TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce(), RecoTauMVATransform::RecoTauMVATransform(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

template<class TauType , class TauDiscriminator >

std::vector<TauDiscInfo> TauDiscriminationProducerBase< TauType, TauDiscriminator >::prediscriminants_

private

Definition at line 104 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

template<class TauType , class TauDiscriminator >

edm::EDGetTokenT<TauCollection> TauDiscriminationProducerBase< TauType, TauDiscriminator >::Tau_token

protected

Definition at line 98 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

template<class TauType , class TauDiscriminator >

size_t TauDiscriminationProducerBase< TauType, TauDiscriminator >::tauIndex_

protected

Definition at line 101 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce().

template<class TauType , class TauDiscriminator >

edm::InputTag TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauProducer_

protected

Definition at line 95 of file TauDiscriminationProducerBase.h.

Referenced by TauDiscriminationProducerBase< TauType, TauDiscriminator >::produce(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

Classes

Public Types

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

template<class TauType, class TauDiscriminator> class TauDiscriminationProducerBase< TauType, TauDiscriminator >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class TauType, class TauDiscriminator>
class TauDiscriminationProducerBase< TauType, TauDiscriminator >