DeepTauId Class Reference

Inheritance diagram for DeepTauId:

Public Member Functions
	DeepTauId (const edm::ParameterSet &cfg, const deep_tau::DeepTauCache *cache)
Public Member Functions inherited from deep_tau::DeepTauBase
	DeepTauBase (const edm::ParameterSet &cfg, const OutputCollection &outputs, const DeepTauCache *cache)
void	produce (edm::Event &event, const edm::EventSetup &es) override
	~DeepTauBase () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
static const OutputCollection &	GetOutputs ()
static void	globalEndJob (const deep_tau::DeepTauCache *cache_)
static std::unique_ptr< deep_tau::DeepTauCache >	initializeGlobalCache (const edm::ParameterSet &cfg)
Static Public Member Functions inherited from deep_tau::DeepTauBase
static void	globalEndJob (const DeepTauCache *cache)
static std::unique_ptr< DeepTauCache >	initializeGlobalCache (const edm::ParameterSet &cfg)

Static Public Attributes
static float	default_value = -999.

Private Member Functions
void	checkInputs (const tensorflow::Tensor &inputs, const char *block_name, int n_inputs, int n_eta=1, int n_phi=1) const
void	createConvFeatures (const TauType &tau, const reco::Vertex &pv, double rho, const pat::ElectronCollection &electrons, const pat::MuonCollection &muons, const pat::PackedCandidateCollection &pfCands, const CellGrid &grid, bool is_inner)
void	createEgammaBlockInputs (const TauType &tau, const reco::Vertex &pv, double rho, const pat::ElectronCollection &electrons, const pat::PackedCandidateCollection &pfCands, const Cell &cell_map, bool is_inner)
void	createHadronsBlockInputs (const TauType &tau, const reco::Vertex &pv, double rho, const pat::PackedCandidateCollection &pfCands, const Cell &cell_map, bool is_inner)
template<typename dnn >
tensorflow::Tensor	createInputsV1 (const TauType &tau, const ElectronCollection &electrons, const MuonCollection &muons) const
void	createMuonBlockInputs (const TauType &tau, const reco::Vertex &pv, double rho, const pat::MuonCollection &muons, const pat::PackedCandidateCollection &pfCands, const Cell &cell_map, bool is_inner)
void	createTauBlockInputs (const TauType &tau, const reco::Vertex &pv, double rho)
template<typename Collection >
void	fillGrids (const TauType &tau, const Collection &objects, CellGrid &inner_grid, CellGrid &outer_grid)
void	getPartialPredictions (tensorflow::Tensor &convTensor, bool is_inner, int eta_index, int phi_index)
tensorflow::Tensor	getPredictions (edm::Event &event, const edm::EventSetup &es, edm::Handle< TauCollection > taus) override
void	getPredictionsV1 (const TauType &tau, const pat::ElectronCollection &electrons, const pat::MuonCollection &muons, std::vector< tensorflow::Tensor > &pred_vector)
void	getPredictionsV2 (const TauType &tau, const pat::ElectronCollection &electrons, const pat::MuonCollection &muons, const pat::PackedCandidateCollection &pfCands, const reco::Vertex &pv, double rho, std::vector< tensorflow::Tensor > &pred_vector)
void	setCellConvFeatures (tensorflow::Tensor &convTensor, const tensorflow::Tensor &features, int eta_index, int phi_index)

Static Private Member Functions
static void	calculateElectronClusterVars (const pat::Electron *ele, float &elecEe, float &elecEgamma)
static bool	calculateElectronClusterVarsV2 (const pat::Electron &ele, float &cc_ele_energy, float &cc_gamma_energy, int &cc_n_gamma)
static bool	calculateGottfriedJacksonAngleDifference (const pat::Tau &tau, double &gj_diff)
static float	calculateGottfriedJacksonAngleDifference (const pat::Tau &tau)
static const pat::Electron *	findMatchedElectron (const pat::Tau &tau, const pat::ElectronCollection &electrons, double deltaR)
static double	getInnerSignalConeRadius (double pt)
template<typename T >
static float	getValue (T value)
template<typename T >
static float	getValueLinear (T value, float min_value, float max_value, bool positive)
template<typename T >
static float	getValueNorm (T value, float mean, float sigma, float n_sigmas_max=5)
static bool	isInEcalCrack (double eta)
template<typename CandidateCollection >
static void	processIsolationPFComponents (const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
template<typename CandidateCollection >
static void	processSignalPFComponents (const pat::Tau &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4_inner, LorentzVectorXYZ &p4_outer, float &pt_inner, float &dEta_inner, float &dPhi_inner, float &m_inner, float &pt_outer, float &dEta_outer, float &dPhi_outer, float &m_outer, float &n_inner, float &n_outer)

Private Attributes
std::array< std::shared_ptr< tensorflow::Tensor >, 2 >	convTensor_
const int	debug_level
std::array< std::shared_ptr< tensorflow::Tensor >, 2 >	eGammaTensor_
edm::EDGetTokenT< ElectronCollection >	electrons_token_
std::array< std::shared_ptr< tensorflow::Tensor >, 2 >	hadronsTensor_
std::string	input_layer_
edm::EDGetTokenT< MuonCollection >	muons_token_
std::array< std::shared_ptr< tensorflow::Tensor >, 2 >	muonTensor_
std::string	output_layer_
edm::EDGetTokenT< double >	rho_token_
std::shared_ptr< tensorflow::Tensor >	tauBlockTensor_
const unsigned	version
std::array< std::shared_ptr< tensorflow::Tensor >, 2 >	zeroOutputTensor_

Static Private Attributes
static float	pi = M_PI

Additional Inherited Members
Public Types inherited from deep_tau::DeepTauBase
using	Cutter = TauWPThreshold
using	CutterPtr = std::unique_ptr< Cutter >
using	ElectronCollection = pat::ElectronCollection
using	LorentzVectorXYZ = ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double >>
using	MuonCollection = pat::MuonCollection
using	OutputCollection = std::map< std::string, Output >
using	TauCollection = std::vector< TauType >
using	TauDiscriminator = pat::PATTauDiscriminator
using	TauRef = edm::Ref< TauCollection >
using	TauRefProd = edm::RefProd< TauCollection >
using	TauType = pat::Tau
using	WPMap = std::map< std::string, CutterPtr >
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >
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
Protected Attributes inherited from deep_tau::DeepTauBase
const DeepTauCache *	cache_
OutputCollection	outputs_
edm::EDGetTokenT< pat::PackedCandidateCollection >	pfcandToken_
edm::EDGetTokenT< TauCollection >	tausToken_
edm::EDGetTokenT< reco::VertexCollection >	vtxToken_
std::map< std::string, WPMap >	workingPoints_

Detailed Description

Definition at line 551 of file DeepTauId.cc.

Constructor & Destructor Documentation

DeepTauId::DeepTauId ( const edm::ParameterSet &  cfg, const deep_tau::DeepTauCache *  cache  )

inlineexplicit

Definition at line 598 of file DeepTauId.cc.

References Exception, gen::n, dataset::name, and jets_cff::version.

                                                                                      :
        DeepTauBase(cfg, GetOutputs(), cache),
        electrons_token_(consumes<ElectronCollection>(cfg.getParameter<edm::InputTag>("electrons"))),
        muons_token_(consumes<MuonCollection>(cfg.getParameter<edm::InputTag>("muons"))),
        rho_token_(consumes<double>(cfg.getParameter<edm::InputTag>("rho"))),
        version(cfg.getParameter<unsigned>("version")),
        debug_level(cfg.getParameter<int>("debug_level"))
    {
        if(version == 1) {
            input_layer_ = cache_->getGraph().node(0).name();
            output_layer_ = cache_->getGraph().node(cache_->getGraph().node_size() - 1).name();
            const auto& shape = cache_->getGraph().node(0).attr().at("shape").shape();
            if(shape.dim(1).size() != dnn_inputs_2017v1::NumberOfInputs)
                throw cms::Exception("DeepTauId") << "number of inputs does not match the expected inputs for the given version";
        } else if(version == 2) {
            tauBlockTensor_ =  std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT, tensorflow::TensorShape{ 1,
                dnn_inputs_2017_v2::TauBlockInputs::NumberOfInputs});
            for(size_t n = 0; n < 2; ++n) {
                const bool is_inner = n == 0;
                const auto n_cells = is_inner ? dnn_inputs_2017_v2::number_of_inner_cell
                                              : dnn_inputs_2017_v2::number_of_outer_cell;
                eGammaTensor_[is_inner] = std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT,
                    tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::EgammaBlockInputs::NumberOfInputs});
                muonTensor_[is_inner] = std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT,
                    tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::MuonBlockInputs::NumberOfInputs});
                hadronsTensor_[is_inner] = std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT,
                    tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::HadronBlockInputs::NumberOfInputs});
                convTensor_[is_inner] = std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT,
                    tensorflow::TensorShape{1, n_cells, n_cells, dnn_inputs_2017_v2::number_of_conv_features});
                zeroOutputTensor_[is_inner] = std::make_shared<tensorflow::Tensor>(tensorflow::DT_FLOAT,
                    tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::number_of_conv_features});


                eGammaTensor_[is_inner]->flat<float>().setZero();
                muonTensor_[is_inner]->flat<float>().setZero();
                hadronsTensor_[is_inner]->flat<float>().setZero();
                getPartialPredictions(*zeroOutputTensor_[is_inner], is_inner, 0, 0);

            }
        } else {
            throw cms::Exception("DeepTauId") << "version " << version << " is not supported.";
        }

    }

Member Function Documentation

static void DeepTauId::calculateElectronClusterVars ( const pat::Electron *  ele, float &  elecEe, float &  elecEgamma  )

inlinestaticprivate

Definition at line 1567 of file DeepTauId.cc.

References randomXiThetaGunProducer_cfi::energy, and pat::Electron::superCluster().

    {
        if(ele) {
            elecEe = elecEgamma = 0;
            auto superCluster = ele->superCluster();
            if(superCluster.isNonnull() && superCluster.isAvailable() && superCluster->clusters().isNonnull()
                    && superCluster->clusters().isAvailable()) {
                for(auto iter = superCluster->clustersBegin(); iter != superCluster->clustersEnd(); ++iter) {
                    const double energy = (*iter)->energy();
                    if(iter == superCluster->clustersBegin()) elecEe += energy;
                    else elecEgamma += energy;
                }
            }
        } else {
            elecEe = elecEgamma = default_value;
        }
    }

static bool DeepTauId::calculateElectronClusterVarsV2 ( const pat::Electron &  ele, float &  cc_ele_energy, float &  cc_gamma_energy, int &  cc_n_gamma  )

inlinestaticprivate

Definition at line 680 of file DeepTauId.cc.

References randomXiThetaGunProducer_cfi::energy, and pat::Electron::superCluster().

    {
        cc_ele_energy = cc_gamma_energy = 0;
        cc_n_gamma = 0;
        const auto& superCluster = ele.superCluster();
        if(superCluster.isNonnull() && superCluster.isAvailable() && superCluster->clusters().isNonnull()
            && superCluster->clusters().isAvailable()) {
            for(auto iter = superCluster->clustersBegin(); iter != superCluster->clustersEnd(); ++iter) {
                const float energy = static_cast<float>((*iter)->energy());
                if(iter == superCluster->clustersBegin())
                    cc_ele_energy += energy;
                else {
                    cc_gamma_energy += energy;
                    ++cc_n_gamma;
                }
            }
            return true;
        } else
            return false;
    }

static bool DeepTauId::calculateGottfriedJacksonAngleDifference ( const pat::Tau &  tau, double &  gj_diff  )

inlinestaticprivate

Definition at line 1648 of file DeepTauId.cc.

References funct::abs(), constexpr, pat::Tau::flightLength(), pat::Tau::hasSecondaryVertex(), reco::LeafCandidate::p(), reco::LeafCandidate::p4(), and funct::pow().

    {
        if(tau.hasSecondaryVertex()) {
            static constexpr double mTau = 1.77682;
            const double mAOne = tau.p4().M();
            const double pAOneMag = tau.p();
            const double argumentThetaGJmax = (std::pow(mTau,2) - std::pow(mAOne,2) ) / ( 2 * mTau * pAOneMag );
            const double argumentThetaGJmeasured = tau.p4().Vect().Dot(tau.flightLength())
                    / ( pAOneMag * tau.flightLength().R() );
            if ( std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1. ) {
                double thetaGJmax = std::asin( argumentThetaGJmax );
                double thetaGJmeasured = std::acos( argumentThetaGJmeasured );
                gj_diff = thetaGJmeasured - thetaGJmax;
                return true;
            }
        }
        return false;
    }

static float DeepTauId::calculateGottfriedJacksonAngleDifference ( const pat::Tau &  tau )

inlinestaticprivate

Definition at line 1667 of file DeepTauId.cc.

    {
        double gj_diff;
        if(calculateGottfriedJacksonAngleDifference(tau, gj_diff))
            return static_cast<float>(gj_diff);
        return default_value;
    }

void DeepTauId::checkInputs ( const tensorflow::Tensor &  inputs, const char *  block_name, int  n_inputs, int  n_eta = 1, int  n_phi = 1  ) const

inlineprivate

Definition at line 702 of file DeepTauId.cc.

References gather_cfg::cout, PVValHelper::eta, Exception, alignBH_cfg::fixed, objects.autophobj::float, input, edm::isNotFinite(), and gen::k.

    {
        if(debug_level >= 1){
            for(int eta = 0; eta < n_eta; ++eta){
                for(int phi = 0; phi < n_phi; phi++){
                    for(int k = 0; k < n_inputs; ++k) {
                        const float input = n_eta == 1 && n_phi == 1
                                          ? inputs.matrix<float>()(0, k) : inputs.tensor<float,4>()(0, eta, phi, k);
                        if(edm::isNotFinite(input))
                            throw cms::Exception("DeepTauId") << "in the " << block_name << ", input is not finite, i.e. infinite or NaN, for eta_index = "
                                                              << n_eta << ", phi_index = " << n_phi << ", input_index = " << k;
                        if(debug_level >= 2)
                            std::cout << block_name << "," << eta << ","<< phi << "," << k << "," << std::setprecision(5) << std::fixed << input << '\n';
                    }
                }
            }
        }
    }

void DeepTauId::createConvFeatures ( const TauType &  tau, const reco::Vertex &  pv, double  rho, const pat::ElectronCollection &  electrons, const pat::MuonCollection &  muons, const pat::PackedCandidateCollection &  pfCands, const CellGrid &  grid, bool  is_inner  )

inlineprivate

Definition at line 847 of file DeepTauId.cc.

References PVValHelper::eta.

    {
        tensorflow::Tensor& convTensor = *convTensor_.at(is_inner);
        for(int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
            for(int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
                const CellIndex cell_index{eta, phi};
                const int eta_index = grid.getEtaTensorIndex(cell_index);
                const int phi_index = grid.getPhiTensorIndex(cell_index);

                const auto cell_iter = grid.find(cell_index);
                if(cell_iter != grid.end()) {
                    const Cell& cell = cell_iter->second;
                    createEgammaBlockInputs(tau, pv, rho, electrons, pfCands, cell, is_inner);
                    createMuonBlockInputs(tau, pv, rho, muons, pfCands, cell, is_inner);
                    createHadronsBlockInputs(tau, pv, rho, pfCands, cell, is_inner);
                    getPartialPredictions(convTensor, is_inner, eta_index, phi_index);
                } else {
                    setCellConvFeatures(convTensor, *zeroOutputTensor_[is_inner], eta_index, phi_index);
                }
            }
        }
    }

void DeepTauId::createEgammaBlockInputs ( const TauType &  tau, const reco::Vertex &  pv, double  rho, const pat::ElectronCollection &  electrons, const pat::PackedCandidateCollection &  pfCands, const Cell &  cell_map, bool  is_inner  )

inlineprivate

Definition at line 964 of file DeepTauId.cc.

References funct::abs(), particleFlow_cfi::dPhi, nanoDQM_cff::Electron, f, pat::Tau::flightLength(), objects.autophobj::float, reco::JetExtendedAssociation::getValue(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, reco::LeafCandidate::polarP4(), reco::Vertex::position(), muonProducer_cfi::rho, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

    {
        namespace dnn = dnn_inputs_2017_v2::EgammaBlockInputs;

        tensorflow::Tensor& inputs = *eGammaTensor_.at(is_inner);
        inputs.flat<float>().setZero();

        const auto& get = [&](int var_index) -> float& {
            return inputs.tensor<float,4>()(0, 0, 0, var_index);
        };

        const bool valid_index_pf_ele = cell_map.count(CellObjectType::PfCand_electron);
        const bool valid_index_pf_gamma = cell_map.count(CellObjectType::PfCand_gamma);
        const bool valid_index_ele = cell_map.count(CellObjectType::Electron);

        if(!cell_map.empty()){
            get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
            get(dnn::tau_pt) =  getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
            get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
            get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
        }
        if(valid_index_pf_ele){
            size_t index_pf_ele = cell_map.at(CellObjectType::PfCand_electron);

            get(dnn::pfCand_ele_valid) = valid_index_pf_ele;
            get(dnn::pfCand_ele_rel_pt) = getValueNorm(pfCands.at(index_pf_ele).polarP4().pt() / tau.polarP4().pt(),
                is_inner ? 0.9792f : 0.304f, is_inner ? 0.5383f : 1.845f);
            get(dnn::pfCand_ele_deta) = getValueLinear(pfCands.at(index_pf_ele).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_ele_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_ele).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_ele_pvAssociationQuality) = getValueLinear<int>(pfCands.at(index_pf_ele).pvAssociationQuality(), 0, 7, true);
            get(dnn::pfCand_ele_puppiWeight) = getValue(pfCands.at(index_pf_ele).puppiWeight());
            get(dnn::pfCand_ele_charge) = getValue(pfCands.at(index_pf_ele).charge());
            get(dnn::pfCand_ele_lostInnerHits) = getValue<int>(pfCands.at(index_pf_ele).lostInnerHits());
            get(dnn::pfCand_ele_numberOfPixelHits) = getValueLinear(pfCands.at(index_pf_ele).numberOfPixelHits(), 0, 10, true);
            get(dnn::pfCand_ele_vertex_dx) = getValueNorm(pfCands.at(index_pf_ele).vertex().x() - pv.position().x(), 0.f, 0.1221f);
            get(dnn::pfCand_ele_vertex_dy) = getValueNorm(pfCands.at(index_pf_ele).vertex().y() - pv.position().y(), 0.f, 0.1226f);
            get(dnn::pfCand_ele_vertex_dz) = getValueNorm(pfCands.at(index_pf_ele).vertex().z() - pv.position().z(), 0.001f, 1.024f);
            get(dnn::pfCand_ele_vertex_dx_tauFL) = getValueNorm(pfCands.at(index_pf_ele).vertex().x() -
                pv.position().x() - tau.flightLength().x(), 0.f, 0.3411f);
            get(dnn::pfCand_ele_vertex_dy_tauFL) = getValueNorm(pfCands.at(index_pf_ele).vertex().y() -
                pv.position().y() - tau.flightLength().y(), 0.0003f, 0.3385f);
            get(dnn::pfCand_ele_vertex_dz_tauFL) = getValueNorm(pfCands.at(index_pf_ele).vertex().z() -
                pv.position().z() - tau.flightLength().z(), 0.f, 1.307f);

            const bool hasTrackDetails = pfCands.at(index_pf_ele).hasTrackDetails();
            if(hasTrackDetails){
                get(dnn::pfCand_ele_hasTrackDetails) = hasTrackDetails;
                get(dnn::pfCand_ele_dxy) = getValueNorm(pfCands.at(index_pf_ele).dxy(), 0.f, 0.171f);
                get(dnn::pfCand_ele_dxy_sig) = getValueNorm(std::abs(pfCands.at(index_pf_ele).dxy()) /
                    pfCands.at(index_pf_ele).dxyError(), 1.634f, 6.45f);
                get(dnn::pfCand_ele_dz) =  getValueNorm(pfCands.at(index_pf_ele).dz(), 0.001f, 1.02f);
                get(dnn::pfCand_ele_dz_sig) =  getValueNorm(std::abs(pfCands.at(index_pf_ele).dz()) /
                    pfCands.at(index_pf_ele).dzError(), 24.56f, 210.4f);
                get(dnn::pfCand_ele_track_chi2_ndof) = getValueNorm(pfCands.at(index_pf_ele).pseudoTrack().chi2() /
                    pfCands.at(index_pf_ele).pseudoTrack().ndof(), 2.272f, 8.439f);
                get(dnn::pfCand_ele_track_ndof) = getValueNorm(pfCands.at(index_pf_ele).pseudoTrack().ndof(), 15.18f, 3.203f);
            }
        }
        if(valid_index_pf_gamma){
            size_t index_pf_gamma = cell_map.at(CellObjectType::PfCand_gamma);
            get(dnn::pfCand_gamma_valid) = valid_index_pf_gamma;
            get(dnn::pfCand_gamma_rel_pt) = getValueNorm(pfCands.at(index_pf_gamma).polarP4().pt() / tau.polarP4().pt(),
                is_inner ? 0.6048f : 0.02576f, is_inner ? 1.669f : 0.3833f);
            get(dnn::pfCand_gamma_deta) = getValueLinear(pfCands.at(index_pf_gamma).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_gamma_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_gamma).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_gamma_pvAssociationQuality) =
                getValueLinear<int>(pfCands.at(index_pf_gamma).pvAssociationQuality(), 0, 7, true);
            get(dnn::pfCand_gamma_fromPV) = getValueLinear<int>(pfCands.at(index_pf_gamma).fromPV(), 0, 3, true);
            get(dnn::pfCand_gamma_puppiWeight) = getValue(pfCands.at(index_pf_gamma).puppiWeight());
            get(dnn::pfCand_gamma_puppiWeightNoLep) = getValue(pfCands.at(index_pf_gamma).puppiWeightNoLep());
            get(dnn::pfCand_gamma_lostInnerHits) = getValue<int>(pfCands.at(index_pf_gamma).lostInnerHits());
            get(dnn::pfCand_gamma_numberOfPixelHits) = getValueLinear(pfCands.at(index_pf_gamma).numberOfPixelHits(), 0, 7, true);
            get(dnn::pfCand_gamma_vertex_dx) = getValueNorm(pfCands.at(index_pf_gamma).vertex().x() - pv.position().x(), 0.f, 0.0067f);
            get(dnn::pfCand_gamma_vertex_dy) = getValueNorm(pfCands.at(index_pf_gamma).vertex().y() - pv.position().y(), 0.f, 0.0069f);
            get(dnn::pfCand_gamma_vertex_dz) = getValueNorm(pfCands.at(index_pf_gamma).vertex().z() - pv.position().z(), 0.f, 0.0578f);
            get(dnn::pfCand_gamma_vertex_dx_tauFL) = getValueNorm(pfCands.at(index_pf_gamma).vertex().x() -
                pv.position().x() - tau.flightLength().x(), 0.001f, 0.9565f);
            get(dnn::pfCand_gamma_vertex_dy_tauFL) = getValueNorm(pfCands.at(index_pf_gamma).vertex().y() -
                pv.position().y() - tau.flightLength().y(), 0.0008f, 0.9592f);
            get(dnn::pfCand_gamma_vertex_dz_tauFL) = getValueNorm(pfCands.at(index_pf_gamma).vertex().z() -
                pv.position().z() - tau.flightLength().z(), 0.0038f, 2.154f);

            const bool hasTrackDetails = pfCands.at(index_pf_gamma).hasTrackDetails();
            if(hasTrackDetails){
                get(dnn::pfCand_gamma_hasTrackDetails) = hasTrackDetails;
                get(dnn::pfCand_gamma_dxy) = getValueNorm(pfCands.at(index_pf_gamma).dxy(), 0.0004f, 0.882f);
                get(dnn::pfCand_gamma_dxy_sig) = getValueNorm(std::abs(pfCands.at(index_pf_gamma).dxy()) /
                    pfCands.at(index_pf_gamma).dxyError(), 4.271f, 63.78f);
                get(dnn::pfCand_gamma_dz) =  getValueNorm(pfCands.at(index_pf_gamma).dz(), 0.0071f, 5.285f);
                get(dnn::pfCand_gamma_dz_sig) =  getValueNorm(std::abs(pfCands.at(index_pf_gamma).dz()) /
                    pfCands.at(index_pf_gamma).dzError(), 162.1f, 622.4f);
                get(dnn::pfCand_gamma_track_chi2_ndof) = pfCands.at(index_pf_gamma).pseudoTrack().ndof() > 0 ?
                    getValueNorm(pfCands.at(index_pf_gamma).pseudoTrack().chi2() /
                                 pfCands.at(index_pf_gamma).pseudoTrack().ndof(), 4.268f, 15.47f) : 0;
                get(dnn::pfCand_gamma_track_ndof) = pfCands.at(index_pf_gamma).pseudoTrack().ndof() > 0 ?
                    getValueNorm(pfCands.at(index_pf_gamma).pseudoTrack().ndof(), 12.25f, 4.774f) : 0;
            }
        }
        if(valid_index_ele){
            size_t index_ele = cell_map.at(CellObjectType::Electron);

            get(dnn::ele_valid) = valid_index_ele;
            get(dnn::ele_rel_pt) = getValueNorm(electrons.at(index_ele).polarP4().pt() / tau.polarP4().pt(),
                is_inner ? 1.067f : 0.5111f, is_inner ? 1.521f : 2.765f);
            get(dnn::ele_deta) = getValueLinear(electrons.at(index_ele).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::ele_dphi) = getValueLinear(dPhi(tau.polarP4(), electrons.at(index_ele).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);

            float cc_ele_energy, cc_gamma_energy;
            int cc_n_gamma;
            const bool cc_valid = calculateElectronClusterVarsV2(electrons.at(index_ele), cc_ele_energy, cc_gamma_energy, cc_n_gamma);
            if(cc_valid){
                get(dnn::ele_cc_valid) = cc_valid;
                get(dnn::ele_cc_ele_rel_energy) = getValueNorm(cc_ele_energy / electrons.at(index_ele).polarP4().pt(), 1.729f, 1.644f);
                get(dnn::ele_cc_gamma_rel_energy) = getValueNorm(cc_gamma_energy / cc_ele_energy, 0.1439f, 0.3284f);
                get(dnn::ele_cc_n_gamma) = getValueNorm(cc_n_gamma, 1.794f, 2.079f);
            }
            get(dnn::ele_rel_trackMomentumAtVtx) = getValueNorm(electrons.at(index_ele).trackMomentumAtVtx().R() /
                electrons.at(index_ele).polarP4().pt(), 1.531f, 1.424f);
            get(dnn::ele_rel_trackMomentumAtCalo) =  getValueNorm(electrons.at(index_ele).trackMomentumAtCalo().R() /
                electrons.at(index_ele).polarP4().pt(), 1.531f, 1.424f);
            get(dnn::ele_rel_trackMomentumOut) = getValueNorm(electrons.at(index_ele).trackMomentumOut().R() /
                electrons.at(index_ele).polarP4().pt(), 0.7735f, 0.935f);
            get(dnn::ele_rel_trackMomentumAtEleClus) = getValueNorm(electrons.at(index_ele).trackMomentumAtEleClus().R() /
                electrons.at(index_ele).polarP4().pt(), 0.7735f, 0.935f);
            get(dnn::ele_rel_trackMomentumAtVtxWithConstraint) =
                getValueNorm(electrons.at(index_ele).trackMomentumAtVtxWithConstraint().R() /
                electrons.at(index_ele).polarP4().pt(), 1.625f, 1.581f);
            get(dnn::ele_rel_ecalEnergy) = getValueNorm(electrons.at(index_ele).ecalEnergy() /
                electrons.at(index_ele).polarP4().pt(), 1.993f, 1.308f);
            get(dnn::ele_ecalEnergy_sig) =  getValueNorm(electrons.at(index_ele).ecalEnergy() /
                electrons.at(index_ele).ecalEnergyError(), 70.25f, 58.16f);
            get(dnn::ele_eSuperClusterOverP) =  getValueNorm(electrons.at(index_ele).eSuperClusterOverP(), 2.432f, 15.13f);
            get(dnn::ele_eSeedClusterOverP) = getValueNorm(electrons.at(index_ele).eSeedClusterOverP(), 2.034f, 13.96f);
            get(dnn::ele_eSeedClusterOverPout) = getValueNorm(electrons.at(index_ele).eSeedClusterOverPout(), 6.64f, 36.8f);
            get(dnn::ele_eEleClusterOverPout) = getValueNorm(electrons.at(index_ele).eEleClusterOverPout(), 4.183f, 20.63f);
            get(dnn::ele_deltaEtaSuperClusterTrackAtVtx) =
                getValueNorm(electrons.at(index_ele).deltaEtaSuperClusterTrackAtVtx(),0.f, 0.0363f);
            get(dnn::ele_deltaEtaSeedClusterTrackAtCalo) =
                getValueNorm(electrons.at(index_ele).deltaEtaSeedClusterTrackAtCalo(), -0.0001f, 0.0512f);
            get(dnn::ele_deltaEtaEleClusterTrackAtCalo) =
                getValueNorm(electrons.at(index_ele).deltaEtaEleClusterTrackAtCalo(), -0.0001f, 0.0541f);
            get(dnn::ele_deltaPhiEleClusterTrackAtCalo) =
                getValueNorm(electrons.at(index_ele).deltaPhiEleClusterTrackAtCalo(), 0.0002f, 0.0553f);
            get(dnn::ele_deltaPhiSuperClusterTrackAtVtx) =
                getValueNorm(electrons.at(index_ele).deltaPhiSuperClusterTrackAtVtx(), 0.0001f, 0.0523f);
            get(dnn::ele_deltaPhiSeedClusterTrackAtCalo) =
                getValueNorm(electrons.at(index_ele).deltaPhiSeedClusterTrackAtCalo(), 0.0004f, 0.0777f);
            get(dnn::ele_mvaInput_earlyBrem) = getValue(electrons.at(index_ele).mvaInput().earlyBrem);
            get(dnn::ele_mvaInput_lateBrem) = getValue(electrons.at(index_ele).mvaInput().lateBrem);
            get(dnn::ele_mvaInput_sigmaEtaEta) = getValueNorm(electrons.at(index_ele).mvaInput().sigmaEtaEta,0.0008f, 0.0052f);
            get(dnn::ele_mvaInput_hadEnergy) = getValueNorm(electrons.at(index_ele).mvaInput().hadEnergy, 14.04f, 69.48f);
            get(dnn::ele_mvaInput_deltaEta) = getValueNorm(electrons.at(index_ele).mvaInput().deltaEta, 0.0099f, 0.0851f);

            const auto& gsfTrack = electrons.at(index_ele).gsfTrack();
            if(gsfTrack.isNonnull()){
                get(dnn::ele_gsfTrack_normalizedChi2) = getValueNorm(gsfTrack->normalizedChi2(), 3.049f, 10.39f);
                get(dnn::ele_gsfTrack_numberOfValidHits) = getValueNorm(gsfTrack->numberOfValidHits(), 16.52f, 2.806f);
                get(dnn::ele_rel_gsfTrack_pt) = getValueNorm(gsfTrack->pt() / electrons.at(index_ele).polarP4().pt(), 1.355f, 16.81f);
                get(dnn::ele_gsfTrack_pt_sig) = getValueNorm(gsfTrack->pt() / gsfTrack->ptError(), 5.046f, 3.119f);
            }
            const auto& closestCtfTrack = electrons.at(index_ele).closestCtfTrackRef();
            const bool has_closestCtfTrack = closestCtfTrack.isNonnull();
            if(has_closestCtfTrack){
                get(dnn::ele_has_closestCtfTrack) = has_closestCtfTrack;
                get(dnn::ele_closestCtfTrack_normalizedChi2) = getValueNorm(closestCtfTrack->normalizedChi2(), 2.411f, 6.98f);
                get(dnn::ele_closestCtfTrack_numberOfValidHits) = getValueNorm(closestCtfTrack->numberOfValidHits(), 15.16f, 5.26f);
            }
        }
        checkInputs(inputs, is_inner ? "egamma_inner_block" : "egamma_outer_block", dnn::NumberOfInputs);
    }

void DeepTauId::createHadronsBlockInputs ( const TauType &  tau, const reco::Vertex &  pv, double  rho, const pat::PackedCandidateCollection &  pfCands, const Cell &  cell_map, bool  is_inner  )

inlineprivate

Definition at line 1272 of file DeepTauId.cc.

References funct::abs(), particleFlow_cfi::dPhi, f, pat::Tau::flightLength(), objects.autophobj::float, edm::Ptr< T >::get(), reco::JetExtendedAssociation::getValue(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, pat::Tau::leadChargedHadrCand(), reco::LeafCandidate::polarP4(), reco::Vertex::position(), muonProducer_cfi::rho, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

    {
        namespace dnn = dnn_inputs_2017_v2::HadronBlockInputs;

        tensorflow::Tensor& inputs = *hadronsTensor_.at(is_inner);
        inputs.flat<float>().setZero();


        const auto& get = [&](int var_index) -> float& {
            return inputs.tensor<float,4>()(0, 0, 0, var_index);
        };

        const bool valid_chH = cell_map.count(CellObjectType::PfCand_chargedHadron);
        const bool valid_nH = cell_map.count(CellObjectType::PfCand_neutralHadron);

        if(!cell_map.empty()){
            get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
            get(dnn::tau_pt) =  getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
            get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
            get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
        }
        if(valid_chH){
            size_t index_chH = cell_map.at(CellObjectType::PfCand_chargedHadron);

            get(dnn::pfCand_chHad_valid) = valid_chH;
            get(dnn::pfCand_chHad_rel_pt) = getValueNorm(pfCands.at(index_chH).polarP4().pt() / tau.polarP4().pt(),
                is_inner ? 0.2564f : 0.0194f, is_inner ? 0.8607f : 0.1865f);
            get(dnn::pfCand_chHad_deta) = getValueLinear(pfCands.at(index_chH).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_chHad_dphi) = getValueLinear(dPhi(tau.polarP4(),pfCands.at(index_chH).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_chHad_leadChargedHadrCand) = getValue(&pfCands.at(index_chH) ==
                dynamic_cast<const pat::PackedCandidate*>(tau.leadChargedHadrCand().get()));
            get(dnn::pfCand_chHad_pvAssociationQuality) =
                getValueLinear<int>(pfCands.at(index_chH).pvAssociationQuality(), 0, 7, true);
            get(dnn::pfCand_chHad_fromPV) = getValueLinear<int>(pfCands.at(index_chH).fromPV(), 0, 3, true);
            get(dnn::pfCand_chHad_puppiWeight) = getValue(pfCands.at(index_chH).puppiWeight());
            get(dnn::pfCand_chHad_puppiWeightNoLep) = getValue(pfCands.at(index_chH).puppiWeightNoLep());
            get(dnn::pfCand_chHad_charge) =  getValue(pfCands.at(index_chH).charge());
            get(dnn::pfCand_chHad_lostInnerHits) = getValue<int>(pfCands.at(index_chH).lostInnerHits());
            get(dnn::pfCand_chHad_numberOfPixelHits) = getValueLinear(pfCands.at(index_chH).numberOfPixelHits(), 0, 12, true);
            get(dnn::pfCand_chHad_vertex_dx) = getValueNorm(pfCands.at(index_chH).vertex().x() - pv.position().x(), 0.0005f, 1.735f);
            get(dnn::pfCand_chHad_vertex_dy) = getValueNorm(pfCands.at(index_chH).vertex().y() - pv.position().y(), -0.0008f, 1.752f);
            get(dnn::pfCand_chHad_vertex_dz) = getValueNorm(pfCands.at(index_chH).vertex().z() - pv.position().z(), -0.0201f, 8.333f);
            get(dnn::pfCand_chHad_vertex_dx_tauFL) = getValueNorm(pfCands.at(index_chH).vertex().x() - pv.position().x()
                - tau.flightLength().x(), -0.0014f, 1.93f);
            get(dnn::pfCand_chHad_vertex_dy_tauFL) = getValueNorm(pfCands.at(index_chH).vertex().y() - pv.position().y()
                - tau.flightLength().y(), 0.0022f, 1.948f);
            get(dnn::pfCand_chHad_vertex_dz_tauFL) = getValueNorm(pfCands.at(index_chH).vertex().z() - pv.position().z()
                - tau.flightLength().z(), -0.0138f, 8.622f);

            const bool hasTrackDetails = pfCands.at(index_chH).hasTrackDetails();
            if(hasTrackDetails){
                get(dnn::pfCand_chHad_hasTrackDetails) = hasTrackDetails;
                get(dnn::pfCand_chHad_dxy) = getValueNorm(pfCands.at(index_chH).dxy(), -0.012f, 2.386f);
                get(dnn::pfCand_chHad_dxy_sig) = getValueNorm(std::abs(pfCands.at(index_chH).dxy()) /
                    pfCands.at(index_chH).dxyError(), 6.417f, 36.28f);
                get(dnn::pfCand_chHad_dz) =  getValueNorm(pfCands.at(index_chH).dz(), -0.0246f, 7.618f);
                get(dnn::pfCand_chHad_dz_sig) =  getValueNorm(std::abs(pfCands.at(index_chH).dz()) /
                    pfCands.at(index_chH).dzError(), 301.3f, 491.1f);
                get(dnn::pfCand_chHad_track_chi2_ndof) = pfCands.at(index_chH).pseudoTrack().ndof() > 0 ?
                    getValueNorm(pfCands.at(index_chH).pseudoTrack().chi2() /
                    pfCands.at(index_chH).pseudoTrack().ndof(), 0.7876f, 3.694f) : 0;
                get(dnn::pfCand_chHad_track_ndof) = pfCands.at(index_chH).pseudoTrack().ndof() > 0 ?
                    getValueNorm(pfCands.at(index_chH).pseudoTrack().ndof(), 13.92f, 6.581f) : 0;
            }
        float hcal_fraction = 0.;
        if(pfCands.at(index_chH).pdgId() == 1 || pfCands.at(index_chH).pdgId() == 130) {
          hcal_fraction = pfCands.at(index_chH).hcalFraction();
        } else if(pfCands.at(index_chH).isIsolatedChargedHadron()) {
          hcal_fraction = pfCands.at(index_chH).rawHcalFraction();
        }
            get(dnn::pfCand_chHad_hcalFraction) = getValue(hcal_fraction);
            get(dnn::pfCand_chHad_rawCaloFraction) = getValueLinear(pfCands.at(index_chH).rawCaloFraction(), 0.f, 2.6f, true);
        }
        if(valid_nH){
            size_t index_nH = cell_map.at(CellObjectType::PfCand_neutralHadron);

            get(dnn::pfCand_nHad_valid) = valid_nH;
            get(dnn::pfCand_nHad_rel_pt) = getValueNorm(pfCands.at(index_nH).polarP4().pt() / tau.polarP4().pt(),
                is_inner ? 0.3163f : 0.0502f, is_inner ? 0.2769f : 0.4266f);
            get(dnn::pfCand_nHad_deta) = getValueLinear(pfCands.at(index_nH).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_nHad_dphi) = getValueLinear(dPhi(tau.polarP4(),pfCands.at(index_nH).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_nHad_puppiWeight) = getValue(pfCands.at(index_nH).puppiWeight());
            get(dnn::pfCand_nHad_puppiWeightNoLep) = getValue(pfCands.at(index_nH).puppiWeightNoLep());
        float hcal_fraction = 0.;
        if(pfCands.at(index_nH).pdgId() == 1 || pfCands.at(index_nH).pdgId() == 130) {
          hcal_fraction = pfCands.at(index_nH).hcalFraction();
        } else if(pfCands.at(index_nH).isIsolatedChargedHadron()) {
          hcal_fraction = pfCands.at(index_nH).rawHcalFraction();
        }
            get(dnn::pfCand_nHad_hcalFraction) = getValue(hcal_fraction);
        }
        checkInputs(inputs, is_inner ? "hadron_inner_block" : "hadron_outer_block", dnn::NumberOfInputs);
    }

template<typename dnn >

tensorflow::Tensor DeepTauId::createInputsV1 ( const TauType &  tau, const ElectronCollection &  electrons, const MuonCollection &  muons  ) const

inlineprivate

Definition at line 1373 of file DeepTauId.cc.

References funct::abs(), tauProducer_cfi::chargedIsoPtSum, constexpr, taus_cff::decayMode, pat::Tau::decayMode(), particleFlow_cfi::dEta, particleFlow_cfi::dPhi, PVValHelper::dxy, pat::Tau::dxy(), pat::Tau::dxy_Sig(), PVValHelper::dz, pat::Tau::ecalEnergyLeadChargedHadrCand(), pat::Tau::emFraction_MVA(), reco::tau::eratio(), PVValHelper::eta, pat::Tau::etaAtEcalEntranceLeadChargedCand(), Exception, pat::Tau::flightLength(), pat::Tau::flightLengthSig(), edm::Ptr< T >::get(), pat::Tau::hasSecondaryVertex(), pat::Tau::hcalEnergyLeadChargedHadrCand(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, pat::Tau::ip3d(), electrons_cff::ip3d, pat::Tau::ip3d_Sig(), edm::Ptr< T >::isNonnull(), pat::Tau::leadChargedHadrCand(), pat::Tau::leadingTrackNormChi2(), pat::Tau::leadPFChargedHadrCand(), ResonanceBuilder::mass, reco::tau::n_photons_total(), tauProducer_cfi::neutralIsoPtSum, tauProducer_cfi::neutralIsoPtSumWeight, reco::LeafCandidate::p4(), tauProducer_cfi::photonPtSumOutsideSignalCone, EnergyCorrector::pt, reco::tau::pt_weighted_deta_strip(), reco::tau::pt_weighted_dphi_strip(), reco::tau::pt_weighted_dr_iso(), reco::tau::pt_weighted_dr_signal(), pat::Tau::ptLeadChargedCand(), tauProducer_cfi::puCorrPtSum, metsig::tau, and pat::Tau::tauID().

    {
        static constexpr bool check_all_set = false;
        static constexpr float default_value_for_set_check = -42;

        tensorflow::Tensor inputs(tensorflow::DT_FLOAT, { 1, dnn_inputs_2017v1::NumberOfInputs});
        const auto& get = [&](int var_index) -> float& { return inputs.matrix<float>()(0, var_index); };
        auto leadChargedHadrCand = dynamic_cast<const pat::PackedCandidate*>(tau.leadChargedHadrCand().get());

        if(check_all_set) {
            for(int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
                get(var_index) = default_value_for_set_check;
            }
        }

        get(dnn::pt) = tau.p4().pt();
        get(dnn::eta) = tau.p4().eta();
        get(dnn::mass) = tau.p4().mass();
        get(dnn::decayMode) = tau.decayMode();
        get(dnn::chargedIsoPtSum) = tau.tauID("chargedIsoPtSum");
        get(dnn::neutralIsoPtSum) = tau.tauID("neutralIsoPtSum");
        get(dnn::neutralIsoPtSumWeight) = tau.tauID("neutralIsoPtSumWeight");
        get(dnn::photonPtSumOutsideSignalCone) = tau.tauID("photonPtSumOutsideSignalCone");
        get(dnn::puCorrPtSum) = tau.tauID("puCorrPtSum");
        get(dnn::dxy) = tau.dxy();
        get(dnn::dxy_sig) = tau.dxy_Sig();
        get(dnn::dz) = leadChargedHadrCand ? leadChargedHadrCand->dz() : default_value;
        get(dnn::ip3d) = tau.ip3d();
        get(dnn::ip3d_sig) = tau.ip3d_Sig();
        get(dnn::hasSecondaryVertex) = tau.hasSecondaryVertex();
        get(dnn::flightLength_r) = tau.flightLength().R();
        get(dnn::flightLength_dEta) = dEta(tau.flightLength(), tau.p4());
        get(dnn::flightLength_dPhi) = dPhi(tau.flightLength(), tau.p4());
        get(dnn::flightLength_sig) = tau.flightLengthSig();
        get(dnn::leadChargedHadrCand_pt) = leadChargedHadrCand ? leadChargedHadrCand->p4().Pt() : default_value;
        get(dnn::leadChargedHadrCand_dEta) = leadChargedHadrCand
                ? dEta(leadChargedHadrCand->p4(), tau.p4()) : default_value;
        get(dnn::leadChargedHadrCand_dPhi) = leadChargedHadrCand
                ? dPhi(leadChargedHadrCand->p4(), tau.p4()) : default_value;
        get(dnn::leadChargedHadrCand_mass) = leadChargedHadrCand
                ? leadChargedHadrCand->p4().mass() : default_value;
        get(dnn::pt_weighted_deta_strip) = reco::tau::pt_weighted_deta_strip(tau, tau.decayMode());
        get(dnn::pt_weighted_dphi_strip) = reco::tau::pt_weighted_dphi_strip(tau, tau.decayMode());
        get(dnn::pt_weighted_dr_signal) = reco::tau::pt_weighted_dr_signal(tau, tau.decayMode());
        get(dnn::pt_weighted_dr_iso) = reco::tau::pt_weighted_dr_iso(tau, tau.decayMode());
        get(dnn::leadingTrackNormChi2) = tau.leadingTrackNormChi2();
        get(dnn::e_ratio) = reco::tau::eratio(tau);
        get(dnn::gj_angle_diff) = calculateGottfriedJacksonAngleDifference(tau);
        get(dnn::n_photons) = reco::tau::n_photons_total(tau);
        get(dnn::emFraction) = tau.emFraction_MVA();
        get(dnn::has_gsf_track) = leadChargedHadrCand && std::abs(leadChargedHadrCand->pdgId()) == 11;
        get(dnn::inside_ecal_crack) = isInEcalCrack(tau.p4().Eta());
        auto gsf_ele = findMatchedElectron(tau, electrons, 0.3);
        get(dnn::gsf_ele_matched) = gsf_ele != nullptr;
        get(dnn::gsf_ele_pt) = gsf_ele != nullptr ? gsf_ele->p4().Pt() : default_value;
        get(dnn::gsf_ele_dEta) = gsf_ele != nullptr ? dEta(gsf_ele->p4(), tau.p4()) : default_value;
        get(dnn::gsf_ele_dPhi) = gsf_ele != nullptr ? dPhi(gsf_ele->p4(), tau.p4()) : default_value;
        get(dnn::gsf_ele_mass) = gsf_ele != nullptr ? gsf_ele->p4().mass() : default_value;
        calculateElectronClusterVars(gsf_ele, get(dnn::gsf_ele_Ee), get(dnn::gsf_ele_Egamma));
        get(dnn::gsf_ele_Pin) = gsf_ele != nullptr ? gsf_ele->trackMomentumAtVtx().R() : default_value;
        get(dnn::gsf_ele_Pout) = gsf_ele != nullptr ? gsf_ele->trackMomentumOut().R() : default_value;
        get(dnn::gsf_ele_EtotOverPin) = get(dnn::gsf_ele_Pin) > 0
                ? (get(dnn::gsf_ele_Ee) + get(dnn::gsf_ele_Egamma)) / get(dnn::gsf_ele_Pin)
                : default_value;
        get(dnn::gsf_ele_Eecal) = gsf_ele != nullptr ? gsf_ele->ecalEnergy() : default_value;
        get(dnn::gsf_ele_dEta_SeedClusterTrackAtCalo) = gsf_ele != nullptr
                ? gsf_ele->deltaEtaSeedClusterTrackAtCalo() : default_value;
        get(dnn::gsf_ele_dPhi_SeedClusterTrackAtCalo) = gsf_ele != nullptr
                ? gsf_ele->deltaPhiSeedClusterTrackAtCalo() : default_value;
        get(dnn::gsf_ele_mvaIn_sigmaEtaEta) = gsf_ele != nullptr
                ? gsf_ele->mvaInput().sigmaEtaEta : default_value;
        get(dnn::gsf_ele_mvaIn_hadEnergy) = gsf_ele != nullptr ? gsf_ele->mvaInput().hadEnergy : default_value;
        get(dnn::gsf_ele_mvaIn_deltaEta) = gsf_ele != nullptr ? gsf_ele->mvaInput().deltaEta : default_value;

        get(dnn::gsf_ele_Chi2NormGSF) = default_value;
        get(dnn::gsf_ele_GSFNumHits) = default_value;
        get(dnn::gsf_ele_GSFTrackResol) = default_value;
        get(dnn::gsf_ele_GSFTracklnPt) = default_value;
        if(gsf_ele != nullptr && gsf_ele->gsfTrack().isNonnull()) {
            get(dnn::gsf_ele_Chi2NormGSF) = gsf_ele->gsfTrack()->normalizedChi2();
            get(dnn::gsf_ele_GSFNumHits) = gsf_ele->gsfTrack()->numberOfValidHits();
            if(gsf_ele->gsfTrack()->pt() > 0) {
                get(dnn::gsf_ele_GSFTrackResol) = gsf_ele->gsfTrack()->ptError() / gsf_ele->gsfTrack()->pt();
                get(dnn::gsf_ele_GSFTracklnPt) = std::log10(gsf_ele->gsfTrack()->pt());
            }
        }

        get(dnn::gsf_ele_Chi2NormKF) = default_value;
        get(dnn::gsf_ele_KFNumHits) = default_value;
        if(gsf_ele != nullptr && gsf_ele->closestCtfTrackRef().isNonnull()) {
            get(dnn::gsf_ele_Chi2NormKF) = gsf_ele->closestCtfTrackRef()->normalizedChi2();
            get(dnn::gsf_ele_KFNumHits) = gsf_ele->closestCtfTrackRef()->numberOfValidHits();
        }
        get(dnn::leadChargedCand_etaAtEcalEntrance) = tau.etaAtEcalEntranceLeadChargedCand();
        get(dnn::leadChargedCand_pt) = tau.ptLeadChargedCand();

        get(dnn::leadChargedHadrCand_HoP) = default_value;
        get(dnn::leadChargedHadrCand_EoP) = default_value;
        if(tau.leadChargedHadrCand()->pt() > 0) {
            get(dnn::leadChargedHadrCand_HoP) = tau.hcalEnergyLeadChargedHadrCand()
                                                    / tau.leadChargedHadrCand()->pt();
            get(dnn::leadChargedHadrCand_EoP) = tau.ecalEnergyLeadChargedHadrCand()
                                                    / tau.leadChargedHadrCand()->pt();
        }

        MuonHitMatchV1 muon_hit_match;
        if(tau.leadPFChargedHadrCand().isNonnull() && tau.leadPFChargedHadrCand()->muonRef().isNonnull())
            muon_hit_match.addMatchedMuon(*tau.leadPFChargedHadrCand()->muonRef(), tau);

        auto matched_muons = muon_hit_match.findMatchedMuons(tau, muons, 0.3, 5);
        for(auto muon : matched_muons)
            muon_hit_match.addMatchedMuon(*muon, tau);
        muon_hit_match.fillTensor<dnn>(get, tau, default_value);

        LorentzVectorXYZ signalChargedHadrCands_sumIn, signalChargedHadrCands_sumOut;
        processSignalPFComponents(tau, tau.signalChargedHadrCands(),
                                  signalChargedHadrCands_sumIn, signalChargedHadrCands_sumOut,
                                  get(dnn::signalChargedHadrCands_sum_innerSigCone_pt),
                                  get(dnn::signalChargedHadrCands_sum_innerSigCone_dEta),
                                  get(dnn::signalChargedHadrCands_sum_innerSigCone_dPhi),
                                  get(dnn::signalChargedHadrCands_sum_innerSigCone_mass),
                                  get(dnn::signalChargedHadrCands_sum_outerSigCone_pt),
                                  get(dnn::signalChargedHadrCands_sum_outerSigCone_dEta),
                                  get(dnn::signalChargedHadrCands_sum_outerSigCone_dPhi),
                                  get(dnn::signalChargedHadrCands_sum_outerSigCone_mass),
                                  get(dnn::signalChargedHadrCands_nTotal_innerSigCone),
                                  get(dnn::signalChargedHadrCands_nTotal_outerSigCone));

        LorentzVectorXYZ signalNeutrHadrCands_sumIn, signalNeutrHadrCands_sumOut;
        processSignalPFComponents(tau, tau.signalNeutrHadrCands(),
                                  signalNeutrHadrCands_sumIn, signalNeutrHadrCands_sumOut,
                                  get(dnn::signalNeutrHadrCands_sum_innerSigCone_pt),
                                  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dEta),
                                  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dPhi),
                                  get(dnn::signalNeutrHadrCands_sum_innerSigCone_mass),
                                  get(dnn::signalNeutrHadrCands_sum_outerSigCone_pt),
                                  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dEta),
                                  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dPhi),
                                  get(dnn::signalNeutrHadrCands_sum_outerSigCone_mass),
                                  get(dnn::signalNeutrHadrCands_nTotal_innerSigCone),
                                  get(dnn::signalNeutrHadrCands_nTotal_outerSigCone));


        LorentzVectorXYZ signalGammaCands_sumIn, signalGammaCands_sumOut;
        processSignalPFComponents(tau, tau.signalGammaCands(),
                                  signalGammaCands_sumIn, signalGammaCands_sumOut,
                                  get(dnn::signalGammaCands_sum_innerSigCone_pt),
                                  get(dnn::signalGammaCands_sum_innerSigCone_dEta),
                                  get(dnn::signalGammaCands_sum_innerSigCone_dPhi),
                                  get(dnn::signalGammaCands_sum_innerSigCone_mass),
                                  get(dnn::signalGammaCands_sum_outerSigCone_pt),
                                  get(dnn::signalGammaCands_sum_outerSigCone_dEta),
                                  get(dnn::signalGammaCands_sum_outerSigCone_dPhi),
                                  get(dnn::signalGammaCands_sum_outerSigCone_mass),
                                  get(dnn::signalGammaCands_nTotal_innerSigCone),
                                  get(dnn::signalGammaCands_nTotal_outerSigCone));

        LorentzVectorXYZ isolationChargedHadrCands_sum;
        processIsolationPFComponents(tau, tau.isolationChargedHadrCands(), isolationChargedHadrCands_sum,
                                     get(dnn::isolationChargedHadrCands_sum_pt),
                                     get(dnn::isolationChargedHadrCands_sum_dEta),
                                     get(dnn::isolationChargedHadrCands_sum_dPhi),
                                     get(dnn::isolationChargedHadrCands_sum_mass),
                                     get(dnn::isolationChargedHadrCands_nTotal));

        LorentzVectorXYZ isolationNeutrHadrCands_sum;
        processIsolationPFComponents(tau, tau.isolationNeutrHadrCands(), isolationNeutrHadrCands_sum,
                                     get(dnn::isolationNeutrHadrCands_sum_pt),
                                     get(dnn::isolationNeutrHadrCands_sum_dEta),
                                     get(dnn::isolationNeutrHadrCands_sum_dPhi),
                                     get(dnn::isolationNeutrHadrCands_sum_mass),
                                     get(dnn::isolationNeutrHadrCands_nTotal));

        LorentzVectorXYZ isolationGammaCands_sum;
        processIsolationPFComponents(tau, tau.isolationGammaCands(), isolationGammaCands_sum,
                                     get(dnn::isolationGammaCands_sum_pt),
                                     get(dnn::isolationGammaCands_sum_dEta),
                                     get(dnn::isolationGammaCands_sum_dPhi),
                                     get(dnn::isolationGammaCands_sum_mass),
                                     get(dnn::isolationGammaCands_nTotal));

        get(dnn::tau_visMass_innerSigCone) = (signalGammaCands_sumIn + signalChargedHadrCands_sumIn).mass();

        if(check_all_set) {
            for(int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
                if(get(var_index) == default_value_for_set_check)
                    throw cms::Exception("DeepTauId: variable with index = ") << var_index << " is not set.";
            }
        }

        return inputs;
    }

void DeepTauId::createMuonBlockInputs ( const TauType &  tau, const reco::Vertex &  pv, double  rho, const pat::MuonCollection &  muons, const pat::PackedCandidateCollection &  pfCands, const Cell &  cell_map, bool  is_inner  )

inlineprivate

Definition at line 1144 of file DeepTauId.cc.

References funct::abs(), MuonSubdetId::CSC, particleFlow_cfi::dPhi, MuonSubdetId::DT, f, pat::Tau::flightLength(), objects.autophobj::float, reco::JetExtendedAssociation::getValue(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, nanoDQM_cfi::Muon, reco::LeafCandidate::polarP4(), reco::Vertex::position(), pat::Muon::PV2D, muonProducer_cfi::rho, MuonSubdetId::RPC, relativeConstraints::station, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

    {
        namespace dnn = dnn_inputs_2017_v2::MuonBlockInputs;

        tensorflow::Tensor& inputs = *muonTensor_.at(is_inner);
        inputs.flat<float>().setZero();

        const auto& get = [&](int var_index) -> float& {
            return inputs.tensor<float,4>()(0, 0, 0, var_index);
        };

        const bool valid_index_pf_muon = cell_map.count(CellObjectType::PfCand_muon);
        const bool valid_index_muon = cell_map.count(CellObjectType::Muon);

        if(!cell_map.empty()){
            get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
            get(dnn::tau_pt) =  getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
            get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
            get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
        }
        if(valid_index_pf_muon){
            size_t index_pf_muon = cell_map.at(CellObjectType::PfCand_muon);

            get(dnn::pfCand_muon_valid) = valid_index_pf_muon;
            get(dnn::pfCand_muon_rel_pt) = getValueNorm(pfCands.at(index_pf_muon).polarP4().pt() / tau.polarP4().pt(),
                is_inner ?  0.9509f : 0.0861f, is_inner ? 0.4294f : 0.4065f);
            get(dnn::pfCand_muon_deta) = getValueLinear(pfCands.at(index_pf_muon).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_muon_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_muon).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::pfCand_muon_pvAssociationQuality) = getValueLinear<int>(pfCands.at(index_pf_muon).pvAssociationQuality(), 0, 7, true);
            get(dnn::pfCand_muon_fromPV) = getValueLinear<int>(pfCands.at(index_pf_muon).fromPV(), 0, 3, true);
            get(dnn::pfCand_muon_puppiWeight) = getValue(pfCands.at(index_pf_muon).puppiWeight());
            get(dnn::pfCand_muon_charge) = getValue(pfCands.at(index_pf_muon).charge());
            get(dnn::pfCand_muon_lostInnerHits) = getValue<int>(pfCands.at(index_pf_muon).lostInnerHits());
            get(dnn::pfCand_muon_numberOfPixelHits) = getValueLinear(pfCands.at(index_pf_muon).numberOfPixelHits(), 0, 11, true);
            get(dnn::pfCand_muon_vertex_dx) = getValueNorm(pfCands.at(index_pf_muon).vertex().x() - pv.position().x(), -0.0007f, 0.6869f);
            get(dnn::pfCand_muon_vertex_dy) = getValueNorm(pfCands.at(index_pf_muon).vertex().y() - pv.position().y(), 0.0001f, 0.6784f);
            get(dnn::pfCand_muon_vertex_dz) = getValueNorm(pfCands.at(index_pf_muon).vertex().z() - pv.position().z(), -0.0117f, 4.097f);
            get(dnn::pfCand_muon_vertex_dx_tauFL) = getValueNorm(pfCands.at(index_pf_muon).vertex().x() -
                pv.position().x() - tau.flightLength().x(), -0.0001f, 0.8642f);
            get(dnn::pfCand_muon_vertex_dy_tauFL) = getValueNorm(pfCands.at(index_pf_muon).vertex().y() -
                pv.position().y() - tau.flightLength().y(), 0.0004f, 0.8561f);
            get(dnn::pfCand_muon_vertex_dz_tauFL) = getValueNorm(pfCands.at(index_pf_muon).vertex().z() -
                pv.position().z() - tau.flightLength().z(), -0.0118f, 4.405f);

            const bool hasTrackDetails = pfCands.at(index_pf_muon).hasTrackDetails();
            if(hasTrackDetails){
                get(dnn::pfCand_muon_hasTrackDetails) = hasTrackDetails;
                get(dnn::pfCand_muon_dxy) = getValueNorm(pfCands.at(index_pf_muon).dxy(), -0.0045f, 0.9655f);
                get(dnn::pfCand_muon_dxy_sig) = getValueNorm(std::abs(pfCands.at(index_pf_muon).dxy()) /
                    pfCands.at(index_pf_muon).dxyError(), 4.575f, 42.36f);
                get(dnn::pfCand_muon_dz) =  getValueNorm(pfCands.at(index_pf_muon).dz(), -0.0117f, 4.097f);
                get(dnn::pfCand_muon_dz_sig) =  getValueNorm(std::abs(pfCands.at(index_pf_muon).dz()) /
                    pfCands.at(index_pf_muon).dzError(), 80.37f, 343.3f);
                get(dnn::pfCand_muon_track_chi2_ndof) =  getValueNorm(pfCands.at(index_pf_muon).pseudoTrack().chi2() /
                    pfCands.at(index_pf_muon).pseudoTrack().ndof(), 0.69f, 1.711f);
                get(dnn::pfCand_muon_track_ndof) =  getValueNorm(pfCands.at(index_pf_muon).pseudoTrack().ndof(), 17.5f, 5.11f);
            }
        }
        if(valid_index_muon){
            size_t index_muon = cell_map.at(CellObjectType::Muon);

            get(dnn::muon_valid) = valid_index_muon;
            get(dnn::muon_rel_pt) = getValueNorm(muons.at(index_muon).polarP4().pt() / tau.polarP4().pt(),
                is_inner ?  0.7966f : 0.2678f, is_inner ? 3.402f : 3.592f);
            get(dnn::muon_deta) = getValueLinear(muons.at(index_muon).polarP4().eta() - tau.polarP4().eta(),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::muon_dphi) = getValueLinear(dPhi(tau.polarP4(), muons.at(index_muon).polarP4()),
                is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
            get(dnn::muon_dxy) = getValueNorm(muons.at(index_muon).dB(pat::Muon::PV2D), 0.0019f, 1.039f);
            get(dnn::muon_dxy_sig) = getValueNorm(std::abs(muons.at(index_muon).dB(pat::Muon::PV2D)) /
                muons.at(index_muon).edB(pat::Muon::PV2D), 8.98f, 71.17f);

            const bool normalizedChi2_valid = muons.at(index_muon).globalTrack().isNonnull() && muons.at(index_muon).normChi2() >= 0;
            if(normalizedChi2_valid){
                get(dnn::muon_normalizedChi2_valid) = normalizedChi2_valid;
                get(dnn::muon_normalizedChi2) = getValueNorm(muons.at(index_muon).normChi2(), 21.52f, 265.8f);
                if(muons.at(index_muon).innerTrack().isNonnull())
                    get(dnn::muon_numberOfValidHits) = getValueNorm(muons.at(index_muon).numberOfValidHits(), 21.84f, 10.59f);
            }
            get(dnn::muon_segmentCompatibility) = getValue(muons.at(index_muon).segmentCompatibility());
            get(dnn::muon_caloCompatibility) = getValue(muons.at(index_muon).caloCompatibility());

            const bool pfEcalEnergy_valid = muons.at(index_muon).pfEcalEnergy() >= 0;
            if(pfEcalEnergy_valid){
                get(dnn::muon_pfEcalEnergy_valid) = pfEcalEnergy_valid;
                get(dnn::muon_rel_pfEcalEnergy) = getValueNorm(muons.at(index_muon).pfEcalEnergy() /
                    muons.at(index_muon).polarP4().pt(), 0.2273f, 0.4865f);
            }

            MuonHitMatchV2 hit_match(muons.at(index_muon));
            static const std::map<int, std::pair<int, int>> muonMatchHitVars = {
                { MuonSubdetId::DT, { dnn::muon_n_matches_DT_1, dnn::muon_n_hits_DT_1 } },
                { MuonSubdetId::CSC, { dnn::muon_n_matches_CSC_1, dnn::muon_n_hits_CSC_1 } },
                { MuonSubdetId::RPC, { dnn::muon_n_matches_RPC_1, dnn::muon_n_hits_RPC_1 } }
            };

            static const std::map<int, std::vector<float>> muonMatchVarLimits = {
                { MuonSubdetId::DT, { 2, 2, 2, 2 } },
                { MuonSubdetId::CSC, { 6, 2, 2, 2 } },
                { MuonSubdetId::RPC, { 7, 6, 4, 4 } }
            };

            static const std::map<int, std::vector<float>> muonHitVarLimits = {
                { MuonSubdetId::DT, { 12, 12, 12, 8 } },
                { MuonSubdetId::CSC, { 24, 12, 12, 12 } },
                { MuonSubdetId::RPC, { 4, 4, 2, 2 } }
            };

            for(int subdet : hit_match.MuonHitMatchV2::consideredSubdets()) {
                const auto& matchHitVar = muonMatchHitVars.at(subdet);
                const auto& matchLimits = muonMatchVarLimits.at(subdet);
                const auto& hitLimits = muonHitVarLimits.at(subdet);
                for(int station = MuonHitMatchV2::first_station_id; station <= MuonHitMatchV2::last_station_id; ++station) {
                    const unsigned n_matches = hit_match.nMatches(subdet, station);
                    const unsigned n_hits = hit_match.nHits(subdet, station);
                    get(matchHitVar.first + station - 1) = getValueLinear(n_matches, 0, matchLimits.at(station - 1), true);
                    get(matchHitVar.second + station - 1) = getValueLinear(n_hits, 0, hitLimits.at(station - 1), true);
                }
            }
        }
        checkInputs(inputs, is_inner ? "muon_inner_block" : "muon_outer_block", dnn::NumberOfInputs);
    }

void DeepTauId::createTauBlockInputs ( const TauType &  tau, const reco::Vertex &  pv, double  rho  )

inlineprivate

Definition at line 879 of file DeepTauId.cc.

References funct::abs(), reco::LeafCandidate::charge(), tauProducer_cfi::chargedIsoPtSum, pat::Tau::decayMode(), pat::Tau::dxy(), pat::Tau::dxy_error(), pat::Tau::dxy_PCA(), pat::Tau::emFraction_MVA(), reco::tau::eratio(), pat::Tau::etaAtEcalEntranceLeadChargedCand(), f, pat::Tau::flightLength(), tauProducer_cfi::footprintCorrection, edm::Ptr< T >::get(), reco::JetExtendedAssociation::getValue(), PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, pat::Tau::ip3d(), pat::Tau::ip3d_error(), pat::Tau::leadChargedHadrCand(), pat::Tau::leadingTrackNormChi2(), reco::tau::n_photons_total(), tauProducer_cfi::neutralIsoPtSum, reco::LeafCandidate::p4(), tauProducer_cfi::photonPtSumOutsideSignalCone, pi, reco::LeafCandidate::polarP4(), reco::tau::pt_weighted_deta_strip(), reco::tau::pt_weighted_dphi_strip(), reco::tau::pt_weighted_dr_iso(), reco::tau::pt_weighted_dr_signal(), tauProducer_cfi::puCorrPtSum, muonProducer_cfi::rho, runTauDisplay::tau_eta, runTauDisplay::tau_mass, runTauDisplay::tau_phi, runTauDisplay::tau_pt, and pat::Tau::tauID().

    {
        namespace dnn = dnn_inputs_2017_v2::TauBlockInputs;

        tensorflow::Tensor& inputs = *tauBlockTensor_;
        inputs.flat<float>().setZero();

        const auto& get = [&](int var_index) -> float& { return inputs.matrix<float>()(0, var_index); };

        auto leadChargedHadrCand = dynamic_cast<const pat::PackedCandidate*>(tau.leadChargedHadrCand().get());

        get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
        get(dnn::tau_pt) =  getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
        get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
        get(dnn::tau_phi) = getValueLinear(tau.polarP4().phi(), -pi, pi, false);
        get(dnn::tau_mass) = getValueNorm(tau.polarP4().mass(), 0.6669f, 0.6553f);
        get(dnn::tau_E_over_pt) = getValueLinear(tau.p4().energy() / tau.p4().pt(), 1.f, 5.2f, true);
        get(dnn::tau_charge) = getValue(tau.charge());
        get(dnn::tau_n_charged_prongs) = getValueLinear(tau.decayMode() / 5 + 1, 1, 3, true);
        get(dnn::tau_n_neutral_prongs) = getValueLinear(tau.decayMode() % 5, 0, 2, true);
        get(dnn::chargedIsoPtSum) = getValueNorm(tau.tauID("chargedIsoPtSum"), 47.78f, 123.5f);
        get(dnn::chargedIsoPtSumdR03_over_dR05) = getValue(tau.tauID("chargedIsoPtSumdR03") / tau.tauID("chargedIsoPtSum"));
        get(dnn::footprintCorrection) = getValueNorm(tau.tauID("footprintCorrectiondR03"), 9.029f, 26.42f);
        get(dnn::neutralIsoPtSum) = getValueNorm(tau.tauID("neutralIsoPtSum"), 57.59f, 155.3f);
        get(dnn::neutralIsoPtSumWeight_over_neutralIsoPtSum) =
            getValue(tau.tauID("neutralIsoPtSumWeight") / tau.tauID("neutralIsoPtSum"));
        get(dnn::neutralIsoPtSumWeightdR03_over_neutralIsoPtSum) =
            getValue(tau.tauID("neutralIsoPtSumWeightdR03") / tau.tauID("neutralIsoPtSum"));
        get(dnn::neutralIsoPtSumdR03_over_dR05) = getValue(tau.tauID("neutralIsoPtSumdR03") / tau.tauID("neutralIsoPtSum"));
        get(dnn::photonPtSumOutsideSignalCone) = getValueNorm(tau.tauID("photonPtSumOutsideSignalConedR03"), 1.731f, 6.846f);
        get(dnn::puCorrPtSum) = getValueNorm(tau.tauID("puCorrPtSum"), 22.38f, 16.34f);
        get(dnn::tau_dxy_pca_x) = getValueNorm(tau.dxy_PCA().x(), -0.0241f, 0.0074f);
        get(dnn::tau_dxy_pca_y) = getValueNorm(tau.dxy_PCA().y(),0.0675f, 0.0128f);
        get(dnn::tau_dxy_pca_z) = getValueNorm(tau.dxy_PCA().z(), 0.7973f, 3.456f);

        const bool tau_dxy_valid = std::isnormal(tau.dxy()) && tau.dxy() > - 10 && std::isnormal(tau.dxy_error())
            && tau.dxy_error() > 0;
        if(tau_dxy_valid){
            get(dnn::tau_dxy_valid) = tau_dxy_valid;
            get(dnn::tau_dxy) = getValueNorm(tau.dxy(), 0.0018f, 0.0085f);
            get(dnn::tau_dxy_sig) = getValueNorm(std::abs(tau.dxy())/tau.dxy_error(), 2.26f, 4.191f);
        }
        const bool tau_ip3d_valid = std::isnormal(tau.ip3d()) && tau.ip3d() > - 10 && std::isnormal(tau.ip3d_error())
            && tau.ip3d_error() > 0;
        if(tau_ip3d_valid){
            get(dnn::tau_ip3d_valid) = tau_ip3d_valid;
            get(dnn::tau_ip3d) = getValueNorm(tau.ip3d(), 0.0026f, 0.0114f);
            get(dnn::tau_ip3d_sig) = getValueNorm(std::abs(tau.ip3d()) / tau.ip3d_error(), 2.928f, 4.466f);
        }
        if(leadChargedHadrCand){
            get(dnn::tau_dz) = getValueNorm(leadChargedHadrCand->dz(), 0.f, 0.0190f);
            const bool tau_dz_sig_valid = leadChargedHadrCand->hasTrackDetails() && std::isnormal(leadChargedHadrCand->dz())
                && std::isnormal(leadChargedHadrCand->dzError()) && leadChargedHadrCand->dzError() > 0;
            get(dnn::tau_dz_sig_valid) = tau_dz_sig_valid;
            const double dzError = leadChargedHadrCand->hasTrackDetails() ? leadChargedHadrCand->dzError() : default_value;
            get(dnn::tau_dz_sig) = getValueNorm(std::abs(leadChargedHadrCand->dz()) / dzError, 4.717f, 11.78f);
        }
        get(dnn::tau_flightLength_x) = getValueNorm(tau.flightLength().x(), -0.0003f, 0.7362f);
        get(dnn::tau_flightLength_y) = getValueNorm(tau.flightLength().y(), -0.0009f, 0.7354f);
        get(dnn::tau_flightLength_z) = getValueNorm(tau.flightLength().z(), -0.0022f, 1.993f);
        // get(dnn::tau_flightLength_sig) = getValueNorm(tau.flightLengthSig(), -4.78f, 9.573f);
        get(dnn::tau_flightLength_sig) = 0.55756444; //This value is set due to a bug in the training
        get(dnn::tau_pt_weighted_deta_strip) = getValueLinear(reco::tau::pt_weighted_deta_strip(tau, tau.decayMode()), 0, 1, true);

        get(dnn::tau_pt_weighted_dphi_strip) = getValueLinear(reco::tau::pt_weighted_dphi_strip(tau, tau.decayMode()), 0, 1, true);
        get(dnn::tau_pt_weighted_dr_signal) = getValueNorm(reco::tau::pt_weighted_dr_signal(tau, tau.decayMode()), 0.0052f, 0.01433f);
        get(dnn::tau_pt_weighted_dr_iso) = getValueLinear(reco::tau::pt_weighted_dr_iso(tau,tau.decayMode()), 0, 1, true);
        get(dnn::tau_leadingTrackNormChi2) = getValueNorm(tau.leadingTrackNormChi2(), 1.538f, 4.401f);
        const auto eratio = reco::tau::eratio(tau);
        const bool tau_e_ratio_valid = std::isnormal(eratio) && eratio > 0.f;
        get(dnn::tau_e_ratio_valid) = tau_e_ratio_valid;
        get(dnn::tau_e_ratio) = tau_e_ratio_valid ? getValueLinear(eratio, 0, 1, true) : 0.f;
        const double gj_angle_diff = calculateGottfriedJacksonAngleDifference(tau);
        const bool tau_gj_angle_diff_valid = (std::isnormal(gj_angle_diff) || gj_angle_diff == 0) && gj_angle_diff >= 0;
        get(dnn::tau_gj_angle_diff_valid) = tau_gj_angle_diff_valid;
        get(dnn::tau_gj_angle_diff) = tau_gj_angle_diff_valid ? getValueLinear(gj_angle_diff, 0, pi, true) : 0;
        get(dnn::tau_n_photons) = getValueNorm(reco::tau::n_photons_total(tau), 2.95f, 3.927f);
        get(dnn::tau_emFraction) = getValueLinear(tau.emFraction_MVA(), -1, 1, false);
        get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.p4().eta()));
        get(dnn::leadChargedCand_etaAtEcalEntrance_minus_tau_eta) =
            getValueNorm(tau.etaAtEcalEntranceLeadChargedCand() - tau.p4().eta(), 0.0042f, 0.0323f);

        checkInputs(inputs, "tau_block",  dnn::NumberOfInputs);
    }

static void DeepTauId::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

inlinestatic

Definition at line 567 of file DeepTauId.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and AlCaHLTBitMon_QueryRunRegistry::string.

    {
        edm::ParameterSetDescription desc;
        desc.add<edm::InputTag>("electrons", edm::InputTag("slimmedElectrons"));
        desc.add<edm::InputTag>("muons", edm::InputTag("slimmedMuons"));
        desc.add<edm::InputTag>("taus", edm::InputTag("slimmedTaus"));
        desc.add<edm::InputTag>("pfcands", edm::InputTag("packedPFCandidates"));
        desc.add<edm::InputTag>("vertices", edm::InputTag("offlineSlimmedPrimaryVertices"));
        desc.add<edm::InputTag>("rho", edm::InputTag("fixedGridRhoAll"));
        desc.add<std::vector<std::string>>("graph_file", {"RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6.pb"});
        desc.add<bool>("mem_mapped", false);
        desc.add<unsigned>("version", 2);
        desc.add<int>("debug_level", 0);

        edm::ParameterSetDescription descWP;
        descWP.add<std::string>("VVVLoose", "0");
        descWP.add<std::string>("VVLoose", "0");
        descWP.add<std::string>("VLoose", "0");
        descWP.add<std::string>("Loose", "0");
        descWP.add<std::string>("Medium", "0");
        descWP.add<std::string>("Tight", "0");
        descWP.add<std::string>("VTight", "0");
        descWP.add<std::string>("VVTight", "0");
        descWP.add<std::string>("VVVTight", "0");
        desc.add<edm::ParameterSetDescription>("VSeWP", descWP);
        desc.add<edm::ParameterSetDescription>("VSmuWP", descWP);
        desc.add<edm::ParameterSetDescription>("VSjetWP", descWP);
        descriptions.add("DeepTau", desc);
    }

template<typename Collection >

void DeepTauId::fillGrids ( const TauType &  tau, const Collection &  objects, CellGrid &  inner_grid, CellGrid &  outer_grid  )

inlineprivate

Definition at line 792 of file DeepTauId.cc.

References constexpr, reco::deltaPhi(), listHistos::grid, gen::n, hgcalPlots::obj, reco::LeafCandidate::polarP4(), and funct::pow().

    {
        static constexpr double outer_dR2 = 0.25;//0.5^2
        const double inner_radius = getInnerSignalConeRadius(tau.polarP4().pt());
        const double inner_dR2 = std::pow(inner_radius, 2);

        const auto addObject = [&](size_t n, double deta, double dphi, CellGrid& grid) {
            const auto& obj = objects.at(n);
            const CellObjectType obj_type = GetCellObjectType(obj);
            if(obj_type  == CellObjectType::Other) return;
            CellIndex cell_index;
            if(grid.tryGetCellIndex(deta, dphi, cell_index)) {
                Cell& cell = grid[cell_index];
                auto iter = cell.find(obj_type);
                if(iter != cell.end()) {
                     const auto& prev_obj = objects.at(iter->second);
                     if(obj.polarP4().pt() > prev_obj.polarP4().pt())
                        iter->second = n;
                } else {
                    cell[obj_type] = n;
                }
            }
        };

        for(size_t n = 0; n < objects.size(); ++n) {
            const auto& obj = objects.at(n);
            const double deta = obj.polarP4().eta() - tau.polarP4().eta();
            const double dphi = reco::deltaPhi(obj.polarP4().phi(), tau.polarP4().phi());
            const double dR2 = std::pow(deta, 2) + std::pow(dphi, 2);
            if(dR2 < inner_dR2)
                addObject(n, deta, dphi, inner_grid);
            if(dR2 < outer_dR2)
                addObject(n, deta, dphi, outer_grid);
        }
    }

static const pat::Electron* DeepTauId::findMatchedElectron ( const pat::Tau &  tau, const pat::ElectronCollection &  electrons, double  deltaR  )

inlinestaticprivate

Definition at line 1681 of file DeepTauId.cc.

References boostedElectronIsolation_cff::deltaR, reco::deltaR2(), reco::LeafCandidate::p4(), and reco::LeafCandidate::pt().

    {
        const double dR2 = deltaR*deltaR;
        const pat::Electron* matched_ele = nullptr;
        for(const auto& ele : electrons) {
            if(reco::deltaR2(tau.p4(), ele.p4()) < dR2 && (!matched_ele || matched_ele->pt() < ele.pt())) {
                matched_ele = &ele;
            }
        }
        return matched_ele;
    }

static double DeepTauId::getInnerSignalConeRadius ( double  pt )

inlinestaticprivate

Definition at line 1640 of file DeepTauId.cc.

References constexpr, SiStripPI::max, and cosmictrackSelector_cfi::min_pt.

    {
        static constexpr double min_pt = 30., min_radius = 0.05, cone_opening_coef = 3.;
        // This is equivalent of the original formula (std::max(std::min(0.1, 3.0/pt), 0.05)
        return std::max(cone_opening_coef / std::max(pt, min_pt), min_radius);
    }

static const OutputCollection& DeepTauId::GetOutputs ( )

inlinestatic

Definition at line 556 of file DeepTauId.cc.

References constexpr, and Output.

    {
        static constexpr size_t e_index = 0, mu_index = 1, tau_index = 2, jet_index = 3;
        static const OutputCollection outputs_ = {
            { "VSe", Output({tau_index}, {e_index, tau_index}) },
            { "VSmu", Output({tau_index}, {mu_index, tau_index}) },
            { "VSjet", Output({tau_index}, {jet_index, tau_index}) },
        };
        return outputs_;
    }

void DeepTauId::getPartialPredictions ( tensorflow::Tensor &  convTensor, bool  is_inner, int  eta_index, int  phi_index  )

inlineprivate

Definition at line 828 of file DeepTauId.cc.

References tensorflow::run().

    {
        std::vector<tensorflow::Tensor> pred_vector;
        if(is_inner) {
            tensorflow::run(&(cache_->getSession("inner")),
                { { "input_inner_egamma", *eGammaTensor_.at(is_inner) },
                  { "input_inner_muon", *muonTensor_.at(is_inner) },
                  { "input_inner_hadrons", *hadronsTensor_.at(is_inner) }, },
                { "inner_all_dropout_4/Identity" }, &pred_vector);
        } else {
            tensorflow::run(&(cache_->getSession("outer")),
                { { "input_outer_egamma", *eGammaTensor_.at(is_inner) },
                  { "input_outer_muon", *muonTensor_.at(is_inner) },
                  { "input_outer_hadrons", *hadronsTensor_.at(is_inner) }, },
                { "outer_all_dropout_4/Identity" }, &pred_vector);
        }
        setCellConvFeatures(convTensor, pred_vector.at(0), eta_index, phi_index);
    }

tensorflow::Tensor DeepTauId::getPredictions ( edm::Event &  event, const edm::EventSetup &  es, edm::Handle< TauCollection >  taus  )

inlineoverrideprivatevirtual

Implements deep_tau::DeepTauBase.

Definition at line 723 of file DeepTauId.cc.

References nano_cff::electrons, Exception, gen::k, extraflags_cff::muons, deep_tau::NumberOfOutputs, jets_cff::version, and electrons_cff::vertices.

    {
        edm::Handle<pat::ElectronCollection> electrons;
        event.getByToken(electrons_token_, electrons);

        edm::Handle<pat::MuonCollection> muons;
        event.getByToken(muons_token_, muons);

        edm::Handle<pat::PackedCandidateCollection> pfCands;
        event.getByToken(pfcandToken_, pfCands);

        edm::Handle<reco::VertexCollection> vertices;
        event.getByToken(vtxToken_, vertices);

        edm::Handle<double> rho;
        event.getByToken(rho_token_, rho);

        tensorflow::Tensor predictions(tensorflow::DT_FLOAT, { static_cast<int>(taus->size()),
                                       deep_tau::NumberOfOutputs});
        for(size_t tau_index = 0; tau_index < taus->size(); ++tau_index) {
            std::vector<tensorflow::Tensor> pred_vector;
            if(version == 1)
                getPredictionsV1(taus->at(tau_index), *electrons, *muons, pred_vector);
            else if(version == 2)
                getPredictionsV2(taus->at(tau_index), *electrons, *muons, *pfCands, vertices->at(0), *rho, pred_vector);
            else
                throw cms::Exception("DeepTauId") << "version " << version << " is not supported.";
            for(int k = 0; k < deep_tau::NumberOfOutputs; ++k) {
                const float pred = pred_vector[0].flat<float>()(k);
                if(!(pred >= 0 && pred <= 1))
                    throw cms::Exception("DeepTauId") << "invalid prediction = " << pred << " for tau_index = "
                                                      << tau_index << ", pred_index = " << k;
                predictions.matrix<float>()(tau_index, k) = pred;
            }
        }
        return predictions;
    }

void DeepTauId::getPredictionsV1 ( const TauType &  tau, const pat::ElectronCollection &  electrons, const pat::MuonCollection &  muons, std::vector< tensorflow::Tensor > &  pred_vector  )

inlineprivate

Definition at line 762 of file DeepTauId.cc.

References nano_cff::electrons, PatBasicFWLiteJetAnalyzer_Selector_cfg::inputs, extraflags_cff::muons, tensorflow::run(), and metsig::tau.

    {
        const tensorflow::Tensor& inputs = createInputsV1<dnn_inputs_2017v1>(tau, electrons, muons);
        tensorflow::run(&(cache_->getSession()), { { input_layer_, inputs } }, { output_layer_ }, &pred_vector);
    }

void DeepTauId::getPredictionsV2 ( const TauType &  tau, const pat::ElectronCollection &  electrons, const pat::MuonCollection &  muons, const pat::PackedCandidateCollection &  pfCands, const reco::Vertex &  pv, double  rho, std::vector< tensorflow::Tensor > &  pred_vector  )

inlineprivate

Definition at line 769 of file DeepTauId.cc.

References tensorflow::run().

    {
        CellGrid inner_grid(dnn_inputs_2017_v2::number_of_inner_cell, dnn_inputs_2017_v2::number_of_inner_cell,
                            0.02, 0.02);
        CellGrid outer_grid(dnn_inputs_2017_v2::number_of_outer_cell, dnn_inputs_2017_v2::number_of_outer_cell,
                            0.05, 0.05);
        fillGrids(tau, electrons, inner_grid, outer_grid);
        fillGrids(tau, muons, inner_grid, outer_grid);
        fillGrids(tau, pfCands, inner_grid, outer_grid);

        createTauBlockInputs(tau, pv, rho);
        createConvFeatures(tau, pv, rho, electrons, muons, pfCands, inner_grid, true);
        createConvFeatures(tau, pv, rho, electrons, muons, pfCands, outer_grid, false);

        tensorflow::run(&(cache_->getSession("core")),
            { { "input_tau", *tauBlockTensor_ },
              { "input_inner", *convTensor_.at(true)}, { "input_outer", *convTensor_.at(false) } },
            { "main_output/Softmax" }, &pred_vector);
    }

template<typename T >

static float DeepTauId::getValue ( T  value )

inlinestaticprivate

Definition at line 656 of file DeepTauId.cc.

References f, and relativeConstraints::value.

    {
        return std::isnormal(value) ? static_cast<float>(value) : 0.f;
    }

template<typename T >

static float DeepTauId::getValueLinear ( T  value, float  min_value, float  max_value, bool  positive  )

inlinestaticprivate

Definition at line 662 of file DeepTauId.cc.

References reco::JetExtendedAssociation::getValue(), and hcaldqm::quantity::min_value.

    {
        const float fixed_value = getValue(value);
        const float clamped_value = std::clamp(fixed_value, min_value, max_value);
        float transformed_value = (clamped_value - min_value) / (max_value - min_value);
        if(!positive)
            transformed_value = transformed_value * 2 - 1;
        return transformed_value;
    }

template<typename T >

static float DeepTauId::getValueNorm ( T  value, float  mean, float  sigma, float  n_sigmas_max = 5  )

inlinestaticprivate

Definition at line 673 of file DeepTauId.cc.

References reco::JetExtendedAssociation::getValue(), and SiStripPI::mean.

    {
        const float fixed_value = getValue(value);
        const float norm_value = (fixed_value - mean) / sigma;
        return std::clamp(norm_value, -n_sigmas_max, n_sigmas_max);
    }

static void DeepTauId::globalEndJob ( const deep_tau::DeepTauCache *  cache_ )

inlinestatic

Definition at line 648 of file DeepTauId.cc.

References deep_tau::DeepTauBase::globalEndJob().

    {
        return DeepTauBase::globalEndJob(cache_);
    }

static std::unique_ptr<deep_tau::DeepTauCache> DeepTauId::initializeGlobalCache ( const edm::ParameterSet &  cfg )

inlinestatic

Definition at line 643 of file DeepTauId.cc.

References deep_tau::DeepTauBase::initializeGlobalCache().

    {
        return DeepTauBase::initializeGlobalCache(cfg);
    }

static bool DeepTauId::isInEcalCrack ( double  eta )

inlinestaticprivate

Definition at line 1675 of file DeepTauId.cc.

References funct::abs().

    {
        const double abs_eta = std::abs(eta);
        return abs_eta > 1.46 && abs_eta < 1.558;
    }

template<typename CandidateCollection >

static void DeepTauId::processIsolationPFComponents ( const pat::Tau &  tau, const CandidateCollection &  candidates, LorentzVectorXYZ &  p4, float &  pt, float &  d_eta, float &  d_phi, float &  m, float &  n  )

inlinestaticprivate

Definition at line 1622 of file DeepTauId.cc.

References particleFlow_cfi::dEta, particleFlow_cfi::dPhi, gen::n, and reco::LeafCandidate::p4().

    {
        p4 = LorentzVectorXYZ(0, 0, 0, 0);
        n = 0;

        for(const auto& cand : candidates) {
            p4 += cand->p4();
            ++n;
        }

        pt = n != 0 ? p4.Pt() : default_value;
        d_eta = n != 0 ? dEta(p4, tau.p4()) : default_value;
        d_phi = n != 0 ? dPhi(p4, tau.p4()) : default_value;
        m = n != 0 ? p4.mass() : default_value;
    }

template<typename CandidateCollection >

static void DeepTauId::processSignalPFComponents ( const pat::Tau &  tau, const CandidateCollection &  candidates, LorentzVectorXYZ &  p4_inner, LorentzVectorXYZ &  p4_outer, float &  pt_inner, float &  dEta_inner, float &  dPhi_inner, float &  m_inner, float &  pt_outer, float &  dEta_outer, float &  dPhi_outer, float &  m_outer, float &  n_inner, float &  n_outer  )

inlinestaticprivate

Definition at line 1586 of file DeepTauId.cc.

References reco::deltaR(), particleFlow_cfi::dEta, particleFlow_cfi::dPhi, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, pat::Tau::leadChargedHadrCand(), reco::LeafCandidate::p4(), and reco::LeafCandidate::pt().

    {
        p4_inner = LorentzVectorXYZ(0, 0, 0, 0);
        p4_outer = LorentzVectorXYZ(0, 0, 0, 0);
        n_inner = 0;
        n_outer = 0;

        const double innerSigCone_radius = getInnerSignalConeRadius(tau.pt());
        for(const auto& cand : candidates) {
            const double dR = reco::deltaR(cand->p4(), tau.leadChargedHadrCand()->p4());
            const bool isInside_innerSigCone = dR < innerSigCone_radius;
            if(isInside_innerSigCone) {
                p4_inner += cand->p4();
                ++n_inner;
            } else {
                p4_outer += cand->p4();
                ++n_outer;
            }
        }

        pt_inner = n_inner != 0 ? p4_inner.Pt() : default_value;
        dEta_inner = n_inner != 0 ? dEta(p4_inner, tau.p4()) : default_value;
        dPhi_inner = n_inner != 0 ? dPhi(p4_inner, tau.p4()) : default_value;
        m_inner = n_inner != 0 ? p4_inner.mass() : default_value;

        pt_outer = n_outer != 0 ? p4_outer.Pt() : default_value;
        dEta_outer = n_outer != 0 ? dEta(p4_outer, tau.p4()) : default_value;
        dPhi_outer = n_outer != 0 ? dPhi(p4_outer, tau.p4()) : default_value;
        m_outer = n_outer != 0 ? p4_outer.mass() : default_value;
    }

void DeepTauId::setCellConvFeatures ( tensorflow::Tensor &  convTensor, const tensorflow::Tensor &  features, int  eta_index, int  phi_index  )

inlineprivate

Definition at line 872 of file DeepTauId.cc.

References gen::n.

    {
        for(int n = 0; n < dnn_inputs_2017_v2::number_of_conv_features; ++n)
            convTensor.tensor<float, 4>()(0, eta_index, phi_index, n) = features.tensor<float, 4>()(0, 0, 0, n);
    }

Member Data Documentation

std::array<std::shared_ptr<tensorflow::Tensor>, 2> DeepTauId::convTensor_

private

Definition at line 1702 of file DeepTauId.cc.

const int DeepTauId::debug_level

private

Definition at line 1700 of file DeepTauId.cc.

float DeepTauId::default_value = -999.

static

Definition at line 554 of file DeepTauId.cc.

std::array<std::shared_ptr<tensorflow::Tensor>, 2> DeepTauId::eGammaTensor_

private

Definition at line 1702 of file DeepTauId.cc.

edm::EDGetTokenT<ElectronCollection> DeepTauId::electrons_token_

private

Definition at line 1695 of file DeepTauId.cc.

std::array<std::shared_ptr<tensorflow::Tensor>, 2> DeepTauId::hadronsTensor_

private

Definition at line 1702 of file DeepTauId.cc.

std::string DeepTauId::input_layer_

private

Definition at line 1698 of file DeepTauId.cc.

edm::EDGetTokenT<MuonCollection> DeepTauId::muons_token_

private

Definition at line 1696 of file DeepTauId.cc.

std::array<std::shared_ptr<tensorflow::Tensor>, 2> DeepTauId::muonTensor_

private

Definition at line 1702 of file DeepTauId.cc.

std::string DeepTauId::output_layer_

private

Definition at line 1698 of file DeepTauId.cc.

float DeepTauId::pi = M_PI

staticprivate

Definition at line 653 of file DeepTauId.cc.

edm::EDGetTokenT<double> DeepTauId::rho_token_

private

Definition at line 1697 of file DeepTauId.cc.

std::shared_ptr<tensorflow::Tensor> DeepTauId::tauBlockTensor_

private

Definition at line 1701 of file DeepTauId.cc.

const unsigned DeepTauId::version

private

Definition at line 1699 of file DeepTauId.cc.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

std::array<std::shared_ptr<tensorflow::Tensor>, 2> DeepTauId::zeroOutputTensor_

private

Definition at line 1702 of file DeepTauId.cc.