AliHistogramRanges.h

Go to the documentation of this file.

#ifndef ALIHISTOGRAMRANGES_H
#define ALIHISTOGRAMRANGES_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */

//_________________________________________________________________________
//_________________________________________________________________________

// ROOT
#include <TObject.h>

class AliHistogramRanges : public TObject {
  
public:   
  
  AliHistogramRanges() ;              // default ctor
  virtual ~AliHistogramRanges() { ; } // dtor
  
  void InitParameters() ;
  
  void Print(const Option_t * ) const ;
  
  //Pt, Energy 
  
  Int_t   GetHistoPtBins()              const { return fHistoPtBins          ; }
  Float_t GetHistoPtMin()               const { return fHistoPtMin           ; }
  Float_t GetHistoPtMax()               const { return fHistoPtMax           ; }
  
  void    SetHistoPtRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoPtBins         = n ; fHistoPtMax         = max ; fHistoPtMin         = min ; }
  
  Int_t   GetHistoEnergyBins()          const { return fHistoPtBins          ; }
  Float_t GetHistoEnergyMin()           const { return fHistoPtMin           ; }
  Float_t GetHistoEnergyMax()           const { return fHistoPtMax           ; }
  
  void    SetHistoEnergyRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    SetHistoPtRangeAndNBins(min, max, n) ; }
  
  Int_t   GetHistoFinePtBins()          const { return fHistoFinePtBins      ; }
  Float_t GetHistoFinePtMin()           const { return fHistoFinePtMin       ; }
  Float_t GetHistoFinePtMax()           const { return fHistoFinePtMax       ; }  
  
  void SetHistoFinePtRangeAndNBins      (Float_t min, Float_t max, Int_t n) {
    fHistoFinePtBins     = n ; fHistoFinePtMax     = max ; fHistoFinePtMin     = min ; }
  
  //Azimuthal angle
  
  Int_t   GetHistoPhiBins()             const { return fHistoPhiBins         ; }
  Float_t GetHistoPhiMin()              const { return fHistoPhiMin          ; }
  Float_t GetHistoPhiMax()              const { return fHistoPhiMax          ; }
  
  void    SetHistoPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoPhiBins        = n ; fHistoPhiMax        = max ; fHistoPhiMin        = min ; }
  
 // Delta azymuthal angle
  Int_t   GetHistoDeltaPhiBins()        const { return fHistoDeltaPhiBins    ; }
  Float_t GetHistoDeltaPhiMin()         const { return fHistoDeltaPhiMin     ; }
  Float_t GetHistoDeltaPhiMax()         const { return fHistoDeltaPhiMax     ; }
  
  void    SetHistoDeltaPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoDeltaPhiBins   = n ; fHistoDeltaPhiMax   = max ; fHistoDeltaPhiMin   = min ; }


// Delta eta angle

  Int_t   GetHistoDeltaEtaBins()        const { return fHistoDeltaEtaBins     ; }
  Float_t GetHistoDeltaEtaMin()         const { return fHistoDeltaEtaMin      ; }
  Float_t GetHistoDeltaEtaMax()         const { return fHistoDeltaEtaMax      ; }
 
  void    SetHistoDeltaEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoDeltaEtaBins  = n ; fHistoDeltaEtaMax   = max ; fHistoDeltaEtaMin   = min ; }


  //Pseudorapidity-rapidity
  
  Int_t   GetHistoEtaBins()             const { return fHistoEtaBins         ; }
  Float_t GetHistoEtaMin()              const { return fHistoEtaMin          ; }
  Float_t GetHistoEtaMax()              const { return fHistoEtaMax          ; }
  
  void    SetHistoEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoEtaBins        = n ; fHistoEtaMax         = max ; fHistoEtaMin       = min ; }
  
  //Mass
  
  Int_t   GetHistoMassBins()            const { return fHistoMassBins        ; }
  Float_t GetHistoMassMin()             const { return fHistoMassMin         ; }
  Float_t GetHistoMassMax()             const { return fHistoMassMax         ; }
  
  void    SetHistoMassRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoMassBins       = n ; fHistoMassMax       = max ; fHistoMassMin       = min ; }
  
  //Asymetry
  
  Int_t   GetHistoAsymmetryBins()        const { return fHistoAsymBins       ; }
  Float_t GetHistoAsymmetryMin()         const { return fHistoAsymMin        ; }
  Float_t GetHistoAsymmetryMax()         const { return fHistoAsymMax        ; }  
  
  void    SetHistoAsymmetryRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoAsymBins       = n ; fHistoAsymMax       = max ; fHistoAsymMin       = min ; }
  
  //VZero
  
  Int_t   GetHistoV0SignalBins()         const { return fHistoV0SBins        ; }
  Int_t   GetHistoV0SignalMin()          const { return fHistoV0SMin         ; }
  Int_t   GetHistoV0SignalMax()          const { return fHistoV0SMax         ; }
  
  void    SetHistoV0SignalRangeAndNBins(Int_t min, Int_t max, Int_t n) {
    fHistoV0SBins        = n ; fHistoV0SMax        = max ; fHistoV0SMin        = min ; }
  
  Int_t   GetHistoV0MultiplicityBins()   const { return fHistoV0MBins        ; }
  Int_t   GetHistoV0MultiplicityMin()    const { return fHistoV0MMin         ; }
  Int_t   GetHistoV0MultiplicityMax()    const { return fHistoV0MMax         ; }
  
  void    SetHistoV0MultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
    fHistoV0MBins        = n ; fHistoV0MMax        = max ; fHistoV0MMin        = min ; }
  
  // Track multiplicity
  
  Int_t   GetHistoTrackMultiplicityBins() const { return fHistoTrMBins      ; }
  Int_t   GetHistoTrackMultiplicityMin()  const { return fHistoTrMMin       ; }
  Int_t   GetHistoTrackMultiplicityMax()  const { return fHistoTrMMax       ; }
  
  void    SetHistoTrackMultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
    fHistoTrMBins        = n ; fHistoTrMMax        = max ; fHistoTrMMin        = min ; }
  
  // dEdx
  
  Int_t   GetHistodEdxBins()             const { return fHistodEdxBins       ; }
  Float_t GetHistodEdxMin()              const { return fHistodEdxMin        ; }
  Float_t GetHistodEdxMax()              const { return fHistodEdxMax        ; }  
  
  void    SetHistodEdxRangeAndNBins        (Float_t min, Float_t max, Int_t n) {
    fHistodEdxBins       = n ; fHistodEdxMax       = max ; fHistodEdxMin       = min ; }
  
  // E over p
  
  Int_t   GetHistoPOverEBins()           const { return fHistoPOverEBins     ; }
  Float_t GetHistoPOverEMin()            const { return fHistoPOverEMin      ; }
  Float_t GetHistoPOverEMax()            const { return fHistoPOverEMax      ; }
  
  void    SetHistoPOverERangeAndNBins      (Float_t min, Float_t max, Int_t n) {
    fHistoPOverEBins     = n ; fHistoPOverEMax     = max ; fHistoPOverEMin     = min ; }
  
  // Number of cells per clusters
  
  Int_t   GetHistoNClusterCellBins()     const { return fHistoNClusCellBins  ; }
  Int_t   GetHistoNClusterCellMin()      const { return fHistoNClusCellMin   ; }
  Int_t   GetHistoNClusterCellMax()      const { return fHistoNClusCellMax   ; }  
 
  void    SetHistoNClusterCellRangeAndNBins(Int_t   min, Int_t   max, Int_t n) {
    fHistoNClusCellBins  = n ; fHistoNClusCellMax  = max ; fHistoNClusCellMin  = min ; }
  
  // Number of clusters
  
  Int_t   GetHistoNClustersBins()        const { return fHistoNClustersBins  ; }
  Int_t   GetHistoNClustersMin()         const { return fHistoNClustersMin   ; }
  Int_t   GetHistoNClustersMax()         const { return fHistoNClustersMax   ; }  
  
  void    SetHistoNClustersRangeAndNBins   (Int_t   min, Int_t   max, Int_t n) {
    fHistoNClustersBins  = n ; fHistoNClustersMax  = max ; fHistoNClustersMin  = min ; }

  // Number of cells 
  
  Int_t   GetHistoNCellsBins()           const { return fHistoNCellsBins     ; }
  Int_t   GetHistoNCellsMin()            const { return fHistoNCellsMin      ; }
  Int_t   GetHistoNCellsMax()            const { return fHistoNCellsMax      ; }  
  
  void    SetHistoNCellsRangeAndNBins      (Int_t   min, Int_t   max, Int_t n) {
    fHistoNCellsBins     = n ; fHistoNCellsMax     = max ; fHistoNCellsMin     = min ; }

  // dR
  
  Int_t   GetHistodRBins()               const { return fHistodRBins         ; }
  Float_t GetHistodRMin()                const { return fHistodRMin          ; }
  Float_t GetHistodRMax()                const { return fHistodRMax          ; }  
  
  void    SetHistodRRangeAndNBins          (Float_t min, Float_t max, Int_t n) {
    fHistodRBins         = n ; fHistodRMax         = max ; fHistodRMin         = min ; }

  // Ratio
  
  Int_t   GetHistoRatioBins()            const { return fHistoRatioBins      ; }
  Float_t GetHistoRatioMin()             const { return fHistoRatioMin       ; }
  Float_t GetHistoRatioMax()             const { return fHistoRatioMax       ; }  
  
  void    SetHistoRatioRangeAndNBins       (Float_t min, Float_t max, Int_t n) {
    fHistoRatioBins      = n ; fHistoRatioMax      = max ; fHistoRatioMin      = min ; }

  // Energy difference
  
  Int_t   GetHistoEDiffBins()            const { return fHistoEDiffBins      ; }
  Float_t GetHistoEDiffMin()             const { return fHistoEDiffMin       ; }
  Float_t GetHistoEDiffMax()             const { return fHistoEDiffMax       ; }  
  
  void    SetHistoEDiffRangeAndNBins       (Float_t min, Float_t max, Int_t n) {
    fHistoEDiffBins      = n ; fHistoEDiffMax      = max ; fHistoEDiffMin      = min ; }
  
  // Hump-Backed Plateau
  
  Int_t   GetHistoHBPBins()              const { return fHistoHBPBins      ; }
  Float_t GetHistoHBPMin()               const { return fHistoHBPMin       ; }
  Float_t GetHistoHBPMax()               const { return fHistoHBPMax       ; }
  
  void    SetHistoHBPRangeAndNBins       (Float_t min, Float_t max, Int_t n) {
    fHistoHBPBins        = n ; fHistoHBPMax        = max ; fHistoHBPMin        = min ; }

  
  // Vertex
  
  Int_t   GetHistoVertexDistBins()       const { return fHistoVertexDistBins ; }
  Float_t GetHistoVertexDistMin()        const { return fHistoVertexDistMin  ; }
  Float_t GetHistoVertexDistMax()        const { return fHistoVertexDistMax  ; }  
  
  void    SetHistoVertexDistRangeAndNBins  (Float_t min, Float_t max, Int_t n) { 
    fHistoVertexDistBins = n ; fHistoVertexDistMax = max ; fHistoVertexDistMin = min ; }

  
  // R =sqrt(x^2+y^2+z^2) (cm)
  
  Int_t   GetHistoRBins()                const { return fHistoRBins          ; }
  Float_t GetHistoRMin()                 const { return fHistoRMin           ; }
  Float_t GetHistoRMax()                 const { return fHistoRMax           ; }    
  
  void    SetHistoRRangeAndNBins           (Float_t min, Float_t max, Int_t n) {
    fHistoRBins         = n ; fHistoRMax           = max ; fHistoRMin          = min ; }
  
  // X position
  
  Int_t   GetHistoXBins()                const { return fHistoXBins          ; }
  Float_t GetHistoXMin()                 const { return fHistoXMin           ; }
  Float_t GetHistoXMax()                 const { return fHistoXMax           ; }
  
  void    SetHistoXRangeAndNBins           (Float_t min, Float_t max, Int_t n) {
    fHistoXBins          = n ; fHistoXMax          = max ; fHistoXMin          = min ; }

  // Y position
  
  Int_t   GetHistoYBins()                const { return fHistoYBins          ; }
  Float_t GetHistoYMin()                 const { return fHistoYMin           ; }
  Float_t GetHistoYMax()                 const { return fHistoYMax           ; }  
  
  void    SetHistoYRangeAndNBins           (Float_t min, Float_t max, Int_t n) {
    fHistoYBins          = n ; fHistoYMax          = max ; fHistoYMin          = min ; }
  
  // Z position
  
  Int_t   GetHistoZBins()                const { return fHistoZBins          ; }
  Float_t GetHistoZMin()                 const { return fHistoZMin           ; }
  Float_t GetHistoZMax()                 const { return fHistoZMax           ; }  
  
  void    SetHistoZRangeAndNBins           (Float_t min, Float_t max, Int_t n) {
    fHistoZBins         = n ; fHistoZMax           = max ; fHistoZMin          = min ; }

  // Shower shape parameters
  
  Int_t   GetHistoShowerShapeBins()      const { return fHistoSSBins         ; }
  Float_t GetHistoShowerShapeMin()       const { return fHistoSSMin          ; }
  Float_t GetHistoShowerShapeMax()       const { return fHistoSSMax          ; }  
  
  void    SetHistoShowerShapeRangeAndNBins (Float_t min, Float_t max, Int_t n) {
    fHistoSSBins        = n ; fHistoSSMax          = max ; fHistoSSMin        = min ; }

  // Time
  
  Int_t   GetHistoTimeBins()             const { return fHistoTimeBins       ; }
  Float_t GetHistoTimeMin()              const { return fHistoTimeMin        ; }
  Float_t GetHistoTimeMax()              const { return fHistoTimeMax        ; }  
  
  void    SetHistoTimeRangeAndNBins        (Float_t min, Float_t max, Int_t n) {
    fHistoTimeBins       = n ; fHistoTimeMax       = max ; fHistoTimeMin       = min ; }    
  
  // Cluster time difference
  
  Int_t   GetHistoDiffTimeBins()         const { return fHistoDiffTimeBins   ; }
  Float_t GetHistoDiffTimeMin()          const { return fHistoDiffTimeMin    ; }
  Float_t GetHistoDiffTimeMax()          const { return fHistoDiffTimeMax    ; }  
   
  void    SetHistoDiffTimeRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoDiffTimeBins   = n ; fHistoDiffTimeMax   = max ; fHistoDiffTimeMin   = min   ; }
  
  //    Track matching histogrammes setters and getters
  
  Int_t   GetHistoTrackResidualEtaBins() const { return fHistoTrackResidualEtaBins ; }
  Float_t GetHistoTrackResidualEtaMin()  const { return fHistoTrackResidualEtaMin  ; }
  Float_t GetHistoTrackResidualEtaMax()  const { return fHistoTrackResidualEtaMax  ; }    
  
  void    SetHistoTrackResidualEtaRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoTrackResidualEtaBins = n ; fHistoTrackResidualEtaMax = max ; fHistoTrackResidualEtaMin = min           ; }
  
  Int_t   GetHistoTrackResidualPhiBins() const { return fHistoTrackResidualPhiBins ; }
  Float_t GetHistoTrackResidualPhiMin()  const { return fHistoTrackResidualPhiMin  ; }
  Float_t GetHistoTrackResidualPhiMax()  const { return fHistoTrackResidualPhiMax  ; }  
  
  void    SetHistoTrackResidualPhiRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoTrackResidualPhiBins = n ; fHistoTrackResidualPhiMax = max ; fHistoTrackResidualPhiMin = min           ; }
  
  // Isolation task, sum pt
  
  void    SetHistoPtSumRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoNPtSumBins = n ;    fHistoPtSumMax = max ;    fHistoPtSumMin = min ; }
  
  Int_t   GetHistoNPtSumBins()           const { return fHistoNPtSumBins   ; }
  Float_t GetHistoPtSumMin()             const { return fHistoPtSumMin     ; }
  Float_t GetHistoPtSumMax()             const { return fHistoPtSumMax     ; }
  
  void    SetHistoPtInConeRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoNPtInConeBins = n ; fHistoPtInConeMax = max ; fHistoPtInConeMin = min  ; }
  
  Int_t   GetHistoNPtInConeBins()        const { return fHistoNPtInConeBins; }
  Float_t GetHistoPtInConeMin()          const { return fHistoPtInConeMin  ; }
  Float_t GetHistoPtInConeMax()          const { return fHistoPtInConeMax  ; }

  // Opening angle
  
  void    SetHistoOpeningAngleRangeAndNBins(Float_t min, Float_t max, Int_t n) {
   fHistoOpAngleBins = n ; fHistoOpAngleMax = max ; fHistoOpAngleMin = min  ; }
  
  Int_t   GetHistoNOpeningAngleBins()    const { return fHistoOpAngleBins ; }
  Float_t GetHistoOpeningAngleMin()      const { return fHistoOpAngleMin  ; }
  Float_t GetHistoOpeningAngleMax()      const { return fHistoOpAngleMax  ; }
  
private:    
  
  Int_t    fHistoPtBins   ;                   
  Float_t  fHistoPtMax    ;                   
  Float_t  fHistoPtMin    ;                   
  Int_t    fHistoPhiBins  ;                   
  Float_t  fHistoPhiMax   ;                   
  Float_t  fHistoPhiMin   ;                   
  Int_t    fHistoEtaBins  ;                   
  Float_t  fHistoEtaMax   ;                   
  Float_t  fHistoEtaMin   ;                   
  Int_t    fHistoDeltaPhiBins  ;              
  Float_t  fHistoDeltaPhiMax   ;              
  Float_t  fHistoDeltaPhiMin   ;              
  Int_t    fHistoDeltaEtaBins  ;              
  Float_t  fHistoDeltaEtaMax   ;              
  Float_t  fHistoDeltaEtaMin   ;              

  Int_t    fHistoMassBins ;                   
  Float_t  fHistoMassMax  ;                   
  Float_t  fHistoMassMin  ;                   
  Int_t    fHistoAsymBins ;                   
  Float_t  fHistoAsymMax  ;                   
  Float_t  fHistoAsymMin  ;                   
  Int_t    fHistoV0SBins  ;                   
  Int_t    fHistoV0SMax   ;                   
  Int_t    fHistoV0SMin   ;                   
  Int_t    fHistoV0MBins  ;                   
  Int_t    fHistoV0MMax   ;                   
  Int_t    fHistoV0MMin   ;                   
  Int_t    fHistoTrMBins  ;                   
  Int_t    fHistoTrMMax   ;                   
  Int_t    fHistoTrMMin   ;                   
  Int_t    fHistoFinePtBins;                  
  Float_t  fHistoFinePtMax;                   
  Float_t  fHistoFinePtMin;                   
  Int_t    fHistoPOverEBins;                  
  Float_t  fHistoPOverEMax;                   
  Float_t  fHistoPOverEMin;                   
  Int_t    fHistodEdxBins;                    
  Float_t  fHistodEdxMax;                     
  Float_t  fHistodEdxMin;                     
  Int_t    fHistodRBins;                      
  Float_t  fHistodRMax;                       
  Float_t  fHistodRMin;                       
  Int_t    fHistoTimeBins;                    
  Float_t  fHistoTimeMax;                     
  Float_t  fHistoTimeMin;                     
  Int_t    fHistoNClusCellBins;               
  Int_t    fHistoNClusCellMax;                
  Int_t    fHistoNClusCellMin;                
  Int_t    fHistoNCellsBins;                  
  Int_t    fHistoNCellsMax;                   
  Int_t    fHistoNCellsMin;                   
  Int_t    fHistoNClustersBins;               
  Int_t    fHistoNClustersMax;                
  Int_t    fHistoNClustersMin;                
  Int_t    fHistoRatioBins;                   
  Float_t  fHistoRatioMax;                    
  Float_t  fHistoRatioMin;                    
  Int_t    fHistoEDiffBins;                   
  Float_t  fHistoEDiffMax;                    
  Float_t  fHistoEDiffMin;                    
  Int_t    fHistoHBPBins;                     
  Float_t  fHistoHBPMax;                      
  Float_t  fHistoHBPMin;                      
  Int_t    fHistoVertexDistBins;              
  Float_t  fHistoVertexDistMax;               
  Float_t  fHistoVertexDistMin;               
  Int_t    fHistoRBins;                       
  Float_t  fHistoRMax;                        
  Float_t  fHistoRMin;                        
  Int_t    fHistoXBins;                       
  Float_t  fHistoXMax;                        
  Float_t  fHistoXMin;                        
  Int_t    fHistoYBins;                       
  Float_t  fHistoYMax;                        
  Float_t  fHistoYMin;                        
  Int_t    fHistoZBins;                       
  Float_t  fHistoZMax;                        
  Float_t  fHistoZMin;                        
  Int_t    fHistoSSBins;                      
  Float_t  fHistoSSMax;                       
  Float_t  fHistoSSMin;                       
  Int_t    fHistoDiffTimeBins;                
  Float_t  fHistoDiffTimeMax;                 
  Float_t  fHistoDiffTimeMin;                 
  Int_t    fHistoTrackResidualEtaBins ;       
  Float_t  fHistoTrackResidualEtaMax  ;       
  Float_t  fHistoTrackResidualEtaMin  ;       
  Int_t    fHistoTrackResidualPhiBins ;       
  Float_t  fHistoTrackResidualPhiMax  ;       
  Float_t  fHistoTrackResidualPhiMin  ;       
  Int_t    fHistoNPtSumBins;                  
  Float_t  fHistoPtSumMax;                    
  Float_t  fHistoPtSumMin;                    
  Int_t    fHistoNPtInConeBins;               
  Float_t  fHistoPtInConeMax;                 
  Float_t  fHistoPtInConeMin;                 
  Int_t    fHistoOpAngleBins;                 
  Float_t  fHistoOpAngleMax ;                 
  Float_t  fHistoOpAngleMin ;                 

  AliHistogramRanges(              const AliHistogramRanges & h) ; 
  
  AliHistogramRanges & operator = (const AliHistogramRanges & h) ; 
  
  ClassDef(AliHistogramRanges,7) ;

} ;


#endif //ALIHISTOGRAMRANGES_H