#include <EcalClusterLazyTools.h>

Inheritance diagram for EcalClusterLazyToolsBase:

Public Member Functions
float	BasicClusterSeedTime (const reco::BasicCluster &cluster)

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

	EcalClusterLazyToolsBase (const edm::Event &ev, const edm::EventSetup &es, edm::EDGetTokenT< EcalRecHitCollection > token1, edm::EDGetTokenT< EcalRecHitCollection > token2)

float	eseffsirir (const reco::SuperCluster &cluster)

float	eseffsixix (const reco::SuperCluster &cluster)

float	eseffsiyiy (const reco::SuperCluster &cluster)

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)

float	SuperClusterSeedTime (const reco::SuperCluster &cluster)

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

	~EcalClusterLazyToolsBase ()

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

Protected Member Functions
void	getADCToGeV (const edm::EventSetup &es)

void	getEBRecHits (const edm::Event &ev)

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

void	getEERecHits (const edm::Event &ev)

void	getESRecHits (const edm::Event &ev)

void	getGeometry (const edm::EventSetup &es)

void	getIntercalibConstants (const edm::EventSetup &es)

void	getLaserDbService (const edm::EventSetup &es)

void	getTopology (const edm::EventSetup &es)

Protected Attributes
edm::ESHandle < EcalADCToGeVConstant >	agc

const EcalRecHitCollection *	ebRecHits_

edm::EDGetTokenT < EcalRecHitCollection >	ebRHToken_

const EcalRecHitCollection *	eeRecHits_

edm::EDGetTokenT < EcalRecHitCollection >	eeRHToken_

const EcalRecHitCollection *	esRecHits_

edm::EDGetTokenT < EcalRecHitCollection >	esRHToken_

const CaloGeometry *	geometry_

edm::ESHandle < EcalIntercalibConstants >	ical

EcalIntercalibConstantMap	icalMap

edm::ESHandle< EcalLaserDbService >	laser

const CaloTopology *	topology_

Detailed Description

Definition at line 34 of file EcalClusterLazyTools.h.

Constructor & Destructor Documentation

EcalClusterLazyToolsBase::EcalClusterLazyToolsBase	(	const edm::Event &	ev,
		const edm::EventSetup &	es,
		edm::EDGetTokenT< EcalRecHitCollection >	token1,
		edm::EDGetTokenT< EcalRecHitCollection >	token2
	)

Definition at line 25 of file EcalClusterLazyTools.cc.

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

                                                                                                                                                                                          {
 
   ebRHToken_ = token1;
   eeRHToken_ = token2;
 
   getGeometry( es );
   getTopology( es );
   getEBRecHits( ev );
   getEERecHits( ev );
   getIntercalibConstants( es );
   getADCToGeV ( es );
   getLaserDbService ( es );
 }

EcalClusterLazyToolsBase::~EcalClusterLazyToolsBase ( )

Definition at line 39 of file EcalClusterLazyTools.cc.

40 {}

Member Function Documentation

float EcalClusterLazyToolsBase::BasicClusterSeedTime ( const reco::BasicCluster & cluster )

Definition at line 140 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 EcalClusterLazyToolsBase::BasicClusterTime	(	const reco::BasicCluster &	cluster,
		const edm::Event &	ev
	)

Definition at line 157 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);
 
 }

float EcalClusterLazyToolsBase::eseffsirir ( const reco::SuperCluster & cluster )

Definition at line 239 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 EcalClusterLazyToolsBase::eseffsixix ( const reco::SuperCluster & cluster )

Definition at line 256 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 EcalClusterLazyToolsBase::eseffsiyiy ( const reco::SuperCluster & cluster )

Definition at line 271 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;
 }

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

protected

Definition at line 107 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

void EcalClusterLazyToolsBase::getEBRecHits ( const edm::Event & ev )

protected

Definition at line 54 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

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

protected

Definition at line 121 of file EcalClusterLazyTools.cc.

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

Referenced by BasicClusterSeedTime(), and BasicClusterTime().

 {
         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 EcalClusterLazyToolsBase::getEERecHits ( const edm::Event & ev )

protected

Definition at line 60 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

std::vector< float > EcalClusterLazyToolsBase::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 286 of file EcalClusterLazyTools.cc.

References CaloNavigator< T, TOPO >::east(), DetId::Ecal, EcalPreshower, CaloGeometry::getSubdetectorGeometry(), CaloNavigator< T, TOPO >::home(), i, j, GetRecoTauVFromDQM_MC_cff::next, CaloNavigator< T, TOPO >::north(), point, CaloNavigator< T, TOPO >::setHome(), CaloNavigator< T, TOPO >::south(), and CaloNavigator< T, TOPO >::west().

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 EcalClusterLazyToolsBase::getESRecHits ( const edm::Event & ev )

protected

Definition at line 66 of file EcalClusterLazyTools.cc.

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

                                                                 {
   edm::Handle< EcalRecHitCollection > pESRecHits;
   ev.getByToken( esRHToken_, 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
     std::vector<int> badf = {
       EcalRecHit::ESFlags::kESDead, // 1
       EcalRecHit::ESFlags::kESTwoGoodRatios,
       EcalRecHit::ESFlags::kESBadRatioFor12, // 5
       EcalRecHit::ESFlags::kESBadRatioFor23Upper,
       EcalRecHit::ESFlags::kESBadRatioFor23Lower,
       EcalRecHit::ESFlags::kESTS1Largest,
       EcalRecHit::ESFlags::kESTS3Largest,
       EcalRecHit::ESFlags::kESTS3Negative, // 10
       EcalRecHit::ESFlags::kESTS13Sigmas, // 14
     };
     
     if (it->checkFlags(badf)) continue;
 
       //Make the map of DetID, EcalRecHit pairs
       rechits_map_.insert(std::make_pair(it->id(), *it));
     }
   }
 }

float EcalClusterLazyToolsBase::getESShape ( const std::vector< float > & ESHits0 )

Definition at line 400 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 EcalClusterLazyToolsBase::getGeometry ( const edm::EventSetup & es )

protected

Definition at line 42 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

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

protected

Definition at line 98 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

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

protected

Definition at line 115 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

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

protected

Definition at line 48 of file EcalClusterLazyTools.cc.

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

Referenced by EcalClusterLazyToolsBase().

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

float EcalClusterLazyToolsBase::SuperClusterSeedTime ( const reco::SuperCluster & cluster )

Definition at line 223 of file EcalClusterLazyTools.cc.

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

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

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

Definition at line 231 of file EcalClusterLazyTools.cc.

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

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