#include <ElectronSeedProducer.h>

Inheritance diagram for ElectronSeedProducer:

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

	ElectronSeedProducer (const edm::ParameterSet &)

virtual void	endRun (edm::Run const &, edm::EventSetup const &) overridefinal

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

virtual	~ElectronSeedProducer ()

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

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

Private Attributes
bool	applyHOverECut_

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< std::vector < reco::Vertex > >	filterVtxTag_

bool	fromTrackerSeeds_

ElectronHcalHelper *	hcalHelper_

edm::EDGetTokenT < TrajectorySeedCollection >	initialSeeds_

ElectronSeedGenerator *	matcher_

double	maxHBarrel_

double	maxHEndcaps_

double	maxHOverEBarrel_

double	maxHOverEEndcaps_

bool	prefilteredSeeds_

double	SCEtCut_

SeedFilter *	seedFilter_

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

TrajectorySeedCollection *	theInitialSeedColl

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

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 41 of file ElectronSeedProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 50 of file ElectronSeedProducer.cc.

References applyHOverECut_, beamSpotTag_, conf_, edm::ParameterSet::exists(), filterVtxTag_, fromTrackerSeeds_, edm::ParameterSet::getParameter(), hcalHelper_, ElectronHcalHelper::Configuration::hcalTowers, ElectronHcalHelper::Configuration::hOverEConeSize, ElectronHcalHelper::Configuration::hOverEPtMin, initialSeeds_, matcher_, maxHBarrel_, maxHEndcaps_, maxHOverEBarrel_, maxHOverEEndcaps_, prefilteredSeeds_, SCEtCut_, superClusters_, ElectronSeedGenerator::Tokens::token_bs, ElectronSeedGenerator::Tokens::token_vtx, funct::true, and ElectronHcalHelper::Configuration::useTowers.

  : //conf_(iConfig),
    seedFilter_(0), applyHOverECut_(true), hcalHelper_(0),
    caloGeom_(0), caloGeomCacheId_(0), caloTopo_(0), 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") ;
 
   // new beamSpot tag
   if (conf_.exists("beamSpot")) { 
     beamSpotTag_ = consumes<reco::BeamSpot>(conf_.getParameter<edm::InputTag>("beamSpot")); 
   } else {
     beamSpotTag_ = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
   }
 
   // for H/E
 //  if (conf_.exists("applyHOverECut"))
 //   { applyHOverECut_ = conf_.getParameter<bool>("applyHOverECut") ; }
   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) ;
     maxHOverEBarrel_=conf_.getParameter<double>("maxHOverEBarrel") ;
     maxHOverEEndcaps_=conf_.getParameter<double>("maxHOverEEndcaps") ;
     maxHBarrel_=conf_.getParameter<double>("maxHBarrel") ;
     maxHEndcaps_=conf_.getParameter<double>("maxHEndcaps") ;
 //    hOverEConeSize_=conf_.getParameter<double>("hOverEConeSize") ;
 //    hOverEHBMinE_=conf_.getParameter<double>("hOverEHBMinE") ;
 //    hOverEHFMinE_=conf_.getParameter<double>("hOverEHFMinE") ;
    }
 
   if( conf_.exists("RegionPSet") ) {
     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_;
   if(conf_.exists("vertices")) {
     esg_tokens.token_vtx = 
       mayConsume<reco::VertexCollection>(conf_.getParameter<edm::InputTag>("vertices"));
   } else {
     esg_tokens.token_vtx = 
       mayConsume<reco::VertexCollection>(edm::InputTag("offlinePrimaryVerticesWithBS"));
   }
   matcher_ = new ElectronSeedGenerator(conf_,esg_tokens) ;
 
   //  get collections from config'
   superClusters_[0]=
     consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("barrelSuperClusters")) ;
   superClusters_[1]=
     consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("endcapSuperClusters")) ;
 
   //register your products
   produces<ElectronSeedCollection>() ;
 }

ElectronSeedProducer::~ElectronSeedProducer ( )

virtual

Definition at line 141 of file ElectronSeedProducer.cc.

References hcalHelper_, and matcher_.

  {
   delete hcalHelper_ ;
   delete matcher_ ;
  }

Member Function Documentation

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

finaloverridevirtual

Reimplemented from edm::EDProducer.

Definition at line 123 of file ElectronSeedProducer.cc.

References beamSpotTag_, conf_, filterVtxTag_, prefilteredSeeds_, seedFilter_, SeedFilter::Tokens::token_bs, and SeedFilter::Tokens::token_vtx.

                                                                        {
   // 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_;
     seedFilter_ = new SeedFilter(conf_,sf_tokens) ;
   }
 }

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

finaloverridevirtual

Reimplemented from edm::EDProducer.

Definition at line 135 of file ElectronSeedProducer.cc.

References seedFilter_.

  {
   delete seedFilter_ ;
   seedFilter_ = 0 ;
  }

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

private

Definition at line 226 of file ElectronSeedProducer.cc.

References EcalBarrel, EcalEndcap, reco::CaloCluster::energy(), eta(), edm::false, i, infinity, LogDebug, reco::BeamSpot::position(), reco::CaloCluster::position(), edm::RefVector< C, T, F >::push_back(), reco::SuperCluster::seed(), and edm::RefVector< C, T, F >::size().

Referenced by produce().

  {
   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 detector = scl.seed()->hitsAndFractions()[0].first.subdetId() ;
          if (detector==EcalBarrel && (had<maxHBarrel_ || had/scle<maxHOverEBarrel_)) HoeVeto=true;
          else if (detector==EcalEndcap && (had<maxHEndcaps_ || had/scle<maxHOverEEndcaps_)) HoeVeto=true;
          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()) ;
         }
      }
    }
   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 270 of file ElectronSeedProducer.cc.

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

Referenced by 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
	)

finaloverridevirtual

Implements edm::EDProducer.

Definition at line 147 of file ElectronSeedProducer.cc.

References beamSpotTag_, edm::eventsetup::EventSetupRecord::cacheIdentifier(), caloGeom_, caloGeomCacheId_, caloTopo_, caloTopoCacheId_, edm::RefToBase< T >::castTo(), ElectronHcalHelper::checkSetup(), filterClusters(), filterSeeds(), fromTrackerSeeds_, edm::EventSetup::get(), edm::Event::getByToken(), hcalHelper_, i, edm::Ref< C, T, F >::id(), initialSeeds_, LogDebug, matcher_, 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) ;
    }
 
   // 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 = 0 ; } // 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);
     if ((fromTrackerSeeds_) && (prefilteredSeeds_))
       { filterSeeds(e,iSetup,clusterRefs) ; }
     matcher_->run(e,iSetup,clusterRefs,hoe1s,hoe2s,theInitialSeedColl,*seeds);
   }
 
   // store the accumulated result
   std::auto_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(pSeeds) ;
   if (fromTrackerSeeds_ && prefilteredSeeds_) delete theInitialSeedColl;
  }