CaloLocalHadCoeff Struct Reference

Hold binned correction data for local hadronic calibration procedure. More...

#include <CaloLocalHadCoeff.h>

Collaboration diagram for CaloLocalHadCoeff:

Classes
class	LocalHadArea
	Definition of correction area. More...
class	LocalHadDimension
	Class defines binning for user dimension. More...

Public Types
typedef std::vector< float >	LocalHadCoeff
	Correction parameters for one general bin.

Public Member Functions
	CaloLocalHadCoeff ()
	Default constructor.
	CaloLocalHadCoeff (const CaloLocalHadCoeff &other)=default
	Copy constructor.
CaloLocalHadCoeff &	operator= (const CaloLocalHadCoeff &other)=default
	CaloLocalHadCoeff (CaloLocalHadCoeff &&) noexcept=default
CaloLocalHadCoeff &	operator= (CaloLocalHadCoeff &&) noexcept=default
const std::string &	getTitle () const
	return name
void	setTitle (const std::string &title)
	set name
int	getSizeAreaSet () const
	return number of areas defined for this data set
void	addArea (LocalHadArea &theArea)
	add new area
void	setArea (const int n_area, const LocalHadArea &theArea)
	replace existing area with another one
const LocalHadArea *	getArea (int n_area) const
	return area
const LocalHadArea *	getAreaFromBin (int iBin) const
	return area defined for given general iBin
const LocalHadArea *	getAreaFromBin (int iBin, int &i_area) const
	return area (and area index) defined for given general iBin
int	getSizeCoeffSet () const
	return total number of coefficient sets
void	setCoeff (const int iBin, const LocalHadCoeff &theCoeff)
	set new data
const LocalHadCoeff *	getCoeff (const int &iBin) const
	get data for given general bin number
const LocalHadCoeff *	getCoeff (const int &n_area, std::vector< float > &vars) const
	get data for given area and list of cluster variables
int	getBin (const int n_area, std::vector< float > &vars) const
	calculate general bin from vector of input cluster variables
int	getBin (const int n_area, std::vector< int > &v_indexes) const
	calculate general bin from known bins in dimensions
int	bin2indexes (const int iBin, std::vector< int > &v_dim_indx) const
	expand general bin into vector of bins for defined dimensions
bool	isNeighbour (const int iBinx, std::vector< int > &v_indx) const
	are this bins is neighbour to this indexes vector (any of their indexes differ per one ?)
bool	isFilled (const int iBin) const
	check if general bin is filled
bool	getInterpArrays (const int n_area, const std::vector< int > &dim, std::vector< float > &x, std::vector< double > &xadj, std::vector< unsigned int > &gbin) const
	for interpolation, build the vector of relative x, and global bins for interpolated array for area n_area and list of dimensions (all in case dim is empty)

Private Attributes
std::string	m_title
	title of data set
std::vector< LocalHadCoeff >	m_CoeffSet
	vector of correction coefficients
std::vector< LocalHadArea >	m_AreaSet
	vector of correction areas

Detailed Description

Hold binned correction data for local hadronic calibration procedure.

defines enums and data types of CaloLocalHadCoeff

Author

Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch, Pavol Strizenec pavol.nosp@m.@mai.nosp@m.l.cer.nosp@m.n.ch

Date

20-July-2009

This class holds binned correction data in multi-dimensional space for classification, weighting, out-of-cluster or dead material correction tools. Data are holded as vector of floats for each bin defined, thereby that at the end they appear to be vector of vector of float. One data set (one CaloLocalHadCoeff) serve for one correction tool.

Binning definition is done via conception of 'correction areas'. One area has fixed number of dimenensions, fixed way how these dimensions have been binned and fixed number of correction parameters for each bin.

For example, em/had classification tool requires following setup: 3 correction coefficients (em fraction of bin, number of entries in bin, some error in bin) are binned in 4 dimensions: cluster eta, log10(cluster energy), log10(cluster energy density), log10(cluter depth).

There could be more, than one, correction area defined for one correction tool. For example, dead material correction have 8 different areas defined for different kind of dead material energy depositions (before presamplers, between emec and hec, before FCAL, etc)

Author

Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch

Date

18-August-2009

Definition at line 41 of file CaloLocalHadCoeff.h.

Member Typedef Documentation

LocalHadCoeff

typedef std::vector<float> CaloLocalHadCoeff::LocalHadCoeff

Correction parameters for one general bin.

Definition at line 220 of file CaloLocalHadCoeff.h.

Constructor & Destructor Documentation

CaloLocalHadCoeff() [1/3]

CaloLocalHadCoeff::CaloLocalHadCoeff

(

)

Default constructor.

Definition at line 162 of file CaloLocalHadCoeff.cxx.

{
   static_assert(std::is_nothrow_move_constructible<CaloLocalHadCoeff>::value);
   static_assert(std::is_nothrow_move_constructible<LocalHadArea>::value);
   static_assert(std::is_nothrow_move_constructible<LocalHadDimension>::value);
}

CaloLocalHadCoeff() [2/3]

CaloLocalHadCoeff::CaloLocalHadCoeff ( const CaloLocalHadCoeff & other )

default

Copy constructor.

CaloLocalHadCoeff() [3/3]

CaloLocalHadCoeff::CaloLocalHadCoeff ( CaloLocalHadCoeff && )

defaultnoexcept

Member Function Documentation

addArea()

void CaloLocalHadCoeff::addArea

(

LocalHadArea &

theArea

)

add new area

Definition at line 176 of file CaloLocalHadCoeff.cxx.

{
  // calculating offset for coefficients of this area using previous areas defined
  int offset = 0;
  for(unsigned int i_area=0; i_area<m_AreaSet.size(); i_area++){
    offset += m_AreaSet[i_area].getLength();
  }
  theArea.setOffset(offset);
  // adding zero coefficients
  CaloLocalHadCoeff::LocalHadCoeff pars;
  pars.resize(theArea.getNpars(), 0.0);
  for(int i_size=0; i_size<theArea.getLength(); i_size++){
    m_CoeffSet.push_back(pars);
  }
  // adding area
  m_AreaSet.push_back(theArea);
}

bin2indexes()

int CaloLocalHadCoeff::bin2indexes	(	const int	iBin,
		std::vector< int > &	v_dim_indx ) const

expand general bin into vector of bins for defined dimensions

Definition at line 301 of file CaloLocalHadCoeff.cxx.

{
  const LocalHadArea *theArea = getAreaFromBin(iBin);
  v_dim_indx.resize(theArea->getNdim(),0);
  for(int i_dim=0; i_dim<theArea->getNdim(); i_dim++){
    int x0 = 0;
    for(int j=0; j<i_dim; j++){
      x0 += v_dim_indx[j]*theArea->getDimLoc(j);
    }
    v_dim_indx[i_dim] = (iBin-theArea->getOffset()-x0)/theArea->getDimLoc(i_dim);
  }
  return 0;
}

getArea()

const CaloLocalHadCoeff::LocalHadArea * CaloLocalHadCoeff::getArea

(

int

n_area

)

const

return area

Definition at line 201 of file CaloLocalHadCoeff.cxx.

{
  if(n_area >= 0 && n_area<(int)m_AreaSet.size() ) {
    return &(m_AreaSet[n_area]);
  } else {
    return nullptr;
  }
}

getAreaFromBin() [1/2]

const CaloLocalHadCoeff::LocalHadArea * CaloLocalHadCoeff::getAreaFromBin

(

int

iBin

)

const

return area defined for given general iBin

Definition at line 211 of file CaloLocalHadCoeff.cxx.

{
  int i_area = 0;
  int narea = m_AreaSet.size();
  for(i_area=0; i_area<narea; i_area++) {
    if( iBin < m_AreaSet[i_area].getOffset() ) break;
    if( iBin >= m_AreaSet[i_area].getOffset()
        && (i_area == narea-1 || iBin < m_AreaSet[i_area+1].getOffset()) ) break;
  }
  return &(m_AreaSet[i_area]);
}

getAreaFromBin() [2/2]

const CaloLocalHadCoeff::LocalHadArea * CaloLocalHadCoeff::getAreaFromBin	(	int	iBin,
		int &	i_area ) const

return area (and area index) defined for given general iBin

Definition at line 224 of file CaloLocalHadCoeff.cxx.

{
  i_area = 0;
  int narea = m_AreaSet.size();
  for(i_area=0; i_area<narea; i_area++) {
    if( iBin < m_AreaSet[i_area].getOffset() ) break;
    if( iBin >= m_AreaSet[i_area].getOffset()
        && (i_area == narea-1 || iBin < m_AreaSet[i_area+1].getOffset()) ) break;
  }
  return &(m_AreaSet[i_area]);
}

getBin() [1/2]

int CaloLocalHadCoeff::getBin	(	const int	n_area,
		std::vector< float > &	vars ) const

calculate general bin from vector of input cluster variables

Definition at line 273 of file CaloLocalHadCoeff.cxx.

{
  const LocalHadArea *area = &m_AreaSet[n_area];
  // loop over dimensions
  int iBin = area->getOffset();
  for(int i_dim=0; i_dim<area->getNdim(); i_dim++){
    int i_bin_dim = area->getDimension(i_dim)->getBin( vars[i_dim] );
    if(i_bin_dim < 0) return -1;
    iBin += i_bin_dim*area->getDimLoc(i_dim);
  }
  return iBin;
}

getBin() [2/2]

int CaloLocalHadCoeff::getBin	(	const int	n_area,
		std::vector< int > &	v_indexes ) const

calculate general bin from known bins in dimensions

Definition at line 288 of file CaloLocalHadCoeff.cxx.

{
  const LocalHadArea *area = &m_AreaSet[n_area];
  // loop over dimensions
  int iBin = area->getOffset();
  for(int i_dim=0; i_dim<area->getNdim(); i_dim++){
    if(v_indexes[i_dim] < 0) return -1;
    iBin += v_indexes[i_dim]*area->getDimLoc(i_dim);
  }
  return iBin;
}

getCoeff() [1/2]

const CaloLocalHadCoeff::LocalHadCoeff * CaloLocalHadCoeff::getCoeff

(

const int &

iBin

)

const

get data for given general bin number

Definition at line 249 of file CaloLocalHadCoeff.cxx.

{
  if ( iBin >= 0 && iBin < (int)m_CoeffSet.size() ) {
    return (& m_CoeffSet[iBin]);
  }else{
    return nullptr;
  }
}

getCoeff() [2/2]

const CaloLocalHadCoeff::LocalHadCoeff * CaloLocalHadCoeff::getCoeff	(	const int &	n_area,
		std::vector< float > &	vars ) const

get data for given area and list of cluster variables

Definition at line 259 of file CaloLocalHadCoeff.cxx.

{
  int iBin = getBin(n_area, vars);
  return getCoeff(iBin);
}

getInterpArrays()

bool CaloLocalHadCoeff::getInterpArrays	(	const int	n_area,
		const std::vector< int > &	dim,
		std::vector< float > &	x,
		std::vector< double > &	xadj,
		std::vector< unsigned int > &	gbin ) const

for interpolation, build the vector of relative x, and global bins for interpolated array for area n_area and list of dimensions (all in case dim is empty)

Definition at line 317 of file CaloLocalHadCoeff.cxx.

                                                                                                      {
  // sanity check
  if(n_area<0 || n_area >= (int)m_AreaSet.size()) return false;
  const LocalHadArea *area=&(m_AreaSet[n_area]);
  if(dim.empty()) {
    std::cout << "CaloLocalHadCoeff::getInterpArrays() -> Error! Empty dimension list" << std::endl;
    return false;
  }else if( (int)dim.size() > area->getNdim()) {
    std::cout << "CaloLocalHadCoeff::getInterpArrays() ->  Error! Vector of dimensions to interpolate exceed defined in area." << std::endl;
    return false;
  }
  int ndim = dim.size();
 
  if((int)x.size()!= area->getNdim()) {
    std::cout<<"CaloLocalHadCoeff::getInterpArrays() -> Error! Wrong size of phase space point !!!"<<std::endl;
    return false;
  }
 
  xadj.resize(ndim);
  unsigned int ncorners = (1<<ndim);
  gbin.resize(ncorners);
 
  float xa;
  int ibin, i;
  unsigned int i_len;
  std::vector<int> vTmp;
  std::vector<int> vIdx(area->getNdim());
  std::vector<std::vector<int> > vpW;
  for(i=0; i<ndim; i++){
    ibin = (area->getDimension(dim[i]))->getBinAdjusted(x[dim[i]],xa);
    //if(xadj<0) printf("%d x:%6.3f  xadj:%6.3f ibin:%d ibin+1:%d  \n",i, x[i], xadj, ibin, ibin+1);
    xadj[i] = xa;
    vTmp.clear();
    vTmp.push_back(ibin);
    if(ibin< (area->getDimension(dim[i]))->getNbins()-1) vTmp.push_back(ibin+1);
    else vTmp.push_back(ibin);
    vpW.push_back(vTmp);
  }
  // fill the vIdx for dimensions we are not interpolating over
  for(i=0; i<area->getNdim(); ++i){
    if(std::find(dim.begin(),dim.end(),i) != dim.end()) continue;
    vIdx[i] = area->getDimension(i)->getBin(x[i]);
  }
 
  // now find the global bin for all corners
  //vTmp.clear();
  //vTmp.resize(ndim);
  for(i_len=0; i_len<ncorners; ++i_len){
    for( i=0; i<ndim; i++){
      //std::cout<<"Sec. idx: "<<int(i_len/int(pow(2,i)))%int(pow(2,i))<<std::endl;
      if(i==0) vIdx[dim[i]] = vpW[i][i_len%2];
      else vIdx[dim[i]] = vpW[i][int(i_len/int(pow(2,i)))%int(pow(2,i))];
      //if(i==2) std::cout<< vTmp[i] <<" ";  
      //std::cout<< vTmp[i] <<" ";  
    }
    // std::cout<<std::endl;
    ibin = getBin(n_area,vIdx);
    gbin[i_len] = ibin;
  }
  return true;
}

getSizeAreaSet()

int CaloLocalHadCoeff::getSizeAreaSet ( ) const

inline

return number of areas defined for this data set

Definition at line 248 of file CaloLocalHadCoeff.h.

{ return (int)m_AreaSet.size(); }

getSizeCoeffSet()

int CaloLocalHadCoeff::getSizeCoeffSet ( ) const

inline

return total number of coefficient sets

Definition at line 269 of file CaloLocalHadCoeff.h.

{ return (int)m_CoeffSet.size(); }

getTitle()

const std::string & CaloLocalHadCoeff::getTitle ( ) const

inline

return name

Definition at line 239 of file CaloLocalHadCoeff.h.

{return m_title;}

isFilled()

bool CaloLocalHadCoeff::isFilled

(

const int

iBin

)

const

check if general bin is filled

Definition at line 97 of file CaloLocalHadCoeff.cxx.

{
  if( bin<0 || bin >= (int)m_CoeffSet.size() ) {
    return false;
  }
  switch(getAreaFromBin(bin)->getType()) {
    case CaloLocalHadDefs::AREA_DMLOOKUP: case CaloLocalHadDefs::AREA_STD: {
      int ient =  CaloLocalHadDefs::BIN_ENTRIES;
      return m_CoeffSet[bin][ient] != 0;
    }
    case CaloLocalHadDefs::AREA_DMFIT:{
      return m_CoeffSet[bin][CaloLocalHadDefs::BIN_P0] != 0 || 
 
         m_CoeffSet[bin][CaloLocalHadDefs::BIN_P1] != 0 ||
 
         m_CoeffSet[bin][CaloLocalHadDefs::BIN_P2] != 0;
    }
    case CaloLocalHadDefs::AREA_DMSMPW:{
      bool bf=false;
      for(unsigned int i=0; i<m_CoeffSet[bin].size(); ++i) if(m_CoeffSet[bin][i] != 0) bf=true;
      return bf;
    }
    default:{
      std::cout<<"CaloLocalHadCoeff::isFilled() -> Error! Unknown area typ: "<<getAreaFromBin(bin)->getType()<<" in isFilled !!"<<std::endl;
      return false;
    }
  }
  // should not come here, but syntax need it:
  return false;
}

isNeighbour()

bool CaloLocalHadCoeff::isNeighbour	(	const int	iBinx,
		std::vector< int > &	v_indx ) const

are this bins is neighbour to this indexes vector (any of their indexes differ per one ?)

Definition at line 80 of file CaloLocalHadCoeff.cxx.

                                                                                 {
  // Sanity check
  if(iBinx < 0 || iBinx >= (int) m_CoeffSet.size()) return false;
  if((int)v_indx.size() != getAreaFromBin(iBinx)->getNdim()) {
     std::cout<<"CaloLocalHadCoeff::LocalHadDimension::getBinAdjusted() -> Error! Wrong indexes vector size in isNeighbour: "<< v_indx.size()<<std::endl;
     return false;
  }
  std::vector<int> xidx;
  bin2indexes(iBinx, xidx);
  for(unsigned int i=0; i<xidx.size(); ++i) {
     if(abs(v_indx[i]-xidx[i]) == 1) return true;
  }
  return false;
}

operator=() [1/2]

CaloLocalHadCoeff & CaloLocalHadCoeff::operator= ( CaloLocalHadCoeff && )

defaultnoexcept

operator=() [2/2]

CaloLocalHadCoeff & CaloLocalHadCoeff::operator= ( const CaloLocalHadCoeff & other )

default

setArea()

void CaloLocalHadCoeff::setArea	(	const int	n_area,
		const LocalHadArea &	theArea )

replace existing area with another one

Definition at line 195 of file CaloLocalHadCoeff.cxx.

{
  m_AreaSet[n_area] = theArea;
}

setCoeff()

void CaloLocalHadCoeff::setCoeff	(	const int	iBin,
		const LocalHadCoeff &	theCoeff )

set new data

Definition at line 243 of file CaloLocalHadCoeff.cxx.

{
  m_CoeffSet[iBin] = theCoeff;
}

setTitle()

void CaloLocalHadCoeff::setTitle ( const std::string & title )

inline

set name

Definition at line 242 of file CaloLocalHadCoeff.h.

{m_title = title; }

Member Data Documentation

m_AreaSet

std::vector<LocalHadArea> CaloLocalHadCoeff::m_AreaSet

private

vector of correction areas

Definition at line 312 of file CaloLocalHadCoeff.h.

m_CoeffSet

std::vector<LocalHadCoeff> CaloLocalHadCoeff::m_CoeffSet

private

vector of correction coefficients

Definition at line 309 of file CaloLocalHadCoeff.h.

m_title

std::string CaloLocalHadCoeff::m_title

private

title of data set

Definition at line 306 of file CaloLocalHadCoeff.h.

---

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

• CaloLocalHadCoeff.h
• CaloLocalHadCoeff.cxx