#include <PFECALSuperClusterProducer.h>

Inheritance diagram for PFECALSuperClusterProducer:

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

	PFECALSuperClusterProducer (const edm::ParameterSet &)

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

	~PFECALSuperClusterProducer ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
PFECALSuperClusterAlgo::clustering_type	_theclusteringtype

PFECALSuperClusterAlgo::energy_weight	_theenergyweight

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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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 44 of file PFECALSuperClusterProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 44 of file PFECALSuperClusterProducer.cc.

References edm::hlt::Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), PFECALSuperClusterAlgo::kBOX, PFECALSuperClusterAlgo::kCalibratedNoPS, PFECALSuperClusterAlgo::kCalibratedTotal, PFECALSuperClusterAlgo::kMustache, PFECALSuperClusterAlgo::kRaw, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     
   verbose_ = 
     iConfig.getUntrackedParameter<bool>("verbose",false);
 
   superClusterAlgo_.setUseRegression(iConfig.getParameter<bool>("useRegression")); 
     
   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");
 
   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_.setThreshPFClusterMustacheOutBarrel( threshPFClusterMustacheOutBarrel );
   //superClusterAlgo_.setThreshPFClusterMustacheOutEndcap( threshPFClusterMustacheOutEndcap );
 
   //Load the ECAL energy calibration
   thePFEnergyCalibration_ = 
     std::shared_ptr<PFEnergyCalibration>(new 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 ( )

Definition at line 169 of file PFECALSuperClusterProducer.cc.

169 {}

Member Function Documentation

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

virtual

Reimplemented from edm::EDProducer.

Definition at line 172 of file PFECALSuperClusterProducer.cc.

                                                                       {
   superClusterAlgo_.update(iE); 
 }

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

virtual

Implements edm::EDProducer.

Definition at line 177 of file PFECALSuperClusterProducer.cc.

References edm::hlt::Exception, edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), 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
   std::auto_ptr<reco::CaloClusterCollection> caloClustersEB(new reco::CaloClusterCollection);
   std::auto_ptr<reco::CaloClusterCollection> caloClustersEE(new reco::CaloClusterCollection);
   std::auto_ptr<reco::CaloClusterCollection> caloClustersES(new 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
   std::auto_ptr<edm::ValueMap<reco::CaloClusterPtr> > pfClusterAssociationEBEE(new edm::ValueMap<reco::CaloClusterPtr>);
   std::auto_ptr<edm::ValueMap<reco::CaloClusterPtr> > pfClusterAssociationES(new 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(caloClustersEB,PFBasicClusterCollectionBarrel_);
   const edm::OrphanHandle<reco::CaloClusterCollection> &caloClusHandleEE = iEvent.put(caloClustersEE,PFBasicClusterCollectionEndcap_);
   const edm::OrphanHandle<reco::CaloClusterCollection> &caloClusHandleES = iEvent.put(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(pfClusterAssociationEBEE,PFClusterAssociationEBEE_);
   iEvent.put(pfClusterAssociationES,PFClusterAssociationES_);
   iEvent.put(superClusterAlgo_.getEBOutputSCCollection(),
          PFSuperClusterCollectionBarrel_);
   iEvent.put(superClusterAlgo_.getEEOutputSCCollection(), 
          PFSuperClusterCollectionEndcapWithPreshower_);
 }