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 "THLimitsFinder.h"
26#include "strlcpy.h"
27#include "snprintf.h"
28
29#include <iostream>
30#include <ctime>
31#include <cassert>
32
34
35////////////////////////////////////////////////////////////////////////////////
36/** \class TAxis
37 \ingroup Histograms
38 \brief Class to manage histogram axis
39
40This class manages histogram axis. It is referenced by TH1 and TGraph.
41To make a graphical representation of an histogram axis, this class
42references the TGaxis class. TAxis supports axis with fixed or variable bin sizes.
43Labels may be associated to individual bins.
44See examples of various axis representations drawn by class TGaxis.
45*///////////////////////////////////////////////////////////////////////////////
46
47////////////////////////////////////////////////////////////////////////////////
48/// Default constructor.
49
51{
52 fNbins = 1;
53 fXmin = 0;
54 fXmax = 1;
55 fFirst = 0;
56 fLast = 0;
57 fParent = nullptr;
58 fLabels = nullptr;
59 fModLabs = nullptr;
60 fBits2 = 0;
61 fTimeDisplay = 0;
62}
63
64////////////////////////////////////////////////////////////////////////////////
65/// Axis constructor for axis with fix bin size
66
68{
69 fParent = nullptr;
70 fLabels = nullptr;
71 fModLabs = nullptr;
72 Set(nbins,xlow,xup);
73}
74
75////////////////////////////////////////////////////////////////////////////////
76/// Axis constructor for variable bin size
77
79{
80 fParent = nullptr;
81 fLabels = nullptr;
82 fModLabs = nullptr;
83 Set(nbins,xbins);
84}
85
86////////////////////////////////////////////////////////////////////////////////
87/// Destructor.
88
90{
91 if (fLabels) {
92 fLabels->Delete();
93 delete fLabels;
94 fLabels = nullptr;
95 }
96 if (fModLabs) {
98 delete fModLabs;
99 fModLabs = nullptr;
100 }
101}
102
103////////////////////////////////////////////////////////////////////////////////
104/// Copy constructor.
105
106TAxis::TAxis(const TAxis &axis) : TNamed(axis), TAttAxis(axis)
107{
108 fParent = nullptr;
109 fLabels = nullptr;
110 fModLabs = nullptr;
111
112 axis.TAxis::Copy(*this);
113}
114
115////////////////////////////////////////////////////////////////////////////////
116/// Assignment operator.
117
119{
120 if (this != &axis)
121 axis.TAxis::Copy(*this);
122 return *this;
123}
124
125
126////////////////////////////////////////////////////////////////////////////////
127/// Choose a reasonable time format from the coordinates in the active pad
128/// and the number of divisions in this axis
129/// If orientation = "X", the horizontal axis of the pad will be used for ref.
130/// If orientation = "Y", the vertical axis of the pad will be used for ref.
131
132const char *TAxis::ChooseTimeFormat(Double_t axislength)
133{
134 const char *formatstr = nullptr;
135 Int_t reasformat = 0;
136 Int_t ndiv,nx1,nx2,n;
137 Double_t awidth;
139
140 if (!axislength) {
141 length = gPad->GetUxmax() - gPad->GetUxmin();
142 } else {
143 length = axislength;
144 }
145
146 ndiv = GetNdivisions();
147 if (ndiv > 1000) {
148 nx2 = ndiv/100;
149 nx1 = TMath::Max(1, ndiv%100);
150 ndiv = 100*nx2 + Int_t(Double_t(nx1)*gPad->GetAbsWNDC());
151 }
152 ndiv = TMath::Abs(ndiv);
153 n = ndiv - (ndiv/100)*100;
154 awidth = length/n;
155
156// width in seconds ?
157 if (awidth>=.5) {
158 reasformat = 1;
159// width in minutes ?
160 if (awidth>=30) {
161 awidth /= 60; reasformat = 2;
162// width in hours ?
163 if (awidth>=30) {
164 awidth /=60; reasformat = 3;
165// width in days ?
166 if (awidth>=12) {
167 awidth /= 24; reasformat = 4;
168// width in months ?
169 if (awidth>=15.218425) {
170 awidth /= 30.43685; reasformat = 5;
171// width in years ?
172 if (awidth>=6) {
173 awidth /= 12; reasformat = 6;
174 if (awidth>=2) {
175 awidth /= 12; reasformat = 7;
176 }
177 }
178 }
179 }
180 }
181 }
182 }
183// set reasonable format
184 switch (reasformat) {
185 case 0:
186 formatstr = "%S";
187 break;
188 case 1:
189 formatstr = "%Mm%S";
190 break;
191 case 2:
192 formatstr = "%Hh%M";
193 break;
194 case 3:
195 formatstr = "%d-%Hh";
196 break;
197 case 4:
198 formatstr = "%d/%m";
199 break;
200 case 5:
201 formatstr = "%d/%m/%y";
202 break;
203 case 6:
204 formatstr = "%d/%m/%y";
205 break;
206 case 7:
207 formatstr = "%m/%y";
208 break;
209 }
210 return formatstr;
211}
212
213////////////////////////////////////////////////////////////////////////////////
214/// Copy axis structure to another axis
215
216void TAxis::Copy(TObject &obj) const
217{
218 TAxis &axis = static_cast<TAxis &>(obj);
219 TNamed::Copy(axis);
220 TAttAxis::Copy(axis);
221 axis.fNbins = fNbins;
222 axis.fXmin = fXmin;
223 axis.fXmax = fXmax;
224 axis.fFirst = fFirst;
225 axis.fLast = fLast;
226 axis.fBits2 = fBits2;
227 fXbins.Copy(axis.fXbins);
230 axis.fParent = fParent;
231 if (axis.fLabels) {
232 axis.fLabels->Delete();
233 delete axis.fLabels;
234 axis.fLabels = nullptr;
235 }
236 if (fLabels) {
237 //Properly handle case where not all bins have labels
238 axis.fLabels = new THashList(axis.fNbins, 3);
239 TIter next(fLabels);
240 while(auto label = (TObjString *)next()) {
241 TObjString *copyLabel = new TObjString(*label);
242 axis.fLabels->Add(copyLabel);
243 copyLabel->SetUniqueID(label->GetUniqueID());
244 }
245 }
246 if (axis.fModLabs) {
247 axis.fModLabs->Delete();
248 delete axis.fModLabs;
249 axis.fModLabs = nullptr;
250 }
251 if (fModLabs) {
252 axis.fModLabs = new TList();
253 TIter next(fModLabs);
254 while(auto 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
338Int_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
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
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
401Int_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
440const 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
553void TAxis::GetCenter(Double_t *center) const
554{
555 for (Int_t bin = 1; bin <= fNbins; bin++)
556 *(center + bin - 1) = GetBinCenter(bin);
557}
558
559////////////////////////////////////////////////////////////////////////////////
560/// Return an array with the low edge of all bins
561
563{
564 for (Int_t bin = 1; bin <= fNbins; bin++)
565 *(edge + bin - 1) = GetBinLowEdge(bin);
566}
567
568////////////////////////////////////////////////////////////////////////////////
569/// Return the number of axis labels.
570///
571/// It is sometimes useful to know the number of labels on an axis. For instance
572/// when changing the labels with TAxis::ChangeLabel. The number of labels is equal
573/// to `the_number_of_divisions + 1`. By default the number of divisions is
574/// optimised to show a coherent labeling of the main tick marks. After optimisation the
575/// real number of divisions will be smaller or equal to number of divisions requested.
576/// In order to turn off the labeling optimization, it is enough to give a negative
577/// number of divisions to TAttAxis::SetNdivisions. The absolute value of this number will be use as
578/// the exact number of divisions. This method takes the two cases (optimised or not) into
579/// account.
580
582{
583 if (fNdivisions > 0) {
584 Int_t divxo = 0;
585 Double_t x1o = 0.;
586 Double_t x2o = 0.;
587 Double_t bwx = 0.;
588 THLimitsFinder::Optimize(fXmin, fXmax,fNdivisions%100,x1o,x2o,divxo,bwx,"");
589 return divxo+1;
590 } else {
591 Int_t divx = -fNdivisions;
592 return divx%100+1;
593 }
594}
595
596////////////////////////////////////////////////////////////////////////////////
597/// Return *only* the time format from the string fTimeFormat
598
599const char *TAxis::GetTimeFormatOnly() const
600{
601 static TString timeformat;
602 Int_t idF = fTimeFormat.Index("%F");
603 if (idF>=0) {
604 timeformat = fTimeFormat(0,idF);
605 } else {
606 timeformat = fTimeFormat;
607 }
608 return timeformat.Data();
609}
610
611////////////////////////////////////////////////////////////////////////////////
612/// Return the ticks option (see SetTicks)
613
614const char *TAxis::GetTicks() const
615{
616 if (TestBit(kTickPlus) && TestBit(kTickMinus)) return "+-";
617 if (TestBit(kTickMinus)) return "-";
618 return "+";
619}
620
621////////////////////////////////////////////////////////////////////////////////
622/// This helper function checks if there is a bin without a label
623/// if all bins have labels, the axis can / will become alphanumeric
624
626{
627 return fLabels->GetSize() != fNbins;
628}
629
630////////////////////////////////////////////////////////////////////////////////
631/// Set option(s) to draw axis with labels
632/// option can be:
633/// - "a" sort by alphabetic order
634/// - ">" sort by decreasing values
635/// - "<" sort by increasing values
636/// - "h" draw labels horizontal
637/// - "v" draw labels vertical
638/// - "u" draw labels up (end of label right adjusted)
639/// - "d" draw labels down (start of label left adjusted)
640
642{
643 if (!fLabels) {
644 Warning("Sort","Cannot sort. No labels");
645 return;
646 }
647 TH1 *h = (TH1*)GetParent();
648 if (!h) {
649 Error("Sort","Axis has no parent");
650 return;
651 }
652
653 h->LabelsOption(option,GetName());
654}
655
656////////////////////////////////////////////////////////////////////////////////
657/// Copy axis attributes to this
658
660{
661 SetTitle(axis->GetTitle());
663 SetAxisColor(axis->GetAxisColor());
665 SetLabelFont(axis->GetLabelFont());
667 SetLabelSize(axis->GetLabelSize());
670 SetTitleSize(axis->GetTitleSize());
672 SetTitleFont(axis->GetTitleFont());
682}
683
684
685
686////////////////////////////////////////////////////////////////////////////////
687/// Save axis attributes as C++ statement(s) on output stream out
688
689void TAxis::SaveAttributes(std::ostream &out, const char *name, const char *subname)
690{
691 char quote = '"';
692 if (strlen(GetTitle())) {
693 TString t(GetTitle());
694 t.ReplaceAll("\\","\\\\");
695 out<<" "<<name<<subname<<"->SetTitle("<<quote<<t.Data()<<quote<<");"<<std::endl;
696 }
697 if (fTimeDisplay) {
698 out<<" "<<name<<subname<<"->SetTimeDisplay(1);"<<std::endl;
699 out<<" "<<name<<subname<<"->SetTimeFormat("<<quote<<GetTimeFormat()<<quote<<");"<<std::endl;
700 }
701 if (fLabels) {
702 TIter next(fLabels);
703 TObjString *obj;
704 while ((obj=(TObjString*)next())) {
705 out<<" "<<name<<subname<<"->SetBinLabel("<<obj->GetUniqueID()<<","<<quote<<obj->GetName()<<quote<<");"<<std::endl;
706 }
707 }
708
709 if (fFirst || fLast) {
710 out<<" "<<name<<subname<<"->SetRange("<<fFirst<<","<<fLast<<");"<<std::endl;
711 }
712
713 if (TestBit(kLabelsHori)) {
714 out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsHori);"<<std::endl;
715 }
716
717 if (TestBit(kLabelsVert)) {
718 out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsVert);"<<std::endl;
719 }
720
721 if (TestBit(kLabelsDown)) {
722 out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsDown);"<<std::endl;
723 }
724
725 if (TestBit(kLabelsUp)) {
726 out<<" "<<name<<subname<<"->SetBit(TAxis::kLabelsUp);"<<std::endl;
727 }
728
729 if (TestBit(kCenterLabels)) {
730 out<<" "<<name<<subname<<"->CenterLabels(true);"<<std::endl;
731 }
732
733 if (TestBit(kCenterTitle)) {
734 out<<" "<<name<<subname<<"->CenterTitle(true);"<<std::endl;
735 }
736
737 if (TestBit(kRotateTitle)) {
738 out<<" "<<name<<subname<<"->RotateTitle(true);"<<std::endl;
739 }
740
741 if (TestBit(kDecimals)) {
742 out<<" "<<name<<subname<<"->SetDecimals();"<<std::endl;
743 }
744
745 if (TestBit(kMoreLogLabels)) {
746 out<<" "<<name<<subname<<"->SetMoreLogLabels();"<<std::endl;
747 }
748
749 if (TestBit(kNoExponent)) {
750 out<<" "<<name<<subname<<"->SetNoExponent();"<<std::endl;
751 }
752
753 TAttAxis::SaveAttributes(out,name,subname);
754}
755
756////////////////////////////////////////////////////////////////////////////////
757/// Initialize axis with fix bins
758
759void TAxis::Set(Int_t nbins, Double_t xlow, Double_t xup)
760{
761 fNbins = nbins;
762 fXmin = xlow;
763 fXmax = xup;
764 if (!fParent) SetDefaults();
765 if (fXbins.fN > 0) fXbins.Set(0);
766}
767
768////////////////////////////////////////////////////////////////////////////////
769/// Initialize axis with variable bins
770
771void TAxis::Set(Int_t nbins, const Float_t *xbins)
772{
773 Int_t bin;
774 fNbins = nbins;
775 fXbins.Set(fNbins+1);
776 for (bin=0; bin<= fNbins; bin++)
777 fXbins.fArray[bin] = xbins[bin];
778 for (bin=1; bin<= fNbins; bin++)
779 if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
780 Error("TAxis::Set", "bins must be in increasing order");
781 fXmin = fXbins.fArray[0];
783 if (!fParent) SetDefaults();
784}
785
786////////////////////////////////////////////////////////////////////////////////
787/// Initialize axis with variable bins
788
789void TAxis::Set(Int_t nbins, const Double_t *xbins)
790{
791 Int_t bin;
792 fNbins = nbins;
793 fXbins.Set(fNbins+1);
794 for (bin=0; bin<= fNbins; bin++)
795 fXbins.fArray[bin] = xbins[bin];
796 for (bin=1; bin<= fNbins; bin++)
797 if (fXbins.fArray[bin] < fXbins.fArray[bin-1])
798 Error("TAxis::Set", "bins must be in increasing order");
799 fXmin = fXbins.fArray[0];
801 if (!fParent) SetDefaults();
802}
803
804////////////////////////////////////////////////////////////////////////////////
805/// Set axis alphanumeric
806
808{
809 if (alphanumeric) fBits2 |= kAlphanumeric;
810 else fBits2 &= ~kAlphanumeric;
811
812 // clear underflow and overflow (in an alphanumeric situation they do not make sense)
813 // NOTE: using AddBinContent instead of SetBinContent in order to not change
814 // the number of entries
815 //((TH1 *)fParent)->ClearUnderflowAndOverflow();
816 // L.M. 26.1.15 Keep underflow and overflows (see ROOT-7034)
817 if (gDebug && fParent) {
818 TH1 * h = dynamic_cast<TH1*>( fParent);
819 if (!h) return;
820 double s[TH1::kNstat];
821 h->GetStats(s);
822 if (s[0] != 0. && gDebug > 0)
823 Info("SetAlphanumeric","Cannot switch axis %s of histogram %s to alphanumeric: it has non-zero content",GetName(),h->GetName());
824 }
825}
826
827
828////////////////////////////////////////////////////////////////////////////////
829/// Set axis default values (from TStyle)
830
832{
833 fFirst = 0;
834 fLast = 0;
835 fBits2 = 0;
836 char name[2];
837 strlcpy(name,GetName(),2);
838 name[1] = 0;
840 fTimeDisplay = 0;
842}
843
844////////////////////////////////////////////////////////////////////////////////
845/// Set label for bin.
846/// If no label list exists, it is created. If all the bins have labels, the
847/// axis becomes alphanumeric and extendable.
848/// New labels will not be added with the Fill method but will end-up in the
849/// underflow bin. See documentation of TAxis::FindBin(const char*)
850
851void TAxis::SetBinLabel(Int_t bin, const char *label)
852{
853 if (!fLabels) fLabels = new THashList(fNbins,3);
854
855 if (bin <= 0 || bin > fNbins) {
856 Error("SetBinLabel","Illegal bin number: %d",bin);
857 return;
858 }
859
860 // Check whether this bin already has a label.
861 TIter next(fLabels);
862 TObjString *obj;
863 while ((obj=(TObjString*)next())) {
864 if ( obj->GetUniqueID()==(UInt_t)bin ) {
865 // It does. Overwrite it.
866 obj->SetString(label);
867 // LM need to rehash the labels list (see ROOT-5025)
869 return;
870 }
871 }
872 // It doesn't. Add this new label.
873 obj = new TObjString(label);
874 fLabels->Add(obj);
875 obj->SetUniqueID((UInt_t)bin);
876
877 // check for Alphanumeric case (labels for each bin)
878 if (CanBeAlphanumeric() && fLabels->GetSize() == fNbins) {
881 }
882}
883
884////////////////////////////////////////////////////////////////////////////////
885/// Define new text attributes for the label number "labNum". It allows to do a
886/// fine tuning of the labels. All the attributes can be changed, even the
887/// label text itself.
888///
889/// \param[in] labNum Number of the label to be changed, negative numbers start from the end
890/// \param[in] labAngle New angle value
891/// \param[in] labSize New size (0 erase the label)
892/// \param[in] labAlign New alignment value
893/// \param[in] labColor New label color
894/// \param[in] labFont New label font
895/// \param[in] labText New label text
896///
897/// #### Notes:
898///
899/// - If an attribute should not be changed just give the value "-1".
900/// - If labnum=0 the list of modified labels is reset.
901/// - To erase a label set labSize to 0.
902/// - If labText is not specified or is an empty string, the text label is not changed.
903/// - To retrieve the number of axis labels use TAxis::GetNlabels.
904
905void TAxis::ChangeLabel(Int_t labNum, Double_t labAngle, Double_t labSize,
906 Int_t labAlign, Int_t labColor, Int_t labFont,
907 TString labText)
908{
909 if (!fModLabs) fModLabs = new TList();
910
911 // Reset the list of modified labels.
912 if (labNum == 0) {
913 delete fModLabs;
914 fModLabs = 0;
915 return;
916 }
917
918 TAxisModLab *ml = new TAxisModLab();
919 ml->SetLabNum(labNum);
920 ml->SetAngle(labAngle);
921 ml->SetSize(labSize);
922 ml->SetAlign(labAlign);
923 ml->SetColor(labColor);
924 ml->SetFont(labFont);
925 ml->SetText(labText);
926
927 fModLabs->Add((TObject*)ml);
928}
929
930
931////////////////////////////////////////////////////////////////////////////////
932/// Set the viewing range for the axis using bin numbers.
933///
934/// \param first First bin of the range.
935/// \param last Last bin of the range.
936/// To set a range using the axis coordinates, use TAxis::SetRangeUser.
937///
938/// If `first == last == 0` or if `first > last` or if the range specified does
939/// not intersect at all with the maximum available range `[0, fNbins + 1]`,
940/// then the viewing range is reset by removing the bit TAxis::kAxisRange. In this
941/// case, the functions TAxis::GetFirst() and TAxis::GetLast() will return 1
942/// and fNbins.
943///
944/// If the range specified partially intersects with `[0, fNbins + 1]`, then the
945/// intersection range is accepted. For instance, if `first == -2` and `last == fNbins`,
946/// the accepted range will be `[0, fNbins]` (`fFirst = 0` and `fLast = fNbins`).
947///
948/// \note For historical reasons, SetRange(0,0) resets the range even though bin 0 is
949/// technically reserved for the underflow; in order to set the range of the axis
950/// so that it only includes the underflow, use `SetRange(-1,0)`.
951
953{
954
955 Int_t nCells = fNbins + 1; // bins + overflow
956
957 // special reset range cases
958 if (last < first || (first < 0 && last < 0) ||
959 (first > nCells && last > nCells) || (first == 0 && last == 0)
960 ) {
961 fFirst = 1;
962 fLast = fNbins;
963 SetBit(kAxisRange, 0);
964 } else {
965 fFirst = std::max(first, 0);
966 fLast = std::min(last, nCells);
967 SetBit(kAxisRange, 1);
968 }
969
970}
971
972
973////////////////////////////////////////////////////////////////////////////////
974/// Set the viewing range for the axis from ufirst to ulast (in user coordinates,
975/// that is, the "natural" axis coordinates).
976/// To set a range using the axis bin numbers, use TAxis::SetRange.
977
979{
980 if (!strstr(GetName(),"xaxis")) {
981 TH1 *hobj = (TH1*)GetParent();
982 if (hobj &&
983 ((hobj->GetDimension() == 2 && strstr(GetName(),"zaxis"))
984 || (hobj->GetDimension() == 1 && strstr(GetName(),"yaxis")))) {
985 hobj->SetMinimum(ufirst);
986 hobj->SetMaximum(ulast);
987 return;
988 }
989 }
990 Int_t ifirst = FindFixBin(ufirst);
991 Int_t ilast = FindFixBin(ulast);
992 // fixes for numerical error and for https://savannah.cern.ch/bugs/index.php?99777
993 if (GetBinUpEdge(ifirst) <= ufirst ) ifirst += 1;
994 if (GetBinLowEdge(ilast) >= ulast ) ilast -= 1;
995 SetRange(ifirst, ilast);
996}
997
998////////////////////////////////////////////////////////////////////////////////
999/// Set ticks orientation.
1000/// option = "+" ticks drawn on the "positive side" (default)
1001/// option = "-" ticks drawn on the "negative side"
1002/// option = "+-" ticks drawn on both sides
1003
1005{
1008 if (strchr(option,'+')) SetBit(kTickPlus);
1009 if (strchr(option,'-')) SetBit(kTickMinus);
1010}
1011
1012////////////////////////////////////////////////////////////////////////////////
1013/// Change the format used for time plotting
1014///
1015/// The format string for date and time use the same options as the one used
1016/// in the standard strftime C function, i.e. :
1017/// for date :
1018///
1019/// %a abbreviated weekday name
1020/// %b abbreviated month name
1021/// %d day of the month (01-31)
1022/// %m month (01-12)
1023/// %y year without century
1024///
1025/// for time :
1026///
1027/// %H hour (24-hour clock)
1028/// %I hour (12-hour clock)
1029/// %p local equivalent of AM or PM
1030/// %M minute (00-59)
1031/// %S seconds (00-61)
1032/// %% %
1033///
1034/// This function allows also to define the time offset. It is done via %F
1035/// which should be appended at the end of the format string. The time
1036/// offset has the following format: 'yyyy-mm-dd hh:mm:ss'
1037/// Example:
1038///
1039/// h = new TH1F("Test","h",3000,0.,200000.);
1040/// h->GetXaxis()->SetTimeDisplay(1);
1041/// h->GetXaxis()->SetTimeFormat("%d\/%m\/%y%F2000-02-28 13:00:01");
1042///
1043/// This defines the time format being "dd/mm/yy" and the time offset as the
1044/// February 28th 2003 at 13:00:01
1045///
1046/// If %F is not specified, the time offset used will be the one defined by:
1047/// gStyle->SetTimeOffset. For example like that:
1048///
1049/// TDatime da(2003,02,28,12,00,00);
1050/// gStyle->SetTimeOffset(da.Convert());
1051
1052void TAxis::SetTimeFormat(const char *tformat)
1053{
1054 TString timeformat = tformat;
1055
1056 if (timeformat.Index("%F")>=0 || timeformat.IsNull()) {
1057 fTimeFormat = timeformat;
1058 return;
1059 }
1060
1061 Int_t idF = fTimeFormat.Index("%F");
1062 if (idF>=0) {
1063 Int_t lnF = fTimeFormat.Length();
1064 TString stringtimeoffset = fTimeFormat(idF,lnF);
1065 fTimeFormat = tformat;
1066 fTimeFormat.Append(stringtimeoffset);
1067 } else {
1068 fTimeFormat = tformat;
1070 }
1071}
1072
1073
1074////////////////////////////////////////////////////////////////////////////////
1075/// Change the time offset
1076/// If option = "gmt", set display mode to GMT.
1077
1079{
1080 TString opt = option;
1081 opt.ToLower();
1082
1083 char tmp[20];
1084 time_t timeoff;
1085 struct tm* utctis;
1086 Int_t idF = fTimeFormat.Index("%F");
1087 if (idF>=0) fTimeFormat.Remove(idF);
1088 fTimeFormat.Append("%F");
1089
1090 timeoff = (time_t)((Long_t)(toffset));
1091 // offset is always saved in GMT to allow file transport
1092 // to different time zones
1093 utctis = gmtime(&timeoff);
1094
1095 strftime(tmp,20,"%Y-%m-%d %H:%M:%S",utctis);
1096 fTimeFormat.Append(tmp);
1097
1098 // append the decimal part of the time offset
1099 Double_t ds = toffset-(Int_t)toffset;
1100 snprintf(tmp,20,"s%g",ds);
1101 fTimeFormat.Append(tmp);
1102
1103 // add GMT/local option
1104 if (opt.Contains("gmt")) fTimeFormat.Append(" GMT");
1105}
1106
1107
1108////////////////////////////////////////////////////////////////////////////////
1109/// Stream an object of class TAxis.
1110
1112{
1113 if (R__b.IsReading()) {
1114 UInt_t R__s, R__c;
1115 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1116 if (R__v > 5) {
1117 R__b.ReadClassBuffer(TAxis::Class(), this, R__v, R__s, R__c);
1118 return;
1119 }
1120 //====process old versions before automatic schema evolution
1121 TNamed::Streamer(R__b);
1122 TAttAxis::Streamer(R__b);
1123 R__b >> fNbins;
1124 if (R__v < 5) {
1126 R__b >> xmin; fXmin = xmin;
1127 R__b >> xmax; fXmax = xmax;
1128 Float_t *xbins = 0;
1129 Int_t n = R__b.ReadArray(xbins);
1130 fXbins.Set(n);
1131 for (Int_t i=0;i<n;i++) fXbins.fArray[i] = xbins[i];
1132 delete [] xbins;
1133 } else {
1134 R__b >> fXmin;
1135 R__b >> fXmax;
1136 fXbins.Streamer(R__b);
1137 }
1138 if (R__v > 2) {
1139 R__b >> fFirst;
1140 R__b >> fLast;
1141 // following lines required to repair for a bug in Root version 1.03
1142 if (fFirst < 0 || fFirst > fNbins) fFirst = 0;
1143 if (fLast < 0 || fLast > fNbins) fLast = 0;
1144 if (fLast < fFirst) { fFirst = 0; fLast = 0;}
1145 if (fFirst ==0 && fLast == 0) SetBit(kAxisRange,0);
1146 }
1147 if (R__v > 3) {
1148 R__b >> fTimeDisplay;
1149 fTimeFormat.Streamer(R__b);
1150 } else {
1151 SetTimeFormat();
1152 }
1153 R__b.CheckByteCount(R__s, R__c, TAxis::IsA());
1154 //====end of old versions
1155
1156 } else {
1157 R__b.WriteClassBuffer(TAxis::Class(),this);
1158 }
1159}
1160
1161////////////////////////////////////////////////////////////////////////////////
1162/// Reset first & last bin to the full range
1163
1165{
1166 if (!gPad) {
1167 Warning("TAxis::UnZoom","Cannot UnZoom if gPad does not exist. Did you mean to draw the TAxis first?");
1168 return;
1169 }
1170 gPad->SetView();
1171
1172 //unzoom object owning this axis
1173 SetRange(0,0);
1174 TH1 *hobj1 = (TH1*)GetParent();
1175 if (!strstr(GetName(),"xaxis")) {
1176 if (!hobj1) return;
1177 if (hobj1->GetDimension() == 2) {
1178 if (strstr(GetName(),"zaxis")) {
1179 hobj1->SetMinimum();
1180 hobj1->SetMaximum();
1181 hobj1->ResetBit(TH1::kIsZoomed);
1182 }
1183 return;
1184 }
1185 if (strcmp(hobj1->GetName(),"hframe") == 0 ) {
1186 hobj1->SetMinimum(fXmin);
1187 hobj1->SetMaximum(fXmax);
1188 } else {
1189 if (fXmin==hobj1->GetMinimum() && fXmax==hobj1->GetMaximum()) {
1190 hobj1->SetMinimum(fXmin);
1191 hobj1->SetMaximum(fXmax);
1192 } else {
1193 hobj1->SetMinimum();
1194 hobj1->SetMaximum();
1195 }
1196 hobj1->ResetBit(TH1::kIsZoomed);
1197 }
1198 }
1199 //must unzoom all histograms in the pad
1200 TIter next(gPad->GetListOfPrimitives());
1201 TObject *obj;
1202 while ((obj= next())) {
1203 if (!obj->InheritsFrom(TH1::Class())) continue;
1204 TH1 *hobj = (TH1*)obj;
1205 if (hobj == hobj1) continue;
1206 if (!strstr(GetName(),"xaxis")) {
1207 if (hobj->GetDimension() == 2) {
1208 if (strstr(GetName(),"zaxis")) {
1209 hobj->SetMinimum();
1210 hobj->SetMaximum();
1211 hobj->ResetBit(TH1::kIsZoomed);
1212 } else {
1213 hobj->GetYaxis()->SetRange(0,0);
1214 }
1215 return;
1216 }
1217 if (strcmp(hobj->GetName(),"hframe") == 0 ) {
1218 hobj->SetMinimum(fXmin);
1219 hobj->SetMaximum(fXmax);
1220 } else {
1221 hobj->SetMinimum();
1222 hobj->SetMaximum();
1223 hobj->ResetBit(TH1::kIsZoomed);
1224 }
1225 } else {
1226 hobj->GetXaxis()->SetRange(0,0);
1227 }
1228 }
1229
1230 gPad->UnZoomed();
1231}
1232
1233////////////////////////////////////////////////////////////////////////////////
1234/// Zoom out by a factor of 'factor' (default =2)
1235/// uses previous zoom factor by default
1236/// Keep center defined by 'offset' fixed
1237/// ie. -1 at left of current range, 0 in center, +1 at right
1238
1240{
1241
1242 if (factor <= 0) factor = 2;
1243 Double_t center = (GetFirst()*(1-offset) + GetLast()*(1+offset))/2.;
1244 Int_t first = int(TMath::Floor(center+(GetFirst()-center)*factor + 0.4999999));
1245 Int_t last = int(TMath::Floor(center+(GetLast() -center)*factor + 0.5000001));
1246 if (first==GetFirst() && last==GetLast()) { first--; last++; }
1247 SetRange(first,last);
1248}
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:45
short Version_t
Definition: RtypesCore.h:65
long Long_t
Definition: RtypesCore.h:54
float Float_t
Definition: RtypesCore.h:57
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
Int_t gDebug
Definition: TROOT.cxx:585
R__EXTERN TStyle * gStyle
Definition: TStyle.h:414
#define gPad
Definition: TVirtualPad.h:288
#define snprintf
Definition: civetweb.c:1540
Double_t * fArray
Definition: TArrayD.h:30
void Streamer(TBuffer &) override
Stream a TArrayD object.
Definition: TArrayD.cxx:149
void Copy(TArrayD &array) const
Definition: TArrayD.h:42
void Set(Int_t n) override
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
Int_t fN
Definition: TArray.h:38
Manages histogram axis attributes.
Definition: TAttAxis.h:18
virtual Color_t GetTitleColor() const
Definition: TAttAxis.h:46
virtual Color_t GetLabelColor() const
Definition: TAttAxis.h:38
Int_t fNdivisions
Number of divisions(10000*n3 + 100*n2 + n1)
Definition: TAttAxis.h:20
virtual Int_t GetNdivisions() const
Definition: TAttAxis.h:36
virtual Color_t GetAxisColor() const
Definition: TAttAxis.h:37
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title.
Definition: TAttAxis.cxx:301
virtual Style_t GetTitleFont() const
Definition: TAttAxis.h:47
virtual Float_t GetLabelOffset() const
Definition: TAttAxis.h:40
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition: TAttAxis.cxx:163
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels.
Definition: TAttAxis.cxx:206
virtual Style_t GetLabelFont() const
Definition: TAttAxis.h:39
virtual void SetTitleFont(Style_t font=62)
Set the title font.
Definition: TAttAxis.cxx:330
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels.
Definition: TAttAxis.cxx:194
virtual void SetLabelFont(Style_t font=62)
Set labels' font.
Definition: TAttAxis.cxx:183
virtual void SetTitleSize(Float_t size=0.04)
Set size of axis title.
Definition: TAttAxis.cxx:312
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:111
virtual void SetTitleColor(Color_t color=1)
Set color of axis title.
Definition: TAttAxis.cxx:321
virtual Float_t GetTitleSize() const
Definition: TAttAxis.h:44
virtual void Streamer(TBuffer &)
Stream an object of class TAttAxis.
Definition: TAttAxis.cxx:339
virtual Float_t GetLabelSize() const
Definition: TAttAxis.h:41
virtual Float_t GetTickLength() const
Definition: TAttAxis.h:45
virtual void ResetAttAxis(Option_t *option="")
Reset axis attributes.
Definition: TAttAxis.cxx:79
virtual Float_t GetTitleOffset() const
Definition: TAttAxis.h:43
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length.
Definition: TAttAxis.cxx:287
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition: TAttAxis.cxx:236
void Copy(TAttAxis &attaxis) const
Copy of the object.
Definition: TAttAxis.cxx:61
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition: TAttAxis.cxx:173
TAxis helper class used to store the modified labels.
Definition: TAxisModLab.h:21
void SetColor(Int_t c=-1)
Set modified label color.
Definition: TAxisModLab.cxx:68
void SetSize(Double_t s=-1.)
Set modified label size.
Definition: TAxisModLab.cxx:54
void SetFont(Int_t f=-1)
Set modified label font.
Definition: TAxisModLab.cxx:75
void SetText(TString t="")
Set modified label text.
Definition: TAxisModLab.cxx:82
void SetAlign(Int_t a=-1)
Set modified label alignment.
Definition: TAxisModLab.cxx:61
void SetLabNum(Int_t n=0)
Set modified label number.
Definition: TAxisModLab.cxx:40
void SetAngle(Double_t a=-1.)
Set modified label angle.
Definition: TAxisModLab.cxx:47
Class to manage histogram axis.
Definition: TAxis.h:30
virtual void GetCenter(Double_t *center) const
Return an array with the center of all bins.
Definition: TAxis.cxx:553
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:1078
virtual void LabelsOption(Option_t *option="h")
Set option(s) to draw axis with labels option can be:
Definition: TAxis.cxx:641
virtual void SetDefaults()
Set axis default values (from TStyle)
Definition: TAxis.cxx:831
virtual void SetBinLabel(Int_t bin, const char *label)
Set label for bin.
Definition: TAxis.cxx:851
Int_t fLast
Last bin to display.
Definition: TAxis.h:38
static TClass * Class()
Bool_t IsAlphanumeric() const
Definition: TAxis.h:84
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:1239
const char * GetTitle() const override
Returns title of object.
Definition: TAxis.h:130
Int_t GetNlabels() const
Return the number of axis labels.
Definition: TAxis.cxx:581
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:478
TObject * fParent
! Object owning this axis
Definition: TAxis.h:42
Double_t fXmax
Upper edge of last bin.
Definition: TAxis.h:35
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to an axis.
Definition: TAxis.cxx:265
Bool_t CanExtend() const
Definition: TAxis.h:82
TArrayD fXbins
Bin edges array in X.
Definition: TAxis.h:36
TAxis()
Default constructor.
Definition: TAxis.cxx:50
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition: TAxis.cxx:281
virtual void UnZoom()
Reset first & last bin to the full range.
Definition: TAxis.cxx:1164
THashList * fLabels
List of labels.
Definition: TAxis.h:43
void SetCanExtend(Bool_t canExtend)
Definition: TAxis.h:86
void Copy(TObject &axis) const override
Copy axis structure to another axis.
Definition: TAxis.cxx:216
virtual void SetTicks(Option_t *option="+")
Set ticks orientation.
Definition: TAxis.cxx:1004
@ kTickMinus
Definition: TAxis.h:60
@ kLabelsUp
Definition: TAxis.h:70
@ kCenterTitle
Definition: TAxis.h:62
@ kRotateTitle
Definition: TAxis.h:64
@ kNoExponent
Definition: TAxis.h:66
@ kMoreLogLabels
Definition: TAxis.h:72
@ kTickPlus
Definition: TAxis.h:59
@ kLabelsDown
Definition: TAxis.h:69
@ kLabelsHori
Definition: TAxis.h:67
@ kAxisRange
Definition: TAxis.h:61
@ kDecimals
Definition: TAxis.h:58
@ kCenterLabels
Bit 13 is used by TObject.
Definition: TAxis.h:63
@ kLabelsVert
Definition: TAxis.h:68
Bool_t fTimeDisplay
On/off displaying time values instead of numerics.
Definition: TAxis.h:40
TList * fModLabs
List of modified labels.
Definition: TAxis.h:44
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition: TAxis.cxx:440
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:293
@ kAlphanumeric
Axis is alphanumeric.
Definition: TAxis.h:48
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:518
Int_t fNbins
Number of bins.
Definition: TAxis.h:33
Double_t fXmin
Low edge of first bin.
Definition: TAxis.h:34
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition: TAxis.cxx:759
Bool_t HasBinWithoutLabel() const
This helper function checks if there is a bin without a label if all bins have labels,...
Definition: TAxis.cxx:625
virtual Int_t FindFixBin(Double_t x) const
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:419
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:132
void SaveAttributes(std::ostream &out, const char *name, const char *subname) override
Save axis attributes as C++ statement(s) on output stream out.
Definition: TAxis.cxx:689
TClass * IsA() const override
Definition: TAxis.h:168
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:469
virtual void ImportAttributes(const TAxis *axis)
Copy axis attributes to this.
Definition: TAxis.cxx:659
virtual const char * GetTimeFormatOnly() const
Return only the time format from the string fTimeFormat.
Definition: TAxis.cxx:599
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
void SetAlphanumeric(Bool_t alphanumeric=kTRUE)
Set axis alphanumeric.
Definition: TAxis.cxx:807
void Streamer(TBuffer &) override
Stream an object of class TAxis.
Definition: TAxis.cxx:1111
TAxis & operator=(const TAxis &)
Assignment operator.
Definition: TAxis.cxx:118
~TAxis() override
Destructor.
Definition: TAxis.cxx:89
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:978
virtual const char * GetTimeFormat() const
Definition: TAxis.h:128
virtual void GetLowEdge(Double_t *edge) const
Return an array with the low edge of all bins.
Definition: TAxis.cxx:562
virtual void SetTimeFormat(const char *format="")
Change the format used for time plotting.
Definition: TAxis.cxx:1052
Bool_t CanBeAlphanumeric()
Definition: TAxis.h:83
TString fTimeFormat
Date&time format, ex: 09/12/99 12:34:00.
Definition: TAxis.h:41
virtual TObject * GetParent() const
Definition: TAxis.h:124
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition: TAxis.cxx:952
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:540
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:528
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:458
virtual const char * GetTicks() const
Return the ticks option (see SetTicks)
Definition: TAxis.cxx:614
UShort_t fBits2
Second bit status word.
Definition: TAxis.h:39
Int_t fFirst
First bin to display.
Definition: TAxis.h:37
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:905
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr)=0
virtual Int_t ReadArray(Bool_t *&b)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
virtual Int_t GetEntries() const
Definition: TCollection.h:179
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:184
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
static TClass * Class()
virtual Int_t GetDimension() const
Definition: TH1.h:281
@ kNstat
Size of statistics data (up to TProfile3D)
Definition: TH1.h:182
@ kIsZoomed
Bit set when zooming on Y axis.
Definition: TH1.h:167
TAxis * GetXaxis()
Definition: TH1.h:322
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:8412
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:400
TAxis * GetYaxis()
Definition: TH1.h:323
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:401
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:8502
static void Optimize(Double_t A1, Double_t A2, Int_t nold, Double_t &BinLow, Double_t &BinHigh, Int_t &nbins, Double_t &BWID, Option_t *option="")
Static function to compute reasonable axis limits.
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:34
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition: THashList.cxx:207
void Rehash(Int_t newCapacity)
Rehash the hashlist.
Definition: THashList.cxx:368
TObject * FindObject(const char *name) const override
Find object using its name.
Definition: THashList.cxx:262
A doubly linked list.
Definition: TList.h:38
void Add(TObject *obj) override
Definition: TList.h:81
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:470
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
void Copy(TObject &named) const override
Copy this to obj.
Definition: TNamed.cxx:94
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
void Streamer(TBuffer &) override
Stream an object of class TObject.
Collectable string class.
Definition: TObjString.h:28
void SetString(const char *s)
Definition: TObjString.h:45
const char * GetName() const override
Returns name of object.
Definition: TObjString.h:38
Mother of all ROOT objects.
Definition: TObject.h:41
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:201
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:458
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:956
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:775
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:526
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:970
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition: TObject.cxx:786
void ResetBit(UInt_t f)
Definition: TObject.h:200
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:944
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1159
const char * Data() const
Definition: TString.h:369
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
Bool_t IsNull() const
Definition: TString.h:407
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
virtual void Streamer(TBuffer &)
Stream a string object.
Definition: TString.cxx:1379
TString & Append(const char *cs)
Definition: TString.h:564
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:639
Double_t GetTimeOffset() const
Definition: TStyle.h:261
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
for(Int_t i=0;i< n;i++)
Definition: legend1.C:18
static constexpr double s
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition: TMathBase.h:250
Double_t Floor(Double_t x)
Rounds x downward, returning the largest integral value that is not greater than x.
Definition: TMath.h:678
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition: TMath.h:660
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Binary search in an array of n values to locate value.
Definition: TMathBase.h:347
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition: TMathBase.h:123
Definition: first.py:1
const double xbins[xbins_n]