#include <ElectronSeedProducer.h>

Inheritance diagram for ElectronSeedProducer:

Public Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) final

	ElectronSeedProducer (const edm::ParameterSet &)

void	endRun (edm::Run const &, edm::EventSetup const &) final

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

	~ElectronSeedProducer () 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 Member Functions
void	filterClusters (const reco::BeamSpot &bs, const edm::Handle< reco::SuperClusterCollection > &superClusters, reco::SuperClusterRefVector &sclRefs, std::vector< float > &hoe1s, std::vector< float > &hoe2s, edm::Event &e, const edm::EventSetup &setup)

void	filterSeeds (edm::Event &e, const edm::EventSetup &setup, reco::SuperClusterRefVector &sclRefs)

Private Attributes
bool	allowHGCal_

bool	applyHOverECut_

bool	applySigmaIEtaIEtaCut_

edm::EDGetTokenT< reco::BeamSpot >	beamSpotTag_

edm::ESHandle< CaloGeometry >	caloGeom_

unsigned long long	caloGeomCacheId_

edm::ESHandle< CaloTopology >	caloTopo_

unsigned long long	caloTopoCacheId_

edm::ParameterSet	conf_

edm::EDGetTokenT< EcalRecHitCollection >	ebRecHitCollection_

edm::EDGetTokenT< EcalRecHitCollection >	eeRecHitCollection_

edm::EDGetTokenT< std::vector< reco::Vertex > >	filterVtxTag_

bool	fromTrackerSeeds_

ElectronHcalHelper *	hcalHelper_

std::unique_ptr< hgcal::ClusterTools >	hgcClusterTools_

edm::EDGetTokenT< TrajectorySeedCollection >	initialSeeds_

ElectronSeedGenerator *	matcher_

double	maxHBarrel_

double	maxHEndcaps_

double	maxHOverEBarrel_

double	maxHOverEEndcaps_

double	maxSigmaIEtaIEtaBarrel_

double	maxSigmaIEtaIEtaEndcaps_

bool	prefilteredSeeds_

double	SCEtCut_

std::unique_ptr< SeedFilter >	seedFilter_

edm::EDGetTokenT< reco::SuperClusterCollection >	superClusters_ [2]

TrajectorySeedCollection *	theInitialSeedColl

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

Description: MeasurementEstimator for Pixel Barrel, ported from ORCA Class defining the search area in the barrel in the pixel match Implementation: <Notes on="" implementation>="">

Description: MeasurementEstimator for Pixel Barrel, ported from ORCA

Implementation: <Notes on="" implementation>="">

Description: EDProducer of ElectronSeed objects

Implementation: <Notes on="" implementation>="">

Definition at line 42 of file ElectronSeedProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 59 of file ElectronSeedProducer.cc.

References allowHGCal_, applyHOverECut_, applySigmaIEtaIEtaCut_, beamSpotTag_, conf_, edm::EDConsumerBase::consumesCollector(), ebRecHitCollection_, eeRecHitCollection_, filterVtxTag_, fromTrackerSeeds_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), hcalHelper_, ElectronHcalHelper::Configuration::hcalTowers, hgcClusterTools_, ElectronHcalHelper::Configuration::hOverEConeSize, ElectronHcalHelper::Configuration::hOverEPtMin, initialSeeds_, matcher_, maxHBarrel_, maxHEndcaps_, maxHOverEBarrel_, maxHOverEEndcaps_, maxSigmaIEtaIEtaBarrel_, maxSigmaIEtaIEtaEndcaps_, prefilteredSeeds_, SCEtCut_, seedFilter_, superClusters_, SeedFilter::Tokens::token_bs, ElectronSeedGenerator::Tokens::token_bs, ElectronSeedGenerator::Tokens::token_measTrkEvt, SeedFilter::Tokens::token_vtx, ElectronSeedGenerator::Tokens::token_vtx, funct::true, and ElectronHcalHelper::Configuration::useTowers.

  : //conf_(iConfig),
    applyHOverECut_(true), hcalHelper_(nullptr),
    caloGeom_(nullptr), caloGeomCacheId_(0), caloTopo_(nullptr), caloTopoCacheId_(0)
  {
   conf_ = iConfig.getParameter<edm::ParameterSet>("SeedConfiguration") ;
 
   initialSeeds_ = consumes<TrajectorySeedCollection>(conf_.getParameter<edm::InputTag>("initialSeeds")) ;
   SCEtCut_ = conf_.getParameter<double>("SCEtCut");
   fromTrackerSeeds_ = conf_.getParameter<bool>("fromTrackerSeeds") ;
   prefilteredSeeds_ = conf_.getParameter<bool>("preFilteredSeeds") ;
 
   auto theconsumes = consumesCollector();
 
   // new beamSpot tag
   beamSpotTag_ = consumes<reco::BeamSpot>(conf_.getParameter<edm::InputTag>("beamSpot")); 
 
   // for H/E
   applyHOverECut_ = conf_.getParameter<bool>("applyHOverECut") ;
   if (applyHOverECut_)
    {
      ElectronHcalHelper::Configuration hcalCfg ;
      hcalCfg.hOverEConeSize = conf_.getParameter<double>("hOverEConeSize") ;
      if (hcalCfg.hOverEConeSize>0)
        {
      hcalCfg.useTowers = true ;
      hcalCfg.hcalTowers = 
        consumes<CaloTowerCollection>(conf_.getParameter<edm::InputTag>("hcalTowers")) ;
      hcalCfg.hOverEPtMin = conf_.getParameter<double>("hOverEPtMin") ;
        }
      hcalHelper_ = new ElectronHcalHelper(hcalCfg) ;
      
      allowHGCal_ = conf_.getParameter<bool>("allowHGCal");
      if( allowHGCal_ ) {
        const edm::ParameterSet& hgcCfg = conf_.getParameterSet("HGCalConfig");
        hgcClusterTools_.reset( new hgcal::ClusterTools(hgcCfg, theconsumes) );
      }
      
      maxHOverEBarrel_=conf_.getParameter<double>("maxHOverEBarrel") ;
      maxHOverEEndcaps_=conf_.getParameter<double>("maxHOverEEndcaps") ;
      maxHBarrel_=conf_.getParameter<double>("maxHBarrel") ;
      maxHEndcaps_=conf_.getParameter<double>("maxHEndcaps") ;
    }
 
   applySigmaIEtaIEtaCut_ = conf_.getParameter<bool>("applySigmaIEtaIEtaCut");
 
   // apply sigma_ieta_ieta cut
   if (applySigmaIEtaIEtaCut_ == true)
     {
       maxSigmaIEtaIEtaBarrel_ = conf_.getParameter<double>("maxSigmaIEtaIEtaBarrel");
       maxSigmaIEtaIEtaEndcaps_ = conf_.getParameter<double>("maxSigmaIEtaIEtaEndcaps");
     }
 
   edm::ParameterSet rpset = conf_.getParameter<edm::ParameterSet>("RegionPSet");
   filterVtxTag_ = consumes<std::vector<reco::Vertex> >(rpset.getParameter<edm::InputTag> ("VertexProducer"));
 
   ElectronSeedGenerator::Tokens esg_tokens;
   esg_tokens.token_bs = beamSpotTag_;
   esg_tokens.token_vtx = mayConsume<reco::VertexCollection>(conf_.getParameter<edm::InputTag>("vertices"));
   esg_tokens.token_measTrkEvt= consumes<MeasurementTrackerEvent>(conf_.getParameter<edm::InputTag>("measurementTrackerEvent"));
 
   matcher_ = new ElectronSeedGenerator(conf_,esg_tokens) ;
 
   //  get collections from config
   if (applySigmaIEtaIEtaCut_ == true) {
     ebRecHitCollection_ = consumes<EcalRecHitCollection> (iConfig.getParameter<edm::InputTag>("ebRecHitCollection"));
     eeRecHitCollection_ = consumes<EcalRecHitCollection> (iConfig.getParameter<edm::InputTag>("eeRecHitCollection"));
   }
 
   superClusters_[0]=
     consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("barrelSuperClusters")) ;
   superClusters_[1]=
     consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("endcapSuperClusters")) ;
 
   // Construction of SeedFilter was in beginRun() with the comment
   // below, but it has to be done here because of ConsumesCollector
   //
   // FIXME: because of a bug presumably in tracker seeding,
   // perhaps in CombinedHitPairGenerator, badly caching some EventSetup product,
   // we must redo the SeedFilter for each run.
   if (prefilteredSeeds_) {
     SeedFilter::Tokens sf_tokens;
     sf_tokens.token_bs  = beamSpotTag_;
     sf_tokens.token_vtx = filterVtxTag_;
     edm::ConsumesCollector iC = consumesCollector();
     seedFilter_.reset(new SeedFilter(conf_, sf_tokens, iC));
   }
 
   //register your products
   produces<ElectronSeedCollection>() ;
 }

ElectronSeedProducer::~ElectronSeedProducer ( )

override

Definition at line 157 of file ElectronSeedProducer.cc.

References hcalHelper_, and matcher_.

  {
   delete hcalHelper_ ;
   delete matcher_ ;
  }

Member Function Documentation

void ElectronSeedProducer::beginRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

finalvirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 151 of file ElectronSeedProducer.cc.

152 {}

void ElectronSeedProducer::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

finalvirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 154 of file ElectronSeedProducer.cc.

155 {}

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

static

Definition at line 323 of file ElectronSeedProducer.cc.

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

                                                                                  {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("endcapSuperClusters",edm::InputTag("particleFlowSuperClusterECAL","particleFlowSuperClusterECALEndcapWithPreshower"));
   {
     edm::ParameterSetDescription psd0, psd1, psd2, psd3, psd4;
     psd1.add<unsigned int>("maxElement", 0);
     psd1.add<std::string>("ComponentName", std::string("StandardHitPairGenerator"));
     psd1.addUntracked<int>("useOnDemandTracker", 0);
     psd1.add<edm::InputTag>("SeedingLayers", edm::InputTag("hltMixedLayerPairs"));
     psd0.add<edm::ParameterSetDescription>("OrderedHitsFactoryPSet", psd1);
 
     psd2.add<double>("deltaPhiRegion", 0.4);
     psd2.add<double>("originHalfLength", 15.0);
     psd2.add<bool>("useZInVertex", true);
     psd2.add<double>("deltaEtaRegion", 0.1);
     psd2.add<double>("ptMin", 1.5 );
     psd2.add<double>("originRadius", 0.2);
     psd2.add<edm::InputTag>("VertexProducer", edm::InputTag("dummyVertices"));
     psd0.add<edm::ParameterSetDescription>("RegionPSet", psd2);
      
     psd0.add<double>("PhiMax2B",0.002);
     psd0.add<double>("hOverEPtMin",0.0);
     psd0.add<double>("PhiMax2F",0.003);
     psd0.add<bool>("searchInTIDTEC",true);
     psd0.add<double>("pPhiMax1",0.125);
     psd0.add<double>("HighPtThreshold",35.0);
     psd0.add<double>("r2MinF",-0.15);
     psd0.add<double>("maxHBarrel",0.0);
     psd0.add<double>("DeltaPhi1Low",0.23);
     psd0.add<double>("DeltaPhi1High",0.08);
     psd0.add<double>("ePhiMin1",-0.125);
     psd0.add<edm::InputTag>("hcalTowers",edm::InputTag("towerMaker"));
     psd0.add<double>("LowPtThreshold",5.0);
     psd0.add<double>("maxHOverEBarrel",0.15);
     psd0.add<double>("maxSigmaIEtaIEtaBarrel", 0.5);
     psd0.add<double>("maxSigmaIEtaIEtaEndcaps", 0.5);
     psd0.add<bool>("dynamicPhiRoad",true);
     psd0.add<double>("ePhiMax1",0.075);
     psd0.add<std::string>("measurementTrackerName","");
     psd0.add<double>("SizeWindowENeg",0.675);
     psd0.add<double>("nSigmasDeltaZ1",5.0);
     psd0.add<double>("rMaxI",0.2);
     psd0.add<double>("maxHEndcaps",0.0);
     psd0.add<bool>("preFilteredSeeds",false);
     psd0.add<double>("r2MaxF",0.15);
     psd0.add<double>("hOverEConeSize",0.15);
     psd0.add<double>("pPhiMin1",-0.075);
     psd0.add<edm::InputTag>("initialSeeds",edm::InputTag("newCombinedSeeds"));
     psd0.add<double>("deltaZ1WithVertex",25.0);
     psd0.add<double>("SCEtCut",0.0);
     psd0.add<double>("z2MaxB",0.09);
     psd0.add<bool>("fromTrackerSeeds",true);
     psd0.add<edm::InputTag>("hcalRecHits",edm::InputTag("hbhereco"));
     psd0.add<double>("z2MinB",-0.09);
     psd0.add<double>("rMinI",-0.2);
     psd0.add<double>("maxHOverEEndcaps",0.15);
     psd0.add<double>("hOverEHBMinE",0.7);
     psd0.add<bool>("useRecoVertex",false);
     psd0.add<edm::InputTag>("beamSpot",edm::InputTag("offlineBeamSpot"));
     psd0.add<edm::InputTag>("measurementTrackerEvent",edm::InputTag("MeasurementTrackerEvent"));
     psd0.add<edm::InputTag>("vertices",edm::InputTag("offlinePrimaryVerticesWithBS"));
     psd0.add<bool>("applyHOverECut",true);
     psd0.add<edm::InputTag>("ebRecHitCollection", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
     psd0.add<edm::InputTag>("eeRecHitCollection", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
     psd0.add<bool>("applySigmaIEtaIEtaCut", false);
     psd0.add<double>("DeltaPhi2F",0.012);
     psd0.add<double>("PhiMin2F",-0.003);
     psd0.add<double>("hOverEHFMinE",0.8);
     psd0.add<double>("DeltaPhi2B",0.008);
     psd0.add<double>("PhiMin2B",-0.002);
     psd0.add<bool>("allowHGCal",false);
     
     psd3.add<std::string>("ComponentName",std::string("SeedFromConsecutiveHitsCreator"));
     psd3.add<std::string>("propagator",std::string("PropagatorWithMaterial"));
     psd3.add<double>("SeedMomentumForBOFF",5.0);
     psd3.add<double>("OriginTransverseErrorMultiplier",1.0);
     psd3.add<double>("MinOneOverPtError",1.0);
     psd3.add<std::string>("magneticField",std::string(""));
     psd3.add<std::string>("TTRHBuilder",std::string("WithTrackAngle"));
     psd3.add<bool>("forceKinematicWithRegionDirection",false);
 
     psd4.add<edm::InputTag>("HGCEEInput",edm::InputTag("HGCalRecHit","HGCEERecHits"));
     psd4.add<edm::InputTag>("HGCFHInput",edm::InputTag("HGCalRecHit","HGCHEFRecHits"));
     psd4.add<edm::InputTag>("HGCBHInput",edm::InputTag("HGCalRecHit","HGCHEBRecHits"));
     
     psd0.add<edm::ParameterSetDescription>("HGCalConfig",psd4);
 
     psd0.add<edm::ParameterSetDescription>("SeedCreatorPSet",psd3);
 
     desc.add<edm::ParameterSetDescription>("SeedConfiguration",psd0);
   }
   desc.add<edm::InputTag>("barrelSuperClusters",edm::InputTag("particleFlowSuperClusterECAL","particleFlowSuperClusterECALBarrel"));
   descriptions.add("ecalDrivenElectronSeeds",desc);
 }

void ElectronSeedProducer::filterClusters	(	const reco::BeamSpot &	bs,
		const edm::Handle< reco::SuperClusterCollection > &	superClusters,
		reco::SuperClusterRefVector &	sclRefs,
		std::vector< float > &	hoe1s,
		std::vector< float > &	hoe2s,
		edm::Event &	e,
		const edm::EventSetup &	setup
	)

private

Definition at line 246 of file ElectronSeedProducer.cc.

References allowHGCal_, applyHOverECut_, applySigmaIEtaIEtaCut_, gamEcalExtractorBlocks_cff::detector, ebRecHitCollection_, EcalBarrel, EcalEndcap, eeRecHitCollection_, reco::CaloCluster::energy(), PVValHelper::eta, funct::false, filterSeeds(), DetId::Forward, HcalEndcap, ElectronHcalHelper::hcalESumDepth1(), ElectronHcalHelper::hcalESumDepth2(), hcalHelper_, hgcClusterTools_, reco::CaloCluster::hitsAndFractions(), mps_fire::i, infinity, edm::isNotFinite(), EcalClusterLazyToolsT< EcalClusterToolsImpl >::localCovariances(), LogDebug, maxHBarrel_, maxHEndcaps_, maxHOverEBarrel_, maxHOverEEndcaps_, reco::BeamSpot::position(), reco::CaloCluster::position(), edm::RefVector< C, T, F >::push_back(), SCEtCut_, reco::SuperCluster::seed(), edm::RefVector< C, T, F >::size(), and mathSSE::sqrt().

Referenced by produce().

  {
 
    std::vector<float> sigmaIEtaIEtaEB_;
    std::vector<float> sigmaIEtaIEtaEE_;
 
   for (unsigned int i=0;i<superClusters->size();++i)
    {
     const SuperCluster & scl = (*superClusters)[i] ;
     double sclEta = EleRelPoint(scl.position(),bs.position()).eta() ;
     if (scl.energy()/cosh(sclEta)>SCEtCut_)
      {
 //      if ((applyHOverECut_==true)&&((hcalHelper_->hcalESum(scl)/scl.energy()) > maxHOverE_))
 //       { continue ; }
 //      sclRefs.push_back(edm::Ref<reco::SuperClusterCollection>(superClusters,i)) ;
        double had1, had2, had, scle ;
 
        bool HoeVeto = false ;
        if (applyHOverECut_==true)
         {
          had1 = hcalHelper_->hcalESumDepth1(scl);
          had2 = hcalHelper_->hcalESumDepth2(scl);
          had = had1+had2 ;
          scle = scl.energy() ;
          int det_group = scl.seed()->hitsAndFractions()[0].first.det() ;
          int detector = scl.seed()->hitsAndFractions()[0].first.subdetId() ;
          if ( detector==EcalBarrel && (had<maxHBarrel_ || had/scle<maxHOverEBarrel_)) HoeVeto=true;
          else if( !allowHGCal_ && detector==EcalEndcap && (had<maxHEndcaps_ || had/scle<maxHOverEEndcaps_) ) HoeVeto=true;
          else if( allowHGCal_ && (detector==HcalEndcap || det_group == DetId::Forward) ) {
            float had_fraction = hgcClusterTools_->getClusterHadronFraction(*(scl.seed()));
            had1 = had_fraction*scl.seed()->energy();
            had2 = 0.;
            HoeVeto= ( had_fraction >= 0.f && had_fraction < maxHOverEEndcaps_ );
          }
          if (HoeVeto)
           {
            sclRefs.push_back(edm::Ref<reco::SuperClusterCollection>(superClusters,i)) ;
            hoe1s.push_back(had1/scle) ;
            hoe2s.push_back(had2/scle) ;
           }
         }
        else
         {
          sclRefs.push_back(edm::Ref<reco::SuperClusterCollection>(superClusters,i)) ;
          hoe1s.push_back(std::numeric_limits<float>::infinity()) ;
          hoe2s.push_back(std::numeric_limits<float>::infinity()) ;
         }
      }
 
     if (applySigmaIEtaIEtaCut_ == true)
       {
     noZS::EcalClusterLazyTools lazyTool_noZS(event, setup, ebRecHitCollection_, eeRecHitCollection_);
     std::vector<float> vCov = lazyTool_noZS.localCovariances(*(scl.seed()));
     int detector = scl.seed()->hitsAndFractions()[0].first.subdetId() ;
     if (detector==EcalBarrel) sigmaIEtaIEtaEB_ .push_back(edm::isNotFinite(vCov[0]) ? 0. : sqrt(vCov[0]));
     if (detector==EcalEndcap) sigmaIEtaIEtaEE_ .push_back(edm::isNotFinite(vCov[0]) ? 0. : sqrt(vCov[0]));
       }
    }
   LogDebug("ElectronSeedProducer")<<"Filtered out "<<sclRefs.size()<<" superclusters from "<<superClusters->size() ;
  }

void ElectronSeedProducer::filterSeeds	(	edm::Event &	e,
		const edm::EventSetup &	setup,
		reco::SuperClusterRefVector &	sclRefs
	)

private

Definition at line 312 of file ElectronSeedProducer.cc.

References mps_fire::i, LogDebug, seedFilter_, edm::RefVector< C, T, F >::size(), and theInitialSeedColl.

Referenced by filterClusters(), and produce().

  {
   for ( unsigned int i=0 ; i<sclRefs.size() ; ++i )
    {
     seedFilter_->seeds(event,setup,sclRefs[i],theInitialSeedColl) ;
     LogDebug("ElectronSeedProducer")<<"Number of Seeds: "<<theInitialSeedColl->size() ;
    }
  }

void ElectronSeedProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	iSetup
	)

final

Definition at line 163 of file ElectronSeedProducer.cc.

References allowHGCal_, beamSpotTag_, edm::eventsetup::EventSetupRecord::cacheIdentifier(), caloGeom_, caloGeomCacheId_, caloTopo_, caloTopoCacheId_, edm::RefToBase< T >::castTo(), ElectronHcalHelper::checkSetup(), fastPrimaryVertexProducer_cfi::clusters, filterClusters(), filterSeeds(), fromTrackerSeeds_, edm::EventSetup::get(), edm::Event::getByToken(), hcalHelper_, hgcClusterTools_, mps_fire::i, edm::Ref< C, T, F >::id(), initialSeeds_, LogDebug, matcher_, eostools::move(), nullptr, prefilteredSeeds_, edm::Handle< T >::product(), edm::Event::put(), ElectronHcalHelper::readEvent(), ElectronSeedGenerator::run(), ElectronSeedGenerator::setupES(), superClusters_, and theInitialSeedColl.

  {
   LogDebug("ElectronSeedProducer") <<"[ElectronSeedProducer::produce] entering " ;
 
   edm::Handle<reco::BeamSpot> theBeamSpot ;
   e.getByToken(beamSpotTag_,theBeamSpot) ;
 
   if (hcalHelper_)
    {
     hcalHelper_->checkSetup(iSetup) ;
     hcalHelper_->readEvent(e) ;
     if( allowHGCal_ ) {
       hgcClusterTools_->getEventSetup(iSetup);
       hgcClusterTools_->getEvent(e);
     }
    }
 
   // get calo geometry
   if (caloGeomCacheId_!=iSetup.get<CaloGeometryRecord>().cacheIdentifier()) {
     iSetup.get<CaloGeometryRecord>().get(caloGeom_);
     caloGeomCacheId_=iSetup.get<CaloGeometryRecord>().cacheIdentifier();
   }
   if (caloTopoCacheId_!=iSetup.get<CaloTopologyRecord>().cacheIdentifier()){
     caloTopoCacheId_=iSetup.get<CaloTopologyRecord>().cacheIdentifier();
     iSetup.get<CaloTopologyRecord>().get(caloTopo_);
   }
 
   matcher_->setupES(iSetup);
 
   // get initial TrajectorySeeds if necessary
   if (fromTrackerSeeds_)
    {
     if (!prefilteredSeeds_)
      {
       edm::Handle<TrajectorySeedCollection> hSeeds;
       e.getByToken(initialSeeds_, hSeeds);
       theInitialSeedColl = const_cast<TrajectorySeedCollection *> (hSeeds.product());
      }
     else
      { theInitialSeedColl = new TrajectorySeedCollection ; }
    }
   else
    { theInitialSeedColl = nullptr ; } // not needed in this case
 
   ElectronSeedCollection * seeds = new ElectronSeedCollection ;
 
   // loop over barrel + endcap
   for (unsigned int i=0; i<2; i++) {
     edm::Handle<SuperClusterCollection> clusters ;
     e.getByToken(superClusters_[i],clusters);
     SuperClusterRefVector clusterRefs ;
     std::vector<float> hoe1s, hoe2s ;
     filterClusters(*theBeamSpot,clusters,/*mhbhe_,*/clusterRefs,hoe1s,hoe2s,e, iSetup);
     if ((fromTrackerSeeds_) && (prefilteredSeeds_))
       { filterSeeds(e,iSetup,clusterRefs) ; }
     matcher_->run(e,iSetup,clusterRefs,hoe1s,hoe2s,theInitialSeedColl,*seeds);
   }
 
   // store the accumulated result
   std::unique_ptr<ElectronSeedCollection> pSeeds(seeds);
   ElectronSeedCollection::iterator is ;
   for ( is=pSeeds->begin() ; is!=pSeeds->end() ; is++ ) {
     edm::RefToBase<CaloCluster> caloCluster = is->caloCluster() ;
     SuperClusterRef superCluster = caloCluster.castTo<SuperClusterRef>() ;
     LogDebug("ElectronSeedProducer")
       << "new seed with "
       << (*is).nHits() << " hits"
       << ", charge " << (*is).getCharge()
       << " and cluster energy " << superCluster->energy()
       << " PID "<<superCluster.id() ;
   }
   e.put(std::move(pSeeds));
   if (fromTrackerSeeds_ && prefilteredSeeds_) delete theInitialSeedColl;
  }