#include <EcalClusterLazyTools.h>

Inheritance diagram for EcalClusterLazyToolsBase:

Classes
struct	ESData

class	ESGetTokens

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

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

	EcalClusterLazyToolsBase (const edm::Event &ev, ESData const &esData, edm::EDGetTokenT< EcalRecHitCollection > token1, edm::EDGetTokenT< EcalRecHitCollection > token2, std::optional< edm::EDGetTokenT< EcalRecHitCollection >> token3)

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

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

Protected Member Functions
EcalRecHitCollection const *	getEcalRecHitCollection (const reco::BasicCluster &cluster) const

Protected Attributes
EcalADCToGeVConstant const *	agc = nullptr

const EcalRecHitCollection *	ebRecHits_

std::unique_ptr < CaloSubdetectorTopology const >	ecalPS_topology_ = nullptr

const EcalRecHitCollection *	eeRecHits_

const EcalRecHitCollection *	esRecHits_

const CaloGeometry *	geometry_

EcalIntercalibConstants const *	ical = nullptr

EcalIntercalibConstantMap const *	icalMap = nullptr

EcalLaserDbService const *	laser = nullptr

const CaloTopology *	topology_

Private Member Functions
void	getESRecHits (const edm::Event &ev, edm::EDGetTokenT< EcalRecHitCollection > const &esRecHitsToken)

Detailed Description

Definition at line 45 of file EcalClusterLazyTools.h.

Constructor & Destructor Documentation

EcalClusterLazyToolsBase::EcalClusterLazyToolsBase	(	const edm::Event &	ev,
		ESData const &	esData,
		edm::EDGetTokenT< EcalRecHitCollection >	token1,
		edm::EDGetTokenT< EcalRecHitCollection >	token2,
		std::optional< edm::EDGetTokenT< EcalRecHitCollection >>	token3
	)

Definition at line 18 of file EcalClusterLazyTools.cc.

References agc, DetId::Ecal, EcalClusterLazyToolsBase::ESData::ecalADCToGeV, EcalClusterLazyToolsBase::ESData::ecalIntercalibConstants, EcalClusterLazyToolsBase::ESData::ecalLaserDbService, EcalPreshower, ecalPS_topology_, geometry_, getESRecHits(), EcalCondObjectContainer< T >::getMap(), CaloGeometry::getSubdetectorGeometry(), ical, icalMap, and laser.

     : geometry_(&esData.caloGeometry),
       topology_(&esData.caloTopology),
       ebRecHits_(&edm::get(ev, token1)),
       eeRecHits_(&edm::get(ev, token2)) {
   if (token3) {
     if (geometry_->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)) {
       ecalPS_topology_ = std::make_unique<EcalPreshowerTopology>();
     } else {
       edm::LogInfo("subdetector geometry not available") << "EcalPreshower geometry is missing" << std::endl;
     }
 
     getESRecHits(ev, *token3);
   }
 
   // get IC's
   ical = &esData.ecalIntercalibConstants;
   icalMap = &ical->getMap();
   // get ADCtoGeV
   agc = &esData.ecalADCToGeV;
   // transp corrections
   laser = &esData.ecalLaserDbService;
 }

Member Function Documentation

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

Definition at line 94 of file EcalClusterLazyTools.cc.

References edm::SortedCollection< T, SORT >::find(), getEcalRecHitCollection(), HLT_FULL_cff::recHits, and reco::CaloCluster::seed().

Referenced by SuperClusterSeedTime().

                                                                                     {
   const EcalRecHitCollection *recHits = getEcalRecHitCollection(cluster);
 
   DetId id = cluster.seed();
   auto 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 108 of file EcalClusterLazyTools.cc.

References gpuClustering::adc, agc, cms::cuda::assert(), EcalBarrel, EcalEndcap, EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), edm::SortedCollection< T, SORT >::find(), EcalADCToGeVConstant::getEBValue(), getEcalRecHitCollection(), EcalADCToGeVConstant::getEEValue(), EcalLaserDbService::getLaserCorrection(), icalMap, laser, HLT_FULL_cff::recHits, mathSSE::sqrt(), and edm::EventBase::time().

Referenced by SuperClusterTime().

                                                                                                     {
   auto 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 (auto detitr = clusterComponents.begin(); detitr != clusterComponents.end(); detitr++) {
     //      EcalRecHitCollection::const_iterator theSeedHit = recHits->find (id); // trash this
     auto 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
     auto 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(false);
     }
     // 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 183 of file EcalClusterLazyTools.cc.

References ecalPS_topology_, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), 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.;
 
   if (!ecalPS_topology_)
     return 0.;
 
   std::vector<float> phoESHitsIXIX =
       getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, ecalPS_topology_.get(), 0, 1);
   std::vector<float> phoESHitsIYIY =
       getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, ecalPS_topology_.get(), 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 201 of file EcalClusterLazyTools.cc.

References ecalPS_topology_, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), rechits_map_, reco::CaloCluster::x(), reco::CaloCluster::y(), and reco::CaloCluster::z().

                                                                           {
   if (!(fabs(cluster.eta()) > 1.6 && fabs(cluster.eta()) < 3.))
     return 0.;
 
   if (!ecalPS_topology_)
     return 0.;
 
   std::vector<float> phoESHitsIXIX =
       getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, ecalPS_topology_.get(), 0, 1);
   float phoESShapeIXIX = getESShape(phoESHitsIXIX);
 
   return phoESShapeIXIX;
 }

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

Definition at line 216 of file EcalClusterLazyTools.cc.

References ecalPS_topology_, reco::CaloCluster::eta(), geometry_, getESHits(), getESShape(), rechits_map_, reco::CaloCluster::x(), reco::CaloCluster::y(), and reco::CaloCluster::z().

                                                                           {
   if (!(fabs(cluster.eta()) > 1.6 && fabs(cluster.eta()) < 3.))
     return 0.;
 
   if (!ecalPS_topology_)
     return 0.;
 
   std::vector<float> phoESHitsIYIY =
       getESHits(cluster.x(), cluster.y(), cluster.z(), rechits_map_, geometry_, ecalPS_topology_.get(), 0, 2);
   float phoESShapeIYIY = getESShape(phoESHitsIYIY);
 
   return phoESShapeIYIY;
 }

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

protected

Definition at line 76 of file EcalClusterLazyTools.cc.

References ebRecHits_, EcalBarrel, EcalEndcap, eeRecHits_, Exception, first, reco::CaloCluster::hitsAndFractions(), HLT_FULL_cff::recHits, and reco::CaloCluster::size().

                                                                                                                    {
   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 = nullptr;
   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;
 }

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

Definition at line 231 of file EcalClusterLazyTools.cc.

References CaloNavigator< T, TOPO >::east(), DetId::Ecal, EcalPreshower, CaloGeometry::getSubdetectorGeometry(), CaloNavigator< T, TOPO >::home(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::next, CaloNavigator< T, TOPO >::north(), point, CaloNavigator< T, TOPO >::setHome(), CaloNavigator< T, TOPO >::south(), digitizers_cfi::strip, 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->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 != rechits_map.end() && it->second.energy() > 1.0e-10)
       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 != rechits_map.end() && it->second.energy() > 1.0e-10)
             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 != rechits_map.end() && it->second.energy() > 1.0e-10)
             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 != rechits_map.end() && it->second.energy() > 1.0e-10)
             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 != rechits_map.end() && it->second.energy() > 1.0e-10)
             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,
		edm::EDGetTokenT< EcalRecHitCollection > const &	esRecHitsToken
	)

private

Definition at line 46 of file EcalClusterLazyTools.cc.

References esRecHits_, edm::Event::getHandle(), and rechits_map_.

Referenced by EcalClusterLazyToolsBase().

                                                                                                         {
   auto pESRecHits = ev.getHandle(esRecHitsToken);
   esRecHits_ = pESRecHits.product();
   // make the map of rechits
   rechits_map_.clear();
   if (pESRecHits.isValid()) {
     for (auto 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 367 of file EcalClusterLazyTools.cc.

References 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;
 }

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

Definition at line 178 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
	)

inline

Definition at line 93 of file EcalClusterLazyTools.h.

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

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

Member Data Documentation

EcalADCToGeVConstant const* EcalClusterLazyToolsBase::agc = nullptr

protected

Definition at line 128 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and EcalClusterLazyToolsBase().

const EcalRecHitCollection* EcalClusterLazyToolsBase::ebRecHits_

protected

Definition at line 120 of file EcalClusterLazyTools.h.

Referenced by getEcalRecHitCollection().

std::unique_ptr<CaloSubdetectorTopology const> EcalClusterLazyToolsBase::ecalPS_topology_ = nullptr

protected

Definition at line 124 of file EcalClusterLazyTools.h.

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

const EcalRecHitCollection* EcalClusterLazyToolsBase::eeRecHits_

protected

Definition at line 121 of file EcalClusterLazyTools.h.

Referenced by getEcalRecHitCollection().

const EcalRecHitCollection* EcalClusterLazyToolsBase::esRecHits_

protected

Definition at line 122 of file EcalClusterLazyTools.h.

Referenced by getESRecHits().

const CaloGeometry* EcalClusterLazyToolsBase::geometry_

protected

Definition at line 118 of file EcalClusterLazyTools.h.

Referenced by EcalClusterLazyToolsT< ClusterTools >::covariances(), EcalClusterLazyToolsBase(), eseffsirir(), eseffsixix(), eseffsiyiy(), EcalClusterLazyToolsT< ClusterTools >::lat(), EcalClusterLazyToolsT< ClusterTools >::zernike20(), and EcalClusterLazyToolsT< ClusterTools >::zernike42().

EcalIntercalibConstants const* EcalClusterLazyToolsBase::ical = nullptr

protected

Definition at line 126 of file EcalClusterLazyTools.h.

Referenced by EcalClusterLazyToolsBase().

EcalIntercalibConstantMap const* EcalClusterLazyToolsBase::icalMap = nullptr

protected

Definition at line 127 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and EcalClusterLazyToolsBase().

EcalLaserDbService const* EcalClusterLazyToolsBase::laser = nullptr

protected

Definition at line 129 of file EcalClusterLazyTools.h.

Referenced by BasicClusterTime(), and EcalClusterLazyToolsBase().

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

Definition at line 98 of file EcalClusterLazyTools.h.

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

const CaloTopology* EcalClusterLazyToolsBase::topology_

protected

Definition at line 119 of file EcalClusterLazyTools.h.

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation