ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
Calib Class Reference

#include <Calib.h>

Collaboration diagram for Calib:

Classes

class  funcDisp
 
class  funcTot
 

Public Member Functions

 Calib (int whichPart, bool saveFile, const std::string &moduleName="")
 
 ~ Calib ()
 
bool fillThresholds (const pix::PixelMapping &pm, const std::string &inThrFile, std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &map_info)
 
bool fillTiming (const pix::PixelMapping &pm, const std::string &inTimFile, std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &map_info)
 
bool totFitting (const pix::PixelMapping &pm, const std::string &inTimFile, std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &map_info)
 

Private Member Functions

int chipId (int iphi, int ieta)
 
int pixelType (int iphi, int ieta, bool isForTOT=false)
 
TIter getRodIterator (const TFile &inputFile)
 
TIter getModuleIterator (TDirectoryFile *rodDir)
 
TH2F * get2DHistogramFromPath (TDirectoryFile *rodDir, const TString &moduleName, const TString &histName, int charge=-1)
 
bool moduleInPart (const TString &modName)
 
std::vector< float > getParams (const TF1 *f, unsigned int params)
 
std::vector< float > getParams_quality (const TF1 *f)
 
bool reFit_normalPix (std::vector< float > &params, std::vector< float > &q, std::vector< float > &qerr, std::vector< float > &tot, std::vector< float > &toterr, std::vector< float > &sig, std::vector< float > &sigerr, const unsigned int fe)
 
void graphTitles (const std::unique_ptr< TGraphErrors > &graph, const std::string &name, const std::string &Yname)
 

Private Attributes

bool m_savefile = false
 
std::unique_ptr< TFile > m_wFile
 
bool m_runOneMOD = false
 
TString m_testMOD = ""
 
int m_whichPart = -1
 
const std::array< TString, 4 > m_MODprefixes {"L0", "L1", "L2", "D"}
 
const std::array< TString, 4 > m_layers {"Blayer", "L1", "L2", "Disk"}
 

Static Private Attributes

static constexpr float m_chi_error = 0.05
 
static constexpr int m_etaBins = 144
 
static constexpr int m_phiBins = 320
 
static constexpr int m_thrnbins = 200
 
static constexpr float m_thrLo = 0.
 
static constexpr float m_thrHi = 6000.
 
static constexpr float m_sigLo = 0.
 
static constexpr float m_sigHi = 500
 
static constexpr int m_timnbins = 300
 
static constexpr float m_timLo = 1000.
 
static constexpr float m_timHi = 7000.
 
static constexpr int m_totnbins = 255
 
static constexpr float m_totLo = 0.
 
static constexpr float m_totHi = 255.
 
static constexpr int m_totsigNBins = 100
 
static constexpr float m_totsigLo = 0.
 
static constexpr float m_totsigHi = 1.
 
static constexpr int m_nFE = 16
 
static constexpr int m_ncharge = 21
 
static constexpr std::array< float, m_ncharge > m_chargeArr { 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000, 7500, 8000, 8500, 9000, 9500, 10000, 12000, 14000, 16000, 18000, 20000, 25000}
 
static constexpr std::array< float, m_ncharge > m_chargeErrArr { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 
static constexpr int m_qthresh = 5
 

Detailed Description

Definition at line 34 of file Calib.h.

Constructor & Destructor Documentation

◆ Calib()

Calib::Calib ( int  whichPart,
bool  saveFile,
const std::string &  moduleName = "" 
)
inline

Definition at line 36 of file Calib.h.

36  {
37  m_whichPart = whichPart;
38 
39  if(saveFile){
40  m_savefile = saveFile;
41  m_wFile = std::make_unique<TFile>(m_layers.at(whichPart)+".HIST.root","RECREATE");
42  }
43  if( not moduleName.empty() ){
44  m_runOneMOD = true;
45  m_testMOD = moduleName;
46  }
47  };

◆ ~ Calib()

Calib::~ Calib ( )
inline

Definition at line 48 of file Calib.h.

48  {
49  if(m_savefile){
50  m_wFile->Write(0,TObject::kOverwrite);
51  m_wFile->Close();
52  }
53  };

Member Function Documentation

◆ chipId()

int Calib::chipId ( int  iphi,
int  ieta 
)
private

Definition at line 716 of file Calib.cxx.

716  {
717  int circ = -1;
718  if (iphi < 160) {
719  circ = (int)(ieta / 18);
720  } else {
721  circ = 15 - (int)(ieta / 18);
722  } // FE15, FE14, ... FE8
723 
724  if (circ>15){
725  printf("Error - FE id error: %d, setting it to -1",circ);
726  circ = -1;//error
727  }
728  return circ;
729 }

◆ fillThresholds()

bool Calib::fillThresholds ( const pix::PixelMapping &  pm,
const std::string &  inThrFile,
std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &  map_info 
)

Definition at line 532 of file Calib.cxx.

532  {
533 
534  if (inThrFile.empty()) return false;
535 
536  TFile riThrFile(inThrFile.c_str(),"READ");
537  if (not riThrFile.IsOpen()) {
538  printf("Error - File %s could not be opened.\n",inThrFile.c_str());
539  return false;
540  } else {
541  printf("File %s opened.\n",inThrFile.c_str());
542  printf("Running threshold calibration...\n");
543  }
544 
545  // Creating here the histograms with this scope owner
546  std::vector< std::vector< std::unique_ptr<TH1F> > > histogramsTHR;
547  std::vector< std::vector< std::unique_ptr<TH1F> > > histogramsSIG;
548  for(unsigned int FE = 0; FE < m_nFE; FE++){
549 
550  histogramsTHR.push_back( std::vector< std::unique_ptr<TH1F> >() );
551  histogramsSIG.push_back( std::vector< std::unique_ptr<TH1F> >() );
552 
553  for(unsigned int pixel=0; pixel<3; pixel++){
554  TString title = "FE"+std::to_string(FE)+"_pixType"+std::to_string(pixel);
555  std::unique_ptr<TH1F> hthr = std::make_unique<TH1F>(title+"_thr", title+"_thr", m_thrnbins, m_thrLo, m_thrHi);
556  hthr->SetDirectory(0);
557  std::unique_ptr<TH1F> hsig = std::make_unique<TH1F>(title+"_sig", title+"_sig", m_thrnbins, m_sigLo, m_sigHi);
558  hsig->SetDirectory(0);
559  //cppcheck-suppress containerOutOfBounds
560  histogramsTHR.at(FE).push_back(std::move(hthr));
561  //cppcheck-suppress containerOutOfBounds
562  histogramsSIG.at(FE).push_back(std::move(hsig));
563  }
564  }
565 
566  //Will strat looping over the RODs
567  TIter rodItr = getRodIterator(riThrFile);
568  TKey* rodKey;
569  while ((rodKey=static_cast<TKey*>(rodItr()))) {
570  const TString rodName(rodKey->GetName());
571  TDirectoryFile* rodDir = (TDirectoryFile*)rodKey->ReadObj();
572  TKey* modKey;
573  TIter modItr=getModuleIterator(rodDir);
574 
575  // Looping over the MODs of each ROD
576  while ((modKey=static_cast<TKey*>(modItr()))) {
577  TString modName(modKey->GetName());
578 
579  if ( not moduleInPart(modName)){
580  continue;
581  }
582  if ( not pm.contains(std::string(modName))){
583  printf("Error - Module %s not found in the PixelMapping tool\n",modName.Data());
584  continue;
585  }
586 
587  if( m_runOneMOD and strcmp(modName, m_testMOD) != 0){
588  continue;
589  }
590 
591  // pixel discriminator threshold
592  std::unique_ptr<TH2F> h2dThr(get2DHistogramFromPath(rodDir,modName, "SCURVE_MEAN"));
593  h2dThr->SetDirectory(0);
594 
595  // Getting histogram for noise
596  std::unique_ptr<TH2F>h2dSig(get2DHistogramFromPath(rodDir,modName, "SCURVE_SIGMA"));
597  h2dSig->SetDirectory(0);
598 
599  for (unsigned int ieta = 0; ieta < m_etaBins; ieta++) {
600  for (unsigned int iphi = 0; iphi < m_phiBins; iphi++) {
601 
602  float thr = h2dThr->GetBinContent(ieta + 1, iphi + 1);
603  float sig = h2dSig->GetBinContent(ieta + 1, iphi + 1);
604 
605  if (thr == 0 || thr > 10000 || sig == 0 || sig > 1000) {
606  continue;
607  }
608 
609  int FE = chipId(iphi, ieta);
610  int pixel= pixelType(iphi, ieta);
611 
612  if(FE<0){
613  return false;
614  }
615 
616  histogramsTHR.at(FE).at(pixel)->Fill(thr);
617  histogramsSIG.at(FE).at(pixel)->Fill(sig);
618 
619  }
620  }
621 
622  // Freeing memory of TH2F
623  h2dThr.reset();
624  h2dSig.reset();
625 
626  int modID = pm.getID(std::string(modName));
627  auto itr = map_info.find( modID );
628 
629  // Map should be empty and therefore we need to create the key - if the key is repeated then it will throw an error
630  if (itr == map_info.end()) {
631 
632  map_info[modID] = std::vector<std::unique_ptr<CalibFrontEndInfo>> ();
633 
634  for(unsigned int FE = 0; FE < m_nFE; FE++){
635  TString subdir(((FE < 10) ? "FE0" : "FE") +std::to_string(FE));
636  map_info[modID].push_back( std::unique_ptr<CalibFrontEndInfo>() );
637  std::unique_ptr<CalibFrontEndInfo> p = std::make_unique<CalibFrontEndInfo>(modID,FE,std::string(modName),std::string(rodKey->GetName()));
638  map_info[modID].at(FE) = std::move(p);
639 
640  for(unsigned int pixel=0; pixel<3; pixel++){
641 
642  // Saving information for the calibration
643  int thr_mean = histogramsTHR.at(FE).at(pixel)->GetMean();
644  int thr_rms = histogramsTHR.at(FE).at(pixel)->GetRMS();
645  int sig_mean = histogramsSIG.at(FE).at(pixel)->GetMean();
646 
647  if(m_savefile){
648 
649  m_wFile->cd();
650  if( !m_wFile->Get(rodName+"/"+modName+"/Thresholds/"+subdir) ){
651  m_wFile->mkdir(rodName+"/"+modName+"/Thresholds/"+subdir,rodName);
652  }
653 
654  m_wFile->cd(rodName+"/"+modName+"/Thresholds/"+subdir);
655 
656  histogramsTHR.at(FE).at(pixel)->SetTitle("Threshold;Pixel threshold;Counts");
657  histogramsSIG.at(FE).at(pixel)->SetTitle("Sigma;Pixel sigma;Counts");
658 
659  std::string type = "";
660  if(pixel == 0) type = "normal";
661  else if(pixel == 1) type = "long";
662  else if(pixel == 2) type = "ganged";
663 
664  histogramsTHR.at(FE).at(pixel)->Write(TString("thres_"+type).Data(), TObject::kWriteDelete);
665  histogramsSIG.at(FE).at(pixel)->Write(TString("sigma_"+type).Data(), TObject::kWriteDelete);
666  }
667 
668  // Reset histograms for next front end
669  histogramsTHR.at(FE).at(pixel)->Reset("ICESM");
670  histogramsSIG.at(FE).at(pixel)->Reset("ICESM");
671 
672  if(pixel == 0){ // normal
673  map_info[modID].at(FE)->set_NormalThreshold(thr_mean);
674  map_info[modID].at(FE)->set_NormalRms(thr_rms);
675  map_info[modID].at(FE)->set_NormalNoise(sig_mean);
676  }
677  else if(pixel == 1){ // long
678  map_info[modID].at(FE)->set_LongThreshold(thr_mean);
679  map_info[modID].at(FE)->set_LongRms(thr_rms);
680  map_info[modID].at(FE)->set_LongNoise(sig_mean);
681  }
682  else if(pixel == 2){ // ganged
683  map_info[modID].at(FE)->set_GangedThreshold(thr_mean);
684  map_info[modID].at(FE)->set_GangedRms(thr_rms);
685  map_info[modID].at(FE)->set_GangedNoise(sig_mean);
686  }
687  else{
688  printf("Calib::fillThresholds: ERROR - Bad pixel in Calib::fillThresholds\n");
689  return false;
690  }
691  }
692  }
693 
694  }
695  else{
696  printf("Calib::fillThresholds: ERROR - REPEATED MOD ID: %s! Contact Offline team\n",std::string(modName).c_str());
697  return false;
698  }
699  } // End of MOD loop
700  } // End of ROD loop
701 
702  for(unsigned int FE = 0; FE < m_nFE; FE++) {
703  for(unsigned int pixel=0; pixel<3; pixel++) {
704  histogramsTHR.at(FE).at(pixel).reset();
705  histogramsSIG.at(FE).at(pixel).reset();
706  }
707  }
708 
709  //Closing file - not needed anymore
710  riThrFile.Close();
711  printf("DONE with threshold calibration.\n");
712  return true;
713 }

◆ fillTiming()

bool Calib::fillTiming ( const pix::PixelMapping &  pm,
const std::string &  inTimFile,
std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &  map_info 
)

Definition at line 352 of file Calib.cxx.

352  {
353 
354  if (inTimFile.empty()) return false;
355 
356  TFile timFile(inTimFile.c_str(),"READ");
357  if (not timFile.IsOpen()) {
358  printf("Error - File %s could not be opened.\n",inTimFile.c_str());
359  return false;
360  } else {
361  printf("File %s opened.\n",inTimFile.c_str());
362  printf("Running timming calibration...\n");
363  }
364 
365  // Creating here the histograms with this scope owner
366  std::vector< std::vector< std::unique_ptr<TH1F> > > histogramsTIM;
367  for(unsigned int FE = 0; FE < m_nFE; FE++){
368 
369  histogramsTIM.push_back( std::vector< std::unique_ptr<TH1F> >() );
370 
371  for(unsigned int pixel=0; pixel<3; pixel++){
372  TString title = "FE"+std::to_string(FE)+"_pixType"+std::to_string(pixel);
373  std::unique_ptr<TH1F> h = std::make_unique<TH1F>(title+"_thr", title+"_thr", m_timnbins, m_timLo, m_timHi);
374  h->SetDirectory(0);
375  //cppcheck-suppress containerOutOfBounds
376  histogramsTIM.at(FE).push_back(std::move(h));
377  }
378  }
379 
380  //Will strat looping over the RODs
381  TIter rodItr = getRodIterator(timFile);
382  TKey* rodKey;
383  while ((rodKey=static_cast<TKey*>(rodItr()))) {
384  const TString rodName(rodKey->GetName());
385  TDirectoryFile* rodDir = static_cast<TDirectoryFile*>(rodKey->ReadObj());
386  TKey* modKey;
387  TIter modItr=getModuleIterator(rodDir);
388 
389  // Looping over the MODs of each ROD
390  while ((modKey=static_cast<TKey*>(modItr()))) {
391  TString modName(modKey->GetName());
392 
393  if ( not moduleInPart(modName)){
394  continue;
395  }
396  if ( not pm.contains(std::string(modName))){
397  printf("Error - Module %s not found in the PixelMapping tool\n",modName.Data());
398  continue;
399  }
400 
401  if( m_runOneMOD and strcmp(modName, m_testMOD) != 0){
402  continue;
403  }
404 
405  std::unique_ptr<TH2F> h2dTim(get2DHistogramFromPath(rodDir,modName, "SCURVE_MEAN"));
406  h2dTim->SetDirectory(0);
407 
408  for (unsigned int ieta = 0; ieta < m_etaBins; ieta++) {
409  for (unsigned int iphi = 0; iphi < m_phiBins; iphi++) {
410 
411  float tim = h2dTim->GetBinContent(ieta + 1, iphi + 1);
412 
413  if (tim<0.5) {
414  continue;
415  }
416 
417  int FE = chipId(iphi, ieta);
418  int pixel= pixelType(iphi, ieta);
419 
420  if(FE<0){
421  return false;
422  }
423 
424  histogramsTIM.at(FE).at(pixel)->Fill(tim);
425  }
426  }
427 
428  // Freeing memory of TH2F
429  h2dTim.reset();
430 
431  int modID = pm.getID(std::string(modName));
432  auto itr = map_info.find( modID );
433  if (itr == map_info.end()) {
434  printf("Calib::fillTiming: ERROR - Mod ID= %16s not found. Creating it -----> Inform Pixel Offline Software Experts... \n",std::string(modName).c_str());
435 
436  map_info[modID] = std::vector<std::unique_ptr<CalibFrontEndInfo>> ();
437 
438  for(unsigned int FE = 0; FE < m_nFE; FE++){
439 
440  map_info[modID].push_back( std::unique_ptr<CalibFrontEndInfo>() );
441  std::unique_ptr<CalibFrontEndInfo> p = std::make_unique<CalibFrontEndInfo>(modID,FE,std::string(modName),std::string(rodKey->GetName()));
442  map_info[modID].at(FE) = std::move(p);
443 
444  for(unsigned int pixel=0; pixel<3; pixel++){
445 
446  // Saving information for the calibration
447  int tim_mean = histogramsTIM.at(FE).at(pixel)->GetMean();
448 
449  // Reset histograms for next front end
450  histogramsTIM.at(FE).at(pixel)->Reset("ICESM");
451 
452  if(pixel == 0){ // normal
453  map_info[modID].at(FE)->set_NormalIntime(tim_mean);
454  }
455  else if(pixel == 1){ // long
456  map_info[modID].at(FE)->set_LongIntime(tim_mean);
457  }
458  else if(pixel == 2){ // ganged
459  map_info[modID].at(FE)->set_GangedIntime(tim_mean);
460  }
461  else{
462  printf("Error - Bad pixel in Calib::fillTiming\n");
463  return false;
464  }
465  }
466  }
467 
468  }
469  else{
470  for(unsigned int FE = 0; FE < m_nFE; FE++){
471  TString subdir(((FE < 10) ? "FE0" : "FE") +std::to_string(FE));
472  for(unsigned int pixel=0; pixel<3; pixel++){
473 
474  // Saving information for the calibration
475  int tim_mean = histogramsTIM.at(FE).at(pixel)->GetMean();
476 
477  if(m_savefile){
478 
479  m_wFile->cd();
480  if( !m_wFile->Get(rodName+"/"+modName+"/Thresholds/"+subdir) ){
481  m_wFile->mkdir(rodName+"/"+modName+"/Thresholds/"+subdir,rodName);
482  }
483 
484  m_wFile->cd(rodName+"/"+modName+"/Thresholds/"+subdir);
485 
486  histogramsTIM.at(FE).at(pixel)->SetTitle("Intime;Pixel intime;Counts");
487 
488  std::string type = "";
489  if(pixel == 0) type = "normal";
490  else if(pixel == 1) type = "long";
491  else if(pixel == 2) type = "ganged";
492 
493  histogramsTIM.at(FE).at(pixel)->Write(TString("intime_"+type).Data(), TObject::kWriteDelete);
494  }
495 
496  // Reset histograms for next front end
497  histogramsTIM.at(FE).at(pixel)->Reset("ICESM");
498 
499  if(pixel == 0){ // normal
500  (itr->second).at(FE)->set_NormalIntime(tim_mean);
501  }
502  else if(pixel == 1){ // long
503  (itr->second).at(FE)->set_LongIntime(tim_mean);
504  }
505  else if(pixel == 2){ // ganged
506  (itr->second).at(FE)->set_GangedIntime(tim_mean);
507  }
508  else{
509  printf("Error - Bad pixel in Calib::fillTiming\n");
510  return false;
511  }
512  } // End of pixel type loop
513  } // End of FE loop
514  }
515  } // End of MOD loop
516  }// End of ROD loop
517 
518  for(unsigned int FE = 0; FE < m_nFE; FE++) {
519  for(unsigned int pixel=0; pixel<3; pixel++) {
520  histogramsTIM.at(FE).at(pixel).reset();
521  }
522  }
523 
524  //Closing file - not needed anymore
525  timFile.Close();
526  printf("DONE with threshold calibration.\n");
527  return true;
528 }

◆ get2DHistogramFromPath()

TH2F * Calib::get2DHistogramFromPath ( TDirectoryFile *  rodDir,
const TString &  moduleName,
const TString &  histName,
int  charge = -1 
)
private

Definition at line 764 of file Calib.cxx.

764  {
765  TString suffix = (charge<0) ? ("") : (TString("/C") + charge);
766  TString fullHistoPath = moduleName + "/" + histName + "/A0/B0" + suffix;
767  TDirectoryFile *histDir = static_cast<TDirectoryFile *>(rodDir->GetDirectory(fullHistoPath));
768 
769  if(!histDir){
770  printf("Error - Directory \"%s\" not found. Exiting..\n",fullHistoPath.Data());
771  return nullptr;
772  }
773  TH2F *pTH2 = static_cast<TH2F*>((static_cast<TKey*>(histDir->GetListOfKeys()->First()))->ReadObj());
774  pTH2->SetDirectory(0);
775 
776  return pTH2;
777 }

◆ getModuleIterator()

TIter Calib::getModuleIterator ( TDirectoryFile *  rodDir)
private

Definition at line 759 of file Calib.cxx.

759  {
760  TList* modKeyList = static_cast<TList*>(rodDir->GetListOfKeys());
761  return TIter(modKeyList);
762 }

◆ getParams()

std::vector< float > Calib::getParams ( const TF1 *  f,
unsigned int  params 
)
private

Definition at line 787 of file Calib.cxx.

787  {
788  std::vector<float> v;
789  for(unsigned int i = 0; i<params; i++){
790  v.push_back(f->GetParameter(i));
791  }
792 
793  return v;
794 }

◆ getParams_quality()

std::vector< float > Calib::getParams_quality ( const TF1 *  f)
private

Definition at line 796 of file Calib.cxx.

796  {
797  std::vector<float> v;
798 
799  v.push_back(f->GetChisquare());
800  v.push_back(f->GetNDF());
801 
802  return v;
803 }

◆ getRodIterator()

TIter Calib::getRodIterator ( const TFile &  inputFile)
private

Definition at line 753 of file Calib.cxx.

753  {
754  TDirectoryFile* scanDir = static_cast<TDirectoryFile*>((static_cast<TKey*>(inputFile.GetListOfKeys()->First()))->ReadObj());
755  TList* rodKeyList = static_cast<TList*>(scanDir->GetListOfKeys());
756  return TIter(rodKeyList);
757 }

◆ graphTitles()

void Calib::graphTitles ( const std::unique_ptr< TGraphErrors > &  graph,
const std::string &  name,
const std::string &  Yname 
)
private

Definition at line 805 of file Calib.cxx.

805  {
806  graph->SetTitle(TString(name)+";Charge;"+TString(Yname));
807  graph->SetMarkerStyle(20);
808 }

◆ moduleInPart()

bool Calib::moduleInPart ( const TString &  modName)
private

Definition at line 779 of file Calib.cxx.

779  {
780  if (modName == "DSP_ERRORS") {
781  return false;
782  }
783  return modName.BeginsWith(m_MODprefixes[m_whichPart]);
784 }

◆ pixelType()

int Calib::pixelType ( int  iphi,
int  ieta,
bool  isForTOT = false 
)
private

Definition at line 732 of file Calib.cxx.

732  {
733 
734  // normal pixels ( by default )
735  int pixtype = 0;
736 
737  // define long pixels
738  if (ieta % 18 == 0 || ieta % 18 == 17) {
739  pixtype = 1;
740  }
741  // define ganged pixels
742  if (iphi > 152 && iphi < 160 && iphi % 2 == 1) {
743  pixtype = 2;
744  }
745  if (iphi > 159 && iphi < 167 && iphi % 2 == 0) {
746  pixtype = 2;
747  }
748 
749  if(isForTOT and pixtype == 2 ) pixtype=1;
750  return pixtype;
751 }

◆ reFit_normalPix()

bool Calib::reFit_normalPix ( std::vector< float > &  params,
std::vector< float > &  q,
std::vector< float > &  qerr,
std::vector< float > &  tot,
std::vector< float > &  toterr,
std::vector< float > &  sig,
std::vector< float > &  sigerr,
const unsigned int  fe 
)
private

Definition at line 298 of file Calib.cxx.

298  {
299 
300  float vecFit_size = q.size()+1;
301  // float vecFit_size = q.size() - m_qthresh;
302  float stopFit = m_ncharge/2.0;
303  // float stopFit = (m_ncharge - m_qthresh)/2.0;
304  if(vecFit_size < stopFit) {
305 
306  // Default values for the fit
307  params.at(0) = 0;
308  params.at(1) = -28284.3;
309  params.at(2) = 0;
310 
311  printf("reFit_normalPix: Refitting skipped. Not enough points to fit.\n");
312 
313  return false;
314  }
315 
316  float parAI0 = params.at(0);
317  float parEI0 = params.at(1);
318  float parCI0 = params.at(2);
319 
320  std::vector<float> v_discrepancy;
321 
322  for(unsigned int i = 0; i < q.size(); i++){
323  float discrepancy = std::abs( 1 - ( (parAI0 * parEI0 - parCI0 * tot.at(i)) / (tot.at(i) - parAI0) ) / q.at(i) );
324 
325  if( i < m_qthresh ){
326  discrepancy = 0.0;
327  }
328  v_discrepancy.push_back(discrepancy);
329  }
330 
331  auto itr_max = std::max_element(v_discrepancy.begin(),v_discrepancy.end());
332 
333  if(*itr_max > m_chi_error){
334 
335  size_t n_max = std::distance(v_discrepancy.begin(), itr_max);
336  printf("FE %02u Refitted, removing charge %5.0f with chi_error %7.5f\n", fe ,q.at(n_max),*itr_max);
337  q.erase(q.begin()+n_max);
338  qerr.erase(qerr.begin()+n_max);
339  tot.erase(tot.begin()+n_max);
340  toterr.erase(toterr.begin()+n_max);
341  sig.erase(sig.begin()+n_max);
342  sigerr.erase(sigerr.begin()+n_max);
343 
344  return true;
345  }
346 
347  return false;
348 
349 }

◆ totFitting()

bool Calib::totFitting ( const pix::PixelMapping &  pm,
const std::string &  inTimFile,
std::map< unsigned int, std::vector< std::unique_ptr< CalibFrontEndInfo >> > &  map_info 
)

Definition at line 15 of file Calib.cxx.

15  {
16 
17  if (inTotFile.empty()) return false;
18 
19  TFile totFile(inTotFile.c_str(),"READ");
20  if (not totFile.IsOpen()) {
21  printf("Error - File %s could not be opened.\n",inTotFile.c_str());
22  totFile.Close();
23  return false;
24  } else {
25  printf("File %s opened.\n",inTotFile.c_str());
26  printf("Running TOT calibration...\n");
27  }
28 
29  // Creating here the histograms with this scope ownership
30  std::vector< std::vector< std::unique_ptr<TH1F> > > histogramsTOT;
31  std::vector< std::vector< std::unique_ptr<TH1F> > > histogramsTOTsig;
32  for(unsigned int FE = 0; FE < m_nFE; FE++){
33 
34  histogramsTOT.push_back( std::vector< std::unique_ptr<TH1F> >() );
35  histogramsTOTsig.push_back( std::vector< std::unique_ptr<TH1F> >() );
36 
37  //Here we combine long and ganged pixels
38  for(unsigned int pixel=0; pixel<2; pixel++){
39  TString title = "FE"+std::to_string(FE)+"_pixType"+std::to_string(pixel);
40  std::unique_ptr<TH1F> htot = std::make_unique<TH1F>(title+"_tot", title+"_tot", m_totnbins, m_totLo, m_totHi);
41  htot->SetDirectory(0);
42  std::unique_ptr<TH1F> htotsig = std::make_unique<TH1F>(title+"_totsig", title+"_totsig", m_totsigNBins, m_totsigLo, m_totsigHi);
43  htotsig->SetDirectory(0);
44  //cppcheck-suppress containerOutOfBounds
45  histogramsTOT.at(FE).push_back(std::move(htot));
46  //cppcheck-suppress containerOutOfBounds
47  histogramsTOTsig.at(FE).push_back(std::move(htotsig));
48  }
49  }
50 
51  // Start looping over the ROD, MOD and charges
52  TIter rodItr=getRodIterator(totFile);
53  TKey* rodKey;
54 
55  while ((rodKey=static_cast<TKey*>(rodItr()))) {
56  TDirectoryFile* rodDir = static_cast<TDirectoryFile*>(rodKey->ReadObj());
57  TIter modItr = getModuleIterator(rodDir);
58  const TString rodName(rodKey->GetName());
59  printf("%s\n",rodName.Data());
60  TKey* modKey;
61  while ((modKey=static_cast<TKey*>(modItr()))) {
62  const TString modName(modKey->GetName());
63 
64  if (not moduleInPart(modName)) continue;
65  if (not pm.contains(std::string(modName))) continue;
66 
67  if( m_runOneMOD and strcmp(modName, m_testMOD) != 0){
68  continue;
69  }
70 
71  printf(" -> %s\n",modName.Data());
72 
73  //creates arrays for the Tgraph
74  std::array<std::array<float, m_ncharge>, m_nFE> totArrI{};
75  std::array<std::array<float, m_ncharge>, m_nFE> totErrArrI{};
76  std::array<std::array<float, m_ncharge>, m_nFE> totSigArrI{};
77  std::array<std::array<float, m_ncharge>, m_nFE> totSigErrArrI{};
78  std::array<std::array<float, m_ncharge>, m_nFE> totLongArrI{};
79  std::array<std::array<float, m_ncharge>, m_nFE> totErrLongArrI{};
80 
81  // loop over charges
82  for (int c=0; c<m_ncharge; ++c) {
83 
84  // Get TH2 for a given charge
85  std::unique_ptr<TH2F> h2dTOTmean(get2DHistogramFromPath(rodDir,modName, "TOT_MEAN", c));
86  std::unique_ptr<TH2F> h2dTOTsig(get2DHistogramFromPath(rodDir,modName, "TOT_SIGMA", c));
87  if(!h2dTOTmean or !h2dTOTsig) {
88  return false;
89  }
90  h2dTOTmean->SetDirectory(0);
91  h2dTOTsig->SetDirectory(0);
92  // loop over pixels
93  for (unsigned int ieta = 0; ieta < m_etaBins; ieta++) {
94  for (unsigned int iphi = 0; iphi < m_phiBins; iphi++) {
95  float totmean = h2dTOTmean->GetBinContent(ieta + 1, iphi + 1);
96  float totsig = h2dTOTsig ->GetBinContent(ieta + 1, iphi + 1);
97 
98  if (totmean<0.1) {
99  continue;
100  }
101 
102  int FE = chipId(iphi, ieta);
103  int pixel= pixelType(iphi, ieta, true);
104 
105  if(FE<0){
106  return false;
107  }
108 
109  histogramsTOT.at(FE).at(pixel)->Fill(totmean);
110  histogramsTOTsig.at(FE).at(pixel)->Fill(totsig);
111 
112  }
113  }
114 
115  // free memory
116  h2dTOTmean.reset();
117  h2dTOTsig.reset();
118 
119  //filling arrays
120  for(unsigned int FE = 0; FE < m_nFE; FE++){
121  for(unsigned int pixel = 0; pixel <2; pixel++){
122 
123  if(pixel == 0){
124  totArrI.at(FE).at(c) = histogramsTOT.at(FE).at(pixel)->GetMean();
125  totErrArrI.at(FE).at(c) = histogramsTOT.at(FE).at(pixel)->GetMeanError();
126  totSigArrI.at(FE).at(c) = std::sqrt(std::pow(histogramsTOTsig.at(FE).at(pixel)->GetMean() ,2)+std::pow(histogramsTOT.at(FE).at(pixel)->GetRMS() ,2));
127  totSigErrArrI.at(FE).at(c) = std::sqrt(std::pow(histogramsTOTsig.at(FE).at(pixel)->GetMeanError(),2)+std::pow(histogramsTOT.at(FE).at(pixel)->GetRMSError(),2));
128 
129  if(totSigErrArrI.at(FE).at(c) > 1.0){
130  totArrI.at(FE).at(c) = 0.0;
131  }
132 
133  }
134  else{
135  totLongArrI.at(FE).at(c) = histogramsTOT.at(FE).at(pixel)->GetMean();
136  totErrLongArrI.at(FE).at(c) = histogramsTOT.at(FE).at(pixel)->GetMeanError();
137 
138  if(totErrLongArrI.at(FE).at(c) > 1.0){
139  totLongArrI.at(FE).at(c) = 0.0;
140  }
141 
142  }
143 
144  //reset histogram for next iteration
145  histogramsTOT.at(FE).at(pixel)->Reset("ICESM");
146  histogramsTOTsig.at(FE).at(pixel)->Reset("ICESM");
147  }
148  }
149  } // End of charge.
150 
151  // loop over FE and create a graph for fitting
152  for(unsigned int FE = 0; FE < m_nFE; FE++) {
153 
154  TString subdir(((FE < 10) ? "FE0" : "FE") +std::to_string(FE));
155 
156  std::vector<float> v_Q;
157  std::vector<float> v_Qerr;
158  std::vector<float> v_TOT;
159  std::vector<float> v_TOTerr;
160  std::vector<float> v_TOTsig;
161  std::vector<float> v_TOTsigerr;
162  std::vector<float> v_TOTlong;
163  std::vector<float> v_TOTlongerr;
164 
165  std::copy(std::begin(m_chargeArr) , std::end(m_chargeArr) , std::back_inserter(v_Q) );
166  std::copy(std::begin(m_chargeErrArr) , std::end(m_chargeErrArr) , std::back_inserter(v_Qerr) );
167  std::copy(std::begin(totArrI[FE]) , std::end(totArrI[FE]) , std::back_inserter(v_TOT) );
168  std::copy(std::begin(totErrArrI[FE]) , std::end(totErrArrI[FE]) , std::back_inserter(v_TOTerr) );
169  std::copy(std::begin(totSigArrI[FE]) , std::end(totSigArrI[FE]) , std::back_inserter(v_TOTsig) );
170  std::copy(std::begin(totSigErrArrI[FE]) , std::end(totSigErrArrI[FE]) , std::back_inserter(v_TOTsigerr) );
171  std::copy(std::begin(totLongArrI[FE]) , std::end(totLongArrI[FE]) , std::back_inserter(v_TOTlong) );
172  std::copy(std::begin(totErrLongArrI[FE]) , std::end(totErrLongArrI[FE]) , std::back_inserter(v_TOTlongerr) );
173 
174  std::vector<float> pixNormalParams;
175  std::vector<float> pixNormalParamsQuality;
176  std::vector<float> pixSigParams;
177  std::vector<float> pixSigParamsQuality;
178  std::vector<float> pixLongParams;
179  std::vector<float> pixLongParamsQuality;
180 
181  //For normal pixels and sig
182  uint8_t n_fit = 0;
183  do{
184  int vecsize = v_Q.size();
185 
186  std::unique_ptr<TGraphErrors> graphnormal = std::make_unique<TGraphErrors>(vecsize, &v_Q.at(0), &v_TOT.at(0) , &v_Qerr.at(0), &v_TOTerr.at(0) );
187  std::unique_ptr<TGraphErrors> graphsig = std::make_unique<TGraphErrors>(vecsize, &v_Q.at(0), &v_TOTsig.at(0) , &v_Qerr.at(0), &v_TOTsigerr.at(0) );
188 
189  std::unique_ptr<TF1> functnormal = std::make_unique<TF1>("normal" ,new funcTot , m_chargeArr[m_qthresh]-100, m_chargeArr[m_ncharge-1]+100, 3);
190  std::unique_ptr<TF1> functnormalsig = std::make_unique<TF1>("normal_sig",new funcDisp, m_chargeArr[m_qthresh]-100, m_chargeArr[m_ncharge-1]+100, 2);
191 
192  graphnormal->Fit(functnormal.get() ,"MRQ");
193  graphsig ->Fit(functnormalsig.get(),"MRQ");
194 
195  pixNormalParams = getParams(functnormal.get() ,3 );
196  pixSigParams = getParams(functnormalsig.get(),2 );
197 
198  pixNormalParamsQuality = getParams_quality(functnormal.get() );
199  pixSigParamsQuality = getParams_quality(functnormalsig.get());
200 
201  if(m_savefile){
202 
203  m_wFile->cd();
204  if( !m_wFile->Get(rodName+"/"+modName+"/TOTfits/"+subdir) ){
205  m_wFile->mkdir(rodName+"/"+modName+"/TOTfits/"+subdir,rodName);
206  }
207 
208  m_wFile->cd(rodName+"/"+modName+"/TOTfits/"+subdir);
209 
210  graphTitles(graphnormal, TString(modName+" - "+subdir+" - normal pixels: Fit: "+std::to_string(n_fit)).Data(), "TOT");
211  graphTitles(graphsig , TString(modName+" - "+subdir+" - normal pixels: Fit: "+std::to_string(n_fit)).Data(), "Charge smearing");
212 
213  graphnormal->Write(TString("normal_fit_"+std::to_string(n_fit)), TObject::kWriteDelete);
214  graphsig->Write(TString("smearing_fit_"+std::to_string(n_fit)), TObject::kWriteDelete);
215  n_fit++;
216  }
217 
218  functnormal.reset();
219  functnormalsig.reset();
220 
221  graphnormal.reset();
222  graphsig.reset();
223 
224  }while(reFit_normalPix(pixNormalParams, v_Q, v_Qerr, v_TOT, v_TOTerr, v_TOTsig, v_TOTsigerr, FE ) );
225 
226 
227  // Since we have modified the vector size we need to clear it and refill it for the long and gange pixels
228  v_Q.clear();
229  v_Qerr.clear();
230 
231  std::copy(std::begin(m_chargeArr) , std::end(m_chargeArr) , std::back_inserter(v_Q) );
232  std::copy(std::begin(m_chargeErrArr) , std::end(m_chargeErrArr) , std::back_inserter(v_Qerr) );
233 
234 
235  //For long and ganged pixels (combined)
236  do{
237 
238  //size will be modified in the condition..
239  int vecsize = v_Q.size();
240 
241  std::unique_ptr<TGraphErrors> graflong = std::make_unique<TGraphErrors>(vecsize, &v_Q.at(0), &v_TOTlong.at(0), &v_Qerr.at(0), &v_TOTlongerr.at(0) );
242 
243  std::unique_ptr<TF1> functlong = std::make_unique<TF1>("long" ,new funcTot , m_chargeArr[m_qthresh]-100, m_chargeArr[m_ncharge-1]+100, 3);
244 
245  graflong ->Fit(functlong.get() ,"MRQ");
246 
247  pixLongParams = getParams(functlong.get() ,3 );
248  pixLongParamsQuality = getParams_quality(functlong.get() );
249 
250  //delete the TF1
251  functlong.reset();
252 
253  //delete the graphs
254  graflong.reset();
255 
256  // no need to loop here.. leaving to improve it in the future - might need refitting
257  }while( false);
258 
259 
260  // Find the module it belong to
261  int modID = pm.getID(std::string(modName));
262  auto itr = map_info.find( modID );
263 
264  if (itr != map_info.end()) {
265  (itr->second).at(FE)->set_NormalParams( pixNormalParams);
266  (itr->second).at(FE)->set_LongParams ( pixLongParams );
267  (itr->second).at(FE)->set_SigParams ( pixSigParams );
268 
269  (itr->second).at(FE)->set_times_fitted ( n_fit );
270 
271  (itr->second).at(FE)->set_NormalParamsQuality( pixNormalParamsQuality);
272  (itr->second).at(FE)->set_LongParamsQuality ( pixLongParamsQuality );
273  (itr->second).at(FE)->set_SigParamsQuality ( pixSigParamsQuality );
274  }
275  else{
276  printf("Error - Module not found in fitting step... Skipping.\n");
277  return false;
278  }
279 
280  } // End of FE loop
281  } // End of MOD
282  } // End of ROD
283 
284  // remove from memory
285  for(unsigned int FE = 0; FE < m_nFE; FE++) {
286  for(unsigned int pixel=0; pixel<2; pixel++) {
287  histogramsTOT.at(FE).at(pixel).reset();
288  histogramsTOTsig.at(FE).at(pixel).reset();
289  }
290  }
291 
292  totFile.Close();
293  return true;
294 }

Member Data Documentation

◆ m_chargeArr

constexpr std::array<float, m_ncharge> Calib::m_chargeArr { 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000, 7500, 8000, 8500, 9000, 9500, 10000, 12000, 14000, 16000, 18000, 20000, 25000}
staticconstexprprivate

Definition at line 96 of file Calib.h.

◆ m_chargeErrArr

constexpr std::array<float, m_ncharge> Calib::m_chargeErrArr { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
staticconstexprprivate

Definition at line 97 of file Calib.h.

◆ m_chi_error

constexpr float Calib::m_chi_error = 0.05
staticconstexprprivate

Definition at line 66 of file Calib.h.

◆ m_etaBins

constexpr int Calib::m_etaBins = 144
staticconstexprprivate

Definition at line 73 of file Calib.h.

◆ m_layers

const std::array<TString, 4> Calib::m_layers {"Blayer", "L1", "L2", "Disk"}
private

Definition at line 71 of file Calib.h.

◆ m_MODprefixes

const std::array<TString, 4> Calib::m_MODprefixes {"L0", "L1", "L2", "D"}
private

Definition at line 70 of file Calib.h.

◆ m_ncharge

constexpr int Calib::m_ncharge = 21
staticconstexprprivate

Definition at line 95 of file Calib.h.

◆ m_nFE

constexpr int Calib::m_nFE = 16
staticconstexprprivate

Definition at line 94 of file Calib.h.

◆ m_phiBins

constexpr int Calib::m_phiBins = 320
staticconstexprprivate

Definition at line 74 of file Calib.h.

◆ m_qthresh

constexpr int Calib::m_qthresh = 5
staticconstexprprivate

Definition at line 100 of file Calib.h.

◆ m_runOneMOD

bool Calib::m_runOneMOD = false
private

Definition at line 63 of file Calib.h.

◆ m_savefile

bool Calib::m_savefile = false
private

Definition at line 60 of file Calib.h.

◆ m_sigHi

constexpr float Calib::m_sigHi = 500
staticconstexprprivate

Definition at line 80 of file Calib.h.

◆ m_sigLo

constexpr float Calib::m_sigLo = 0.
staticconstexprprivate

Definition at line 79 of file Calib.h.

◆ m_testMOD

TString Calib::m_testMOD = ""
private

Definition at line 64 of file Calib.h.

◆ m_thrHi

constexpr float Calib::m_thrHi = 6000.
staticconstexprprivate

Definition at line 78 of file Calib.h.

◆ m_thrLo

constexpr float Calib::m_thrLo = 0.
staticconstexprprivate

Definition at line 77 of file Calib.h.

◆ m_thrnbins

constexpr int Calib::m_thrnbins = 200
staticconstexprprivate

Definition at line 76 of file Calib.h.

◆ m_timHi

constexpr float Calib::m_timHi = 7000.
staticconstexprprivate

Definition at line 84 of file Calib.h.

◆ m_timLo

constexpr float Calib::m_timLo = 1000.
staticconstexprprivate

Definition at line 83 of file Calib.h.

◆ m_timnbins

constexpr int Calib::m_timnbins = 300
staticconstexprprivate

Definition at line 82 of file Calib.h.

◆ m_totHi

constexpr float Calib::m_totHi = 255.
staticconstexprprivate

Definition at line 88 of file Calib.h.

◆ m_totLo

constexpr float Calib::m_totLo = 0.
staticconstexprprivate

Definition at line 87 of file Calib.h.

◆ m_totnbins

constexpr int Calib::m_totnbins = 255
staticconstexprprivate

Definition at line 86 of file Calib.h.

◆ m_totsigHi

constexpr float Calib::m_totsigHi = 1.
staticconstexprprivate

Definition at line 91 of file Calib.h.

◆ m_totsigLo

constexpr float Calib::m_totsigLo = 0.
staticconstexprprivate

Definition at line 90 of file Calib.h.

◆ m_totsigNBins

constexpr int Calib::m_totsigNBins = 100
staticconstexprprivate

Definition at line 89 of file Calib.h.

◆ m_wFile

std::unique_ptr<TFile> Calib::m_wFile
private

Definition at line 61 of file Calib.h.

◆ m_whichPart

int Calib::m_whichPart = -1
private

Definition at line 69 of file Calib.h.

The documentation for this class was generated from the following files:
Calib::m_chi_error
static constexpr float m_chi_error
Definition: Calib.h:66
Calib::m_layers
const std::array< TString, 4 > m_layers
Definition: Calib.h:71
Calib::m_phiBins
static constexpr int m_phiBins
Definition: Calib.h:74
Calib::chipId
int chipId(int iphi, int ieta)
Definition: Calib.cxx:716
Calib::m_nFE
static constexpr int m_nFE
Definition: Calib.h:94
Calib::getRodIterator
TIter getRodIterator(const TFile &inputFile)
Definition: Calib.cxx:753
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:186
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
Calib::m_chargeArr
static constexpr std::array< float, m_ncharge > m_chargeArr
Definition: Calib.h:96
Calib::pixelType
int pixelType(int iphi, int ieta, bool isForTOT=false)
Definition: Calib.cxx:732
Calib::m_MODprefixes
const std::array< TString, 4 > m_MODprefixes
Definition: Calib.h:70
Calib::m_savefile
bool m_savefile
Definition: Calib.h:60
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
Data
@ Data
Definition: BaseObject.h:11
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
Calib::m_sigLo
static constexpr float m_sigLo
Definition: Calib.h:79
Calib::m_thrLo
static constexpr float m_thrLo
Definition: Calib.h:77
Calib::m_totsigLo
static constexpr float m_totsigLo
Definition: Calib.h:90
pix::PixelMapping::getID
int getID(const std::string &geographicalID) const
Definition: PixelMapping.cxx:86
Calib::m_timnbins
static constexpr int m_timnbins
Definition: Calib.h:82
Calib::m_totHi
static constexpr float m_totHi
Definition: Calib.h:88
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
Calib::getParams_quality
std::vector< float > getParams_quality(const TF1 *f)
Definition: Calib.cxx:796
Calib::m_thrHi
static constexpr float m_thrHi
Definition: Calib.h:78
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Calib::m_timHi
static constexpr float m_timHi
Definition: Calib.h:84
Calib::m_timLo
static constexpr float m_timLo
Definition: Calib.h:83
Calib::m_chargeErrArr
static constexpr std::array< float, m_ncharge > m_chargeErrArr
Definition: Calib.h:97
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Calib::reFit_normalPix
bool reFit_normalPix(std::vector< float > &params, std::vector< float > &q, std::vector< float > &qerr, std::vector< float > &tot, std::vector< float > &toterr, std::vector< float > &sig, std::vector< float > &sigerr, const unsigned int fe)
Definition: Calib.cxx:298
CaloCondBlobAlgs_fillNoiseFromASCII.inputFile
string inputFile
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:17
lumiFormat.i
int i
Definition: lumiFormat.py:85
Calib::m_wFile
std::unique_ptr< TFile > m_wFile
Definition: Calib.h:61
Calib::m_totsigHi
static constexpr float m_totsigHi
Definition: Calib.h:91
covarianceTool.title
title
Definition: covarianceTool.py:542
python.BuildSignatureFlags.sig
sig
Definition: BuildSignatureFlags.py:218
Calib::getModuleIterator
TIter getModuleIterator(TDirectoryFile *rodDir)
Definition: Calib.cxx:759
Calib::m_etaBins
static constexpr int m_etaBins
Definition: Calib.h:73
hist_file_dump.f
f
Definition: hist_file_dump.py:135
Calib::m_qthresh
static constexpr int m_qthresh
Definition: Calib.h:100
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
funcDisp
double funcDisp(double *x, double *par)
Definition: CalibrateIBL.cxx:60
charge
double charge(const T &p)
Definition: AtlasPID.h:756
Calib::m_thrnbins
static constexpr int m_thrnbins
Definition: Calib.h:76
Calib::m_totsigNBins
static constexpr int m_totsigNBins
Definition: Calib.h:89
Calib::m_sigHi
static constexpr float m_sigHi
Definition: Calib.h:80
python.PyAthena.v
v
Definition: PyAthena.py:154
Calib::graphTitles
void graphTitles(const std::unique_ptr< TGraphErrors > &graph, const std::string &name, const std::string &Yname)
Definition: Calib.cxx:805
Calib::m_totnbins
static constexpr int m_totnbins
Definition: Calib.h:86
h
Calib::m_runOneMOD
bool m_runOneMOD
Definition: Calib.h:63
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
BchCleanup.modName
modName
Definition: BchCleanup.py:201
Calib::moduleInPart
bool moduleInPart(const TString &modName)
Definition: Calib.cxx:779
Calib::m_ncharge
static constexpr int m_ncharge
Definition: Calib.h:95
Calib::getParams
std::vector< float > getParams(const TF1 *f, unsigned int params)
Definition: Calib.cxx:787
extractSporadic.q
list q
Definition: extractSporadic.py:98
Calib::get2DHistogramFromPath
TH2F * get2DHistogramFromPath(TDirectoryFile *rodDir, const TString &moduleName, const TString &histName, int charge=-1)
Definition: Calib.cxx:764
calibdata.copy
bool copy
Definition: calibdata.py:27
Calib::m_whichPart
int m_whichPart
Definition: Calib.h:69
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
python.LumiCalcRecover.subdir
subdir
Definition: LumiCalcRecover.py:25
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
pix::PixelMapping::contains
bool contains(const std::string &geographicalID) const
Definition: PixelMapping.cxx:97
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
Calib::m_totLo
static constexpr float m_totLo
Definition: Calib.h:87
python.compressB64.c
def c
Definition: compressB64.py:93
SiliconTech::pixel
@ pixel
Calib::m_testMOD
TString m_testMOD
Definition: Calib.h:64
Generated on Sun Dec 22 2024 21:27:36 for ATLAS Offline Software by   doxygen 1.8.18