CaloLocalHadCoeffHelper Class Reference

#include <CaloLocalHadCoeffHelper.h>

Collaboration diagram for CaloLocalHadCoeffHelper:

Public Types
enum	keys_dim_order {   DIM_EMFRAC, DIM_SIDE, DIM_ETA, DIM_PHI,   DIM_ENER, DIM_LAMBDA, DIM_UNKNOWN }

Public Member Functions
	CaloLocalHadCoeffHelper ()
virtual	~CaloLocalHadCoeffHelper ()
CaloLocalHadCoeff *	InitDataFromFile (const char *fname)
void	PrintData (const CaloLocalHadCoeff *data, std::ostream &fout)
void	PrintData (const CaloLocalHadCoeff *data, const char *fname)
const CaloLocalHadCoeff::LocalHadArea *	getAreaFromName (const CaloLocalHadCoeff *coeff, const std::string &sname, int &indx) const

Private Member Functions
CaloLocalHadCoeff::LocalHadDimension *	parse_dim (std::string &sLine)

Detailed Description

Definition at line 14 of file CaloLocalHadCoeffHelper.h.

Member Enumeration Documentation

keys_dim_order

enum CaloLocalHadCoeffHelper::keys_dim_order

Enumerator
DIM_EMFRAC
DIM_SIDE
DIM_ETA
DIM_PHI
DIM_ENER
DIM_LAMBDA
DIM_UNKNOWN

Definition at line 17 of file CaloLocalHadCoeffHelper.h.

{ DIM_EMFRAC, DIM_SIDE, DIM_ETA, DIM_PHI, DIM_ENER, DIM_LAMBDA, DIM_UNKNOWN};

Constructor & Destructor Documentation

CaloLocalHadCoeffHelper()

CaloLocalHadCoeffHelper::CaloLocalHadCoeffHelper

(

)

Definition at line 29 of file CaloLocalHadCoeffHelper.cxx.

{
 
}

~CaloLocalHadCoeffHelper()

CaloLocalHadCoeffHelper::~CaloLocalHadCoeffHelper ( )

virtual

Definition at line 35 of file CaloLocalHadCoeffHelper.cxx.

{
 
}

Member Function Documentation

getAreaFromName()

const CaloLocalHadCoeff::LocalHadArea * CaloLocalHadCoeffHelper::getAreaFromName	(	const CaloLocalHadCoeff *	coeff,
		const std::string &	sname,
		int &	indx
	)		const

Definition at line 42 of file CaloLocalHadCoeffHelper.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 << "CaloLocalHadCoeffHelper::getAreaFromName() -> Error! No such area '" << sname << "'" << std::endl;
  return nullptr;
}

InitDataFromFile()

CaloLocalHadCoeff * CaloLocalHadCoeffHelper::InitDataFromFile

(

const char *

fname

)

Definition at line 59 of file CaloLocalHadCoeffHelper.cxx.

{
  CaloLocalHadCoeff *data = new CaloLocalHadCoeff();
 
  char cLine[MAX_BUFFER_LEN];
 
  // Find the full path to filename
  std::cout << "CaloLocalHadCoeffHelper::InitDataFromFile - Reading file '" << filename << "'." << std::endl;
 
  std::ifstream fin(filename);
  if ( !fin ) {
    std::cout << "CaloLocalHadCoeffHelper::InitDataFromFile - Can't open file '" << filename << "'." << std::endl;
    delete data; return nullptr;
  }
 
  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) ||
        area_npars < 0 || area_npars > 1000 ) {
      std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() -> Error! Could not parse line '" << cLine << "' at p1." << std::endl;
      delete data; return nullptr;
    }
 
    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;
      }
      CaloLocalHadCoeff::LocalHadDimension *dim = parse_dim(sLine);
      if( !dim ) {
        std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << sLine << "' at p2a." << std::endl;
        delete data; return nullptr;
      }
      theArea.addDimension(*dim);
      delete 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;
        delete data; return nullptr;
      }
      sLine = cLine;
      ist.clear(); ist.str(sLine);
      int idummy;
      if( !(ist >> idummy) ) {
        std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() -> Warning! Area " << theArea.getTitle() << " doesn't have parameters." << std::endl;
        break;
      }
      if(idummy != theArea.getOffset()+i_len){
        std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p3." << std::endl;
        delete data; return nullptr;
      }
      for(int j=0; j<theArea.getNdim(); j++) {
        if(!(ist >> idummy)) {
          std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() -> panic!" << std::endl;
          delete data; return nullptr;
        }
      }
      CaloLocalHadCoeff::LocalHadCoeff pars;
      pars.resize(theArea.getNpars(),0.0);
      for(int j=0; j<theArea.getNpars(); j++) {
        if( !(ist >> pars[j]) ) {
          std::cout << "CaloLocalHadCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p4." << std::endl;
          std::cout << " dmArea.m_title" << theArea.getTitle() << std::endl;
          delete data; return nullptr;
        }
      }
      data->setCoeff(theArea.getOffset()+i_len, pars);
    }
  }
  fin.close();
 
  return data;
}

parse_dim()

CaloLocalHadCoeff::LocalHadDimension * CaloLocalHadCoeffHelper::parse_dim ( std::string &  sLine )

private

Definition at line 234 of file CaloLocalHadCoeffHelper.cxx.

{
  CaloLocalHadCoeff::LocalHadDimension *dim = nullptr;
  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) ||
      dim_nbins <= 0 ||
      dim_nbins > 1000)
  {
    std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p1." << std::endl;
    return nullptr;
  }
 
  if(stype.find("flat") != std::string::npos) {
    // equidistant binning
    dim = new CaloLocalHadCoeff::LocalHadDimension(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 nullptr;
      }else{
        x_bins.push_back(e);
      }
    }
    dim = new CaloLocalHadCoeff::LocalHadDimension(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 nullptr;
  }
  return dim;
}

PrintData() [1/2]

void CaloLocalHadCoeffHelper::PrintData	(	const CaloLocalHadCoeff *	data,
		const char *	fname
	)

Definition at line 155 of file CaloLocalHadCoeffHelper.cxx.

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

PrintData() [2/2]

void CaloLocalHadCoeffHelper::PrintData	(	const CaloLocalHadCoeff *	data,
		std::ostream &	fout
	)

Definition at line 168 of file CaloLocalHadCoeffHelper.cxx.

{
  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);
      sprintf(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 << "CaloLocalHadCoeffHelper::PrintData() -> Error! Wrong bin number" << std::endl;
        return;
      }
      boost::io::ios_base_all_saver foutsave (fout);
      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:

• CaloLocalHadCoeffHelper.h
• CaloLocalHadCoeffHelper.cxx