SetOfH.h

Go to the documentation of this file.

#ifndef __SETOFH_H
#define __SETOFH_H

#include "jbltools/sfh/ROList.h"

#include "jbltools/sfh/BinningFunPoR.h"
#include "jbltools/sfh/Binning.h"

#include <Rtypes.h> // for Option_t


class BinningFun;
class TH1;

// Class SetOfH

class SetOfH: public ROList {
  public:
    SetOfH (const char* name_,               
            const char* title_,              
            const ROListPoR& hhl,            
            const BinningFunPoR& binning1_,  
            Option_t* option_ = 0            
           );
    SetOfH (const char* name_,               
            const char* title_,              
            const ROListPoR& hhl,            
            const BinningFunPoR& binning1_,  
            const BinningFunPoR& binning2_,  
            Option_t* option_ = 0            
           );
    virtual ~SetOfH ();
    
    TH1 *getHisto (unsigned int i                   
                   );
    
    
    // Functions from THProfile
    virtual void Divide(TF1* f1,              
                        Double_t c1 = 1       
                       );
    virtual void Divide(const TH1* h1         
                        );

    virtual void Divide(const TH1* h1,        
                        const TH1* h2,        
                        Double_t c1 = 1,      
                        Double_t c2 = 1,      
                        Option_t* option = 0  
                        );
             
    virtual void Divide(const SetOfH *soh  
                        );
    virtual void Divide(const SetOfH *soh1, 
                        const SetOfH *soh2, 
                        Double_t c1 = 1,             
                        Double_t c2 = 1,             
                        Option_t *option = 0         
                        );
                        
                        

    virtual void Divide(const SetOfH *soh1,          
                        const SetOfH *soh2,          
                        const SetOfH *soh3,          
                        Double_t c1 = 1,             
                        Double_t c2 = 1              
                        );

    virtual void Multiply(TF1 *f1,                   
                          Double_t c1 = 1            
                         );
    virtual void Multiply(const TH1 *h1              
                          );                         


    virtual void Multiply(const TH1 *h1,              
                          const TH1 *h2,              
                          Double_t c1 = 1,            
                          Double_t c2 = 1,            
                          Option_t* option = 0        
                          );
             
    virtual void Multiply(const SetOfH *soh       
                          );
    virtual void Multiply(const SetOfH *soh1,      
                          const SetOfH *soh2,      
                          Double_t c1 = 1,             
                          Double_t c2 = 1,             
                          Option_t *option = 0         
                          );


    virtual void Add (const SetOfH *soh,           
                      Double_t c1 = 1                  
                      );
    
    virtual const char *genBinTitle (IndexType i    
                                    ) const;
    virtual const char *genBinName (IndexType i     
                                   ) const;
    
    inline const char *getTitle () const;
    inline const char *getName () const;
    inline const char *getOption () const;
    inline const BinningFun *getBinning () const;
    inline       BinningFun *getBinning ();
    inline const BinningFun *getBinning (int i     
                                        ) const;
    inline       BinningFun *getBinning (int i     
                                        );
    virtual void initHisto (IndexType i    
                            ) = 0; 
   
       
  private:
    // Data members
    char *name;                       
    char *title;                      
    BinningFun *binning1;             
    BinningFun *binning2;             
    BinningFun *binning3;             
    char *option;                     
    
  protected:
    virtual void initHistos ();           
  private:
    void init (const char* name_,     
               const char* title_,    
               Option_t *option_      
               );
    SetOfH (const SetOfH& source);
    SetOfH& operator= (const SetOfH& source);
};

// Implementation of inline methods

const char *SetOfH::getTitle () const {
  return title;
}

const char *SetOfH::getName () const {
  return name;
}

const char *SetOfH::getOption () const {
  return name;
}

const BinningFun *SetOfH::getBinning () const {
  return binning1;
}

BinningFun *SetOfH::getBinning () {
  return binning1;
}

const BinningFun *SetOfH::getBinning (int i) const {
  switch (i) {
    case 1: return binning1; break;
    case 2: return binning2; break;
    case 3: return binning3; break;
  }
  return 0;
}

BinningFun *SetOfH::getBinning (int i) {
  switch (i) {
    case 1: return binning1; break;
    case 2: return binning2; break;
    case 3: return binning3; break;
  }
  return 0;
}

#endif

---