Logo ROOT  
Reference Guide
TAxis.cxx
Go to the documentation of this file.
1 // @(#)root/hist:$Id$
2 // Author: Rene Brun 12/12/94
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include "TAxis.h"
13 #include "TVirtualPad.h"
14 #include "TStyle.h"
15 #include "TError.h"
16 #include "THashList.h"
17 #include "TList.h"
18 #include "TAxisModLab.h"
19 #include "TH1.h"
20 #include "TObjString.h"
21 #include "TDatime.h"
22 #include "TTimeStamp.h"
23 #include "TBuffer.h"
24 #include "TMath.h"
25 #include "strlcpy.h"
26 #include "snprintf.h"
27 
28 #include <iostream>
29 #include <ctime>
30 #include <cassert>
31 
33 
34 ////////////////////////////////////////////////////////////////////////////////
35 /** \class TAxis
36  \ingroup Hist
37  \brief Class to manage histogram axis
38 
39 This class manages histogram axis. It is referenced by TH1 and TGraph.
40 To make a graphical representation of an histogram axis, this class
41 references the TGaxis class. TAxis supports axis with fixed or variable bin sizes.
42 Labels may be associated to individual bins.
43 See examples of various axis representations drawn by class TGaxis.
44 *///////////////////////////////////////////////////////////////////////////////
45 
46 ////////////////////////////////////////////////////////////////////////////////
47 /// Default constructor.
48 
50 {
51  fNbins = 1;
52  fXmin = 0;
53  fXmax = 1;
54  fFirst = 0;
55  fLast = 0;
56  fParent = 0;
57  fLabels = 0;
58  fModLabs = 0;
59  fBits2 = 0;
60  fTimeDisplay = 0;
61 }
62 
63 ////////////////////////////////////////////////////////////////////////////////
64 /// Axis constructor for axis with fix bin size
65 
67 {
68  fParent = 0;
69  fLabels = 0;
70  fModLabs = 0;
71  Set(nbins,xlow,xup);
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Axis constructor for variable bin size
76 
77 TAxis::TAxis(Int_t nbins,const Double_t *xbins): TNamed(), TAttAxis()
78 {
79  fParent = 0;
80  fLabels = 0;
81  fModLabs = 0;
82  Set(nbins,xbins);
83 }
84 
85 ////////////////////////////////////////////////////////////////////////////////
86 /// Destructor.
87 
89 {
90  if (fLabels) {
91  fLabels->Delete();
92  delete fLabels;
93  fLabels = 0;
94  }
95  if (fModLabs) {
96  fModLabs->Delete();
97  delete fModLabs;
98  fModLabs = 0;
99  }
100 }
101 
102 ////////////////////////////////////////////////////////////////////////////////
103 /// Copy constructor.
104 
105 TAxis::TAxis(const TAxis &axis) : TNamed(axis), TAttAxis(axis), fLabels(0), fModLabs(0)
106 {
107  axis.Copy(*this);
108 }
109 
110 ////////////////////////////////////////////////////////////////////////////////
111 /// Assignment operator.
112 
114 {
115  orig.Copy( *this );
116  return *this;
117 }
118 
119 
120 ////////////////////////////////////////////////////////////////////////////////
121 /// Choose a reasonable time format from the coordinates in the active pad
122 /// and the number of divisions in this axis
123 /// If orientation = "X", the horizontal axis of the pad will be used for ref.
124 /// If orientation = "Y", the vertical axis of the pad will be used for ref.
125 
126 const char *TAxis::ChooseTimeFormat(Double_t axislength)
127 {
128  const char *formatstr = nullptr;
129  Int_t reasformat = 0;
130  Int_t ndiv,nx1,nx2,n;
131  Double_t awidth;
132  Double_t length;
133 
134  if (!axislength) {
135  length = gPad->GetUxmax() - gPad->GetUxmin();
136  } else {
137  length = axislength;
138  }
139 
140  ndiv = GetNdivisions();
141  if (ndiv > 1000) {
142  nx2 = ndiv/100;
143  nx1 = TMath::Max(1, ndiv%100);
144  ndiv = 100*nx2 + Int_t(Double_t(nx1)*gPad->GetAbsWNDC());
145  }
146  ndiv = TMath::Abs(ndiv);
147  n = ndiv - (ndiv/100)*100;
148  awidth = length/n;
149 
150 // width in seconds ?
151  if (awidth>=.5) {
152  reasformat = 1;
153 // width in minutes ?
154  if (awidth>=30) {
155  awidth /= 60; reasformat = 2;
156 // width in hours ?
157  if (awidth>=30) {
158  awidth /=60; reasformat = 3;
159 // width in days ?
160  if (awidth>=12) {
161  awidth /= 24; reasformat = 4;
162 // width in months ?
163  if (awidth>=15.218425) {
164  awidth /= 30.43685; reasformat = 5;
165 // width in years ?
166  if (awidth>=6) {
167  awidth /= 12; reasformat = 6;
168  if (awidth>=2) {
169  awidth /= 12; reasformat = 7;
170  }
171  }
172  }
173  }
174  }
175  }
176  }
177 // set reasonable format
178  switch (reasformat) {
179  case 0:
180  formatstr = "%S";
181  break;
182  case 1:
183  formatstr = "%Mm%S";
184  break;
185  case 2:
186  formatstr = "%Hh%M";
187  break;
188  case 3:
189  formatstr = "%d-%Hh";
190  break;
191  case 4:
192  formatstr = "%d/%m";
193  break;
194  case 5:
195  formatstr = "%d/%m/%y";
196  break;
197  case 6:
198  formatstr = "%d/%m/%y";
199  break;
200  case 7:
201  formatstr = "%m/%y";
202  break;
203  }
204  return formatstr;
205 }
206 
207 ////////////////////////////////////////////////////////////////////////////////
208 /// Copy axis structure to another axis
209 
210 void TAxis::Copy(TObject &obj) const
211 {
212  TNamed::Copy(obj);
213  TAttAxis::Copy(((TAxis&)obj));
214  TAxis &axis( ((TAxis&)obj) );
215  axis.fNbins = fNbins;
216  axis.fXmin = fXmin;
217  axis.fXmax = fXmax;
218  axis.fFirst = fFirst;
219  axis.fLast = fLast;
220  axis.fBits2 = fBits2;
221  fXbins.Copy(axis.fXbins);
222  axis.fTimeFormat = fTimeFormat;
223  axis.fTimeDisplay = fTimeDisplay;
224  axis.fParent = fParent;
225  if (axis.fLabels) {
226  axis.fLabels->Delete();
227  delete axis.fLabels;
228  axis.fLabels = 0;
229  }
230  if (fLabels) {
231  //Properly handle case where not all bins have labels
232  TIter next(fLabels);
233  TObjString *label;
234  if(! axis.fLabels) {
235  axis.fLabels = new THashList(axis.fNbins, 3);
236  }
237  while( (label=(TObjString*)next()) ) {
238  TObjString *copyLabel = new TObjString(*label);
239  axis.fLabels->Add(copyLabel);
240  copyLabel->SetUniqueID(label->GetUniqueID());
241  }
242  }
243  if (axis.fModLabs) {
244  axis.fModLabs->Delete();
245  delete axis.fModLabs;
246  axis.fModLabs = 0;
247  }
248  if (fModLabs) {
249  TIter next(fModLabs);
250  TAxisModLab *modlabel;
251  if(! axis.fModLabs) {
252  axis.fModLabs = new TList();
253  }
254  while( (modlabel=(TAxisModLab*)next()) ) {
255  TAxisModLab *copyModLabel = new TAxisModLab(*modlabel);
256  axis.fModLabs->Add(copyModLabel);
257  copyModLabel->SetUniqueID(modlabel->GetUniqueID());
258  }
259  }
260 }
261 
262 ////////////////////////////////////////////////////////////////////////////////
263 /// Compute distance from point px,py to an axis
264 
266 {
267  return 9999;
268 }
269 
270 ////////////////////////////////////////////////////////////////////////////////
271 /// Execute action corresponding to one event
272 ///
273 /// This member function is called when an axis is clicked with the locator.
274 /// The axis range is set between the position where the mouse is pressed
275 /// and the position where it is released.
276 /// If the mouse position is outside the current axis range when it is released
277 /// the axis is unzoomed with the corresponding proportions.
278 /// Note that the mouse does not need to be in the pad or even canvas
279 /// when it is released.
280 
282 {
283  if (!gPad) return;
284  gPad->ExecuteEventAxis(event,px,py,this);
285 }
286 
287 ////////////////////////////////////////////////////////////////////////////////
288 /// Find bin number corresponding to abscissa x. NOTE: this method does not work with alphanumeric bins !!!
289 ///
290 /// If x is underflow or overflow, attempt to extend the axis if TAxis::kCanExtend is true.
291 /// Otherwise, return 0 or fNbins+1.
292 
294 {
295  Int_t bin;
296  // NOTE: This should not be allowed for Alphanumeric histograms,
297  // but it is heavily used (legacy) in the TTreePlayer to fill alphanumeric histograms.
298  // but in case of alphanumeric do-not extend the axis. It makes no sense
299  if (IsAlphanumeric() && gDebug) Info("FindBin","Numeric query on alphanumeric axis - Sorting the bins or extending the axes / rebinning can alter the correspondence between the label and the bin interval.");
300  if (x < fXmin) { //*-* underflow
301  bin = 0;
302  if (fParent == 0) return bin;
303  if (!CanExtend() || IsAlphanumeric() ) return bin;
304  ((TH1*)fParent)->ExtendAxis(x,this);
305  return FindFixBin(x);
306  } else if ( !(x < fXmax)) { //*-* overflow (note the way to catch NaN)
307  bin = fNbins+1;
308  if (fParent == 0) return bin;
309  if (!CanExtend() || IsAlphanumeric() ) return bin;
310  ((TH1*)fParent)->ExtendAxis(x,this);
311  return FindFixBin(x);
312  } else {
313  if (!fXbins.fN) { //*-* fix bins
314  bin = 1 + int (fNbins*(x-fXmin)/(fXmax-fXmin) );
315  } else { //*-* variable bin sizes
316  //for (bin =1; x >= fXbins.fArray[bin]; bin++);
318  }
319  }
320  return bin;
321 }
322 
323 ////////////////////////////////////////////////////////////////////////////////
324 /// Find bin number with label.
325 /// If the List of labels does not exist create it and make the axis alphanumeric
326 /// If one wants just to add a single label- just call TAxis::SetBinLabel
327 /// If label is not in the list of labels do the following depending on the
328 /// bit TAxis::kCanExtend; of the axis.
329 /// - if the bit is set add the new label and if the number of labels exceeds
330 /// the number of bins, double the number of bins via TH1::LabelsInflate
331 /// - if the bit is not set and the histogram has labels in each bin
332 /// set the bit automatically and consider the histogram as alphanumeric
333 /// if histogram has only some bins with labels then the histogram is not
334 /// consider alphanumeric and return -1
335 ///
336 /// -1 is returned only when the Axis has no parent histogram
337 
338 Int_t TAxis::FindBin(const char *label)
339 {
340  //create list of labels if it does not exist yet
341  if (!fLabels) {
342  if (!fParent) return -1;
343  fLabels = new THashList(fNbins,3);
344  // we set the axis alphanumeric
345  // when list of labels does not exist
346  // do we want to do this also when histogram is not empty ?????
347  if (CanBeAlphanumeric() ) {
350  if (fXmax <= fXmin) {
351  //L.M. Dec 2010 in case of no min and max specified use 0 ->NBINS
352  fXmin = 0;
353  fXmax = fNbins;
354  }
355  }
356  }
357 
358  // search for label in the existing list and return it if it exists
359  TObjString *obj = (TObjString*)fLabels->FindObject(label);
360  if (obj) return (Int_t)obj->GetUniqueID();
361 
362  // if labels is not in the list and we have already labels
363  if (!IsAlphanumeric()) {
364  // if bins without labels exist or if the axis cannot be set to alphanumeric
365  if (HasBinWithoutLabel() || !CanBeAlphanumeric() ) {
366  Info("FindBin","Label %s is not in the list and the axis is not alphanumeric - ignore it",label);
367  return -1;
368  }
369  else {
370  Info("FindBin","Label %s not in the list. It will be added to the histogram",label);
373  }
374  }
375 
376  //Not yet in the list. Can we extend the axis ?
377  assert ( CanExtend() && IsAlphanumeric() );
378  // {
379  // if (gDebug>0)
380  // Info("FindBin","Label %s is not in the list and the axis cannot be extended - the entry will be added in the underflow bin",label);
381  // return 0;
382  // }
383 
384  Int_t n = fLabels->GetEntries();
385 
386  //may be we have to resize the histogram (doubling number of channels)
387  if (n >= fNbins) ((TH1*)fParent)->LabelsInflate(GetName());
388 
389  //add new label to the list: assign bin number
390  obj = new TObjString(label);
391  fLabels->Add(obj);
392  obj->SetUniqueID(n+1);
393  return n+1;
394 }
395 
396 ////////////////////////////////////////////////////////////////////////////////
397 /// Find bin number with label.
398 /// If the List of labels does not exist or the label does not exist just return -1 .
399 /// Do not attempt to modify the axis. This is different than FindBin
400 
401 Int_t TAxis::FindFixBin(const char *label) const
402 {
403  //create list of labels if it does not exist yet
404  if (!fLabels) return -1;
405 
406  // search for label in the existing list and return it if it exists
407  TObjString *obj = (TObjString*)fLabels->FindObject(label);
408  if (obj) return (Int_t)obj->GetUniqueID();
409  return -1;
410 }
411 
412 
413 ////////////////////////////////////////////////////////////////////////////////
414 /// Find bin number corresponding to abscissa x
415 ///
416 /// Identical to TAxis::FindBin except that if x is an underflow/overflow
417 /// no attempt is made to extend the axis.
418 
420 {
421  Int_t bin;
422  if (x < fXmin) { //*-* underflow
423  bin = 0;
424  } else if ( !(x < fXmax)) { //*-* overflow (note the way to catch NaN
425  bin = fNbins+1;
426  } else {
427  if (!fXbins.fN) { //*-* fix bins
428  bin = 1 + int (fNbins*(x-fXmin)/(fXmax-fXmin) );
429  } else { //*-* variable bin sizes
430 // for (bin =1; x >= fXbins.fArray[bin]; bin++);
432  }
433  }
434  return bin;
435 }
436 
437 ////////////////////////////////////////////////////////////////////////////////
438 /// Return label for bin
439 
440 const char *TAxis::GetBinLabel(Int_t bin) const
441 {
442  if (!fLabels) return "";
443  if (bin <= 0 || bin > fNbins) return "";
444  TIter next(fLabels);
445  TObjString *obj;
446  while ((obj=(TObjString*)next())) {
447  Int_t binid = (Int_t)obj->GetUniqueID();
448  if (binid == bin) return obj->GetName();
449  }
450  return "";
451 }
452 
453 ////////////////////////////////////////////////////////////////////////////////
454 /// Return first bin on the axis
455 /// i.e. 1 if no range defined
456 /// NOTE: in some cases a zero is returned (see TAxis::SetRange)
457 
459 {
460  if (!TestBit(kAxisRange)) return 1;
461  return fFirst;
462 }
463 
464 ////////////////////////////////////////////////////////////////////////////////
465 /// Return last bin on the axis
466 /// i.e. fNbins if no range defined
467 /// NOTE: in some cases a zero is returned (see TAxis::SetRange)
468 
470 {
471  if (!TestBit(kAxisRange)) return fNbins;
472  return fLast;
473 }
474 
475 ////////////////////////////////////////////////////////////////////////////////
476 /// Return center of bin
477 
479 {
480  Double_t binwidth;
481  if (!fXbins.fN || bin<1 || bin>fNbins) {
482  binwidth = (fXmax - fXmin) / Double_t(fNbins);
483  return fXmin + (bin-1) * binwidth + 0.5*binwidth;
484  } else {
485  binwidth = fXbins.fArray[bin] - fXbins.fArray[bin-1];
486  return fXbins.fArray[bin-1] + 0.5*binwidth;
487  }
488 }
489 
490 ////////////////////////////////////////////////////////////////////////////////
491 /// Return center of bin in log
492 /// With a log-equidistant binning for a bin with low and up edges, the mean is :
493 /// 0.5*(ln low + ln up) i.e. sqrt(low*up) in logx (e.g. sqrt(10^0*10^2) = 10).
494 /// Imagine a bin with low=1 and up=100 :
495 /// - the center in lin is (100-1)/2=50.5
496 /// - the center in log would be sqrt(1*100)=10 (!=log(50.5))
497 ///
498 /// NB: if the low edge of the bin is negative, the function returns the bin center
499 /// as computed by TAxis::GetBinCenter
500 
502 {
503  Double_t low,up;
504  if (!fXbins.fN || bin<1 || bin>fNbins) {
505  Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
506  low = fXmin + (bin-1) * binwidth;
507  up = low+binwidth;
508  } else {
509  low = fXbins.fArray[bin-1];
510  up = fXbins.fArray[bin];
511  }
512  if (low <=0 ) return GetBinCenter(bin);
513  return TMath::Sqrt(low*up);
514 }
515 ////////////////////////////////////////////////////////////////////////////////
516 /// Return low edge of bin
517 
519 {
520  if (fXbins.fN && bin > 0 && bin <=fNbins) return fXbins.fArray[bin-1];
521  Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
522  return fXmin + (bin-1) * binwidth;
523 }
524 
525 ////////////////////////////////////////////////////////////////////////////////
526 /// Return up edge of bin
527 
529 {
530  if (!fXbins.fN || bin < 1 || bin>fNbins) {
531  Double_t binwidth = (fXmax - fXmin) / Double_t(fNbins);
532  return fXmin + bin*binwidth;
533  }
534  return fXbins.fArray[bin];
535 }
536 
537 ////////////////////////////////////////////////////////////////////////////////
538 /// Return bin width
539 
541 {
542  if (fNbins <= 0) return 0;
543  if (fXbins.fN <= 0) return (fXmax - fXmin) / Double_t(fNbins);
544  if (bin >fNbins) bin = fNbins;
545  if (bin <1 ) bin = 1;
546  return fXbins.fArray[bin] - fXbins.fArray[bin-1];
547 }
548 
549 
550 ////////////////////////////////////////////////////////////////////////////////
551 /// Return an array with the center of all bins
552 
553 void TAxis::GetCenter(Double_t *center) const
554 {
555  Int_t bin;
556  for (bin=1; bin<=fNbins; bin++) *(center + bin-1) = GetBinCenter(bin);
557 }
558 
559 ////////////////////////////////////////////////////////////////////////////////
560 /// Return an array with the low edge of all bins
561 
562 void TAxis::GetLowEdge(Double_t *edge) const
563 {
564  Int_t bin;
565  for (bin=1; bin<=fNbins; bin++) *(edge + bin-1) = GetBinLowEdge(bin);
566 }
567 
568 ////////////////////////////////////////////////////////////////////////////////
569 /// Return *only* the time format from the string fTimeFormat
570 
571 const char *TAxis::GetTimeFormatOnly() const
572 {
573  static TString timeformat;
574  Int_t idF = fTimeFormat.Index("%F");
575  if (idF>=0) {
576  timeformat = fTimeFormat(0,idF);
577  } else {
578  timeformat = fTimeFormat;
579  }
580  return timeformat.Data();
581 }
582 
583 ////////////////////////////////////////////////////////////////////////////////
584 /// Return the ticks option (see SetTicks)
585 
586 const char *TAxis::GetTicks() const
587 {
588  if (TestBit(kTickPlus) && TestBit(kTickMinus)) return "+-";
589  if (TestBit(kTickMinus)) return "-";
590  return "+";
591 }
592 
593 ////////////////////////////////////////////////////////////////////////////////
594 /// this helper function checks if there is a bin without a label
595 /// if all bins have labels, the axis can / will become alphanumeric
596 
598 {
599  return fLabels->GetSize() != fNbins;
600 }
601 
602 ////////////////////////////////////////////////////////////////////////////////
603 /// Set option(s) to draw axis with labels
604 /// option can be:
605 /// - "a" sort by alphabetic order
606 /// - ">" sort by decreasing values
607 /// - "<" sort by increasing values
608 /// - "h" draw labels horizontal
609 /// - "v" draw labels vertical
610 /// - "u" draw labels up (end of label right adjusted)
611 /// - "d" draw labels down (start of label left adjusted)
612 
614 {
615  if (!fLabels) {
616  Warning("Sort","Cannot sort. No labels");
617  return;
618  }
619  TH1 *h = (TH1*)GetParent();
620  if (!h) {
621  Error("Sort","Axis has no parent");
622  return;
623  }
624 
625  h->LabelsOption(option,GetName());
626 }
627 
628 ////////////////////////////////////////////////////////////////////////////////
629 /// Copy axis attributes to this
630 
632 {
633  SetTitle(axis->GetTitle());
634  SetNdivisions(axis->GetNdivisions());
635  SetAxisColor(axis->GetAxisColor());
636  SetLabelColor(axis->GetLabelColor());
637  SetLabelFont(axis->GetLabelFont());
639  SetLabelSize(axis->GetLabelSize());
640  SetTickLength(axis->GetTickLength());
642  SetTitleSize(axis->GetTitleSize());
643  SetTitleColor(axis->GetTitleColor());
644  SetTitleFont(axis->GetTitleFont());
653  SetTimeFormat(axis->GetTimeFormat());
654 }
655 
656 
657 
658 ////////////////////////////////////////////////////////////////////////////////
659 /// Save axis attributes as C++ statement(s) on output stream out
660 
661 void TAxis::SaveAttributes(std::ostream &out, const char *name, const char *subname)
662 {
663  char quote = '"';
664  if (strlen(GetTitle())) {
665  TString t(GetTitle());
666  t.ReplaceAll("\\","\\\\");
667  out<<" "<<name<<subname<<"->SetTitle("<<quote<<t.Data()<<quote<<");"<<std::endl;
668  }
669  if (fTimeDisplay) {
670  out<<" "<<name<<subname<<"->SetTimeDisplay(1);"<<std::endl;
671  out<<" "<<name<<subname<<"->SetTimeFormat("<<quote<<GetTimeFormat()<<quote<<");"<<std::endl;
672  }
673  if (fLabels) {
674  TIter next(fLabels);
675  TObjString *obj;
676  while ((obj=(TObjString*)next())) {
677  out<<" "<<name<<subname<<"->SetBinLabel("<<obj->GetUniqueID()<<","<<quote<<obj->GetName()<<quote<<");"<<std::endl;
678  }
679  }
680 
681  if (fFirst || fLast) {
682  out<<" "<<name<<subname<<"->SetRange("<<fFirst<<","<<fLast<<");"<<std::endl;
683  }
684 
685  if (TestBit(kLabelsHori)) {
686  out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsHori);"<<std::endl;
687  }
688 
689  if (TestBit(kLabelsVert)) {
690  out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsVert);"<<std::endl;
691  }
692 
693  if (TestBit(kLabelsDown)) {
694  out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsDown);"<<std::endl;
695  }
696 
697  if (TestBit(kLabelsUp)) {
698  out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsUp);"<<std::endl;
699  }
700 
701  if (TestBit(kCenterLabels)) {
702  out<<" "<<name<<subname<<"->CenterLabels(true);"<<std::endl;
703  }
704 
705  if (TestBit(kCenterTitle)) {
706  out<<" "<<name<<subname<<"->CenterTitle(true);"<<std::endl;
707  }
708 
709  if (TestBit(kRotateTitle)) {
710  out<<" "<<name<<subname<<"->RotateTitle(true);"<<std::endl;
711  }
712 
713  if (TestBit(kDecimals)) {
714  out<<" "<<name<<subname<<"->SetDecimals();"<<std::endl;
715  }
716 
717  if (TestBit(kMoreLogLabels)) {
718  out<<" "<<name<<subname<<"->SetMoreLogLabels();"<<std::endl;
719  }
720 
721  if (TestBit(kNoExponent)) {
722  out<<" "<<name<<subname<<"->SetNoExponent();"<<std::endl;
723  }
724 
725  TAttAxis::SaveAttributes(out,name,subname);
726 }
727 
728 ////////////////////////////////////////////////////////////////////////////////
729 /// Initialize axis with fix bins
730 
731 void TAxis::Set(Int_t nbins, Double_t xlow, Double_t xup)
732 {
733  fNbins = nbins;
734  fXmin = xlow;
735  fXmax = xup;
736  if (!fParent) SetDefaults();
737  if (fXbins.fN > 0) fXbins.Set(0);
738 }
739 
740 ////////////////////////////////////////////////////////////////////////////////
741 /// Initialize axis with variable bins
742 
743 void TAxis::Set(Int_t nbins, const Float_t *xbins)
744 {
745  Int_t bin;
746  fNbins = nbins;
747  fXbins.Set(fNbins+1);
748  for (bin=0; bin<= fNbins; bin++)
749  fXbins.fArray[bin] = xbins[bin];
750  for (bin=1; bin<= fNbins; bin++)
751  if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
752  Error("TAxis::Set", "bins must be in increasing order");
753  fXmin = fXbins.fArray[0];
755  if (!fParent) SetDefaults();
756 }
757 
758 ////////////////////////////////////////////////////////////////////////////////
759 /// Initialize axis with variable bins
760 
761 void TAxis::Set(Int_t nbins, const Double_t *xbins)
762 {
763  Int_t bin;
764  fNbins = nbins;
765  fXbins.Set(fNbins+1);
766  for (bin=0; bin<= fNbins; bin++)
767  fXbins.fArray[bin] = xbins[bin];
768  for (bin=1; bin<= fNbins; bin++)
769  if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
770  Error("TAxis::Set", "bins must be in increasing order");
771  fXmin = fXbins.fArray[0];
773  if (!fParent) SetDefaults();
774 }
775 
776 ////////////////////////////////////////////////////////////////////////////////
777 /// Set axis alphanumeric
778 
779 void TAxis::SetAlphanumeric(Bool_t alphanumeric)
780 {
781  if (alphanumeric) fBits2 |= kAlphanumeric;
782  else fBits2 &= ~kAlphanumeric;
783 
784  // clear underflow and overflow (in an alphanumeric situation they do not make sense)
785  // NOTE: using AddBinContent instead of SetBinContent in order to not change
786  // the number of entries
787  //((TH1 *)fParent)->ClearUnderflowAndOverflow();
788  // L.M. 26.1.15 Keep underflow and overflows (see ROOT-7034)
789  if (gDebug && fParent) {
790  TH1 * h = dynamic_cast<TH1*>( fParent);
791  if (!h) return;
792  double s[TH1::kNstat];
793  h->GetStats(s);
794  if (s[0] != 0. && gDebug > 0)
795  Info("SetAlphanumeric","Histogram %s is set alphanumeric but has non-zero content",GetName());
796  }
797 }
798 
799 
800 ////////////////////////////////////////////////////////////////////////////////
801 /// Set axis default values (from TStyle)
802 
804 {
805  fFirst = 0;
806  fLast = 0;
807  fBits2 = 0;
808  char name[2];
809  strlcpy(name,GetName(),2);
810  name[1] = 0;
812  fTimeDisplay = 0;
813  SetTimeFormat();
814 }
815 
816 ////////////////////////////////////////////////////////////////////////////////
817 /// Set label for bin.
818 /// If no label list exists, it is created. If all the bins have labels, the
819 /// axis becomes alphanumeric and extendable.
820 /// New labels will not be added with the Fill method but will end-up in the
821 /// underflow bin. See documentation of TAxis::FindBin(const char*)
822 
823 void TAxis::SetBinLabel(Int_t bin, const char *label)
824 {
825  if (!fLabels) fLabels = new THashList(fNbins,3);
826 
827  if (bin <= 0 || bin > fNbins) {
828  Error("SetBinLabel","Illegal bin number: %d",bin);
829  return;
830  }
831 
832  // Check whether this bin already has a label.
833  TIter next(fLabels);
834  TObjString *obj;
835  while ((obj=(TObjString*)next())) {
836  if ( obj->GetUniqueID()==(UInt_t)bin ) {
837  // It does. Overwrite it.
838  obj->SetString(label);
839  // LM need to rehash the labels list (see ROOT-5025)
841  return;
842  }
843  }
844  // It doesn't. Add this new label.
845  obj = new TObjString(label);
846  fLabels->Add(obj);
847  obj->SetUniqueID((UInt_t)bin);
848 
849  // check for Alphanumeric case (labels for each bin)
850  if (CanBeAlphanumeric() && fLabels->GetSize() == fNbins) {
853  }
854 }
855 
856 ////////////////////////////////////////////////////////////////////////////////
857 /// Define new text attributes for the label number "labNum". It allows to do a
858 /// fine tuning of the labels. All the attributes can be changed, even the
859 /// label text itself.
860 ///
861 /// \param[in] labNum Number of the label to be changed, negative numbers start from the end
862 /// \param[in] labAngle New angle value
863 /// \param[in] labSize New size (0 erase the label)
864 /// \param[in] labAlign New alignment value
865 /// \param[in] labColor New label color
866 /// \param[in] labFont New label font
867 /// \param[in] labText New label text
868 ///
869 /// If an attribute should not be changed just give the value "-1".
870 ///
871 /// If labnum=0 the list of modified labels is reset.
872 
873 void TAxis::ChangeLabel(Int_t labNum, Double_t labAngle, Double_t labSize,
874  Int_t labAlign, Int_t labColor, Int_t labFont,
875  TString labText)
876 {
877  if (!fModLabs) fModLabs = new TList();
878 
879  // Reset the list of modified labels.
880  if (labNum == 0) {
881  delete fModLabs;
882  fModLabs = 0;
883  return;
884  }
885 
886  TAxisModLab *ml = new TAxisModLab();
887  ml->SetLabNum(labNum);
888  ml->SetAngle(labAngle);
889  ml->SetSize(labSize);
890  ml->SetAlign(labAlign);
891  ml->SetColor(labColor);
892  ml->SetFont(labFont);
893  ml->SetText(labText);
894 
895  fModLabs->Add((TObject*)ml);
896 }
897 
898 
899 ////////////////////////////////////////////////////////////////////////////////
900 /// Set the viewing range for the axis using bin numbers.
901 ///
902 /// \param first First bin of the range.
903 /// \param last Last bin of the range.
904 /// To set a range using the axis coordinates, use TAxis::SetRangeUser.
905 ///
906 /// If `first == last == 0` or if `first > last` or if the range specified does
907 /// not intersect at all with the maximum available range `[0, fNbins + 1]`,
908 /// then the viewing range is reset by removing the bit TAxis::kAxisRange. In this
909 /// case, the functions TAxis::GetFirst() and TAxis::GetLast() will return 1
910 /// and fNbins.
911 ///
912 /// If the range specified partially intersects with `[0, fNbins + 1]`, then the
913 /// intersection range is accepted. For instance, if `first == -2` and `last == fNbins`,
914 /// the accepted range will be `[0, fNbins]` (`fFirst = 0` and `fLast = fNbins`).
915 ///
916 /// \note For historical reasons, SetRange(0,0) resets the range even though bin 0 is
917 /// technically reserved for the underflow; in order to set the range of the axis
918 /// so that it only includes the underflow, use `SetRange(-1,0)`.
919 
921 {
922 
923  Int_t nCells = fNbins + 1; // bins + overflow
924 
925  // special reset range cases
926  if (last < first || (first < 0 && last < 0) ||
927  (first > nCells && last > nCells) || (first == 0 && last == 0)
928  ) {
929  fFirst = 1;
930  fLast = fNbins;
931  SetBit(kAxisRange, 0);
932  } else {
933  fFirst = std::max(first, 0);
934  fLast = std::min(last, nCells);
935  SetBit(kAxisRange, 1);
936  }
937 
938 }
939 
940 
941 ////////////////////////////////////////////////////////////////////////////////
942 /// Set the viewing range for the axis from ufirst to ulast (in user coordinates,
943 /// that is, the "natural" axis coordinates).
944 /// To set a range using the axis bin numbers, use TAxis::SetRange.
945 
947 {
948  if (!strstr(GetName(),"xaxis")) {
949  TH1 *hobj = (TH1*)GetParent();
950  if (hobj &&
951  ((hobj->GetDimension() == 2 && strstr(GetName(),"zaxis"))
952  || (hobj->GetDimension() == 1 && strstr(GetName(),"yaxis")))) {
953  hobj->SetMinimum(ufirst);
954  hobj->SetMaximum(ulast);
955  return;
956  }
957  }
958  Int_t ifirst = FindFixBin(ufirst);
959  Int_t ilast = FindFixBin(ulast);
960  // fixes for numerical error and for https://savannah.cern.ch/bugs/index.php?99777
961  if (GetBinUpEdge(ifirst) <= ufirst ) ifirst += 1;
962  if (GetBinLowEdge(ilast) >= ulast ) ilast -= 1;
963  SetRange(ifirst, ilast);
964 }
965 
966 ////////////////////////////////////////////////////////////////////////////////
967 /// Set ticks orientation.
968 /// option = "+" ticks drawn on the "positive side" (default)
969 /// option = "-" ticks drawn on the "negative side"
970 /// option = "+-" ticks drawn on both sides
971 
973 {
976  if (strchr(option,'+')) SetBit(kTickPlus);
977  if (strchr(option,'-')) SetBit(kTickMinus);
978 }
979 
980 ////////////////////////////////////////////////////////////////////////////////
981 /// Change the format used for time plotting
982 ///
983 /// The format string for date and time use the same options as the one used
984 /// in the standard strftime C function, i.e. :
985 /// for date :
986 ///
987 /// %a abbreviated weekday name
988 /// %b abbreviated month name
989 /// %d day of the month (01-31)
990 /// %m month (01-12)
991 /// %y year without century
992 ///
993 /// for time :
994 ///
995 /// %H hour (24-hour clock)
996 /// %I hour (12-hour clock)
997 /// %p local equivalent of AM or PM
998 /// %M minute (00-59)
999 /// %S seconds (00-61)
1000 /// %% %
1001 ///
1002 /// This function allows also to define the time offset. It is done via %F
1003 /// which should be appended at the end of the format string. The time
1004 /// offset has the following format: 'yyyy-mm-dd hh:mm:ss'
1005 /// Example:
1006 ///
1007 /// h = new TH1F("Test","h",3000,0.,200000.);
1008 /// h->GetXaxis()->SetTimeDisplay(1);
1009 /// h->GetXaxis()->SetTimeFormat("%d\/%m\/%y%F2000-02-28 13:00:01");
1010 ///
1011 /// This defines the time format being "dd/mm/yy" and the time offset as the
1012 /// February 28th 2003 at 13:00:01
1013 ///
1014 /// If %F is not specified, the time offset used will be the one defined by:
1015 /// gStyle->SetTimeOffset. For example like that:
1016 ///
1017 /// TDatime da(2003,02,28,12,00,00);
1018 /// gStyle->SetTimeOffset(da.Convert());
1019 
1020 void TAxis::SetTimeFormat(const char *tformat)
1021 {
1022  TString timeformat = tformat;
1023 
1024  if (timeformat.Index("%F")>=0 || timeformat.IsNull()) {
1025  fTimeFormat = timeformat;
1026  return;
1027  }
1028 
1029  Int_t idF = fTimeFormat.Index("%F");
1030  if (idF>=0) {
1031  Int_t lnF = fTimeFormat.Length();
1032  TString stringtimeoffset = fTimeFormat(idF,lnF);
1033  fTimeFormat = tformat;
1034  fTimeFormat.Append(stringtimeoffset);
1035  } else {
1036  fTimeFormat = tformat;
1038  }
1039 }
1040 
1041 
1042 ////////////////////////////////////////////////////////////////////////////////
1043 /// Change the time offset
1044 /// If option = "gmt", set display mode to GMT.
1045 
1047 {
1048  TString opt = option;
1049  opt.ToLower();
1050 
1051  char tmp[20];
1052  time_t timeoff;
1053  struct tm* utctis;
1054  Int_t idF = fTimeFormat.Index("%F");
1055  if (idF>=0) fTimeFormat.Remove(idF);
1056  fTimeFormat.Append("%F");
1057 
1058  timeoff = (time_t)((Long_t)(toffset));
1059  // offset is always saved in GMT to allow file transport
1060  // to different time zones
1061  utctis = gmtime(&timeoff);
1062 
1063  strftime(tmp,20,"%Y-%m-%d %H:%M:%S",utctis);
1064  fTimeFormat.Append(tmp);
1065 
1066  // append the decimal part of the time offset
1067  Double_t ds = toffset-(Int_t)toffset;
1068  snprintf(tmp,20,"s%g",ds);
1069  fTimeFormat.Append(tmp);
1070 
1071  // add GMT/local option
1072  if (opt.Contains("gmt")) fTimeFormat.Append(" GMT");
1073 }
1074 
1075 
1076 ////////////////////////////////////////////////////////////////////////////////
1077 /// Stream an object of class TAxis.
1078 
1079 void TAxis::Streamer(TBuffer &R__b)
1080 {
1081  if (R__b.IsReading()) {
1082  UInt_t R__s, R__c;
1083  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1084  if (R__v > 5) {
1085  R__b.ReadClassBuffer(TAxis::Class(), this, R__v, R__s, R__c);
1086  return;
1087  }
1088  //====process old versions before automatic schema evolution
1089  TNamed::Streamer(R__b);
1090  TAttAxis::Streamer(R__b);
1091  R__b >> fNbins;
1092  if (R__v < 5) {
1093  Float_t xmin,xmax;
1094  R__b >> xmin; fXmin = xmin;
1095  R__b >> xmax; fXmax = xmax;
1096  Float_t *xbins = 0;
1097  Int_t n = R__b.ReadArray(xbins);
1098  fXbins.Set(n);
1099  for (Int_t i=0;i<n;i++) fXbins.fArray[i] = xbins[i];
1100  delete [] xbins;
1101  } else {
1102  R__b >> fXmin;
1103  R__b >> fXmax;
1104  fXbins.Streamer(R__b);
1105  }
1106  if (R__v > 2) {
1107  R__b >> fFirst;
1108  R__b >> fLast;
1109  // following lines required to repair for a bug in Root version 1.03
1110  if (fFirst < 0 || fFirst > fNbins) fFirst = 0;
1111  if (fLast < 0 || fLast > fNbins) fLast = 0;
1112  if (fLast < fFirst) { fFirst = 0; fLast = 0;}
1113  if (fFirst ==0 && fLast == 0) SetBit(kAxisRange,0);
1114  }
1115  if (R__v > 3) {
1116  R__b >> fTimeDisplay;
1117  fTimeFormat.Streamer(R__b);
1118  } else {
1119  SetTimeFormat();
1120  }
1121  R__b.CheckByteCount(R__s, R__c, TAxis::IsA());
1122  //====end of old versions
1123 
1124  } else {
1125  R__b.WriteClassBuffer(TAxis::Class(),this);
1126  }
1127 }
1128 
1129 ////////////////////////////////////////////////////////////////////////////////
1130 /// Reset first & last bin to the full range
1131 
1133 {
1134  if (!gPad) return;
1135  gPad->SetView();
1136 
1137  //unzoom object owning this axis
1138  SetRange(0,0);
1139  TH1 *hobj1 = (TH1*)GetParent();
1140  if (!strstr(GetName(),"xaxis")) {
1141  if (!hobj1) return;
1142  if (hobj1->GetDimension() == 2) {
1143  if (strstr(GetName(),"zaxis")) {
1144  hobj1->SetMinimum();
1145  hobj1->SetMaximum();
1146  hobj1->ResetBit(TH1::kIsZoomed);
1147  }
1148  return;
1149  }
1150  if (strcmp(hobj1->GetName(),"hframe") == 0 ) {
1151  hobj1->SetMinimum(fXmin);
1152  hobj1->SetMaximum(fXmax);
1153  } else {
1154  if (fXmin==hobj1->GetMinimum() && fXmax==hobj1->GetMaximum()) {
1155  hobj1->SetMinimum(fXmin);
1156  hobj1->SetMaximum(fXmax);
1157  } else {
1158  hobj1->SetMinimum();
1159  hobj1->SetMaximum();
1160  }
1161  hobj1->ResetBit(TH1::kIsZoomed);
1162  }
1163  }
1164  //must unzoom all histograms in the pad
1165  TIter next(gPad->GetListOfPrimitives());
1166  TObject *obj;
1167  while ((obj= next())) {
1168  if (!obj->InheritsFrom(TH1::Class())) continue;
1169  TH1 *hobj = (TH1*)obj;
1170  if (hobj == hobj1) continue;
1171  if (!strstr(GetName(),"xaxis")) {
1172  if (hobj->GetDimension() == 2) {
1173  if (strstr(GetName(),"zaxis")) {
1174  hobj->SetMinimum();
1175  hobj->SetMaximum();
1176  hobj->ResetBit(TH1::kIsZoomed);
1177  } else {
1178  hobj->GetYaxis()->SetRange(0,0);
1179  }
1180  return;
1181  }
1182  if (strcmp(hobj->GetName(),"hframe") == 0 ) {
1183  hobj->SetMinimum(fXmin);
1184  hobj->SetMaximum(fXmax);
1185  } else {
1186  hobj->SetMinimum();
1187  hobj->SetMaximum();
1188  hobj->ResetBit(TH1::kIsZoomed);
1189  }
1190  } else {
1191  hobj->GetXaxis()->SetRange(0,0);
1192  }
1193  }
1194 
1195  gPad->UnZoomed();
1196 }
1197 
1198 ////////////////////////////////////////////////////////////////////////////////
1199 /// Zoom out by a factor of 'factor' (default =2)
1200 /// uses previous zoom factor by default
1201 /// Keep center defined by 'offset' fixed
1202 /// ie. -1 at left of current range, 0 in center, +1 at right
1203 
1204 void TAxis::ZoomOut(Double_t factor, Double_t offset)
1205 {
1206 
1207  if (factor <= 0) factor = 2;
1208  Double_t center = (GetFirst()*(1-offset) + GetLast()*(1+offset))/2.;
1209  Int_t first = int(TMath::Floor(center+(GetFirst()-center)*factor + 0.4999999));
1210  Int_t last = int(TMath::Floor(center+(GetLast() -center)*factor + 0.5000001));
1211  if (first==GetFirst() && last==GetLast()) { first--; last++; }
1212  SetRange(first,last);
1213 }
TAxis::GetBinLabel
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition: TAxis.cxx:440
TAxis::operator=
TAxis & operator=(const TAxis &)
Assignment operator.
Definition: TAxis.cxx:113
TAxis::kNoExponent
@ kNoExponent
Definition: TAxis.h:66
n
const Int_t n
Definition: legend1.C:16
TAttAxis::ResetAttAxis
virtual void ResetAttAxis(Option_t *option="")
Reset axis attributes.
Definition: TAttAxis.cxx:78
TAxis
Class to manage histogram axis.
Definition: TAxis.h:30
TAxis::fLabels
THashList * fLabels
Object owning this axis.
Definition: TAxis.h:43
first
Definition: first.py:1
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TAxis::SetTimeOffset
virtual void SetTimeOffset(Double_t toffset, Option_t *option="local")
Change the time offset If option = "gmt", set display mode to GMT.
Definition: TAxis.cxx:1046
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TAxis::GetBinLowEdge
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:518
Version_t
short Version_t
Definition: RtypesCore.h:65
snprintf
#define snprintf
Definition: civetweb.c:1540
TAxis::Set
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition: TAxis.cxx:731
TAxis::SaveAttributes
virtual void SaveAttributes(std::ostream &out, const char *name, const char *subname)
Save axis attributes as C++ statement(s) on output stream out.
Definition: TAxis.cxx:661
TAxis::fFirst
Int_t fFirst
Definition: TAxis.h:37
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
TAxisModLab::SetText
void SetText(TString t="")
Set modified label text.
Definition: TAxisModLab.cxx:82
TCollection::GetEntries
virtual Int_t GetEntries() const
Definition: TCollection.h:177
TH1::SetMinimum
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:396
TAxis::CanExtend
Bool_t CanExtend() const
Definition: TAxis.h:82
TTimeStamp.h
TList::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:469
TString::Data
const char * Data() const
Definition: TString.h:369
TAxis::TAxis
TAxis()
Default constructor.
Definition: TAxis.cxx:49
TAttAxis::SetAxisColor
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition: TAttAxis.cxx:162
TAttAxis::Copy
void Copy(TAttAxis &attaxis) const
Copy of the object.
Definition: TAttAxis.cxx:60
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TObjString.h
TAxis::SetRangeUser
virtual void SetRangeUser(Double_t ufirst, Double_t ulast)
Set the viewing range for the axis from ufirst to ulast (in user coordinates, that is,...
Definition: TAxis.cxx:946
TDatime.h
TBuffer::ReadClassBuffer
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
xmax
float xmax
Definition: THbookFile.cxx:95
TAxisModLab::SetFont
void SetFont(Int_t f=-1)
Set modified label font.
Definition: TAxisModLab.cxx:75
TAttAxis::SetLabelOffset
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels.
Definition: TAttAxis.cxx:192
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:864
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
TAttAxis::GetLabelSize
virtual Float_t GetLabelSize() const
Definition: TAttAxis.h:47
TAxis::GetFirst
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:458
TAxisModLab
Definition: TAxisModLab.h:21
Float_t
float Float_t
Definition: RtypesCore.h:57
TStyle.h
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:168
Int_t
int Int_t
Definition: RtypesCore.h:45
TAxis::GetBinCenter
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:478
TAxis::SetTimeFormat
virtual void SetTimeFormat(const char *format="")
Change the format used for time plotting.
Definition: TAxis.cxx:1020
TObject::GetUniqueID
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:377
TAxis::GetBinUpEdge
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:528
TAxis::fXmax
Double_t fXmax
Definition: TAxis.h:35
TAxis::fBits2
UShort_t fBits2
Definition: TAxis.h:39
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TAxis::kCenterTitle
@ kCenterTitle
Definition: TAxis.h:62
x
Double_t x[n]
Definition: legend1.C:17
TString::Length
Ssiz_t Length() const
Definition: TString.h:410
TAttAxis::GetAxisColor
virtual Color_t GetAxisColor() const
Definition: TAttAxis.h:43
TList.h
TObjString::SetString
void SetString(const char *s)
Definition: TObjString.h:51
TAxis::Copy
virtual void Copy(TObject &axis) const
Copy axis structure to another axis.
Definition: TAxis.cxx:210
TBuffer::ReadArray
virtual Int_t ReadArray(Bool_t *&b)=0
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TBuffer
Definition: TBuffer.h:43
TArray::fN
Int_t fN
Definition: TArray.h:38
TAxisModLab::SetAlign
void SetAlign(Int_t a=-1)
Set modified label alignment.
Definition: TAxisModLab.cxx:61
TBuffer::CheckByteCount
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
TString
Definition: TString.h:136
TAttAxis::GetLabelOffset
virtual Float_t GetLabelOffset() const
Definition: TAttAxis.h:46
TAxis::ImportAttributes
virtual void ImportAttributes(const TAxis *axis)
Copy axis attributes to this.
Definition: TAxis.cxx:631
TAxis::GetTicks
virtual const char * GetTicks() const
Return the ticks option (see SetTicks)
Definition: TAxis.cxx:586
TAxis::IsAlphanumeric
Bool_t IsAlphanumeric()
Definition: TAxis.h:84
TAxis::ExecuteEvent
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Definition: TAxis.cxx:281
TAxis::LabelsOption
virtual void LabelsOption(Option_t *option="h")
Set option(s) to draw axis with labels option can be:
Definition: TAxis.cxx:613
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
TAxis::GetLowEdge
virtual void GetLowEdge(Double_t *edge) const
Return an array with the low edge of all bins.
Definition: TAxis.cxx:562
TObjString::GetName
const char * GetName() const
Returns name of object.
Definition: TObjString.h:44
TAttAxis::SetTitleColor
virtual void SetTitleColor(Color_t color=1)
Set color of axis title.
Definition: TAttAxis.cxx:312
TAxisModLab::SetAngle
void SetAngle(Double_t a=-1.)
Set modified label angle.
Definition: TAxisModLab.cxx:47
bool
TAxis::HasBinWithoutLabel
Bool_t HasBinWithoutLabel() const
this helper function checks if there is a bin without a label if all bins have labels,...
Definition: TAxis.cxx:597
TString::ReplaceAll
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
TAttAxis::SetTitleSize
virtual void SetTitleSize(Float_t size=0.04)
Set size of axis title.
Definition: TAttAxis.cxx:303
TAxis::GetTitle
const char * GetTitle() const
Returns title of object.
Definition: TAxis.h:129
TAxis::GetParent
virtual TObject * GetParent() const
Definition: TAxis.h:123
TH1::GetDimension
virtual Int_t GetDimension() const
Definition: TH1.h:279
TObjString
Definition: TObjString.h:28
TAxis::kCenterLabels
@ kCenterLabels
Definition: TAxis.h:63
TNamed::Copy
virtual void Copy(TObject &named) const
Copy this to obj.
Definition: TNamed.cxx:94
TAxis::GetCenter
virtual void GetCenter(Double_t *center) const
Return an array with the center of all bins.
Definition: TAxis.cxx:553
TAxis::kTickMinus
@ kTickMinus
Definition: TAxis.h:60
TAttAxis::SetLabelSize
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels.
Definition: TAttAxis.cxx:203
TAxis::kMoreLogLabels
@ kMoreLogLabels
Definition: TAxis.h:72
TAxis::SetRange
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition: TAxis.cxx:920
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TAxis::fTimeFormat
TString fTimeFormat
Definition: TAxis.h:41
TAxisModLab::SetColor
void SetColor(Int_t c=-1)
Set modified label color.
Definition: TAxisModLab.cxx:68
TBuffer.h
TAxis::ChooseTimeFormat
const char * ChooseTimeFormat(Double_t axislength=0)
Choose a reasonable time format from the coordinates in the active pad and the number of divisions in...
Definition: TAxis.cxx:126
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
TObject::ResetBit
void ResetBit(UInt_t f)
Definition: TObject.h:171
TAxis::kLabelsHori
@ kLabelsHori
Definition: TAxis.h:67
TH1::GetYaxis
TAxis * GetYaxis()
Definition: TH1.h:318
xmin
float xmin
Definition: THbookFile.cxx:95
TAxis::~TAxis
virtual ~TAxis()
Destructor.
Definition: TAxis.cxx:88
TAttAxis::GetTitleColor
virtual Color_t GetTitleColor() const
Definition: TAttAxis.h:52
THashList
Definition: THashList.h:34
h
#define h(i)
Definition: RSha256.hxx:124
TAttAxis::GetTickLength
virtual Float_t GetTickLength() const
Definition: TAttAxis.h:51
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TAxis::kLabelsUp
@ kLabelsUp
Definition: TAxis.h:70
THashList::FindObject
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
TAxis::kAxisRange
@ kAxisRange
Definition: TAxis.h:61
TAttAxis::SetTitleFont
virtual void SetTitleFont(Style_t font=62)
Set the title font.
Definition: TAttAxis.cxx:321
TMath::Floor
Double_t Floor(Double_t x)
Definition: TMath.h:703
TAttAxis::GetLabelColor
virtual Color_t GetLabelColor() const
Definition: TAttAxis.h:44
TString::Remove
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
TNamed
Definition: TNamed.h:29
TBuffer::WriteClassBuffer
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
TArrayD::Set
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
TString::Append
TString & Append(const char *cs)
Definition: TString.h:564
TArrayD::Copy
void Copy(TArrayD &array) const
Definition: TArrayD.h:48
TAxis::ChangeLabel
void ChangeLabel(Int_t labNum=0, Double_t labAngle=-1., Double_t labSize=-1., Int_t labAlign=-1, Int_t labColor=-1, Int_t labFont=-1, TString labText="")
Define new text attributes for the label number "labNum".
Definition: TAxis.cxx:873
gDebug
R__EXTERN Int_t gDebug
Definition: RtypesCore.h:119
Long_t
long Long_t
Definition: RtypesCore.h:54
TAxis::kTickPlus
@ kTickPlus
Definition: TAxis.h:59
TStyle::GetTimeOffset
Double_t GetTimeOffset() const
Definition: TStyle.h:260
TH1::SetMaximum
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:395
TAxisModLab::SetSize
void SetSize(Double_t s=-1.)
Set modified label size.
Definition: TAxisModLab.cxx:54
TAxis::GetLast
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:469
TH1::GetMinimum
virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const
Return minimum value larger than minval of bins in the range, unless the value has been overridden by...
Definition: TH1.cxx:8090
THashList::Rehash
void Rehash(Int_t newCapacity)
Rehash the hashlist.
Definition: THashList.cxx:368
TVirtualPad.h
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TAxis::GetTimeFormat
virtual const char * GetTimeFormat() const
Definition: TAxis.h:127
TAxis::kAlphanumeric
@ kAlphanumeric
Definition: TAxis.h:48
TAxis::SetCanExtend
void SetCanExtend(Bool_t canExtend)
Definition: TAxis.h:86
TAxisModLab::SetLabNum
void SetLabNum(Int_t n=0)
Set modified label number.
Definition: TAxisModLab.cxx:40
TAxis::SetTicks
virtual void SetTicks(Option_t *option="+")
Set ticks orientation.
Definition: TAxis.cxx:972
TAxis::SetDefaults
virtual void SetDefaults()
Set axis default values (from TStyle)
Definition: TAxis.cxx:803
TAxis::UnZoom
virtual void UnZoom()
Reset first & last bin to the full range.
Definition: TAxis.cxx:1132
TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
TAxis::fModLabs
TList * fModLabs
Definition: TAxis.h:44
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:876
TAxis::kLabelsDown
@ kLabelsDown
Definition: TAxis.h:69
TBuffer::ReadVersion
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
TAxis::SetAlphanumeric
void SetAlphanumeric(Bool_t alphanumeric=kTRUE)
Set axis alphanumeric.
Definition: TAxis.cxx:779
unsigned int
TMath::BinarySearch
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Definition: TMathBase.h:278
THashList.h
THashList::Delete
void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: THashList.cxx:207
TString::Index
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
TAttAxis::SaveAttributes
virtual void SaveAttributes(std::ostream &out, const char *name, const char *subname)
Save axis attributes as C++ statement(s) on output stream out.
Definition: TAttAxis.cxx:110
TArrayD::fArray
Double_t * fArray
Definition: TArrayD.h:36
TAxis::fXbins
TArrayD fXbins
Definition: TAxis.h:36
TAxis::SetBinLabel
virtual void SetBinLabel(Int_t bin, const char *label)
Set label for bin.
Definition: TAxis.cxx:823
TBuffer::IsReading
Bool_t IsReading() const
Definition: TBuffer.h:86
TAttAxis::SetLabelColor
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition: TAttAxis.cxx:172
TString::IsNull
Bool_t IsNull() const
Definition: TString.h:407
Double_t
double Double_t
Definition: RtypesCore.h:59
TAxis::kLabelsVert
@ kLabelsVert
Definition: TAxis.h:68
TH1::kNstat
@ kNstat
Definition: TH1.h:180
TAxis::CanBeAlphanumeric
Bool_t CanBeAlphanumeric()
Definition: TAxis.h:83
TAxis::fNbins
Int_t fNbins
Definition: TAxis.h:33
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TAxis::fTimeDisplay
Bool_t fTimeDisplay
Definition: TAxis.h:40
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TAttAxis::GetTitleFont
virtual Style_t GetTitleFont() const
Definition: TAttAxis.h:53
TAxis.h
TObject
Definition: TObject.h:37
TH1::kIsZoomed
@ kIsZoomed
bit set when zooming on Y axis
Definition: TH1.h:165
TH1
Definition: TH1.h:57
TAttAxis
Definition: TAttAxis.h:18
TAttAxis::SetTickLength
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length.
Definition: TAttAxis.cxx:279
name
char name[80]
Definition: TGX11.cxx:110
TAxis::GetTimeFormatOnly
virtual const char * GetTimeFormatOnly() const
Return only the time format from the string fTimeFormat.
Definition: TAxis.cxx:571
TAxis::FindBin
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:293
TAttAxis::SetNdivisions
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition: TAttAxis.cxx:228
TAxis::kRotateTitle
@ kRotateTitle
Definition: TAxis.h:64
gPad
#define gPad
Definition: TVirtualPad.h:287
TIter
Definition: TCollection.h:233
TAxis::FindFixBin
virtual Int_t FindFixBin(Double_t x) const
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:419
TAxisModLab.h
TAxis::fParent
TObject * fParent
Definition: TAxis.h:42
TAttAxis::GetLabelFont
virtual Style_t GetLabelFont() const
Definition: TAttAxis.h:45
TAxis::GetBinCenterLog
virtual Double_t GetBinCenterLog(Int_t bin) const
Return center of bin in log With a log-equidistant binning for a bin with low and up edges,...
Definition: TAxis.cxx:501
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
TAxis::fXmin
Double_t fXmin
Definition: TAxis.h:34
TAttAxis::SetTitleOffset
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title.
Definition: TAttAxis.cxx:293
Class
void Class()
Definition: Class.C:29
TString::ToLower
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1125
TH1::GetXaxis
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:317
TH1::GetMaximum
virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const
Return maximum value smaller than maxval of bins in the range, unless the value has been overridden b...
Definition: TH1.cxx:8005
TAxis::ZoomOut
virtual void ZoomOut(Double_t factor=0, Double_t offset=0)
Zoom out by a factor of 'factor' (default =2) uses previous zoom factor by default Keep center define...
Definition: TAxis.cxx:1204
for
for(Int_t i=0;i< n;i++)
Definition: legend1.C:18
TAttAxis::SetLabelFont
virtual void SetLabelFont(Style_t font=62)
Set labels' font.
Definition: TAttAxis.cxx:182
TH1.h
TAxis::DistancetoPrimitive
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to an axis.
Definition: TAxis.cxx:265
TAttAxis::GetNdivisions
virtual Int_t GetNdivisions() const
Definition: TAttAxis.h:42
TAttAxis::GetTitleSize
virtual Float_t GetTitleSize() const
Definition: TAttAxis.h:50
TList
Definition: TList.h:44
TAxis::GetBinWidth
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:540
TMath.h
TObject::SetUniqueID
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition: TObject.cxx:707
TAxis::kDecimals
@ kDecimals
Definition: TAxis.h:58
int
TError.h
TAxis::fLast
Int_t fLast
Definition: TAxis.h:38
TAttAxis::GetTitleOffset
virtual Float_t GetTitleOffset() const
Definition: TAttAxis.h:49