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<>
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 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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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 55 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 58 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 59 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 60 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 69 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, TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >, PFTauDecayModeCutMultiplexer, reco::tau::PATTauDiscriminationByMVAIsolationRun2, reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2, PFRecoTauDiscriminationByIsolationMVA2, PFRecoTauDiscriminationAgainstElectron2, PFRecoTauDiscriminationAgainstElectronMVA6, PATTauDiscriminationAgainstElectronMVA6, and PFRecoTauDiscriminationByNProngs.

Definition at line 74 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 PATTauDiscriminationAgainstElectronMVA6.

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 80 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 115 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 106 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 102 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 113 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 107 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 110 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 104 of file TauDiscriminationProducerBase.h.

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