Inheritance diagram for TICLCandidateFromTrackstersProducer:

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

	TICLCandidateFromTrackstersProducer (const edm::ParameterSet &)

	~TICLCandidateFromTrackstersProducer () 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 Attributes
float	min_particle_prob_

std::unique_ptr< TracksterMomentumPluginBase >	momentum_algo_

std::unique_ptr< TracksterTrackPluginBase >	track_algo_

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

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 24 of file TICLCandidateFromTrackstersProducer.cc.

Constructor & Destructor Documentation

◆ TICLCandidateFromTrackstersProducer()

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

Definition at line 63 of file TICLCandidateFromTrackstersProducer.cc.

References get, edm::ParameterSet::getParameter(), momentum_algo_, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, track_algo_, trackster_tokens_, and edm::vector_transform().

     : min_particle_prob_(ps.getParameter<double>("minParticleProbability")) {
   trackster_tokens_ =
       edm::vector_transform(ps.getParameter<std::vector<edm::InputTag>>("tracksterCollections"),
                             [this](edm::InputTag const& tag) { return consumes<std::vector<Trackster>>(tag); });
   produces<std::vector<TICLCandidate>>();
   auto pset_momentum = ps.getParameter<edm::ParameterSet>("momentumPlugin");
   momentum_algo_ = TracksterMomentumPluginFactory::get()->create(
       pset_momentum.getParameter<std::string>("plugin"), pset_momentum, consumesCollector());
 
   auto pset_track = ps.getParameter<edm::ParameterSet>("trackPlugin");
   track_algo_ = TracksterTrackPluginFactory::get()->create(
       pset_track.getParameter<std::string>("plugin"), pset_track, consumesCollector());
 }

◆ ~TICLCandidateFromTrackstersProducer()

TICLCandidateFromTrackstersProducer::~TICLCandidateFromTrackstersProducer ( )

inlineoverride

Definition at line 27 of file TICLCandidateFromTrackstersProducer.cc.

27 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 78 of file TICLCandidateFromTrackstersProducer.cc.

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

                                                                                                      {
   edm::ParameterSetDescription desc;
 
   std::vector<edm::InputTag> source_vector{edm::InputTag("trackstersTrk"),
                                            edm::InputTag("trackstersMIP"),
                                            edm::InputTag("trackstersEM"),
                                            edm::InputTag("trackstersHAD")};
   desc.add<std::vector<edm::InputTag>>("tracksterCollections", source_vector);
   desc.add<double>("minParticleProbability", 0.);
 
   edm::ParameterSetDescription desc_momentum;
   desc_momentum.add<std::string>("plugin", "TracksterP4FromEnergySum");
   desc_momentum.add<bool>("energyFromRegression", false);
   desc_momentum.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc_momentum.add<edm::InputTag>("layerClusters", edm::InputTag("hgcalLayerClusters"));
   desc_momentum.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<edm::ParameterSetDescription>("momentumPlugin", desc_momentum);
 
   edm::ParameterSetDescription desc_track;
   desc_track.add<std::string>("plugin", "TracksterRecoTrackPlugin");
   desc.add<edm::ParameterSetDescription>("trackPlugin", desc_track);
 
   descriptions.add("ticlCandidateFromTrackstersProducer", desc);
 }

◆ produce()

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

override

Definition at line 103 of file TICLCandidateFromTrackstersProducer.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, HLT_2023v12_cff::distance, HCALHighEnergyHPDFilter_cfi::energy, edm::Event::getByToken(), mps_fire::i, hgcal_clustering::max_index(), min_particle_prob_, momentum_algo_, eostools::move(), ticl::mpion2, HiggsValidation_cfi::pdg_id, edm::Event::put(), mps_fire::result, mathSSE::sqrt(), track_algo_, and trackster_tokens_.

                                                                                         {
   auto result = std::make_unique<std::vector<TICLCandidate>>();
 
   std::vector<const Trackster*> trackster_ptrs;
 
   // adds one TICLCandidate for each trackster that has a minimum particle probability
   for (auto& trackster_token : trackster_tokens_) {
     edm::Handle<std::vector<Trackster>> trackster_h;
     evt.getByToken(trackster_token, trackster_h);
     for (size_t i_trackster = 0; i_trackster < trackster_h->size(); ++i_trackster) {
       auto const& trackster = trackster_h->at(i_trackster);
       auto id_prob_begin = std::begin(trackster.id_probabilities());
       auto max_id_prob_it = std::max_element(id_prob_begin, std::end(trackster.id_probabilities()));
       float max_id_prob = *max_id_prob_it;
       if (max_id_prob < min_particle_prob_)
         continue;
 
       trackster_ptrs.push_back(&trackster);
       auto& ticl_cand = result->emplace_back(edm::Ptr<ticl::Trackster>(trackster_h, i_trackster));
       auto max_index = std::distance(id_prob_begin, max_id_prob_it);
       auto pdg_id = pdg_id_from_particle_type(static_cast<ticl::Trackster::ParticleType>(max_index));
       ticl_cand.setPdgId(pdg_id);
     }
   }
 
   momentum_algo_->setP4(trackster_ptrs, *result, evt);
   track_algo_->setTrack(trackster_ptrs, *result, evt);
 
   // charge assignment
   for (size_t i = 0; i < result->size(); ++i) {
     auto& ticl_cand = result->at(i);
     auto pdg_id = ticl_cand.pdgId();
     if (pdg_id == -11 || pdg_id == -13 || pdg_id == 211) {
       if (ticl_cand.trackPtr().isNonnull()) {
         auto charge = ticl_cand.trackPtr()->charge();
         ticl_cand.setCharge(charge);
         ticl_cand.setPdgId(pdg_id * charge);
         // If this is a special 0 energy trackster that has been injected
         // starting from a seed that has not been linked to any shower,
         // re-assign the energy and momentum to be the ones of the track linked
         // to the original seeding region.
         if (ticl_cand.rawEnergy() == 0.) {
           auto const& three_mom = ticl_cand.trackPtr()->momentum();
           constexpr double mpion2 = 0.13957 * 0.13957;
           double energy = std::sqrt(three_mom.mag2() + mpion2);
           math::XYZTLorentzVector trk_p4(three_mom.x(), three_mom.y(), three_mom.z(), energy);
           ticl_cand.setP4(trk_p4);
           ticl_cand.setRawEnergy(energy);
         }
       } else {
         // Demote them to be neutral, since there's not track associated.
         ticl_cand.setCharge(0);
         if (pdg_id == -11) {
           ticl_cand.setPdgId(22);
         } else {
           ticl_cand.setPdgId(130);
         }
       }
     }
   }
 
   evt.put(std::move(result));
 }