CMS 3D CMS Logo
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes

EcalClusterLazyTools Class Reference

#include <EcalClusterLazyTools.h>

List of all members.

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, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
float e1x3 (const reco::BasicCluster &cluster)
float e1x3 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e1x5 (const reco::BasicCluster &cluster)
float e1x5 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2nd (const reco::BasicCluster &cluster)
float e2nd (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x2 (const reco::BasicCluster &cluster)
float e2x2 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x5Bottom (const reco::BasicCluster &cluster)
float e2x5Bottom (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x5Left (const reco::BasicCluster &cluster)
float e2x5Left (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x5Max (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x5Max (const reco::BasicCluster &cluster)
float e2x5Right (const reco::BasicCluster &cluster)
float e2x5Right (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e2x5Top (const reco::BasicCluster &cluster)
float e2x5Top (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e3x1 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e3x1 (const reco::BasicCluster &cluster)
float e3x2 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e3x2 (const reco::BasicCluster &cluster)
float e3x3 (const reco::BasicCluster &cluster)
float e3x3 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e4x4 (const reco::BasicCluster &cluster)
float e4x4 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e5x1 (const reco::BasicCluster &cluster)
float e5x1 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float e5x5 (const reco::BasicCluster &cluster)
float e5x5 (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float eBottom (const reco::BasicCluster &cluster)
float eBottom (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
 EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, edm::InputTag redEBRecHits, edm::InputTag redEERecHits, const edm::ParameterSet &config)
 EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, edm::InputTag redEBRecHits, edm::InputTag redEERecHits)
 EcalClusterLazyTools (const edm::Event &ev, const edm::EventSetup &es, edm::InputTag redEBRecHits, edm::InputTag redEERecHits, edm::InputTag redESRecHits)
float eLeft (const reco::BasicCluster &cluster)
float eLeft (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float eMax (const reco::BasicCluster &cluster)
float eMax (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float > energyBasketFractionEta (const reco::BasicCluster &cluster)
std::vector< float > energyBasketFractionEta (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
std::vector< float > energyBasketFractionPhi (const reco::BasicCluster &cluster)
std::vector< float > energyBasketFractionPhi (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float eRight (const reco::BasicCluster &cluster)
float eRight (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, 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, std::vector< int > flagsexcl, std::vector< int > severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
float eTop (const reco::BasicCluster &cluster)
std::vector< float > getESHits (double X, double Y, double Z, std::map< DetId, EcalRecHit > rechits_map, const CaloGeometry *geometry, CaloSubdetectorTopology *topology_p, int row=0, int plane=1)
float getESShape (std::vector< float > ESHits0)
std::pair< DetId, float > getMaximum (const reco::BasicCluster &cluster)
std::pair< DetId, float > getMaximum (const reco::BasicCluster &cluster, std::vector< int > flagsexcl, 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, std::vector< int > flagsexcl, 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, std::vector< int > flagsexcl, 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, std::vector< int > flagsexcl, 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, std::vector< int > flagsexcl, 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, edm::InputTag redEBRecHits)
const EcalRecHitCollection * getEcalRecHitCollection (const reco::BasicCluster &cluster)
void getEERecHits (const edm::Event &ev, edm::InputTag redEERecHits)
void getESRecHits (const edm::Event &ev, 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,
edm::InputTag  redEBRecHits,
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,
edm::InputTag  redEBRecHits,
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,
edm::InputTag  redEBRecHits,
edm::InputTag  redEERecHits,
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(), edm::SortedCollection< T, SORT >::find(), EcalCondObjectContainer< T >::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 geometry_, getEcalRecHitCollection(), and topology_.

Referenced by covariances(), SoftElectronProducer::produce(), and EgammaHLTClusterShapeProducer::produce().

{
        return EcalClusterTools::covariances( cluster, getEcalRecHitCollection(cluster), topology_, geometry_, w0 );
}
std::vector< float > EcalClusterLazyTools::covariances ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv,
float  w0 = 4.7 
)

Definition at line 466 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::covariances( cluster, getEcalRecHitCollection(cluster), topology_, geometry_, flagsexcl, severitiesexcl, sevLv, w0 );
}
float EcalClusterLazyTools::e1x3 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 201 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::e1x3( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::e1x3 ( const reco::BasicCluster &  cluster)

Definition at line 195 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e1x3().

{
        return EcalClusterTools::e1x3( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e1x5 ( const reco::BasicCluster &  cluster)

Definition at line 219 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e1x5().

{
        return EcalClusterTools::e1x5( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e1x5 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 224 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection().

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

{
        return EcalClusterTools::e2nd( cluster, getEcalRecHitCollection(cluster) );
}
float EcalClusterLazyTools::e2nd ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 412 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x2(), and SoftElectronProducer::produce().

{
        return EcalClusterTools::e2x2( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x2 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 247 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x5Bottom().

{
        return EcalClusterTools::e2x5Bottom( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x5Bottom ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 335 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x5Left().

{
        return EcalClusterTools::e2x5Left( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x5Left ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 313 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x5Max().

{
        return EcalClusterTools::e2x5Max( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x5Max ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 346 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x5Right().

{
        return EcalClusterTools::e2x5Right( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x5Right ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 302 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by e2x5Top().

{
        return EcalClusterTools::e2x5Top( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e2x5Top ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 324 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::e2x5Top( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::e3x1 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 213 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::e3x1( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::e3x1 ( const reco::BasicCluster &  cluster)

Definition at line 208 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e3x1().

{
        return EcalClusterTools::e3x1( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e3x2 ( const reco::BasicCluster &  cluster)

Definition at line 253 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e3x2().

{
        return EcalClusterTools::e3x2( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e3x2 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 258 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

Referenced by EgammaSuperClusters::analyze(), EGEnergyCorrector::CorrectedEnergyWithError(), e3x3(), pat::PATElectronProducer::produce(), SoftElectronProducer::produce(), EgammaHLTR9IDProducer::produce(), EgammaHLTR9Producer::produce(), PTDRElectronID::result(), and FourVectorHLTOffline::selectElectrons().

{
        return EcalClusterTools::e3x3( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e3x3 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 269 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::e3x3( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::e4x4 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 280 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::e4x4( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::e4x4 ( const reco::BasicCluster &  cluster)

Definition at line 275 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e4x4().

{
        return EcalClusterTools::e4x4( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e5x1 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 236 of file EcalClusterLazyTools.cc.

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

{
  return EcalClusterTools::e5x1( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
        }
float EcalClusterLazyTools::e5x1 ( const reco::BasicCluster &  cluster)

Definition at line 231 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by e5x1().

{
  return EcalClusterTools::e5x1( cluster, getEcalRecHitCollection(cluster), topology_ );
        }
float EcalClusterLazyTools::e5x5 ( const reco::BasicCluster &  cluster)

Definition at line 286 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by EgammaSuperClusters::analyze(), EGEnergyCorrector::CorrectedEnergyWithError(), e5x5(), SoftElectronProducer::produce(), and PTDRElectronID::result().

{
        return EcalClusterTools::e5x5( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::e5x5 ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 291 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

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

{
        return EcalClusterTools::eBottom( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::eBottom ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 390 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection(), and topology_.

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

{
        return EcalClusterTools::eLeft( cluster, getEcalRecHitCollection(cluster), topology_ );
}
float EcalClusterLazyTools::eLeft ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 357 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection().

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

{
        return EcalClusterTools::eMax( cluster, getEcalRecHitCollection(cluster) );
}
float EcalClusterLazyTools::eMax ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 401 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection().

Referenced by energyBasketFractionEta().

{
        return EcalClusterTools::energyBasketFractionEta( cluster, getEcalRecHitCollection(cluster) );
}
std::vector< float > EcalClusterLazyTools::energyBasketFractionEta ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 433 of file EcalClusterLazyTools.cc.

References 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 getEcalRecHitCollection().

Referenced by energyBasketFractionPhi().

{
        return EcalClusterTools::energyBasketFractionPhi( cluster, getEcalRecHitCollection(cluster) );
}
std::vector< float > EcalClusterLazyTools::energyBasketFractionPhi ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 444 of file EcalClusterLazyTools.cc.

References energyBasketFractionPhi(), and getEcalRecHitCollection().

{
        return EcalClusterTools::energyBasketFractionPhi( cluster, getEcalRecHitCollection(cluster), flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::eRight ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 368 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::eRight( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::eRight ( const reco::BasicCluster &  cluster)

Definition at line 363 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

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

{
        return EcalClusterTools::eRight( cluster, getEcalRecHitCollection(cluster), topology_ );
}
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,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 379 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::eTop( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv );
}
float EcalClusterLazyTools::eTop ( const reco::BasicCluster &  cluster)

Definition at line 374 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

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

{
        return EcalClusterTools::eTop( cluster, getEcalRecHitCollection(cluster), topology_ );
}
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,
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_, 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,
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,
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 CaloNavigator< T >::east(), DetId::Ecal, EcalPreshower, CaloGeometry::getSubdetectorGeometry(), CaloNavigator< T >::home(), i, j, CaloNavigator< T >::north(), point, CaloNavigator< T >::setHome(), CaloNavigator< T >::south(), strip(), and CaloNavigator< T >::west().

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

{
  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,
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 ( std::vector< float >  ESHits0)

Definition at line 778 of file EcalClusterLazyTools.cc.

References UserOptions_cff::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< T >::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().

Referenced by QcdPhotonsDQM::analyze(), getMaximum(), EcalDigiSelector::produce(), and HiSpikeCleaner::produce().

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

Definition at line 422 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and 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< T >::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,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv,
bool  logW = true,
float  w0 = 4.7 
)
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_, and getEcalRecHitCollection().

{
        return EcalClusterTools::lat( cluster, getEcalRecHitCollection(cluster), geometry_, logW, w0 );
}
std::vector< float > EcalClusterLazyTools::localCovariances ( const reco::BasicCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv,
float  w0 = 4.7 
)

Definition at line 476 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::localCovariances( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv, w0 );
}
std::vector< float > EcalClusterLazyTools::localCovariances ( const reco::BasicCluster &  cluster,
float  w0 = 4.7 
)

Definition at line 471 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

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

{
        return EcalClusterTools::localCovariances( cluster, getEcalRecHitCollection(cluster), topology_, 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 topology_.

Referenced by EcalDigiSelector::produce().

{
        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,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv 
)

Definition at line 512 of file EcalClusterLazyTools.cc.

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

{
  return EcalClusterTools::matrixEnergy( cluster, getEcalRecHitCollection(cluster), topology_, id, ixMin, ixMax, iyMin, iyMax, flagsexcl, severitiesexcl, sevLv );
}
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(), and topology_.

Referenced by matrixEnergy().

{
  return EcalClusterTools::matrixEnergy( cluster, getEcalRecHitCollection(cluster), topology_, id, ixMin, ixMax, iyMin, iyMax );
}
std::vector< float > EcalClusterLazyTools::scLocalCovariances ( const reco::SuperCluster &  cluster,
std::vector< int >  flagsexcl,
std::vector< int >  severitiesexcl,
const EcalSeverityLevelAlgo *  sevLv,
float  w0 = 4.7 
)

Definition at line 486 of file EcalClusterLazyTools.cc.

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

{
        return EcalClusterTools::scLocalCovariances( cluster, getEcalRecHitCollection(cluster), topology_, flagsexcl, severitiesexcl, sevLv, w0 );
}
std::vector< float > EcalClusterLazyTools::scLocalCovariances ( const reco::SuperCluster &  cluster,
float  w0 = 4.7 
)

Definition at line 481 of file EcalClusterLazyTools.cc.

References getEcalRecHitCollection(), and topology_.

Referenced by scLocalCovariances().

{
        return EcalClusterTools::scLocalCovariances( cluster, getEcalRecHitCollection(cluster), topology_, 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_, and getEcalRecHitCollection().

{
        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_, and getEcalRecHitCollection().

{
        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().

Generated for CMSSW Reference Manual by doxygen 1.7.3