CaloLCCoeffHelper Class Reference

#include <CaloLCCoeffHelper.h>

Collaboration diagram for CaloLCCoeffHelper:

Public Member Functions
	CaloLCCoeffHelper ()
virtual	~CaloLCCoeffHelper ()

Static Public Member Functions
static std::optional< CaloLocalHadCoeff >	InitDataFromFile (const char *fname)
static void	PrintData (CaloLocalHadCoeff *m_data, std::ostream &fout)
static void	PrintData (CaloLocalHadCoeff *m_data, const char *fname)
static const CaloLocalHadCoeff::LocalHadArea *	getAreaFromName (const CaloLocalHadCoeff *m_coeff, const std::string &sname, int &m_indx)
static bool	Interpolate (const CaloLocalHadCoeff *m_data, const unsigned int n_area, std::vector< float > &x, CaloLocalHadCoeff::LocalHadCoeff &pars, const std::vector< int > &dim, double xfit=0.)
static CaloLocalHadDefs::LocalHadDimensionId	getDimensionId (const std::string &dimensionName)

Static Private Member Functions
static std::optional< CaloLocalHadCoeff::LocalHadDimension >	parse_dim (const std::string &sLine)

Detailed Description

Definition at line 15 of file CaloLCCoeffHelper.h.

Constructor & Destructor Documentation

CaloLCCoeffHelper()

CaloLCCoeffHelper::CaloLCCoeffHelper ( )

default

~CaloLCCoeffHelper()

CaloLCCoeffHelper::~CaloLCCoeffHelper ( )

virtualdefault

Member Function Documentation

getAreaFromName()

const CaloLocalHadCoeff::LocalHadArea * CaloLCCoeffHelper::getAreaFromName ( const CaloLocalHadCoeff *  m_coeff, const std::string &  sname, int &  m_indx  )

static

Definition at line 39 of file CaloLCCoeffHelper.cxx.

{
  for(int i_area=0; i_area<coeff->getSizeAreaSet(); i_area++) {
    if(sname == coeff->getArea(i_area)->getTitle()) {
      indx = i_area;
      return coeff->getArea(i_area);
    }
  }
  std::cout << "CaloLCCoeffHelper::getAreaFromName() -> Error! No such area '" << sname << "'" << std::endl;
  return nullptr;
}

getDimensionId()

static CaloLocalHadDefs::LocalHadDimensionId CaloLCCoeffHelper::getDimensionId ( const std::string &  dimensionName )

inlinestatic

Definition at line 32 of file CaloLCCoeffHelper.h.

    {
      if(dimensionName == "DIMC_SIDE") {
        return CaloLocalHadDefs::DIMC_SIDE;
      }else if(dimensionName == "DIMC_ETA") {
        return CaloLocalHadDefs::DIMC_ETA;
      }else if(dimensionName == "DIMC_PHI") {
        return CaloLocalHadDefs::DIMC_PHI;
      }else if(dimensionName == "DIMC_ENER") {
        return CaloLocalHadDefs::DIMC_ENER;
      }else if(dimensionName == "DIMC_EDENS") {
        return CaloLocalHadDefs::DIMC_EDENS;
      }else if(dimensionName == "DIMC_LAMBDA") {
        return CaloLocalHadDefs::DIMC_LAMBDA;
 
      }else if(dimensionName == "DIMW_SIDE") {
        return CaloLocalHadDefs::DIMW_SIDE;
      }else if(dimensionName == "DIMW_ETA") {
        return CaloLocalHadDefs::DIMW_ETA;
      }else if(dimensionName == "DIMW_PHI") {
        return CaloLocalHadDefs::DIMW_PHI;
      }else if(dimensionName == "DIMW_ENER") {
        return CaloLocalHadDefs::DIMW_ENER;
      }else if(dimensionName == "DIMW_EDENS") {
        return CaloLocalHadDefs::DIMW_EDENS;
 
      }else if(dimensionName == "DIMO_SIDE") {
        return CaloLocalHadDefs::DIMO_SIDE;
      }else if(dimensionName == "DIMO_PHI") {
        return CaloLocalHadDefs::DIMO_PHI;
      }else if(dimensionName == "DIMO_ENER") {
        return CaloLocalHadDefs::DIMO_ENER;
      }else if(dimensionName == "DIMO_ETA") {
        return CaloLocalHadDefs::DIMO_ETA;
      }else if(dimensionName == "DIMO_LAMBDA") {
        return CaloLocalHadDefs::DIMO_LAMBDA;
 
      }else if(dimensionName == "DIMD_EMFRAC") {
        return CaloLocalHadDefs::DIMD_EMFRAC;
      }else if(dimensionName == "DIMD_SIDE") {
        return CaloLocalHadDefs::DIMD_SIDE;
      }else if(dimensionName == "DIMD_ETA") {
        return CaloLocalHadDefs::DIMD_ETA;
      }else if(dimensionName == "DIMD_PHI") {
        return CaloLocalHadDefs::DIMD_PHI;
      }else if(dimensionName == "DIMD_ENER") {
        return CaloLocalHadDefs::DIMD_ENER;
      }else if(dimensionName == "DIMD_LAMBDA") {
        return CaloLocalHadDefs::DIMD_LAMBDA;
 
      }else{
        //std::cout << " CaloUtils/CaloLocalHadCoeffHelper/getDimensionId() -> Error! Unknown dimension '" << dimensionName << "'" << std::endl;
        return CaloLocalHadDefs::DIMU_UNKNOWN;
      }
    }

InitDataFromFile()

std::optional< CaloLocalHadCoeff > CaloLCCoeffHelper::InitDataFromFile ( const char *  fname )

static

Definition at line 56 of file CaloLCCoeffHelper.cxx.

{
  std::optional<CaloLocalHadCoeff> data=std::make_optional<CaloLocalHadCoeff>();
 
  char cLine[1024];
 
  // Find the full path to filename
  std::cout << "CaloLCCoeffHelper::InitDataFromFile - Reading file '" << filename << "'." << std::endl;
 
  std::ifstream fin(filename);
  if ( !fin ) {
    std::cout << "CaloLCCoeffHelper::InitDataFromFile - Can't open file '" << filename << "'." << std::endl;
    return std::nullopt;
  }
 
  std::string sLine;
  std::istringstream ist;
  while(fin.getline(cLine,sizeof(cLine)-1)) {
    if( strlen(cLine)==0 ||  cLine[0] == '#' || cLine[0] == '\n') continue;
 
    // parsing area line
    sLine = cLine;
    ist.clear(); ist.str(sLine);
    std::string sdummy, area_title;
    int area_indx(0), area_type(0), area_npars(0);
    if( !(ist >> sdummy >> area_indx >> area_title >> area_type >> area_npars) ) {
      std::cout << "CaloLCCoeffHelper::initDataFromFile() -> Error! Could not parse line '" << cLine << "' at p1." << std::endl;
      return std::nullopt;
    }
 
    CaloLocalHadCoeff::LocalHadArea theArea(area_title.c_str(), area_type, area_npars);
 
    // loop over defined dimensions
    while(fin.getline(cLine,sizeof(cLine)-1)){
      if( cLine[0] == '#') continue;
      sLine = cLine;
      if(sLine.find("break") != std::string::npos) {
        break;
      }
      auto dim = parse_dim(sLine);
      if( !dim ) {
        std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << sLine << "' at p2a." << std::endl;
        return std::nullopt;
      }
      theArea.addDimension(*dim);
    }
    data->addArea(theArea);
 
    // now reading parameters
    for(int i_len=0; i_len<theArea.getLength(); i_len++){
      if(!fin.getline(cLine,sizeof(cLine)-1)) {
        std::cout << "panic " << std::endl;
        return std::nullopt;
      }
      sLine = cLine;
      ist.clear(); ist.str(sLine);
      int idummy;
      if( !(ist >> idummy) ) {
        std::cout << "CaloLCCoeffHelper::initDataFromFile() -> Warning! Area " << theArea.getTitle() << " doesn't have parameters." << std::endl;
        break;
      }
      if(idummy != theArea.getOffset()+i_len){
        std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p3." << std::endl;
        return std::nullopt;
      }
      for(int j=0; j<theArea.getNdim(); j++) {
        if(!(ist >> idummy)) {
          std::cout << "CaloLCCoeffHelper::initDataFromFile() -> panic!" << std::endl;
          return std::nullopt;
        }
      }
      CaloLocalHadCoeff::LocalHadCoeff pars;
      pars.resize(theArea.getNpars(),0.0);
      for(int j=0; j<theArea.getNpars(); j++) {
        if( !(ist >> pars[j]) ) {
          std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p4." << std::endl;
          std::cout << " dmArea.m_title" << theArea.getTitle() << std::endl;
          return std::nullopt;
        }
      }
      data->setCoeff(theArea.getOffset()+i_len, pars);
    }
  }
  fin.close();
 
  return data;
}

Interpolate()

bool CaloLCCoeffHelper::Interpolate ( const CaloLocalHadCoeff *  m_data, const unsigned int  n_area, std::vector< float > &  x, CaloLocalHadCoeff::LocalHadCoeff &  pars, const std::vector< int > &  dim, double  xfit = 0.  )

static

Definition at line 230 of file CaloLCCoeffHelper.cxx.

{
  // Sanity check
  if( n_area >= (unsigned int)data->getSizeAreaSet()) return false;
  // We are not extrapolator
  if(!data->isFilled(data->getBin(n_area,x))) {
    return false;
  }
 
  const CaloLocalHadCoeff::LocalHadArea *area = data->getArea(n_area);
  unsigned int ndim;
  if(dim.empty()) {
    std::cout << "CaloLCCoeffHelper::Interpolate() -> Error! Empty vector of dimensions to interpolate trough." << std::endl;
    return false;
  } else if ( (int)dim.size() > area->getNdim()){  
    std::cout << "CaloLCCoeffHelper::Interpolate() -> Error! Vector of dimensions to interpolate exceed defined in area." << std::endl;
    return false;
  } else ndim=dim.size();
  unsigned int ncorners = (1<<ndim);
 
  std::vector<double > vXadj(ndim);
  std::vector<unsigned int > vgbins(ncorners);
  std::vector<double > vWeights(ncorners);
  std::vector<int> ebindx;
  std::vector<int> bx;
  unsigned int nip;
 
  switch (area->getType()) {
    case CaloLocalHadDefs::AREA_STD: case CaloLocalHadDefs::AREA_DMLOOKUP : case CaloLocalHadDefs::AREA_DMSMPW: case CaloLocalHadDefs::AREA_DMFIT: {
      nip = data->getCoeff(area->getOffset()+1)->size(); 
      if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
        nip = 1;
      } else {
        nip = data->getCoeff(area->getOffset()+1)->size();
      }
      pars.resize(nip);
      for(unsigned int ip=0; ip<nip; ++ip) {
        bool isa =   data->getInterpArrays(n_area,dim,x,vXadj,vgbins);
        if(! isa) {
          std::cout<<"No arrays for x: ";
          for(unsigned int l=0; l<x.size(); ++l) std::cout<<x[l]<<" ";
          std::cout<<std::endl;
          return false;
        }
        for(unsigned int i_len=0; i_len<ncorners; ++i_len){
          // Check for empty bin here TODO !!!!!
          if(data->isFilled(vgbins[i_len])) {
            const CaloLocalHadCoeff::LocalHadCoeff * lpars =
              data->getCoeff(vgbins[i_len]);
            if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
              // std::cout << "xxx " << xfit << " " << (*pars)[0] << " " << (*pars)[1] << " " << (*pars)[2] << std::endl;
              vWeights[i_len] = (*lpars)[0] + (*lpars)[1]*pow(xfit,(*lpars)[2]);
              } else {
                vWeights[i_len] = (*lpars)[ip];
              }
              //   std::cout<<vWeights[i_len]<<" ";
          } else {
            // std::cout<<x[0]<<" "<<x[1]<<"  :  "<<vXadj[0]<<" "<<vXadj[1]<<" | ";
            // if empty, put inside average over all neighbours in our list
            vWeights[i_len] = 0.;
            unsigned int icount = 0;
            data->bin2indexes(vgbins[i_len],ebindx);
            // for(unsigned int blen=0; blen<ebindx.size(); ++blen) { std::cout<<ebindx[blen]<<" "; }
            //std::cout<<" | ";
            for(unsigned int blen=0; blen<ncorners; ++blen){
              if(blen == i_len) continue;
              if(!data->isFilled(vgbins[blen])){
                data->bin2indexes(vgbins[i_len],bx);
                //for(unsigned int l=0; l<bx.size(); ++l) { std::cout<<bx[l]<<" "; }
                //std::cout<<" nf| ";
                continue;
              }
              if(data->isNeighbour(vgbins[blen], ebindx)) {
                const CaloLocalHadCoeff::LocalHadCoeff * lpars =
                  data->getCoeff(vgbins[blen]);
                if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
                  vWeights[i_len] = (*lpars)[0] + (*lpars)[1]*pow(xfit,(*lpars)[2]);
                } else {
                  vWeights[i_len] += (*lpars)[ip];
                }
                ++icount;
              } 
            }
            if(icount) {
              //std::cout<<"i"; 
              vWeights[i_len] /= icount;
            }
            //std::cout<<vWeights[i_len]<<"a ";
            //std::cout<<std::endl;
          }
        }
        pars[ip] = CaloWeightInterpolator::getWeight(vWeights,vXadj);
      }
      return true;
    }
    default: {
      std::cout<<"Not implemented yet for this Area type !!!"<<std::endl;
      return false;
    }
  }
  // Should not get here, but syntax needs this
  return false;
}

parse_dim()

std::optional< CaloLocalHadCoeff::LocalHadDimension > CaloLCCoeffHelper::parse_dim ( const std::string &  sLine )

staticprivate

Definition at line 341 of file CaloLCCoeffHelper.cxx.

{
  std::optional<CaloLocalHadCoeff::LocalHadDimension> dim{std::nullopt};
  std::istringstream ist(sLine.c_str());
 
  std::string dim_title;
  std::string stype;
  int dim_nbins(0), dim_type(0);
  float dim_xmax(0), dim_xmin(0);
 
  if( !(ist >> dim_title >> dim_nbins >> dim_xmin >> dim_xmax >> stype) ){
    std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p1." << std::endl;
    return std::nullopt;
  }
 
  // Check nbins for reasonableness --- prevents a coverity warning.
  if (dim_nbins < 1)
    dim_nbins = 1;
  else if (dim_nbins > 10000)
    dim_nbins = 10000;
 
  if(stype.find("flat") != std::string::npos) {
    // equidistant binning
    dim.emplace(dim_title.c_str(), dim_type, dim_nbins, dim_xmin, dim_xmax);
  }else if(stype.find("hand") != std::string::npos) {
    // user defined binning
    std::vector<float> x_bins;
    float e;
    for(int i=0; i<dim_nbins+1; i++) {
      if( !(ist >> e) ) {
        std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p2." << std::endl;
        return std::nullopt;
      }else{
        x_bins.push_back(e);
      }
    }
    dim.emplace(dim_title.c_str(), dim_type, x_bins);
  }else{
    std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p3." << std::endl;
    return std::nullopt;
  }
  return dim;
}

PrintData() [1/2]

void CaloLCCoeffHelper::PrintData ( CaloLocalHadCoeff *  m_data, const char *  fname  )

static

Definition at line 149 of file CaloLCCoeffHelper.cxx.

{
  std::ofstream fout;
  fout.open(fname);
  PrintData(data, fout);
  fout.close();
}

PrintData() [2/2]

void CaloLCCoeffHelper::PrintData ( CaloLocalHadCoeff *  m_data, std::ostream &  fout  )

static

Definition at line 162 of file CaloLCCoeffHelper.cxx.

{
  boost::io::ios_base_all_saver ifs (fout);
  const char *comments = 
  {
    "# Coefficients for local hadronic calibration .\n\n"
  };
  fout << comments << std::endl;
  char line[1024];
 
  // loop over areas
  for(int i_area=0; i_area < data->getSizeAreaSet(); i_area++){
    const CaloLocalHadCoeff::LocalHadArea *area = data->getArea(i_area);
    fout << "area  " << i_area << "  " << area->getTitle() << "  " << area->getType() << " " << area->getNpars() << std::endl;
    for(int i_dim=0; i_dim<area->getNdim(); i_dim++){
      const CaloLocalHadCoeff::LocalHadDimension *dim = area->getDimension(i_dim);
      snprintf(line,sizeof(line),
               "%-6s %2d %6.3f %12.3f ",dim->getTitle().c_str(), dim->getNbins(), dim->getXmin(), dim->getXmax() );
       std::string sline(line);
       sline += "flat";
       fout << sline;
//       if( !dim.m_xbins.size() ) {
//         sline += "flat";
//         fout << sline;
//       }else {
//         sline += "hand";
//         fout << sline;
//         for(unsigned int i=0; i<dim.m_xbins.size(); i++){
//           fout << " " << dim.m_xbins[i];
//         }
//       }
      fout << std::endl;
    }
    fout << "break" << std::endl; // i.e. no more dimensions
 
    // now printing the data
    for(int i_data=0; i_data<area->getLength(); i_data++) {
      int indx = area->getOffset() + i_data;
      const CaloLocalHadCoeff::LocalHadCoeff *pars = data->getCoeff(indx);
      if( !pars ) {
        std::cout << "CaloLCCoeffHelper::PrintData() -> Error! Wrong bin number" << std::endl;
        return;
      }
      fout << std::setw(5) << indx << "   ";
      std::vector<int > v_dim_indexes;
      data->bin2indexes(indx, v_dim_indexes);
      for(unsigned int i_dim=0; i_dim<v_dim_indexes.size(); i_dim++){
        fout << std::setw(4) << v_dim_indexes[i_dim]  << " ";
      }
      fout << "     ";
      for(unsigned int i_par=0; i_par<(*pars).size(); i_par++) {
        fout << std::fixed << std::setprecision(6) << std::setw(12) << (*pars)[i_par] << " ";
      }
      fout << std::endl;
    }
 
    // end of DM area
    fout << std::endl;
  }
  // printing title strin
}

---

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

• CaloLCCoeffHelper.h
• CaloLCCoeffHelper.cxx