#include <DeepTauBase.h>

Inheritance diagram for deep_tau::DeepTauBase:

Classes
struct	Output

struct	TauDiscInfo

Public Types
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 > >
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
	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

	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	globalEndJob (const DeepTauCache *cache)

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

Public Attributes
uint8_t	andPrediscriminants_

std::vector< TauDiscInfo< pat::PATTauDiscriminator > >	patPrediscriminants_

std::vector< TauDiscInfo< reco::PFTauDiscriminator > >	recoPrediscriminants_

Protected Attributes
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
static const std::vector< BasicDiscriminator >	requiredBasicDiscriminators_

static const std::vector< BasicDiscriminator >	requiredBasicDiscriminatorsdR03_

static const std::map< BasicDiscriminator, std::string >	stringFromDiscriminator_

Private Member Functions
virtual void	createOutputs (edm::Event &event, const tensorflow::Tensor &pred, edm::Handle< TauCollection > taus)

virtual tensorflow::Tensor	getPredictions (edm::Event &event, edm::Handle< TauCollection > taus)=0

Detailed Description

Definition at line 66 of file DeepTauBase.h.

Member Typedef Documentation

◆ CandidateCollection

using deep_tau::DeepTauBase::CandidateCollection = edm::View<reco::Candidate>

Definition at line 70 of file DeepTauBase.h.

◆ Cutter

using deep_tau::DeepTauBase::Cutter = TauWPThreshold

Definition at line 76 of file DeepTauBase.h.

◆ CutterPtr

using deep_tau::DeepTauBase::CutterPtr = std::unique_ptr<Cutter>

Definition at line 77 of file DeepTauBase.h.

◆ ElectronCollection

using deep_tau::DeepTauBase::ElectronCollection = pat::ElectronCollection

Definition at line 73 of file DeepTauBase.h.

◆ LorentzVectorXYZ

using deep_tau::DeepTauBase::LorentzVectorXYZ = ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >

Definition at line 75 of file DeepTauBase.h.

◆ MuonCollection

using deep_tau::DeepTauBase::MuonCollection = pat::MuonCollection

Definition at line 74 of file DeepTauBase.h.

◆ OutputCollection

using deep_tau::DeepTauBase::OutputCollection = std::map<std::string, Output>

Definition at line 91 of file DeepTauBase.h.

◆ TauCollection

using deep_tau::DeepTauBase::TauCollection = edm::View<reco::BaseTau>

Definition at line 69 of file DeepTauBase.h.

◆ TauDiscriminator

using deep_tau::DeepTauBase::TauDiscriminator = reco::TauDiscriminatorContainer

Definition at line 68 of file DeepTauBase.h.

◆ TauRef

using deep_tau::DeepTauBase::TauRef = edm::Ref<TauCollection>

Definition at line 71 of file DeepTauBase.h.

◆ TauRefProd

using deep_tau::DeepTauBase::TauRefProd = edm::RefProd<TauCollection>

Definition at line 72 of file DeepTauBase.h.

◆ WPList

using deep_tau::DeepTauBase::WPList = std::vector<CutterPtr>

Definition at line 78 of file DeepTauBase.h.

Member Enumeration Documentation

◆ BasicDiscriminator

enum deep_tau::DeepTauBase::BasicDiscriminator

Enumerator
ChargedIsoPtSum
NeutralIsoPtSum
NeutralIsoPtSumWeight
FootprintCorrection
PhotonPtSumOutsideSignalCone
PUcorrPtSum

Definition at line 115 of file DeepTauBase.h.

                             {
       ChargedIsoPtSum,
       NeutralIsoPtSum,
       NeutralIsoPtSumWeight,
       FootprintCorrection,
       PhotonPtSumOutsideSignalCone,
       PUcorrPtSum
     };

Constructor & Destructor Documentation

◆ DeepTauBase()

deep_tau::DeepTauBase::DeepTauBase	(	const edm::ParameterSet &	cfg,
		const OutputCollection &	outputs,
		const DeepTauCache *	cache
	)

Definition at line 91 of file DeepTauBase.cc.

References andPrediscriminants_, looper::cfg, deep_tau::DeepTauBase::TauDiscInfo< ConsumeType >::cut, DMR_cfg::cut, deep_tau::DeepTauBase::TauDiscInfo< ConsumeType >::disc_token, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), is_online_, label, deep_tau::DeepTauBase::TauDiscInfo< ConsumeType >::label, outputs_, patPrediscriminants_, recoPrediscriminants_, AlCaHLTBitMon_QueryRunRegistry::string, HcalDetIdTransform::transform(), and workingPoints_.

       : tausToken_(consumes<TauCollection>(cfg.getParameter<edm::InputTag>("taus"))),
         pfcandToken_(consumes<CandidateCollection>(cfg.getParameter<edm::InputTag>("pfcands"))),
         vtxToken_(consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("vertices"))),
         is_online_(cfg.getParameter<bool>("is_online")),
         outputs_(outputCollection),
         cache_(cache) {
     for (const auto& output_desc : outputs_) {
       produces<TauDiscriminator>(output_desc.first);
       const auto& cut_list = cfg.getParameter<std::vector<std::string>>(output_desc.first + "WP");
       for (const std::string& cut_str : cut_list) {
         workingPoints_[output_desc.first].push_back(std::make_unique<Cutter>(cut_str));
       }
     }
 
     // prediscriminant operator
     // require the tau to pass the following prediscriminants
     const edm::ParameterSet& prediscriminantConfig = cfg.getParameter<edm::ParameterSet>("Prediscriminants");
 
     // determine boolean operator used on the prediscriminants
     std::string pdBoolOperator = prediscriminantConfig.getParameter<std::string>("BooleanOperator");
     // convert string to lowercase
     transform(pdBoolOperator.begin(), pdBoolOperator.end(), pdBoolOperator.begin(), ::tolower);
 
     if (pdBoolOperator == "and") {
       andPrediscriminants_ = 0x1;  //use chars instead of bools so we can do a bitwise trick later
     } else if (pdBoolOperator == "or") {
       andPrediscriminants_ = 0x0;
     } else {
       throw cms::Exception("TauDiscriminationProducerBase")
           << "PrediscriminantBooleanOperator defined incorrectly, options are: AND,OR";
     }
 
     // get the list of prediscriminants
     std::vector<std::string> prediscriminantsNames =
         prediscriminantConfig.getParameterNamesForType<edm::ParameterSet>();
 
     for (auto const& iDisc : prediscriminantsNames) {
       const edm::ParameterSet& iPredisc = prediscriminantConfig.getParameter<edm::ParameterSet>(iDisc);
       const edm::InputTag& label = iPredisc.getParameter<edm::InputTag>("Producer");
       double cut = iPredisc.getParameter<double>("cut");
 
       if (is_online_) {
         TauDiscInfo<reco::PFTauDiscriminator> thisDiscriminator;
         thisDiscriminator.label = label;
         thisDiscriminator.cut = cut;
         thisDiscriminator.disc_token = consumes<reco::PFTauDiscriminator>(label);
         recoPrediscriminants_.push_back(thisDiscriminator);
       } else {
         TauDiscInfo<pat::PATTauDiscriminator> thisDiscriminator;
         thisDiscriminator.label = label;
         thisDiscriminator.cut = cut;
         thisDiscriminator.disc_token = consumes<pat::PATTauDiscriminator>(label);
         patPrediscriminants_.push_back(thisDiscriminator);
       }
     }
   }

◆ ~DeepTauBase()

deep_tau::DeepTauBase::~DeepTauBase ( )

inlineoverride

Definition at line 94 of file DeepTauBase.h.

94 {}

Member Function Documentation

◆ createOutputs()

void deep_tau::DeepTauBase::createOutputs	(	edm::Event &	event,
		const tensorflow::Tensor &	pred,
		edm::Handle< TauCollection >	taus
	)

privatevirtual

Definition at line 182 of file DeepTauBase.cc.

References is_online_, eostools::move(), outputs_, mps_fire::result, Tau3MuMonitor_cff::taus, FWLite::working_points, and workingPoints_.

Referenced by produce().

                                                                                                               {
     for (const auto& output_desc : outputs_) {
       const WPList* working_points = nullptr;
       if (workingPoints_.find(output_desc.first) != workingPoints_.end()) {
         working_points = &workingPoints_.at(output_desc.first);
       }
       auto result = output_desc.second.get_value(taus, pred, working_points, is_online_);
       event.put(std::move(result), output_desc.first);
     }
   }

◆ getPredictions()

virtual tensorflow::Tensor deep_tau::DeepTauBase::getPredictions	(	edm::Event &	event,
		edm::Handle< TauCollection >	taus
	)

privatepure virtual

Implemented in DeepTauId.

Referenced by produce().

◆ globalEndJob()

static void deep_tau::DeepTauBase::globalEndJob ( const DeepTauCache * cache )

inlinestatic

Definition at line 99 of file DeepTauBase.h.

99 {}

◆ initializeGlobalCache()

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

static

Definition at line 193 of file DeepTauBase.cc.

References looper::cfg, mps_splice::entry, edm::FileInPath::fullPath(), HLT_2022v15_cff::graph_file, HLT_2022v15_cff::mem_mapped, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                            {
     const auto graph_name_vector = cfg.getParameter<std::vector<std::string>>("graph_file");
     std::map<std::string, std::string> graph_names;
     for (const auto& entry : graph_name_vector) {
       const size_t sep_pos = entry.find(':');
       std::string entry_name, graph_file;
       if (sep_pos != std::string::npos) {
         entry_name = entry.substr(0, sep_pos);
         graph_file = entry.substr(sep_pos + 1);
       } else {
         entry_name = "";
         graph_file = entry;
       }
       graph_file = edm::FileInPath(graph_file).fullPath();
       if (graph_names.count(entry_name))
         throw cms::Exception("DeepTauCache") << "Duplicated graph entries";
       graph_names[entry_name] = graph_file;
     }
     bool mem_mapped = cfg.getParameter<bool>("mem_mapped");
     return std::make_unique<DeepTauCache>(graph_names, mem_mapped);
   }

◆ produce()

void deep_tau::DeepTauBase::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

override

Definition at line 151 of file DeepTauBase.cc.

References createOutputs(), Exception, getPredictions(), is_online_, patPrediscriminants_, recoPrediscriminants_, Tau3MuMonitor_cff::taus, and tausToken_.

                                                                     {
     edm::Handle<TauCollection> taus;
     event.getByToken(tausToken_, taus);
     edm::ProductID tauProductID = taus.id();
 
     // load prediscriminators
     size_t nPrediscriminants =
         patPrediscriminants_.empty() ? recoPrediscriminants_.size() : patPrediscriminants_.size();
     for (size_t iDisc = 0; iDisc < nPrediscriminants; ++iDisc) {
       edm::ProductID discKeyId;
       if (is_online_) {
         recoPrediscriminants_[iDisc].fill(event);
         discKeyId = recoPrediscriminants_[iDisc].handle->keyProduct().id();
       } else {
         patPrediscriminants_[iDisc].fill(event);
         discKeyId = patPrediscriminants_[iDisc].handle->keyProduct().id();
       }
 
       // Check to make sure the product is correct for the discriminator.
       // If not, throw a more informative exception.
       if (tauProductID != discKeyId) {
         throw cms::Exception("MisconfiguredPrediscriminant")
             << "The tau collection has product ID: " << tauProductID
             << " but the pre-discriminator is keyed with product ID: " << discKeyId << std::endl;
       }
     }
 
     const tensorflow::Tensor& pred = getPredictions(event, taus);
     createOutputs(event, pred, taus);
   }

Member Data Documentation

◆ andPrediscriminants_

uint8_t deep_tau::DeepTauBase::andPrediscriminants_

Definition at line 111 of file DeepTauBase.h.

Referenced by DeepTauBase(), and DeepTauId::getPredictions().

◆ cache_

const DeepTauCache* deep_tau::DeepTauBase::cache_

protected

Definition at line 135 of file DeepTauBase.h.

Referenced by DeepTauId::getPartialPredictions(), DeepTauId::getPredictionsV2(), and DeepTauId::globalEndJob().

◆ is_online_

const bool deep_tau::DeepTauBase::is_online_

protected

Definition at line 133 of file DeepTauBase.h.

Referenced by createOutputs(), DeepTauId::createTauBlockInputs(), DeepTauBase(), DeepTauId::getPredictions(), and produce().

◆ outputs_

OutputCollection deep_tau::DeepTauBase::outputs_

protected

Definition at line 134 of file DeepTauBase.h.

Referenced by createOutputs(), DeepTauBase(), and DeepTauId::GetOutputs().

◆ patPrediscriminants_

std::vector<TauDiscInfo<pat::PATTauDiscriminator> > deep_tau::DeepTauBase::patPrediscriminants_

Definition at line 112 of file DeepTauBase.h.

Referenced by DeepTauBase(), DeepTauId::getPredictions(), and produce().

◆ pfcandToken_

edm::EDGetTokenT<CandidateCollection> deep_tau::DeepTauBase::pfcandToken_

protected

Definition at line 130 of file DeepTauBase.h.

Referenced by DeepTauId::getPredictions().

◆ recoPrediscriminants_

std::vector<TauDiscInfo<reco::PFTauDiscriminator> > deep_tau::DeepTauBase::recoPrediscriminants_

Definition at line 113 of file DeepTauBase.h.

Referenced by DeepTauBase(), DeepTauId::getPredictions(), and produce().

◆ requiredBasicDiscriminators_

const std::vector< bd > deep_tau::DeepTauBase::requiredBasicDiscriminators_

staticprotected

Initial value:

= {bd::ChargedIsoPtSum,
                                                                             bd::NeutralIsoPtSum,
                                                                             bd::NeutralIsoPtSumWeight,
                                                                             bd::PhotonPtSumOutsideSignalCone,
                                                                             bd::PUcorrPtSum}

Definition at line 138 of file DeepTauBase.h.

Referenced by DeepTauId::getPredictions().

◆ requiredBasicDiscriminatorsdR03_

const std::vector< bd > deep_tau::DeepTauBase::requiredBasicDiscriminatorsdR03_

staticprotected

Initial value:

= {bd::ChargedIsoPtSum,
                                                                                 bd::NeutralIsoPtSum,
                                                                                 bd::NeutralIsoPtSumWeight,
                                                                                 bd::PhotonPtSumOutsideSignalCone,
                                                                                 bd::FootprintCorrection}

Definition at line 139 of file DeepTauBase.h.

Referenced by DeepTauId::getPredictions().

◆ stringFromDiscriminator_

const std::map< bd, std::string > deep_tau::DeepTauBase::stringFromDiscriminator_

staticprotected

Initial value:

{
    {bd::ChargedIsoPtSum, "ChargedIsoPtSum"},
    {bd::NeutralIsoPtSum, "NeutralIsoPtSum"},
    {bd::NeutralIsoPtSumWeight, "NeutralIsoPtSumWeight"},
    {bd::FootprintCorrection, "TauFootprintCorrection"},
    {bd::PhotonPtSumOutsideSignalCone, "PhotonPtSumOutsideSignalCone"},
    {bd::PUcorrPtSum, "PUcorrPtSum"}}

Definition at line 137 of file DeepTauBase.h.

Referenced by DeepTauId::matchDiscriminatorIndices().

◆ tausToken_

edm::EDGetTokenT<TauCollection> deep_tau::DeepTauBase::tausToken_

protected

Definition at line 129 of file DeepTauBase.h.

Referenced by produce().

◆ vtxToken_

edm::EDGetTokenT<reco::VertexCollection> deep_tau::DeepTauBase::vtxToken_

protected

Definition at line 131 of file DeepTauBase.h.

Referenced by DeepTauId::getPredictions().

◆ workingPoints_

std::map<std::string, WPList> deep_tau::DeepTauBase::workingPoints_

protected

Definition at line 132 of file DeepTauBase.h.

Referenced by createOutputs(), and DeepTauBase().

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ CandidateCollection

◆ Cutter

◆ CutterPtr

◆ ElectronCollection

◆ LorentzVectorXYZ

◆ MuonCollection

◆ OutputCollection

◆ TauCollection

◆ TauDiscriminator

◆ TauRef

◆ TauRefProd

◆ WPList

Member Enumeration Documentation

◆ BasicDiscriminator

Constructor & Destructor Documentation

◆ DeepTauBase()

◆ ~DeepTauBase()

Member Function Documentation

◆ createOutputs()

◆ getPredictions()

◆ globalEndJob()

◆ initializeGlobalCache()

◆ produce()

Member Data Documentation

◆ andPrediscriminants_

◆ cache_

◆ is_online_

◆ outputs_

◆ patPrediscriminants_

◆ pfcandToken_

◆ recoPrediscriminants_

◆ requiredBasicDiscriminators_

◆ requiredBasicDiscriminatorsdR03_

◆ stringFromDiscriminator_

◆ tausToken_

◆ vtxToken_

◆ workingPoints_