AliNeutralMesonSelection.h

Go to the documentation of this file.

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

//_________________________________________________________________________
//_________________________________________________________________________

// --- ROOT system ---
#include<TObject.h>
#include<TArrayD.h>
#include<TString.h>

class TLorentzVector ;
class TList   ;
class TH2F    ;

class AliNeutralMesonSelection : public TObject {
  
 public:
    
  AliNeutralMesonSelection() ; // default ctor
  
  virtual ~AliNeutralMesonSelection() { ; }   

  // General
    
  TList *  GetCreateOutputObjects();
  
  void     InitParameters();  
  
  void     Print(const Option_t * opt) const;

  Bool_t   AreNeutralMesonSelectionHistosKept()   const { return fKeepNeutralMesonHistos ; }
  void     KeepNeutralMesonSelectionHistos(Bool_t keep) { fKeepNeutralMesonHistos = keep ; }
  
  Bool_t   SelectPair(TLorentzVector particlei,  TLorentzVector particlej, Int_t calo)  ;
  
  void     SetParticle(TString particleName) ;  // Do some default settings for "Pi0" or "Eta"
  TString  GetParticle()                          const { return fParticle               ; }
  
  Int_t  GetDebug()                               const { return fDebug                  ; }
  void   SetDebug(Int_t d)                              { fDebug = d                     ; }
  
  // Asymmetry selection
    
  Float_t  GetAsymmetryCut()                      const { return fAsymmetryCut           ; }
  void     SetAsymmetryCut(Float_t asy)                 { fAsymmetryCut = asy            ; }
  
  void     SwitchOnAsymmetryCut()                       { fUseAsymmetryCut = kTRUE       ; }
  void     SwitchOffAsymmetryCut()                      { fUseAsymmetryCut = kFALSE      ; }
  
  //Opening angle selection 
  
  Double_t GetAngleMaxParam(Int_t i)              const { return fAngleMaxParam.At(i)    ; }
  void     SetAngleMaxParam(Int_t i, Double_t par)      { fAngleMaxParam.AddAt(par,i)    ; }
  
  void     SetShiftMinAngleCut(Float_t a, Float_t b)    { fShiftMinAngle[0] = a          ;
                                                          fShiftMinAngle[1] = b          ; }
  
  void     SwitchOnAngleSelection()                     { fUseAngleCut = kTRUE           ; }
  void     SwitchOffAngleSelection()                    { fUseAngleCut = kFALSE          ; }

  Bool_t   IsAngleInWindow(Float_t angle, Float_t e) const ;
  
  //Invariant mass selection
  
  Double_t GetInvMassMaxCut()                     const { return fInvMassMaxCut          ; }
  Double_t GetInvMassMinCut()                     const { return fInvMassMinCut          ; }
  
  void     SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
            { fInvMassMaxCut =invmassmax;  fInvMassMinCut =invmassmin                    ; }  
  
  void     SetSideBandCutRanges( Double_t lmin, Double_t lmax, 
                                 Double_t rmin, Double_t rmax )
            { fLeftBandMinCut  = lmin ; fLeftBandMaxCut  = lmax ; 
              fRightBandMinCut = rmin ; fRightBandMaxCut = rmax ; } 
  
  void     SetInvMassCutMaxParameters(Float_t a, Float_t b, Float_t c)
            { fInvMassMaxCutParam[0] = a ; 
              fInvMassMaxCutParam[1] = b ; 
              fInvMassMaxCutParam[2] = c ; }  

  Double_t GetMass()                              const { return fM                      ; }
  void     SetMass(Double_t m)                          { fM = m                         ; }
  
  
  // Decay photon bit setting
  static const Int_t fgkMaxNDecayBits = 8;
  
  enum decayTypes { kPi0          = 0, kEta          = 1,
                    kPi0RightSide = 2, kEtaRightSide = 3, kEtaLeftSide  = 4,
                    kPi0LeftSide  = 5, kEtaBothSides = 6, kPi0BothSides = 7 } ;

  UInt_t    GetDecayBit()                         const { return fDecayBit               ; }
  
  void    SetDecayBit(Int_t &tag, UInt_t set) const {
    // Set bit of type set (decayTypes) in tag
    tag |= (1<<set) ;
  }
  
  void    SetDecayBit(Int_t &tag) const {
    // Set bit of type set (decayTypes) in tag
    tag |= (1<<fDecayBit) ;
  }
  
  Bool_t  CheckDecayBit(Int_t tag, UInt_t test) const {
    // Check if in tag the bit test (decayTypes) is set.
    if (tag & (1<<test) ) return  kTRUE ;
    else return kFALSE ;
  }

  Bool_t  CheckDecayBit(Int_t tag) const {
    // Check if in tag the bit test (decayTypes) is set.
    if (tag & (1<<fDecayBit) ) return  kTRUE ;
    else return kFALSE ;
  }
    
  // Histograms setters and getters
  
  virtual void SetHistoERangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoNEBins = n ;
    fHistoEMax = max ;
    fHistoEMin = min ;
  }
  
  Int_t   GetHistoNEBins()     const { return fHistoNEBins    ; }
  Float_t GetHistoEMin()       const { return fHistoEMin      ; }
  Float_t GetHistoEMax()       const { return fHistoEMax      ; }
    
  virtual void SetHistoAngleRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoNAngleBins = n ;
    fHistoAngleMax = max ;
    fHistoAngleMin = min ;
  }
  
  Int_t   GetHistoNAngleBins() const { return fHistoNAngleBins ; }
  Float_t GetHistoAngleMin()   const { return fHistoAngleMin   ; }
  Float_t GetHistoAngleMax()   const { return fHistoAngleMax   ; }
  
  virtual void SetHistoIMRangeAndNBins(Float_t min, Float_t max, Int_t n) {
    fHistoNIMBins = n ;
    fHistoIMMax = max ;
    fHistoIMMin = min ;
  }
  
  Int_t   GetHistoNIMBins()    const { return fHistoNIMBins    ; }
  Float_t GetHistoIMMin()      const { return fHistoIMMin      ; }
  Float_t GetHistoIMMax()      const { return fHistoIMMax      ; }
  
 private:
  
  Float_t  fAsymmetryCut  ;               
  
  Bool_t   fUseAsymmetryCut;              

  Double_t fM ;                           
  
  Double_t fInvMassMaxCut ;               
  
  Double_t fInvMassMinCut ;               
  
  Double_t fInvMassMaxCutParam[3];        
  
  Double_t fLeftBandMinCut  ;             
  
  Double_t fLeftBandMaxCut  ;             
  
  Double_t fRightBandMinCut ;             
  
  Double_t fRightBandMaxCut ;             
  
  TArrayD  fAngleMaxParam ;               
  
  Bool_t   fUseAngleCut   ;               
  
  Float_t  fShiftMinAngle[2] ;            
  
  Bool_t   fKeepNeutralMesonHistos ;      
  
  TString  fParticle ;                    
  
  UInt_t   fDecayBit;                     

  Int_t    fDebug ;                       
    
  // Histograms
  TH2F *   fhAnglePairNoCut ;             
  
  TH2F *   fhAnglePairOpeningAngleCut ;   
  
  TH2F *   fhAnglePairAsymmetryCut ;      
  
  TH2F *   fhAnglePairAllCut ;            
  
  
  TH2F *   fhInvMassPairNoCut ;           
  
  TH2F *   fhInvMassPairOpeningAngleCut ; 
  
  TH2F *   fhInvMassPairAsymmetryCut ;    
  
  TH2F *   fhInvMassPairAllCut ;          

  TH2F *   fhAsymmetryNoCut ;             
  
  TH2F *   fhAsymmetryOpeningAngleCut ;   
  
  TH2F *   fhAsymmetryAllCut ;            
  
  
  // Histograms binning and range
  Int_t    fHistoNEBins ;                 
  
  Float_t  fHistoEMax ;                   
  
  Float_t  fHistoEMin ;                   
  
  Int_t    fHistoNAngleBins ;             
  
  Float_t  fHistoAngleMax ;               
  
  Float_t  fHistoAngleMin ;               
  
  
  Int_t    fHistoNIMBins ;                
  
  Float_t  fHistoIMMax ;                  
  
  Float_t  fHistoIMMin ;                  
  
  AliNeutralMesonSelection(              const AliNeutralMesonSelection & nm) ;
  
  AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & nm) ; 
  
  ClassDef(AliNeutralMesonSelection,8) ;

} ;

#endif //ALINEUTRALMESONSELECTION_H