Inheritance diagram for L2TauNNProducer:

Classes
struct	caloRecHitCollections

struct	InputDescTau

Public Types
using	TrackSoAHost = pixelTrack::TrackSoAHostPhase1

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< L2TauNNProducerCacheData > >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
	L2TauNNProducer (const edm::ParameterSet &, const L2TauNNProducerCacheData *)

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< L2TauNNProducerCacheData > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

static void	globalEndJob (L2TauNNProducerCacheData *)

static std::unique_ptr< L2TauNNProducerCacheData >	initializeGlobalCache (const edm::ParameterSet &)

Static Public Attributes
static constexpr float	dEta_width = 2 * L2TauTagNNv1::dR_max / static_cast<float>(L2TauTagNNv1::nCellEta)

static constexpr float	dPhi_width = 2 * L2TauTagNNv1::dR_max / static_cast<float>(L2TauTagNNv1::nCellPhi)

static constexpr float	dR2_max = L2TauTagNNv1::dR_max * L2TauTagNNv1::dR_max

Private Member Functions
void	checknan (tensorflow::Tensor &tensor, int debugLevel)

void	fillCaloRecHits (tensorflow::Tensor &cellGridMatrix, const std::vector< l1t::TauRef > &allTaus, const caloRecHitCollections &caloRecHits)

void	fillL1TauVars (tensorflow::Tensor &cellGridMatrix, const std::vector< l1t::TauRef > &allTaus)

void	fillPatatracks (tensorflow::Tensor &cellGridMatrix, const std::vector< l1t::TauRef > &allTaus, const TrackSoAHost &patatracks_tsoa, const ZVertexSoAHost &patavtx_soa, const reco::BeamSpot &beamspot, const MagneticField *magfi)

template<typename VPos , typename LVec >
std::tuple< float, float, int, int >	getEtaPhiIndices (const VPos &position, const LVec &tau_p4)

template<typename LVec >
std::tuple< float, float, int, int >	getEtaPhiIndices (float eta, float phi, const LVec &tau_p4)

std::vector< float >	getTauScore (const tensorflow::Tensor &cellGridMatrix)

std::pair< float, float >	impactParameter (int it, const TrackSoAHost &patatracks_tsoa, float patatrackPhi, const reco::BeamSpot &beamspot, const MagneticField *magfi)

void	produce (edm::Event &event, const edm::EventSetup &eventsetup) override

void	selectGoodTracksAndVertices (const ZVertexSoAHost &patavtx_soa, const TrackSoAHost &patatracks_tsoa, std::vector< int > &trkGood, std::vector< int > &vtxGood)

void	standardizeTensor (tensorflow::Tensor &tensor)

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	bFieldToken_

const int	debugLevel_

const edm::EDGetTokenT< EcalRecHitCollection >	ebToken_

const edm::EDGetTokenT< EcalRecHitCollection >	eeToken_

const float	fractionSumPt2_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometryToken_

const edm::EDGetTokenT< HBHERecHitCollection >	hbheToken_

const edm::EDGetTokenT< HORecHitCollection >	hoToken_

std::string	inputTensorName_

std::vector< InputDescTau >	L1TauDesc_

const L2TauNNProducerCacheData *	L2cacheData_

const unsigned int	maxVtx_

const float	minSumPt2_

std::string	outputTensorName_

const edm::EDGetTokenT< TrackSoAHost >	pataTracksToken_

const edm::EDGetTokenT< ZVertexSoAHost >	pataVerticesToken_

const edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	tauTriggerToken_

const float	trackChi2Max_

const float	trackPtMax_

const float	trackPtMin_

Detailed Description

Definition at line 148 of file L2TauTagNNProducer.cc.

Member Typedef Documentation

◆ TrackSoAHost

using L2TauNNProducer::TrackSoAHost = pixelTrack::TrackSoAHostPhase1

Definition at line 150 of file L2TauTagNNProducer.cc.

Constructor & Destructor Documentation

◆ L2TauNNProducer()

L2TauNNProducer::L2TauNNProducer	(	const edm::ParameterSet &	cfg,
		const L2TauNNProducerCacheData *	cacheData
	)

explicit

Definition at line 291 of file L2TauTagNNProducer.cc.

References looper::cfg, L2TauNNProducer::InputDescTau::CollectionName, submitPVResolutionJobs::desc, Exception, L2TauNNProducerCacheData::graphDef, inputTensorName_, L2TauNNProducer::InputDescTau::inputToken_, L1TauDesc_, L2cacheData_, Skims_PA_cff::name, outputTensorName_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : debugLevel_(cfg.getParameter<int>("debugLevel")),
       hbheToken_(consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("hbheInput"))),
       hoToken_(consumes<HORecHitCollection>(cfg.getParameter<edm::InputTag>("hoInput"))),
       ebToken_(consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("ebInput"))),
       eeToken_(consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("eeInput"))),
       geometryToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
       bFieldToken_(esConsumes<MagneticField, IdealMagneticFieldRecord>()),
       pataVerticesToken_(consumes(cfg.getParameter<edm::InputTag>("pataVertices"))),
       pataTracksToken_(consumes(cfg.getParameter<edm::InputTag>("pataTracks"))),
       beamSpotToken_(consumes<reco::BeamSpot>(cfg.getParameter<edm::InputTag>("BeamSpot"))),
       maxVtx_(cfg.getParameter<uint>("maxVtx")),
       fractionSumPt2_(cfg.getParameter<double>("fractionSumPt2")),
       minSumPt2_(cfg.getParameter<double>("minSumPt2")),
       trackPtMin_(cfg.getParameter<double>("track_pt_min")),
       trackPtMax_(cfg.getParameter<double>("track_pt_max")),
       trackChi2Max_(cfg.getParameter<double>("track_chi2_max")) {
   if (cacheData->graphDef == nullptr) {
     throw cms::Exception("InvalidCacheData") << "Invalid Cache Data.";
   }
   inputTensorName_ = cacheData->graphDef->node(0).name();
   outputTensorName_ = cacheData->graphDef->node(cacheData->graphDef->node_size() - 1).name();
   L2cacheData_ = cacheData;
   std::vector<edm::ParameterSet> L1TauCollections = cfg.getParameter<std::vector<edm::ParameterSet>>("L1Taus");
   L1TauDesc_.reserve(L1TauCollections.size());
   for (const auto& l1TauInput : L1TauCollections) {
     InputDescTau toInsert;
     toInsert.CollectionName = l1TauInput.getParameter<std::string>("L1CollectionName");
     toInsert.inputToken_ =
         consumes<trigger::TriggerFilterObjectWithRefs>(l1TauInput.getParameter<edm::InputTag>("L1TauTrigger"));
     L1TauDesc_.push_back(toInsert);
   }
   for (const auto& desc : L1TauDesc_)
     produces<std::vector<float>>(desc.CollectionName);
 }

Member Function Documentation

◆ checknan()

void L2TauNNProducer::checknan	(	tensorflow::Tensor &	tensor,
		int	debugLevel
	)

private

Definition at line 327 of file L2TauTagNNProducer.cc.

References ztail::d, HLT_2022v15_cff::debugLevel, Exception, input, edm::isNotFinite(), and L2TauTagNNv1::varNameMap.

Referenced by produce().

                                                                        {
   using NNInputs = L2TauTagNNv1::NNInputs;
   std::vector<int> tensor_shape(tensor.shape().dims());
   for (int d = 0; d < tensor.shape().dims(); d++) {
     tensor_shape.at(d) = tensor.shape().dim_size(d);
   }
   if (tensor_shape.size() != 4) {
     throw cms::Exception("InvalidTensor") << "Tensor shape does not have 4 dimensions!";
   }
   for (int tau_idx = 0; tau_idx < tensor_shape.at(0); tau_idx++) {
     for (int phi_idx = 0; phi_idx < tensor_shape.at(1); phi_idx++) {
       for (int eta_idx = 0; eta_idx < tensor_shape.at(2); eta_idx++) {
         for (int var_idx = 0; var_idx < tensor_shape.at(3); var_idx++) {
           auto getCell = [&](NNInputs input) -> float& {
             return getCellImpl(tensor, tau_idx, phi_idx, eta_idx, input);
           };
           auto nonstd_var = getCell(static_cast<NNInputs>(var_idx));
           if (edm::isNotFinite(nonstd_var)) {
             edm::LogWarning("InputVar") << "var is nan \nvar name= "
                                         << L2TauTagNNv1::varNameMap.at(static_cast<L2TauTagNNv1::NNInputs>(var_idx))
                                         << "\t var_idx = " << var_idx << "\t eta_idx = " << eta_idx
                                         << "\t phi_idx = " << phi_idx << "\t tau_idx = " << tau_idx;
             if (debugLevel > 2) {
               edm::LogWarning("InputVar") << "other vars in same cell \n";
               if (var_idx + 1 < tensor_shape.at(3))
                 edm::LogWarning("InputVar") << L2TauTagNNv1::varNameMap.at(static_cast<NNInputs>(var_idx + 1))
                                             << "\t = " << getCell(static_cast<NNInputs>(var_idx + 1));
               if (var_idx + 2 < tensor_shape.at(3))
                 edm::LogWarning("InputVar") << L2TauTagNNv1::varNameMap.at(static_cast<NNInputs>(var_idx + 2))
                                             << "\t = " << getCell(static_cast<NNInputs>(var_idx + 2));
               if (var_idx + 3 < tensor_shape.at(3))
                 edm::LogWarning("InputVar") << L2TauTagNNv1::varNameMap.at(static_cast<NNInputs>(var_idx + 3))
                                             << "\t = " << getCell(static_cast<NNInputs>(var_idx + 3));
               if (var_idx + 4 < tensor_shape.at(3))
                 edm::LogWarning("InputVar") << L2TauTagNNv1::varNameMap.at(static_cast<NNInputs>(var_idx + 4))
                                             << "\t = " << getCell(static_cast<NNInputs>(var_idx + 4));
             }
           }
         }
       }
     }
   }
 }

◆ fillCaloRecHits()

void L2TauNNProducer::fillCaloRecHits	(	tensorflow::Tensor &	cellGridMatrix,
		const std::vector< l1t::TauRef > &	allTaus,
		const caloRecHitCollections &	caloRecHits
	)

private

Definition at line 437 of file L2TauTagNNProducer.cc.

References reco::deltaR2(), dR2_max, L2TauNNProducer::caloRecHitCollections::eb, L2TauNNProducer::caloRecHitCollections::ee, L2TauNNProducer::caloRecHitCollections::geometry, getEtaPhiIndices(), CaloGeometry::getGeometry(), L2TauNNProducer::caloRecHitCollections::hbhe, L2TauNNProducer::caloRecHitCollections::ho, input, L2TauTagNNv1::nCellEta, L2TauTagNNv1::nCellPhi, and position.

Referenced by produce().

                                                                                 {
   using NNInputs = L2TauTagNNv1::NNInputs;
 
   const int nTaus = allTaus.size();
   float deta, dphi;
   int eta_idx = 0;
   int phi_idx = 0;
   int tau_idx = 0;
 
   auto getCell = [&](NNInputs input) -> float& {
     return getCellImpl(cellGridMatrix, tau_idx, phi_idx, eta_idx, input);
   };
   for (tau_idx = 0; tau_idx < nTaus; tau_idx++) {
     // calorechit_EE
     for (const auto& caloRecHit_ee : *caloRecHits.ee) {
       if (caloRecHit_ee.energy() <= 0)
         continue;
       const auto& position = caloRecHits.geometry->getGeometry(caloRecHit_ee.id())->getPosition();
       const float eeCalEn = caloRecHit_ee.energy();
       const float eeCalChi2 = caloRecHit_ee.chi2();
       if (reco::deltaR2(position, allTaus[tau_idx]->polarP4()) < dR2_max) {
         std::tie(deta, dphi, eta_idx, phi_idx) = getEtaPhiIndices(position, allTaus[tau_idx]->polarP4());
         getCell(NNInputs::EcalEnergySum) += eeCalEn;
         getCell(NNInputs::EcalSize) += 1.;
         getCell(NNInputs::EcalEnergyStdDev) += eeCalEn * eeCalEn;
         getCell(NNInputs::EcalDeltaEta) += deta * eeCalEn;
         getCell(NNInputs::EcalDeltaPhi) += dphi * eeCalEn;
         if (eeCalChi2 >= 0) {
           getCell(NNInputs::EcalChi2) += eeCalChi2 * eeCalEn;
           getCell(NNInputs::EcalEnergySumForPositiveChi2) += eeCalEn;
           getCell(NNInputs::EcalSizeForPositiveChi2) += 1.;
         }
       }
     }
 
     // calorechit_EB
     for (const auto& caloRecHit_eb : *caloRecHits.eb) {
       if (caloRecHit_eb.energy() <= 0)
         continue;
       const auto& position = caloRecHits.geometry->getGeometry(caloRecHit_eb.id())->getPosition();
       const float ebCalEn = caloRecHit_eb.energy();
       const float ebCalChi2 = caloRecHit_eb.chi2();
       if (reco::deltaR2(position, allTaus[tau_idx]->polarP4()) < dR2_max) {
         std::tie(deta, dphi, eta_idx, phi_idx) = getEtaPhiIndices(position, allTaus[tau_idx]->polarP4());
         getCell(NNInputs::EcalEnergySum) += ebCalEn;
         getCell(NNInputs::EcalSize) += 1.;
         getCell(NNInputs::EcalEnergyStdDev) += ebCalEn * ebCalEn;
         getCell(NNInputs::EcalDeltaEta) += deta * ebCalEn;
         getCell(NNInputs::EcalDeltaPhi) += dphi * ebCalEn;
         if (ebCalChi2 >= 0) {
           getCell(NNInputs::EcalChi2) += ebCalChi2 * ebCalEn;
           getCell(NNInputs::EcalEnergySumForPositiveChi2) += ebCalEn;
           getCell(NNInputs::EcalSizeForPositiveChi2) += 1.;
         }
       }
     }
 
     // calorechit_HBHE
     for (const auto& caloRecHit_hbhe : *caloRecHits.hbhe) {
       if (caloRecHit_hbhe.energy() <= 0)
         continue;
       const auto& position = caloRecHits.geometry->getGeometry(caloRecHit_hbhe.id())->getPosition();
       const float hbheCalEn = caloRecHit_hbhe.energy();
       const float hbheCalChi2 = caloRecHit_hbhe.chi2();
       if (reco::deltaR2(position, allTaus[tau_idx]->polarP4()) < dR2_max) {
         std::tie(deta, dphi, eta_idx, phi_idx) = getEtaPhiIndices(position, allTaus[tau_idx]->polarP4());
         getCell(NNInputs::HcalEnergySum) += hbheCalEn;
         getCell(NNInputs::HcalEnergyStdDev) += hbheCalEn * hbheCalEn;
         getCell(NNInputs::HcalSize) += 1.;
         getCell(NNInputs::HcalDeltaEta) += deta * hbheCalEn;
         getCell(NNInputs::HcalDeltaPhi) += dphi * hbheCalEn;
         if (hbheCalChi2 >= 0) {
           getCell(NNInputs::HcalChi2) += hbheCalChi2 * hbheCalEn;
           getCell(NNInputs::HcalEnergySumForPositiveChi2) += hbheCalEn;
           getCell(NNInputs::HcalSizeForPositiveChi2) += 1.;
         }
       }
     }
 
     // calorechit_HO
     for (const auto& caloRecHit_ho : *caloRecHits.ho) {
       if (caloRecHit_ho.energy() <= 0)
         continue;
       const auto& position = caloRecHits.geometry->getGeometry(caloRecHit_ho.id())->getPosition();
       const float hoCalEn = caloRecHit_ho.energy();
       if (reco::deltaR2(position, allTaus[tau_idx]->polarP4()) < dR2_max) {
         std::tie(deta, dphi, eta_idx, phi_idx) = getEtaPhiIndices(position, allTaus[tau_idx]->polarP4());
         getCell(NNInputs::HcalEnergySum) += hoCalEn;
         getCell(NNInputs::HcalEnergyStdDev) += hoCalEn * hoCalEn;
         getCell(NNInputs::HcalSize) += 1.;
         getCell(NNInputs::HcalDeltaEta) += deta * hoCalEn;
         getCell(NNInputs::HcalDeltaPhi) += dphi * hoCalEn;
       }
     }
 
     // normalize to sum and define stdDev
     for (eta_idx = 0; eta_idx < L2TauTagNNv1::nCellEta; eta_idx++) {
       for (phi_idx = 0; phi_idx < L2TauTagNNv1::nCellPhi; phi_idx++) {
         /* normalize eCal vars*/
         if (getCell(NNInputs::EcalEnergySum) > 0.) {
           getCell(NNInputs::EcalDeltaEta) /= getCell(NNInputs::EcalEnergySum);
           getCell(NNInputs::EcalDeltaPhi) /= getCell(NNInputs::EcalEnergySum);
         }
         if (getCell(NNInputs::EcalEnergySumForPositiveChi2) > 0.) {
           getCell(NNInputs::EcalChi2) /= getCell(NNInputs::EcalEnergySumForPositiveChi2);
         }
         if (getCell(NNInputs::EcalSize) > 1.) {
           // (stdDev - (enSum*enSum)/size) / (size-1)
           getCell(NNInputs::EcalEnergyStdDev) =
               (getCell(NNInputs::EcalEnergyStdDev) -
                (getCell(NNInputs::EcalEnergySum) * getCell(NNInputs::EcalEnergySum)) / getCell(NNInputs::EcalSize)) /
               (getCell(NNInputs::EcalSize) - 1);
         } else {
           getCell(NNInputs::EcalEnergyStdDev) = 0.;
         }
         /* normalize hCal Vars */
         if (getCell(NNInputs::HcalEnergySum) > 0.) {
           getCell(NNInputs::HcalDeltaEta) /= getCell(NNInputs::HcalEnergySum);
           getCell(NNInputs::HcalDeltaPhi) /= getCell(NNInputs::HcalEnergySum);
         }
         if (getCell(NNInputs::HcalEnergySumForPositiveChi2) > 0.) {
           getCell(NNInputs::HcalChi2) /= getCell(NNInputs::HcalEnergySumForPositiveChi2);
         }
         if (getCell(NNInputs::HcalSize) > 1.) {
           // (stdDev - (enSum*enSum)/size) / (size-1)
           getCell(NNInputs::HcalEnergyStdDev) =
               (getCell(NNInputs::HcalEnergyStdDev) -
                (getCell(NNInputs::HcalEnergySum) * getCell(NNInputs::HcalEnergySum)) / getCell(NNInputs::HcalSize)) /
               (getCell(NNInputs::HcalSize) - 1);
         } else {
           getCell(NNInputs::HcalEnergyStdDev) = 0.;
         }
       }
     }
   }
 }

◆ fillDescriptions()

void L2TauNNProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 259 of file L2TauTagNNProducer.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, and parallelization::uint.

                                                                                  {
   edm::ParameterSetDescription desc;
   desc.add<int>("debugLevel", 0)->setComment("set debug level for printing out info");
   edm::ParameterSetDescription l1TausPset;
   l1TausPset.add<std::string>("L1CollectionName", "DoubleTau")->setComment("Name of collections");
   l1TausPset.add<edm::InputTag>("L1TauTrigger", edm::InputTag("hltL1sDoubleTauBigOR"))
       ->setComment("Which trigger should the L1 Taus collection pass");
   edm::ParameterSet l1TausPSetDefault;
   l1TausPSetDefault.addParameter<std::string>("L1CollectionName", "DoubleTau");
   l1TausPSetDefault.addParameter<edm::InputTag>("L1TauTrigger", edm::InputTag("hltL1sDoubleTauBigOR"));
   desc.addVPSet("L1Taus", l1TausPset, {l1TausPSetDefault});
   desc.add<edm::InputTag>("hbheInput", edm::InputTag("hltHbhereco"))->setComment("HBHE recHit collection");
   desc.add<edm::InputTag>("hoInput", edm::InputTag("hltHoreco"))->setComment("HO recHit Collection");
   desc.add<edm::InputTag>("ebInput", edm::InputTag("hltEcalRecHit:EcalRecHitsEB"))->setComment("EB recHit Collection");
   desc.add<edm::InputTag>("eeInput", edm::InputTag("hltEcalRecHit:EcalRecHitsEE"))->setComment("EE recHit Collection");
   desc.add<edm::InputTag>("pataVertices", edm::InputTag("hltPixelVerticesSoA"))
       ->setComment("patatrack vertices collection");
   desc.add<edm::InputTag>("pataTracks", edm::InputTag("hltPixelTracksSoA"))->setComment("patatrack collection");
   desc.add<edm::InputTag>("BeamSpot", edm::InputTag("hltOnlineBeamSpot"))->setComment("BeamSpot Collection");
   desc.add<uint>("maxVtx", 100)->setComment("max output collection size (number of accepted vertices)");
   desc.add<double>("fractionSumPt2", 0.3)->setComment("threshold on sumPt2 fraction of the leading vertex");
   desc.add<double>("minSumPt2", 0.)->setComment("min sumPt2");
   desc.add<double>("track_pt_min", 1.0)->setComment("min track p_T");
   desc.add<double>("track_pt_max", 10.0)->setComment("max track p_T");
   desc.add<double>("track_chi2_max", 99999.)->setComment("max track chi2");
   desc.add<std::string>("graphPath", "RecoTauTag/TrainingFiles/data/L2TauNNTag/L2TauTag_Run3v1.pb")
       ->setComment("path to the saved CNN");
   desc.add<std::string>("normalizationDict", "RecoTauTag/TrainingFiles/data/L2TauNNTag/NormalizationDict.json")
       ->setComment("path to the dictionary for variable standardization");
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillL1TauVars()

void L2TauNNProducer::fillL1TauVars	(	tensorflow::Tensor &	cellGridMatrix,
		const std::vector< l1t::TauRef > &	allTaus
	)

private

Definition at line 405 of file L2TauTagNNProducer.cc.

References input, L2TauTagNNv1::nCellEta, and L2TauTagNNv1::nCellPhi.

Referenced by produce().

                                                                                                          {
   using NNInputs = L2TauTagNNv1::NNInputs;
 
   const int nTaus = allTaus.size();
   for (int tau_idx = 0; tau_idx < nTaus; tau_idx++) {
     for (int eta_idx = 0; eta_idx < L2TauTagNNv1::nCellEta; eta_idx++) {
       for (int phi_idx = 0; phi_idx < L2TauTagNNv1::nCellPhi; phi_idx++) {
         auto getCell = [&](NNInputs input) -> float& {
           return getCellImpl(cellGridMatrix, tau_idx, phi_idx, eta_idx, input);
         };
         getCell(NNInputs::l1Tau_pt) = allTaus[tau_idx]->pt();
         getCell(NNInputs::l1Tau_eta) = allTaus[tau_idx]->eta();
         getCell(NNInputs::l1Tau_hwIso) = allTaus[tau_idx]->hwIso();
       }
     }
   }
 }

◆ fillPatatracks()

void L2TauNNProducer::fillPatatracks	(	tensorflow::Tensor &	cellGridMatrix,
		const std::vector< l1t::TauRef > &	allTaus,
		const TrackSoAHost &	patatracks_tsoa,
		const ZVertexSoAHost &	patavtx_soa,
		const reco::BeamSpot &	beamspot,
		const MagneticField *	magfi
	)

private

Definition at line 655 of file L2TauTagNNProducer.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, cms::cuda::PortableHostCollection< T >::const_view(), reco::deltaR2(), dR2_max, spr::find(), getEtaPhiIndices(), impactParameter(), input, SiStripPI::min, L2TauTagNNv1::nCellEta, L2TauTagNNv1::nCellPhi, nHits, TrackCollections2monitor_cff::nVertices, PVValHelper::phi, selectGoodTracksAndVertices(), and cms::cuda::PortableHostCollection< T >::view().

Referenced by produce().

                                                                  {
   using NNInputs = L2TauTagNNv1::NNInputs;
   using patatrackHelpers = TracksUtilities<pixelTopology::Phase1>;
   float deta, dphi;
   int eta_idx = 0;
   int phi_idx = 0;
   int tau_idx = 0;
 
   auto getCell = [&](NNInputs input) -> float& {
     return getCellImpl(cellGridMatrix, tau_idx, phi_idx, eta_idx, input);
   };
 
   std::vector<int> trkGood;
   std::vector<int> vtxGood;
 
   selectGoodTracksAndVertices(patavtx_soa, patatracks_tsoa, trkGood, vtxGood);
 
   const int nTaus = allTaus.size();
   for (tau_idx = 0; tau_idx < nTaus; tau_idx++) {
     const float tauEta = allTaus[tau_idx]->eta();
     const float tauPhi = allTaus[tau_idx]->phi();
 
     for (const auto it : trkGood) {
       const float patatrackPt = patatracks_tsoa.const_view()[it].pt();
       if (patatrackPt <= 0)
         continue;
       const float patatrackPhi = patatrackHelpers::phi(patatracks_tsoa.const_view(), it);
       const float patatrackEta = patatracks_tsoa.const_view()[it].eta();
       const float patatrackCharge = patatrackHelpers::charge(patatracks_tsoa.const_view(), it);
       const float patatrackChi2OverNdof = patatracks_tsoa.view()[it].chi2();
       const auto nHits = patatrackHelpers::nHits(patatracks_tsoa.const_view(), it);
       if (nHits <= 0)
         continue;
       const int patatrackNdof = 2 * std::min(6, nHits) - 5;
 
       const int vtx_idx_assTrk = patavtx_soa.view()[it].idv();
       if (reco::deltaR2(patatrackEta, patatrackPhi, tauEta, tauPhi) < dR2_max) {
         std::tie(deta, dphi, eta_idx, phi_idx) =
             getEtaPhiIndices(patatrackEta, patatrackPhi, allTaus[tau_idx]->polarP4());
         getCell(NNInputs::PatatrackPtSum) += patatrackPt;
         getCell(NNInputs::PatatrackSize) += 1.;
         getCell(NNInputs::PatatrackChargeSum) += patatrackCharge;
         getCell(NNInputs::PatatrackDeltaEta) += deta * patatrackPt;
         getCell(NNInputs::PatatrackDeltaPhi) += dphi * patatrackPt;
         getCell(NNInputs::PatatrackChi2OverNdof) += patatrackChi2OverNdof * patatrackPt;
         getCell(NNInputs::PatatrackNdof) += patatrackNdof * patatrackPt;
         std::pair<float, float> impactParameters = impactParameter(it, patatracks_tsoa, patatrackPhi, beamspot, magfi);
         getCell(NNInputs::PatatrackDxy) += impactParameters.first * patatrackPt;
         getCell(NNInputs::PatatrackDz) += impactParameters.second * patatrackPt;
         if ((std::find(vtxGood.begin(), vtxGood.end(), vtx_idx_assTrk) != vtxGood.end())) {
           getCell(NNInputs::PatatrackPtSumWithVertex) += patatrackPt;
           getCell(NNInputs::PatatrackSizeWithVertex) += 1.;
         }
       }
     }
 
     // normalize to sum and define stdDev
     for (eta_idx = 0; eta_idx < L2TauTagNNv1::nCellEta; eta_idx++) {
       for (phi_idx = 0; phi_idx < L2TauTagNNv1::nCellPhi; phi_idx++) {
         getCell(NNInputs::nVertices) = vtxGood.size();
         if (getCell(NNInputs::PatatrackPtSum) > 0.) {
           getCell(NNInputs::PatatrackDeltaEta) /= getCell(NNInputs::PatatrackPtSum);
           getCell(NNInputs::PatatrackDeltaPhi) /= getCell(NNInputs::PatatrackPtSum);
           getCell(NNInputs::PatatrackChi2OverNdof) /= getCell(NNInputs::PatatrackPtSum);
           getCell(NNInputs::PatatrackNdof) /= getCell(NNInputs::PatatrackPtSum);
           getCell(NNInputs::PatatrackDxy) /= getCell(NNInputs::PatatrackPtSum);
           getCell(NNInputs::PatatrackDz) /= getCell(NNInputs::PatatrackPtSum);
         }
       }
     }
   }
 }

◆ getEtaPhiIndices() [1/2]

template<typename VPos , typename LVec >

std::tuple< float, float, int, int > L2TauNNProducer::getEtaPhiIndices	(	const VPos &	position,
		const LVec &	tau_p4
	)

private

Definition at line 433 of file L2TauTagNNProducer.cc.

References position.

Referenced by fillCaloRecHits(), and fillPatatracks().

                                                                                                            {
   return getEtaPhiIndices(position.eta(), position.phi(), tau_p4);
 }

◆ getEtaPhiIndices() [2/2]

template<typename LVec >

std::tuple< float, float, int, int > L2TauNNProducer::getEtaPhiIndices	(	float	eta,
		float	phi,
		const LVec &	tau_p4
	)

private

Definition at line 424 of file L2TauTagNNProducer.cc.

References reco::deltaPhi(), dEta_width, dPhi_width, L2TauTagNNv1::dR_max, PVValHelper::eta, and phi.

                                                                                                            {
   const float deta = eta - tau_p4.eta();
   const float dphi = reco::deltaPhi(phi, tau_p4.phi());
   const int eta_idx = static_cast<int>(floor((deta + L2TauTagNNv1::dR_max) / dEta_width));
   const int phi_idx = static_cast<int>(floor((dphi + L2TauTagNNv1::dR_max) / dPhi_width));
   return std::make_tuple(deta, dphi, eta_idx, phi_idx);
 }

◆ getTauScore()

std::vector< float > L2TauNNProducer::getTauScore ( const tensorflow::Tensor & cellGridMatrix )

private

Definition at line 733 of file L2TauTagNNProducer.cc.

References L2cacheData_, tensorflow::run(), and L2TauNNProducerCacheData::session.

Referenced by produce().

                                                                                     {
   std::vector<tensorflow::Tensor> pred_tensor;
   tensorflow::run(L2cacheData_->session, {{inputTensorName_, cellGridMatrix}}, {outputTensorName_}, &pred_tensor);
   const int nTau = cellGridMatrix.shape().dim_size(0);
   std::vector<float> pred_vector(nTau);
   for (int tau_idx = 0; tau_idx < nTau; ++tau_idx) {
     pred_vector[tau_idx] = pred_tensor[0].matrix<float>()(tau_idx, 0);
   }
 
   return pred_vector;
 }

◆ globalEndJob()

void L2TauNNProducer::globalEndJob ( L2TauNNProducerCacheData * cacheData )

static

Definition at line 253 of file L2TauTagNNProducer.cc.

References tensorflow::closeSession(), L2TauNNProducerCacheData::graphDef, and L2TauNNProducerCacheData::session.

                                                                       {
   if (cacheData->graphDef != nullptr) {
     delete cacheData->graphDef;
   }
   tensorflow::closeSession(cacheData->session);
 }

◆ impactParameter()

std::pair< float, float > L2TauNNProducer::impactParameter	(	int	it,
		const TrackSoAHost &	patatracks_tsoa,
		float	patatrackPhi,
		const reco::BeamSpot &	beamspot,
		const MagneticField *	magfi
	)

private

Definition at line 624 of file L2TauTagNNProducer.cc.

References LocalTrajectoryParameters::charge(), TracksUtilities< TrackerTraits >::copyToDense(), funct::cos(), f, runTauDisplay::gp, M_PI_2, LocalTrajectoryParameters::momentum(), phi, LocalTrajectoryParameters::position(), createTree::pp, funct::sin(), riemannFit::transformToPerigeePlane(), and cms::cuda::PortableHostCollection< T >::view().

Referenced by fillPatatracks().

                                                                                      {
   /* dxy and dz */
   riemannFit::Vector5d ipar, opar;
   riemannFit::Matrix5d icov, ocov;
   TracksUtilities<pixelTopology::Phase1>::copyToDense(patatracks_tsoa.view(), ipar, icov, it);
   riemannFit::transformToPerigeePlane(ipar, icov, opar, ocov);
   LocalTrajectoryParameters lpar(opar(0), opar(1), opar(2), opar(3), opar(4), 1.);
   float sp = std::sin(patatrackPhi);
   float cp = std::cos(patatrackPhi);
   Surface::RotationType Rotation(sp, -cp, 0, 0, 0, -1.f, cp, sp, 0);
   GlobalPoint BeamSpotPoint(beamspot.x0(), beamspot.y0(), beamspot.z0());
   Plane impPointPlane(BeamSpotPoint, Rotation);
   GlobalTrajectoryParameters gp(
       impPointPlane.toGlobal(lpar.position()), impPointPlane.toGlobal(lpar.momentum()), lpar.charge(), magfi);
   GlobalPoint vv = gp.position();
   math::XYZPoint pos(vv.x(), vv.y(), vv.z());
   GlobalVector pp = gp.momentum();
   math::XYZVector mom(pp.x(), pp.y(), pp.z());
   auto lambda = M_PI_2 - pp.theta();
   auto phi = pp.phi();
   float patatrackDxy = -vv.x() * std::sin(phi) + vv.y() * std::cos(phi);
   float patatrackDz =
       (vv.z() * std::cos(lambda) - (vv.x() * std::cos(phi) + vv.y() * std::sin(phi)) * std::sin(lambda)) /
       std::cos(lambda);
   return std::make_pair(patatrackDxy, patatrackDz);
 }

◆ initializeGlobalCache()

std::unique_ptr< L2TauNNProducerCacheData > L2TauNNProducer::initializeGlobalCache ( const edm::ParameterSet & cfg )

static

Definition at line 228 of file L2TauTagNNProducer.cc.

References looper::cfg, tensorflow::createSession(), edm::FileInPath::fullPath(), HLT_2022v15_cff::graphPath, crabWrapper::key, tensorflow::loadGraphDef(), normDictElement::max, normDictElement::mean, normDictElement::min, HLT_2022v15_cff::normalizationDict, L2TauTagNNv1::nVars, tensorflow::setLogging(), normDictElement::std, AlCaHLTBitMon_QueryRunRegistry::string, heppy_batch::val, trigObjTnPSource_cfi::var, and L2TauTagNNv1::varNameMap.

                                                                                                          {
   std::unique_ptr<L2TauNNProducerCacheData> cacheData = std::make_unique<L2TauNNProducerCacheData>();
   cacheData->normVec.reserve(L2TauTagNNv1::nVars);
 
   auto const graphPath = edm::FileInPath(cfg.getParameter<std::string>("graphPath")).fullPath();
 
   cacheData->graphDef = tensorflow::loadGraphDef(graphPath);
   cacheData->session = tensorflow::createSession(cacheData->graphDef);
 
   tensorflow::setLogging("2");
 
   boost::property_tree::ptree loadPtreeRoot;
   auto const normalizationDict = edm::FileInPath(cfg.getParameter<std::string>("normalizationDict")).fullPath();
   boost::property_tree::read_json(normalizationDict, loadPtreeRoot);
   for (const auto& [key, val] : L2TauTagNNv1::varNameMap) {
     boost::property_tree::ptree var = loadPtreeRoot.get_child(val);
     normDictElement current_element;
     current_element.mean = var.get_child("mean").get_value<float>();
     current_element.std = var.get_child("std").get_value<float>();
     current_element.min = var.get_child("min").get_value<float>();
     current_element.max = var.get_child("max").get_value<float>();
     cacheData->normVec.push_back(current_element);
   }
   return cacheData;
 }

◆ produce()

void L2TauNNProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventsetup
	)

overrideprivate

Definition at line 745 of file L2TauTagNNProducer.cc.

References beamSpotToken_, bFieldToken_, checknan(), debugLevel_, HLT_2022v15_cff::distance, L2TauNNProducer::caloRecHitCollections::eb, ebToken_, L2TauNNProducer::caloRecHitCollections::ee, eeToken_, fillCaloRecHits(), fillL1TauVars(), fillPatatracks(), spr::find(), relativeConstraints::geometry, L2TauNNProducer::caloRecHitCollections::geometry, geometryToken_, edm::EventSetup::getHandle(), getTauScore(), photonIsolationHIProducer_cfi::hbhe, L2TauNNProducer::caloRecHitCollections::hbhe, hbheToken_, photonIsolationHIProducer_cfi::ho, L2TauNNProducer::caloRecHitCollections::ho, hoToken_, L1TauDesc_, eostools::move(), L2TauTagNNv1::nCellEta, L2TauTagNNv1::nCellPhi, L2TauTagNNv1::nVars, pataTracksToken_, pataVerticesToken_, DiDispStaMuonMonitor_cfi::pt, standardizeTensor(), and trigger::TriggerL1Tau.

                                                                               {
   std::vector<std::vector<size_t>> TauCollectionMap(L1TauDesc_.size());
   l1t::TauVectorRef allTaus;
 
   for (size_t inp_idx = 0; inp_idx < L1TauDesc_.size(); inp_idx++) {
     l1t::TauVectorRef l1Taus;
     auto const& l1TriggeredTaus = event.get(L1TauDesc_[inp_idx].inputToken_);
     l1TriggeredTaus.getObjects(trigger::TriggerL1Tau, l1Taus);
     TauCollectionMap.at(inp_idx).resize(l1Taus.size());
 
     for (size_t l1_idx = 0; l1_idx < l1Taus.size(); l1_idx++) {
       size_t tau_idx;
       const auto iter = std::find(allTaus.begin(), allTaus.end(), l1Taus[l1_idx]);
       if (iter != allTaus.end()) {
         tau_idx = std::distance(allTaus.begin(), iter);
       } else {
         allTaus.push_back(l1Taus[l1_idx]);
         tau_idx = allTaus.size() - 1;
       }
       TauCollectionMap.at(inp_idx).at(l1_idx) = tau_idx;
     }
   }
   const auto ebCal = event.getHandle(ebToken_);
   const auto eeCal = event.getHandle(eeToken_);
   const auto hbhe = event.getHandle(hbheToken_);
   const auto ho = event.getHandle(hoToken_);
   auto const& patatracks_SoA = event.get(pataTracksToken_);
   auto const& vertices_SoA = event.get(pataVerticesToken_);
   const auto bsHandle = event.getHandle(beamSpotToken_);
 
   auto const fieldESH = eventsetup.getHandle(bFieldToken_);
   auto const geometry = eventsetup.getHandle(geometryToken_);
 
   caloRecHitCollections caloRecHits;
   caloRecHits.hbhe = &*hbhe;
   caloRecHits.ho = &*ho;
   caloRecHits.eb = &*ebCal;
   caloRecHits.ee = &*eeCal;
   caloRecHits.geometry = &*geometry;
 
   const int nTaus = allTaus.size();
   tensorflow::Tensor cellGridMatrix(tensorflow::DT_FLOAT,
                                     {nTaus, L2TauTagNNv1::nCellEta, L2TauTagNNv1::nCellPhi, L2TauTagNNv1::nVars});
   const int n_inputs = nTaus * L2TauTagNNv1::nCellEta * L2TauTagNNv1::nCellPhi * L2TauTagNNv1::nVars;
   for (int input_idx = 0; input_idx < n_inputs; ++input_idx) {
     cellGridMatrix.flat<float>()(input_idx) = 0;
   }
   fillL1TauVars(cellGridMatrix, allTaus);
 
   fillCaloRecHits(cellGridMatrix, allTaus, caloRecHits);
 
   fillPatatracks(cellGridMatrix, allTaus, patatracks_SoA, vertices_SoA, *bsHandle, fieldESH.product());
 
   standardizeTensor(cellGridMatrix);
 
   if (debugLevel_ > 0) {
     checknan(cellGridMatrix, debugLevel_);
   }
 
   std::vector<float> tau_score = getTauScore(cellGridMatrix);
 
   for (size_t inp_idx = 0; inp_idx < L1TauDesc_.size(); inp_idx++) {
     const size_t nTau = TauCollectionMap[inp_idx].size();
     auto tau_tags = std::make_unique<std::vector<float>>(nTau);
     for (size_t tau_pos = 0; tau_pos < nTau; ++tau_pos) {
       const auto tau_idx = TauCollectionMap[inp_idx][tau_pos];
       if (debugLevel_ > 0) {
         edm::LogInfo("DebugInfo") << event.id().event() << " \t " << (allTaus[tau_idx])->pt() << " \t "
                                   << tau_score.at(tau_idx) << std::endl;
       }
       (*tau_tags)[tau_pos] = tau_score.at(tau_idx);
     }
     event.put(std::move(tau_tags), L1TauDesc_[inp_idx].CollectionName);
   }
 }

◆ selectGoodTracksAndVertices()

void L2TauNNProducer::selectGoodTracksAndVertices	(	const ZVertexSoAHost &	patavtx_soa,
		const TrackSoAHost &	patatracks_tsoa,
		std::vector< int > &	trkGood,
		std::vector< int > &	vtxGood
	)

private

Definition at line 576 of file L2TauTagNNProducer.cc.

References cms::cuda::assert(), cms::cuda::PortableHostCollection< T >::const_view(), fractionSumPt2_, dqmiolumiharvest::j, pixelTrack::loose, DMR_cfg::maxTracks, maxVtx_, SiStripPI::min, minSumPt2_, nHits, quality, trackChi2Max_, trackPtMax_, trackPtMin_, and cms::cuda::PortableHostCollection< T >::view().

Referenced by fillPatatracks().

                                                                            {
   using patatrackHelpers = TracksUtilities<pixelTopology::Phase1>;
   const auto maxTracks = patatracks_tsoa.view().metadata().size();
   const int nv = patavtx_soa.view().nvFinal();
   trkGood.clear();
   trkGood.reserve(maxTracks);
   vtxGood.clear();
   vtxGood.reserve(nv);
   auto const* quality = patatracks_tsoa.view().quality();
 
   // No need to sort either as the algorithms is just using the max (not even the location, just the max value of pt2sum).
   std::vector<float> pTSquaredSum(nv, 0);
   std::vector<int> nTrkAssociated(nv, 0);
 
   for (int32_t trk_idx = 0; trk_idx < maxTracks; ++trk_idx) {
     auto nHits = patatrackHelpers::nHits(patatracks_tsoa.view(), trk_idx);
     if (nHits == 0) {
       break;
     }
     int vtx_ass_to_track = patavtx_soa.view()[trk_idx].idv();
     if (vtx_ass_to_track >= 0 && vtx_ass_to_track < nv) {
       auto patatrackPt = patatracks_tsoa.view()[trk_idx].pt();
       ++nTrkAssociated[vtx_ass_to_track];
       if (patatrackPt >= trackPtMin_ && patatracks_tsoa.const_view()[trk_idx].chi2() <= trackChi2Max_) {
         patatrackPt = std::min(patatrackPt, trackPtMax_);
         pTSquaredSum[vtx_ass_to_track] += patatrackPt * patatrackPt;
       }
     }
     if (nHits > 0 and quality[trk_idx] >= pixelTrack::Quality::loose) {
       trkGood.push_back(trk_idx);
     }
   }
   if (nv > 0) {
     const auto minFOM_fromFrac = (*std::max_element(pTSquaredSum.begin(), pTSquaredSum.end())) * fractionSumPt2_;
     for (int j = nv - 1; j >= 0 && vtxGood.size() < maxVtx_; --j) {
       auto vtx_idx = patavtx_soa.view()[j].sortInd();
       assert(vtx_idx < nv);
       if (nTrkAssociated[vtx_idx] >= 2 && pTSquaredSum[vtx_idx] >= minFOM_fromFrac &&
           pTSquaredSum[vtx_idx] > minSumPt2_) {
         vtxGood.push_back(vtx_idx);
       }
     }
   }
 }

◆ standardizeTensor()

void L2TauNNProducer::standardizeTensor ( tensorflow::Tensor & tensor )

private

Definition at line 371 of file L2TauTagNNProducer.cc.

References ztail::d, Exception, input, L2cacheData_, SiStripPI::max, SiStripPI::mean, SiStripPI::min, and L2TauNNProducerCacheData::normVec.

Referenced by produce().

                                                                 {
   using NNInputs = L2TauTagNNv1::NNInputs;
   std::vector<int> tensor_shape(tensor.shape().dims());
   for (int d = 0; d < tensor.shape().dims(); d++) {
     tensor_shape.at(d) = tensor.shape().dim_size(d);
   }
   if (tensor_shape.size() != 4) {
     throw cms::Exception("InvalidTensor") << "Tensor shape does not have 4 dimensions!";
   }
   for (int tau_idx = 0; tau_idx < tensor_shape.at(0); tau_idx++) {
     for (int phi_idx = 0; phi_idx < tensor_shape.at(1); phi_idx++) {
       for (int eta_idx = 0; eta_idx < tensor_shape.at(2); eta_idx++) {
         for (int var_idx = 0; var_idx < tensor_shape.at(3); var_idx++) {
           auto getCell = [&](NNInputs input) -> float& {
             return getCellImpl(tensor, tau_idx, phi_idx, eta_idx, input);
           };
           float mean = L2cacheData_->normVec.at(var_idx).mean;
           float std = L2cacheData_->normVec.at(var_idx).std;
           float min = L2cacheData_->normVec.at(var_idx).min;
           float max = L2cacheData_->normVec.at(var_idx).max;
           float nonstd_var = getCell(static_cast<NNInputs>(var_idx));
           float std_var = static_cast<float>((nonstd_var - mean) / std);
           if (std_var > max) {
             std_var = static_cast<float>(max);
           } else if (std_var < min) {
             std_var = static_cast<float>(min);
           }
           getCell(static_cast<NNInputs>(var_idx)) = std_var;
         }
       }
     }
   }
 }

Member Data Documentation

◆ beamSpotToken_

const edm::EDGetTokenT<reco::BeamSpot> L2TauNNProducer::beamSpotToken_

private

Definition at line 216 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ bFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> L2TauNNProducer::bFieldToken_

private

Definition at line 213 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ debugLevel_

const int L2TauNNProducer::debugLevel_

private

Definition at line 205 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ dEta_width

constexpr float L2TauNNProducer::dEta_width = 2 * L2TauTagNNv1::dR_max / static_cast<float>(L2TauTagNNv1::nCellEta)

static

Definition at line 166 of file L2TauTagNNProducer.cc.

Referenced by getEtaPhiIndices().

◆ dPhi_width

constexpr float L2TauNNProducer::dPhi_width = 2 * L2TauTagNNv1::dR_max / static_cast<float>(L2TauTagNNv1::nCellPhi)

static

Definition at line 167 of file L2TauTagNNProducer.cc.

Referenced by getEtaPhiIndices().

◆ dR2_max

constexpr float L2TauNNProducer::dR2_max = L2TauTagNNv1::dR_max * L2TauTagNNv1::dR_max

static

Definition at line 165 of file L2TauTagNNProducer.cc.

Referenced by fillCaloRecHits(), and fillPatatracks().

◆ ebToken_

const edm::EDGetTokenT<EcalRecHitCollection> L2TauNNProducer::ebToken_

private

Definition at line 210 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ eeToken_

const edm::EDGetTokenT<EcalRecHitCollection> L2TauNNProducer::eeToken_

private

Definition at line 211 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ fractionSumPt2_

const float L2TauNNProducer::fractionSumPt2_

private

Definition at line 218 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

◆ geometryToken_

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> L2TauNNProducer::geometryToken_

private

Definition at line 212 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ hbheToken_

const edm::EDGetTokenT<HBHERecHitCollection> L2TauNNProducer::hbheToken_

private

Definition at line 208 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ hoToken_

const edm::EDGetTokenT<HORecHitCollection> L2TauNNProducer::hoToken_

private

Definition at line 209 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ inputTensorName_

std::string L2TauNNProducer::inputTensorName_

private

Definition at line 223 of file L2TauTagNNProducer.cc.

Referenced by L2TauNNProducer().

◆ L1TauDesc_

std::vector<InputDescTau> L2TauNNProducer::L1TauDesc_

private

Definition at line 207 of file L2TauTagNNProducer.cc.

Referenced by L2TauNNProducer(), and produce().

◆ L2cacheData_

const L2TauNNProducerCacheData* L2TauNNProducer::L2cacheData_

private

Definition at line 225 of file L2TauTagNNProducer.cc.

Referenced by getTauScore(), L2TauNNProducer(), and standardizeTensor().

◆ maxVtx_

const unsigned int L2TauNNProducer::maxVtx_

private

Definition at line 217 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

◆ minSumPt2_

const float L2TauNNProducer::minSumPt2_

private

Definition at line 219 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

◆ outputTensorName_

std::string L2TauNNProducer::outputTensorName_

private

Definition at line 224 of file L2TauTagNNProducer.cc.

Referenced by L2TauNNProducer().

◆ pataTracksToken_

const edm::EDGetTokenT<TrackSoAHost> L2TauNNProducer::pataTracksToken_

private

Definition at line 215 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ pataVerticesToken_

const edm::EDGetTokenT<ZVertexSoAHost> L2TauNNProducer::pataVerticesToken_

private

Definition at line 214 of file L2TauTagNNProducer.cc.

Referenced by produce().

◆ tauTriggerToken_

const edm::EDGetTokenT<trigger::TriggerFilterObjectWithRefs> L2TauNNProducer::tauTriggerToken_

private

Definition at line 206 of file L2TauTagNNProducer.cc.

◆ trackChi2Max_

const float L2TauNNProducer::trackChi2Max_

private

Definition at line 222 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

◆ trackPtMax_

const float L2TauNNProducer::trackPtMax_

private

Definition at line 221 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

◆ trackPtMin_

const float L2TauNNProducer::trackPtMin_

private

Definition at line 220 of file L2TauTagNNProducer.cc.

Referenced by selectGoodTracksAndVertices().

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ TrackSoAHost

Constructor & Destructor Documentation

◆ L2TauNNProducer()

Member Function Documentation

◆ checknan()

◆ fillCaloRecHits()

◆ fillDescriptions()

◆ fillL1TauVars()

◆ fillPatatracks()

◆ getEtaPhiIndices() [1/2]

◆ getEtaPhiIndices() [2/2]

◆ getTauScore()

◆ globalEndJob()

◆ impactParameter()

◆ initializeGlobalCache()

◆ produce()

◆ selectGoodTracksAndVertices()

◆ standardizeTensor()

Member Data Documentation

◆ beamSpotToken_

◆ bFieldToken_

◆ debugLevel_

◆ dEta_width

◆ dPhi_width

◆ dR2_max

◆ ebToken_

◆ eeToken_

◆ fractionSumPt2_

◆ geometryToken_

◆ hbheToken_

◆ hoToken_

◆ inputTensorName_

◆ L1TauDesc_

◆ L2cacheData_

◆ maxVtx_

◆ minSumPt2_

◆ outputTensorName_

◆ pataTracksToken_

◆ pataVerticesToken_

◆ tauTriggerToken_

◆ trackChi2Max_

◆ trackPtMax_

◆ trackPtMin_