]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TPC/AliTPCFCVoltError3D.h
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add histograms with masked regions due to frame, setting of the regions added, some...
[u/mrichter/AliRoot.git] / TPC / AliTPCFCVoltError3D.h
diff --git a/TPC/AliTPCFCVoltError3D.h b/TPC/AliTPCFCVoltError3D.h
index bf52ac83562c593a636ba3a49fd723044554e9f1..8575bd6e6685e15e732aa7fba4867eeab50fe202 100644 (file)
--- a/TPC/AliTPCFCVoltError3D.h
+++ b/TPC/AliTPCFCVoltError3D.h
@@ -5,9 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCFCVoltError3D class                                              //
-// date: 01/06/2010                                                       //
 // Authors: Jim Thomas, Stefan Rossegger                                  //
 ////////////////////////////////////////////////////////////////////////////
 
@@ -38,31 +36,34 @@ public:
   // Set rod shift in Voltage equivalents (40V ~ 1mm)
   // rod numbers: 0-17 (IFC), 18-35 (OFC)
   // note: strips move accordingly
-  void SetRodVoltShiftA(Int_t rod, Float_t voltOffset) {fRodVoltShiftA[rod]=voltOffset; fInitLookUp=kFALSE;}
-  void SetRodVoltShiftC(Int_t rod, Float_t voltOffset) {fRodVoltShiftC[rod]=voltOffset; fInitLookUp=kFALSE;}
+  void SetRodVoltShiftA(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fRodVoltShiftA[rod]=voltOffset; fInitLookUp=doInit;}
+  void SetRodVoltShiftC(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fRodVoltShiftC[rod]=voltOffset; fInitLookUp=doInit;}
   Float_t GetRodVoltShiftA(Int_t i) const {return fRodVoltShiftA[i];}// 0-17: IFC, 18-35; OFC
   Float_t GetRodVoltShiftC(Int_t i) const {return fRodVoltShiftC[i];}// 0-17: IFC, 18-35; OFC
 
   // Set rotated clip (just at High Voltage RODs) in Voltage equivalents (40V ~ 1mm)
   // rod number: 0 (IFC), 1 (OFC)
-  void SetRotatedClipVoltA(Int_t rod, Float_t voltOffset) {fRotatedClipVoltA[rod]=voltOffset; fInitLookUp=kFALSE;}
-  void SetRotatedClipVoltC(Int_t rod, Float_t voltOffset) {fRotatedClipVoltC[rod]=voltOffset; fInitLookUp=kFALSE;}
+  void SetRotatedClipVoltA(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fRotatedClipVoltA[rod]=voltOffset; fInitLookUp=doInit;}
+  void SetRotatedClipVoltC(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fRotatedClipVoltC[rod]=voltOffset; fInitLookUp=doInit;}
   Float_t GetRotatedClipVoltA(Int_t i) const {return fRotatedClipVoltA[i];}// (0,1):(IFC,OFC)
   Float_t GetRotatedClipVoltC(Int_t i) const {return fRotatedClipVoltC[i];}// (0,1):(IFC,OFC)
 
   // Set rod shift in Voltage equivalents (40V ~ 1mm)
   // rod numbers: 0-17 (OFC)
   // note: strips DO NOT move, only the copper rods do ...
-  void SetOFCRodShiftA(Int_t rod, Float_t voltOffset) {fOFCRodShiftA[rod]=voltOffset; fInitLookUp=kFALSE;}
-  void SetOFCRodShiftC(Int_t rod, Float_t voltOffset) {fOFCRodShiftC[rod]=voltOffset; fInitLookUp=kFALSE;}
-  Float_t GetOFCRodShiftA(Int_t i) const {return fOFCRodShiftA[i];}// 0-17: OFC
-  Float_t GetOFCRodShiftC(Int_t i) const {return fOFCRodShiftC[i];}// 0-17: OFC
+  void SetCopperRodShiftA(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fCopperRodShiftA[rod]=voltOffset; fInitLookUp=doInit;}
+  void SetCopperRodShiftC(Int_t rod, Float_t voltOffset, Bool_t doInit=kTRUE) {fCopperRodShiftC[rod]=voltOffset; fInitLookUp=doInit;}
+  Float_t GetCopperRodShiftA(Int_t i) const {return fCopperRodShiftA[i];}// 0-17: IFC, 18-35; OFC
+  Float_t GetCopperRodShiftC(Int_t i) const {return fCopperRodShiftC[i];}// 0-17: IFC, 18-35; OFC
 
 
   void InitFCVoltError3D(); // Fill the lookup tables
+  void ForceInitFCVoltError3D() { fInitLookUp=kFALSE; InitFCVoltError3D(); }
 
   virtual void Print(const Option_t* option="") const;
 
+
+
 protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
@@ -77,16 +78,16 @@ private:
   Float_t fRodVoltShiftC[36];      // Rod (&strips) shift in Volt (40V~1mm) 
   Float_t fRotatedClipVoltA[2];    // rotated clips at HV rod
   Float_t fRotatedClipVoltC[2];    // rotated clips at HV rod
-  Float_t fOFCRodShiftA[18];        // only Rod shift on OFC
-  Float_t fOFCRodShiftC[18];        // only Rod shift on OFC
+  Float_t fCopperRodShiftA[36];    // only Rod shift 
+  Float_t fCopperRodShiftC[36];    // only Rod shift 
 
-  Bool_t fInitLookUp;           // flag to check it the Look Up table was created (SUM)
-  Bool_t fInitLookUpBasic[5];   // flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
+  Bool_t fInitLookUp;           // flag to check if the Look Up table was created (SUM)
+  Bool_t fInitLookUpBasic[6];   // ! flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
 
 
-  TMatrixD *fLookUpErOverEz[kNPhi];   // Array to store electric field integral (int Er/Ez)
-  TMatrixD *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
-  TMatrixD *fLookUpDeltaEz[kNPhi];    // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpErOverEz[kNPhi];   // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
+  TMatrixF *fLookUpDeltaEz[kNPhi];    // Array to store electric field integral (int Er/Ez)
 
   // basic numbers for the poisson relaxation //can be set individually in each class
   enum {kRows   =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
@@ -99,30 +100,34 @@ private:
   // needed for the faster calculation of the final distortion table
 
   // for Rod and Strip shift
-  TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices];   // Array to store electric field integral (int Er/Ez)
-  TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; // Array to store electric field integral (int Ephi/Ez)
-  TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices];    // Array to store electric field integral (int Ez)
+  TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices];   // ! Array to store electric field integral (int Er/Ez)
+  TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; // ! Array to store electric field integral (int Ephi/Ez)
+  TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices];    // ! Array to store electric field integral (int Ez)
 
-  TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices];   // Array to store electric field integral 
-  TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; // Array to store electric field integral 
-  TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices];    // Array to store electric field integral 
+  TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
 
   // for rotated clips
-  TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices];   // Array to store electric field integral 
-  TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; // Array to store electric field integral 
-  TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices];    // Array to store electric field integral 
+  TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
+
+  TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
 
-  TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices];   // Array to store electric field integral 
-  TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; // Array to store electric field integral 
-  TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices];    // Array to store electric field integral 
+  // for (only rod) shift (copper rods)
+  TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
 
-  // for (only rod) shift (just OFC since they are copper plated)
-  TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices];   // Array to store electric field integral 
-  TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; // Array to store electric field integral 
-  TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices];    // Array to store electric field integral 
+  TMatrixD *fLookUpBasic6ErOverEz[kPhiSlices];   // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic6EphiOverEz[kPhiSlices]; // ! Array to store electric field integral 
+  TMatrixD *fLookUpBasic6DeltaEz[kPhiSlices];    // ! Array to store electric field integral 
 
 
-  ClassDef(AliTPCFCVoltError3D,0); 
+  ClassDef(AliTPCFCVoltError3D,3); //
 };
 
 #endif