Inheritance diagram for TrackstersMergeProducer:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

	TrackstersMergeProducer (const edm::ParameterSet &ps)

	~TrackstersMergeProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	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)

Private Types
typedef ticl::Trackster::IterationIndex	TracksterIterIndex

Private Member Functions
void	assignTimeToCandidates (std::vector< TICLCandidate > &resultCandidates) const

void	dumpTrackster (const Trackster &) const

void	energyRegressionAndID (const std::vector< reco::CaloCluster > &layerClusters, const tensorflow::Session *, std::vector< Trackster > &result) const

void	fillTile (TICLTracksterTiles &, const std::vector< Trackster > &, TracksterIterIndex)

void	printTrackstersDebug (const std::vector< Trackster > &, const char *label) const

Private Attributes
const edm::EDGetTokenT< std::vector< reco::CaloCluster > >	clusters_token_

const edm::EDGetTokenT< edm::ValueMap< std::pair< float, float > > >	clustersTime_token_

const double	cosangle_align_

const bool	debug_

const double	e_over_h_threshold_

const std::string	eidInputName_

const float	eidMinClusterEnergy_

const int	eidNClusters_

const int	eidNLayers_

const std::string	eidOutputNameEnergy_

const std::string	eidOutputNameId_

tensorflow::Session *	eidSession_

const int	eta_bin_window_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometry_token_

const double	halo_max_distance2_

const bool	optimiseAcrossTracksters_

const int	phi_bin_window_

const double	pt_neutral_threshold_

const double	pt_sigma_high_

const double	pt_sigma_low_

const double	resol_calo_offset_em_

const double	resol_calo_offset_had_

const double	resol_calo_scale_em_

const double	resol_calo_scale_had_

hgcal::RecHitTools	rhtools_

const edm::EDGetTokenT< std::vector< TICLSeedingRegion > >	seedingTrk_token_

const std::string	tfDnnLabel_

const edm::ESGetToken< TfGraphDefWrapper, TfGraphRecord >	tfDnnToken_

const tensorflow::Session *	tfSession_

const double	track_max_eta_

const int	track_max_missing_outerhits_

const double	track_min_eta_

const double	track_min_pt_

const edm::EDGetTokenT< std::vector< reco::Track > >	tracks_token_

const edm::EDGetTokenT< std::vector< Trackster > >	trackstersem_token_

const edm::EDGetTokenT< std::vector< Trackster > >	trackstershad_token_

const edm::EDGetTokenT< std::vector< Trackster > >	tracksterstrk_token_

const edm::EDGetTokenT< std::vector< Trackster > >	tracksterstrkem_token_

Static Private Attributes
static constexpr int	eidNFeatures_ = 3

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
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

Detailed Description

Definition at line 27 of file TrackstersMergeProducer.cc.

Member Typedef Documentation

◆ TracksterIterIndex

typedef ticl::Trackster::IterationIndex TrackstersMergeProducer::TracksterIterIndex

private

Definition at line 35 of file TrackstersMergeProducer.cc.

Constructor & Destructor Documentation

◆ TrackstersMergeProducer()

TrackstersMergeProducer::TrackstersMergeProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 90 of file TrackstersMergeProducer.cc.

     : tracksterstrkem_token_(consumes<std::vector<Trackster>>(ps.getParameter<edm::InputTag>("tracksterstrkem"))),
       trackstersem_token_(consumes<std::vector<Trackster>>(ps.getParameter<edm::InputTag>("trackstersem"))),
       tracksterstrk_token_(consumes<std::vector<Trackster>>(ps.getParameter<edm::InputTag>("tracksterstrk"))),
       trackstershad_token_(consumes<std::vector<Trackster>>(ps.getParameter<edm::InputTag>("trackstershad"))),
       seedingTrk_token_(consumes<std::vector<TICLSeedingRegion>>(ps.getParameter<edm::InputTag>("seedingTrk"))),
       clusters_token_(consumes<std::vector<reco::CaloCluster>>(ps.getParameter<edm::InputTag>("layer_clusters"))),
       clustersTime_token_(
           consumes<edm::ValueMap<std::pair<float, float>>>(ps.getParameter<edm::InputTag>("layer_clustersTime"))),
       tracks_token_(consumes<std::vector<reco::Track>>(ps.getParameter<edm::InputTag>("tracks"))),
       geometry_token_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
       tfDnnLabel_(ps.getParameter<std::string>("tfDnnLabel")),
       tfDnnToken_(esConsumes(edm::ESInputTag("", tfDnnLabel_))),
       tfSession_(nullptr),
       optimiseAcrossTracksters_(ps.getParameter<bool>("optimiseAcrossTracksters")),
       eta_bin_window_(ps.getParameter<int>("eta_bin_window")),
       phi_bin_window_(ps.getParameter<int>("phi_bin_window")),
       pt_sigma_high_(ps.getParameter<double>("pt_sigma_high")),
       pt_sigma_low_(ps.getParameter<double>("pt_sigma_low")),
       halo_max_distance2_(ps.getParameter<double>("halo_max_distance2")),
       track_min_pt_(ps.getParameter<double>("track_min_pt")),
       track_min_eta_(ps.getParameter<double>("track_min_eta")),
       track_max_eta_(ps.getParameter<double>("track_max_eta")),
       track_max_missing_outerhits_(ps.getParameter<int>("track_max_missing_outerhits")),
       cosangle_align_(ps.getParameter<double>("cosangle_align")),
       e_over_h_threshold_(ps.getParameter<double>("e_over_h_threshold")),
       pt_neutral_threshold_(ps.getParameter<double>("pt_neutral_threshold")),
       resol_calo_offset_had_(ps.getParameter<double>("resol_calo_offset_had")),
       resol_calo_scale_had_(ps.getParameter<double>("resol_calo_scale_had")),
       resol_calo_offset_em_(ps.getParameter<double>("resol_calo_offset_em")),
       resol_calo_scale_em_(ps.getParameter<double>("resol_calo_scale_em")),
       debug_(ps.getParameter<bool>("debug")),
       eidInputName_(ps.getParameter<std::string>("eid_input_name")),
       eidOutputNameEnergy_(ps.getParameter<std::string>("eid_output_name_energy")),
       eidOutputNameId_(ps.getParameter<std::string>("eid_output_name_id")),
       eidMinClusterEnergy_(ps.getParameter<double>("eid_min_cluster_energy")),
       eidNLayers_(ps.getParameter<int>("eid_n_layers")),
       eidNClusters_(ps.getParameter<int>("eid_n_clusters")),
       eidSession_(nullptr) {
   produces<std::vector<Trackster>>();
   produces<std::vector<TICLCandidate>>();
 }

◆ ~TrackstersMergeProducer()

TrackstersMergeProducer::~TrackstersMergeProducer ( )

inlineoverride

Definition at line 30 of file TrackstersMergeProducer.cc.

30 {};

Member Function Documentation

◆ assignTimeToCandidates()

void TrackstersMergeProducer::assignTimeToCandidates ( std::vector< TICLCandidate > & resultCandidates ) const

private

Definition at line 687 of file TrackstersMergeProducer.cc.

References funct::pow(), mathSSE::sqrt(), and protons_cff::time.

Referenced by produce().

                                                                                                      {
   for (auto &cand : resultCandidates) {
     if (cand.tracksters().size() > 1) {  // For single-trackster candidates the timing is already set
       float time = 0.f;
       float timeErr = 0.f;
       for (const auto &tr : cand.tracksters()) {
         if (tr->timeError() > 0) {
           auto invTimeESq = pow(tr->timeError(), -2);
           time += tr->time() * invTimeESq;
           timeErr += invTimeESq;
         }
       }
       if (timeErr > 0) {
         timeErr = 1. / timeErr;
 
         cand.setTime(time * timeErr);
         cand.setTimeError(sqrt(timeErr));
       }
     }
   }
 }

◆ dumpTrackster()

void TrackstersMergeProducer::dumpTrackster ( const Trackster & t ) const

private

Definition at line 148 of file TrackstersMergeProducer.cc.

References mps_fire::end, alignBH_cfg::fixed, dqmMemoryStats::float, LogDebug, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::s, mathSSE::sqrt(), and submitPVValidationJobs::t.

                                                                     {
   auto e_over_h = (t.raw_em_pt() / ((t.raw_pt() - t.raw_em_pt()) != 0. ? (t.raw_pt() - t.raw_em_pt()) : 1.));
   LogDebug("TrackstersMergeProducer")
       << "\nTrackster raw_pt: " << t.raw_pt() << " raw_em_pt: " << t.raw_em_pt() << " eoh: " << e_over_h
       << " barycenter: " << t.barycenter() << " eta,phi (baricenter): " << t.barycenter().eta() << ", "
       << t.barycenter().phi() << " eta,phi (eigen): " << t.eigenvectors(0).eta() << ", " << t.eigenvectors(0).phi()
       << " pt(eigen): " << std::sqrt(t.eigenvectors(0).Unit().perp2()) * t.raw_energy() << " seedID: " << t.seedID()
       << " seedIndex: " << t.seedIndex() << " size: " << t.vertices().size() << " average usage: "
       << (std::accumulate(std::begin(t.vertex_multiplicity()), std::end(t.vertex_multiplicity()), 0.) /
           (float)t.vertex_multiplicity().size())
       << " raw_energy: " << t.raw_energy() << " regressed energy: " << t.regressed_energy()
       << " probs(ga/e/mu/np/cp/nh/am/unk): ";
   for (auto const &p : t.id_probabilities()) {
     LogDebug("TrackstersMergeProducer") << std::fixed << p << " ";
   }
   LogDebug("TrackstersMergeProducer") << " sigmas: ";
   for (auto const &s : t.sigmas()) {
     LogDebug("TrackstersMergeProducer") << s << " ";
   }
   LogDebug("TrackstersMergeProducer") << std::endl;
 }

◆ energyRegressionAndID()

void TrackstersMergeProducer::energyRegressionAndID	(	const std::vector< reco::CaloCluster > &	layerClusters,
		const tensorflow::Session *	eidSession,
		std::vector< Trackster > &	result
	)		const

private

Definition at line 545 of file TrackstersMergeProducer.cc.

References a, funct::abs(), b, data, eidInputName_, eidMinClusterEnergy_, eidNClusters_, eidNFeatures_, eidNLayers_, eidOutputNameEnergy_, eidOutputNameId_, HCALHighEnergyHPDFilter_cfi::energy, reco::CaloCluster::energy(), reco::CaloCluster::eta(), f, lowptgsfeleseed::features(), dqmMemoryStats::float, hgcal::RecHitTools::getLayerWithOffset(), reco::CaloCluster::hitsAndFractions(), mps_fire::i, input, createfilelist::int, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, jetsAK4_CHS_cff::outputNames, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, reco::CaloCluster::phi(), rhtools_, tensorflow::run(), jetUpdater_cfi::sort, bphysicsOniaDQM_cfi::vertex, ticl::Trackster::vertex_multiplicity(), AlignmentTracksFromVertexSelector_cfi::vertices, and ticl::Trackster::vertices().

Referenced by produce().

                                                                                             {
   // Energy regression and particle identification strategy:
   //
   // 1. Set default values for regressed energy and particle id for each trackster.
   // 2. Store indices of tracksters whose total sum of cluster energies is above the
   //    eidMinClusterEnergy_ (GeV) treshold. Inference is not applied for soft tracksters.
   // 3. When no trackster passes the selection, return.
   // 4. Create input and output tensors. The batch dimension is determined by the number of
   //    selected tracksters.
   // 5. Fill input tensors with layer cluster features. Per layer, clusters are ordered descending
   //    by energy. Given that tensor data is contiguous in memory, we can use pointer arithmetic to
   //    fill values, even with batching.
   // 6. Zero-fill features for empty clusters in each layer.
   // 7. Batched inference.
   // 8. Assign the regressed energy and id probabilities to each trackster.
   //
   // Indices used throughout this method:
   // i -> batch element / trackster
   // j -> layer
   // k -> cluster
   // l -> feature
 
   // set default values per trackster, determine if the cluster energy threshold is passed,
   // and store indices of hard tracksters
   std::vector<int> tracksterIndices;
   for (int i = 0; i < (int)tracksters.size(); i++) {
     // calculate the cluster energy sum (2)
     // note: after the loop, sumClusterEnergy might be just above the threshold
     // which is enough to decide whether to run inference for the trackster or
     // not
     float sumClusterEnergy = 0.;
     for (const unsigned int &vertex : tracksters[i].vertices()) {
       sumClusterEnergy += (float)layerClusters[vertex].energy();
       // there might be many clusters, so try to stop early
       if (sumClusterEnergy >= eidMinClusterEnergy_) {
         // set default values (1)
         tracksters[i].setRegressedEnergy(0.f);
         tracksters[i].zeroProbabilities();
         tracksterIndices.push_back(i);
         break;
       }
     }
   }
 
   // do nothing when no trackster passes the selection (3)
   int batchSize = (int)tracksterIndices.size();
   if (batchSize == 0) {
     return;
   }
 
   // create input and output tensors (4)
   tensorflow::TensorShape shape({batchSize, eidNLayers_, eidNClusters_, eidNFeatures_});
   tensorflow::Tensor input(tensorflow::DT_FLOAT, shape);
   tensorflow::NamedTensorList inputList = {{eidInputName_, input}};
   static constexpr int inputDimension = 4;
 
   std::vector<tensorflow::Tensor> outputs;
   std::vector<std::string> outputNames;
   if (!eidOutputNameEnergy_.empty()) {
     outputNames.push_back(eidOutputNameEnergy_);
   }
   if (!eidOutputNameId_.empty()) {
     outputNames.push_back(eidOutputNameId_);
   }
 
   // fill input tensor (5)
   for (int i = 0; i < batchSize; i++) {
     const Trackster &trackster = tracksters[tracksterIndices[i]];
 
     // per layer, we only consider the first eidNClusters_ clusters in terms of
     // energy, so in order to avoid creating large / nested structures to do
     // the sorting for an unknown number of total clusters, create a sorted
     // list of layer cluster indices to keep track of the filled clusters
     std::vector<int> clusterIndices(trackster.vertices().size());
     for (int k = 0; k < (int)trackster.vertices().size(); k++) {
       clusterIndices[k] = k;
     }
     sort(clusterIndices.begin(), clusterIndices.end(), [&layerClusters, &trackster](const int &a, const int &b) {
       return layerClusters[trackster.vertices(a)].energy() > layerClusters[trackster.vertices(b)].energy();
     });
 
     // keep track of the number of seen clusters per layer
     std::vector<int> seenClusters(eidNLayers_);
 
     // loop through clusters by descending energy
     for (const int &k : clusterIndices) {
       // get features per layer and cluster and store the values directly in the input tensor
       const reco::CaloCluster &cluster = layerClusters[trackster.vertices(k)];
       int j = rhtools_.getLayerWithOffset(cluster.hitsAndFractions()[0].first) - 1;
       if (j < eidNLayers_ && seenClusters[j] < eidNClusters_) {
         // get the pointer to the first feature value for the current batch, layer and cluster
         float *features = &input.tensor<float, inputDimension>()(i, j, seenClusters[j], 0);
 
         // fill features
         *(features++) = float(cluster.energy() / float(trackster.vertex_multiplicity(k)));
         *(features++) = float(std::abs(cluster.eta()));
         *(features) = float(cluster.phi());
 
         // increment seen clusters
         seenClusters[j]++;
       }
     }
 
     // zero-fill features of empty clusters in each layer (6)
     for (int j = 0; j < eidNLayers_; j++) {
       for (int k = seenClusters[j]; k < eidNClusters_; k++) {
         float *features = &input.tensor<float, inputDimension>()(i, j, k, 0);
         for (int l = 0; l < eidNFeatures_; l++) {
           *(features++) = 0.f;
         }
       }
     }
   }
 
   // run the inference (7)
   tensorflow::run(const_cast<tensorflow::Session *>(eidSession), inputList, outputNames, &outputs);
 
   // store regressed energy per trackster (8)
   if (!eidOutputNameEnergy_.empty()) {
     // get the pointer to the energy tensor, dimension is batch x 1
     float *energy = outputs[0].flat<float>().data();
 
     for (const int &i : tracksterIndices) {
       tracksters[i].setRegressedEnergy(*(energy++));
     }
   }
 
   // store id probabilities per trackster (8)
   if (!eidOutputNameId_.empty()) {
     // get the pointer to the id probability tensor, dimension is batch x id_probabilities.size()
     int probsIdx = !eidOutputNameEnergy_.empty();
     float *probs = outputs[probsIdx].flat<float>().data();
 
     for (const int &i : tracksterIndices) {
       tracksters[i].setProbabilities(probs);
       probs += tracksters[i].id_probabilities().size();
     }
   }
 }

◆ fillDescriptions()

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

static

Definition at line 736 of file TrackstersMergeProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v14_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("tracksterstrkem", edm::InputTag("ticlTrackstersTrkEM"));
   desc.add<edm::InputTag>("trackstersem", edm::InputTag("ticlTrackstersEM"));
   desc.add<edm::InputTag>("tracksterstrk", edm::InputTag("ticlTrackstersTrk"));
   desc.add<edm::InputTag>("trackstershad", edm::InputTag("ticlTrackstersHAD"));
   desc.add<edm::InputTag>("seedingTrk", edm::InputTag("ticlSeedingTrk"));
   desc.add<edm::InputTag>("layer_clusters", edm::InputTag("hgcalLayerClusters"));
   desc.add<edm::InputTag>("layer_clustersTime", edm::InputTag("hgcalLayerClusters", "timeLayerCluster"));
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<bool>("optimiseAcrossTracksters", true);
   desc.add<int>("eta_bin_window", 1);
   desc.add<int>("phi_bin_window", 1);
   desc.add<double>("pt_sigma_high", 2.);
   desc.add<double>("pt_sigma_low", 2.);
   desc.add<double>("halo_max_distance2", 4.);
   desc.add<double>("track_min_pt", 1.);
   desc.add<double>("track_min_eta", 1.48);
   desc.add<double>("track_max_eta", 3.);
   desc.add<int>("track_max_missing_outerhits", 5);
   desc.add<double>("cosangle_align", 0.9945);
   desc.add<double>("e_over_h_threshold", 1.);
   desc.add<double>("pt_neutral_threshold", 2.);
   desc.add<double>("resol_calo_offset_had", 1.5);
   desc.add<double>("resol_calo_scale_had", 0.15);
   desc.add<double>("resol_calo_offset_em", 1.5);
   desc.add<double>("resol_calo_scale_em", 0.15);
   desc.add<bool>("debug", true);
   desc.add<std::string>("tfDnnLabel", "tracksterSelectionTf");
   desc.add<std::string>("eid_input_name", "input");
   desc.add<std::string>("eid_output_name_energy", "output/regressed_energy");
   desc.add<std::string>("eid_output_name_id", "output/id_probabilities");
   desc.add<double>("eid_min_cluster_energy", 1.);
   desc.add<int>("eid_n_layers", 50);
   desc.add<int>("eid_n_clusters", 10);
   descriptions.add("trackstersMergeProducer", desc);
 }

◆ fillTile()

void TrackstersMergeProducer::fillTile	(	TICLTracksterTiles &	tracksterTile,
		const std::vector< Trackster > &	tracksters,
		TracksterIterIndex	tracksterIteration
	)

private

Definition at line 133 of file TrackstersMergeProducer.cc.

References TICLGenericTile< T >::fill(), LogDebug, BeamMonitor_cff::phiBin, and submitPVValidationJobs::t.

Referenced by produce().

                                                                               {
   int tracksterId = 0;
   for (auto const &t : tracksters) {
     tracksterTile.fill(tracksterIteration, t.barycenter().eta(), t.barycenter().phi(), tracksterId);
     LogDebug("TrackstersMergeProducer") << "Adding tracksterId: " << tracksterId << " into bin [eta,phi]: [ "
                                         << tracksterTile[tracksterIteration].etaBin(t.barycenter().eta()) << ", "
                                         << tracksterTile[tracksterIteration].phiBin(t.barycenter().phi())
                                         << "] for iteration: " << tracksterIteration << std::endl;
 
     tracksterId++;
   }
 }

◆ printTrackstersDebug()

void TrackstersMergeProducer::printTrackstersDebug	(	const std::vector< Trackster > &	tracksters,
		const char *	label
	)		const

private

Definition at line 709 of file TrackstersMergeProducer.cc.

References debug_, mps_fire::end, alignBH_cfg::fixed, dqmMemoryStats::float, label, LogDebug, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::s, mathSSE::sqrt(), and submitPVValidationJobs::t.

Referenced by produce().

                                                                                                                   {
   if (!debug_)
     return;
 
   int counter = 0;
   for (auto const &t : tracksters) {
     LogDebug("TrackstersMergeProducer")
         << counter++ << " TrackstersMergeProducer (" << label << ") obj barycenter: " << t.barycenter()
         << " eta,phi (baricenter): " << t.barycenter().eta() << ", " << t.barycenter().phi()
         << " eta,phi (eigen): " << t.eigenvectors(0).eta() << ", " << t.eigenvectors(0).phi()
         << " pt(eigen): " << std::sqrt(t.eigenvectors(0).Unit().perp2()) * t.raw_energy() << " seedID: " << t.seedID()
         << " seedIndex: " << t.seedIndex() << " size: " << t.vertices().size() << " average usage: "
         << (std::accumulate(std::begin(t.vertex_multiplicity()), std::end(t.vertex_multiplicity()), 0.) /
             (float)t.vertex_multiplicity().size())
         << " raw_energy: " << t.raw_energy() << " regressed energy: " << t.regressed_energy()
         << " probs(ga/e/mu/np/cp/nh/am/unk): ";
     for (auto const &p : t.id_probabilities()) {
       LogDebug("TrackstersMergeProducer") << std::fixed << p << " ";
     }
     LogDebug("TrackstersMergeProducer") << " sigmas: ";
     for (auto const &s : t.sigmas()) {
       LogDebug("TrackstersMergeProducer") << s << " ";
     }
     LogDebug("TrackstersMergeProducer") << std::endl;
   }
 }

◆ produce()

void TrackstersMergeProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 170 of file TrackstersMergeProducer.cc.

References funct::abs(), TICLCandidate::addTrackster(), ticl::assignPCAtoTracksters(), assignTimeToCandidates(), clusters_token_, clustersTime_token_, debug_, HCALHighEnergyHPDFilter_cfi::energy, energyRegressionAndID(), fillTile(), relativeConstraints::geom, geometry_token_, edm::Event::getByToken(), edm::EventSetup::getData(), edm::EventSetup::getHandle(), hgcal::RecHitTools::getPositionLayer(), halo_max_distance2_, reco::TrackBase::highPurity, mps_fire::i, hgcal::RecHitTools::lastLayerEE(), hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, mag2(), eostools::move(), printTrackstersDebug(), edm::Event::put(), rhtools_, alignCSCRings::s, ticlTrackstersMerge_cfi::seedingTrk, seedingTrk_token_, reco::LeafCandidate::setCharge(), hgcal::RecHitTools::setGeometry(), reco::LeafCandidate::setP4(), reco::LeafCandidate::setPdgId(), TICLCandidate::setRawEnergy(), TICLCandidate::setTrackPtr(), mathSSE::sqrt(), submitPVValidationJobs::t, tfDnnToken_, tfSession_, HLT_2022v14_cff::track, track_max_eta_, track_max_missing_outerhits_, track_min_eta_, track_min_pt_, tracks, tracks_token_, trackstersem_token_, trackstershad_token_, tracksterstrk_token_, tracksterstrkem_token_, and z.

                                                                             {
   edm::ESHandle<CaloGeometry> geom = es.getHandle(geometry_token_);
   rhtools_.setGeometry(*geom);
   auto resultTrackstersMerged = std::make_unique<std::vector<Trackster>>();
   auto resultCandidates = std::make_unique<std::vector<TICLCandidate>>();
 
   tfSession_ = es.getData(tfDnnToken_).getSession();
 
   TICLTracksterTiles tracksterTile;
   std::vector<bool> usedTrackstersMerged;
   std::vector<int> indexInMergedCollTRKEM;
   std::vector<int> indexInMergedCollEM;
   std::vector<int> indexInMergedCollTRK;
   std::vector<int> indexInMergedCollHAD;
   std::vector<bool> usedSeeds;
 
   // associating seed to the index of the trackster in the merged collection and the iteration that found it
   std::map<int, std::vector<std::pair<int, TracksterIterIndex>>> seedToTracksterAssociator;
   edm::Handle<std::vector<reco::Track>> track_h;
   evt.getByToken(tracks_token_, track_h);
   const auto &tracks = *track_h;
 
   edm::Handle<std::vector<reco::CaloCluster>> cluster_h;
   evt.getByToken(clusters_token_, cluster_h);
   const auto &layerClusters = *cluster_h;
 
   edm::Handle<edm::ValueMap<std::pair<float, float>>> clustersTime_h;
   evt.getByToken(clustersTime_token_, clustersTime_h);
   const auto &layerClustersTimes = *clustersTime_h;
 
   edm::Handle<std::vector<Trackster>> trackstersem_h;
   evt.getByToken(trackstersem_token_, trackstersem_h);
   const auto &trackstersEM = *trackstersem_h;
 
   edm::Handle<std::vector<Trackster>> tracksterstrkem_h;
   evt.getByToken(tracksterstrkem_token_, tracksterstrkem_h);
   const auto &trackstersTRKEM = *tracksterstrkem_h;
 
   edm::Handle<std::vector<Trackster>> tracksterstrk_h;
   evt.getByToken(tracksterstrk_token_, tracksterstrk_h);
   const auto &trackstersTRK = *tracksterstrk_h;
 
   edm::Handle<std::vector<Trackster>> trackstershad_h;
   evt.getByToken(trackstershad_token_, trackstershad_h);
   const auto &trackstersHAD = *trackstershad_h;
 
   edm::Handle<std::vector<TICLSeedingRegion>> seedingTrk_h;
   evt.getByToken(seedingTrk_token_, seedingTrk_h);
   const auto &seedingTrk = *seedingTrk_h;
   usedSeeds.resize(tracks.size(), false);
 
   fillTile(tracksterTile, trackstersTRKEM, TracksterIterIndex::TRKEM);
   fillTile(tracksterTile, trackstersEM, TracksterIterIndex::EM);
   fillTile(tracksterTile, trackstersTRK, TracksterIterIndex::TRKHAD);
   fillTile(tracksterTile, trackstersHAD, TracksterIterIndex::HAD);
 
   auto totalNumberOfTracksters =
       trackstersTRKEM.size() + trackstersTRK.size() + trackstersEM.size() + trackstersHAD.size();
   resultTrackstersMerged->reserve(totalNumberOfTracksters);
   usedTrackstersMerged.resize(totalNumberOfTracksters, false);
   indexInMergedCollTRKEM.reserve(trackstersTRKEM.size());
   indexInMergedCollEM.reserve(trackstersEM.size());
   indexInMergedCollTRK.reserve(trackstersTRK.size());
   indexInMergedCollHAD.reserve(trackstersHAD.size());
 
   if (debug_) {
     printTrackstersDebug(trackstersTRKEM, "tracksterTRKEM");
     printTrackstersDebug(trackstersEM, "tracksterEM");
     printTrackstersDebug(trackstersTRK, "tracksterTRK");
     printTrackstersDebug(trackstersHAD, "tracksterHAD");
   }
 
   for (auto const &t : trackstersTRKEM) {
     indexInMergedCollTRKEM.push_back(resultTrackstersMerged->size());
     seedToTracksterAssociator[t.seedIndex()].emplace_back(resultTrackstersMerged->size(), TracksterIterIndex::TRKEM);
     resultTrackstersMerged->push_back(t);
   }
 
   for (auto const &t : trackstersEM) {
     indexInMergedCollEM.push_back(resultTrackstersMerged->size());
     resultTrackstersMerged->push_back(t);
   }
 
   for (auto const &t : trackstersTRK) {
     indexInMergedCollTRK.push_back(resultTrackstersMerged->size());
     seedToTracksterAssociator[t.seedIndex()].emplace_back(resultTrackstersMerged->size(), TracksterIterIndex::TRKHAD);
     resultTrackstersMerged->push_back(t);
   }
 
   for (auto const &t : trackstersHAD) {
     indexInMergedCollHAD.push_back(resultTrackstersMerged->size());
     resultTrackstersMerged->push_back(t);
   }
 
   assignPCAtoTracksters(*resultTrackstersMerged,
                         layerClusters,
                         layerClustersTimes,
                         rhtools_.getPositionLayer(rhtools_.lastLayerEE()).z());
   energyRegressionAndID(layerClusters, tfSession_, *resultTrackstersMerged);
 
   printTrackstersDebug(*resultTrackstersMerged, "TrackstersMergeProducer");
 
   auto trackstersMergedHandle = evt.put(std::move(resultTrackstersMerged));
 
   // TICL Candidate creation
   // We start from neutrals first
 
   // Photons
   for (unsigned i = 0; i < trackstersEM.size(); ++i) {
     auto mergedIdx = indexInMergedCollEM[i];
     usedTrackstersMerged[mergedIdx] = true;
     const auto &t = trackstersEM[i];  //trackster
     TICLCandidate tmpCandidate;
     tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, mergedIdx));
     tmpCandidate.setCharge(0);
     tmpCandidate.setPdgId(22);
     tmpCandidate.setRawEnergy(t.raw_energy());
     math::XYZTLorentzVector p4(t.raw_energy() * t.barycenter().unit().x(),
                                t.raw_energy() * t.barycenter().unit().y(),
                                t.raw_energy() * t.barycenter().unit().z(),
                                t.raw_energy());
     tmpCandidate.setP4(p4);
     resultCandidates->push_back(tmpCandidate);
   }
 
   // Neutral Hadrons
   constexpr double mpion = 0.13957;
   constexpr float mpion2 = mpion * mpion;
   for (unsigned i = 0; i < trackstersHAD.size(); ++i) {
     auto mergedIdx = indexInMergedCollHAD[i];
     usedTrackstersMerged[mergedIdx] = true;
     const auto &t = trackstersHAD[i];  //trackster
     TICLCandidate tmpCandidate;
     tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, mergedIdx));
     tmpCandidate.setCharge(0);
     tmpCandidate.setPdgId(130);
     tmpCandidate.setRawEnergy(t.raw_energy());
     float momentum = std::sqrt(t.raw_energy() * t.raw_energy() - mpion2);
     math::XYZTLorentzVector p4(momentum * t.barycenter().unit().x(),
                                momentum * t.barycenter().unit().y(),
                                momentum * t.barycenter().unit().z(),
                                t.raw_energy());
     tmpCandidate.setP4(p4);
     resultCandidates->push_back(tmpCandidate);
   }
 
   // Charged Particles
   for (unsigned i = 0; i < trackstersTRKEM.size(); ++i) {
     auto mergedIdx = indexInMergedCollTRKEM[i];
     if (!usedTrackstersMerged[mergedIdx]) {
       const auto &t = trackstersTRKEM[i];  //trackster
       auto trackIdx = t.seedIndex();
       auto const &track = tracks[trackIdx];
       if (!usedSeeds[trackIdx] and t.raw_energy() > 0) {
         usedSeeds[trackIdx] = true;
         usedTrackstersMerged[mergedIdx] = true;
 
         std::vector<int> trackstersTRKwithSameSeed;
         std::vector<int> trackstersTRKEMwithSameSeed;
 
         for (const auto &tracksterIterationPair : seedToTracksterAssociator[trackIdx]) {
           if (tracksterIterationPair.first != mergedIdx and !usedTrackstersMerged[tracksterIterationPair.first] and
               trackstersMergedHandle->at(tracksterIterationPair.first).raw_energy() > 0.) {
             if (tracksterIterationPair.second == TracksterIterIndex::TRKEM) {
               trackstersTRKEMwithSameSeed.push_back(tracksterIterationPair.first);
             } else if (tracksterIterationPair.second == TracksterIterIndex::TRKHAD) {
               trackstersTRKwithSameSeed.push_back(tracksterIterationPair.first);
             }
           }
         }
 
         float tracksterTotalRawPt = t.raw_pt();
         std::vector<int> haloTrackstersTRKIdx;
         bool foundCompatibleTRK = false;
 
         for (auto otherTracksterIdx : trackstersTRKwithSameSeed) {
           usedTrackstersMerged[otherTracksterIdx] = true;
           tracksterTotalRawPt += trackstersMergedHandle->at(otherTracksterIdx).raw_pt();
 
           // Check the X,Y,Z barycenter and merge if they are very close (halo)
           if ((t.barycenter() - trackstersMergedHandle->at(otherTracksterIdx).barycenter()).mag2() <
               halo_max_distance2_) {
             haloTrackstersTRKIdx.push_back(otherTracksterIdx);
 
           } else {
             foundCompatibleTRK = true;
           }
         }
 
         //check if there is 1-to-1 relationship
         if (trackstersTRKEMwithSameSeed.empty()) {
           if (foundCompatibleTRK) {
             TICLCandidate tmpCandidate;
             tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, mergedIdx));
             double raw_energy = t.raw_energy();
 
             tmpCandidate.setCharge(track.charge());
             tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, trackIdx));
             tmpCandidate.setPdgId(211 * track.charge());
             for (auto otherTracksterIdx : trackstersTRKwithSameSeed) {
               tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, otherTracksterIdx));
               raw_energy += trackstersMergedHandle->at(otherTracksterIdx).raw_energy();
             }
             tmpCandidate.setRawEnergy(raw_energy);
             math::XYZTLorentzVector p4(raw_energy * track.momentum().unit().x(),
                                        raw_energy * track.momentum().unit().y(),
                                        raw_energy * track.momentum().unit().z(),
                                        raw_energy);
             tmpCandidate.setP4(p4);
             resultCandidates->push_back(tmpCandidate);
 
           } else {
             TICLCandidate tmpCandidate;
             tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, mergedIdx));
             double raw_energy = t.raw_energy();
             tmpCandidate.setCharge(track.charge());
             tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, trackIdx));
             for (auto otherTracksterIdx : trackstersTRKwithSameSeed) {
               tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, otherTracksterIdx));
               raw_energy += trackstersMergedHandle->at(otherTracksterIdx).raw_energy();
             }
             tmpCandidate.setPdgId(11 * track.charge());
 
             tmpCandidate.setRawEnergy(raw_energy);
             math::XYZTLorentzVector p4(raw_energy * track.momentum().unit().x(),
                                        raw_energy * track.momentum().unit().y(),
                                        raw_energy * track.momentum().unit().z(),
                                        raw_energy);
             tmpCandidate.setP4(p4);
             resultCandidates->push_back(tmpCandidate);
           }
 
         } else {
           // if 1-to-many find closest trackster in momentum
           int closestTrackster = mergedIdx;
           float minPtDiff = std::abs(t.raw_pt() - track.pt());
           for (auto otherTracksterIdx : trackstersTRKEMwithSameSeed) {
             auto thisPt = tracksterTotalRawPt + trackstersMergedHandle->at(otherTracksterIdx).raw_pt() - t.raw_pt();
             closestTrackster = std::abs(thisPt - track.pt()) < minPtDiff ? otherTracksterIdx : closestTrackster;
           }
           usedTrackstersMerged[closestTrackster] = true;
 
           if (foundCompatibleTRK) {
             TICLCandidate tmpCandidate;
             tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, closestTrackster));
             double raw_energy = trackstersMergedHandle->at(closestTrackster).raw_energy();
 
             tmpCandidate.setCharge(track.charge());
             tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, trackIdx));
             tmpCandidate.setPdgId(211 * track.charge());
             for (auto otherTracksterIdx : trackstersTRKwithSameSeed) {
               tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, otherTracksterIdx));
               raw_energy += trackstersMergedHandle->at(otherTracksterIdx).raw_energy();
             }
             tmpCandidate.setRawEnergy(raw_energy);
             float momentum = std::sqrt(raw_energy * raw_energy - mpion2);
             math::XYZTLorentzVector p4(momentum * track.momentum().unit().x(),
                                        momentum * track.momentum().unit().y(),
                                        momentum * track.momentum().unit().z(),
                                        raw_energy);
             tmpCandidate.setP4(p4);
             resultCandidates->push_back(tmpCandidate);
 
           } else {
             TICLCandidate tmpCandidate;
             tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, closestTrackster));
             double raw_energy = trackstersMergedHandle->at(closestTrackster).raw_energy();
 
             tmpCandidate.setCharge(track.charge());
             tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, trackIdx));
             for (auto otherTracksterIdx : trackstersTRKwithSameSeed) {
               tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, otherTracksterIdx));
               raw_energy += trackstersMergedHandle->at(otherTracksterIdx).raw_energy();
             }
             tmpCandidate.setPdgId(11 * track.charge());
             tmpCandidate.setRawEnergy(raw_energy);
             math::XYZTLorentzVector p4(raw_energy * track.momentum().unit().x(),
                                        raw_energy * track.momentum().unit().y(),
                                        raw_energy * track.momentum().unit().z(),
                                        raw_energy);
             tmpCandidate.setP4(p4);
             resultCandidates->push_back(tmpCandidate);
           }
           // Promote all other TRKEM tracksters as photons with their energy.
           for (auto otherTracksterIdx : trackstersTRKEMwithSameSeed) {
             auto tmpIndex = (otherTracksterIdx != closestTrackster) ? otherTracksterIdx : mergedIdx;
             TICLCandidate photonCandidate;
             const auto &otherTrackster = trackstersMergedHandle->at(tmpIndex);
             auto gammaEnergy = otherTrackster.raw_energy();
             photonCandidate.setCharge(0);
             photonCandidate.setPdgId(22);
             photonCandidate.setRawEnergy(gammaEnergy);
             math::XYZTLorentzVector gammaP4(gammaEnergy * otherTrackster.barycenter().unit().x(),
                                             gammaEnergy * otherTrackster.barycenter().unit().y(),
                                             gammaEnergy * otherTrackster.barycenter().unit().z(),
                                             gammaEnergy);
             photonCandidate.setP4(gammaP4);
             photonCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, tmpIndex));
             resultCandidates->push_back(photonCandidate);
           }
         }
       }
     }
   }  //end of loop over trackstersTRKEM
 
   for (unsigned i = 0; i < trackstersTRK.size(); ++i) {
     auto mergedIdx = indexInMergedCollTRK[i];
     const auto &t = trackstersTRK[i];  //trackster
 
     if (!usedTrackstersMerged[mergedIdx] and t.raw_energy() > 0) {
       auto trackIdx = t.seedIndex();
       auto const &track = tracks[trackIdx];
       if (!usedSeeds[trackIdx]) {
         usedSeeds[trackIdx] = true;
         usedTrackstersMerged[mergedIdx] = true;
         TICLCandidate tmpCandidate;
         tmpCandidate.addTrackster(edm::Ptr<ticl::Trackster>(trackstersMergedHandle, mergedIdx));
         tmpCandidate.setCharge(track.charge());
         tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, trackIdx));
         tmpCandidate.setPdgId(211 * track.charge());
         tmpCandidate.setRawEnergy(t.raw_energy());
         float momentum = std::sqrt(t.raw_energy() * t.raw_energy() - mpion2);
         math::XYZTLorentzVector p4(momentum * track.momentum().unit().x(),
                                    momentum * track.momentum().unit().y(),
                                    momentum * track.momentum().unit().z(),
                                    t.raw_energy());
         tmpCandidate.setP4(p4);
         resultCandidates->push_back(tmpCandidate);
       }
     }
   }
   // For all seeds that have 0-energy tracksters whose track is not marked as used, create a charged hadron with the track information.
   for (auto const &s : seedingTrk) {
     if (usedSeeds[s.index] == false) {
       auto const &track = tracks[s.index];
       // emit a charged hadron
       TICLCandidate tmpCandidate;
       tmpCandidate.setCharge(track.charge());
       tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, s.index));
       tmpCandidate.setPdgId(211 * track.charge());
       float energy = std::sqrt(track.p() * track.p() + mpion2);
       tmpCandidate.setRawEnergy(energy);
       math::PtEtaPhiMLorentzVector p4Polar(track.pt(), track.eta(), track.phi(), mpion);
       tmpCandidate.setP4(p4Polar);
       resultCandidates->push_back(tmpCandidate);
       usedSeeds[s.index] = true;
     }
   }
 
   // for all general tracks (high purity, pt > 1), check if they have been used: if not, promote them as charged hadrons
   for (unsigned i = 0; i < tracks.size(); ++i) {
     auto const &track = tracks[i];
     if (track.pt() > track_min_pt_ and track.quality(reco::TrackBase::highPurity) and
         track.missingOuterHits() < track_max_missing_outerhits_ and std::abs(track.outerEta()) > track_min_eta_ and
         std::abs(track.outerEta()) < track_max_eta_ and usedSeeds[i] == false) {
       // emit a charged hadron
       TICLCandidate tmpCandidate;
       tmpCandidate.setCharge(track.charge());
       tmpCandidate.setTrackPtr(edm::Ptr<reco::Track>(track_h, i));
       tmpCandidate.setPdgId(211 * track.charge());
       float energy = std::sqrt(track.p() * track.p() + mpion2);
       tmpCandidate.setRawEnergy(energy);
       math::PtEtaPhiMLorentzVector p4Polar(track.pt(), track.eta(), track.phi(), mpion);
       tmpCandidate.setP4(p4Polar);
       resultCandidates->push_back(tmpCandidate);
       usedSeeds[i] = true;
     }
   }
 
   // Compute timing
   assignTimeToCandidates(*resultCandidates);
 
   evt.put(std::move(resultCandidates));
 }

Member Data Documentation

◆ clusters_token_

const edm::EDGetTokenT<std::vector<reco::CaloCluster> > TrackstersMergeProducer::clusters_token_

private

Definition at line 51 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ clustersTime_token_

const edm::EDGetTokenT<edm::ValueMap<std::pair<float, float> > > TrackstersMergeProducer::clustersTime_token_

private

Definition at line 52 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ cosangle_align_

const double TrackstersMergeProducer::cosangle_align_

private

Definition at line 69 of file TrackstersMergeProducer.cc.

◆ debug_

const bool TrackstersMergeProducer::debug_

private

Definition at line 76 of file TrackstersMergeProducer.cc.

Referenced by printTrackstersDebug(), and produce().

◆ e_over_h_threshold_

const double TrackstersMergeProducer::e_over_h_threshold_

private

Definition at line 70 of file TrackstersMergeProducer.cc.

◆ eidInputName_

const std::string TrackstersMergeProducer::eidInputName_

private

Definition at line 77 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidMinClusterEnergy_

const float TrackstersMergeProducer::eidMinClusterEnergy_

private

Definition at line 80 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidNClusters_

const int TrackstersMergeProducer::eidNClusters_

private

Definition at line 82 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidNFeatures_

constexpr int TrackstersMergeProducer::eidNFeatures_ = 3

staticprivate

Definition at line 87 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidNLayers_

const int TrackstersMergeProducer::eidNLayers_

private

Definition at line 81 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidOutputNameEnergy_

const std::string TrackstersMergeProducer::eidOutputNameEnergy_

private

Definition at line 78 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidOutputNameId_

const std::string TrackstersMergeProducer::eidOutputNameId_

private

Definition at line 79 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID().

◆ eidSession_

tensorflow::Session* TrackstersMergeProducer::eidSession_

private

Definition at line 84 of file TrackstersMergeProducer.cc.

◆ eta_bin_window_

const int TrackstersMergeProducer::eta_bin_window_

private

Definition at line 60 of file TrackstersMergeProducer.cc.

◆ geometry_token_

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> TrackstersMergeProducer::geometry_token_

private

Definition at line 54 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ halo_max_distance2_

const double TrackstersMergeProducer::halo_max_distance2_

private

Definition at line 64 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ optimiseAcrossTracksters_

const bool TrackstersMergeProducer::optimiseAcrossTracksters_

private

Definition at line 59 of file TrackstersMergeProducer.cc.

◆ phi_bin_window_

const int TrackstersMergeProducer::phi_bin_window_

private

Definition at line 61 of file TrackstersMergeProducer.cc.

◆ pt_neutral_threshold_

const double TrackstersMergeProducer::pt_neutral_threshold_

private

Definition at line 71 of file TrackstersMergeProducer.cc.

◆ pt_sigma_high_

const double TrackstersMergeProducer::pt_sigma_high_

private

Definition at line 62 of file TrackstersMergeProducer.cc.

◆ pt_sigma_low_

const double TrackstersMergeProducer::pt_sigma_low_

private

Definition at line 63 of file TrackstersMergeProducer.cc.

◆ resol_calo_offset_em_

const double TrackstersMergeProducer::resol_calo_offset_em_

private

Definition at line 74 of file TrackstersMergeProducer.cc.

◆ resol_calo_offset_had_

const double TrackstersMergeProducer::resol_calo_offset_had_

private

Definition at line 72 of file TrackstersMergeProducer.cc.

◆ resol_calo_scale_em_

const double TrackstersMergeProducer::resol_calo_scale_em_

private

Definition at line 75 of file TrackstersMergeProducer.cc.

◆ resol_calo_scale_had_

const double TrackstersMergeProducer::resol_calo_scale_had_

private

Definition at line 73 of file TrackstersMergeProducer.cc.

◆ rhtools_

hgcal::RecHitTools TrackstersMergeProducer::rhtools_

private

Definition at line 85 of file TrackstersMergeProducer.cc.

Referenced by energyRegressionAndID(), and produce().

◆ seedingTrk_token_

const edm::EDGetTokenT<std::vector<TICLSeedingRegion> > TrackstersMergeProducer::seedingTrk_token_

private

Definition at line 50 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ tfDnnLabel_

const std::string TrackstersMergeProducer::tfDnnLabel_

private

Definition at line 55 of file TrackstersMergeProducer.cc.

◆ tfDnnToken_

const edm::ESGetToken<TfGraphDefWrapper, TfGraphRecord> TrackstersMergeProducer::tfDnnToken_

private

Definition at line 56 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ tfSession_

const tensorflow::Session* TrackstersMergeProducer::tfSession_

private

Definition at line 57 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ track_max_eta_

const double TrackstersMergeProducer::track_max_eta_

private

Definition at line 67 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ track_max_missing_outerhits_

const int TrackstersMergeProducer::track_max_missing_outerhits_

private

Definition at line 68 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ track_min_eta_

const double TrackstersMergeProducer::track_min_eta_

private

Definition at line 66 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ track_min_pt_

const double TrackstersMergeProducer::track_min_pt_

private

Definition at line 65 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ tracks_token_

const edm::EDGetTokenT<std::vector<reco::Track> > TrackstersMergeProducer::tracks_token_

private

Definition at line 53 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ trackstersem_token_

const edm::EDGetTokenT<std::vector<Trackster> > TrackstersMergeProducer::trackstersem_token_

private

Definition at line 47 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ trackstershad_token_

const edm::EDGetTokenT<std::vector<Trackster> > TrackstersMergeProducer::trackstershad_token_

private

Definition at line 49 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ tracksterstrk_token_

const edm::EDGetTokenT<std::vector<Trackster> > TrackstersMergeProducer::tracksterstrk_token_

private

Definition at line 48 of file TrackstersMergeProducer.cc.

Referenced by produce().

◆ tracksterstrkem_token_

const edm::EDGetTokenT<std::vector<Trackster> > TrackstersMergeProducer::tracksterstrkem_token_

private

Definition at line 46 of file TrackstersMergeProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ TracksterIterIndex

Constructor & Destructor Documentation

◆ TrackstersMergeProducer()

◆ ~TrackstersMergeProducer()

Member Function Documentation

◆ assignTimeToCandidates()

◆ dumpTrackster()

◆ energyRegressionAndID()

◆ fillDescriptions()

◆ fillTile()

◆ printTrackstersDebug()

◆ produce()

Member Data Documentation

◆ clusters_token_

◆ clustersTime_token_

◆ cosangle_align_

◆ debug_

◆ e_over_h_threshold_

◆ eidInputName_

◆ eidMinClusterEnergy_

◆ eidNClusters_

◆ eidNFeatures_

◆ eidNLayers_

◆ eidOutputNameEnergy_

◆ eidOutputNameId_

◆ eidSession_

◆ eta_bin_window_

◆ geometry_token_

◆ halo_max_distance2_

◆ optimiseAcrossTracksters_

◆ phi_bin_window_

◆ pt_neutral_threshold_

◆ pt_sigma_high_

◆ pt_sigma_low_

◆ resol_calo_offset_em_

◆ resol_calo_offset_had_

◆ resol_calo_scale_em_

◆ resol_calo_scale_had_

◆ rhtools_

◆ seedingTrk_token_

◆ tfDnnLabel_

◆ tfDnnToken_

◆ tfSession_

◆ track_max_eta_

◆ track_max_missing_outerhits_

◆ track_min_eta_

◆ track_min_pt_

◆ tracks_token_

◆ trackstersem_token_

◆ trackstershad_token_

◆ tracksterstrk_token_

◆ tracksterstrkem_token_