doxy: converted TPC/ main dir
authordberzano <dario.berzano@cern.ch>
Fri, 9 Jan 2015 15:43:51 +0000 (16:43 +0100)
committerdberzano <dario.berzano@cern.ch>
Fri, 9 Jan 2015 17:25:34 +0000 (18:25 +0100)
TPC/AliTPCCombinedTrackfit.cxx
TPC/AliTPCCombinedTrackfit.h
TPC/AliTPCEfield.cxx
TPC/AliTPCEfield.h
TPC/AliTPCExBConical.cxx
TPC/AliTPCExBConical.h
TPC/TestTPCTrackHits.cxx
TPC/TestTPCTrackHits.h
doxygen/debug/run.sh

index a492f3f..9eec298 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-//
-// Combine cosmic track pairs (upper, lower) and do track fitting
-// oooooOOOOOooooo
-// oooooOOOOOooooo
-// oooooOOOOOooooo
-//
-//  Xianguo Lu <lu@physi.uni-heidelberg.de>
+
+/// \class AliTPCCombinedTrackfit
+/// 
+/// Combine cosmic track pairs (upper, lower) and do track fitting
+/// 
+/// \author Xianguo Lu <lu@physi.uni-heidelberg.de>
 
 #include <TAxis.h>
 #include <TCanvas.h>
@@ -43,9 +42,8 @@ AliTPCCombinedTrackfit::AliTPCCombinedTrackfit(const Int_t dlev, const TString t
   , fLeverArm(-999)
   , fFitNcls(-999), fMissNcls(-999), fPreChi2(-999)
 {
-  //
-  //Constructor
-  //
+  /// Constructor
+
   fInnerClusterUp.SetXYZ(-999,-999,-999);
   fInnerClusterLow.SetXYZ(-999,-999,-999);
 
@@ -55,9 +53,7 @@ AliTPCCombinedTrackfit::AliTPCCombinedTrackfit(const Int_t dlev, const TString t
 
 AliTPCCombinedTrackfit::~AliTPCCombinedTrackfit()
 {
-  //
-  //Destructor
-  //
+  /// Destructor
 
   delete fStreamer;
   
@@ -67,10 +63,8 @@ AliTPCCombinedTrackfit::~AliTPCCombinedTrackfit()
 
 Bool_t AliTPCCombinedTrackfit::CombineESDtracks(AliESDtrack * &trk0, AliESDtrack *&trk1)
 {
-  //
-  //Get TPCseeds from the 2 ESDtracks, swap TPCseeds and ESDTracks (if necessary) according to y (0:upper 1:lower), perform trackfit using TPCseeds
-  //if fStatus==0, i.e. combine is successful, swap of the ESDtracks is kept since pointer *& is used
-  //
+  /// Get TPCseeds from the 2 ESDtracks, swap TPCseeds and ESDTracks (if necessary) according to y (0:upper 1:lower), perform trackfit using TPCseeds
+  /// if fStatus==0, i.e. combine is successful, swap of the ESDtracks is kept since pointer *& is used
 
   IniCombineESDtracks();
 
@@ -95,10 +89,9 @@ Bool_t AliTPCCombinedTrackfit::CombineESDtracks(AliESDtrack * &trk0, AliESDtrack
 
 Bool_t AliTPCCombinedTrackfit::CombineTPCseeds(AliTPCseed * &seed0, AliTPCseed *&seed1)
 {
-  //
-  //same as AliTPCCombinedTrackfit::CombineESDtracks, except that the seeds are passed in from outside, which can be still unordered
-  //if fStatus==0, i.e. combine is successful, swap of the TPCseeds is kept since pointer *& is used
-  //
+  /// same as AliTPCCombinedTrackfit::CombineESDtracks, except that the seeds are passed in from outside, which can be still unordered
+  /// if fStatus==0, i.e. combine is successful, swap of the TPCseeds is kept since pointer *& is used
+
   IniCombineESDtracks();
 
   fSeedUp  = seed0;
@@ -121,17 +114,15 @@ Bool_t AliTPCCombinedTrackfit::CombineTPCseeds(AliTPCseed * &seed0, AliTPCseed *
 
 void AliTPCCombinedTrackfit::Print() const
 {
-  //
-  //print out variable values
-  //
+  /// print out variable values
+
   printf("Status %2d NclsU %3d NclsD %3d ZinnerU %7.2f ZinnerD %7.2f LeverArm %7.2f\n", fStatus, fSeedUp->GetNumberOfClusters(), fSeedLow->GetNumberOfClusters(), fInnerClusterUp.Z(), fInnerClusterLow.Z(), fLeverArm);
 }
 
 Double_t AliTPCCombinedTrackfit::ImpactParameter() const
 {
-  //
-  //calculate the impactparameter from (0,0,0)
-  //
+  /// calculate the impactparameter from (0,0,0)
+
   const TVector3 p0(0,0,0);
   const TVector3 va = p0 - fInnerClusterUp;
   const TVector3 vb = fInnerClusterLow - fInnerClusterUp;
@@ -143,9 +134,8 @@ Double_t AliTPCCombinedTrackfit::ImpactParameter() const
 
 Double_t AliTPCCombinedTrackfit::MinPhi() const
 {
-  //
-  //the smaller phi of the two tracks w.r.t. horizon
-  //
+  /// the smaller phi of the two tracks w.r.t. horizon
+
   Double_t fsp[] = {fabs(sin(fTrackparUp->Phi())), fabs(sin(fTrackparLow->Phi()))};;
   return asin(TMath::Min(fsp[0], fsp[1])) * TMath::RadToDeg();
 }
@@ -154,9 +144,7 @@ Double_t AliTPCCombinedTrackfit::MinPhi() const
 
 void AliTPCCombinedTrackfit::IniCombineESDtracks()
 {
-  //
-  //initialization, for reuse of the same AliTPCCombinedTrackfit instance
-  //
+  /// initialization, for reuse of the same AliTPCCombinedTrackfit instance
 
   fSeedUp = 0x0;
   fSeedLow = 0x0;
@@ -170,9 +158,7 @@ void AliTPCCombinedTrackfit::IniCombineESDtracks()
 
 void AliTPCCombinedTrackfit::CombineTPCseeds(Bool_t &kswap)
 {
-  //
-  //do combined trackfit using TPCseeds
-  //
+  /// do combined trackfit using TPCseeds
 
   if(
      !CheckNcls()
@@ -205,9 +191,7 @@ void AliTPCCombinedTrackfit::CombineTPCseeds(Bool_t &kswap)
 
 void AliTPCCombinedTrackfit::Update()
 {
-  //
-  //Update variables depending on the fit result
-  //
+  /// Update variables depending on the fit result
 
   if(fMissNcls || fFitNcls==0){
     fStatus = kFailPropagation;
@@ -245,11 +229,10 @@ void AliTPCCombinedTrackfit::Update()
 
 Bool_t AliTPCCombinedTrackfit::CheckLeverArm()
 {
-  //
-  //if lever arm is too short, no need to use combined track fit. 
-  //On the other hand, short lever arm from two tracks mostly means they are fake pairs.
-  //lever arm extents over one quadrant, e.g. (0,250)-(250,0): 250*sqrt(2)~350
-  //
+  /// if lever arm is too short, no need to use combined track fit.
+  /// On the other hand, short lever arm from two tracks mostly means they are fake pairs.
+  /// lever arm extents over one quadrant, e.g. (0,250)-(250,0): 250*sqrt(2)~350
+
   if(fLeverArm<fgkCutLeverArm){
     fStatus = kFailLeverArm;
     return kFALSE;
@@ -260,9 +243,7 @@ Bool_t AliTPCCombinedTrackfit::CheckLeverArm()
 
 Bool_t AliTPCCombinedTrackfit::AnaSeeds(Bool_t &kswap)
 {
-  //
-  //swap seeds (if necessary) so that (y of fSeedUp) > (y of fSeedLow)
-  //
+  /// swap seeds (if necessary) so that (y of fSeedUp) > (y of fSeedLow)
 
   //---------------------------------- navigate through all clusters ----------------------------------
   AliTPCseed ** seeds[]={&fSeedUp, &fSeedLow};
@@ -342,9 +323,8 @@ Bool_t AliTPCCombinedTrackfit::AnaSeeds(Bool_t &kswap)
 
 Bool_t AliTPCCombinedTrackfit::CheckNcls()
 {
-  //
-  //check number of clusters in TPCseed, for too small number MakeSeed will fail
-  //
+  /// check number of clusters in TPCseed, for too small number MakeSeed will fail
+
   if( fSeedUp->GetNumberOfClusters()<AliTPCCosmicUtils::fgkNclsMin || fSeedLow->GetNumberOfClusters()<AliTPCCosmicUtils::fgkNclsMin ){
     fStatus = kFailNclsMin;
     return kFALSE;
@@ -355,9 +335,8 @@ Bool_t AliTPCCombinedTrackfit::CheckNcls()
 
 Bool_t AliTPCCombinedTrackfit::GetTPCseeds(const AliESDtrack *trk0,  const AliESDtrack *trk1)
 {
-  //
-  //Get TPC seeds from ESDfriendTrack
-  //
+  /// Get TPC seeds from ESDfriendTrack
+
   fSeedUp  = AliTPCCosmicUtils::GetTPCseed(trk0);
   fSeedLow = AliTPCCosmicUtils::GetTPCseed(trk1);
 
index 7464c2b..1c2e033 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-//
-// Combine cosmic track pairs (upper, lower) and do track fitting
-//
-// ----- Usage:
-/*
-  fCombinedTrackfit = new AliTPCCombinedTrackfit(debuglevel, "anystring");
-
-  //order not important; will be internally ordered (potinters modified due to &) such that track0 is the upper one
-  //kfit = kTRUE: good fit, kFALSE: bad fit
-  const Bool_t kfit = fCombinedTrackfit->CombineESDtracks(esdtrack0, esdtrack1);
 
-  //status = 0 for good fit (i.e. kfit=kTRUE), non-0 for bad fit (i.e. kfit=kFALSE), see "enum CombineStatus" definition in header file
-  const Int_t status = fCombinedTrackfit->GetStatus(); 
+/// \class AliTPCCombinedTrackfit
+/// \brief Combine cosmic track pairs (upper, lower) and do track fitting.
+/// 
+/// Usage
+/// -----
+///
+/// ~~~{.cxx}
+/// fCombinedTrackfit = new AliTPCCombinedTrackfit(debuglevel, "anystring");
+///
+/// //order not important; will be internally ordered (potinters modified due to &) such that track0 is the upper one
+/// //kfit = kTRUE: good fit, kFALSE: bad fit
+/// const Bool_t kfit = fCombinedTrackfit->CombineESDtracks(esdtrack0, esdtrack1);
+///
+/// //status = 0 for good fit (i.e. kfit=kTRUE), non-0 for bad fit (i.e. kfit=kFALSE), see "enum CombineStatus" definition in header file
+/// const Int_t status = fCombinedTrackfit->GetStatus(); 
+///
+/// //in Analysis Task write when terminate 
+/// fCombinedTrackfit->GetStreamer()->GetFile()->Write();
+/// ~~~
+///
+/// Debug output
+/// ------------
+///
+/// For (debuglevel & 1)==1 && good fit, the following info saved:
+///
+/// ~~~{.cxx}
+///
+/// (*fStreamer)<<"TrackProp"<<
+///     "Tup.="<<fTrackparUp<<          //AliExternalTrackParam at uppermost cluster obtained by upward propagation
+///     "Tlow.="<<fTrackparLow<<        //AliExternalTrackParam at lowermost cluster obtained by downward propagation
+///     "icup.="<<&fInnerClusterUp<<    //TVector3 position of the innermost cluster of the upper track
+///     "iclow.="<<&fInnerClusterLow<<
+///     "leverarm="<<fLeverArm<<
+///     "ncl="<<fFitNcls<<              //number of clusters used in successful propagation  
+///     "nmiss="<<fMissNcls<<           //number of clusters failed in propagation, should always be 0 in this case.
+///     "chi2="<<fPreChi2<<             //chi2/nfit  
+///     "momup="<<  momup <<            //momentum at uppermost cluster with upward propagation
+///     "momlow="<< momlow <<           //momentum at lowermost cluster with downward propagation
+///     "ptup="<<   ptup <<
+///     "ptlow="<<  ptlow <<
+///     "\n";
+/// ~~~
+///
+/// For (debuglevel & 2)==1, debug info in `AliTPCCosmicUtils::FitKernel` saved
+///
+/// Efficiency
+/// ----------
+///
+/// For 2011 Feb. cosmic data nch=2 events, the kfit and status look like:
+/// 
+/// ~~~{.cxx}
+/// kfit,status (  0,   1):   68939 / 2611959 =   2.639%          //kFailGetTPCseeds
+/// kfit,status (  0,   2):   14886 / 2611959 =   0.570%          //not both tracks have ncl > AliTPCCosmicUtils::fgkNclsMin
+/// kfit,status (  0,   3):   53185 / 2611959 =   2.036%          //clusters in two tracks should be clearly separated in y, i.e. lowest cluster of upper track higher than highest cluster of lower track; otherwise fail
+/// kfit,status (  0,   4):   39841 / 2611959 =   1.525%          //fLeverArm<fgkCutLeverArm
+/// kfit,status (  0,   6):   12933 / 2611959 =   0.495%          //fail in propagation of at least one cluster
+/// kfit,status (  0,   7):   19994 / 2611959 =   0.765%          //chi2/nfit > fgkMaxChi2
+/// kfit,status (  1,   0): 2402181 / 2611959 =  91.969%          //i.e. 92% of nch=2 events are successfully fitted.
+/// ~~~
+/// 
+/// Resolution
+/// ----------
+///
+/// For muon momentum small than 20 GeV, energy loss in muon filter is visable when compaing fTrackparUp and fTrackparLow; energy loss estimated as 5 MeV/cm.
+/// Particle traversing muon filter can be rejected by requiring `fInnerClusterUp.fZ > -40 && fInnerClusterLow.fZ > -40`
+/// Momentum resolution is estimated by comparing the trackfit result by upward propagation through odd pad rows and that by downward propagation through even pad rows. Number of clusters used in this case is only half of that in normal usage.
+/// RMS of log10 p = 0.01 at 10 GeV/c, 0.1 at 100 GeV/c, 0.5 at 1 TeV/c.
+/// Muon filter deteriorates momentum resolution by about +0.01 (absolute value).
+///
+/// \author Xianguo Lu <lu@physi.uni-heidelberg.de>
 
-  //in Analysis Task write when terminate 
-  fCombinedTrackfit->GetStreamer()->GetFile()->Write();
-*/
-//
-// ----- Debug output:
-// for (debuglevel & 1)==1 && good fit, the following info saved:
-/*
-  (*fStreamer)<<"TrackProp"<<
-      "Tup.="<<fTrackparUp<<          //AliExternalTrackParam at uppermost cluster obtained by upward propagation
-      "Tlow.="<<fTrackparLow<<        //AliExternalTrackParam at lowermost cluster obtained by downward propagation
-      "icup.="<<&fInnerClusterUp<<    //TVector3 position of the innermost cluster of the upper track
-      "iclow.="<<&fInnerClusterLow<<
-      "leverarm="<<fLeverArm<<
-      "ncl="<<fFitNcls<<              //number of clusters used in successful propagation  
-      "nmiss="<<fMissNcls<<           //number of clusters failed in propagation, should always be 0 in this case.
-      "chi2="<<fPreChi2<<             //chi2/nfit  
-      "momup="<<  momup <<            //momentum at uppermost cluster with upward propagation
-      "momlow="<< momlow <<           //momentum at lowermost cluster with downward propagation
-      "ptup="<<   ptup <<
-      "ptlow="<<  ptlow <<
-      "\n";
- */
-// for (debuglevel & 2)==1, debug info in AliTPCCosmicUtils::FitKernel saved
-//
-// ----- Efficiency:
-// for 2011 Feb. cosmic data nch=2 events, the kfit and status look like:
-/*
-kfit,status (  0,   1):   68939 / 2611959 =   2.639%          //kFailGetTPCseeds
-kfit,status (  0,   2):   14886 / 2611959 =   0.570%          //not both tracks have ncl > AliTPCCosmicUtils::fgkNclsMin
-kfit,status (  0,   3):   53185 / 2611959 =   2.036%          //clusters in two tracks should be clearly separated in y, i.e. lowest cluster of upper track higher than highest cluster of lower track; otherwise fail
-kfit,status (  0,   4):   39841 / 2611959 =   1.525%          //fLeverArm<fgkCutLeverArm
-kfit,status (  0,   6):   12933 / 2611959 =   0.495%          //fail in propagation of at least one cluster
-kfit,status (  0,   7):   19994 / 2611959 =   0.765%          //chi2/nfit > fgkMaxChi2
-kfit,status (  1,   0): 2402181 / 2611959 =  91.969%          //i.e. 92% of nch=2 events are successfully fitted.
-*/
-//
-// ----- Resolution:
-// for muon momentum small than 20 GeV, energy loss in muon filter is visable when compaing fTrackparUp and fTrackparLow; energy loss estimated as 5 MeV/cm.
-// particle traversing muon filter can be rejected by requiring "fInnerClusterUp.fZ > -40 && fInnerClusterLow.fZ > -40"
-// momentum resolution is estimated by comparing the trackfit result by upward propagation through odd pad rows and that by downward propagation through even pad rows. Number of clusters used in this case is only half of that in normal usage.
-// RMS of log10 p = 0.01 at 10 GeV/c, 0.1 at 100 GeV/c, 0.5 at 1 TeV/c.
-// muon filter deteriorates momentum resolution by about +0.01 (absolute value).
-//
-//  Xianguo Lu <lu@physi.uni-heidelberg.de>
-//
 /*
 //in [cm]
 const Double_t _TPCZMIN = -250;
@@ -136,26 +149,26 @@ class AliTPCCombinedTrackfit
   void CombineTPCseeds(Bool_t &kswap);
   void Update();
 
-  TTreeSRedirector *fStreamer;     //!debug streamer
-  Int_t fDebugLevel;                    //debug level
+  TTreeSRedirector *fStreamer;     //!< debug streamer
+  Int_t fDebugLevel;                    ///< debug level
 
-  AliTPCseed * fSeedUp;                         //TPC seed of upper track
-  AliTPCseed * fSeedLow;                        //TPC seed of lower track
-  AliExternalTrackParam * fTrackparUp;          //track param of upper track
-  AliExternalTrackParam * fTrackparLow;         //track param of lower track
+  AliTPCseed * fSeedUp;                         ///< TPC seed of upper track
+  AliTPCseed * fSeedLow;                        ///< TPC seed of lower track
+  AliExternalTrackParam * fTrackparUp;          ///< track param of upper track
+  AliExternalTrackParam * fTrackparLow;         ///< track param of lower track
 
-  Int_t fStatus;                               //status for CombineESDtracks/CombineTPCseeds: 0-successful, otherwise fail
+  Int_t fStatus;                               ///< status for CombineESDtracks/CombineTPCseeds: 0-successful, otherwise fail
   
-  TVector3 fInnerClusterUp;                    //xyz of the inner most TPC trackpoint of the Upper track
-  TVector3 fInnerClusterLow;                   //xyz of the inner most TPC trackpoint of the Lower track
-  Double_t fLeverArm;                          //transverse difference between upper most and lower most clusters
+  TVector3 fInnerClusterUp;                    ///< xyz of the inner most TPC trackpoint of the Upper track
+  TVector3 fInnerClusterLow;                   ///< xyz of the inner most TPC trackpoint of the Lower track
+  Double_t fLeverArm;                          ///< transverse difference between upper most and lower most clusters
 
-  Int_t fFitNcls;                              //number of TPC clusters successful in propagation (mean of the two propagation: upwards and downwards)
-  Int_t fMissNcls;                             //number of TPC clusters fail in propagation (sum of the two propagation)
-  Double_t fPreChi2;                           //Predicted chi2/nfit over the two propagation
+  Int_t fFitNcls;                              ///< number of TPC clusters successful in propagation (mean of the two propagation: upwards and downwards)
+  Int_t fMissNcls;                             ///< number of TPC clusters fail in propagation (sum of the two propagation)
+  Double_t fPreChi2;                           ///< Predicted chi2/nfit over the two propagation
 
-  static const Double_t fgkCutLeverArm = 350;  //minimum lever arm 350 ~ 250 * sqrt(2)
-  static const Double_t fgkMaxChi2 = 10;       //max. chi2/ncls
+  static const Double_t fgkCutLeverArm = 350;  ///< minimum lever arm 350 ~ 250 * sqrt(2)
+  static const Double_t fgkMaxChi2 = 10;       ///< max. chi2/ncls
 };
 
 #endif
index 759dfe9..c711f90 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-  Calculation of the Electric field:
-  Sollution of laplace equation in cartezian system, with boundary condition.
-  Se details:
-  http://web.mit.edu/6.013_book/www/chapter5/5.10.html
 
-
-*/
-
-/* $Id: AliTPCEfield.cxx 41275 2010-05-16 22:23:06Z marian $ */
+/// \class AliTPCEfield
+///
+/// Solution of Laplace equation in cartesian system, with boundary condition.
+///
+/// See details:
+/// http://web.mit.edu/6.013_book/www/chapter5/5.10.html
 
 #include "TTreeStream.h"
 #include "TMath.h"
@@ -30,8 +27,9 @@
 #include "TRandom.h"
 #include "AliTPCEfield.h"
 
+/// \cond CLASSIMP
 ClassImp(AliTPCEfield)
-
+/// \endcond
 
 AliTPCEfield* AliTPCEfield::fgInstance=0;
 
@@ -42,7 +40,8 @@ AliTPCEfield::AliTPCEfield():
   fIs2D(kTRUE),
   fWorkspace(0)   // file with trees, pictures ...
 {
-  //
+  /// 
+
   for (Int_t i=0; i<3; i++){
     fMin[i]=0; fMax[i]=0;
   }
@@ -57,7 +56,8 @@ AliTPCEfield::AliTPCEfield(const char* name, Int_t maxFreq, Bool_t is2D, Bool_t
   fUseLinear(useLinear),
   fWorkspace(0)   // file with trees, pictures ...
 {
-  //
+  /// 
+
   for (Int_t i=0; i<3; i++){
     fMin[i]=0; fMax[i]=0;
   }
@@ -67,15 +67,14 @@ AliTPCEfield::AliTPCEfield(const char* name, Int_t maxFreq, Bool_t is2D, Bool_t
 }
 
 void AliTPCEfield::MakeFitFunctions(Int_t maxFreq){
-  //
-  // fit functions = f(x,y,z) = fx(x)*fy(y)*fz(z)
-  // function can be of following types: 
-  // 0 - constant
-  // 1 - linear
-  // 2 - hypx
-  // 3 - hypy
-  // 4 - hypz
-  //
+  /// fit functions = \f$ f(x,y,z) = fx(x)*fy(y)*fz(z) \f$
+  /// function can be of following types:
+  /// 0 - constant
+  /// 1 - linear
+  /// 2 - hypx
+  /// 3 - hypy
+  /// 4 - hypz
+
   Int_t nfunctions=0;
   if (fIs2D)     nfunctions = 1+(maxFreq)*8;
   if (!fIs2D)    nfunctions = 1+(maxFreq)*8;
@@ -123,17 +122,15 @@ void AliTPCEfield::MakeFitFunctions(Int_t maxFreq){
 
 
 AliTPCEfield::~AliTPCEfield() {
-  //
-  // Destructor
-  //
+  /// Destructor
+
   if (fWorkspace) delete fWorkspace;
 }
 
 void AliTPCEfield::SetRange(Double_t x0, Double_t x1, Double_t y0, Double_t y1, Double_t z0,Double_t z1){
-  //
-  // Set the ranges - coordinates are rescaled in order to use proper
-  // cos,sin expansion in scaled space
-  //
+  /// Set the ranges - coordinates are rescaled in order to use proper
+  /// cos,sin expansion in scaled space
+
   fMin[0]=x0; fMax[0]=x1;
   fMin[1]=y0; fMax[1]=y1;
   fMin[2]=z0; fMax[2]=z1;
@@ -143,13 +140,12 @@ void AliTPCEfield::SetRange(Double_t x0, Double_t x1, Double_t y0, Double_t y1,
 
 
 void AliTPCEfield::AddBoundaryLine(Double_t x0,Double_t y0,Double_t z0,  Double_t v0, Double_t x1, Double_t y1, Double_t z1,Double_t v1, Int_t id, Int_t npoints){
-  //
-  // Add a e field boundary line
-  // From point (x0,y0) to point (x1,y1)
-  // Linear decrease of potential is assumed
-  // Boundary can be identified using boundary ID
-  // The line is written into tree Boundary
-  // 
+  /// Add a e field boundary line
+  /// From point (x0,y0) to point (x1,y1)
+  /// Linear decrease of potential is assumed
+  /// Boundary can be identified using boundary ID
+  /// The line is written into tree Boundary
+
   Double_t deltaX = (x1-x0);
   Double_t deltaY = (y1-y0);
   Double_t deltaZ = (z1-z0);
@@ -171,16 +167,15 @@ void AliTPCEfield::AddBoundaryLine(Double_t x0,Double_t y0,Double_t z0,  Double_
 }
 
 TTree * AliTPCEfield::GetTree(const char * tname){
-  //  
-  //
-  //
+  /// 
+
   return ((*fWorkspace)<<tname).GetTree();
 }
 
 Double_t AliTPCEfield::Field(Int_t ftype,  Double_t ifx, Double_t ify, Double_t ifz, Double_t x, Double_t y, Double_t z){
-  //
-  // Field component in 
-  // f frequency
+  /// Field component in
+  /// f frequency
+
   Double_t fx=1,fy=1,fz=1;
   const Double_t kEps=0.01;
   //
@@ -216,12 +211,9 @@ Double_t AliTPCEfield::Field(Int_t ftype,  Double_t ifx, Double_t ify, Double_t
 
 
 Double_t AliTPCEfield::FieldDn(Int_t ftype, Double_t ifx, Double_t ify, Double_t ifz, Int_t dn, Double_t x, Double_t y, Double_t z){
-  //
-  //
-  //
- //
-  // Field component in 
-  // f frequency
+ /// Field component in
+ /// f frequency
+
   Double_t fx=1,fy=1,fz=1;
   const Double_t kEps=0.01;
   //
@@ -266,12 +258,12 @@ Double_t AliTPCEfield::FieldDn(Int_t ftype, Double_t ifx, Double_t ify, Double_t
 
 
 Double_t AliTPCEfield::EvalField(Int_t ifun, Double_t x, Double_t y, Double_t z, Int_t type){
-  //
-  // Evaluate function ifun at position gx amd gy
-  // type == 0 - field
-  //      == 1 - Ex
-  //      == 2 - Ey
-  //      == 3 - Ez
+  /// Evaluate function ifun at position gx amd gy
+  /// type == 0 - field
+  ///      == 1 - Ex
+  ///      == 2 - Ey
+  ///      == 3 - Ez
+
   TMatrixD &mat    = *fFitFunctions;
   Int_t     fid   = TMath::Nint(mat(ifun,0));
   Double_t   ifx   = (mat(ifun,1));
@@ -284,12 +276,12 @@ Double_t AliTPCEfield::EvalField(Int_t ifun, Double_t x, Double_t y, Double_t z,
 }
 
 Double_t AliTPCEfield::Eval(Double_t x, Double_t y, Double_t z, Int_t type){
-  //
-  // Evaluate function ifun at position gx amd gy
-  // type == 0 - field
-  //      == 1 - Ex
-  //      == 2 - Ey
-  //      == 3 - Ez
+  /// Evaluate function ifun at position gx amd gy
+  /// type == 0 - field
+  ///      == 1 - Ex
+  ///      == 2 - Ey
+  ///      == 3 - Ez
+
   Double_t value=0;   
   Double_t lx= 2.*(x-(fMin[0]+fMax[0])*0.5)/fScale;
   Double_t ly= 2.*(y-(fMin[1]+fMax[1])*0.5)/fScale;
@@ -304,18 +296,16 @@ Double_t AliTPCEfield::Eval(Double_t x, Double_t y, Double_t z, Int_t type){
 }
 
 Double_t AliTPCEfield::EvalS(Double_t x, Double_t y, Double_t z,  Int_t type){
-  //
-  // static evaluation - possible to use it in the TF1 
-  //
+  /// static evaluation - possible to use it in the TF1
+
   return fgInstance->Eval(x,y,z,type);
 }
 
 void AliTPCEfield::FitField(){
-  //
-  // Fit the e field
-  // Minimize chi2 residuals at the boundary points 
-  // ?Tempoary sollution - integrals can be calculated analytically -
-  //
+  /// Fit the e field
+  /// Minimize chi2 residuals at the boundary points
+  /// ?Tempoary sollution - integrals can be calculated analytically -
+
   Int_t nfun=fFitFunctions->GetNrows();
   Double_t *fun =new Double_t[nfun];
   fFitter= new TLinearFitter(nfun, Form("hyp%d", nfun-1));
@@ -373,9 +363,8 @@ void AliTPCEfield::FitField(){
 
 
 TMatrixD* AliTPCEfield::MakeCorrelation(TMatrixD &matrix){
-  //
-  //
-  //
+  /// 
+
   Int_t nrows = matrix.GetNrows();
   TMatrixD * mat = new TMatrixD(nrows,nrows);
   for (Int_t irow=0; irow<nrows; irow++)
@@ -389,9 +378,8 @@ TMatrixD* AliTPCEfield::MakeCorrelation(TMatrixD &matrix){
 
 
 void AliTPCEfield::DumpField(Double_t gridSize, Double_t step){
-  //
-  //
-  //
+  /// 
+
   Double_t stepSize=0.001*fScale/fMaxFreq;
   //
   for (Double_t x = fMin[0]+stepSize; x<=fMax[0]-stepSize; x+=gridSize){
index 46408e6..e32ea68 100644 (file)
@@ -4,8 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliTPCEfield.h 35613 2009-10-16 03:24:40Z marian $ */
-
+/// \class AliTPCEfield
+/// \brief Calculation of the electric field
 
 #include "TNamed.h"
 #include "TMatrixD.h"
@@ -21,7 +21,8 @@ public:
   void SetRange(Double_t x0, Double_t x1, Double_t y0, Double_t y1, Double_t z00,Double_t z1=0);
   void AddBoundaryLine(Double_t x0,Double_t y0, Double_t z0, Double_t v0, Double_t x1, Double_t y1, Double_t z1, Double_t v1, Int_t id=0, Int_t npoints=100);
   TTree * GetTree(const char * tname="Boundary");
-  //
+/// \class AliTPCEfield
+
   void MakeFitFunctions(Int_t maxFreq);
   void FitField();
   void DumpField(Double_t gridSize=5, Double_t step=0.5);
@@ -40,19 +41,19 @@ public:
   Double_t SinHNorm(Double_t x, Double_t norm){ return 0.5*(TMath::Exp(x-norm)-TMath::Exp(-x-norm));}
   Double_t CosHNorm(Double_t x, Double_t norm){ return 0.5*(TMath::Exp(x-norm)+TMath::Exp(-x-norm));}
  public:
-  Double_t fMin[3];      // range of coordinates from Min to Max
-  Double_t fMax[3];      //  
-  Double_t fScale;       // scaling factor
-  Int_t    fMaxFreq;     // maximal frequency of expansion
-  Bool_t   fIs2D;        // flag for 2D field
-  Bool_t   fUseLinear;   // flag to use also linear term of the field 
+  Double_t fMin[3];      ///< range of coordinates from Min to Max
+  Double_t fMax[3];      ///< 
+  Double_t fScale;       ///< scaling factor
+  Int_t    fMaxFreq;     ///< maximal frequency of expansion
+  Bool_t   fIs2D;        ///< flag for 2D field
+  Bool_t   fUseLinear;   ///< flag to use also linear term of the field
   //
-  TTreeSRedirector * fWorkspace;    //! workspace
-  TMatrixD  *fFitFunctions;         // fit function description
-  TVectorD  *fFitParam;             // fit parameters - coeficients
-  TMatrixD  *fFitCovar;             // fit covariance
-  TLinearFitter *fFitter;           // linear fitter - temporary solution - integrals to be calculated
-  static AliTPCEfield* fgInstance;  // instance of fied  - for visualization
+  TTreeSRedirector * fWorkspace;    //!< workspace
+  TMatrixD  *fFitFunctions;         ///< fit function description
+  TVectorD  *fFitParam;             ///< fit parameters - coeficients
+  TMatrixD  *fFitCovar;             ///< fit covariance
+  TLinearFitter *fFitter;           ///< linear fitter - temporary solution - integrals to be calculated
+  static AliTPCEfield* fgInstance;  ///< instance of fied  - for visualization
   ClassDef(AliTPCEfield,1)
 };
 
index 5f93a2a..57d2981 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBConical class                                                   //
-// The class calculates the space point distortions due to the conical shape 
-// of ALICE TPC:
-//
-// Becasue of mechanical deformation ALICE TPC, chambers are misaligned in z direction
-// TPC has roughly conical shape
-//
-// For the moment ONLY efective correction used - NOT EDGE EFFECT calcualted //  
-//                                                           //
-//                     //
-// The class allows "effective Omega Tau" corrections.                    // 
-// 
-//                                                                        //
-// date: 02/05/2010                                                       //
-// Authors: Marian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger     //
-//                                                                        //
-// Example usage:                                                         //
-//  AliTPCExBConical conical;                                                //
-//  conical.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB         //
-//  conical.SetXConical(0.001);   // set conical in X direction (in rad)     //
-//  // plot dRPhi distortions ...                                            //
-//  conical.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");                //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBConical
+/// 
+/// Calculates the space point distortions due to the conical shape of ALICE TPC.
+/// 
+/// Becasue of mechanical deformation ALICE TPC, chambers are misaligned in z direction
+/// TPC has roughly conical shape
+/// 
+/// For the moment ONLY efective correction used - NOT EDGE EFFECT calcualted
+/// 
+/// The class allows "effective Omega Tau" corrections.
+/// 
+/// Example usage:
+///
+/// ~~~{.cxx}
+/// AliTPCExBConical conical;
+/// conical.SetOmegaTauT1T2(0.32,1.,1.); // values ideally from OCDB
+/// conical.SetXConical(0.001);   // set conical in X direction (in rad)
+/// // plot dRPhi distortions ...
+/// conical.CreateHistoDRPhiinZR(1.,100,100)->Draw("surf2");
+/// ~~~
+/// 
+/// \author Marian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
+
 #include "AliMagF.h"
 #include "TGeoGlobalMagField.h"
 #include "AliTPCcalibDB.h"
@@ -63,25 +62,22 @@ AliTPCExBConical::AliTPCExBConical()
 }
 
 AliTPCExBConical::~AliTPCExBConical() {
-  //
-  // default destructor
-  //
+  /// default destructor
+
 }
 
 
 
 void AliTPCExBConical::Init() {
-  //
-  // Initialization funtion
-  //
-  
+  /// Initialization funtion
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
-  Double_t bzField = magF->SolenoidField()/10.; //field in T
+  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 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);
@@ -90,16 +86,15 @@ void AliTPCExBConical::Init() {
 }
 
 void AliTPCExBConical::Update(const TTimeStamp &/*timeStamp*/) {
-  //
-  // Update function 
-  //
+  /// Update function
+
   AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
   if (!magF) AliError("Magneticd field - not initialized");
-  Double_t bzField = magF->SolenoidField()/10.; //field in T
+  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 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);
@@ -110,9 +105,8 @@ void AliTPCExBConical::Update(const TTimeStamp &/*timeStamp*/) {
 
 
 void AliTPCExBConical::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
-  //
-  // Calculates the correction due conical shape
-  //   
+  /// Calculates the correction due conical shape
+
   AliTPCROC * calROC = AliTPCROC::Instance();
   const Double_t kRTPC0  =calROC->GetPadRowRadii(0,0);
   const Double_t kRTPC1  =calROC->GetPadRowRadii(36,calROC->GetNRows(36)-1);
@@ -136,10 +130,8 @@ void AliTPCExBConical::GetCorrection(const Float_t x[],const Short_t roc,Float_t
 }
 
 void AliTPCExBConical::Print(const Option_t* option) const {
-  //
-  // Print function to check the settings (e.g. the conical in the X direction)
-  // option=="a" prints the C0 and C1 coefficents for calibration purposes
-  //
+  /// Print function to check the settings (e.g. the conical in the X direction)
+  /// option=="a" prints the C0 and C1 coefficents for calibration purposes
 
   TString opt = option; opt.ToLower();
   printf("%s:%s\n",GetTitle(), GetName());
@@ -152,17 +144,15 @@ void AliTPCExBConical::Print(const Option_t* option) const {
 
 
 void AliTPCExBConical::SetConicalA(Float_t conicalA[3]){
-  //
-  // set paramters of conical shape - A side - obtained from alignment
-  //
+  /// set paramters of conical shape - A side - obtained from alignment
+
   fConicalA[0]= conicalA[0];  // constant
   fConicalA[1]= conicalA[1];  // cos 
   fConicalA[2]= conicalA[2];  // sin
 }
 void AliTPCExBConical::SetConicalC(Float_t conicalC[3]){
-  //
-  // set paramters of conical shape -C side obtained form the alignemnt
-  // 
+  /// set paramters of conical shape -C side obtained form the alignemnt
+
   fConicalC[0]= conicalC[0];  // constant
   fConicalC[1]= conicalC[1];  // cos 
   fConicalC[2]= conicalC[2];  // sin
index 547967c..241147e 100644 (file)
@@ -4,12 +4,11 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// AliTPCExBConical class                                                   //
-// date: 02/05/2010                                                       //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger                    //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBConical
+/// \brief Calculates the space point distortions due to the conical shape of ALICE TPC
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
 
 #include "AliTPCCorrection.h"
 
@@ -48,11 +47,11 @@ protected:
   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
 
 private:
-  Float_t fC1; // coefficient C1                 (compare Jim Thomas's notes for definitions)
-  Float_t fC2; // coefficient C2                 (compare Jim Thomas's notes for definitions)
-  Float_t  fConicalFactor;                  // empirical factor - transform conical angle to delta
-  Float_t  fConicalA[3];               // Conical shape parameterization A side
-  Float_t  fConicalC[3];               // Conical shape parameterization C side
+  Float_t fC1; ///< coefficient C1                 (compare Jim Thomas's notes for definitions)
+  Float_t fC2; ///< coefficient C2                 (compare Jim Thomas's notes for definitions)
+  Float_t  fConicalFactor;                  ///< empirical factor - transform conical angle to delta
+  Float_t  fConicalA[3];               ///< Conical shape parameterization A side
+  Float_t  fConicalC[3];               ///< Conical shape parameterization C side
 
   ClassDef(AliTPCExBConical,1);
 };
index 58184a4..47c6ff9 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
-/*
-  Author : MI
-  macro to compare TClonesArray hits with interpolated hits
-  ConvertHits1 read 
-*/
+/// Macro to compare TClonesArray hits with interpolated hits
+/// ConvertHits1 read 
+///
+/// \author MI
 
 #include "alles.h"
 #include "AliObjectArray.h"
 #include "AliArrayBranch.h"
 #include "TestTPCTrackHits.h"
  
+/// \cond CLASSIMP
 ClassImp(AliTPChitD)
+/// \endcond
  
 void CompareHits(TClonesArray * arr, AliTPCTrackHits * myhits,  Bool_t debug, TClonesArray *arrd=0);
 AliTPCTrackHits * MakeTrack(TClonesArray * arr, TClonesArray * arrp, AliTPCTrackHits *myhits);
 
 void ConvertHits(const char * benchmark, Bool_t debug)
 {      
-  //
-  //convert - not parametrised hits stored in Clones array
-  //to
 
+  /// convert - not parametrised hits stored in Clones array
+  /// to
 
   TFile f("galice.root","update");  
   TClonesArray *arr = new TClonesArray("AliTPChit",100);
index a270aae..652627c 100644 (file)
@@ -3,17 +3,18 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
-
 void ConvertHits(const char * benchmark="0", Bool_t debug=kFALSE);
 void CompareHits(const char * benchmark="1", Bool_t debug=kFALSE);
 
+/// \class AliTPChitD
+/// \brief Macro to compare TClonesArray hits with interpolated hits
+/// \author MI
+
 class AliTPChitD : public AliTPChit {
 public:
   AliTPChit * GetDelta() {return &fDelta;}
 private:
-  AliTPChit fDelta;     //delta of hit information 
+  AliTPChit fDelta;     ///< delta of hit information
   ClassDef(AliTPChitD,1) 
 };
 #endif
index ceb1c7e..40344d5 100755 (executable)
@@ -2,20 +2,8 @@
 
 cd "${ALICE_ROOT}"/../src/
 
-# find TPC/ -maxdepth 1 -name '*.h' -or -name '*.cxx'
-
-#Files=$( find TPC/ -name '*.C' -or -name '*.h' -or -name '*.cxx' )
-
-# Files=(
-#   'TPC/LandauTest.C'
-#   #'TPC/Attic/AliTPCCalibTCF.h'
-# )
-
-# Files=(
-#   'EVE/EveDet/AliEveEMCALSModuleData.h'
-# )
-
-Files=$( find TPC/ -maxdepth 1 -name '*.h' -or -name '*.cxx' )
+# TPC
+Files=$( find TPC/ -maxdepth 1 -name '*.h' -or -name '*.cxx' -or -name '*.C' )
 
 while [[ $# -gt 0 ]] ; do
   case "$1" in