[u/mrichter/AliRoot.git] / PWG4 / PartCorrBase / AliNeutralMesonSelection.h

#ifndef ALINEUTRALMESONSELECTION_H
#define ALINEUTRALMESONSELECTION_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */
/* $Id: AliNeutralMesonSelection.h 27413 2008-07-18 13:28:12Z gconesab $ */

//_________________________________________________________________________
// Class that contains methods to select candidate pairs to neutral meson 
// 2 main selections, invariant mass around pi0 (also any other mass),
// apperture angle to distinguish from combinatorial.
// There is a 3rd cut based on the gamma correlation on phi or pt.
//-- Author: Gustavo Conesa (INFN-LNF)

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

class TLorentzVector ;
class TList ;
class TH2F ;

//--- ANALYSIS system ---

class AliNeutralMesonSelection : public TObject {
  
 public: 
  AliNeutralMesonSelection() ; // default ctor
  virtual ~AliNeutralMesonSelection() { ; } //virtual dtor  
 private:
  AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
  AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
  
 public:
  // 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, TString calo)  ;
  
  void     SetParticle(TString particleName) ;  // Do some default settings for "Pi0" or "Eta"
  
  // 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)    ; }
  
  Float_t  GetShiftMinAngleCut()                  const { return fShiftMinAngle          ; }
  void     SetShiftMinAngleCut(Float_t shift)           { fShiftMinAngle = shift         ; }
  
  void     SwitchOnAngleSelection()                     { fUseAngleCut = kTRUE           ; }
  void     SwitchOffAngleSelection()                    { fUseAngleCut = kFALSE          ; }

  Bool_t   IsAngleInWindow(const Float_t angle, const 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     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                         ; }
      
  //Histogrammes 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  ;               // Asymmetry cut
  Bool_t   fUseAsymmetryCut;              // Use the asymmetry cut
  
  Double_t fM ;                           // Mass of the neutral meson
  Double_t fInvMassMaxCut ;               // Invariant Mass cut maximum
  Double_t fInvMassMinCut ;               // Invariant Masscut minimun
  Double_t fInvMassMaxCutParam[3];        // Variable invariant mass max cut, for pi0 in EMCAL
  
  TArrayD  fAngleMaxParam ;               // Max opening angle selection parameters
  Bool_t   fUseAngleCut   ;               // Select pairs depending on their opening angle
  Float_t  fShiftMinAngle ;               // Correction shift for min angle from true kinematic limit, resolution effects
  
  Bool_t   fKeepNeutralMesonHistos ;      // Keep neutral meson selection histograms

  //Histograms
  TH2F *   fhAnglePairNoCut ;             //! Aperture angle of decay photons, no cuts
  TH2F *   fhAnglePairOpeningAngleCut ;   //! Aperture angle of decay photons, cut on opening angle
  TH2F *   fhAnglePairAsymmetryCut ;      //! Aperture angle of decay photons, asymmetry cut
  TH2F *   fhAnglePairAllCut ;            //! Aperture angle of decay photons, all cuts
  
  TH2F *   fhInvMassPairNoCut ;           //! Invariant mass of decay photons, no cuts
  TH2F *   fhInvMassPairOpeningAngleCut ; //! Invariant mass of decay photons, cut on opening angle
  TH2F *   fhInvMassPairAsymmetryCut ;    //! Invariant mass of decay photons, asymmetry cut  
  TH2F *   fhInvMassPairAllCut ;          //! Invariant mass of decay photons, all cuts

  TH2F *   fhAsymmetryNoCut ;             //! Asymmetry of decay photons, no cuts
  TH2F *   fhAsymmetryOpeningAngleCut ;   //! Asymmetry of decay photons, cut on opening angle
  TH2F *   fhAsymmetryAllCut ;            //! Asymmetry of decay photons, all cuts
  
  //Histograms binning and range    
  Int_t    fHistoNEBins ;                 // Number of bins in pi0 E axis
  Float_t  fHistoEMax ;                   // Maximum value of pi0 E histogram range
  Float_t  fHistoEMin ;                   // Minimum value of pi0 E histogram range
  
  Int_t    fHistoNAngleBins ;             // Number of bins in angle axis
  Float_t  fHistoAngleMax ;               // Maximum value of angle histogram range
  Float_t  fHistoAngleMin ;               // Minimum value of angle histogram range
  
  Int_t    fHistoNIMBins ;                // Number of bins in Invariant Mass axis
  Float_t  fHistoIMMax ;                  // Maximum value of Invariant Mass histogram range
  Float_t  fHistoIMMin ;                  // Minimum value of Invariant Mass histogram range
  
  ClassDef(AliNeutralMesonSelection,6)
    
} ;

#endif //ALINEUTRALMESONSELECTION_H
Commit	Line	Data
1c5acb87	1	#ifndef ALINEUTRALMESONSELECTION_H
	2	#define ALINEUTRALMESONSELECTION_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5	/* $Id: AliNeutralMesonSelection.h 27413 2008-07-18 13:28:12Z gconesab $ */
	6
	7	//_________________________________________________________________________
	8	// Class that contains methods to select candidate pairs to neutral meson
	9	// 2 main selections, invariant mass around pi0 (also any other mass),
	10	// apperture angle to distinguish from combinatorial.
	11	// There is a 3rd cut based on the gamma correlation on phi or pt.
	12	//-- Author: Gustavo Conesa (INFN-LNF)
	13
	14	// --- ROOT system ---
	15	#include<TObject.h>
	16	#include<TArrayD.h>
	17
	18	class TLorentzVector ;
	19	class TList ;
	20	class TH2F ;
	21
	22	//--- ANALYSIS system ---
1c5acb87	23
1c5acb87	24	class AliNeutralMesonSelection : public TObject {
477d6cee	25
477d6cee	26	public:
477d6cee	27	AliNeutralMesonSelection() ; // default ctor
9542ac75	28	virtual ~AliNeutralMesonSelection() { ; } //virtual dtor
78219bac	29	private:
477d6cee	30	AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
477d6cee	31	AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
477d6cee	32
78219bac	33	public:
a5fb4114	34	// General
9542ac75	35
a5fb4114	36	TList * GetCreateOutputObjects();
9542ac75	37
a5fb4114	38	void InitParameters();
9542ac75	39
a5fb4114	40	void Print(const Option_t * opt) const;
78219bac	41
9542ac75	42	Bool_t AreNeutralMesonSelectionHistosKept() const { return fKeepNeutralMesonHistos ; }
	43	void KeepNeutralMesonSelectionHistos(Bool_t keep) { fKeepNeutralMesonHistos = keep ; }
	44
3bfcb597	45	Bool_t SelectPair(TLorentzVector particlei, TLorentzVector particlej, TString calo) ;
	46
	47	void SetParticle(TString particleName) ; // Do some default settings for "Pi0" or "Eta"
9542ac75	48
	49	// Asymmetry selection
	50
	51	Float_t GetAsymmetryCut() const { return fAsymmetryCut ; }
	52	void SetAsymmetryCut(Float_t asy) { fAsymmetryCut = asy ; }
	53
	54	void SwitchOnAsymmetryCut() { fUseAsymmetryCut = kTRUE ; }
	55	void SwitchOffAsymmetryCut() { fUseAsymmetryCut = kFALSE ; }
	56
a5fb4114	57	//Opening angle selection
9542ac75	58
a5fb4114	59	Double_t GetAngleMaxParam(Int_t i) const { return fAngleMaxParam.At(i) ; }
a5fb4114	60	void SetAngleMaxParam(Int_t i, Double_t par) { fAngleMaxParam.AddAt(par,i) ; }
477d6cee	61
9542ac75	62	Float_t GetShiftMinAngleCut() const { return fShiftMinAngle ; }
a5fb4114	63	void SetShiftMinAngleCut(Float_t shift) { fShiftMinAngle = shift ; }
	64
	65	void SwitchOnAngleSelection() { fUseAngleCut = kTRUE ; }
	66	void SwitchOffAngleSelection() { fUseAngleCut = kFALSE ; }
9542ac75	67
9542ac75	68	Bool_t IsAngleInWindow(const Float_t angle, const Float_t e) const ;
a5fb4114	69
a5fb4114	70	//Invariant mass selection
9542ac75	71
a5fb4114	72	Double_t GetInvMassMaxCut() const { return fInvMassMaxCut ; }
a5fb4114	73	Double_t GetInvMassMinCut() const { return fInvMassMinCut ; }
477d6cee	74
b6991fc4	75	void SetInvMassCutRange(Double_t invmassmin, Double_t invmassmax)
9542ac75	76	{ fInvMassMaxCut =invmassmax; fInvMassMinCut =invmassmin ; }
477d6cee	77
3bfcb597	78	void SetInvMassCutMaxParameters(Float_t a, Float_t b, Float_t c)
	79	{ fInvMassMaxCutParam[0] = a ;
	80	fInvMassMaxCutParam[1] = b ;
	81	fInvMassMaxCutParam[2] = c ; }
	82
a5fb4114	83	Double_t GetMass() const { return fM ; }
a5fb4114	84	void SetMass(Double_t m) { fM = m ; }
3bfcb597	85
477d6cee	86	//Histogrammes setters and getters
	87
	88	virtual void SetHistoERangeAndNBins(Float_t min, Float_t max, Int_t n) {
	89	fHistoNEBins = n ;
	90	fHistoEMax = max ;
	91	fHistoEMin = min ;
	92	}
	93
a5fb4114	94	Int_t GetHistoNEBins() const { return fHistoNEBins ; }
	95	Float_t GetHistoEMin() const { return fHistoEMin ; }
	96	Float_t GetHistoEMax() const { return fHistoEMax ; }
3bfcb597	97
477d6cee	98	virtual void SetHistoAngleRangeAndNBins(Float_t min, Float_t max, Int_t n) {
	99	fHistoNAngleBins = n ;
	100	fHistoAngleMax = max ;
	101	fHistoAngleMin = min ;
	102	}
	103
	104	Int_t GetHistoNAngleBins() const { return fHistoNAngleBins ; }
a5fb4114	105	Float_t GetHistoAngleMin() const { return fHistoAngleMin ; }
a5fb4114	106	Float_t GetHistoAngleMax() const { return fHistoAngleMax ; }
477d6cee	107
	108	virtual void SetHistoIMRangeAndNBins(Float_t min, Float_t max, Int_t n) {
	109	fHistoNIMBins = n ;
	110	fHistoIMMax = max ;
	111	fHistoIMMin = min ;
	112	}
	113
a5fb4114	114	Int_t GetHistoNIMBins() const { return fHistoNIMBins ; }
	115	Float_t GetHistoIMMin() const { return fHistoIMMin ; }
	116	Float_t GetHistoIMMax() const { return fHistoIMMax ; }
477d6cee	117
	118
	119	private:
9542ac75	120
	121	Float_t fAsymmetryCut ; // Asymmetry cut
	122	Bool_t fUseAsymmetryCut; // Use the asymmetry cut
	123
	124	Double_t fM ; // Mass of the neutral meson
	125	Double_t fInvMassMaxCut ; // Invariant Mass cut maximum
	126	Double_t fInvMassMinCut ; // Invariant Masscut minimun
3bfcb597	127	Double_t fInvMassMaxCutParam[3]; // Variable invariant mass max cut, for pi0 in EMCAL
9542ac75	128
	129	TArrayD fAngleMaxParam ; // Max opening angle selection parameters
	130	Bool_t fUseAngleCut ; // Select pairs depending on their opening angle
	131	Float_t fShiftMinAngle ; // Correction shift for min angle from true kinematic limit, resolution effects
	132
	133	Bool_t fKeepNeutralMesonHistos ; // Keep neutral meson selection histograms
3bfcb597	134
477d6cee	135	//Histograms
9542ac75	136	TH2F * fhAnglePairNoCut ; //! Aperture angle of decay photons, no cuts
	137	TH2F * fhAnglePairOpeningAngleCut ; //! Aperture angle of decay photons, cut on opening angle
	138	TH2F * fhAnglePairAsymmetryCut ; //! Aperture angle of decay photons, asymmetry cut
	139	TH2F * fhAnglePairAllCut ; //! Aperture angle of decay photons, all cuts
	140
	141	TH2F * fhInvMassPairNoCut ; //! Invariant mass of decay photons, no cuts
	142	TH2F * fhInvMassPairOpeningAngleCut ; //! Invariant mass of decay photons, cut on opening angle
	143	TH2F * fhInvMassPairAsymmetryCut ; //! Invariant mass of decay photons, asymmetry cut
	144	TH2F * fhInvMassPairAllCut ; //! Invariant mass of decay photons, all cuts
	145
	146	TH2F * fhAsymmetryNoCut ; //! Asymmetry of decay photons, no cuts
	147	TH2F * fhAsymmetryOpeningAngleCut ; //! Asymmetry of decay photons, cut on opening angle
	148	TH2F * fhAsymmetryAllCut ; //! Asymmetry of decay photons, all cuts
477d6cee	149
477d6cee	150	//Histograms binning and range
9542ac75	151	Int_t fHistoNEBins ; // Number of bins in pi0 E axis
	152	Float_t fHistoEMax ; // Maximum value of pi0 E histogram range
	153	Float_t fHistoEMin ; // Minimum value of pi0 E histogram range
	154
9542ac75	155	Int_t fHistoNAngleBins ; // Number of bins in angle axis
	156	Float_t fHistoAngleMax ; // Maximum value of angle histogram range
	157	Float_t fHistoAngleMin ; // Minimum value of angle histogram range
	158
	159	Int_t fHistoNIMBins ; // Number of bins in Invariant Mass axis
	160	Float_t fHistoIMMax ; // Maximum value of Invariant Mass histogram range
	161	Float_t fHistoIMMin ; // Minimum value of Invariant Mass histogram range
	162
3bfcb597	163	ClassDef(AliNeutralMesonSelection,6)
1c5acb87	164
9542ac75	165	} ;
1c5acb87	166
	167	#endif //ALINEUTRALMESONSELECTION_H
	168
	169
	170