#include <PFECALSuperClusterProducer.h>

Inheritance diagram for PFECALSuperClusterProducer:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override

	PFECALSuperClusterProducer (const edm::ParameterSet &)

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

	~PFECALSuperClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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<>
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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Author: Nicolas Chanon Additional authors for Mustache: Y. Gershtein, R. Patel, L. Gray

Date: July 2012

Definition at line 43 of file PFECALSuperClusterProducer.h.

Constructor & Destructor Documentation

PFECALSuperClusterProducer::PFECALSuperClusterProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 46 of file PFECALSuperClusterProducer.cc.

References particleFlowSuperClusterECAL_cfi::doSatelliteClusterMerge, particleFlowSuperClusterECAL_cfi::dropUnseedable, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), PFECALSuperClusterAlgo::kBOX, PFECALSuperClusterAlgo::kCalibratedNoPS, PFECALSuperClusterAlgo::kCalibratedTotal, PFECALSuperClusterAlgo::kMustache, PFECALSuperClusterAlgo::kRaw, particleFlowSuperClusterECAL_cfi::satelliteClusterSeedThreshold, particleFlowSuperClusterECAL_cfi::satelliteMajorityFraction, particleFlowSuperClusterECAL_cfi::seedThresholdIsET, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     
   verbose_ = 
     iConfig.getUntrackedParameter<bool>("verbose",false);
 
   superClusterAlgo_.setUseRegression(iConfig.getParameter<bool>("useRegression")); 
 
   isOOTCollection_ = iConfig.getParameter<bool>("isOOTCollection");
   superClusterAlgo_.setIsOOTCollection(isOOTCollection_);
 
   superClusterAlgo_.setTokens(iConfig,consumesCollector());
 
   std::string _typename = iConfig.getParameter<std::string>("ClusteringType");
   if( _typename == ClusterType__BOX ) {
     _theclusteringtype = PFECALSuperClusterAlgo::kBOX;
   } else if ( _typename == ClusterType__Mustache ) {
     _theclusteringtype = PFECALSuperClusterAlgo::kMustache;
   } else {
     throw cms::Exception("InvalidClusteringType") 
       << "You have not chosen a valid clustering type," 
       << " please choose from \"Box\" or \"Mustache\"!";
   }
 
   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 threshPFClusterES = iConfig.getParameter<double>("thresh_PFClusterES");
 
   //double threshPFClusterMustacheOutBarrel = iConfig.getParameter<double>("thresh_PFClusterMustacheOutBarrel");
   //double threshPFClusterMustacheOutEndcap = iConfig.getParameter<double>("thresh_PFClusterMustacheOutEndcap");
 
   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_.setVerbosityLevel(verbose_);
   superClusterAlgo_.setClusteringType(_theclusteringtype);
   superClusterAlgo_.setEnergyWeighting(_theenergyweight);
   superClusterAlgo_.setUseETForSeeding(seedThresholdIsET);
   superClusterAlgo_.setUseDynamicDPhi(useDynamicDPhi);
 
   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_.setThreshPFClusterES( threshPFClusterES );
 
   superClusterAlgo_.setSatelliteMerging( doSatelliteClusterMerge );
   superClusterAlgo_.setSatelliteThreshold( satelliteClusterSeedThreshold );
   superClusterAlgo_.setMajorityFraction( satelliteMajorityFraction );
   superClusterAlgo_.setDropUnseedable( dropUnseedable );
   //superClusterAlgo_.setThreshPFClusterMustacheOutBarrel( threshPFClusterMustacheOutBarrel );
   //superClusterAlgo_.setThreshPFClusterMustacheOutEndcap( threshPFClusterMustacheOutEndcap );
 
   //Load the ECAL energy calibration
   thePFEnergyCalibration_ = 
     std::make_shared<PFEnergyCalibration>();
   superClusterAlgo_.setPFClusterCalibration(thePFEnergyCalibration_);
   superClusterAlgo_.setUsePS(iConfig.getParameter<bool>("use_preshower"));
 
   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 ( )

override

Definition at line 176 of file PFECALSuperClusterProducer.cc.

References beginLuminosityBlock().

176 {}

Member Function Documentation

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

override

Definition at line 179 of file PFECALSuperClusterProducer.cc.

Referenced by ~PFECALSuperClusterProducer().

                                                                       {
   superClusterAlgo_.update(iE); 
 }

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

static

Definition at line 312 of file PFECALSuperClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                             {
   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.add<bool>("use_preshower",true);
   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");
   {
     edm::ParameterSetDescription psd0;
     psd0.add<bool>("isHLT", false);
     psd0.add<edm::InputTag>("ecalRecHitsEE",edm::InputTag("ecalRecHit","EcalRecHitsEE"));
     psd0.add<edm::InputTag>("ecalRecHitsEB",edm::InputTag("ecalRecHit","EcalRecHitsEB"));
     psd0.add<std::string>("regressionKeyEB","pfscecal_EBCorrection_offline_v1");
     psd0.add<std::string>("regressionKeyEE","pfscecal_EECorrection_offline_v1");
     psd0.add<std::string>("uncertaintyKeyEB","pfscecal_EBUncertainty_offline_v1");
     psd0.add<std::string>("uncertaintyKeyEE","pfscecal_EEUncertainty_offline_v1");
     psd0.add<edm::InputTag>("vertexCollection",edm::InputTag("offlinePrimaryVertices")); 
     psd0.add<double>("eRecHitThreshold", 1.);
     desc.add<edm::ParameterSetDescription>("regressionConfig",psd0);
   }
   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>("ClusteringType","Mustache");
   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","EcalRecHitsEE"));
   desc.add<edm::InputTag>("endcapRecHits",edm::InputTag("ecalRecHit","EcalRecHitsEB"));
   desc.add<std::string>("PFSuperClusterCollectionEndcapWithPreshower","particleFlowSuperClusterECALEndcapWithPreshower");
   desc.add<bool>("dropUnseedable",false);
   descriptions.add("particleFlowSuperClusterECALMustache",desc);
 }

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

override

Definition at line 184 of file PFECALSuperClusterProducer.cc.

References fastPrimaryVertexProducer_cfi::clusters, TauDecayModes::dec, Exception, edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), eostools::move(), edm::PtrVector< T >::push_back(), and edm::Event::put().

                                              {
   
   // 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_);
 }