eflowLayerIntegrator Class Reference

This class calculates the LHED (Layer of Highest Energy Density) in a cluster or group of clusters. More...

#include <eflowLayerIntegrator.h>

Collaboration diagram for eflowLayerIntegrator:

Public Member Functions
	eflowLayerIntegrator (double stdDev, double error, double rMaxOverStdDev, bool isHLLHC=false)
	eflowLayerIntegrator (const eflowLayerIntegrator &originalEflowLayerIntegrator)
eflowLayerIntegrator &	operator= (const eflowLayerIntegrator &originalEflowLayerIntegrator)
	~eflowLayerIntegrator ()
void	measureNewClus (const xAOD::CaloCluster *clus, const eflowTrackCaloPoints &trackCalo)
void	measureNewClus (eflowTrackClusterLink *trackClusterLink)
void	measureNewClus (const std::vector< eflowRecCluster * > &efRecClusters, eflowRecTrack *track)
void	measureNewClus (const std::vector< xAOD::CaloCluster * > &clusVec, const eflowTrackCaloPoints &trackCalo)
eflowFirstIntENUM	getFirstIntLayer () const

Private Member Functions
void	resetAllClustersIntegralForNewTrack (const eflowTrackCaloPoints &trackCalo)
void	addToAllClustersIntegral (const std::vector< double > &clusterIntegral)
void	measureCluster (eflowTrackClusterLink *trackClusterLink)
void	measureCluster (const xAOD::CaloCluster *clus, const eflowTrackCaloPoints &trackCalo)
void	measureCell (const CaloCell *cell, const eflowTrackCaloPoints &trackCalo)

Private Attributes
double	m_rMax
bool	m_isHLLHC
std::vector< double >	m_allClustersIntegral
std::vector< double >	m_singleClusterIntegral
eflowDepthCalculator	m_caloModel
double	m_densityConversion [eflowCalo::nRegions] {}
std::vector< double >	m_nUnitCellPerWindowOverCellEtaPhiArea
std::unique_ptr< eflowCellIntegrator< 0 > >	m_integrator
std::unique_ptr< eflowCellIntegrator< 1 > >	m_integratorLookup

Detailed Description

This class calculates the LHED (Layer of Highest Energy Density) in a cluster or group of clusters.

This is calculated using an integral over the eta-phi enegry density in each calorimeter layer using 2D Gaussian Weights, and makes use of eflowCellIntegrator to do the integral over each calorimeter cell.

Definition at line 35 of file eflowLayerIntegrator.h.

Constructor & Destructor Documentation

eflowLayerIntegrator() [1/2]

eflowLayerIntegrator::eflowLayerIntegrator	(	double	stdDev,
		double	error,
		double	rMaxOverStdDev,
		bool	isHLLHC = false )

Definition at line 32 of file eflowLayerIntegrator.cxx.

                                                                                                           :
    m_rMax(rMaxOverStdDev * stdDev),
    m_isHLLHC(isHLLHC),
    m_allClustersIntegral(eflowCalo::nRegions, 0.0),
    m_nUnitCellPerWindowOverCellEtaPhiArea(eflowCalo::nRegions),
    m_integrator(std::make_unique<eflowCellIntegrator<0> >(stdDev, error)),
    m_integratorLookup(std::make_unique<eflowCellIntegrator<1> >(stdDev, error)) {
  eflowDatabase database;
 
  /* Set up density conversion factors */
  double emX0PerUnitLengthToTheMinus3  = pow(database.getEmX0PerUnitLength(),  -3.0);
  double hadX0PerUnitLengthToTheMinus3 = pow(database.getHadX0PerUnitLength(), -3.0);
  for (int i = 0; i < eflowCalo::nRegions; i++) {
    eflowCaloENUM layer = (eflowCaloENUM)(i);
    m_densityConversion[i] = (layer >= eflowCalo::EMB1 && layer <= eflowCalo::EME3) ?
                             emX0PerUnitLengthToTheMinus3 :
                             hadX0PerUnitLengthToTheMinus3;
    if(i==13) m_densityConversion[i] = pow(database.getFCalX0PerUnitLength(0), -3.0);
    if(i==14) m_densityConversion[i] = pow(database.getFCalX0PerUnitLength(1), -3.0);
    if(i==15) m_densityConversion[i] = pow(database.getFCalX0PerUnitLength(2), -3.0);
  }
 
  /* More setup */
  double nUnitCellsPerWindow = M_PI * stdDev * stdDev / (database.getEtaUnit() * database.getPhiUnit());
  std::vector<double> cellEtaWidth = database.getCellEtaWidth();
  std::vector<double> cellPhiWidth = database.getCellPhiWidth();
  for (int i = 0; i < eflowCalo::nRegions; i++){
    m_nUnitCellPerWindowOverCellEtaPhiArea[i] =
        nUnitCellsPerWindow / (cellEtaWidth[i] * cellPhiWidth[i]);
  }
}

eflowLayerIntegrator() [2/2]

eflowLayerIntegrator::eflowLayerIntegrator

(

const eflowLayerIntegrator &

originalEflowLayerIntegrator

)

Definition at line 64 of file eflowLayerIntegrator.cxx.

  : m_rMax (originalEflowLayerIntegrator.m_rMax),
    m_isHLLHC (originalEflowLayerIntegrator.m_isHLLHC),
    m_allClustersIntegral (originalEflowLayerIntegrator.m_allClustersIntegral),
    m_nUnitCellPerWindowOverCellEtaPhiArea (originalEflowLayerIntegrator.m_nUnitCellPerWindowOverCellEtaPhiArea),
    m_integrator (std::make_unique<eflowCellIntegrator<0> >(*originalEflowLayerIntegrator.m_integrator)),
    m_integratorLookup (std::make_unique<eflowCellIntegrator<1> >(*originalEflowLayerIntegrator.m_integratorLookup))
{
  for (int i = 0; i < eflowCalo::nRegions; i++){
    m_densityConversion[i] = originalEflowLayerIntegrator.m_densityConversion[i];
    m_nUnitCellPerWindowOverCellEtaPhiArea[i] = originalEflowLayerIntegrator.m_nUnitCellPerWindowOverCellEtaPhiArea[i];
  }
}

~eflowLayerIntegrator()

eflowLayerIntegrator::~eflowLayerIntegrator ( )

default

Member Function Documentation

addToAllClustersIntegral()

void eflowLayerIntegrator::addToAllClustersIntegral ( const std::vector< double > & clusterIntegral )

private

Definition at line 116 of file eflowLayerIntegrator.cxx.

                                                                                            {
  assert(clusterIntegral.size() == m_allClustersIntegral.size());
 
  if (clusterIntegral.size() != m_allClustersIntegral.size()){
    std::cerr << " eflowLayerIntegrator ERROR: cluster integral sizes do not match" << std::endl;
    return;
  }
 
  for (int i = 0; i < eflowCalo::nRegions; i++) {
    if (m_allClustersIntegral[i] != eflowTrackCaloPoints::defaultEta()){
      m_allClustersIntegral[i] += clusterIntegral[i];
    }
  }
}

getFirstIntLayer()

eflowFirstIntENUM eflowLayerIntegrator::getFirstIntLayer

(

)

const

Definition at line 230 of file eflowLayerIntegrator.cxx.

                                                               {
 
  const double* depthArray = m_caloModel.getDepthArray();
 
  double xPrev = 0.0;
  double yPrev = 0.0;
  int result = eflowCalo::Unknown;
  double maxGradient = -10.0;
 
  for (int layer = 0; layer < eflowCalo::nRegions; ++layer){
 
    if (m_allClustersIntegral[layer] == eflowTrackCaloPoints::defaultEta()) { continue; }
 
    double convertedDensity = m_allClustersIntegral[layer] * m_densityConversion[layer];
    eflowDepthLayerENUM depthLayer = eflowDepthCalculator::depthIndex((eflowCaloENUM)layer);
 
    const double dx = depthArray[depthLayer+1] - xPrev;
    const double dy = convertedDensity - yPrev;
    xPrev = depthArray[depthLayer+1];
    yPrev = convertedDensity;
    const double gradient  = dy / dx;
 
    if (gradient > maxGradient) {
      maxGradient = gradient;
      result = layer;
    }
  }
  
  return eflowFirstIntRegions::translateCalo((eflowCaloENUM)result);
}

measureCell()

void eflowLayerIntegrator::measureCell ( const CaloCell * cell, const eflowTrackCaloPoints & trackCalo )

private

Definition at line 193 of file eflowLayerIntegrator.cxx.

                                                                                                  {
  const CaloDetDescrElement* caloDetDescrElement = cell->caloDDE();
  if (!caloDetDescrElement) return;
  //very rarely a calorimeter cell has zero volume - in such cases one cannot calculate an energy fensity.
  //This is expected to happen for certain cells, for example presampler barrel or some tile gap cells.
  //See https://its.cern.ch/jira/browse/ATR-20919 for discussion of this bug.
  if ( caloDetDescrElement->volume() < 1e-6 ) return;
 
  eflowCaloENUM layer = eflowCalo::translateSampl(caloDetDescrElement->getSampling());
  if (eflowCalo::Unknown == layer) { return; }
 
  const double extrapTrackEta = trackCalo.getEta(layer);
  const double extrapTrackPhi = trackCalo.getPhi(layer);
  if (extrapTrackEta == eflowTrackCaloPoints::defaultEta() ||
      extrapTrackPhi == eflowTrackCaloPoints::defaultPhi()) {
    return;
  }
 
  const double etaWidth = caloDetDescrElement->deta();
  const double phiWidth = caloDetDescrElement->dphi();
 
  const double dEta = cell->eta() - extrapTrackEta;
  const double dPhi = xAOD::P4Helpers::deltaPhi(cell->phi(), extrapTrackPhi);
  const double dr = sqrt(dEta * dEta + dPhi * dPhi);
 
  if ( fabs(dr - std::max(etaWidth, phiWidth)) <= m_rMax || dr <= m_rMax ) {
 
    eflowRange etaRange(dEta - etaWidth/2.0, dEta + etaWidth/2.0);
    eflowRange phiRange(dPhi - phiWidth/2.0, dPhi+phiWidth/2.0);
 
    const double weight     = m_integratorLookup->integrate(etaRange, phiRange);
 
    m_singleClusterIntegral[layer] += weight * cell->energy() / caloDetDescrElement->volume();
  }
 
}

measureCluster() [1/2]

void eflowLayerIntegrator::measureCluster ( const xAOD::CaloCluster * clus, const eflowTrackCaloPoints & trackCalo )

private

Definition at line 174 of file eflowLayerIntegrator.cxx.

                                                                                                            {
  m_singleClusterIntegral.assign(eflowCalo::nRegions, 0.0);
 
  const CaloClusterCellLink* theCellLink = clus->getCellLinks();
 
  if (theCellLink){
  
    CaloClusterCellLink::const_iterator itCell = theCellLink->begin();
    CaloClusterCellLink::const_iterator itCellEnd = theCellLink->end();
 
    for (; itCell != itCellEnd; ++itCell) {
      measureCell(*itCell, trackCalo);
    }
  }//if valid cell link
 
  addToAllClustersIntegral(m_singleClusterIntegral);
 
}

measureCluster() [2/2]

void eflowLayerIntegrator::measureCluster ( eflowTrackClusterLink * trackClusterLink )

private

Definition at line 160 of file eflowLayerIntegrator.cxx.

                                                                                 {
  if (trackClusterLink->getClusterIntegral().empty()){
    /* The track-cluster pair hasn't been integrated yet. Integrate as usual and store the results */
    measureCluster(trackClusterLink->getCluster()->getCluster(), trackClusterLink->getTrack()->getTrackCaloPoints());
    trackClusterLink->setClusterIntegral(m_singleClusterIntegral);
    if (trackClusterLink->getTrack()->getCaloDepthArray().empty()) {
      trackClusterLink->getTrack()->setCaloDepthArray(m_caloModel.getDepthArray());
    }
  } else {
    /* The track-cluster pair has already been integrated. Take integral from the TrackClusterLink and add to total integral */
    addToAllClustersIntegral(trackClusterLink->getClusterIntegral());
  }
}

measureNewClus() [1/4]

void eflowLayerIntegrator::measureNewClus	(	const std::vector< eflowRecCluster * > &	efRecClusters,
		eflowRecTrack *	track )

Definition at line 139 of file eflowLayerIntegrator.cxx.

                                                                                                                {
  resetAllClustersIntegralForNewTrack(track->getTrackCaloPoints());
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  for (eflowRecCluster* cluster : efRecClusters) {
    measureCluster(eflowTrackClusterLink::getInstance(track, cluster, ctx));
  }
}

measureNewClus() [2/4]

void eflowLayerIntegrator::measureNewClus	(	const std::vector< xAOD::CaloCluster * > &	clusVec,
		const eflowTrackCaloPoints &	trackCalo )

Definition at line 131 of file eflowLayerIntegrator.cxx.

                                                                                                                           {
  resetAllClustersIntegralForNewTrack(trackCalo);
 
  for (xAOD::CaloCluster* cluster : clusVec) {
    measureCluster(cluster, trackCalo);
  }
}

measureNewClus() [3/4]

void eflowLayerIntegrator::measureNewClus	(	const xAOD::CaloCluster *	clus,
		const eflowTrackCaloPoints &	trackCalo )

Definition at line 154 of file eflowLayerIntegrator.cxx.

                                                                                                            {
  resetAllClustersIntegralForNewTrack(trackCalo);
 
  measureCluster(clus, trackCalo);
}

measureNewClus() [4/4]

void eflowLayerIntegrator::measureNewClus

(

eflowTrackClusterLink *

trackClusterLink

)

Definition at line 148 of file eflowLayerIntegrator.cxx.

                                                                                 {
  resetAllClustersIntegralForNewTrack(trackClusterLink->getTrack()->getTrackCaloPoints());
 
  measureCluster(trackClusterLink);
}

operator=()

eflowLayerIntegrator & eflowLayerIntegrator::operator=

(

const eflowLayerIntegrator &

originalEflowLayerIntegrator

)

Definition at line 78 of file eflowLayerIntegrator.cxx.

                                                                                                             {
  if (this == &originalEflowLayerIntegrator) return *this;
  //if not assigning to self, then we copy the data to the new object
  else {
    m_rMax = originalEflowLayerIntegrator.m_rMax;
    m_isHLLHC = originalEflowLayerIntegrator.m_isHLLHC;
    m_allClustersIntegral =  originalEflowLayerIntegrator.m_allClustersIntegral;
    m_nUnitCellPerWindowOverCellEtaPhiArea = originalEflowLayerIntegrator.m_nUnitCellPerWindowOverCellEtaPhiArea;
    m_integrator = std::make_unique<eflowCellIntegrator<0> >(*originalEflowLayerIntegrator.m_integrator);
    m_integratorLookup = std::make_unique<eflowCellIntegrator<1> >(*originalEflowLayerIntegrator.m_integratorLookup);
 
    for (int i = 0; i < eflowCalo::nRegions; i++){
      m_densityConversion[i] = originalEflowLayerIntegrator.m_densityConversion[i];
      m_nUnitCellPerWindowOverCellEtaPhiArea[i] = originalEflowLayerIntegrator.m_nUnitCellPerWindowOverCellEtaPhiArea[i];
    }
    return *this;
  }//if not assigning to self, then we have copied the data to the new object
}

resetAllClustersIntegralForNewTrack()

void eflowLayerIntegrator::resetAllClustersIntegralForNewTrack ( const eflowTrackCaloPoints & trackCalo )

private

Definition at line 99 of file eflowLayerIntegrator.cxx.

                                                                                                    {
  for (int iLayer = 0; iLayer < eflowCalo::nRegions; iLayer++) {
    m_allClustersIntegral[iLayer] = trackCalo.haveLayer((eflowCaloENUM)iLayer) ? 0.0 : eflowTrackCaloPoints::defaultEta();
  }
  /* Calculate the caloDepthArray */
  double em2Eta = trackCalo.getEM2eta();
  if (!m_isHLLHC) {
    if ( fabs(em2Eta) > 2.5 ) em2Eta = 2.49;  //sometimes track extrapolator returns e.g. 2.51 for em2Eta, which causes depth array to be filled with zeroes.
  }
  else{
    if(em2Eta<-998.) em2Eta = trackCalo.getFCAL0eta();
    if ( fabs(em2Eta) > 4.0 ) { em2Eta = 3.99; }   //sometimes track extrapolator returns e.g. 4.01 for em2Eta, which causes depth array to be filled with zeroes.
  }
 
  m_caloModel.calcDepthArray(em2Eta, 1.0e-4);
}

Member Data Documentation

m_allClustersIntegral

std::vector<double> eflowLayerIntegrator::m_allClustersIntegral

private

Definition at line 65 of file eflowLayerIntegrator.h.

m_caloModel

eflowDepthCalculator eflowLayerIntegrator::m_caloModel

private

Definition at line 68 of file eflowLayerIntegrator.h.

m_densityConversion

double eflowLayerIntegrator::m_densityConversion[eflowCalo::nRegions] {}

private

Definition at line 70 of file eflowLayerIntegrator.h.

{};

m_integrator

std::unique_ptr<eflowCellIntegrator<0> > eflowLayerIntegrator::m_integrator

private

Definition at line 74 of file eflowLayerIntegrator.h.

m_integratorLookup

std::unique_ptr<eflowCellIntegrator<1> > eflowLayerIntegrator::m_integratorLookup

private

Definition at line 75 of file eflowLayerIntegrator.h.

m_isHLLHC

bool eflowLayerIntegrator::m_isHLLHC

private

Definition at line 63 of file eflowLayerIntegrator.h.

m_nUnitCellPerWindowOverCellEtaPhiArea

std::vector<double> eflowLayerIntegrator::m_nUnitCellPerWindowOverCellEtaPhiArea

private

Definition at line 72 of file eflowLayerIntegrator.h.

m_rMax

double eflowLayerIntegrator::m_rMax

private

Definition at line 60 of file eflowLayerIntegrator.h.

m_singleClusterIntegral

std::vector<double> eflowLayerIntegrator::m_singleClusterIntegral

private

Definition at line 66 of file eflowLayerIntegrator.h.

---

The documentation for this class was generated from the following files:

• eflowLayerIntegrator.h
• eflowLayerIntegrator.cxx