Inheritance diagram for LegacyPFClusterProducer:

Public Member Functions
	LegacyPFClusterProducer (edm::ParameterSet const &config)

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
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::unique_ptr< PFCPositionCalculatorBase >	allCellsPositionCalc_

const bool	cutsFromDB_

const edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd >	hcalCutsToken_

const edm::EDGetTokenT< reco::PFRecHitHostCollection >	InputPFRecHitSoA_Token_

const edm::EDPutTokenT< reco::PFClusterCollection >	legacyPfClustersToken_

const edm::ESGetToken< reco::PFClusterParamsHostCollection, JobConfigurationGPURecord >	pfClusParamsToken_

const edm::EDGetTokenT< reco::PFClusterHostCollection >	pfClusterSoAToken_

const edm::EDGetTokenT< reco::PFRecHitFractionHostCollection >	pfRecHitFractionSoAToken_

std::unique_ptr< PFCPositionCalculatorBase >	positionCalc_

const edm::EDGetTokenT< reco::PFRecHitCollection >	recHitsLabel_

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 37 of file LegacyPFClusterProducer.cc.

Constructor & Destructor Documentation

◆ LegacyPFClusterProducer()

LegacyPFClusterProducer::LegacyPFClusterProducer ( edm::ParameterSet const & config )

inline

Definition at line 39 of file LegacyPFClusterProducer.cc.

       : pfClusterSoAToken_(consumes(config.getParameter<edm::InputTag>("src"))),
         pfRecHitFractionSoAToken_(consumes(config.getParameter<edm::InputTag>("src"))),
         InputPFRecHitSoA_Token_{consumes(config.getParameter<edm::InputTag>("PFRecHitsLabelIn"))},
         pfClusParamsToken_(esConsumes(config.getParameter<edm::ESInputTag>("pfClusterParams"))),
         legacyPfClustersToken_(produces()),
         recHitsLabel_(consumes(config.getParameter<edm::InputTag>("recHitsSource"))),
         hcalCutsToken_(esConsumes<HcalPFCuts, HcalPFCutsRcd>(edm::ESInputTag("", "withTopo"))),
         cutsFromDB_(config.getParameter<bool>("usePFThresholdsFromDB")) {
     edm::ConsumesCollector cc = consumesCollector();
 
     //setup pf cluster builder if requested
     const edm::ParameterSet& pfcConf = config.getParameterSet("pfClusterBuilder");
     if (!pfcConf.empty()) {
       if (pfcConf.exists("positionCalc")) {
         const edm::ParameterSet& acConf = pfcConf.getParameterSet("positionCalc");
         const std::string& algoac = acConf.getParameter<std::string>("algoName");
         positionCalc_ = PFCPositionCalculatorFactory::get()->create(algoac, acConf, cc);
       }
 
       if (pfcConf.exists("allCellsPositionCalc")) {
         const edm::ParameterSet& acConf = pfcConf.getParameterSet("allCellsPositionCalc");
         const std::string& algoac = acConf.getParameter<std::string>("algoName");
         allCellsPositionCalc_ = PFCPositionCalculatorFactory::get()->create(algoac, acConf, cc);
       }
     }
   }

Member Function Documentation

◆ fillDescriptions()

static void LegacyPFClusterProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 67 of file LegacyPFClusterProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, MillePedeFileConverter_cfg::e, HLT_2023v12_cff::pfClusterBuilder, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src");
     desc.add<edm::InputTag>("PFRecHitsLabelIn");
     desc.add<edm::ESInputTag>("pfClusterParams");
     desc.add<edm::InputTag>("recHitsSource");
     desc.add<bool>("usePFThresholdsFromDB", true);
     {
       edm::ParameterSetDescription pfClusterBuilder;
       pfClusterBuilder.add<unsigned int>("maxIterations", 5);
       pfClusterBuilder.add<double>("minFracTot", 1e-20);
       pfClusterBuilder.add<double>("minFractionToKeep", 1e-7);
       pfClusterBuilder.add<bool>("excludeOtherSeeds", true);
       pfClusterBuilder.add<double>("showerSigma", 10.);
       pfClusterBuilder.add<double>("stoppingTolerance", 1e-8);
       pfClusterBuilder.add<double>("timeSigmaEB", 10.);
       pfClusterBuilder.add<double>("timeSigmaEE", 10.);
       pfClusterBuilder.add<double>("maxNSigmaTime", 10.);
       pfClusterBuilder.add<double>("minChi2Prob", 0.);
       pfClusterBuilder.add<bool>("clusterTimeResFromSeed", false);
       pfClusterBuilder.add<std::string>("algoName", "");
       {
         edm::ParameterSetDescription validator;
         validator.add<std::string>("detector", "");
         validator.add<std::vector<int>>("depths", {});
         validator.add<std::vector<double>>("recHitEnergyNorm", {});
         std::vector<edm::ParameterSet> vDefaults(2);
         vDefaults[0].addParameter<std::string>("detector", "HCAL_BARREL1");
         vDefaults[0].addParameter<std::vector<int>>("depths", {1, 2, 3, 4});
         vDefaults[0].addParameter<std::vector<double>>("recHitEnergyNorm", {0.1, 0.2, 0.3, 0.3});
         vDefaults[1].addParameter<std::string>("detector", "HCAL_ENDCAP");
         vDefaults[1].addParameter<std::vector<int>>("depths", {1, 2, 3, 4, 5, 6, 7});
         vDefaults[1].addParameter<std::vector<double>>("recHitEnergyNorm", {0.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2});
         pfClusterBuilder.addVPSet("recHitEnergyNorms", validator, vDefaults);
       }
       {
         edm::ParameterSetDescription bar;
         bar.add<std::string>("algoName", "Basic2DGenericPFlowPositionCalc");
         bar.add<double>("minFractionInCalc", 1e-9);
         bar.add<int>("posCalcNCrystals", 5);
         {
           edm::ParameterSetDescription validator;
           validator.add<std::string>("detector", "");
           validator.add<std::vector<int>>("depths", {});
           validator.add<std::vector<double>>("logWeightDenominator", {});
           std::vector<edm::ParameterSet> vDefaults(2);
           vDefaults[0].addParameter<std::string>("detector", "HCAL_BARREL1");
           vDefaults[0].addParameter<std::vector<int>>("depths", {1, 2, 3, 4});
           vDefaults[0].addParameter<std::vector<double>>("logWeightDenominator", {0.1, 0.2, 0.3, 0.3});
           vDefaults[1].addParameter<std::string>("detector", "HCAL_ENDCAP");
           vDefaults[1].addParameter<std::vector<int>>("depths", {1, 2, 3, 4, 5, 6, 7});
           vDefaults[1].addParameter<std::vector<double>>("logWeightDenominator", {0.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2});
           bar.addVPSet("logWeightDenominatorByDetector", validator, vDefaults);
         }
         bar.add<double>("minAllowedNormalization", 1e-9);
         pfClusterBuilder.add("positionCalc", bar);
       }
       {
         edm::ParameterSetDescription bar;
         bar.add<std::string>("algoName", "Basic2DGenericPFlowPositionCalc");
         bar.add<double>("minFractionInCalc", 1e-9);
         bar.add<int>("posCalcNCrystals", -1);
         {
           edm::ParameterSetDescription validator;
           validator.add<std::string>("detector", "");
           validator.add<std::vector<int>>("depths", {});
           validator.add<std::vector<double>>("logWeightDenominator", {});
           std::vector<edm::ParameterSet> vDefaults(2);
           vDefaults[0].addParameter<std::string>("detector", "HCAL_BARREL1");
           vDefaults[0].addParameter<std::vector<int>>("depths", {1, 2, 3, 4});
           vDefaults[0].addParameter<std::vector<double>>("logWeightDenominator", {0.1, 0.2, 0.3, 0.3});
           vDefaults[1].addParameter<std::string>("detector", "HCAL_ENDCAP");
           vDefaults[1].addParameter<std::vector<int>>("depths", {1, 2, 3, 4, 5, 6, 7});
           vDefaults[1].addParameter<std::vector<double>>("logWeightDenominator", {0.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2});
           bar.addVPSet("logWeightDenominatorByDetector", validator, vDefaults);
         }
         bar.add<double>("minAllowedNormalization", 1e-9);
         pfClusterBuilder.add("allCellsPositionCalc", bar);
       }
       {
         edm::ParameterSetDescription bar;
         bar.add<double>("corrTermLowE", 0.);
         bar.add<double>("threshLowE", 6.);
         bar.add<double>("noiseTerm", 21.86);
         bar.add<double>("constantTermLowE", 4.24);
         bar.add<double>("noiseTermLowE", 8.);
         bar.add<double>("threshHighE", 15.);
         bar.add<double>("constantTerm", 2.82);
         pfClusterBuilder.add("timeResolutionCalcBarrel", bar);
       }
       {
         edm::ParameterSetDescription bar;
         bar.add<double>("corrTermLowE", 0.);
         bar.add<double>("threshLowE", 6.);
         bar.add<double>("noiseTerm", 21.86);
         bar.add<double>("constantTermLowE", 4.24);
         bar.add<double>("noiseTermLowE", 8.);
         bar.add<double>("threshHighE", 15.);
         bar.add<double>("constantTerm", 2.82);
         pfClusterBuilder.add("timeResolutionCalcEndcap", bar);
       }
       {
         edm::ParameterSetDescription bar;
         pfClusterBuilder.add("positionReCalc", bar);
       }
       {
         edm::ParameterSetDescription bar;
         pfClusterBuilder.add("energyCorrector", bar);
       }
       desc.add("pfClusterBuilder", pfClusterBuilder);
     }
     descriptions.addWithDefaultLabel(desc);
   }

◆ produce()

void LegacyPFClusterProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

overrideprivate

Definition at line 196 of file LegacyPFClusterProducer.cc.

References allCellsPositionCalc_, cutsFromDB_, hcalRecHitTable_cff::detId, DivergingColor::frac, hcalCutsToken_, mps_fire::i, InputPFRecHitSoA_Token_, dqmdumpme::k, legacyPfClustersToken_, eostools::move(), dqmiodumpmetadata::n, hltrates_dqm_sourceclient-live_cfg::offset, MillePedeFileConverter_cfg::out, pfClusterSoAToken_, pfRecHitFractionSoAToken_, pfClusterHBHEAlpaka_cff::pfRecHits, positionCalc_, recHitsLabel_, singleTopDQM_cfi::setup, and groupFilesInBlocks::temp.

                                                                                  {
   const reco::PFRecHitHostCollection& pfRecHits = event.get(InputPFRecHitSoA_Token_);
 
   HcalPFCuts const* paramPF = cutsFromDB_ ? &setup.getData(hcalCutsToken_) : nullptr;
 
   auto const& pfClusterSoA = event.get(pfClusterSoAToken_).const_view();
   auto const& pfRecHitFractionSoA = event.get(pfRecHitFractionSoAToken_).const_view();
 
   int nRH = pfRecHits.view().size();
   reco::PFClusterCollection out;
   out.reserve(nRH);
 
   auto const rechitsHandle = event.getHandle(recHitsLabel_);
 
   // Build PFClusters in legacy format
   std::vector<int> nTopoSeeds(nRH, 0);
 
   for (int i = 0; i < pfClusterSoA.nSeeds(); i++) {
     nTopoSeeds[pfClusterSoA[i].topoId()]++;
   }
 
   // Looping over SoA PFClusters to produce legacy PFCluster collection
   for (int i = 0; i < pfClusterSoA.nSeeds(); i++) {
     unsigned int n = pfClusterSoA[i].seedRHIdx();
     reco::PFCluster temp;
     temp.setSeed((*rechitsHandle)[n].detId());  // Pulling the detId of this PFRecHit from the legacy format input
     int offset = pfClusterSoA[i].rhfracOffset();
     for (int k = offset; k < (offset + pfClusterSoA[i].rhfracSize()) && k >= 0;
          k++) {  // Looping over PFRecHits in the same topo cluster
       if (pfRecHitFractionSoA[k].pfrhIdx() < nRH && pfRecHitFractionSoA[k].pfrhIdx() > -1 &&
           pfRecHitFractionSoA[k].frac() > 0.0) {
         const reco::PFRecHitRef& refhit = reco::PFRecHitRef(rechitsHandle, pfRecHitFractionSoA[k].pfrhIdx());
         temp.addRecHitFraction(reco::PFRecHitFraction(refhit, pfRecHitFractionSoA[k].frac()));
       }
     }
 
     // Now PFRecHitFraction of this PFCluster is set. Now compute calculateAndSetPosition (energy, position etc)
     if (nTopoSeeds[pfClusterSoA[i].topoId()] == 1 && allCellsPositionCalc_) {
       allCellsPositionCalc_->calculateAndSetPosition(temp, paramPF);
     } else {
       positionCalc_->calculateAndSetPosition(temp, paramPF);
     }
     out.emplace_back(std::move(temp));
   }
 
   event.emplace(legacyPfClustersToken_, std::move(out));
 }