HTool

class HTool : public TNamed

    protected:

      void initVariables()

    public:

                           HTool(const char* name, const char* title)
                           HTool(const HTool&)
                           ~HTool()
        static TDirectory* changeToDir(TString)
             static Bool_t checkDir(TString, TFile*)
            static TClass* Class()
               static void cleanHist(TH1* h, Double_t threshold = 3, Double_t val = 0)
               static TF1* cleanHistArroundLine(TH2* h, TF1* f = 0, TString axis = y, Int_t firstbin = 1, Int_t lastbin = 0, Int_t cut = 0, TString opt = QNR, TString suffix, TString optline = pol1, Float_t windowfunc = 1000., Float_t windowfunc2 = 1000.)
               static TF1* cleanHistBelowLine(TH2* h, TF1* f = 0, TString axis = y, Int_t firstbin = 1, Int_t lastbin = 0, Int_t cut = 0, TString opt = QNR, TString suffix, TString optline = pol1, Float_t windowfunc = 1000.)
             static Bool_t cleanHistCutG(TH2* = 0, TCutG* = 0)
             static Bool_t close(TFile**)
             static Bool_t closeAscii(FILE**)
             static Bool_t compHistFiles(TString nameinp1, TString nameinp2, TString name)
               static TH1* copyHist(TH1* h, TString name, Int_t val = -99, Int_t valerr = -99)
               static TH1* copyHistRange(TH1* h, TString name, Int_t val = -99, Int_t valerr = -99, Int_t start = 0, Int_t end = -99)
               static void deleteObject(TObject* h)
             static Bool_t drawHistComp(TString nameinp1, TString nameinp2, TString name, TCanvas* comp = 0, Int_t padn = 1)
               static TH2* exchangeXY(TH2* h2 = 0, TString newname)
             static Bool_t exchangeXYGraph(TGraph* g = 0)
              static Int_t exec(TString command, TString& output)
              static Int_t findFilledRange(TH1* h, Int_t& first, Int_t& last)
             static Bool_t findString(TString* classes, Int_t size, TString name)
         static TObjArray* fitArray(TObjArray* array = 0, TF1* fit = 0, TString name, Float_t min = 0, Float_t max = 0, Int_t opt = 0, Float_t x1 = 0, Float_t x2 = 0, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
             static Bool_t fitScatter(TH2* h = 0, TF1* f = 0, TH1* hnorm = 0, TString opt = QNR, Float_t xmin = 0, Float_t xmax = 0, Float_t ymin = 0, Float_t ymax = 0, Float_t window = 0, Bool_t clean = kFALSE)
             static Bool_t flipAxis(TH2* h2 = 0, TString opt = x)
               static TH1* getHist(TFile* inp, TString name)
             static TList* getListOfAllDataMembers(TClass* cl)
           static Double_t getMaxHistArray(TH1** h, Int_t size, Int_t& index)
           static Double_t getMinHistArray(TH1** h, Int_t size, Int_t& index)
         static TObjArray* glob(TString pattern)
            static TGraph* histToGraph(TH1* h = 0, TString newname, Bool_t exchange = kFALSE, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
      static TGraphErrors* histToGraphErrors(TH1* h = 0, TString newname, Bool_t exchange = kFALSE, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
           virtual TClass* IsA() const
           static Double_t kurtosis(Int_t n, Short_t* data)
           static Double_t kurtosis(Int_t n, Int_t* data)
           static Double_t kurtosis(Int_t n, Float_t* data)
           static Double_t kurtosis(Int_t n, Double_t* data)
             static Bool_t makeHists(TString infile, Int_t evs = 0, TString histdescriptionfile, TString listofClasses)
        static TDirectory* Mkdir(TDirectory*, const Char_t*, Int_t, Int_t p = 1)
              static Int_t normalize_max(TH2* h2 = 0, TString axis = y)
             static Bool_t open(TFile**, TString, TString)
             static Bool_t openAscii(FILE**, TString, TString)
                    HTool& operator=(const HTool&)
           static TString* parseString(TString options, Int_t& size, TString separator, Bool_t tolower = kTRUE)
             static Bool_t printCompHistInfo(TH1* h1 = 0, TH1* h2 = 0, Int_t detail = 0)
             static Bool_t printHistInfo(TH1* h1 = 0)
         static TObjArray* projections(TH2* h2, TString axis = y, Int_t firstbin = 0, Int_t lastbin = -1, Int_t nsteps = -99, TString opt = e, TString suffix, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
              static TH1D* projectY(TH1* h = 0, Int_t xbin1 = 1, Int_t xbin2 = 0, TString suff, Int_t ybin = 0, Float_t ymin = -99, Float_t ymax = -99, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
             static Bool_t readHistsDescription(TString file, TObjArray* myhists, TString* classes = 0, Int_t sizeclass = 0)
               static TH2* reBin(TH2* h2 = 0, Int_t groupX = 2, Int_t gropY = 2, TString newname)
              static Int_t removeEnds(TH1* h, Int_t first = 1, Int_t last = -1)
               static void resetHist(TH1* h, Float_t val = -99, Float_t valerr = -99)
           static Double_t roundDigits(Double_t d, Int_t ndigits = -1)
            static Float_t roundDigits(Float_t f, Int_t ndigits = -1)
               static void roundHist(TH2* h = 0, Int_t ndigit = -1, Int_t ndigiterr = -1)
             static Bool_t scaleGraph(TGraph* g = 0, Double_t xscale = 1., Double_t yscale = 1.)
               static void scanOracle(TString, TString)
               static void setHistErrors(TH1* h, TH1* h2)
             static Bool_t shiftGraph(TGraph* g = 0, Double_t xshift = 0., Double_t yshift = 0.)
             static Bool_t shiftHist(TH1* h = 0, Float_t shift = 0)
             static Bool_t shiftHistByBin(TH1* h = 0, Int_t shiftbin = 0)
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
           static Double_t skew(Int_t n, Short_t* data)
           static Double_t skew(Int_t n, Int_t* data)
           static Double_t skew(Int_t n, Float_t* data)
           static Double_t skew(Int_t n, Double_t* data)
         static TObjArray* slices(TH2* h = 0, TF1* f = 0, TString axis = y, Int_t firstbin = 1, Int_t lastbin = 0, Int_t cut = 0, TString opt = QNR, TString suffix, Int_t markerstyle = 8, Int_t markercolor = 2, Float_t markersize = 0.7)
               static void sort(Int_t n, Char_t* arr, Int_t* index = 0, Bool_t down = kTRUE, Bool_t overwrite = kTRUE)
               static void sort(Int_t n, Short_t* arr, Int_t* index = 0, Bool_t down = kTRUE, Bool_t overwrite = kTRUE)
               static void sort(Int_t n, Int_t* arr, Int_t* index = 0, Bool_t down = kTRUE, Bool_t overwrite = kTRUE)
               static void sort(Int_t n, Float_t* arr, Int_t* index = 0, Bool_t down = kTRUE, Bool_t overwrite = kTRUE)
               static void sort(Int_t n, Double_t* arr, Int_t* index = 0, Bool_t down = kTRUE, Bool_t overwrite = kTRUE)
               static void sortParallel(Int_t n, Int_t nArrays, Char_t* listarr, Int_t leading = 0, Int_t* index = 0, Bool_t down = kTRUE)
               static void sortParallel(Int_t n, Int_t nArrays, Short_t* listarr, Int_t leading = 0, Int_t* index = 0, Bool_t down = kTRUE)
               static void sortParallel(Int_t n, Int_t nArrays, Int_t* listarr, Int_t leading = 0, Int_t* index = 0, Bool_t down = kTRUE)
               static void sortParallel(Int_t n, Int_t nArrays, Float_t* listarr, Int_t leading = 0, Int_t* index = 0, Bool_t down = kTRUE)
               static void sortParallel(Int_t n, Int_t nArrays, Double_t* listarr, Int_t leading = 0, Int_t* index = 0, Bool_t down = kTRUE)
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
           static Double_t weightedMean(Int_t n, Short_t* data, Short_t* dataerr)
           static Double_t weightedMean(Int_t n, Int_t* data, Int_t* dataerr)
           static Double_t weightedMean(Int_t n, Float_t* data, Float_t* dataerr)
           static Double_t weightedMean(Int_t n, Double_t* data, Double_t* dataerr)
           static Double_t weightedMeanAndSigma(Int_t n, Short_t* data, Short_t* dataerr, Double_t* mean, Double_t* sigma)
           static Double_t weightedMeanAndSigma(Int_t n, Int_t* data, Int_t* dataerr, Double_t* mean, Double_t* sigma)
           static Double_t weightedMeanAndSigma(Int_t n, Float_t* data, Float_t* dataerr, Double_t* mean, Double_t* sigma)
           static Double_t weightedMeanAndSigma(Int_t n, Double_t* data, Double_t* dataerr, Double_t* mean, Double_t* sigma)
           static Double_t weightedSigma(Int_t n, Short_t* dataerr)
           static Double_t weightedSigma(Int_t n, Int_t* dataerr)
           static Double_t weightedSigma(Int_t n, Float_t* dataerr)
           static Double_t weightedSigma(Int_t n, Double_t* dataerr)
             static Bool_t writeHistInfo(TH1* h1 = 0, FILE* anaout = 0)
               static void writeObject(TObject* h)

Data Members

Class Description

 HTool
 Tool Class

 constructor for HTool

 destructor of HTool

 inits all variables

 Opens root file "fName" to the pointer "file" with option
 New,Read,Recreate and Update. Checks if file exists or is
 already opened. If everything works fine kTRUE is returned.

 Close the root file of the pointer file if
 existing and open and sets the file pointer to 0.
 Returns kTRUE if OK.

 Opens ascii file "fName" to the pointer file with the option
 "r" and "w". Returns kTRUE if OK.

 Close ascii file of the pointer file if file!=0 and
 sets the file pointr to 0 afterwards. Returns kTRUE
 if OK.

 Expand 'pattern' as it would be done by the shell (see sh(1)):
 '*', '?', '~', '$ENVIRONMENT_VARIABLE' and '[', ']' are expanded. In case
 the expansion is successful, a TObjArray of TObjStrings with the
 names of all existing files is returned - otherwise NULL.

 The returned TObjArray must be deleted by the caller of the function!

 This example returns all existing .root files in /tmp as well as all .root
 files in your home directory starting with the characters 'a', 'b', 'c'
 and 'e':

 TObjArray* files = HTool::glob( "/tmp/*.root $HOME/[a-c,e]*.root" );
 if (files)
 {
    TObjString* name = NULL;
    TIterator*  file = files->MakeIterator();
    while ((name = (TObjString*)file->Next()))
    {
       Char_t* input = name->GetString.Data(); ...
    }
    delete files;
 }

 Function to create subdirectories, where dirold is the pointer of the old Directory,
 "c" the name of the new Directory an "i" the number (c + i) of the directory."p" gives
 the formating number of digits filled with 0. If "i"==-99 the numbering part is skipped.
 Checks if the Directrory exists , if so changes into otherwise create it new. The
 pointer to the new Directory is returned.

 Changes into the given path. If the Directory is not existing
 it will be created. The pointer to the new directory will be returned.

 Checks if a given path "p" in file "input" exists.
 The actual directory will not be changed. Returns
 kTRUE if OK.

 return a list of all data members of a class.
 contains all data members of bass classes.

 scans oracle runs table source code to extract
 file names, run ids and number of events

 Round d to ndigits

 Round d to ndigits

 Execute 'command' in a shell and return the exit code of 'command'.
 'output' is filled with the data written to STDOUT and STDERR by
 'command'.

 sorts array arrIn. If down=kTRUE sort in decreasing order.
 If overwrite=kTRUE input array is sorted otherwise not and
 the result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts array arrIn. If down=kTRUE sort in decreasing order.
 If overwrite=kTRUE input array is sorted otherwise not and
 the result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts array arrIn. If down=kTRUE sort in decreasing order.
 If overwrite=kTRUE input array is sorted otherwise not and
 the result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts array arrIn. If down=kTRUE sort in decreasing order.
 If overwrite=kTRUE input array is sorted otherwise not and
 the result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts array arrIn. If down=kTRUE sort in decreasing order.
 If overwrite=kTRUE input array is sorted otherwise not and
 the result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts n arrays arrIn paralell (destruktive!). Array pointer arrIn[leading] will be the
 leading one. The other arrays will be sorted according to the reordering of the leading array.
 If down=kTRUE sort in decreasing order.
 The result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts n arrays arrIn paralell (destruktive!). Array pointer arrIn[leading] will be the
 leading one. The other arrays will be sorted according to the reordering of the leading array.
 If down=kTRUE sort in decreasing order.
 The result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts n arrays arrIn paralell (destruktive!). Array pointer arrIn[leading] will be the
 leading one. The other arrays will be sorted according to the reordering of the leading array.
 If down=kTRUE sort in decreasing order.
 The result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts n arrays arrIn paralell (destruktive!). Array pointer arrIn[leading] will be the
 leading one. The other arrays will be sorted according to the reordering of the leading array.
 If down=kTRUE sort in decreasing order.
 The result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 sorts n arrays arrIn paralell (destruktive!). Array pointer arrIn[leading] will be the
 leading one. The other arrays will be sorted according to the reordering of the leading array.
 If down=kTRUE sort in decreasing order.
 The result can be obtained from the index array (has to be provided
 by the caller with size >=n ) If index=NULL the index array is not used.
 if index=NULL and overwrite=kFALSE the function returns
 without doing anything.

 calculates the kurtosis

   ---                     
                          
   /   ( x-mean)^4         
   ---                     
  ----------------  - 3    
       n*sigma^4           


 The kutosis will be > 0 for distributions
 compared wider than a normal distribution and
 and < 0 for distributions beeing peaking stronger

 calculates the kurtosis

   ---                     
                          
   /   ( x-mean)^4         
   ---                     
  ----------------  - 3    
       n*sigma^4           


 The kutosis will be > 0 for distributions
 compared wider than a normal distribution and
 and < 0 for distributions beeing peaking stronger

 calculates the kurtosis

   ---                     
                          
   /   ( x-mean)^4         
   ---                     
  ----------------  - 3    
       n*sigma^4           


 The kutosis will be > 0 for distributions
 compared wider than a normal distribution and
 and < 0 for distributions beeing peaking stronger

 calculates the kurtosis

   ---                     
                          
   /   ( x-mean)^4         
   ---                     
  ----------------  - 3    
       n*sigma^4           


 The kutosis will be > 0 for distributions
 compared wider than a normal distribution and
 and < 0 for distributions beeing peaking stronger

 calculates the skew

   ---                     
                          
   /   ( x-mean)^3         
   ---                     
  ----------------         
       n*sigma^3           


 The skew will be > 0 for distributions
 haveing more entries in the tails larger than mean
 and < 0 for distributions haveing more entries small
 than mean

 calculates the skew

   ---                     
                          
   /   ( x-mean)^3         
   ---                     
  ----------------         
       n*sigma^3           


 The skew will be > 0 for distributions
 haveing more entries in the tails larger than mean
 and < 0 for distributions haveing more entries small
 than mean

 calculates the skew

   ---                     
                          
   /   ( x-mean)^3         
   ---                     
  ----------------         
       n*sigma^3           


 The skew will be > 0 for distributions
 haveing more entries in the tails larger than mean
 and < 0 for distributions haveing more entries small
 than mean

 calculates the skew

   ---                     
                          
   /   ( x-mean)^3         
   ---                     
  ----------------         
       n*sigma^3           


 The skew will be > 0 for distributions
 haveing more entries in the tails larger than mean
 and < 0 for distributions haveing more entries small
 than mean

 calculates the weighted mean

   ---                     
                          
   /   x/sigma^2           
   ---                     
  ----------------         
   ---                     
                          
   /   1/sigma^2           
   ---                     

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 calculates the weighted mean

   ---                     
                          
   /   x/sigma^2           
   ---                     
  ----------------         
   ---                     
                          
   /   1/sigma^2           
   ---                     

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 calculates the weighted mean

   ---                     
                          
   /   x/sigma^2           
   ---                     
  ----------------         
   ---                     
                          
   /   1/sigma^2           
   ---                     

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 calculates the weighted mean

   ---                     
                          
   /   x/sigma^2           
   ---                     
  ----------------         
   ---                     
                          
   /   1/sigma^2           
   ---                     

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 calculates the weighted sigma

             1                  
sqrt  ----------------          
        ---                     
                               
        /   1/sigma^2           
        ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted sigma

             1                  
sqrt  ----------------          
        ---                     
                               
        /   1/sigma^2           
        ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted sigma

             1                  
sqrt  ----------------          
        ---                     
                               
        /   1/sigma^2           
        ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted sigma

             1                  
sqrt  ----------------          
        ---                     
                               
        /   1/sigma^2           
        ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted mean and sigma

         ---                    
                               
         /   x/sigma^2          
         ---                    
 mean = ----------------        
         ---                    
                               
         /   1/sigma^2          
         ---                    

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 and

                     1                  
sigma = sqrt  ----------------          
                ---                     
                                       
                /   1/sigma^2           
                ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted mean and sigma

         ---                    
                               
         /   x/sigma^2          
         ---                    
 mean = ----------------        
         ---                    
                               
         /   1/sigma^2          
         ---                    

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 and

                     1                  
sigma = sqrt  ----------------          
                ---                     
                                       
                /   1/sigma^2           
                ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted mean and sigma

         ---                    
                               
         /   x/sigma^2          
         ---                    
 mean = ----------------        
         ---                    
                               
         /   1/sigma^2          
         ---                    

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 and

                     1                  
sigma = sqrt  ----------------          
                ---                     
                                       
                /   1/sigma^2           
                ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 calculates the weighted mean and sigma

         ---                    
                               
         /   x/sigma^2          
         ---                    
 mean = ----------------        
         ---                    
                               
         /   1/sigma^2          
         ---                    

 where x are the data points from data[i] and
 sigma the standard deviations of the points from dataerr[i]

 and

                     1                  
sigma = sqrt  ----------------          
                ---                     
                                       
                /   1/sigma^2           
                ---                     

 where sigma is the standard deviations of the
 points from dataerr[i]

 Round bin content to ndigit and binerror to ndigterr digits.
 for ndigit or ndigiterr =-1 the rounding will be skipped for
 the corresponding value.

 gets histogram with name name from root file

 calls internal the fitslice of root. Suffix can be added to name of fitted hists.
 Returns a TObjArray pointer to an array containing the result hists of the fit.
 Numbering is the same as the the parameters of the fitfunction + chi2 at last place.

 calls internal the projections function of the hist.
 Suffix can be added to name of fitted hists.
 Returns a TObjArray pointer to an array containing
 the result hists of the loop of projections.

 Applies fit fit to all hists in array. The result of the fit
 will be returned in a TObjArray which contains hists for all parameters
 from fit (with corresponding errors set). The number of hists is equal npar+1.
 The ordering inside the array starts from par0 to parN and the last hist
 will contain the chi2. The number of bins in the hists will be equal to the
 the number of fitted hists. The range of the result hists can be set via
 min and max. If these values ar not specified the range will be 0-1.
 If opt=1 fit will use range x1 x2 arround max of hists

 removes bins from start to first and from last to end
 (first and last are kept). returns hist with name newname

 removes bins from start to first and from last to end
 (first and last are kept). returns hist with name newname

 find first bins and last filled bins

 clean hist if bincontent is below a certain value (threshold):
 The bin content is replaced by val.

 reset hist with val for content and valerr for errors
 (if this values not equal -99).

 copy old hist into new one. You can decide to copy content of hist (val!=-99) and
 errors (valerr!=-99). Combinations are possible.
 if no new name is specified, _copy is appended to old name.

 copy old hist into new one. You can decide to copy content of hist (val!=-99) and
 errors (valerr!=-99). Combinations are possible.
 if no new name is specified, _copy is appended to old name.
 Copy is done in range from start to end. If end = -99, Full histogram is copied.

 beforms slices HTool::operation and fits the result with a line
 Resets the bins blow line equation - windowfunc to 0.

 beforms slices HTool::operation and fits the result with a line
 Resets the bins arround line equation +- windowfunc to 0.

 puts all bins outside the cut to 0.

 sets bincontent of hist h2 as errors of h

 Finds maximum of all hists in TH1* array of size size.
 return max and the index of the hist inside the array
 which has the highest max.

 Finds minimum of all hists in TH1* array of size size.
 return min and the index of the hist inside the array
 which has the lowest min.

 Rebins h2 with groups of groupX and groupY. The new created
 hist with name newname (if specified) or oldname_rebin will
 be returned.

 creates new hist with name newname (if specified)
 or oldname_exchangeXY with exchanged
 x- and y-axis

 flips x or y axis or both depending on opt (x,y,xy)

 Creates a TGraph from hist h. The axis can be excganged if
 exchange=kTRUE; The Graph does not take empty bins into account.

 Creates a TGraphErrors from hist h. The axis can be excganged if
 exchange=kTRUE; The Graph does not take empty bins into account.

 shifts hist content by shiftbin bins

 shifts hist content by value shift

 Project to axis and and calc scaling factor for the bin
 to maximum of total hist max_total/max_proj. The bins of
 the hist are scaled by the factor. The result is 2D hist
 where each bin Projection has the same maximum height.
 The opration is performed on the original Hist!
 arguments:
 TH2* ht        :pointer to hist which should be normalized
 TString axis   :="x" , or "y" depending on the projection
 return values:
 -1 : In the case of zero pointer input or unknown axis argument
  0 : If opreation has been succesful
  3 : TH2 max is 0 (most probably empty).

 exchanges x-values and y-values.

 scales x-values and y-values with  xscale,yscale.

 add shift to x-values and y-values

 loops over TString options and find substrings separated by separator
 and puts them to an array of TStrings. size will hold the size of this
 array and the pointer to the array is returned. If tolower is kTRUE options
 will be made toLower.

 searches name in TString array classes with size size.
 return kTRUE if the string is found.

 reads the hist descriptions from ascii file file.
 Creates the hists found in TString array classes
 with size size and adds them to TObjArray myhists.

 makeHists(TString infile,Int_t evs,TString histdescriptionfile,TString listofClasses)
 Takes all categories in infile and generates generic histograms of all datamembers.
 T->Draw() is used to fill the hists. evs is the number of entries to loop over. if evs=0
 the full size of the tree will be used.
 INPUT:
 histdescriptionfile is the file with description of the histograms to fill (ascii).
 if histdescriptionfile=="" histograms will be filled generic and a histdescription file
 histDescription.txt will be generated in the working directory.
 listofClasses contains a list of Classes which should be taken into account, all other
 classes will be ignored. if listofClasses=="" all classes in infile will be taken.
 OUTPUT:
 I.   a root file treeHists.root will be generated which contains all histograms of the
      selected variables
 II.  if histdescriptionfile has been empty an ascii file treeHistDescription.txt will
      be generated in the working directory.
 III. an ascii file treeHistResults.txt with the analysis results of the hists will be created,
      which can be used for diff of different files.

 Gets histogram with name name from 2 input files and plots them into
 into a canvas. If the canvas pointer is 0 a canvas will be created.
 if padn=1 they will be overlayed in on pad, if pad=2 and comp=0, a
 new canvas with n pads will be created and the 2 hists will be plotted single
 if n=2 and comp not equal 0, the 2 pads of comp will used to draw.

 Gets histogram with name name from 2 input files and compares them by
 mean,rms,range,maximum,maxposition, entries....

 prints information over hist to screen .

 prints information over hist to screen .

 writes information over hist to ascii file .

Inline Functions

               void deleteObject(TObject* h)
               void writeObject(TObject* h)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
              HTool HTool(const HTool&)
             HTool& operator=(const HTool&)