EcalClusterLazyTools Class Reference

#include <EcalClusterLazyTools.h>

Public Member Functions
float	BasicClusterSeedTime (const reco::BasicCluster &cluster)
float	BasicClusterTime (const reco::BasicCluster &cluster, const edm::Event &ev)
std::vector< float >	covariances (const reco::BasicCluster &cluster, float w0=4.7)
std::vector< float >	covariances (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
float	e1x3 (const reco::BasicCluster &cluster)
float	e1x3 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e1x5 (const reco::BasicCluster &cluster)
float	e1x5 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2nd (const reco::BasicCluster &cluster)
float	e2nd (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x2 (const reco::BasicCluster &cluster)
float	e2x2 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x5Bottom (const reco::BasicCluster &cluster)
float	e2x5Bottom (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x5Left (const reco::BasicCluster &cluster)
float	e2x5Left (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x5Max (const reco::BasicCluster &cluster)
float	e2x5Max (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x5Right (const reco::BasicCluster &cluster)
float	e2x5Right (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e2x5Top (const reco::BasicCluster &cluster)
float	e2x5Top (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e3x1 (const reco::BasicCluster &cluster)
float	e3x1 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e3x2 (const reco::BasicCluster &cluster)
float	e3x2 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e3x3 (const reco::BasicCluster &cluster)
float	e3x3 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e4x4 (const reco::BasicCluster &cluster)
float	e4x4 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e5x1 (const reco::BasicCluster &cluster)
float	e5x1 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	e5x5 (const reco::BasicCluster &cluster)
float	e5x5 (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	eBottom (const reco::BasicCluster &cluster)
float	eBottom (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
	EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, const edm::InputTag &redEBRecHits, const edm::InputTag &redEERecHits, const edm::ParameterSet &config)
	EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, const edm::InputTag &redEBRecHits, const edm::InputTag &redEERecHits)
	EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, const edm::InputTag &redEBRecHits, const edm::InputTag &redEERecHits, const edm::InputTag &redESRecHits)
float	eLeft (const reco::BasicCluster &cluster)
float	eLeft (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	eMax (const reco::BasicCluster &cluster)
float	eMax (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float >	energyBasketFractionEta (const reco::BasicCluster &cluster)
std::vector< float >	energyBasketFractionEta (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float >	energyBasketFractionPhi (const reco::BasicCluster &cluster)
std::vector< float >	energyBasketFractionPhi (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	eRight (const reco::BasicCluster &cluster)
float	eRight (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float	eseffsirir (const reco::SuperCluster &cluster)
float	eseffsixix (const reco::SuperCluster &cluster)
float	eseffsiyiy (const reco::SuperCluster &cluster)
float	eTop (const reco::BasicCluster &cluster)
float	eTop (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float >	getESHits (double X, double Y, double Z, const std::map< DetId, EcalRecHit > &rechits_map, const CaloGeometry *geometry, CaloSubdetectorTopology *topology_p, int row=0, int plane=1)
float	getESShape (const std::vector< float > &ESHits0)
std::pair< DetId, float >	getMaximum (const reco::BasicCluster &cluster)
std::pair< DetId, float >	getMaximum (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float >	lat (const reco::BasicCluster &cluster, bool logW=true, float w0=4.7)
std::vector< float >	lat (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, bool logW=true, float w0=4.7)
std::vector< float >	localCovariances (const reco::BasicCluster &cluster, float w0=4.7)
std::vector< float >	localCovariances (const reco::BasicCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
std::vector< DetId >	matrixDetId (DetId id, int ixMin, int ixMax, int iyMin, int iyMax)
float	matrixEnergy (const reco::BasicCluster &cluster, DetId id, int ixMin, int ixMax, int iyMin, int iyMax)
float	matrixEnergy (const reco::BasicCluster &cluster, DetId id, int ixMin, int ixMax, int iyMin, int iyMax, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float >	scLocalCovariances (const reco::SuperCluster &cluster, float w0=4.7)
std::vector< float >	scLocalCovariances (const reco::SuperCluster &cluster, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
float	SuperClusterSeedTime (const reco::SuperCluster &cluster)
float	SuperClusterTime (const reco::SuperCluster &cluster, const edm::Event &ev)
double	zernike20 (const reco::BasicCluster &cluster, double R0=6.6, bool logW=true, float w0=4.7)
double	zernike42 (const reco::BasicCluster &cluster, double R0=6.6, bool logW=true, float w0=4.7)
	~EcalClusterLazyTools ()

Public Attributes
std::map< DetId, EcalRecHit >	rechits_map_

Private Member Functions
void	getADCToGeV (const edm::EventSetup &es)
void	getEBRecHits (const edm::Event &ev, const edm::InputTag &redEBRecHits)
const EcalRecHitCollection *	getEcalRecHitCollection (const reco::BasicCluster &cluster)
void	getEERecHits (const edm::Event &ev, const edm::InputTag &redEERecHits)
void	getESRecHits (const edm::Event &ev, const edm::InputTag &redESRecHits)
void	getGeometry (const edm::EventSetup &es)
void	getIntercalibConstants (const edm::EventSetup &es)
void	getLaserDbService (const edm::EventSetup &es)
void	getTopology (const edm::EventSetup &es)

Private Attributes
edm::ESHandle < EcalADCToGeVConstant >	agc
const EcalRecHitCollection *	ebRecHits_
const EcalRecHitCollection *	eeRecHits_
const EcalRecHitCollection *	esRecHits_
const CaloGeometry *	geometry_
edm::ESHandle < EcalIntercalibConstants >	ical
EcalIntercalibConstantMap	icalMap
edm::ESHandle< EcalLaserDbService >	laser
const CaloTopology *	topology_

Detailed Description

various cluster tools (e.g. cluster shapes)

Author

Federico Ferri

Version

$Id:

Definition at line 33 of file EcalClusterLazyTools.h.

Constructor & Destructor Documentation

EcalClusterLazyTools::EcalClusterLazyTools	(	const edm::Event &	ev,
		const edm::EventSetup &	es,
		const edm::InputTag &	redEBRecHits,
		const edm::InputTag &	redEERecHits,
		const edm::ParameterSet &	config
	)

Definition at line 61 of file EcalClusterLazyTools.cc.

References getADCToGeV(), getEBRecHits(), getEERecHits(), getGeometry(), getIntercalibConstants(), getLaserDbService(), and getTopology().

{
        getGeometry( es );
        getTopology( es );
        getEBRecHits( ev, redEBRecHits );
        getEERecHits( ev, redEERecHits );
        getIntercalibConstants( es );
        getADCToGeV ( es );
        getLaserDbService ( es );

//  edm::ESHandle<EcalSeverityLevelAlgo> sevLv;
//  es.get<EcalSeverityLevelAlgoRcd>().get(sevLv);

}

EcalClusterLazyTools::EcalClusterLazyTools	(	const edm::Event &	ev,
		const edm::EventSetup &	es,
		const edm::InputTag &	redEBRecHits,
		const edm::InputTag &	redEERecHits
	)

Definition at line 26 of file EcalClusterLazyTools.cc.

References getADCToGeV(), getEBRecHits(), getEERecHits(), getGeometry(), getIntercalibConstants(), getLaserDbService(), and getTopology().

{
        getGeometry( es );
        getTopology( es );
        getEBRecHits( ev, redEBRecHits );
        getEERecHits( ev, redEERecHits );
    getIntercalibConstants( es );
    getADCToGeV ( es );
    getLaserDbService ( es );

  //AA
  //Flags and Severities to be excluded from photon calculations
/*
  const std::vector<std::string> flagnames = 
    config.getParameter<std::vector<std::string> >("RecHitFlagToBeExcluded");

  flagsexcl_= 
    StringToEnumValue<EcalRecHit::Flags>(flagnames);

  const std::vector<std::string> severitynames = 
    config.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcluded");

  severitiesexcl_= 
    StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynames);
  //AA

  //AA
*/
  //Get the severity level object
//  edm::ESHandle<EcalSeverityLevelAlgo> sevLv;
//  es.get<EcalSeverityLevelAlgoRcd>().get(sevLv);
  //

}

EcalClusterLazyTools::EcalClusterLazyTools	(	const edm::Event &	ev,
		const edm::EventSetup &	es,
		const edm::InputTag &	redEBRecHits,
		const edm::InputTag &	redEERecHits,
		const edm::InputTag &	redESRecHits
	)

Definition at line 76 of file EcalClusterLazyTools.cc.

References getADCToGeV(), getEBRecHits(), getEERecHits(), getESRecHits(), getGeometry(), getIntercalibConstants(), getLaserDbService(), and getTopology().

{
        getGeometry( es );
        getTopology( es );
        getEBRecHits( ev, redEBRecHits );
        getEERecHits( ev, redEERecHits );
        getESRecHits( ev, redESRecHits );
        getIntercalibConstants( es );
        getADCToGeV ( es );
        getLaserDbService ( es );

}

EcalClusterLazyTools::~EcalClusterLazyTools

(

)

Definition at line 89 of file EcalClusterLazyTools.cc.

{
}

Member Function Documentation

float EcalClusterLazyTools::BasicClusterSeedTime

(

const reco::BasicCluster &

cluster

)

Definition at line 519 of file EcalClusterLazyTools.cc.

References edm::SortedCollection< T, SORT >::find(), and getEcalRecHitCollection().

Referenced by SuperClusterSeedTime().

{
  
  const EcalRecHitCollection *recHits = getEcalRecHitCollection( cluster );
  
  DetId id = cluster.seed();
  EcalRecHitCollection::const_iterator theSeedHit = recHits->find (id);
  //  std::cout << "the seed of the BC has time: " 
  //<< (*theSeedHit).time() 
  //<< "and energy: " << (*theSeedHit).energy() << " collection size: " << recHits->size() 
  //<< "\n" <<std::endl; // GF debug
  
  return (*theSeedHit).time();
}

float EcalClusterLazyTools::BasicClusterTime	(	const reco::BasicCluster &	cluster,
		const edm::Event &	ev
	)

Definition at line 536 of file EcalClusterLazyTools.cc.

References ecalMGPA::adc(), agc, EcalBarrel, EcalEndcap, EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), edm::SortedCollection< T, SORT >::find(), first, getEcalRecHitCollection(), icalMap, laser, mathSSE::sqrt(), and edm::EventBase::time().

Referenced by SuperClusterTime().

{
  
  std::vector<std::pair<DetId, float> > clusterComponents = (cluster).hitsAndFractions() ;
  //std::cout << "BC has this many components: " << clusterComponents.size() << std::endl; // GF debug
  
  const EcalRecHitCollection *recHits = getEcalRecHitCollection( cluster );
  //std::cout << "BasicClusterClusterTime - rechits are this many: " << recHits->size() << std::endl; // GF debug
  
  
  float weightedTsum   = 0;
  float sumOfWeights   = 0;
  
  for (std::vector<std::pair<DetId, float> >::const_iterator detitr = clusterComponents.begin(); detitr != clusterComponents.end(); detitr++ )
    {
      //      EcalRecHitCollection::const_iterator theSeedHit = recHits->find (id); // trash this
      EcalRecHitCollection::const_iterator oneHit = recHits->find( (detitr -> first) ) ;
      
      // in order to get back the ADC counts from the recHit energy, three ingredients are necessary:
      // 1) get laser correction coefficient
      float lasercalib = 1.;
      lasercalib = laser->getLaserCorrection( detitr->first, ev.time());
      // 2) get intercalibration
      EcalIntercalibConstantMap::const_iterator icalit = icalMap.find(detitr->first);
      EcalIntercalibConstant icalconst = 1.;
      if( icalit!=icalMap.end() ) {
    icalconst = (*icalit);
    // std::cout << "icalconst set to: " << icalconst << std::endl;
      } else {
    edm::LogError("EcalClusterLazyTools") << "No intercalib const found for xtal "  << (detitr->first).rawId() << "bailing out";
    assert(0);
      }
      // 3) get adc2GeV
      float adcToGeV = 1.;
      if       ( (detitr -> first).subdetId() == EcalBarrel )  adcToGeV = float(agc->getEBValue());
      else if  ( (detitr -> first).subdetId() == EcalEndcap )  adcToGeV = float(agc->getEEValue());
            float adc = 2.;
      if (icalconst>0 && lasercalib>0 && adcToGeV>0)  adc= (*oneHit).energy()/(icalconst*lasercalib*adcToGeV);

      // don't consider recHits with too little amplitude; take sigma_noise_total into account
      if( (detitr -> first).subdetId() == EcalBarrel  &&  adc< (1.1*20) ) continue;
      if( (detitr -> first).subdetId() == EcalEndcap  &&  adc< (2.2*20) ) continue;

      // count only on rechits whose error is trusted by the method (ratio)
      if(! (*oneHit).isTimeErrorValid()) continue;

      float timeError    = (*oneHit).timeError();
      // the constant used to build timeError is largely over-estimated ; remove in quadrature 0.6 and add 0.15 back.
      // could be prettier if value of constant term was changed at recHit production level
      if (timeError>0.6) timeError = sqrt( timeError*timeError - 0.6*0.6 + 0.15*0.15);
      else               timeError = sqrt( timeError*timeError           + 0.15*0.15);

      // do the error weighting
      weightedTsum += (*oneHit).time() / (timeError*timeError);
      sumOfWeights += 1. / (timeError*timeError);

    }
  
  // what if no crytal is available for weighted average?
  if     ( sumOfWeights ==0 )  return -999;
  else   return ( weightedTsum / sumOfWeights);

}

std::vector< float > EcalClusterLazyTools::covariances	(	const reco::BasicCluster &	cluster,
		float	w0 = 4.7
	)

Definition at line 461 of file EcalClusterLazyTools.cc.

References EcalClusterTools::covariances(), geometry_, getEcalRecHitCollection(), and topology_.

Referenced by EgammaHLTClusterShapeProducer::produce().

{
        return EcalClusterTools::covariances( cluster, getEcalRecHitCollection(cluster), topology_, geometry_, w0 );
}

std::vector< float > EcalClusterLazyTools::covariances	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv,
		float	w0 = 4.7
	)

Definition at line 466 of file EcalClusterLazyTools.cc.

References EcalClusterTools::covariances(), geometry_, getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::covariances( cluster, getEcalRecHitCollection(cluster), topology_, geometry_, flagsexcl, severitiesexcl, sevLv, w0 );
}

float EcalClusterLazyTools::e1x3

(

const reco::BasicCluster &

cluster

)

Definition at line 195 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e1x3(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e1x3( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e1x3	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 201 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e1x3(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e1x3( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e1x5

(

const reco::BasicCluster &

cluster

)

Definition at line 219 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e1x5(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e1x5( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e1x5	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 224 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e1x5(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e1x5( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2nd

(

const reco::BasicCluster &

cluster

)

Definition at line 407 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2nd(), and getEcalRecHitCollection().

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), and EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2nd( cluster, getEcalRecHitCollection(cluster) );
}

float EcalClusterLazyTools::e2nd	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 412 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2nd(), and getEcalRecHitCollection().

{
        return EcalClusterTools::e2nd( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x2

(

const reco::BasicCluster &

cluster

)

Definition at line 242 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x2(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x2( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x2	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 247 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x2(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x2( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x5Bottom

(

const reco::BasicCluster &

cluster

)

Definition at line 330 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Bottom(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2x5Bottom( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x5Bottom	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 335 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Bottom(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x5Bottom( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x5Left

(

const reco::BasicCluster &

cluster

)

Definition at line 308 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Left(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2x5Left( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x5Left	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 313 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Left(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x5Left( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x5Max

(

const reco::BasicCluster &

cluster

)

Definition at line 341 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Max(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2x5Max( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x5Max	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 346 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Max(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x5Max( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x5Right

(

const reco::BasicCluster &

cluster

)

Definition at line 297 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Right(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2x5Right( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x5Right	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 302 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Right(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x5Right( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e2x5Top

(

const reco::BasicCluster &

cluster

)

Definition at line 319 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Top(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::e2x5Top( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e2x5Top	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 324 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e2x5Top(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e2x5Top( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e3x1

(

const reco::BasicCluster &

cluster

)

Definition at line 208 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x1(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e3x1( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e3x1	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 213 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x1(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e3x1( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e3x2

(

const reco::BasicCluster &

cluster

)

Definition at line 253 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x2(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e3x2( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e3x2	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 258 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x2(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e3x2( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e3x3

(

const reco::BasicCluster &

cluster

)

Definition at line 264 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x3(), getEcalRecHitCollection(), and topology_.

Referenced by EgammaSuperClusters::analyze(), EGEnergyCorrector::CorrectedEnergyWithError(), EGEnergyCorrector::CorrectedEnergyWithErrorV3(), EGammaMvaEleEstimator::IDIsoCombinedMvaValue(), EGammaMvaEleEstimator::mvaValue(), EgammaHLTR9IDProducer::produce(), EgammaHLTR9Producer::produce(), pat::PATElectronProducer::produce(), PTDRElectronID::result(), and FourVectorHLTOffline::selectElectrons().

{
        return EcalClusterTools::e3x3( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e3x3	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 269 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e3x3(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e3x3( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e4x4

(

const reco::BasicCluster &

cluster

)

Definition at line 275 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e4x4(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e4x4( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e4x4	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 280 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e4x4(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e4x4( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::e5x1

(

const reco::BasicCluster &

cluster

)

Definition at line 231 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e5x1(), getEcalRecHitCollection(), and topology_.

{
  return EcalClusterTools::e5x1( cluster, getEcalRecHitCollection(cluster), topology_ );
    }

float EcalClusterLazyTools::e5x1	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 236 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e5x1(), getEcalRecHitCollection(), and topology_.

{
  return EcalClusterTools::e5x1( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
    }

float EcalClusterLazyTools::e5x5

(

const reco::BasicCluster &

cluster

)

Definition at line 286 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e5x5(), getEcalRecHitCollection(), and topology_.

Referenced by EgammaSuperClusters::analyze(), EGEnergyCorrector::CorrectedEnergyWithError(), EGEnergyCorrector::CorrectedEnergyWithErrorV3(), and PTDRElectronID::result().

{
        return EcalClusterTools::e5x5( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::e5x5	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 291 of file EcalClusterLazyTools.cc.

References EcalClusterTools::e5x5(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::e5x5( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::eBottom

(

const reco::BasicCluster &

cluster

)

Definition at line 385 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eBottom(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), and EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::eBottom( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::eBottom	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 390 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eBottom(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::eBottom( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::eLeft

(

const reco::BasicCluster &

cluster

)

Definition at line 352 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eLeft(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), and EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::eLeft( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::eLeft	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 357 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eLeft(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::eLeft( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::eMax

(

const reco::BasicCluster &

cluster

)

Definition at line 396 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eMax(), and getEcalRecHitCollection().

Referenced by EgammaSuperClusters::analyze(), EGEnergyCorrector::CorrectedEnergyWithError(), EGEnergyCorrector::CorrectedEnergyWithErrorV3(), EgammaHLTR9Producer::produce(), and FourVectorHLTOffline::selectElectrons().

{
        return EcalClusterTools::eMax( cluster, getEcalRecHitCollection(cluster) );
}

float EcalClusterLazyTools::eMax	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 401 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eMax(), and getEcalRecHitCollection().

{
        return EcalClusterTools::eMax( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}

std::vector< float > EcalClusterLazyTools::energyBasketFractionEta

(

const reco::BasicCluster &

cluster

)

Definition at line 428 of file EcalClusterLazyTools.cc.

References EcalClusterTools::energyBasketFractionEta(), and getEcalRecHitCollection().

{
        return EcalClusterTools::energyBasketFractionEta( cluster, getEcalRecHitCollection(cluster) );
}

std::vector< float > EcalClusterLazyTools::energyBasketFractionEta	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 433 of file EcalClusterLazyTools.cc.

References EcalClusterTools::energyBasketFractionEta(), and getEcalRecHitCollection().

{
        return EcalClusterTools::energyBasketFractionEta( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}

std::vector< float > EcalClusterLazyTools::energyBasketFractionPhi

(

const reco::BasicCluster &

cluster

)

Definition at line 439 of file EcalClusterLazyTools.cc.

References EcalClusterTools::energyBasketFractionPhi(), and getEcalRecHitCollection().

{
        return EcalClusterTools::energyBasketFractionPhi( cluster, getEcalRecHitCollection(cluster) );
}

std::vector< float > EcalClusterLazyTools::energyBasketFractionPhi	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 444 of file EcalClusterLazyTools.cc.

References EcalClusterTools::energyBasketFractionPhi(), and getEcalRecHitCollection().

{
        return EcalClusterTools::energyBasketFractionPhi( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::eRight

(

const reco::BasicCluster &

cluster

)

Definition at line 363 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eRight(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), and EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::eRight( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::eRight	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 368 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eRight(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::eRight( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

float EcalClusterLazyTools::eseffsirir

(

const reco::SuperCluster &

cluster

)

Definition at line 618 of file EcalClusterLazyTools.cc.

References DetId::Ecal, EcalPreshower, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), CaloGeometry::getSubdetectorGeometry(), rechits_map_, mathSSE::sqrt(), reco::CaloCluster::x(), reco::CaloCluster::y(), and reco::CaloCluster::z().

{
  if (!(fabs(cluster.eta()) > 1.6 && fabs(cluster.eta()) < 3.)) return 0.;

  const CaloSubdetectorGeometry *geometryES = geometry_->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
  CaloSubdetectorTopology *topology_p = 0;
  if (geometryES) topology_p = new EcalPreshowerTopology(geometry_);

  std::vector<float> phoESHitsIXIX = getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, topology_p, 0, 1);
  std::vector<float> phoESHitsIYIY = getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, topology_p, 0, 2);
  float phoESShapeIXIX = getESShape(phoESHitsIXIX);
  float phoESShapeIYIY = getESShape(phoESHitsIYIY);

  return sqrt(phoESShapeIXIX*phoESShapeIXIX + phoESShapeIYIY*phoESShapeIYIY);
}

float EcalClusterLazyTools::eseffsixix

(

const reco::SuperCluster &

cluster

)

Definition at line 635 of file EcalClusterLazyTools.cc.

References DetId::Ecal, EcalPreshower, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), CaloGeometry::getSubdetectorGeometry(), rechits_map_, reco::CaloCluster::x(), reco::CaloCluster::y(), and reco::CaloCluster::z().

{
  if (!(fabs(cluster.eta()) > 1.6 && fabs(cluster.eta()) < 3.)) return 0.;

  const CaloSubdetectorGeometry *geometryES = geometry_->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
  CaloSubdetectorTopology *topology_p = 0;
  if (geometryES) topology_p = new EcalPreshowerTopology(geometry_);

  std::vector<float> phoESHitsIXIX = getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, topology_p, 0, 1);
  float phoESShapeIXIX = getESShape(phoESHitsIXIX);

  return phoESShapeIXIX;
}

float EcalClusterLazyTools::eseffsiyiy

(

const reco::SuperCluster &

cluster

)

Definition at line 650 of file EcalClusterLazyTools.cc.

References DetId::Ecal, EcalPreshower, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), CaloGeometry::getSubdetectorGeometry(), rechits_map_, reco::CaloCluster::x(), reco::CaloCluster::y(), and reco::CaloCluster::z().

{
  if (!(fabs(cluster.eta()) > 1.6 && fabs(cluster.eta()) < 3.)) return 0.;

  const CaloSubdetectorGeometry *geometryES = geometry_->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
  CaloSubdetectorTopology *topology_p = 0;
  if (geometryES) topology_p = new EcalPreshowerTopology(geometry_);

  std::vector<float> phoESHitsIYIY = getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, topology_p, 0, 2);
  float phoESShapeIYIY = getESShape(phoESHitsIYIY);

  return phoESShapeIYIY;
}

float EcalClusterLazyTools::eTop

(

const reco::BasicCluster &

cluster

)

Definition at line 374 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eTop(), getEcalRecHitCollection(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), and EGEnergyCorrector::CorrectedEnergyWithErrorV3().

{
        return EcalClusterTools::eTop( cluster, getEcalRecHitCollection(cluster), topology_ );
}

float EcalClusterLazyTools::eTop	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 379 of file EcalClusterLazyTools.cc.

References EcalClusterTools::eTop(), getEcalRecHitCollection(), and topology_.

{
        return EcalClusterTools::eTop( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}

void EcalClusterLazyTools::getADCToGeV ( const edm::EventSetup &  es )

private

Definition at line 162 of file EcalClusterLazyTools.cc.

References agc, and edm::EventSetup::get().

Referenced by EcalClusterLazyTools().

{
  // get ADCtoGeV
  es.get<EcalADCToGeVConstantRcd>().get(agc);
}

void EcalClusterLazyTools::getEBRecHits ( const edm::Event &  ev, const edm::InputTag &  redEBRecHits  )

private

Definition at line 113 of file EcalClusterLazyTools.cc.

References ebRecHits_, edm::Event::getByLabel(), and edm::Handle< T >::product().

Referenced by EcalClusterLazyTools().

{
        edm::Handle< EcalRecHitCollection > pEBRecHits;
        ev.getByLabel( redEBRecHits, pEBRecHits );
        ebRecHits_ = pEBRecHits.product();
}

const EcalRecHitCollection * EcalClusterLazyTools::getEcalRecHitCollection ( const reco::BasicCluster &  cluster )

private

Definition at line 176 of file EcalClusterLazyTools.cc.

References ebRecHits_, EcalBarrel, EcalEndcap, eeRecHits_, edm::hlt::Exception, and first.

Referenced by BasicClusterSeedTime(), BasicClusterTime(), covariances(), e1x3(), e1x5(), e2nd(), e2x2(), e2x5Bottom(), e2x5Left(), e2x5Max(), e2x5Right(), e2x5Top(), e3x1(), e3x2(), e3x3(), e4x4(), e5x1(), e5x5(), eBottom(), eLeft(), eMax(), energyBasketFractionEta(), energyBasketFractionPhi(), eRight(), eTop(), getMaximum(), lat(), localCovariances(), matrixEnergy(), scLocalCovariances(), zernike20(), and zernike42().

{
        if ( cluster.size() == 0 ) {
                throw cms::Exception("InvalidCluster") << "The cluster has no crystals!";
        }
        DetId id = (cluster.hitsAndFractions()[0]).first; // size is by definition > 0 -- FIXME??
        const EcalRecHitCollection *recHits = 0;
        if ( id.subdetId() == EcalBarrel ) {
                recHits = ebRecHits_;
        } else if ( id.subdetId() == EcalEndcap ) {
                recHits = eeRecHits_;
        } else {
                throw cms::Exception("InvalidSubdetector") << "The subdetId() " << id.subdetId() << " does not correspond to EcalBarrel neither EcalEndcap";
        }
        return recHits;
}

void EcalClusterLazyTools::getEERecHits ( const edm::Event &  ev, const edm::InputTag &  redEERecHits  )

private

Definition at line 122 of file EcalClusterLazyTools.cc.

References eeRecHits_, edm::Event::getByLabel(), and edm::Handle< T >::product().

Referenced by EcalClusterLazyTools().

{
        edm::Handle< EcalRecHitCollection > pEERecHits;
        ev.getByLabel( redEERecHits, pEERecHits );
        eeRecHits_ = pEERecHits.product();
}

std::vector< float > EcalClusterLazyTools::getESHits	(	double	X,
		double	Y,
		double	Z,
		const std::map< DetId, EcalRecHit > &	rechits_map,
		const CaloGeometry *	geometry,
		CaloSubdetectorTopology *	topology_p,
		int	row = 0,
		int	plane = 1
	)

Definition at line 665 of file EcalClusterLazyTools.cc.

References DetId::Ecal, EcalPreshower, CaloGeometry::getSubdetectorGeometry(), i, j, GetRecoTauVFromDQM_MC_cff::next, and point.

Referenced by eseffsirir(), eseffsixix(), and eseffsiyiy().

{
  std::map<DetId, EcalRecHit> rechits_map = _rechits_map;
  std::vector<float> esHits;

  const GlobalPoint point(X,Y,Z);

  const CaloSubdetectorGeometry *geometry_p ;
  geometry_p = geometry->getSubdetectorGeometry (DetId::Ecal,EcalPreshower) ;

  DetId esId = (dynamic_cast<const EcalPreshowerGeometry*>(geometry_p))->getClosestCellInPlane(point, plane);
  ESDetId esDetId = (esId == DetId(0)) ? ESDetId(0) : ESDetId(esId);

  std::map<DetId, EcalRecHit>::iterator it;
  ESDetId next;
  ESDetId strip;
  strip = esDetId;

  EcalPreshowerNavigator theESNav(strip, topology_p);
  theESNav.setHome(strip);

  if (row == 1) {
    if (plane==1 && strip != ESDetId(0)) strip = theESNav.north();
    if (plane==2 && strip != ESDetId(0)) strip = theESNav.east();
  } else if (row == -1) {
    if (plane==1 && strip != ESDetId(0)) strip = theESNav.south();
    if (plane==2 && strip != ESDetId(0)) strip = theESNav.west();
  }


  if (strip == ESDetId(0)) {
    for (int i=0; i<31; ++i) esHits.push_back(0);
  } else {
    it = rechits_map.find(strip);
    if (it->second.energy() > 1.0e-10 && it != rechits_map.end()) esHits.push_back(it->second.energy());
    else esHits.push_back(0);
    //cout<<"center : "<<strip<<" "<<it->second.energy()<<endl;

    // Front Plane
    if (plane==1) {
      // east road
      for (int i=0; i<15; ++i) {
        next = theESNav.east();
        if (next != ESDetId(0)) {
          it = rechits_map.find(next);
          if (it->second.energy() > 1.0e-10 && it != rechits_map.end()) esHits.push_back(it->second.energy());
          else esHits.push_back(0);
          //cout<<"east "<<i<<" : "<<next<<" "<<it->second.energy()<<endl;
        } else {
          for (int j=i; j<15; j++) esHits.push_back(0);
          break;
          //cout<<"east "<<i<<" : "<<next<<" "<<0<<endl;
        }
      }

      // west road
      theESNav.setHome(strip);
      theESNav.home();
      for (int i=0; i<15; ++i) {
        next = theESNav.west();
        if (next != ESDetId(0)) {
          it = rechits_map.find(next);
          if (it->second.energy() > 1.0e-10 && it != rechits_map.end()) esHits.push_back(it->second.energy());
          else esHits.push_back(0);
          //cout<<"west "<<i<<" : "<<next<<" "<<it->second.energy()<<endl;
        } else {
          for (int j=i; j<15; j++) esHits.push_back(0);
          break;
          //cout<<"west "<<i<<" : "<<next<<" "<<0<<endl;
        }
      }
    } // End of Front Plane

    // Rear Plane
    if (plane==2) {
      // north road
      for (int i=0; i<15; ++i) {
        next = theESNav.north();
        if (next != ESDetId(0)) {
          it = rechits_map.find(next);
          if (it->second.energy() > 1.0e-10 && it != rechits_map.end()) esHits.push_back(it->second.energy());
          else esHits.push_back(0);
          //cout<<"north "<<i<<" : "<<next<<" "<<it->second.energy()<<endl;
        } else {
          for (int j=i; j<15; j++) esHits.push_back(0);
          break;
          //cout<<"north "<<i<<" : "<<next<<" "<<0<<endl;
        }
      }

      // south road
      theESNav.setHome(strip);
      theESNav.home();
      for (int i=0; i<15; ++i) {
        next = theESNav.south();
        if (next != ESDetId(0)) {
          it = rechits_map.find(next);
          if (it->second.energy() > 1.0e-10 && it != rechits_map.end()) esHits.push_back(it->second.energy());
          else esHits.push_back(0);
          //cout<<"south "<<i<<" : "<<next<<" "<<it->second.energy()<<endl;
        } else {
          for (int j=i; j<15; j++) esHits.push_back(0);
          break;
          //cout<<"south "<<i<<" : "<<next<<" "<<0<<endl;
        }
      }
    } // End of Rear Plane
  } // Fill ES RecHits

  return esHits;
}

void EcalClusterLazyTools::getESRecHits ( const edm::Event &  ev, const edm::InputTag &  redESRecHits  )

private

Definition at line 131 of file EcalClusterLazyTools.cc.

References esRecHits_, edm::Event::getByLabel(), edm::HandleBase::isValid(), edm::Handle< T >::product(), and rechits_map_.

Referenced by EcalClusterLazyTools().

{
        edm::Handle< EcalRecHitCollection > pESRecHits;
        ev.getByLabel( redESRecHits, pESRecHits );
        esRecHits_ = pESRecHits.product();

        // make the map of rechits
        rechits_map_.clear();
        if (pESRecHits.isValid()) {
          EcalRecHitCollection::const_iterator it;
          for (it = pESRecHits->begin(); it != pESRecHits->end(); ++it) {
            // remove bad ES rechits
            if (it->recoFlag()==1 || it->recoFlag()==14 || (it->recoFlag()<=10 && it->recoFlag()>=5)) continue;
            //Make the map of DetID, EcalRecHit pairs
            rechits_map_.insert(std::make_pair(it->id(), *it));
          }
        }

}

float EcalClusterLazyTools::getESShape

(

const std::vector< float > &

ESHits0

)

Definition at line 779 of file EcalClusterLazyTools.cc.

References customizeTrackingMonitorSeedNumber::idx, and mathSSE::sqrt().

Referenced by eseffsirir(), eseffsixix(), and eseffsiyiy().

{
  const int nBIN = 21;
  float esRH[nBIN];
  for (int idx=0; idx<nBIN; idx++) {
    esRH[idx] = 0.;
  }

  for(int ibin=0; ibin<((nBIN+1)/2); ibin++) {
    if (ibin==0) {
      esRH[(nBIN-1)/2] = ESHits0[ibin];
    } else {
      esRH[(nBIN-1)/2+ibin] = ESHits0[ibin];
      esRH[(nBIN-1)/2-ibin] = ESHits0[ibin+15];
    }
  }

  // ---- Effective Energy Deposit Width ---- //
  double EffWidthSigmaISIS = 0.;
  double totalEnergyISIS   = 0.;
  double EffStatsISIS      = 0.;
  for (int id_X=0; id_X<21; id_X++) {
    totalEnergyISIS  += esRH[id_X];
    EffStatsISIS     += esRH[id_X]*(id_X-10)*(id_X-10);
  }
  EffWidthSigmaISIS  = (totalEnergyISIS>0.)  ? sqrt(fabs(EffStatsISIS  / totalEnergyISIS))   : 0.;

  return EffWidthSigmaISIS;
}

void EcalClusterLazyTools::getGeometry ( const edm::EventSetup &  es )

private

Definition at line 95 of file EcalClusterLazyTools.cc.

References geometry_, edm::EventSetup::get(), and edm::ESHandle< class >::product().

Referenced by EcalClusterLazyTools().

{
        edm::ESHandle<CaloGeometry> pGeometry;
        es.get<CaloGeometryRecord>().get(pGeometry);
        geometry_ = pGeometry.product();
}

void EcalClusterLazyTools::getIntercalibConstants ( const edm::EventSetup &  es )

private

Definition at line 153 of file EcalClusterLazyTools.cc.

References edm::EventSetup::get(), ical, and icalMap.

Referenced by EcalClusterLazyTools().

{
  // get IC's
  es.get<EcalIntercalibConstantsRcd>().get(ical);
  icalMap = ical->getMap();
}

void EcalClusterLazyTools::getLaserDbService ( const edm::EventSetup &  es )

private

Definition at line 170 of file EcalClusterLazyTools.cc.

References edm::EventSetup::get(), and laser.

Referenced by EcalClusterLazyTools().

                                                                          {
  // transp corrections
  es.get<EcalLaserDbRecord>().get(laser);
}

std::pair< DetId, float > EcalClusterLazyTools::getMaximum

(

const reco::BasicCluster &

cluster

)

Definition at line 417 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and EcalClusterTools::getMaximum().

Referenced by pat::PATPhotonProducer::produce(), HiSpikeCleaner::produce(), and pat::PATElectronProducer::produce().

{
        return EcalClusterTools::getMaximum( cluster, getEcalRecHitCollection(cluster) );
}

std::pair< DetId, float > EcalClusterLazyTools::getMaximum	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 422 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and EcalClusterTools::getMaximum().

{
        return EcalClusterTools::getMaximum( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}

void EcalClusterLazyTools::getTopology ( const edm::EventSetup &  es )

private

Definition at line 104 of file EcalClusterLazyTools.cc.

References edm::EventSetup::get(), edm::ESHandle< class >::product(), and topology_.

Referenced by EcalClusterLazyTools().

{
        edm::ESHandle<CaloTopology> pTopology;
        es.get<CaloTopologyRecord>().get(pTopology);
        topology_ = pTopology.product();
}

std::vector< float > EcalClusterLazyTools::lat	(	const reco::BasicCluster &	cluster,
		bool	logW = true,
		float	w0 = 4.7
	)

Definition at line 450 of file EcalClusterLazyTools.cc.

References geometry_, getEcalRecHitCollection(), and EcalClusterTools::lat().

{
        return EcalClusterTools::lat( cluster, getEcalRecHitCollection(cluster), geometry_, logW, w0 );
}

std::vector<float> EcalClusterLazyTools::lat	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv,
		bool	logW = true,
		float	w0 = 4.7
	)

std::vector< float > EcalClusterLazyTools::localCovariances	(	const reco::BasicCluster &	cluster,
		float	w0 = 4.7
	)

Definition at line 471 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::localCovariances(), and topology_.

Referenced by EGEnergyCorrector::CorrectedEnergyWithError(), EGEnergyCorrector::CorrectedEnergyWithErrorV3(), ElectronLikelihood::getInputVar(), EGammaMvaEleEstimator::IDIsoCombinedMvaValue(), HLTEgamma::MakeL1IsolatedElectrons(), HLTEgamma::MakeL1IsolatedPhotons(), HLTEgamma::MakeL1NonIsolatedElectrons(), HLTEgamma::MakeL1NonIsolatedPhotons(), EGammaMvaEleEstimator::mvaValue(), EgammaHLTClusterShapeProducer::produce(), pat::PATElectronProducer::produce(), and PTDRElectronID::result().

{
        return EcalClusterTools::localCovariances( cluster, getEcalRecHitCollection(cluster), topology_, w0 );
}

std::vector< float > EcalClusterLazyTools::localCovariances	(	const reco::BasicCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv,
		float	w0 = 4.7
	)

Definition at line 476 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::localCovariances(), and topology_.

{
        return EcalClusterTools::localCovariances( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv, w0 );
}

std::vector< DetId > EcalClusterLazyTools::matrixDetId	(	DetId	id,
		int	ixMin,
		int	ixMax,
		int	iyMin,
		int	iyMax
	)

Definition at line 502 of file EcalClusterLazyTools.cc.

References EcalClusterTools::matrixDetId(), and topology_.

{
        return EcalClusterTools::matrixDetId( topology_, id, ixMin, ixMax, iyMin, iyMax );
}

float EcalClusterLazyTools::matrixEnergy	(	const reco::BasicCluster &	cluster,
		DetId	id,
		int	ixMin,
		int	ixMax,
		int	iyMin,
		int	iyMax
	)

Definition at line 507 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::matrixEnergy(), and topology_.

{
  return EcalClusterTools::matrixEnergy( cluster, getEcalRecHitCollection(cluster), topology_, id, ixMin, ixMax, iyMin, iyMax );
}

float EcalClusterLazyTools::matrixEnergy	(	const reco::BasicCluster &	cluster,
		DetId	id,
		int	ixMin,
		int	ixMax,
		int	iyMin,
		int	iyMax,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv
	)

Definition at line 512 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::matrixEnergy(), and topology_.

{
  return EcalClusterTools::matrixEnergy( cluster, getEcalRecHitCollection(cluster), topology_, id, ixMin, ixMax, iyMin, iyMax, flagsexcl, severitiesexcl, sevLv );
}

std::vector< float > EcalClusterLazyTools::scLocalCovariances	(	const reco::SuperCluster &	cluster,
		float	w0 = 4.7
	)

Definition at line 481 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::scLocalCovariances(), and topology_.

{
        return EcalClusterTools::scLocalCovariances( cluster, getEcalRecHitCollection(cluster), topology_, w0 );
}

std::vector< float > EcalClusterLazyTools::scLocalCovariances	(	const reco::SuperCluster &	cluster,
		const std::vector< int > &	flagsexcl,
		const std::vector< int > &	severitiesexcl,
		const EcalSeverityLevelAlgo *	sevLv,
		float	w0 = 4.7
	)

Definition at line 486 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), EcalClusterTools::scLocalCovariances(), and topology_.

{
        return EcalClusterTools::scLocalCovariances( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv, w0 );
}

float EcalClusterLazyTools::SuperClusterSeedTime

(

const reco::SuperCluster &

cluster

)

Definition at line 602 of file EcalClusterLazyTools.cc.

References BasicClusterSeedTime(), and reco::SuperCluster::seed().

                                                                               {

  return BasicClusterSeedTime ( (*cluster.seed()) );

}

float EcalClusterLazyTools::SuperClusterTime	(	const reco::SuperCluster &	cluster,
		const edm::Event &	ev
	)

Definition at line 610 of file EcalClusterLazyTools.cc.

References BasicClusterTime(), and reco::SuperCluster::seed().

                                                                                               {
  
  return BasicClusterTime ( (*cluster.seed()) , ev);

}

double EcalClusterLazyTools::zernike20	(	const reco::BasicCluster &	cluster,
		double	R0 = 6.6,
		bool	logW = true,
		float	w0 = 4.7
	)

Definition at line 491 of file EcalClusterLazyTools.cc.

References geometry_, getEcalRecHitCollection(), and EcalClusterTools::zernike20().

{
        return EcalClusterTools::zernike20( cluster, getEcalRecHitCollection(cluster), geometry_, R0, logW, w0 );
}

double EcalClusterLazyTools::zernike42	(	const reco::BasicCluster &	cluster,
		double	R0 = 6.6,
		bool	logW = true,
		float	w0 = 4.7
	)

Definition at line 497 of file EcalClusterLazyTools.cc.

References geometry_, getEcalRecHitCollection(), and EcalClusterTools::zernike42().

{
        return EcalClusterTools::zernike42( cluster, getEcalRecHitCollection(cluster), geometry_, R0, logW, w0 );
}

Member Data Documentation

edm::ESHandle<EcalADCToGeVConstant> EcalClusterLazyTools::agc

private

Definition at line 196 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and getADCToGeV().

const EcalRecHitCollection* EcalClusterLazyTools::ebRecHits_

private

Definition at line 189 of file EcalClusterLazyTools.h.

Referenced by getEBRecHits(), and getEcalRecHitCollection().

const EcalRecHitCollection* EcalClusterLazyTools::eeRecHits_

private

Definition at line 190 of file EcalClusterLazyTools.h.

Referenced by getEcalRecHitCollection(), and getEERecHits().

const EcalRecHitCollection* EcalClusterLazyTools::esRecHits_

private

Definition at line 191 of file EcalClusterLazyTools.h.

Referenced by getESRecHits().

const CaloGeometry* EcalClusterLazyTools::geometry_

private

Definition at line 187 of file EcalClusterLazyTools.h.

Referenced by covariances(), eseffsirir(), eseffsixix(), eseffsiyiy(), getGeometry(), lat(), zernike20(), and zernike42().

edm::ESHandle<EcalIntercalibConstants> EcalClusterLazyTools::ical

private

Definition at line 194 of file EcalClusterLazyTools.h.

Referenced by getIntercalibConstants().

EcalIntercalibConstantMap EcalClusterLazyTools::icalMap

private

Definition at line 195 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and getIntercalibConstants().

edm::ESHandle<EcalLaserDbService> EcalClusterLazyTools::laser

private

Definition at line 197 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and getLaserDbService().

std::map<DetId, EcalRecHit> EcalClusterLazyTools::rechits_map_

Definition at line 165 of file EcalClusterLazyTools.h.

Referenced by eseffsirir(), eseffsixix(), eseffsiyiy(), and getESRecHits().

const CaloTopology* EcalClusterLazyTools::topology_

private

Definition at line 188 of file EcalClusterLazyTools.h.

Referenced by covariances(), e1x3(), e1x5(), e2x2(), e2x5Bottom(), e2x5Left(), e2x5Max(), e2x5Right(), e2x5Top(), e3x1(), e3x2(), e3x3(), e4x4(), e5x1(), e5x5(), eBottom(), eLeft(), eRight(), eTop(), getTopology(), localCovariances(), matrixDetId(), matrixEnergy(), and scLocalCovariances().