ROOT logo
// @(#)root/hist:$Id$
// Author: Rene Brun   14/01/2002
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// THLimitsFinder                                                       //
//                                                                      //
// Class to compute nice axis limits.
//
// This class is called by default by the histograming system
// and also by TTree::Draw, TTreePlayer::DrawSelect.
//
// A different finder may be specified via THLimitsFinder::SetFinder.
//
//////////////////////////////////////////////////////////////////////////

#include "TH1.h"
#include "TMath.h"
#include "THLimitsFinder.h"

THLimitsFinder *THLimitsFinder::fgLimitsFinder = 0;

ClassImp(THLimitsFinder)

//______________________________________________________________________________
THLimitsFinder::THLimitsFinder()
{
}

//______________________________________________________________________________
THLimitsFinder::~THLimitsFinder()
{
}


//______________________________________________________________________________
Int_t THLimitsFinder::FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax)
{
// compute the best axis limits for the X axis.
// If the bit kIsInteger is set, the number of channels is also recomputed.
// The axis parameters are replaced by the optimized parameters
// example:
//  With the input parameters xmin=-1.467 and xmax=2.344, the function
//  will compute better limits -1.8 and 2.7 and store them in the axis.
         
   Int_t newbins;
   TAxis *xaxis = h->GetXaxis();
   
   if (xmin >= xmax) {
      if (xaxis->GetLabels()) {xmin  = 0; xmax  = xmin +xaxis->GetNbins();}
      else                    {xmin -= 1; xmax += 1;}
   }   
   
   THLimitsFinder::OptimizeLimits(xaxis->GetNbins(),
                                  newbins,xmin,xmax,
                                  xaxis->TestBit(TAxis::kIsInteger));
   
   h->SetBins(newbins,xmin,xmax);
 
   return 0;
}

//______________________________________________________________________________
Int_t THLimitsFinder::FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax)
{
// compute the best axis limits for the X and Y axis.
// If the bit kIsInteger is set, the number of channels is also recomputed.
// The axis parameters are replaced by the optimized parameters

   Int_t newbinsx,newbinsy;
   TAxis *xaxis = h->GetXaxis();
   TAxis *yaxis = h->GetYaxis();
   
   if (xmin >= xmax) {
      if (xaxis->GetLabels()) {xmin  = 0; xmax  = xmin +xaxis->GetNbins();}
      else                    {xmin -= 1; xmax += 1;}
   }   
   if (ymin >= ymax) {
      if (yaxis->GetLabels()) {ymin  = 0; ymax  = ymin +yaxis->GetNbins();}
      else                    {ymin -= 1; ymax += 1;}
   }      
   
   THLimitsFinder::OptimizeLimits(xaxis->GetNbins(),
                                  newbinsx,xmin,xmax,
                                  xaxis->TestBit(TAxis::kIsInteger));
   
   THLimitsFinder::OptimizeLimits(yaxis->GetNbins(),
                                  newbinsy,ymin,ymax,
                                  yaxis->TestBit(TAxis::kIsInteger));
  
   h->SetBins(newbinsx,xmin,xmax,newbinsy,ymin,ymax);
   return 0;
}

//______________________________________________________________________________
Int_t THLimitsFinder::FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax)
{
// compute the best axis limits for the X, Y and Z axis.
// If the bit kIsInteger is set, the number of channels is also recomputed.
// The axis parameters are replaced by the optimized parameters

   Int_t newbinsx,newbinsy,newbinsz;
   TAxis *xaxis = h->GetXaxis();
   TAxis *yaxis = h->GetYaxis();
   TAxis *zaxis = h->GetZaxis();
   
   if (xmin >= xmax) {
      if (xaxis->GetLabels()) {xmin  = 0; xmax  = xmin +xaxis->GetNbins();}
      else                    {xmin -= 1; xmax += 1;}
   }   
   if (ymin >= ymax) {
      if (yaxis->GetLabels()) {ymin  = 0; ymax  = ymin +yaxis->GetNbins();}
      else                    {ymin -= 1; ymax += 1;}
   }      
   if (zmin >= zmax) {
      if (zaxis->GetLabels()) {zmin  = 0; zmax  = zmin +zaxis->GetNbins();}
      else                    {zmin -= 1; zmax += 1;}
   }         
   
   THLimitsFinder::OptimizeLimits(xaxis->GetNbins(),
                                  newbinsx,xmin,xmax,
                                  xaxis->TestBit(TAxis::kIsInteger));
   
   THLimitsFinder::OptimizeLimits(yaxis->GetNbins(),
                                  newbinsy,ymin,ymax,
                                  yaxis->TestBit(TAxis::kIsInteger));
   
   THLimitsFinder::OptimizeLimits(zaxis->GetNbins(),
                                  newbinsz,zmin,zmax,
                                  zaxis->TestBit(TAxis::kIsInteger));
  
   h->SetBins(newbinsx,xmin,xmax,newbinsy,ymin,ymax,newbinsz,zmin,zmax);
   return 0;
}

//______________________________________________________________________________
THLimitsFinder *THLimitsFinder::GetLimitsFinder() 
{
// Return pointer to the current finder.
// Create one if none exists
// Use SetLimitsFinder to set a user defined finder.
   
   if (!fgLimitsFinder) fgLimitsFinder = new THLimitsFinder();
   return fgLimitsFinder;
}

//______________________________________________________________________________
void THLimitsFinder::SetLimitsFinder(THLimitsFinder *finder) 
{
// This static function can be used to specify a finder derived from THLimitsFinder.
// The finder may redefine the functions FindGoodLimits.
// Note that the redefined functions may call THLimitsFinder::FindGoodLimits.
      
   fgLimitsFinder = finder;
}

//______________________________________________________________________________
void THLimitsFinder::Optimize(Double_t A1,  Double_t A2,  Int_t nold ,
                              Double_t &BinLow, Double_t &BinHigh, 
                              Int_t &nbins, Double_t &BinWidth,
                              Option_t *option)
{
// static function to compute reasonable axis limits
//
// Input parameters:
//
//  A1,A2          : Original axis limits
//  BinLow,BinHigh : Optimized axis limits. They should be initialized by the 
//                   calling method for instance to 0.
//  nold           : Original number of divisions.
//  nbins          : Optimized number of divisions.
//  BinWidth       : Optimized bin width. It should be initialized by the 
//                   calling method for instance to 0.
//  option         : "T" means Time axis.

   Int_t lwid, kwid;
   Int_t ntemp = 0;
   Int_t jlog  = 0;
   Double_t siground = 0;
   Double_t alb, awidth, sigfig;
   Double_t timemulti = 1;
   Int_t roundmode =0;

   Int_t optionTime;
   if(strchr(option,'t')) optionTime = 1;  else optionTime = 0;

   nbins = nold;

   Double_t al = TMath::Min(A1,A2);
   Double_t ah = TMath::Max(A1,A2);
   if (al == ah) ah = al+1;
   // if nold  ==  -1 , program uses binwidth input from calling routine
   if (nold == -1 && BinWidth > 0 ) goto L90;
   ntemp = TMath::Max(nold,2);
   if (ntemp < 1) ntemp = 1;

L20:
   awidth = (ah-al)/Double_t(ntemp);
   timemulti = 1;
   if (awidth >= FLT_MAX) goto LOK;  //in float.h
   if (awidth <= 0)       goto LOK;

//      If time representation, bin width should be rounded to seconds
//      minutes, hours or days

   if (optionTime && awidth>=60) { // if width in seconds, treat it as normal
      //   width in minutes
      awidth /= 60; timemulti *=60;
      roundmode = 1; // round minutes (60)
      //   width in hours ?
      if (awidth>=60) {
         awidth /= 60; timemulti *= 60;
         roundmode = 2; // round hours (24)
         //   width in days ?
         if (awidth>=24) {
            awidth /= 24; timemulti *= 24;
            roundmode = 3; // round days (30)
            //   width in months ?
            if (awidth>=30.43685) { // Mean month length in 1900.
               awidth /= 30.43685; timemulti *= 30.43685;
               roundmode = 2; // round months (12)
               //   width in years ?
               if (awidth>=12) {
                  awidth /= 12; timemulti *= 12;
                  roundmode = 0; // round years (10)
               }
            }
         }
      }
   }
//      Get nominal bin width in exponential form

   jlog   = Int_t(TMath::Log10(awidth));
   if (jlog <-200 || jlog > 200) {
      BinLow   = 0;
      BinHigh  = 1;
      BinWidth = 0.01;
      nbins    = 100;
      return;
   }
   if (awidth <= 1 && (!optionTime || timemulti==1) ) jlog--;
   sigfig = awidth*TMath::Power(10,-jlog) -1e-10;
   //in the above statement, it is important to substract 1e-10
   //to avoid precision problems if the tests below
   
//      Round mantissa

   switch (roundmode) {

//      Round mantissa up to 1, 1.5, 2, 3, or 6 in case of minutes
      case 1: // case 60
         if      (sigfig <= 1)    siground = 1;
         else if (sigfig <= 1.5 && jlog==1)    siground = 1.5;
         else if (sigfig <= 2)    siground = 2;
         else if (sigfig <= 3 && jlog ==1)    siground = 3;
         else if (sigfig <= 5 && sigfig>3 && jlog ==0) siground = 5; //added (Damir in 3.10/02)
         else if (jlog==0)        {siground = 1; jlog++;}
         else                     siground = 6;
         break;
      case 2: // case 12 and 24

//      Round mantissa up to 1, 1.2, 2, 2.4, 3 or 6 in case of hours or months
         if      (sigfig <= 1 && jlog==0)    siground = 1;
         else if (sigfig <= 1.2 && jlog==1)    siground = 1.2;
         else if (sigfig <= 2 && jlog==0)    siground = 2;
         else if (sigfig <= 2.4 && jlog==1)    siground = 2.4;
         else if (sigfig <= 3)    siground = 3;
         else if (sigfig <= 6)    siground = 6;
         else if (jlog==0)        siground = 12;
         else                     siground = 2.4;
         break;

//-      Round mantissa up to 1, 1.4, 2, or 7 in case of days (weeks)
      case 3: // case 30
         if      (sigfig <= 1 && jlog==0)    siground = 1;
         else if (sigfig <= 1.4 && jlog==1)    siground = 1.4;
         else if (sigfig <= 3 && jlog ==1)    siground = 3;
         else                     siground = 7;
         break;
      default :
      
//      Round mantissa up to 1, 2, 2.5, 5, or 10 in case of decimal number
         if      (sigfig <= 1)    siground = 1;
         else if (sigfig <= 2)    siground = 2;
         else if (sigfig <= 5 && (!optionTime || jlog<1))  siground = 5;
         else if (sigfig <= 6 && optionTime && jlog==1)    siground = 6;
         else                    {siground = 1;   jlog++; }
         break;
   }

   BinWidth = siground*TMath::Power(10,jlog);
   if (optionTime) BinWidth *= timemulti;

//      Get new bounds from new width BinWidth

L90:
   alb  = al/BinWidth;
   if (TMath::Abs(alb) > 1e9) {
      BinLow  = al;
      BinHigh = ah;
      if (nbins > 10*nold && nbins > 10000) nbins = nold;
      return;
   }
   lwid   = Int_t(alb);
   if (alb < 0) lwid--;
   BinLow     = BinWidth*Double_t(lwid);
   alb        = ah/BinWidth + 1.00001;
   kwid = Int_t(alb);
   if (alb < 0) kwid--;
   BinHigh = BinWidth*Double_t(kwid);
   nbins = kwid - lwid;
   if (nold == -1) goto LOK;
   if (nold <= 5) {          //    Request for one bin is difficult case
      if (nold > 1 || nbins == 1)goto LOK;
      BinWidth = BinWidth*2;
      nbins    = 1;
      goto LOK;
   }
   if (2*nbins == nold && !optionTime) {ntemp++; goto L20; }

LOK:
   Double_t oldBinLow = BinLow;
   Double_t oldBinHigh = BinHigh;
   Int_t oldnbins = nbins;

   Double_t atest = BinWidth*0.0001;
   //if (TMath::Abs(BinLow-A1)  >= atest) { BinLow  += BinWidth;  nbins--; } //replaced by Damir in 3.10/02
   //if (TMath::Abs(BinHigh-A2) >= atest) { BinHigh -= BinWidth;  nbins--; } //by the next two lines
   if (al-BinLow  >= atest) { BinLow  += BinWidth;  nbins--; }
   if (BinHigh-ah >= atest) { BinHigh -= BinWidth;  nbins--; }
   if (!optionTime && BinLow >= BinHigh) {
      //this case may happen when nbins <=5
      BinLow = oldBinLow;
      BinHigh = oldBinHigh;
      nbins = oldnbins;
   }
   else if (optionTime && BinLow>=BinHigh) {
      nbins = 2*oldnbins;
      BinHigh = oldBinHigh;
      BinLow = oldBinLow;
      BinWidth = (oldBinHigh - oldBinLow)/nbins;
      atest = BinWidth*0.0001;
      if (al-BinLow  >= atest) { BinLow  += BinWidth;  nbins--; }
      if (BinHigh-ah >= atest) { BinHigh -= BinWidth;  nbins--; }
   }
}

//______________________________________________________________________________
void THLimitsFinder::OptimizeLimits(Int_t nbins, Int_t &newbins, Double_t &xmin, Double_t &xmax, Bool_t isInteger)
{
// Optimize axis limits.
// When isInter=kTRUE, the function makes an integer binwidth
// and recompute the number of bins accordingly.
   
   Double_t binlow = 0,binhigh = 0,binwidth=0;
   Int_t n=0;
   Double_t dx = 0.1*(xmax-xmin);
   if (isInteger) dx = 5*(xmax-xmin)/nbins;
   Double_t umin = xmin - dx;
   Double_t umax = xmax + dx;
   if (umin < 0 && xmin >= 0) umin = 0;
   if (umax > 0 && xmax <= 0) umax = 0;
   
   THLimitsFinder::Optimize(umin,umax,nbins,binlow,binhigh,n,binwidth,"");
   
   if (binwidth <= 0 || binwidth > 1.e+39) {
      xmin = -1;
      xmax = 1;
   } else {
      xmin    = binlow;
      xmax    = binhigh;
   }
   if (isInteger) {
      Int_t ixmin = Int_t(xmin);
      Int_t ixmax = Int_t(xmax);
      Double_t dxmin = Double_t(ixmin);
      Double_t dxmax = Double_t(ixmax);
      if (xmin < 0 && xmin != dxmin) xmin = dxmin - 1;
      else                           xmin = dxmin;
      if (xmax > 0 && xmax != dxmax)      xmax = dxmax + 1;
      else if (xmax ==0 && xmax == dxmax) xmax = 1;
      else                                xmax = dxmax;
      if (xmin >= xmax) xmax = xmin+1;
      Int_t bw = Int_t((xmax-xmin)/nbins);
      if (bw == 0) bw = 1;
      nbins = Int_t((xmax-xmin)/bw);
      if (xmin +nbins*bw < umax) {nbins++; xmax = xmin +nbins*bw;}
      if (xmin > umin)           {nbins++; xmin = xmax -nbins*bw;}
   }
   newbins = nbins;
}
 THLimitsFinder.cxx:1
 THLimitsFinder.cxx:2
 THLimitsFinder.cxx:3
 THLimitsFinder.cxx:4
 THLimitsFinder.cxx:5
 THLimitsFinder.cxx:6
 THLimitsFinder.cxx:7
 THLimitsFinder.cxx:8
 THLimitsFinder.cxx:9
 THLimitsFinder.cxx:10
 THLimitsFinder.cxx:11
 THLimitsFinder.cxx:12
 THLimitsFinder.cxx:13
 THLimitsFinder.cxx:14
 THLimitsFinder.cxx:15
 THLimitsFinder.cxx:16
 THLimitsFinder.cxx:17
 THLimitsFinder.cxx:18
 THLimitsFinder.cxx:19
 THLimitsFinder.cxx:20
 THLimitsFinder.cxx:21
 THLimitsFinder.cxx:22
 THLimitsFinder.cxx:23
 THLimitsFinder.cxx:24
 THLimitsFinder.cxx:25
 THLimitsFinder.cxx:26
 THLimitsFinder.cxx:27
 THLimitsFinder.cxx:28
 THLimitsFinder.cxx:29
 THLimitsFinder.cxx:30
 THLimitsFinder.cxx:31
 THLimitsFinder.cxx:32
 THLimitsFinder.cxx:33
 THLimitsFinder.cxx:34
 THLimitsFinder.cxx:35
 THLimitsFinder.cxx:36
 THLimitsFinder.cxx:37
 THLimitsFinder.cxx:38
 THLimitsFinder.cxx:39
 THLimitsFinder.cxx:40
 THLimitsFinder.cxx:41
 THLimitsFinder.cxx:42
 THLimitsFinder.cxx:43
 THLimitsFinder.cxx:44
 THLimitsFinder.cxx:45
 THLimitsFinder.cxx:46
 THLimitsFinder.cxx:47
 THLimitsFinder.cxx:48
 THLimitsFinder.cxx:49
 THLimitsFinder.cxx:50
 THLimitsFinder.cxx:51
 THLimitsFinder.cxx:52
 THLimitsFinder.cxx:53
 THLimitsFinder.cxx:54
 THLimitsFinder.cxx:55
 THLimitsFinder.cxx:56
 THLimitsFinder.cxx:57
 THLimitsFinder.cxx:58
 THLimitsFinder.cxx:59
 THLimitsFinder.cxx:60
 THLimitsFinder.cxx:61
 THLimitsFinder.cxx:62
 THLimitsFinder.cxx:63
 THLimitsFinder.cxx:64
 THLimitsFinder.cxx:65
 THLimitsFinder.cxx:66
 THLimitsFinder.cxx:67
 THLimitsFinder.cxx:68
 THLimitsFinder.cxx:69
 THLimitsFinder.cxx:70
 THLimitsFinder.cxx:71
 THLimitsFinder.cxx:72
 THLimitsFinder.cxx:73
 THLimitsFinder.cxx:74
 THLimitsFinder.cxx:75
 THLimitsFinder.cxx:76
 THLimitsFinder.cxx:77
 THLimitsFinder.cxx:78
 THLimitsFinder.cxx:79
 THLimitsFinder.cxx:80
 THLimitsFinder.cxx:81
 THLimitsFinder.cxx:82
 THLimitsFinder.cxx:83
 THLimitsFinder.cxx:84
 THLimitsFinder.cxx:85
 THLimitsFinder.cxx:86
 THLimitsFinder.cxx:87
 THLimitsFinder.cxx:88
 THLimitsFinder.cxx:89
 THLimitsFinder.cxx:90
 THLimitsFinder.cxx:91
 THLimitsFinder.cxx:92
 THLimitsFinder.cxx:93
 THLimitsFinder.cxx:94
 THLimitsFinder.cxx:95
 THLimitsFinder.cxx:96
 THLimitsFinder.cxx:97
 THLimitsFinder.cxx:98
 THLimitsFinder.cxx:99
 THLimitsFinder.cxx:100
 THLimitsFinder.cxx:101
 THLimitsFinder.cxx:102
 THLimitsFinder.cxx:103
 THLimitsFinder.cxx:104
 THLimitsFinder.cxx:105
 THLimitsFinder.cxx:106
 THLimitsFinder.cxx:107
 THLimitsFinder.cxx:108
 THLimitsFinder.cxx:109
 THLimitsFinder.cxx:110
 THLimitsFinder.cxx:111
 THLimitsFinder.cxx:112
 THLimitsFinder.cxx:113
 THLimitsFinder.cxx:114
 THLimitsFinder.cxx:115
 THLimitsFinder.cxx:116
 THLimitsFinder.cxx:117
 THLimitsFinder.cxx:118
 THLimitsFinder.cxx:119
 THLimitsFinder.cxx:120
 THLimitsFinder.cxx:121
 THLimitsFinder.cxx:122
 THLimitsFinder.cxx:123
 THLimitsFinder.cxx:124
 THLimitsFinder.cxx:125
 THLimitsFinder.cxx:126
 THLimitsFinder.cxx:127
 THLimitsFinder.cxx:128
 THLimitsFinder.cxx:129
 THLimitsFinder.cxx:130
 THLimitsFinder.cxx:131
 THLimitsFinder.cxx:132
 THLimitsFinder.cxx:133
 THLimitsFinder.cxx:134
 THLimitsFinder.cxx:135
 THLimitsFinder.cxx:136
 THLimitsFinder.cxx:137
 THLimitsFinder.cxx:138
 THLimitsFinder.cxx:139
 THLimitsFinder.cxx:140
 THLimitsFinder.cxx:141
 THLimitsFinder.cxx:142
 THLimitsFinder.cxx:143
 THLimitsFinder.cxx:144
 THLimitsFinder.cxx:145
 THLimitsFinder.cxx:146
 THLimitsFinder.cxx:147
 THLimitsFinder.cxx:148
 THLimitsFinder.cxx:149
 THLimitsFinder.cxx:150
 THLimitsFinder.cxx:151
 THLimitsFinder.cxx:152
 THLimitsFinder.cxx:153
 THLimitsFinder.cxx:154
 THLimitsFinder.cxx:155
 THLimitsFinder.cxx:156
 THLimitsFinder.cxx:157
 THLimitsFinder.cxx:158
 THLimitsFinder.cxx:159
 THLimitsFinder.cxx:160
 THLimitsFinder.cxx:161
 THLimitsFinder.cxx:162
 THLimitsFinder.cxx:163
 THLimitsFinder.cxx:164
 THLimitsFinder.cxx:165
 THLimitsFinder.cxx:166
 THLimitsFinder.cxx:167
 THLimitsFinder.cxx:168
 THLimitsFinder.cxx:169
 THLimitsFinder.cxx:170
 THLimitsFinder.cxx:171
 THLimitsFinder.cxx:172
 THLimitsFinder.cxx:173
 THLimitsFinder.cxx:174
 THLimitsFinder.cxx:175
 THLimitsFinder.cxx:176
 THLimitsFinder.cxx:177
 THLimitsFinder.cxx:178
 THLimitsFinder.cxx:179
 THLimitsFinder.cxx:180
 THLimitsFinder.cxx:181
 THLimitsFinder.cxx:182
 THLimitsFinder.cxx:183
 THLimitsFinder.cxx:184
 THLimitsFinder.cxx:185
 THLimitsFinder.cxx:186
 THLimitsFinder.cxx:187
 THLimitsFinder.cxx:188
 THLimitsFinder.cxx:189
 THLimitsFinder.cxx:190
 THLimitsFinder.cxx:191
 THLimitsFinder.cxx:192
 THLimitsFinder.cxx:193
 THLimitsFinder.cxx:194
 THLimitsFinder.cxx:195
 THLimitsFinder.cxx:196
 THLimitsFinder.cxx:197
 THLimitsFinder.cxx:198
 THLimitsFinder.cxx:199
 THLimitsFinder.cxx:200
 THLimitsFinder.cxx:201
 THLimitsFinder.cxx:202
 THLimitsFinder.cxx:203
 THLimitsFinder.cxx:204
 THLimitsFinder.cxx:205
 THLimitsFinder.cxx:206
 THLimitsFinder.cxx:207
 THLimitsFinder.cxx:208
 THLimitsFinder.cxx:209
 THLimitsFinder.cxx:210
 THLimitsFinder.cxx:211
 THLimitsFinder.cxx:212
 THLimitsFinder.cxx:213
 THLimitsFinder.cxx:214
 THLimitsFinder.cxx:215
 THLimitsFinder.cxx:216
 THLimitsFinder.cxx:217
 THLimitsFinder.cxx:218
 THLimitsFinder.cxx:219
 THLimitsFinder.cxx:220
 THLimitsFinder.cxx:221
 THLimitsFinder.cxx:222
 THLimitsFinder.cxx:223
 THLimitsFinder.cxx:224
 THLimitsFinder.cxx:225
 THLimitsFinder.cxx:226
 THLimitsFinder.cxx:227
 THLimitsFinder.cxx:228
 THLimitsFinder.cxx:229
 THLimitsFinder.cxx:230
 THLimitsFinder.cxx:231
 THLimitsFinder.cxx:232
 THLimitsFinder.cxx:233
 THLimitsFinder.cxx:234
 THLimitsFinder.cxx:235
 THLimitsFinder.cxx:236
 THLimitsFinder.cxx:237
 THLimitsFinder.cxx:238
 THLimitsFinder.cxx:239
 THLimitsFinder.cxx:240
 THLimitsFinder.cxx:241
 THLimitsFinder.cxx:242
 THLimitsFinder.cxx:243
 THLimitsFinder.cxx:244
 THLimitsFinder.cxx:245
 THLimitsFinder.cxx:246
 THLimitsFinder.cxx:247
 THLimitsFinder.cxx:248
 THLimitsFinder.cxx:249
 THLimitsFinder.cxx:250
 THLimitsFinder.cxx:251
 THLimitsFinder.cxx:252
 THLimitsFinder.cxx:253
 THLimitsFinder.cxx:254
 THLimitsFinder.cxx:255
 THLimitsFinder.cxx:256
 THLimitsFinder.cxx:257
 THLimitsFinder.cxx:258
 THLimitsFinder.cxx:259
 THLimitsFinder.cxx:260
 THLimitsFinder.cxx:261
 THLimitsFinder.cxx:262
 THLimitsFinder.cxx:263
 THLimitsFinder.cxx:264
 THLimitsFinder.cxx:265
 THLimitsFinder.cxx:266
 THLimitsFinder.cxx:267
 THLimitsFinder.cxx:268
 THLimitsFinder.cxx:269
 THLimitsFinder.cxx:270
 THLimitsFinder.cxx:271
 THLimitsFinder.cxx:272
 THLimitsFinder.cxx:273
 THLimitsFinder.cxx:274
 THLimitsFinder.cxx:275
 THLimitsFinder.cxx:276
 THLimitsFinder.cxx:277
 THLimitsFinder.cxx:278
 THLimitsFinder.cxx:279
 THLimitsFinder.cxx:280
 THLimitsFinder.cxx:281
 THLimitsFinder.cxx:282
 THLimitsFinder.cxx:283
 THLimitsFinder.cxx:284
 THLimitsFinder.cxx:285
 THLimitsFinder.cxx:286
 THLimitsFinder.cxx:287
 THLimitsFinder.cxx:288
 THLimitsFinder.cxx:289
 THLimitsFinder.cxx:290
 THLimitsFinder.cxx:291
 THLimitsFinder.cxx:292
 THLimitsFinder.cxx:293
 THLimitsFinder.cxx:294
 THLimitsFinder.cxx:295
 THLimitsFinder.cxx:296
 THLimitsFinder.cxx:297
 THLimitsFinder.cxx:298
 THLimitsFinder.cxx:299
 THLimitsFinder.cxx:300
 THLimitsFinder.cxx:301
 THLimitsFinder.cxx:302
 THLimitsFinder.cxx:303
 THLimitsFinder.cxx:304
 THLimitsFinder.cxx:305
 THLimitsFinder.cxx:306
 THLimitsFinder.cxx:307
 THLimitsFinder.cxx:308
 THLimitsFinder.cxx:309
 THLimitsFinder.cxx:310
 THLimitsFinder.cxx:311
 THLimitsFinder.cxx:312
 THLimitsFinder.cxx:313
 THLimitsFinder.cxx:314
 THLimitsFinder.cxx:315
 THLimitsFinder.cxx:316
 THLimitsFinder.cxx:317
 THLimitsFinder.cxx:318
 THLimitsFinder.cxx:319
 THLimitsFinder.cxx:320
 THLimitsFinder.cxx:321
 THLimitsFinder.cxx:322
 THLimitsFinder.cxx:323
 THLimitsFinder.cxx:324
 THLimitsFinder.cxx:325
 THLimitsFinder.cxx:326
 THLimitsFinder.cxx:327
 THLimitsFinder.cxx:328
 THLimitsFinder.cxx:329
 THLimitsFinder.cxx:330
 THLimitsFinder.cxx:331
 THLimitsFinder.cxx:332
 THLimitsFinder.cxx:333
 THLimitsFinder.cxx:334
 THLimitsFinder.cxx:335
 THLimitsFinder.cxx:336
 THLimitsFinder.cxx:337
 THLimitsFinder.cxx:338
 THLimitsFinder.cxx:339
 THLimitsFinder.cxx:340
 THLimitsFinder.cxx:341
 THLimitsFinder.cxx:342
 THLimitsFinder.cxx:343
 THLimitsFinder.cxx:344
 THLimitsFinder.cxx:345
 THLimitsFinder.cxx:346
 THLimitsFinder.cxx:347
 THLimitsFinder.cxx:348
 THLimitsFinder.cxx:349
 THLimitsFinder.cxx:350
 THLimitsFinder.cxx:351
 THLimitsFinder.cxx:352
 THLimitsFinder.cxx:353
 THLimitsFinder.cxx:354
 THLimitsFinder.cxx:355
 THLimitsFinder.cxx:356
 THLimitsFinder.cxx:357
 THLimitsFinder.cxx:358
 THLimitsFinder.cxx:359
 THLimitsFinder.cxx:360
 THLimitsFinder.cxx:361
 THLimitsFinder.cxx:362
 THLimitsFinder.cxx:363
 THLimitsFinder.cxx:364
 THLimitsFinder.cxx:365
 THLimitsFinder.cxx:366
 THLimitsFinder.cxx:367
 THLimitsFinder.cxx:368
 THLimitsFinder.cxx:369
 THLimitsFinder.cxx:370
 THLimitsFinder.cxx:371
 THLimitsFinder.cxx:372
 THLimitsFinder.cxx:373
 THLimitsFinder.cxx:374
 THLimitsFinder.cxx:375
 THLimitsFinder.cxx:376
 THLimitsFinder.cxx:377
 THLimitsFinder.cxx:378
 THLimitsFinder.cxx:379
 THLimitsFinder.cxx:380
 THLimitsFinder.cxx:381
 THLimitsFinder.cxx:382
 THLimitsFinder.cxx:383
 THLimitsFinder.cxx:384
 THLimitsFinder.cxx:385
 THLimitsFinder.cxx:386
 THLimitsFinder.cxx:387
 THLimitsFinder.cxx:388
 THLimitsFinder.cxx:389
 THLimitsFinder.cxx:390
 THLimitsFinder.cxx:391
 THLimitsFinder.cxx:392
 THLimitsFinder.cxx:393
 THLimitsFinder.cxx:394
 THLimitsFinder.cxx:395
 THLimitsFinder.cxx:396
 THLimitsFinder.cxx:397
 THLimitsFinder.cxx:398