EgammaHLTHybridClusterProducer Class Reference

#include <EgammaHLTHybridClusterProducer.h>

Inheritance diagram for EgammaHLTHybridClusterProducer:

Public Member Functions
	EgammaHLTHybridClusterProducer (const edm::ParameterSet &ps)
void	produce (edm::Event &, const edm::EventSetup &) override
	~EgammaHLTHybridClusterProducer () override
Public Member Functions inherited from edm::EDProducer
	EDProducer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
	~EDProducer () 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)
	~ProducerBase () noexcept(false) override
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::EDProducer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()

Private Member Functions
bool	counterExceeded () const

Private Attributes
std::string	basicclusterCollection_
bool	doIsolated_
edm::InputTag	hitcollection_
edm::EDGetTokenT< EcalRecHitCollection >	hittoken_
HybridClusterAlgo *	hybrid_p
double	l1LowerThr_
double	l1LowerThrIgnoreIsolation_
edm::EDGetTokenT< l1extra::L1EmParticleCollection >	l1TagIsolated_
edm::EDGetTokenT< l1extra::L1EmParticleCollection >	l1TagNonIsolated_
double	l1UpperThr_
int	nEvt_
int	nMaxPrintout_
PositionCalc	posCalculator_
double	regionEtaMargin_
double	regionPhiMargin_
std::string	superclusterCollection_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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

Definition at line 23 of file EgammaHLTHybridClusterProducer.h.

Constructor & Destructor Documentation

EgammaHLTHybridClusterProducer::EgammaHLTHybridClusterProducer

(

const edm::ParameterSet &

ps

)

Definition at line 46 of file EgammaHLTHybridClusterProducer.cc.

References basicclusterCollection_, cosmicSuperClusters_cfi::bremRecoveryPset, doIsolated_, cosmicSuperClusters_cfi::dynamicPhiRoad, edm::ParameterSet::getParameter(), hitcollection_, hittoken_, hybrid_p, l1LowerThr_, l1LowerThrIgnoreIsolation_, l1TagIsolated_, l1TagNonIsolated_, l1UpperThr_, nEvt_, posCalculator_, regionEtaMargin_, regionPhiMargin_, AlCaHLTBitMon_QueryRunRegistry::string, and superclusterCollection_.

                                                                                        {

  basicclusterCollection_ = ps.getParameter<std::string>("basicclusterCollection");
  superclusterCollection_ = ps.getParameter<std::string>("superclusterCollection");
  hitcollection_ = ps.getParameter<edm::InputTag>("ecalhitcollection");
  hittoken_ = consumes<EcalRecHitCollection>(hitcollection_);
  
  // L1 matching parameters
  l1TagIsolated_    = consumes<l1extra::L1EmParticleCollection>(ps.getParameter< edm::InputTag > ("l1TagIsolated"));
  l1TagNonIsolated_ = consumes<l1extra::L1EmParticleCollection>(ps.getParameter< edm::InputTag > ("l1TagNonIsolated"));

  doIsolated_   = ps.getParameter<bool>("doIsolated");

  l1LowerThr_ = ps.getParameter<double> ("l1LowerThr");
  l1UpperThr_ = ps.getParameter<double> ("l1UpperThr");
  l1LowerThrIgnoreIsolation_ = ps.getParameter<double> ("l1LowerThrIgnoreIsolation");

  regionEtaMargin_   = ps.getParameter<double>("regionEtaMargin");
  regionPhiMargin_   = ps.getParameter<double>("regionPhiMargin");

  // Parameters for the position calculation:
  posCalculator_ = PositionCalc( ps.getParameter<edm::ParameterSet>("posCalcParameters") );
  
  const std::vector<std::string> flagnames = 
    ps.getParameter<std::vector<std::string> >("RecHitFlagToBeExcluded");

  const std::vector<int> flagsexcl= 
    StringToEnumValue<EcalRecHit::Flags>(flagnames);

  const std::vector<std::string> severitynames = 
    ps.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcluded");
   
  const std::vector<int> severitiesexcl= 
    StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynames);


  hybrid_p = new HybridClusterAlgo(ps.getParameter<double>("HybridBarrelSeedThr"), 
                                   ps.getParameter<int>("step"),
                                   ps.getParameter<double>("ethresh"),
                                   ps.getParameter<double>("eseed"),
                                   ps.getParameter<double>("xi"),
                                   ps.getParameter<bool>("useEtForXi"),
                                   ps.getParameter<double>("ewing"),
                                   flagsexcl,
                                   posCalculator_,
                       ps.getParameter<bool>("dynamicEThresh"),
                                   ps.getParameter<double>("eThreshA"),
                                   ps.getParameter<double>("eThreshB"),
                   severitiesexcl,
                   ps.getParameter<bool>("excludeFlagged")
                   );

  bool dynamicPhiRoad = ps.getParameter<bool>("dynamicPhiRoad");
    if (dynamicPhiRoad) {
     edm::ParameterSet bremRecoveryPset = ps.getParameter<edm::ParameterSet>("bremRecoveryPset");
     hybrid_p->setDynamicPhiRoad(bremRecoveryPset);
  }

  produces< reco::BasicClusterCollection >(basicclusterCollection_);
  produces< reco::SuperClusterCollection >(superclusterCollection_);
  nEvt_ = 0;
}

EgammaHLTHybridClusterProducer::~EgammaHLTHybridClusterProducer ( )

override

Definition at line 110 of file EgammaHLTHybridClusterProducer.cc.

References hybrid_p.

{
  delete hybrid_p;
}

Member Function Documentation

bool EgammaHLTHybridClusterProducer::counterExceeded ( ) const

inlineprivate

Definition at line 55 of file EgammaHLTHybridClusterProducer.h.

{ return ((nEvt_ > nMaxPrintout_) || (nMaxPrintout_ < 0));}

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

static

Definition at line 115 of file EgammaHLTHybridClusterProducer.cc.

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

                                                                                                {

  edm::ParameterSetDescription desc;
  desc.add<std::string>("debugLevel" , "INFO");
  desc.add<std::string>("basicclusterCollection", "");
  desc.add<std::string>("superclusterCollection", "");
  desc.add<edm::InputTag>("ecalhitcollection", edm::InputTag("ecalRecHit","EcalRecHitsEB"));
  desc.add<edm::InputTag>("l1TagIsolated", edm::InputTag("l1extraParticles","Isolated"));
  desc.add<edm::InputTag>("l1TagNonIsolated", edm::InputTag("l1extraParticles","NonIsolated"));
  desc.add<bool>("doIsolated", true);
  desc.add<double>("l1LowerThr", 0);
  desc.add<double>("l1UpperThr", 9999.0);
  desc.add<double>("l1LowerThrIgnoreIsolation", 999.0);
  desc.add<double>("regionEtaMargin", 0.14);
  desc.add<double>("regionPhiMargin", 0.4);

  edm::ParameterSetDescription posCalcPSET;
  posCalcPSET.add<double>("T0_barl", 7.4);
  posCalcPSET.add<double>("T0_endc", 3.1);
  posCalcPSET.add<double>("T0_endcPresh", 1.2);
  posCalcPSET.add<double>("W0", 4.2);
  posCalcPSET.add<double>("X0", 0.89);
  posCalcPSET.add<bool>("LogWeighted", true);
  desc.add<edm::ParameterSetDescription>("posCalcParameters", posCalcPSET);

  desc.add<std::vector<std::string>>("RecHitFlagToBeExcluded", std::vector<std::string>());
  desc.add<std::vector<std::string> >("RecHitSeverityToBeExcluded", std::vector<std::string>());
  desc.add<double>("severityRecHitThreshold", 4.0);
  desc.add<double>("HybridBarrelSeedThr", 1.0);
  desc.add<int>("step", 10);
  desc.add<double>("ethresh", 0.1);
  desc.add<double>("eseed", 0.35);
  desc.add<double>("xi", 0);
  desc.add<bool>("useEtForXi", true);
  desc.add<double>("ewing", 1.0);
  desc.add<bool>("dynamicEThresh", false);
  desc.add<double>("eThreshA", 0.003);
  desc.add<double>("eThreshB", 0.1);
  desc.add<bool>("excludeFlagged", false);
  desc.add<bool>("dynamicPhiRoad", false);
  //desc.add<edm::ParameterSet>("bremRecoveryPset", edm::ParameterSet());
  
  descriptions.add("hltEgammaHLTHybridClusterProducer", desc);  
}

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

override

Definition at line 161 of file EgammaHLTHybridClusterProducer.cc.

References basicclusterCollection_, doIsolated_, DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), L1CaloGeometry::etaBinHighEdge(), L1CaloGeometry::etaBinLowEdge(), edm::EventSetup::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), hitcollection_, hittoken_, hybrid_p, mps_fire::i, edm::InputTag::instance(), edm::OrphanHandleBase::isValid(), edm::HandleBase::isValid(), l1LowerThr_, l1LowerThrIgnoreIsolation_, l1TagIsolated_, l1TagNonIsolated_, l1UpperThr_, HybridClusterAlgo::makeClusters(), HybridClusterAlgo::makeSuperClusters(), eostools::move(), nEvt_, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::PtrVector< T >::push_back(), edm::Event::put(), regionEtaMargin_, regionPhiMargin_, superclusterCollection_, and ecaldqm::topology().

{
  // get the hit collection from the event:
  edm::Handle<EcalRecHitCollection> rhcHandle;
  evt.getByToken(hittoken_, rhcHandle);
  
  if (!(rhcHandle.isValid()))  
    {
      edm::LogError("ProductNotFound")<< "could not get a handle on the EcalRecHitCollection!" << std::endl;
      return;
    }
  const EcalRecHitCollection *hit_collection = rhcHandle.product();

  // get the collection geometry:
  edm::ESHandle<CaloGeometry> geoHandle;
  es.get<CaloGeometryRecord>().get(geoHandle);
  const CaloGeometry& geometry = *geoHandle;
  const CaloSubdetectorGeometry *geometry_p;
  std::unique_ptr<const CaloSubdetectorTopology> topology;

  //edm::ESHandle<EcalChannelStatus> chStatus;
  //es.get<EcalChannelStatusRcd>().get(chStatus);
  //const EcalChannelStatus* theEcalChStatus = chStatus.product();
  
  edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
  es.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
  const EcalSeverityLevelAlgo* sevLevel = sevlv.product();
 
  if(hitcollection_.instance() == "EcalRecHitsEB") {
    geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
    topology.reset(new EcalBarrelTopology(geoHandle));
  } else if(hitcollection_.instance() == "EcalRecHitsEE") {
    geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
    topology.reset(new EcalEndcapTopology(geoHandle));
  } else if(hitcollection_.instance() == "EcalRecHitsPS") {
    geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
    topology.reset(new EcalPreshowerTopology (geoHandle));
  } else throw(std::runtime_error("\n\nHybrid Cluster Producer encountered invalied ecalhitcollection type.\n\n"));
    
  //Get the L1 EM Particle Collection
  //Get the L1 EM Particle Collection
  edm::Handle< l1extra::L1EmParticleCollection > emIsolColl ;
  if(doIsolated_)
    evt.getByToken(l1TagIsolated_, emIsolColl);

  //Get the L1 EM Particle Collection
  edm::Handle< l1extra::L1EmParticleCollection > emNonIsolColl ;
  evt.getByToken(l1TagNonIsolated_, emNonIsolColl);

  // Get the CaloGeometry
  edm::ESHandle<L1CaloGeometry> l1CaloGeom ;
  es.get<L1CaloGeometryRecord>().get(l1CaloGeom) ;

  std::vector<RectangularEtaPhiRegion> regions;

  if(doIsolated_) {
    for( l1extra::L1EmParticleCollection::const_iterator emItr = emIsolColl->begin(); emItr != emIsolColl->end() ;++emItr ){

    if (emItr->et() > l1LowerThr_ && emItr->et() < l1UpperThr_) {

      // Access the GCT hardware object corresponding to the L1Extra EM object.
      int etaIndex = emItr->gctEmCand()->etaIndex() ;
      int phiIndex = emItr->gctEmCand()->phiIndex() ;
      // Use the L1CaloGeometry to find the eta, phi bin boundaries.
      double etaLow  = l1CaloGeom->etaBinLowEdge( etaIndex ) ;
      double etaHigh = l1CaloGeom->etaBinHighEdge( etaIndex ) ;
      double phiLow  = l1CaloGeom->emJetPhiBinLowEdge( phiIndex ) ;
      double phiHigh = l1CaloGeom->emJetPhiBinHighEdge( phiIndex ) ;

       int isbarl=0;
       //Part of the region is in the barel if either the upper or lower
       //edge of the region is within the barrel
       if(((float)(etaLow)>-1.479 && (float)(etaLow)<1.479) || 
      ((float)(etaHigh)>-1.479 && (float)(etaHigh)<1.479)) isbarl=1;


      etaLow -= regionEtaMargin_;
      etaHigh += regionEtaMargin_;
      phiLow -= regionPhiMargin_;
      phiHigh += regionPhiMargin_;

      if (etaHigh>1.479) etaHigh=1.479;
      if (etaLow<-1.479) etaLow=-1.479;

      if(isbarl) regions.push_back(RectangularEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));

    }
  }
  }

  if(!doIsolated_||l1LowerThrIgnoreIsolation_<64) {
    for( l1extra::L1EmParticleCollection::const_iterator emItr = emNonIsolColl->begin(); emItr != emNonIsolColl->end() ;++emItr ){

      if(doIsolated_&&emItr->et()<l1LowerThrIgnoreIsolation_) continue;

    if (emItr->et() > l1LowerThr_ && emItr->et() < l1UpperThr_) {

      // Access the GCT hardware object corresponding to the L1Extra EM object.
      int etaIndex = emItr->gctEmCand()->etaIndex() ;
      int phiIndex = emItr->gctEmCand()->phiIndex() ;
      // Use the L1CaloGeometry to find the eta, phi bin boundaries.
      double etaLow  = l1CaloGeom->etaBinLowEdge( etaIndex ) ;
      double etaHigh = l1CaloGeom->etaBinHighEdge( etaIndex ) ;
      double phiLow  = l1CaloGeom->emJetPhiBinLowEdge( phiIndex ) ;
      double phiHigh = l1CaloGeom->emJetPhiBinHighEdge( phiIndex ) ;

       int isbarl=0;
       //Part of the region is in the barel if either the upper or lower
       //edge of the region is within the barrel
       if(((float)(etaLow)>-1.479 && (float)(etaLow)<1.479) || 
          ((float)(etaHigh)>-1.479 && (float)(etaHigh)<1.479)) isbarl=1;
       
       
       etaLow -= regionEtaMargin_;
       etaHigh += regionEtaMargin_;
       phiLow -= regionPhiMargin_;
       phiHigh += regionPhiMargin_;
       
       if (etaHigh>1.479) etaHigh=1.479;
       if (etaLow<-1.479) etaLow=-1.479;
       
       if(isbarl) regions.push_back(RectangularEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));
       
    }
    }
  }
  
  // make the Basic clusters!
  reco::BasicClusterCollection basicClusters;
  hybrid_p->makeClusters(hit_collection, geometry_p, basicClusters, sevLevel, true, regions);
  
  // create an unique_ptr to a BasicClusterCollection, copy the clusters into it and put in the Event:
  auto basicclusters_p = std::make_unique<reco::BasicClusterCollection>();
  basicclusters_p->assign(basicClusters.begin(), basicClusters.end());
  edm::OrphanHandle<reco::BasicClusterCollection> bccHandle =  evt.put(std::move(basicclusters_p),
                                                                       basicclusterCollection_);
  if (!(bccHandle.isValid())) {
    return;
  }
  reco::BasicClusterCollection clusterCollection = *bccHandle;

  reco::CaloClusterPtrVector clusterRefVector;
  for (unsigned int i = 0; i < clusterCollection.size(); i++){
    clusterRefVector.push_back(reco::CaloClusterPtr(bccHandle, i));
  }

  reco::SuperClusterCollection superClusters = hybrid_p->makeSuperClusters(clusterRefVector);

  auto superclusters_p = std::make_unique<reco::SuperClusterCollection>();
  superclusters_p->assign(superClusters.begin(), superClusters.end());
  evt.put(std::move(superclusters_p), superclusterCollection_);


  nEvt_++;
}

Member Data Documentation

std::string EgammaHLTHybridClusterProducer::basicclusterCollection_

private

Definition at line 37 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

bool EgammaHLTHybridClusterProducer::doIsolated_

private

Definition at line 35 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

edm::InputTag EgammaHLTHybridClusterProducer::hitcollection_

private

Definition at line 40 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

edm::EDGetTokenT<EcalRecHitCollection> EgammaHLTHybridClusterProducer::hittoken_

private

Definition at line 39 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

HybridClusterAlgo* EgammaHLTHybridClusterProducer::hybrid_p

private

Definition at line 52 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), produce(), and ~EgammaHLTHybridClusterProducer().

double EgammaHLTHybridClusterProducer::l1LowerThr_

private

Definition at line 45 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

double EgammaHLTHybridClusterProducer::l1LowerThrIgnoreIsolation_

private

Definition at line 47 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

edm::EDGetTokenT<l1extra::L1EmParticleCollection> EgammaHLTHybridClusterProducer::l1TagIsolated_

private

Definition at line 42 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

edm::EDGetTokenT<l1extra::L1EmParticleCollection> EgammaHLTHybridClusterProducer::l1TagNonIsolated_

private

Definition at line 43 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

double EgammaHLTHybridClusterProducer::l1UpperThr_

private

Definition at line 46 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

int EgammaHLTHybridClusterProducer::nEvt_

private

Definition at line 33 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

int EgammaHLTHybridClusterProducer::nMaxPrintout_

private

Definition at line 32 of file EgammaHLTHybridClusterProducer.h.

PositionCalc EgammaHLTHybridClusterProducer::posCalculator_

private

Definition at line 53 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer().

double EgammaHLTHybridClusterProducer::regionEtaMargin_

private

Definition at line 49 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

double EgammaHLTHybridClusterProducer::regionPhiMargin_

private

Definition at line 50 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().

std::string EgammaHLTHybridClusterProducer::superclusterCollection_

private

Definition at line 38 of file EgammaHLTHybridClusterProducer.h.

Referenced by EgammaHLTHybridClusterProducer(), and produce().