AliTPCClusterParam.h

Go to the documentation of this file.

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

/* $Id: AliTPCClusterParam.h,v */



#include <TObject.h>
#include <TVectorDfwd.h>
#include <TMatrixDfwd.h>

class TTree;
class TObjArray;
class TH1;
class THnBase;
//_____________________________________________________________________________
class AliTPCClusterParam : public TObject {
 public:
  static AliTPCClusterParam* Instance();
  AliTPCClusterParam();
  AliTPCClusterParam(const AliTPCClusterParam& param);
  AliTPCClusterParam & operator=(const AliTPCClusterParam& param);
  virtual           ~AliTPCClusterParam();
  virtual void  Print(Option_t* option = "") const;
  void SetInstance(AliTPCClusterParam *const param){fgInstance = param;}
  //
  // Seting functions
  //
  void FitData(TTree * tree);
  void FitResol(TTree * tree);
  void FitRMS(TTree * tree);
  void SetQnorm(Int_t ipad, Int_t itype,  const TVectorD *const norm);
  void SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode=1);
  Double_t  GetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType) const;
  TMatrixD *GetQnormCorrMatrix(){return fQNormCorr;};
  void ResetQnormCorr();
  void SetWaveCorrectionMap( THnBase *WaveCorrectionMap);
  void SetResolutionYMap( THnBase *ResolutionYMap);
  //
  // Charge parameterization
  //
  Float_t Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
  Float_t QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);


  Float_t QnormPos(Int_t ipad, Bool_t isMax,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt);
  static Float_t SQnormPos(Int_t ipad, Bool_t isMax,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt){ return fgInstance->QnormPos(ipad,isMax,pad,time,z,sy2,sz2,qm,qt);;}

  Float_t PosCorrection(Int_t type, Int_t ipad,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm);
  static Float_t  SPosCorrection(Int_t type, Int_t ipad,  Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm){ return fgInstance->PosCorrection(type,ipad,pad,time,z,sy2,sz2,qm);}
  //
  // Error parameterization
  //
  Float_t GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle) const;
  Float_t GetError0Par(Int_t dim, Int_t type, Float_t z, Float_t angle) const;
  Float_t GetError1(Int_t dim, Int_t type, Float_t z, Float_t angle) const;
  Float_t GetErrorQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
  Float_t GetErrorQPar(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
  Float_t GetErrorQParScaled(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
  //
  // Shape parameterization
  //
  Float_t GetRMS0(Int_t dim, Int_t type, Float_t z, Float_t angle) const;
  Float_t GetRMS1(Int_t dim, Int_t type, Float_t z, Float_t angle) const;
  Float_t GetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
  Float_t GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
  Float_t GetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM) const;
  //
  // Correction and resolution maps
  //
  const THnBase *GetWaveCorrectionMap() const { return fWaveCorrectionMap; }
  const THnBase *GetResolutionYMap() const { return  fResolutionYMap; }
  Float_t GetWaveCorrection(Int_t Type, Float_t Z, Int_t QMax, Float_t Pad, Float_t angleY ) const;
  static Float_t SGetWaveCorrection(Int_t Type, Float_t Z, Int_t QMax, Float_t Pad, Float_t angleY ){return (fgInstance) ? fgInstance->GetWaveCorrection(Type,Z,QMax,Pad,angleY):0;}
  //
  //
  //
  void Test(TTree * tree, const char *output="TestClusterParam.root");
  //
  // static methods equivalents  - use instance of param object - useful for tree draw and TF2 visualization
  static Float_t SGetError0(Int_t dim, Int_t type, Float_t z, Float_t angle){
    return fgInstance->GetError0(dim,type,z,angle);
  }
  static Float_t SGetError0Par(Int_t dim, Int_t type, Float_t z, Float_t angle){
    return fgInstance->GetError0Par(dim,type,z,angle);
  }
  static Float_t SGetError1(Int_t dim, Int_t type, Float_t z, Float_t angle){
    return fgInstance->GetError1(dim,type,z,angle);
  }
  static Float_t SGetErrorQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean){
    return fgInstance->GetErrorQ(dim,type,z,angle,Qmean);
  }
  static Float_t SGetErrorQPar(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean){
    return fgInstance->GetErrorQPar(dim,type,z,angle,Qmean);
  }
  static Float_t SGetErrorQParScaled(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean){
    return fgInstance->GetErrorQParScaled(dim,type,z,angle,Qmean);
  }

  static Float_t SGetRMS0(Int_t dim, Int_t type, Float_t z, Float_t angle){
    return fgInstance->GetRMS0(dim,type,z,angle);
  }
  static Float_t SGetRMS1(Int_t dim, Int_t type, Float_t z, Float_t angle){
    return fgInstance->GetRMS1(dim,type,z,angle);
  }
  static Float_t SGetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean){
    return fgInstance->GetRMSQ(dim,type,z,angle,Qmean);
  }
  static Float_t SGetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean){
    return fgInstance->GetRMSSigma(dim,type,z,angle,Qmean);
  }
  static Float_t SGetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM){
    return fgInstance->GetShapeFactor(dim,type,z,angle,Qmean, rmsL, rmsM);
  }
  //
  //
  static Float_t SQnorm(Int_t ipad, Int_t itype,Float_t dr, Float_t ty, Float_t tz) {return fgInstance->Qnorm(ipad, itype, dr,ty,tz);}
  static Float_t SQnormHis(Int_t ipad, Int_t itype,Float_t dr, Float_t ty, Float_t tz) {return fgInstance->QnormHis(ipad, itype, dr,ty,tz);}

  //
  // Analytical position angular correction
  //
  static Double_t  GaussConvolution(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1);
  static Double_t  GaussConvolutionTail(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau);
  static Double_t  GaussConvolutionGamma4(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau);
  static Double_t QmaxCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0,  Float_t effLength=0, Float_t effDiff=1);
  static Double_t QtotCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0, Float_t qtot, Float_t thr,  Float_t effLength=0, Float_t effDiff=1);

  //
  //
  //
  void FitResol0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitResol0Par(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitResol1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error);
  void FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error);
  void FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  void FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
  //
  TVectorD*& PosYcor(Int_t ind) {return fPosYcor[ind];}
  TVectorD*& PosZcor(Int_t ind) {return fPosZcor[ind];}
  Float_t GetParamS0Par(Int_t i, Int_t j, Int_t k) const {return fParamS0Par[i][j][k];}
  Float_t GetParamRMS0(Int_t i, Int_t j, Int_t k) const {return fParamRMS0[i][j][k];}
  TVectorD* QpadTnorm() const {return fQpadTnorm;}
  TVectorD* QpadMnorm() const {return fQpadMnorm;}

protected:
  Float_t fRatio;               
  Float_t fParamS0[2][3][4];    
  Float_t fErrorS0[2][3][4];    
  Float_t fParamS0Par[2][3][7];    
  Float_t fErrorS0Par[2][3][7];    
  Float_t fParamSQ[2][3][6];    
  Float_t fErrorSQ[2][3][6];    
  Float_t fParamSQPar[2][3][9];    
  Float_t fErrorSQPar[2][3][9];    
  Float_t fParamS1[2][4];       
  Float_t fErrorS1[2][4];       
  //
  Float_t fParamRMS0[2][3][4];   
  Float_t fErrorRMS0[2][3][4];   
  Float_t fParamRMSQ[2][3][6];   
  Float_t fErrorRMSQ[2][3][6];   
  Float_t fParamRMS1[2][5];      
  Float_t fErrorRMS1[2][5];      
  Float_t fErrorRMSSys[2];        
  Float_t fRMSSigmaRatio[2][2];   
  Float_t fRMSSigmaFit[2][3][2];   
  //
  // charge normalization parametrization
  //
  TObjArray *fQNorm;              
  TMatrixD  *fQNormCorr;          
  TObjArray *fQNormHis;           
  //
  TVectorD  *fPosQTnorm[3];       
  TVectorD  *fPosQMnorm[3];       
  TVectorD  *fQpadTnorm;          
  TVectorD  *fQpadMnorm;          
  //
  // Position corrections
  //
  TVectorD  *fPosYcor[3];       
  TVectorD  *fPosZcor[3];       
  //
  // Wave Correction Map
  //
  THnBase* fWaveCorrectionMap; 
  Bool_t   fWaveCorrectionMirroredPad;   
  Bool_t   fWaveCorrectionMirroredZ;     
  Bool_t   fWaveCorrectionMirroredAngle; 
  //
  // Resolution Map
  //
  THnBase* fResolutionYMap; 
  //
  static AliTPCClusterParam*   fgInstance; 
  ClassDef(AliTPCClusterParam,7)    //  TPC Cluster parameter class
};

#endif