Obsolete tracker output removed
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Feb 2010 17:33:32 +0000 (17:33 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 18 Feb 2010 17:33:32 +0000 (17:33 +0000)
15 files changed:
HLT/TPCLib/tracking-ca/AliHLTTPCCABaseTrackParam.cxx [moved from HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam2.cxx with 92% similarity, mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCABaseTrackParam.h [moved from HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam2.h with 85% similarity, mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.cxx [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.h [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.h

old mode 100755 (executable)
new mode 100644 (file)
similarity index 92%
rename from HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam2.cxx
rename to HLT/TPCLib/tracking-ca/AliHLTTPCCABaseTrackParam.cxx
index bd1a6a5..8ae39c2
@@ -1,4 +1,4 @@
-// $Id: AliHLTTPCCATrackParam.cxx 33907 2009-07-23 13:52:49Z sgorbuno $
+// $Id: AliHLTTPCCABaseTrackParam.cxx 33907 2009-07-23 13:52:49Z sgorbuno $
 // **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          *
 // ALICE Experiment at CERN, All rights reserved.                           *
@@ -17,4 +17,4 @@
 //                                                                          *
 //***************************************************************************
 
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
old mode 100755 (executable)
new mode 100644 (file)
similarity index 85%
rename from HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam2.h
rename to HLT/TPCLib/tracking-ca/AliHLTTPCCABaseTrackParam.h
index e2a37e2..ee6c16e
@@ -1,5 +1,5 @@
 //-*- Mode: C++ -*-
-// $Id: AliHLTTPCCATrackParam2.h 35151 2009-10-01 13:35:10Z sgorbuno $
+// $Id: AliHLTTPCCABaseTrackParam.h 35151 2009-10-01 13:35:10Z sgorbuno $
 // ************************************************************************
 // This file is property of and copyright by the ALICE HLT Project        *
 // ALICE Experiment at CERN, All rights reserved.                         *
@@ -8,21 +8,20 @@
 //*************************************************************************
 
 
-#ifndef ALIHLTTPCCATRACKPARAM2_H
-#define ALIHLTTPCCATRACKPARAM2_H
+#ifndef ALIHLTTPCCABASETRACKPARAM_H
+#define ALIHLTTPCCABASETRACKPARAM_H
 
 #include "AliHLTTPCCADef.h"
-
-class AliHLTTPCCATrackLinearisation;
+class AliHLTTPCCATrackParam;
 
 /**
- * @class AliHLTTPCCATrackParam
+ * @class AliHLTTPCCABaseTrackParam
  *
- * AliHLTTPCCATrackParam class describes the track parametrisation
- * which is used by the AliHLTTPCCATracker slice tracker.
+ * AliHLTTPCCABaseTrackParam class contains track parameters 
+ * used in output of the AliHLTTPCCATracker slice tracker.
  * This class is used for transfer between tracker and merger and does not contain the covariance matrice
  */
-class AliHLTTPCCATrackParam2
+class AliHLTTPCCABaseTrackParam
 {
   public:
 
@@ -63,4 +62,4 @@ class AliHLTTPCCATrackParam2
     float fP[5];   // 'active' track parameters: Y, Z, SinPhi, DzDs, q/Pt
 };
 
-#endif //ALIHLTTPCCATRACKPARAM2_H
+#endif 
index 4c2fcb7..8d4b781 100644 (file)
@@ -27,7 +27,6 @@
 #include "AliHLTTPCCATrack.h"
 #include "AliHLTTPCCAPerformance.h"
 #include "AliHLTTPCCAMCTrack.h"
-#include "AliHLTTPCCAOutTrack.h"
 
 #include "TString.h"
 #include "Riostream.h"
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.cxx
deleted file mode 100644 (file)
index 1ff7151..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-// @(#) $Id$
-// **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          *
-// ALICE Experiment at CERN, All rights reserved.                           *
-//                                                                          *
-// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
-//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
-//                  for The ALICE HLT Project.                              *
-//                                                                          *
-// Permission to use, copy, modify and distribute this software and its     *
-// documentation strictly for non-commercial purposes is hereby granted     *
-// without fee, provided that the above copyright notice appears in all     *
-// copies and that both the copyright notice and this permission notice     *
-// appear in the supporting documentation. The authors make no claims       *
-// about the suitability of this software for any purpose. It is            *
-// provided "as is" without express or implied warranty.                    *
-//                                                                          *
-//***************************************************************************
-
-
-#include "AliHLTTPCCAOutTrack.h"
-
-
-ClassImp( AliHLTTPCCAOutTrack )
-
-GPUh() void AliHLTTPCCAOutTrack::Dummy() const
-{
-  //* do nothing
-}
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.h
deleted file mode 100644 (file)
index 5cf8461..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-//-*- Mode: C++ -*-
-// @(#) $Id$
-// ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        *
-// ALICE Experiment at CERN, All rights reserved.                         *
-// See cxx source for full Copyright notice                               *
-//                                                                        *
-//*************************************************************************
-
-#ifndef ALIHLTTPCCAOUTTRACK_H
-#define ALIHLTTPCCAOUTTRACK_H
-
-#include "AliHLTTPCCATrackParam.h"
-
-/**
- * @class AliHLTTPCCAOutTrack
- * AliHLTTPCCAOutTrack class is used to store the final
- * reconstructed tracks which will be then readed
- * by the AliHLTTPCCATrackerComponent
- *
- * The class contains no temporary variables, etc.
- *
- */
-class AliHLTTPCCAOutTrack
-{
-  public:
-
-    AliHLTTPCCAOutTrack(): fFirstHitRef( 0 ), fNHits( 0 ), fStartPoint(), fEndPoint(), fOrigTrackID( 0 ) {}
-    virtual ~AliHLTTPCCAOutTrack() {}
-
-    GPUhd() int NHits()               const { return fNHits; }
-    GPUhd() int FirstHitRef()         const { return fFirstHitRef; }
-
-    GPUhd() const AliHLTTPCCATrackParam &StartPoint() const { return fStartPoint; }
-    GPUhd() const AliHLTTPCCATrackParam &EndPoint()   const { return fEndPoint; }
-    GPUhd() int OrigTrackID()                const { return fOrigTrackID; }
-
-    GPUhd() void SetNHits( int v )               { fNHits = v; }
-    GPUhd() void SetFirstHitRef( int v )         { fFirstHitRef = v; }
-
-    GPUhd() void SetStartPoint( const AliHLTTPCCATrackParam &v ) { fStartPoint = v; }
-    GPUhd() void SetEndPoint( const AliHLTTPCCATrackParam &v )   { fEndPoint = v; }
-    GPUhd() void SetOrigTrackID( int v )                { fOrigTrackID = v; }
-
-  protected:
-
-    int fFirstHitRef;   //* index of the first hit reference in track->hit reference array
-    int fNHits;         //* number of track hits
-    AliHLTTPCCATrackParam fStartPoint; //* fitted track parameters at the start point
-    AliHLTTPCCATrackParam fEndPoint;   //* fitted track parameters at the start point
-    int fOrigTrackID;                //* index of the original slice track
-
-  private:
-
-    void Dummy() const; // to make rulechecker happy by having something in .cxx file
-
-    ClassDef( AliHLTTPCCAOutTrack, 1 )
-};
-
-
-#endif //ALIHLTTPCCAOUTTRACK_H
index c8cbf4c..c4d8ce8 100644 (file)
@@ -21,7 +21,6 @@
 #include "AliHLTTPCCAPerformance.h"
 #include "AliHLTTPCCAMCTrack.h"
 #include "AliHLTTPCCAMCPoint.h"
-#include "AliHLTTPCCAOutTrack.h"
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAStandaloneFramework.h"
index e41d2db..c725d3e 100644 (file)
@@ -47,35 +47,27 @@ void AliHLTTPCCASliceOutput::SetPointers(int nTracks, int nTrackClusters, const
 
   int size = 0;
 
-  if (outputControl == NULL || outputControl->fDefaultOutput)
   {
     AssignNoAlignment( fTracksOffset,            size, nTracks*sizeof(AliHLTTPCCASliceTrack) );
     AssignNoAlignment( fClusterIdOffset,         size, nTrackClusters*sizeof(int) );
     AssignNoAlignment( fClusterRowOffset,        size, nTrackClusters*sizeof(float) );
     AssignNoAlignment( fClusterPackedXYZOffset, size, nTrackClusters*sizeof(AliHLTTPCCACompressedCluster) );
-   }
-
+  }
+  
   char *mem = fMemory + size;
 
-  if (outputControl == NULL || outputControl->fObsoleteOutput)
-  {
-         // memory for output tracks
-         AssignMemory( fOutTracks, mem, nTracks );
-         // arrays for track hits
-         AssignMemory( fOutTrackHits, mem, nTrackClusters );
-  }
   if ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput) > fMemorySize)
   {
-         fMemorySize = NULL;
-         //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
+    fMemorySize = NULL;
+    //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
   }
 }
 
 void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl)
 {
        //Allocate All memory needed for slice output
-  const int memsize = (outputControl->fDefaultOutput ? EstimateSize(nTracks, nTrackHits) : sizeof(AliHLTTPCCASliceOutput)) +
-         (outputControl->fObsoleteOutput? (nTracks * sizeof(AliHLTTPCCAOutTrack) + nTrackHits * sizeof(int)) : 0);
+  const int memsize =  EstimateSize(nTracks, nTrackHits);
+
   if (outputControl->fOutputPtr)
   {
          if (outputControl->fOutputMaxSize < memsize)
index 454fc3f..49cb779 100644 (file)
@@ -14,8 +14,6 @@
 #include <cstdlib>
 #include "AliHLTTPCCASliceTrack.h"
 #include "AliHLTTPCCACompressedInputData.h"
-//Obsolete
-#include "AliHLTTPCCAOutTrack.h"
 
 /**
  * @class AliHLTTPCCASliceOutput
@@ -32,82 +30,63 @@ class AliHLTTPCCASliceOutput
 {
   public:
 
-       struct outputControlStruct
-       {
-               outputControlStruct() : fObsoleteOutput( 1 ), fDefaultOutput( 1 ), fOutputPtr( NULL ), fOutputMaxSize ( 0 ), fEndOfSpace(0) {}
-               int fObsoleteOutput;    //Enable Obsolete Output
-               int fDefaultOutput;             //Enable Default Output
-               char* fOutputPtr;               //Pointer to Output Space, NULL to allocate output space
-               int fOutputMaxSize;             //Max Size of Output Data if Pointer to output space is given
-               bool fEndOfSpace; // end of space flag 
-       };
-
-    GPUhd() int NTracks()                    const { return fNTracks;              }
-    GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }
-
-    GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return TracksP()[i]; }
-    GPUhd() unsigned char   ClusterRow     ( int i )  const { return ClusterRowP()[i]; }
-    GPUhd()  int   ClusterId     ( int i )  const { return ClusterIdP()[i]; }
-    GPUhd() const AliHLTTPCCACompressedCluster &ClusterPackedXYZ ( int i )  const { return ClusterPackedXYZP()[i]; }
-
-    GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
-    void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL);
-       static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl);
-
-    GPUhd() void SetNTracks       ( int v )  { fNTracks = v;        }
-    GPUhd() void SetNTrackClusters( int v )  { fNTrackClusters = v; }
-
-    GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) {  TracksP()[i] = v; }
-    GPUhd() void SetClusterRow( int i, unsigned char v ) {  ClusterRowP()[i] = v; }
-    GPUhd() void SetClusterId( int i, int v ) {  ClusterIdP()[i] = v; }
-    GPUhd() void SetClusterPackedXYZ( int i, AliHLTTPCCACompressedCluster v ) {  ClusterPackedXYZP()[i] = v; }
-
-    GPUhd() size_t OutputMemorySize() const { return(fMemorySize); }
-
-       //Obsolete Output
-
-    GPUhd()  int NOutTracks() const { return(fNOutTracks); }
-       GPUhd()  void SetNOutTracks(int val) { fNOutTracks = val; }
-    GPUhd()  AliHLTTPCCAOutTrack *OutTracks() const { return  fOutTracks; }
-    GPUhd()  const AliHLTTPCCAOutTrack &OutTrack( int index ) const { return fOutTracks[index]; }
-    GPUhd()  int NOutTrackHits() const { return  fNOutTrackHits; }
-       GPUhd()  void SetNOutTrackHits(int val) { fNOutTrackHits = val; }
-    GPUhd()  void SetOutTrackHit(int n, int val) { fOutTrackHits[n] = val; }
-    GPUhd()  int OutTrackHit( int i ) const { return  fOutTrackHits[i]; }
+  struct outputControlStruct
+  {
+    outputControlStruct() :  fOutputPtr( NULL ), fOutputMaxSize ( 0 ), fEndOfSpace(0) {}
+    char* fOutputPtr;          //Pointer to Output Space, NULL to allocate output space
+    int fOutputMaxSize;                //Max Size of Output Data if Pointer to output space is given
+    bool fEndOfSpace; // end of space flag 
+  };
+
+  GPUhd() int NTracks()                    const { return fNTracks;              }
+  GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }
+  
+  GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return TracksP()[i]; }
+  GPUhd() unsigned char   ClusterRow     ( int i )  const { return ClusterRowP()[i]; }
+  GPUhd()  int   ClusterId     ( int i )  const { return ClusterIdP()[i]; }
+  GPUhd() const AliHLTTPCCACompressedCluster &ClusterPackedXYZ ( int i )  const { return ClusterPackedXYZP()[i]; }
+
+  GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
+  void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL);
+  static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl);
+
+  GPUhd() void SetNTracks       ( int v )  { fNTracks = v;        }
+  GPUhd() void SetNTrackClusters( int v )  { fNTrackClusters = v; }
+  
+  GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) {  TracksP()[i] = v; }
+  GPUhd() void SetClusterRow( int i, unsigned char v ) {  ClusterRowP()[i] = v; }
+  GPUhd() void SetClusterId( int i, int v ) {  ClusterIdP()[i] = v; }
+  GPUhd() void SetClusterPackedXYZ( int i, AliHLTTPCCACompressedCluster v ) {  ClusterPackedXYZP()[i] = v; }
+
+  GPUhd() size_t OutputMemorySize() const { return(fMemorySize); }
 
-  private:
-    AliHLTTPCCASliceOutput()
-        : fNTracks( 0 ), fNTrackClusters( 0 ), fTracksOffset( 0 ),  fClusterIdOffset( 0 ), fClusterRowOffset( 0 ), fClusterPackedXYZOffset( 0 ),
-               fMemorySize( 0 ), fNOutTracks(0), fNOutTrackHits(0), fOutTracks(0), fOutTrackHits(0) {}
 
-       ~AliHLTTPCCASliceOutput() {}
-    const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
-    AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& );
+  private:
+  AliHLTTPCCASliceOutput()
+    : fNTracks( 0 ), fNTrackClusters( 0 ), fTracksOffset( 0 ),  fClusterIdOffset( 0 ), fClusterRowOffset( 0 ), fClusterPackedXYZOffset( 0 ),
+      fMemorySize( 0 ){}
+  
+  ~AliHLTTPCCASliceOutput() {}
+  const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
+  AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& );
 
-       GPUh() void SetMemorySize(size_t val) { fMemorySize = val; }
+  GPUh() void SetMemorySize(size_t val) { fMemorySize = val; }
 
   GPUh() AliHLTTPCCASliceTrack *TracksP() const { return (AliHLTTPCCASliceTrack*)(fMemory+fTracksOffset); }
   GPUh() int *ClusterIdP() const { return (int*)(fMemory+fClusterIdOffset); }
   GPUh() UChar_t *ClusterRowP() const { return (UChar_t *)(fMemory+fClusterRowOffset); }
   GPUh() AliHLTTPCCACompressedCluster *ClusterPackedXYZP() const { return (AliHLTTPCCACompressedCluster *)(fMemory+fClusterPackedXYZOffset); }
 
-    int fNTracks;                   // number of reconstructed tracks
-    int fNTrackClusters;            // total number of track clusters
-    int fTracksOffset; // pointer to reconstructed tracks
-    int fClusterIdOffset;              // pointer to cluster Id's ( packed slice, patch, cluster )
-    int fClusterRowOffset;     // pointer to cluster row numbers
-    int fClusterPackedXYZOffset;    // pointer to cluster coordinates 
-       size_t fMemorySize;                             // Amount of memory really used
-
-    // obsolete output
-
-       int fNOutTracks;
-       int fNOutTrackHits;
-    AliHLTTPCCAOutTrack *fOutTracks; // output array of the reconstructed tracks
-    int *fOutTrackHits;  // output array of ID's of the reconstructed hits
+  int fNTracks;                   // number of reconstructed tracks
+  int fNTrackClusters;            // total number of track clusters
+  int fTracksOffset; // pointer to reconstructed tracks
+  int fClusterIdOffset;              // pointer to cluster Id's ( packed slice, patch, cluster )
+  int fClusterRowOffset;     // pointer to cluster row numbers
+  int fClusterPackedXYZOffset;    // pointer to cluster coordinates 
+  size_t fMemorySize;                          // Amount of memory really used
 
-       //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
-       //This way the whole Slice Output is one consecutive Memory Segment
+  //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
+  //This way the whole Slice Output is one consecutive Memory Segment
     char fMemory[1]; // the memory where the pointers above point into
 
 };
index a20b123..66ad3f6 100644 (file)
@@ -10,7 +10,7 @@
 #ifndef ALIHLTTPCCASLICETRACK_H
 #define ALIHLTTPCCASLICETRACK_H
 
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
 
 /**
  * @class AliHLTTPCCASliceTrack
@@ -31,15 +31,15 @@ class AliHLTTPCCASliceTrack
 
     GPUhd() int NClusters()                    const { return fNClusters;       }
     GPUhd() int FirstClusterRef()              const { return fFirstClusterRef; }
-    GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam;           }
+    GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam;           }
 
     GPUhd() void SetNClusters( int v )                   { fNClusters = v;       }
     GPUhd() void SetFirstClusterRef( int v )              { fFirstClusterRef = v; }
-    GPUhd() void SetParam( const AliHLTTPCCATrackParam2 &v ) { fParam = v;           }
+    GPUhd() void SetParam( const AliHLTTPCCABaseTrackParam &v ) { fParam = v;           }
 
   private:
 
-    AliHLTTPCCATrackParam2 fParam; //* fitted track parameters at its innermost cluster
+    AliHLTTPCCABaseTrackParam fParam; //* fitted track parameters at its innermost cluster
     int fFirstClusterRef;       //* index of the index of the first track cluster in corresponding cluster arrays
     int fNClusters;             //* number of track clusters
 
index 2faefd7..92aec10 100644 (file)
@@ -11,7 +11,7 @@
 #define ALIHLTTPCCATRACK_H
 
 #include "AliHLTTPCCADef.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
 
 /**
  * @class ALIHLTTPCCAtrack
@@ -31,18 +31,18 @@ class AliHLTTPCCATrack
     GPUhd() bool Alive()               const { return fAlive; }
     GPUhd() int  NHits()               const { return fNHits; }
     GPUhd() int  FirstHitID()          const { return fFirstHitID; }
-    GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam; };
+    GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam; };
 
     GPUhd() void SetAlive( bool v )               { fAlive = v; }
     GPUhd() void SetNHits( int v )               { fNHits = v; }
     GPUhd() void SetFirstHitID( int v )          { fFirstHitID = v; }
-    GPUhd() void SetParam( AliHLTTPCCATrackParam2 v ) { fParam = v; };
+    GPUhd() void SetParam( AliHLTTPCCABaseTrackParam v ) { fParam = v; };
 
   private:
     bool fAlive;       // flag for mark tracks used by the track merger
     int  fFirstHitID; // index of the first track cell in the track->cell pointer array
     int  fNHits;      // number of track cells
-    AliHLTTPCCATrackParam2 fParam; // track parameters
+    AliHLTTPCCABaseTrackParam fParam; // track parameters
 
   private:
     //void Dummy(); // to make rulechecker happy by having something in .cxx file
index c2c2c11..690caeb 100644 (file)
@@ -13,7 +13,7 @@
 
 #include "AliHLTTPCCADef.h"
 #include "AliHLTTPCCAMath.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
 
 class AliHLTTPCCATrackLinearisation;
 
@@ -32,8 +32,8 @@ class AliHLTTPCCATrackParam
       float fBethe, fE, fTheta2, fEP2, fSigmadE2, fK22, fK33, fK43, fK44;// parameters
     };
 
-       GPUd() const AliHLTTPCCATrackParam2& GetParam() const { return fParam; }
-       GPUd() void SetParam(const AliHLTTPCCATrackParam2& v) { fParam = v; }
+       GPUd() const AliHLTTPCCABaseTrackParam& GetParam() const { return fParam; }
+       GPUd() void SetParam(const AliHLTTPCCABaseTrackParam& v) { fParam = v; }
        GPUd() void InitParam();
 
     GPUd() float X()      const { return fParam.X();    }
@@ -140,7 +140,7 @@ class AliHLTTPCCATrackParam
 #ifndef HLTCA_GPUCODE
   private:
 #endif //!HLTCA_GPUCODE
-       AliHLTTPCCATrackParam2 fParam; // Track Parameters
+       AliHLTTPCCABaseTrackParam fParam; // Track Parameters
 
   private:
        //WARNING, Track Param Data is copied in the GPU Tracklet Constructor element by element instead of using copy constructor!!!
index 3faf7b3..f8fed37 100644 (file)
@@ -18,7 +18,6 @@
 //***************************************************************************
 
 #include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAOutTrack.h"
 #include "AliHLTTPCCARow.h"
 #include "AliHLTTPCCATrack.h"
 #include "AliHLTTPCCATracklet.h"
@@ -426,8 +425,6 @@ GPUh() int AliHLTTPCCATracker::CheckEmptySlice() const
       if (useOutput == NULL) return(1);
       useOutput->SetNTracks( 0 );
       useOutput->SetNTrackClusters( 0 );
-      useOutput->SetNOutTracks(0);
-      useOutput->SetNOutTrackHits(0);
     }
 
     return 1;
@@ -636,135 +633,79 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
   TStopwatch timer;
 
   //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
-
+  
   if (fOutputControl == NULL) fOutputControl = new AliHLTTPCCASliceOutput::outputControlStruct;
   AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits, fOutputControl);
   AliHLTTPCCASliceOutput* useOutput = *fOutput;
   if (useOutput == NULL) return;
 
-  if (fOutputControl->fDefaultOutput)
-  {
-         useOutput->SetNTracks( fCommonMem->fNTracks );
-         useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
-
-         int nStoredHits = 0;
-
-         for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
-               AliHLTTPCCATrack &iTrack = fTracks[iTr];
-
-               AliHLTTPCCASliceTrack out;
-               out.SetFirstClusterRef( nStoredHits );
-               out.SetNClusters( iTrack.NHits() );
-               out.SetParam( iTrack.Param() );
-
-               useOutput->SetTrack( iTr, out );
-
-               int iID = iTrack.FirstHitID();
-               for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
-                 const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
-                 int iRow = ic.RowIndex();
-                 int ih = ic.HitIndex();
-
-                 const AliHLTTPCCARow &row = fData.Row( iRow );
-
-                 //float y0 = row.Grid().YMin();
-                 //float z0 = row.Grid().ZMin();
-                 //float stepY = row.HstepY();
-                 //float stepZ = row.HstepZ();
-                 //float x = row.X();
-
-                 //const uint4 *tmpint4 = RowData() + row.FullOffset();
-                 //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
-                 //ushort2 hh = hits[ih];
-                 //float y = y0 + hh.x*stepY;
-                 //float z = z0 + hh.y*stepZ;
-
-                 int clusterIndex = fData.ClusterDataIndex( row, ih );
-                 int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
-
-                 if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) {
-                       //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-                       //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-                       //abort();
-                       continue;
-                 }
-                 if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) {
-                       //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-                       //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-                       //abort();
-                       continue;
-                 }
-
-                 float origX = fClusterData->X( clusterIndex );
-                 float origY = fClusterData->Y( clusterIndex );
-                 float origZ = fClusterData->Z( clusterIndex );
-
-
-                 int id = fClusterData->Id( clusterIndex );
-                 AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
-
-                 //float2 hUnpackedYZ;
-                 //hUnpackedYZ.x = origY;
-                 //hUnpackedYZ.y = origZ;
-                 //float hUnpackedX = origX;
-
-                 useOutput->SetClusterId( nStoredHits, id  );
-                 useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
-                 useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
-                 nStoredHits++;
-               }
-         }
-  }
-
-
-  // old stuff
-  if (fOutputControl->fObsoleteOutput)
-  {
-         useOutput->SetNOutTrackHits(0);
-         useOutput->SetNOutTracks(0);
-
-
-         for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
-
-               const AliHLTTPCCATrack &iTrack = fTracks[iTr];
-
-               //std::cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl;
-
-               //if( !iTrack.Alive() ) continue;
-               if ( iTrack.NHits() < 3 ) continue;
-               AliHLTTPCCAOutTrack &out = useOutput->OutTracks()[useOutput->NOutTracks()];
-               out.SetFirstHitRef( useOutput->NOutTrackHits() );
-               out.SetNHits( 0 );
-               out.SetOrigTrackID( iTr );
-               AliHLTTPCCATrackParam tmpParam;
-               tmpParam.InitParam();
-               tmpParam.SetParam(iTrack.Param());
-               out.SetStartPoint( tmpParam );
-               out.SetEndPoint( tmpParam );
-
-               int iID = iTrack.FirstHitID();
-               int nOutTrackHitsOld = useOutput->NOutTrackHits();
-
-               for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
-                 const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
-                 const AliHLTTPCCARow &row = Row( ic );
-                 int ih = ic.HitIndex();
-                 useOutput->SetOutTrackHit(useOutput->NOutTrackHits(), HitInputID( row, ih ));
-                 useOutput->SetNOutTrackHits(useOutput->NOutTrackHits() + 1 );
-                 //std::cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<HitInputID( row, ih )<<std::endl;
-                 if ( useOutput->NOutTrackHits() >= 10*NHitsTotal() ) {
-                       std::cout << "fNOutTrackHits>NHitsTotal()" << std::endl;
-                       //exit(0);
-                       return;//SG!!!
-                 }
-                 out.SetNHits( out.NHits() + 1 );
-               }
-               if ( out.NHits() >= 2 ) {
-                 useOutput->SetNOutTracks(useOutput->NOutTracks() + 1);
-               } else {
-                 useOutput->SetNOutTrackHits(nOutTrackHitsOld);
-               }
-         }
+  useOutput->SetNTracks( fCommonMem->fNTracks );
+  useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
+
+  int nStoredHits = 0;
+
+  for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
+    AliHLTTPCCATrack &iTrack = fTracks[iTr];
+    AliHLTTPCCASliceTrack out;
+    out.SetFirstClusterRef( nStoredHits );
+    out.SetNClusters( iTrack.NHits() );
+    out.SetParam( iTrack.Param() );
+   
+    useOutput->SetTrack( iTr, out );
+   
+    int iID = iTrack.FirstHitID();
+    for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
+      const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
+      int iRow = ic.RowIndex();
+      int ih = ic.HitIndex();
+      
+      const AliHLTTPCCARow &row = fData.Row( iRow );
+      
+      //float y0 = row.Grid().YMin();
+      //float z0 = row.Grid().ZMin();
+      //float stepY = row.HstepY();
+      //float stepZ = row.HstepZ();
+      //float x = row.X();
+      
+      //const uint4 *tmpint4 = RowData() + row.FullOffset();
+      //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
+      //ushort2 hh = hits[ih];
+      //float y = y0 + hh.x*stepY;
+      //float z = z0 + hh.y*stepZ;
+      
+      int clusterIndex = fData.ClusterDataIndex( row, ih );
+      int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
+      
+      if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) {
+       //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
+       //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
+       //abort();
+       continue;
+      }
+      if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) {
+       //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
+       //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
+       //abort();
+       continue;
+      }
+      
+      float origX = fClusterData->X( clusterIndex );
+      float origY = fClusterData->Y( clusterIndex );
+      float origZ = fClusterData->Z( clusterIndex );
+      
+      int id = fClusterData->Id( clusterIndex );
+      AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
+      
+      //float2 hUnpackedYZ;
+      //hUnpackedYZ.x = origY;
+      //hUnpackedYZ.y = origZ;
+      //float hUnpackedX = origX;
+      
+      useOutput->SetClusterId( nStoredHits, id  );
+      useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
+      useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
+      nStoredHits++;
+    }
   }
 
   timer.Stop();
@@ -946,87 +887,13 @@ GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
   }
 }
 
-GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
+GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &/*out*/ )
 {
-  //* Write tracks to file
-  AliHLTTPCCASliceOutput* useOutput = *fOutput;
-
-  out << fTimers[0] << std::endl;
-  out << useOutput->NOutTrackHits() << std::endl;
-  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
-    out << useOutput->OutTrackHit(ih) << " ";
-  }
-  out << std::endl;
-
-  out << useOutput->NOutTracks() << std::endl;
-
-  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
-    const AliHLTTPCCAOutTrack &t = useOutput->OutTrack(itr);
-    AliHLTTPCCATrackParam p1 = t.StartPoint();
-    AliHLTTPCCATrackParam p2 = t.EndPoint();
-    out << t.NHits() << " ";
-    out << t.FirstHitRef() << " ";
-    out << t.OrigTrackID() << " ";
-    out << std::endl;
-    out << p1.X() << " ";
-    out << p1.SignCosPhi() << " ";
-    out << p1.Chi2() << " ";
-    out << p1.NDF() << std::endl;
-    for ( int i = 0; i < 5; i++ ) out << p1.Par()[i] << " ";
-    out << std::endl;
-    for ( int i = 0; i < 15; i++ ) out << p1.Cov()[i] << " ";
-    out << std::endl;
-    out << p2.X() << " ";
-    out << p2.SignCosPhi() << " ";
-    out << p2.Chi2() << " ";
-    out << p2.NDF() << std::endl;
-    for ( int i = 0; i < 5; i++ ) out << p2.Par()[i] << " ";
-    out << std::endl;
-    for ( int i = 0; i < 15; i++ ) out << p2.Cov()[i] << " ";
-    out << std::endl;
-  }
+  //* Write tracks to file --- dummy
 }
 
-GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
+GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &/*in*/ )
 {
-  //* Read tracks  from file
-  AliHLTTPCCASliceOutput::Allocate(*fOutput, 4096, 16384, fOutputControl);//Just some max values
-  AliHLTTPCCASliceOutput* useOutput = *fOutput;
-
-  int tmpval;
-  in >> fTimers[0];
-  in >> tmpval;
-  useOutput->SetNOutTrackHits(tmpval);
-
-  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
-    in >> tmpval;
-       useOutput->SetOutTrackHit(ih, tmpval);
-  }
-  in >> tmpval;
-  useOutput->SetNOutTracks(tmpval);
-
-  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
-    AliHLTTPCCAOutTrack &t = useOutput->OutTracks()[itr];
-    AliHLTTPCCATrackParam p1, p2;
-    int i;
-    float f;
-    in >> i; t.SetNHits( i );
-    in >> i; t.SetFirstHitRef( i );
-    in >> i; t.SetOrigTrackID( i );
-    in >> f; p1.SetX( f );
-    in >> f; p1.SetSignCosPhi( f );
-    in >> f; p1.SetChi2( f );
-    in >> i; p1.SetNDF( i );
-    for ( int j = 0; j < 5; j++ ) { in >> f; p1.SetPar( j, f ); }
-    for ( int j = 0; j < 15; j++ ) { in >> f; p1.SetCov( j, f ); }
-    in >> f; p2.SetX( f );
-    in >> f; p2.SetSignCosPhi( f );
-    in >> f; p2.SetChi2( f );
-    in >> i; p2.SetNDF( i );
-    for ( int j = 0; j < 5; j++ ) { in >> f; p2.SetPar( j, f ); }
-    for ( int j = 0; j < 15; j++ ) { in >> f; p2.SetCov( j, f ); }
-    t.SetStartPoint( p1 );
-    t.SetEndPoint( p2 );
-  }
+  //* Read tracks  from file -- dummy
 }
 #endif
index 1a2e03a..488f016 100644 (file)
@@ -31,7 +31,6 @@ using namespace std;
 #include "AliHLTTPCCATrackerComponent.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCCATrackerFramework.h"
-#include "AliHLTTPCCAOutTrack.h"
 #include "AliHLTTPCCAParam.h"
 #include "AliHLTTPCCATrackConvertor.h"
 #include "AliHLTArray.h"
@@ -70,8 +69,7 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
     fClusterErrorCorrectionZ(0),
     fFullTime( 0 ),
     fRecoTime( 0 ),
-    fNEvents( 0 ),
-    fOutputTRAKSEGS( 0 ),
+    fNEvents( 0 ),    
     fAllowGPU( 0)
 {
   // see header file for class documentation
@@ -94,7 +92,6 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent( const AliHLTTPCCATrack
     fFullTime( 0 ),
     fRecoTime( 0 ),
     fNEvents( 0 ),
-    fOutputTRAKSEGS( 0 ),
     fAllowGPU( 0)
 {
   // see header file for class documentation
@@ -136,8 +133,7 @@ void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataT
 AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
 {
   // see header file for class documentation
-  if ( fOutputTRAKSEGS ) return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
-  else return AliHLTTPCCADefinitions::fgkTrackletsDataType;
+  return AliHLTTPCCADefinitions::fgkTrackletsDataType;
 }
 
 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
@@ -164,7 +160,6 @@ void AliHLTTPCCATrackerComponent::SetDefaultConfiguration()
   fNeighboursSearchArea = 0;
   fClusterErrorCorrectionY = 0;
   fClusterErrorCorrectionZ = 0;
-  fOutputTRAKSEGS = 0;
   fFullTime = 0;
   fRecoTime = 0;
   fNEvents = 0;
@@ -230,12 +225,6 @@ int AliHLTTPCCATrackerComponent::ReadConfigurationString(  const char* arguments
      continue;
    }
 
-   if ( argument.CompareTo( "-outputTRAKSEGS" ) == 0 ) {
-      fOutputTRAKSEGS = 1;
-      HLTInfo( "The special output type \"TRAKSEGS\" is set" );
-      continue;
-    }
-
     if (argument.CompareTo( "-allowGPU" ) == 0) {
       fAllowGPU = 1;
       HLTImportant( "Will try to run tracker on GPU" );
@@ -451,53 +440,37 @@ int AliHLTTPCCATrackerComponent::DoEvent
 
     // Determine slice number to really use. (for obsolete output)
     if ( slices.size() > 1 ) {
-               Logging( fOutputTRAKSEGS ? kHLTLogError : kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
+      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
                "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
                evtData.fEventID, evtData.fEventID );
       unsigned maxCntSlice = 0;
       slCntIter = sliceCnts.begin();
       for ( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ ) {
-        Logging( fOutputTRAKSEGS ? kHLTLogError : kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
+        Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
                  "Slice %lu found %lu times.", *slIter, *slCntIter );
-        if ( fOutputTRAKSEGS && maxCntSlice < *slCntIter ) {
-          maxCntSlice = *slCntIter;
-          slice = *slIter;
-        }
       }
-      if (fOutputTRAKSEGS)
-      {
-           Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-               "Using slice %lu.", slice );
-       }
     } else if ( slices.size() > 0 ) {
       slice = *( slices.begin() );
     }
 
 
-         if (fOutputTRAKSEGS)
+    for (int islice = minslice;islice <= maxslice;islice++)
+      {
+       bool found = false;
+       for(slIter = slices.begin(); slIter != slices.end();slIter++)
          {
-                 minslice = maxslice = slice;
+           if (*slIter == islice)
+             {
+               found = true;
+               break;
+             }
          }
-         else
+       if (!found)
          {
-                 for (int islice = minslice;islice <= maxslice;islice++)
-                 {
-                         bool found = false;
-                         for(slIter = slices.begin(); slIter != slices.end();slIter++)
-                         {
-                                 if (*slIter == islice)
-                                 {
-                                         found = true;
-                                         break;
-                                 }
-                         }
-                         if (!found)
-                         {
-                                 maxslice = islice - 1;
-                                 break;
-                         }
-                 }
-        }
+           maxslice = islice - 1;
+           break;
+         }
+      }
   }
 
   if ( !fTracker ) fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU);
@@ -688,11 +661,9 @@ int AliHLTTPCCATrackerComponent::DoEvent
   AliHLTTPCCASliceOutput::outputControlStruct outputControl;
   //Set tracker output so tracker does not have to output both formats!
   outputControl.fEndOfSpace = 0;
-  outputControl.fObsoleteOutput = fOutputTRAKSEGS;
-  outputControl.fDefaultOutput = !fOutputTRAKSEGS;
 
   //For new output we can write directly to output buffer
-  outputControl.fOutputPtr = fOutputTRAKSEGS ? NULL : (char*) outputPtr;
+  outputControl.fOutputPtr =  (char*) outputPtr;
   outputControl.fOutputMaxSize = maxBufferSize;
 
   AliHLTTPCCASliceOutput** sliceOutput = new AliHLTTPCCASliceOutput*[slicecount];
@@ -717,159 +688,47 @@ int AliHLTTPCCATrackerComponent::DoEvent
       error = 1;
       break;     
     }
-         slice = minslice + islice;
-
-         if (sliceOutput[islice])
-         {
-                 // write reconstructed tracks
-
-                 if ( fOutputTRAKSEGS ) {
-
-                 Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
-                                  "%d tracks found for slice %d", sliceOutput[islice]->NOutTracks(), slice );
-
-                       ntracks = sliceOutput[islice]->NOutTracks();
-
-                       AliHLTTPCTrackletData* outPtr = ( AliHLTTPCTrackletData* )( outputPtr );
-
-                       AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
-
-                       mySize =   ( ( AliHLTUInt8_t * )currOutTracklet ) -  ( ( AliHLTUInt8_t * )outputPtr );
-
-                       outPtr->fTrackletCnt = 0;
-
-                       for ( int itr = 0; itr < ntracks; itr++ ) {
-
-                         AliHLTTPCCAOutTrack &t = sliceOutput[islice]->OutTracks()[itr];
-
-                         //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Wrtite output","track %d with %d hits", itr, t.NHits());
-
-                         if ( t.NHits() < fMinNTrackClusters ) continue;
-
-                         // calculate output track size
-
-                         unsigned int dSize = sizeof( AliHLTTPCTrackSegmentData ) + t.NHits() * sizeof( unsigned int );
-
-                         if ( mySize + dSize > maxBufferSize ) {
-                               HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, ntracks - itr + 1 );
-                               ret = -ENOSPC;
-                               error = 1;
-                               break;
-                         }
-
-                         // convert CA track parameters to HLT Track Segment
-
-                         int iFirstRow = 1000;
-                         int iLastRow = -1;
-                         int iFirstHit = sliceOutput[islice]->OutTrackHit(t.FirstHitRef());
-                         int iLastHit = iFirstHit;
-                         for ( int ih = 0; ih < t.NHits(); ih++ ) {
-                               int hitID = sliceOutput[islice]->OutTrackHit(t.FirstHitRef() + ih);
-                               int iRow = clusterData[islice].RowNumber( hitID );
-                               if ( iRow < iFirstRow ) {  iFirstRow = iRow; iFirstHit = hitID; }
-                               if ( iRow > iLastRow ) { iLastRow = iRow; iLastHit = hitID; }
-                         }
-
-                         AliHLTTPCCATrackParam par = t.StartPoint();
-
-                         par.TransportToX( clusterData[islice].X( iFirstHit ), .99 );
-
-                         AliExternalTrackParam tp;
-                         AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0 );
-
-                         currOutTracklet->fX = tp.GetX();
-                         currOutTracklet->fY = tp.GetY();
-                         currOutTracklet->fZ = tp.GetZ();
-                         currOutTracklet->fCharge = ( int ) tp.GetSign();
-                         currOutTracklet->fPt = TMath::Abs( tp.GetSignedPt() );
-                         float snp =  tp.GetSnp() ;
-                         if ( snp > .999 ) snp = .999;
-                         if ( snp < -.999 ) snp = -.999;
-                         currOutTracklet->fPsi = TMath::ASin( snp );
-                         currOutTracklet->fTgl = tp.GetTgl();
-
-                         currOutTracklet->fY0err = tp.GetSigmaY2();
-                         currOutTracklet->fZ0err = tp.GetSigmaZ2();
-                         float h = -currOutTracklet->fPt * currOutTracklet->fPt;
-                         currOutTracklet->fPterr = h * h * tp.GetSigma1Pt2();
-                         h = 1. / TMath::Sqrt((1.-snp)*(1.+snp));
-                         currOutTracklet->fPsierr = h * h * tp.GetSigmaSnp2();
-                         currOutTracklet->fTglerr = tp.GetSigmaTgl2();
-
-                         if ( par.TransportToX( clusterData[islice].X( iLastHit ), .99 ) ) {
-                               currOutTracklet->fLastX = par.GetX();
-                               currOutTracklet->fLastY = par.GetY();
-                               currOutTracklet->fLastZ = par.GetZ();
-                         } else {
-                               currOutTracklet->fLastX = clusterData[islice].X( iLastHit );
-                               currOutTracklet->fLastY = clusterData[islice].Y( iLastHit );
-                               currOutTracklet->fLastZ = clusterData[islice].Z( iLastHit );
-                         }
-                         //if( currOutTracklet->fLastX<10. ) {
-                         //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",clusterData[islice].X( iLastHit ),clusterData[islice].Y( iLastHit],clusterData[islice].Z( iLastHit],
-                         //par.GetX(), par.GetY(),par.GetZ(),currOutTracklet->fLastX,currOutTracklet->fLastY ,currOutTracklet->fLastZ, t.NHits());
-                         //}
-               #ifdef INCLUDE_TPC_HOUGH
-               #ifdef ROWHOUGHPARAMS
-                         currOutTracklet->fTrackID = 0;
-                         currOutTracklet->fRowRange1 = clusterData[islice].RowNumber( iFirstHit );
-                         currOutTracklet->fRowRange2 = clusterData[islice].RowNumber( iLastHit );
-                         currOutTracklet->fSector = slice;
-                         currOutTracklet->fPID = 211;
-               #endif
-               #endif // INCLUDE_TPC_HOUGH
-
-
-                         currOutTracklet->fNPoints = t.NHits();
-
-                         for ( int i = 0; i < t.NHits(); i++ ) {
-                               currOutTracklet->fPointIDs[i] = clusterData[islice].Id( sliceOutput[islice]->OutTrackHit(t.FirstHitRef()+i) );
-                         }
-
-                         currOutTracklet = ( AliHLTTPCTrackSegmentData* )( ( Byte_t * )currOutTracklet + dSize );
-                         mySize += dSize;
-                         outPtr->fTrackletCnt++;
-                       }
-
-                 } else { // default output type
-
-                 Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
-                                  "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
-
-                         mySize += sliceOutput[islice]->OutputMemorySize();
-                         ntracks += sliceOutput[islice]->NTracks();
-                 }
-         }
-         else
-         {
-                 HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
-                 mySize = 0;
-                 ret = -ENOSPC;
-                 ntracks = 0;
-                 error = 1;
-                 break;
-         }
+    slice = minslice + islice;
+    
+    if (sliceOutput[islice])
+      {
+       // write reconstructed tracks
+       Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
+                "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
+       
+       mySize += sliceOutput[islice]->OutputMemorySize();
+       ntracks += sliceOutput[islice]->NTracks();        
+      }
+    else
+      {
+       HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
+       mySize = 0;
+       ret = -ENOSPC;
+       ntracks = 0;
+       error = 1;
+       break;
+      }
   }
-
+  
   size = 0;
   if (error == 0)
   {
-         for (int islice = 0;islice < slicecount;islice++)
+    for (int islice = 0;islice < slicecount;islice++)
+      {
+       slice = minslice + islice;
+       mySize = sliceOutput[islice]->OutputMemorySize();
+       if (mySize > 0)
          {
-                 slice = minslice + islice;
-                 if (!fOutputTRAKSEGS) mySize = sliceOutput[islice]->OutputMemorySize();
-                 if (mySize > 0)
-                 {
-                       AliHLTComponentBlockData bd;
-                       FillBlockData( bd );
-                       bd.fOffset = fOutputTRAKSEGS ? 0 : ((char*) sliceOutput[islice] - (char*) outputPtr);
-                       bd.fSize = mySize;
-                       bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
-                       bd.fDataType = GetOutputDataType();
-                       outputBlocks.push_back( bd );
-                       size += mySize;
-                 }
+           AliHLTComponentBlockData bd;
+           FillBlockData( bd );
+           bd.fOffset = ((char*) sliceOutput[islice] - (char*) outputPtr);
+           bd.fSize = mySize;
+           bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
+           bd.fDataType = GetOutputDataType();
+           outputBlocks.push_back( bd );
+           size += mySize;
          }
+      }
   }
 
   //No longer needed
index 1b05fe0..7142ce9 100644 (file)
@@ -89,7 +89,6 @@ class AliHLTTPCCATrackerComponent : public AliHLTProcessor
     double fFullTime; //* total time for DoEvent() [s]
     double fRecoTime; //* total reconstruction time [s]
     Long_t    fNEvents;  //* number of reconstructed events
-    bool fOutputTRAKSEGS; //* use old type of output
     bool fAllowGPU;    //* Allow this tracker to run on GPU
 
     static bool CompareClusters( AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b );
index d0cbab6..9633860 100644 (file)
@@ -10,7 +10,7 @@
 #define ALIHLTTPCCATRACKLET_H
 
 #include "AliHLTTPCCADef.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
 #include "AliHLTTPCCAGPUConfig.h"
 
 /**
@@ -32,7 +32,7 @@ class AliHLTTPCCATracklet
     GPUhd() int  NHits()                const { return fNHits;      }
     GPUhd() int  FirstRow()             const { return fFirstRow;   }
     GPUhd() int  LastRow()              const { return fLastRow;    }
-    GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam; }
+    GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam; }
 #ifndef EXTERN_ROW_HITS
     GPUhd() int  RowHit( int i )   const { return fRowHits[i];    }
        GPUhd() const int* RowHits()    const                   { return(fRowHits); }
@@ -42,13 +42,13 @@ class AliHLTTPCCATracklet
     GPUhd() void SetNHits( int v )               {  fNHits = v;      }
     GPUhd() void SetFirstRow( int v )            {  fFirstRow = v;   }
     GPUhd() void SetLastRow( int v )             {  fLastRow = v;    }
-    GPUhd() void SetParam( const AliHLTTPCCATrackParam2 &v ) { fParam = v;      }
+    GPUhd() void SetParam( const AliHLTTPCCABaseTrackParam &v ) { fParam = v;      }
 
   private:
     int fNHits;                 // N hits
     int fFirstRow;              // first TPC row
     int fLastRow;               // last TPC row
-    AliHLTTPCCATrackParam2 fParam; // tracklet parameters
+    AliHLTTPCCABaseTrackParam fParam; // tracklet parameters
 #ifndef EXTERN_ROW_HITS
     int fRowHits[HLTCA_ROW_COUNT + 1];          // hit index for each TPC row
 #endif //EXTERN_ROW_HITS