TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType > Class Template Reference

#include <TauDiscriminationProducerBase.h>

Inheritance diagram for TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >:

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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
virtual void	beginEvent (const edm::Event &, const edm::EventSetup &)
virtual TauDiscriminatorDataType	discriminate (const TauRef &tau) const =0
virtual void	endEvent (edm::Event &)
void	produce (edm::Event &, const edm::EventSetup &) override
	TauDiscriminationProducerBase ()
	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
	~TauDiscriminationProducerBase () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)
static std::string	getTauTypeString ()
	helper method to retrieve tau type name, e.g. to build correct cfi getter More...

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_

Detailed Description

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>
class TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >

Definition at line 54 of file TauDiscriminationProducerBase.h.

Member Typedef Documentation

TauCollection

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

Definition at line 57 of file TauDiscriminationProducerBase.h.

TauRef

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

Definition at line 58 of file TauDiscriminationProducerBase.h.

TauRefProd

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

Definition at line 59 of file TauDiscriminationProducerBase.h.

Constructor & Destructor Documentation

TauDiscriminationProducerBase() [1/2]

template<class TauType , class TauDiscriminator , class TauDiscriminatorDataType , class ConsumeType >

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

explicit

Definition at line 40 of file TauDiscriminationProducerBase.cc.

    : moduleLabel_(iConfig.getParameter<std::string>("@module_label")) {
  // tau collection to discriminate
  TauProducer_ = iConfig.getParameter<edm::InputTag>(getTauTypeString() + "Producer");
  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<ConsumeType>(label);
    prediscriminants_.push_back(thisDiscriminator);
  }
 
  prediscriminantFailValue_ = 0.;
 
  // register product
  produces<TauDiscriminator>();
}

TauDiscriminationProducerBase() [2/2]

template<class TauType , class TauDiscriminator , class TauDiscriminatorDataType , class ConsumeType >

TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::TauDiscriminationProducerBase

(

)

Definition at line 32 of file TauDiscriminationProducerBase.cc.

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

~TauDiscriminationProducerBase()

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

inlineoverride

Definition at line 68 of file TauDiscriminationProducerBase.h.

{}

Member Function Documentation

beginEvent()

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

inlinevirtual

Reimplemented in PFRecoTauDiscriminationByIsolationContainer, PFRecoTauDiscriminationByIsolation, TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >, TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >, PFTauDecayModeCutMultiplexer, reco::tau::PATTauDiscriminationByMVAIsolationRun2, reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2, PFRecoTauDiscriminationByIsolationMVA2, PFRecoTauDiscriminationAgainstElectron2, and PFRecoTauDiscriminationByNProngs.

Definition at line 73 of file TauDiscriminationProducerBase.h.

{}

discriminate()

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

pure virtual

Implemented in TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >, reco::tau::PATTauDiscriminationByMVAIsolationRun2, and TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >.

endEvent()

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

inlinevirtual

Definition at line 79 of file TauDiscriminationProducerBase.h.

{}

fillProducerDescriptions()

template<class TauType , class TauDiscriminator , class TauDiscriminatorDataType , class ConsumeType >

void TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::fillProducerDescriptions ( edm::ParameterSetDescription &  desc )

static

Definition at line 173 of file TauDiscriminationProducerBase.cc.

                                                               {
  // helper function, it fills the description of the Producers parameter
  desc.add<edm::InputTag>(getTauTypeString() + "Producer", edm::InputTag("fixme"));
  {
    edm::ParameterSetDescription pset_prediscriminants;
    pset_prediscriminants.add<std::string>("BooleanOperator", "AND");
    // optional producers // will it pass if I don't specify them?
 
    {
      edm::ParameterSetDescription producer_params;
      producer_params.add<double>("cut", 0.);
      producer_params.add<edm::InputTag>("Producer", edm::InputTag("fixme"));
 
      pset_prediscriminants.addOptional<edm::ParameterSetDescription>("leadTrack", producer_params);
      pset_prediscriminants.addOptional<edm::ParameterSetDescription>("decayMode", producer_params);
    }
 
    desc.add<edm::ParameterSetDescription>("Prediscriminants", pset_prediscriminants);
  }
}

Referenced by PFTauDecayModeCutMultiplexer::fillDescriptions(), TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >::fillDescriptions(), and reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::fillDescriptions().

getTauTypeString()

template<class TauType , class TauDiscriminator , class TauDiscriminatorDataType , class ConsumeType >

std::string TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::getTauTypeString ( )

static

helper method to retrieve tau type name, e.g. to build correct cfi getter

Definition at line 196 of file TauDiscriminationProducerBase.cc.

                                                                                                                  {
  if (std::is_same<TauType, reco::PFTau>::value)
    return "PFTau";
  if (std::is_same<TauType, pat::Tau>::value)
    return "PATTau";
  throw cms::Exception("TauDiscriminationProducerBase")
      << "Unsupported TauType used. You must use either PFTau or PATTau.";
}

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

produce()

template<class TauType , class TauDiscriminator , class TauDiscriminatorDataType , class ConsumeType >

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

override

Definition at line 88 of file TauDiscriminationProducerBase.cc.

                                                      {
  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
  std::unique_ptr<TauDiscriminator> output = helper<TauDiscriminator, TauCollection>::init_result_object(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;
      }
    }
 
    TauDiscriminatorDataType result = TauDiscriminatorDataType(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)[tauRef] = 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

andPrediscriminants_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

uint8_t TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::andPrediscriminants_

private

Definition at line 114 of file TauDiscriminationProducerBase.h.

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

moduleLabel_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

protected

Definition at line 105 of file TauDiscriminationProducerBase.h.

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

prediscriminantFailValue_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

double TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::prediscriminantFailValue_

protected

Definition at line 101 of file TauDiscriminationProducerBase.h.

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

prediscriminants_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

private

Definition at line 112 of file TauDiscriminationProducerBase.h.

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

Tau_token

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

protected

Definition at line 106 of file TauDiscriminationProducerBase.h.

Referenced by reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::beginEvent(), and TauDiscriminationProducerBase< TauType, TauDiscriminator >::TauDiscriminationProducerBase().

tauIndex_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

size_t TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::tauIndex_

protected

Definition at line 109 of file TauDiscriminationProducerBase.h.

TauProducer_

template<class TauType, class TauDiscriminator, class TauDiscriminatorDataType = double, class ConsumeType = TauDiscriminator>

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

protected

Definition at line 103 of file TauDiscriminationProducerBase.h.

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