Due to developments in the Off-line code there is an impact on the HLT DA algorithms...

diff --git a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
index 39ecd5f423dc1e9307b1506b11e45a79b1562019..112e95118d2c2dba3ff549b69acaa6e45f0289ff 100644 (file)
--- a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
+++ b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
@@ -275,7 +275,7 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponent_EventData& evt
 
   free(memBufIn);
 
-  UInt_t memBufOutSize = 0;
+  //UInt_t memBufOutSize = 0;
   //   void *memBufOut = clusterizer->WriteClustersToMemory(memBufOut, memBufOutSize);
   Int_t iNclusters = clusterizer->GetNclusters();
   Logging( kHLTLogInfo, "HLT::TRDClusterizer::DoEvent", "COUNT", "N of Clusters = %d", iNclusters);

diff --git a/HLT/TRD/AliHLTTRDDefinitions.cxx b/HLT/TRD/AliHLTTRDDefinitions.cxx
index fed4f8e04d45ca8d170910329911a59df55d3a3d..17d4ad788966d7abf98d5deacbb2a381824c2bdf 100644 (file)
--- a/HLT/TRD/AliHLTTRDDefinitions.cxx
+++ b/HLT/TRD/AliHLTTRDDefinitions.cxx
@@ -37,3 +37,14 @@ const AliHLTComponentDataType AliHLTTRDDefinitions::fgkMCMtrackletDataType = { s
 
 const AliHLTComponentDataType AliHLTTRDDefinitions::fgkMCMcalibrationDataType = { sizeof(AliHLTComponentDataType), {'M','C','M','C','A','L','I','H'},{'T','R','D',' '}};;
 
+AliHLTTRDDefinitions::AliHLTTRDDefinitions()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+}
+
+AliHLTTRDDefinitions::~AliHLTTRDDefinitions()
+{
+  // see header file for class documentation
+}

diff --git a/HLT/TRD/AliHLTTRDDefinitions.h b/HLT/TRD/AliHLTTRDDefinitions.h
index 3bdcbfd73e5a1e27835d5d22cba3201a9971c859..3b2c940ec4a9331f988a860f53f16ac87d00374b 100644 (file)
--- a/HLT/TRD/AliHLTTRDDefinitions.h
+++ b/HLT/TRD/AliHLTTRDDefinitions.h
@@ -23,6 +23,8 @@
 class AliHLTTRDDefinitions
 {
     public:
+      AliHLTTRDDefinitions();
+      virtual ~AliHLTTRDDefinitions();
 
       static const AliHLTComponentDataType fgkDDLRawDataType;
       static const AliHLTComponentDataType fgkClusterDataType;

diff --git a/HLT/TRD/AliHLTTRDLinkDef.h b/HLT/TRD/AliHLTTRDLinkDef.h
index f7faa93d21d8b8f8e82068f650afd4194cc9f88e..901da380cddfb2de7727422e029a4d8b4caf4aba 100644 (file)
--- a/HLT/TRD/AliHLTTRDLinkDef.h
+++ b/HLT/TRD/AliHLTTRDLinkDef.h
@@ -5,12 +5,9 @@
 #pragma link off all functions;
 
 #pragma link C++ class AliTRDclusterizerV1HLT;
-#pragma link C++ class AliTRDtriggerHLT;
-#pragma link C++ class AliHLTTRDCalibrationComponent;
 #pragma link C++ class AliHLTTRDClusterizerComponent;
 #pragma link C++ class AliHLTTRDTrackerComponent;
 #pragma link C++ class AliHLTTRDDefinitions;
-#pragma link C++ class AliHLTTRDCalibra;
 #pragma link C++ class AliTRDtrackerHLT;
 #endif
 

diff --git a/HLT/TRD/AliTRDtrackerHLT.cxx b/HLT/TRD/AliTRDtrackerHLT.cxx
index d198cc4f1f3e61b15de0efc7e02dcd8311b4e3f0..26f3cc672f42c19fe4a487ad6c522e11c88cf629 100644 (file)
--- a/HLT/TRD/AliTRDtrackerHLT.cxx
+++ b/HLT/TRD/AliTRDtrackerHLT.cxx
@@ -199,7 +199,7 @@ AliTRDtrackerHLT::AliTRDtrackerHLT(const TFile *geomfile)
     }
   }
 
-  AliTRDpadPlane *padPlane = AliTRDCommonParam::Instance()->GetPadPlane(0,0);
+  AliTRDpadPlane *padPlane = fGeom->GetPadPlane(0,0);
   Float_t tiltAngle = TMath::Abs(padPlane->GetTiltingAngle());
   if (tiltAngle < 0.1) {
     fNoTilt = kTRUE;
@@ -436,8 +436,7 @@ Bool_t  AliTRDtrackerHLT::Transform(AliTRDcluster *cluster)
   Double_t vdrift = AliTRDcalibDB::Instance()->GetVdrift(cluster->GetDetector(),0,0);
   Double_t exB    = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift,-AliTracker::GetBz()*0.1);
 
-  AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();  
-  AliTRDpadPlane    *padPlane    = commonParam->GetPadPlane(plane,chamber);
+  AliTRDpadPlane    *padPlane    = fGeom->GetPadPlane(plane,chamber);
   Double_t zshiftIdeal = 0.5*(padPlane->GetRow0()+padPlane->GetRowEnd());
   Double_t localPos[3];
   Double_t localPosTracker[3];
@@ -1649,7 +1648,7 @@ void AliTRDtrackerHLT::MakeSeedsMI(Int_t /*inner*/, Int_t /*outer*/, AliESD *esd
     }
   }
 
-  AliTRDpadPlane *padPlane = AliTRDCommonParam::Instance()->GetPadPlane(0,0);
+  AliTRDpadPlane *padPlane = fGeom->GetPadPlane(0,0);
   Double_t h01 = TMath::Tan(-TMath::Pi() / 180.0 * padPlane->GetTiltingAngle());
   Double_t hL[6];                                                // Tilting angle
   Double_t xcl[6];                                               // X - position of reference cluster
@@ -3167,14 +3166,14 @@ AliTRDtrackingSectorHLT
   for (Int_t plane = 0; plane < AliTRDgeometry::Nplan(); plane++) {
 
     ymax          = fGeom->GetChamberWidth(plane) / 2.0;
-    padPlane      = commonParam->GetPadPlane(plane,0);
+    padPlane      = fGeom->GetPadPlane(plane,0);
     ymaxsensitive = (padPlane->GetColSize(1) * padPlane->GetNcols() - 4.0) / 2.0;    
 
     for (Int_t ch = 0; ch < kNchambers; ch++) {
       zmax[ch]          = fGeom->GetChamberLength(plane,ch) / 2.0;
       Float_t pad       = padPlane->GetRowSize(1);
-      Float_t row0      = commonParam->GetRow0(plane,ch,0);
-      Int_t   nPads     = commonParam->GetRowMax(plane,ch,0);
+      Float_t row0      = fGeom->GetRow0(plane,ch,0);
+      Int_t   nPads     = fGeom->GetRowMax(plane,ch,0);
       zmaxsensitive[ch] = Float_t(nPads) * pad / 2.0;      
       zc[ch]            = -(pad * nPads) / 2.0 + row0;
     }
@@ -3567,7 +3566,7 @@ Double_t AliTRDtrackerHLT::GetTiltFactor(const AliTRDcluster *c)
 
   Int_t    det   = c->GetDetector();    
   Int_t    plane = fGeom->GetPlane(det);
-  AliTRDpadPlane *padPlane = AliTRDCommonParam::Instance()->GetPadPlane(plane,0);
+  AliTRDpadPlane *padPlane = fGeom->GetPadPlane(plane,0);
   Double_t h01   = TMath::Tan(-TMath::Pi() / 180.0 * padPlane->GetTiltingAngle());
 
   if (fNoTilt) {

diff --git a/HLT/TRD/AliTRDtrackerHLT.h b/HLT/TRD/AliTRDtrackerHLT.h
index ee27997c3d6b1ccada97b9c223c91a7e8bbc6723..992c0ed12fcf3604e55e4774e3b5c92a36a9aed5 100644 (file)
--- a/HLT/TRD/AliTRDtrackerHLT.h
+++ b/HLT/TRD/AliTRDtrackerHLT.h
@@ -45,147 +45,147 @@ namespace AliTRDtrackingHLT {
         , kTrackingSectors      = 18   };
 }
 
- class AliTRDpropagationLayerHLT {
+class AliTRDpropagationLayerHLT {
     
-  public: 
+ public: 
     
-    AliTRDpropagationLayerHLT(Double_t x, Double_t dx, Double_t rho
-                          , Double_t x0, Int_t tbIndex, Int_t plane); 
-    AliTRDpropagationLayerHLT(const AliTRDpropagationLayerHLT &/*p*/);
-    ~AliTRDpropagationLayerHLT() { 
-      if (fTimeBinIndex >= 0) { 
-       delete[] fClusters; 
-       delete[] fIndex; 
-      }     
-    }
-    AliTRDpropagationLayerHLT &operator=(const AliTRDpropagationLayerHLT &/*p*/) 
-      {return *this;}
+  AliTRDpropagationLayerHLT(Double_t x, Double_t dx, Double_t rho
+                           , Double_t x0, Int_t tbIndex, Int_t plane); 
+  AliTRDpropagationLayerHLT(const AliTRDpropagationLayerHLT &/*p*/);
+  ~AliTRDpropagationLayerHLT() { 
+    if (fTimeBinIndex >= 0) { 
+      delete[] fClusters; 
+      delete[] fIndex; 
+    }     
+  }
+  AliTRDpropagationLayerHLT &operator=(const AliTRDpropagationLayerHLT &/*p*/) 
+    {return *this;}
 
-    operator Int_t() const {return fN;}
-    AliTRDcluster  *operator[](Int_t i) {return fClusters[i];}
+  operator Int_t() const {return fN;}
+  AliTRDcluster  *operator[](Int_t i) {return fClusters[i];}
     
-    void SetZmax(Int_t cham, Double_t center, Double_t w) { 
-      fZc[cham] = center;  
-      fZmax[cham]    = w; 
-    }
-    void SetYmax(Double_t w, Double_t wsensitive) {
-      fYmax          = w;
-      fYmaxSensitive = wsensitive;
-    }
+  void SetZmax(Int_t cham, Double_t center, Double_t w) { 
+    fZc[cham] = center;  
+    fZmax[cham]    = w; 
+  }
+  void SetYmax(Double_t w, Double_t wsensitive) {
+    fYmax          = w;
+    fYmaxSensitive = wsensitive;
+  }
 
-    void SetZ(Double_t* center, Double_t *w, Double_t *wsensitive);
-    void SetHoles(Bool_t* holes);
-    void SetHole(Double_t Zmax, Double_t Ymax
-                , Double_t rho = 1.29e-3, Double_t x0 = 36.66
-                , Double_t Yc = 0.0, Double_t Zc = 0.0);
+  void SetZ(Double_t* center, Double_t *w, Double_t *wsensitive);
+  void SetHoles(Bool_t* holes);
+  void SetHole(Double_t Zmax, Double_t Ymax
+              , Double_t rho = 1.29e-3, Double_t x0 = 36.66
+              , Double_t Yc = 0.0, Double_t Zc = 0.0);
     
-    Double_t GetYmax() const           { return fYmax;                  }
-    Double_t GetZmax(Int_t c) const    { return fZmax[c];               }
-    Double_t GetZc(Int_t c) const      { return fZc[c];                 }
-    UInt_t   GetIndex(Int_t i) const   { return fIndex[i];              }  
-    Double_t GetX() const              { return fX;                     }
-    Double_t GetdX() const             { return fdX;                    }
-    Int_t    GetTimeBinIndex() const   { return fTimeBinIndex;          }     
-    Int_t    GetPlane() const          { return fPlane;                 }
-    Bool_t   IsHole(Int_t zone) const  { return fIsHole[zone];          }              
-    Bool_t   IsSensitive() const       { return (fTimeBinIndex >= 0)? kTRUE : kFALSE;} 
+  Double_t GetYmax() const           { return fYmax;                  }
+  Double_t GetZmax(Int_t c) const    { return fZmax[c];               }
+  Double_t GetZc(Int_t c) const      { return fZc[c];                 }
+  UInt_t   GetIndex(Int_t i) const   { return fIndex[i];              }  
+  Double_t GetX() const              { return fX;                     }
+  Double_t GetdX() const             { return fdX;                    }
+  Int_t    GetTimeBinIndex() const   { return fTimeBinIndex;          }     
+  Int_t    GetPlane() const          { return fPlane;                 }
+  Bool_t   IsHole(Int_t zone) const  { return fIsHole[zone];          }              
+  Bool_t   IsSensitive() const       { return (fTimeBinIndex >= 0)? kTRUE : kFALSE;} 
     
-    void     Clear() { 
-      for (Int_t i = 0; i < fN; i++) fClusters[i] = NULL;
-      fN = 0;
-    }
+  void     Clear() { 
+    for (Int_t i = 0; i < fN; i++) fClusters[i] = NULL;
+    fN = 0;
+  }
     
-    void     InsertCluster(AliTRDcluster *c, UInt_t index);
-    Int_t    Find(Float_t y) const; 
-    Int_t    FindNearestCluster(Float_t y, Float_t z, Float_t maxroad, Float_t maxroadz) const;
+  void     InsertCluster(AliTRDcluster *c, UInt_t index);
+  Int_t    Find(Float_t y) const; 
+  Int_t    FindNearestCluster(Float_t y, Float_t z, Float_t maxroad, Float_t maxroadz) const;
  
-    void SetX(Double_t x) {fX = x;}
+  void SetX(Double_t x) {fX = x;}
 
     
-  private:     
+ private:     
     
-    Int_t                     fN;                            // This is fN
-    Int_t                     fSec;                          // Sector mumber
-    AliTRDcluster           **fClusters;                     // Array of pointers to clusters
-    UInt_t                   *fIndex;                        // Array of cluster indexes
-    Double_t                  fX;                            // X coordinate of the middle plane
-    Double_t                  fdX;                           // Radial thickness of the time bin
-    Double_t                  fRho;                          // Default density of the material 
-    Double_t                  fX0;                           // Default radiation length 
-    Int_t                     fTimeBinIndex;                 // Plane * F(local_tb)  
-    Int_t                     fPlane;                        // Plane number
-    Double_t                  fZc[AliTRDtrackingHLT::kZones];                   // Z position of the center for 5 active areas
-    Double_t                  fZmax[AliTRDtrackingHLT::kZones];                 // Half of active area length in Z
-    Double_t                  fZmaxSensitive[AliTRDtrackingHLT::kZones];        // Sensitive area for detection Z     
-    Bool_t                    fIsHole[AliTRDtrackingHLT::kZones];               // Is hole in given sector       
-    Double_t                  fYmax;                         // Half of active area length in Y
-    Double_t                  fYmaxSensitive;                // Half of active area length in Y
+  Int_t                     fN;                            // This is fN
+  Int_t                     fSec;                          // Sector mumber
+  AliTRDcluster           **fClusters;                     //! Array of pointers to clusters
+  UInt_t                   *fIndex;                        //! Array of cluster indexes
+  Double_t                  fX;                            // X coordinate of the middle plane
+  Double_t                  fdX;                           // Radial thickness of the time bin
+  Double_t                  fRho;                          // Default density of the material 
+  Double_t                  fX0;                           // Default radiation length 
+  Int_t                     fTimeBinIndex;                 // Plane * F(local_tb)  
+  Int_t                     fPlane;                        // Plane number
+  Double_t                  fZc[AliTRDtrackingHLT::kZones];                   // Z position of the center for 5 active areas
+  Double_t                  fZmax[AliTRDtrackingHLT::kZones];                 // Half of active area length in Z
+  Double_t                  fZmaxSensitive[AliTRDtrackingHLT::kZones];        // Sensitive area for detection Z     
+  Bool_t                    fIsHole[AliTRDtrackingHLT::kZones];               // Is hole in given sector       
+  Double_t                  fYmax;                         // Half of active area length in Y
+  Double_t                  fYmaxSensitive;                // Half of active area length in Y
     
-    Bool_t                    fHole;                         // kTRUE if there is a hole in the layer
-    Double_t                  fHoleZc;                       // Z of the center of the hole 
-    Double_t                  fHoleZmax;                     // Half of the hole length in Z
-    Double_t                  fHoleYc;                       // Y of the center of the hole 
-    Double_t                  fHoleYmax;                     // Half of the hole length in Y 
-    Double_t                  fHoleRho;                      // Density of the gas in the hole 
-    Double_t                  fHoleX0;                       // Radiation length of the gas in the hole 
+  Bool_t                    fHole;                         // kTRUE if there is a hole in the layer
+  Double_t                  fHoleZc;                       // Z of the center of the hole 
+  Double_t                  fHoleZmax;                     // Half of the hole length in Z
+  Double_t                  fHoleYc;                       // Y of the center of the hole 
+  Double_t                  fHoleYmax;                     // Half of the hole length in Y 
+  Double_t                  fHoleRho;                      // Density of the gas in the hole 
+  Double_t                  fHoleX0;                       // Radiation length of the gas in the hole 
     
-  };
+};
 
-  class AliTRDtrackingSectorHLT {
+class AliTRDtrackingSectorHLT {
     
-   public:
+ public:
     
-    AliTRDtrackingSectorHLT(AliTRDgeometry* geo, Int_t gs);
-    AliTRDtrackingSectorHLT(const AliTRDtrackingSectorHLT &/*t*/);
-    ~AliTRDtrackingSectorHLT() { 
-      for (Int_t i = 0; i < fN; i++) delete fLayers[i];           
-    }
+  AliTRDtrackingSectorHLT(AliTRDgeometry* geo, Int_t gs);
+  AliTRDtrackingSectorHLT(const AliTRDtrackingSectorHLT &/*t*/);
+  ~AliTRDtrackingSectorHLT() { 
+    for (Int_t i = 0; i < fN; i++) delete fLayers[i];           
+  }
     
-    AliTRDtrackingSectorHLT &operator=(const AliTRDtrackingSectorHLT &/*t*/){ return *this;}
+  AliTRDtrackingSectorHLT &operator=(const AliTRDtrackingSectorHLT &/*t*/){ return *this;}
     
-    Int_t    GetNumberOfLayers() const             { return fN;}
-    Int_t    GetNumberOfTimeBins() const;
-    Int_t    GetLayerNumber(Double_t x) const;
-    Int_t    GetInnerTimeBin() const;
-    Int_t    GetOuterTimeBin() const;
-    Int_t    GetLayerNumber(Int_t tb) const        { return fTimeBinIndex[tb];}
-    Double_t GetX(Int_t pl) const                  { return fLayers[pl]->GetX();}
-    AliTRDpropagationLayerHLT* GetLayer(Int_t i)      { return fLayers[i];}
+  Int_t    GetNumberOfLayers() const             { return fN;}
+  Int_t    GetNumberOfTimeBins() const;
+  Int_t    GetLayerNumber(Double_t x) const;
+  Int_t    GetInnerTimeBin() const;
+  Int_t    GetOuterTimeBin() const;
+  Int_t    GetLayerNumber(Int_t tb) const        { return fTimeBinIndex[tb];}
+  Double_t GetX(Int_t pl) const                  { return fLayers[pl]->GetX();}
+  AliTRDpropagationLayerHLT* GetLayer(Int_t i)      { return fLayers[i];}
     
-    void     MapTimeBinLayers();
-    Int_t    Find(Double_t x) const; 
-    void     InsertLayer(AliTRDpropagationLayerHLT *pl);
-    Int_t    CookTimeBinIndex(Int_t plane, Int_t localTB) const;     
+  void     MapTimeBinLayers();
+  Int_t    Find(Double_t x) const; 
+  void     InsertLayer(AliTRDpropagationLayerHLT *pl);
+  Int_t    CookTimeBinIndex(Int_t plane, Int_t localTB) const;     
     
-  private:
+ private:
     
-    Int_t                   fN;                              // Total number of layers
-    AliTRDgeometry         *fGeom;                           // Geometry
-    AliTRDpropagationLayerHLT *fLayers[AliTRDtrackingHLT::kMaxLayersPerSector];    // Layers   
-    Int_t                   fTimeBinIndex[AliTRDtrackingHLT::kMaxTimeBinIndex]; // Time bin index
-    Int_t                   fGeomSector;                     // Sector# in AliTRDgeometry
+  Int_t                   fN;                              // Total number of layers
+  AliTRDgeometry         *fGeom;                           //! Geometry
+  AliTRDpropagationLayerHLT *fLayers[AliTRDtrackingHLT::kMaxLayersPerSector];    //! Layers   
+  Int_t                   fTimeBinIndex[AliTRDtrackingHLT::kMaxTimeBinIndex]; // Time bin index
+  Int_t                   fGeomSector;                     // Sector# in AliTRDgeometry
     
-  };
+};
 
 class AliTRDtrackerHLT : public AliTracker { 
 
   // Histograms
-  TH1D *fHBackfit;  // Histogram for back propagation
-  TH1D *fHClSearch; // Cluster search
-  TH1D *fHRefit;
+  TH1D *fHBackfit;  //! Histogram for back propagation
+  TH1D *fHClSearch; //! Cluster search
+  TH1D *fHRefit; //!
   
-  TH1D *fHX;
-  TH1D *fHNCl;
-  TH1D *fHNClTrack;
-  TH1D *fHFindCl[4];
-  TH1D *fHMinYPos;
-  TH1D *fHMinYNeg; 
-  TH1D *fHMinZ;
+  TH1D *fHX; //!
+  TH1D *fHNCl; //!
+  TH1D *fHNClTrack; //!
+  TH1D *fHFindCl[4]; //!
+  TH1D *fHMinYPos; //!
+  TH1D *fHMinYNeg; //!
+  TH1D *fHMinZ; //!
 
-  TH2D *fHMinD;
-  TH1D *fHDeltaX;
+  TH2D *fHMinD; //!
+  TH1D *fHDeltaX; //!
 
-  TH1D *fHXCl;
+  TH1D *fHXCl; //!
 
   void InitLogHists();
   void SaveLogHists();
@@ -211,11 +211,11 @@ class AliTRDtrackerHLT : public AliTracker {
   Double_t GetX(Int_t sec, Int_t plane, Int_t localTB) const;
   Double_t GetX(Int_t sec, Int_t pl) const        { return fTrSec[sec]->GetLayer(pl)->GetX();            }
   Int_t    GetGlobalTimeBin(Int_t sec, Int_t plane, Int_t localTB) const 
-    { return fTrSec[sec]->CookTimeBinIndex(plane,localTB); }
+  { return fTrSec[sec]->CookTimeBinIndex(plane,localTB); }
   Double_t GetLayerNumber(Int_t sec, Double_t x) const 
-    { return fTrSec[sec]->GetLayerNumber(x);               }
+  { return fTrSec[sec]->GetLayerNumber(x);               }
   AliCluster    *GetCluster(Int_t index) const    { if (index >= fNclusters) return NULL; 
-  return (AliCluster *) fClusters->UncheckedAt(index); }
+    return (AliCluster *) fClusters->UncheckedAt(index); }
   
   static  Int_t    Freq(Int_t n, const Int_t *inlist, Int_t *outlist, Bool_t down);    
   Int_t    Clusters2Tracks(AliESD *event);
@@ -234,20 +234,20 @@ class AliTRDtrackerHLT : public AliTracker {
   Int_t    ReadClusters(TObjArray *array, TTree *in) const;
   AliTRDcluster *GetCluster(AliTRDtrack *track, Int_t plane, Int_t timebin, UInt_t &index);
   Int_t    FindClusters(Int_t sector, Int_t t0, Int_t t1, AliTRDtrack *track
-                              , Int_t *clusters, AliTRDtracklet &tracklet);
+                       , Int_t *clusters, AliTRDtracklet &tracklet);
 
   void     MakeSeedsMI(Int_t inner, Int_t outer, AliESD *esd = 0);
   
  protected:
       
-  AliTRDgeometry          *fGeom;                          // Pointer to TRD geometry
-  AliTRDtrackingSectorHLT    *fTrSec[AliTRDtrackingHLT::kTrackingSectors];       // Array of tracking sectors;    
+  AliTRDgeometry          *fGeom;                          //! Pointer to TRD geometry
+  AliTRDtrackingSectorHLT    *fTrSec[AliTRDtrackingHLT::kTrackingSectors];       //! Array of tracking sectors;    
   Int_t                    fNclusters;                     // Number of clusters in TRD 
-  TObjArray               *fClusters;                      // List of clusters for all sectors
+  TObjArray               *fClusters;                      //! List of clusters for all sectors
   Int_t                    fNseeds;                        // Number of track seeds  
-  TObjArray               *fSeeds;                         // List of track seeds
+  TObjArray               *fSeeds;                         //! List of track seeds
   Int_t                    fNtracks;                       // Number of reconstructed tracks 
-  TObjArray               *fTracks;                        // List of reconstructed tracks   
+  TObjArray               *fTracks;                        //! List of reconstructed tracks   
   Int_t                    fTimeBinsPerPlane;              // Timebins per plane in track prolongation 
   
   static const Double_t    fgkMaxChi2;                     // Max increment in track chi2 
@@ -273,10 +273,10 @@ class AliTRDtrackerHLT : public AliTracker {
   Double_t ExpectedSigmaY2(Double_t r, Double_t tgl, Double_t pt) const;
   Double_t ExpectedSigmaZ2(Double_t r, Double_t tgl) const;
   
-  TTreeSRedirector        *fDebugStreamer;                 //!Debug streamer
+  TTreeSRedirector        *fDebugStreamer;                 //! Debug streamer
   
   ClassDef(AliTRDtrackerHLT,2)                                        // TRD tracker
     
- };
+};
 
 #endif 

diff --git a/HLT/TRD/Makefile.am b/HLT/TRD/Makefile.am
index 8214fd18a1b2124b565240bf92bc695032272027..26f25e72e6b580d30028750ab8870ddd1011e2b6 100644 (file)
--- a/HLT/TRD/Makefile.am
+++ b/HLT/TRD/Makefile.am
@@ -19,23 +19,17 @@ lib_LTLIBRARIES                     =  libAliHLTTRD.la
 
 # library sources
 libAliHLTTRD_la_SOURCES                = AliTRDclusterizerV1HLT.cxx \
-                                 AliTRDtriggerHLT.cxx \
                                  AliHLTTRDDefinitions.cxx \
                                  AliHLTTRDClusterizerComponent.cxx \
                                  AliHLTTRDTrackerComponent.cxx \
-                                 AliHLTTRDCalibrationComponent.cxx \
-                                 AliHLTTRDCalibra.cxx \
                                  AliTRDtrackerHLT.cxx
 
 # class header files, the link definition for the root dictionary
 # will be created from the names of the header files
 CLASS_HDRS                     = AliTRDclusterizerV1HLT.h \
-                                 AliTRDtriggerHLT.h \
                                  AliHLTTRDDefinitions.h \
                                  AliHLTTRDClusterizerComponent.h \
                                  AliHLTTRDTrackerComponent.h \
-                                 AliHLTTRDCalibrationComponent.h \
-                                 AliHLTTRDCalibra.h \
                                  AliTRDtrackerHLT.h
 
 pkginclude_HEADERS             = $(CLASS_HDRS) 

diff --git a/HLT/libAliHLTTRD.pkg b/HLT/libAliHLTTRD.pkg
index 0d703f83d44d443351b6f01ac88d29c5a8102177..392ef351d0cfb733f26c4027444bc3a10f02a61d 100644 (file)
--- a/HLT/libAliHLTTRD.pkg
+++ b/HLT/libAliHLTTRD.pkg
@@ -10,25 +10,19 @@ include $(MODDIR)/hlt.conf
 
 # library sources
 MODULE_SRCS= \
-       AliHLTTRDCalibrationComponent.cxx \
-       AliHLTTRDCalibra.cxx \
         AliHLTTRDClusterizerComponent.cxx \
         AliHLTTRDDefinitions.cxx \
         AliHLTTRDTrackerComponent.cxx \
         AliTRDclusterizerV1HLT.cxx \
-        AliTRDtriggerHLT.cxx \
        AliTRDtrackerHLT.cxx
 
 # class header files, the link definition for the root dictionary
 # will be created from the names of the header files
 CLASS_HDRS:= \
-       AliHLTTRDCalibrationComponent.h \
-       AliHLTTRDCalibra.h \
         AliHLTTRDClusterizerComponent.h \
         AliHLTTRDDefinitions.h \
         AliHLTTRDTrackerComponent.h \
         AliTRDclusterizerV1HLT.h \
-        AliTRDtriggerHLT.h \
        AliTRDtrackerHLT.h
 
 # library headers