ATLAS Offline Software
computils.cxx
Go to the documentation of this file.
1 
10 // cppcheck-suppress-file stlIfStrFind; cannot use C++20 starts_with in this standalone code
11 
12 #include <stdlib.h>
13 #include <sys/time.h>
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include <glob.h>
17 #include <stdint.h>
18 
19 #include <iostream>
20 #include <string>
21 #include <vector>
22 
23 #include "label.h"
24 #include "DrawLabel.h"
25 
26 #include "TFile.h"
27 #include "TKey.h"
28 #include "TTree.h"
29 #include "TList.h"
30 #include "TObject.h"
31 #include "TDirectory.h"
32 #include "TH1D.h"
33 
34 #include "TLegend.h"
35 #include "TColor.h"
36 
37 #include "computils.h"
38 
39 bool LINEF = true;
40 bool LINES = false;
41 
42 
43 bool Plots::s_watermark = true;
44 
45 int colours[6] = { 1, 2, kBlue-4, 6, kCyan-2, kMagenta+2 };
46 int markers[6] = { 20, 24, 25, 26, 25, 22 };
47 double msizes[6] = { 0.85, 1, 1, 1, 1, 1 };
48 
49 
50 
51 double Entries( TH1* h ) {
52  double n = 0;
53  for ( int i=h->GetNbinsX()+1 ; --i ; ) n += h->GetBinContent(i);
54  return n;
55 }
56 
57 
58 double integral( TH1* h ) {
59  double n=0;
60  for ( int i=h->GetNbinsX() ; i>0 ; i-- ) n += h->GetBinContent(i);
61  return n;
62 }
63 
64 
65 
66 void Norm( TH1* h, double scale ) {
67  double n = 0;
68  for ( int i=h->GetNbinsX()+2 ; --i ; ) n += h->GetBinContent(i);
69  if ( n!=0 ) {
70  double in=scale/n;
71  for ( int i=h->GetNbinsX()+2 ; --i ; ) {
72  h->SetBinContent(i, h->GetBinContent(i)*in );
73  h->SetBinError(i, h->GetBinError(i)*in );
74  }
75  }
76 
77 }
78 
79 
80 
82  m_mean(0), m_error(0) {
83 
84  double f = 0;
85  double fx = 0;
86  double fx2 = 0;
87 
88  for ( int i=0 ; i<h->GetNbinsX() ; i++ ) {
89  double w = h->GetBinLowEdge(i+2)-h->GetBinLowEdge(i+1);
90  f += h->GetBinContent(i+1)*w;
91  fx += h->GetBinContent(i+1)*w*h->GetBinCenter(i+1);
92  fx2 += h->GetBinContent(i+1)*w*h->GetBinCenter(i+1)*h->GetBinCenter(i+1);
93  }
94 
95  if ( f!=0 ) {
96  m_mean = fx/f;
97  m_error = std::sqrt( (fx2/f - m_mean*m_mean )/f );
98  }
99 
100 }
101 
102 
103 
104 
105 
106 
107 
108 union floaty_t {
109  floaty_t( float n = 0.0f ) : f(n) {}
110 
113  bool negative() const { return i < 0; }
114 
116  int32_t raw_mantissa() const { return i & ((1 << 23) - 1); }
118  int32_t raw_exponent() const { return (i >> 23) & 0xff; }
119 
120  int32_t i;
121  float f;
122 };
123 
124 
125 bool almost_equal( floaty_t a, floaty_t b, int max_diff ) {
126 
127  // Check for trivial equality to make sure +0==-0
128  if ( a.f == b.f ) return true;
129 
130  // Different signs means they do not match.
131  if ( a.negative() != b.negative() ) return false;
132 
133  // Find the difference in last place units
134  int ulps_diff = std::abs( a.i - b.i );
135  if (ulps_diff <= max_diff) return true;
136 
137  return false;
138 }
139 
140 
141 bool almost_equal( float a, float b, int max_diff ) {
142  return almost_equal( floaty_t(a), floaty_t(b), max_diff );
143 }
144 
145 
148  return almost_equal( a, b, 5 );
149 }
150 
151 
152 void trim_tgraph( TH1* h, TGraphAsymmErrors* t ) {
153 
154  double ylo = h->GetMinimum();
155 
156  int ih=1;
157 
158  for ( int i=0 ; i<t->GetN() && ih<=h->GetNbinsX() ; i++, ih++ ) {
159 
160  double yt = 0;
161  double xt = 0;
162  double ye = 0;
163 
164  t->GetPoint( i, xt, yt );
165  ye = t->GetErrorYlow( i );
166 
167  double yh = h->GetBinContent(ih);
168  double xh = h->GetBinCenter(ih);
169 
170  while( !almost_equal( xh, xt, 5 ) && ih<=h->GetNbinsX() ) {
171  ih++;
172  yh = h->GetBinContent(ih);
173  xh = h->GetBinCenter(ih);
174  }
175 
176  if ( !almost_equal( yh, yt, 5 ) ) throw data_mismatch(std::string("for histogram ")+h->GetName());
177 
178  if ( (yt-ye) < ylo ) {
179  h->SetBinContent(ih, ylo-100 );
180  t->SetPoint( i, xt, ylo-100 );
181  }
182 
183  }
184 }
185 
186 
187 void ATLASFORAPP_LABEL( double x, double y, int color, double size )
188 {
189  TLatex* lat = new TLatex(); //lat.SetTextAlign(12); lat.SetTextSize(tsize);
190  lat->SetNDC();
191  lat->SetTextFont(72);
192  lat->SetTextColor(color);
193  lat->SetTextSize(size);
194  lat->DrawLatex(x,y,"ATLAS");
195 
196  TLatex* lat2 = new TLatex(); //lat.SetTextAlign(12); lat.SetTextSize(tsize);
197  lat2->SetNDC();
198  lat2->SetTextFont(52);
199  lat2->SetTextColor(color);
200  lat2->SetTextSize(size); // this 0.13 should really be calculated as a ratio of the width of the canvas
201  lat2->DrawLatex(x+0.13,y,"For Approval");
202 }
203 
204 void myText( Double_t x, Double_t y, Color_t color, const std::string& text, Double_t tsize) {
205 
206  //Double_t tsize=0.05;
207  TLatex lat; lat.SetTextAlign(12); lat.SetTextSize(tsize);
208  lat.SetNDC();
209  lat.SetTextColor(color);
210  lat.DrawLatex(x,y,text.c_str());
211 }
212 
213 
214 std::string stime() {
215  time_t t;
216  time(&t);
217  return label("%s", ctime(&t) );
218 }
219 
220 
222 bool contains( const std::string& s, const std::string& p) {
223  return (s.find(p)!=std::string::npos);
224 }
225 
226 
227 bool contains( const std::string& s, char p) noexcept {
228  return (s.find(p)!=std::string::npos);
229 }
230 
231 
233 bool fcontains( const std::string& s, const std::string& p) {
234  return (s.find(p)==0);
235 }
236 
237 
238 double plotable( TH1* h ) { // , double xlo, double xhi ) {
239  double n = 0;
240 
241  double xlo = h->GetBinLowEdge(1);
242  double xhi = h->GetBinLowEdge(h->GetNbinsX()+1);
243 
244  // if ( xlo!=-999 ) _xlo = xlo;
245  // if ( xhi!=-999 ) _xhi = xhi;
246 
247  for ( int i=h->GetNbinsX()+1 ; --i ; ) {
248  if ( h->GetBinCenter(i)>xlo && h->GetBinCenter(i)<xhi ) n += h->GetBinContent(i);
249  }
250  return n;
251 }
252 
253 
254 
255 bool exists( const std::string& filename ) {
256  struct stat sb;
257  if ( stat( filename.c_str(), &sb)==0 ) return true; // && S_ISREG(sb.st_mode ))
258  else return false;
259 }
260 
261 
262 
263 std::string globbed( const std::string& s ) {
266 
267  glob_t glob_result;
268  glob( s.c_str(), GLOB_TILDE, 0, &glob_result );
269 
270  std::vector<std::string> ret;
271  for( unsigned i=0 ; i<glob_result.gl_pathc ; i++ ){
272  ret.push_back( std::string(glob_result.gl_pathv[i]) );
273  }
274  globfree(&glob_result);
275 
276 
277  if ( ret.empty() ) {
278  std::cerr << "no matching file: " << s << std::endl;
279  return "";
280  }
281 
282  if ( ret.size()>1 ) {
283  for ( unsigned i=0 ; i<ret.size() ; i++ ) {
284  std::cout << "matched " << ret[i] << std::endl;
285  }
286  }
287 
288  return ret[0];
289 }
290 
291 
292 
293 
294 
295 bool empty( TH1* h ) {
296  for ( int i=h->GetNbinsX() ; i>0 ; i-- ) if ( h->GetBinContent(i)!=0 ) return false;
297  return true;
298 }
299 
300 
301 std::string tail( std::string s, const std::string& pattern ) {
302  size_t pos = s.find(pattern);
303  while ( pos != std::string::npos ) {
304  s.erase( 0, pos+1 );
305  pos = s.find(pattern);
306  }
307  return s;
308 }
309 
310 
311 std::string head( std::string s, const std::string& pattern ) {
312  size_t pos = s.find_last_of(pattern);
313  if ( pos != std::string::npos ) {
314  s.erase( pos, s.size() );
315  }
316  return s;
317 }
318 
319 
320 void contents( std::vector<std::string>& keys, TDirectory* td,
321  const std::string& directory, const std::string& pattern, const std::string& path ) {
322  std::vector<std::string> patterns;
323  patterns.push_back(pattern);
324  contents( keys, td, directory, patterns, path );
325 }
326 
327 
328 
329 
330 void contents( std::vector<std::string>& keys, TDirectory* td,
331  const std::string& directory, const std::vector<std::string>& patterns, const std::string& path ) {
332 
333  bool print = false;
334 
335  TList* tl = td->GetListOfKeys();
336 
337  for ( int i=tl->GetSize() ; i-- ; ) {
338 
339  TKey* tobj = (TKey*)tl->At(i);
340 
341  if ( tobj==0 ) continue;
342 
343  if ( std::string(tobj->GetClassName()).find("TDirectory")!=std::string::npos ) {
344 
345  TDirectory* tnd = (TDirectory*)tobj->ReadObj();
346 
348  std::string dname = tnd->GetName();
349 
350  std::string newpath = path+dname+"/";
351  contents( keys, tnd, directory, patterns, newpath );
352 
353  }
354  else {
357  if ( directory == "" || contains( path, directory ) ) {
358 
359 
360  bool matched = true;
361  for ( size_t i=patterns.size() ; i-- ; ) {
362  const std::string& pattern = patterns[i];
363  if ( contains(std::string(tobj->GetName()), pattern ) ) matched &=true;
364  else matched = false;
365  }
366  if ( matched ) {
367  if ( print ) std::cout << "will process " << td->GetName() << " \t:: " << tobj->GetName() << "\tpatterns: " << patterns.size() << std::endl;
368  print = false;
369  keys.push_back( path+tobj->GetName() );
370  }
371  }
372  }
373  }
374 }
375 
376 
377 
378 
379 
380 double realmax( TH1* h, bool include_error, double lo, double hi ) {
381  double rm = 0;
382  if ( h->GetNbinsX()==0 ) return 0;
383 
384  bool first = true;
385  for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
386 
387  if ( lo!=hi ) {
388  double c = h->GetBinCenter(i);
389  if ( lo>c || hi<c ) continue;
390  }
391 
392  double re = h->GetBinContent(i);
393  if ( include_error ) re += h->GetBinError(i);
394  if ( re!=0 ) {
395  if ( first || rm<re ) {
396  rm = re;
397  first = false;
398  }
399  }
400  }
401 
402  return rm;
403 }
404 
405 
406 // double realmin( TH1* h, bool include_error, double lo, double hi ) {
407 double realmin( TH1* h, bool , double lo, double hi ) {
408 
409  if ( h->GetNbinsX()==0 ) return 0;
410 
411  double rm = 0;
412 
413  bool first = true;
414  for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
415 
416  if ( lo!=hi ) {
417  double c = h->GetBinCenter(i);
418  if ( lo>c || hi<c ) continue;
419  }
420 
421  double re = h->GetBinContent(i);
422 
423  if ( re!=0 ) {
424  // if ( include_error ) re -= h->GetBinError(i);
425  if ( first || rm>re ) rm = re;
426  first = false;
427  }
428  }
429 
430  return rm;
431 }
432 
433 
434 double hmean( TH1* h ) {
435  double N = integral(h);
436  double n=0;
437  for ( int i=h->GetNbinsX() ; i>0 ; i-- ) {
438  n += h->GetBinContent(i);
439  if ( 2*n>N ) return h->GetBinCenter(i);
440  }
441  return 0;
442 }
443 
444 
445 
446 
447 std::vector<int> findxrange(TH1* h, bool symmetric ) {
448 
449  int ilo = 1;
450  int ihi = h->GetNbinsX();
451 
452  h->GetXaxis()->SetRange( ilo, ihi );
453 
454  std::vector<int> limits(2,0);
455  limits[0] = ilo;
456  limits[1] = ihi;
457 
458  if ( empty(h) ) return limits;
459 
460 #if 1
461 
463  for ( ; ilo<=ihi ; ilo++ ) if ( h->GetBinContent(ilo)!=0 ) break;
464  for ( ; ihi>=ilo ; ihi-- ) if ( h->GetBinContent(ihi)!=0 ) break;
465 
466 #else
467 
469 
471 
472  double icont = 1/content;
473 
474  double flo = 0;
475  double fhi = 0;
476  for ( ; ilo<=ihi ; ilo++ ) {
477  flo += h->GetBinContent(ilo);
478  if ( (flo*icont)>0.0005 ) break;
479  }
480 
481  for ( ; ihi>=ilo ; ihi-- ) {
482  fhi += h->GetBinContent(ihi);
483  if ( (fhi*icont)>0.0005 ) break;
484  }
485 
486 #endif
487 
488  int delta_lo = ilo-1;
489  int delta_hi = h->GetNbinsX()-ihi;
490 
491  if ( symmetric ) {
492  if ( delta_hi<delta_lo ) {
493  limits[0] = 1+delta_hi;
494  limits[1] = ihi;
495  }
496  else {
497  limits[0] = 1+delta_lo;
498  limits[1] = h->GetNbinsX()-delta_lo;
499  }
500  }
501  else {
502 
503  if ( ilo>1 ) ilo--;
504  if ( ihi<h->GetNbinsX() ) ihi++;
505 
506  limits[0] = ilo;
507  limits[1] = ihi;
508  }
509 
510  return limits;
511 
512 }
513 
514 
515 
516 void xrange(TH1* h, bool symmetric ) {
517  std::vector<int> limits = findxrange( h, symmetric );
518  h->GetXaxis()->SetRange( limits[0], limits[1] );
519 }
520 
521 
522 
523 
524 std::vector<double> findxrangeuser(TH1* h, bool symmetric ) {
525 
526  std::vector<int> limits = findxrange( h, symmetric );
527 
528  std::vector<double> dlimits(2,0);
529 
530  double dx = h->GetBinLowEdge(limits[1]+1)-h->GetBinLowEdge(limits[1]);
531 
532  dlimits[0] = h->GetBinLowEdge(limits[0]);
533  dlimits[1] = h->GetBinLowEdge(limits[1]+1)-dx*1e-11;
534 
535  return dlimits;
536 }
537 
538 
539 void xrangeuser(TH1* h, bool symmetric ) {
540  std::vector<double> limits = findxrangeuser( h, symmetric );
541  h->GetXaxis()->SetRangeUser( limits[0], limits[1] );
542 }
543 
544 
545 
546 std::string findcell( std::string name, const std::string& regex, const std::string& splitex ) {
547 
548  size_t posex = name.find( regex );
549 
550  if ( posex==std::string::npos ) return "";
551 
552  size_t pos = name.find_last_of( splitex );
553 
554  std::string duff = name;
555 
556  while ( pos!=std::string::npos && pos>posex+regex.size() ) {
557  name.resize(pos); //pos must be <=string length
558  pos = name.find_last_of( splitex );
559  }
560 
561  pos = name.find( regex );
562 
563  name = name.substr( pos, name.size() );
564 
565  pos = name.find( splitex );
566 
567  if ( pos!=std::string::npos ) return name.substr( 0, pos );
568 
569  return name;
570 }
571 
572 
573 
574 std::string findrun( TFile* f ) {
575 
576  TDirectory* here = gDirectory;
577 
578  f->cd();
579 
580  std::cout << "gDirectory::GetName() " << gDirectory->GetName() << std::endl;
581 
582  // gDirectory->pwd();
583 
584  // gDirectory->ls();
585 
586  TList* tl = gDirectory->GetListOfKeys();
587 
589 
590  for ( int i=0 ; i<tl->GetSize() ; i++ ) {
591 
592  TKey* tobj = (TKey*)tl->At(i);
593 
594  if ( tobj==0 ) continue;
595 
596  if ( std::string(tobj->GetClassName()).find("TDirectory")!=std::string::npos ) {
597 
598  TDirectory* tnd = (TDirectory*)tobj->ReadObj();
599 
600  std::string name = tnd->GetName();
601 
602  if ( name.find( "run_" )==0 ) {
603  here->cd();
604  return name;
605  }
606  }
607  }
608 
609  here->cd();
610 
611  return "";
612 }
613 
614 
615 
616 
618 
619 void copyReleaseInfo( TFile* finput, TFile* foutdir ) {
620 
621  std::vector<std::string> release_data;
622 
623  if ( finput && foutdir ) {
624 
625  TTree* tree = (TTree*)finput->Get("dataTree");
626  TTree* clone = tree->CloneTree();
627 
628  foutdir->cd();
629  clone->Write("", TObject::kOverwrite);
630 
631  delete clone;
632 
633  }
634 
635 }
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xrange
void xrange(TH1 *h, bool symmetric)
Definition: computils.cxx:516
fcontains
bool fcontains(const std::string &s, const std::string &p)
contains a string at the beginning of the string
Definition: computils.cxx:233
color
Definition: jFexInputByteStreamTool.cxx:25
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Norm
void Norm(TH1 *h, double scale)
Definition: computils.cxx:66
yt
#define yt
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:128
findrun
std::string findrun(TFile *f)
Definition: computils.cxx:574
Entries
double Entries(TH1 *h)
Definition: computils.cxx:51
integral
double integral(TH1 *h)
Definition: computils.cxx:58
realmax
double realmax(TH1 *h, bool include_error, double lo, double hi)
Definition: computils.cxx:380
floaty_t::raw_mantissa
int32_t raw_mantissa() const
float has 23 bit mentissa
Definition: computils.cxx:116
floaty_t::negative
bool negative() const
portable extraction of components sign
Definition: computils.cxx:113
tail
std::string tail(std::string s, const std::string &pattern)
tail of a string
Definition: computils.cxx:301
patterns
std::vector< std::string > patterns
Definition: listroot.cxx:187
tree
TChain * tree
Definition: tile_monitor.h:30
floaty_t::f
float f
Definition: computils.cxx:121
realmin
double realmin(TH1 *h, bool, double lo, double hi)
Definition: computils.cxx:407
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
stime
std::string stime()
return the current data and time
Definition: computils.cxx:214
data_mismatch
Definition: computils.h:99
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
x
#define x
empty
bool empty(TH1 *h)
Definition: computils.cxx:295
xrangeuser
void xrangeuser(TH1 *h, bool symmetric)
Definition: computils.cxx:539
ATLASFORAPP_LABEL
void ATLASFORAPP_LABEL(double x, double y, int color, double size)
Definition: computils.cxx:187
hmean
double hmean(TH1 *h)
Definition: computils.cxx:434
python.Utilities.clone
clone
Definition: Utilities.py:134
colours
int colours[6]
Definition: computils.cxx:45
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
LINEF
bool LINEF
Definition: computils.cxx:39
grepfile.content
string content
Definition: grepfile.py:56
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
xt
#define xt
contains
bool contains(const std::string &s, const std::string &p)
contains a string
Definition: computils.cxx:222
myText
void myText(Double_t x, Double_t y, Color_t color, const std::string &text, Double_t tsize)
Definition: computils.cxx:204
WritePulseShapeToCool.xhi
xhi
Definition: WritePulseShapeToCool.py:152
DeMoScan.directory
string directory
Definition: DeMoScan.py:80
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:731
floaty_t::floaty_t
floaty_t(float n=0.0f)
Definition: computils.cxx:109
true_mean::true_mean
true_mean(TH1F *h)
Definition: computils.cxx:81
markers
int markers[6]
Definition: computils.cxx:46
add-xsec-uncert-quadrature-N.label
label
Definition: add-xsec-uncert-quadrature-N.py:104
hist_file_dump.f
f
Definition: hist_file_dump.py:135
WritePulseShapeToCool.xlo
xlo
Definition: WritePulseShapeToCool.py:133
contents
void contents(std::vector< std::string > &keys, TDirectory *td, const std::string &directory, const std::string &pattern, const std::string &path)
Definition: computils.cxx:320
WritePulseShapeToCool.ylo
ylo
Definition: WritePulseShapeToCool.py:134
beamspotman.stat
stat
Definition: beamspotman.py:266
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:25
head
std::string head(std::string s, const std::string &pattern)
head of a string
Definition: computils.cxx:311
findxrangeuser
std::vector< double > findxrangeuser(TH1 *h, bool symmetric)
Definition: computils.cxx:524
keylayer_zslicemap.sb
sb
Definition: keylayer_zslicemap.py:192
globbed
std::string globbed(const std::string &s)
match a file name
Definition: computils.cxx:263
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
label.h
true_mean::m_mean
double m_mean
Definition: computils.h:140
findxrange
std::vector< int > findxrange(TH1 *h, bool symmetric)
automatically set the xrange on a histogram
Definition: computils.cxx:447
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
python.ElectronD3PDObject.matched
matched
Definition: ElectronD3PDObject.py:138
true_mean::m_error
double m_error
Definition: computils.h:141
copyReleaseInfo
void copyReleaseInfo(TFile *finput, TFile *foutdir)
copy the release info TTree
Definition: computils.cxx:619
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
PlotCalibFromCool.lat
lat
Definition: PlotCalibFromCool.py:867
trim_tgraph
void trim_tgraph(TH1 *h, TGraphAsymmErrors *t)
Definition: computils.cxx:152
findcell
std::string findcell(std::string name, const std::string &regex, const std::string &splitex)
Definition: computils.cxx:546
floaty_t::i
int32_t i
Definition: computils.cxx:120
a
TList * a
Definition: liststreamerinfos.cxx:10
plotable
double plotable(TH1 *h)
Definition: computils.cxx:238
y
#define y
h
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
DeMoScan.first
bool first
Definition: DeMoScan.py:536
re
const boost::regex re(r_e)
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
operator==
bool operator==(floaty_t a, floaty_t b)
Definition: computils.cxx:146
makeTransCanvas.text
text
Definition: makeTransCanvas.py:11
dq_defect_create_virtual_defects.dname
dname
Definition: dq_defect_create_virtual_defects.py:71
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
DrawLabel.h
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
atlasStyleMacro.tsize
float tsize
Definition: atlasStyleMacro.py:37
LINES
bool LINES
Definition: computils.cxx:40
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
almost_equal
bool almost_equal(floaty_t a, floaty_t b, int max_diff)
Definition: computils.cxx:125
computils.h
python.compressB64.c
def c
Definition: compressB64.py:93
floaty_t
Definition: computils.cxx:108
Plots::s_watermark
static bool s_watermark
Definition: computils.h:1247
msizes
double msizes[6]
Definition: computils.cxx:47
floaty_t::raw_exponent
int32_t raw_exponent() const
and an 8 bit exponent
Definition: computils.cxx:118
exists
bool exists(const std::string &filename)
does a file exist
Definition: computils.cxx:255