[u/mrichter/AliRoot.git] / PWG / CaloTrackCorrBase / AliCaloPID.h

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

//_________________________________________________________________________
// Class for PID selection with calorimeters
// The Output of the main method GetIdentifiedParticleType is a PDG number identifying the cluster, 
// being kPhoton, kElectron, kPi0 ... as defined in the header file
//   - GetIdentifiedParticleType(const AliVCluster * cluster) 
//      Assignes a PID tag to the cluster, right now there is the possibility to : use bayesian weights from reco, 
//      recalculate them (EMCAL) or use other procedures not used in reco.
//      In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
//      and do SwitchOnBayesianRecalculation().
//      To change the PID parameters from Low to High like the ones by default, use the constructor 
//      AliCaloPID(flux)
//      where flux is AliCaloPID::kLow or AliCaloPID::kHigh
//      If it is necessary to change the parameters use the constructor 
//      AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before.

//   - GetGetIdentifiedParticleTypeFromBayesian(const Double_t * pid, const Float_t energy)
//      Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle, 
//      executed when bayesian is ON by GetIdentifiedParticleType(const AliVCluster * cluster) 
//   - SetPIDBits: Simple PID, depending on the thresholds fLOCut fTOFCut and even the
//     result of the PID bayesian a different PID bit is set. 
//
//
//*-- Author: Gustavo Conesa (INFN-LNF)

// --- ROOT system ---
#include <TObject.h> 
class TString ;
class TLorentzVector ;
#include <TFormula.h>
class TList;
class TH2F ;

//--- AliRoot system ---
class AliVCluster;
class AliVCaloCells;
class AliAODPWG4Particle;
class AliEMCALPIDUtils;
class AliCalorimeterUtils;
class AliVEvent;

class AliCaloPID : public TObject {
	
 public: 
  
  AliCaloPID() ; // ctor
  AliCaloPID(Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
  AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
  virtual ~AliCaloPID() ;//virtual dtor
  	
  enum PidType 
  {
    kPhoton         = 22,
    kPi0            = 111,
    kEta            = 221, 
    kElectron       = 11, 
    kEleCon         =-11, 
    kNeutralHadron  = 2112, 
    kChargedHadron  = 211, 
    kNeutralUnknown = 130, 
    kChargedUnknown = 321
  };
  
  enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1};
  
  // Main methods
  
  //  TList *   GetCreateOutputObjects(); // Not implemented

  void      InitParameters();
  
  Bool_t    IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy,  Int_t nlm) const;

  Bool_t    IsInPi0SplitMassRange     (Float_t energy, Float_t mass, Int_t nlm) const;
  
  Bool_t    IsInM02Range              (Float_t m02) const;
  Bool_t    IsInPi0M02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
  Bool_t    IsInEtaM02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
  Bool_t    IsInConM02Range           (Float_t energy, Float_t m02,  Int_t nlm) const;
  
  
  Int_t     GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy) ;

  Int_t     GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster * cluster, AliVCaloCells* cells, 
                                                          AliCalorimeterUtils * caloutils,
                                                          Double_t vertex[3], 
                                                          Int_t & nLocMax, Double_t & mass, Double_t & angle,
                                                          TLorentzVector & l1  , TLorentzVector & l2,
                                                          Int_t   & absId1,   Int_t   & absId2,
                                                          Float_t & distbad1, Float_t & distbad2,
                                                          Bool_t  & fidcut1,  Bool_t  & fidcut2  ) const;
  
  Int_t     GetIdentifiedParticleType(AliVCluster * cluster) ;
  
  TString   GetPIDParametersList();
  
  Bool_t    IsTrackMatched(AliVCluster * cluster, AliCalorimeterUtils* cu, AliVEvent* event) const ;    
  
  void      SetPIDBits(AliVCluster * cluster, AliAODPWG4Particle *aodph, 
                       AliCalorimeterUtils* cu, AliVEvent* event);
  
  void      Print(const Option_t * opt)const;
  
  void      PrintClusterPIDWeights(const Double_t * pid) const;
  
  //Check if cluster photon-like. Uses photon cluster parameterization in real pp data 
  //Returns distance in sigmas. Recommended cut 2.5
  Float_t TestPHOSDispersion(Double_t pt, Double_t m20, Double_t m02) const ;
  //Checks distance to the closest track. Takes into account 
  //non-perpendicular incidence of tracks.
  Float_t TestPHOSChargedVeto(Double_t dx, Double_t dz, Double_t ptTrack,
                              Int_t chargeTrack, Double_t mf) const ;
  
  // Setters, getters
  
  void    SetDebug(Int_t deb)                  { fDebug = deb                 ; }
  Int_t   GetDebug()                     const { return fDebug                ; }	

  enum    eventType{kLow,kHigh};
  void    SetLowParticleFlux()                 { fParticleFlux        = kLow  ; }
  void    SetHighParticleFlux()                { fParticleFlux        = kHigh ; }  
  // not really used, only for bayesian recalculation in EMCAL, but could be useful in future
  
  // Bayesian
  
  void    SwitchOnBayesian()                   { fUseBayesianWeights  = kTRUE ; }
  void    SwitchOffBayesian()                  { fUseBayesianWeights  = kFALSE; }
  void    SwitchOnBayesianRecalculation()      { fRecalculateBayesian = kTRUE ; fUseBayesianWeights  = kTRUE ;} // EMCAL
  void    SwitchOffBayesianRecalculation()     { fRecalculateBayesian = kFALSE; } // EMCAL
  
  AliEMCALPIDUtils * GetEMCALPIDUtils() ; 
  
  //Weight getters
  Float_t GetEMCALPhotonWeight()         const { return fEMCALPhotonWeight    ; }
  Float_t GetEMCALPi0Weight()            const { return fEMCALPi0Weight       ; }
  Float_t GetEMCALElectronWeight()       const { return fEMCALElectronWeight  ; }
  Float_t GetEMCALChargeWeight()         const { return fEMCALChargeWeight    ; }
  Float_t GetEMCALNeutralWeight()        const { return fEMCALNeutralWeight   ; }
  Float_t GetPHOSPhotonWeight()          const { return fPHOSPhotonWeight     ; }
  Float_t GetPHOSPi0Weight()             const { return fPHOSPi0Weight        ; }
  Float_t GetPHOSElectronWeight()        const { return fPHOSElectronWeight   ; }
  Float_t GetPHOSChargeWeight()          const { return fPHOSChargeWeight     ; }
  Float_t GetPHOSNeutralWeight()         const { return fPHOSNeutralWeight    ; }
  
  Bool_t  IsPHOSPIDWeightFormulaOn()     const { return fPHOSWeightFormula    ; } 

  TFormula * GetPHOSPhotonWeightFormula()      { 
    if(!fPHOSPhotonWeightFormula) 
      fPHOSPhotonWeightFormula = new TFormula("phos_photon_weight",
                                              fPHOSPhotonWeightFormulaExpression);
    return fPHOSPhotonWeightFormula                                           ; } 
  
  TFormula * GetPHOSPi0WeightFormula()         { 
    if(!fPHOSPi0WeightFormula) 
      fPHOSPi0WeightFormula = new TFormula("phos_pi0_weight",
                                           fPHOSPi0WeightFormulaExpression);
    return fPHOSPi0WeightFormula                                              ; } 
  
  TString  GetPHOSPhotonWeightFormulaExpression() const { return fPHOSPhotonWeightFormulaExpression ; } 
  TString  GetPHOSPi0WeightFormulaExpression()    const { return fPHOSPi0WeightFormulaExpression    ; } 
  
  //Weight setters
  void    SetEMCALPhotonWeight  (Float_t  w)   { fEMCALPhotonWeight   = w     ; }
  void    SetEMCALPi0Weight     (Float_t  w)   { fEMCALPi0Weight      = w     ; }
  void    SetEMCALElectronWeight(Float_t  w)   { fEMCALElectronWeight = w     ; }
  void    SetEMCALChargeWeight  (Float_t  w)   { fEMCALChargeWeight   = w     ; }
  void    SetEMCALNeutralWeight (Float_t  w)   { fEMCALNeutralWeight  = w     ; }
  void    SetPHOSPhotonWeight   (Float_t  w)   { fPHOSPhotonWeight    = w     ; }
  void    SetPHOSPi0Weight      (Float_t  w)   { fPHOSPi0Weight       = w     ; }
  void    SetPHOSElectronWeight (Float_t  w)   { fPHOSElectronWeight  = w     ; }
  void    SetPHOSChargeWeight   (Float_t  w)   { fPHOSChargeWeight    = w     ; }
  void    SetPHOSNeutralWeight  (Float_t  w)   { fPHOSNeutralWeight   = w     ; }
  
  void    UsePHOSPIDWeightFormula   (Bool_t ok )           { fPHOSWeightFormula                 = ok ; } 
  void    SetPHOSPhotonWeightFormulaExpression(TString ph) { fPHOSPhotonWeightFormulaExpression = ph ; } 
  void    SetPHOSPi0WeightFormulaExpression   (TString pi) { fPHOSPi0WeightFormulaExpression    = pi ; }
  
  //PID cuts 
  
  void    SetEMCALLambda0CutMax(Float_t lcut ) { fEMCALL0CutMax     = lcut    ; }
  Float_t GetEMCALLambda0CutMax()        const { return fEMCALL0CutMax        ; }   
  
  void    SetEMCALLambda0CutMin(Float_t lcut ) { fEMCALL0CutMin     = lcut    ; }
  Float_t GetEMCALLambda0CutMin()        const { return fEMCALL0CutMin        ; }   
  
  void    SetEMCALDEtaCut(Float_t dcut )       { fEMCALDEtaCut      = dcut    ; }
  Float_t GetEMCALDEtaCut()              const { return fEMCALDEtaCut         ; }   
  
  void    SetEMCALDPhiCut(Float_t dcut )       { fEMCALDPhiCut      = dcut    ; }
  Float_t GetEMCALDPhiCut()              const { return fEMCALDPhiCut         ; }   
  
  void    SetTOFCut(Float_t tcut )             { fTOFCut            = tcut    ; }
  Float_t GetTOFCut()                    const { return fTOFCut               ; }   
  
  void    SetPHOSRCut(Float_t rcut )           { fPHOSRCut          = rcut    ; }
  Float_t GetPHOSRCut()                  const { return fPHOSRCut             ; }   

  void    SetPHOSDispersionCut(Float_t dcut )  { fPHOSDispersionCut = dcut    ; }
  Float_t GetPHOSDispersionCut()         const { return fPHOSDispersionCut    ; }   
  
  // Cluster splitting analysis
  
  void    SwitchOnSimpleSplitMassCut()         { fUseSimpleMassCut   = kTRUE  ; }
  void    SwitchOffSimpleSplitMassCut()        { fUseSimpleMassCut   = kFALSE ; }

  void    SwitchOnSimpleSplitM02Cut()          { fUseSimpleM02Cut    = kTRUE  ; }
  void    SwitchOffSimpleSplitM02Cut()         { fUseSimpleM02Cut    = kFALSE ; }
  
  void    SwitchOnSplitAsymmetryCut()          { fUseSplitAsyCut     = kTRUE  ; }
  void    SwitchOffSplitAsymmetryCut()         { fUseSplitAsyCut     = kFALSE ; }
  Bool_t  IsSplitAsymmetryCutOn()              { return fUseSplitAsyCut       ; }

  void    SwitchOnSplitShowerShapeCut()        { fUseSplitSSCut      = kTRUE  ; }
  void    SwitchOffSplitShowerShapeCut()       { fUseSplitSSCut      = kFALSE ; }
  Bool_t  IsSplitShowerShapeCutOn()            { return fUseSplitSSCut        ; }
  
  void    SetClusterSplittingM02Cut(Float_t min=0, Float_t max=100) 
  { fSplitM02MinCut   = min ; fSplitM02MaxCut  = max ; }
  
  void    SetClusterSplittingMinNCells(Int_t c) { fSplitMinNCells = c         ; }
  Int_t   GetClusterSplittingMinNCells() const  { return fSplitMinNCells      ; }
  
  void    SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i]  = min ; }
  Float_t GetSplitEnergyFractionMinimum(Int_t i) const       { if( i < 3 && i >=0 ) return fSplitEFracMin[i] ;  else return 0 ; }

  void    SetSubClusterEnergyMinimum   (Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSubClusterEMin[i] = min ; }
  Float_t GetSubClusterEnergyMinimum   (Int_t i) const       { if( i < 3 && i >=0 ) return fSubClusterEMin[i];  else return 0 ; }
  
  Float_t GetPi0MinMass()                const { return fMassPi0Min           ; } // Simple cut case
  Float_t GetEtaMinMass()                const { return fMassEtaMin           ; } // Simple cut case
  Float_t GetPhotonMinMass()             const { return fMassPhoMin           ; }  
  Float_t GetPi0MaxMass()                const { return fMassPi0Max           ; }
  Float_t GetEtaMaxMass()                const { return fMassEtaMax           ; }
  Float_t GetPhotonMaxMass()             const { return fMassPhoMax           ; }
  
  void    SetSplitWidthSigma(Float_t s)        { fSplitWidthSigma        = s  ; }

  void    SetPi0MassShiftHighECell(Float_t s)  { fMassShiftHighECell     = s  ; }
  
  void    SetPi0MassSelectionParameters    (Int_t inlm, Int_t iparam, Float_t param)
  { if(iparam < 6 ) fMassPi0Param[inlm][iparam] = param ; }

  void    SetPi0WidthSelectionParameters    (Int_t inlm, Int_t iparam, Float_t param)
  { if(iparam < 6 ) fWidthPi0Param[inlm][iparam] = param ; }
  
  void    SetM02MaximumSelectionParameters      (Int_t inlm, Int_t iparam, Float_t param)
  { if(iparam < 5 && inlm < 2) fM02MaxParam[inlm][iparam] = param ; }
  
  void    SetM02MaximumShiftForNLMN(Int_t shift) { fM02MaxParamShiftNLMN = shift ; }
  
  void    SetM02MinimumSelectionParameters      (Int_t inlm, Int_t iparam, Float_t param)
  { if(iparam < 5 && inlm < 2) fM02MinParam[inlm][iparam] = param ; }
  
  void    SetAsymmetryMinimumSelectionParameters(Int_t inlm, Int_t iparam, Float_t param)
  { if(iparam < 4 && inlm < 2) fAsyMinParam[inlm][iparam] = param ; }

  void    SetPi0MassRange(Float_t min, Float_t max)    { fMassPi0Min    = min ; fMassPi0Max = max ; } // Simple case
  void    SetEtaMassRange(Float_t min, Float_t max)    { fMassEtaMin    = min ; fMassEtaMax = max ; }
  void    SetPhotonMassRange(Float_t min, Float_t max) { fMassPhoMin    = min ; fMassPhoMax = max ; }
    
private:
  
  Int_t	    fDebug;                             // Debug level
  Int_t     fParticleFlux;                      // Particle flux for setting PID parameters

  // Bayesian
  AliEMCALPIDUtils * fEMCALPIDUtils;            // Pointer to EMCALPID to redo the PID Bayesian calculation
  Bool_t    fUseBayesianWeights;                // Select clusters based on weights calculated in reconstruction
  Bool_t    fRecalculateBayesian;               // Recalculate PID bayesian or use simple PID?

  Float_t   fEMCALPhotonWeight;                 // Bayesian PID weight for photons in EMCAL 
  Float_t   fEMCALPi0Weight;                    // Bayesian PID weight for pi0 in EMCAL 
  Float_t   fEMCALElectronWeight;               // Bayesian PID weight for electrons in EMCAL 
  Float_t   fEMCALChargeWeight;                 // Bayesian PID weight for charged hadrons in EMCAL 
  Float_t   fEMCALNeutralWeight;                // Bayesian PID weight for neutral hadrons in EMCAL 
  Float_t   fPHOSPhotonWeight;                  // Bayesian PID weight for photons in PHOS 
  Float_t   fPHOSPi0Weight;                     // Bayesian PID weight for pi0 in PHOS 
  Float_t   fPHOSElectronWeight;                // Bayesian PID weight for electrons in PHOS 
  Float_t   fPHOSChargeWeight;                  // Bayesian PID weight for charged hadrons in PHOS 
  Float_t   fPHOSNeutralWeight;                 // Bayesian PID weight for neutral hadrons in PHOS 
  
  Bool_t    fPHOSWeightFormula ;                // Use parametrized weight threshold, function of energy
  TFormula *fPHOSPhotonWeightFormula ;          // Formula for photon weight
  TFormula *fPHOSPi0WeightFormula ;             // Formula for pi0 weight
  TString   fPHOSPhotonWeightFormulaExpression; // Photon weight formula in string
  TString   fPHOSPi0WeightFormulaExpression;    // Pi0 weight formula in string

  // PID calculation
  Float_t   fEMCALL0CutMax;                     // Max Cut on shower shape lambda0, used in PID evaluation, only EMCAL
  Float_t   fEMCALL0CutMin;                     // Min Cut on shower shape lambda0, used in PID evaluation, only EMCAL
  Float_t   fEMCALDEtaCut;                      // Track matching cut on Dz
  Float_t   fEMCALDPhiCut;                      // Track matching cut on Dx

  Float_t   fTOFCut;                            // Cut on TOF, used in PID evaluation
  
  Float_t   fPHOSDispersionCut;                 // Shower shape elipse radious cut
  Float_t   fPHOSRCut;                          // Track-Cluster distance cut for track matching in PHOS  
  
  // Cluster splitting mass ranges
  Bool_t    fUseSimpleMassCut;                  // Use simple min-max pi0 mass cut
  Bool_t    fUseSimpleM02Cut;                   // Use simple min-max M02 cut
  Bool_t    fUseSplitAsyCut ;                   // Remove splitted clusters with too large asymmetry
  Bool_t    fUseSplitSSCut  ;                   // Remove splitted clusters out of shower shape band
  Float_t   fSplitM02MaxCut ;                   // Study clusters with l0 smaller than cut
  Float_t   fSplitM02MinCut ;                   // Study clusters with l0 larger than cut  // simple case
  Int_t     fSplitMinNCells ;                   // Study clusters with ncells larger than cut  
  Float_t   fMassEtaMin  ;                      // Min Eta mass
  Float_t   fMassEtaMax  ;                      // Max Eta mass  
  Float_t   fMassPi0Min  ;                      // Min Pi0 mass // simple cut case
  Float_t   fMassPi0Max  ;                      // Min Pi0 mass // simple cut case
  Float_t   fMassPhoMin  ;                      // Min Photon mass
  Float_t   fMassPhoMax  ;                      // Min Photon mass
  Float_t   fMassPi0Param [2][6] ;              // mean mass param, 2 regions in energy
  Float_t   fWidthPi0Param[2][6] ;              // width param, 2 regions in energy
  Float_t   fM02MinParam[2][5] ;                // 5 param for expo + pol fit on M02 minimum for pi0 selection (maximum for conversions)
  Float_t   fM02MaxParam[2][5] ;                // 5 param for expo + pol fit on M02 maximum for pi0 selection
  Float_t   fM02MaxParamShiftNLMN;              // shift of max M02 for NLM>2
  Float_t   fAsyMinParam[2][4] ;                // 3 param for fit on asymmetry minimum, for 2 cases, NLM=1 and NLM>=2
  Float_t   fSplitEFracMin[3]  ;                // Do not use clusters with too large energy in cluster compared
                                                // to energy in splitted clusters, depeding on NLM
  Float_t   fSubClusterEMin[3]  ;               // Do not use sub-clusters with too low energy depeding on NLM
  Float_t   fSplitWidthSigma;                   // Cut on mass+-width*fSplitWidthSigma
  Float_t   fMassShiftHighECell;                // Shift cuts 5 MeV for Ecell > 150 MeV, default Ecell > 50 MeV

  AliCaloPID & operator = (const AliCaloPID & cpid) ; // cpy assignment
  AliCaloPID(              const AliCaloPID & cpid) ; // cpy ctor
  
  ClassDef(AliCaloPID,22)
  
} ;


#endif //ALICALOPID_H
Commit	Line	Data
1c5acb87	1	#ifndef ALICALOPID_H
	2	#define ALICALOPID_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
1c5acb87	5
1c5acb87	6	//_________________________________________________________________________
bdd2a262	7	// Class for PID selection with calorimeters
49b5c49b	8	// The Output of the main method GetIdentifiedParticleType is a PDG number identifying the cluster,
bdd2a262	9	// being kPhoton, kElectron, kPi0 ... as defined in the header file
3c1d9afb	10	// - GetIdentifiedParticleType(const AliVCluster * cluster)
49b5c49b	11	// Assignes a PID tag to the cluster, right now there is the possibility to : use bayesian weights from reco,
49b5c49b	12	// recalculate them (EMCAL) or use other procedures not used in reco.
bdd2a262	13	// In order to recalculate Bayesian, it is necessary to load the EMCALUtils library
	14	// and do SwitchOnBayesianRecalculation().
	15	// To change the PID parameters from Low to High like the ones by default, use the constructor
	16	// AliCaloPID(flux)
	17	// where flux is AliCaloPID::kLow or AliCaloPID::kHigh
	18	// If it is necessary to change the parameters use the constructor
	19	// AliCaloPID(AliEMCALPIDUtils *utils) and set the parameters before.
49b5c49b	20
3c1d9afb	21	// - GetGetIdentifiedParticleTypeFromBayesian(const Double_t * pid, const Float_t energy)
49b5c49b	22	// Reads the PID weights array of the ESDs and depending on its magnitude identifies the particle,
3c1d9afb	23	// executed when bayesian is ON by GetIdentifiedParticleType(const AliVCluster * cluster)
9a6fa057	24	// - SetPIDBits: Simple PID, depending on the thresholds fLOCut fTOFCut and even the
bdd2a262	25	// result of the PID bayesian a different PID bit is set.
bdd2a262	26	//
1c5acb87	27	//
	28	//*-- Author: Gustavo Conesa (INFN-LNF)
	29
	30	// --- ROOT system ---
	31	#include <TObject.h>
	32	class TString ;
	33	class TLorentzVector ;
a5fb4114	34	#include <TFormula.h>
f21fc003	35	class TList;
d39cba7e	36	class TH2F ;
1c5acb87	37
1c5acb87	38	//--- AliRoot system ---
0ae57829	39	class AliVCluster;
3c1d9afb	40	class AliVCaloCells;
1c5acb87	41	class AliAODPWG4Particle;
c5693f62	42	class AliEMCALPIDUtils;
f2ccb5b8	43	class AliCalorimeterUtils;
49b5c49b	44	class AliVEvent;
1c5acb87	45
	46	class AliCaloPID : public TObject {
	47
477d6cee	48	public:
	49
	50	AliCaloPID() ; // ctor
8a2dbbff	51	AliCaloPID(Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
f21fc003	52	AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
477d6cee	53	virtual ~AliCaloPID() ;//virtual dtor
c5693f62	54
3c1d9afb	55	enum PidType
3c1d9afb	56	{
a5fb4114	57	kPhoton = 22,
	58	kPi0 = 111,
	59	kEta = 221,
	60	kElectron = 11,
	61	kEleCon =-11,
	62	kNeutralHadron = 2112,
	63	kChargedHadron = 211,
477d6cee	64	kNeutralUnknown = 130,
a5fb4114	65	kChargedUnknown = 321
477d6cee	66	};
	67
	68	enum TagType {kPi0Decay, kEtaDecay, kOtherDecay, kConversion, kNoTag = -1};
	69
49b5c49b	70	// Main methods
49b5c49b	71
9e5f7975	72	// TList * GetCreateOutputObjects(); // Not implemented
d39cba7e	73
a5fb4114	74	void InitParameters();
9a6fa057	75
8a2dbbff	76	Bool_t IsInPi0SplitAsymmetryRange(Float_t energy, Float_t asy, Int_t nlm) const;
995c6150	77
8a2dbbff	78	Bool_t IsInPi0SplitMassRange (Float_t energy, Float_t mass, Int_t nlm) const;
995c6150	79
8a2dbbff	80	Bool_t IsInM02Range (Float_t m02) const;
	81	Bool_t IsInPi0M02Range (Float_t energy, Float_t m02, Int_t nlm) const;
	82	Bool_t IsInEtaM02Range (Float_t energy, Float_t m02, Int_t nlm) const;
	83	Bool_t IsInConM02Range (Float_t energy, Float_t m02, Int_t nlm) const;
5a72d9af	84
5a72d9af	85
8a2dbbff	86	Int_t GetIdentifiedParticleTypeFromBayesWeights(Bool_t isEMCAL, Double_t * pid, Float_t energy) ;
3c1d9afb	87
	88	Int_t GetIdentifiedParticleTypeFromClusterSplitting(AliVCluster * cluster, AliVCaloCells* cells,
	89	AliCalorimeterUtils * caloutils,
	90	Double_t vertex[3],
bfdcf7fb	91	Int_t & nLocMax, Double_t & mass, Double_t & angle,
cfdf2b91	92	TLorentzVector & l1 , TLorentzVector & l2,
4914e781	93	Int_t & absId1, Int_t & absId2,
4914e781	94	Float_t & distbad1, Float_t & distbad2,
8a2dbbff	95	Bool_t & fidcut1, Bool_t & fidcut2 ) const;
477d6cee	96
8a2dbbff	97	Int_t GetIdentifiedParticleType(AliVCluster * cluster) ;
477d6cee	98
9a6fa057	99	TString GetPIDParametersList();
477d6cee	100
49b5c49b	101	Bool_t IsTrackMatched(AliVCluster * cluster, AliCalorimeterUtils* cu, AliVEvent* event) const ;
49b5c49b	102
3c1d9afb	103	void SetPIDBits(AliVCluster * cluster, AliAODPWG4Particle *aodph,
49b5c49b	104	AliCalorimeterUtils* cu, AliVEvent* event);
477d6cee	105
a5fb4114	106	void Print(const Option_t * opt)const;
a5fb4114	107
3c1d9afb	108	void PrintClusterPIDWeights(const Double_t * pid) const;
3c1d9afb	109
49b5c49b	110	//Check if cluster photon-like. Uses photon cluster parameterization in real pp data
49b5c49b	111	//Returns distance in sigmas. Recommended cut 2.5
8a2dbbff	112	Float_t TestPHOSDispersion(Double_t pt, Double_t m20, Double_t m02) const ;
49b5c49b	113	//Checks distance to the closest track. Takes into account
49b5c49b	114	//non-perpendicular incidence of tracks.
8a2dbbff	115	Float_t TestPHOSChargedVeto(Double_t dx, Double_t dz, Double_t ptTrack,
8a2dbbff	116	Int_t chargeTrack, Double_t mf) const ;
49b5c49b	117
	118	// Setters, getters
	119
	120	void SetDebug(Int_t deb) { fDebug = deb ; }
	121	Int_t GetDebug() const { return fDebug ; }
	122
	123	enum eventType{kLow,kHigh};
	124	void SetLowParticleFlux() { fParticleFlux = kLow ; }
	125	void SetHighParticleFlux() { fParticleFlux = kHigh ; }
	126	// not really used, only for bayesian recalculation in EMCAL, but could be useful in future
	127
	128	// Bayesian
	129
	130	void SwitchOnBayesian() { fUseBayesianWeights = kTRUE ; }
	131	void SwitchOffBayesian() { fUseBayesianWeights = kFALSE; }
	132	void SwitchOnBayesianRecalculation() { fRecalculateBayesian = kTRUE ; fUseBayesianWeights = kTRUE ;} // EMCAL
	133	void SwitchOffBayesianRecalculation() { fRecalculateBayesian = kFALSE; } // EMCAL
	134
c5693f62	135	AliEMCALPIDUtils * GetEMCALPIDUtils() ;
477d6cee	136
477d6cee	137	//Weight getters
49b5c49b	138	Float_t GetEMCALPhotonWeight() const { return fEMCALPhotonWeight ; }
	139	Float_t GetEMCALPi0Weight() const { return fEMCALPi0Weight ; }
	140	Float_t GetEMCALElectronWeight() const { return fEMCALElectronWeight ; }
	141	Float_t GetEMCALChargeWeight() const { return fEMCALChargeWeight ; }
	142	Float_t GetEMCALNeutralWeight() const { return fEMCALNeutralWeight ; }
	143	Float_t GetPHOSPhotonWeight() const { return fPHOSPhotonWeight ; }
	144	Float_t GetPHOSPi0Weight() const { return fPHOSPi0Weight ; }
	145	Float_t GetPHOSElectronWeight() const { return fPHOSElectronWeight ; }
	146	Float_t GetPHOSChargeWeight() const { return fPHOSChargeWeight ; }
	147	Float_t GetPHOSNeutralWeight() const { return fPHOSNeutralWeight ; }
	148
	149	Bool_t IsPHOSPIDWeightFormulaOn() const { return fPHOSWeightFormula ; }
	150
	151	TFormula * GetPHOSPhotonWeightFormula() {
a5fb4114	152	if(!fPHOSPhotonWeightFormula)
	153	fPHOSPhotonWeightFormula = new TFormula("phos_photon_weight",
	154	fPHOSPhotonWeightFormulaExpression);
49b5c49b	155	return fPHOSPhotonWeightFormula ; }
477d6cee	156
49b5c49b	157	TFormula * GetPHOSPi0WeightFormula() {
a5fb4114	158	if(!fPHOSPi0WeightFormula)
	159	fPHOSPi0WeightFormula = new TFormula("phos_pi0_weight",
	160	fPHOSPi0WeightFormulaExpression);
49b5c49b	161	return fPHOSPi0WeightFormula ; }
5ae09196	162
49b5c49b	163	TString GetPHOSPhotonWeightFormulaExpression() const { return fPHOSPhotonWeightFormulaExpression ; }
49b5c49b	164	TString GetPHOSPi0WeightFormulaExpression() const { return fPHOSPi0WeightFormulaExpression ; }
5ae09196	165
a5fb4114	166	//Weight setters
49b5c49b	167	void SetEMCALPhotonWeight (Float_t w) { fEMCALPhotonWeight = w ; }
	168	void SetEMCALPi0Weight (Float_t w) { fEMCALPi0Weight = w ; }
	169	void SetEMCALElectronWeight(Float_t w) { fEMCALElectronWeight = w ; }
	170	void SetEMCALChargeWeight (Float_t w) { fEMCALChargeWeight = w ; }
	171	void SetEMCALNeutralWeight (Float_t w) { fEMCALNeutralWeight = w ; }
	172	void SetPHOSPhotonWeight (Float_t w) { fPHOSPhotonWeight = w ; }
	173	void SetPHOSPi0Weight (Float_t w) { fPHOSPi0Weight = w ; }
	174	void SetPHOSElectronWeight (Float_t w) { fPHOSElectronWeight = w ; }
	175	void SetPHOSChargeWeight (Float_t w) { fPHOSChargeWeight = w ; }
	176	void SetPHOSNeutralWeight (Float_t w) { fPHOSNeutralWeight = w ; }
	177
	178	void UsePHOSPIDWeightFormula (Bool_t ok ) { fPHOSWeightFormula = ok ; }
	179	void SetPHOSPhotonWeightFormulaExpression(TString ph) { fPHOSPhotonWeightFormulaExpression = ph ; }
	180	void SetPHOSPi0WeightFormulaExpression (TString pi) { fPHOSPi0WeightFormulaExpression = pi ; }
d39cba7e	181
49b5c49b	182	//PID cuts
d39cba7e	183
49b5c49b	184	void SetEMCALLambda0CutMax(Float_t lcut ) { fEMCALL0CutMax = lcut ; }
	185	Float_t GetEMCALLambda0CutMax() const { return fEMCALL0CutMax ; }
	186
	187	void SetEMCALLambda0CutMin(Float_t lcut ) { fEMCALL0CutMin = lcut ; }
	188	Float_t GetEMCALLambda0CutMin() const { return fEMCALL0CutMin ; }
	189
	190	void SetEMCALDEtaCut(Float_t dcut ) { fEMCALDEtaCut = dcut ; }
	191	Float_t GetEMCALDEtaCut() const { return fEMCALDEtaCut ; }
	192
	193	void SetEMCALDPhiCut(Float_t dcut ) { fEMCALDPhiCut = dcut ; }
	194	Float_t GetEMCALDPhiCut() const { return fEMCALDPhiCut ; }
	195
	196	void SetTOFCut(Float_t tcut ) { fTOFCut = tcut ; }
	197	Float_t GetTOFCut() const { return fTOFCut ; }
	198
	199	void SetPHOSRCut(Float_t rcut ) { fPHOSRCut = rcut ; }
	200	Float_t GetPHOSRCut() const { return fPHOSRCut ; }
a5fb4114	201
49b5c49b	202	void SetPHOSDispersionCut(Float_t dcut ) { fPHOSDispersionCut = dcut ; }
	203	Float_t GetPHOSDispersionCut() const { return fPHOSDispersionCut ; }
	204
3c1d9afb	205	// Cluster splitting analysis
3c1d9afb	206
5a72d9af	207	void SwitchOnSimpleSplitMassCut() { fUseSimpleMassCut = kTRUE ; }
5a72d9af	208	void SwitchOffSimpleSplitMassCut() { fUseSimpleMassCut = kFALSE ; }
3c1d9afb	209
5a72d9af	210	void SwitchOnSimpleSplitM02Cut() { fUseSimpleM02Cut = kTRUE ; }
	211	void SwitchOffSimpleSplitM02Cut() { fUseSimpleM02Cut = kFALSE ; }
	212
667432ef	213	void SwitchOnSplitAsymmetryCut() { fUseSplitAsyCut = kTRUE ; }
667432ef	214	void SwitchOffSplitAsymmetryCut() { fUseSplitAsyCut = kFALSE ; }
40cc0ed9	215	Bool_t IsSplitAsymmetryCutOn() { return fUseSplitAsyCut ; }
40cc0ed9	216
035e250e	217	void SwitchOnSplitShowerShapeCut() { fUseSplitSSCut = kTRUE ; }
035e250e	218	void SwitchOffSplitShowerShapeCut() { fUseSplitSSCut = kFALSE ; }
40cc0ed9	219	Bool_t IsSplitShowerShapeCutOn() { return fUseSplitSSCut ; }
035e250e	220
3c1d9afb	221	void SetClusterSplittingM02Cut(Float_t min=0, Float_t max=100)
	222	{ fSplitM02MinCut = min ; fSplitM02MaxCut = max ; }
	223
eb4ccbd1	224	void SetClusterSplittingMinNCells(Int_t c) { fSplitMinNCells = c ; }
eb4ccbd1	225	Int_t GetClusterSplittingMinNCells() const { return fSplitMinNCells ; }
667432ef	226
2c36e041	227	void SetSplitEnergyFractionMinimum(Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSplitEFracMin[i] = min ; }
	228	Float_t GetSplitEnergyFractionMinimum(Int_t i) const { if( i < 3 && i >=0 ) return fSplitEFracMin[i] ; else return 0 ; }
	229
	230	void SetSubClusterEnergyMinimum (Int_t i, Float_t min){ if (i < 3 && i >=0 ) fSubClusterEMin[i] = min ; }
	231	Float_t GetSubClusterEnergyMinimum (Int_t i) const { if( i < 3 && i >=0 ) return fSubClusterEMin[i]; else return 0 ; }
3c1d9afb	232
5a72d9af	233	Float_t GetPi0MinMass() const { return fMassPi0Min ; } // Simple cut case
5a72d9af	234	Float_t GetEtaMinMass() const { return fMassEtaMin ; } // Simple cut case
3c1d9afb	235	Float_t GetPhotonMinMass() const { return fMassPhoMin ; }
	236	Float_t GetPi0MaxMass() const { return fMassPi0Max ; }
	237	Float_t GetEtaMaxMass() const { return fMassEtaMax ; }
	238	Float_t GetPhotonMaxMass() const { return fMassPhoMax ; }
	239
5a72d9af	240	void SetSplitWidthSigma(Float_t s) { fSplitWidthSigma = s ; }
ac207ee4	241
8a871c4f	242	void SetPi0MassShiftHighECell(Float_t s) { fMassShiftHighECell = s ; }
1be44524	243
	244	void SetPi0MassSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
	245	{ if(iparam < 6 ) fMassPi0Param[inlm][iparam] = param ; }
	246
	247	void SetPi0WidthSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
	248	{ if(iparam < 6 ) fWidthPi0Param[inlm][iparam] = param ; }
	249
5b4c2f5b	250	void SetM02MaximumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
1be44524	251	{ if(iparam < 5 && inlm < 2) fM02MaxParam[inlm][iparam] = param ; }
	252
	253	void SetM02MaximumShiftForNLMN(Int_t shift) { fM02MaxParamShiftNLMN = shift ; }
	254
a5a3f703	255	void SetM02MinimumSelectionParameters (Int_t inlm, Int_t iparam, Float_t param)
1be44524	256	{ if(iparam < 5 && inlm < 2) fM02MinParam[inlm][iparam] = param ; }
1be44524	257
afc83530	258	void SetAsymmetryMinimumSelectionParameters(Int_t inlm, Int_t iparam, Float_t param)
ac207ee4	259	{ if(iparam < 4 && inlm < 2) fAsyMinParam[inlm][iparam] = param ; }
5a72d9af	260
	261	void SetPi0MassRange(Float_t min, Float_t max) { fMassPi0Min = min ; fMassPi0Max = max ; } // Simple case
	262	void SetEtaMassRange(Float_t min, Float_t max) { fMassEtaMin = min ; fMassEtaMax = max ; }
	263	void SetPhotonMassRange(Float_t min, Float_t max) { fMassPhoMin = min ; fMassPhoMax = max ; }
667432ef	264
f2ccb5b8	265	private:
477d6cee	266
49b5c49b	267	Int_t fDebug; // Debug level
	268	Int_t fParticleFlux; // Particle flux for setting PID parameters
	269
	270	// Bayesian
	271	AliEMCALPIDUtils * fEMCALPIDUtils; // Pointer to EMCALPID to redo the PID Bayesian calculation
	272	Bool_t fUseBayesianWeights; // Select clusters based on weights calculated in reconstruction
	273	Bool_t fRecalculateBayesian; // Recalculate PID bayesian or use simple PID?
	274
	275	Float_t fEMCALPhotonWeight; // Bayesian PID weight for photons in EMCAL
	276	Float_t fEMCALPi0Weight; // Bayesian PID weight for pi0 in EMCAL
	277	Float_t fEMCALElectronWeight; // Bayesian PID weight for electrons in EMCAL
	278	Float_t fEMCALChargeWeight; // Bayesian PID weight for charged hadrons in EMCAL
	279	Float_t fEMCALNeutralWeight; // Bayesian PID weight for neutral hadrons in EMCAL
	280	Float_t fPHOSPhotonWeight; // Bayesian PID weight for photons in PHOS
	281	Float_t fPHOSPi0Weight; // Bayesian PID weight for pi0 in PHOS
	282	Float_t fPHOSElectronWeight; // Bayesian PID weight for electrons in PHOS
	283	Float_t fPHOSChargeWeight; // Bayesian PID weight for charged hadrons in PHOS
	284	Float_t fPHOSNeutralWeight; // Bayesian PID weight for neutral hadrons in PHOS
a5fb4114	285
9a6fa057	286	Bool_t fPHOSWeightFormula ; // Use parametrized weight threshold, function of energy
	287	TFormula *fPHOSPhotonWeightFormula ; // Formula for photon weight
	288	TFormula *fPHOSPi0WeightFormula ; // Formula for pi0 weight
a5fb4114	289	TString fPHOSPhotonWeightFormulaExpression; // Photon weight formula in string
	290	TString fPHOSPi0WeightFormulaExpression; // Pi0 weight formula in string
	291
49b5c49b	292	// PID calculation
	293	Float_t fEMCALL0CutMax; // Max Cut on shower shape lambda0, used in PID evaluation, only EMCAL
	294	Float_t fEMCALL0CutMin; // Min Cut on shower shape lambda0, used in PID evaluation, only EMCAL
	295	Float_t fEMCALDEtaCut; // Track matching cut on Dz
	296	Float_t fEMCALDPhiCut; // Track matching cut on Dx
ae182e60	297
49b5c49b	298	Float_t fTOFCut; // Cut on TOF, used in PID evaluation
	299
	300	Float_t fPHOSDispersionCut; // Shower shape elipse radious cut
	301	Float_t fPHOSRCut; // Track-Cluster distance cut for track matching in PHOS
49b5c49b	302
3c1d9afb	303	// Cluster splitting mass ranges
5a72d9af	304	Bool_t fUseSimpleMassCut; // Use simple min-max pi0 mass cut
5a72d9af	305	Bool_t fUseSimpleM02Cut; // Use simple min-max M02 cut
035e250e	306	Bool_t fUseSplitAsyCut ; // Remove splitted clusters with too large asymmetry
035e250e	307	Bool_t fUseSplitSSCut ; // Remove splitted clusters out of shower shape band
667432ef	308	Float_t fSplitM02MaxCut ; // Study clusters with l0 smaller than cut
5a72d9af	309	Float_t fSplitM02MinCut ; // Study clusters with l0 larger than cut // simple case
3c1d9afb	310	Int_t fSplitMinNCells ; // Study clusters with ncells larger than cut
	311	Float_t fMassEtaMin ; // Min Eta mass
	312	Float_t fMassEtaMax ; // Max Eta mass
5a72d9af	313	Float_t fMassPi0Min ; // Min Pi0 mass // simple cut case
5a72d9af	314	Float_t fMassPi0Max ; // Min Pi0 mass // simple cut case
3c1d9afb	315	Float_t fMassPhoMin ; // Min Photon mass
3c1d9afb	316	Float_t fMassPhoMax ; // Min Photon mass
1be44524	317	Float_t fMassPi0Param [2][6] ; // mean mass param, 2 regions in energy
	318	Float_t fWidthPi0Param[2][6] ; // width param, 2 regions in energy
	319	Float_t fM02MinParam[2][5] ; // 5 param for expo + pol fit on M02 minimum for pi0 selection (maximum for conversions)
	320	Float_t fM02MaxParam[2][5] ; // 5 param for expo + pol fit on M02 maximum for pi0 selection
	321	Float_t fM02MaxParamShiftNLMN; // shift of max M02 for NLM>2
	322	Float_t fAsyMinParam[2][4] ; // 3 param for fit on asymmetry minimum, for 2 cases, NLM=1 and NLM>=2
4d97a954	323	Float_t fSplitEFracMin[3] ; // Do not use clusters with too large energy in cluster compared
4d97a954	324	// to energy in splitted clusters, depeding on NLM
2c36e041	325	Float_t fSubClusterEMin[3] ; // Do not use sub-clusters with too low energy depeding on NLM
5a72d9af	326	Float_t fSplitWidthSigma; // Cut on mass+-width*fSplitWidthSigma
ac207ee4	327	Float_t fMassShiftHighECell; // Shift cuts 5 MeV for Ecell > 150 MeV, default Ecell > 50 MeV
5a72d9af	328
5a72d9af	329	AliCaloPID & operator = (const AliCaloPID & cpid) ; // cpy assignment
5a72d9af	330	AliCaloPID( const AliCaloPID & cpid) ; // cpy ctor
c5693f62	331
745a2967	332	ClassDef(AliCaloPID,22)
3c1d9afb	333
e5dbdaf0	334	} ;
1c5acb87	335
	336
	337	#endif //ALICALOPID_H
	338
	339
	340