ATLAS Offline Software
CaloLCCoeffHelper.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // //-----------------------------------------------------------------------
6 // File and Version Information:
7 // $Id: CaloHadDMCoeffHelper.cxx,v 1.2 2009-03-06 14:43:23 pospelov Exp $
8 //
9 // Description: see CaloHadDMCoeffHelper.h
10 //
11 // Environment:
12 // Software developed for the ATLAS Detector at CERN LHC
13 //
14 // Author List:
15 // Gennady Pospelov
16 //
17 //-----------------------------------------------------------------------
19 #include <iostream>
20 #include <sstream>
21 #include <cstring>
22 #include <iomanip>
23 #include <cmath>
24 #include "boost/io/ios_state.hpp"
25 
28 
29 
31 = default;
32 
33 
35 = default;
36 
37 
38 // get HadDMArea from area name
39 const CaloLocalHadCoeff::LocalHadArea * CaloLCCoeffHelper::getAreaFromName(const CaloLocalHadCoeff * coeff, const std::string& sname, int &indx)
40 {
41  for(int i_area=0; i_area<coeff->getSizeAreaSet(); i_area++) {
42  if(sname == coeff->getArea(i_area)->getTitle()) {
43  indx = i_area;
44  return coeff->getArea(i_area);
45  }
46  }
47  std::cout << "CaloLCCoeffHelper::getAreaFromName() -> Error! No such area '" << sname << "'" << std::endl;
48  return nullptr;
49 }
50 
51 
52 
53 /* ****************************************************************************
54 To read set of local hadronic coefficients from text file
55 **************************************************************************** */
56 std::optional<CaloLocalHadCoeff> CaloLCCoeffHelper::InitDataFromFile(const char *filename)
57 {
58  std::optional<CaloLocalHadCoeff> data=std::make_optional<CaloLocalHadCoeff>();
59 
60  char cLine[1024];
61 
62  // Find the full path to filename
63  std::cout << "CaloLCCoeffHelper::InitDataFromFile - Reading file '" << filename << "'." << std::endl;
64 
65  std::ifstream fin(filename);
66  if ( !fin ) {
67  std::cout << "CaloLCCoeffHelper::InitDataFromFile - Can't open file '" << filename << "'." << std::endl;
68  return std::nullopt;
69  }
70 
71  std::string sLine;
72  std::istringstream ist;
73  while(fin.getline(cLine,sizeof(cLine)-1)) {
74  if( strlen(cLine)==0 || cLine[0] == '#' || cLine[0] == '\n') continue;
75 
76  // parsing area line
77  sLine = cLine;
78  ist.clear(); ist.str(sLine);
79  std::string sdummy, area_title;
80  int area_indx(0), area_type(0), area_npars(0);
81  if( !(ist >> sdummy >> area_indx >> area_title >> area_type >> area_npars) ||
82  area_npars < 0 || area_npars > 1000 ) {
83  std::cout << "CaloLCCoeffHelper::initDataFromFile() -> Error! Could not parse line '" << cLine << "' at p1." << std::endl;
84  return std::nullopt;
85  }
86 
87  CaloLocalHadCoeff::LocalHadArea theArea(area_title.c_str(), area_type, area_npars);
88 
89  // loop over defined dimensions
90  while(fin.getline(cLine,sizeof(cLine)-1)){
91  if( cLine[0] == '#') continue;
92  sLine = cLine;
93  if(sLine.find("break") != std::string::npos) {
94  break;
95  }
96  auto dim = parse_dim(sLine);
97  if( !dim ) {
98  std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << sLine << "' at p2a." << std::endl;
99  return std::nullopt;
100  }
101  theArea.addDimension(*dim);
102  }
103  data->addArea(theArea);
104 
105  // now reading parameters
106  for(int i_len=0; i_len<theArea.getLength(); i_len++){
107  if(!fin.getline(cLine,sizeof(cLine)-1)) {
108  std::cout << "panic " << std::endl;
109  return std::nullopt;
110  }
111  sLine = cLine;
112  ist.clear(); ist.str(sLine);
113  int idummy;
114  if( !(ist >> idummy) ) {
115  std::cout << "CaloLCCoeffHelper::initDataFromFile() -> Warning! Area " << theArea.getTitle() << " doesn't have parameters." << std::endl;
116  break;
117  }
118  if(idummy != theArea.getOffset()+i_len){
119  std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p3." << std::endl;
120  return std::nullopt;
121  }
122  for(int j=0; j<theArea.getNdim(); j++) {
123  if(!(ist >> idummy)) {
124  std::cout << "CaloLCCoeffHelper::initDataFromFile() -> panic!" << std::endl;
125  return std::nullopt;
126  }
127  }
129  pars.resize(theArea.getNpars(),0.0);
130  for(int j=0; j<theArea.getNpars(); j++) {
131  if( !(ist >> pars[j]) ) {
132  std::cout << "CaloLCCoeffHelper::initDataFromFile() ->Error! Could not parse line '" << cLine << "' at p4." << std::endl;
133  std::cout << " dmArea.m_title" << theArea.getTitle() << std::endl;
134  return std::nullopt;
135  }
136  }
137  data->setCoeff(theArea.getOffset()+i_len, pars);
138  }
139  }
140  fin.close();
141 
142  return data;
143 }
144 
145 
146 
147 /* ****************************************************************************
148 
149 **************************************************************************** */
151 {
152  std::ofstream fout;
153  fout.open(fname);
154  PrintData(data, fout);
155  fout.close();
156 }
157 
158 
159 
160 /* ****************************************************************************
161 
162 **************************************************************************** */
164 {
165  boost::io::ios_base_all_saver ifs (fout);
166  const char *comments =
167  {
168  "# Coefficients for local hadronic calibration .\n\n"
169  };
170  fout << comments << std::endl;
171  char line[1024];
172 
173  // loop over areas
174  for(int i_area=0; i_area < data->getSizeAreaSet(); i_area++){
175  const CaloLocalHadCoeff::LocalHadArea *area = data->getArea(i_area);
176  fout << "area " << i_area << " " << area->getTitle() << " " << area->getType() << " " << area->getNpars() << std::endl;
177  for(int i_dim=0; i_dim<area->getNdim(); i_dim++){
178  const CaloLocalHadCoeff::LocalHadDimension *dim = area->getDimension(i_dim);
179  snprintf(line,sizeof(line),
180  "%-6s %2d %6.3f %12.3f ",dim->getTitle().c_str(), dim->getNbins(), dim->getXmin(), dim->getXmax() );
181  std::string sline(line);
182  sline += "flat";
183  fout << sline;
184 // if( !dim.m_xbins.size() ) {
185 // sline += "flat";
186 // fout << sline;
187 // }else {
188 // sline += "hand";
189 // fout << sline;
190 // for(unsigned int i=0; i<dim.m_xbins.size(); i++){
191 // fout << " " << dim.m_xbins[i];
192 // }
193 // }
194  fout << std::endl;
195  }
196  fout << "break" << std::endl; // i.e. no more dimensions
197 
198  // now printing the data
199  for(int i_data=0; i_data<area->getLength(); i_data++) {
200  int indx = area->getOffset() + i_data;
201  const CaloLocalHadCoeff::LocalHadCoeff *pars = data->getCoeff(indx);
202  if( !pars ) {
203  std::cout << "CaloLCCoeffHelper::PrintData() -> Error! Wrong bin number" << std::endl;
204  return;
205  }
206  fout << std::setw(5) << indx << " ";
207  std::vector<int > v_dim_indexes;
208  data->bin2indexes(indx, v_dim_indexes);
209  for(unsigned int i_dim=0; i_dim<v_dim_indexes.size(); i_dim++){
210  fout << std::setw(4) << v_dim_indexes[i_dim] << " ";
211  }
212  fout << " ";
213  for(unsigned int i_par=0; i_par<(*pars).size(); i_par++) {
214  fout << std::fixed << std::setprecision(6) << std::setw(12) << (*pars)[i_par] << " ";
215  }
216  fout << std::endl;
217  }
218 
219  // end of DM area
220  fout << std::endl;
221  }
222  // printing title strin
223 }
224 
225 
226 
227 /* **************************************************************************
228  Interpolate data, area in phase space point x, over dimensions dim (all if 0)
229  for speed reason, no check on dim content !!!!!!!!
230 *************************************************************************** */
231 bool CaloLCCoeffHelper::Interpolate(const CaloLocalHadCoeff *data, const unsigned int n_area,
232  std::vector<float> &x, CaloLocalHadCoeff::LocalHadCoeff &pars,
233  const std::vector<int> &dim, double xfit)
234 {
235  // Sanity check
236  if( n_area >= (unsigned int)data->getSizeAreaSet()) return false;
237  // We are not extrapolator
238  if(!data->isFilled(data->getBin(n_area,x))) {
239  return false;
240  }
241 
242  const CaloLocalHadCoeff::LocalHadArea *area = data->getArea(n_area);
243  unsigned int ndim;
244  if(dim.empty()) {
245  std::cout << "CaloLCCoeffHelper::Interpolate() -> Error! Empty vector of dimensions to interpolate trough." << std::endl;
246  return false;
247  } else if ( (int)dim.size() > area->getNdim()){
248  std::cout << "CaloLCCoeffHelper::Interpolate() -> Error! Vector of dimensions to interpolate exceed defined in area." << std::endl;
249  return false;
250  } else ndim=dim.size();
251  unsigned int ncorners = (1<<ndim);
252 
253  std::vector<double > vXadj(ndim);
254  std::vector<unsigned int > vgbins(ncorners);
255  std::vector<double > vWeights(ncorners);
256  std::vector<int> ebindx;
257  std::vector<int> bx;
258  unsigned int nip;
259 
260  switch (area->getType()) {
262  nip = data->getCoeff(area->getOffset()+1)->size();
263  if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
264  nip = 1;
265  } else {
266  nip = data->getCoeff(area->getOffset()+1)->size();
267  }
268  pars.resize(nip);
269  for(unsigned int ip=0; ip<nip; ++ip) {
270  bool isa = data->getInterpArrays(n_area,dim,x,vXadj,vgbins);
271  if(! isa) {
272  std::cout<<"No arrays for x: ";
273  for(unsigned int l=0; l<x.size(); ++l) std::cout<<x[l]<<" ";
274  std::cout<<std::endl;
275  return false;
276  }
277  for(unsigned int i_len=0; i_len<ncorners; ++i_len){
278  // Check for empty bin here TODO !!!!!
279  if(data->isFilled(vgbins[i_len])) {
280  const CaloLocalHadCoeff::LocalHadCoeff * lpars =
281  data->getCoeff(vgbins[i_len]);
282  if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
283  // std::cout << "xxx " << xfit << " " << (*pars)[0] << " " << (*pars)[1] << " " << (*pars)[2] << std::endl;
284  vWeights[i_len] = (*lpars)[0] + (*lpars)[1]*pow(xfit,(*lpars)[2]);
285  } else {
286  vWeights[i_len] = (*lpars)[ip];
287  }
288  // std::cout<<vWeights[i_len]<<" ";
289  } else {
290  // std::cout<<x[0]<<" "<<x[1]<<" : "<<vXadj[0]<<" "<<vXadj[1]<<" | ";
291  // if empty, put inside average over all neighbours in our list
292  vWeights[i_len] = 0.;
293  unsigned int icount = 0;
294  data->bin2indexes(vgbins[i_len],ebindx);
295  // for(unsigned int blen=0; blen<ebindx.size(); ++blen) { std::cout<<ebindx[blen]<<" "; }
296  //std::cout<<" | ";
297  for(unsigned int blen=0; blen<ncorners; ++blen){
298  if(blen == i_len) continue;
299  if(!data->isFilled(vgbins[blen])){
300  data->bin2indexes(vgbins[i_len],bx);
301  //for(unsigned int l=0; l<bx.size(); ++l) { std::cout<<bx[l]<<" "; }
302  //std::cout<<" nf| ";
303  continue;
304  }
305  if(data->isNeighbour(vgbins[blen], ebindx)) {
306  const CaloLocalHadCoeff::LocalHadCoeff * lpars =
307  data->getCoeff(vgbins[blen]);
308  if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
309  vWeights[i_len] = (*lpars)[0] + (*lpars)[1]*pow(xfit,(*lpars)[2]);
310  } else {
311  vWeights[i_len] += (*lpars)[ip];
312  }
313  ++icount;
314  }
315  }
316  if(icount) {
317  //std::cout<<"i";
318  vWeights[i_len] /= icount;
319  }
320  //std::cout<<vWeights[i_len]<<"a ";
321  //std::cout<<std::endl;
322  }
323  }
324  pars[ip] = CaloWeightInterpolator::getWeight(vWeights,vXadj);
325  }
326  return true;
327  }
328  default: {
329  std::cout<<"Not implemented yet for this Area type !!!"<<std::endl;
330  return false;
331  }
332  }
333  // Should not get here, but syntax needs this
334  return false;
335 }
336 
337 
338 
339 /* **************************************************************************
340 parsing dimension string of type 'ener 8 3.1 6.3'
341 *************************************************************************** */
342 std::optional<CaloLocalHadCoeff::LocalHadDimension> CaloLCCoeffHelper::parse_dim(const std::string &sLine)
343 {
344  std::optional<CaloLocalHadCoeff::LocalHadDimension> dim{std::nullopt};
345  std::istringstream ist(sLine.c_str());
346 
347  std::string dim_title;
348  std::string stype;
349  int dim_nbins(0), dim_type(0);
350  float dim_xmax(0), dim_xmin(0);
351 
352  if( !(ist >> dim_title >> dim_nbins >> dim_xmin >> dim_xmax >> stype) ){
353  std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p1." << std::endl;
354  return std::nullopt;
355  }
356 
357  // Check nbins for reasonableness --- prevents a coverity warning.
358  if (dim_nbins < 1)
359  dim_nbins = 1;
360  else if (dim_nbins > 10000)
361  dim_nbins = 10000;
362 
363  if(stype.find("flat") != std::string::npos) {
364  // equidistant binning
365  dim.emplace(dim_title.c_str(), dim_type, dim_nbins, dim_xmin, dim_xmax);
366  }else if(stype.find("hand") != std::string::npos) {
367  // user defined binning
368  std::vector<float> x_bins;
369  float e;
370  for(int i=0; i<dim_nbins+1; i++) {
371  if( !(ist >> e) ) {
372  std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p2." << std::endl;
373  return std::nullopt;
374  }else{
375  x_bins.push_back(e);
376  }
377  }
378  dim.emplace(dim_title.c_str(), dim_type, x_bins);
379  }else{
380  std::cout << "CaloHadDMCoeffHelper::parse_dim() -> Error! Could not parse line '" << sLine << "' at p3." << std::endl;
381  return std::nullopt;
382  }
383  return dim;
384 }
385 
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
CaloLocalHadCoeff::LocalHadDimension
Class defines binning for user dimension.
Definition: CaloLocalHadCoeff.h:47
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
CaloLCCoeffHelper::getAreaFromName
static const CaloLocalHadCoeff::LocalHadArea * getAreaFromName(const CaloLocalHadCoeff *m_coeff, const std::string &sname, int &m_indx)
Definition: CaloLCCoeffHelper.cxx:39
WriteBchToCool.comments
comments
Definition: WriteBchToCool.py:297
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
CaloLocalHadDefs.h
CaloLocalHadDefs::AREA_DMFIT
@ AREA_DMFIT
Definition: CaloLocalHadDefs.h:21
CaloLocalHadCoeff::LocalHadArea::getOffset
int getOffset() const
return area offset
Definition: CaloLocalHadCoeff.h:175
CaloLocalHadDefs::AREA_DMSMPW
@ AREA_DMSMPW
Definition: CaloLocalHadDefs.h:23
CaloLCCoeffHelper::InitDataFromFile
static std::optional< CaloLocalHadCoeff > InitDataFromFile(const char *fname)
Definition: CaloLCCoeffHelper.cxx:56
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
CaloLocalHadCoeff::LocalHadArea::getLength
int getLength() const
return area length
Definition: CaloLocalHadCoeff.h:177
CaloLCCoeffHelper::~CaloLCCoeffHelper
virtual ~CaloLCCoeffHelper()
x
#define x
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
CaloWeightInterpolator.h
CaloLocalHadCoeff::LocalHadCoeff
std::vector< float > LocalHadCoeff
Correction parameters for one general bin.
Definition: CaloLocalHadCoeff.h:220
CaloLocalHadCoeff::LocalHadArea::addDimension
void addDimension(LocalHadDimension &dim)
to add new dimension
Definition: CaloLocalHadCoeff.cxx:135
lumiFormat.i
int i
Definition: lumiFormat.py:85
dqt_zlumi_alleff_HIST.fout
fout
Definition: dqt_zlumi_alleff_HIST.py:59
fitman.bx
bx
Definition: fitman.py:410
CaloLocalHadCoeff
Hold binned correction data for local hadronic calibration procedure.
Definition: CaloLocalHadCoeff.h:41
CaloLCCoeffHelper::CaloLCCoeffHelper
CaloLCCoeffHelper()
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
CaloLCCoeffHelper.h
CaloLocalHadCoeff::LocalHadArea::getNdim
int getNdim() const
get number of dimensions
Definition: CaloLocalHadCoeff.h:179
CaloLCCoeffHelper::Interpolate
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.)
Definition: CaloLCCoeffHelper.cxx:231
CaloLocalHadCoeff::LocalHadArea::getNpars
int getNpars() const
return number of parameters
Definition: CaloLocalHadCoeff.h:173
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
MuonCalib::Legendre::coeff
constexpr double coeff(const unsigned l, const unsigned k)
Calculates the n-th coefficient of the legendre polynomial series.
Definition: LegendrePoly.h:92
CaloLocalHadDefs::AREA_STD
@ AREA_STD
Definition: CaloLocalHadDefs.h:20
CaloLocalHadCoeff::LocalHadArea::getTitle
const std::string & getTitle() const
return name
Definition: CaloLocalHadCoeff.h:183
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
CaloLocalHadCoeff::LocalHadArea
Definition of correction area.
Definition: CaloLocalHadCoeff.h:145
compute_lumi.fin
fin
Definition: compute_lumi.py:19
CaloLCCoeffHelper::parse_dim
static std::optional< CaloLocalHadCoeff::LocalHadDimension > parse_dim(const std::string &sLine)
Definition: CaloLCCoeffHelper.cxx:342
area
double area(double R)
Definition: ConvertStaveServices.cxx:42
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
CaloWeightInterpolator::getWeight
static double getWeight(std::vector< double > &w, std::vector< double > &x)
Definition: CaloWeightInterpolator.cxx:26
CaloLCCoeffHelper::PrintData
static void PrintData(CaloLocalHadCoeff *m_data, std::ostream &fout)
Definition: CaloLCCoeffHelper.cxx:163
CaloLocalHadDefs::AREA_DMLOOKUP
@ AREA_DMLOOKUP
Definition: CaloLocalHadDefs.h:22