reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2 Class Reference

Inheritance diagram for reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &) override
reco::SingleTauDiscriminatorContainer	discriminate (const PFTauRef &) const override
	PFRecoTauDiscriminationByMVAIsolationRun2 (const edm::ParameterSet &cfg)
	~PFRecoTauDiscriminationByMVAIsolationRun2 () override
Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
virtual TauDiscriminatorDataType	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
	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	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
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...

Private Types
typedef edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > >	PFTauTIPAssociationByRef

Private Attributes
edm::Handle< reco::TauDiscriminatorContainer >	basicTauDiscriminators_
edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminators_token
int	chargedIsoPtSum_index_ = 0
int	footprintCorrection_index_ = 0
std::string	input_id_name_suffix_
edm::FileInPath	inputFileName_
std::vector< TFile * >	inputFilesToDelete_
bool	loadMVAfromDB_
std::string	moduleLabel_
float *	mvaInput_
std::string	mvaName_
int	mvaOpt_
const GBRForest *	mvaReader_
edm::ESGetToken< GBRForest, GBRWrapperRcd >	mvaToken_
int	neutralIsoPtSum_index_ = 0
edm::ProcessHistoryID	phID_
int	photonPtSumOutsideSignalCone_index_ = 0
int	pucorrPtSum_index_ = 0
edm::Handle< PFTauTIPAssociationByRef >	tauLifetimeInfos
edm::Handle< TauCollection >	taus_
edm::EDGetTokenT< PFTauTIPAssociationByRef >	TauTransverseImpactParameters_token
int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
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
Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
std::string	moduleLabel_
double	prediscriminantFailValue_
edm::EDGetTokenT< TauCollection >	Tau_token
size_t	tauIndex_
edm::InputTag	TauProducer_

Detailed Description

Definition at line 67 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Member Typedef Documentation

PFTauTIPAssociationByRef

typedef edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef> > reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::PFTauTIPAssociationByRef

private

Definition at line 153 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationByMVAIsolationRun2()

reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::PFRecoTauDiscriminationByMVAIsolationRun2 ( const edm::ParameterSet &  cfg )

inlineexplicit

Definition at line 69 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

References cms::cuda::assert(), basicTauDiscriminators_token, looper::cfg, deDxTools::esConsumes(), Exception, input_id_name_suffix_, inputFileName_, reco::tau::kDBnewDMwLT, reco::tau::kDBnewDMwLTwGJ, reco::tau::kDBoldDMwLT, reco::tau::kDBoldDMwLTwGJ, reco::tau::kNewDMwLT, reco::tau::kNewDMwoLT, reco::tau::kOldDMwLT, reco::tau::kOldDMwoLT, reco::tau::kPWnewDMwLT, reco::tau::kPWoldDMwLT, loadMVAfromDB_, mvaInput_, mvaName_, mvaOpt_, mvaToken_, AlCaHLTBitMon_QueryRunRegistry::string, TauTransverseImpactParameters_token, and verbosity_.

          : PFTauDiscriminationContainerProducerBase(cfg),
            moduleLabel_(cfg.getParameter<std::string>("@module_label")),
            mvaReader_(nullptr),
            mvaInput_(nullptr) {
        mvaName_ = cfg.getParameter<std::string>("mvaName");
        loadMVAfromDB_ = cfg.getParameter<bool>("loadMVAfromDB");
        if (!loadMVAfromDB_) {
          inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
        } else {
          mvaToken_ = esConsumes(edm::ESInputTag{"", mvaName_});
        }
        std::string mvaOpt_string = cfg.getParameter<std::string>("mvaOpt");
        if (mvaOpt_string == "oldDMwoLT")
          mvaOpt_ = kOldDMwoLT;
        else if (mvaOpt_string == "oldDMwLT")
          mvaOpt_ = kOldDMwLT;
        else if (mvaOpt_string == "newDMwoLT")
          mvaOpt_ = kNewDMwoLT;
        else if (mvaOpt_string == "newDMwLT")
          mvaOpt_ = kNewDMwLT;
        else if (mvaOpt_string == "DBoldDMwLT")
          mvaOpt_ = kDBoldDMwLT;
        else if (mvaOpt_string == "DBnewDMwLT")
          mvaOpt_ = kDBnewDMwLT;
        else if (mvaOpt_string == "PWoldDMwLT")
          mvaOpt_ = kPWoldDMwLT;
        else if (mvaOpt_string == "PWnewDMwLT")
          mvaOpt_ = kPWnewDMwLT;
        else if (mvaOpt_string == "DBoldDMwLTwGJ")
          mvaOpt_ = kDBoldDMwLTwGJ;
        else if (mvaOpt_string == "DBnewDMwLTwGJ")
          mvaOpt_ = kDBnewDMwLTwGJ;
        else
          throw cms::Exception("PFRecoTauDiscriminationByMVAIsolationRun2")
              << " Invalid Configuration Parameter 'mvaOpt' = " << mvaOpt_string << " !!\n";

        if (mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT)
          mvaInput_ = new float[6];
        else if (mvaOpt_ == kOldDMwLT || mvaOpt_ == kNewDMwLT)
          mvaInput_ = new float[12];
        else if (mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kDBnewDMwLT || mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kPWnewDMwLT ||
                 mvaOpt_ == kDBoldDMwLTwGJ || mvaOpt_ == kDBnewDMwLTwGJ)
          mvaInput_ = new float[23];
        else
          assert(0);

        TauTransverseImpactParameters_token =
            consumes<PFTauTIPAssociationByRef>(cfg.getParameter<edm::InputTag>("srcTauTransverseImpactParameters"));

        basicTauDiscriminators_token =
            consumes<reco::TauDiscriminatorContainer>(cfg.getParameter<edm::InputTag>("srcBasicTauDiscriminators"));
        input_id_name_suffix_ = cfg.getParameter<std::string>("inputIDNameSuffix");

        verbosity_ = cfg.getParameter<int>("verbosity");
      }

~PFRecoTauDiscriminationByMVAIsolationRun2()

reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::~PFRecoTauDiscriminationByMVAIsolationRun2 ( )

inlineoverride

Definition at line 130 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

References inputFilesToDelete_, loadMVAfromDB_, mvaInput_, and mvaReader_.

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

Member Function Documentation

beginEvent()

void reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::beginEvent ( const edm::Event &  evt, const edm::EventSetup &  es  )

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >.

Definition at line 174 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

References basicTauDiscriminators_, basicTauDiscriminators_token, chargedIsoPtSum_index_, footprintCorrection_index_, edm::Event::getByToken(), edm::EventSetup::getData(), mps_fire::i, input_id_name_suffix_, inputFileName_, inputFilesToDelete_, loadMVAfromDB_, mvaName_, mvaReader_, mvaToken_, neutralIsoPtSum_index_, edm::parameterSet(), phID_, photonPtSumOutsideSignalCone_index_, edm::Event::processHistory(), edm::Event::processHistoryID(), pucorrPtSum_index_, edm::Provenance::stable(), TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::Tau_token, tauLifetimeInfos, taus_, TauTransverseImpactParameters_token, and parallelization::uint.

                                                                                                           {
      if (!mvaReader_) {
        if (loadMVAfromDB_) {
          mvaReader_ = &es.getData(mvaToken_);
        } else {
          mvaReader_ = loadMVAfromFile(inputFileName_, mvaName_, inputFilesToDelete_);
        }
      }

      evt.getByToken(TauTransverseImpactParameters_token, tauLifetimeInfos);

      evt.getByToken(basicTauDiscriminators_token, basicTauDiscriminators_);

      evt.getByToken(Tau_token, taus_);

      // load indices from input provenance config if process history changed, in particular for the first event
      // skip missing IDs and leave treatment to produce/discriminate function
      if (evt.processHistoryID() != phID_ && basicTauDiscriminators_.isValid()) {
        phID_ = evt.processHistoryID();
        const edm::Provenance* prov = basicTauDiscriminators_.provenance();
        const std::vector<edm::ParameterSet> psetsFromProvenance =
            edm::parameterSet(prov->stable(), evt.processHistory())
                .getParameter<std::vector<edm::ParameterSet>>("IDdefinitions");
        for (uint i = 0; i < psetsFromProvenance.size(); i++) {
          if (psetsFromProvenance[i].getParameter<std::string>("IDname") == "ChargedIsoPtSum" + input_id_name_suffix_)
            chargedIsoPtSum_index_ = i;
          else if (psetsFromProvenance[i].getParameter<std::string>("IDname") ==
                   "NeutralIsoPtSum" + input_id_name_suffix_)
            neutralIsoPtSum_index_ = i;
          else if (psetsFromProvenance[i].getParameter<std::string>("IDname") == "PUcorrPtSum" + input_id_name_suffix_)
            pucorrPtSum_index_ = i;
          else if (psetsFromProvenance[i].getParameter<std::string>("IDname") ==
                   "PhotonPtSumOutsideSignalCone" + input_id_name_suffix_)
            photonPtSumOutsideSignalCone_index_ = i;
          else if (psetsFromProvenance[i].getParameter<std::string>("IDname") ==
                   "TauFootprintCorrection" + input_id_name_suffix_)
            footprintCorrection_index_ = i;
        }
      }
    }

discriminate()

reco::SingleTauDiscriminatorContainer reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate ( const PFTauRef &  tau ) const

override

Definition at line 215 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

References funct::abs(), chargedIsoPtSum_index_, reco::PFTauTransverseImpactParameter::dxy(), reco::PFTauTransverseImpactParameter::dxy_Sig(), MillePedeFileConverter_cfg::e, reco::tau::eratio(), f, reco::PFTauTransverseImpactParameter::flightLength(), reco::PFTauTransverseImpactParameter::flightLengthSig(), nano_mu_digi_cff::float, footprintCorrection_index_, GBRForest::GetClassifier(), reco::PFTauTransverseImpactParameter::hasSecondaryVertex(), reco::PFTauTransverseImpactParameter::ip3d(), reco::PFTauTransverseImpactParameter::ip3d_Sig(), reco::tau::kDBnewDMwLT, reco::tau::kDBnewDMwLTwGJ, reco::tau::kDBoldDMwLT, reco::tau::kDBoldDMwLTwGJ, reco::tau::kNewDMwLT, reco::tau::kNewDMwoLT, reco::tau::kOldDMwLT, reco::tau::kOldDMwoLT, reco::tau::kPWnewDMwLT, reco::tau::kPWoldDMwLT, reco::tau::lead_track_chi2(), dqm-mbProfile::log, SiStripPI::max, SiStripPI::min, mvaInput_, mvaOpt_, mvaReader_, reco::tau::n_photons_total(), neutralIsoPtSum_index_, l1ctLayer1_cff::nPhoton, photonPtSumOutsideSignalCone_index_, conifer::pow(), reco::tau::pt_weighted_deta_strip(), reco::tau::pt_weighted_dphi_strip(), reco::tau::pt_weighted_dr_iso(), reco::tau::pt_weighted_dr_signal(), pucorrPtSum_index_, PDWG_TauSkim_cff::rawValues, mps_fire::result, mathSSE::sqrt(), metsig::tau, and verbosity_.

                                   {
      reco::SingleTauDiscriminatorContainer result;
      result.rawValues = {-1.};

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

      int tauDecayMode = tau->decayMode();

      if (((mvaOpt_ == kOldDMwoLT || mvaOpt_ == kOldDMwLT || mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kPWoldDMwLT ||
            mvaOpt_ == kDBoldDMwLTwGJ) &&
           (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 10)) ||
          ((mvaOpt_ == kNewDMwoLT || mvaOpt_ == kNewDMwLT || mvaOpt_ == kDBnewDMwLT || mvaOpt_ == kPWnewDMwLT ||
            mvaOpt_ == kDBnewDMwLTwGJ) &&
           (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 5 || tauDecayMode == 6 ||
            tauDecayMode == 10 || tauDecayMode == 11))) {
        auto const rawValues = (*basicTauDiscriminators_)[tau].rawValues;
        float chargedIsoPtSum = rawValues.at(chargedIsoPtSum_index_);
        float neutralIsoPtSum = rawValues.at(neutralIsoPtSum_index_);
        float puCorrPtSum = rawValues.at(pucorrPtSum_index_);
        float photonPtSumOutsideSignalCone = rawValues.at(photonPtSumOutsideSignalCone_index_);
        float footprintCorrection = rawValues.at(footprintCorrection_index_);

        const reco::PFTauTransverseImpactParameter& tauLifetimeInfo = *(*tauLifetimeInfos)[tau];

        float decayDistX = tauLifetimeInfo.flightLength().x();
        float decayDistY = tauLifetimeInfo.flightLength().y();
        float decayDistZ = tauLifetimeInfo.flightLength().z();
        float decayDistMag = std::sqrt(decayDistX * decayDistX + decayDistY * decayDistY + decayDistZ * decayDistZ);

        float nPhoton = (float)reco::tau::n_photons_total(*tau);
        float ptWeightedDetaStrip = reco::tau::pt_weighted_deta_strip(*tau, tauDecayMode);
        float ptWeightedDphiStrip = reco::tau::pt_weighted_dphi_strip(*tau, tauDecayMode);
        float ptWeightedDrSignal = reco::tau::pt_weighted_dr_signal(*tau, tauDecayMode);
        float ptWeightedDrIsolation = reco::tau::pt_weighted_dr_iso(*tau, tauDecayMode);
        float leadingTrackChi2 = reco::tau::lead_track_chi2(*tau);
        float eRatio = reco::tau::eratio(*tau);

        // Difference between measured and maximally allowed Gottfried-Jackson angle
        float gjAngleDiff = -999;
        if (tauDecayMode == 10) {
          double mTau = 1.77682;
          double mAOne = tau->p4().M();
          double pAOneMag = tau->p();
          double argumentThetaGJmax = (std::pow(mTau, 2) - std::pow(mAOne, 2)) / (2 * mTau * pAOneMag);
          double argumentThetaGJmeasured =
              (tau->p4().px() * decayDistX + tau->p4().py() * decayDistY + tau->p4().pz() * decayDistZ) /
              (pAOneMag * decayDistMag);
          if (std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1.) {
            double thetaGJmax = std::asin(argumentThetaGJmax);
            double thetaGJmeasured = std::acos(argumentThetaGJmeasured);
            gjAngleDiff = thetaGJmeasured - thetaGJmax;
          }
        }

        if (mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT) {
          mvaInput_[0] = std::log(std::max(1.f, (float)tau->pt()));
          mvaInput_[1] = std::abs((float)tau->eta());
          mvaInput_[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput_[3] = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f * puCorrPtSum));
          mvaInput_[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput_[5] = tauDecayMode;
        } else if (mvaOpt_ == kOldDMwLT || mvaOpt_ == kNewDMwLT) {
          mvaInput_[0] = std::log(std::max(1.f, (float)tau->pt()));
          mvaInput_[1] = std::abs((float)tau->eta());
          mvaInput_[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput_[3] = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f * puCorrPtSum));
          mvaInput_[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput_[5] = tauDecayMode;
          mvaInput_[6] = std::copysign(+1.f, (float)tauLifetimeInfo.dxy());
          mvaInput_[7] = std::sqrt(std::abs(std::min(1.f, (float)tauLifetimeInfo.dxy())));
          mvaInput_[8] = std::min(10.f, std::abs((float)tauLifetimeInfo.dxy_Sig()));
          mvaInput_[9] = (tauLifetimeInfo.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput_[10] = std::sqrt(decayDistMag);
          mvaInput_[11] = std::min(10.f, (float)tauLifetimeInfo.flightLengthSig());
        } else if (mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kDBnewDMwLT) {
          mvaInput_[0] = std::log(std::max(1.f, (float)tau->pt()));
          mvaInput_[1] = std::abs((float)tau->eta());
          mvaInput_[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput_[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput_[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput_[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput_[6] = tauDecayMode;
          mvaInput_[7] = std::min(30.f, nPhoton);
          mvaInput_[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput_[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput_[12] = std::min(100.f, leadingTrackChi2);
          mvaInput_[13] = std::min(1.f, eRatio);
          mvaInput_[14] = std::copysign(+1.f, (float)tauLifetimeInfo.dxy());
          mvaInput_[15] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.dxy())));
          mvaInput_[16] = std::min(10.f, std::abs((float)tauLifetimeInfo.dxy_Sig()));
          mvaInput_[17] = std::copysign(+1.f, (float)tauLifetimeInfo.ip3d());
          mvaInput_[18] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.ip3d())));
          mvaInput_[19] = std::min(10.f, std::abs((float)tauLifetimeInfo.ip3d_Sig()));
          mvaInput_[20] = (tauLifetimeInfo.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput_[21] = std::sqrt(decayDistMag);
          mvaInput_[22] = std::min(10.f, (float)tauLifetimeInfo.flightLengthSig());
        } else if (mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kPWnewDMwLT) {
          mvaInput_[0] = std::log(std::max(1.f, (float)tau->pt()));
          mvaInput_[1] = std::abs((float)tau->eta());
          mvaInput_[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput_[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput_[4] = std::log(std::max(1.e-2f, footprintCorrection));
          mvaInput_[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput_[6] = tauDecayMode;
          mvaInput_[7] = std::min(30.f, nPhoton);
          mvaInput_[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput_[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput_[12] = std::min(100.f, leadingTrackChi2);
          mvaInput_[13] = std::min(1.f, eRatio);
          mvaInput_[14] = std::copysign(+1.f, (float)tauLifetimeInfo.dxy());
          mvaInput_[15] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.dxy())));
          mvaInput_[16] = std::min(10.f, std::abs((float)tauLifetimeInfo.dxy_Sig()));
          mvaInput_[17] = std::copysign(+1.f, (float)tauLifetimeInfo.ip3d());
          mvaInput_[18] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.ip3d())));
          mvaInput_[19] = std::min(10.f, std::abs((float)tauLifetimeInfo.ip3d_Sig()));
          mvaInput_[20] = (tauLifetimeInfo.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput_[21] = std::sqrt(decayDistMag);
          mvaInput_[22] = std::min(10.f, (float)tauLifetimeInfo.flightLengthSig());
        } else if (mvaOpt_ == kDBoldDMwLTwGJ || mvaOpt_ == kDBnewDMwLTwGJ) {
          mvaInput_[0] = std::log(std::max(1.f, (float)tau->pt()));
          mvaInput_[1] = std::abs((float)tau->eta());
          mvaInput_[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput_[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput_[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput_[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput_[6] = tauDecayMode;
          mvaInput_[7] = std::min(30.f, nPhoton);
          mvaInput_[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput_[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput_[12] = std::min(1.f, eRatio);
          mvaInput_[13] = std::copysign(+1.f, (float)tauLifetimeInfo.dxy());
          mvaInput_[14] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.dxy())));
          mvaInput_[15] = std::min(10.f, std::abs((float)tauLifetimeInfo.dxy_Sig()));
          mvaInput_[16] = std::copysign(+1.f, (float)tauLifetimeInfo.ip3d());
          mvaInput_[17] = std::sqrt(std::min(1.f, std::abs((float)tauLifetimeInfo.ip3d())));
          mvaInput_[18] = std::min(10.f, std::abs((float)tauLifetimeInfo.ip3d_Sig()));
          mvaInput_[19] = (tauLifetimeInfo.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput_[20] = std::sqrt(decayDistMag);
          mvaInput_[21] = std::min(10.f, (float)tauLifetimeInfo.flightLengthSig());
          mvaInput_[22] = std::max(-1.f, gjAngleDiff);
        }

        double mvaValue = mvaReader_->GetClassifier(mvaInput_);
        if (verbosity_) {
          edm::LogPrint("PFTauDiscByMVAIsol2") << "<PFRecoTauDiscriminationByMVAIsolationRun2::discriminate>:";
          edm::LogPrint("PFTauDiscByMVAIsol2") << " tau: Pt = " << tau->pt() << ", eta = " << tau->eta();
          edm::LogPrint("PFTauDiscByMVAIsol2") << " isolation: charged = " << chargedIsoPtSum
                                               << ", neutral = " << neutralIsoPtSum << ", PUcorr = " << puCorrPtSum;
          edm::LogPrint("PFTauDiscByMVAIsol2") << " decay mode = " << tauDecayMode;
          edm::LogPrint("PFTauDiscByMVAIsol2") << " impact parameter: distance = " << tauLifetimeInfo.dxy()
                                               << ", significance = " << tauLifetimeInfo.dxy_Sig();
          edm::LogPrint("PFTauDiscByMVAIsol2")
              << " has decay vertex = " << tauLifetimeInfo.hasSecondaryVertex() << ":"
              << " distance = " << decayDistMag << ", significance = " << tauLifetimeInfo.flightLengthSig();
          edm::LogPrint("PFTauDiscByMVAIsol2") << "--> mvaValue = " << mvaValue;
        }
        result.rawValues.at(0) = mvaValue;
      }
      return result;
    }

fillDescriptions()

void reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 385 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >::fillProducerDescriptions(), ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                               {
      // pfRecoTauDiscriminationByMVAIsolationRun2
      edm::ParameterSetDescription desc;

      desc.add<std::string>("mvaName", "tauIdMVAnewDMwLT");
      desc.add<bool>("loadMVAfromDB", true);
      desc.addOptional<edm::FileInPath>("inputFileName");
      desc.add<std::string>("mvaOpt", "newDMwLT");

      desc.add<edm::InputTag>("srcTauTransverseImpactParameters", edm::InputTag(""));
      desc.add<edm::InputTag>("srcBasicTauDiscriminators", edm::InputTag("hpsPFTauBasicDiscriminators"));
      desc.add<std::string>("inputIDNameSuffix", "");

      desc.add<int>("verbosity", 0);

      fillProducerDescriptions(desc);  // inherited from the base

      descriptions.add("pfRecoTauDiscriminationByMVAIsolationRun2", desc);
    }

Member Data Documentation

basicTauDiscriminators_

edm::Handle<reco::TauDiscriminatorContainer> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::basicTauDiscriminators_

private

Definition at line 158 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent().

basicTauDiscriminators_token

edm::EDGetTokenT<reco::TauDiscriminatorContainer> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::basicTauDiscriminators_token

private

Definition at line 157 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

chargedIsoPtSum_index_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::chargedIsoPtSum_index_ = 0

private

Definition at line 159 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and discriminate().

footprintCorrection_index_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::footprintCorrection_index_ = 0

private

Definition at line 163 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and discriminate().

input_id_name_suffix_

std::string reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::input_id_name_suffix_

private

Definition at line 164 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

inputFileName_

edm::FileInPath reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::inputFileName_

private

Definition at line 147 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

inputFilesToDelete_

std::vector<TFile*> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::inputFilesToDelete_

private

Definition at line 169 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and ~PFRecoTauDiscriminationByMVAIsolationRun2().

loadMVAfromDB_

bool reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::loadMVAfromDB_

private

Definition at line 146 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), PFRecoTauDiscriminationByMVAIsolationRun2(), and ~PFRecoTauDiscriminationByMVAIsolationRun2().

moduleLabel_

std::string reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::moduleLabel_

private

Definition at line 142 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

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

mvaInput_

float* reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::mvaInput_

private

Definition at line 150 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by discriminate(), PFRecoTauDiscriminationByMVAIsolationRun2(), and ~PFRecoTauDiscriminationByMVAIsolationRun2().

mvaName_

std::string reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::mvaName_

private

Definition at line 144 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

mvaOpt_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::mvaOpt_

private

Definition at line 149 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByMVAIsolationRun2().

mvaReader_

const GBRForest* reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::mvaReader_

private

Definition at line 148 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), discriminate(), and ~PFRecoTauDiscriminationByMVAIsolationRun2().

mvaToken_

edm::ESGetToken<GBRForest, GBRWrapperRcd> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::mvaToken_

private

Definition at line 145 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

neutralIsoPtSum_index_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::neutralIsoPtSum_index_ = 0

private

Definition at line 160 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and discriminate().

phID_

edm::ProcessHistoryID reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::phID_

private

Definition at line 165 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent().

photonPtSumOutsideSignalCone_index_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::photonPtSumOutsideSignalCone_index_ = 0

private

Definition at line 162 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and discriminate().

pucorrPtSum_index_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::pucorrPtSum_index_ = 0

private

Definition at line 161 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and discriminate().

tauLifetimeInfos

edm::Handle<PFTauTIPAssociationByRef> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::tauLifetimeInfos

private

Definition at line 155 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent().

taus_

edm::Handle<TauCollection> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::taus_

private

Definition at line 167 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent().

TauTransverseImpactParameters_token

edm::EDGetTokenT<PFTauTIPAssociationByRef> reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::TauTransverseImpactParameters_token

private

Definition at line 154 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by beginEvent(), and PFRecoTauDiscriminationByMVAIsolationRun2().

verbosity_

int reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::verbosity_

private

Definition at line 171 of file PFRecoTauDiscriminationByMVAIsolationRun2.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByMVAIsolationRun2().