AliTPCTransform.h

Go to the documentation of this file.

#ifndef ALITPCTRANSFORM_H
#define ALITPCTRANSFORM_H

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



class AliTPCRecoParam;
class TTreeSRedirector;
class TGraph;
class AliTPCclusterMI;
#include "AliTPCChebCorr.h"
#include "AliTransform.h"
#include <time.h>

class AliTPCTransform:public AliTransform {
public:
  AliTPCTransform();
  AliTPCTransform(const AliTPCTransform& transform);

  virtual ~AliTPCTransform();
  virtual void Transform(Double_t *x,Int_t *i,UInt_t time,
       Int_t coordinateType);
  void ResetCache();
  void SetPrimVertex(Double_t *vtx);
  void Local2RotatedGlobal(Int_t sec,  Double_t *x) const;
  void RotatedGlobal2Global(Int_t sector,Double_t *x) const;
  void Global2RotatedGlobal(Int_t sector,Double_t *x) const;
  void GetCosAndSin(Int_t sector,Double_t &cos,Double_t &sin) const;
  time_t GetCurrentTimeStamp() const { return fCurrentTimeStamp;}
  const AliTPCRecoParam * GetCurrentRecoParam() const {return fCurrentRecoParam;}
  AliTPCRecoParam * GetCurrentRecoParamNonConst() const {return fCurrentRecoParam;}
  UInt_t GetCurrentRunNumber() const { return fCurrentRun;}
  AliTPCChebCorr* GetCorrMapCacheRef() const {return fCorrMapCacheRef;}
  AliTPCChebCorr* GetCorrMapCache0() const {return fCorrMapCache0;}
  AliTPCChebCorr* GetCorrMapCache1() const {return fCorrMapCache1;}
  //
  Double_t TimeBin2Z(double t, int sector, double yLab) const;
  Double_t Z2TimeBin(double t, int sector, double yLab) const;
  //
  static TObjArray* LoadCorrectionMaps(Bool_t refMap, Bool_t corrMode=kTRUE);
  static AliTPCChebCorr* LoadFieldDependendStaticCorrectionMap(Bool_t ref,Bool_t corrMode=kTRUE,TObjArray* mapsArrProvided=0);
  void CleanCorrectionMaps();
  Double_t ErrY2Syst(const AliTPCclusterMI * cl, const double tgAngPhi);
  Double_t ErrZ2Syst(const AliTPCclusterMI * cl, const double tgAngLam);
  void ErrY2Z2Syst(const AliTPCclusterMI * cl, const double tgPhi, const double tgLam,double &serry2, double &serrz2);

  void LoadCorrectionMapsForTimeBin(TObjArray* mapsArrProvided=0);
  // set current values
  //
  void SetCurrentRecoParam(AliTPCRecoParam* param){fCurrentRecoParam=param;}
  void SetCurrentRun(Int_t run){fCurrentRun=run;}
  void SetCurrentTimeStamp(time_t timeStamp);
  void ApplyTransformations(Double_t *xyz, Int_t volID);
  //
  // new correction maps
  Bool_t  UpdateTimeDependentCache();
  void    ApplyCorrectionMap(int roc, int row, double xyzSect[3]);
  void    ApplyDistortionMap(int roc, double xyzLab[3]);
  void    EvalCorrectionMap(int roc, int row, const double xyz[3], float *res, Bool_t ref=kFALSE);
  Float_t EvalCorrectionMap(int roc, int row, const double xyz[3], int dimOut, Bool_t ref=kFALSE);
  Float_t GetCorrMapComponent(int roc, int row, const double xyz[3], int dimOut);
  void    EvalDistortionMap(int roc, const double xyzSector[3], float *res, Bool_t ref=kFALSE);
  const   Float_t* GetLastMapCorrection() const {return fLastCorr;}
  const   Float_t* GetLastMapCorrectionRef() const {return fLastCorrRef;}
  Float_t GetCurrentMapScaling()             const {return fCurrentMapScaling;}
  Float_t GetCurrentMapFluctStrenght()       const {return fCurrentMapFluctStrenght;}
  void    SetCurrentMapFluctStrenght(float s=0.f)  {fCurrentMapFluctStrenght = s;}
  void    SetCorrectionMapMode(Bool_t v=kTRUE);
  Bool_t  GetCorrectionMapMode()             const {return fCorrMapMode;}
  //
  static void RotateToSectorUp(float *x, int& idROC);
  static void RotateToSectorDown(float *x, int& idROC);
  static void RotateToSectorUp(double *x, int& idROC);
  static void RotateToSectorDown(double *x,  int& idROC);
  static int  SectorUp(int idROC);
  static int  SectorDown(int idROC);
  static double GetMaxY2X() {return fgkMaxY2X;}
  void SetDebugStreamer(TTreeSRedirector * pcstream){fDebugStreamer=pcstream;}
  TTreeSRedirector *GetDebugStreemer() const { return fDebugStreamer;}     

  //
private:
  enum {  // time tolerances for various cache updates
    kMaxTDiffVDCorrVaria=3, // +-time update for minor vdrift corrections 
    kMaxTDiffVDCorrPT=60,   // +-time update for vdrift PT correction
    kMaxTDiffCorrMap=3      // +-time update for SP corrections
  };

  AliTPCTransform& operator=(const AliTPCTransform&); // not implemented
  Float_t  fLastCorr[4]; 
  Float_t  fLastCorrRef[4];  
  Double_t fCoss[18];  
  Double_t fSins[18];  
  Double_t fPrimVtx[3];
  AliTPCRecoParam * fCurrentRecoParam; 
  AliTPCChebCorr* fCorrMapCacheRef;    
  AliTPCChebCorr* fCorrMapCache0;      
  AliTPCChebCorr* fCorrMapCache1;      
  Float_t  fCurrentMapScaling;               
  Float_t  fCurrentMapFluctStrenght;   
  Float_t  fCorrMapLumiCOG;                  
  TGraph*  fLumiGraphRun;                    
  TGraph*  fLumiGraphMap;                    
  Int_t    fCurrentRun;                
  time_t   fCurrentTimeStamp;          
  Bool_t   fTimeDependentUpdated;      
  Bool_t   fCorrMapMode;               
  //
  // vdrift corrections cache
  Double_t fVDCorrectionTime;   
  Double_t fVDCorrectionTimeGY; 
  Double_t fTime0CorrTime;      
  Double_t fDeltaZCorrTime;     
  Double_t fDriftCorrPT;        
  Double_t fTBinOffset;         
  //
  // last cache update times
  time_t fLastTimeStampCorrMap; 
  time_t fLastTimeStampVDCorrPT; 
  time_t fLastTimeStampVDCorrVaria; 
  //
  static const Double_t fgkSin20;       // sin(20)
  static const Double_t fgkCos20;       // sin(20)
  static const Double_t fgkMaxY2X;      // tg(10)
  TTreeSRedirector *fDebugStreamer;     
  //
  ClassDef(AliTPCTransform,5)
};

//_________________________________________________
inline void AliTPCTransform::RotateToSectorUp(float *x, int& idROC)
{
  // rotate point in sector coordinates to sector+1
  idROC += ((idROC%18)==17) ? -17 : 1;
  float tmp = x[0];
  x[0] = fgkCos20*tmp - fgkSin20*x[1];
  x[1] = fgkSin20*tmp + fgkCos20*x[1];
}

//_________________________________________________
inline void AliTPCTransform::RotateToSectorDown(float *x, int& idROC)
{
  // rotate point in sector coordinates to sector-1
  idROC += ((idROC%18)== 0) ?  17 : -1; // change to the lower sector
  float tmp = x[0];
  x[0] = fgkCos20*tmp + fgkSin20*x[1];
  x[1] =-fgkSin20*tmp + fgkCos20*x[1];
}

//_________________________________________________
inline void AliTPCTransform::RotateToSectorUp(double *x, int& idROC)
{
  // rotate point in sector coordinates to sector+1
  idROC += ((idROC%18)==17) ? -17 : 1;
  double tmp = x[0];
  x[0] = fgkCos20*tmp - fgkSin20*x[1];
  x[1] = fgkSin20*tmp + fgkCos20*x[1];
}

//_________________________________________________
inline void AliTPCTransform::RotateToSectorDown(double *x, int& idROC)
{
  // rotate point in sector coordinates to sector-1
  idROC += ((idROC%18)== 0) ?  17 : -1; // change to the lower sector
  double tmp = x[0];
  x[0] = fgkCos20*tmp + fgkSin20*x[1];
  x[1] =-fgkSin20*tmp + fgkCos20*x[1];
}

//_________________________________________________
inline int AliTPCTransform::SectorUp(int idROC)
{
  // sector+1
  return idROC + (((idROC%18)==17) ? -17 : 1);
}

//_________________________________________________
inline int AliTPCTransform::SectorDown(int idROC)
{
  // sector-1
  return idROC + (((idROC%18)== 0) ?  17 : -1); // change to the lower sector
}


#endif