Inheritance diagram for TICLCandidateProducer:

Public Member Functions
void	beginRun (edm::Run const &iEvent, edm::EventSetup const &es) override

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

	TICLCandidateProducer (const edm::ParameterSet &ps)

	~TICLCandidateProducer () 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 Member Functions
template<typename F >
void	assignTimeToCandidates (std::vector< TICLCandidate > &resultCandidates, edm::Handle< std::vector< reco::Track >> track_h, MtdHostCollection::ConstView &inputTimingView, F func) const

void	dumpCandidate (const TICLCandidate &) const

Private Attributes
edm::ESHandle< MagneticField >	bfield_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	bfield_token_

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

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

const StringCutObjectSelector< reco::Track >	cutTk_

const std::string	detector_

std::vector< edm::EDGetTokenT< std::vector< std::vector< unsigned > > > >	egamma_tracksterlinks_tokens_

std::vector< edm::EDGetTokenT< std::vector< Trackster > > >	egamma_tracksters_tokens_

std::vector< edm::EDGetTokenT< std::vector< std::vector< unsigned > > > >	general_tracksterlinks_tokens_

std::vector< edm::EDGetTokenT< std::vector< Trackster > > >	general_tracksters_tokens_

std::unique_ptr< TICLInterpretationAlgoBase< reco::Track > >	generalInterpretationAlgo_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometry_token_

edm::ESGetToken< HGCalDDDConstants, IdealGeometryRecord >	hdc_token_

const HGCalDDDConstants *	hgcons_

std::once_flag	initializeGeometry_

edm::EDGetTokenT< MtdHostCollection >	inputTimingToken_

const edm::EDGetTokenT< std::vector< reco::Muon > >	muons_token_

std::vector< edm::EDGetTokenT< std::vector< float > > >	original_masks_tokens_

edm::ESHandle< Propagator >	propagator_

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagator_token_

const std::string	propName_

hgcal::RecHitTools	rhtools_

const float	timingQualityThreshold_

const float	tkEnergyCut_ = 2.0f

edm::ESHandle< GlobalTrackingGeometry >	trackingGeometry_

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	trackingGeometry_token_

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

const bool	useMTDTiming_

const bool	useTimingAverage_

Static Private Attributes
static constexpr float	c_light_ = CLHEP::c_light * CLHEP::ns / CLHEP::cm

static constexpr float	timeRes = 0.02f

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 58 of file TICLCandidateProducer.cc.

Constructor & Destructor Documentation

◆ TICLCandidateProducer()

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

explicit

Definition at line 116 of file TICLCandidateProducer.cc.

References cms::cuda::assert(), detector_, egamma_tracksterlinks_tokens_, egamma_tracksters_tokens_, general_tracksterlinks_tokens_, general_tracksters_tokens_, generalInterpretationAlgo_, get, edm::ParameterSet::getParameter(), hdc_token_, inputTimingToken_, original_masks_tokens_, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, useMTDTiming_, and trackerHitRTTI::vector.

     : 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"))),
       muons_token_(consumes<std::vector<reco::Muon>>(ps.getParameter<edm::InputTag>("muons"))),
       useMTDTiming_(ps.getParameter<bool>("useMTDTiming")),
       useTimingAverage_(ps.getParameter<bool>("useTimingAverage")),
       timingQualityThreshold_(ps.getParameter<double>("timingQualityThreshold")),
       geometry_token_(esConsumes<CaloGeometry, CaloGeometryRecord, edm::Transition::BeginRun>()),
       bfield_token_(esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>()),
       detector_(ps.getParameter<std::string>("detector")),
       propName_(ps.getParameter<std::string>("propagator")),
       propagator_token_(
           esConsumes<Propagator, TrackingComponentsRecord, edm::Transition::BeginRun>(edm::ESInputTag("", propName_))),
       trackingGeometry_token_(
           esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord, edm::Transition::BeginRun>()),
       cutTk_(ps.getParameter<std::string>("cutTk")) {
   // These are the CLUE3DEM Tracksters put in the event by the TracksterLinksProducer with the superclustering algorithm
   for (auto const &tag : ps.getParameter<std::vector<edm::InputTag>>("egamma_tracksters_collections")) {
     egamma_tracksters_tokens_.emplace_back(consumes<std::vector<Trackster>>(tag));
   }
 
   // These are the links put in the event by the TracksterLinksProducer with the superclustering algorithm
   for (auto const &tag : ps.getParameter<std::vector<edm::InputTag>>("egamma_tracksterlinks_collections")) {
     egamma_tracksterlinks_tokens_.emplace_back(consumes<std::vector<std::vector<unsigned int>>>(tag));
   }
 
   //make sure that the number of tracksters collections and tracksterlinks collections is the same
   assert(egamma_tracksters_tokens_.size() == egamma_tracksterlinks_tokens_.size());
 
   // Loop over the edm::VInputTag and append the token to general_tracksters_tokens_
   // These, instead, are the tracksters already merged by the TrackstersLinksProducer
   for (auto const &tag : ps.getParameter<std::vector<edm::InputTag>>("general_tracksters_collections")) {
     general_tracksters_tokens_.emplace_back(consumes<std::vector<Trackster>>(tag));
   }
 
   for (auto const &tag : ps.getParameter<std::vector<edm::InputTag>>("general_tracksterlinks_collections")) {
     general_tracksterlinks_tokens_.emplace_back(consumes<std::vector<std::vector<unsigned int>>>(tag));
   }
 
   //make sure that the number of tracksters collections and tracksterlinks collections is the same
   assert(general_tracksters_tokens_.size() == general_tracksterlinks_tokens_.size());
 
   //Loop over the edm::VInputTag of masks and append the token to original_masks_tokens_
   for (auto const &tag : ps.getParameter<std::vector<edm::InputTag>>("original_masks")) {
     original_masks_tokens_.emplace_back(consumes<std::vector<float>>(tag));
   }
 
   std::string detectorName_ = (detector_ == "HFNose") ? "HGCalHFNoseSensitive" : "HGCalEESensitive";
   hdc_token_ =
       esConsumes<HGCalDDDConstants, IdealGeometryRecord, edm::Transition::BeginRun>(edm::ESInputTag("", detectorName_));
   if (useMTDTiming_) {
     inputTimingToken_ = consumes<MtdHostCollection>(ps.getParameter<edm::InputTag>("timingSoA"));
   }
 
   produces<std::vector<TICLCandidate>>();
 
   // New trackster collection after linking
   produces<std::vector<Trackster>>();
 
   auto interpretationPSet = ps.getParameter<edm::ParameterSet>("interpretationDescPSet");
   auto algoType = interpretationPSet.getParameter<std::string>("type");
   generalInterpretationAlgo_ =
       TICLGeneralInterpretationPluginFactory::get()->create(algoType, interpretationPSet, consumesCollector());
 }

◆ ~TICLCandidateProducer()

TICLCandidateProducer::~TICLCandidateProducer ( )

inlineoverride

Definition at line 61 of file TICLCandidateProducer.cc.

61 {};

Member Function Documentation

◆ assignTimeToCandidates()

template<typename F >

void TICLCandidateProducer::assignTimeToCandidates	(	std::vector< TICLCandidate > &	resultCandidates,
		edm::Handle< std::vector< reco::Track >>	track_h,
		MtdHostCollection::ConstView &	inputTimingView,
		F	func
	)		const

private

Definition at line 402 of file TICLCandidateProducer.cc.

References HLT_2024v14_cff::beta, c_light_, f, EcalMonitorTask_cff::func, castor_dqm_sourceclient_file_cfg::path, funct::pow(), mathSSE::sqrt(), hcalRecHitTable_cff::time, timeRes, timingQualityThreshold_, useMTDTiming_, useTimingAverage_, x, y, and z.

Referenced by produce().

                                                                  {
   for (auto &cand : resultCandidates) {
     float beta = 1;
     float time = 0.f;
     float invTimeErr = 0.f;
     float timeErr = -1.f;
 
     for (const auto &tr : cand.tracksters()) {
       if (tr->timeError() > 0) {
         const auto invTimeESq = pow(tr->timeError(), -2);
         const auto x = tr->barycenter().X();
         const auto y = tr->barycenter().Y();
         const auto z = tr->barycenter().Z();
         auto path = std::sqrt(x * x + y * y + z * z);
         if (cand.trackPtr().get() != nullptr) {
           const auto &trackIndex = cand.trackPtr().get() - (edm::Ptr<reco::Track>(track_h, 0)).get();
           if (useMTDTiming_ and inputTimingView.timeErr()[trackIndex] > 0) {
             const auto xMtd = inputTimingView.posInMTD_x()[trackIndex];
             const auto yMtd = inputTimingView.posInMTD_y()[trackIndex];
             const auto zMtd = inputTimingView.posInMTD_z()[trackIndex];
 
             beta = inputTimingView.beta()[trackIndex];
             path = std::sqrt((x - xMtd) * (x - xMtd) + (y - yMtd) * (y - yMtd) + (z - zMtd) * (z - zMtd)) +
                    inputTimingView.pathLength()[trackIndex];
           } else {
             float pathLength = func(*(cand.trackPtr().get()), z);
             if (pathLength) {
               path = pathLength;
             }
           }
         }
         time += (tr->time() - path / (beta * c_light_)) * invTimeESq;
         invTimeErr += invTimeESq;
       }
     }
     if (invTimeErr > 0) {
       time = time / invTimeErr;
       // FIXME_ set a liminf of 0.02 ns on the ts error (based on residuals)
       timeErr = sqrt(1.f / invTimeErr);
       if (timeErr < timeRes)
         timeErr = timeRes;
       cand.setTime(time, timeErr);
     }
 
     if (useMTDTiming_ and cand.charge()) {
       // Check MTD timing availability
       const auto &trackIndex = cand.trackPtr().get() - (edm::Ptr<reco::Track>(track_h, 0)).get();
       const bool assocQuality = inputTimingView.MVAquality()[trackIndex] > timingQualityThreshold_;
       if (assocQuality) {
         const auto timeHGC = cand.time();
         const auto timeEHGC = cand.timeError();
         const auto timeMTD = inputTimingView.time0()[trackIndex];
         const auto timeEMTD = inputTimingView.time0Err()[trackIndex];
 
         if (useTimingAverage_ && (timeEMTD > 0 && timeEHGC > 0)) {
           // Compute weighted average between HGCAL and MTD timing
           const auto invTimeESqHGC = pow(timeEHGC, -2);
           const auto invTimeESqMTD = pow(timeEMTD, -2);
           timeErr = 1.f / (invTimeESqHGC + invTimeESqMTD);
           time = (timeHGC * invTimeESqHGC + timeMTD * invTimeESqMTD) * timeErr;
           timeErr = sqrt(timeErr);
         } else if (timeEMTD > 0) {
           time = timeMTD;
           timeErr = timeEMTD;
         }
       }
       cand.setTime(time, timeErr);
       cand.setMTDTime(inputTimingView.time()[trackIndex], inputTimingView.timeErr()[trackIndex]);
     }
   }
 }

◆ beginRun()

void TICLCandidateProducer::beginRun	(	edm::Run const &	iEvent,
		edm::EventSetup const &	es
	)

override

Definition at line 183 of file TICLCandidateProducer.cc.

References bfield_, bfield_token_, generalInterpretationAlgo_, relativeConstraints::geom, geometry_token_, edm::EventSetup::getHandle(), hdc_token_, hgcons_, edm::ESHandle< T >::product(), propagator_, propagator_token_, rhtools_, hgcal::RecHitTools::setGeometry(), trackingGeometry_, and trackingGeometry_token_.

                                                                                   {
   edm::ESHandle<HGCalDDDConstants> hdc = es.getHandle(hdc_token_);
   hgcons_ = hdc.product();
 
   edm::ESHandle<CaloGeometry> geom = es.getHandle(geometry_token_);
   rhtools_.setGeometry(*geom);
 
   bfield_ = es.getHandle(bfield_token_);
   propagator_ = es.getHandle(propagator_token_);
   generalInterpretationAlgo_->initialize(hgcons_, rhtools_, bfield_, propagator_);
 
   trackingGeometry_ = es.getHandle(trackingGeometry_token_);
 };

◆ dumpCandidate()

void TICLCandidateProducer::dumpCandidate ( const TICLCandidate & ) const

private

◆ fillDescriptions()

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

static

Definition at line 477 of file TICLCandidateProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                        {
   edm::ParameterSetDescription desc;
   edm::ParameterSetDescription interpretationDesc;
   interpretationDesc.addNode(edm::PluginDescription<TICLGeneralInterpretationPluginFactory>("type", "General", true));
   desc.add<edm::ParameterSetDescription>("interpretationDescPSet", interpretationDesc);
   desc.add<std::vector<edm::InputTag>>("egamma_tracksters_collections", {edm::InputTag("ticlTracksterLinks")});
   desc.add<std::vector<edm::InputTag>>("egamma_tracksterlinks_collections", {edm::InputTag("ticlTracksterLinks")});
   desc.add<std::vector<edm::InputTag>>("general_tracksters_collections", {edm::InputTag("ticlTracksterLinks")});
   desc.add<std::vector<edm::InputTag>>("general_tracksterlinks_collections", {edm::InputTag("ticlTracksterLinks")});
   desc.add<std::vector<edm::InputTag>>("original_masks",
                                        {edm::InputTag("hgcalMergeLayerClusters", "InitialLayerClustersMask")});
   desc.add<edm::InputTag>("layer_clusters", edm::InputTag("hgcalMergeLayerClusters"));
   desc.add<edm::InputTag>("layer_clustersTime", edm::InputTag("hgcalMergeLayerClusters", "timeLayerCluster"));
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("timingSoA", edm::InputTag("mtdSoA"));
   desc.add<edm::InputTag>("muons", edm::InputTag("muons1stStep"));
   desc.add<std::string>("detector", "HGCAL");
   desc.add<std::string>("propagator", "PropagatorWithMaterial");
   desc.add<bool>("useMTDTiming", true);
   desc.add<bool>("useTimingAverage", true);
   desc.add<double>("timingQualityThreshold", 0.5);
   desc.add<std::string>("cutTk",
                         "1.48 < abs(eta) < 3.0 && pt > 1. && quality(\"highPurity\") && "
                         "hitPattern().numberOfLostHits(\"MISSING_OUTER_HITS\") < 5");
   descriptions.add("ticlCandidateProducer", desc);
 }

◆ produce()

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

override

Definition at line 227 of file TICLCandidateProducer.cc.

References ticl::assignPCAtoTracksters(), assignTimeToCandidates(), bfield_, Disk::build(), clusters_token_, clustersTime_token_, cutTk_, filterTracks(), general_tracksterlinks_tokens_, general_tracksters_tokens_, generalInterpretationAlgo_, edm::Event::get(), edm::Event::getByToken(), hgcal::RecHitTools::getPositionLayer(), hgcons_, mps_fire::i, trajectoryStateTransform::innerFreeState(), trajectoryStateTransform::innerStateOnSurface(), input, inputTimingToken_, createfilelist::int, edm::Ref< C, T, F >::isNonnull(), dqmiolumiharvest::j, dqmdumpme::k, hgcal::RecHitTools::lastLayerEE(), hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, LogDebug, eostools::move(), PFMuonAlgo::muAssocToTrack(), muons_token_, original_masks_tokens_, trajectoryStateTransform::outerFreeState(), trajectoryStateTransform::outerStateOnSurface(), edm::ESHandle< T >::product(), TrackCandidateProducer_cfi::propagator, propagator_, edm::Event::put(), HGCalDDDConstants::rangeR(), rhtools_, edm::second(), reco::LeafCandidate::setPdgId(), findQualityFiles::size, tkEnergyCut_, HLT_2024v14_cff::track, trackingGeometry_, DiMuonV_cfg::tracks, tracks_token_, useMTDTiming_, and z.

                                                                           {
   auto resultTracksters = std::make_unique<std::vector<Trackster>>();
   auto resultTrackstersMerged = std::make_unique<std::vector<Trackster>>();
   auto linkedResultTracksters = std::make_unique<std::vector<std::vector<unsigned int>>>();
 
   const auto &layerClusters = evt.get(clusters_token_);
   const auto &layerClustersTimes = evt.get(clustersTime_token_);
   edm::Handle<reco::MuonCollection> muons_h;
   evt.getByToken(muons_token_, muons_h);
 
   edm::Handle<std::vector<reco::Track>> tracks_h;
   evt.getByToken(tracks_token_, tracks_h);
   const auto &tracks = *tracks_h;
 
   edm::Handle<MtdHostCollection> inputTiming_h;
   MtdHostCollection::ConstView inputTimingView;
   if (useMTDTiming_) {
     evt.getByToken(inputTimingToken_, inputTiming_h);
     inputTimingView = (*inputTiming_h).const_view();
   }
 
   auto const bFieldProd = bfield_.product();
   const Propagator *propagator = propagator_.product();
 
   // loop over the original_masks_tokens_ and get the original masks collections and multiply them
   // to get the global mask
   std::vector<float> original_global_mask(layerClusters.size(), 1.f);
   for (unsigned int i = 0; i < original_masks_tokens_.size(); ++i) {
     const auto &tmp_mask = evt.get(original_masks_tokens_[i]);
     for (unsigned int j = 0; j < tmp_mask.size(); ++j) {
       original_global_mask[j] *= tmp_mask[j];
     }
   }
 
   auto resultMask = std::make_unique<std::vector<float>>(original_global_mask);
 
   std::vector<edm::Handle<std::vector<Trackster>>> general_tracksters_h(general_tracksters_tokens_.size());
   MultiVectorManager<Trackster> generalTrackstersManager;
   for (unsigned int i = 0; i < general_tracksters_tokens_.size(); ++i) {
     evt.getByToken(general_tracksters_tokens_[i], general_tracksters_h[i]);
     //Fill MultiVectorManager
     generalTrackstersManager.addVector(*general_tracksters_h[i]);
   }
   //now get the general_tracksterlinks_tokens_
   std::vector<edm::Handle<std::vector<std::vector<unsigned>>>> general_tracksterlinks_h(
       general_tracksterlinks_tokens_.size());
   std::vector<std::vector<unsigned>> generalTracksterLinksGlobalId;
   for (unsigned int i = 0; i < general_tracksterlinks_tokens_.size(); ++i) {
     evt.getByToken(general_tracksterlinks_tokens_[i], general_tracksterlinks_h[i]);
     for (unsigned int j = 0; j < general_tracksterlinks_h[i]->size(); ++j) {
       generalTracksterLinksGlobalId.emplace_back();
       auto &links_vector = generalTracksterLinksGlobalId.back();
       links_vector.resize((*general_tracksterlinks_h[i])[j].size());
       for (unsigned int k = 0; k < links_vector.size(); ++k) {
         links_vector[k] = generalTrackstersManager.getGlobalIndex(i, (*general_tracksterlinks_h[i])[j][k]);
       }
     }
   }
 
   std::vector<bool> maskTracks;
   maskTracks.resize(tracks.size());
   filterTracks(tracks_h, muons_h, cutTk_, tkEnergyCut_, maskTracks);
 
   const typename TICLInterpretationAlgoBase<reco::Track>::Inputs input(evt,
                                                                        es,
                                                                        layerClusters,
                                                                        layerClustersTimes,
                                                                        generalTrackstersManager,
                                                                        generalTracksterLinksGlobalId,
                                                                        tracks_h,
                                                                        maskTracks);
 
   auto resultCandidates = std::make_unique<std::vector<TICLCandidate>>();
   std::vector<int> trackstersInTrackIndices(tracks.size(), -1);
 
   //TODO
   //egammaInterpretationAlg_->makecandidates(inputGSF, inputTiming, *resultTrackstersMerged, trackstersInGSFTrackIndices)
   // mask generalTracks associated to GSFTrack linked in egammaInterpretationAlgo_
 
   generalInterpretationAlgo_->makeCandidates(input, inputTiming_h, *resultTracksters, trackstersInTrackIndices);
 
   assignPCAtoTracksters(*resultTracksters,
                         layerClusters,
                         layerClustersTimes,
                         rhtools_.getPositionLayer(rhtools_.lastLayerEE()).z(),
                         rhtools_,
                         true);
 
   std::vector<bool> maskTracksters(resultTracksters->size(), true);
   edm::OrphanHandle<std::vector<Trackster>> resultTracksters_h = evt.put(std::move(resultTracksters));
   //create ChargedCandidates
   for (size_t iTrack = 0; iTrack < tracks.size(); iTrack++) {
     if (maskTracks[iTrack]) {
       auto const tracksterId = trackstersInTrackIndices[iTrack];
       auto trackPtr = edm::Ptr<reco::Track>(tracks_h, iTrack);
       if (tracksterId != -1 and !maskTracksters.empty()) {
         auto tracksterPtr = edm::Ptr<Trackster>(resultTracksters_h, tracksterId);
         TICLCandidate chargedCandidate(trackPtr, tracksterPtr);
         resultCandidates->push_back(chargedCandidate);
         maskTracksters[tracksterId] = false;
       } else {
         //charged candidates track only
         edm::Ptr<Trackster> tracksterPtr;
         TICLCandidate chargedCandidate(trackPtr, tracksterPtr);
         auto trackRef = edm::Ref<reco::TrackCollection>(tracks_h, iTrack);
         const int muId = PFMuonAlgo::muAssocToTrack(trackRef, *muons_h);
         const reco::MuonRef muonRef = reco::MuonRef(muons_h, muId);
         if (muonRef.isNonnull() and muonRef->isGlobalMuon()) {
           // create muon candidate
           chargedCandidate.setPdgId(13 * trackPtr.get()->charge());
         }
         resultCandidates->push_back(chargedCandidate);
       }
     }
   }
 
   //Neutral Candidate
   for (size_t iTrackster = 0; iTrackster < maskTracksters.size(); iTrackster++) {
     if (maskTracksters[iTrackster]) {
       edm::Ptr<Trackster> tracksterPtr(resultTracksters_h, iTrackster);
       edm::Ptr<reco::Track> trackPtr;
       TICLCandidate neutralCandidate(trackPtr, tracksterPtr);
       resultCandidates->push_back(neutralCandidate);
     }
   }
 
   auto getPathLength =
       [&](const reco::Track &track, float zVal) {
         const auto &fts_inn = trajectoryStateTransform::innerFreeState(track, bFieldProd);
         const auto &fts_out = trajectoryStateTransform::outerFreeState(track, bFieldProd);
         const auto &surf_inn = trajectoryStateTransform::innerStateOnSurface(track, *trackingGeometry_, bFieldProd);
         const auto &surf_out = trajectoryStateTransform::outerStateOnSurface(track, *trackingGeometry_, bFieldProd);
 
         Basic3DVector<float> pos(track.referencePoint());
         Basic3DVector<float> mom(track.momentum());
         FreeTrajectoryState stateAtBeamspot{GlobalPoint(pos), GlobalVector(mom), track.charge(), bFieldProd};
 
         float pathlength = propagator->propagateWithPath(stateAtBeamspot, surf_inn.surface()).second;
 
         if (pathlength) {
           const auto &t_inn_out = propagator->propagateWithPath(fts_inn, surf_out.surface());
 
           if (t_inn_out.first.isValid()) {
             pathlength += t_inn_out.second;
 
             std::pair<float, float> rMinMax = hgcons_->rangeR(zVal, true);
 
             int iSide = int(track.eta() > 0);
             float zSide = (iSide == 0) ? (-1. * zVal) : zVal;
             const auto &disk = std::make_unique<GeomDet>(
                 Disk::build(Disk::PositionType(0, 0, zSide),
                             Disk::RotationType(),
                             SimpleDiskBounds(rMinMax.first, rMinMax.second, zSide - 0.5, zSide + 0.5))
                     .get());
             const auto &tsos = propagator->propagateWithPath(fts_out, disk->surface());
 
             if (tsos.first.isValid()) {
               pathlength += tsos.second;
               return pathlength;
             }
           }
         }
 #ifdef EDM_ML_DEBUG
         LogDebug("TICLCandidateProducer")
             << "Not able to use the track to compute the path length. A straight line will be used instead.";
 #endif
         return 0.f;
       };
 
   assignTimeToCandidates(*resultCandidates, tracks_h, inputTimingView, getPathLength);
 
   evt.put(std::move(resultCandidates));
 }

Member Data Documentation

◆ bfield_

edm::ESHandle<MagneticField> TICLCandidateProducer::bfield_

private

Definition at line 109 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and produce().

◆ bfield_token_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TICLCandidateProducer::bfield_token_

private

Definition at line 97 of file TICLCandidateProducer.cc.

Referenced by beginRun().

◆ c_light_

constexpr float TICLCandidateProducer::c_light_ = CLHEP::c_light * CLHEP::ns / CLHEP::cm

staticprivate

Definition at line 112 of file TICLCandidateProducer.cc.

Referenced by assignTimeToCandidates().

◆ clusters_token_

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

private

Definition at line 83 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ clustersTime_token_

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

private

Definition at line 84 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ cutTk_

const StringCutObjectSelector<reco::Track> TICLCandidateProducer::cutTk_

private

Definition at line 107 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ detector_

const std::string TICLCandidateProducer::detector_

private

Definition at line 98 of file TICLCandidateProducer.cc.

Referenced by TICLCandidateProducer().

◆ egamma_tracksterlinks_tokens_

std::vector<edm::EDGetTokenT<std::vector<std::vector<unsigned> > > > TICLCandidateProducer::egamma_tracksterlinks_tokens_

private

Definition at line 78 of file TICLCandidateProducer.cc.

Referenced by TICLCandidateProducer().

◆ egamma_tracksters_tokens_

std::vector<edm::EDGetTokenT<std::vector<Trackster> > > TICLCandidateProducer::egamma_tracksters_tokens_

private

Definition at line 77 of file TICLCandidateProducer.cc.

Referenced by TICLCandidateProducer().

◆ general_tracksterlinks_tokens_

std::vector<edm::EDGetTokenT<std::vector<std::vector<unsigned> > > > TICLCandidateProducer::general_tracksterlinks_tokens_

private

Definition at line 81 of file TICLCandidateProducer.cc.

Referenced by produce(), and TICLCandidateProducer().

◆ general_tracksters_tokens_

std::vector<edm::EDGetTokenT<std::vector<Trackster> > > TICLCandidateProducer::general_tracksters_tokens_

private

Definition at line 80 of file TICLCandidateProducer.cc.

Referenced by produce(), and TICLCandidateProducer().

◆ generalInterpretationAlgo_

std::unique_ptr<TICLInterpretationAlgoBase<reco::Track> > TICLCandidateProducer::generalInterpretationAlgo_

private

Definition at line 76 of file TICLCandidateProducer.cc.

Referenced by beginRun(), produce(), and TICLCandidateProducer().

◆ geometry_token_

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

private

Definition at line 95 of file TICLCandidateProducer.cc.

Referenced by beginRun().

◆ hdc_token_

edm::ESGetToken<HGCalDDDConstants, IdealGeometryRecord> TICLCandidateProducer::hdc_token_

private

Definition at line 108 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and TICLCandidateProducer().

◆ hgcons_

const HGCalDDDConstants* TICLCandidateProducer::hgcons_

private

Definition at line 104 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and produce().

◆ initializeGeometry_

std::once_flag TICLCandidateProducer::initializeGeometry_

private

Definition at line 103 of file TICLCandidateProducer.cc.

◆ inputTimingToken_

edm::EDGetTokenT<MtdHostCollection> TICLCandidateProducer::inputTimingToken_

private

Definition at line 89 of file TICLCandidateProducer.cc.

Referenced by produce(), and TICLCandidateProducer().

◆ muons_token_

const edm::EDGetTokenT<std::vector<reco::Muon> > TICLCandidateProducer::muons_token_

private

Definition at line 91 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ original_masks_tokens_

std::vector<edm::EDGetTokenT<std::vector<float> > > TICLCandidateProducer::original_masks_tokens_

private

Definition at line 86 of file TICLCandidateProducer.cc.

Referenced by produce(), and TICLCandidateProducer().

◆ propagator_

edm::ESHandle<Propagator> TICLCandidateProducer::propagator_

private

Definition at line 110 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and produce().

◆ propagator_token_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> TICLCandidateProducer::propagator_token_

private

Definition at line 100 of file TICLCandidateProducer.cc.

Referenced by beginRun().

◆ propName_

const std::string TICLCandidateProducer::propName_

private

Definition at line 99 of file TICLCandidateProducer.cc.

◆ rhtools_

hgcal::RecHitTools TICLCandidateProducer::rhtools_

private

Definition at line 105 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and produce().

◆ timeRes

constexpr float TICLCandidateProducer::timeRes = 0.02f

staticprivate

Definition at line 113 of file TICLCandidateProducer.cc.

Referenced by assignTimeToCandidates().

◆ timingQualityThreshold_

const float TICLCandidateProducer::timingQualityThreshold_

private

Definition at line 94 of file TICLCandidateProducer.cc.

Referenced by assignTimeToCandidates().

◆ tkEnergyCut_

const float TICLCandidateProducer::tkEnergyCut_ = 2.0f

private

Definition at line 106 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ trackingGeometry_

edm::ESHandle<GlobalTrackingGeometry> TICLCandidateProducer::trackingGeometry_

private

Definition at line 111 of file TICLCandidateProducer.cc.

Referenced by beginRun(), and produce().

◆ trackingGeometry_token_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> TICLCandidateProducer::trackingGeometry_token_

private

Definition at line 101 of file TICLCandidateProducer.cc.

Referenced by beginRun().

◆ tracks_token_

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

private

Definition at line 88 of file TICLCandidateProducer.cc.

Referenced by produce().

◆ useMTDTiming_

const bool TICLCandidateProducer::useMTDTiming_

private

Definition at line 92 of file TICLCandidateProducer.cc.

Referenced by assignTimeToCandidates(), produce(), and TICLCandidateProducer().

◆ useTimingAverage_

const bool TICLCandidateProducer::useTimingAverage_

private

Definition at line 93 of file TICLCandidateProducer.cc.

Referenced by assignTimeToCandidates().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TICLCandidateProducer()

◆ ~TICLCandidateProducer()

Member Function Documentation

◆ assignTimeToCandidates()

◆ beginRun()

◆ dumpCandidate()

◆ fillDescriptions()

◆ produce()

Member Data Documentation

◆ bfield_

◆ bfield_token_

◆ c_light_

◆ clusters_token_

◆ clustersTime_token_

◆ cutTk_

◆ detector_

◆ egamma_tracksterlinks_tokens_

◆ egamma_tracksters_tokens_

◆ general_tracksterlinks_tokens_

◆ general_tracksters_tokens_

◆ generalInterpretationAlgo_

◆ geometry_token_

◆ hdc_token_

◆ hgcons_

◆ initializeGeometry_

◆ inputTimingToken_

◆ muons_token_

◆ original_masks_tokens_

◆ propagator_

◆ propagator_token_

◆ propName_

◆ rhtools_

◆ timeRes

◆ timingQualityThreshold_

◆ tkEnergyCut_

◆ trackingGeometry_

◆ trackingGeometry_token_

◆ tracks_token_

◆ useMTDTiming_

◆ useTimingAverage_