ATLAS Offline Software
Functions | Variables
CalibrateIBL.cxx File Reference
#include "CxxUtils/checker_macros.h"
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <sstream>
#include <utility>
#include <map>
#include <array>
#include "TFile.h"
#include "TDirectory.h"
#include "TDirectoryFile.h"
#include "TKey.h"
#include "TH2D.h"
#include "TH2F.h"
#include "TProfile.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TMultiGraph.h"
#include "TMath.h"
#include "TF1.h"
#include "TStyle.h"
#include "TVectorT.h"
#include "THStack.h"
#include "TRandom3.h"
#include "ChargeCalibration/common/PixelMapping.h"
#include "PathResolver/PathResolver.h"

Go to the source code of this file.

Functions

double funcDisp (double *x, double *par)
 
double ChrgfromToT (float tot, double par[10])
 
double ToTfromChrg (float chrg, double par[5])
 
double funcRation5 (double *x, double *par)
 
double funcDispConvoluted (double *x, double *par)
 
int iblCalib (const std::string &InDir, const std::string &THRscan, const std::string &scan, const std::string &scanLowCharge)
 
void printError ()
 
int main (int argc, char *argv[])
 

Variables

 ATLAS_NO_CHECK_FILE_THREAD_SAFETY
 

Function Documentation

◆ ChrgfromToT()

double ChrgfromToT ( float  tot,
double  par[10] 
)

Definition at line 67 of file CalibrateIBL.cxx.

68 {
69  int lr = (tot <= 6. ? 0 : 5);
70  double chrg = 1400.;
71 
72  double num = par[0 + lr] + tot * (par[1 + lr] + tot * (par[2 + lr] + tot * par[3 + lr]));
73  double denom = 1. + tot * par[4 + lr];
74  if (denom != 0.)
75  chrg = num / denom;
76 
77  return chrg;
78 }

◆ funcDisp()

double funcDisp ( double *  x,
double *  par 
)

Definition at line 60 of file CalibrateIBL.cxx.

61 {
62  double ret = 9.9e10;
63  ret = par[0] * 0.1 * (1. - exp(-(x[0] - 1400.) * (x[0] - 1400.) / (1000. * par[1])) + par[2] * 0.0001 * sqrt(x[0]));
64  return ret;
65 }

◆ funcDispConvoluted()

double funcDispConvoluted ( double *  x,
double *  par 
)

Definition at line 100 of file CalibrateIBL.cxx.

101 {
102  double ret = 9.9e09;
103  ret = -par[0] * (x[0] - par[1]) + par[2];
104  return ret;
105 }

◆ funcRation5()

double funcRation5 ( double *  x,
double *  par 
)

Definition at line 90 of file CalibrateIBL.cxx.

91 {
92  double ret = 9.9e10;
93  double num = par[0] + x[0] * (par[1] + x[0] * (par[2] + x[0] * par[3]));
94  double denom = 1. + x[0] * par[4];
95  if (denom != 0.0)
96  ret = num / denom;
97  return ret;
98 }

◆ iblCalib()

int iblCalib ( const std::string &  InDir,
const std::string &  THRscan,
const std::string &  scan,
const std::string &  scanLowCharge 
) 
    TF1 f1Disp( "f1Disp", funcDisp_old, chrgAbaciIBL[1], chrgAbaciIBL[nchargeIBL-1], 2 );
    grTotSig->Fit( &f1Disp,"MRQ" );
    Double_t parP0 = 1.*f1Disp.GetParameter(0);
    Double_t parP1 = 1.*f1Disp.GetParameter(1);
    Double_t parP2 = 0. ;

    TF1 f1Disp( "f1Disp", funcDisp, chrgAbaciIBL[1], chrgAbaciIBL[nchargeIBL-1], 3 );
    f1Disp.SetParLimits( 0, 3, 7 ) ;
    f1Disp.SetParLimits( 1, 300., 1000. ) ;
    f1Disp.SetParLimits( 2, -5, 5 ) ;

    grTotSig->Fit( &f1Disp,"MRQ" );
    Double_t parP0 = 1.*f1Disp.GetParameter(0);
    Double_t parP1 = 1.*f1Disp.GetParameter(1);
    Double_t parP2 = 1.*f1Disp.GetParameter(2);

paraToTRes[sfe][0] = parP0; paraToTRes[sfe][1] = parP1; paraToTRes[sfe][2] = parP2;

Definition at line 107 of file CalibrateIBL.cxx.

108 {
109  // creating the object for the pixel mapping
110  PixelMapping pixmap(PathResolver::find_file("PixelCalibAlgs/mapping.csv", "DATAPATH"));
111 
112  const bool run3 = true; // new series of injection charges (22) and new format
113  const float badRDfracCut = 0.2; // Cut on the fraction of bad read out per frontend
114  float HDCshift = 2;
115 
116  // Shall we try this later ?
117  const int finerToT = 1; // smaller bin size for ToT if doing fit
118  constexpr bool moreFE = false;
119  constexpr int npsFEs = moreFE ? 8 : 2;
120 
121  gStyle->SetOptFit(1100);
122 
123 #if defined(DEMOXCHECK)
124 
125  std::cout << " DEMOXCHECK will run ... " << std::endl;
126 
127  // For debugging a small area of pixels will print their readout and injection
128  int XcheckCharge[2] = {13, 14}, XcheckToT = 10;
129  int XcheckPhi[2] = {57, 63}, XcheckEta[2] = {23, 29};
130  TString XcheckModule = "LI_S11_A_M3_A6";
131 
132  // fill some histograms for monitoring
133  int ToTfill = 3 * finerToT, CHRGfill = 3;
134  const int HDC = 2; // specifying output
135 
136 #endif
137 
138  Double_t tmpRCf_H[4] = {0.868295, 0.67523, 0.732279, 0.678458}; // initial values from history calibration
139  Double_t tmpRCf_T[4] = {1.02844, 1.10788, 1.07204, 1.11015}; // initial values from history calibration
140  Double_t reverseCF_H[4], reverseCF_T[4];
141  for (int t = 0; t < 4; t++)
142  {
143  reverseCF_H[t] = tmpRCf_H[t];
144  reverseCF_T[t] = tmpRCf_T[t];
145  }
146 
147  Double_t RDentries[33] = {0, 10494.8, 14605.6, 62952.6, 8663.57, 17320.2, 20417, 49508.9,
148  21646.8, 31503.9, 14955.6, 16290.7, 11617.5, 16461.2, 11980.5, 17210.5,
149  12773.7, 18574, 13930.9, 19777, 14629.4, 20619.5, 15191.6, 20883,
150  15411.1, 19198, 12097.4, 12109.7, 8881.96, 17235.1, 20802.3, 11265.8,
151  0.};
152 
153  std::vector<int> reversedModules = {182, 211, 213, 229, 223, 231, 246, 280, 295, 350, 357, 360, 371, 403, 416, 423};
154 
155  // outputs : something@somewhere as one like ...
156  TString Outdir = "./";
157  string spec = "ToTbin" + to_string(finerToT) + "_FrtEnd" + to_string(npsFEs) + "_";
158 
159 #if defined(DEMOXCHECK)
160  spec += "DEMOXCHECK_";
161 #endif
162 
163  TString StrFileName = spec + scan;
164  TString rootFileName = Outdir + "/TotChargeCalib_" + StrFileName + ".root";
165  TString logFileName = Outdir + "/ChargeCalib_" + StrFileName + ".log";
166  TString dbFileName = Outdir + "/ChargeCalib_" + StrFileName + ".TXT";
167  if (!run3)
168  {
169  rootFileName = Outdir + "/TotChargeCalib_run2_" + StrFileName + ".root";
170  logFileName = Outdir + "/ChargeCalib_run2_" + StrFileName + ".log";
171  dbFileName = Outdir + "/ChargeCalib_run2_" + StrFileName + ".TXT";
172  }
173 
174  // fetch pictures from directory : ToT/ROD_L1_Sxx/LI_Sy_AC_Mz_ACk
175  ofstream logout(logFileName);
176  ofstream txtDB(dbFileName);
177 
178  TString inThrFile = "";
179  TString inTotFile = "";
180  TString rodPath = "";
181  TString inTotFileAux = "";
182  TString rodPathAux = "";
183 
184  std::cout << " Running IBL calibration analysis ... " << endl;
185 
186  inThrFile = InDir + THRscan + ".root";
187  inTotFile = InDir + scan + ".root";
188  rodPath = inTotFile + ":/" + scan.substr(scan.find("_")+1);
189  inTotFileAux = InDir + scanLowCharge + ".root";
190  rodPathAux = inTotFileAux + ":/" + scanLowCharge.substr(scanLowCharge.find("_")+1);
191 
192  // historical record for run2 fomat
193  if (!run3)
194  {
195  inThrFile = "calib2018/IBL/THR_SCAN_S000083686.root";
196  inTotFile = "calib2018/IBL/TOT_SCAN_S000083690.root";
197  rodPath = inTotFile + ":/S000083690";
198  }
199 
200  // selecting Q threshold
201  int nrow = 336, ncol = 160; // y-axis, x-axis respectively
202 
203  const Int_t numChrgs = 22;
204  Double_t IBLchrgs[numChrgs] = {1400., 1500., 1750., 2000., 2500., 3000., 3500., 4000., 5000., 6000., 8000., 10000.,
205  12000., 14000., 16000., 18000., 20000., 22000., 24000., 26000., 28000., 30000.};
206 
207  const Int_t nchargeIBL = (run3 ? 22 : 19);
208 
209  int skip = numChrgs - nchargeIBL;
210  Double_t chrgAbaciIBL[nchargeIBL], chargeErrArrIBL[nchargeIBL];
211  for (int c = 0; c < nchargeIBL; c++)
212  {
213  chrgAbaciIBL[c] = IBLchrgs[c + skip];
214  chargeErrArrIBL[c] = 0.;
215  }
216 
217  Double_t chrgsbins[nchargeIBL + 1];
218  for (int c = 1; c < nchargeIBL; c++)
219  chrgsbins[c] = 0.5 * (chrgAbaciIBL[c - 1] + chrgAbaciIBL[c]);
220 
221  chrgsbins[0] = chrgAbaciIBL[0] - 0.5 * (chrgAbaciIBL[1] - chrgAbaciIBL[0]);
222  chrgsbins[nchargeIBL] = chrgAbaciIBL[nchargeIBL - 1] + 0.5 * (chrgAbaciIBL[nchargeIBL - 1] - chrgAbaciIBL[nchargeIBL - 2]);
223 
224  // please note extra +1 for ending bins.
225  const Int_t nToTibl = 16 * finerToT + 1;
226 
227  Double_t totAbaci[nToTibl], totbins[nToTibl + 1];
228 
229  totbins[0] = -0.25;
230  totbins[1] = 0.5;
231  totAbaci[0] = 0.0;
232  totAbaci[1] = 1.;
233  for (int t = 2; t < nToTibl; t++)
234  {
235  totAbaci[t] = totAbaci[1] + (t - 1) / (1. * finerToT);
236  totbins[t] = 0.5 * (totAbaci[t] + totAbaci[t - 1]);
237  }
238  totbins[nToTibl] = totAbaci[nToTibl - 1] + 0.5 * (totbins[nToTibl - 1] - totbins[nToTibl - 2]);
239 
240  Double_t totErrArr[nToTibl];
241  for (int t = 0; t < nToTibl; t++)
242  totErrArr[t] = 0.;
243 
244 #if defined(DEMOXCHECK)
245  for (int t = 0; t < nToTibl; t++)
246  logout << " totAbaci : " << t << " " << totbins[t] << " < " << totAbaci[t] << " > " << totbins[t + 1] << endl;
247 
248  if (finerToT == 1)
249  {
250  for (int t = 1; t < nToTibl; t++)
251  {
252  RDentries[t] = RDentries[2 * t - 1] + RDentries[2 * t];
253  logout << " finer RDentries : " << t << " " << 2 * t - 1 << " " << 2 * t << " " << RDentries[t] << endl;
254  }
255  }
256 #endif
257 
258  map<string, map<string, map<string, float>>> pcdMap;
259 
260  TFile roFile(rootFileName, "RECREATE");
261  TDirectory *roThrDir = roFile.mkdir("Threshold");
262  TDirectory *roTotDir = roFile.mkdir("ToT");
263 
264  // ****************************** Threshold IBL ******************************
265 
266  Double_t THR_avg[2][npsFEs], ThrSig_avg[2][npsFEs];
267  array<std::unique_ptr<TH2D> , npsFEs> h2_Thr{};
268  array<std::unique_ptr<TH2D> , npsFEs> h2_ThrSig{};
269 
270  std::multimap<float, TString, std::greater<float>> badThr_Order;
271 
272  for (int sfe = 0; sfe < npsFEs; sfe++)
273  {
274  stringstream ss;
275  ss << sfe;
276 
277  string knowModule = "LI_S06_C_M1_C1";
278  string idx = "I" + ss.str();
279 
280  pcdMap[knowModule][idx]["ThrNorm"] = -42.;
281  pcdMap[knowModule][idx]["ThrRmsNorm"] = -42.;
282  pcdMap[knowModule][idx]["ThrSigNorm"] = -42.;
283  pcdMap[knowModule][idx]["ThrLong"] = -42.;
284  pcdMap[knowModule][idx]["ThrRmsLong"] = -42.;
285  pcdMap[knowModule][idx]["ThrSigLong"] = -42.;
286 
287  for (int nl = 0; nl < 2; nl++)
288  THR_avg[nl][sfe] = ThrSig_avg[nl][sfe] = -99.;
289 
290  idx = "Threshold" + ss.str();
291  h2_Thr[sfe] = std::make_unique<TH2D>(idx.c_str(), " ", 2, 0, 2, 200, 0, 5000);
292  idx = "ThresholdSig" + ss.str();
293  h2_ThrSig[sfe] = std::make_unique<TH2D>(idx.c_str(), " ", 2, 0, 2, 200, 0, 500);
294  }
295 
296  if (inThrFile.Length() > 0)
297  {
298  std::cout << endl
299  << "INFO =>> [IBL] threshold scan analysis..." << endl;
300 
301  TFile riThrFile(inThrFile, "READ");
302  TString chi2HistName = "SCURVE_CHI2";
303  TString thrHistName = "SCURVE_MEAN";
304  TString sigHistName = "SCURVE_SIGMA";
305 
306  std::unique_ptr<TH1F> h1dChi2 = std::make_unique<TH1F>("h1dChi2", "", 200, 0, 1);
307  std::unique_ptr<TH1F> h1dThr = std::make_unique<TH1F>("h1dThr" , "", 200, 0, 5000);
308  std::unique_ptr<TH1F> h1dSig = std::make_unique<TH1F>("h1dSig" , "", 200, 0, 500);
309 
310  TDirectoryFile *scanDir = (TDirectoryFile *)((TKey *)riThrFile.GetListOfKeys()->First())->ReadObj();
311  TList *rodKeyList = (TList *)scanDir->GetListOfKeys();
312  TIter rodItr(rodKeyList);
313  TKey *rodKey;
314 
315  while ((rodKey = (TKey *)rodItr()))
316  {
317  TString rodName(rodKey->GetName());
318  TDirectoryFile *rodDir = (TDirectoryFile *)rodKey->ReadObj();
319  TList *modKeyList = (TList *)rodDir->GetListOfKeys();
320  TIter modItr(modKeyList);
321  TKey *modKey;
322 
323  TDirectory *dirRod = roThrDir->mkdir(rodName);
324 
325  while ((modKey = (TKey *)modItr()))
326  {
327  TString modName(modKey->GetName());
328  string modStr(modKey->GetName());
329  TDirectory *dirMod = dirRod->mkdir(modName);
330 
331  TString chi2HistDirPath = modName + "/" + chi2HistName + "/A0/B0";
332 
333  TDirectory *chi2HistDir = (TDirectory *)rodDir->Get(chi2HistDirPath);
334  if (chi2HistDir == NULL)
335  {
336  cout << " Warning : NULL dir " << endl;
337  continue;
338  }
339 
340  std::unique_ptr<TH2D> h2dChi2 (static_cast<TH2D*>(static_cast<TKey*>(chi2HistDir->GetListOfKeys()->First())->ReadObj()));
341  if (h2dChi2 == NULL)
342  {
343  cout << " Warning : NULL dir " << endl;
344  continue;
345  }
346  TString thrHistDirPath = modName + "/" + thrHistName + "/A0/B0";
347  TDirectoryFile *thrHistDir = (TDirectoryFile *)rodDir->Get(thrHistDirPath);
348  std::unique_ptr<TH2D> h2dThr(static_cast<TH2D*>(static_cast<TKey*>(thrHistDir->GetListOfKeys()->First())->ReadObj()));
349  TString sigHistDirPath = modName + "/" + sigHistName + "/A0/B0";
350 
351  TDirectoryFile *sigHistDir = (TDirectoryFile *)rodDir->Get(sigHistDirPath);
352  std::unique_ptr<TH2D> h2dSig (static_cast<TH2D*>(static_cast<TKey*>(sigHistDir->GetListOfKeys()->First())->ReadObj()));
353 
354  array<std::unique_ptr<TH1F>, npsFEs> h1_ThrNorm{};
355  array<std::unique_ptr<TH1F>, npsFEs> h1_ThrSigNorm{};
356  array<std::unique_ptr<TH1F>, npsFEs> h1_ThrLong{};
357  array<std::unique_ptr<TH1F>, npsFEs> h1_ThrSigLong{};
358  array<float, npsFEs> IlledThr{};
359 
360  for (int sfe = 0; sfe < npsFEs; sfe++)
361  {
362  stringstream ss;
363  ss << sfe;
364 
365  string hname = modStr + "ThrNorm" + ss.str();
366  h1_ThrNorm[sfe] = std::make_unique<TH1F>(hname.c_str(), "", 200, 0, 5000);
367  hname = modStr + "ThrSigNorm" + ss.str();
368  h1_ThrSigNorm[sfe] = std::make_unique<TH1F>(hname.c_str(), "", 200, 0, 500);
369  hname = modStr + "ThrLong" + ss.str();
370  h1_ThrLong[sfe] = std::make_unique<TH1F>(hname.c_str(), "", 200, 0, 5000);
371  hname = modStr + "ThrSigLong" + ss.str();
372  h1_ThrSigLong[sfe] = std::make_unique<TH1F>(hname.c_str(), "", 200, 0, 500);
373  }
374 
375  for (int col = 1; col <= ncol; col++)
376  {
377  for (int row = 1; row <= nrow; row++)
378  {
379  float chi2 = h2dChi2->GetBinContent(col, row);
380  float thr = h2dThr->GetBinContent(col, row);
381  float sig = h2dSig->GetBinContent(col, row);
382 
383  h1dChi2->Fill(chi2);
384  h1dThr->Fill(thr);
385  h1dSig->Fill(sig);
386  // Shall we measure/count the goodness of THR scan here ?
387  bool filled = true;
388  if (thr == 0 || thr > 10000 || sig == 0 || sig > 1000 || chi2 > 0.5 || chi2 <= 0)
389  {
390  filled = false;
391  }
392  int circ = -1;
393  if (filled)
394  {
395  if (col == 1 || col == ncol / 2 || col == ncol / 2 + 1 || col == ncol)
396  {
397  if (moreFE)
398  {
399  circ = (int)(row / 84.);
400  if (col > 80)
401  {
402  circ = 7 - circ;
403  }
404  }
405  else
406  {
407  if (col <= ncol / 2)
408  circ = 0;
409  else
410  circ = 1;
411  }
412 
413  h1_ThrLong[circ]->Fill(thr);
414  h1_ThrSigLong[circ]->Fill(sig);
415  }
416  else
417  {
418  if (moreFE)
419  {
420  circ = (int)(row / 84.);
421  if (col > 80)
422  {
423  circ = 7 - circ;
424  }
425  }
426  else
427  {
428  if (col <= ncol / 2)
429  circ = 0;
430  else
431  circ = 1;
432  }
433 
434  h1_ThrNorm[circ]->Fill(thr);
435  h1_ThrSigNorm[circ]->Fill(sig);
436  }
437  }
438  else
439  {
440  // Note: what is the intention? circ is -1 here
441  continue;
442  }
443  }
444  }
445  h2dSig.reset();
446  h2dThr.reset();
447  h2dChi2.reset();
448 
449  for (int sfe = 0; sfe < npsFEs; sfe++)
450  {
451  stringstream ss;
452  ss << sfe;
453  string feName = "I" + ss.str();
454 
455  float THRnorm = h1_ThrNorm[sfe]->GetMean();
456  bool valid = THRnorm > 100.;
457  pcdMap[modStr][feName]["ThrNorm"] = THRnorm;
458  pcdMap[modStr][feName]["ThrRmsNorm"] = h1_ThrNorm[sfe]->GetRMS();
459  float THRnormSig = h1_ThrSigNorm[sfe]->GetMean();
460  pcdMap[modStr][feName]["ThrSigNorm"] = THRnormSig;
461  float THRlong = h1_ThrLong[sfe]->GetMean();
462  pcdMap[modStr][feName]["ThrLong"] = THRlong;
463  pcdMap[modStr][feName]["ThrRmsLong"] = h1_ThrLong[sfe]->GetRMS();
464  float THRlongSig = h1_ThrSigLong[sfe]->GetMean();
465  pcdMap[modStr][feName]["ThrSigLong"] = THRlongSig;
466 
467  float blank = 100. * IlledThr[sfe] * npsFEs / (1. * ncol * nrow);
468 
469  if (blank > 0.01)
470  badThr_Order.insert(std::pair<float, TString>(blank, (TString)(modName + " : " + blank)));
471 
472  if (valid)
473  {
474  h2_Thr[sfe]->Fill(0.5, THRnorm, 1);
475  h2_Thr[sfe]->Fill(1.5, THRlong, 1);
476  h2_ThrSig[sfe]->Fill(0.5, THRnormSig, 1);
477  h2_ThrSig[sfe]->Fill(1.5, THRlongSig, 1);
478  }
479  dirMod->WriteTObject(h1_ThrNorm[sfe].get());
480  dirMod->WriteTObject(h1_ThrLong[sfe].get());
481 
482  h1_ThrNorm[sfe].reset();
483  h1_ThrSigNorm[sfe].reset();
484  h1_ThrLong[sfe].reset();
485  h1_ThrSigLong[sfe].reset();
486  }
487  }
488  }
489  roThrDir->WriteTObject(h1dChi2.get());
490  h1dChi2.reset();
491  roThrDir->WriteTObject(h1dThr.get());
492  h1dThr.reset();
493  roThrDir->WriteTObject(h1dSig.get());
494  h1dSig.reset();
495  }
496 
497  for (int sfe = 0; sfe < npsFEs; sfe++)
498  {
499  stringstream ss;
500  ss << sfe;
501  string hName = "thrNorm" + ss.str();
502  THR_avg[0][sfe] = h2_Thr[sfe]->ProjectionY(hName.c_str(), 1, 1)->GetMean();
503  hName = "thrLong" + ss.str();
504  THR_avg[1][sfe] = h2_Thr[sfe]->ProjectionY(hName.c_str(), 2, 2)->GetMean();
505  hName = "thrSigNorm" + ss.str();
506  ThrSig_avg[0][sfe] = h2_ThrSig[sfe]->ProjectionY(hName.c_str(), 1, 1)->GetMean();
507  hName = "thrSigLong" + ss.str();
508  ThrSig_avg[1][sfe] = h2_ThrSig[sfe]->ProjectionY(hName.c_str(), 2, 2)->GetMean();
509  h2_Thr[sfe].reset();
510  h2_ThrSig[sfe].reset();
511  }
512  // ****************************** End - Threshold IBL ******************************
513 
515  /************************* IBL ToT ***************************/
517 
518  if (inTotFile.Length() == 0 || inTotFileAux.Length() == 0)
519  {
520  logout << " Missing ToT file from calib scan as input " << endl;
521  return 0;
522  }
523 
524  std::cout << endl
525  << "INFO =>> [IBL] tot calib analysis..." << endl;
526 
527  TFile riTotFile(inTotFile, "READ");
528  TFile riTotFileAux(inTotFileAux, "READ");
529 
530  TString totHistName = "TOT_MEAN";
531  TString totSigHistName = "TOT_SIGMA";
532 
533  TDirectoryFile *scanDir = (TDirectoryFile *)((TKey *)riTotFile.GetListOfKeys()->First())->ReadObj();
534  TList *rodKeyList = (TList *)scanDir->GetListOfKeys();
535  TIter rodItr(rodKeyList);
536  TKey *rodKey;
537 
538  std::map<float, std::pair<vector<TString>, vector<Double_t>>> ModuDataToPrint;
539 
540 #if defined(DEMOXCHECK)
541  vector<TH1F *> h1_ChrgEntry;
542  h1_ChrgEntry.reserve(nToTibl);
543 
544  vector<TH1F *> h1d_totSprdAll;
545  h1d_totSprdAll.reserve(nToTibl - 1);
546 
547  for (int t = 0; t < nToTibl; t++)
548  {
549  stringstream tt;
550  tt << t;
551 
552  string hname = "ChrgEntries_ToT_" + tt.str();
553  h1_ChrgEntry[t] = new TH1F(hname.c_str(), "RD entries ", 100, 0., 100000);
554 
555  hname = "totSprdsFll_ToT_" + tt.str();
556  if (t < nToTibl - 1)
557  h1d_totSprdAll[t] = new TH1F(hname.c_str(), "ToT spread ", 36, 0.2, 1.1);
558  }
559 #endif
560 
561  const Int_t totFE = 14 * 16 * npsFEs; // 16 modules on each of 14 ReadOutDisk
562  Double_t TotArray[totFE][nchargeIBL], TotErrArray[totFE][nchargeIBL];
563  Double_t TotSigArray[totFE][nchargeIBL], TotSigErrArray[totFE][nchargeIBL];
564  Double_t ChrgArray[totFE][nToTibl], ChrgErrArray[totFE][nToTibl];
565 
566  gRandom = new TRandom3(2203);
567 
568  float occuPhiEta[nchargeIBL][totFE];
569 
570  Int_t cntRod = 0;
571  std::map<float, TString> devChrg_Order;
572  std::map<float, TString> devToT_Order;
573 
574  std::multimap<float, TString, std::greater<float>> badModules_Order;
575  std::multimap<float, TString, std::greater<float>> badModules_Order_detailed;
576 
577  while ((rodKey = (TKey *)rodItr()))
578  {
579  TString rodName(rodKey->GetName());
580  string rodStr(rodKey->GetName());
581  TDirectoryFile *rodDir = (TDirectoryFile *)rodKey->ReadObj();
582 
583  TString path = rodDir->GetPath();
584  TString pathAux = path.ReplaceAll(rodPath, rodPathAux);
585 
586  TDirectoryFile *rodDirAux = (TDirectoryFile *)riTotFileAux.Get(pathAux);
587  if (rodDirAux == NULL)
588  {
589  std::cout<< " Fail to get the rodPath in Aux: "<< pathAux << endl;
590  logout << " Fail to get the rodPath in Aux " << endl;
591  continue;
592  }
593 
594  TDirectory *dirRod = roTotDir->mkdir(rodName);
595 
596  TList *modKeyList = (TList *)rodDir->GetListOfKeys();
597  TIter modItr(modKeyList);
598 
599  TKey *modKey;
600 
601  int cntMod = 0;
602  string modNames[16 * npsFEs];
603 
604  float occuChrgs[nToTibl][16 * npsFEs];
605 
606 #if defined(DEMOXCHECK)
607  TString feName_maxDevChrg = "", feName_maxDevToT = "";
608  float maxDevChrg = -9., maxDevToT = -9., avgDevChrg = 0., avgDevToT = 0.;
609 
610  vector<TH1F *> h1d_totSprd;
611  h1d_totSprd.reserve(nToTibl - 1);
612 
613  for (int t = 0; t < nToTibl - 1; t++)
614  {
615  stringstream tt;
616  tt << t + 1;
617 
618  string prfmodname = "ToT_Sprd_" + tt.str();
619  h1d_totSprd[t] = new TH1F(prfmodname.c_str(), "ToT spread ", 28, 0.3, 1.0);
620  prfmodname = rodStr + "ToT spread @ ToT_" + tt.str();
621  h1d_totSprd[t]->SetTitle(prfmodname.c_str());
622  }
623 #endif
624 
625  while ((modKey = (TKey *)modItr()))
626  {
627  TString modName(modKey->GetName());
628  string modStr(modKey->GetName());
629 
630  TDirectory *dirMod = dirRod->mkdir(modName);
631  bool ibl3Dfe0 = false, ibl3Dfe1 = false;
632 
633  int hashID = -1, hashIDL = -1, hashIDR = -1;
634  int bec = -1;
635  int layer = -1;
636  int phi_module = -1;
637  int eta_module = -1;
638  int eta_moduleL = -1, eta_moduleR = -1;
639  pixmap.mapping(modStr, &hashID, &bec, &layer, &phi_module, &eta_module);
640  if (hashID == -1)
641  {
642  pixmap.mapping(modStr + "_1", &hashID, &bec, &layer, &phi_module, &eta_module);
643  if (hashID != -1)
644  {
645  ibl3Dfe0 = true;
646  hashIDL = hashID;
647  eta_moduleL = eta_module;
648  }
649 
650  pixmap.mapping(modStr + "_2", &hashID, &bec, &layer, &phi_module, &eta_module);
651  if (hashID != -1)
652  {
653  ibl3Dfe1 = true;
654  hashIDR = hashID;
655  eta_moduleR = eta_module;
656  }
657  }
658  if (hashID == -1){
659  std::cout<< "negative hash ID\n";
660  continue;
661  }
662 
663 
664  if (pcdMap.find(modStr) == pcdMap.end()){
665  std::cout<< "MOD not found "<< modStr << "\n";
666  continue;
667  }
668 
669 
670  // a stack of Charge-ToT data for ToT-charge converting
671  array<std::unique_ptr<TH2D>, npsFEs> h2d_XchrgYtot{};
672  array<std::unique_ptr<TH2D>, npsFEs> h2d_XchrgYToTSig{};
673 
674  for (int sfe = 0; sfe < npsFEs; sfe++)
675  {
676  stringstream ss;
677  ss << sfe;
678 
679  modNames[cntMod * npsFEs + sfe] = modStr + "-" + ss.str();
680 
681  string prfmodname = modStr + "ToTvsChrg_FE" + ss.str();
682  h2d_XchrgYtot[sfe] = std::make_unique<TH2D>(prfmodname.c_str(), "ToT vs Charge", nchargeIBL, chrgsbins, nToTibl, totbins);
683 
684  prfmodname = modStr + "ToT_Sig_vsChrg_FE" + ss.str();
685  h2d_XchrgYToTSig[sfe] = std::make_unique<TH2D>(prfmodname.c_str(), "ToT Sig vs Charge", nchargeIBL, chrgsbins, 100, 0., 1.);
686  }
687 
688  // Fill ToT-Chrg for pixels per module
689  for (int c = 0; c < nchargeIBL; c++)
690  {
691  TString totHistDirPath = modName + "/" + totHistName + "/A0/B0/C";
692  totHistDirPath += std::to_string(c);
693 
694  std::unique_ptr<TH2F> h2dTot;
695  TDirectoryFile* totHistDir(static_cast<TDirectoryFile*> (rodDir->Get(totHistDirPath)));
696  if(!totHistDir){
697  std::cout<<" Missing totHistDir in : " << totHistDirPath << endl;
698  }
699  else {
700  h2dTot.reset(static_cast<TH2F*> ((static_cast<TKey*>(totHistDir->GetListOfKeys()->First()))->ReadObj()));
701  h2dTot->SetDirectory(0);
702  }
703 
704  unique_ptr<TH2F> h2dTotAux;
705  TDirectoryFile* totHistDirAux(static_cast<TDirectoryFile*>(rodDirAux->Get(totHistDirPath)));
706  if (!totHistDirAux)
707  {
708  std::cout<<" Missing totHistDir in : " << totHistDirPath << endl;
709  logout << " Missing totHistDir in : " << totHistDirPath << endl;
710  }
711  else {
712  h2dTotAux.reset(static_cast<TH2F*> ((static_cast<TKey*>(totHistDirAux->GetListOfKeys()->First())->ReadObj())));
713  h2dTotAux->SetDirectory(0);
714  }
715 
716  TString totSigHistDirPath = modName + "/" + totSigHistName + "/A0/B0/C";
717  totSigHistDirPath += std::to_string(c);
718  TDirectoryFile* totSigHistDir (static_cast<TDirectoryFile*>(rodDir->Get(totSigHistDirPath)));
719  unique_ptr<TH2F> h2dTotSig (static_cast<TH2F*> ((static_cast<TKey*>(totSigHistDir->GetListOfKeys()->First()))->ReadObj()));
720  h2dTotSig->SetDirectory(0);
721 
722  // Now one fill the calib-data from all pixles as basics.
723  for (int ieta = 0; ieta < ncol; ieta++)
724  {
725  for (int iphi = 0; iphi < nrow; iphi++)
726  {
727  int circ = -1;
728  if (moreFE)
729  {
730  // virtual FE with 80*84 pixels, so that sFE0, sFE1, sFE7, sFE6 will make up the physical 1'st FE
731  // while sFE2, sFE3, sFE5, sFE4 make up the physical 2'nd.
732  circ = (int)(iphi / 84.); // sFE0, sFE1, sFE2, sFE3
733  if (ieta > 80)
734  {
735  circ = 7 - circ;
736  } // sFE7, sFE6, sFE5, sFE4
737  }
738  else
739  {
740  if (ieta < ncol / 2)
741  circ = 0;
742  else
743  circ = 1;
744  }
745 
746  float tot = h2dTot->GetBinContent(ieta + 1, iphi + 1) + HDCshift;
747  float totAux = h2dTotAux->GetBinContent(ieta + 1, iphi + 1);
748 
749  // use ToT from higher HDC as default
750  float filltot = tot;
751 
752  // use ToT from lower HDC for SMALL charges, dirty in studying
753  // May 4, 2022, please keep below strategy, it give reasonable merging till now
754 
755  if (tot <= 5 || c <= 5)
756  {
757  if ((c == 0 && tot - totAux > 0.8) || (c >= 1 && c <= 3 && tot - totAux > 0.5) || (c > 4 && tot - totAux > 0.3))
758  filltot = totAux;
759  else
760  filltot = 0.5 * (totAux + tot);
761  if (c == 0 && totAux > 2.)
762  filltot = 1.;
763  }
764 
765  if (c > 19)
766  filltot = 0.5 * (totAux + tot + 2.);
767 
768  if (filltot > 0.){
769  h2d_XchrgYtot[circ]->Fill(chrgAbaciIBL[c], filltot, 1.);
770  }
771 
772 
773  float err = h2dTotSig->GetBinContent(ieta + 1, iphi + 1);
774  h2d_XchrgYToTSig[circ]->Fill(chrgAbaciIBL[c], err, 1.);
775  if (err == 0.)
776  err = 0.05;
777 
778 #if defined(DEMOXCHECK)
779  if (modName == XcheckModule && (iphi >= XcheckPhi[0] && iphi <= XcheckPhi[1]) && (ieta >= XcheckEta[0] && ieta <= XcheckEta[1]) && (c == XcheckCharge[0] || c == XcheckCharge[1] || (int)(tot + 0.5) == XcheckToT || (int)(totAux + 0.5) == XcheckToT))
780  logout << " tot = " << tot << ", totAux = " << totAux << " @injection " << chrgAbaciIBL[c] << " " << err << endl;
781 #endif
782  }
783  } // all pixels done over a module
784 
785  h2dTotSig.reset();
786  h2dTotAux.reset();
787  h2dTot.reset();
788 
789  } // end looping over charges
790  float modHash = -1;
791  if (!(ibl3Dfe0 || ibl3Dfe1))
792  {
793  modHash = hashID;
794  }
795 
796  array<TDirectory *, npsFEs> dirFE;
797 
798  Int_t idxMod = cntRod * 16 * npsFEs + cntMod * npsFEs;
799 
800  for (int sfe = 0; sfe < npsFEs; sfe++)
801  {
802  stringstream ss;
803  ss << sfe;
804 
805  if (ibl3Dfe0 && sfe < npsFEs / 2)
806  {
807  modHash = hashIDL;
808  }
809  else if (ibl3Dfe1 && sfe >= npsFEs / 2)
810  {
811  modHash = hashIDR;
812  }
813  else
814  modHash += (sfe < npsFEs / 2 ? 0 : 1) * 0.8;
815 
816  string prfmodname = "DirFE_" + ss.str();
817  dirFE[sfe] = dirMod->mkdir(prfmodname.c_str());
818 
819  // standard deviation will be adopted for ERROR
820  prfmodname = modStr + "_profile_Tot_FE" + ss.str();
821  std::unique_ptr<TProfile> prfl_TotsFE(h2d_XchrgYtot[sfe]->ProfileX(prfmodname.c_str(), 1, -1, "s"));
822  prfl_TotsFE->SetTitle(prfmodname.c_str());
823  prfmodname = modStr + "_profile_Chrg_FE" + ss.str();
824  // shanly : seeming free from ROOT-7770 issue. 2021 Sep 17
825  std::unique_ptr<TProfile> prfl_ChrgsFE(h2d_XchrgYtot[sfe]->ProfileY(prfmodname.c_str(), 1, -1, "s"));
826  prfl_ChrgsFE->SetTitle(prfmodname.c_str());
827 
828  Double_t TotArr[nchargeIBL], TotErrArr[nchargeIBL];
829  Double_t ChrgArr[nToTibl], ChrgErrArr[nToTibl];
830 
831  Int_t idxFE = idxMod + sfe;
832  // ToT distribution along nchargeIBL bins charges
833  int dumbFE = 0;
834  for (int c = 0; c < nchargeIBL; c++)
835  {
836  TotArr[c] = TotArray[idxFE][c] = prfl_TotsFE->GetBinContent(c + 1);
837  TotErrArr[c] = TotErrArray[idxFE][c] = prfl_TotsFE->GetBinError(c + 1);
838 
839  occuPhiEta[c][idxFE] = prfl_TotsFE->GetBinEntries(c + 1) * npsFEs / (1. * ncol * nrow);
840 
841  if ((1. - occuPhiEta[c][idxFE]) > badRDfracCut)
842  dumbFE++;
843 
844  stringstream sc;
845  sc << c;
846  prfmodname = modStr + "_ToTsig_FE" + ss.str() + "Chrg" + sc.str();
847 
848  std::unique_ptr<TH1D> h_ToTsig(h2d_XchrgYToTSig[sfe]->ProjectionY(prfmodname.c_str(), c + 1, c + 1));
849  TotSigArray[idxFE][c] = TMath::Sqrt(h_ToTsig->GetMean() * h_ToTsig->GetMean() + h_ToTsig->GetRMS() * h_ToTsig->GetRMS());
850  TotSigErrArray[idxFE][c] = TMath::Sqrt(h_ToTsig->GetMeanError() * h_ToTsig->GetMeanError() + h_ToTsig->GetRMSError() * h_ToTsig->GetRMSError());
851 
852  h_ToTsig.reset();
853  }
854  prfl_TotsFE.reset();
855 
856  if (dumbFE > 5)
857  {
858  for (int c = 0; c < nchargeIBL; c++)
859  {
860  TotArr[c] = TotArray[idxFE][c] = 0.5 * (TotArray[idxFE - 1][c] + TotArray[idxFE - 2][c]);
861  TotErrArr[c] = TotErrArray[idxFE][c] = 0.5 * (TotErrArray[idxFE - 1][c] + TotErrArray[idxFE - 2][c]);
862 
863  TotSigArray[idxFE][c] = 0.5 * (TotSigArray[idxFE - 1][c] + TotSigArray[idxFE - 2][c]);
864  TotSigErrArray[idxFE][c] = 0.5 * (TotSigErrArray[idxFE - 1][c] + TotSigErrArray[idxFE - 2][c]);
865 
866  }
867  }
868  // Charges distribution along 16 bins ToT
869  Double_t errToT_overChrg[nToTibl];
870  for (int t = 0; t < nToTibl; t++)
871  {
872  ChrgArr[t] = ChrgArray[idxFE][t] = prfl_ChrgsFE->GetBinContent(t + 1);
873  ChrgErrArr[t] = ChrgErrArray[idxFE][t] = prfl_ChrgsFE->GetBinError(t + 1);
874 
875  occuChrgs[t][cntMod * npsFEs + sfe] = prfl_ChrgsFE->GetBinEntries(t + 1) / RDentries[t];
876 
877  stringstream st;
878  st << t;
879  prfmodname = modStr + "_Chrg_FE" + ss.str() + "ToT" + st.str();
880  std::unique_ptr<TH1D> h_chrg(h2d_XchrgYtot[sfe]->ProjectionX(prfmodname.c_str(), t + 1, t + 1));
881  st.str("");
882  st << totAbaci[t];
883  prfmodname = modStr + " Charge_FE" + ss.str() + " @ ToT : " + st.str();
884  h_chrg->SetTitle(prfmodname.c_str());
885 
886  Double_t scl = h_chrg->Integral();
887  errToT_overChrg[t] = 0.;
888  if (scl > 0.)
889  for (int b = 0; b < nchargeIBL; b++)
890  {
891  errToT_overChrg[t] += TotErrArr[b] * (h_chrg->GetBinContent(b + 1)) / scl;
892  }
893  if (errToT_overChrg[t] == 0.)
894  errToT_overChrg[t] = 1.1;
895 
896  h_chrg.reset();
897  }
898  prfl_ChrgsFE.reset();
899 #if defined(DEMOXCHECK)
900  for (int b = 1; b < nToTibl; b++)
901  {
902  double err = errToT_overChrg[b];
903  h1d_totSprd[b - 1]->Fill(err);
904  h1d_totSprdAll[b - 1]->Fill(err);
905  }
906 #endif
907 
908  // try a correction upon dumb FE
909  if (dumbFE > 5)
910  {
911  for (int t = 0; t < nToTibl; t++)
912  {
913  ChrgArr[t] = ChrgArray[idxFE][t] = 0.5 * (ChrgArray[idxFE - 1][t] + ChrgArray[idxFE - 2][t]);
914  ChrgErrArr[t] = ChrgErrArray[idxFE][t] = 0.5 * (ChrgErrArray[idxFE - 1][t] + ChrgErrArray[idxFE - 2][t]);
915  }
916  }
917  bool xoticMod = std::find(reversedModules.begin(), reversedModules.end(), int(modHash)) != reversedModules.end();
918 
919  // when charges' order are distorted along ToTs
920  bool reverseH = false, reverseT = false;
921  for (int t = 4; t >= 1; t--)
922  if (ChrgArr[t] > ChrgArr[t + 1])
923  {
924  reverseH = true;
925  break;
926  }
927  for (int t = 4; t >= 1; t--)
928  {
929  int tl = nToTibl - t;
930  if (ChrgArr[tl] < ChrgArr[tl - 1])
931  {
932  reverseT = true;
933  break;
934  }
935  }
936 
937  if (reverseH)
938  {
939 #if defined(DEMOXCHECK)
940  logout << " Head reversed : " << int(modHash) << " " << modName << " " << sfe << " " << ChrgArr[1] << " "
941  << ChrgArr[2] << " " << ChrgArr[3] << " " << ChrgArr[4] << " " << ChrgArr[5] << std::endl;
942 #endif
943  // try a correction with some averaged factors
944  for (int t = 4; t >= 1; t--)
945  if (ChrgArr[t] > ChrgArr[t + 1] && (occuChrgs[t][cntMod * npsFEs + sfe] < 0.5 || xoticMod))
946  ChrgArr[t] = ChrgArray[idxFE][t] = reverseCF_H[t - 1] * ChrgArr[t + 1];
947  }
948  else // prepare the average factors along ToTs
949  {
950  for (int t = 4; t >= 1; t--)
951  if (ChrgArr[t + 1] != 0.)
952  reverseCF_H[t - 1] = (reverseCF_H[t - 1] == tmpRCf_H[t - 1] ? ChrgArr[t] / ChrgArr[t + 1] : 0.5 * (reverseCF_H[t - 1] + ChrgArr[t] / ChrgArr[t + 1]));
953  }
954 
955  if (reverseT)
956  {
957 #if defined(DEMOXCHECK)
958  logout << " Tail reversed : " << int(modHash) << " " << modName << " " << sfe << " " << ChrgArr[nToTibl - 5] << " "
959  << ChrgArr[nToTibl - 4] << " " << ChrgArr[nToTibl - 3] << " " << ChrgArr[nToTibl - 2] << " " << ChrgArr[nToTibl - 1] << std::endl;
960 #endif
961  // try a correction with some averaged factors
962  for (int t = 4; t >= 1; t--)
963  {
964  int tl = nToTibl - t;
965  if (ChrgArr[tl] < ChrgArr[tl - 1] && (occuChrgs[tl][cntMod * npsFEs + sfe] < 0.5 || xoticMod))
966  ChrgArr[tl] = ChrgArray[idxFE][tl] = reverseCF_T[t - 1] * ChrgArr[tl - 1];
967  }
968  }
969  else // prepare the average factors along ToTs
970  {
971  for (int t = 4; t >= 1; t--)
972  {
973  int tl = nToTibl - t;
974  if (ChrgArr[tl - 1] != 0.)
975  reverseCF_T[t - 1] = (reverseCF_T[t - 1] == tmpRCf_T[t - 1] ? ChrgArr[tl] / ChrgArr[tl - 1] : 0.5 * (reverseCF_T[t - 1] + ChrgArr[tl] / ChrgArr[tl - 1]));
976  }
977  }
978 
979  string gername = modStr + "_grToTsig_FE_" + ss.str();
980  std::unique_ptr<TGraphErrors> grTotSig = std::make_unique<TGraphErrors>(nchargeIBL, chrgAbaciIBL, TotSigArray[sfe], chargeErrArrIBL, TotSigErrArray[sfe]);
981  grTotSig->SetTitle(gername.c_str());
982  grTotSig->SetName(gername.c_str());
983 
984  std::unique_ptr<TGraph> grTotSprd = std::make_unique<TGraph>(nToTibl, totAbaci, errToT_overChrg);
985  gername = "ToTsprd";
986  grTotSprd->SetName(gername.c_str());
987  gername = modStr + " ToT spread over FrontEnd @ FE " + ss.str();
988  grTotSprd->SetTitle(gername.c_str());
989  grTotSprd->SetLineColor(4);
990  grTotSprd->SetMarkerStyle(4);
991  grTotSprd->SetMarkerSize(1.);
992 
993  TF1 ToTres("ToTres", funcDispConvoluted, 0.8, 16.5, 3);
994  ToTres.SetParameter(1,13.);
995  ToTres.SetParameter(2,0.65);
996  ToTres.SetParLimits(1, 10., 16.);
997  ToTres.SetParLimits(2, 0.3, 1.0);
998 
999  grTotSprd->Fit(&ToTres, "MRQ");
1000  Double_t parP0 = ToTres.GetParameter(0);
1001  Double_t parP1 = ToTres.GetParameter(1);
1002 
1003  dirFE[sfe]->WriteTObject(grTotSprd.get());
1004  grTotSprd.reset();
1005  // Lets' keep the bad 2-para fit untill the dataBase will be updated someday
1028  gername = modStr + "_grToT_FE_" + ss.str();
1029  std::unique_ptr<TGraphErrors> grTot = std::make_unique<TGraphErrors>(nchargeIBL, chrgAbaciIBL, TotArr, chargeErrArrIBL, TotErrArr);
1030  grTot->SetTitle(gername.c_str());
1031  grTot->SetName(gername.c_str());
1032  TF1 *f1ToTfromCharge = new TF1("ToTfromCharge", funcRation5, chrgAbaciIBL[0] - 100., chrgAbaciIBL[nchargeIBL - 1] + 300., 5);
1033 
1034  grTot->Fit(f1ToTfromCharge, "MRQ");
1035 
1036  std::unique_ptr<TGraphErrors> grChrg = std::make_unique<TGraphErrors>(nToTibl, totAbaci, ChrgArr, totErrArr, ChrgErrArr);
1037 
1038  gername = modStr + "_grChrg_FE_" + ss.str();
1039  grChrg->SetName(gername.c_str());
1040  grChrg->SetTitle(gername.c_str());
1041  grChrg->SetLineColor(3);
1042  grChrg->SetLineWidth(3);
1043 
1044  TF1 *f1ChargefromToTLeft = new TF1("ChargefromToTL", funcRation5, 1., 7.5, 5);
1045  f1ChargefromToTLeft->SetLineColor(2);
1046  grChrg->Fit(f1ChargefromToTLeft, "MRQ");
1047  if (f1ChargefromToTLeft->GetChisquare() / 4. > 2.){
1048  logout << "bad fit Left... " << std::endl;
1049  }
1050 
1051  TF1 *f1ChargefromToTRight = new TF1("ChargefromToTR", funcRation5, 5.5, 16., 5);
1052  f1ChargefromToTRight->SetLineColor(4);
1053  grChrg->Fit(f1ChargefromToTRight, "MRQ+");
1054 
1055  dirFE[sfe]->WriteTObject(grTot.get());
1056  dirFE[sfe]->WriteTObject(grTotSig.get());
1057  dirFE[sfe]->WriteTObject(h2d_XchrgYtot[sfe].get());
1058 
1059  h2d_XchrgYtot[sfe].reset();
1060  h2d_XchrgYToTSig[sfe].reset();
1061  grTot.reset();
1062  grTotSig.reset();
1063  grChrg.reset();
1064 
1065  // prepare a map sor sorting
1066  string Idx = "I" + ss.str();
1067  vector<TString> modName2prt;
1068  modName2prt.push_back(modName);
1069  modName2prt.push_back((TString)(Idx));
1070  // unfortunately some tuning is necessary to satisfy dataBase reauirements
1071  // 5 for module ID, 4 for threshold, nToTibl - 1 for charges at ToT, 3 for ResToT
1072  std::vector<Double_t> prtAux;
1073  prtAux.reserve(5 + 4 + nToTibl - 1 + 3); // skip ToT = 0
1074  // @ 0 ... 4
1075  prtAux.push_back(modHash);
1076  prtAux.push_back(bec);
1077  prtAux.push_back(layer);
1078  prtAux.push_back(phi_module);
1079  prtAux.push_back(eta_module);
1080 
1081  modName2prt[0] = (modStr + "_" + ss.str()).c_str();
1082  if (ibl3Dfe0 && sfe < npsFEs / 2)
1083  {
1084  if (!moreFE)
1085  modName2prt[0] = modName + "_0";
1086  prtAux[0] = hashIDL;
1087  prtAux[4] = eta_moduleL;
1088  }
1089  if (ibl3Dfe1 && sfe >= npsFEs / 2)
1090  {
1091  if (!moreFE)
1092  modName2prt[0] = modName + "_1";
1093  prtAux[0] = hashIDR;
1094  prtAux[4] = eta_moduleR;
1095  }
1096 
1097  // @ 5 ... 8
1098  float ThrNorm = pcdMap[modStr][Idx]["ThrNorm"];
1099  if (ThrNorm == 0. || ThrNorm == -42.)
1100  {
1101  // retrieve something from average when it's missing in calibration
1102  prtAux.push_back(THR_avg[0][sfe]);
1103  prtAux.push_back(ThrSig_avg[0][sfe]);
1104  prtAux.push_back(THR_avg[1][sfe]);
1105  prtAux.push_back(ThrSig_avg[1][sfe]);
1106  }
1107  else
1108  {
1109  prtAux.push_back(pcdMap[modStr][Idx]["ThrNorm"]);
1110  prtAux.push_back(pcdMap[modStr][Idx]["ThrSigNorm"]);
1111  prtAux.push_back(pcdMap[modStr][Idx]["ThrLong"]);
1112  prtAux.push_back(pcdMap[modStr][Idx]["ThrSigLong"]);
1113  }
1114  // since this version, the goodness will be skipped
1115  // @ 10 ... nToTibl + 8, with ToT = 0 skipped
1116  for (int t = 1; t < nToTibl; t++)
1117  prtAux.push_back(ChrgArr[t]);
1118 
1119  // @ nToTibl + 9, nToTibl + 10
1120  prtAux.push_back(parP0);
1121  prtAux.push_back(parP1);
1122 
1123  std::pair<vector<TString>, vector<Double_t>> payloadDB = std::pair<vector<TString>, vector<Double_t>>(modName2prt, prtAux);
1124  ModuDataToPrint.insert(std::pair<float, std::pair<vector<TString>, vector<Double_t>>>(modHash, payloadDB));
1125  } // end 1'st loop over FrontEnds
1126 
1127  cntMod++;
1128  } // end of loop over Mods
1129 
1130 #if defined(DEMOXCHECK)
1131 
1132  TDirectory *dirToTSprd = dirRod->mkdir("ToT_Spreads");
1133  for (int b = 0; b < nToTibl - 1; b++)
1134  {
1135  Int_t upper = h1d_totSprd[b]->FindLastBinAbove(1, 1);
1136  h1d_totSprd[b]->SetAxisRange(h1d_totSprd[b]->GetBinLowEdge(
1137  h1d_totSprd[b]->FindFirstBinAbove(1, 1)),
1138  h1d_totSprd[b]->GetBinLowEdge(upper) + h1d_totSprd[b]->GetBinWidth(upper), "X");
1139 
1140  dirToTSprd->WriteTObject(h1d_totSprd[b]);
1141  delete h1d_totSprd[b];
1142  }
1143  h1d_totSprd.clear();
1144 
1145  TString hn = "";
1146 
1147  TH2F *h2_badChrgs = new TH2F(rodName + "ChargeOccupancy", "Occupancy ", nchargeIBL, 0, nchargeIBL, 16 * npsFEs, 0, 16 * npsFEs);
1148  hn = "Occupancy along charges @ " + rodName;
1149  h2_badChrgs->SetTitle(hn);
1150 
1151  TH2F *h2_badToT = new TH2F(rodName + "ToTOccupancy", "Occupancy ", nToTibl - 1, 0.5, nToTibl - 0.5, 16 * npsFEs, 0, 16 * npsFEs);
1152  hn = "Occupancy along ToT @ " + rodName;
1153  h2_badToT->SetTitle(hn);
1154 
1155  bool fillChrg = false, fillToT = false;
1156 
1157  for (int sfe = 0; sfe < 16 * npsFEs; sfe++)
1158  {
1159  float PhiEta = 0.;
1160  for (int c = 0; c < nchargeIBL; c++)
1161  {
1162  float occu = occuPhiEta[c][cntRod * 16 * npsFEs + sfe];
1163  float nt = 10. - floor(10. * occu + 0.5);
1164  PhiEta += 0.1 * nt;
1165  TString modchrg = (TString)(modNames[sfe] + "_Chrg_" + c);
1166  if (nt > 0.01)
1167  badModules_Order_detailed.insert(std::pair<float, TString>(1. - occu, modchrg));
1168  if (nt > 5.)
1169  continue;
1170  if (nt < 0.1)
1171  nt = 0.01;
1172 
1173  h2_badChrgs->SetBinContent(c + 1, sfe + 1, nt);
1174  fillChrg = true;
1175  }
1176  PhiEta /= nchargeIBL;
1177  if (PhiEta > 0.01)
1178  badModules_Order.insert(std::pair<float, TString>(PhiEta,
1179  (TString)(modNames[sfe])));
1180 
1181  for (int t = 1; t < nToTibl; t++)
1182  {
1183  float nt = floor(10. * occuChrgs[t][sfe] + 0.5);
1184  if (nt > 5.)
1185  continue;
1186  h2_badToT->SetBinContent(t + 1, sfe + 1, nt);
1187  fillToT = true;
1188  }
1189 
1190  TString shortName = modNames[sfe].substr(9, 13).c_str();
1191  h2_badChrgs->GetYaxis()->SetBinLabel(sfe + 1, shortName);
1192  h2_badToT->GetYaxis()->SetBinLabel(sfe + 1, shortName);
1193  h2_badChrgs->SetStats(kFALSE);
1194  h2_badToT->SetStats(kFALSE);
1195  h2_badChrgs->SetTickLength(0.01, "Y");
1196  h2_badToT->SetTickLength(0.01, "Y");
1197  }
1198 
1199  h2_badChrgs->SetOption("TEXT");
1200  h2_badToT->SetOption("TEXT");
1201 
1202  if (fillChrg)
1203  {
1204  dirRod->WriteTObject(h2_badChrgs, "", "Overwrite");
1205  }
1206 
1207  if (fillToT)
1208  {
1209  dirRod->WriteTObject(h2_badToT, "", "WriteDelete");
1210  }
1211 
1212  delete h2_badChrgs;
1213  delete h2_badToT;
1214 
1215 #endif
1216 
1217  cntRod++;
1218  } // end of loop over Rods
1219 
1220 #if defined(DEMOXCHECK)
1221 
1222  for (int t = 0; t < 4; t++)
1223  {
1224  if (t == 0)
1225  logout << " correction factors for reversed charges : ";
1226  logout << reverseCF_H[t] << ", ";
1227  if (t == 3)
1228  logout << endl;
1229  }
1230  for (int t = 0; t < 4; t++)
1231  {
1232  if (t == 0)
1233  logout << " correction factors for reversed charges : ";
1234  logout << reverseCF_T[t] << ", ";
1235  if (t == 3)
1236  logout << endl;
1237  }
1238 
1239  for (int t = 0; t < nToTibl; t++)
1240  {
1241  if (t == 0)
1242  logout << "RD Entries per ToT bin ";
1243  logout << h1_ChrgEntry[t]->GetMean() << ", ";
1244  if (t == nToTibl - 1)
1245  logout << std::endl;
1246  roTotDir->WriteTObject(h1_ChrgEntry[t]);
1247  delete h1_ChrgEntry[t];
1248  }
1249  h1_ChrgEntry.clear();
1250 
1251  for (std::map<float, TString>::const_iterator itr = devChrg_Order.begin();
1252  itr != devChrg_Order.end(); ++itr)
1253  logout << " Charge dev order : " << itr->second << " : " << itr->first << endl;
1254 
1255  for (std::map<float, TString>::const_iterator itr = devToT_Order.begin();
1256  itr != devToT_Order.end(); ++itr)
1257  logout << " ToT dev order : " << itr->second << " : " << itr->first << endl;
1258 
1259  logout << "ToTRes (spread) & its RMS @ ToT from 1 to 16 : " << endl;
1260  for (int t = 0; t < nToTibl - 1; t++)
1261  {
1262  if (t == 0)
1263  logout << "[ ";
1264  logout << "[ " << h1d_totSprdAll[t]->GetMean() << " , " << h1d_totSprdAll[t]->GetStdDev() << " ] ";
1265  if (t < nToTibl - 2)
1266  logout << " , " << endl;
1267  if (t == nToTibl - 2)
1268  logout << " ] " << endl;
1269  delete h1d_totSprdAll[t];
1270  }
1271  h1d_totSprdAll.clear();
1272 #endif
1273 
1274  logout << " goto print " << std::endl;
1275 
1276  // Comment out for information only
1277  // txtDB << "####################################################################################################" << endl;
1278  // txtDB << "=========== physics meaning of each column ====================" << endl;
1279  // txtDB << "hashId " << "Threshold " << "ThresholdRMS " << "ThresholdLong " << "ThresholdRMSLong " << "Chrg_ToT1 "
1280  // << "Chrg_ToT2 " << "Chrg_ToT3 " << "Chrg_ToT4 " << "Chrg_ToT5 " << "Chrg_ToT6 " << "Chrg_ToT7 " << "Chrg_ToT8 " << "Chrg_ToT9 "
1281  // << "Chrg_ToT10 " << "Chrg_ToT11 " << "Chrg_ToT12 " << "Chrg_ToT13 " << "Chrg_ToT14 " << "Chrg_ToT15 " << "Chrg_ToT16 "
1282  // << "ToT_sprd " << " ToT_sprd_var" << endl;
1283 
1284  // txtDB << "######################## TXT for IBL calibration ____Start : _> ###########################" << endl;
1285 
1286  // now print the dataBase payloads in a TXT format
1287  for (std::map<float, std::pair<vector<TString>, vector<Double_t>>>::const_iterator itr = ModuDataToPrint.begin();
1288  itr != ModuDataToPrint.end(); ++itr)
1289  {
1290  int hash = floor(itr->first);
1291  std::pair<vector<TString>, vector<Double_t>> payload = itr->second;
1292  vector<Double_t> fe = payload.second;
1293 
1294  txtDB << hash << " ";
1295 
1296  for (unsigned int t = 5; t < fe.size(); t++)
1297  {
1298  if (t < fe.size() - 2)
1299  {
1300  txtDB << (int)(fe[t]) << " ";
1301 #if defined(DEMOXCHECK)
1302  if (fe[t] > fe[t + 1] && t >= 9 && t <= 23)
1303  logout << " Reversed charge ! " << t - 5 << " " << fe[t] << " " << fe[t + 1] << std::endl;
1304 #endif
1305  }
1306  else
1307  {
1308  float p01 = abs(fe[t]);
1309  if (t < fe.size() - 1)
1310  txtDB << 0.001 * (int)(p01 * 1000.) << " ";
1311  else
1312  txtDB << 0.000000001 * (int)(p01 * 1000000000.) << " ";
1313  }
1314  }
1315  txtDB << endl;
1316  }
1317  // txtDB << "####################################################################################################" << endl;
1318  // txtDB << "######################## TXT for IBL calibration <___ : End _____ ###########################" << endl;
1319  // txtDB << "####################################################################################################" << endl;
1320 
1321  std::cout << " Please find the file : " << dbFileName << " for dataBase payload " << endl;
1322 
1323  // statistics for BAD frontends, only for ELOG reports
1324  logout << " modules lacking in RD during Threshold scan : " << std::endl;
1325  for (std::multimap<float, TString, std::greater<float>>::const_iterator itr = badThr_Order.begin(); itr != badThr_Order.end(); ++itr)
1326  logout << " " << itr->second << " " << (itr->first) * 100. << "%" << endl;
1327 
1328  logout << " modules lacking in RD during ToT scan : " << std::endl;
1329  for (std::multimap<float, TString, std::greater<float>>::const_iterator itr = badModules_Order.begin(); itr != badModules_Order.end(); ++itr)
1330  logout << " " << itr->second << " " << (itr->first) * 100. << "%" << endl;
1331 
1332  logout << " modules lacking in RD at certain charges during ToT scan : " << std::endl;
1333  for (std::multimap<float, TString, std::greater<float>>::const_iterator itr = badModules_Order_detailed.begin();
1334  itr != badModules_Order_detailed.end(); ++itr)
1335  logout << " " << itr->second << " " << (itr->first) * 100. << "%" << endl;
1336 
1337  roFile.Close();
1338  txtDB.close();
1339  logout.close();
1340 
1341  return 0;
1342 }

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 1350 of file CalibrateIBL.cxx.

1350  {
1351 
1352  bool saveInfo = false;
1353  std::string THR = "THR";
1354  std::string TOT_HISDIS = "TOT_HISDIS";
1355  std::string TOT_LOWQ = "TOT_LOWQ";
1356  std::string dpath = "directory_path";
1357 
1358  for(int i=1; i<argc; i++){
1359  std::string aux(argv[i]);
1360  if (THR.compare(aux.substr(0,aux.find("="))) == 0) THR = aux.substr(aux.find("=")+1);
1361  else if(TOT_HISDIS.compare(aux.substr(0,aux.find("="))) == 0) TOT_HISDIS = aux.substr(aux.find("=")+1);
1362  else if(TOT_LOWQ.compare(aux.substr(0,aux.find("="))) == 0) TOT_LOWQ = aux.substr(aux.find("=")+1);
1363  else if(dpath.compare(aux.substr(0,aux.find("="))) == 0) dpath = aux.substr(aux.find("=")+1);
1364  else if(aux.compare("saveInfo") == 0) saveInfo = true;
1365  else{
1366  printError();
1367  return 1;
1368  }
1369  }
1370 
1371  printf("%-14s = %s\n","Directory path",dpath.c_str());
1372  printf("%-14s = %s.root\n","THR",THR.c_str());
1373  printf("%-14s = %s.root\n","TOT_HISDIS",TOT_HISDIS.c_str());
1374  printf("%-14s = %s.root\n","TOT_LOWQ",TOT_LOWQ.c_str());
1375  printf("%-14s = %s\n\n\n" ,"Save root file",saveInfo ? "True" : "False" );
1376 
1377  bool correctArgc = (THR.compare("THR") == 0) or (TOT_HISDIS.compare("TOT_HISDIS") == 0) or (TOT_LOWQ.compare("TOT_LOWQ") == 0) or (dpath.compare("directory_path") == 0);
1378 
1379  if(correctArgc){
1380  printf("Cannot continue, one arguments is incorrect or not filled correctly...\n");
1381  printf("Helper below:\n**********************\n\n");
1382  printError();
1383  return 1;
1384  }
1385 
1386  iblCalib(dpath, THR, TOT_HISDIS, TOT_LOWQ);
1387  return 0;
1388 
1389 }

◆ printError()

void printError ( )

Definition at line 1344 of file CalibrateIBL.cxx.

1344  {
1345  printf("ERROR - Argument not expected or wrongly set:\n\n");
1346  printf("Valid format is: ./IBLCalibration THR=SCAN_Sxxxxxxxxx TOT_HISDIS=SCAN_Sxxxxxxxxx TOT_LOWQ=SCAN_Sxxxxxxxxx directory_path=path/to/file/\n");
1347  printf("\n\t i.e: ./IBLCalibration THR=SCAN_S000087719 TOT_HISDIS=SCAN_S000087717 TOT_LOWQ=SCAN_S000087710 directory_path=/eos/user/x/xxxx/\n");
1348 }

◆ ToTfromChrg()

double ToTfromChrg ( float  chrg,
double  par[5] 
)

Definition at line 80 of file CalibrateIBL.cxx.

81 {
82  double tot = 0.;
83  double num = par[0] + chrg * (par[1] + chrg * (par[2] + chrg * par[3]));
84  double denom = 1. + chrg * par[4];
85  if (denom != 0.0)
86  tot = num / denom;
87  return tot;
88 }

Variable Documentation

◆ ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 24 of file CalibrateIBL.cxx.

query_example.row
row
Definition: query_example.py:24
printError
void printError()
Definition: CalibrateIBL.cxx:1344
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:128
Merge_LAr_blobs.filled
list filled
Definition: Merge_LAr_blobs.py:43
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
CaloCondBlobAlgs_fillNoiseFromASCII.spec
spec
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:47
SH::scanDir
void scanDir(SampleHandler &sh, DiskList &list, const std::string &pattern, const std::string &samplePattern, const std::string &samplePostfix)
effects: scan the given directory and add all subdirectories as samples that contain root files.
Definition: ToolsDiscovery.cxx:45
GetMean
TGraphErrors * GetMean(TH2F *histo)
Definition: TRTCalib_makeplots.cxx:3907
upper
int upper(int c)
Definition: LArBadChannelParser.cxx:49
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
x
#define x
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RunTileCalibRec.run3
run3
Definition: RunTileCalibRec.py:217
calibdata.valid
list valid
Definition: calibdata.py:45
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArCellNtuple.argv
argv
Definition: LArCellNtuple.py:152
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
python.BuildSignatureFlags.sig
sig
Definition: BuildSignatureFlags.py:219
DQHistogramMergeRegExp.argc
argc
Definition: DQHistogramMergeRegExp.py:20
compute_lumi.denom
denom
Definition: compute_lumi.py:76
pix::PixelMapping
Definition: PixelMapping.h:18
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
funcRation5
double funcRation5(double *x, double *par)
Definition: CalibrateIBL.cxx:90
query_example.col
col
Definition: query_example.py:7
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
scan
void scan(TDirectory *td=0, int depth=0)
Definition: listroot.cxx:440
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
BchCleanup.modName
modName
Definition: BchCleanup.py:201
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
DiTauMassTools::MMCFitMethod::shortName
const std::string shortName[MAX]
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:48
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1063
skip
bool skip
Definition: TrigGlobEffCorrValidation.cxx:190
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:874
python.compressB64.c
def c
Definition: compressB64.py:93
funcDispConvoluted
double funcDispConvoluted(double *x, double *par)
Definition: CalibrateIBL.cxx:100
iblCalib
int iblCalib(const std::string &InDir, const std::string &THRscan, const std::string &scan, const std::string &scanLowCharge)
Definition: CalibrateIBL.cxx:107
Generated on Mon Apr 21 2025 21:23:58 for ATLAS Offline Software by   doxygen 1.8.18