PFRecoTauDiscriminationAgainstMuonMVA Class Reference

Inheritance diagram for PFRecoTauDiscriminationAgainstMuonMVA:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &)
double	discriminate (const PFTauRef &)
void	endEvent (edm::Event &)
	PFRecoTauDiscriminationAgainstMuonMVA (const edm::ParameterSet &cfg)
	~PFRecoTauDiscriminationAgainstMuonMVA ()
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 ()
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 Attributes
std::auto_ptr< PFTauDiscriminator >	category_output_
double	dRmuonMatch_
edm::FileInPath	inputFileName_
std::vector< TFile * >	inputFilesToDelete_
std::string	moduleLabel_
edm::Handle< reco::MuonCollection >	muons_
edm::EDGetTokenT < reco::MuonCollection >	Muons_token
float *	mvaInput_
double	mvaMin_
std::string	mvaName_
const GBRForest *	mvaReader_
bool	returnMVA_
edm::InputTag	srcMuons_
size_t	tauIndex_
edm::Handle< TauCollection >	taus_
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

MVA based discriminator against muon -> tau fakes

Author

Christian Veelken, LLR

Definition at line 56 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationAgainstMuonMVA::PFRecoTauDiscriminationAgainstMuonMVA ( const edm::ParameterSet &  cfg )

inlineexplicit

Definition at line 59 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

    : PFTauDiscriminationProducerBase(cfg),
      moduleLabel_(cfg.getParameter<std::string>("@module_label")),
      mvaReader_(0),
      mvaInput_(0)
  {
    inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
    mvaName_ = cfg.getParameter<std::string>("mvaName");
    mvaReader_ = loadMVAfromFile(inputFileName_, mvaName_, inputFilesToDelete_);
    returnMVA_ = cfg.getParameter<bool>("returnMVA");
    mvaMin_ = cfg.getParameter<double>("mvaMin");
    mvaInput_ = new float[11];
  
    srcMuons_ = cfg.getParameter<edm::InputTag>("srcMuons");
    Muons_token=consumes<reco::MuonCollection>(srcMuons_);
    dRmuonMatch_ = cfg.getParameter<double>("dRmuonMatch");

    verbosity_ = ( cfg.exists("verbosity") ) ?
      cfg.getParameter<int>("verbosity") : 0;

    produces<PFTauDiscriminator>("category");
  }

PFRecoTauDiscriminationAgainstMuonMVA::~PFRecoTauDiscriminationAgainstMuonMVA ( )

inline

Definition at line 88 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

  {
    delete mvaReader_;
    delete[] mvaInput_;
    for ( std::vector<TFile*>::iterator it = inputFilesToDelete_.begin();
      it != inputFilesToDelete_.end(); ++it ) {
      delete (*it);
    }
  }

Member Function Documentation

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 123 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

References edm::Event::getByToken().

{
  evt.getByToken(Muons_token, muons_);

  evt.getByToken(Tau_token, taus_);
  category_output_.reset(new PFTauDiscriminator(TauRefProd(taus_)));
  tauIndex_ = 0;
}

double PFRecoTauDiscriminationAgainstMuonMVA::discriminate

(

const PFTauRef &

tau

)

Definition at line 154 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

References Abs(), python.rootplot.argparse::category, reco::deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::isNull(), Max(), moduleLabel_(), metsig::muon, reco::Muon::NoArbitration, and patZpeak::numMuons.

{
  if ( verbosity_ ) {
    edm::LogPrint("PFTauAgainstMuonMVA") << "<PFRecoTauDiscriminationAgainstMuonMVA::discriminate>:" ;
    edm::LogPrint("PFTauAgainstMuonMVA") << " moduleLabel = " << moduleLabel_ ;
    edm::LogPrint("PFTauAgainstMuonMVA") << " mvaMin = " << mvaMin_ ;
  }
  
  // CV: define dummy category index in order to use RecoTauDiscriminantCutMultiplexer module to appy WP cuts
  double category = 0.; 
  category_output_->setValue(tauIndex_, category);
  ++tauIndex_;

  // CV: computation of anti-muon MVA value requires presence of leading charged hadron
  if ( tau->leadPFChargedHadrCand().isNull() ) return 0.;

  mvaInput_[0]  = TMath::Abs(tau->eta());
  double tauCaloEnECAL = 0.;
  double tauCaloEnHCAL = 0.;
  const std::vector<reco::PFCandidatePtr>& tauSignalPFCands = tau->signalPFCands();
  for ( std::vector<reco::PFCandidatePtr>::const_iterator tauSignalPFCand = tauSignalPFCands.begin();
    tauSignalPFCand != tauSignalPFCands.end(); ++tauSignalPFCand ) {
    tauCaloEnECAL += (*tauSignalPFCand)->ecalEnergy();
    tauCaloEnHCAL += (*tauSignalPFCand)->hcalEnergy();
  }
  mvaInput_[1]  = TMath::Sqrt(TMath::Max(0., tauCaloEnECAL));
  mvaInput_[2]  = TMath::Sqrt(TMath::Max(0., tauCaloEnHCAL));
  mvaInput_[3]  = tau->leadPFChargedHadrCand()->pt()/TMath::Max(1.,Double_t(tau->pt()));
  mvaInput_[4]  = TMath::Sqrt(TMath::Max(0., tau->leadPFChargedHadrCand()->ecalEnergy()));
  mvaInput_[5]  = TMath::Sqrt(TMath::Max(0., tau->leadPFChargedHadrCand()->hcalEnergy()));
  int numMatches = 0;
  std::vector<int> numHitsDT(4);
  std::vector<int> numHitsCSC(4);
  std::vector<int> numHitsRPC(4);
  for ( int iStation = 0; iStation < 4; ++iStation ) {
    numHitsDT[iStation]  = 0;
    numHitsCSC[iStation] = 0;
    numHitsRPC[iStation] = 0;
  }
  if ( tau->leadPFChargedHadrCand().isNonnull() ) {
    reco::MuonRef muonRef = tau->leadPFChargedHadrCand()->muonRef();      
    if ( muonRef.isNonnull() ) {
      numMatches = muonRef->numberOfMatches(reco::Muon::NoArbitration);
      countHits(*muonRef, numHitsDT, numHitsCSC, numHitsRPC);
    }
  }
  size_t numMuons = muons_->size();
  for ( size_t idxMuon = 0; idxMuon < numMuons; ++idxMuon ) {
    reco::MuonRef muon(muons_, idxMuon);
    if ( tau->leadPFChargedHadrCand().isNonnull() && tau->leadPFChargedHadrCand()->muonRef().isNonnull() && muon == tau->leadPFChargedHadrCand()->muonRef() ) { 
      continue;
    }
    double dR = deltaR(muon->p4(), tau->p4());
    if ( dR < dRmuonMatch_ ) {
      numMatches += muon->numberOfMatches(reco::Muon::NoArbitration);
      countHits(*muon, numHitsDT, numHitsCSC, numHitsRPC);
    }
  }
  mvaInput_[6]  = numMatches;
  mvaInput_[7]  = numHitsDT[0] + numHitsCSC[0] + numHitsRPC[0];
  mvaInput_[8]  = numHitsDT[1] + numHitsCSC[1] + numHitsRPC[1];
  mvaInput_[9]  = numHitsDT[2] + numHitsCSC[2] + numHitsRPC[2];
  mvaInput_[10] = numHitsDT[3] + numHitsCSC[3] + numHitsRPC[3];

  double mvaValue = mvaReader_->GetClassifier(mvaInput_);
  if ( verbosity_ ) {
    edm::LogPrint("PFTauAgainstMuonMVA") << "mvaValue = " << mvaValue ;
  }

  double retVal = -1.;
  if ( returnMVA_ ) {
    retVal = mvaValue;
    if ( verbosity_ ) {
      edm::LogPrint("PFTauAgainstMuonMVA") << "--> retVal = " << retVal ;
    }
  } else {
    retVal = ( mvaValue > mvaMin_ ) ? 1. : 0.;
    if ( verbosity_ ) {
      edm::LogPrint("PFTauAgainstMuonMVA") << "--> retVal = " << retVal << ": discriminator = ";
      if ( retVal > 0.5 ) edm::LogPrint("PFTauAgainstMuonMVA") << "PASSED." ;
      else edm::LogPrint("PFTauAgainstMuonMVA") << "FAILED." ;
    }
  }
  return retVal;
}

void PFRecoTauDiscriminationAgainstMuonMVA::endEvent ( edm::Event &  evt )

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 240 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

References edm::Event::put().

{
  // add all category indices to event
  evt.put(category_output_, "category");
}

Member Data Documentation

std::auto_ptr<PFTauDiscriminator> PFRecoTauDiscriminationAgainstMuonMVA::category_output_

private

Definition at line 115 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

double PFRecoTauDiscriminationAgainstMuonMVA::dRmuonMatch_

private

Definition at line 112 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

edm::FileInPath PFRecoTauDiscriminationAgainstMuonMVA::inputFileName_

private

Definition at line 102 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

std::vector<TFile*> PFRecoTauDiscriminationAgainstMuonMVA::inputFilesToDelete_

private

Definition at line 118 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

std::string PFRecoTauDiscriminationAgainstMuonMVA::moduleLabel_

private

Definition at line 100 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

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

edm::Handle<reco::MuonCollection> PFRecoTauDiscriminationAgainstMuonMVA::muons_

private

Definition at line 110 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

edm::EDGetTokenT<reco::MuonCollection> PFRecoTauDiscriminationAgainstMuonMVA::Muons_token

private

Definition at line 111 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

float* PFRecoTauDiscriminationAgainstMuonMVA::mvaInput_

private

Definition at line 107 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

double PFRecoTauDiscriminationAgainstMuonMVA::mvaMin_

private

Definition at line 106 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

std::string PFRecoTauDiscriminationAgainstMuonMVA::mvaName_

private

Definition at line 103 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

const GBRForest* PFRecoTauDiscriminationAgainstMuonMVA::mvaReader_

private

Definition at line 104 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

bool PFRecoTauDiscriminationAgainstMuonMVA::returnMVA_

private

Definition at line 105 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

edm::InputTag PFRecoTauDiscriminationAgainstMuonMVA::srcMuons_

private

Definition at line 109 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

size_t PFRecoTauDiscriminationAgainstMuonMVA::tauIndex_

private

Definition at line 116 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

edm::Handle<TauCollection> PFRecoTauDiscriminationAgainstMuonMVA::taus_

private

Definition at line 114 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.

int PFRecoTauDiscriminationAgainstMuonMVA::verbosity_

private

Definition at line 120 of file PFRecoTauDiscriminationAgainstMuonMVA.cc.