DeepTauIdSonicProducer Class Reference

Inheritance diagram for DeepTauIdSonicProducer:

Public Member Functions
void	acquire (edm::Event const &iEvent, edm::EventSetup const &iSetup, Input &iInput) override
	DeepTauIdSonicProducer (edm::ParameterSet const &cfg)
void	produce (edm::Event &iEvent, edm::EventSetup const &iSetup, Output const &iOutput) override
Public Member Functions inherited from DeepTauIdBase< TritonEDProducer<> >
	DeepTauIdBase (const edm::ParameterSet &cfg)
const std::map< BasicDiscriminator, size_t >	matchDiscriminatorIndices (edm::Event const &event, edm::EDGetTokenT< reco::TauDiscriminatorContainer > discriminatorContainerToken, std::vector< BasicDiscriminator > requiredDiscr)
Public Member Functions inherited from TritonEDProducerT< G, Capabilities >
void	endStream () final
	TritonEDProducerT (edm::ParameterSet const &cfg)
virtual void	tritonEndStream ()
Public Member Functions inherited from SonicEDProducer< TritonClient, edm::GlobalCache< G >, Capabilities... >
void	produce (edm::Event &iEvent, edm::EventSetup const &iSetup) final
virtual void	produce (edm::Event &iEvent, edm::EventSetup const &iSetup, Output const &iOutput)=0
	SonicEDProducer (edm::ParameterSet const &cfg)
	~SonicEDProducer () override=default
Public Member Functions inherited from SonicAcquirer< TritonClient, edm::stream::EDProducer< edm::ExternalWork, Capabilities... > >
void	acquire (edm::Event const &iEvent, edm::EventSetup const &iSetup, edm::WaitingTaskWithArenaHolder holder) final
virtual void	acquire (edm::Event const &iEvent, edm::EventSetup const &iSetup, Input &iInput)=0
void	beginStream (edm::StreamID) override
	SonicAcquirer (edm::ParameterSet const &cfg)
	~SonicAcquirer () override=default
Public Member Functions inherited from edm::stream::EDProducer< edm::ExternalWork, Capabilities... >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from DeepTauIdBase< TritonEDProducer<> >
static void	fillDescriptionsHelper (edm::ParameterSetDescription &desc)
static const IDOutputCollection &	GetIDOutputs ()
Static Public Member Functions inherited from TritonEDProducerT< G, Capabilities >
static void	globalEndJob (G *)
static std::unique_ptr< G >	initializeGlobalCache (edm::ParameterSet const &pset)

Private Member Functions
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, const TauFunc &tau_funcs, bool is_inner, std::vector< float > *p_egammaBlockInputs, std::vector< float > *p_muonBlockInputs, std::vector< float > *p_hadronBlockInputs, std::vector< int64_t > *p_GridposInputs)
template<typename CandidateCastType , typename TauCastType >
void	prepareInputsV2 (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, const TauFunc &tau_funcs)

Private Attributes
std::vector< float > *	p_egammaInnerBlockInputs
std::vector< float > *	p_egammaOuterBlockInputs
std::vector< float > *	p_hadronInnerBlockInputs
std::vector< float > *	p_hadronOuterBlockInputs
std::vector< int64_t > *	p_innerGridposInputs
std::vector< float > *	p_muonInnerBlockInputs
std::vector< float > *	p_muonOuterBlockInputs
std::vector< int64_t > *	p_outerGridposInputs
std::vector< float > *	p_tauBlockInputs
std::vector< size_t >	tau_indices_

Additional Inherited Members
Public Types inherited from DeepTauIdBase< TritonEDProducer<> >
using	BasicDiscriminator = deep_tau::BasicDiscriminator
using	CandidateCollection = edm::View< reco::Candidate >
using	Cutter = tau::TauWPThreshold
using	CutterPtr = std::unique_ptr< Cutter >
using	ElectronCollection = pat::ElectronCollection
using	IDOutputCollection = std::map< std::string, IDOutput >
using	LorentzVectorXYZ = ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > >
using	MuonCollection = pat::MuonCollection
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 SonicEDProducer< TritonClient, edm::GlobalCache< G >, Capabilities... >
typedef TritonClient ::Output	Output
Public Types inherited from SonicAcquirer< TritonClient, edm::stream::EDProducer< edm::ExternalWork, Capabilities... > >
typedef TritonClient ::Input	Input
Public Types inherited from edm::stream::EDProducer< edm::ExternalWork, Capabilities... >
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 Attributes inherited from DeepTauIdBase< TritonEDProducer<> >
uint8_t	andPrediscriminants_
std::vector< TauDiscInfo< pat::PATTauDiscriminator > >	patPrediscriminants_
std::vector< TauDiscInfo< reco::PFTauDiscriminator > >	recoPrediscriminants_
Static Public Attributes inherited from DeepTauIdBase< TritonEDProducer<> >
static constexpr float	default_value
Protected Member Functions inherited from DeepTauIdBase< TritonEDProducer<> >
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, EgammaBlockType &egammaBlockInputs)
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, HadronBlockType &hadronBlockInputs)
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, MuonBlockType &muonBlockInputs)
void	createOutputs (edm::Event &event, const PredType &pred, edm::Handle< TauCollection > taus)
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, TauBlockType &tauBlockInputs)
void	fillGrids (const TauCastType &tau, const Collection &objects, CellGrid &inner_grid, CellGrid &outer_grid)
void	loadPrediscriminants (edm::Event const &event, edm::Handle< TauCollection > const &taus)
Protected Member Functions inherited from SonicAcquirer< TritonClient, edm::stream::EDProducer< edm::ExternalWork, Capabilities... > >
void	makeClient ()
Static Protected Member Functions inherited from DeepTauIdBase< TritonEDProducer<> >
static void	calculateElectronClusterVars (const pat::Electron *ele, float &elecEe, float &elecEgamma)
static bool	calculateElectronClusterVarsV2 (const pat::Electron &ele, float &cc_ele_energy, float &cc_gamma_energy, int &cc_n_gamma)
static bool	calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, double &gj_diff, TauFunc tau_funcs)
static float	calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, TauFunc tau_funcs)
static const pat::Electron *	findMatchedElectron (const TauCastType &tau, const std::vector< pat::Electron > *electrons, double deltaR)
static double	getInnerSignalConeRadius (double pt)
static float	getValue (T value)
static float	getValueLinear (T value, float min_value, float max_value, bool positive)
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)
static void	processIsolationPFComponents (const TauCastType &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
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)
Protected Attributes inherited from DeepTauIdBase< TritonEDProducer<> >
std::map< BasicDiscriminator, size_t >	basicDiscrdR03IndexMap_
std::map< BasicDiscriminator, size_t >	basicDiscrIndexMap_
edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminators_inputToken_
edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminatorsdR03_inputToken_
const int	debug_level
const bool	disable_CellIndex_workaround_
const bool	disable_dxy_pca_
const bool	disable_hcalFraction_workaround_
bool	discrIndicesMapped_
edm::EDGetTokenT< std::vector< pat::Electron > >	electrons_token_
int	file_counter_
IDOutputCollection	idoutputs_
std::string	input_layer_
bool	is_first_block_
const bool	is_online_
std::ofstream *	json_file_
edm::EDGetTokenT< std::vector< pat::Muon > >	muons_token_
std::string	output_layer_
edm::EDGetTokenT< CandidateCollection >	pfcandToken_
edm::EDGetTokenT< edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > > >	pfTauTransverseImpactParameters_token_
const std::vector< BasicDiscriminator >	requiredBasicDiscriminators_
const std::vector< BasicDiscriminator >	requiredBasicDiscriminatorsdR03_
edm::EDGetTokenT< double >	rho_token_
const bool	save_inputs_
const std::map< std::pair< deep_tau::Scaling::FeatureT, bool >, deep_tau::Scaling::ScalingParams > *	scalingParamsMap_
const std::map< BasicDiscriminator, std::string >	stringFromDiscriminator_
const unsigned	sub_version_
std::vector< int >	tauInputs_indices_
edm::EDGetTokenT< TauCollection >	tausToken_
const unsigned	version_
edm::EDGetTokenT< reco::VertexCollection >	vtxToken_
std::map< std::string, WPList >	workingPoints_
const unsigned	year_
Protected Attributes inherited from SonicAcquirer< TritonClient, edm::stream::EDProducer< edm::ExternalWork, Capabilities... > >
std::unique_ptr< TritonClient >	client_
edm::ParameterSet	clientPset_
std::string	debugName_
std::chrono::time_point< std::chrono::high_resolution_clock >	t_dispatch_
bool	verbose_
Static Protected Attributes inherited from DeepTauIdBase< TritonEDProducer<> >
static constexpr float	pi

Detailed Description

Definition at line 11 of file DeepTauIdSONIC.cc.

Constructor & Destructor Documentation

DeepTauIdSonicProducer()

DeepTauIdSonicProducer::DeepTauIdSonicProducer ( edm::ParameterSet const &  cfg )

inlineexplicit

Definition at line 13 of file DeepTauIdSONIC.cc.

: DeepTauIdBase<TritonEDProducer<>>(cfg){};

Member Function Documentation

acquire()

void DeepTauIdSonicProducer::acquire ( edm::Event const &  iEvent, edm::EventSetup const &  iSetup, Input &  iInput  )

override

Definition at line 61 of file DeepTauIdSONIC.cc.

References DeepTauIdBase< TritonEDProducer<> >::andPrediscriminants_, DeepTauIdBase< TritonEDProducer<> >::basicDiscrdR03IndexMap_, DeepTauIdBase< TritonEDProducer<> >::basicDiscrIndexMap_, HLT_2023v12_cff::basicTauDiscriminators, DeepTauIdBase< TritonEDProducer<> >::basicTauDiscriminators_inputToken_, HLT_2023v12_cff::basicTauDiscriminatorsdR03, DeepTauIdBase< TritonEDProducer<> >::basicTauDiscriminatorsdR03_inputToken_, SonicAcquirer< TritonClient, edm::stream::EDProducer< edm::ExternalWork, Capabilities... > >::client_, DeepTauIdBase< TritonEDProducer<> >::discrIndicesMapped_, DeepTauIdBase< TritonEDProducer<> >::electrons_token_, iEvent, DeepTauIdBase< TritonEDProducer<> >::is_online_, DeepTauIdBase< TritonEDProducer<> >::loadPrediscriminants(), DeepTauIdBase< TritonEDProducer<> >::matchDiscriminatorIndices(), DeepTauIdBase< TritonEDProducer<> >::muons_token_, p_egammaInnerBlockInputs, p_egammaOuterBlockInputs, p_hadronInnerBlockInputs, p_hadronOuterBlockInputs, p_innerGridposInputs, p_muonInnerBlockInputs, p_muonOuterBlockInputs, p_outerGridposInputs, p_tauBlockInputs, DeepTauIdBase< TritonEDProducer<> >::patPrediscriminants_, DeepTauIdBase< TritonEDProducer<> >::pfcandToken_, HLT_2023v12_cff::pfTauTransverseImpactParameters, DeepTauIdBase< TritonEDProducer<> >::pfTauTransverseImpactParameters_token_, DeepTauIdBase< TritonEDProducer<> >::recoPrediscriminants_, DeepTauIdBase< TritonEDProducer<> >::requiredBasicDiscriminators_, DeepTauIdBase< TritonEDProducer<> >::requiredBasicDiscriminatorsdR03_, rho, DeepTauIdBase< TritonEDProducer<> >::rho_token_, tau_indices_, Tau3MuMonitor_cff::taus, DeepTauIdBase< TritonEDProducer<> >::tausToken_, AlignmentTracksFromVertexSelector_cfi::vertices, and DeepTauIdBase< TritonEDProducer<> >::vtxToken_.

                                                                                                       {
  edm::Handle<TauCollection> taus;
  iEvent.getByToken(tausToken_, taus);

  loadPrediscriminants(iEvent, taus);

  const std::vector<pat::Electron> electron_collection_default;
  const std::vector<pat::Muon> muon_collection_default;
  const reco::TauDiscriminatorContainer basicTauDiscriminators_default;
  const reco::TauDiscriminatorContainer basicTauDiscriminatorsdR03_default;
  const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>
      pfTauTransverseImpactParameters_default;

  const std::vector<pat::Electron>* electron_collection;
  const std::vector<pat::Muon>* muon_collection;
  const reco::TauDiscriminatorContainer* basicTauDiscriminators;
  const reco::TauDiscriminatorContainer* basicTauDiscriminatorsdR03;
  const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>*
      pfTauTransverseImpactParameters;

  if (!is_online_) {
    electron_collection = &iEvent.get(electrons_token_);
    muon_collection = &iEvent.get(muons_token_);
    pfTauTransverseImpactParameters = &pfTauTransverseImpactParameters_default;
    basicTauDiscriminators = &basicTauDiscriminators_default;
    basicTauDiscriminatorsdR03 = &basicTauDiscriminatorsdR03_default;
  } else {
    electron_collection = &electron_collection_default;
    muon_collection = &muon_collection_default;
    pfTauTransverseImpactParameters = &iEvent.get(pfTauTransverseImpactParameters_token_);
    basicTauDiscriminators = &iEvent.get(basicTauDiscriminators_inputToken_);
    basicTauDiscriminatorsdR03 = &iEvent.get(basicTauDiscriminatorsdR03_inputToken_);

    // Get indices for discriminators
    if (!discrIndicesMapped_) {
      basicDiscrIndexMap_ =
          matchDiscriminatorIndices(iEvent, basicTauDiscriminators_inputToken_, requiredBasicDiscriminators_);
      basicDiscrdR03IndexMap_ =
          matchDiscriminatorIndices(iEvent, basicTauDiscriminatorsdR03_inputToken_, requiredBasicDiscriminatorsdR03_);
      discrIndicesMapped_ = true;
    }
  }

  TauFunc tauIDs = {basicTauDiscriminators,
                    basicTauDiscriminatorsdR03,
                    pfTauTransverseImpactParameters,
                    basicDiscrIndexMap_,
                    basicDiscrdR03IndexMap_};

  edm::Handle<edm::View<reco::Candidate>> pfCands;
  iEvent.getByToken(pfcandToken_, pfCands);

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

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

  // vector to store the indices for the taus passing the selections
  tau_indices_.clear();

  for (size_t tau_index = 0; tau_index < taus->size(); ++tau_index) {
    const edm::RefToBase<reco::BaseTau> tauRef = taus->refAt(tau_index);
    bool passesPrediscriminants;
    if (is_online_) {
      passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<reco::PFTauDiscriminator>>>(
          recoPrediscriminants_, andPrediscriminants_, tauRef);
    } else {
      passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<pat::PATTauDiscriminator>>>(
          patPrediscriminants_, andPrediscriminants_, tauRef);
    }
    if (!passesPrediscriminants)
      continue;

    // tau index that passes the selection
    tau_indices_.push_back(tau_index);
  }

  if (tau_indices_.empty()) {
    // no tau passing the requirement
    // no need to run acquire and inference
    client_->setBatchSize(0);
    return;
  }

  int n_taus = tau_indices_.size();
  // for the regular non-split deep-tau model, set the
  // batch size to the number of taus per event
  client_->setBatchSize(n_taus);

  auto& input_tauBlock = iInput.at("input_tau");
  auto& input_innerEgammaBlock = iInput.at("input_inner_egamma");
  auto& input_outerEgammaBlock = iInput.at("input_outer_egamma");
  auto& input_innerMuonBlock = iInput.at("input_inner_muon");
  auto& input_outerMuonBlock = iInput.at("input_outer_muon");
  auto& input_innerHadronBlock = iInput.at("input_inner_hadrons");
  auto& input_outerHadronBlock = iInput.at("input_outer_hadrons");

  p_innerGridposInputs = nullptr;
  p_outerGridposInputs = nullptr;

  auto data_tauBlock = input_tauBlock.allocate<float>();
  auto data_innerEgammaBlock = input_innerEgammaBlock.allocate<float>();
  auto data_outerEgammaBlock = input_outerEgammaBlock.allocate<float>();
  auto data_innerMuonBlock = input_innerMuonBlock.allocate<float>();
  auto data_outerMuonBlock = input_outerMuonBlock.allocate<float>();
  auto data_innerHadronBlock = input_innerHadronBlock.allocate<float>();
  auto data_outerHadronBlock = input_outerHadronBlock.allocate<float>();

  for (unsigned itau_passed = 0; itau_passed < tau_indices_.size(); ++itau_passed) {
    // batch size is not one, needs to go to corresponding itau
    p_tauBlockInputs = &((*data_tauBlock)[itau_passed]);

    p_egammaInnerBlockInputs = &((*data_innerEgammaBlock)[itau_passed]);
    p_muonInnerBlockInputs = &((*data_innerMuonBlock)[itau_passed]);
    p_hadronInnerBlockInputs = &((*data_innerHadronBlock)[itau_passed]);

    p_egammaOuterBlockInputs = &((*data_outerEgammaBlock)[itau_passed]);
    p_muonOuterBlockInputs = &((*data_outerMuonBlock)[itau_passed]);
    p_hadronOuterBlockInputs = &((*data_outerHadronBlock)[itau_passed]);

    int tau_index = tau_indices_[itau_passed];
    const edm::RefToBase<reco::BaseTau> tauRef = taus->refAt(tau_index);
    prepareInputsV2<pat::PackedCandidate, pat::Tau>(taus->at(tau_index),
                                                    tau_index,
                                                    tauRef,
                                                    electron_collection,
                                                    muon_collection,
                                                    *pfCands,
                                                    vertices->at(0),
                                                    *rho,
                                                    tauIDs);
  }

  // set all input data to the server
  input_tauBlock.toServer(data_tauBlock);

  input_innerEgammaBlock.toServer(data_innerEgammaBlock);
  input_innerMuonBlock.toServer(data_innerMuonBlock);
  input_innerHadronBlock.toServer(data_innerHadronBlock);

  input_outerEgammaBlock.toServer(data_outerEgammaBlock);
  input_outerMuonBlock.toServer(data_outerMuonBlock);
  input_outerHadronBlock.toServer(data_outerHadronBlock);
}

createConvFeatures()

template<typename CandidateCastType , typename TauCastType >

void DeepTauIdSonicProducer::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, const TauFunc &  tau_funcs, bool  is_inner, std::vector< float > *  p_egammaBlockInputs, std::vector< float > *  p_muonBlockInputs, std::vector< float > *  p_hadronBlockInputs, std::vector< int64_t > *  p_GridposInputs  )

private

Definition at line 299 of file DeepTauIdSONIC.cc.

References gather_cfg::cout, DeepTauIdBase< TritonEDProducer<> >::debug_level, pwdgSkimBPark_cfi::electrons, PVValHelper::eta, getRunAppsInfo::grid, heavyIonCSV_trainingSettings::idx, DiMuonV_cfg::muons, phi, MetAnalyzer::pv(), rho, and metsig::tau.

                                                                                     {
  // fill in the block inputs with zeros
  int n_cells = 0;
  int n_cell_oneside = is_inner ? dnn_inputs_v2::number_of_inner_cell : dnn_inputs_v2::number_of_outer_cell;

  n_cells = is_inner ? (dnn_inputs_v2::number_of_inner_cell * dnn_inputs_v2::number_of_inner_cell)
                     : (dnn_inputs_v2::number_of_outer_cell * dnn_inputs_v2::number_of_outer_cell);

  p_egammaBlockInputs->insert(
      p_egammaBlockInputs->end(), n_cells * dnn_inputs_v2::EgammaBlockInputs::NumberOfInputs, 0.);
  std::vector<float>::iterator egammaIter = p_egammaBlockInputs->begin();

  p_muonBlockInputs->insert(p_muonBlockInputs->end(), n_cells * dnn_inputs_v2::MuonBlockInputs::NumberOfInputs, 0.);
  std::vector<float>::iterator muonIter = p_muonBlockInputs->begin();

  p_hadronBlockInputs->insert(
      p_hadronBlockInputs->end(), n_cells * dnn_inputs_v2::HadronBlockInputs::NumberOfInputs, 0.);
  std::vector<float>::iterator hadronIter = p_hadronBlockInputs->begin();

  unsigned idx = 0;
  for (int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
    for (int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
      if (debug_level >= 2) {
        std::cout << "processing ( eta = " << eta << ", phi = " << phi << " )" << std::endl;
      }
      const CellIndex cell_index{eta, phi};

      const auto cell_iter = grid.find(cell_index);
      if (cell_iter != grid.end()) {
        if (debug_level >= 2) {
          std::cout << " creating inputs for ( eta = " << eta << ", phi = " << phi << " ): idx = " << idx << std::endl;
        }
        const Cell& cell = cell_iter->second;
        const int eta_index = grid.getEtaTensorIndex(cell_index);
        const int phi_index = grid.getPhiTensorIndex(cell_index);
        std::vector<float>::iterator egammaIterCell =
            egammaIter + (eta_index * n_cell_oneside + phi_index) * dnn_inputs_v2::EgammaBlockInputs::NumberOfInputs;
        std::vector<float>::iterator muonIterCell =
            muonIter + (eta_index * n_cell_oneside + phi_index) * dnn_inputs_v2::MuonBlockInputs::NumberOfInputs;
        std::vector<float>::iterator hadronIterCell =
            hadronIter + (eta_index * n_cell_oneside + phi_index) * dnn_inputs_v2::HadronBlockInputs::NumberOfInputs;

        createEgammaBlockInputs<CandidateCastType>(
            idx, tau, tau_index, tau_ref, pv, rho, electrons, pfCands, cell, tau_funcs, is_inner, egammaIterCell);
        createMuonBlockInputs<CandidateCastType>(
            idx, tau, tau_index, tau_ref, pv, rho, muons, pfCands, cell, tau_funcs, is_inner, muonIterCell);
        createHadronsBlockInputs<CandidateCastType>(
            idx, tau, tau_index, tau_ref, pv, rho, pfCands, cell, tau_funcs, is_inner, hadronIterCell);

        idx += 1;
      } else {
        if (debug_level >= 2) {
          std::cout << " skipping creation of inputs, because ( eta = " << eta << ", phi = " << phi
                    << " ) is not in the grid !!" << std::endl;
        }
        // we need to fill in the zeros for the input tensors
        idx += 1;
      }
    }
  }
}

fillDescriptions()

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

static

Definition at line 375 of file DeepTauIdSONIC.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, DeepTauIdBase< TritonEDProducer<> >::fillDescriptionsHelper(), and TritonClient::fillPSetDescription().

                                                                                        {
  edm::ParameterSetDescription desc;
  TritonClient::fillPSetDescription(desc);
  fillDescriptionsHelper(desc);
  descriptions.add("DeepTauIdSonicProducer", desc);
}

prepareInputsV2()

template<typename CandidateCastType , typename TauCastType >

void DeepTauIdSonicProducer::prepareInputsV2 ( 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, const TauFunc &  tau_funcs  )

private

Definition at line 242 of file DeepTauIdSONIC.cc.

References DeepTauIdBase< TritonEDProducer<> >::disable_CellIndex_workaround_, pwdgSkimBPark_cfi::electrons, DeepTauIdBase< TritonEDProducer<> >::fillGrids(), DiMuonV_cfg::muons, p_egammaInnerBlockInputs, p_egammaOuterBlockInputs, p_hadronInnerBlockInputs, p_hadronOuterBlockInputs, p_innerGridposInputs, p_muonInnerBlockInputs, p_muonOuterBlockInputs, p_outerGridposInputs, p_tauBlockInputs, MetAnalyzer::pv(), rho, and metsig::tau.

                                                                       {
  using namespace dnn_inputs_v2;
  CellGrid inner_grid(number_of_inner_cell, number_of_inner_cell, 0.02, 0.02, disable_CellIndex_workaround_);
  CellGrid outer_grid(number_of_outer_cell, number_of_outer_cell, 0.05, 0.05, disable_CellIndex_workaround_);
  auto tau_casted = dynamic_cast<const TauCastType&>(tau);
  // fill in the inner and outer grids for electrons, muons, and pfCands
  fillGrids(tau_casted, *electrons, inner_grid, outer_grid);
  fillGrids(tau_casted, *muons, inner_grid, outer_grid);
  fillGrids(tau_casted, pfCands, inner_grid, outer_grid);

  p_tauBlockInputs->insert(p_tauBlockInputs->end(), TauBlockInputs::NumberOfInputs, 0.);
  std::vector<float>::iterator tauIter = p_tauBlockInputs->begin();

  createTauBlockInputs<CandidateCastType>(tau_casted, tau_index, tau_ref, pv, rho, tau_funcs, tauIter);

  // egamma, muon, and hadron inner and outer inputs for the grids
  createConvFeatures<CandidateCastType>(tau_casted,
                                        tau_index,
                                        tau_ref,
                                        pv,
                                        rho,
                                        electrons,
                                        muons,
                                        pfCands,
                                        inner_grid,
                                        tau_funcs,
                                        true,
                                        p_egammaInnerBlockInputs,
                                        p_muonInnerBlockInputs,
                                        p_hadronInnerBlockInputs,
                                        p_innerGridposInputs);
  createConvFeatures<CandidateCastType>(tau_casted,
                                        tau_index,
                                        tau_ref,
                                        pv,
                                        rho,
                                        electrons,
                                        muons,
                                        pfCands,
                                        outer_grid,
                                        tau_funcs,
                                        false,
                                        p_egammaOuterBlockInputs,
                                        p_muonOuterBlockInputs,
                                        p_hadronOuterBlockInputs,
                                        p_outerGridposInputs);
}

produce()

void DeepTauIdSonicProducer::produce ( edm::Event &  iEvent, edm::EventSetup const &  iSetup, Output const &  iOutput  )

override

Definition at line 207 of file DeepTauIdSONIC.cc.

References filterCSVwithJSON::copy, gather_cfg::cout, DeepTauIdBase< TritonEDProducer<> >::createOutputs(), DeepTauIdBase< TritonEDProducer<> >::debug_level, mps_fire::end, f, mps_fire::i, iEvent, dqmdumpme::k, deep_tau::NumberOfOutputs, tau_indices_, Tau3MuMonitor_cff::taus, and DeepTauIdBase< TritonEDProducer<> >::tausToken_.

                                                                                                         {
  edm::Handle<TauCollection> taus;
  iEvent.getByToken(tausToken_, taus);

  if (taus->empty()) {
    std::vector<std::vector<float>> pred_all(0, std::vector<float>(deep_tau::NumberOfOutputs, 0.));
    createOutputs(iEvent, pred_all, taus);
    return;
  }

  const auto& output_tauval = iOutput.at("main_output/Softmax");
  const auto& outputs_tauval = output_tauval.fromServer<float>();

  // fill the taus passing the selections with the results from produce,
  //  and the taus failing the selections with 2 and -1.0
  std::vector<std::vector<float>> pred_all(taus->size(), std::vector<float>(deep_tau::NumberOfOutputs, 0.));
  for (unsigned itau = 0; itau < taus->size(); ++itau) {
    for (int k = 0; k < deep_tau::NumberOfOutputs; ++k) {
      pred_all[itau][k] = (k == 2) ? -1.f : 2.f;
    }
  }
  for (unsigned itau_passed = 0; itau_passed < tau_indices_.size(); ++itau_passed) {
    int tau_index = tau_indices_[itau_passed];
    std::copy(outputs_tauval[itau_passed].begin(), outputs_tauval[itau_passed].end(), pred_all[tau_index].begin());

    if (debug_level >= 2) {
      for (int i = 0; i < 4; ++i) {
        std::cout << "tau index " << itau_passed << " k " << i << " pred " << pred_all[tau_index][i] << std::endl;
      }
    }
  }
  createOutputs(iEvent, pred_all, taus);
}

Member Data Documentation

p_egammaInnerBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_egammaInnerBlockInputs

private

Definition at line 23 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_egammaOuterBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_egammaOuterBlockInputs

private

Definition at line 26 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_hadronInnerBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_hadronInnerBlockInputs

private

Definition at line 25 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_hadronOuterBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_hadronOuterBlockInputs

private

Definition at line 28 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_innerGridposInputs

std::vector<int64_t>* DeepTauIdSonicProducer::p_innerGridposInputs

private

Definition at line 29 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_muonInnerBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_muonInnerBlockInputs

private

Definition at line 24 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_muonOuterBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_muonOuterBlockInputs

private

Definition at line 27 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_outerGridposInputs

std::vector<int64_t>* DeepTauIdSonicProducer::p_outerGridposInputs

private

Definition at line 30 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

p_tauBlockInputs

std::vector<float>* DeepTauIdSonicProducer::p_tauBlockInputs

private

Definition at line 22 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and prepareInputsV2().

tau_indices_

std::vector<size_t> DeepTauIdSonicProducer::tau_indices_

private

Definition at line 20 of file DeepTauIdSONIC.cc.

Referenced by acquire(), and produce().