eflowEEtaBinnedParameters Class Reference

Inherits from eflowEEtaBinBase. More...

#include <eflowEEtaBinnedParameters.h>

Inheritance diagram for eflowEEtaBinnedParameters:

Collaboration diagram for eflowEEtaBinnedParameters:

Public Member Functions
	eflowEEtaBinnedParameters ()=default
void	initialise (const std::vector< double > &eBinBounds, const std::vector< double > &etaBinBounds, bool useAbsEta=true)
void	setFudgeMean (int energyBin, int etaBin, eflowFirstIntENUM j1st, double fudgeMean)
void	setFudgeStdDev (int energyBin, int etaBin, eflowFirstIntENUM j1st, double fudgeStdDev)
void	setShapeParam (int energyBin, int etaBin, eflowFirstIntENUM j1st, eflowCaloENUM layer, int paramNumber, double shapeParam)
double	getInterpolation (const eflowParameters **bin1, const eflowParameters **bin2, double e, double eta, bool useLegacyEnergyBinIndexing) const
eflowFirstIntENUM	adjustLFI (double e, double eta, eflowFirstIntENUM j1st, bool useLegacyEnergyBinIndexing) const
bool	binExists (double e, double eta) const

Static Public Member Functions
static double	getErrorReturnValue ()

Protected Member Functions
int	getNumEBins () const
int	getNumEtaBins () const
int	getEBinIndexLegacy (double e) const
int	getEBinIndex (double e) const
int	getEtaBinIndex (double eta) const

Static Protected Member Functions
static int	getBinIndex (double x, const std::vector< double > &binBounds)

Protected Attributes
bool	m_useAbsEta {true}
std::vector< double >	m_eBinBounds
std::vector< double >	m_etaBinBounds

Static Protected Attributes
static const double	m_errorReturnValue = -999.0

Private Attributes
std::vector< std::vector< std::unique_ptr< eflowParameters > > >	m_bins

Detailed Description

Inherits from eflowEEtaBinBase.

This class adds the infrastructure to store data and its set methods are used in e.g. eflowCellEOverPTool_mc12_JetETMiss. It also calculates an interpolation weight for moving between bins.

Definition at line 56 of file eflowEEtaBinnedParameters.h.

Constructor & Destructor Documentation

eflowEEtaBinnedParameters()

eflowEEtaBinnedParameters::eflowEEtaBinnedParameters ( )

default

Member Function Documentation

adjustLFI()

eflowFirstIntENUM eflowEEtaBinnedParameters::adjustLFI	(	double	e,
		double	eta,
		eflowFirstIntENUM	j1st,
		bool	useLegacyEnergyBinIndexing
	)		const

Definition at line 109 of file eflowEEtaBinnedParameters.cxx.

                                                                                                                  {
 
 
  int eBinIndex = 0;               
  if (useLegacyEnergyBinIndexing) {
    eBinIndex = getEBinIndexLegacy(e);
  } else {
    eBinIndex = getEBinIndex(e);
  }
 
  //hard code this check - needs to be rechecked if ever remake e/p tables
  //if e.g track extrapolation slightly off can have inconsistent j1st and eta (e.g eta = 1.52, j1st = EMB2) and hence fudgeMean is zero
  if (0 <= eBinIndex && eBinIndex <= 5) {
    if (fabs(eta) < 1.5) {
      if (eflowFirstIntRegions::EME1 == j1st) j1st = eflowFirstIntRegions::EMB1;
      if (eflowFirstIntRegions::EME2 == j1st) j1st = eflowFirstIntRegions::EMB2;
      if (eflowFirstIntRegions::EME3 == j1st) j1st = eflowFirstIntRegions::EMB3;
      if (eflowFirstIntRegions::HEC == j1st) j1st = eflowFirstIntRegions::Tile;
    }
    if (fabs(eta) >= 1.6) {
      if (eflowFirstIntRegions::EMB1 == j1st) j1st = eflowFirstIntRegions::EME1;
      if (eflowFirstIntRegions::EMB2 == j1st) j1st = eflowFirstIntRegions::EME2;
      if (eflowFirstIntRegions::EMB3 == j1st) j1st = eflowFirstIntRegions::EME3;
      if (eflowFirstIntRegions::Tile == j1st) j1st = eflowFirstIntRegions::HEC;
    }
 
  }
 
  if (0 == eBinIndex || 1 == eBinIndex) {
    if (fabs(eta) >= 1.0 && fabs(eta) < 1.1) {
      if(eflowFirstIntRegions::Tile == j1st) j1st = eflowFirstIntRegions::EMB3;
    }
    else if (fabs(eta) >= 1.2 && fabs(eta) < 1.3) {
      if(eflowFirstIntRegions::Tile == j1st) j1st = eflowFirstIntRegions::EMB3;
    }
    else if (fabs(eta) >= 1.5 && fabs(eta) < 1.6) {
      if(eflowFirstIntRegions::EMB3 == j1st) j1st = eflowFirstIntRegions::EME3;
    }
 
  } else if (2 == eBinIndex) {
    if (fabs(eta) >= 1.5 && fabs(eta) < 1.6) {
      if(eflowFirstIntRegions::EMB2 == j1st) j1st = eflowFirstIntRegions::EME2;
    }
 
  } else if (3 == eBinIndex) {
    if (fabs(eta) >= 1.5 && fabs(eta) < 1.6) {
      if (eflowFirstIntRegions::EMB2 == j1st) j1st = eflowFirstIntRegions::EME2;
      if (eflowFirstIntRegions::EMB1 == j1st) j1st = eflowFirstIntRegions::EME1;
    }
 
  } else if (4 == eBinIndex || 5 == eBinIndex) {
    if (fabs(eta) >= 1.5 && fabs(eta) < 1.6) {
      if(eflowFirstIntRegions::EMB1 == j1st) j1st = eflowFirstIntRegions::EME1;
    }
  }
 
  return j1st;
}

binExists()

bool eflowEEtaBinBase::binExists ( double  e, double  eta  ) const

inlineinherited

Definition at line 32 of file eflowEEtaBinBase.h.

{ return (getEBinIndex(e) >= 0 && getEtaBinIndex(eta) >= 0); }

getBinIndex()

int eflowEEtaBinBase::getBinIndex ( double  x, const std::vector< double > &  binBounds  )

staticprotectedinherited

Definition at line 67 of file eflowEEtaBinBase.cxx.

                                                                              {
  int nBins = binBounds.size() - 1;
  int bin = -1;
  for (int i = 0; i < nBins; i++) {
    if (x >= binBounds[i] && x < binBounds[i+1]) {
      bin = i;
      break;
    }
  }
  return bin;
}

getEBinIndex()

int eflowEEtaBinBase::getEBinIndex ( double  e ) const

protectedinherited

Definition at line 28 of file eflowEEtaBinBase.cxx.

                                                 {
  int nEBins = getNumEBins();
  for (int i = 0; i < (nEBins-1); i++) {
    if (e > m_eBinBounds[i] && e < m_eBinBounds[i + 1]) return i;
  } 
  //for the final bin we simply check if the track energy is greater than the lower bound
  if ( e > m_eBinBounds.back() ) return nEBins-1;    
  return 0;
}

getEBinIndexLegacy()

int eflowEEtaBinBase::getEBinIndexLegacy ( double  e ) const

protectedinherited

Definition at line 38 of file eflowEEtaBinBase.cxx.

                                                       {
 
  int nEBins = getNumEBins();
  int bin = 0;
  for (int i = nEBins - 1; i > 0; i--) {
    if (e > sqrt(m_eBinBounds[i - 1] * m_eBinBounds[i])) {
      bin = i;
      break;
    }
  }
  return bin;
 
}

getErrorReturnValue()

static double eflowEEtaBinBase::getErrorReturnValue ( )

inlinestaticinherited

Definition at line 34 of file eflowEEtaBinBase.h.

{return m_errorReturnValue;}

getEtaBinIndex()

int eflowEEtaBinBase::getEtaBinIndex ( double  eta ) const

protectedinherited

Definition at line 52 of file eflowEEtaBinBase.cxx.

                                                     {
  if (m_useAbsEta) eta = fabs(eta);
 
  /* If eta is outside bin range, return highest/lowest bin to avoid binning failures
   * (in practice we always use absEta, so it can only be too high) */
  if (eta > m_etaBinBounds.back()) {
    return m_etaBinBounds.size()-2; // Yes, it's minus *two* --> we need to return the index of the *low* edge of the bin
  }
  if (eta < m_etaBinBounds[0]){
    return 0;
  }
 
  return getBinIndex(eta, m_etaBinBounds);
}

getInterpolation()

double eflowEEtaBinnedParameters::getInterpolation	(	const eflowParameters **	bin1,
		const eflowParameters **	bin2,
		double	e,
		double	eta,
		bool	useLegacyEnergyBinIndexing
	)		const

Definition at line 52 of file eflowEEtaBinnedParameters.cxx.

                                                                                                                       {
  double weight;
  int eBin = 0;
  if (useLegacyEnergyBinIndexing) {
    eBin = getEBinIndexLegacy(e);
  } else {
    eBin = getEBinIndex(e);
  }
  int etaBin = getEtaBinIndex(eta);
 
  /* Check for invalid bins */
  if (eBin < 0 || etaBin < 0) {
    *bin1 = nullptr;
    *bin2 = nullptr;
    weight = -1.0;
    return weight;
  }
 
  if ((0 == eBin && e <= m_eBinBounds[eBin]) ||
      (eBin == getNumEBins() - 1 && e >= m_eBinBounds[getNumEBins() - 1])) {
    /* If e is below the lowest (above the highest) pinpoint, just return the lowest (highest) bin; no interpolation in this case. */
    *bin1 = m_bins[eBin][etaBin].get();
    *bin2 = m_bins[eBin][etaBin].get();
    weight = 1.0;
  } else {
    /* The "normal" case: interpolate between two energies */
    int lowEBin = eBin;
    int highEBin = eBin;
 
    if (e >= m_eBinBounds[eBin]) {
      highEBin = eBin + 1;
    } else {
      lowEBin = eBin - 1;
    }
    auto outOfRange = [this](int bin)->bool{
      return (bin<0) or (bin>=std::ssize(m_bins));
    };
    
    if (outOfRange(lowEBin) or outOfRange(highEBin)){
      throw std::out_of_range("Attempt to access element out of range in eflowEEtaBinnedParameters::getInterpolation");
    }
    *bin1 = m_bins[lowEBin][etaBin].get();
    *bin2 = m_bins[highEBin][etaBin].get();
 
    double higherEBound = m_eBinBounds[highEBin];
    double lowerEBound = m_eBinBounds[lowEBin];
    //deals with e = 0 bin to avoid dividing by zero
    if (lowerEBound < FLT_MIN) lowerEBound = FLT_MIN;
 
    weight = log(higherEBound / e) / log(higherEBound / lowerEBound);
  }
  return weight;
}

getNumEBins()

int eflowEEtaBinBase::getNumEBins ( ) const

inlineprotectedinherited

Definition at line 38 of file eflowEEtaBinBase.h.

{ return m_eBinBounds.size(); }

getNumEtaBins()

int eflowEEtaBinBase::getNumEtaBins ( ) const

inlineprotectedinherited

Definition at line 39 of file eflowEEtaBinBase.h.

{ return m_etaBinBounds.size(); }

initialise()

void eflowEEtaBinnedParameters::initialise	(	const std::vector< double > &	eBinBounds,
		const std::vector< double > &	etaBinBounds,
		bool	useAbsEta = true
	)

Definition at line 33 of file eflowEEtaBinnedParameters.cxx.

                                                                                                                                     {
  m_useAbsEta = useAbsEta;
  m_eBinBounds = eBinBounds;
  m_etaBinBounds = etaBinBounds;
 
  /* Create all the bins */
  int nEBins = getNumEBins();
  int nEtaBins = getNumEtaBins()-1;
  m_bins.reserve(nEBins);
  for (int iEBin = 0; iEBin < nEBins; iEBin++) {
    std::vector<std::unique_ptr<eflowParameters> > tempVector;
    tempVector.reserve(nEtaBins);
    for (int iEtaBin = 0; iEtaBin < nEtaBins; iEtaBin++) {
      tempVector.push_back(std::make_unique<eflowParameters>());
    }
    m_bins.push_back(std::move(tempVector));
  }
}

setFudgeMean()

void eflowEEtaBinnedParameters::setFudgeMean ( int  energyBin, int  etaBin, eflowFirstIntENUM  j1st, double  fudgeMean  )

inline

Definition at line 63 of file eflowEEtaBinnedParameters.h.

                                                                                         {
    if (m_bins[energyBin][etaBin]) {
      eflowFirstIntParameters* j1stBin = m_bins[energyBin][etaBin]->getFirstIntBin(j1st);
      if (j1stBin) j1stBin->setFudgeMean(fudgeMean);
    }
  }

setFudgeStdDev()

void eflowEEtaBinnedParameters::setFudgeStdDev ( int  energyBin, int  etaBin, eflowFirstIntENUM  j1st, double  fudgeStdDev  )

inline

Definition at line 69 of file eflowEEtaBinnedParameters.h.

                                                                                             {
    if (m_bins[energyBin][etaBin]) {
      eflowFirstIntParameters* j1stBin = m_bins[energyBin][etaBin]->getFirstIntBin(j1st);
      if (j1stBin) j1stBin->setFudgeStdDev(fudgeStdDev);
    }
  }

setShapeParam()

void eflowEEtaBinnedParameters::setShapeParam ( int  energyBin, int  etaBin, eflowFirstIntENUM  j1st, eflowCaloENUM  layer, int  paramNumber, double  shapeParam  )

inline

Definition at line 75 of file eflowEEtaBinnedParameters.h.

                                                         {
    if (m_bins[energyBin][etaBin]) {
      eflowFirstIntParameters* j1stBin = m_bins[energyBin][etaBin]->getFirstIntBin(j1st);
      if (j1stBin) j1stBin->setShapeParameter(layer, paramNumber, shapeParam);
    }
  }

Member Data Documentation

m_bins

std::vector< std::vector<std::unique_ptr<eflowParameters> > > eflowEEtaBinnedParameters::m_bins

private

Definition at line 90 of file eflowEEtaBinnedParameters.h.

m_eBinBounds

std::vector<double> eflowEEtaBinBase::m_eBinBounds

protectedinherited

Definition at line 49 of file eflowEEtaBinBase.h.

m_errorReturnValue

const double eflowEEtaBinBase::m_errorReturnValue = -999.0

staticprotectedinherited

Definition at line 46 of file eflowEEtaBinBase.h.

m_etaBinBounds

std::vector<double> eflowEEtaBinBase::m_etaBinBounds

protectedinherited

Definition at line 50 of file eflowEEtaBinBase.h.

m_useAbsEta

bool eflowEEtaBinBase::m_useAbsEta {true}

protectedinherited

Definition at line 48 of file eflowEEtaBinBase.h.

---

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

• eflowEEtaBinnedParameters.h
• eflowEEtaBinnedParameters.cxx