ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

// _________________________________________________________________
//
// Begin_Html
//   <h2>AliTPCFCVoltError3D class   </h2>       
//   The class calculates the space point distortions due to residual voltage errors 
//   on the Field Cage (FC) boundaries (rods and strips) of the TPC in 3D. It uses 
//   the Poisson relaxation technique in three dimension as implemented in the parent class. 
//   <p>
//   Although the calculation is performed in 3D, the calculation time was significantly 
//   reduced by using certain symmetry conditions within the calculation.
//   <p>
//   The input parameters can be set via the functions (e.g.) SetRodVoltShift(rod,dV) where 
//   rod is the number of the rod on which the voltage offset dV is set. The corresponding 
//   shift in z direction would be $dz=dV/40$ with an opposite sign for the C side. The 
//   rods are numbered in anti-clock-wise direction starting at $\phi=0$. Rods in the IFC 
//   are from 0 to 17, rods on the OFC go from 18 to 35. <br>
//   This convention is following the offline numbering scheme of the ROCs.
//   <p>
//   Different misalignment scenarios can be modeled: 
//   <ul>
//   <li> A rotated clip scenario is only possible at two positions (Rod 11 at IFC, rod 3(+18) at OFC) 
//        and can be set via SetRotatedClipVolt. The key feature is that at the mentioned positions,
//        the strip-ends were combined. At these positions, a systematic offset of one strip-end in
//        respect to the other is possible. 
//   <li> A normal rod offset, where the strips follow the movement of the rod, can be set via 
//        SetRodVoltShift. It has a anti-mirrored signature in terms of distortions when compared 
//        to the rotated clip. This misalignment is possible at each single rod of the FC.
//   <li> A simple rod offset, where the strips do not follow the shift, results in an even more 
//        localized distortion close to the rod. The difference to a rod shift, where the strips follow,
//        is more dominant on the OFC. This effect can be set via the function SetCopperRodShift.
//   </ul>
// End_Html
//
// Begin_Macro(source)
//   {
//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
//   TCanvas *c2 = new TCanvas("cAliTPCVoltError3D","cAliTPCVoltError3D",500,450); 
//   AliTPCFCVoltError3D fc;
//   fc.SetOmegaTauT1T2(0,1,1); 
//   fc.SetRotatedClipVoltA(0,40);
//   fc.SetRodVoltShiftA(3,40); 
//   fc.SetCopperRodShiftA(7+18,40);
//   fc.SetRodVoltShiftA(15+18,40); 
//   fc.CreateHistoDRPhiinXY(10)->Draw("cont4z");
//   return c2;
//   } 
// End_Macro
//
// Begin_Html
//   <p>
//   Date: 08/08/2010  <br>
//   Authors: Jim Thomas, Stefan Rossegger  
// End_Html 
// _________________________________________________________________


#include "AliMagF.h"
#include "TGeoGlobalMagField.h"
#include "AliTPCcalibDB.h"
#include "AliTPCParam.h"
#include "AliLog.h"
#include "TMatrixD.h"
#include "TMatrixF.h"

#include "TMath.h"
#include "AliTPCROC.h"
#include "AliTPCFCVoltError3D.h"

ClassImp(AliTPCFCVoltError3D)

AliTPCFCVoltError3D::AliTPCFCVoltError3D()
  : AliTPCCorrection("FieldCageVoltErrors","FieldCage (Rods) Voltage Errors"),
    fC0(0.),fC1(0.),
    fInitLookUp(kFALSE)
{
  //
  // default constructor
  //

  // flags for filled 'basic lookup tables'
  for (Int_t i=0; i<6; i++){
    fInitLookUpBasic[i]= kFALSE;  
  }

  // Boundary settings 
  for (Int_t i=0; i<36; i++){
    fRodVoltShiftA[i] = 0;  
    fRodVoltShiftC[i] = 0;  
  }
  for (Int_t i=0; i<2; i++){
    fRotatedClipVoltA[i] = 0;  
    fRotatedClipVoltC[i] = 0;  
  }
  // 
  for (Int_t i=0; i<36; i++){
    fCopperRodShiftA[i] = 0;  
    fCopperRodShiftC[i] = 0;  
  }

  // Array which will contain the solution according to the setted boundary conditions
  // it represents a sum up of the 4 basic look up tables (created individually)
  // see InitFCVoltError3D() function
  for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
    fLookUpErOverEz[k]   =  new TMatrixF(kNR,kNZ);  
    fLookUpEphiOverEz[k] =  new TMatrixF(kNR,kNZ);
    fLookUpDeltaEz[k]    =  new TMatrixF(kNR,kNZ);   
  }
  
  for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
    fLookUpBasic1ErOverEz[k]   = 0;
    fLookUpBasic1EphiOverEz[k] = 0; 
    fLookUpBasic1DeltaEz[k]    = 0;

    fLookUpBasic2ErOverEz[k]   = 0;
    fLookUpBasic2EphiOverEz[k] = 0; 
    fLookUpBasic2DeltaEz[k]    = 0;

    fLookUpBasic3ErOverEz[k]   = 0;
    fLookUpBasic3EphiOverEz[k] = 0; 
    fLookUpBasic3DeltaEz[k]    = 0;

    fLookUpBasic4ErOverEz[k]   = 0;
    fLookUpBasic4EphiOverEz[k] = 0; 
    fLookUpBasic4DeltaEz[k]    = 0;
    
    fLookUpBasic5ErOverEz[k]   = 0;
    fLookUpBasic5EphiOverEz[k] = 0; 
    fLookUpBasic5DeltaEz[k]    = 0;

    fLookUpBasic6ErOverEz[k]   = 0;
    fLookUpBasic6EphiOverEz[k] = 0; 
    fLookUpBasic6DeltaEz[k]    = 0;
  }

}

AliTPCFCVoltError3D::~AliTPCFCVoltError3D() {
  //
  // destructor
  //
  
  for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
    delete fLookUpErOverEz[k];
    delete fLookUpEphiOverEz[k];
    delete fLookUpDeltaEz[k];
  }

  for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
    delete fLookUpBasic1ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic1EphiOverEz[k]; 
    delete fLookUpBasic1DeltaEz[k]; 

    delete fLookUpBasic2ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic2EphiOverEz[k]; 
    delete fLookUpBasic2DeltaEz[k]; 
    
    delete fLookUpBasic3ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic3EphiOverEz[k]; 
    delete fLookUpBasic3DeltaEz[k]; 

    delete fLookUpBasic4ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic4EphiOverEz[k]; 
    delete fLookUpBasic4DeltaEz[k]; 

    delete fLookUpBasic5ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic5EphiOverEz[k]; 
    delete fLookUpBasic5DeltaEz[k]; 

    delete fLookUpBasic6ErOverEz[k];  // does nothing if pointer is zero!
    delete fLookUpBasic6EphiOverEz[k]; 
    delete fLookUpBasic6DeltaEz[k]; 

  }
}


Bool_t AliTPCFCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
  //
  // Add correction  and make them compact
  // Assumptions:
  //  - origin of distortion/correction are additive
  //  - only correction ot the same type supported ()
  if (corr==NULL) {
    AliError("Zerro pointer - correction");
    return kFALSE;
  }  
  AliTPCFCVoltError3D * corrC = dynamic_cast<AliTPCFCVoltError3D *>(corr);
  if (corrC == NULL)  {
    AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
    return kFALSE;
  }
  //
  for (Int_t isec=0; isec<36; isec++){
    fRodVoltShiftA[isec]+= weight*corrC->fRodVoltShiftA[isec];      // Rod (&strips) shift in Volt (40V~1mm) 
    fRodVoltShiftC[isec]+=weight*corrC->fRodVoltShiftC[isec];      // Rod (&strips) shift in Volt (40V~1mm) 
    fCopperRodShiftA[isec]+=weight*corrC->fCopperRodShiftA[isec];    // only Rod shift 
    fCopperRodShiftC[isec]+=weight*corrC->fCopperRodShiftC[isec];    // only Rod shift 
  }
  for (Int_t isec=0; isec<2; isec++){  
    fRotatedClipVoltA[isec]+= weight*corrC->fRotatedClipVoltA[isec];    // rotated clips at HV rod
    fRotatedClipVoltC[isec]+= weight*corrC-> fRotatedClipVoltC[isec];    // rotated clips at HV rod
  }

  return kTRUE;
}



void AliTPCFCVoltError3D::Init() {
  //
  // Initialization funtion
  //
  
  AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
  if (!magF) AliError("Magneticd field - not initialized");
  Double_t bzField = magF->SolenoidField()/10.; //field in T
  AliTPCParam *param= AliTPCcalibDB::Instance()->GetParameters();
  if (!param) AliError("Parameters - not initialized");
  Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]   // From dataBase: to be updated: per second (ideally)
  Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
  // Correction Terms for effective omegaTau; obtained by a laser calibration run
  SetOmegaTauT1T2(wt,fT1,fT2);

  if (!fInitLookUp) InitFCVoltError3D();
}

void AliTPCFCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
  //
  // Update function 
  //
  AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
  if (!magF) AliError("Magneticd field - not initialized");
  Double_t bzField = magF->SolenoidField()/10.; //field in T
  AliTPCParam *param= AliTPCcalibDB::Instance()->GetParameters();
  if (!param) AliError("Parameters - not initialized");
  Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us]  // From dataBase: to be updated: per second (ideally)
  Double_t ezField = 400; // [V/cm]   // to be updated: never (hopefully)
  Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ; 
  // Correction Terms for effective omegaTau; obtained by a laser calibration run
  SetOmegaTauT1T2(wt,fT1,fT2);


}



void AliTPCFCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
  //
  // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
  //   
  const Double_t kEpsilon=Double_t(FLT_MIN);

  if (!fInitLookUp) {
    AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
    InitFCVoltError3D();
  }

  static Bool_t forceInit=kTRUE; //temporary needed for back compatibility with old OCDB entries
  if (forceInit &&fLookUpErOverEz[0]){
    if (TMath::Abs(fLookUpErOverEz[0]->Sum())<kEpsilon){//temporary needed for back compatibility with old OCDB entries
      ForceInitFCVoltError3D();
    }
    forceInit=kFALSE;
  }


  Int_t   order     = 1 ;               // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2         
                                        // note that the poisson solution was linearly mirroed on this grid!
  Float_t intEr, intEphi, intDeltaEz;
  Float_t r, phi, z ;
  Int_t    sign;

  r      =  TMath::Sqrt( x[0]*x[0] + x[1]*x[1] ) ;
  phi    =  TMath::ATan2(x[1],x[0]) ;
  if ( phi < 0 ) phi += TMath::TwoPi() ;                   // Table uses phi from 0 to 2*Pi
  z      =  x[2] ;                                         // Create temporary copy of x[2]

  if ( (roc%36) < 18 ) {
    sign =  1;       // (TPC A side)
  } else {
    sign = -1;       // (TPC C side)
  }
  
  if ( sign==1  && z <  fgkZOffSet ) z =  fgkZOffSet;    // Protect against discontinuity at CE
  if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet;    // Protect against discontinuity at CE
  

  if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
    AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");

  // Get the Er and Ephi field integrals plus the integral over DeltaEz 
  intEr      = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
				  fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz  );
  intEphi    = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
				  fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz  );
  intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi, 
				  fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz  );

  //  printf("%lf %lf %lf\n",intEr,intEphi,intDeltaEz);

  // Calculate distorted position
  if ( r > 0.0 ) {
    phi =  phi + ( fC0*intEphi - fC1*intEr ) / r;      
    r   =  r   + ( fC0*intEr   + fC1*intEphi );  
  }
  
  // Calculate correction in cartesian coordinates
  dx[0] = r * TMath::Cos(phi) - x[0];
  dx[1] = r * TMath::Sin(phi) - x[1]; 
  dx[2] = intDeltaEz;  // z distortion - (internally scaled with driftvelocity dependency 
                       // on the Ez field plus the actual ROC misalignment (if set TRUE)

}

void AliTPCFCVoltError3D::InitFCVoltError3D() {
  //
  // Initialization of the Lookup table which contains the solutions of the 
  // Dirichlet boundary problem
  // Calculation of the single 3D-Poisson solver is done just if needed
  // (see basic lookup tables in header file)
  //

  const Int_t   order       =    1  ;  // Linear interpolation = 1, Quadratic = 2  
  const Float_t gridSizeR   =  (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
  const Float_t gridSizeZ   =  fgkTPCZ0 / (kColumns-1) ;
  const Float_t gridSizePhi =  TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);

  // temporary arrays to create the boundary conditions
  TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ; 
  for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
    arrayofArrayV[k]     =   new TMatrixD(kRows,kColumns) ;
    arrayofCharge[k]     =   new TMatrixD(kRows,kColumns) ;
  }
  Double_t  innerList[kPhiSlices], outerList[kPhiSlices] ;
  
  // list of point as used in the poisson relation and the interpolation (during sum up)
  Double_t  rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
  for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
    philist[k] =  gridSizePhi * k;
    for ( Int_t i = 0 ; i < kRows ; i++ )    {
      rlist[i] = fgkIFCRadius + i*gridSizeR ;
      for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
	zedlist[j]  = j * gridSizeZ ;
      }
    }
  }

  // ==========================================================================
  // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
  // Allow for different size grid spacing in R and Z directions
  
  const Int_t   symmetry[6] =    {1,1,-1,-1,1,1}; // shifted rod (2x), rotated clip (2x), only rod shift on OFC (1x)

  // check which lookup tables are needed ---------------------------------

  Bool_t needTable[6] ={kFALSE,kFALSE,kFALSE,kFALSE,kFALSE,kFALSE};

  // Shifted rods & strips
  for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
    if (fRodVoltShiftA[rod]!=0) needTable[0]=kTRUE;
    if (fRodVoltShiftC[rod]!=0) needTable[0]=kTRUE;
  }
  for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
    if (fRodVoltShiftA[rod]!=0) needTable[1]=kTRUE;
    if (fRodVoltShiftC[rod]!=0) needTable[1]=kTRUE;
  }
  // Rotated clips
  if (fRotatedClipVoltA[0]!=0 || fRotatedClipVoltC[0]!=0) needTable[2]=kTRUE;
  if (fRotatedClipVoltA[1]!=0 || fRotatedClipVoltC[1]!=0) needTable[3]=kTRUE;
 
  // shifted Copper rods 
  for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
    if (fCopperRodShiftA[rod]!=0) needTable[4]=kTRUE;
    if (fCopperRodShiftC[rod]!=0) needTable[4]=kTRUE;
  }
  // shifted Copper rods 
  for ( Int_t rod = 18; rod < 36 ; rod++ ) {
    if (fCopperRodShiftA[rod]!=0) needTable[5]=kTRUE;
    if (fCopperRodShiftC[rod]!=0) needTable[5]=kTRUE;
  }


  // reserve the arrays for the basic lookup tables ----------------------
  if (needTable[0] && !fInitLookUpBasic[0]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic1ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic1EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic1DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
  if (needTable[1] && !fInitLookUpBasic[1]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic2ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic2EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic2DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
  if (needTable[2] && !fInitLookUpBasic[2]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic3ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic3EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic3DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
  if (needTable[3] && !fInitLookUpBasic[3]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic4ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic4EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic4DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
  if (needTable[4] && !fInitLookUpBasic[4]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic5ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic5EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic5DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
  if (needTable[5] && !fInitLookUpBasic[5]) {
    for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {   // Possibly make an extra table to be used for 0 == 360
      fLookUpBasic6ErOverEz[k]   =   new TMatrixD(kRows,kColumns);
      fLookUpBasic6EphiOverEz[k] =   new TMatrixD(kRows,kColumns);
      fLookUpBasic6DeltaEz[k]    =   new TMatrixD(kRows,kColumns);
      // will be deleted in destructor
    }
  }
 
  // Set bondaries and solve Poisson's equation --------------------------
 
  for (Int_t look=0; look<6; look++) {
   
    Float_t inner18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;  
    Float_t outer18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ; 
  
    if (needTable[look] && !fInitLookUpBasic[look]) {

      // Specify which rod is the reference; other distortions calculated by summing over multiple rotations of refrence
      // Note: the interpolation later on depends on it!! Do not change if not really needed!
      if (look==0) {
	AliInfo(Form("IFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	inner18[0] = 1;  
      } else if (look==1) {
	AliInfo(Form("OFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	outer18[0] = 1;  
      } else if (look==2) {
	AliInfo(Form("IFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	inner18[0] = 1; 
      } else if (look==3) {
	AliInfo(Form("OFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	outer18[0] = 1;  
      } else if (look==4) {
	AliInfo(Form("IFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	inner18[0] = 1;  
      } else if (look==5) {
	AliInfo(Form("OFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
	outer18[0] = 1;  
      }
      // Build potentials on boundary stripes for a rotated clip (SYMMETRY==-1) or a shifted rod (SYMMETRY==1)
      if (look<4) {
	// in these cases, the strips follow the actual rod shift (linear interpolation between the rods)
	for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
	  Int_t slices = kPhiSlicesPerSector ;
	  Int_t ipoint = k/slices  ;  
	  innerList[k] = (((ipoint+1)*slices-k)*inner18[ipoint]-(k-ipoint*slices)*inner18[ipoint+1])/slices ;
	  outerList[k] = (((ipoint+1)*slices-k)*outer18[ipoint]-(k-ipoint*slices)*outer18[ipoint+1])/slices ;
	  if ( (k%slices) == 0 && symmetry[look] == -1 ) { innerList[k] = 0.0 ; outerList[k] = 0.0 ; } 
	  // above, force Zero if Anti-Sym
	} 
      } else if (look==4){
	// in this case, we assume that the strips stay at the correct position, but the rods move
	// the distortion is then much more localized around the rod (indicated by real data)
	for ( Int_t k = 0 ; k < kPhiSlices ; k++ )
	  innerList[k] = outerList[k] = 0;
	innerList[0] = inner18[0];     // point at rod
	innerList[0] = inner18[0]/4*3;  // point close to rod (educated guess)
      } else if (look==5){
	// in this case, we assume that the strips stay at the correct position, but the copper plated OFC-rods move
	// the distortion is then much more localized around the rod (indicated by real data)
	for ( Int_t k = 0 ; k < kPhiSlices ; k++ )
	  innerList[k] = outerList[k] = 0;
	outerList[0] = outer18[0];   // point at rod
	outerList[1] = outer18[0]/4; // point close to rod (educated-`guessed` scaling)
      }

      // Fill arrays with initial conditions.  V on the boundary and Charge in the volume.
      for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
	TMatrixD &arrayV    =  *arrayofArrayV[k] ;
	TMatrixD &charge    =  *arrayofCharge[k] ;
       	for ( Int_t i = 0 ; i < kRows ; i++ )    {
	  for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
	    arrayV(i,j) = 0.0 ; 
	    charge(i,j) = 0.0 ;
	    if ( i == 0 )       arrayV(i,j) = innerList[k] ; 
	    if ( i == kRows-1 ) arrayV(i,j) = outerList[k] ; 
	  }
	}      
	// no charge in the volume
	for ( Int_t i = 1 ; i < kRows-1 ; i++ )  { 
	  for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
	    charge(i,j)  =  0.0 ;
	  }
	}
      }      
     
      // Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
      // Allow for different size grid spacing in R and Z directions
      if (look==0) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic1ErOverEz, fLookUpBasic1EphiOverEz, fLookUpBasic1DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[0]) ;
	AliInfo("IFC - ROD&Strip shift : done ");
      } else if (look==1) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic2ErOverEz, fLookUpBasic2EphiOverEz, fLookUpBasic2DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[1]) ;
	
	AliInfo("OFC - ROD&Strip shift : done ");
      } else if (look==2) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic3ErOverEz, fLookUpBasic3EphiOverEz, fLookUpBasic3DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[2]) ;
	AliInfo("IFC - Clip rot. : done ");
      } else if (look==3) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic4ErOverEz, fLookUpBasic4EphiOverEz, fLookUpBasic4DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[3]) ;
	AliInfo("OFC - Clip rot. : done ");
      } else if (look==4) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic5ErOverEz, fLookUpBasic5EphiOverEz, fLookUpBasic5DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[4]) ;
	AliInfo("IFC - CopperRod shift : done ");
      } else if (look==5) {
	PoissonRelaxation3D( arrayofArrayV, arrayofCharge, 
			     fLookUpBasic6ErOverEz, fLookUpBasic6EphiOverEz, fLookUpBasic6DeltaEz,
			     kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[5]) ;
	AliInfo("OFC - CopperRod shift : done ");
      }
      
      fInitLookUpBasic[look] = kTRUE;
    }
  }
  

  // =============================================================================
  // Create the final lookup table with corresponding ROD shifts or clip rotations

  Float_t erIntegralSum   = 0.0 ;
  Float_t ephiIntegralSum = 0.0 ;
  Float_t ezIntegralSum   = 0.0 ;

  Double_t phiPrime     = 0. ;
  Double_t erIntegral   = 0. ;
  Double_t ephiIntegral = 0. ;
  Double_t ezIntegral   = 0. ;


  AliInfo("Calculation of combined Look-up Table");

  // Interpolate and sum the Basic lookup tables onto the standard grid
  Double_t  r, phi, z ;
  for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
    phi = fgkPhiList[k] ;

    TMatrixF &erOverEz   =  *fLookUpErOverEz[k]  ;
    TMatrixF &ephiOverEz =  *fLookUpEphiOverEz[k];
    TMatrixF &deltaEz    =  *fLookUpDeltaEz[k]   ;

    for ( Int_t i = 0 ; i < kNZ ; i++ ) {
      z = TMath::Abs(fgkZList[i]) ;  // Symmetric solution in Z that depends only on ABS(Z)
      for ( Int_t j = 0 ; j < kNR ; j++ ) { 
	r = fgkRList[j] ;
	// Interpolate basicLookup tables; once for each rod, then sum the results
	
	erIntegralSum   = 0.0 ;
	ephiIntegralSum = 0.0 ;
	ezIntegralSum   = 0.0 ;
 
	// SHIFTED RODS =========================================================

	// IFC ROD SHIFTS +++++++++++++++++++++++++++++
	for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
	  
	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  
	  if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
	  if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  

	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    

	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic1ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic1DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic1ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic1DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[0] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[0] == -1 ) erIntegral   *= -1  ;    

	  }

	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fRodVoltShiftA[rod]*erIntegral   ;
	    ephiIntegralSum += fRodVoltShiftA[rod]*ephiIntegral ;
	    ezIntegralSum   += fRodVoltShiftA[rod]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fRodVoltShiftC[rod]*erIntegral   ;
	    ephiIntegralSum += fRodVoltShiftC[rod]*ephiIntegral ;
	    ezIntegralSum   -= fRodVoltShiftC[rod]*ezIntegral;
	  }
	}

	// OFC ROD SHIFTS +++++++++++++++++++++++++++++
	for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {

	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  
	  if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
	  if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;  
		  
	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    

	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic2ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic2DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic2ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic2DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[1] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[1] == -1 ) erIntegral   *= -1  ;    

	  }

	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fRodVoltShiftA[rod]*erIntegral   ;
	    ephiIntegralSum += fRodVoltShiftA[rod]*ephiIntegral ;
	    ezIntegralSum   += fRodVoltShiftA[rod]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fRodVoltShiftC[rod]*erIntegral   ;
	    ephiIntegralSum += fRodVoltShiftC[rod]*ephiIntegral ;
	    ezIntegralSum   -= fRodVoltShiftC[rod]*ezIntegral;
	  }

	} // rod loop - shited ROD


	// Rotated clips =========================================================

	Int_t rodIFC = 11; // resistor rod positions, IFC
	Int_t rodOFC =  3; // resistor rod positions, OFC
	// just one rod on IFC and OFC

	// IFC ROTATED CLIP +++++++++++++++++++++++++++++
	for ( Int_t rod = rodIFC ; rod < rodIFC+1 ; rod++ ) { // loop over 1 to keep the "ignore"-functionality

	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  if ( fRotatedClipVoltA[0] == 0 && fgkZList[i] > 0) continue ;
	  if ( fRotatedClipVoltC[0] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
	  
	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
	  
	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic3ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic3DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic3ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic3DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[2] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[2] == -1 ) erIntegral   *= -1  ;    
	    
	  }
	  
	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fRotatedClipVoltA[0]*erIntegral   ;
	    ephiIntegralSum += fRotatedClipVoltA[0]*ephiIntegral ;
	    ezIntegralSum   += fRotatedClipVoltA[0]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fRotatedClipVoltC[0]*erIntegral   ;
	    ephiIntegralSum += fRotatedClipVoltC[0]*ephiIntegral ;
	    ezIntegralSum   -= fRotatedClipVoltC[0]*ezIntegral;
	  }
	}

	// OFC: ROTATED CLIP  +++++++++++++++++++++++++++++
	for ( Int_t rod = rodOFC ; rod < rodOFC+1 ; rod++ ) { // loop over 1 to keep the "ignore"-functionality
	  
	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  
	  if ( fRotatedClipVoltA[1] == 0 && fgkZList[i] > 0) continue ;
	  if ( fRotatedClipVoltC[1] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  
	  
	  
	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    
	  
	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic4ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic4DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic4ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic4DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[3] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[3] == -1 ) erIntegral   *= -1  ;    
	    
	  }
	  
	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fRotatedClipVoltA[1]*erIntegral   ;
	    ephiIntegralSum += fRotatedClipVoltA[1]*ephiIntegral ;
	    ezIntegralSum   += fRotatedClipVoltA[1]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fRotatedClipVoltC[1]*erIntegral   ;
	    ephiIntegralSum += fRotatedClipVoltC[1]*ephiIntegral ;
	    ezIntegralSum   -= fRotatedClipVoltC[1]*ezIntegral;
	  }
	}

	// IFC Cooper rod shift  +++++++++++++++++++++++++++++
	for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
	  
	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  
	  if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
	  if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - rod*kPhiSlicesPerSector*gridSizePhi ;  

	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    

	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic5ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic5DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic5ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic5DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[4] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[4] == -1 ) erIntegral   *= -1  ;    

	  }

	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fCopperRodShiftA[rod]*erIntegral   ;
	    ephiIntegralSum += fCopperRodShiftA[rod]*ephiIntegral ;
	    ezIntegralSum   += fCopperRodShiftA[rod]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fCopperRodShiftC[rod]*erIntegral   ;
	    ephiIntegralSum += fCopperRodShiftC[rod]*ephiIntegral ;
	    ezIntegralSum   -= fCopperRodShiftC[rod]*ezIntegral;
	  }
	}

	// OFC Cooper rod shift  +++++++++++++++++++++++++++++
	for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
	  
	  erIntegral = ephiIntegral = ezIntegral = 0.0 ;
	  
	  if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
	  if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;

	  // Rotate to a position where we have maps and prepare to sum
	  phiPrime =  phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;  

	  if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ;   // Stay in range from 0 to TwoPi    

	  if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic6ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic6DeltaEz   );
	    
	  }  else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
	    
	    phiPrime     = TMath::TwoPi() - phiPrime ;
	    
	    erIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices, 
					      rlist, zedlist, philist, fLookUpBasic6ErOverEz  );
	    ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
	    ezIntegral   = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
					      rlist, zedlist, philist, fLookUpBasic6DeltaEz   );
	    
	    // Flip symmetry of phi integral for symmetric boundary conditions
	    if ( symmetry[5] ==  1 ) ephiIntegral *= -1  ;    
	    // Flip symmetry of r integral if anti-symmetric boundary conditions 
	    if ( symmetry[5] == -1 ) erIntegral   *= -1  ;    

	  }

	  if ( fgkZList[i] > 0 ) {
	    erIntegralSum   += fCopperRodShiftA[rod]*erIntegral   ;
	    ephiIntegralSum += fCopperRodShiftA[rod]*ephiIntegral ;
	    ezIntegralSum   += fCopperRodShiftA[rod]*ezIntegral;
	  } else if ( fgkZList[i] < 0 ) {
	    erIntegralSum   += fCopperRodShiftC[rod]*erIntegral   ;
	    ephiIntegralSum += fCopperRodShiftC[rod]*ephiIntegral ;
	    ezIntegralSum   -= fCopperRodShiftC[rod]*ezIntegral;
	  }
	}

	// put the sum into the final lookup table
	erOverEz(j,i)   =  erIntegralSum;
	ephiOverEz(j,i) =  ephiIntegralSum;
	deltaEz(j,i)    =  ezIntegralSum;
	
	//	if (j==1) printf("%lf %lf %lf: %lf %lf %lf\n",r, phi, z, erIntegralSum,ephiIntegralSum,ezIntegralSum);
 
      } // endo r loop
    } // end of z loop
  } // end of phi loop


  // clear the temporary arrays lists
  for ( Int_t k = 0 ; k < kPhiSlices ; k++ )  {
    delete arrayofArrayV[k];
    delete arrayofCharge[k];
  }
 
  AliInfo(" done");
  fInitLookUp = kTRUE;

}

void AliTPCFCVoltError3D::Print(const Option_t* option) const {
  //
  // Print function to check the settings of the Rod shifts and the rotated clips
  // option=="a" prints the C0 and C1 coefficents for calibration purposes
  //

  TString opt = option; opt.ToLower();
  printf("%s\n",GetTitle());
  printf(" - ROD shifts  (residual voltage settings): 40V correspond to 1mm of shift\n");
  Int_t count = 0;
  printf("  : A-side - (Rod & Strips) \n     "); 
  for (Int_t i=0; i<36;i++) {
    if (fRodVoltShiftA[i]!=0) {
      printf("Rod%2d:%3.1fV ",i,fRodVoltShiftA[i]);
      count++;
    }
    if (count==0&&i==35) 
      printf("-> all at 0 V\n");
    else if (i==35){
      printf("\n");
      count=0;
    }
  } 
  printf("  : C-side - (Rod & Strips) \n     "); 
  for (Int_t i=0; i<36;i++) {
    if (fRodVoltShiftC[i]!=0) {
      printf("Rod%2d:%3.1fV ",i,fRodVoltShiftC[i]);
      count++;
    }
    if (count==0&&i==35) 
      printf("-> all at 0 V\n");
    else if (i==35){
      printf("\n");
      count=0;
    }
  } 
 
  printf(" - Rotated clips (residual voltage settings): 40V correspond to 1mm of 'offset'\n");
  if (fRotatedClipVoltA[0]!=0) {   printf("     A side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[0]); count++; }
  if (fRotatedClipVoltA[1]!=0) {   printf("     A side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[1]); count++; }
  if (fRotatedClipVoltC[0]!=0) {   printf("     C side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[0]); count++; }
  if (fRotatedClipVoltC[1]!=0) {   printf("     C side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[1]); count++; }
  if (count==0) 
    printf("     -> no rotated clips \n");

  count=0;
  printf(" - Copper ROD shifts (without strips):\n");
  printf("  : A-side - (Copper Rod shift) \n     "); 
  for (Int_t i=0; i<36;i++) {
    if (fCopperRodShiftA[i]!=0) {
      printf("Rod%2d:%3.1fV ",i,fCopperRodShiftA[i]);
      count++;
    }
    if (count==0&&i==35) 
      printf("-> all at 0 V\n");
    else if (i==35){
      printf("\n");
      count=0;
    }
  } 
  printf("  : C-side - (Copper Rod shift) \n     "); 
  for (Int_t i=0; i<36;i++) {
    if (fCopperRodShiftC[i]!=0) {
      printf("Rod%2d:%3.1fV ",i,fCopperRodShiftC[i]);
      count++;
    }
    if (count==0&&i==35) 
      printf("-> all at 0 V\n");
    else if (i==35){
      printf("\n");
      count=0;
    }
  } 

  if (opt.Contains("a")) { // Print all details
    printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
    printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
  }

  if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitFCVoltError3D() ...");

}
 AliTPCFCVoltError3D.cxx:1
 AliTPCFCVoltError3D.cxx:2
 AliTPCFCVoltError3D.cxx:3
 AliTPCFCVoltError3D.cxx:4
 AliTPCFCVoltError3D.cxx:5
 AliTPCFCVoltError3D.cxx:6
 AliTPCFCVoltError3D.cxx:7
 AliTPCFCVoltError3D.cxx:8
 AliTPCFCVoltError3D.cxx:9
 AliTPCFCVoltError3D.cxx:10
 AliTPCFCVoltError3D.cxx:11
 AliTPCFCVoltError3D.cxx:12
 AliTPCFCVoltError3D.cxx:13
 AliTPCFCVoltError3D.cxx:14
 AliTPCFCVoltError3D.cxx:15
 AliTPCFCVoltError3D.cxx:16
 AliTPCFCVoltError3D.cxx:17
 AliTPCFCVoltError3D.cxx:18
 AliTPCFCVoltError3D.cxx:19
 AliTPCFCVoltError3D.cxx:20
 AliTPCFCVoltError3D.cxx:21
 AliTPCFCVoltError3D.cxx:22
 AliTPCFCVoltError3D.cxx:23
 AliTPCFCVoltError3D.cxx:24
 AliTPCFCVoltError3D.cxx:25
 AliTPCFCVoltError3D.cxx:26
 AliTPCFCVoltError3D.cxx:27
 AliTPCFCVoltError3D.cxx:28
 AliTPCFCVoltError3D.cxx:29
 AliTPCFCVoltError3D.cxx:30
 AliTPCFCVoltError3D.cxx:31
 AliTPCFCVoltError3D.cxx:32
 AliTPCFCVoltError3D.cxx:33
 AliTPCFCVoltError3D.cxx:34
 AliTPCFCVoltError3D.cxx:35
 AliTPCFCVoltError3D.cxx:36
 AliTPCFCVoltError3D.cxx:37
 AliTPCFCVoltError3D.cxx:38
 AliTPCFCVoltError3D.cxx:39
 AliTPCFCVoltError3D.cxx:40
 AliTPCFCVoltError3D.cxx:41
 AliTPCFCVoltError3D.cxx:42
 AliTPCFCVoltError3D.cxx:43
 AliTPCFCVoltError3D.cxx:44
 AliTPCFCVoltError3D.cxx:45
 AliTPCFCVoltError3D.cxx:46
 AliTPCFCVoltError3D.cxx:47
 AliTPCFCVoltError3D.cxx:48
 AliTPCFCVoltError3D.cxx:49
 AliTPCFCVoltError3D.cxx:50
 AliTPCFCVoltError3D.cxx:51
 AliTPCFCVoltError3D.cxx:52
 AliTPCFCVoltError3D.cxx:53
 AliTPCFCVoltError3D.cxx:54
 AliTPCFCVoltError3D.cxx:55
 AliTPCFCVoltError3D.cxx:56
 AliTPCFCVoltError3D.cxx:57
 AliTPCFCVoltError3D.cxx:58
 AliTPCFCVoltError3D.cxx:59
 AliTPCFCVoltError3D.cxx:60
 AliTPCFCVoltError3D.cxx:61
 AliTPCFCVoltError3D.cxx:62
 AliTPCFCVoltError3D.cxx:63
 AliTPCFCVoltError3D.cxx:64
 AliTPCFCVoltError3D.cxx:65
 AliTPCFCVoltError3D.cxx:66
 AliTPCFCVoltError3D.cxx:67
 AliTPCFCVoltError3D.cxx:68
 AliTPCFCVoltError3D.cxx:69
 AliTPCFCVoltError3D.cxx:70
 AliTPCFCVoltError3D.cxx:71
 AliTPCFCVoltError3D.cxx:72
 AliTPCFCVoltError3D.cxx:73
 AliTPCFCVoltError3D.cxx:74
 AliTPCFCVoltError3D.cxx:75
 AliTPCFCVoltError3D.cxx:76
 AliTPCFCVoltError3D.cxx:77
 AliTPCFCVoltError3D.cxx:78
 AliTPCFCVoltError3D.cxx:79
 AliTPCFCVoltError3D.cxx:80
 AliTPCFCVoltError3D.cxx:81
 AliTPCFCVoltError3D.cxx:82
 AliTPCFCVoltError3D.cxx:83
 AliTPCFCVoltError3D.cxx:84
 AliTPCFCVoltError3D.cxx:85
 AliTPCFCVoltError3D.cxx:86
 AliTPCFCVoltError3D.cxx:87
 AliTPCFCVoltError3D.cxx:88
 AliTPCFCVoltError3D.cxx:89
 AliTPCFCVoltError3D.cxx:90
 AliTPCFCVoltError3D.cxx:91
 AliTPCFCVoltError3D.cxx:92
 AliTPCFCVoltError3D.cxx:93
 AliTPCFCVoltError3D.cxx:94
 AliTPCFCVoltError3D.cxx:95
 AliTPCFCVoltError3D.cxx:96
 AliTPCFCVoltError3D.cxx:97
 AliTPCFCVoltError3D.cxx:98
 AliTPCFCVoltError3D.cxx:99
 AliTPCFCVoltError3D.cxx:100
 AliTPCFCVoltError3D.cxx:101
 AliTPCFCVoltError3D.cxx:102
 AliTPCFCVoltError3D.cxx:103
 AliTPCFCVoltError3D.cxx:104
 AliTPCFCVoltError3D.cxx:105
 AliTPCFCVoltError3D.cxx:106
 AliTPCFCVoltError3D.cxx:107
 AliTPCFCVoltError3D.cxx:108
 AliTPCFCVoltError3D.cxx:109
 AliTPCFCVoltError3D.cxx:110
 AliTPCFCVoltError3D.cxx:111
 AliTPCFCVoltError3D.cxx:112
 AliTPCFCVoltError3D.cxx:113
 AliTPCFCVoltError3D.cxx:114
 AliTPCFCVoltError3D.cxx:115
 AliTPCFCVoltError3D.cxx:116
 AliTPCFCVoltError3D.cxx:117
 AliTPCFCVoltError3D.cxx:118
 AliTPCFCVoltError3D.cxx:119
 AliTPCFCVoltError3D.cxx:120
 AliTPCFCVoltError3D.cxx:121
 AliTPCFCVoltError3D.cxx:122
 AliTPCFCVoltError3D.cxx:123
 AliTPCFCVoltError3D.cxx:124
 AliTPCFCVoltError3D.cxx:125
 AliTPCFCVoltError3D.cxx:126
 AliTPCFCVoltError3D.cxx:127
 AliTPCFCVoltError3D.cxx:128
 AliTPCFCVoltError3D.cxx:129
 AliTPCFCVoltError3D.cxx:130
 AliTPCFCVoltError3D.cxx:131
 AliTPCFCVoltError3D.cxx:132
 AliTPCFCVoltError3D.cxx:133
 AliTPCFCVoltError3D.cxx:134
 AliTPCFCVoltError3D.cxx:135
 AliTPCFCVoltError3D.cxx:136
 AliTPCFCVoltError3D.cxx:137
 AliTPCFCVoltError3D.cxx:138
 AliTPCFCVoltError3D.cxx:139
 AliTPCFCVoltError3D.cxx:140
 AliTPCFCVoltError3D.cxx:141
 AliTPCFCVoltError3D.cxx:142
 AliTPCFCVoltError3D.cxx:143
 AliTPCFCVoltError3D.cxx:144
 AliTPCFCVoltError3D.cxx:145
 AliTPCFCVoltError3D.cxx:146
 AliTPCFCVoltError3D.cxx:147
 AliTPCFCVoltError3D.cxx:148
 AliTPCFCVoltError3D.cxx:149
 AliTPCFCVoltError3D.cxx:150
 AliTPCFCVoltError3D.cxx:151
 AliTPCFCVoltError3D.cxx:152
 AliTPCFCVoltError3D.cxx:153
 AliTPCFCVoltError3D.cxx:154
 AliTPCFCVoltError3D.cxx:155
 AliTPCFCVoltError3D.cxx:156
 AliTPCFCVoltError3D.cxx:157
 AliTPCFCVoltError3D.cxx:158
 AliTPCFCVoltError3D.cxx:159
 AliTPCFCVoltError3D.cxx:160
 AliTPCFCVoltError3D.cxx:161
 AliTPCFCVoltError3D.cxx:162
 AliTPCFCVoltError3D.cxx:163
 AliTPCFCVoltError3D.cxx:164
 AliTPCFCVoltError3D.cxx:165
 AliTPCFCVoltError3D.cxx:166
 AliTPCFCVoltError3D.cxx:167
 AliTPCFCVoltError3D.cxx:168
 AliTPCFCVoltError3D.cxx:169
 AliTPCFCVoltError3D.cxx:170
 AliTPCFCVoltError3D.cxx:171
 AliTPCFCVoltError3D.cxx:172
 AliTPCFCVoltError3D.cxx:173
 AliTPCFCVoltError3D.cxx:174
 AliTPCFCVoltError3D.cxx:175
 AliTPCFCVoltError3D.cxx:176
 AliTPCFCVoltError3D.cxx:177
 AliTPCFCVoltError3D.cxx:178
 AliTPCFCVoltError3D.cxx:179
 AliTPCFCVoltError3D.cxx:180
 AliTPCFCVoltError3D.cxx:181
 AliTPCFCVoltError3D.cxx:182
 AliTPCFCVoltError3D.cxx:183
 AliTPCFCVoltError3D.cxx:184
 AliTPCFCVoltError3D.cxx:185
 AliTPCFCVoltError3D.cxx:186
 AliTPCFCVoltError3D.cxx:187
 AliTPCFCVoltError3D.cxx:188
 AliTPCFCVoltError3D.cxx:189
 AliTPCFCVoltError3D.cxx:190
 AliTPCFCVoltError3D.cxx:191
 AliTPCFCVoltError3D.cxx:192
 AliTPCFCVoltError3D.cxx:193
 AliTPCFCVoltError3D.cxx:194
 AliTPCFCVoltError3D.cxx:195
 AliTPCFCVoltError3D.cxx:196
 AliTPCFCVoltError3D.cxx:197
 AliTPCFCVoltError3D.cxx:198
 AliTPCFCVoltError3D.cxx:199
 AliTPCFCVoltError3D.cxx:200
 AliTPCFCVoltError3D.cxx:201
 AliTPCFCVoltError3D.cxx:202
 AliTPCFCVoltError3D.cxx:203
 AliTPCFCVoltError3D.cxx:204
 AliTPCFCVoltError3D.cxx:205
 AliTPCFCVoltError3D.cxx:206
 AliTPCFCVoltError3D.cxx:207
 AliTPCFCVoltError3D.cxx:208
 AliTPCFCVoltError3D.cxx:209
 AliTPCFCVoltError3D.cxx:210
 AliTPCFCVoltError3D.cxx:211
 AliTPCFCVoltError3D.cxx:212
 AliTPCFCVoltError3D.cxx:213
 AliTPCFCVoltError3D.cxx:214
 AliTPCFCVoltError3D.cxx:215
 AliTPCFCVoltError3D.cxx:216
 AliTPCFCVoltError3D.cxx:217
 AliTPCFCVoltError3D.cxx:218
 AliTPCFCVoltError3D.cxx:219
 AliTPCFCVoltError3D.cxx:220
 AliTPCFCVoltError3D.cxx:221
 AliTPCFCVoltError3D.cxx:222
 AliTPCFCVoltError3D.cxx:223
 AliTPCFCVoltError3D.cxx:224
 AliTPCFCVoltError3D.cxx:225
 AliTPCFCVoltError3D.cxx:226
 AliTPCFCVoltError3D.cxx:227
 AliTPCFCVoltError3D.cxx:228
 AliTPCFCVoltError3D.cxx:229
 AliTPCFCVoltError3D.cxx:230
 AliTPCFCVoltError3D.cxx:231
 AliTPCFCVoltError3D.cxx:232
 AliTPCFCVoltError3D.cxx:233
 AliTPCFCVoltError3D.cxx:234
 AliTPCFCVoltError3D.cxx:235
 AliTPCFCVoltError3D.cxx:236
 AliTPCFCVoltError3D.cxx:237
 AliTPCFCVoltError3D.cxx:238
 AliTPCFCVoltError3D.cxx:239
 AliTPCFCVoltError3D.cxx:240
 AliTPCFCVoltError3D.cxx:241
 AliTPCFCVoltError3D.cxx:242
 AliTPCFCVoltError3D.cxx:243
 AliTPCFCVoltError3D.cxx:244
 AliTPCFCVoltError3D.cxx:245
 AliTPCFCVoltError3D.cxx:246
 AliTPCFCVoltError3D.cxx:247
 AliTPCFCVoltError3D.cxx:248
 AliTPCFCVoltError3D.cxx:249
 AliTPCFCVoltError3D.cxx:250
 AliTPCFCVoltError3D.cxx:251
 AliTPCFCVoltError3D.cxx:252
 AliTPCFCVoltError3D.cxx:253
 AliTPCFCVoltError3D.cxx:254
 AliTPCFCVoltError3D.cxx:255
 AliTPCFCVoltError3D.cxx:256
 AliTPCFCVoltError3D.cxx:257
 AliTPCFCVoltError3D.cxx:258
 AliTPCFCVoltError3D.cxx:259
 AliTPCFCVoltError3D.cxx:260
 AliTPCFCVoltError3D.cxx:261
 AliTPCFCVoltError3D.cxx:262
 AliTPCFCVoltError3D.cxx:263
 AliTPCFCVoltError3D.cxx:264
 AliTPCFCVoltError3D.cxx:265
 AliTPCFCVoltError3D.cxx:266
 AliTPCFCVoltError3D.cxx:267
 AliTPCFCVoltError3D.cxx:268
 AliTPCFCVoltError3D.cxx:269
 AliTPCFCVoltError3D.cxx:270
 AliTPCFCVoltError3D.cxx:271
 AliTPCFCVoltError3D.cxx:272
 AliTPCFCVoltError3D.cxx:273
 AliTPCFCVoltError3D.cxx:274
 AliTPCFCVoltError3D.cxx:275
 AliTPCFCVoltError3D.cxx:276
 AliTPCFCVoltError3D.cxx:277
 AliTPCFCVoltError3D.cxx:278
 AliTPCFCVoltError3D.cxx:279
 AliTPCFCVoltError3D.cxx:280
 AliTPCFCVoltError3D.cxx:281
 AliTPCFCVoltError3D.cxx:282
 AliTPCFCVoltError3D.cxx:283
 AliTPCFCVoltError3D.cxx:284
 AliTPCFCVoltError3D.cxx:285
 AliTPCFCVoltError3D.cxx:286
 AliTPCFCVoltError3D.cxx:287
 AliTPCFCVoltError3D.cxx:288
 AliTPCFCVoltError3D.cxx:289
 AliTPCFCVoltError3D.cxx:290
 AliTPCFCVoltError3D.cxx:291
 AliTPCFCVoltError3D.cxx:292
 AliTPCFCVoltError3D.cxx:293
 AliTPCFCVoltError3D.cxx:294
 AliTPCFCVoltError3D.cxx:295
 AliTPCFCVoltError3D.cxx:296
 AliTPCFCVoltError3D.cxx:297
 AliTPCFCVoltError3D.cxx:298
 AliTPCFCVoltError3D.cxx:299
 AliTPCFCVoltError3D.cxx:300
 AliTPCFCVoltError3D.cxx:301
 AliTPCFCVoltError3D.cxx:302
 AliTPCFCVoltError3D.cxx:303
 AliTPCFCVoltError3D.cxx:304
 AliTPCFCVoltError3D.cxx:305
 AliTPCFCVoltError3D.cxx:306
 AliTPCFCVoltError3D.cxx:307
 AliTPCFCVoltError3D.cxx:308
 AliTPCFCVoltError3D.cxx:309
 AliTPCFCVoltError3D.cxx:310
 AliTPCFCVoltError3D.cxx:311
 AliTPCFCVoltError3D.cxx:312
 AliTPCFCVoltError3D.cxx:313
 AliTPCFCVoltError3D.cxx:314
 AliTPCFCVoltError3D.cxx:315
 AliTPCFCVoltError3D.cxx:316
 AliTPCFCVoltError3D.cxx:317
 AliTPCFCVoltError3D.cxx:318
 AliTPCFCVoltError3D.cxx:319
 AliTPCFCVoltError3D.cxx:320
 AliTPCFCVoltError3D.cxx:321
 AliTPCFCVoltError3D.cxx:322
 AliTPCFCVoltError3D.cxx:323
 AliTPCFCVoltError3D.cxx:324
 AliTPCFCVoltError3D.cxx:325
 AliTPCFCVoltError3D.cxx:326
 AliTPCFCVoltError3D.cxx:327
 AliTPCFCVoltError3D.cxx:328
 AliTPCFCVoltError3D.cxx:329
 AliTPCFCVoltError3D.cxx:330
 AliTPCFCVoltError3D.cxx:331
 AliTPCFCVoltError3D.cxx:332
 AliTPCFCVoltError3D.cxx:333
 AliTPCFCVoltError3D.cxx:334
 AliTPCFCVoltError3D.cxx:335
 AliTPCFCVoltError3D.cxx:336
 AliTPCFCVoltError3D.cxx:337
 AliTPCFCVoltError3D.cxx:338
 AliTPCFCVoltError3D.cxx:339
 AliTPCFCVoltError3D.cxx:340
 AliTPCFCVoltError3D.cxx:341
 AliTPCFCVoltError3D.cxx:342
 AliTPCFCVoltError3D.cxx:343
 AliTPCFCVoltError3D.cxx:344
 AliTPCFCVoltError3D.cxx:345
 AliTPCFCVoltError3D.cxx:346
 AliTPCFCVoltError3D.cxx:347
 AliTPCFCVoltError3D.cxx:348
 AliTPCFCVoltError3D.cxx:349
 AliTPCFCVoltError3D.cxx:350
 AliTPCFCVoltError3D.cxx:351
 AliTPCFCVoltError3D.cxx:352
 AliTPCFCVoltError3D.cxx:353
 AliTPCFCVoltError3D.cxx:354
 AliTPCFCVoltError3D.cxx:355
 AliTPCFCVoltError3D.cxx:356
 AliTPCFCVoltError3D.cxx:357
 AliTPCFCVoltError3D.cxx:358
 AliTPCFCVoltError3D.cxx:359
 AliTPCFCVoltError3D.cxx:360
 AliTPCFCVoltError3D.cxx:361
 AliTPCFCVoltError3D.cxx:362
 AliTPCFCVoltError3D.cxx:363
 AliTPCFCVoltError3D.cxx:364
 AliTPCFCVoltError3D.cxx:365
 AliTPCFCVoltError3D.cxx:366
 AliTPCFCVoltError3D.cxx:367
 AliTPCFCVoltError3D.cxx:368
 AliTPCFCVoltError3D.cxx:369
 AliTPCFCVoltError3D.cxx:370
 AliTPCFCVoltError3D.cxx:371
 AliTPCFCVoltError3D.cxx:372
 AliTPCFCVoltError3D.cxx:373
 AliTPCFCVoltError3D.cxx:374
 AliTPCFCVoltError3D.cxx:375
 AliTPCFCVoltError3D.cxx:376
 AliTPCFCVoltError3D.cxx:377
 AliTPCFCVoltError3D.cxx:378
 AliTPCFCVoltError3D.cxx:379
 AliTPCFCVoltError3D.cxx:380
 AliTPCFCVoltError3D.cxx:381
 AliTPCFCVoltError3D.cxx:382
 AliTPCFCVoltError3D.cxx:383
 AliTPCFCVoltError3D.cxx:384
 AliTPCFCVoltError3D.cxx:385
 AliTPCFCVoltError3D.cxx:386
 AliTPCFCVoltError3D.cxx:387
 AliTPCFCVoltError3D.cxx:388
 AliTPCFCVoltError3D.cxx:389
 AliTPCFCVoltError3D.cxx:390
 AliTPCFCVoltError3D.cxx:391
 AliTPCFCVoltError3D.cxx:392
 AliTPCFCVoltError3D.cxx:393
 AliTPCFCVoltError3D.cxx:394
 AliTPCFCVoltError3D.cxx:395
 AliTPCFCVoltError3D.cxx:396
 AliTPCFCVoltError3D.cxx:397
 AliTPCFCVoltError3D.cxx:398
 AliTPCFCVoltError3D.cxx:399
 AliTPCFCVoltError3D.cxx:400
 AliTPCFCVoltError3D.cxx:401
 AliTPCFCVoltError3D.cxx:402
 AliTPCFCVoltError3D.cxx:403
 AliTPCFCVoltError3D.cxx:404
 AliTPCFCVoltError3D.cxx:405
 AliTPCFCVoltError3D.cxx:406
 AliTPCFCVoltError3D.cxx:407
 AliTPCFCVoltError3D.cxx:408
 AliTPCFCVoltError3D.cxx:409
 AliTPCFCVoltError3D.cxx:410
 AliTPCFCVoltError3D.cxx:411
 AliTPCFCVoltError3D.cxx:412
 AliTPCFCVoltError3D.cxx:413
 AliTPCFCVoltError3D.cxx:414
 AliTPCFCVoltError3D.cxx:415
 AliTPCFCVoltError3D.cxx:416
 AliTPCFCVoltError3D.cxx:417
 AliTPCFCVoltError3D.cxx:418
 AliTPCFCVoltError3D.cxx:419
 AliTPCFCVoltError3D.cxx:420
 AliTPCFCVoltError3D.cxx:421
 AliTPCFCVoltError3D.cxx:422
 AliTPCFCVoltError3D.cxx:423
 AliTPCFCVoltError3D.cxx:424
 AliTPCFCVoltError3D.cxx:425
 AliTPCFCVoltError3D.cxx:426
 AliTPCFCVoltError3D.cxx:427
 AliTPCFCVoltError3D.cxx:428
 AliTPCFCVoltError3D.cxx:429
 AliTPCFCVoltError3D.cxx:430
 AliTPCFCVoltError3D.cxx:431
 AliTPCFCVoltError3D.cxx:432
 AliTPCFCVoltError3D.cxx:433
 AliTPCFCVoltError3D.cxx:434
 AliTPCFCVoltError3D.cxx:435
 AliTPCFCVoltError3D.cxx:436
 AliTPCFCVoltError3D.cxx:437
 AliTPCFCVoltError3D.cxx:438
 AliTPCFCVoltError3D.cxx:439
 AliTPCFCVoltError3D.cxx:440
 AliTPCFCVoltError3D.cxx:441
 AliTPCFCVoltError3D.cxx:442
 AliTPCFCVoltError3D.cxx:443
 AliTPCFCVoltError3D.cxx:444
 AliTPCFCVoltError3D.cxx:445
 AliTPCFCVoltError3D.cxx:446
 AliTPCFCVoltError3D.cxx:447
 AliTPCFCVoltError3D.cxx:448
 AliTPCFCVoltError3D.cxx:449
 AliTPCFCVoltError3D.cxx:450
 AliTPCFCVoltError3D.cxx:451
 AliTPCFCVoltError3D.cxx:452
 AliTPCFCVoltError3D.cxx:453
 AliTPCFCVoltError3D.cxx:454
 AliTPCFCVoltError3D.cxx:455
 AliTPCFCVoltError3D.cxx:456
 AliTPCFCVoltError3D.cxx:457
 AliTPCFCVoltError3D.cxx:458
 AliTPCFCVoltError3D.cxx:459
 AliTPCFCVoltError3D.cxx:460
 AliTPCFCVoltError3D.cxx:461
 AliTPCFCVoltError3D.cxx:462
 AliTPCFCVoltError3D.cxx:463
 AliTPCFCVoltError3D.cxx:464
 AliTPCFCVoltError3D.cxx:465
 AliTPCFCVoltError3D.cxx:466
 AliTPCFCVoltError3D.cxx:467
 AliTPCFCVoltError3D.cxx:468
 AliTPCFCVoltError3D.cxx:469
 AliTPCFCVoltError3D.cxx:470
 AliTPCFCVoltError3D.cxx:471
 AliTPCFCVoltError3D.cxx:472
 AliTPCFCVoltError3D.cxx:473
 AliTPCFCVoltError3D.cxx:474
 AliTPCFCVoltError3D.cxx:475
 AliTPCFCVoltError3D.cxx:476
 AliTPCFCVoltError3D.cxx:477
 AliTPCFCVoltError3D.cxx:478
 AliTPCFCVoltError3D.cxx:479
 AliTPCFCVoltError3D.cxx:480
 AliTPCFCVoltError3D.cxx:481
 AliTPCFCVoltError3D.cxx:482
 AliTPCFCVoltError3D.cxx:483
 AliTPCFCVoltError3D.cxx:484
 AliTPCFCVoltError3D.cxx:485
 AliTPCFCVoltError3D.cxx:486
 AliTPCFCVoltError3D.cxx:487
 AliTPCFCVoltError3D.cxx:488
 AliTPCFCVoltError3D.cxx:489
 AliTPCFCVoltError3D.cxx:490
 AliTPCFCVoltError3D.cxx:491
 AliTPCFCVoltError3D.cxx:492
 AliTPCFCVoltError3D.cxx:493
 AliTPCFCVoltError3D.cxx:494
 AliTPCFCVoltError3D.cxx:495
 AliTPCFCVoltError3D.cxx:496
 AliTPCFCVoltError3D.cxx:497
 AliTPCFCVoltError3D.cxx:498
 AliTPCFCVoltError3D.cxx:499
 AliTPCFCVoltError3D.cxx:500
 AliTPCFCVoltError3D.cxx:501
 AliTPCFCVoltError3D.cxx:502
 AliTPCFCVoltError3D.cxx:503
 AliTPCFCVoltError3D.cxx:504
 AliTPCFCVoltError3D.cxx:505
 AliTPCFCVoltError3D.cxx:506
 AliTPCFCVoltError3D.cxx:507
 AliTPCFCVoltError3D.cxx:508
 AliTPCFCVoltError3D.cxx:509
 AliTPCFCVoltError3D.cxx:510
 AliTPCFCVoltError3D.cxx:511
 AliTPCFCVoltError3D.cxx:512
 AliTPCFCVoltError3D.cxx:513
 AliTPCFCVoltError3D.cxx:514
 AliTPCFCVoltError3D.cxx:515
 AliTPCFCVoltError3D.cxx:516
 AliTPCFCVoltError3D.cxx:517
 AliTPCFCVoltError3D.cxx:518
 AliTPCFCVoltError3D.cxx:519
 AliTPCFCVoltError3D.cxx:520
 AliTPCFCVoltError3D.cxx:521
 AliTPCFCVoltError3D.cxx:522
 AliTPCFCVoltError3D.cxx:523
 AliTPCFCVoltError3D.cxx:524
 AliTPCFCVoltError3D.cxx:525
 AliTPCFCVoltError3D.cxx:526
 AliTPCFCVoltError3D.cxx:527
 AliTPCFCVoltError3D.cxx:528
 AliTPCFCVoltError3D.cxx:529
 AliTPCFCVoltError3D.cxx:530
 AliTPCFCVoltError3D.cxx:531
 AliTPCFCVoltError3D.cxx:532
 AliTPCFCVoltError3D.cxx:533
 AliTPCFCVoltError3D.cxx:534
 AliTPCFCVoltError3D.cxx:535
 AliTPCFCVoltError3D.cxx:536
 AliTPCFCVoltError3D.cxx:537
 AliTPCFCVoltError3D.cxx:538
 AliTPCFCVoltError3D.cxx:539
 AliTPCFCVoltError3D.cxx:540
 AliTPCFCVoltError3D.cxx:541
 AliTPCFCVoltError3D.cxx:542
 AliTPCFCVoltError3D.cxx:543
 AliTPCFCVoltError3D.cxx:544
 AliTPCFCVoltError3D.cxx:545
 AliTPCFCVoltError3D.cxx:546
 AliTPCFCVoltError3D.cxx:547
 AliTPCFCVoltError3D.cxx:548
 AliTPCFCVoltError3D.cxx:549
 AliTPCFCVoltError3D.cxx:550
 AliTPCFCVoltError3D.cxx:551
 AliTPCFCVoltError3D.cxx:552
 AliTPCFCVoltError3D.cxx:553
 AliTPCFCVoltError3D.cxx:554
 AliTPCFCVoltError3D.cxx:555
 AliTPCFCVoltError3D.cxx:556
 AliTPCFCVoltError3D.cxx:557
 AliTPCFCVoltError3D.cxx:558
 AliTPCFCVoltError3D.cxx:559
 AliTPCFCVoltError3D.cxx:560
 AliTPCFCVoltError3D.cxx:561
 AliTPCFCVoltError3D.cxx:562
 AliTPCFCVoltError3D.cxx:563
 AliTPCFCVoltError3D.cxx:564
 AliTPCFCVoltError3D.cxx:565
 AliTPCFCVoltError3D.cxx:566
 AliTPCFCVoltError3D.cxx:567
 AliTPCFCVoltError3D.cxx:568
 AliTPCFCVoltError3D.cxx:569
 AliTPCFCVoltError3D.cxx:570
 AliTPCFCVoltError3D.cxx:571
 AliTPCFCVoltError3D.cxx:572
 AliTPCFCVoltError3D.cxx:573
 AliTPCFCVoltError3D.cxx:574
 AliTPCFCVoltError3D.cxx:575
 AliTPCFCVoltError3D.cxx:576
 AliTPCFCVoltError3D.cxx:577
 AliTPCFCVoltError3D.cxx:578
 AliTPCFCVoltError3D.cxx:579
 AliTPCFCVoltError3D.cxx:580
 AliTPCFCVoltError3D.cxx:581
 AliTPCFCVoltError3D.cxx:582
 AliTPCFCVoltError3D.cxx:583
 AliTPCFCVoltError3D.cxx:584
 AliTPCFCVoltError3D.cxx:585
 AliTPCFCVoltError3D.cxx:586
 AliTPCFCVoltError3D.cxx:587
 AliTPCFCVoltError3D.cxx:588
 AliTPCFCVoltError3D.cxx:589
 AliTPCFCVoltError3D.cxx:590
 AliTPCFCVoltError3D.cxx:591
 AliTPCFCVoltError3D.cxx:592
 AliTPCFCVoltError3D.cxx:593
 AliTPCFCVoltError3D.cxx:594
 AliTPCFCVoltError3D.cxx:595
 AliTPCFCVoltError3D.cxx:596
 AliTPCFCVoltError3D.cxx:597
 AliTPCFCVoltError3D.cxx:598
 AliTPCFCVoltError3D.cxx:599
 AliTPCFCVoltError3D.cxx:600
 AliTPCFCVoltError3D.cxx:601
 AliTPCFCVoltError3D.cxx:602
 AliTPCFCVoltError3D.cxx:603
 AliTPCFCVoltError3D.cxx:604
 AliTPCFCVoltError3D.cxx:605
 AliTPCFCVoltError3D.cxx:606
 AliTPCFCVoltError3D.cxx:607
 AliTPCFCVoltError3D.cxx:608
 AliTPCFCVoltError3D.cxx:609
 AliTPCFCVoltError3D.cxx:610
 AliTPCFCVoltError3D.cxx:611
 AliTPCFCVoltError3D.cxx:612
 AliTPCFCVoltError3D.cxx:613
 AliTPCFCVoltError3D.cxx:614
 AliTPCFCVoltError3D.cxx:615
 AliTPCFCVoltError3D.cxx:616
 AliTPCFCVoltError3D.cxx:617
 AliTPCFCVoltError3D.cxx:618
 AliTPCFCVoltError3D.cxx:619
 AliTPCFCVoltError3D.cxx:620
 AliTPCFCVoltError3D.cxx:621
 AliTPCFCVoltError3D.cxx:622
 AliTPCFCVoltError3D.cxx:623
 AliTPCFCVoltError3D.cxx:624
 AliTPCFCVoltError3D.cxx:625
 AliTPCFCVoltError3D.cxx:626
 AliTPCFCVoltError3D.cxx:627
 AliTPCFCVoltError3D.cxx:628
 AliTPCFCVoltError3D.cxx:629
 AliTPCFCVoltError3D.cxx:630
 AliTPCFCVoltError3D.cxx:631
 AliTPCFCVoltError3D.cxx:632
 AliTPCFCVoltError3D.cxx:633
 AliTPCFCVoltError3D.cxx:634
 AliTPCFCVoltError3D.cxx:635
 AliTPCFCVoltError3D.cxx:636
 AliTPCFCVoltError3D.cxx:637
 AliTPCFCVoltError3D.cxx:638
 AliTPCFCVoltError3D.cxx:639
 AliTPCFCVoltError3D.cxx:640
 AliTPCFCVoltError3D.cxx:641
 AliTPCFCVoltError3D.cxx:642
 AliTPCFCVoltError3D.cxx:643
 AliTPCFCVoltError3D.cxx:644
 AliTPCFCVoltError3D.cxx:645
 AliTPCFCVoltError3D.cxx:646
 AliTPCFCVoltError3D.cxx:647
 AliTPCFCVoltError3D.cxx:648
 AliTPCFCVoltError3D.cxx:649
 AliTPCFCVoltError3D.cxx:650
 AliTPCFCVoltError3D.cxx:651
 AliTPCFCVoltError3D.cxx:652
 AliTPCFCVoltError3D.cxx:653
 AliTPCFCVoltError3D.cxx:654
 AliTPCFCVoltError3D.cxx:655
 AliTPCFCVoltError3D.cxx:656
 AliTPCFCVoltError3D.cxx:657
 AliTPCFCVoltError3D.cxx:658
 AliTPCFCVoltError3D.cxx:659
 AliTPCFCVoltError3D.cxx:660
 AliTPCFCVoltError3D.cxx:661
 AliTPCFCVoltError3D.cxx:662
 AliTPCFCVoltError3D.cxx:663
 AliTPCFCVoltError3D.cxx:664
 AliTPCFCVoltError3D.cxx:665
 AliTPCFCVoltError3D.cxx:666
 AliTPCFCVoltError3D.cxx:667
 AliTPCFCVoltError3D.cxx:668
 AliTPCFCVoltError3D.cxx:669
 AliTPCFCVoltError3D.cxx:670
 AliTPCFCVoltError3D.cxx:671
 AliTPCFCVoltError3D.cxx:672
 AliTPCFCVoltError3D.cxx:673
 AliTPCFCVoltError3D.cxx:674
 AliTPCFCVoltError3D.cxx:675
 AliTPCFCVoltError3D.cxx:676
 AliTPCFCVoltError3D.cxx:677
 AliTPCFCVoltError3D.cxx:678
 AliTPCFCVoltError3D.cxx:679
 AliTPCFCVoltError3D.cxx:680
 AliTPCFCVoltError3D.cxx:681
 AliTPCFCVoltError3D.cxx:682
 AliTPCFCVoltError3D.cxx:683
 AliTPCFCVoltError3D.cxx:684
 AliTPCFCVoltError3D.cxx:685
 AliTPCFCVoltError3D.cxx:686
 AliTPCFCVoltError3D.cxx:687
 AliTPCFCVoltError3D.cxx:688
 AliTPCFCVoltError3D.cxx:689
 AliTPCFCVoltError3D.cxx:690
 AliTPCFCVoltError3D.cxx:691
 AliTPCFCVoltError3D.cxx:692
 AliTPCFCVoltError3D.cxx:693
 AliTPCFCVoltError3D.cxx:694
 AliTPCFCVoltError3D.cxx:695
 AliTPCFCVoltError3D.cxx:696
 AliTPCFCVoltError3D.cxx:697
 AliTPCFCVoltError3D.cxx:698
 AliTPCFCVoltError3D.cxx:699
 AliTPCFCVoltError3D.cxx:700
 AliTPCFCVoltError3D.cxx:701
 AliTPCFCVoltError3D.cxx:702
 AliTPCFCVoltError3D.cxx:703
 AliTPCFCVoltError3D.cxx:704
 AliTPCFCVoltError3D.cxx:705
 AliTPCFCVoltError3D.cxx:706
 AliTPCFCVoltError3D.cxx:707
 AliTPCFCVoltError3D.cxx:708
 AliTPCFCVoltError3D.cxx:709
 AliTPCFCVoltError3D.cxx:710
 AliTPCFCVoltError3D.cxx:711
 AliTPCFCVoltError3D.cxx:712
 AliTPCFCVoltError3D.cxx:713
 AliTPCFCVoltError3D.cxx:714
 AliTPCFCVoltError3D.cxx:715
 AliTPCFCVoltError3D.cxx:716
 AliTPCFCVoltError3D.cxx:717
 AliTPCFCVoltError3D.cxx:718
 AliTPCFCVoltError3D.cxx:719
 AliTPCFCVoltError3D.cxx:720
 AliTPCFCVoltError3D.cxx:721
 AliTPCFCVoltError3D.cxx:722
 AliTPCFCVoltError3D.cxx:723
 AliTPCFCVoltError3D.cxx:724
 AliTPCFCVoltError3D.cxx:725
 AliTPCFCVoltError3D.cxx:726
 AliTPCFCVoltError3D.cxx:727
 AliTPCFCVoltError3D.cxx:728
 AliTPCFCVoltError3D.cxx:729
 AliTPCFCVoltError3D.cxx:730
 AliTPCFCVoltError3D.cxx:731
 AliTPCFCVoltError3D.cxx:732
 AliTPCFCVoltError3D.cxx:733
 AliTPCFCVoltError3D.cxx:734
 AliTPCFCVoltError3D.cxx:735
 AliTPCFCVoltError3D.cxx:736
 AliTPCFCVoltError3D.cxx:737
 AliTPCFCVoltError3D.cxx:738
 AliTPCFCVoltError3D.cxx:739
 AliTPCFCVoltError3D.cxx:740
 AliTPCFCVoltError3D.cxx:741
 AliTPCFCVoltError3D.cxx:742
 AliTPCFCVoltError3D.cxx:743
 AliTPCFCVoltError3D.cxx:744
 AliTPCFCVoltError3D.cxx:745
 AliTPCFCVoltError3D.cxx:746
 AliTPCFCVoltError3D.cxx:747
 AliTPCFCVoltError3D.cxx:748
 AliTPCFCVoltError3D.cxx:749
 AliTPCFCVoltError3D.cxx:750
 AliTPCFCVoltError3D.cxx:751
 AliTPCFCVoltError3D.cxx:752
 AliTPCFCVoltError3D.cxx:753
 AliTPCFCVoltError3D.cxx:754
 AliTPCFCVoltError3D.cxx:755
 AliTPCFCVoltError3D.cxx:756
 AliTPCFCVoltError3D.cxx:757
 AliTPCFCVoltError3D.cxx:758
 AliTPCFCVoltError3D.cxx:759
 AliTPCFCVoltError3D.cxx:760
 AliTPCFCVoltError3D.cxx:761
 AliTPCFCVoltError3D.cxx:762
 AliTPCFCVoltError3D.cxx:763
 AliTPCFCVoltError3D.cxx:764
 AliTPCFCVoltError3D.cxx:765
 AliTPCFCVoltError3D.cxx:766
 AliTPCFCVoltError3D.cxx:767
 AliTPCFCVoltError3D.cxx:768
 AliTPCFCVoltError3D.cxx:769
 AliTPCFCVoltError3D.cxx:770
 AliTPCFCVoltError3D.cxx:771
 AliTPCFCVoltError3D.cxx:772
 AliTPCFCVoltError3D.cxx:773
 AliTPCFCVoltError3D.cxx:774
 AliTPCFCVoltError3D.cxx:775
 AliTPCFCVoltError3D.cxx:776
 AliTPCFCVoltError3D.cxx:777
 AliTPCFCVoltError3D.cxx:778
 AliTPCFCVoltError3D.cxx:779
 AliTPCFCVoltError3D.cxx:780
 AliTPCFCVoltError3D.cxx:781
 AliTPCFCVoltError3D.cxx:782
 AliTPCFCVoltError3D.cxx:783
 AliTPCFCVoltError3D.cxx:784
 AliTPCFCVoltError3D.cxx:785
 AliTPCFCVoltError3D.cxx:786
 AliTPCFCVoltError3D.cxx:787
 AliTPCFCVoltError3D.cxx:788
 AliTPCFCVoltError3D.cxx:789
 AliTPCFCVoltError3D.cxx:790
 AliTPCFCVoltError3D.cxx:791
 AliTPCFCVoltError3D.cxx:792
 AliTPCFCVoltError3D.cxx:793
 AliTPCFCVoltError3D.cxx:794
 AliTPCFCVoltError3D.cxx:795
 AliTPCFCVoltError3D.cxx:796
 AliTPCFCVoltError3D.cxx:797
 AliTPCFCVoltError3D.cxx:798
 AliTPCFCVoltError3D.cxx:799
 AliTPCFCVoltError3D.cxx:800
 AliTPCFCVoltError3D.cxx:801
 AliTPCFCVoltError3D.cxx:802
 AliTPCFCVoltError3D.cxx:803
 AliTPCFCVoltError3D.cxx:804
 AliTPCFCVoltError3D.cxx:805
 AliTPCFCVoltError3D.cxx:806
 AliTPCFCVoltError3D.cxx:807
 AliTPCFCVoltError3D.cxx:808
 AliTPCFCVoltError3D.cxx:809
 AliTPCFCVoltError3D.cxx:810
 AliTPCFCVoltError3D.cxx:811
 AliTPCFCVoltError3D.cxx:812
 AliTPCFCVoltError3D.cxx:813
 AliTPCFCVoltError3D.cxx:814
 AliTPCFCVoltError3D.cxx:815
 AliTPCFCVoltError3D.cxx:816
 AliTPCFCVoltError3D.cxx:817
 AliTPCFCVoltError3D.cxx:818
 AliTPCFCVoltError3D.cxx:819
 AliTPCFCVoltError3D.cxx:820
 AliTPCFCVoltError3D.cxx:821
 AliTPCFCVoltError3D.cxx:822
 AliTPCFCVoltError3D.cxx:823
 AliTPCFCVoltError3D.cxx:824
 AliTPCFCVoltError3D.cxx:825
 AliTPCFCVoltError3D.cxx:826
 AliTPCFCVoltError3D.cxx:827
 AliTPCFCVoltError3D.cxx:828
 AliTPCFCVoltError3D.cxx:829
 AliTPCFCVoltError3D.cxx:830
 AliTPCFCVoltError3D.cxx:831
 AliTPCFCVoltError3D.cxx:832
 AliTPCFCVoltError3D.cxx:833
 AliTPCFCVoltError3D.cxx:834
 AliTPCFCVoltError3D.cxx:835
 AliTPCFCVoltError3D.cxx:836
 AliTPCFCVoltError3D.cxx:837
 AliTPCFCVoltError3D.cxx:838
 AliTPCFCVoltError3D.cxx:839
 AliTPCFCVoltError3D.cxx:840
 AliTPCFCVoltError3D.cxx:841
 AliTPCFCVoltError3D.cxx:842
 AliTPCFCVoltError3D.cxx:843
 AliTPCFCVoltError3D.cxx:844
 AliTPCFCVoltError3D.cxx:845
 AliTPCFCVoltError3D.cxx:846
 AliTPCFCVoltError3D.cxx:847
 AliTPCFCVoltError3D.cxx:848
 AliTPCFCVoltError3D.cxx:849
 AliTPCFCVoltError3D.cxx:850
 AliTPCFCVoltError3D.cxx:851
 AliTPCFCVoltError3D.cxx:852
 AliTPCFCVoltError3D.cxx:853
 AliTPCFCVoltError3D.cxx:854
 AliTPCFCVoltError3D.cxx:855
 AliTPCFCVoltError3D.cxx:856
 AliTPCFCVoltError3D.cxx:857
 AliTPCFCVoltError3D.cxx:858
 AliTPCFCVoltError3D.cxx:859
 AliTPCFCVoltError3D.cxx:860
 AliTPCFCVoltError3D.cxx:861
 AliTPCFCVoltError3D.cxx:862
 AliTPCFCVoltError3D.cxx:863
 AliTPCFCVoltError3D.cxx:864
 AliTPCFCVoltError3D.cxx:865
 AliTPCFCVoltError3D.cxx:866
 AliTPCFCVoltError3D.cxx:867
 AliTPCFCVoltError3D.cxx:868
 AliTPCFCVoltError3D.cxx:869
 AliTPCFCVoltError3D.cxx:870
 AliTPCFCVoltError3D.cxx:871
 AliTPCFCVoltError3D.cxx:872
 AliTPCFCVoltError3D.cxx:873
 AliTPCFCVoltError3D.cxx:874
 AliTPCFCVoltError3D.cxx:875
 AliTPCFCVoltError3D.cxx:876
 AliTPCFCVoltError3D.cxx:877
 AliTPCFCVoltError3D.cxx:878
 AliTPCFCVoltError3D.cxx:879
 AliTPCFCVoltError3D.cxx:880
 AliTPCFCVoltError3D.cxx:881
 AliTPCFCVoltError3D.cxx:882
 AliTPCFCVoltError3D.cxx:883
 AliTPCFCVoltError3D.cxx:884
 AliTPCFCVoltError3D.cxx:885
 AliTPCFCVoltError3D.cxx:886
 AliTPCFCVoltError3D.cxx:887
 AliTPCFCVoltError3D.cxx:888
 AliTPCFCVoltError3D.cxx:889
 AliTPCFCVoltError3D.cxx:890
 AliTPCFCVoltError3D.cxx:891
 AliTPCFCVoltError3D.cxx:892
 AliTPCFCVoltError3D.cxx:893
 AliTPCFCVoltError3D.cxx:894
 AliTPCFCVoltError3D.cxx:895
 AliTPCFCVoltError3D.cxx:896
 AliTPCFCVoltError3D.cxx:897
 AliTPCFCVoltError3D.cxx:898
 AliTPCFCVoltError3D.cxx:899
 AliTPCFCVoltError3D.cxx:900
 AliTPCFCVoltError3D.cxx:901
 AliTPCFCVoltError3D.cxx:902
 AliTPCFCVoltError3D.cxx:903
 AliTPCFCVoltError3D.cxx:904
 AliTPCFCVoltError3D.cxx:905
 AliTPCFCVoltError3D.cxx:906
 AliTPCFCVoltError3D.cxx:907
 AliTPCFCVoltError3D.cxx:908
 AliTPCFCVoltError3D.cxx:909
 AliTPCFCVoltError3D.cxx:910
 AliTPCFCVoltError3D.cxx:911
 AliTPCFCVoltError3D.cxx:912
 AliTPCFCVoltError3D.cxx:913
 AliTPCFCVoltError3D.cxx:914
 AliTPCFCVoltError3D.cxx:915
 AliTPCFCVoltError3D.cxx:916
 AliTPCFCVoltError3D.cxx:917
 AliTPCFCVoltError3D.cxx:918
 AliTPCFCVoltError3D.cxx:919
 AliTPCFCVoltError3D.cxx:920
 AliTPCFCVoltError3D.cxx:921
 AliTPCFCVoltError3D.cxx:922
 AliTPCFCVoltError3D.cxx:923
 AliTPCFCVoltError3D.cxx:924
 AliTPCFCVoltError3D.cxx:925
 AliTPCFCVoltError3D.cxx:926
 AliTPCFCVoltError3D.cxx:927
 AliTPCFCVoltError3D.cxx:928
 AliTPCFCVoltError3D.cxx:929
 AliTPCFCVoltError3D.cxx:930
 AliTPCFCVoltError3D.cxx:931
 AliTPCFCVoltError3D.cxx:932
 AliTPCFCVoltError3D.cxx:933
 AliTPCFCVoltError3D.cxx:934
 AliTPCFCVoltError3D.cxx:935
 AliTPCFCVoltError3D.cxx:936
 AliTPCFCVoltError3D.cxx:937
 AliTPCFCVoltError3D.cxx:938
 AliTPCFCVoltError3D.cxx:939
 AliTPCFCVoltError3D.cxx:940
 AliTPCFCVoltError3D.cxx:941
 AliTPCFCVoltError3D.cxx:942
 AliTPCFCVoltError3D.cxx:943
 AliTPCFCVoltError3D.cxx:944
 AliTPCFCVoltError3D.cxx:945
 AliTPCFCVoltError3D.cxx:946
 AliTPCFCVoltError3D.cxx:947
 AliTPCFCVoltError3D.cxx:948
 AliTPCFCVoltError3D.cxx:949
 AliTPCFCVoltError3D.cxx:950
 AliTPCFCVoltError3D.cxx:951
 AliTPCFCVoltError3D.cxx:952
 AliTPCFCVoltError3D.cxx:953
 AliTPCFCVoltError3D.cxx:954
 AliTPCFCVoltError3D.cxx:955
 AliTPCFCVoltError3D.cxx:956
 AliTPCFCVoltError3D.cxx:957
 AliTPCFCVoltError3D.cxx:958
 AliTPCFCVoltError3D.cxx:959
 AliTPCFCVoltError3D.cxx:960
 AliTPCFCVoltError3D.cxx:961
 AliTPCFCVoltError3D.cxx:962
 AliTPCFCVoltError3D.cxx:963
 AliTPCFCVoltError3D.cxx:964
 AliTPCFCVoltError3D.cxx:965
 AliTPCFCVoltError3D.cxx:966
 AliTPCFCVoltError3D.cxx:967
 AliTPCFCVoltError3D.cxx:968
 AliTPCFCVoltError3D.cxx:969
 AliTPCFCVoltError3D.cxx:970
 AliTPCFCVoltError3D.cxx:971
 AliTPCFCVoltError3D.cxx:972
 AliTPCFCVoltError3D.cxx:973
 AliTPCFCVoltError3D.cxx:974
 AliTPCFCVoltError3D.cxx:975
 AliTPCFCVoltError3D.cxx:976
 AliTPCFCVoltError3D.cxx:977
 AliTPCFCVoltError3D.cxx:978
 AliTPCFCVoltError3D.cxx:979
 AliTPCFCVoltError3D.cxx:980
 AliTPCFCVoltError3D.cxx:981
 AliTPCFCVoltError3D.cxx:982
 AliTPCFCVoltError3D.cxx:983
 AliTPCFCVoltError3D.cxx:984
 AliTPCFCVoltError3D.cxx:985
 AliTPCFCVoltError3D.cxx:986
 AliTPCFCVoltError3D.cxx:987
 AliTPCFCVoltError3D.cxx:988
 AliTPCFCVoltError3D.cxx:989
 AliTPCFCVoltError3D.cxx:990
 AliTPCFCVoltError3D.cxx:991
 AliTPCFCVoltError3D.cxx:992
 AliTPCFCVoltError3D.cxx:993
 AliTPCFCVoltError3D.cxx:994
 AliTPCFCVoltError3D.cxx:995
 AliTPCFCVoltError3D.cxx:996
 AliTPCFCVoltError3D.cxx:997
 AliTPCFCVoltError3D.cxx:998
 AliTPCFCVoltError3D.cxx:999
 AliTPCFCVoltError3D.cxx:1000
 AliTPCFCVoltError3D.cxx:1001
 AliTPCFCVoltError3D.cxx:1002
 AliTPCFCVoltError3D.cxx:1003
 AliTPCFCVoltError3D.cxx:1004
 AliTPCFCVoltError3D.cxx:1005
 AliTPCFCVoltError3D.cxx:1006
 AliTPCFCVoltError3D.cxx:1007
 AliTPCFCVoltError3D.cxx:1008
 AliTPCFCVoltError3D.cxx:1009
 AliTPCFCVoltError3D.cxx:1010
 AliTPCFCVoltError3D.cxx:1011
 AliTPCFCVoltError3D.cxx:1012
 AliTPCFCVoltError3D.cxx:1013
 AliTPCFCVoltError3D.cxx:1014
 AliTPCFCVoltError3D.cxx:1015
 AliTPCFCVoltError3D.cxx:1016
 AliTPCFCVoltError3D.cxx:1017
 AliTPCFCVoltError3D.cxx:1018
 AliTPCFCVoltError3D.cxx:1019
 AliTPCFCVoltError3D.cxx:1020