CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes
DeepTauId Class Reference
Inheritance diagram for DeepTauId:
deep_tau::DeepTauBase edm::stream::EDProducer< edm::GlobalCache< DeepTauCache > >

Public Member Functions

 DeepTauId (const edm::ParameterSet &cfg, const deep_tau::DeepTauCache *cache)
 
const std::map< BasicDiscriminator, size_t > matchDiscriminatorIndices (edm::Event &event, edm::EDGetTokenT< reco::TauDiscriminatorContainer > discriminatorContainerToken, std::vector< BasicDiscriminator > requiredDiscr)
 
- 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 hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () 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 constexpr float default_value = -999.
 

Private Member Functions

void checkInputs (const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr) const
 
template<typename CandidateCastType , typename TauCastType >
void createConvFeatures (const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const CellGrid &grid, TauFunc tau_funcs, bool is_inner)
 
template<typename CandidateCastType , typename TauCastType >
void createEgammaBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Electron > *electrons, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner)
 
template<typename CandidateCastType , typename TauCastType >
void createHadronsBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner)
 
template<typename dnn , typename CandidateCastType , typename TauCastType >
tensorflow::Tensor createInputsV1 (const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, TauFunc tau_funcs) const
 
template<typename CandidateCastType , typename TauCastType >
void createMuonBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner)
 
template<typename CandidateCastType , typename TauCastType >
void createTauBlockInputs (const TauCastType &tau, const size_t &tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, TauFunc tau_funcs)
 
template<typename Collection , typename TauCastType >
void fillGrids (const TauCastType &tau, const Collection &objects, CellGrid &inner_grid, CellGrid &outer_grid)
 
tensorflow::Tensor getPartialPredictions (bool is_inner)
 
tensorflow::Tensor getPredictions (edm::Event &event, edm::Handle< TauCollection > taus) override
 
template<typename CandidateCastType , typename TauCastType >
void getPredictionsV1 (TauCollection::const_reference &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, std::vector< tensorflow::Tensor > &pred_vector, TauFunc tau_funcs)
 
template<typename CandidateCastType , typename TauCastType >
void getPredictionsV2 (TauCollection::const_reference &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const reco::Vertex &pv, double rho, std::vector< tensorflow::Tensor > &pred_vector, TauFunc tau_funcs)
 
void saveInputs (const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr)
 
void setCellConvFeatures (tensorflow::Tensor &convTensor, const tensorflow::Tensor &features, unsigned batch_idx, 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)
 
template<typename TauCastType >
static bool calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, double &gj_diff, TauFunc tau_funcs)
 
template<typename TauCastType >
static float calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, TauFunc tau_funcs)
 
template<typename TauCastType >
static const pat::Electron * findMatchedElectron (const TauCastType &tau, const std::vector< pat::Electron > *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 isAbove (double value, double min)
 
static bool isInEcalCrack (double eta)
 
template<typename CandidateCollection , typename TauCastType >
static void processIsolationPFComponents (const TauCastType &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
 
template<typename CandidateCollection , typename TauCastType >
static void processSignalPFComponents (const TauCastType &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::map< BasicDiscriminator, size_t > basicDiscrdR03IndexMap_
 
std::map< BasicDiscriminator, size_t > basicDiscrIndexMap_
 
edm::EDGetTokenT< reco::TauDiscriminatorContainer > basicTauDiscriminators_inputToken_
 
edm::EDGetTokenT< reco::TauDiscriminatorContainer > basicTauDiscriminatorsdR03_inputToken_
 
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > convTensor_
 
const int debug_level
 
const bool disable_CellIndex_workaround_
 
const bool disable_dxy_pca_
 
const bool disable_hcalFraction_workaround_
 
bool discrIndicesMapped_ = false
 
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > eGammaTensor_
 
edm::EDGetTokenT< std::vector< pat::Electron > > electrons_token_
 
int file_counter_
 
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > hadronsTensor_
 
std::string input_layer_
 
bool is_first_block_
 
std::ofstream * json_file_
 
edm::EDGetTokenT< std::vector< pat::Muon > > muons_token_
 
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > muonTensor_
 
std::string output_layer_
 
edm::EDGetTokenT< edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > > > pfTauTransverseImpactParameters_token_
 
edm::EDGetTokenT< double > rho_token_
 
const bool save_inputs_
 
std::unique_ptr< tensorflow::Tensor > tauBlockTensor_
 
const unsigned version_
 
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > zeroOutputTensor_
 

Static Private Attributes

static constexpr float pi = M_PI
 

Additional Inherited Members

- Public Types inherited from deep_tau::DeepTauBase
enum  BasicDiscriminator {
  ChargedIsoPtSum, NeutralIsoPtSum, NeutralIsoPtSumWeight, FootprintCorrection,
  PhotonPtSumOutsideSignalCone, PUcorrPtSum
}
 
using CandidateCollection = edm::View< reco::Candidate >
 
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 = edm::View< reco::BaseTau >
 
using TauDiscriminator = reco::TauDiscriminatorContainer
 
using TauRef = edm::Ref< TauCollection >
 
using TauRefProd = edm::RefProd< TauCollection >
 
using WPList = std::vector< 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
 
- Public Attributes inherited from deep_tau::DeepTauBase
uint8_t andPrediscriminants_
 
std::vector< TauDiscInfo< pat::PATTauDiscriminator > > patPrediscriminants_
 
std::vector< TauDiscInfo< reco::PFTauDiscriminator > > recoPrediscriminants_
 
- Protected Attributes inherited from deep_tau::DeepTauBase
const DeepTauCache * cache_
 
const bool is_online_
 
OutputCollection outputs_
 
edm::EDGetTokenT< CandidateCollection > pfcandToken_
 
edm::EDGetTokenT< TauCollection > tausToken_
 
edm::EDGetTokenT< reco::VertexCollection > vtxToken_
 
std::map< std::string, WPList > workingPoints_
 
- Static Protected Attributes inherited from deep_tau::DeepTauBase
static const std::vector< BasicDiscriminator > requiredBasicDiscriminators_
 
static const std::vector< BasicDiscriminator > requiredBasicDiscriminatorsdR03_
 
static const std::map< BasicDiscriminator, std::string > stringFromDiscriminator_
 

Detailed Description

Definition at line 1100 of file DeepTauId.cc.

Constructor & Destructor Documentation

◆ DeepTauId()

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

Definition at line 1189 of file DeepTauId.cc.

1190  : DeepTauBase(cfg, GetOutputs(), cache),
1191  electrons_token_(consumes<std::vector<pat::Electron>>(cfg.getParameter<edm::InputTag>("electrons"))),
1192  muons_token_(consumes<std::vector<pat::Muon>>(cfg.getParameter<edm::InputTag>("muons"))),
1193  rho_token_(consumes<double>(cfg.getParameter<edm::InputTag>("rho"))),
1194  basicTauDiscriminators_inputToken_(consumes<reco::TauDiscriminatorContainer>(
1195  cfg.getUntrackedParameter<edm::InputTag>("basicTauDiscriminators"))),
1196  basicTauDiscriminatorsdR03_inputToken_(consumes<reco::TauDiscriminatorContainer>(
1197  cfg.getUntrackedParameter<edm::InputTag>("basicTauDiscriminatorsdR03"))),
1198  pfTauTransverseImpactParameters_token_(
1199  consumes<edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>>(
1200  cfg.getParameter<edm::InputTag>("pfTauTransverseImpactParameters"))),
1201  version_(cfg.getParameter<unsigned>("version")),
1202  debug_level(cfg.getParameter<int>("debug_level")),
1203  disable_dxy_pca_(cfg.getParameter<bool>("disable_dxy_pca")),
1204  disable_hcalFraction_workaround_(cfg.getParameter<bool>("disable_hcalFraction_workaround")),
1205  disable_CellIndex_workaround_(cfg.getParameter<bool>("disable_CellIndex_workaround")),
1206  save_inputs_(cfg.getParameter<bool>("save_inputs")),
1207  json_file_(nullptr),
1208  file_counter_(0) {
1209  if (version_ == 1) {
1210  input_layer_ = cache_->getGraph().node(0).name();
1211  output_layer_ = cache_->getGraph().node(cache_->getGraph().node_size() - 1).name();
1212  const auto& shape = cache_->getGraph().node(0).attr().at("shape").shape();
1213  if (shape.dim(1).size() != dnn_inputs_2017v1::NumberOfInputs)
1214  throw cms::Exception("DeepTauId")
1215  << "number of inputs does not match the expected inputs for the given version";
1216  } else if (version_ == 2) {
1217  tauBlockTensor_ = std::make_unique<tensorflow::Tensor>(
1218  tensorflow::DT_FLOAT, tensorflow::TensorShape{1, dnn_inputs_2017_v2::TauBlockInputs::NumberOfInputs});
1219  for (size_t n = 0; n < 2; ++n) {
1220  const bool is_inner = n == 0;
1221  const auto n_cells =
1222  is_inner ? dnn_inputs_2017_v2::number_of_inner_cell : dnn_inputs_2017_v2::number_of_outer_cell;
1223  eGammaTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1224  tensorflow::DT_FLOAT,
1225  tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::EgammaBlockInputs::NumberOfInputs});
1226  muonTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1227  tensorflow::DT_FLOAT,
1228  tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::MuonBlockInputs::NumberOfInputs});
1229  hadronsTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1230  tensorflow::DT_FLOAT,
1231  tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::HadronBlockInputs::NumberOfInputs});
1232  convTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1233  tensorflow::DT_FLOAT,
1234  tensorflow::TensorShape{1, n_cells, n_cells, dnn_inputs_2017_v2::number_of_conv_features});
1235  zeroOutputTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1236  tensorflow::DT_FLOAT, tensorflow::TensorShape{1, 1, 1, dnn_inputs_2017_v2::number_of_conv_features});
1237 
1238  eGammaTensor_[is_inner]->flat<float>().setZero();
1239  muonTensor_[is_inner]->flat<float>().setZero();
1240  hadronsTensor_[is_inner]->flat<float>().setZero();
1241 
1242  setCellConvFeatures(*zeroOutputTensor_[is_inner], getPartialPredictions(is_inner), 0, 0, 0);
1243  }
1244  } else {
1245  throw cms::Exception("DeepTauId") << "version " << version_ << " is not supported.";
1246  }
1247  }

References deep_tau::DeepTauBase::cache_, convTensor_, eGammaTensor_, Exception, deep_tau::DeepTauCache::getGraph(), getPartialPredictions(), hadronsTensor_, input_layer_, muonTensor_, dqmiodumpmetadata::n, Skims_PA_cff::name, output_layer_, setCellConvFeatures(), tauBlockTensor_, version_, and zeroOutputTensor_.

Member Function Documentation

◆ calculateElectronClusterVars()

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

Definition at line 2650 of file DeepTauId.cc.

2650  {
2651  if (ele) {
2652  elecEe = elecEgamma = 0;
2653  auto superCluster = ele->superCluster();
2654  if (superCluster.isNonnull() && superCluster.isAvailable() && superCluster->clusters().isNonnull() &&
2655  superCluster->clusters().isAvailable()) {
2656  for (auto iter = superCluster->clustersBegin(); iter != superCluster->clustersEnd(); ++iter) {
2657  const double energy = (*iter)->energy();
2658  if (iter == superCluster->clustersBegin())
2659  elecEe += energy;
2660  else
2661  elecEgamma += energy;
2662  }
2663  }
2664  } else {
2665  elecEe = elecEgamma = default_value;
2666  }
2667  }

References default_value, HCALHighEnergyHPDFilter_cfi::energy, and pat::Electron::superCluster().

Referenced by createInputsV1().

◆ calculateElectronClusterVarsV2()

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

Definition at line 1282 of file DeepTauId.cc.

1285  {
1286  cc_ele_energy = cc_gamma_energy = 0;
1287  cc_n_gamma = 0;
1288  const auto& superCluster = ele.superCluster();
1289  if (superCluster.isNonnull() && superCluster.isAvailable() && superCluster->clusters().isNonnull() &&
1290  superCluster->clusters().isAvailable()) {
1291  for (auto iter = superCluster->clustersBegin(); iter != superCluster->clustersEnd(); ++iter) {
1292  const float energy = static_cast<float>((*iter)->energy());
1293  if (iter == superCluster->clustersBegin())
1294  cc_ele_energy += energy;
1295  else {
1296  cc_gamma_energy += energy;
1297  ++cc_n_gamma;
1298  }
1299  }
1300  return true;
1301  } else
1302  return false;
1303  }

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

Referenced by createEgammaBlockInputs().

◆ calculateGottfriedJacksonAngleDifference() [1/2]

template<typename TauCastType >
static bool DeepTauId::calculateGottfriedJacksonAngleDifference ( const TauCastType &  tau,
const size_t  tau_index,
double &  gj_diff,
TauFunc  tau_funcs 
)
inlinestaticprivate

Definition at line 2744 of file DeepTauId.cc.

2747  {
2748  if (tau_funcs.getHasSecondaryVertex(tau, tau_index)) {
2749  static constexpr double mTau = 1.77682;
2750  const double mAOne = tau.p4().M();
2751  const double pAOneMag = tau.p();
2752  const double argumentThetaGJmax = (std::pow(mTau, 2) - std::pow(mAOne, 2)) / (2 * mTau * pAOneMag);
2753  const double argumentThetaGJmeasured = tau.p4().Vect().Dot(tau_funcs.getFlightLength(tau, tau_index)) /
2754  (pAOneMag * tau_funcs.getFlightLength(tau, tau_index).R());
2755  if (std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1.) {
2756  double thetaGJmax = std::asin(argumentThetaGJmax);
2757  double thetaGJmeasured = std::acos(argumentThetaGJmeasured);
2758  gj_diff = thetaGJmeasured - thetaGJmax;
2759  return true;
2760  }
2761  }
2762  return false;
2763  }

References funct::abs(), funct::pow(), and metsig::tau.

Referenced by calculateGottfriedJacksonAngleDifference(), createInputsV1(), and createTauBlockInputs().

◆ calculateGottfriedJacksonAngleDifference() [2/2]

template<typename TauCastType >
static float DeepTauId::calculateGottfriedJacksonAngleDifference ( const TauCastType &  tau,
const size_t  tau_index,
TauFunc  tau_funcs 
)
inlinestaticprivate

Definition at line 2766 of file DeepTauId.cc.

2768  {
2769  double gj_diff;
2770  if (calculateGottfriedJacksonAngleDifference(tau, tau_index, gj_diff, tau_funcs))
2771  return static_cast<float>(gj_diff);
2772  return default_value;
2773  }

References calculateGottfriedJacksonAngleDifference(), default_value, and metsig::tau.

◆ checkInputs()

void DeepTauId::checkInputs ( const tensorflow::Tensor &  inputs,
const std::string &  block_name,
int  n_inputs,
const CellGrid *  grid = nullptr 
) const
inlineprivate

Definition at line 1305 of file DeepTauId.cc.

1308  {
1309  if (debug_level >= 1) {
1310  std::cout << "<checkInputs>: block_name = " << block_name << std::endl;
1311  if (block_name == "input_tau") {
1312  for (int input_index = 0; input_index < n_inputs; ++input_index) {
1313  float input = inputs.matrix<float>()(0, input_index);
1314  if (edm::isNotFinite(input)) {
1315  throw cms::Exception("DeepTauId")
1316  << "in the " << block_name
1317  << ", input is not finite, i.e. infinite or NaN, for input_index = " << input_index;
1318  }
1319  if (debug_level >= 2) {
1320  std::cout << block_name << "[var = " << input_index << "] = " << std::setprecision(5) << std::fixed << input
1321  << std::endl;
1322  }
1323  }
1324  } else {
1325  assert(grid);
1326  int n_eta, n_phi;
1327  if (block_name.find("input_inner") != std::string::npos) {
1328  n_eta = 5;
1329  n_phi = 5;
1330  } else if (block_name.find("input_outer") != std::string::npos) {
1331  n_eta = 10;
1332  n_phi = 10;
1333  } else
1334  assert(0);
1335  int eta_phi_index = 0;
1336  for (int eta = -n_eta; eta <= n_eta; ++eta) {
1337  for (int phi = -n_phi; phi <= n_phi; ++phi) {
1338  const CellIndex cell_index{eta, phi};
1339  const auto cell_iter = grid->find(cell_index);
1340  if (cell_iter != grid->end()) {
1341  for (int input_index = 0; input_index < n_inputs; ++input_index) {
1342  float input = inputs.tensor<float, 4>()(eta_phi_index, 0, 0, input_index);
1343  if (edm::isNotFinite(input)) {
1344  throw cms::Exception("DeepTauId")
1345  << "in the " << block_name << ", input is not finite, i.e. infinite or NaN, for eta = " << eta
1346  << ", phi = " << phi << ", input_index = " << input_index;
1347  }
1348  if (debug_level >= 2) {
1349  std::cout << block_name << "[eta = " << eta << "][phi = " << phi << "][var = " << input_index
1350  << "] = " << std::setprecision(5) << std::fixed << input << std::endl;
1351  }
1352  }
1353  eta_phi_index += 1;
1354  }
1355  }
1356  }
1357  }
1358  }
1359  }

References cms::cuda::assert(), gather_cfg::cout, debug_level, PVValHelper::eta, Exception, alignBH_cfg::fixed, dqmMemoryStats::float, getRunAppsInfo::grid, input, PixelMapPlotter::inputs, edm::isNotFinite(), and phi.

Referenced by getPredictionsV2().

◆ createConvFeatures()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::createConvFeatures ( const TauCastType &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const reco::Vertex &  pv,
double  rho,
const std::vector< pat::Electron > *  electrons,
const std::vector< pat::Muon > *  muons,
const edm::View< reco::Candidate > &  pfCands,
const CellGrid &  grid,
TauFunc  tau_funcs,
bool  is_inner 
)
inlineprivate

Definition at line 1736 of file DeepTauId.cc.

1746  {
1747  if (debug_level >= 2) {
1748  std::cout << "<DeepTauId::createConvFeatures (is_inner = " << is_inner << ")>:" << std::endl;
1749  }
1750  tensorflow::Tensor& convTensor = *convTensor_.at(is_inner);
1751  eGammaTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1752  tensorflow::DT_FLOAT,
1753  tensorflow::TensorShape{
1754  (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_2017_v2::EgammaBlockInputs::NumberOfInputs});
1755  muonTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1756  tensorflow::DT_FLOAT,
1757  tensorflow::TensorShape{
1758  (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_2017_v2::MuonBlockInputs::NumberOfInputs});
1759  hadronsTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
1760  tensorflow::DT_FLOAT,
1761  tensorflow::TensorShape{
1762  (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_2017_v2::HadronBlockInputs::NumberOfInputs});
1763 
1764  eGammaTensor_[is_inner]->flat<float>().setZero();
1765  muonTensor_[is_inner]->flat<float>().setZero();
1766  hadronsTensor_[is_inner]->flat<float>().setZero();
1767 
1768  unsigned idx = 0;
1769  for (int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
1770  for (int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
1771  if (debug_level >= 2) {
1772  std::cout << "processing ( eta = " << eta << ", phi = " << phi << " )" << std::endl;
1773  }
1774  const CellIndex cell_index{eta, phi};
1775  const auto cell_iter = grid.find(cell_index);
1776  if (cell_iter != grid.end()) {
1777  if (debug_level >= 2) {
1778  std::cout << " creating inputs for ( eta = " << eta << ", phi = " << phi << " ): idx = " << idx
1779  << std::endl;
1780  }
1781  const Cell& cell = cell_iter->second;
1782  createEgammaBlockInputs<CandidateCastType>(
1783  idx, tau, tau_index, tau_ref, pv, rho, electrons, pfCands, cell, tau_funcs, is_inner);
1784  createMuonBlockInputs<CandidateCastType>(
1785  idx, tau, tau_index, tau_ref, pv, rho, muons, pfCands, cell, tau_funcs, is_inner);
1786  createHadronsBlockInputs<CandidateCastType>(
1787  idx, tau, tau_index, tau_ref, pv, rho, pfCands, cell, tau_funcs, is_inner);
1788  idx += 1;
1789  } else {
1790  if (debug_level >= 2) {
1791  std::cout << " skipping creation of inputs, because ( eta = " << eta << ", phi = " << phi
1792  << " ) is not in the grid !!" << std::endl;
1793  }
1794  }
1795  }
1796  }
1797 
1798  const auto predTensor = getPartialPredictions(is_inner);
1799  idx = 0;
1800  for (int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
1801  for (int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
1802  const CellIndex cell_index{eta, phi};
1803  const int eta_index = grid.getEtaTensorIndex(cell_index);
1804  const int phi_index = grid.getPhiTensorIndex(cell_index);
1805 
1806  const auto cell_iter = grid.find(cell_index);
1807  if (cell_iter != grid.end()) {
1808  setCellConvFeatures(convTensor, predTensor, idx, eta_index, phi_index);
1809  idx += 1;
1810  } else {
1811  setCellConvFeatures(convTensor, *zeroOutputTensor_[is_inner], 0, eta_index, phi_index);
1812  }
1813  }
1814  }
1815  }

References convTensor_, gather_cfg::cout, debug_level, eGammaTensor_, pwdgSkimBPark_cfi::electrons, PVValHelper::eta, getPartialPredictions(), getRunAppsInfo::grid, hadronsTensor_, training_settings::idx, createfilelist::int, PDWG_BPHSkim_cff::muons, muonTensor_, phi, MetAnalyzer::pv(), rho, setCellConvFeatures(), metsig::tau, and zeroOutputTensor_.

◆ createEgammaBlockInputs()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::createEgammaBlockInputs ( unsigned  idx,
const TauCastType &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const reco::Vertex &  pv,
double  rho,
const std::vector< pat::Electron > *  electrons,
const edm::View< reco::Candidate > &  pfCands,
const Cell &  cell_map,
TauFunc  tau_funcs,
bool  is_inner 
)
inlineprivate

Definition at line 1934 of file DeepTauId.cc.

1944  {
1945  namespace dnn = dnn_inputs_2017_v2::EgammaBlockInputs;
1946 
1947  tensorflow::Tensor& inputs = *eGammaTensor_.at(is_inner);
1948 
1949  const auto& get = [&](int var_index) -> float& { return inputs.tensor<float, 4>()(idx, 0, 0, var_index); };
1950 
1951  const bool valid_index_pf_ele = cell_map.count(CellObjectType::PfCand_electron);
1952  const bool valid_index_pf_gamma = cell_map.count(CellObjectType::PfCand_gamma);
1953  const bool valid_index_ele = cell_map.count(CellObjectType::Electron);
1954 
1955  if (!cell_map.empty()) {
1956  get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
1957  get(dnn::tau_pt) = getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
1958  get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
1959  get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
1960  }
1961  if (valid_index_pf_ele) {
1962  size_t index_pf_ele = cell_map.at(CellObjectType::PfCand_electron);
1963  const auto& ele_cand = dynamic_cast<const CandidateCastType&>(pfCands.at(index_pf_ele));
1964 
1965  get(dnn::pfCand_ele_valid) = valid_index_pf_ele;
1966  get(dnn::pfCand_ele_rel_pt) = getValueNorm(pfCands.at(index_pf_ele).polarP4().pt() / tau.polarP4().pt(),
1967  is_inner ? 0.9792f : 0.304f,
1968  is_inner ? 0.5383f : 1.845f);
1969  get(dnn::pfCand_ele_deta) = getValueLinear(pfCands.at(index_pf_ele).polarP4().eta() - tau.polarP4().eta(),
1970  is_inner ? -0.1f : -0.5f,
1971  is_inner ? 0.1f : 0.5f,
1972  false);
1973  get(dnn::pfCand_ele_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_ele).polarP4()),
1974  is_inner ? -0.1f : -0.5f,
1975  is_inner ? 0.1f : 0.5f,
1976  false);
1977  get(dnn::pfCand_ele_pvAssociationQuality) =
1978  getValueLinear<int>(candFunc::getPvAssocationQuality(ele_cand), 0, 7, true);
1979  get(dnn::pfCand_ele_puppiWeight) = is_inner ? getValue(candFunc::getPuppiWeight(ele_cand, 0.9906834f))
1980  : getValue(candFunc::getPuppiWeight(ele_cand, 0.9669586f));
1981  get(dnn::pfCand_ele_charge) = getValue(ele_cand.charge());
1982  get(dnn::pfCand_ele_lostInnerHits) = getValue<int>(candFunc::getLostInnerHits(ele_cand, 0));
1983  get(dnn::pfCand_ele_numberOfPixelHits) = getValueLinear(candFunc::getNumberOfPixelHits(ele_cand, 0), 0, 10, true);
1984  get(dnn::pfCand_ele_vertex_dx) =
1985  getValueNorm(pfCands.at(index_pf_ele).vertex().x() - pv.position().x(), 0.f, 0.1221f);
1986  get(dnn::pfCand_ele_vertex_dy) =
1987  getValueNorm(pfCands.at(index_pf_ele).vertex().y() - pv.position().y(), 0.f, 0.1226f);
1988  get(dnn::pfCand_ele_vertex_dz) =
1989  getValueNorm(pfCands.at(index_pf_ele).vertex().z() - pv.position().z(), 0.001f, 1.024f);
1990  get(dnn::pfCand_ele_vertex_dx_tauFL) = getValueNorm(
1991  pfCands.at(index_pf_ele).vertex().x() - pv.position().x() - tau_funcs.getFlightLength(tau, tau_index).x(),
1992  0.f,
1993  0.3411f);
1994  get(dnn::pfCand_ele_vertex_dy_tauFL) = getValueNorm(
1995  pfCands.at(index_pf_ele).vertex().y() - pv.position().y() - tau_funcs.getFlightLength(tau, tau_index).y(),
1996  0.0003f,
1997  0.3385f);
1998  get(dnn::pfCand_ele_vertex_dz_tauFL) = getValueNorm(
1999  pfCands.at(index_pf_ele).vertex().z() - pv.position().z() - tau_funcs.getFlightLength(tau, tau_index).z(),
2000  0.f,
2001  1.307f);
2002 
2003  const bool hasTrackDetails = candFunc::getHasTrackDetails(ele_cand);
2004  if (hasTrackDetails) {
2005  get(dnn::pfCand_ele_hasTrackDetails) = hasTrackDetails;
2006  get(dnn::pfCand_ele_dxy) = getValueNorm(candFunc::getTauDxy(ele_cand), 0.f, 0.171f);
2007  get(dnn::pfCand_ele_dxy_sig) =
2008  getValueNorm(std::abs(candFunc::getTauDxy(ele_cand)) / pfCands.at(index_pf_ele).dxyError(), 1.634f, 6.45f);
2009  get(dnn::pfCand_ele_dz) = getValueNorm(candFunc::getTauDz(ele_cand), 0.001f, 1.02f);
2010  get(dnn::pfCand_ele_dz_sig) =
2011  getValueNorm(std::abs(candFunc::getTauDz(ele_cand)) / ele_cand.dzError(), 24.56f, 210.4f);
2012  get(dnn::pfCand_ele_track_chi2_ndof) = getValueNorm(
2013  candFunc::getPseudoTrack(ele_cand).chi2() / candFunc::getPseudoTrack(ele_cand).ndof(), 2.272f, 8.439f);
2014  get(dnn::pfCand_ele_track_ndof) = getValueNorm(candFunc::getPseudoTrack(ele_cand).ndof(), 15.18f, 3.203f);
2015  }
2016  }
2017  if (valid_index_pf_gamma) {
2018  size_t index_pf_gamma = cell_map.at(CellObjectType::PfCand_gamma);
2019  const auto& gamma_cand = dynamic_cast<const CandidateCastType&>(pfCands.at(index_pf_gamma));
2020 
2021  get(dnn::pfCand_gamma_valid) = valid_index_pf_gamma;
2022  get(dnn::pfCand_gamma_rel_pt) = getValueNorm(pfCands.at(index_pf_gamma).polarP4().pt() / tau.polarP4().pt(),
2023  is_inner ? 0.6048f : 0.02576f,
2024  is_inner ? 1.669f : 0.3833f);
2025  get(dnn::pfCand_gamma_deta) = getValueLinear(pfCands.at(index_pf_gamma).polarP4().eta() - tau.polarP4().eta(),
2026  is_inner ? -0.1f : -0.5f,
2027  is_inner ? 0.1f : 0.5f,
2028  false);
2029  get(dnn::pfCand_gamma_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_gamma).polarP4()),
2030  is_inner ? -0.1f : -0.5f,
2031  is_inner ? 0.1f : 0.5f,
2032  false);
2033  get(dnn::pfCand_gamma_pvAssociationQuality) =
2034  getValueLinear<int>(candFunc::getPvAssocationQuality(gamma_cand), 0, 7, true);
2035  get(dnn::pfCand_gamma_fromPV) = getValueLinear<int>(candFunc::getFromPV(gamma_cand), 0, 3, true);
2036  get(dnn::pfCand_gamma_puppiWeight) = is_inner ? getValue(candFunc::getPuppiWeight(gamma_cand, 0.9084110f))
2037  : getValue(candFunc::getPuppiWeight(gamma_cand, 0.4211567f));
2038  get(dnn::pfCand_gamma_puppiWeightNoLep) = is_inner
2039  ? getValue(candFunc::getPuppiWeightNoLep(gamma_cand, 0.8857716f))
2040  : getValue(candFunc::getPuppiWeightNoLep(gamma_cand, 0.3822604f));
2041  get(dnn::pfCand_gamma_lostInnerHits) = getValue<int>(candFunc::getLostInnerHits(gamma_cand, 0));
2042  get(dnn::pfCand_gamma_numberOfPixelHits) =
2043  getValueLinear(candFunc::getNumberOfPixelHits(gamma_cand, 0), 0, 7, true);
2044  get(dnn::pfCand_gamma_vertex_dx) =
2045  getValueNorm(pfCands.at(index_pf_gamma).vertex().x() - pv.position().x(), 0.f, 0.0067f);
2046  get(dnn::pfCand_gamma_vertex_dy) =
2047  getValueNorm(pfCands.at(index_pf_gamma).vertex().y() - pv.position().y(), 0.f, 0.0069f);
2048  get(dnn::pfCand_gamma_vertex_dz) =
2049  getValueNorm(pfCands.at(index_pf_gamma).vertex().z() - pv.position().z(), 0.f, 0.0578f);
2050  get(dnn::pfCand_gamma_vertex_dx_tauFL) = getValueNorm(
2051  pfCands.at(index_pf_gamma).vertex().x() - pv.position().x() - tau_funcs.getFlightLength(tau, tau_index).x(),
2052  0.001f,
2053  0.9565f);
2054  get(dnn::pfCand_gamma_vertex_dy_tauFL) = getValueNorm(
2055  pfCands.at(index_pf_gamma).vertex().y() - pv.position().y() - tau_funcs.getFlightLength(tau, tau_index).y(),
2056  0.0008f,
2057  0.9592f);
2058  get(dnn::pfCand_gamma_vertex_dz_tauFL) = getValueNorm(
2059  pfCands.at(index_pf_gamma).vertex().z() - pv.position().z() - tau_funcs.getFlightLength(tau, tau_index).z(),
2060  0.0038f,
2061  2.154f);
2062  const bool hasTrackDetails = candFunc::getHasTrackDetails(gamma_cand);
2063  if (hasTrackDetails) {
2064  get(dnn::pfCand_gamma_hasTrackDetails) = hasTrackDetails;
2065  get(dnn::pfCand_gamma_dxy) = getValueNorm(candFunc::getTauDxy(gamma_cand), 0.0004f, 0.882f);
2066  get(dnn::pfCand_gamma_dxy_sig) =
2067  getValueNorm(std::abs(candFunc::getTauDxy(gamma_cand)) / gamma_cand.dxyError(), 4.271f, 63.78f);
2068  get(dnn::pfCand_gamma_dz) = getValueNorm(candFunc::getTauDz(gamma_cand), 0.0071f, 5.285f);
2069  get(dnn::pfCand_gamma_dz_sig) =
2070  getValueNorm(std::abs(candFunc::getTauDz(gamma_cand)) / gamma_cand.dzError(), 162.1f, 622.4f);
2071  get(dnn::pfCand_gamma_track_chi2_ndof) = candFunc::getPseudoTrack(gamma_cand).ndof() > 0
2072  ? getValueNorm(candFunc::getPseudoTrack(gamma_cand).chi2() /
2073  candFunc::getPseudoTrack(gamma_cand).ndof(),
2074  4.268f,
2075  15.47f)
2076  : 0;
2077  get(dnn::pfCand_gamma_track_ndof) =
2078  candFunc::getPseudoTrack(gamma_cand).ndof() > 0
2079  ? getValueNorm(candFunc::getPseudoTrack(gamma_cand).ndof(), 12.25f, 4.774f)
2080  : 0;
2081  }
2082  }
2083  if (valid_index_ele) {
2084  size_t index_ele = cell_map.at(CellObjectType::Electron);
2085 
2086  get(dnn::ele_valid) = valid_index_ele;
2087  get(dnn::ele_rel_pt) = getValueNorm(electrons->at(index_ele).polarP4().pt() / tau.polarP4().pt(),
2088  is_inner ? 1.067f : 0.5111f,
2089  is_inner ? 1.521f : 2.765f);
2090  get(dnn::ele_deta) = getValueLinear(electrons->at(index_ele).polarP4().eta() - tau.polarP4().eta(),
2091  is_inner ? -0.1f : -0.5f,
2092  is_inner ? 0.1f : 0.5f,
2093  false);
2094  get(dnn::ele_dphi) = getValueLinear(dPhi(tau.polarP4(), electrons->at(index_ele).polarP4()),
2095  is_inner ? -0.1f : -0.5f,
2096  is_inner ? 0.1f : 0.5f,
2097  false);
2098 
2099  float cc_ele_energy, cc_gamma_energy;
2100  int cc_n_gamma;
2101  const bool cc_valid =
2102  calculateElectronClusterVarsV2(electrons->at(index_ele), cc_ele_energy, cc_gamma_energy, cc_n_gamma);
2103  if (cc_valid) {
2104  get(dnn::ele_cc_valid) = cc_valid;
2105  get(dnn::ele_cc_ele_rel_energy) =
2106  getValueNorm(cc_ele_energy / electrons->at(index_ele).polarP4().pt(), 1.729f, 1.644f);
2107  get(dnn::ele_cc_gamma_rel_energy) = getValueNorm(cc_gamma_energy / cc_ele_energy, 0.1439f, 0.3284f);
2108  get(dnn::ele_cc_n_gamma) = getValueNorm(cc_n_gamma, 1.794f, 2.079f);
2109  }
2110  get(dnn::ele_rel_trackMomentumAtVtx) = getValueNorm(
2111  electrons->at(index_ele).trackMomentumAtVtx().R() / electrons->at(index_ele).polarP4().pt(), 1.531f, 1.424f);
2112  get(dnn::ele_rel_trackMomentumAtCalo) = getValueNorm(
2113  electrons->at(index_ele).trackMomentumAtCalo().R() / electrons->at(index_ele).polarP4().pt(), 1.531f, 1.424f);
2114  get(dnn::ele_rel_trackMomentumOut) = getValueNorm(
2115  electrons->at(index_ele).trackMomentumOut().R() / electrons->at(index_ele).polarP4().pt(), 0.7735f, 0.935f);
2116  get(dnn::ele_rel_trackMomentumAtEleClus) =
2117  getValueNorm(electrons->at(index_ele).trackMomentumAtEleClus().R() / electrons->at(index_ele).polarP4().pt(),
2118  0.7735f,
2119  0.935f);
2120  get(dnn::ele_rel_trackMomentumAtVtxWithConstraint) = getValueNorm(
2121  electrons->at(index_ele).trackMomentumAtVtxWithConstraint().R() / electrons->at(index_ele).polarP4().pt(),
2122  1.625f,
2123  1.581f);
2124  get(dnn::ele_rel_ecalEnergy) =
2125  getValueNorm(electrons->at(index_ele).ecalEnergy() / electrons->at(index_ele).polarP4().pt(), 1.993f, 1.308f);
2126  get(dnn::ele_ecalEnergy_sig) = getValueNorm(
2127  electrons->at(index_ele).ecalEnergy() / electrons->at(index_ele).ecalEnergyError(), 70.25f, 58.16f);
2128  get(dnn::ele_eSuperClusterOverP) = getValueNorm(electrons->at(index_ele).eSuperClusterOverP(), 2.432f, 15.13f);
2129  get(dnn::ele_eSeedClusterOverP) = getValueNorm(electrons->at(index_ele).eSeedClusterOverP(), 2.034f, 13.96f);
2130  get(dnn::ele_eSeedClusterOverPout) = getValueNorm(electrons->at(index_ele).eSeedClusterOverPout(), 6.64f, 36.8f);
2131  get(dnn::ele_eEleClusterOverPout) = getValueNorm(electrons->at(index_ele).eEleClusterOverPout(), 4.183f, 20.63f);
2132  get(dnn::ele_deltaEtaSuperClusterTrackAtVtx) =
2133  getValueNorm(electrons->at(index_ele).deltaEtaSuperClusterTrackAtVtx(), 0.f, 0.0363f);
2134  get(dnn::ele_deltaEtaSeedClusterTrackAtCalo) =
2135  getValueNorm(electrons->at(index_ele).deltaEtaSeedClusterTrackAtCalo(), -0.0001f, 0.0512f);
2136  get(dnn::ele_deltaEtaEleClusterTrackAtCalo) =
2137  getValueNorm(electrons->at(index_ele).deltaEtaEleClusterTrackAtCalo(), -0.0001f, 0.0541f);
2138  get(dnn::ele_deltaPhiEleClusterTrackAtCalo) =
2139  getValueNorm(electrons->at(index_ele).deltaPhiEleClusterTrackAtCalo(), 0.0002f, 0.0553f);
2140  get(dnn::ele_deltaPhiSuperClusterTrackAtVtx) =
2141  getValueNorm(electrons->at(index_ele).deltaPhiSuperClusterTrackAtVtx(), 0.0001f, 0.0523f);
2142  get(dnn::ele_deltaPhiSeedClusterTrackAtCalo) =
2143  getValueNorm(electrons->at(index_ele).deltaPhiSeedClusterTrackAtCalo(), 0.0004f, 0.0777f);
2144  get(dnn::ele_mvaInput_earlyBrem) = getValue(electrons->at(index_ele).mvaInput().earlyBrem);
2145  get(dnn::ele_mvaInput_lateBrem) = getValue(electrons->at(index_ele).mvaInput().lateBrem);
2146  get(dnn::ele_mvaInput_sigmaEtaEta) =
2147  getValueNorm(electrons->at(index_ele).mvaInput().sigmaEtaEta, 0.0008f, 0.0052f);
2148  get(dnn::ele_mvaInput_hadEnergy) = getValueNorm(electrons->at(index_ele).mvaInput().hadEnergy, 14.04f, 69.48f);
2149  get(dnn::ele_mvaInput_deltaEta) = getValueNorm(electrons->at(index_ele).mvaInput().deltaEta, 0.0099f, 0.0851f);
2150  const auto& gsfTrack = electrons->at(index_ele).gsfTrack();
2151  if (gsfTrack.isNonnull()) {
2152  get(dnn::ele_gsfTrack_normalizedChi2) = getValueNorm(gsfTrack->normalizedChi2(), 3.049f, 10.39f);
2153  get(dnn::ele_gsfTrack_numberOfValidHits) = getValueNorm(gsfTrack->numberOfValidHits(), 16.52f, 2.806f);
2154  get(dnn::ele_rel_gsfTrack_pt) =
2155  getValueNorm(gsfTrack->pt() / electrons->at(index_ele).polarP4().pt(), 1.355f, 16.81f);
2156  get(dnn::ele_gsfTrack_pt_sig) = getValueNorm(gsfTrack->pt() / gsfTrack->ptError(), 5.046f, 3.119f);
2157  }
2158  const auto& closestCtfTrack = electrons->at(index_ele).closestCtfTrackRef();
2159  const bool has_closestCtfTrack = closestCtfTrack.isNonnull();
2160  if (has_closestCtfTrack) {
2161  get(dnn::ele_has_closestCtfTrack) = has_closestCtfTrack;
2162  get(dnn::ele_closestCtfTrack_normalizedChi2) = getValueNorm(closestCtfTrack->normalizedChi2(), 2.411f, 6.98f);
2163  get(dnn::ele_closestCtfTrack_numberOfValidHits) =
2164  getValueNorm(closestCtfTrack->numberOfValidHits(), 15.16f, 5.26f);
2165  }
2166  }
2167  }

References funct::abs(), edm::View< T >::at(), calculateElectronClusterVarsV2(), hltPixelTracks_cff::chi2, HLT_2018_cff::dPhi, eGammaTensor_, nanoDQM_cff::Electron, pwdgSkimBPark_cfi::electrons, f, dqmMemoryStats::float, get, getValue(), getValueLinear(), getValueNorm(), training_settings::idx, PixelMapPlotter::inputs, isInEcalCrack(), ndof, MetAnalyzer::pv(), rho, ZElectronSkim_cff::rho, metsig::tau, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

◆ createHadronsBlockInputs()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::createHadronsBlockInputs ( unsigned  idx,
const TauCastType &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const reco::Vertex &  pv,
double  rho,
const edm::View< reco::Candidate > &  pfCands,
const Cell &  cell_map,
TauFunc  tau_funcs,
bool  is_inner 
)
inlineprivate

Definition at line 2321 of file DeepTauId.cc.

2330  {
2331  namespace dnn = dnn_inputs_2017_v2::HadronBlockInputs;
2332 
2333  tensorflow::Tensor& inputs = *hadronsTensor_.at(is_inner);
2334 
2335  const auto& get = [&](int var_index) -> float& { return inputs.tensor<float, 4>()(idx, 0, 0, var_index); };
2336 
2337  const bool valid_chH = cell_map.count(CellObjectType::PfCand_chargedHadron);
2338  const bool valid_nH = cell_map.count(CellObjectType::PfCand_neutralHadron);
2339 
2340  if (!cell_map.empty()) {
2341  get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
2342  get(dnn::tau_pt) = getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
2343  get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
2344  get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
2345  }
2346  if (valid_chH) {
2347  size_t index_chH = cell_map.at(CellObjectType::PfCand_chargedHadron);
2348  const auto& chH_cand = dynamic_cast<const CandidateCastType&>(pfCands.at(index_chH));
2349 
2350  get(dnn::pfCand_chHad_valid) = valid_chH;
2351  get(dnn::pfCand_chHad_rel_pt) = getValueNorm(pfCands.at(index_chH).polarP4().pt() / tau.polarP4().pt(),
2352  is_inner ? 0.2564f : 0.0194f,
2353  is_inner ? 0.8607f : 0.1865f);
2354  get(dnn::pfCand_chHad_deta) = getValueLinear(pfCands.at(index_chH).polarP4().eta() - tau.polarP4().eta(),
2355  is_inner ? -0.1f : -0.5f,
2356  is_inner ? 0.1f : 0.5f,
2357  false);
2358  get(dnn::pfCand_chHad_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_chH).polarP4()),
2359  is_inner ? -0.1f : -0.5f,
2360  is_inner ? 0.1f : 0.5f,
2361  false);
2362  get(dnn::pfCand_chHad_leadChargedHadrCand) =
2363  getValue(&chH_cand == dynamic_cast<const CandidateCastType*>(tau.leadChargedHadrCand().get()));
2364  get(dnn::pfCand_chHad_pvAssociationQuality) =
2365  getValueLinear<int>(candFunc::getPvAssocationQuality(chH_cand), 0, 7, true);
2366  get(dnn::pfCand_chHad_fromPV) = getValueLinear<int>(candFunc::getFromPV(chH_cand), 0, 3, true);
2367  const float default_chH_pw_inner = 0.7614090f;
2368  const float default_chH_pw_outer = 0.1974930f;
2369  get(dnn::pfCand_chHad_puppiWeight) = is_inner
2370  ? getValue(candFunc::getPuppiWeight(chH_cand, default_chH_pw_inner))
2371  : getValue(candFunc::getPuppiWeight(chH_cand, default_chH_pw_outer));
2372  get(dnn::pfCand_chHad_puppiWeightNoLep) =
2373  is_inner ? getValue(candFunc::getPuppiWeightNoLep(chH_cand, default_chH_pw_inner))
2374  : getValue(candFunc::getPuppiWeightNoLep(chH_cand, default_chH_pw_outer));
2375  get(dnn::pfCand_chHad_charge) = getValue(chH_cand.charge());
2376  get(dnn::pfCand_chHad_lostInnerHits) = getValue<int>(candFunc::getLostInnerHits(chH_cand, 0));
2377  get(dnn::pfCand_chHad_numberOfPixelHits) =
2378  getValueLinear(candFunc::getNumberOfPixelHits(chH_cand, 0), 0, 12, true);
2379  get(dnn::pfCand_chHad_vertex_dx) =
2380  getValueNorm(pfCands.at(index_chH).vertex().x() - pv.position().x(), 0.0005f, 1.735f);
2381  get(dnn::pfCand_chHad_vertex_dy) =
2382  getValueNorm(pfCands.at(index_chH).vertex().y() - pv.position().y(), -0.0008f, 1.752f);
2383  get(dnn::pfCand_chHad_vertex_dz) =
2384  getValueNorm(pfCands.at(index_chH).vertex().z() - pv.position().z(), -0.0201f, 8.333f);
2385  get(dnn::pfCand_chHad_vertex_dx_tauFL) = getValueNorm(
2386  pfCands.at(index_chH).vertex().x() - pv.position().x() - tau_funcs.getFlightLength(tau, tau_index).x(),
2387  -0.0014f,
2388  1.93f);
2389  get(dnn::pfCand_chHad_vertex_dy_tauFL) = getValueNorm(
2390  pfCands.at(index_chH).vertex().y() - pv.position().y() - tau_funcs.getFlightLength(tau, tau_index).y(),
2391  0.0022f,
2392  1.948f);
2393  get(dnn::pfCand_chHad_vertex_dz_tauFL) = getValueNorm(
2394  pfCands.at(index_chH).vertex().z() - pv.position().z() - tau_funcs.getFlightLength(tau, tau_index).z(),
2395  -0.0138f,
2396  8.622f);
2397 
2398  const bool hasTrackDetails = candFunc::getHasTrackDetails(chH_cand);
2399  if (hasTrackDetails) {
2400  get(dnn::pfCand_chHad_hasTrackDetails) = hasTrackDetails;
2401  get(dnn::pfCand_chHad_dxy) = getValueNorm(candFunc::getTauDxy(chH_cand), -0.012f, 2.386f);
2402  get(dnn::pfCand_chHad_dxy_sig) =
2403  getValueNorm(std::abs(candFunc::getTauDxy(chH_cand)) / chH_cand.dxyError(), 6.417f, 36.28f);
2404  get(dnn::pfCand_chHad_dz) = getValueNorm(candFunc::getTauDz(chH_cand), -0.0246f, 7.618f);
2405  get(dnn::pfCand_chHad_dz_sig) =
2406  getValueNorm(std::abs(candFunc::getTauDz(chH_cand)) / chH_cand.dzError(), 301.3f, 491.1f);
2407  get(dnn::pfCand_chHad_track_chi2_ndof) =
2408  candFunc::getPseudoTrack(chH_cand).ndof() > 0
2409  ? getValueNorm(candFunc::getPseudoTrack(chH_cand).chi2() / candFunc::getPseudoTrack(chH_cand).ndof(),
2410  0.7876f,
2411  3.694f)
2412  : 0;
2413  get(dnn::pfCand_chHad_track_ndof) =
2414  candFunc::getPseudoTrack(chH_cand).ndof() > 0
2415  ? getValueNorm(candFunc::getPseudoTrack(chH_cand).ndof(), 13.92f, 6.581f)
2416  : 0;
2417  }
2418  float hcal_fraction = candFunc::getHCalFraction(chH_cand, disable_hcalFraction_workaround_);
2419  get(dnn::pfCand_chHad_hcalFraction) = getValue(hcal_fraction);
2420  get(dnn::pfCand_chHad_rawCaloFraction) = getValueLinear(candFunc::getRawCaloFraction(chH_cand), 0.f, 2.6f, true);
2421  }
2422  if (valid_nH) {
2423  size_t index_nH = cell_map.at(CellObjectType::PfCand_neutralHadron);
2424  const auto& nH_cand = dynamic_cast<const CandidateCastType&>(pfCands.at(index_nH));
2425 
2426  get(dnn::pfCand_nHad_valid) = valid_nH;
2427  get(dnn::pfCand_nHad_rel_pt) = getValueNorm(pfCands.at(index_nH).polarP4().pt() / tau.polarP4().pt(),
2428  is_inner ? 0.3163f : 0.0502f,
2429  is_inner ? 0.2769f : 0.4266f);
2430  get(dnn::pfCand_nHad_deta) = getValueLinear(pfCands.at(index_nH).polarP4().eta() - tau.polarP4().eta(),
2431  is_inner ? -0.1f : -0.5f,
2432  is_inner ? 0.1f : 0.5f,
2433  false);
2434  get(dnn::pfCand_nHad_dphi) = getValueLinear(
2435  dPhi(tau.polarP4(), pfCands.at(index_nH).polarP4()), is_inner ? -0.1f : -0.5f, is_inner ? 0.1f : 0.5f, false);
2436  get(dnn::pfCand_nHad_puppiWeight) = is_inner ? getValue(candFunc::getPuppiWeight(nH_cand, 0.9798355f))
2437  : getValue(candFunc::getPuppiWeight(nH_cand, 0.7813260f));
2438  get(dnn::pfCand_nHad_puppiWeightNoLep) = is_inner ? getValue(candFunc::getPuppiWeightNoLep(nH_cand, 0.9046796f))
2439  : getValue(candFunc::getPuppiWeightNoLep(nH_cand, 0.6554860f));
2440  float hcal_fraction = candFunc::getHCalFraction(nH_cand, disable_hcalFraction_workaround_);
2441  get(dnn::pfCand_nHad_hcalFraction) = getValue(hcal_fraction);
2442  }
2443  }

References funct::abs(), edm::View< T >::at(), hltPixelTracks_cff::chi2, disable_hcalFraction_workaround_, HLT_2018_cff::dPhi, f, dqmMemoryStats::float, get, getValue(), getValueLinear(), getValueNorm(), hadronsTensor_, training_settings::idx, PixelMapPlotter::inputs, isInEcalCrack(), ndof, MetAnalyzer::pv(), rho, ZElectronSkim_cff::rho, metsig::tau, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

◆ createInputsV1()

template<typename dnn , typename CandidateCastType , typename TauCastType >
tensorflow::Tensor DeepTauId::createInputsV1 ( const TauCastType &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const std::vector< pat::Electron > *  electrons,
const std::vector< pat::Muon > *  muons,
TauFunc  tau_funcs 
) const
inlineprivate

Definition at line 2446 of file DeepTauId.cc.

2451  {
2452  static constexpr bool check_all_set = false;
2453  static constexpr float default_value_for_set_check = -42;
2454 
2455  tensorflow::Tensor inputs(tensorflow::DT_FLOAT, {1, dnn_inputs_2017v1::NumberOfInputs});
2456  const auto& get = [&](int var_index) -> float& { return inputs.matrix<float>()(0, var_index); };
2457  auto leadChargedHadrCand = dynamic_cast<const CandidateCastType*>(tau.leadChargedHadrCand().get());
2458 
2459  if (check_all_set) {
2460  for (int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
2461  get(var_index) = default_value_for_set_check;
2462  }
2463  }
2464 
2465  get(dnn::pt) = tau.p4().pt();
2466  get(dnn::eta) = tau.p4().eta();
2467  get(dnn::mass) = tau.p4().mass();
2468  get(dnn::decayMode) = tau.decayMode();
2469  get(dnn::chargedIsoPtSum) = tau_funcs.getChargedIsoPtSum(tau, tau_ref);
2470  get(dnn::neutralIsoPtSum) = tau_funcs.getNeutralIsoPtSum(tau, tau_ref);
2471  get(dnn::neutralIsoPtSumWeight) = tau_funcs.getNeutralIsoPtSumWeight(tau, tau_ref);
2472  get(dnn::photonPtSumOutsideSignalCone) = tau_funcs.getPhotonPtSumOutsideSignalCone(tau, tau_ref);
2473  get(dnn::puCorrPtSum) = tau_funcs.getPuCorrPtSum(tau, tau_ref);
2474  get(dnn::dxy) = tau_funcs.getdxy(tau, tau_index);
2475  get(dnn::dxy_sig) = tau_funcs.getdxySig(tau, tau_index);
2476  get(dnn::dz) = leadChargedHadrCand ? candFunc::getTauDz(*leadChargedHadrCand) : default_value;
2477  get(dnn::ip3d) = tau_funcs.getip3d(tau, tau_index);
2478  get(dnn::ip3d_sig) = tau_funcs.getip3dSig(tau, tau_index);
2479  get(dnn::hasSecondaryVertex) = tau_funcs.getHasSecondaryVertex(tau, tau_index);
2480  get(dnn::flightLength_r) = tau_funcs.getFlightLength(tau, tau_index).R();
2481  get(dnn::flightLength_dEta) = dEta(tau_funcs.getFlightLength(tau, tau_index), tau.p4());
2482  get(dnn::flightLength_dPhi) = dPhi(tau_funcs.getFlightLength(tau, tau_index), tau.p4());
2483  get(dnn::flightLength_sig) = tau_funcs.getFlightLengthSig(tau, tau_index);
2484  get(dnn::leadChargedHadrCand_pt) = leadChargedHadrCand ? leadChargedHadrCand->p4().Pt() : default_value;
2485  get(dnn::leadChargedHadrCand_dEta) =
2486  leadChargedHadrCand ? dEta(leadChargedHadrCand->p4(), tau.p4()) : default_value;
2487  get(dnn::leadChargedHadrCand_dPhi) =
2488  leadChargedHadrCand ? dPhi(leadChargedHadrCand->p4(), tau.p4()) : default_value;
2489  get(dnn::leadChargedHadrCand_mass) = leadChargedHadrCand ? leadChargedHadrCand->p4().mass() : default_value;
2490  get(dnn::pt_weighted_deta_strip) = reco::tau::pt_weighted_deta_strip(tau, tau.decayMode());
2491  get(dnn::pt_weighted_dphi_strip) = reco::tau::pt_weighted_dphi_strip(tau, tau.decayMode());
2492  get(dnn::pt_weighted_dr_signal) = reco::tau::pt_weighted_dr_signal(tau, tau.decayMode());
2493  get(dnn::pt_weighted_dr_iso) = reco::tau::pt_weighted_dr_iso(tau, tau.decayMode());
2494  get(dnn::leadingTrackNormChi2) = tau_funcs.getLeadingTrackNormChi2(tau);
2495  get(dnn::e_ratio) = reco::tau::eratio(tau);
2496  get(dnn::gj_angle_diff) = calculateGottfriedJacksonAngleDifference(tau, tau_index, tau_funcs);
2497  get(dnn::n_photons) = reco::tau::n_photons_total(tau);
2498  get(dnn::emFraction) = tau_funcs.getEmFraction(tau);
2499  get(dnn::has_gsf_track) = leadChargedHadrCand && std::abs(leadChargedHadrCand->pdgId()) == 11;
2500  get(dnn::inside_ecal_crack) = isInEcalCrack(tau.p4().Eta());
2501  auto gsf_ele = findMatchedElectron(tau, electrons, 0.3);
2502  get(dnn::gsf_ele_matched) = gsf_ele != nullptr;
2503  get(dnn::gsf_ele_pt) = gsf_ele != nullptr ? gsf_ele->p4().Pt() : default_value;
2504  get(dnn::gsf_ele_dEta) = gsf_ele != nullptr ? dEta(gsf_ele->p4(), tau.p4()) : default_value;
2505  get(dnn::gsf_ele_dPhi) = gsf_ele != nullptr ? dPhi(gsf_ele->p4(), tau.p4()) : default_value;
2506  get(dnn::gsf_ele_mass) = gsf_ele != nullptr ? gsf_ele->p4().mass() : default_value;
2507  calculateElectronClusterVars(gsf_ele, get(dnn::gsf_ele_Ee), get(dnn::gsf_ele_Egamma));
2508  get(dnn::gsf_ele_Pin) = gsf_ele != nullptr ? gsf_ele->trackMomentumAtVtx().R() : default_value;
2509  get(dnn::gsf_ele_Pout) = gsf_ele != nullptr ? gsf_ele->trackMomentumOut().R() : default_value;
2510  get(dnn::gsf_ele_EtotOverPin) = get(dnn::gsf_ele_Pin) > 0
2511  ? (get(dnn::gsf_ele_Ee) + get(dnn::gsf_ele_Egamma)) / get(dnn::gsf_ele_Pin)
2512  : default_value;
2513  get(dnn::gsf_ele_Eecal) = gsf_ele != nullptr ? gsf_ele->ecalEnergy() : default_value;
2514  get(dnn::gsf_ele_dEta_SeedClusterTrackAtCalo) =
2515  gsf_ele != nullptr ? gsf_ele->deltaEtaSeedClusterTrackAtCalo() : default_value;
2516  get(dnn::gsf_ele_dPhi_SeedClusterTrackAtCalo) =
2517  gsf_ele != nullptr ? gsf_ele->deltaPhiSeedClusterTrackAtCalo() : default_value;
2518  get(dnn::gsf_ele_mvaIn_sigmaEtaEta) = gsf_ele != nullptr ? gsf_ele->mvaInput().sigmaEtaEta : default_value;
2519  get(dnn::gsf_ele_mvaIn_hadEnergy) = gsf_ele != nullptr ? gsf_ele->mvaInput().hadEnergy : default_value;
2520  get(dnn::gsf_ele_mvaIn_deltaEta) = gsf_ele != nullptr ? gsf_ele->mvaInput().deltaEta : default_value;
2521 
2522  get(dnn::gsf_ele_Chi2NormGSF) = default_value;
2523  get(dnn::gsf_ele_GSFNumHits) = default_value;
2524  get(dnn::gsf_ele_GSFTrackResol) = default_value;
2525  get(dnn::gsf_ele_GSFTracklnPt) = default_value;
2526  if (gsf_ele != nullptr && gsf_ele->gsfTrack().isNonnull()) {
2527  get(dnn::gsf_ele_Chi2NormGSF) = gsf_ele->gsfTrack()->normalizedChi2();
2528  get(dnn::gsf_ele_GSFNumHits) = gsf_ele->gsfTrack()->numberOfValidHits();
2529  if (gsf_ele->gsfTrack()->pt() > 0) {
2530  get(dnn::gsf_ele_GSFTrackResol) = gsf_ele->gsfTrack()->ptError() / gsf_ele->gsfTrack()->pt();
2531  get(dnn::gsf_ele_GSFTracklnPt) = std::log10(gsf_ele->gsfTrack()->pt());
2532  }
2533  }
2534 
2535  get(dnn::gsf_ele_Chi2NormKF) = default_value;
2536  get(dnn::gsf_ele_KFNumHits) = default_value;
2537  if (gsf_ele != nullptr && gsf_ele->closestCtfTrackRef().isNonnull()) {
2538  get(dnn::gsf_ele_Chi2NormKF) = gsf_ele->closestCtfTrackRef()->normalizedChi2();
2539  get(dnn::gsf_ele_KFNumHits) = gsf_ele->closestCtfTrackRef()->numberOfValidHits();
2540  }
2541  get(dnn::leadChargedCand_etaAtEcalEntrance) = tau_funcs.getEtaAtEcalEntrance(tau);
2542  get(dnn::leadChargedCand_pt) = leadChargedHadrCand->pt();
2543 
2544  get(dnn::leadChargedHadrCand_HoP) = default_value;
2545  get(dnn::leadChargedHadrCand_EoP) = default_value;
2546  if (leadChargedHadrCand->pt() > 0) {
2547  get(dnn::leadChargedHadrCand_HoP) = tau_funcs.getEcalEnergyLeadingChargedHadr(tau) / leadChargedHadrCand->pt();
2548  get(dnn::leadChargedHadrCand_EoP) = tau_funcs.getHcalEnergyLeadingChargedHadr(tau) / leadChargedHadrCand->pt();
2549  }
2550 
2551  MuonHitMatchV1 muon_hit_match;
2552  if (tau.leadPFChargedHadrCand().isNonnull() && tau.leadPFChargedHadrCand()->muonRef().isNonnull())
2553  muon_hit_match.addMatchedMuon(*tau.leadPFChargedHadrCand()->muonRef(), tau);
2554 
2555  auto matched_muons = muon_hit_match.findMatchedMuons(tau, muons, 0.3, 5);
2556  for (auto muon : matched_muons)
2557  muon_hit_match.addMatchedMuon(*muon, tau);
2558  muon_hit_match.fillTensor<dnn>(get, tau, default_value);
2559 
2560  LorentzVectorXYZ signalChargedHadrCands_sumIn, signalChargedHadrCands_sumOut;
2561  processSignalPFComponents(tau,
2562  tau.signalChargedHadrCands(),
2563  signalChargedHadrCands_sumIn,
2564  signalChargedHadrCands_sumOut,
2565  get(dnn::signalChargedHadrCands_sum_innerSigCone_pt),
2566  get(dnn::signalChargedHadrCands_sum_innerSigCone_dEta),
2567  get(dnn::signalChargedHadrCands_sum_innerSigCone_dPhi),
2568  get(dnn::signalChargedHadrCands_sum_innerSigCone_mass),
2569  get(dnn::signalChargedHadrCands_sum_outerSigCone_pt),
2570  get(dnn::signalChargedHadrCands_sum_outerSigCone_dEta),
2571  get(dnn::signalChargedHadrCands_sum_outerSigCone_dPhi),
2572  get(dnn::signalChargedHadrCands_sum_outerSigCone_mass),
2573  get(dnn::signalChargedHadrCands_nTotal_innerSigCone),
2574  get(dnn::signalChargedHadrCands_nTotal_outerSigCone));
2575 
2576  LorentzVectorXYZ signalNeutrHadrCands_sumIn, signalNeutrHadrCands_sumOut;
2577  processSignalPFComponents(tau,
2578  tau.signalNeutrHadrCands(),
2579  signalNeutrHadrCands_sumIn,
2580  signalNeutrHadrCands_sumOut,
2581  get(dnn::signalNeutrHadrCands_sum_innerSigCone_pt),
2582  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dEta),
2583  get(dnn::signalNeutrHadrCands_sum_innerSigCone_dPhi),
2584  get(dnn::signalNeutrHadrCands_sum_innerSigCone_mass),
2585  get(dnn::signalNeutrHadrCands_sum_outerSigCone_pt),
2586  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dEta),
2587  get(dnn::signalNeutrHadrCands_sum_outerSigCone_dPhi),
2588  get(dnn::signalNeutrHadrCands_sum_outerSigCone_mass),
2589  get(dnn::signalNeutrHadrCands_nTotal_innerSigCone),
2590  get(dnn::signalNeutrHadrCands_nTotal_outerSigCone));
2591 
2592  LorentzVectorXYZ signalGammaCands_sumIn, signalGammaCands_sumOut;
2593  processSignalPFComponents(tau,
2594  tau.signalGammaCands(),
2595  signalGammaCands_sumIn,
2596  signalGammaCands_sumOut,
2597  get(dnn::signalGammaCands_sum_innerSigCone_pt),
2598  get(dnn::signalGammaCands_sum_innerSigCone_dEta),
2599  get(dnn::signalGammaCands_sum_innerSigCone_dPhi),
2600  get(dnn::signalGammaCands_sum_innerSigCone_mass),
2601  get(dnn::signalGammaCands_sum_outerSigCone_pt),
2602  get(dnn::signalGammaCands_sum_outerSigCone_dEta),
2603  get(dnn::signalGammaCands_sum_outerSigCone_dPhi),
2604  get(dnn::signalGammaCands_sum_outerSigCone_mass),
2605  get(dnn::signalGammaCands_nTotal_innerSigCone),
2606  get(dnn::signalGammaCands_nTotal_outerSigCone));
2607 
2608  LorentzVectorXYZ isolationChargedHadrCands_sum;
2609  processIsolationPFComponents(tau,
2610  tau.isolationChargedHadrCands(),
2611  isolationChargedHadrCands_sum,
2612  get(dnn::isolationChargedHadrCands_sum_pt),
2613  get(dnn::isolationChargedHadrCands_sum_dEta),
2614  get(dnn::isolationChargedHadrCands_sum_dPhi),
2615  get(dnn::isolationChargedHadrCands_sum_mass),
2616  get(dnn::isolationChargedHadrCands_nTotal));
2617 
2618  LorentzVectorXYZ isolationNeutrHadrCands_sum;
2619  processIsolationPFComponents(tau,
2620  tau.isolationNeutrHadrCands(),
2621  isolationNeutrHadrCands_sum,
2622  get(dnn::isolationNeutrHadrCands_sum_pt),
2623  get(dnn::isolationNeutrHadrCands_sum_dEta),
2624  get(dnn::isolationNeutrHadrCands_sum_dPhi),
2625  get(dnn::isolationNeutrHadrCands_sum_mass),
2626  get(dnn::isolationNeutrHadrCands_nTotal));
2627 
2628  LorentzVectorXYZ isolationGammaCands_sum;
2629  processIsolationPFComponents(tau,
2630  tau.isolationGammaCands(),
2631  isolationGammaCands_sum,
2632  get(dnn::isolationGammaCands_sum_pt),
2633  get(dnn::isolationGammaCands_sum_dEta),
2634  get(dnn::isolationGammaCands_sum_dPhi),
2635  get(dnn::isolationGammaCands_sum_mass),
2636  get(dnn::isolationGammaCands_nTotal));
2637 
2638  get(dnn::tau_visMass_innerSigCone) = (signalGammaCands_sumIn + signalChargedHadrCands_sumIn).mass();
2639 
2640  if (check_all_set) {
2641  for (int var_index = 0; var_index < dnn::NumberOfInputs; ++var_index) {
2642  if (get(var_index) == default_value_for_set_check)
2643  throw cms::Exception("DeepTauId: variable with index = ") << var_index << " is not set.";
2644  }
2645  }
2646 
2647  return inputs;
2648  }

References funct::abs(), calculateElectronClusterVars(), calculateGottfriedJacksonAngleDifference(), taus_cff::decayMode, default_value, HLT_2018_cff::dEta, HLT_2018_cff::dPhi, PVValHelper::dxy, PVValHelper::dz, pwdgSkimBPark_cfi::electrons, reco::tau::eratio(), PVValHelper::eta, findMatchedElectron(), get, PixelMapPlotter::inputs, electrons_cff::ip3d, isInEcalCrack(), EgHLTOffHistBins_cfi::mass, PDWG_BPHSkim_cff::muons, reco::tau::n_photons_total(), processIsolationPFComponents(), processSignalPFComponents(), DiDispStaMuonMonitor_cfi::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(), and metsig::tau.

◆ createMuonBlockInputs()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::createMuonBlockInputs ( unsigned  idx,
const TauCastType &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const reco::Vertex &  pv,
double  rho,
const std::vector< pat::Muon > *  muons,
const edm::View< reco::Candidate > &  pfCands,
const Cell &  cell_map,
TauFunc  tau_funcs,
bool  is_inner 
)
inlineprivate

Definition at line 2170 of file DeepTauId.cc.

2180  {
2181  namespace dnn = dnn_inputs_2017_v2::MuonBlockInputs;
2182 
2183  tensorflow::Tensor& inputs = *muonTensor_.at(is_inner);
2184 
2185  const auto& get = [&](int var_index) -> float& { return inputs.tensor<float, 4>()(idx, 0, 0, var_index); };
2186 
2187  const bool valid_index_pf_muon = cell_map.count(CellObjectType::PfCand_muon);
2188  const bool valid_index_muon = cell_map.count(CellObjectType::Muon);
2189 
2190  if (!cell_map.empty()) {
2191  get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
2192  get(dnn::tau_pt) = getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
2193  get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
2194  get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.polarP4().eta()));
2195  }
2196  if (valid_index_pf_muon) {
2197  size_t index_pf_muon = cell_map.at(CellObjectType::PfCand_muon);
2198  const auto& muon_cand = dynamic_cast<const CandidateCastType&>(pfCands.at(index_pf_muon));
2199 
2200  get(dnn::pfCand_muon_valid) = valid_index_pf_muon;
2201  get(dnn::pfCand_muon_rel_pt) = getValueNorm(pfCands.at(index_pf_muon).polarP4().pt() / tau.polarP4().pt(),
2202  is_inner ? 0.9509f : 0.0861f,
2203  is_inner ? 0.4294f : 0.4065f);
2204  get(dnn::pfCand_muon_deta) = getValueLinear(pfCands.at(index_pf_muon).polarP4().eta() - tau.polarP4().eta(),
2205  is_inner ? -0.1f : -0.5f,
2206  is_inner ? 0.1f : 0.5f,
2207  false);
2208  get(dnn::pfCand_muon_dphi) = getValueLinear(dPhi(tau.polarP4(), pfCands.at(index_pf_muon).polarP4()),
2209  is_inner ? -0.1f : -0.5f,
2210  is_inner ? 0.1f : 0.5f,
2211  false);
2212  get(dnn::pfCand_muon_pvAssociationQuality) =
2213  getValueLinear<int>(candFunc::getPvAssocationQuality(muon_cand), 0, 7, true);
2214  get(dnn::pfCand_muon_fromPV) = getValueLinear<int>(candFunc::getFromPV(muon_cand), 0, 3, true);
2215  get(dnn::pfCand_muon_puppiWeight) = is_inner ? getValue(candFunc::getPuppiWeight(muon_cand, 0.9786588f))
2216  : getValue(candFunc::getPuppiWeight(muon_cand, 0.8132477f));
2217  get(dnn::pfCand_muon_charge) = getValue(muon_cand.charge());
2218  get(dnn::pfCand_muon_lostInnerHits) = getValue<int>(candFunc::getLostInnerHits(muon_cand, 0));
2219  get(dnn::pfCand_muon_numberOfPixelHits) =
2220  getValueLinear(candFunc::getNumberOfPixelHits(muon_cand, 0), 0, 11, true);
2221  get(dnn::pfCand_muon_vertex_dx) =
2222  getValueNorm(pfCands.at(index_pf_muon).vertex().x() - pv.position().x(), -0.0007f, 0.6869f);
2223  get(dnn::pfCand_muon_vertex_dy) =
2224  getValueNorm(pfCands.at(index_pf_muon).vertex().y() - pv.position().y(), 0.0001f, 0.6784f);
2225  get(dnn::pfCand_muon_vertex_dz) =
2226  getValueNorm(pfCands.at(index_pf_muon).vertex().z() - pv.position().z(), -0.0117f, 4.097f);
2227  get(dnn::pfCand_muon_vertex_dx_tauFL) = getValueNorm(
2228  pfCands.at(index_pf_muon).vertex().x() - pv.position().x() - tau_funcs.getFlightLength(tau, tau_index).x(),
2229  -0.0001f,
2230  0.8642f);
2231  get(dnn::pfCand_muon_vertex_dy_tauFL) = getValueNorm(
2232  pfCands.at(index_pf_muon).vertex().y() - pv.position().y() - tau_funcs.getFlightLength(tau, tau_index).y(),
2233  0.0004f,
2234  0.8561f);
2235  get(dnn::pfCand_muon_vertex_dz_tauFL) = getValueNorm(
2236  pfCands.at(index_pf_muon).vertex().z() - pv.position().z() - tau_funcs.getFlightLength(tau, tau_index).z(),
2237  -0.0118f,
2238  4.405f);
2239 
2240  const bool hasTrackDetails = candFunc::getHasTrackDetails(muon_cand);
2241  if (hasTrackDetails) {
2242  get(dnn::pfCand_muon_hasTrackDetails) = hasTrackDetails;
2243  get(dnn::pfCand_muon_dxy) = getValueNorm(candFunc::getTauDxy(muon_cand), -0.0045f, 0.9655f);
2244  get(dnn::pfCand_muon_dxy_sig) =
2245  getValueNorm(std::abs(candFunc::getTauDxy(muon_cand)) / muon_cand.dxyError(), 4.575f, 42.36f);
2246  get(dnn::pfCand_muon_dz) = getValueNorm(candFunc::getTauDz(muon_cand), -0.0117f, 4.097f);
2247  get(dnn::pfCand_muon_dz_sig) =
2248  getValueNorm(std::abs(candFunc::getTauDz(muon_cand)) / muon_cand.dzError(), 80.37f, 343.3f);
2249  get(dnn::pfCand_muon_track_chi2_ndof) = getValueNorm(
2250  candFunc::getPseudoTrack(muon_cand).chi2() / candFunc::getPseudoTrack(muon_cand).ndof(), 0.69f, 1.711f);
2251  get(dnn::pfCand_muon_track_ndof) = getValueNorm(candFunc::getPseudoTrack(muon_cand).ndof(), 17.5f, 5.11f);
2252  }
2253  }
2254  if (valid_index_muon) {
2255  size_t index_muon = cell_map.at(CellObjectType::Muon);
2256 
2257  get(dnn::muon_valid) = valid_index_muon;
2258  get(dnn::muon_rel_pt) = getValueNorm(muons->at(index_muon).polarP4().pt() / tau.polarP4().pt(),
2259  is_inner ? 0.7966f : 0.2678f,
2260  is_inner ? 3.402f : 3.592f);
2261  get(dnn::muon_deta) = getValueLinear(muons->at(index_muon).polarP4().eta() - tau.polarP4().eta(),
2262  is_inner ? -0.1f : -0.5f,
2263  is_inner ? 0.1f : 0.5f,
2264  false);
2265  get(dnn::muon_dphi) = getValueLinear(dPhi(tau.polarP4(), muons->at(index_muon).polarP4()),
2266  is_inner ? -0.1f : -0.5f,
2267  is_inner ? 0.1f : 0.5f,
2268  false);
2269  get(dnn::muon_dxy) = getValueNorm(muons->at(index_muon).dB(pat::Muon::PV2D), 0.0019f, 1.039f);
2270  get(dnn::muon_dxy_sig) =
2271  getValueNorm(std::abs(muons->at(index_muon).dB(pat::Muon::PV2D)) / muons->at(index_muon).edB(pat::Muon::PV2D),
2272  8.98f,
2273  71.17f);
2274 
2275  const bool normalizedChi2_valid =
2276  muons->at(index_muon).globalTrack().isNonnull() && muons->at(index_muon).normChi2() >= 0;
2277  if (normalizedChi2_valid) {
2278  get(dnn::muon_normalizedChi2_valid) = normalizedChi2_valid;
2279  get(dnn::muon_normalizedChi2) = getValueNorm(muons->at(index_muon).normChi2(), 21.52f, 265.8f);
2280  if (muons->at(index_muon).innerTrack().isNonnull())
2281  get(dnn::muon_numberOfValidHits) = getValueNorm(muons->at(index_muon).numberOfValidHits(), 21.84f, 10.59f);
2282  }
2283  get(dnn::muon_segmentCompatibility) = getValue(muons->at(index_muon).segmentCompatibility());
2284  get(dnn::muon_caloCompatibility) = getValue(muons->at(index_muon).caloCompatibility());
2285 
2286  const bool pfEcalEnergy_valid = muons->at(index_muon).pfEcalEnergy() >= 0;
2287  if (pfEcalEnergy_valid) {
2288  get(dnn::muon_pfEcalEnergy_valid) = pfEcalEnergy_valid;
2289  get(dnn::muon_rel_pfEcalEnergy) =
2290  getValueNorm(muons->at(index_muon).pfEcalEnergy() / muons->at(index_muon).polarP4().pt(), 0.2273f, 0.4865f);
2291  }
2292 
2293  MuonHitMatchV2 hit_match(muons->at(index_muon));
2294  static const std::map<int, std::pair<int, int>> muonMatchHitVars = {
2295  {MuonSubdetId::DT, {dnn::muon_n_matches_DT_1, dnn::muon_n_hits_DT_1}},
2296  {MuonSubdetId::CSC, {dnn::muon_n_matches_CSC_1, dnn::muon_n_hits_CSC_1}},
2297  {MuonSubdetId::RPC, {dnn::muon_n_matches_RPC_1, dnn::muon_n_hits_RPC_1}}};
2298 
2299  static const std::map<int, std::vector<float>> muonMatchVarLimits = {
2300  {MuonSubdetId::DT, {2, 2, 2, 2}}, {MuonSubdetId::CSC, {6, 2, 2, 2}}, {MuonSubdetId::RPC, {7, 6, 4, 4}}};
2301 
2302  static const std::map<int, std::vector<float>> muonHitVarLimits = {{MuonSubdetId::DT, {12, 12, 12, 8}},
2303  {MuonSubdetId::CSC, {24, 12, 12, 12}},
2304  {MuonSubdetId::RPC, {4, 4, 2, 2}}};
2305 
2306  for (int subdet : hit_match.MuonHitMatchV2::consideredSubdets()) {
2307  const auto& matchHitVar = muonMatchHitVars.at(subdet);
2308  const auto& matchLimits = muonMatchVarLimits.at(subdet);
2309  const auto& hitLimits = muonHitVarLimits.at(subdet);
2310  for (int station = MuonHitMatchV2::first_station_id; station <= MuonHitMatchV2::last_station_id; ++station) {
2311  const unsigned n_matches = hit_match.nMatches(subdet, station);
2312  const unsigned n_hits = hit_match.nHits(subdet, station);
2313  get(matchHitVar.first + station - 1) = getValueLinear(n_matches, 0, matchLimits.at(station - 1), true);
2314  get(matchHitVar.second + station - 1) = getValueLinear(n_hits, 0, hitLimits.at(station - 1), true);
2315  }
2316  }
2317  }
2318  }

References funct::abs(), edm::View< T >::at(), hltPixelTracks_cff::chi2, MuonSubdetId::CSC, HLT_2018_cff::dPhi, MuonSubdetId::DT, f, dqmMemoryStats::float, get, getValue(), getValueLinear(), getValueNorm(), training_settings::idx, PixelMapPlotter::inputs, isInEcalCrack(), dumpRecoGeometry_cfg::Muon, PDWG_BPHSkim_cff::muons, muonTensor_, ndof, MetAnalyzer::pv(), pat::Muon::PV2D, rho, ZElectronSkim_cff::rho, MuonSubdetId::RPC, relativeConstraints::station, metsig::tau, runTauDisplay::tau_eta, and runTauDisplay::tau_pt.

◆ createTauBlockInputs()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::createTauBlockInputs ( const TauCastType &  tau,
const size_t &  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const reco::Vertex &  pv,
double  rho,
TauFunc  tau_funcs 
)
inlineprivate

Definition at line 1828 of file DeepTauId.cc.

1833  {
1834  namespace dnn = dnn_inputs_2017_v2::TauBlockInputs;
1835 
1836  tensorflow::Tensor& inputs = *tauBlockTensor_;
1837  inputs.flat<float>().setZero();
1838 
1839  const auto& get = [&](int var_index) -> float& { return inputs.matrix<float>()(0, var_index); };
1840 
1841  auto leadChargedHadrCand = dynamic_cast<const CandidateCastType*>(tau.leadChargedHadrCand().get());
1842 
1843  get(dnn::rho) = getValueNorm(rho, 21.49f, 9.713f);
1844  get(dnn::tau_pt) = getValueLinear(tau.polarP4().pt(), 20.f, 1000.f, true);
1845  get(dnn::tau_eta) = getValueLinear(tau.polarP4().eta(), -2.3f, 2.3f, false);
1846  get(dnn::tau_phi) = getValueLinear(tau.polarP4().phi(), -pi, pi, false);
1847  get(dnn::tau_mass) = getValueNorm(tau.polarP4().mass(), 0.6669f, 0.6553f);
1848  get(dnn::tau_E_over_pt) = getValueLinear(tau.p4().energy() / tau.p4().pt(), 1.f, 5.2f, true);
1849  get(dnn::tau_charge) = getValue(tau.charge());
1850  get(dnn::tau_n_charged_prongs) = getValueLinear(tau.decayMode() / 5 + 1, 1, 3, true);
1851  get(dnn::tau_n_neutral_prongs) = getValueLinear(tau.decayMode() % 5, 0, 2, true);
1852  get(dnn::chargedIsoPtSum) = getValueNorm(tau_funcs.getChargedIsoPtSum(tau, tau_ref), 47.78f, 123.5f);
1853  get(dnn::chargedIsoPtSumdR03_over_dR05) =
1854  getValue(tau_funcs.getChargedIsoPtSumdR03(tau, tau_ref) / tau_funcs.getChargedIsoPtSum(tau, tau_ref));
1855  get(dnn::footprintCorrection) = getValueNorm(tau_funcs.getFootprintCorrectiondR03(tau, tau_ref), 9.029f, 26.42f);
1856  get(dnn::neutralIsoPtSum) = getValueNorm(tau_funcs.getNeutralIsoPtSum(tau, tau_ref), 57.59f, 155.3f);
1857  get(dnn::neutralIsoPtSumWeight_over_neutralIsoPtSum) =
1858  getValue(tau_funcs.getNeutralIsoPtSumWeight(tau, tau_ref) / tau_funcs.getNeutralIsoPtSum(tau, tau_ref));
1859  get(dnn::neutralIsoPtSumWeightdR03_over_neutralIsoPtSum) =
1860  getValue(tau_funcs.getNeutralIsoPtSumdR03Weight(tau, tau_ref) / tau_funcs.getNeutralIsoPtSum(tau, tau_ref));
1861  get(dnn::neutralIsoPtSumdR03_over_dR05) =
1862  getValue(tau_funcs.getNeutralIsoPtSumdR03(tau, tau_ref) / tau_funcs.getNeutralIsoPtSum(tau, tau_ref));
1863  get(dnn::photonPtSumOutsideSignalCone) =
1864  getValueNorm(tau_funcs.getPhotonPtSumOutsideSignalCone(tau, tau_ref), 1.731f, 6.846f);
1865  get(dnn::puCorrPtSum) = getValueNorm(tau_funcs.getPuCorrPtSum(tau, tau_ref), 22.38f, 16.34f);
1866  // The global PCA coordinates were used as inputs during the NN training, but it was decided to disable
1867  // them for the inference, because modeling of dxy_PCA in MC poorly describes the data, and x and y coordinates
1868  // in data results outside of the expected 5 std. dev. input validity range. On the other hand,
1869  // these coordinates are strongly era-dependent. Kept as comment to document what NN expects.
1870  if (!disable_dxy_pca_) {
1871  auto const pca = tau_funcs.getdxyPCA(tau, tau_index);
1872  get(dnn::tau_dxy_pca_x) = getValueNorm(pca.x(), -0.0241f, 0.0074f);
1873  get(dnn::tau_dxy_pca_y) = getValueNorm(pca.y(), 0.0675f, 0.0128f);
1874  get(dnn::tau_dxy_pca_z) = getValueNorm(pca.z(), 0.7973f, 3.456f);
1875  } else {
1876  get(dnn::tau_dxy_pca_x) = 0;
1877  get(dnn::tau_dxy_pca_y) = 0;
1878  get(dnn::tau_dxy_pca_z) = 0;
1879  }
1880  const bool tau_dxy_valid =
1881  isAbove(tau_funcs.getdxy(tau, tau_index), -10) && isAbove(tau_funcs.getdxyError(tau, tau_index), 0);
1882  if (tau_dxy_valid) {
1883  get(dnn::tau_dxy_valid) = tau_dxy_valid;
1884  get(dnn::tau_dxy) = getValueNorm(tau_funcs.getdxy(tau, tau_index), 0.0018f, 0.0085f);
1885  get(dnn::tau_dxy_sig) = getValueNorm(
1886  std::abs(tau_funcs.getdxy(tau, tau_index)) / tau_funcs.getdxyError(tau, tau_index), 2.26f, 4.191f);
1887  }
1888  const bool tau_ip3d_valid =
1889  isAbove(tau_funcs.getip3d(tau, tau_index), -10) && isAbove(tau_funcs.getip3dError(tau, tau_index), 0);
1890  if (tau_ip3d_valid) {
1891  get(dnn::tau_ip3d_valid) = tau_ip3d_valid;
1892  get(dnn::tau_ip3d) = getValueNorm(tau_funcs.getip3d(tau, tau_index), 0.0026f, 0.0114f);
1893  get(dnn::tau_ip3d_sig) = getValueNorm(
1894  std::abs(tau_funcs.getip3d(tau, tau_index)) / tau_funcs.getip3dError(tau, tau_index), 2.928f, 4.466f);
1895  }
1896  if (leadChargedHadrCand) {
1897  const bool hasTrackDetails = candFunc::getHasTrackDetails(*leadChargedHadrCand);
1898  const float tau_dz = (is_online_ && !hasTrackDetails) ? 0 : candFunc::getTauDz(*leadChargedHadrCand);
1899  get(dnn::tau_dz) = getValueNorm(tau_dz, 0.f, 0.0190f);
1900  get(dnn::tau_dz_sig_valid) = candFunc::getTauDZSigValid(*leadChargedHadrCand);
1901  const double dzError = hasTrackDetails ? leadChargedHadrCand->dzError() : -999.;
1902  get(dnn::tau_dz_sig) = getValueNorm(std::abs(tau_dz) / dzError, 4.717f, 11.78f);
1903  }
1904  get(dnn::tau_flightLength_x) = getValueNorm(tau_funcs.getFlightLength(tau, tau_index).x(), -0.0003f, 0.7362f);
1905  get(dnn::tau_flightLength_y) = getValueNorm(tau_funcs.getFlightLength(tau, tau_index).y(), -0.0009f, 0.7354f);
1906  get(dnn::tau_flightLength_z) = getValueNorm(tau_funcs.getFlightLength(tau, tau_index).z(), -0.0022f, 1.993f);
1907  get(dnn::tau_flightLength_sig) = 0.55756444; //This value is set due to a bug in the training
1908  get(dnn::tau_pt_weighted_deta_strip) =
1909  getValueLinear(reco::tau::pt_weighted_deta_strip(tau, tau.decayMode()), 0, 1, true);
1910 
1911  get(dnn::tau_pt_weighted_dphi_strip) =
1912  getValueLinear(reco::tau::pt_weighted_dphi_strip(tau, tau.decayMode()), 0, 1, true);
1913  get(dnn::tau_pt_weighted_dr_signal) =
1914  getValueNorm(reco::tau::pt_weighted_dr_signal(tau, tau.decayMode()), 0.0052f, 0.01433f);
1915  get(dnn::tau_pt_weighted_dr_iso) = getValueLinear(reco::tau::pt_weighted_dr_iso(tau, tau.decayMode()), 0, 1, true);
1916  get(dnn::tau_leadingTrackNormChi2) = getValueNorm(tau_funcs.getLeadingTrackNormChi2(tau), 1.538f, 4.401f);
1917  const auto eratio = reco::tau::eratio(tau);
1918  const bool tau_e_ratio_valid = std::isnormal(eratio) && eratio > 0.f;
1919  get(dnn::tau_e_ratio_valid) = tau_e_ratio_valid;
1920  get(dnn::tau_e_ratio) = tau_e_ratio_valid ? getValueLinear(eratio, 0, 1, true) : 0.f;
1921  const double gj_angle_diff = calculateGottfriedJacksonAngleDifference(tau, tau_index, tau_funcs);
1922  const bool tau_gj_angle_diff_valid = (std::isnormal(gj_angle_diff) || gj_angle_diff == 0) && gj_angle_diff >= 0;
1923  get(dnn::tau_gj_angle_diff_valid) = tau_gj_angle_diff_valid;
1924  get(dnn::tau_gj_angle_diff) = tau_gj_angle_diff_valid ? getValueLinear(gj_angle_diff, 0, pi, true) : 0;
1925  get(dnn::tau_n_photons) = getValueNorm(reco::tau::n_photons_total(tau), 2.95f, 3.927f);
1926  get(dnn::tau_emFraction) = getValueLinear(tau_funcs.getEmFraction(tau), -1, 1, false);
1927 
1928  get(dnn::tau_inside_ecal_crack) = getValue(isInEcalCrack(tau.p4().eta()));
1929  get(dnn::leadChargedCand_etaAtEcalEntrance_minus_tau_eta) =
1930  getValueNorm(tau_funcs.getEtaAtEcalEntrance(tau) - tau.p4().eta(), 0.0042f, 0.0323f);
1931  }

References funct::abs(), calculateGottfriedJacksonAngleDifference(), disable_dxy_pca_, reco::tau::eratio(), f, get, getValue(), getValueLinear(), getValueNorm(), PixelMapPlotter::inputs, deep_tau::DeepTauBase::is_online_, isAbove(), isInEcalCrack(), reco::tau::n_photons_total(), pi, reco::tau::pt_weighted_deta_strip(), reco::tau::pt_weighted_dphi_strip(), reco::tau::pt_weighted_dr_iso(), reco::tau::pt_weighted_dr_signal(), rho, ZElectronSkim_cff::rho, metsig::tau, runTauDisplay::tau_eta, runTauDisplay::tau_mass, runTauDisplay::tau_phi, runTauDisplay::tau_pt, and tauBlockTensor_.

◆ fillDescriptions()

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

Definition at line 1146 of file DeepTauId.cc.

1146  {
1147  edm::ParameterSetDescription desc;
1148  desc.add<edm::InputTag>("electrons", edm::InputTag("slimmedElectrons"));
1149  desc.add<edm::InputTag>("muons", edm::InputTag("slimmedMuons"));
1150  desc.add<edm::InputTag>("taus", edm::InputTag("slimmedTaus"));
1151  desc.add<edm::InputTag>("pfcands", edm::InputTag("packedPFCandidates"));
1152  desc.add<edm::InputTag>("vertices", edm::InputTag("offlineSlimmedPrimaryVertices"));
1153  desc.add<edm::InputTag>("rho", edm::InputTag("fixedGridRhoAll"));
1154  desc.add<std::vector<std::string>>("graph_file",
1155  {"RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6.pb"});
1156  desc.add<bool>("mem_mapped", false);
1157  desc.add<unsigned>("version", 2);
1158  desc.add<int>("debug_level", 0);
1159  desc.add<bool>("disable_dxy_pca", false);
1160  desc.add<bool>("disable_hcalFraction_workaround", false);
1161  desc.add<bool>("disable_CellIndex_workaround", false);
1162  desc.add<bool>("save_inputs", false);
1163  desc.add<bool>("is_online", false);
1164 
1165  desc.add<std::vector<std::string>>("VSeWP");
1166  desc.add<std::vector<std::string>>("VSmuWP");
1167  desc.add<std::vector<std::string>>("VSjetWP");
1168 
1169  desc.addUntracked<edm::InputTag>("basicTauDiscriminators", edm::InputTag("basicTauDiscriminators"));
1170  desc.addUntracked<edm::InputTag>("basicTauDiscriminatorsdR03", edm::InputTag("basicTauDiscriminatorsdR03"));
1171  desc.add<edm::InputTag>("pfTauTransverseImpactParameters", edm::InputTag("hpsPFTauTransverseImpactParameters"));
1172 
1173  {
1174  edm::ParameterSetDescription pset_Prediscriminants;
1175  pset_Prediscriminants.add<std::string>("BooleanOperator", "and");
1176  {
1177  edm::ParameterSetDescription psd1;
1178  psd1.add<double>("cut");
1179  psd1.add<edm::InputTag>("Producer");
1180  pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("decayMode", psd1);
1181  }
1182  desc.add<edm::ParameterSetDescription>("Prediscriminants", pset_Prediscriminants);
1183  }
1184 
1185  descriptions.add("DeepTau", desc);
1186  }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addUntracked(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ fillGrids()

template<typename Collection , typename TauCastType >
void DeepTauId::fillGrids ( const TauCastType &  tau,
const Collection &  objects,
CellGrid &  inner_grid,
CellGrid &  outer_grid 
)
inlineprivate

Definition at line 1675 of file DeepTauId.cc.

1675  {
1676  static constexpr double outer_dR2 = 0.25; //0.5^2
1677  const double inner_radius = getInnerSignalConeRadius(tau.polarP4().pt());
1678  const double inner_dR2 = std::pow(inner_radius, 2);
1679 
1680  const auto addObject = [&](size_t n, double deta, double dphi, CellGrid& grid) {
1681  const auto& obj = objects.at(n);
1682  const CellObjectType obj_type = GetCellObjectType(obj);
1683  if (obj_type == CellObjectType::Other)
1684  return;
1685  CellIndex cell_index;
1686  if (grid.tryGetCellIndex(deta, dphi, cell_index)) {
1687  Cell& cell = grid[cell_index];
1688  auto iter = cell.find(obj_type);
1689  if (iter != cell.end()) {
1690  const auto& prev_obj = objects.at(iter->second);
1691  if (obj.polarP4().pt() > prev_obj.polarP4().pt())
1692  iter->second = n;
1693  } else {
1694  cell[obj_type] = n;
1695  }
1696  }
1697  };
1698 
1699  for (size_t n = 0; n < objects.size(); ++n) {
1700  const auto& obj = objects.at(n);
1701  const double deta = obj.polarP4().eta() - tau.polarP4().eta();
1702  const double dphi = reco::deltaPhi(obj.polarP4().phi(), tau.polarP4().phi());
1703  const double dR2 = std::pow(deta, 2) + std::pow(dphi, 2);
1704  if (dR2 < inner_dR2)
1705  addObject(n, deta, dphi, inner_grid);
1706  if (dR2 < outer_dR2)
1707  addObject(n, deta, dphi, outer_grid);
1708  }
1709  }

References reco::deltaPhi(), getInnerSignalConeRadius(), getRunAppsInfo::grid, dqmiodumpmetadata::n, getGTfromDQMFile::obj, funct::pow(), and metsig::tau.

Referenced by getPredictionsV2().

◆ findMatchedElectron()

template<typename TauCastType >
static const pat::Electron* DeepTauId::findMatchedElectron ( const TauCastType &  tau,
const std::vector< pat::Electron > *  electrons,
double  deltaR 
)
inlinestaticprivate

Definition at line 2781 of file DeepTauId.cc.

2783  {
2784  const double dR2 = deltaR * deltaR;
2785  const pat::Electron* matched_ele = nullptr;
2786  for (const auto& ele : *electrons) {
2787  if (reco::deltaR2(tau.p4(), ele.p4()) < dR2 && (!matched_ele || matched_ele->pt() < ele.pt())) {
2788  matched_ele = &ele;
2789  }
2790  }
2791  return matched_ele;
2792  }

References PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::deltaR2(), pwdgSkimBPark_cfi::electrons, reco::LeafCandidate::pt(), and metsig::tau.

Referenced by createInputsV1().

◆ getInnerSignalConeRadius()

static double DeepTauId::getInnerSignalConeRadius ( double  pt)
inlinestaticprivate

Definition at line 2736 of file DeepTauId.cc.

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

References SiStripPI::max, cosmictrackSelector_cfi::min_pt, and DiDispStaMuonMonitor_cfi::pt.

Referenced by fillGrids(), and processSignalPFComponents().

◆ GetOutputs()

static const OutputCollection& DeepTauId::GetOutputs ( )
inlinestatic

Definition at line 1104 of file DeepTauId.cc.

1104  {
1105  static constexpr size_t e_index = 0, mu_index = 1, tau_index = 2, jet_index = 3;
1106  static const OutputCollection outputs_ = {
1107  {"VSe", Output({tau_index}, {e_index, tau_index})},
1108  {"VSmu", Output({tau_index}, {mu_index, tau_index})},
1109  {"VSjet", Output({tau_index}, {jet_index, tau_index})},
1110  };
1111  return outputs_;
1112  }

References Output, and deep_tau::DeepTauBase::outputs_.

◆ getPartialPredictions()

tensorflow::Tensor DeepTauId::getPartialPredictions ( bool  is_inner)
inlineprivate

Definition at line 1711 of file DeepTauId.cc.

1711  {
1712  std::vector<tensorflow::Tensor> pred_vector;
1713  if (is_inner) {
1714  tensorflow::run(&(cache_->getSession("inner")),
1715  {
1716  {"input_inner_egamma", *eGammaTensor_.at(is_inner)},
1717  {"input_inner_muon", *muonTensor_.at(is_inner)},
1718  {"input_inner_hadrons", *hadronsTensor_.at(is_inner)},
1719  },
1720  {"inner_all_dropout_4/Identity"},
1721  &pred_vector);
1722  } else {
1723  tensorflow::run(&(cache_->getSession("outer")),
1724  {
1725  {"input_outer_egamma", *eGammaTensor_.at(is_inner)},
1726  {"input_outer_muon", *muonTensor_.at(is_inner)},
1727  {"input_outer_hadrons", *hadronsTensor_.at(is_inner)},
1728  },
1729  {"outer_all_dropout_4/Identity"},
1730  &pred_vector);
1731  }
1732  return pred_vector.at(0);
1733  }

References deep_tau::DeepTauBase::cache_, eGammaTensor_, deep_tau::DeepTauCache::getSession(), hadronsTensor_, muonTensor_, and tensorflow::run().

Referenced by createConvFeatures(), and DeepTauId().

◆ getPredictions()

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

Implements deep_tau::DeepTauBase.

Definition at line 1422 of file DeepTauId.cc.

1422  {
1423  // Empty dummy vectors
1424  const std::vector<pat::Electron> electron_collection_default;
1425  const std::vector<pat::Muon> muon_collection_default;
1426  const reco::TauDiscriminatorContainer basicTauDiscriminators_default;
1427  const reco::TauDiscriminatorContainer basicTauDiscriminatorsdR03_default;
1428  const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>
1429  pfTauTransverseImpactParameters_default;
1430 
1431  const std::vector<pat::Electron>* electron_collection;
1432  const std::vector<pat::Muon>* muon_collection;
1433  const reco::TauDiscriminatorContainer* basicTauDiscriminators;
1434  const reco::TauDiscriminatorContainer* basicTauDiscriminatorsdR03;
1435  const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>*
1436  pfTauTransverseImpactParameters;
1437 
1438  if (!is_online_) {
1439  electron_collection = &event.get(electrons_token_);
1440  muon_collection = &event.get(muons_token_);
1441  pfTauTransverseImpactParameters = &pfTauTransverseImpactParameters_default;
1442  basicTauDiscriminators = &basicTauDiscriminators_default;
1443  basicTauDiscriminatorsdR03 = &basicTauDiscriminatorsdR03_default;
1444  } else {
1445  electron_collection = &electron_collection_default;
1446  muon_collection = &muon_collection_default;
1447  pfTauTransverseImpactParameters = &event.get(pfTauTransverseImpactParameters_token_);
1448  basicTauDiscriminators = &event.get(basicTauDiscriminators_inputToken_);
1449  basicTauDiscriminatorsdR03 = &event.get(basicTauDiscriminatorsdR03_inputToken_);
1450 
1451  // Get indices for discriminators
1452  if (!discrIndicesMapped_) {
1453  basicDiscrIndexMap_ =
1454  matchDiscriminatorIndices(event, basicTauDiscriminators_inputToken_, requiredBasicDiscriminators_);
1455  basicDiscrdR03IndexMap_ =
1456  matchDiscriminatorIndices(event, basicTauDiscriminatorsdR03_inputToken_, requiredBasicDiscriminatorsdR03_);
1457  discrIndicesMapped_ = true;
1458  }
1459  }
1460 
1461  TauFunc tauIDs = {basicTauDiscriminators,
1462  basicTauDiscriminatorsdR03,
1463  pfTauTransverseImpactParameters,
1464  basicDiscrIndexMap_,
1465  basicDiscrdR03IndexMap_};
1466 
1467  edm::Handle<edm::View<reco::Candidate>> pfCands;
1468  event.getByToken(pfcandToken_, pfCands);
1469 
1470  edm::Handle<reco::VertexCollection> vertices;
1471  event.getByToken(vtxToken_, vertices);
1472 
1473  edm::Handle<double> rho;
1474  event.getByToken(rho_token_, rho);
1475 
1476  tensorflow::Tensor predictions(tensorflow::DT_FLOAT, {static_cast<int>(taus->size()), deep_tau::NumberOfOutputs});
1477 
1478  for (size_t tau_index = 0; tau_index < taus->size(); ++tau_index) {
1479  const edm::RefToBase<reco::BaseTau> tauRef = taus->refAt(tau_index);
1480 
1481  std::vector<tensorflow::Tensor> pred_vector;
1482 
1483  bool passesPrediscriminants;
1484  if (is_online_) {
1485  passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<reco::PFTauDiscriminator>>>(
1486  recoPrediscriminants_, andPrediscriminants_, tauRef);
1487  } else {
1488  passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<pat::PATTauDiscriminator>>>(
1489  patPrediscriminants_, andPrediscriminants_, tauRef);
1490  }
1491 
1492  if (passesPrediscriminants) {
1493  if (version_ == 1) {
1494  if (is_online_)
1495  getPredictionsV1<reco::PFCandidate, reco::PFTau>(
1496  taus->at(tau_index), tau_index, tauRef, electron_collection, muon_collection, pred_vector, tauIDs);
1497  else
1498  getPredictionsV1<pat::PackedCandidate, pat::Tau>(
1499  taus->at(tau_index), tau_index, tauRef, electron_collection, muon_collection, pred_vector, tauIDs);
1500  } else if (version_ == 2) {
1501  if (is_online_) {
1502  getPredictionsV2<reco::PFCandidate, reco::PFTau>(taus->at(tau_index),
1503  tau_index,
1504  tauRef,
1505  electron_collection,
1506  muon_collection,
1507  *pfCands,
1508  vertices->at(0),
1509  *rho,
1510  pred_vector,
1511  tauIDs);
1512  } else
1513  getPredictionsV2<pat::PackedCandidate, pat::Tau>(taus->at(tau_index),
1514  tau_index,
1515  tauRef,
1516  electron_collection,
1517  muon_collection,
1518  *pfCands,
1519  vertices->at(0),
1520  *rho,
1521  pred_vector,
1522  tauIDs);
1523  } else {
1524  throw cms::Exception("DeepTauId") << "version " << version_ << " is not supported.";
1525  }
1526 
1527  for (int k = 0; k < deep_tau::NumberOfOutputs; ++k) {
1528  const float pred = pred_vector[0].flat<float>()(k);
1529  if (!(pred >= 0 && pred <= 1))
1530  throw cms::Exception("DeepTauId")
1531  << "invalid prediction = " << pred << " for tau_index = " << tau_index << ", pred_index = " << k;
1532  predictions.matrix<float>()(tau_index, k) = pred;
1533  }
1534  }
1535  }
1536  return predictions;
1537  }

References deep_tau::DeepTauBase::andPrediscriminants_, basicDiscrdR03IndexMap_, basicDiscrIndexMap_, basicTauDiscriminators_inputToken_, basicTauDiscriminatorsdR03_inputToken_, discrIndicesMapped_, electrons_token_, Exception, edm::ValueMap< T >::get(), deep_tau::DeepTauBase::is_online_, dqmdumpme::k, matchDiscriminatorIndices(), muons_token_, deep_tau::NumberOfOutputs, deep_tau::DeepTauBase::patPrediscriminants_, deep_tau::DeepTauBase::pfcandToken_, pfTauTransverseImpactParameters_token_, deep_tau::DeepTauBase::recoPrediscriminants_, deep_tau::DeepTauBase::requiredBasicDiscriminators_, deep_tau::DeepTauBase::requiredBasicDiscriminatorsdR03_, rho, rho_token_, Tau3MuMonitor_cff::taus, version_, pwdgSkimBPark_cfi::vertices, and deep_tau::DeepTauBase::vtxToken_.

◆ getPredictionsV1()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::getPredictionsV1 ( TauCollection::const_reference &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const std::vector< pat::Electron > *  electrons,
const std::vector< pat::Muon > *  muons,
std::vector< tensorflow::Tensor > &  pred_vector,
TauFunc  tau_funcs 
)
inlineprivate

Definition at line 1540 of file DeepTauId.cc.

1546  {
1547  const tensorflow::Tensor& inputs = createInputsV1<dnn_inputs_2017v1, const CandidateCastType>(
1548  dynamic_cast<const TauCastType&>(tau), tau_index, tau_ref, electrons, muons, tau_funcs);
1549  tensorflow::run(&(cache_->getSession()), {{input_layer_, inputs}}, {output_layer_}, &pred_vector);
1550  }

References deep_tau::DeepTauBase::cache_, pwdgSkimBPark_cfi::electrons, deep_tau::DeepTauCache::getSession(), input_layer_, PixelMapPlotter::inputs, PDWG_BPHSkim_cff::muons, output_layer_, tensorflow::run(), and metsig::tau.

◆ getPredictionsV2()

template<typename CandidateCastType , typename TauCastType >
void DeepTauId::getPredictionsV2 ( TauCollection::const_reference &  tau,
const size_t  tau_index,
const edm::RefToBase< reco::BaseTau >  tau_ref,
const std::vector< pat::Electron > *  electrons,
const std::vector< pat::Muon > *  muons,
const edm::View< reco::Candidate > &  pfCands,
const reco::Vertex &  pv,
double  rho,
std::vector< tensorflow::Tensor > &  pred_vector,
TauFunc  tau_funcs 
)
inlineprivate

Definition at line 1553 of file DeepTauId.cc.

1562  {
1563  if (debug_level >= 2) {
1564  std::cout << "<DeepTauId::getPredictionsV2 (moduleLabel = " << moduleDescription().moduleLabel()
1565  << ")>:" << std::endl;
1566  std::cout << " tau: pT = " << tau.pt() << ", eta = " << tau.eta() << ", phi = " << tau.phi() << std::endl;
1567  }
1568  CellGrid inner_grid(dnn_inputs_2017_v2::number_of_inner_cell,
1569  dnn_inputs_2017_v2::number_of_inner_cell,
1570  0.02,
1571  0.02,
1572  disable_CellIndex_workaround_);
1573  CellGrid outer_grid(dnn_inputs_2017_v2::number_of_outer_cell,
1574  dnn_inputs_2017_v2::number_of_outer_cell,
1575  0.05,
1576  0.05,
1577  disable_CellIndex_workaround_);
1578  fillGrids(dynamic_cast<const TauCastType&>(tau), *electrons, inner_grid, outer_grid);
1579  fillGrids(dynamic_cast<const TauCastType&>(tau), *muons, inner_grid, outer_grid);
1580  fillGrids(dynamic_cast<const TauCastType&>(tau), pfCands, inner_grid, outer_grid);
1581 
1582  createTauBlockInputs<CandidateCastType>(
1583  dynamic_cast<const TauCastType&>(tau), tau_index, tau_ref, pv, rho, tau_funcs);
1584  using namespace dnn_inputs_2017_v2;
1585  checkInputs(*tauBlockTensor_, "input_tau", TauBlockInputs::NumberOfInputs);
1586  createConvFeatures<CandidateCastType>(dynamic_cast<const TauCastType&>(tau),
1587  tau_index,
1588  tau_ref,
1589  pv,
1590  rho,
1591  electrons,
1592  muons,
1593  pfCands,
1594  inner_grid,
1595  tau_funcs,
1596  true);
1597  checkInputs(*eGammaTensor_[true], "input_inner_egamma", EgammaBlockInputs::NumberOfInputs, &inner_grid);
1598  checkInputs(*muonTensor_[true], "input_inner_muon", MuonBlockInputs::NumberOfInputs, &inner_grid);
1599  checkInputs(*hadronsTensor_[true], "input_inner_hadrons", HadronBlockInputs::NumberOfInputs, &inner_grid);
1600  createConvFeatures<CandidateCastType>(dynamic_cast<const TauCastType&>(tau),
1601  tau_index,
1602  tau_ref,
1603  pv,
1604  rho,
1605  electrons,
1606  muons,
1607  pfCands,
1608  outer_grid,
1609  tau_funcs,
1610  false);
1611  checkInputs(*eGammaTensor_[false], "input_outer_egamma", EgammaBlockInputs::NumberOfInputs, &outer_grid);
1612  checkInputs(*muonTensor_[false], "input_outer_muon", MuonBlockInputs::NumberOfInputs, &outer_grid);
1613  checkInputs(*hadronsTensor_[false], "input_outer_hadrons", HadronBlockInputs::NumberOfInputs, &outer_grid);
1614 
1615  if (save_inputs_) {
1616  std::string json_file_name = "DeepTauId_" + std::to_string(file_counter_) + ".json";
1617  json_file_ = new std::ofstream(json_file_name.data());
1618  is_first_block_ = true;
1619  (*json_file_) << "{";
1620  saveInputs(*tauBlockTensor_, "input_tau", dnn_inputs_2017_v2::TauBlockInputs::NumberOfInputs);
1621  saveInputs(*eGammaTensor_[true],
1622  "input_inner_egamma",
1623  dnn_inputs_2017_v2::EgammaBlockInputs::NumberOfInputs,
1624  &inner_grid);
1625  saveInputs(
1626  *muonTensor_[true], "input_inner_muon", dnn_inputs_2017_v2::MuonBlockInputs::NumberOfInputs, &inner_grid);
1627  saveInputs(*hadronsTensor_[true],
1628  "input_inner_hadrons",
1629  dnn_inputs_2017_v2::HadronBlockInputs::NumberOfInputs,
1630  &inner_grid);
1631  saveInputs(*eGammaTensor_[false],
1632  "input_outer_egamma",
1633  dnn_inputs_2017_v2::EgammaBlockInputs::NumberOfInputs,
1634  &outer_grid);
1635  saveInputs(
1636  *muonTensor_[false], "input_outer_muon", dnn_inputs_2017_v2::MuonBlockInputs::NumberOfInputs, &outer_grid);
1637  saveInputs(*hadronsTensor_[false],
1638  "input_outer_hadrons",
1639  dnn_inputs_2017_v2::HadronBlockInputs::NumberOfInputs,
1640  &outer_grid);
1641  (*json_file_) << "}";
1642  delete json_file_;
1643  ++file_counter_;
1644  }
1645 
1646  tensorflow::run(&(cache_->getSession("core")),
1647  {{"input_tau", *tauBlockTensor_},
1648  {"input_inner", *convTensor_.at(true)},
1649  {"input_outer", *convTensor_.at(false)}},
1650  {"main_output/Softmax"},
1651  &pred_vector);
1652  if (debug_level >= 1) {
1653  std::cout << "output = { ";
1654  for (int idx = 0; idx < deep_tau::NumberOfOutputs; ++idx) {
1655  if (idx > 0)
1656  std::cout << ", ";
1657  std::string label;
1658  if (idx == 0)
1659  label = "e";
1660  else if (idx == 1)
1661  label = "mu";
1662  else if (idx == 2)
1663  label = "tau";
1664  else if (idx == 3)
1665  label = "jet";
1666  else
1667  assert(0);
1668  std::cout << label << " = " << pred_vector[0].flat<float>()(idx);
1669  }
1670  std::cout << " }" << std::endl;
1671  }
1672  }

References cms::cuda::assert(), deep_tau::DeepTauBase::cache_, checkInputs(), convTensor_, gather_cfg::cout, debug_level, disable_CellIndex_workaround_, eGammaTensor_, pwdgSkimBPark_cfi::electrons, file_counter_, fillGrids(), deep_tau::DeepTauCache::getSession(), hadronsTensor_, training_settings::idx, is_first_block_, json_file_, label, PDWG_BPHSkim_cff::muons, muonTensor_, deep_tau::NumberOfOutputs, MetAnalyzer::pv(), rho, tensorflow::run(), save_inputs_, saveInputs(), AlCaHLTBitMon_QueryRunRegistry::string, metsig::tau, and tauBlockTensor_.

◆ getValue()

template<typename T >
static float DeepTauId::getValue ( T  value)
inlinestaticprivate

Definition at line 1259 of file DeepTauId.cc.

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

Referenced by createEgammaBlockInputs(), createHadronsBlockInputs(), createMuonBlockInputs(), createTauBlockInputs(), getValueLinear(), and getValueNorm().

◆ getValueLinear()

template<typename T >
static float DeepTauId::getValueLinear ( T  value,
float  min_value,
float  max_value,
bool  positive 
)
inlinestaticprivate

Definition at line 1264 of file DeepTauId.cc.

1264  {
1265  const float fixed_value = getValue(value);
1266  const float clamped_value = std::clamp(fixed_value, min_value, max_value);
1267  float transformed_value = (clamped_value - min_value) / (max_value - min_value);
1268  if (!positive)
1269  transformed_value = transformed_value * 2 - 1;
1270  return transformed_value;
1271  }

References getValue(), hcaldqm::quantity::max_value, and hcaldqm::quantity::min_value.

Referenced by createEgammaBlockInputs(), createHadronsBlockInputs(), createMuonBlockInputs(), and createTauBlockInputs().

◆ getValueNorm()

template<typename T >
static float DeepTauId::getValueNorm ( T  value,
float  mean,
float  sigma,
float  n_sigmas_max = 5 
)
inlinestaticprivate

Definition at line 1274 of file DeepTauId.cc.

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

References getValue(), and SiStripPI::mean.

Referenced by createEgammaBlockInputs(), createHadronsBlockInputs(), createMuonBlockInputs(), and createTauBlockInputs().

◆ globalEndJob()

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

Definition at line 1253 of file DeepTauId.cc.

1253 { return DeepTauBase::globalEndJob(cache_); }

References deep_tau::DeepTauBase::cache_.

◆ initializeGlobalCache()

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

Definition at line 1249 of file DeepTauId.cc.

1249  {
1250  return DeepTauBase::initializeGlobalCache(cfg);
1251  }

References looper::cfg.

◆ isAbove()

static bool DeepTauId::isAbove ( double  value,
double  min 
)
inlinestaticprivate

Definition at line 1280 of file DeepTauId.cc.

1280 { return std::isnormal(value) && value > min; }

References min().

Referenced by createTauBlockInputs().

◆ isInEcalCrack()

static bool DeepTauId::isInEcalCrack ( double  eta)
inlinestaticprivate

Definition at line 2775 of file DeepTauId.cc.

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

References funct::abs(), and PVValHelper::eta.

Referenced by createEgammaBlockInputs(), createHadronsBlockInputs(), createInputsV1(), createMuonBlockInputs(), and createTauBlockInputs().

◆ matchDiscriminatorIndices()

const std::map<BasicDiscriminator, size_t> DeepTauId::matchDiscriminatorIndices ( edm::Event &  event,
edm::EDGetTokenT< reco::TauDiscriminatorContainer >  discriminatorContainerToken,
std::vector< BasicDiscriminator >  requiredDiscr 
)
inline

Definition at line 1114 of file DeepTauId.cc.

1117  {
1118  std::map<std::string, size_t> discrIndexMapStr;
1119  auto const aHandle = event.getHandle(discriminatorContainerToken);
1120  auto const aProv = aHandle.provenance();
1121  if (aProv == nullptr)
1122  aHandle.whyFailed()->raise();
1123  const auto& psetsFromProvenance = edm::parameterSet(*aProv, event.processHistory());
1124  auto const idlist = psetsFromProvenance.getParameter<std::vector<edm::ParameterSet>>("IDdefinitions");
1125  for (size_t j = 0; j < idlist.size(); ++j) {
1126  std::string idname = idlist[j].getParameter<std::string>("IDname");
1127  if (discrIndexMapStr.count(idname)) {
1128  throw cms::Exception("DeepTauId")
1129  << "basic discriminator " << idname << " appears more than once in the input.";
1130  }
1131  discrIndexMapStr[idname] = j;
1132  }
1133 
1134  //translate to a map of <BasicDiscriminator, index> and check if all discriminators are present
1135  std::map<BasicDiscriminator, size_t> discrIndexMap;
1136  for (size_t i = 0; i < requiredDiscr.size(); i++) {
1137  if (discrIndexMapStr.find(stringFromDiscriminator_.at(requiredDiscr[i])) == discrIndexMapStr.end())
1138  throw cms::Exception("DeepTauId") << "Basic Discriminator " << stringFromDiscriminator_.at(requiredDiscr[i])
1139  << " was not provided in the config file.";
1140  else
1141  discrIndexMap[requiredDiscr[i]] = discrIndexMapStr[stringFromDiscriminator_.at(requiredDiscr[i])];
1142  }
1143  return discrIndexMap;
1144  }

References Exception, edm::ParameterSet::getParameter(), mps_fire::i, dqmiolumiharvest::j, edm::parameterSet(), AlCaHLTBitMon_QueryRunRegistry::string, and deep_tau::DeepTauBase::stringFromDiscriminator_.

Referenced by getPredictions().

◆ processIsolationPFComponents()

template<typename CandidateCollection , typename TauCastType >
static void DeepTauId::processIsolationPFComponents ( const TauCastType &  tau,
const CandidateCollection &  candidates,
LorentzVectorXYZ &  p4,
float &  pt,
float &  d_eta,
float &  d_phi,
float &  m,
float &  n 
)
inlinestaticprivate

Definition at line 2714 of file DeepTauId.cc.

2721  {
2722  p4 = LorentzVectorXYZ(0, 0, 0, 0);
2723  n = 0;
2724 
2725  for (const auto& cand : candidates) {
2726  p4 += cand->p4();
2727  ++n;
2728  }
2729 
2730  pt = n != 0 ? p4.Pt() : default_value;
2731  d_eta = n != 0 ? dEta(p4, tau.p4()) : default_value;
2732  d_phi = n != 0 ? dPhi(p4, tau.p4()) : default_value;
2733  m = n != 0 ? p4.mass() : default_value;
2734  }

References HLT_2018_cff::candidates, default_value, HLT_2018_cff::dEta, HLT_2018_cff::dPhi, visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, p4, DiDispStaMuonMonitor_cfi::pt, and metsig::tau.

Referenced by createInputsV1().

◆ processSignalPFComponents()

template<typename CandidateCollection , typename TauCastType >
static void DeepTauId::processSignalPFComponents ( const TauCastType &  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 2670 of file DeepTauId.cc.

2683  {
2684  p4_inner = LorentzVectorXYZ(0, 0, 0, 0);
2685  p4_outer = LorentzVectorXYZ(0, 0, 0, 0);
2686  n_inner = 0;
2687  n_outer = 0;
2688 
2689  const double innerSigCone_radius = getInnerSignalConeRadius(tau.pt());
2690  for (const auto& cand : candidates) {
2691  const double dR = reco::deltaR(cand->p4(), tau.leadChargedHadrCand()->p4());
2692  const bool isInside_innerSigCone = dR < innerSigCone_radius;
2693  if (isInside_innerSigCone) {
2694  p4_inner += cand->p4();
2695  ++n_inner;
2696  } else {
2697  p4_outer += cand->p4();
2698  ++n_outer;
2699  }
2700  }
2701 
2702  pt_inner = n_inner != 0 ? p4_inner.Pt() : default_value;
2703  dEta_inner = n_inner != 0 ? dEta(p4_inner, tau.p4()) : default_value;
2704  dPhi_inner = n_inner != 0 ? dPhi(p4_inner, tau.p4()) : default_value;
2705  m_inner = n_inner != 0 ? p4_inner.mass() : default_value;
2706 
2707  pt_outer = n_outer != 0 ? p4_outer.Pt() : default_value;
2708  dEta_outer = n_outer != 0 ? dEta(p4_outer, tau.p4()) : default_value;
2709  dPhi_outer = n_outer != 0 ? dPhi(p4_outer, tau.p4()) : default_value;
2710  m_outer = n_outer != 0 ? p4_outer.mass() : default_value;
2711  }

References HLT_2018_cff::candidates, default_value, reco::deltaR(), HLT_2018_cff::dEta, HLT_2018_cff::dPhi, HGC3DClusterGenMatchSelector_cfi::dR, getInnerSignalConeRadius(), and metsig::tau.

Referenced by createInputsV1().

◆ saveInputs()

void DeepTauId::saveInputs ( const tensorflow::Tensor &  inputs,
const std::string &  block_name,
int  n_inputs,
const CellGrid *  grid = nullptr 
)
inlineprivate

Definition at line 1361 of file DeepTauId.cc.

1364  {
1365  if (debug_level >= 1) {
1366  std::cout << "<saveInputs>: block_name = " << block_name << std::endl;
1367  }
1368  if (!is_first_block_)
1369  (*json_file_) << ", ";
1370  (*json_file_) << "\"" << block_name << "\": [";
1371  if (block_name == "input_tau") {
1372  for (int input_index = 0; input_index < n_inputs; ++input_index) {
1373  float input = inputs.matrix<float>()(0, input_index);
1374  if (input_index != 0)
1375  (*json_file_) << ", ";
1376  (*json_file_) << input;
1377  }
1378  } else {
1379  assert(grid);
1380  int n_eta, n_phi;
1381  if (block_name.find("input_inner") != std::string::npos) {
1382  n_eta = 5;
1383  n_phi = 5;
1384  } else if (block_name.find("input_outer") != std::string::npos) {
1385  n_eta = 10;
1386  n_phi = 10;
1387  } else
1388  assert(0);
1389  int eta_phi_index = 0;
1390  for (int eta = -n_eta; eta <= n_eta; ++eta) {
1391  if (eta != -n_eta)
1392  (*json_file_) << ", ";
1393  (*json_file_) << "[";
1394  for (int phi = -n_phi; phi <= n_phi; ++phi) {
1395  if (phi != -n_phi)
1396  (*json_file_) << ", ";
1397  (*json_file_) << "[";
1398  const CellIndex cell_index{eta, phi};
1399  const auto cell_iter = grid->find(cell_index);
1400  for (int input_index = 0; input_index < n_inputs; ++input_index) {
1401  float input = 0.;
1402  if (cell_iter != grid->end()) {
1403  input = inputs.tensor<float, 4>()(eta_phi_index, 0, 0, input_index);
1404  }
1405  if (input_index != 0)
1406  (*json_file_) << ", ";
1407  (*json_file_) << input;
1408  }
1409  if (cell_iter != grid->end()) {
1410  eta_phi_index += 1;
1411  }
1412  (*json_file_) << "]";
1413  }
1414  (*json_file_) << "]";
1415  }
1416  }
1417  (*json_file_) << "]";
1418  is_first_block_ = false;
1419  }

References cms::cuda::assert(), gather_cfg::cout, debug_level, PVValHelper::eta, dqmMemoryStats::float, getRunAppsInfo::grid, input, PixelMapPlotter::inputs, is_first_block_, and phi.

Referenced by getPredictionsV2().

◆ setCellConvFeatures()

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

Definition at line 1817 of file DeepTauId.cc.

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

References postprocess-scan-build::features, dqmMemoryStats::float, and dqmiodumpmetadata::n.

Referenced by createConvFeatures(), and DeepTauId().

Member Data Documentation

◆ basicDiscrdR03IndexMap_

std::map<BasicDiscriminator, size_t> DeepTauId::basicDiscrdR03IndexMap_
private

Definition at line 2819 of file DeepTauId.cc.

Referenced by getPredictions().

◆ basicDiscrIndexMap_

std::map<BasicDiscriminator, size_t> DeepTauId::basicDiscrIndexMap_
private

Definition at line 2818 of file DeepTauId.cc.

Referenced by getPredictions().

◆ basicTauDiscriminators_inputToken_

edm::EDGetTokenT<reco::TauDiscriminatorContainer> DeepTauId::basicTauDiscriminators_inputToken_
private

Definition at line 2798 of file DeepTauId.cc.

Referenced by getPredictions().

◆ basicTauDiscriminatorsdR03_inputToken_

edm::EDGetTokenT<reco::TauDiscriminatorContainer> DeepTauId::basicTauDiscriminatorsdR03_inputToken_
private

Definition at line 2799 of file DeepTauId.cc.

Referenced by getPredictions().

◆ convTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::convTensor_
private

Definition at line 2809 of file DeepTauId.cc.

Referenced by createConvFeatures(), DeepTauId(), and getPredictionsV2().

◆ debug_level

const int DeepTauId::debug_level
private

Definition at line 2804 of file DeepTauId.cc.

Referenced by checkInputs(), createConvFeatures(), getPredictionsV2(), and saveInputs().

◆ default_value

constexpr float DeepTauId::default_value = -999.
staticconstexpr

Definition at line 1102 of file DeepTauId.cc.

Referenced by calculateElectronClusterVars(), calculateGottfriedJacksonAngleDifference(), createInputsV1(), processIsolationPFComponents(), and processSignalPFComponents().

◆ disable_CellIndex_workaround_

const bool DeepTauId::disable_CellIndex_workaround_
private

Definition at line 2807 of file DeepTauId.cc.

Referenced by getPredictionsV2().

◆ disable_dxy_pca_

const bool DeepTauId::disable_dxy_pca_
private

Definition at line 2805 of file DeepTauId.cc.

Referenced by createTauBlockInputs().

◆ disable_hcalFraction_workaround_

const bool DeepTauId::disable_hcalFraction_workaround_
private

Definition at line 2806 of file DeepTauId.cc.

Referenced by createHadronsBlockInputs().

◆ discrIndicesMapped_

bool DeepTauId::discrIndicesMapped_ = false
private

Definition at line 2817 of file DeepTauId.cc.

Referenced by getPredictions().

◆ eGammaTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::eGammaTensor_
private

Definition at line 2809 of file DeepTauId.cc.

Referenced by createConvFeatures(), createEgammaBlockInputs(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

◆ electrons_token_

edm::EDGetTokenT<std::vector<pat::Electron> > DeepTauId::electrons_token_
private

Definition at line 2795 of file DeepTauId.cc.

Referenced by getPredictions().

◆ file_counter_

int DeepTauId::file_counter_
private

Definition at line 2814 of file DeepTauId.cc.

Referenced by getPredictionsV2().

◆ hadronsTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::hadronsTensor_
private

Definition at line 2809 of file DeepTauId.cc.

Referenced by createConvFeatures(), createHadronsBlockInputs(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

◆ input_layer_

std::string DeepTauId::input_layer_
private

Definition at line 2802 of file DeepTauId.cc.

Referenced by DeepTauId(), and getPredictionsV1().

◆ is_first_block_

bool DeepTauId::is_first_block_
private

Definition at line 2813 of file DeepTauId.cc.

Referenced by getPredictionsV2(), and saveInputs().

◆ json_file_

std::ofstream* DeepTauId::json_file_
private

Definition at line 2812 of file DeepTauId.cc.

Referenced by getPredictionsV2().

◆ muons_token_

edm::EDGetTokenT<std::vector<pat::Muon> > DeepTauId::muons_token_
private

Definition at line 2796 of file DeepTauId.cc.

Referenced by getPredictions().

◆ muonTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::muonTensor_
private

Definition at line 2809 of file DeepTauId.cc.

Referenced by createConvFeatures(), createMuonBlockInputs(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

◆ output_layer_

std::string DeepTauId::output_layer_
private

Definition at line 2802 of file DeepTauId.cc.

Referenced by DeepTauId(), and getPredictionsV1().

◆ pfTauTransverseImpactParameters_token_

edm::EDGetTokenT<edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef> > > DeepTauId::pfTauTransverseImpactParameters_token_
private

Definition at line 2801 of file DeepTauId.cc.

Referenced by getPredictions().

◆ pi

constexpr float DeepTauId::pi = M_PI
staticconstexprprivate

Definition at line 1256 of file DeepTauId.cc.

Referenced by createTauBlockInputs().

◆ rho_token_

edm::EDGetTokenT<double> DeepTauId::rho_token_
private

Definition at line 2797 of file DeepTauId.cc.

Referenced by getPredictions().

◆ save_inputs_

const bool DeepTauId::save_inputs_
private

Definition at line 2811 of file DeepTauId.cc.

Referenced by getPredictionsV2().

◆ tauBlockTensor_

std::unique_ptr<tensorflow::Tensor> DeepTauId::tauBlockTensor_
private

Definition at line 2808 of file DeepTauId.cc.

Referenced by createTauBlockInputs(), DeepTauId(), and getPredictionsV2().

◆ version_

const unsigned DeepTauId::version_
private

Definition at line 2803 of file DeepTauId.cc.

Referenced by DeepTauId(), and getPredictions().

◆ zeroOutputTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::zeroOutputTensor_
private

Definition at line 2809 of file DeepTauId.cc.

Referenced by createConvFeatures(), and DeepTauId().

edm::RefProd
Definition: EDProductfwd.h:25
reco::tau::pt_weighted_deta_strip
float pt_weighted_deta_strip(const reco::PFTau &tau, int dm)
Definition: PFRecoTauClusterVariables.h:36
deep_tau::DeepTauBase::cache_
const DeepTauCache * cache_
Definition: DeepTauBase.h:135
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
deep_tau::DeepTauBase::patPrediscriminants_
std::vector< TauDiscInfo< pat::PATTauDiscriminator > > patPrediscriminants_
Definition: DeepTauBase.h:112
alignBH_cfg.fixed
fixed
Definition: alignBH_cfg.py:54
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
DeepTauId::rho_token_
edm::EDGetTokenT< double > rho_token_
Definition: DeepTauId.cc:2797
dnn_inputs_2017_v2
Definition: DeepTauId.cc:158
DeepTauId::calculateElectronClusterVars
static void calculateElectronClusterVars(const pat::Electron *ele, float &elecEe, float &elecEgamma)
Definition: DeepTauId.cc:2650
mps_fire.i
i
Definition: mps_fire.py:355
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
DeepTauId::getInnerSignalConeRadius
static double getInnerSignalConeRadius(double pt)
Definition: DeepTauId.cc:2736
input
static const std::string input
Definition: EdmProvDump.cc:48
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
deep_tau::DeepTauCache::getSession
tensorflow::Session & getSession(const std::string &name="") const
Definition: DeepTauBase.h:57
SiStripPI::mean
Definition: SiStripPayloadInspectorHelper.h:169
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
deep_tau::DeepTauBase::pfcandToken_
edm::EDGetTokenT< CandidateCollection > pfcandToken_
Definition: DeepTauBase.h:130
runTauDisplay.tau_eta
tau_eta
Definition: runTauDisplay.py:126
dnn_inputs_2017_v2::MuonBlockInputs
Definition: DeepTauId.cc:307
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
metsig::tau
Definition: SignAlgoResolutions.h:49
muon
Definition: MuonCocktails.h:17
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
DeepTauId::isInEcalCrack
static bool isInEcalCrack(double eta)
Definition: DeepTauId.cc:2775
DeepTauId::pi
static constexpr float pi
Definition: DeepTauId.cc:1256
DeepTauId::getValue
static float getValue(T value)
Definition: DeepTauId.cc:1259
DeepTauId::setCellConvFeatures
void setCellConvFeatures(tensorflow::Tensor &convTensor, const tensorflow::Tensor &features, unsigned batch_idx, int eta_index, int phi_index)
Definition: DeepTauId.cc:1817
DeepTauId::version_
const unsigned version_
Definition: DeepTauId.cc:2803
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
min
T min(T a, T b)
Definition: MathUtil.h:58
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
postprocess-scan-build.features
features
Definition: postprocess-scan-build.py:8
Tau3MuMonitor_cff.taus
taus
Definition: Tau3MuMonitor_cff.py:7
relativeConstraints.station
station
Definition: relativeConstraints.py:67
reco::tau::eratio
float eratio(const reco::PFTau &tau)
return ratio of energy in ECAL over sum of energy in ECAL and HCAL
Definition: PFRecoTauClusterVariables.cc:78
deep_tau::DeepTauBase::OutputCollection
std::map< std::string, Output > OutputCollection
Definition: DeepTauBase.h:91
gather_cfg.cout
cout
Definition: gather_cfg.py:144
DeepTauId::matchDiscriminatorIndices
const std::map< BasicDiscriminator, size_t > matchDiscriminatorIndices(edm::Event &event, edm::EDGetTokenT< reco::TauDiscriminatorContainer > discriminatorContainerToken, std::vector< BasicDiscriminator > requiredDiscr)
Definition: DeepTauId.cc:1114
objects
Definition: __init__.py:1
ZElectronSkim_cff.rho
rho
Definition: ZElectronSkim_cff.py:38
DeepTauId::hadronsTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > hadronsTensor_
Definition: DeepTauId.cc:2809
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
DeepTauId::debug_level
const int debug_level
Definition: DeepTauId.cc:2804
deep_tau::DeepTauBase::requiredBasicDiscriminatorsdR03_
static const std::vector< BasicDiscriminator > requiredBasicDiscriminatorsdR03_
Definition: DeepTauBase.h:139
DeepTauId::getValueNorm
static float getValueNorm(T value, float mean, float sigma, float n_sigmas_max=5)
Definition: DeepTauId.cc:1274
getRunAppsInfo.grid
grid
Definition: getRunAppsInfo.py:92
cms::cuda::assert
assert(be >=bs)
deep_tau::DeepTauBase::vtxToken_
edm::EDGetTokenT< reco::VertexCollection > vtxToken_
Definition: DeepTauBase.h:131
DeepTauId::muons_token_
edm::EDGetTokenT< std::vector< pat::Muon > > muons_token_
Definition: DeepTauId.cc:2796
deep_tau::DeepTauBase::LorentzVectorXYZ
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > > LorentzVectorXYZ
Definition: DeepTauBase.h:75
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
DeepTauId::disable_dxy_pca_
const bool disable_dxy_pca_
Definition: DeepTauId.cc:2805
edm::Handle
Definition: AssociativeIterator.h:50
training_settings.idx
idx
Definition: training_settings.py:16
edm::ParameterSetDescription::addOptional
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:105
DeepTauId::zeroOutputTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > zeroOutputTensor_
Definition: DeepTauId.cc:2809
DeepTauId::basicDiscrIndexMap_
std::map< BasicDiscriminator, size_t > basicDiscrIndexMap_
Definition: DeepTauId.cc:2818
deep_tau::NumberOfOutputs
constexpr int NumberOfOutputs
Definition: DeepTauId.cc:18
cosmictrackSelector_cfi.min_pt
min_pt
Definition: cosmictrackSelector_cfi.py:18
HLT_2018_cff.dEta
dEta
Definition: HLT_2018_cff.py:12289
DeepTauId::default_value
static constexpr float default_value
Definition: DeepTauId.cc:1102
ndof
Definition: HIMultiTrackSelector.h:49
DeepTauId::json_file_
std::ofstream * json_file_
Definition: DeepTauId.cc:2812
deep_tau::DeepTauBase::DeepTauBase
DeepTauBase(const edm::ParameterSet &cfg, const OutputCollection &outputs, const DeepTauCache *cache)
Definition: DeepTauBase.cc:86
reco::tau::pt_weighted_dphi_strip
float pt_weighted_dphi_strip(const reco::PFTau &tau, int dm)
Definition: PFRecoTauClusterVariables.h:44
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
DeepTauId::processIsolationPFComponents
static void processIsolationPFComponents(const TauCastType &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
Definition: DeepTauId.cc:2714
deep_tau::DeepTauBase::requiredBasicDiscriminators_
static const std::vector< BasicDiscriminator > requiredBasicDiscriminators_
Definition: DeepTauBase.h:138
PVValHelper::eta
Definition: PVValidationHelpers.h:69
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:72
HLT_2018_cff.dPhi
dPhi
Definition: HLT_2018_cff.py:12290
DeepTauId::basicTauDiscriminators_inputToken_
edm::EDGetTokenT< reco::TauDiscriminatorContainer > basicTauDiscriminators_inputToken_
Definition: DeepTauId.cc:2798
dnn_inputs_2017_v2::HadronBlockInputs
Definition: DeepTauId.cc:377
deep_tau::DeepTauBase::is_online_
const bool is_online_
Definition: DeepTauBase.h:133
DeepTauId::checkInputs
void checkInputs(const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr) const
Definition: DeepTauId.cc:1305
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
DeepTauId::getValueLinear
static float getValueLinear(T value, float min_value, float max_value, bool positive)
Definition: DeepTauId.cc:1264
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
DeepTauId::findMatchedElectron
static const pat::Electron * findMatchedElectron(const TauCastType &tau, const std::vector< pat::Electron > *electrons, double deltaR)
Definition: DeepTauId.cc:2781
dqmdumpme.k
k
Definition: dqmdumpme.py:60
hcaldqm::quantity::min_value
const std::map< ValueQuantityType, double > min_value
Definition: ValueQuantity.h:130
DeepTauId::file_counter_
int file_counter_
Definition: DeepTauId.cc:2814
DeepTauId::convTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > convTensor_
Definition: DeepTauId.cc:2809
DeepTauId::calculateElectronClusterVarsV2
static bool calculateElectronClusterVarsV2(const pat::Electron &ele, float &cc_ele_energy, float &cc_gamma_energy, int &cc_n_gamma)
Definition: DeepTauId.cc:1282
taus_cff.decayMode
decayMode
Definition: taus_cff.py:60
utilities.cache
def cache(function)
Definition: utilities.py:3
getGTfromDQMFile.obj
obj
Definition: getGTfromDQMFile.py:32
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
DeepTauId::disable_hcalFraction_workaround_
const bool disable_hcalFraction_workaround_
Definition: DeepTauId.cc:2806
runTauDisplay.tau_phi
tau_phi
Definition: runTauDisplay.py:127
DDAxes::rho
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::AssociationVector
Definition: AssociationVector.h:67
DeepTauId::basicTauDiscriminatorsdR03_inputToken_
edm::EDGetTokenT< reco::TauDiscriminatorContainer > basicTauDiscriminatorsdR03_inputToken_
Definition: DeepTauId.cc:2799
deep_tau::DeepTauBase::outputs_
OutputCollection outputs_
Definition: DeepTauBase.h:134
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
edm::View::at
const_reference at(size_type pos) const
DeepTauId::calculateGottfriedJacksonAngleDifference
static bool calculateGottfriedJacksonAngleDifference(const TauCastType &tau, const size_t tau_index, double &gj_diff, TauFunc tau_funcs)
Definition: DeepTauId.cc:2744
DeepTauId::pfTauTransverseImpactParameters_token_
edm::EDGetTokenT< edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > > > pfTauTransverseImpactParameters_token_
Definition: DeepTauId.cc:2801
candFunc
Definition: DeepTauId.cc:611
DeepTauId::isAbove
static bool isAbove(double value, double min)
Definition: DeepTauId.cc:1280
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
DeepTauId::output_layer_
std::string output_layer_
Definition: DeepTauId.cc:2802
Cell
Definition: LogEleMapdb.h:8
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
dnn_inputs_2017_v2::EgammaBlockInputs
Definition: DeepTauId.cc:215
deep_tau::DeepTauBase::stringFromDiscriminator_
static const std::map< BasicDiscriminator, std::string > stringFromDiscriminator_
Definition: DeepTauBase.h:137
reco::tau::n_photons_total
unsigned int n_photons_total(const reco::PFTau &tau)
return total number of pf photon candidates with pT>500 MeV, which are associated to signal
Definition: PFRecoTauClusterVariables.cc:157
cand
Definition: decayParser.h:34
electrons_cff.ip3d
ip3d
Definition: electrons_cff.py:363
runTauDisplay.tau_mass
tau_mass
Definition: runTauDisplay.py:128
createfilelist.int
int
Definition: createfilelist.py:10
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
dumpRecoGeometry_cfg.Muon
Muon
Definition: dumpRecoGeometry_cfg.py:190
DeepTauId::disable_CellIndex_workaround_
const bool disable_CellIndex_workaround_
Definition: DeepTauId.cc:2807
p4
double p4[4]
Definition: TauolaWrapper.h:92
value
Definition: value.py:1
pat::Muon::PV2D
Definition: Muon.h:235
PixelMapPlotter.inputs
inputs
Definition: PixelMapPlotter.py:490
DeepTauId::GetOutputs
static const OutputCollection & GetOutputs()
Definition: DeepTauId.cc:1104
DeepTauId::eGammaTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > eGammaTensor_
Definition: DeepTauId.cc:2809
get
#define get
DeepTauId::tauBlockTensor_
std::unique_ptr< tensorflow::Tensor > tauBlockTensor_
Definition: DeepTauId.cc:2808
looper.cfg
cfg
Definition: looper.py:297
nanoDQM_cff.Electron
Electron
Definition: nanoDQM_cff.py:62
DDAxes::phi
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ValueMap::get
const_reference_type get(ProductID id, size_t idx) const
Definition: ValueMap.h:144
DeepTauId::is_first_block_
bool is_first_block_
Definition: DeepTauId.cc:2813
DeepTauId::basicDiscrdR03IndexMap_
std::map< BasicDiscriminator, size_t > basicDiscrdR03IndexMap_
Definition: DeepTauId.cc:2819
hcaldqm::quantity::max_value
const std::map< ValueQuantityType, double > max_value
Definition: ValueQuantity.h:190
PVValHelper::dxy
Definition: PVValidationHelpers.h:47
pat::Electron::superCluster
reco::SuperClusterRef superCluster() const override
override the reco::GsfElectron::superCluster method, to access the internal storage of the superclust...
pwdgSkimBPark_cfi.electrons
electrons
Definition: pwdgSkimBPark_cfi.py:6
DeepTauId::muonTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 > muonTensor_
Definition: DeepTauId.cc:2809
DeepTauId::electrons_token_
edm::EDGetTokenT< std::vector< pat::Electron > > electrons_token_
Definition: DeepTauId.cc:2795
PVValHelper::dz
Definition: PVValidationHelpers.h:50
MuonSubdetId::RPC
static constexpr int RPC
Definition: MuonSubdetId.h:13
deep_tau::DeepTauBase::recoPrediscriminants_
std::vector< TauDiscInfo< reco::PFTauDiscriminator > > recoPrediscriminants_
Definition: DeepTauBase.h:113
HLT_2018_cff.candidates
candidates
Definition: HLT_2018_cff.py:53513
CellObjectType
CellObjectType
Definition: DeepTauId.cc:963
edm::ValueMap
Definition: ValueMap.h:107
runTauDisplay.tau_pt
tau_pt
Definition: runTauDisplay.py:125
Exception
Definition: hltDiff.cc:246
reco::tau::pt_weighted_dr_signal
float pt_weighted_dr_signal(const reco::PFTau &tau, int dm)
Definition: PFRecoTauClusterVariables.h:32
DeepTauId::saveInputs
void saveInputs(const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr)
Definition: DeepTauId.cc:1361
edm::parameterSet
ParameterSet const & parameterSet(Provenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
tensorflow::run
void run(Session *session, const NamedTensorList &inputs, const std::vector< std::string > &outputNames, std::vector< Tensor > *outputs, const thread::ThreadPoolOptions &threadPoolOptions)
Definition: TensorFlow.cc:211
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
DeepTauId::input_layer_
std::string input_layer_
Definition: DeepTauId.cc:2802
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
reco::tau::pt_weighted_dr_iso
float pt_weighted_dr_iso(const reco::PFTau &tau, int dm)
Definition: PFRecoTauClusterVariables.h:52
reco::deltaR
constexpr auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
edm::RefToBase
Definition: AssociativeIterator.h:54
DeepTauId::fillGrids
void fillGrids(const TauCastType &tau, const Collection &objects, CellGrid &inner_grid, CellGrid &outer_grid)
Definition: DeepTauId.cc:1675
DeepTauId::save_inputs_
const bool save_inputs_
Definition: DeepTauId.cc:2811
deep_tau::DeepTauBase::andPrediscriminants_
uint8_t andPrediscriminants_
Definition: DeepTauBase.h:111
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
cms::Exception
Definition: Exception.h:70
pat::Electron
Analysis-level electron class.
Definition: Electron.h:51
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HGC3DClusterGenMatchSelector_cfi.dR
dR
Definition: HGC3DClusterGenMatchSelector_cfi.py:7
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
event
Definition: event.py:1
dnn_inputs_2017_v2::TauBlockInputs
Definition: DeepTauId.cc:162
edm::InputTag
Definition: InputTag.h:15
DeepTauId::getPartialPredictions
tensorflow::Tensor getPartialPredictions(bool is_inner)
Definition: DeepTauId.cc:1711
label
const char * label
Definition: PFTauDecayModeTools.cc:11
deep_tau::DeepTauCache::getGraph
const tensorflow::GraphDef & getGraph(const std::string &name="") const
Definition: DeepTauBase.h:58
Output
#define Output(cl)
Definition: vmac.h:194
DeepTauId::discrIndicesMapped_
bool discrIndicesMapped_
Definition: DeepTauId.cc:2817
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
DeepTauId::processSignalPFComponents
static void processSignalPFComponents(const TauCastType &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)
Definition: DeepTauId.cc:2670
Generated for CMSSW Reference Manual by doxygen 1.8.16