eflowRingSubtractionManager Class Reference

This stores information, a rank and ring thickness, about cell rings in an ordered way. More...

#include <eflowRingSubtractionManager.h>

Collaboration diagram for eflowRingSubtractionManager:

Public Member Functions
	eflowRingSubtractionManager ()
double	fudgeMean () const
double	fudgeStdDev () const
void	setFudgeMean (double fudgeMean)
void	setFudgeStdDev (double fudgeStdDev)
void	clear ()
std::map< double, RingId >::const_iterator	rankBegin () const
std::map< double, RingId >::const_iterator	rankEnd () const
double	ringThickness (eflowCaloENUM layer) const
bool	getOrdering (const eflowEEtaBinnedParameters *binnedParameters, double e, double eta, eflowFirstIntENUM j1st, bool useLegacyEnergyBinIndexing)

Private Member Functions
void	setParameters (const eflowFirstIntParameters &param, const std::vector< double > &ringThickness)

Static Private Member Functions
static double	ringMeanRank (const std::vector< double > &p, double rMin, double rMax)
static std::vector< eflowCaloENUM >	orderedLayersByShowerParam (const eflowFirstIntParameters &param, unsigned int whichParam=0)

Private Attributes
std::map< double, RingId >	m_rankMap
std::vector< double >	m_ringThickness
double	m_fudgeMean {}
double	m_fudgeStdDev {}

Static Private Attributes
static constexpr double	m_rMax = 0.75
static constexpr double	m_weightRange = 1.0e6

Detailed Description

This stores information, a rank and ring thickness, about cell rings in an ordered way.

The rings are ranked in descending energy density order. A ring is a list of calorimeter cells, in a given calorimeter layer, between two radii r1 and r2. This object is stored in the eflowRecTrack object, such that we have an eflowRingSubtractionManager for each track. The data in this object is filled in the simulateShower method of eflowCaloObject.

Definition at line 31 of file eflowRingSubtractionManager.h.

Constructor & Destructor Documentation

eflowRingSubtractionManager()

eflowRingSubtractionManager::eflowRingSubtractionManager

(

)

Definition at line 27 of file eflowRingSubtractionManager.cxx.

: m_ringThickness(eflowCalo::nRegions), m_fudgeMean(0), m_fudgeStdDev(-1) {}

Member Function Documentation

clear()

void eflowRingSubtractionManager::clear ( )

inline

Definition at line 43 of file eflowRingSubtractionManager.h.

{m_rankMap.clear();}

fudgeMean()

double eflowRingSubtractionManager::fudgeMean ( ) const

inline

Definition at line 37 of file eflowRingSubtractionManager.h.

{return m_fudgeMean;}

fudgeStdDev()

double eflowRingSubtractionManager::fudgeStdDev ( ) const

inline

Definition at line 38 of file eflowRingSubtractionManager.h.

{return m_fudgeStdDev;}

getOrdering()

bool eflowRingSubtractionManager::getOrdering	(	const eflowEEtaBinnedParameters *	binnedParameters,
		double	e,
		double	eta,
		eflowFirstIntENUM	j1st,
		bool	useLegacyEnergyBinIndexing
	)

Definition at line 103 of file eflowRingSubtractionManager.cxx.

                                                                                                                                                                              {
  const eflowParameters* bin1 = nullptr;
  const eflowParameters* bin2 = nullptr;
 
  /* Get the left- and right-bin given (e,eta), return the weight of the two bins and fill the bins to &bin1 and &bin2 */
  double weight = binnedParameters->getInterpolation(&bin1, &bin2, e, eta, useLegacyEnergyBinIndexing);
  if (!(bin1 && bin2)) { return false; }
 
  eflowFirstIntENUM adjustedJ1st = binnedParameters->adjustLFI(e, eta, j1st, useLegacyEnergyBinIndexing);
 
  /* Interpolate the firstInBins */
  eflowFirstIntParameters meanBin;
  bool isFailed = !(meanBin.getWeightedParameters(bin1->getFirstIntBin(adjustedJ1st), bin2->getFirstIntBin(adjustedJ1st), weight));
  if (isFailed) { return false; }
 
  /* Set the ring thicknesses */
  std::vector<double> ringThicknesses(eflowCalo::nRegions);
  for (int i = 0; i < eflowCalo::nRegions; i++) {
    //This was reviously interpolated - but the ring thickeness is a geometric property of the calorimeter without any energy dependence, so it was not needed.
    ringThicknesses[i] = eflowRingThicknesses::ringThickness((eflowCaloENUM) i);
  }
 
  setParameters(meanBin, ringThicknesses);
  return true;
}

orderedLayersByShowerParam()

std::vector< eflowCaloENUM > eflowRingSubtractionManager::orderedLayersByShowerParam ( const eflowFirstIntParameters &  param, unsigned int  whichParam = 0  )

staticprivate

Definition at line 42 of file eflowRingSubtractionManager.cxx.

                                                                   {
  /* Prepare a vector of calo layers which is ordered by the p0 parameter */
  /* First prepare a list of all layers (which are not eflowCalo::Unknown i.e. 999) */
  std::list<eflowCaloENUM> allLayers;
  for (int iLayer = 0; iLayer < eflowCalo::nRegions; iLayer++) {
    if (iLayer != eflowCalo::Unknown) {
      allLayers.push_back((eflowCaloENUM) (iLayer));
    }
  }
  /* Loop over the list to find the layer with highest p0.
   * Attach it to the end of the ordered vector and remove it from the list.
   * Repeat until the list is empty */
  std::vector<eflowCaloENUM> orderedLayers;
  while (!allLayers.empty()) {
    std::list<eflowCaloENUM>::iterator itLayer = allLayers.begin();
    std::list<eflowCaloENUM>::iterator itMaxP0Layer = itLayer;
    double p0Max = param.getShapeParameter(*itMaxP0Layer, whichParam);
    /* Get current highest p0-layer */
    for (; itLayer != allLayers.end(); ++itLayer) {
      double p0 = param.getShapeParameter(*itLayer, whichParam);
      if (p0 > p0Max) {
        itMaxP0Layer = itLayer;
        p0Max = p0;
      }
    }
    /* Attach to vector and remove from list */
    orderedLayers.push_back(*itMaxP0Layer);
    allLayers.erase(itMaxP0Layer);
  }
  return orderedLayers;
}

rankBegin()

std::map<double,RingId>::const_iterator eflowRingSubtractionManager::rankBegin ( ) const

inline

Definition at line 44 of file eflowRingSubtractionManager.h.

{return m_rankMap.begin();}

rankEnd()

std::map<double,RingId>::const_iterator eflowRingSubtractionManager::rankEnd ( ) const

inline

Definition at line 45 of file eflowRingSubtractionManager.h.

{return m_rankMap.end();}

ringMeanRank()

double eflowRingSubtractionManager::ringMeanRank ( const std::vector< double > &  p, double  rMin, double  rMax  )

staticprivate

Definition at line 29 of file eflowRingSubtractionManager.cxx.

                                                                                                  {
 
  double x1 = 0.0;
  double x2 = 0.0;
 
  if (0 != p[1] && 0 != p[3]){
    x1 = exp(-rMin / p[1]) - exp(-rMax / p[1]);
    x2 = exp(-rMin / p[3]) - exp(-rMax / p[3]);
  }
 
  return (p[0] * p[1] * x1 + p[2] * p[3] * x2) / (rMax - rMin); // hard coded 4-param model for now
}

ringThickness()

double eflowRingSubtractionManager::ringThickness ( eflowCaloENUM  layer ) const

inline

Definition at line 47 of file eflowRingSubtractionManager.h.

{return m_ringThickness[layer];}

setFudgeMean()

void eflowRingSubtractionManager::setFudgeMean ( double  fudgeMean )

inline

Definition at line 40 of file eflowRingSubtractionManager.h.

{m_fudgeMean = fudgeMean;}

setFudgeStdDev()

void eflowRingSubtractionManager::setFudgeStdDev ( double  fudgeStdDev )

inline

Definition at line 41 of file eflowRingSubtractionManager.h.

{m_fudgeStdDev = fudgeStdDev;}

setParameters()

void eflowRingSubtractionManager::setParameters ( const eflowFirstIntParameters &  param, const std::vector< double > &  ringThickness  )

private

Definition at line 75 of file eflowRingSubtractionManager.cxx.

                                                                                                                         {
  /* Prepare a vector of calo layers which is ordered by the p0 parameter */
  std::vector<eflowCaloENUM> orderedLayers = orderedLayersByShowerParam(param, 0);
 
  /* Set e/p and ring thicknesses */
  m_fudgeMean = param.fudgeMean();
  m_fudgeStdDev = param.fudgeStdDev();
  m_ringThickness = ringThickness;
 
  /* Populate the ring/rank map */
  m_rankMap.clear();
  double weight;
  double weightMax = ringMeanRank(param.getShapeParameters(orderedLayers[0]), 0.0, ringThickness[orderedLayers[0]])/m_weightRange;
  for (const auto & layer : orderedLayers) {
    /* Add weights to map (map does the ordering) */
    const int nRings = (int)(m_rMax / ringThickness[layer]);
 
    for (int iRing = 0; iRing < nRings; iRing++) {
      weight = ringMeanRank(param.getShapeParameters(layer), iRing*ringThickness[layer], (iRing+1)*ringThickness[layer]);
      if (weight == 0 || weight < weightMax) {
        break;                    // only add weights within a factor (range) of weightMax (say 10^6)
      } else {
        m_rankMap[1.0/weight] = RingId(layer, iRing);
      }
    }
  }
}

Member Data Documentation

m_fudgeMean

double eflowRingSubtractionManager::m_fudgeMean {}

private

Definition at line 61 of file eflowRingSubtractionManager.h.

m_fudgeStdDev

double eflowRingSubtractionManager::m_fudgeStdDev {}

private

Definition at line 62 of file eflowRingSubtractionManager.h.

m_rankMap

std::map<double,RingId> eflowRingSubtractionManager::m_rankMap

private

Definition at line 59 of file eflowRingSubtractionManager.h.

m_ringThickness

std::vector<double> eflowRingSubtractionManager::m_ringThickness

private

Definition at line 60 of file eflowRingSubtractionManager.h.

m_rMax

constexpr double eflowRingSubtractionManager::m_rMax = 0.75

staticconstexprprivate

Definition at line 64 of file eflowRingSubtractionManager.h.

m_weightRange

constexpr double eflowRingSubtractionManager::m_weightRange = 1.0e6

staticconstexprprivate

Definition at line 65 of file eflowRingSubtractionManager.h.

---

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

• eflowRingSubtractionManager.h
• eflowRingSubtractionManager.cxx