PFECALSuperClusterProducer Class Reference

Inheritance diagram for PFECALSuperClusterProducer:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override
	PFECALSuperClusterProducer (const edm::ParameterSet &, const reco::SCProducerCache *gcache)
void	produce (edm::Event &, const edm::EventSetup &) override
	~PFECALSuperClusterProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< reco::SCProducerCache > >
	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)
static void	globalEndJob (const reco::SCProducerCache *)
static std::unique_ptr< reco::SCProducerCache >	initializeGlobalCache (const edm::ParameterSet &config)

Private Attributes
PFECALSuperClusterAlgo::clustering_type	_theclusteringtype
PFECALSuperClusterAlgo::energy_weight	_theenergyweight
bool	isOOTCollection_
std::string	PFBasicClusterCollectionBarrel_
std::string	PFBasicClusterCollectionEndcap_
std::string	PFBasicClusterCollectionPreshower_
std::string	PFClusterAssociationEBEE_
std::string	PFClusterAssociationES_
std::string	PFSuperClusterCollectionBarrel_
std::string	PFSuperClusterCollectionEndcap_
std::string	PFSuperClusterCollectionEndcapWithPreshower_
PFECALSuperClusterAlgo	superClusterAlgo_
	clustering algorithm More...
std::shared_ptr< PFEnergyCalibration >	thePFEnergyCalibration_
bool	verbose_
	verbose ? More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< reco::SCProducerCache > >
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 48 of file PFECALSuperClusterProducer.cc.

Constructor & Destructor Documentation

PFECALSuperClusterProducer()

PFECALSuperClusterProducer::PFECALSuperClusterProducer ( const edm::ParameterSet &  iConfig, const reco::SCProducerCache *  gcache  )

explicit

Definition at line 107 of file PFECALSuperClusterProducer.cc.

References _theclusteringtype, _theenergyweight, HLT_2022v14_cff::doSatelliteClusterMerge, HLT_2022v14_cff::dropUnseedable, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), isOOTCollection_, PFECALSuperClusterAlgo::kBOX, PFECALSuperClusterAlgo::kCalibratedNoPS, PFECALSuperClusterAlgo::kCalibratedTotal, PFECALSuperClusterAlgo::kDeepSC, PFECALSuperClusterAlgo::kMustache, PFECALSuperClusterAlgo::kRaw, PFBasicClusterCollectionBarrel_, PFBasicClusterCollectionEndcap_, PFBasicClusterCollectionPreshower_, PFClusterAssociationEBEE_, PFClusterAssociationES_, PFSuperClusterCollectionBarrel_, PFSuperClusterCollectionEndcap_, PFSuperClusterCollectionEndcapWithPreshower_, HLT_2022v14_cff::satelliteClusterSeedThreshold, HLT_2022v14_cff::satelliteMajorityFraction, HLT_2022v14_cff::seedThresholdIsET, PFECALSuperClusterAlgo::setClusteringType(), PFECALSuperClusterAlgo::setCrackCorrections(), PFECALSuperClusterAlgo::setDropUnseedable(), PFECALSuperClusterAlgo::setEnergyWeighting(), PFECALSuperClusterAlgo::setEtawidthSuperClusterBarrel(), PFECALSuperClusterAlgo::setEtawidthSuperClusterEndcap(), PFECALSuperClusterAlgo::setIsOOTCollection(), PFECALSuperClusterAlgo::setMajorityFraction(), PFECALSuperClusterAlgo::setPFClusterCalibration(), PFECALSuperClusterAlgo::setPhiwidthSuperClusterBarrel(), PFECALSuperClusterAlgo::setPhiwidthSuperClusterEndcap(), PFECALSuperClusterAlgo::setSatelliteMerging(), PFECALSuperClusterAlgo::setSatelliteThreshold(), PFECALSuperClusterAlgo::setThreshPFClusterBarrel(), PFECALSuperClusterAlgo::setThreshPFClusterEndcap(), PFECALSuperClusterAlgo::setThreshPFClusterSeedBarrel(), PFECALSuperClusterAlgo::setThreshPFClusterSeedEndcap(), PFECALSuperClusterAlgo::setThreshSuperClusterEt(), PFECALSuperClusterAlgo::setTokens(), PFECALSuperClusterAlgo::setUseDynamicDPhi(), PFECALSuperClusterAlgo::setUseETForSeeding(), PFECALSuperClusterAlgo::setUseRegression(), PFECALSuperClusterAlgo::setVerbosityLevel(), AlCaHLTBitMon_QueryRunRegistry::string, superClusterAlgo_, thePFEnergyCalibration_, and verbose_.

    : superClusterAlgo_(gcache) {
  verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);

  superClusterAlgo_.setUseRegression(iConfig.getParameter<bool>("useRegression"));

  isOOTCollection_ = iConfig.getParameter<bool>("isOOTCollection");
  superClusterAlgo_.setIsOOTCollection(isOOTCollection_);

  std::string _typename = iConfig.getParameter<std::string>("ClusteringType");
  if (_typename == ClusterType__BOX) {
    _theclusteringtype = PFECALSuperClusterAlgo::kBOX;
  } else if (_typename == ClusterType__Mustache) {
    _theclusteringtype = PFECALSuperClusterAlgo::kMustache;
  } else if (_typename == ClusterType__DeepSC) {
    _theclusteringtype = PFECALSuperClusterAlgo::kDeepSC;
  } else {
    throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid clustering type,"
                                                  << " please choose from \"Box\" or \"Mustache\" or \"DeepSC\"!";
  }

  std::string _weightname = iConfig.getParameter<std::string>("EnergyWeight");
  if (_weightname == EnergyWeight__Raw) {
    _theenergyweight = PFECALSuperClusterAlgo::kRaw;
  } else if (_weightname == EnergyWeight__CalibratedNoPS) {
    _theenergyweight = PFECALSuperClusterAlgo::kCalibratedNoPS;
  } else if (_weightname == EnergyWeight__CalibratedTotal) {
    _theenergyweight = PFECALSuperClusterAlgo::kCalibratedTotal;
  } else {
    throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid energy weighting scheme,"
                                                  << " please choose from \"Raw\", \"CalibratedNoPS\", or"
                                                  << " \"CalibratedTotal\"!";
  }

  // parameters for clustering
  bool seedThresholdIsET = iConfig.getParameter<bool>("seedThresholdIsET");

  bool useDynamicDPhi = iConfig.getParameter<bool>("useDynamicDPhiWindow");

  double threshPFClusterSeedBarrel = iConfig.getParameter<double>("thresh_PFClusterSeedBarrel");
  double threshPFClusterBarrel = iConfig.getParameter<double>("thresh_PFClusterBarrel");

  double threshPFClusterSeedEndcap = iConfig.getParameter<double>("thresh_PFClusterSeedEndcap");
  double threshPFClusterEndcap = iConfig.getParameter<double>("thresh_PFClusterEndcap");

  double phiwidthSuperClusterBarrel = iConfig.getParameter<double>("phiwidth_SuperClusterBarrel");
  double etawidthSuperClusterBarrel = iConfig.getParameter<double>("etawidth_SuperClusterBarrel");

  double phiwidthSuperClusterEndcap = iConfig.getParameter<double>("phiwidth_SuperClusterEndcap");
  double etawidthSuperClusterEndcap = iConfig.getParameter<double>("etawidth_SuperClusterEndcap");

  double doSatelliteClusterMerge = iConfig.getParameter<bool>("doSatelliteClusterMerge");
  double satelliteClusterSeedThreshold = iConfig.getParameter<double>("satelliteClusterSeedThreshold");
  double satelliteMajorityFraction = iConfig.getParameter<double>("satelliteMajorityFraction");
  bool dropUnseedable = iConfig.getParameter<bool>("dropUnseedable");

  superClusterAlgo_.setClusteringType(_theclusteringtype);
  superClusterAlgo_.setUseDynamicDPhi(useDynamicDPhi);
  // clusteringType and useDynamicDPhi need to be defined before setting the tokens in order to esConsume only the necessary records
  superClusterAlgo_.setTokens(iConfig, consumesCollector());

  superClusterAlgo_.setVerbosityLevel(verbose_);
  superClusterAlgo_.setEnergyWeighting(_theenergyweight);
  superClusterAlgo_.setUseETForSeeding(seedThresholdIsET);

  superClusterAlgo_.setThreshSuperClusterEt(iConfig.getParameter<double>("thresh_SCEt"));

  superClusterAlgo_.setThreshPFClusterSeedBarrel(threshPFClusterSeedBarrel);
  superClusterAlgo_.setThreshPFClusterBarrel(threshPFClusterBarrel);

  superClusterAlgo_.setThreshPFClusterSeedEndcap(threshPFClusterSeedEndcap);
  superClusterAlgo_.setThreshPFClusterEndcap(threshPFClusterEndcap);

  superClusterAlgo_.setPhiwidthSuperClusterBarrel(phiwidthSuperClusterBarrel);
  superClusterAlgo_.setEtawidthSuperClusterBarrel(etawidthSuperClusterBarrel);

  superClusterAlgo_.setPhiwidthSuperClusterEndcap(phiwidthSuperClusterEndcap);
  superClusterAlgo_.setEtawidthSuperClusterEndcap(etawidthSuperClusterEndcap);

  superClusterAlgo_.setSatelliteMerging(doSatelliteClusterMerge);
  superClusterAlgo_.setSatelliteThreshold(satelliteClusterSeedThreshold);
  superClusterAlgo_.setMajorityFraction(satelliteMajorityFraction);
  superClusterAlgo_.setDropUnseedable(dropUnseedable);

  //Load the ECAL energy calibration
  thePFEnergyCalibration_ = std::make_shared<PFEnergyCalibration>();
  superClusterAlgo_.setPFClusterCalibration(thePFEnergyCalibration_);

  bool applyCrackCorrections_ = iConfig.getParameter<bool>("applyCrackCorrections");
  superClusterAlgo_.setCrackCorrections(applyCrackCorrections_);

  PFBasicClusterCollectionBarrel_ = iConfig.getParameter<string>("PFBasicClusterCollectionBarrel");
  PFSuperClusterCollectionBarrel_ = iConfig.getParameter<string>("PFSuperClusterCollectionBarrel");

  PFBasicClusterCollectionEndcap_ = iConfig.getParameter<string>("PFBasicClusterCollectionEndcap");
  PFSuperClusterCollectionEndcap_ = iConfig.getParameter<string>("PFSuperClusterCollectionEndcap");

  PFBasicClusterCollectionPreshower_ = iConfig.getParameter<string>("PFBasicClusterCollectionPreshower");
  PFSuperClusterCollectionEndcapWithPreshower_ =
      iConfig.getParameter<string>("PFSuperClusterCollectionEndcapWithPreshower");

  PFClusterAssociationEBEE_ = "PFClusterAssociationEBEE";
  PFClusterAssociationES_ = "PFClusterAssociationES";

  produces<reco::SuperClusterCollection>(PFSuperClusterCollectionBarrel_);
  produces<reco::SuperClusterCollection>(PFSuperClusterCollectionEndcapWithPreshower_);
  produces<reco::CaloClusterCollection>(PFBasicClusterCollectionBarrel_);
  produces<reco::CaloClusterCollection>(PFBasicClusterCollectionEndcap_);
  produces<reco::CaloClusterCollection>(PFBasicClusterCollectionPreshower_);
  produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationEBEE_);
  produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationES_);
}

~PFECALSuperClusterProducer()

PFECALSuperClusterProducer::~PFECALSuperClusterProducer ( )

override

Definition at line 221 of file PFECALSuperClusterProducer.cc.

{}

Member Function Documentation

beginLuminosityBlock()

void PFECALSuperClusterProducer::beginLuminosityBlock ( const edm::LuminosityBlock &  iL, const edm::EventSetup &  iE  )

override

Definition at line 223 of file PFECALSuperClusterProducer.cc.

References superClusterAlgo_, and PFECALSuperClusterAlgo::update().

                                                                                                     {
  superClusterAlgo_.update(iE);
}

fillDescriptions()

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

static

Definition at line 352 of file PFECALSuperClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_2022v14_cff::InputTag, SCEnergyCorrectorSemiParm::makePSetDescription(), or, AlCaHLTBitMon_QueryRunRegistry::string, and parallelization::uint.

                                                                                            {
  edm::ParameterSetDescription desc;
  desc.add<std::string>("PFSuperClusterCollectionEndcap", "particleFlowSuperClusterECALEndcap");
  desc.add<bool>("doSatelliteClusterMerge", false);
  desc.add<double>("thresh_PFClusterBarrel", 0.0);
  desc.add<std::string>("PFBasicClusterCollectionBarrel", "particleFlowBasicClusterECALBarrel");
  desc.add<bool>("useRegression", true);
  desc.add<double>("satelliteMajorityFraction", 0.5);
  desc.add<double>("thresh_PFClusterEndcap", 0.0);
  desc.add<edm::InputTag>("ESAssociation", edm::InputTag("particleFlowClusterECAL"));
  desc.add<std::string>("PFBasicClusterCollectionPreshower", "particleFlowBasicClusterECALPreshower");
  desc.addUntracked<bool>("verbose", false);
  desc.add<double>("thresh_SCEt", 4.0);
  desc.add<double>("etawidth_SuperClusterEndcap", 0.04);
  desc.add<double>("phiwidth_SuperClusterEndcap", 0.6);
  desc.add<bool>("useDynamicDPhiWindow", true);
  desc.add<std::string>("PFSuperClusterCollectionBarrel", "particleFlowSuperClusterECALBarrel");
  desc.add<edm::ParameterSetDescription>("regressionConfig", SCEnergyCorrectorSemiParm::makePSetDescription());
  desc.add<bool>("applyCrackCorrections", false);
  desc.add<double>("satelliteClusterSeedThreshold", 50.0);
  desc.add<double>("etawidth_SuperClusterBarrel", 0.04);
  desc.add<std::string>("PFBasicClusterCollectionEndcap", "particleFlowBasicClusterECALEndcap");
  desc.add<edm::InputTag>("PFClusters", edm::InputTag("particleFlowClusterECAL"));
  desc.add<double>("thresh_PFClusterSeedBarrel", 1.0);
  desc.add<std::string>("EnergyWeight", "Raw");
  desc.add<edm::InputTag>("BeamSpot", edm::InputTag("offlineBeamSpot"));
  desc.add<double>("thresh_PFClusterSeedEndcap", 1.0);
  desc.add<double>("phiwidth_SuperClusterBarrel", 0.6);
  desc.add<double>("thresh_PFClusterES", 0.0);
  desc.add<bool>("seedThresholdIsET", true);
  desc.add<bool>("isOOTCollection", false);
  desc.add<edm::InputTag>("barrelRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
  desc.add<edm::InputTag>("endcapRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
  desc.add<std::string>("PFSuperClusterCollectionEndcapWithPreshower",
                        "particleFlowSuperClusterECALEndcapWithPreshower");
  desc.add<bool>("dropUnseedable", false);

  edm::ParameterSetDescription deepSCParams;
  deepSCParams.add<std::string>("modelFile", "");
  deepSCParams.add<std::string>("configFileClusterFeatures", "");
  deepSCParams.add<std::string>("configFileWindowFeatures", "");
  deepSCParams.add<std::string>("configFileHitsFeatures", "");
  deepSCParams.add<uint>("nClusterFeatures", 12);
  deepSCParams.add<uint>("nWindowFeatures", 18);
  deepSCParams.add<uint>("nHitsFeatures", 4);
  deepSCParams.add<uint>("maxNClusters", 40);
  deepSCParams.add<uint>("maxNRechits", 40);
  deepSCParams.add<uint>("batchSize", 64);
  deepSCParams.add<std::string>("collectionStrategy", "Cascade");

  EmptyGroupDescription emptyGroup;

  // Add DeepSC parameters only to the specific ClusteringType
  edm::ParameterSwitch<std::string> switchNode(
      edm::ParameterDescription<std::string>("ClusteringType", ClusterType__Mustache, true),
      ClusterType__Mustache >> emptyGroup or ClusterType__BOX >> emptyGroup or
          ClusterType__DeepSC >>
              edm::ParameterDescription<edm::ParameterSetDescription>("deepSuperClusterConfig", deepSCParams, true));
  desc.addNode(switchNode);

  descriptions.add("particleFlowSuperClusterECALMustache", desc);
}

globalEndJob()

static void PFECALSuperClusterProducer::globalEndJob ( const reco::SCProducerCache *  )

inlinestatic

Definition at line 60 of file PFECALSuperClusterProducer.cc.

{};

initializeGlobalCache()

static std::unique_ptr<reco::SCProducerCache> PFECALSuperClusterProducer::initializeGlobalCache ( const edm::ParameterSet &  config )

inlinestatic

Definition at line 56 of file PFECALSuperClusterProducer.cc.

References submitPVResolutionJobs::config.

                                                                                                 {
    return std::make_unique<reco::SCProducerCache>(config);
  }

produce()

void PFECALSuperClusterProducer::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 227 of file PFECALSuperClusterProducer.cc.

References bsc_activity_cfg::clusters, TauDecayModes::dec, Exception, edm::helper::Filler< Map >::fill(), PFECALSuperClusterAlgo::getEBOutputSCCollection(), PFECALSuperClusterAlgo::getEEOutputSCCollection(), iEvent, edm::helper::Filler< Map >::insert(), PFECALSuperClusterAlgo::loadAndSortPFClusters(), eostools::move(), PFBasicClusterCollectionBarrel_, PFBasicClusterCollectionEndcap_, PFBasicClusterCollectionPreshower_, PFClusterAssociationEBEE_, PFClusterAssociationES_, PFSuperClusterCollectionBarrel_, PFSuperClusterCollectionEndcapWithPreshower_, edm::PtrVector< T >::push_back(), PFECALSuperClusterAlgo::run(), superClusterAlgo_, and PFECALSuperClusterAlgo::updateSCParams().

                                                                                      {
  // update SC parameters
  superClusterAlgo_.updateSCParams(iSetup);
  // do clustering
  superClusterAlgo_.loadAndSortPFClusters(iEvent);
  superClusterAlgo_.run();

  //build collections of output CaloClusters from the used PFClusters
  auto caloClustersEB = std::make_unique<reco::CaloClusterCollection>();
  auto caloClustersEE = std::make_unique<reco::CaloClusterCollection>();
  auto caloClustersES = std::make_unique<reco::CaloClusterCollection>();

  std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEB;  //maps of pfclusters to caloclusters
  std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEE;
  std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapES;

  //fill calocluster collections and maps
  for (const auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
    for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
      if (!pfClusterMapEB.count(*pfclus)) {
        reco::CaloCluster caloclus(**pfclus);
        caloClustersEB->push_back(caloclus);
        pfClusterMapEB[*pfclus] = caloClustersEB->size() - 1;
      } else {
        throw cms::Exception("PFECALSuperClusterProducer::produce")
            << "Found an EB pfcluster matched to more than one EB supercluster!" << std::dec << std::endl;
      }
    }
  }
  for (const auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
    for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
      if (!pfClusterMapEE.count(*pfclus)) {
        reco::CaloCluster caloclus(**pfclus);
        caloClustersEE->push_back(caloclus);
        pfClusterMapEE[*pfclus] = caloClustersEE->size() - 1;
      } else {
        throw cms::Exception("PFECALSuperClusterProducer::produce")
            << "Found an EE pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
      }
    }
    for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
         ++pfclus) {
      if (!pfClusterMapES.count(*pfclus)) {
        reco::CaloCluster caloclus(**pfclus);
        caloClustersES->push_back(caloclus);
        pfClusterMapES[*pfclus] = caloClustersES->size() - 1;
      } else {
        throw cms::Exception("PFECALSuperClusterProducer::produce")
            << "Found an ES pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
      }
    }
  }

  //create ValueMaps from output CaloClusters back to original PFClusters
  auto pfClusterAssociationEBEE = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();
  auto pfClusterAssociationES = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();

  //vectors to fill ValueMaps
  std::vector<reco::CaloClusterPtr> clusptrsEB(caloClustersEB->size());
  std::vector<reco::CaloClusterPtr> clusptrsEE(caloClustersEE->size());
  std::vector<reco::CaloClusterPtr> clusptrsES(caloClustersES->size());

  //put calocluster output collections in event and get orphan handles to create ptrs
  const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEB =
      iEvent.put(std::move(caloClustersEB), PFBasicClusterCollectionBarrel_);
  const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEE =
      iEvent.put(std::move(caloClustersEE), PFBasicClusterCollectionEndcap_);
  const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleES =
      iEvent.put(std::move(caloClustersES), PFBasicClusterCollectionPreshower_);

  //relink superclusters to output caloclusters and fill vectors for ValueMaps
  for (auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
    reco::CaloClusterPtr seedptr(caloClusHandleEB, pfClusterMapEB[ebsc.seed()]);
    ebsc.setSeed(seedptr);

    reco::CaloClusterPtrVector clusters;
    for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
      int caloclusidx = pfClusterMapEB[*pfclus];
      reco::CaloClusterPtr clusptr(caloClusHandleEB, caloclusidx);
      clusters.push_back(clusptr);
      clusptrsEB[caloclusidx] = *pfclus;
    }
    ebsc.setClusters(clusters);
  }
  for (auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
    reco::CaloClusterPtr seedptr(caloClusHandleEE, pfClusterMapEE[eesc.seed()]);
    eesc.setSeed(seedptr);

    reco::CaloClusterPtrVector clusters;
    for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
      int caloclusidx = pfClusterMapEE[*pfclus];
      reco::CaloClusterPtr clusptr(caloClusHandleEE, caloclusidx);
      clusters.push_back(clusptr);
      clusptrsEE[caloclusidx] = *pfclus;
    }
    eesc.setClusters(clusters);

    reco::CaloClusterPtrVector psclusters;
    for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
         ++pfclus) {
      int caloclusidx = pfClusterMapES[*pfclus];
      reco::CaloClusterPtr clusptr(caloClusHandleES, caloclusidx);
      psclusters.push_back(clusptr);
      clusptrsES[caloclusidx] = *pfclus;
    }
    eesc.setPreshowerClusters(psclusters);
  }

  //fill association maps from output CaloClusters back to original PFClusters
  edm::ValueMap<reco::CaloClusterPtr>::Filler fillerEBEE(*pfClusterAssociationEBEE);
  fillerEBEE.insert(caloClusHandleEB, clusptrsEB.begin(), clusptrsEB.end());
  fillerEBEE.insert(caloClusHandleEE, clusptrsEE.begin(), clusptrsEE.end());
  fillerEBEE.fill();

  edm::ValueMap<reco::CaloClusterPtr>::Filler fillerES(*pfClusterAssociationES);
  fillerES.insert(caloClusHandleES, clusptrsES.begin(), clusptrsES.end());
  fillerES.fill();

  //store in the event
  iEvent.put(std::move(pfClusterAssociationEBEE), PFClusterAssociationEBEE_);
  iEvent.put(std::move(pfClusterAssociationES), PFClusterAssociationES_);
  iEvent.put(std::move(superClusterAlgo_.getEBOutputSCCollection()), PFSuperClusterCollectionBarrel_);
  iEvent.put(std::move(superClusterAlgo_.getEEOutputSCCollection()), PFSuperClusterCollectionEndcapWithPreshower_);
}

Member Data Documentation

_theclusteringtype

PFECALSuperClusterAlgo::clustering_type PFECALSuperClusterProducer::_theclusteringtype

private

Definition at line 69 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().

_theenergyweight

PFECALSuperClusterAlgo::energy_weight PFECALSuperClusterProducer::_theenergyweight

private

Definition at line 70 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().

isOOTCollection_

bool PFECALSuperClusterProducer::isOOTCollection_

private

Definition at line 87 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().

PFBasicClusterCollectionBarrel_

std::string PFECALSuperClusterProducer::PFBasicClusterCollectionBarrel_

private

Definition at line 77 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFBasicClusterCollectionEndcap_

std::string PFECALSuperClusterProducer::PFBasicClusterCollectionEndcap_

private

Definition at line 79 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFBasicClusterCollectionPreshower_

std::string PFECALSuperClusterProducer::PFBasicClusterCollectionPreshower_

private

Definition at line 81 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFClusterAssociationEBEE_

std::string PFECALSuperClusterProducer::PFClusterAssociationEBEE_

private

Definition at line 83 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFClusterAssociationES_

std::string PFECALSuperClusterProducer::PFClusterAssociationES_

private

Definition at line 84 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFSuperClusterCollectionBarrel_

std::string PFECALSuperClusterProducer::PFSuperClusterCollectionBarrel_

private

Definition at line 78 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

PFSuperClusterCollectionEndcap_

std::string PFECALSuperClusterProducer::PFSuperClusterCollectionEndcap_

private

Definition at line 80 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().

PFSuperClusterCollectionEndcapWithPreshower_

std::string PFECALSuperClusterProducer::PFSuperClusterCollectionEndcapWithPreshower_

private

Definition at line 82 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer(), and produce().

superClusterAlgo_

PFECALSuperClusterAlgo PFECALSuperClusterProducer::superClusterAlgo_

private

clustering algorithm

Definition at line 68 of file PFECALSuperClusterProducer.cc.

Referenced by beginLuminosityBlock(), PFECALSuperClusterProducer(), and produce().

thePFEnergyCalibration_

std::shared_ptr<PFEnergyCalibration> PFECALSuperClusterProducer::thePFEnergyCalibration_

private

Definition at line 72 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().

verbose_

bool PFECALSuperClusterProducer::verbose_

private

verbose ?

Definition at line 75 of file PFECALSuperClusterProducer.cc.

Referenced by PFECALSuperClusterProducer().