- Inclusion of AliTPCSpaceCharge3D in TPCbase library
authorsrossegg <srossegg@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Nov 2010 17:03:12 +0000 (17:03 +0000)
committersrossegg <srossegg@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Nov 2010 17:03:12 +0000 (17:03 +0000)
- Updates of the documentation of the classes related to calibration of the field distortions
    Note: NO CHANGES IN THE FUNCTIONALITY
  Extended comments (documentation) is now written in root-html format (including simple example plots in the html version)

20 files changed:
TPC/AliTPCBoundaryVoltError.cxx
TPC/AliTPCBoundaryVoltError.h
TPC/AliTPCCorrection.cxx
TPC/AliTPCCorrection.h
TPC/AliTPCExBBShape.cxx
TPC/AliTPCExBBShape.h
TPC/AliTPCExBTwist.cxx
TPC/AliTPCExBTwist.h
TPC/AliTPCFCVoltError3D.cxx
TPC/AliTPCFCVoltError3D.h
TPC/AliTPCGGVoltError.cxx
TPC/AliTPCGGVoltError.h
TPC/AliTPCROCVoltError3D.cxx
TPC/AliTPCROCVoltError3D.h
TPC/AliTPCSpaceCharge.cxx
TPC/AliTPCSpaceCharge.h
TPC/AliTPCSpaceCharge3D.cxx
TPC/AliTPCSpaceCharge3D.h
TPC/TPCbaseLinkDef.h
TPC/libTPCbase.pkg

index 7b8f6cdcd9365ea425370c8b27cd055605914e29..7e927c8d75c144462cbf4359e30eea984e02a36d 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//////////////////////////////////////////////////////////////////////////////
-//                                                                          //
-// AliTPCBoundaryVoltError class                                            //
-// The class calculates the space point distortions due to residual voltage //
-// errors on the main boundaries of the TPC. For example, the inner vessel  //
-// of the TPC is shifted by a certain amount, whereas the ROCs on the A side//
-// and the ROCs on the C side follow this mechanical shift (at the inner    //
-// vessel) in z direction (see example below). This example is commonly     //
-// named "conical deformation" of the TPC field cage.                       //
-//                                                                          //
-// The class allows "effective Omega Tau" corrections.                      // 
-//                                                                          //
-// NOTE: This class is capable of calculating z distortions due to          //
-//       drift velocity change in dependence of the electric field!!!       //
-//                                                                          //
-// date: 01/06/2010                                                         //
-// Authors: Jim Thomas, Stefan Rossegger                                    //
-//                                                                          //
-// Example usage (e.g +1mm shift of "conical deformation")                  //
-//  AliTPCBoundaryVoltError bve;                                            //
-//  Float_t boundA[8] = {-40,-40,-40,0,0,0,0,-40}; // voltages A-side       //
-//  Float_t boundC[6] = { 40, 40, 40,0,0,0}; // voltages C-side             //
-//  bve.SetBoundariesA(boundA);                                             //
-//  bve.SetBoundariesC(boundC);                                             //
-//  bve.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB            //
-//  // initialization of the look up                                        //
-//  bve.InitBoundaryVoltErrorDistortion();                                  // 
-//  // plot dRPhi distortions ...                                           //
-//  bve.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");                    //
-//////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2> AliTPCBoundaryVoltError class   </h2>       
+//   This class calculates the space point distortions due to residual voltage errors on 
+//   the main boundaries of the TPC. For example, the inner vessel of the TPC is shifted 
+//   by a certain amount, whereas the ROCs on the A side and the C side follow this mechanical 
+//   shift (at the inner vessel) in z direction. This example can be named "conical deformation"
+//   of the TPC field cage (see example below).                    
+//   <p>
+//   The boundary conditions can be set via two arrays (A and C side) which contain the 
+//   residual voltage setting modeling a possible shift or an inhomogeneity on the TPC field 
+//   cage. In order to avoid that the user splits the Central Electrode (CE), the settings for 
+//   the C side is taken from the array on the A side (points: A.6 and A.7). The region betweem
+//    the points is interpolated linearly onto the boundaries.
+//   <p>
+//   The class uses the PoissonRelaxation2D (see AliTPCCorrection) to calculate the resulting 
+//   electrical field inhomogeneities in the (r,z)-plane. Then, the Langevin-integral formalism 
+//   is used to calculate the space point distortions. <br>
+//   Note: This class assumes a homogeneous magnetic field. 
+//   <p>
+//   One has two possibilities when calculating the $dz$ distortions. The resulting distortions 
+//   are purely due to the change of the drift velocity (along with the change of the drift field) 
+//   when the SetROCDisplacement is FALSE. This emulates for example a Gating-Grid Voltage offset 
+//   without moving the ROCs. When the flag is set to TRUE, the ROCs are assumed to be misaligned 
+//   and the corresponding offset in z is added.
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,300); 
+//   AliTPCBoundaryVoltError bve;     
+//   Float_t val = 40;// [Volt]; 40V corresponds to 1mm
+//   /* IFC shift, CE follows, ROC follows by factor half */
+//   Float_t boundA[8] = { val, val, val,0,0,0,0,val}; // voltages A-side
+//   Float_t boundC[6] = {-val,-val,-val,0,0,0};       // voltages C-side  
+//   bve.SetBoundariesA(boundA);                                        
+//   bve.SetBoundariesC(boundC);                                        
+//   bve.SetOmegaTauT1T2(-0.32,1,1);
+//   bve.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz distortions
+//   bve.CreateHistoDRinZR(0)->Draw("surf2"); 
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+// Date: 01/06/2010 <br>
+// Authors: Jim Thomas, Stefan Rossegger      
+// End_Html 
+// _________________________________________________________________
+
 
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
index fb6f0494c948e4cad9f9c9c433c4d0f4ea626ef5..4d34a00dd1e2dede13b267ee616a2119a74dccfd 100644 (file)
@@ -5,7 +5,6 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCBoundaryVoltError class                                          //
 // date: 01/06/2010                                                       //
 // Authors: Jim Thomas, Stefan Rossegger                                  //
index 797eac93d0ba18ba783b10c6a8dc21bc4072eaba..0b809f791d7b5c99d45400ffb33ae446d45cbec2 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// AliTPCCorrection class                                                     //
-//                                                                            //
-// This class provides a general framework to deal with space point           //
-// distortions. An correction class which inherits from here is for example   //
-// AliTPCExBBShape or AliTPCExBTwist                                          //
-//                                                                            //
-// General functions are (for example):                                       //
-//   CorrectPoint(x,roc) where x is the vector of inital positions in         //
-//   cartesian coordinates and roc represents the Read Out chamber number     //
-//   according to the offline naming convention. The vector x is overwritten  //
-//   with the corrected coordinates.                                          //
-//                                                                            //
-// An alternative usage would be CorrectPoint(x,roc,dx), which leaves the     //
-//   vector x untouched, put returns the distortions via the vector dx        //
-//                                                                            //
-// The class allows "effective Omega Tau" corrections to be shifted to the    //
-// single distortion classes.                                                 //
-//                                                                            //
-// Note: This class is normally used via the class AliTPCComposedCorrection   //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                        //
-////////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2>  AliTPCCorrection class   </h2>    
+//  
+//   The AliTPCCorrection class provides a general framework to deal with space point distortions. 
+//   An correction class which inherits from here is for example AliTPCExBBShape or AliTPCExBTwist. <br> 
+//   General virtual functions are (for example) CorrectPoint(x,roc) where x is the vector of initial 
+//   positions in cartesian coordinates and roc represents the read-out chamber number according to 
+//   the offline numbering convention. The vector x is overwritten with the corrected coordinates. <br> 
+//   An alternative usage would be CorrectPoint(x,roc,dx), which leaves the vector x untouched, but 
+//   returns the distortions via the vector dx. <br>
+//   This class is normally used via the general class AliTPCComposedCorrection.   
+//   <p>
+//   Furthermore, the class contains basic geometrical descriptions like field cage radii 
+//   (fgkIFCRadius, fgkOFCRadius) and length (fgkTPCZ0) plus the voltages. Also, the definitions 
+//   of size and widths of the fulcrums building the grid of the final look-up table, which is 
+//   then interpolated, is defined in kNX and fgkXList).
+//   <p>
+//   All physics-model classes below are derived from this class in order to not duplicate code 
+//   and to allow a uniform treatment of all physics models.
+//   <p>
+//   <h3> Poisson solver </h3>    
+//   A numerical solver of the Poisson equation (relaxation technique) is implemented for 2-dimensional 
+//   geometries (r,z) as well as for 3-dimensional problems (r,$\phi$,z). The corresponding function 
+//   names are PoissonRelaxation?D. The relevant function arguments are the arrays of the boundary and 
+//   initial conditions (ArrayofArrayV, ArrayofChargeDensities) as well as the grid granularity which 
+//   is used during the calculation. These inputs can be chosen according to the needs of the physical 
+//   effect which is supposed to be simulated. In the 3D version, different symmetry conditions can be set
+//   in order to reduce the calculation time (used in AliTPCFCVoltError3D).
+//   <p>
+//   <h3> Unified plotting functionality  </h3>    
+//   Generic plot functions were implemented. They return a histogram pointer in the chosen plane of 
+//   the TPC drift volume with a selectable grid granularity and the magnitude of the correction vector.
+//   For example, the function CreateHistoDZinXY(z,nx,ny) returns a 2-dimensional histogram which contains 
+//   the longitudinal corrections $dz$ in the (x,y)-plane at the given z position with the granularity of 
+//   nx and ny. The magnitude of the corrections is defined by the class from which this function is called.
+//   In the same manner, standard plots for the (r,$\phi$)-plane and for the other corrections like $dr$ and $rd\phi$ are available  
+//   <p>                                                                      
+//   Note: This class is normally used via the class AliTPCComposedCorrection
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",700,1050);  c2->Divide(2,3);
+//   AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
+//   roc.SetOmegaTauT1T2(0,1,1); // B=0
+//   Float_t z0 = 1; // at +1 cm -> A side
+//   c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z"); 
+//   c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z"); 
+//   c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z"); 
+//   Float_t phi0=0.5;
+//   c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2"); 
+//   c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2"); 
+//   c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2"); 
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+//   Date: 27/04/2010  <br>
+//   Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                     
+// End_Html 
+// _________________________________________________________________
+
+
 #include "Riostream.h"
 
 #include <TH2F.h>
@@ -1411,7 +1454,7 @@ AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackPara
   if (npoints2<npoints)  return 0;
   AliTrackerBase::PropagateTrackToBxByBz(track0,refX,kMass,2.,kTRUE,kMaxSnp);
   track1->Rotate(track0->GetAlpha());
-  AliTrackerBase::PropagateTrackToBxByBz(track1,refX,kMass,2.,kTRUE,kMaxSnp);
+  AliTrackerBase::PropagateTrackToBxByBz(track1,refX,kMass,2.,kFALSE,kMaxSnp);
 
   if (pcstream) (*pcstream)<<Form("fitDistort%s",GetName())<<
     "point0.="<<&pointArray0<<   //  points
index c3fd4cb54089a1cbeca0969635323141317e22a7..a11422fa448ffa99fc559928a9083b4e33af640b 100644 (file)
@@ -4,30 +4,59 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2>  AliTPCCorrection class   </h2>    
+//                                                                          
+//   This class provides a general framework to deal with space point         
+//   distortions. An correction class which inherits from here is for example 
+//   AliTPCExBBShape or AliTPCExBTwist                                        
+//   <p>                                                                        
+//   General functions are (for example):  <br>                                    
+//   CorrectPoint(x,roc) where x is the vector of inital positions in        
+//   cartesian coordinates and roc represents the Read Out chamber number    
+//   according to the offline naming convention. The vector x is overwritten 
+//   with the corrected coordinates.                                         
+//   <p>                                                                        
+//   An alternative usage would be CorrectPoint(x,roc,dx), which leaves the    
+//   vector x untouched, put returns the distortions via the vector dx      
+//   <p>
+//   Several plot functionalities (see example below), general solvers as well as simplified interpolation techniques are implemented.
+//   <p>                                                                       
+//   The class allows "effective Omega Tau" corrections to be shifted to the 
+//   single distortion classes.                                              
+//   <p>                                                                      
+//   Note: This class is normally used via the class AliTPCComposedCorrection
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",800,1200);  c2->Divide(2,3);
+//   AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
+//   roc.SetOmegaTauT1T2(0,1,1); // B=0
+//   Float_t z0 = 1; // at +1 cm -> A side
+//   c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z"); 
+//   c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z"); 
+//   c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z"); 
+//   Float_t phi0=0.5;
+//   c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2"); 
+//   c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2"); 
+//   c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2"); 
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+//   Date: 27/04/2010  <br>
+//   Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                     
+// End_Html 
+// _________________________________________________________________
+
 ////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
 // AliTPCCorrection class                                                     //
-//                                                                            //
-// This class provides a general framework to deal with space point           //
-// distortions. An correction class which inherits from here is for example   //
-// AliTPCExBBShape or AliTPCExBTwist                                          //
-//                                                                            //
-// General functions are (for example):                                       //
-//   CorrectPoint(x,roc) where x is the vector of inital positions in         //
-//   cartesian coordinates and roc represents the Read Out chamber number     //
-//   according to the offline naming convention. The vector x is overwritten  //
-//   with the corrected coordinates.                                          //
-//                                                                            //
-// An alternative usage would be CorrectPoint(x,roc,dx), which leaves the     //
-//   vector x untouched, put returns the distortions via the vector dx        //
-//                                                                            //
-// The class allows "effective Omega Tau" corrections to be shifted to the    //
-// single distortion classes.                                                 //
-//                                                                            //
-// Note: This class is normally used via the class AliTPCComposedCorrection   //
-//                                                                            //
-// date: 27/04/2010                                                           //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                        //
 ////////////////////////////////////////////////////////////////////////////////
 
 
index 2e3c6fe8114bd0fcc49b2ec0ab909f0055bfff32..51b78b742c4bb199ee41e3d1f54bdcf76c38855f 100644 (file)
  **************************************************************************/
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliExBBShape class                                                     //
-// The class calculates the space point distortions due to the B field    //
-// shape imperfections using a second order technique based on integrals  //
-// over Bz (e.g. int By/Bz) obtained via the AliMagF class                //
-// The class allows "effective Omega Tau" corrections.                    //
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Magnus Mager, Jim Thomas, Stefan Rossegger                    //
-//                                                                        //
-// Example usage:                                                         //
-//  AliMagF mag("mag","mag");                                             //
-//  AliTPCExBBShape exb;                                                  //
-//  exb.SetBField(&mag);             // use Bfield from AliMagF           //
-//  exb.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB          //
-//  // plot dRPhi distortions ...                                         //
-//  exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");                   //
+// AliTPCExBBShape class                                                  //
 ////////////////////////////////////////////////////////////////////////////
 
 #include <AliMagF.h>
index 9c7b569b281751f78470c873cefe08da4e2f7813..defcce7fbb8aabc2a24cada01b3e07b3c82df1be 100644 (file)
@@ -4,17 +4,35 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliExBBShape class                                                     //
-// The class calculates the space point distortions due to the B field    //
-// shape imperfections using a second order technique based on integrals  //
-// over Bz (e.g. int By/Bz) obtained via the AliMagF class                //
-// The class allows "effective Omega Tau" corrections.                    //
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Magnus Mager, Jim Thomas, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2>AliExBBShape class </h2>                                                    
+//   The class calculates the space point distortions due to the B field    
+//   shape imperfections using a second order technique based on integrals  
+//   over Bz (e.g. int By/Bz) obtained via the AliMagF class. The essential 
+//   input for this class is the magnetic field maps which can be set via the function SetBField.  
+//   <p>
+//   The class allows "effective Omega Tau" corrections.                    
+//   End_Html
+//   Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,300); 
+//   AliTPCExBBShape exb;                                                 
+//   AliMagF mag("mag","mag");        // 0.5 Tesla (solenoid)
+//   exb.SetBField(&mag);             // use Bfield from AliMagF        
+//   exb.SetOmegaTauT1T2(-0.32,1.,1.); // values ideally from OCDB     
+//   exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2"); 
+//   return c2;
+//   } 
+// End_Macro
+// Begin_Html
+//   <p>
+//   Date: 27/04/2010 <br>                                                      
+//   Authors: Magnus Mager, Jim Thomas, Stefan Rossegger                    
+// End_Html 
+// _________________________________________________________________
 
 #include "AliTPCCorrection.h"
 
index ba8104b6319ff24d6a9a170ce837202169be5e48..4c120f9f7e4269540044656ebef22ecd50f87567 100644 (file)
  **************************************************************************/
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCExBTwist class                                                   //
-// The class calculates the space point distortions due to a mismatch     //
-// of the E and B field axis (original code from STAR)                    //
-// The class allows "effective Omega Tau" corrections.                    // 
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-//                                                                        //
-// Example usage:                                                         //
-//  AliTPCExBTwist twist;                                                 //
-//  twist.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB        //
-//  twist.SetXTwist(0.001);   // set twist in X direction (in rad)        //
-//  // plot dRPhi distortions ...                                         //
-//  twist.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");                //
 ////////////////////////////////////////////////////////////////////////////
+
+
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
 #include "AliTPCcalibDB.h"
index afceedceba07c1314569440eb866a17ffe2aee0b..5a5799ba5bc01a78dac11341b5bbb6a9a2f4651d 100644 (file)
@@ -4,16 +4,39 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBTwist class                                                   //
-// The class calculates the space point distortions due to a mismatch     //
-// of the E and B field axis (original code from STAR)                    //
-// The class allows "effective Omega Tau" corrections.                    // 
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2> AliTPCExBTwist class    </h2>       
+//   The class calculates the space point distortions due to a mismatch     
+//   of the E and B field axis (original code from STAR)                    
+//   <p>
+//   It assumes a homogeneous magnetic and electric field. The calculations performed 
+//   within this class can be written in a compact form as well (compare notes of Jim Thomas)
+//   <p>
+//   The inputs to this class are the twist angles in the x and y plane ($\theta_x,\theta_y$) 
+//   in cartesian coordinates. They can be set via the member functions SetXTwist and SetYTwist.
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,300); 
+//   AliTPCExBTwist twist;
+//   twist.SetXTwist(0.001);  // x angle in [rad]
+//   twist.SetXTwist(0.0005); // y angle in [rad]
+//   twist.SetOmegaTauT1T2(0.32,1,1);
+//   twist.CreateHistoDRPhiinXY(1.)->Draw("surf2"); // A side
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+// Date: 27/04/2010  <br>
+// Authors: Jim Thomas, Magnus Mager, Stefan Rossegger 
+// End_Html 
+// _________________________________________________________________
 
 #include "AliTPCCorrection.h"
 
index 9abaf99d442a1b4f1b8ac178f5d74fa3c12f88a4..37c2aaa704a1c308afca63f413ba6ec57b31ba89 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//////////////////////////////////////////////////////////////////////////////
-//                                                                          //
-// AliTPCFCVoltError3D class                                                //
-// The class calculates the space point distortions due to residual voltage //
-// errors on the Field Cage boundaries (rods) of the TPC in 3D.             //
-//                                                                          //
-// The class allows "effective Omega Tau" corrections.                      // 
-//                                                                          //
-// NOTE: This class is capable of calculating z distortions due to          //
-//       drift velocity changes in dependence of the electric field!!!      //
-//                                                                          //
-// date: 08/08/2010                                                         //
-// Authors: Jim Thomas, Stefan Rossegger                                    //
-//                                                                          //
-// Example usage :                                                          //
-//  AliTPCFCVoltError3D fcerror;                                            //
-//////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// 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("c2","c2",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"
index 70711f64766564ab3c20ed5ed728ebec78a54a33..03a21b49358dce16f663f43ac04293f3afa60532 100644 (file)
@@ -5,9 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCFCVoltError3D class                                              //
-// date: 01/06/2010                                                       //
 // Authors: Jim Thomas, Stefan Rossegger                                  //
 ////////////////////////////////////////////////////////////////////////////
 
index dee07bf848ccd532495653777a13e4a198c2e89c..27b47a105a28518b637cd322a1ec413f633ae350 100644 (file)
  **************************************************************************/
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCGGVoltError class                                                //
-// The class calculates the electric field and space point distortions    //
-// due a Gating Grid (GG) Error voltage. It uses the exact calculation    //
-// technique based on bessel functions. (original code from STAR)         //
-// The class allows "effective Omega Tau" corrections.                    // 
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Jim Thomas, Stefan Rossegger, Magnus Mager                    //
-//                                                                        //
-// Example usage:                                                         //
-//  AliTPCGGVoltError GGerror;                                            //
-//  GGerror.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB      //
-//  GGerror.SetDeltaVGGA(50.);           // voltage offset A-side         //
-//  GGerror.SetDeltaVGGC(50.);           // voltage offset C-side         //
-//  GGerror.InitGGVoltErrorDistortion(); // initialization of the look up //
-//  // plot dRPhi distortions ...                                         //
-//  GGerror.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");              //
 ////////////////////////////////////////////////////////////////////////////
 
 
index 5be161ea071bfb3f43bf2f1720bd896bd20968ee..9e5f935aaf9d0c1120f3bd29d6f10ab22316afa0 100644 (file)
@@ -4,17 +4,45 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCGGVoltError class                                                //
-// The class calculates the electric field and space point distortions    //
-// due a Gating Grid (GG) Error voltage. It uses the exact calculation    //
-// technique based on bessel functions. (original code from STAR)         //
-// The class allows "effective Omega Tau" corrections.                    // 
-//                                                                        //
-// date: 27/04/2010                                                       //
-// Authors: Jim Thomas, Stefan Rossegger, Magnus Mager                    //
-////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2> AliTPCGGVoltError class   </h2>         
+//   The class calculates the electric field and the resulting space point distortions 
+//   due a Gating Grid (GG) voltage error. It uses the analytical solution for such a problem. 
+//   <p>
+//   The input is the effective GG voltage residual in respect to the ideal setting. The effective 
+//   residual voltage can be set via the functions SetDeltaVGGx. Note that this effective 
+//   voltage-residuals are approx. a factor 0.9 lower than the actual difference in the setting 
+//   of the GG due to the fact that the voltage on the GG is partially screened by the wire 
+//   structure. The calculation has to be performed with the observable effective voltage difference.
+//   <p>
+//   Unfortunately, the class is not capable of calculation the $dz$ offset due to possible changes 
+//   of the drift velocity in dependence of the electric field. The special case of the numerical 
+//   approximation (AliTPCBoundaryVoltError), which is capable of calculating the same effect, should 
+//   be used for this purpose. 
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,300); 
+//   AliTPCGGVoltError gg;
+//   gg.SetDeltaVGGA(-40); gg.SetDeltaVGGC(-40); // 40 Volt offset
+//   gg.InitGGVoltErrorDistortion();
+//   gg.SetOmegaTauT1T2(0,1,1); // B=0
+//   gg.CreateHistoDRinZR(0)->Draw("surf2"); 
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+//   Date: 27/04/2010  <br>
+//   Authors: Jim Thomas, Stefan Rossegger, Magnus Mager   
+// End_Html 
+// _________________________________________________________________
+
 
 #include "AliTPCCorrection.h"
 
index eee16ade38824dac66413a93c702d35e0931e944..4a4f7e0a7f67948aa31af221908e33054ecbfb02 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//////////////////////////////////////////////////////////////////////////////
-//                                                                          //
-// AliTPCROCVoltError3D class                                               //
-// The class calculates the space point distortions due to residual voltage //
-// errors on Read Out Chambers of the TPC in 3D.                            //
-//                                                                          //
-// The class allows "effective Omega Tau" corrections.                      // 
-//                                                                          //
-// NOTE: This class is capable of calculating z distortions due to          //
-//       misalignment and the vd dependency on the residual drift field     //
-//                                                                          //
-// date: 08/08/2010                                                         //
-// Authors: Jim Thomas, Stefan Rossegger                                    //
-//                                                                          //
-// Example usage :                                                          //
-//  AliTPCROCVoltError3D ROCerror;                                            //
-//////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2> AliTPCROCVoltError3D class   </h2>    
+//   The class calculates the space point distortions due to z offsets of the 
+//   ROCs via the residual voltage technique (Poisson relaxation) in 3D. 
+//   Since the GG (part of the ROCs) represents the closure of the FC in z direction,
+//   every misalignment in z produces not only dz distortions but also electrical 
+//   field inhomogeneities throughout the volume, which produces additional dr and rd$\phi$ distortions.
+//   <p>
+//   Each ROC can be misaligned (in z direction) in three ways. A general z0 offset, 
+//   an inclination along the x and an inclination along the y axis. The z-misalignment's
+//   can be set via the function SetROCData(TMatrixD *mat) for each single chamber (ROC). 
+//   The array size has to be (72,3) representing the 72 chambers according to the 
+//   offline numbering scheme (IROC: roc$<$36; OROC: roc$\geq$36) and the three misalignment's
+//   (see the source code for further details).
+//   <p>
+//   Internally, these z offsets (unit is cm)  are recalculated into residual voltage 
+//   equivalents in order to make use of the relaxation technique. 
+//   <p>
+//   One has two possibilities when calculating the $dz$ distortions. The resulting 
+//   distortions are purely due to the change of the drift velocity (along with the 
+//   change of the drift field) when the SetROCDisplacement is FALSE. <br>
+//   For this class, this is a rather unphysical setting and should be avoided. <br>
+//   When the flag is set to TRUE, the corresponding offset in z is added to the dz 
+//   calculation of the outer ROCs. <br>
+//   For the Alice TPC gas, both effects are of similar magnitude. This means, if the 
+//   drift length is sufficiently large, a z-offset of a chamber appears to have (approx.) 
+//   twice the magnitude when one looks at the actual dz distortions.
+//   <p>
+//   In addition, this class allows a correction regarding the different arrival times 
+//   of the electrons due to the geometrical difference of the inner and outer chambers.
+//   The impact was simulated via Garfield. If the flag is set via the 
+//   function SetElectronArrivalCorrection, the electron-arrival correction is added to the dz calculation.
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,400); 
+//   AliTPCROCVoltError3D roc; 
+//   roc.SetElectronArrivalCorrection(kFALSE);  // Correction for electron arrival offset, IROC vs OROC
+//   roc.SetROCDisplacement(kTRUE);   // include the chamber offset in z when calculating the dz 
+//   roc.SetOmegaTauT1T2(0,1,1); // B=0
+//   roc.CreateHistoDZinXY(1.,300,300)->Draw("colz"); 
+//   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"
index 8b595ffbd09575a64791344573fa1196ca183417..bf5a3caa9dcdda51406be27612801394f71b6db1 100644 (file)
@@ -5,9 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCROCVoltError3D class                                              //
-// date: 01/06/2010                                                       //
+// AliTPCROCVoltError3D class                                             //
 // Authors: Jim Thomas, Stefan Rossegger                                  //
 ////////////////////////////////////////////////////////////////////////////
 
index 8742612a443357d71bbc2b4959bba434af79a1bb..d0306bbabf2b9fd8a5a7f65a9ab2f2ccacb2c21a 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//////////////////////////////////////////////////////////////////////////////
-//                                                                          //
-// AliTPCSpaceCharge class                                                  //
-// The class calculates the space point distortions due to a space charge   //
-// effect ....                                                              //
-// The class allows "effective Omega Tau" corrections.                      // 
-//                                                                          //
-// NOTE: This class is capable of calculating z distortions due to          //
-//       drift velocity change in dependence of the electric field!!!       //
-//                                                                          //
-// date: 23/08/2010                                                         //
-// Authors: Jim Thomas, Stefan Rossegger                                    //
-//                                                                          //
-// Example usage:                                                           //
-//////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2> AliTPCSpaceCharge class  </h2>    
+//   The class calculates the space point distortions due to a rotational 
+//   symmetric space charge distribution with the TPC drift volume. 
+//   <p>
+//   The class uses the PoissonRelaxation2D to calculate the resulting 
+//   electrical field inhomogeneities in the (r,z)-plane. Then, the 
+//   Langevin-integral formalism is used to calculate the space point distortions. 
+//   <p>
+//   The class assumes, that the distortions scales linearly with the magnitude 
+//   of the space charge distribution $\rho(r,z)$. The in here assumed distribution is 
+//   $$\rho(r,z) = \frac{(A-B\,z)}{r^2} $$ wherein the factors A and B scale with the
+//   event multiplicity and the interaction rate.
+//   <p>
+//   The scaling factor can be set via the function SetCorrectionFactor. An example of 
+//   the shape of the distortions is given below.
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,300); 
+//   AliTPCSpaceCharge sc;
+//   sc.SetOmegaTauT1T2(-0.32,1,1); // B=0.5 Tesla
+//   sc.SetCorrectionFactor(0.0015);
+//   sc.CreateHistoDRinZR(0.)->Draw("surf2");
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+//   Date: 23/08/2010 <br>
+// Authors: Jim Thomas, Stefan Rossegger 
+// End_Html 
+// _________________________________________________________________
+
+
 
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
index 21c10422d2d703cd10d8d8693a5aa9f3b1c533cd..a263953d93f0ad912b8bd07f058eab2882219cd7 100644 (file)
@@ -5,9 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
 // AliTPCSpaceCharge class                                                //
-// date: 19/06/2010                                                       //
 // Authors: Jim Thomas, Stefan Rossegger                                  //
 ////////////////////////////////////////////////////////////////////////////
 
index ff138324de1a654a49aa714e7f5fe537f2e25d4e..b4b7183653769b73f1b15be80a7541e53eae217d 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-//////////////////////////////////////////////////////////////////////////////
-//                                                                          //
-// AliTPCSpaceCharge3D class                                                //
-// The class calculates the space point distortions due to a space charge   //
-// effect ....                                                              //
-// Method of calculation:                                                   //
-// The analytical solution for the poisson problem in 3D (cylindrical coord)//
-// is used in form of look up tables. PieceOfCake (POC) voxel were pre-     //
-// calculated and can be sumed up (weighted) according to the what is needed// 
-//                                                                          //
-// The class allows "effective Omega Tau" corrections.                      // 
-//                                                                          //
-// NOTE: This class is not  capable of calculation z distortions due to     //
-//       drift velocity change in dependence of the electric field!!!       //
-//                                                                          //
-// date: 19/06/2010                                                         //
-// Authors: Stefan Rossegger                                                //
-//                                                                          //
-// Example usage:                                                           //
-//////////////////////////////////////////////////////////////////////////////
+// _________________________________________________________________
+//
+// Begin_Html
+//   <h2>  AliTPCSpaceCharge3D class   </h2>    
+//   The class calculates the space point distortions due to an arbitrary space
+//   charge distribution in 3D. 
+//   <p>
+//   The method of calculation is based on the analytical solution for the Poisson 
+//   problem in 3D (cylindrical coordinates). The solution is used in form of 
+//   look up tables, where the pre calculated solutions for different voxel 
+//   positions are stored. These voxel solutions can be summed up according 
+//   to the weight of the position of the applied space charge distribution.
+//   Further details can be found in \cite[chap.5]{PhD-thesis_S.Rossegger}.
+//   <p>
+//   The class also allows a simple scaling of the resulting distortions
+//   via the function SetCorrectionFactor. This speeds up the calculation 
+//   time under the assumption, that the distortions scales linearly with the 
+//   magnitude of the space charge distribution $\rho(r,z)$ and the shape stays 
+//   the same at higher luminosities.
+//   <p>
+//   In contrast to the implementation in 2D (see the class AliTPCSpaceChargeabove), 
+//   the input charge distribution can be of arbitrary character. An example on how 
+//   to produce a corresponding charge distribution can be found in the function 
+//   WriteChargeDistributionToFile. In there, a $\rho(r,z) = (A-B\,z)/r^2$, 
+//   with slightly different magnitude on the A and C side (due to the muon absorber),
+//   is superpositioned with a few leaking wires at arbitrary positions. 
+// End_Html
+//
+// Begin_Macro(source) 
+//   {
+//   gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+//   TCanvas *c2 = new TCanvas("c2","c2",500,400); 
+//   AliTPCSpaceCharge3D sc;
+//   sc.WriteChargeDistributionToFile("SC_zr2_GGleaks.root");
+//   sc.SetSCDataFileName("SC_zr2_GGleaks.root");
+//   sc.SetOmegaTauT1T2(0,1,1); // B=0
+//   sc.InitSpaceCharge3DDistortion();
+//   sc.CreateHistoDRinXY(15,300,300)->Draw("colz");
+//   return c2;
+//   } 
+// End_Macro
+//
+// Begin_Html
+//   <p>
+//   Date: 19/06/2010  <br>                                                       
+//   Authors: Stefan Rossegger                                                
+// End_Html 
+// _________________________________________________________________
+
 
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
index f557d2e0e1aa15e81793eec637b864aab6ce9f26..b69b7fdc74f614f26663bc3ae676f752132e6251 100644 (file)
@@ -5,9 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 ////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCSpaceCharge3D class                                           //
-// date: 19/06/2010                                                       //
+// AliTPCSpaceCharge3D class                                              //
 // Authors: Stefan Rossegger                                              //
 ////////////////////////////////////////////////////////////////////////////
 
index e120ff988fa4e5b4d72f7493968baf7215abb812..33aa06b6dbc67937e58e71ea45640b4796d0fe81 100644 (file)
 #pragma link C++ class AliTPCBoundaryVoltError+;
 #pragma link C++ class AliTPCCalibGlobalMisalignment+;
 #pragma link C++ class AliTPCSpaceCharge+;
+#pragma link C++ class AliTPCSpaceCharge3D+;
 
 #pragma link C++ class AliTPCExBEffective+;
 #pragma link C++ class AliTPCExBEffectiveSector+;
index 39de901575b2b64958b0d4c9af2f229afb0a382a..558ff739adb7455e5055ac5b50798c247758e682 100644 (file)
@@ -25,7 +25,10 @@ SRCS:=  AliSegmentID.cxx  AliSegmentArray.cxx AliDigits.cxx AliH2F.cxx \
        AliTPCkalmanTime.cxx AliESDcosmic.cxx AliTPCPointCorrection.cxx AliTPCTransformation.cxx \
        AliTPCkalmanFit.cxx AliTPCLaserTrack.cxx AliTPCcalibBase.cxx \
        AliTPCCorrection.cxx AliTPCInverseCorrection.cxx AliTPCComposedCorrection.cxx \
-       AliTPCExBBShape.cxx AliTPCExBTwist.cxx AliTPCGGVoltError.cxx AliTPCFCVoltError3D.cxx AliTPCROCVoltError3D.cxx AliTPCBoundaryVoltError.cxx AliTPCSpaceCharge.cxx AliXRDPROOFtoolkit.cxx AliTPCCalibGlobalMisalignment.cxx AliTPCExBEffective.cxx AliTPCExBEffectiveSector.cxx 
+       AliTPCExBBShape.cxx AliTPCExBTwist.cxx AliTPCGGVoltError.cxx AliTPCBoundaryVoltError.cxx \
+       AliTPCCalibGlobalMisalignment.cxx AliTPCFCVoltError3D.cxx AliTPCROCVoltError3D.cxx  \
+       AliTPCSpaceCharge.cxx AliTPCSpaceCharge3D.cxx AliXRDPROOFtoolkit.cxx \
+       AliTPCExBEffective.cxx AliTPCExBEffectiveSector.cxx 
 
 HDRS:= $(SRCS:.cxx=.h)