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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 24 of file TICLCandidateFromTrackstersProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 63 of file TICLCandidateFromTrackstersProducer.cc.

References timingPdfMaker::get, edm::ParameterSet::getParameter(), momentum_algo_, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::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 ( )

inlineoverride

Definition at line 27 of file TICLCandidateFromTrackstersProducer.cc.

References fillDescriptions().

27 {}

Member Function Documentation

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

static

Definition at line 78 of file TICLCandidateFromTrackstersProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::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.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);
 }

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

override

Definition at line 102 of file TICLCandidateFromTrackstersProducer.cc.

References begin, ALCARECOTkAlJpsiMuMu_cff::charge, HLT_2018_cff::distance, end, edm::Event::getByToken(), mps_fire::i, hgcal_clustering::max_index(), min_particle_prob_, momentum_algo_, eostools::move(), HiggsValidation_cfi::pdg_id, edm::Event::put(), mps_fire::result, 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);
       } else {
         // FIXME - placeholder for downstream PF code to work, but proper symmetric charge assignment needed
         ticl_cand.setCharge(1);
       }
     }
   }
 
   evt.put(std::move(result));
 }