TPC CA Global Merger component added
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Apr 2009 14:07:41 +0000 (14:07 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Apr 2009 14:07:41 +0000 (14:07 +0000)
16 files changed:
HLT/TPCLib/tracking-ca/AliHLTTPCCADataCompressor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.cxx [new file with mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.h [new file with mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCAMerger.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMerger.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAProcess.h
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.h
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx

index 83f00f9..05bc9bd 100644 (file)
@@ -60,9 +60,7 @@ GPUhd() inline UShort_t AliHLTTPCCADataCompressor::YZ2UShort( Float_t Y, Float_t
   else if( Y>255. ) Y = 255.;
   if( Z<0. ) Z = 0.;
   else if( Z>255. ) Z = 255.;
-  UInt_t iY = static_cast<UInt_t>( Y );
-  UInt_t iZ = static_cast<UInt_t>( Z );
-  return static_cast<UShort_t>( (iY<<8) + iZ );
+  return static_cast<UShort_t>( ( static_cast<UInt_t>( Y )<<8) + static_cast<UInt_t>( Z ) );
 }  
 
 GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Y( UShort_t iYZ )
@@ -70,8 +68,7 @@ GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Y( UShort_t iYZ )
   // extract Y coordinate from the compressed 16bits format to [-3.,3.]
 
   const Float_t kMult = 6./255.; 
-  Float_t y = (iYZ >> 8);
-  return y*kMult - 3.;
+  return (iYZ >> 8)*kMult - 3.;
 }  
 
 GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Z( UShort_t iYZ )
@@ -79,8 +76,7 @@ GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Z( UShort_t iYZ )
   // extract Z coordinate from the compressed 16bits format to [-3.,3.]
 
   const Float_t kMult = 6./255.; 
-  Float_t z = (iYZ % 256);
-  return z*kMult - 3.;
+  return (iYZ % 256)*kMult - 3.;
 }
 
 #endif
index 56bb6bd..8464b18 100644 (file)
@@ -83,6 +83,13 @@ typedef float          Size_t;      //Attribute size (float)
 
 #include "Rtypes.h"
 
+#include "AliHLTDataTypes.h"
+
+namespace AliHLTTPCCADefinitions
+{
+  extern const AliHLTComponentDataType fgkTrackletsDataType;
+}
+
 #endif
 
 
index 029a454..95485df 100644 (file)
 #include "TApplication.h"
 
 
+class AliHLTTPCCADisplay::AliHLTTPCCADisplayTmpHit
+{
+
+public:
+
+  Int_t ID() const { return fHitID; }
+  Double_t S() const { return fS; }
+  Double_t Z() const { return fZ; }
+  
+  void SetID( Int_t v ){ fHitID = v; }    
+  void SetS( Double_t v){ fS = v; }
+  void SetZ( Double_t v){ fZ = v; }
+  
+  static Bool_t CompareHitDS( const AliHLTTPCCADisplayTmpHit &a, 
+                             const AliHLTTPCCADisplayTmpHit  &b )
+  {    
+    return (a.fS < b.fS);
+  }
+
+  static Bool_t CompareHitZ( const AliHLTTPCCADisplayTmpHit &a, 
+                            const AliHLTTPCCADisplayTmpHit  &b )
+  {    
+    return (a.fZ < b.fZ);
+  }
+
+private:
+
+  Int_t fHitID; // hit ID
+  Double_t fS;  // hit position on the XY track curve 
+  Double_t fZ;  // hit Z position
+
+};
+
 
 
 AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
@@ -373,7 +406,7 @@ Int_t AliHLTTPCCADisplay::GetColorK( Double_t k ) const
   return kMyColor[iy];
 }
 
-void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t * yv ) const
+void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
 {
   // convert coordinates global->view
   *xv = x*fCos + y*fSin;
index 6adb15d..75fa0d8 100644 (file)
@@ -29,6 +29,7 @@ class TCanvas;
 #include "TLatex.h"
 
 
+
 /**
  * @class AliHLTTPCCADisplay
  */
@@ -37,32 +38,7 @@ class AliHLTTPCCADisplay
 
  public:
   
-  class AliHLTTPCCADisplayTmpHit{  
-
-  public:
-    Int_t ID() const { return fHitID; }
-    Double_t S() const { return fS; }
-    Double_t Z() const { return fZ; }
-
-    void SetID( Int_t v ){ this->fHitID = v; }    
-    void SetS( Double_t v){ this->fS = v; }
-    void SetZ( Double_t v){ this->fZ = v; }
-
-    static Bool_t CompareHitDS( const AliHLTTPCCADisplayTmpHit &a, 
-                                const AliHLTTPCCADisplayTmpHit  &b )
-    {    
-      return (a.fS < b.fS);
-    }
-    static Bool_t CompareHitZ( const AliHLTTPCCADisplayTmpHit &a, 
-                                const AliHLTTPCCADisplayTmpHit  &b )
-    {    
-      return (a.fZ < b.fZ);
-    }
-  private:
-    Int_t fHitID; // hit ID
-    Double_t fS;  // hit position on the XY track curve 
-    Double_t fZ;  // hit Z position
-  };
+  class AliHLTTPCCADisplayTmpHit;
 
   static AliHLTTPCCADisplay &Instance();
   
index f094c5c..2cf0960 100644 (file)
@@ -197,9 +197,10 @@ void AliHLTTPCCAGBTracker::FindTracks()
   Float_t *hitY = new Float_t [nHitsTotal];
   Float_t *hitZ = new Float_t [nHitsTotal];
 
-  Int_t sliceNHits[fNSlices];  
-  Int_t rowNHits[fNSlices][200];
-  
+  Int_t *sliceNHits = new Int_t[ fNSlices ];
+  Int_t **rowNHits = new Int_t* [fNSlices];
+  for( Int_t i=0; i<fNSlices; i++ ) rowNHits[i] = new Int_t[200];
+
   for( Int_t is=0; is<fNSlices; is++ ){
     sliceNHits[is] = 0;
     for( Int_t ir=0; ir<200; ir++ ) rowNHits[is][ir] = 0;    
@@ -224,16 +225,20 @@ void AliHLTTPCCAGBTracker::FindTracks()
        hitZ[firstRowHit + ih] = h.Z(); 
       }
       firstRowHit+=rowNHits[is][ir];
-    }
-    fSlices[is].ReadEvent( rowFirstHits, rowNHits[is], hitY, hitZ, sliceNHits[is] );
-    
+    }    
+    fSlices[is].ReadEvent( rowFirstHits, &*rowNHits[is], hitY, hitZ, sliceNHits[is] );
+   
     //Int_t data[ rowNHits[is]]
     //AliHLTTPCCAEventHeader event;
 
     firstSliceHit+=sliceNHits[is];
   }
 
-
+  if( sliceNHits ) delete[] sliceNHits;
+  if( rowNHits ){
+    for( Int_t i=0; i<fNSlices; i++ ) delete[] rowNHits[i];
+    delete[] rowNHits;
+  }
   if( hitY ) delete[] hitY;
   hitY=0;
   if( hitZ ) delete[] hitZ;
@@ -330,10 +335,13 @@ void AliHLTTPCCAGBTracker::Merging1()
 
   AliHLTTPCCAMerger merger;
   merger.SetSliceParam( fSlices[0].Param() );
-  const AliHLTTPCCASliceOutput * sliceOutput[fNSlices];
-  for( Int_t i=0; i<fNSlices; i++ ) sliceOutput[i] = fSlices[i].Output();  
-  merger.Reconstruct( sliceOutput );  
-  
+
+  for( Int_t i=0; i<fNSlices; i++ ) {
+    merger.SetSliceData( i, fSlices[i].Output() );
+  }
+
+  merger.Reconstruct();
+
   const AliHLTTPCCAMergerOutput &out = *(merger.Output());
   
   
@@ -385,135 +393,6 @@ void AliHLTTPCCAGBTracker::Merging1()
 }
 
 
-
-void AliHLTTPCCAGBTracker::FindTracks0()
-{
-  //* main tracking routine
-  fTime = 0;
-  fStatNEvents++;  
-#ifdef DRAW
-  AliHLTTPCCADisplay::Instance().SetTPCView();
-  AliHLTTPCCADisplay::Instance().DrawTPC();
-#endif //DRAW  
-
-  if( fNHits<=0 ) return;
-  
-  std::sort(fHits,fHits+fNHits, AliHLTTPCCAGBHit::Compare );  
-
-  // Read hits, row by row
-
-  Int_t nHitsTotal = fNHits;
-  Float_t *hitY = new Float_t [nHitsTotal];
-  Float_t *hitZ = new Float_t [nHitsTotal];
-
-  Int_t sliceNHits[fNSlices];  
-  Int_t rowNHits[fNSlices][200];
-  
-  for( Int_t is=0; is<fNSlices; is++ ){
-    sliceNHits[is] = 0;
-    for( Int_t ir=0; ir<200; ir++ ) rowNHits[is][ir] = 0;    
-  }
-
-  for( Int_t ih=0; ih<nHitsTotal; ih++){
-    AliHLTTPCCAGBHit &h = fHits[ih];    
-    sliceNHits[h.ISlice()]++;
-    rowNHits[h.ISlice()][h.IRow()]++;
-  }
-  
-  Int_t firstSliceHit = 0;
-  for( Int_t is=0; is<fNSlices; is++ ){
-    fFirstSliceHit[is] = firstSliceHit;
-    Int_t rowFirstHits[200];
-    Int_t firstRowHit = 0;
-    for( Int_t ir=0; ir<200; ir++ ){
-      rowFirstHits[ir] = firstRowHit;
-      for( Int_t ih=0; ih<rowNHits[is][ir]; ih++){
-       AliHLTTPCCAGBHit &h = fHits[firstSliceHit + firstRowHit + ih];    
-       hitY[firstRowHit + ih] = h.Y();
-       hitZ[firstRowHit + ih] = h.Z(); 
-      }
-      firstRowHit+=rowNHits[is][ir];
-    }
-    //if( is==24 ){//SG!!!
-    fSlices[is].ReadEvent( rowFirstHits, rowNHits[is], hitY, hitZ, sliceNHits[is] );
-    //}
-    
-    //Int_t data[ rowNHits[is]]
-    //AliHLTTPCCAEventHeader event;
-
-    firstSliceHit+=sliceNHits[is];
-  }
-
-  if( hitY ) delete[] hitY;
-  if( hitZ ) delete[] hitZ;
-}
-
-
-void AliHLTTPCCAGBTracker::FindTracks1()
-{
-  //* main tracking routine
-
-  TStopwatch timer2;
-  //std::cout<<"Start CA reconstruction"<<std::endl;
-  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
-    TStopwatch timer;
-    AliHLTTPCCATracker &slice = fSlices[iSlice];
-    slice.Reconstruct();
-    timer.Stop();
-    //fTime+= timer.CpuTime();
-    //blaTime+= timer.CpuTime();
-    fStatTime[0] += timer.CpuTime();
-    fStatTime[1]+=slice.Timer(0);
-    fStatTime[2]+=slice.Timer(1);
-    fStatTime[3]+=slice.Timer(2);
-    fStatTime[4]+=slice.Timer(3);
-    fStatTime[5]+=slice.Timer(4);
-    fStatTime[6]+=slice.Timer(5);
-    fStatTime[7]+=slice.Timer(6);
-    fStatTime[8]+=slice.Timer(7);
-  }
-
-  timer2.Stop();
-  //std::cout<<"blaTime = "<<timer2.CpuTime()*1.e3<<std::endl;
-  fSliceTrackerTime = timer2.CpuTime();
-}
-
-
-void AliHLTTPCCAGBTracker::FindTracks2()
-{
-  //* main tracking routine
-
-  TStopwatch timer1;
-
-  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
-    AliHLTTPCCATracker &iS = fSlices[iSlice];
-    if( fSliceTrackInfos[iSlice] ) delete[] fSliceTrackInfos[iSlice];
-    fSliceTrackInfos[iSlice]=0;
-    Int_t iNTracks = *iS.NOutTracks();    
-    fSliceTrackInfos[iSlice] = new AliHLTTPCCAGBSliceTrackInfo[iNTracks];
-    for( Int_t itr=0; itr<iNTracks; itr++ ){
-      fSliceTrackInfos[iSlice][itr].fPrevNeighbour = -1;
-      fSliceTrackInfos[iSlice][itr].fNextNeighbour = -1; 
-      fSliceTrackInfos[iSlice][itr].fUsed = 0;
-    }
-  }
-  
-  //std::cout<<"Start CA merging"<<std::endl;
-  TStopwatch timerMerge;
-  Merging();
-  timerMerge.Stop();
-  fStatTime[9]+=timerMerge.CpuTime();  
-  //fTime+=timerMerge.CpuTime();
-  //std::cout<<"End CA merging"<<std::endl;
-  timer1.Stop();
-  fTime+= fSliceTrackerTime + timer1.CpuTime();
-
-#ifdef DRAW
-  AliHLTTPCCADisplay::Instance().Ask();
-#endif //DRAW
-}
-
-
 void AliHLTTPCCAGBTracker::Refit()
 {
   //* Refit the slice tracks
index 8da2a22..4f1e0a7 100644 (file)
@@ -58,10 +58,6 @@ public:
 
   void FindTracks();
 
-  void FindTracks0();
-  void FindTracks1();
-  void FindTracks2();
-
 
   void Refit();
 
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.cxx
new file mode 100644 (file)
index 0000000..2fc31b2
--- /dev/null
@@ -0,0 +1,392 @@
+// **************************************************************************
+// 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>                *
+//                  Matthias Kretz <kretz@kde.org>                          *
+//                  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.                    *
+//                                                                          *
+//***************************************************************************
+
+
+/** @file   AliHLTTPCCAGlobalMergerComponent.cxx
+    @author Matthias Kretz
+    @date
+    @brief  HLT TPC CA global merger component.
+*/
+
+#if __GNUC__>= 3
+using namespace std;
+#endif
+
+#include "AliHLTTPCCAGlobalMergerComponent.h"
+#include "AliHLTTPCCAMergerOutput.h"
+#include "AliHLTTPCTransform.h"
+#include "AliHLTTPCCAMerger.h"
+#include "AliHLTTPCVertex.h"
+#include "AliHLTTPCVertexData.h"
+#include "AliHLTTPCTrackSegmentData.h"
+#include "AliHLTTPCTrack.h"
+#include "AliHLTTPCTrackArray.h"
+#include "AliHLTTPCTrackletDataFormat.h"
+#include "AliHLTTPCCADef.h"
+#include "AliHLTTPCDefinitions.h"
+#include "AliHLTTPCCATrackConvertor.h"
+
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "TObjString.h"
+#include "TObjArray.h"
+
+#include <climits>
+#include <cstdlib>
+#include <cerrno>
+
+
+// ROOT macro for the implementation of ROOT specific class methods
+ClassImp( AliHLTTPCCAGlobalMergerComponent )
+
+
+// global object for registration
+AliHLTTPCCAGlobalMergerComponent AliHLTTPCCAGlobalMergerComponent::fgAliHLTTPCCAGlobalMergerComponent;
+
+AliHLTTPCCAGlobalMergerComponent::AliHLTTPCCAGlobalMergerComponent()
+  : fGlobalMerger( 0 ), fSolenoidBz(5)
+{
+  // see header file for class documentation
+}
+
+// Public functions to implement AliHLTComponent's interface.
+// These functions are required for the registration process
+
+const char *AliHLTTPCCAGlobalMergerComponent::GetComponentID()
+{
+  // see header file for class documentation
+  return "TPCCAGlobalMerger";
+}
+
+void AliHLTTPCCAGlobalMergerComponent::GetInputDataTypes( AliHLTComponentDataTypeList &list )
+{
+  // see header file for class documentation
+  list.clear();
+  list.push_back( AliHLTTPCCADefinitions::fgkTrackletsDataType );
+  //list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
+  //list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
+}
+
+AliHLTComponentDataType AliHLTTPCCAGlobalMergerComponent::GetOutputDataType()
+{
+  // see header file for class documentation
+  return AliHLTTPCDefinitions::fgkTracksDataType;
+}
+
+void AliHLTTPCCAGlobalMergerComponent::GetOutputDataSize( unsigned long &constBase, double &inputMultiplier )
+{
+  // see header file for class documentation
+  // XXX TODO: Find more realistic values.
+  constBase = 0;
+  inputMultiplier = 1.0;
+}
+
+AliHLTComponent *AliHLTTPCCAGlobalMergerComponent::Spawn()
+{
+  // see header file for class documentation
+  return new AliHLTTPCCAGlobalMergerComponent;
+}
+
+int AliHLTTPCCAGlobalMergerComponent::DoInit( int argc, const char** argv )
+{
+  // see header file for class documentation
+  if ( fGlobalMerger ) {
+    return EINPROGRESS;
+  }
+
+  // Initialize the merger
+
+  fGlobalMerger = new AliHLTTPCCAMerger();
+
+  AliHLTTPCCAParam param;
+  
+  {
+    // get gemetry
+    Int_t iSec = 0;
+    Float_t inRmin = 83.65; 
+    Float_t outRmax = 247.7;
+    Float_t plusZmin = 0.0529937; 
+    Float_t plusZmax = 249.778; 
+    Float_t minusZmin = -249.645; 
+    Float_t minusZmax = -0.0799937; 
+    Float_t dalpha = 0.349066;
+    Float_t alpha = 0.174533 + dalpha*iSec;    
+    Bool_t zPlus = (iSec<18 );
+    Float_t zMin =  zPlus ?plusZmin :minusZmin;
+    Float_t zMax =  zPlus ?plusZmax :minusZmax;
+    Int_t nRows = AliHLTTPCTransform::GetNRows();        
+    Float_t padPitch = 0.4;
+    Float_t sigmaZ = 0.228808;    
+    Float_t *rowX = new Float_t [nRows];
+    for( Int_t irow=0; irow<nRows; irow++){
+      rowX[irow] = AliHLTTPCTransform::Row2X( irow );
+    }
+     
+    param.Initialize( iSec, nRows, rowX, alpha, dalpha,
+                     inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );    
+    delete[] rowX;
+  }
+
+
+  fGlobalMerger->SetSliceParam( param );
+
+  Int_t iResult = EINVAL;
+
+  TString arguments=""; 
+  for (int i=0; i<argc; i++) {
+    TString argument=argv[i];
+    if (!arguments.IsNull()) arguments+=" ";
+    arguments+=argument;
+  }
+  if (!arguments.IsNull()) {
+    iResult=Configure(arguments.Data());
+  } else {
+    iResult=Reconfigure(NULL, NULL);
+  }  
+  return iResult;
+}
+
+int AliHLTTPCCAGlobalMergerComponent::DoDeinit()
+{
+  // see header file for class documentation
+  delete fGlobalMerger;
+  fGlobalMerger = 0;
+
+  return 0;
+}
+
+int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &evtData,
+                                              const AliHLTComponentBlockData *blocks, AliHLTComponentTriggerData &/*trigData*/,
+    AliHLTUInt8_t *outputPtr, AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks )
+{
+  // see header file for class documentation
+  int iResult = 0;
+  UInt_t maxBufferSize = size;
+
+  size = 0;
+
+  if ( !outputPtr ) {
+      return -ENOSPC;
+  }
+  if ( !IsDataEvent() ) {
+    return 0;
+  }
+
+  fGlobalMerger->Clear();
+
+  const AliHLTComponentBlockData *const blocksEnd = blocks + evtData.fBlockCnt;
+  for ( const AliHLTComponentBlockData *block = blocks; block < blocksEnd; ++block ) {
+    if ( block->fDataType != AliHLTTPCCADefinitions::fgkTrackletsDataType ) {
+      continue;
+    }
+
+    int slice = AliHLTTPCDefinitions::GetMinSliceNr( *block );
+    if ( slice < 0 || slice >= AliHLTTPCTransform::GetNSlice() ) {
+      HLTError( "invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
+          slice, block->fSpecification, DataType2Text(block->fDataType).c_str() );
+      // just remember the error, if there are other valid blocks ignore the error, return code otherwise
+      iResult = -EBADF;
+      continue;
+    }
+
+    if ( slice != AliHLTTPCDefinitions::GetMaxSliceNr( *block ) ) {
+      // the code was not written for/ never used with multiple slices in one data block/ specification
+      HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
+          block->fSpecification, DataType2Text(block->fDataType).c_str());
+    }
+
+    fGlobalMerger->SetSliceData( slice, reinterpret_cast<AliHLTTPCCASliceOutput *>( block->fPtr ) );
+  }
+  fGlobalMerger->Reconstruct();
+
+  const AliHLTTPCCAMergerOutput *mergerOutput = fGlobalMerger->Output();
+
+
+  // Fill output tracks
+
+  UInt_t mySize = 0;
+
+  {
+    // check if there was enough space in the output buffer
+
+    Int_t nTracks = mergerOutput->NTracks();
+
+    AliHLTTPCTrackArray array( nTracks );
+
+    Int_t nClusters=0;
+    for( Int_t itr=0; itr<nTracks; itr++){
+      // convert AliHLTTPCCAMergedTrack to AliHLTTPCTrack
+
+      const AliHLTTPCCAMergedTrack &track = mergerOutput->Track( itr );
+      AliHLTTPCTrack out;
+
+      // first convert to AliExternalTrackParam ( Kappa to Pt )
+
+      AliExternalTrackParam tp, tpEnd;
+      AliHLTTPCCATrackConvertor::GetExtParam( track.InnerParam(), tp, 0, fSolenoidBz );      
+      AliHLTTPCCATrackConvertor::GetExtParam( track.OuterParam(), tpEnd, 0, fSolenoidBz );      
+
+      // set parameters, with rotation to global coordinates
+      
+      out.SetCharge((Int_t ) tp.GetSign());
+      out.SetPt( TMath::Abs(tp.GetSignedPt()) );
+      out.SetPsi( fmod( TMath::ASin( tp.GetSnp() ) + track.InnerAlpha() ,2*TMath::Pi() ) );
+      out.SetTgl( tp.GetTgl() );
+      {
+       Float_t sinA = TMath::Sin( track.InnerAlpha() );
+       Float_t cosA = TMath::Cos( track.InnerAlpha() );
+       
+       out.SetFirstPoint( tp.GetX()*cosA - tp.GetY()*sinA,
+                          tp.GetX()*sinA + tp.GetY()*cosA, 
+                          tp.GetZ() );
+      }
+      
+      {
+       Float_t sinA = TMath::Sin( track.OuterAlpha() );
+       Float_t cosA = TMath::Cos( track.OuterAlpha() );
+       
+       out.SetLastPoint( tpEnd.GetX()*cosA - tpEnd.GetY()*sinA,
+                         tpEnd.GetX()*sinA + tpEnd.GetY()*cosA, 
+                         tpEnd.GetZ() );
+      }
+
+      // set parameter errors w/o rotation, as it is done in AliHLTTPCTrackArray
+
+      out.SetY0err(tp.GetSigmaY2());
+      out.SetZ0err(tp.GetSigmaZ2());
+      Float_t h = -out.GetPt()*out.GetPt();
+      out.SetPterr( h*h*tp.GetSigma1Pt2() );
+      h = 1./TMath::Sqrt(1-out.GetSnp()*out.GetSnp());
+      out.SetPsierr(h*h*tp.GetSigmaSnp2());
+      out.SetTglerr(tp.GetSigmaTgl2());  
+      // set cluster ID's
+
+      UInt_t hitID[1000];
+      for( Int_t i=0; i<track.NClusters(); i++ ) hitID[i] = mergerOutput->ClusterIDsrc(track.FirstClusterRef()+i);
+
+      out.SetNHits( track.NClusters() );
+      out.SetHits( track.NClusters(), hitID );
+      
+      out.SetSector(-1);
+      out.CalculateHelix();
+      if( !out.CheckConsistency() )  *(array.NextTrack()) = out;      
+      nClusters+=track.NClusters();
+    }
+
+    
+    if ( sizeof(AliHLTTPCTrackletData) + nTracks*sizeof(AliHLTTPCTrackSegmentData) + nClusters*sizeof(UInt_t)
+        > maxBufferSize ){
+      iResult = -ENOSPC;
+    } else {
+      AliHLTTPCTrackletData *outPtr = (AliHLTTPCTrackletData*)(outputPtr);
+      UInt_t nOutTracks = 0;
+      mySize = array.WriteTracks( nOutTracks, outPtr->fTracklets );
+      mySize += sizeof(AliHLTTPCTrackletData);
+      outPtr->fTrackletCnt = nOutTracks;
+    }
+  }
+  
+  AliHLTComponentBlockData resultData;
+  FillBlockData( resultData );
+  resultData.fOffset = 0;
+  resultData.fSize = mySize;
+  resultData.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
+  outputBlocks.push_back( resultData );
+  size = resultData.fSize;
+
+  //HLTWarning("CAGlobalMerger:: output %d tracks",mergerOutput->NTracks());
+
+  return iResult;
+}
+
+
+
+Int_t AliHLTTPCCAGlobalMergerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
+{
+  // see header file for class documentation
+
+
+  HLTWarning("dummy Reconfigure() method called" );
+  return EINVAL;
+  /*
+
+  Int_t iResult=EINVAL;
+  const char* pathBField=kAliHLTCDBSolenoidBz;
+  
+  if (pathBField) {
+    HLTInfo("reconfigure B-Field from entry %s, chain id %s", pathBField,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
+    if (pEntry) {
+      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
+      if (pString) {
+       HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+       iResult=Configure(pString->GetString().Data());
+      } else {
+       HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
+      }
+    } else {
+      HLTError("cannot fetch object \"%s\" from CDB", pathBField);
+    }
+  }  
+  return iResult;  
+*/
+}
+
+
+Int_t AliHLTTPCCAGlobalMergerComponent::Configure( const char* arguments )
+{
+  //* Set parameters
+
+  Int_t iResult=EINVAL;
+  if (!arguments) return iResult;
+  
+  TString allArgs=arguments;
+  TString argument;
+  Int_t bMissingParam=0;
+  
+  TObjArray* pTokens=allArgs.Tokenize(" ");
+
+  Int_t nArgs =  pTokens ?pTokens->GetEntries() :0;
+
+  for (int i=0; i<nArgs; i++ ){
+    argument=((TObjString*)pTokens->At(i))->GetString();
+    if (argument.IsNull()){
+    }
+    else if (argument.CompareTo("-solenoidBz")==0 ){
+      if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; 
+      fSolenoidBz = ((TObjString*)pTokens->At(i))->GetString().Atof();
+      HLTInfo("Magnetic Field set to: %f", fSolenoidBz );
+    }
+    else {
+      HLTError("Unknown option %s ", argument.Data());
+      iResult=-EINVAL;
+    }
+  }
+  delete pTokens;
+
+  if (bMissingParam) {
+    HLTError("Specifier missed for %s", argument.Data());    
+    iResult=-EINVAL;
+  }
+
+  return iResult;
+}
+  
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.h
new file mode 100644 (file)
index 0000000..2651af1
--- /dev/null
@@ -0,0 +1,117 @@
+// ************************************************************************
+// 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 ALIHLTTPCCAGLOBALMERGERCOMPONENT_H
+#define ALIHLTTPCCAGLOBALMERGERCOMPONENT_H
+
+/** @file   AliHLTTPCCAGlobalMergerComponent.h
+    @author Matthias Kretz
+    @date
+    @brief  HLT TPC CA global merger component.
+*/
+
+#include "AliHLTProcessor.h"
+
+class AliHLTTPCCAMerger;
+class AliHLTTPCVertex;
+
+/**
+ * @class AliHLTTPCCAGlobalMergerComponent
+ * The TPC global merger component
+ *
+ * Interface to the global merger of the CA tracker for HLT.
+ */
+class AliHLTTPCCAGlobalMergerComponent : public AliHLTProcessor
+{
+  public:
+    /**
+     * Constructs a AliHLTTPCCAGlobalMergerComponent.
+     */
+    AliHLTTPCCAGlobalMergerComponent();
+
+    /**
+     * Destructs the AliHLTTPCCAGlobalMergerComponent
+     */
+    virtual ~AliHLTTPCCAGlobalMergerComponent() {};
+
+    // Public functions to implement AliHLTComponent's interface.
+    // These functions are required for the registration process
+
+    /**
+     * @copydoc AliHLTComponent::GetComponentID
+     */
+    const char *GetComponentID();
+
+    /**
+     * @copydoc AliHLTComponent::GetInputDataTypes
+     */
+    void GetInputDataTypes( AliHLTComponentDataTypeList &list );
+
+    /**
+     * @copydoc AliHLTComponent::GetOutputDataType
+     */
+    AliHLTComponentDataType GetOutputDataType();
+
+    /**
+     * @copydoc AliHLTComponent::GetOutputDataSize
+     */
+    virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+
+    /**
+     * @copydoc AliHLTComponent::Spawn
+     */
+    AliHLTComponent *Spawn();
+
+  protected:
+
+    // Protected functions to implement AliHLTComponent's interface.
+    // These functions provide initialization as well as the actual processing
+    // capabilities of the component.
+
+    /**
+     * @copydoc AliHLTComponent::DoInit
+     */
+    int DoInit( int argc, const char **argv );
+
+    /**
+     * @copydoc AliHLTComponent::DoDeinit
+     */
+    int DoDeinit();
+
+    /** reconfigure **/
+    Int_t Reconfigure(const char* cdbEntry, const char* chainId);
+
+    /**
+     * @copydoc @ref AliHLTProcessor::DoEvent
+     */
+    int DoEvent( const AliHLTComponentEventData &evtData, const AliHLTComponentBlockData *blocks,
+        AliHLTComponentTriggerData &trigData, AliHLTUInt8_t *outputPtr,
+        AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks );
+
+    using AliHLTProcessor::DoEvent;
+
+  private:
+    
+    static AliHLTTPCCAGlobalMergerComponent fgAliHLTTPCCAGlobalMergerComponent;
+
+    // disable copy
+    AliHLTTPCCAGlobalMergerComponent( const AliHLTTPCCAGlobalMergerComponent & );
+    AliHLTTPCCAGlobalMergerComponent &operator=( const AliHLTTPCCAGlobalMergerComponent & );
+
+    /** set configuration parameters **/
+    Int_t Configure( const char* arguments );
+
+    /** the global merger object */
+    AliHLTTPCCAMerger *fGlobalMerger; //!
+
+    Double_t fSolenoidBz;  // magnetic field  
+
+    ClassDef( AliHLTTPCCAGlobalMergerComponent, 0 )
+};
+
+#endif
index cf51209..eed8890 100644 (file)
 #include "AliHLTTPCCAParam.h"
 
 
+
+class AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo
+{
+  
+public:
+  
+  UInt_t  ISlice()    const { return fISlice;    }
+  UInt_t  IRow()      const { return fIRow;      }
+  UInt_t  IClu()      const { return fIClu;      }
+  UChar_t PackedAmp() const { return fPackedAmp; }
+  Float_t Y()         const { return fY;         }
+  Float_t Z()         const { return fZ;         }
+  Float_t Err2Y()     const { return fErr2Y;     }
+  Float_t Err2Z()     const { return fErr2Z;     }
+    
+  void SetISlice    ( UInt_t v  ) { fISlice    = v; }
+  void SetIRow      ( UInt_t v  ) { fIRow      = v; }
+  void SetIClu      ( UInt_t v  ) { fIClu      = v; }
+  void SetPackedAmp ( UChar_t v ) { fPackedAmp = v; }
+  void SetY         ( Float_t v ) { fY         = v; } 
+  void SetZ         ( Float_t v ) { fZ         = v; } 
+  void SetErr2Y     ( Float_t v ) { fErr2Y     = v; } 
+  void SetErr2Z     ( Float_t v ) { fErr2Z     = v; } 
+  
+private:
+  
+  UInt_t fISlice;            // slice number
+  UInt_t fIRow;              // row number
+  UInt_t fIClu;              // cluster number
+  UChar_t fPackedAmp; // packed cluster amplitude
+  Float_t fY;                // y position (slice coord.system)
+  Float_t fZ;                // z position (slice coord.system)
+  Float_t fErr2Y;            // Squared measurement error of y position
+  Float_t fErr2Z;            // Squared measurement error of z position
+};
+
+
+class AliHLTTPCCAMerger::AliHLTTPCCASliceTrackInfo
+{
+
+public:
+
+  const AliHLTTPCCATrackParam &InnerParam() const { return fInnerParam;      }
+  const AliHLTTPCCATrackParam &OuterParam() const { return fOuterParam;      }  
+  Float_t InnerAlpha()                      const { return fInnerAlpha;      }
+  Float_t OuterAlpha()                      const { return fOuterAlpha;      }
+  Int_t   NClusters()                       const { return fNClusters;       }
+  Int_t   FirstClusterRef()                 const { return fFirstClusterRef; }
+  Int_t   PrevNeighbour()                   const { return fPrevNeighbour;   }
+  Int_t   NextNeighbour()                   const { return fNextNeighbour;   }
+  Bool_t  Used()                            const { return fUsed;            }
+  
+  void SetInnerParam( const AliHLTTPCCATrackParam &v ) { fInnerParam = v;      }
+  void SetOuterParam( const AliHLTTPCCATrackParam &v ) { fOuterParam = v;      }
+  void SetInnerAlpha( Float_t v )                      { fInnerAlpha = v;      }
+  void SetOuterAlpha( Float_t v )                      { fOuterAlpha = v;      }
+  void SetNClusters ( Int_t v )                        { fNClusters = v;       }
+  void SetFirstClusterRef( Int_t v )                   { fFirstClusterRef = v; }
+  void SetPrevNeighbour( Int_t v )                     { fPrevNeighbour = v;   }
+  void SetNextNeighbour( Int_t v )                     { fNextNeighbour = v;   }
+  void SetUsed( Bool_t v )                             { fUsed = v;            }
+
+private:
+
+  AliHLTTPCCATrackParam fInnerParam; // inner parameters
+  AliHLTTPCCATrackParam fOuterParam; // outer parameters
+  Float_t fInnerAlpha;               // alpha angle for inner parameters
+  Float_t fOuterAlpha;               // alpha angle for outer parameters
+  Int_t fNClusters;                  // N clusters
+  Int_t fFirstClusterRef;  // index of the first track cluster in the global cluster array
+  Int_t fPrevNeighbour;    // neighbour in the previous slise
+  Int_t fNextNeighbour;    // neighbour in the next slise
+  Bool_t fUsed;            // is the slice track already merged
+
+};
+
+
+class AliHLTTPCCAMerger::AliHLTTPCCABorderTrack
+{
+
+public:
+  const AliHLTTPCCATrackParam &Param() const { return fParam;     }
+  Int_t   TrackID()                    const { return fTrackID;   }
+  Int_t   NClusters()                  const { return fNClusters; }
+  Int_t   IRow()                       const { return fIRow;      }
+  Float_t X()                          const { return fX;         }
+  Bool_t  OK()                         const { return fOK;        }
+  
+  void SetParam     ( const AliHLTTPCCATrackParam &v ) { fParam     = v; }
+  void SetTrackID   ( Int_t v )                        { fTrackID   = v; }
+  void SetNClusters ( Int_t v )                        { fNClusters = v; }
+  void SetIRow      ( Int_t v )                        { fIRow      = v; }
+  void SetX         ( Float_t v )                      { fX         = v; }
+  void SetOK        ( Bool_t v )                       { fOK        = v; }
+
+private:
+
+  AliHLTTPCCATrackParam fParam;  // track parameters at the border
+  Int_t   fTrackID;              // track index
+  Int_t   fNClusters;            // n clusters
+  Int_t   fIRow;                 // row number of the closest cluster
+  Float_t fX;                    // X coordinate of the closest cluster
+  Bool_t  fOK;                   // is the track rotated and extrapolated correctly
+
+};
+
+
+
 AliHLTTPCCAMerger::AliHLTTPCCAMerger()
   :
   fSliceParam(),
-  fkSlices(0),
   fOutput(0),  
   fTrackInfos(0),
   fMaxTrackInfos(0),
@@ -48,9 +156,10 @@ AliHLTTPCCAMerger::AliHLTTPCCAMerger()
   fMaxClusterInfos(0)
 {
   //* constructor
+  Clear();
 }
 
-
+/*
 AliHLTTPCCAMerger::AliHLTTPCCAMerger(const AliHLTTPCCAMerger&)
   : 
   fSliceParam(),
@@ -61,14 +170,13 @@ AliHLTTPCCAMerger::AliHLTTPCCAMerger(const AliHLTTPCCAMerger&)
   fClusterInfos(0),
   fMaxClusterInfos(0)
 {
-  //* dummy
 }
 
 const AliHLTTPCCAMerger &AliHLTTPCCAMerger::operator=(const AliHLTTPCCAMerger&) const
 {
-  //* dummy
   return *this;
 }
+*/
 
 AliHLTTPCCAMerger::~AliHLTTPCCAMerger()
 {
@@ -78,12 +186,23 @@ AliHLTTPCCAMerger::~AliHLTTPCCAMerger()
   if( fOutput ) delete[] ((char*)(fOutput));
 }
 
+void AliHLTTPCCAMerger::Clear()
+{
+  for ( int i = 0; i < fgkNSlices; ++i ) {
+    fkSlices[i] = 0;
+  }
+}
+
+
+void AliHLTTPCCAMerger::SetSliceData( int index, const AliHLTTPCCASliceOutput *SliceData )
+{
+  fkSlices[index] = SliceData;
+}
 
-void AliHLTTPCCAMerger::Reconstruct( const AliHLTTPCCASliceOutput **SliceOutput )
+void AliHLTTPCCAMerger::Reconstruct()
 {
   //* main merging routine
 
-  fkSlices = SliceOutput;
   UnpackSlices();
   Merging();
 }
@@ -97,6 +216,7 @@ void AliHLTTPCCAMerger::UnpackSlices()
   Int_t nTracksTotal=0;
   Int_t nTrackClustersTotal=0;
   for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
+    if( !fkSlices[iSlice] ) continue;
     nTracksTotal+=fkSlices[iSlice]->NTracks();
     nTrackClustersTotal+=fkSlices[iSlice]->NTrackClusters();    
   }
@@ -127,9 +247,12 @@ void AliHLTTPCCAMerger::UnpackSlices()
 
   for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
 
-    const AliHLTTPCCASliceOutput &slice = *(fkSlices[iSlice]);
     fSliceTrackInfoStart[ iSlice ] = nTracksCurrent;
     fSliceNTrackInfos[ iSlice ] = 0;
+    if( !fkSlices[iSlice] ) continue;
+
+    const AliHLTTPCCASliceOutput &slice = *(fkSlices[iSlice]);
 
     for( Int_t itr=0; itr<slice.NTracks(); itr++ ){
   
@@ -138,9 +261,9 @@ void AliHLTTPCCAMerger::UnpackSlices()
       Int_t nCluNew = 0;
       
       for( Int_t iTrClu=0; iTrClu<sTrack.NClusters(); iTrClu++ ){
-       
+
        // unpack cluster information
-       
+
        AliHLTTPCCAClusterInfo &clu = fClusterInfos[nClustersCurrent + nCluNew];
        Int_t ic = sTrack.FirstClusterRef() + iTrClu;
 
@@ -153,6 +276,7 @@ void AliHLTTPCCAMerger::UnpackSlices()
        clu.SetZ( yz.y );
 
        if( !t0.TransportToX( fSliceParam.RowX( clu.IRow() ), .999 ) ) continue;
+       
        Float_t err2Y, err2Z;
        fSliceParam.GetClusterErrors2( clu.IRow(), clu.Z(), t0.SinPhi(), t0.CosPhi(), t0.DzDs(), err2Y, err2Z );
        
@@ -160,6 +284,7 @@ void AliHLTTPCCAMerger::UnpackSlices()
        clu.SetErr2Z( err2Z );
        nCluNew++ ;
       }
+
       if( nCluNew<.8*sTrack.NClusters() ) continue;
       
       // refit the track 
@@ -174,24 +299,26 @@ void AliHLTTPCCAMerger::UnpackSlices()
       Float_t endAlpha = startAlpha;
       
       if( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits, nHits, 0 ) ) continue;
+      
       startPoint = endPoint;
       startAlpha = endAlpha;
       if( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits, nHits, 1 ) ) continue;
+      
       if( nHits<.8*sTrack.NClusters() ) continue;
 
       // store the track
       
       AliHLTTPCCASliceTrackInfo &track = fTrackInfos[nTracksCurrent];      
-      track.fInnerParam = startPoint;
-      track.fInnerAlpha = startAlpha;
-      track.fOuterParam = endPoint;
-      track.fOuterAlpha = endAlpha;
-      track.fFirstClusterRef = nClustersCurrent;
-      track.fNClusters = nHits;
-      track.fPrevNeighbour = -1;
-      track.fNextNeighbour = -1;
-      track.fUsed = 0;
+
+      track.SetInnerParam( startPoint );
+      track.SetInnerAlpha( startAlpha );
+      track.SetOuterParam( endPoint );
+      track.SetOuterAlpha( endAlpha );
+      track.SetFirstClusterRef( nClustersCurrent );
+      track.SetNClusters( nHits );
+      track.SetPrevNeighbour( -1 );
+      track.SetNextNeighbour( -1 );
+      track.SetUsed( 0 );
       
       for( Int_t i=0; i<nHits; i++ ) 
        fClusterInfos[nClustersCurrent + i] = fClusterInfos[hits[i]];
@@ -221,8 +348,10 @@ Bool_t AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha,
   Int_t nHitsNew = 0;
 
   for( Int_t ihit=0; ihit<NTrackHits; ihit++){
+    
     Int_t jhit = dir ?(NTrackHits-1-ihit) :ihit;
     AliHLTTPCCAClusterInfo &h = fClusterInfos[hits[jhit]];
+
     Int_t iSlice = h.ISlice();
 
     Float_t sliceAlpha =  fSliceParam.Alpha( iSlice );
@@ -235,7 +364,7 @@ Bool_t AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha,
     Float_t x = fSliceParam.RowX( h.IRow() );
     
     if( !t.TransportToXWithMaterial( x, t0, fitPar ) ) continue;
-
+    
     if( first ){
       t.SetCov( 0, 10 );
       t.SetCov( 1,  0 );
@@ -258,12 +387,12 @@ Bool_t AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha,
     }
   
     if( !t.Filter2NoCos( h.Y(), h.Z(), h.Err2Y(), h.Err2Z() ) ) continue;                  
+    
     first = 0;
 
     hitsNew[nHitsNew++] = hits[jhit];
   }
   
-
   if( CAMath::Abs(t.Kappa())<1.e-8 ) t.SetKappa( 1.e-8 );
   
   Bool_t ok=1;
@@ -342,10 +471,10 @@ void AliHLTTPCCAMerger::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLTTPC
 
   for (Int_t itr=0; itr<fSliceNTrackInfos[iSlice]; itr++) {
 
-    AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice] + itr ];
+    const AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice] + itr ];
 
-    AliHLTTPCCATrackParam t0 = track.fInnerParam;
-    AliHLTTPCCATrackParam t1 = track.fOuterParam;
+    AliHLTTPCCATrackParam t0 = track.InnerParam();
+    AliHLTTPCCATrackParam t1 = track.OuterParam();
 
     const Float_t maxSin = CAMath::Sin(60./180.*CAMath::Pi());
 
@@ -362,23 +491,27 @@ void AliHLTTPCCAMerger::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLTTPC
 
     if( do0 ){
       AliHLTTPCCABorderTrack &b = B[nB];
-      b.fOK = 1;
-      b.fITrack = itr;
-      b.fNHits = track.fNClusters;
-      b.fIRow = fClusterInfos[ track.fFirstClusterRef + 0 ].IRow();
-      b.fParam = t0;
-      b.fX = t0.GetX();
-      if( b.fParam.TransportToX( x0, maxSin ) ) nB++;
+      b.SetX( t0.GetX() );
+      if( t0.TransportToX( x0, maxSin ) ){
+       b.SetOK( 1 );
+       b.SetTrackID( itr );
+       b.SetNClusters( track.NClusters() );
+       b.SetIRow( fClusterInfos[ track.FirstClusterRef() + 0 ].IRow() );
+       b.SetParam( t0 );
+       nB++;
+      }
     }
     if( do1 ){
       AliHLTTPCCABorderTrack &b = B[nB];
-      b.fOK = 1;
-      b.fITrack = itr;
-      b.fNHits = track.fNClusters;
-      b.fIRow = fClusterInfos[ track.fFirstClusterRef + track.fNClusters-1 ].IRow();
-      b.fParam = t1;    
-      b.fX = t0.GetX();
-      if( b.fParam.TransportToX( x0, maxSin ) ) nB++;
+      b.SetX( t1.GetX() );
+      if( t1.TransportToX( x0, maxSin ) ){
+       b.SetOK( 1 );
+       b.SetTrackID( itr );
+       b.SetNClusters( track.NClusters() );
+       b.SetIRow( fClusterInfos[ track.FirstClusterRef() + track.NClusters()-1 ].IRow() );
+       b.SetParam( t1 );  
+       nB++;
+      }
     }
     if( do0 || do1 ) statOK++;
     statAll++;
@@ -408,22 +541,22 @@ void AliHLTTPCCAMerger::SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack
 
   for (Int_t i1=0; i1<N1; i1++) {      
     AliHLTTPCCABorderTrack &b1 = B1[i1];
-    if( !b1.fOK ) continue;
-    if( b1.fNHits < minNPartHits ) continue;
-    AliHLTTPCCATrackParam &t1 = b1.fParam;
+    if( !b1.OK() ) continue;
+    if( b1.NClusters() < minNPartHits ) continue;
+    const AliHLTTPCCATrackParam &t1 = b1.Param();
     Int_t iBest2 = -1;
     Int_t lBest2 = 0;
     Int_t start2 = (iSlice1!=iSlice2) ?0 :i1+1;
     for (Int_t i2=start2; i2<N2; i2++) {
       AliHLTTPCCABorderTrack &b2 = B2[i2];
-      if( !b2.fOK ) continue;
-      if( b2.fNHits < minNPartHits ) continue;
-      if( b2.fNHits < lBest2 ) continue;
-      if( b1.fNHits + b2.fNHits < minNTotalHits ) continue;
+      if( !b2.OK() ) continue;
+      if( b2.NClusters() < minNPartHits ) continue;
+      if( b2.NClusters() < lBest2 ) continue;
+      if( b1.NClusters() + b2.NClusters() < minNTotalHits ) continue;
 
       //if( TMath::Abs(b1.fX - b2.fX)>maxDX ) continue;
 
-      AliHLTTPCCATrackParam &t2 = b2.fParam;
+      const AliHLTTPCCATrackParam &t2 = b2.Param();
 
       Float_t c= t2.CosPhi()*t1.CosPhi()>=0 ?1 :-1;
       Float_t dk = t2.Kappa() - c*t1.Kappa(); 
@@ -442,34 +575,33 @@ void AliHLTTPCCAMerger::SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack
             
       if( chi2zt>factor2zt ) continue;
       
-      lBest2 = b2.fNHits;
-      iBest2 = b2.fITrack;
+      lBest2 = b2.NClusters();
+      iBest2 = b2.TrackID();
     }
       
     if( iBest2 <0 ) continue;
 
-    AliHLTTPCCASliceTrackInfo &newTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1]+b1.fITrack ];
-    
+    AliHLTTPCCASliceTrackInfo &newTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1]+b1.TrackID() ];    
     AliHLTTPCCASliceTrackInfo &newTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2]+iBest2 ];
 
-    Int_t old1 = newTrack2.fPrevNeighbour;
+    Int_t old1 = newTrack2.PrevNeighbour();
   
     if( old1 >= 0 ){
       AliHLTTPCCASliceTrackInfo &oldTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1]+old1];
-      if( oldTrack1.fNClusters  < newTrack1.fNClusters ){
-       newTrack2.fPrevNeighbour = -1;
-       oldTrack1.fNextNeighbour = -1;  
+      if( oldTrack1.NClusters()  < newTrack1.NClusters() ){
+       newTrack2.SetPrevNeighbour(-1);
+       oldTrack1.SetNextNeighbour(-1); 
       } else continue;
     }
-    Int_t old2 = newTrack1.fNextNeighbour;
+    Int_t old2 = newTrack1.NextNeighbour();
     if( old2 >= 0 ){
       AliHLTTPCCASliceTrackInfo &oldTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2]+old2];
-      if( oldTrack2.fNClusters < newTrack2.fNClusters ){
-       oldTrack2.fPrevNeighbour = -1;
+      if( oldTrack2.NClusters() < newTrack2.NClusters() ){
+       oldTrack2.SetPrevNeighbour(-1);
       } else continue;
     }
-    newTrack1.fNextNeighbour = iBest2; 
-    newTrack2.fPrevNeighbour = b1.fITrack;     
+    newTrack1.SetNextNeighbour(iBest2); 
+    newTrack2.SetPrevNeighbour(b1.TrackID());  
   }  
   
 }
@@ -479,6 +611,10 @@ void AliHLTTPCCAMerger::Merging()
 {
   //* track merging between slices
 
+  fOutput->SetNTracks( 0 );
+  fOutput->SetNTrackClusters( 0 );
+  fOutput->SetPointers();
+
 
   // for each slice set number of the next neighbouring slice
      
@@ -509,7 +645,7 @@ void AliHLTTPCCAMerger::Merging()
     AliHLTTPCCASliceTrackInfo *tmpT = new AliHLTTPCCASliceTrackInfo[maxNSliceTracks];
     AliHLTTPCCAClusterInfo *tmpH = new AliHLTTPCCAClusterInfo[fMaxClusterInfos];
 
-    for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){         
+    for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
 
       Int_t nBord=0;
       MakeBorderTracks( iSlice, 4, bord, nBord );   
@@ -519,36 +655,36 @@ void AliHLTTPCCAMerger::Merging()
       Int_t sliceFirstClusterRef = 0;
       for( Int_t itr=0; itr<fSliceNTrackInfos[iSlice]; itr++ ){
        AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice]+itr];
-       if( itr==0 ) sliceFirstClusterRef = track.fFirstClusterRef;
-       track.fPrevNeighbour = -1;
-       if( track.fNextNeighbour == -2 ){
-         track.fNextNeighbour = -1;
+       if( itr==0 ) sliceFirstClusterRef = track.FirstClusterRef();
+       track.SetPrevNeighbour( -1 );
+       if( track.NextNeighbour() == -2 ){
+         track.SetNextNeighbour( -1 );
          continue;
        }
        AliHLTTPCCASliceTrackInfo &trackNew = tmpT[nTr];
        trackNew = track;
-       trackNew.fFirstClusterRef = sliceFirstClusterRef + nH;
+       trackNew.SetFirstClusterRef( sliceFirstClusterRef + nH);
 
-       for( Int_t ih=0; ih<track.fNClusters; ih++ ) tmpH[nH+ih] = fClusterInfos[track.fFirstClusterRef+ih];
+       for( Int_t ih=0; ih<track.NClusters(); ih++ ) tmpH[nH+ih] = fClusterInfos[track.FirstClusterRef()+ih];
        nTr++;
-       nH+=track.fNClusters;
+       nH+=track.NClusters();
 
-       int jtr =  track.fNextNeighbour;
+       int jtr =  track.NextNeighbour();
 
        if( jtr<0 ) continue;
        AliHLTTPCCASliceTrackInfo &neighTrack = fTrackInfos[ fSliceTrackInfoStart[iSlice]+jtr];
        
-       track.fNextNeighbour = -1;
-       neighTrack.fNextNeighbour = -2;
+       track.SetNextNeighbour(-1);
+       neighTrack.SetNextNeighbour(-2);
 
-       for( Int_t ih=0; ih<neighTrack.fNClusters; ih++ ) 
-         tmpH[nH+ih] = fClusterInfos[neighTrack.fFirstClusterRef+ih];
+       for( Int_t ih=0; ih<neighTrack.NClusters(); ih++ ) 
+         tmpH[nH+ih] = fClusterInfos[neighTrack.FirstClusterRef()+ih];
 
-       trackNew.fNClusters += neighTrack.fNClusters;
-       trackNew.fNextNeighbour = -1;
-       nH+=neighTrack.fNClusters;
-       if( neighTrack.fInnerParam.X() < track.fInnerParam.X() ) trackNew.fInnerParam = neighTrack.fInnerParam;
-       if( neighTrack.fOuterParam.X() > track.fOuterParam.X() ) trackNew.fOuterParam = neighTrack.fOuterParam;
+       trackNew.SetNClusters( trackNew.NClusters() + neighTrack.NClusters() );
+       trackNew.SetNextNeighbour( -1 );
+       nH+=neighTrack.NClusters();
+       if( neighTrack.InnerParam().X() < track.InnerParam().X() ) trackNew.SetInnerParam( neighTrack.InnerParam());
+       if( neighTrack.OuterParam().X() > track.OuterParam().X() ) trackNew.SetOuterParam( neighTrack.OuterParam());
       }
       
       fSliceNTrackInfos[iSlice] = nTr;
@@ -609,11 +745,11 @@ void AliHLTTPCCAMerger::Merging()
 
       AliHLTTPCCASliceTrackInfo &track = fTrackInfos[fSliceTrackInfoStart[iSlice]+itr];
 
-      if( track.fUsed ) continue;
-      if( track.fPrevNeighbour>=0 ) continue;
+      if( track.Used() ) continue;
+      if( track.PrevNeighbour()>=0 ) continue;
 
-      AliHLTTPCCATrackParam startPoint = track.fInnerParam, endPoint = track.fOuterParam;
-      Float_t startAlpha = track.fInnerAlpha, endAlpha = track.fOuterAlpha;      
+      AliHLTTPCCATrackParam startPoint = track.InnerParam(), endPoint = track.OuterParam();
+      Float_t startAlpha = track.InnerAlpha(), endAlpha = track.OuterAlpha();      
 
       Int_t hits[2000];
       Int_t firstHit = 1000;
@@ -622,54 +758,54 @@ void AliHLTTPCCAMerger::Merging()
       Int_t jtr = itr;
 
       {
-       track.fUsed = 1;
-       for( Int_t jhit=0; jhit<track.fNClusters; jhit++){
-         Int_t id = track.fFirstClusterRef + jhit;
+       track.SetUsed( 1 );
+       for( Int_t jhit=0; jhit<track.NClusters(); jhit++){
+         Int_t id = track.FirstClusterRef() + jhit;
          hits[firstHit+jhit] = id;
        }
-       nHits=track.fNClusters;
-       jtr = track.fNextNeighbour;
+       nHits=track.NClusters();
+       jtr = track.NextNeighbour();
        jSlice = nextSlice[iSlice];                     
       }
 
       while( jtr >=0 ){
        AliHLTTPCCASliceTrackInfo &segment = fTrackInfos[fSliceTrackInfoStart[jSlice]+jtr];
-       if( segment.fUsed ) break;
-       segment.fUsed = 1;
+       if( segment.Used() ) break;
+       segment.SetUsed( 1 );
        Bool_t dir = 0;
        Int_t startHit = firstHit+ nHits;
-       Float_t d00 = startPoint.GetDistXZ2(segment.fInnerParam );
-       Float_t d01 = startPoint.GetDistXZ2(segment.fOuterParam );
-       Float_t d10 = endPoint.GetDistXZ2(segment.fInnerParam);
-       Float_t d11 = endPoint.GetDistXZ2(segment.fOuterParam );
+       Float_t d00 = startPoint.GetDistXZ2(segment.InnerParam() );
+       Float_t d01 = startPoint.GetDistXZ2(segment.OuterParam() );
+       Float_t d10 = endPoint.GetDistXZ2(segment.InnerParam() );
+       Float_t d11 = endPoint.GetDistXZ2(segment.OuterParam() );
        if( d00<=d01 && d00<=d10 && d00<=d11 ){
-         startPoint = segment.fOuterParam;
-         startAlpha = segment.fOuterAlpha;
+         startPoint = segment.OuterParam();
+         startAlpha = segment.OuterAlpha();
          dir = 1;
-         firstHit -= segment.fNClusters;
+         firstHit -= segment.NClusters();
          startHit = firstHit;
        }else if( d01<=d10 && d01<=d11 ){
-         startPoint = segment.fInnerParam;
-         startAlpha = segment.fInnerAlpha;
+         startPoint = segment.InnerParam();
+         startAlpha = segment.InnerAlpha();
          dir = 0;
-         firstHit -= segment.fNClusters;
+         firstHit -= segment.NClusters();
          startHit = firstHit;
        }else if( d10<=d11 ){
-         endPoint = segment.fOuterParam;
-         endAlpha = segment.fOuterAlpha;
+         endPoint = segment.OuterParam();
+         endAlpha = segment.OuterAlpha();
          dir = 0;
        }else{
-         endPoint = segment.fInnerParam;
-         endAlpha = segment.fInnerAlpha;
+         endPoint = segment.InnerParam();
+         endAlpha = segment.InnerAlpha();
          dir = 1;
        }
        
-       for( Int_t jhit=0; jhit<segment.fNClusters; jhit++){
-         Int_t id = segment.fFirstClusterRef + jhit;
-         hits[startHit+(dir ?(segment.fNClusters-1-jhit) :jhit)] = id;
+       for( Int_t jhit=0; jhit<segment.NClusters(); jhit++){
+         Int_t id = segment.FirstClusterRef() + jhit;
+         hits[startHit+(dir ?(segment.NClusters()-1-jhit) :jhit)] = id;
        }
-       nHits+=segment.fNClusters;
-       jtr = segment.fNextNeighbour;
+       nHits+=segment.NClusters();
+       jtr = segment.NextNeighbour();
        jSlice = nextSlice[jSlice];                     
       }
 
index d72da55..ca1c379 100644 (file)
 
 #include "AliHLTTPCCADef.h"
 #include "AliHLTTPCCAParam.h"
+#include "AliHLTTPCCATrackParam.h"
 
 #if !defined(HLTCA_GPUCODE)
 #include <iostream>
 #endif
 
-class AliHLTTPCCATrackParam;
 class AliHLTTPCCASliceTrack;
 class AliHLTTPCCASliceOutput;
 class AliHLTTPCCAMergedTrack;
@@ -32,76 +32,25 @@ class AliHLTTPCCAMerger
 public:
 
   AliHLTTPCCAMerger();
-  AliHLTTPCCAMerger(const AliHLTTPCCAMerger&);
-  const AliHLTTPCCAMerger &operator=(const AliHLTTPCCAMerger&) const;
   ~AliHLTTPCCAMerger();
 
   void SetSliceParam( const AliHLTTPCCAParam &v ){ fSliceParam = v; }
 
-  void Reconstruct( const AliHLTTPCCASliceOutput **Slices );
+  void Clear();
+  void SetSliceData( int index, const AliHLTTPCCASliceOutput *SliceData );
+  void Reconstruct();
 
   const AliHLTTPCCAMergerOutput * Output() const { return fOutput; }
   
  private:
-  
-  class AliHLTTPCCAClusterInfo{
-
-  public:
-    
-    UInt_t  ISlice()    const { return fISlice;    }
-    UInt_t  IRow()      const { return fIRow;      }
-    UInt_t  IClu()      const { return fIClu;      }
-    UChar_t PackedAmp() const { return fPackedAmp; }
-    Float_t Y()         const { return fY;         }
-    Float_t Z()         const { return fZ;         }
-    Float_t Err2Y()     const { return fErr2Y;     }
-    Float_t Err2Z()     const { return fErr2Z;     }
-    
-    void SetISlice    ( UInt_t v  ) { fISlice    = v; }
-    void SetIRow      ( UInt_t v  ) { fIRow      = v; }
-    void SetIClu      ( UInt_t v  ) { fIClu      = v; }
-    void SetPackedAmp ( UChar_t v ) { fPackedAmp = v; }
-    void SetY         ( Float_t v ) { fY         = v; } 
-    void SetZ         ( Float_t v ) { fZ         = v; } 
-    void SetErr2Y     ( Float_t v ) { fErr2Y     = v; } 
-    void SetErr2Z     ( Float_t v ) { fErr2Z     = v; } 
-
-  private:
-
-    UInt_t fISlice;            // slice number
-    UInt_t fIRow;              // row number
-    UInt_t fIClu;              // cluster number
-    UChar_t fPackedAmp; // packed cluster amplitude
-    Float_t fY;                // y position (slice coord.system)
-    Float_t fZ;                // z position (slice coord.system)
-    Float_t fErr2Y;            // Squared measurement error of y position
-    Float_t fErr2Z;            // Squared measurement error of z position
-  };
 
-  struct AliHLTTPCCASliceTrackInfo{
-
-    AliHLTTPCCATrackParam fInnerParam; // inner parameters
-    AliHLTTPCCATrackParam fOuterParam; // outer parameters
-    Float_t fInnerAlpha;                 // alpha angle for inner parameters
-    Float_t fOuterAlpha;                 // alpha angle for outer parameters
-    Int_t fNClusters;                  // N clusters
-    Int_t fFirstClusterRef; //index of the first track cluster in the global cluster array
-    Int_t fPrevNeighbour; // neighbour in the previous slise
-    Int_t fNextNeighbour; // neighbour in the next slise
-    Bool_t fUsed;         // is the slice track already merged
-  };
-
-  struct AliHLTTPCCABorderTrack{
-
-    AliHLTTPCCABorderTrack(): fParam(), fITrack(0), fIRow(0), fNHits(0), fX(0), fOK(0){};
-    AliHLTTPCCATrackParam fParam; // track parameters at the border
-    Int_t fITrack;               // track index
-    Int_t fIRow;                 // row number of the closest cluster
-    Int_t fNHits;                // n hits
-    Float_t fX;                  // X coordinate of the closest cluster
-    Bool_t fOK;                  // is the trak rotated and extrapolated correctly
-  };
+  AliHLTTPCCAMerger(const AliHLTTPCCAMerger&);
+  const AliHLTTPCCAMerger &operator=(const AliHLTTPCCAMerger&) const;
   
+  class AliHLTTPCCAClusterInfo;
+  class AliHLTTPCCASliceTrackInfo;
+  class AliHLTTPCCABorderTrack;
+
   void MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLTTPCCABorderTrack B[], Int_t &nB);
   void SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack B1[], Int_t N1,
                          Int_t iSlice2, AliHLTTPCCABorderTrack B2[], Int_t N2 );
@@ -117,7 +66,7 @@ public:
   
   static const Int_t fgkNSlices = 36;       //* N slices 
   AliHLTTPCCAParam fSliceParam;           //* slice parameters (geometry, calibr, etc.)
-  const AliHLTTPCCASliceOutput **fkSlices;       //* array of input slice tracks  
+  const AliHLTTPCCASliceOutput *fkSlices[fgkNSlices]; //* array of input slice tracks
   AliHLTTPCCAMergerOutput *fOutput;       //* array of output merged tracks  
   AliHLTTPCCASliceTrackInfo *fTrackInfos; //* additional information for slice tracks
   Int_t fMaxTrackInfos;                   //* booked size of fTrackInfos array
index 67556fc..eaad3e6 100644 (file)
@@ -93,12 +93,14 @@ GPUg() void AliHLTTPCCAProcess1( Int_t nBlocks, Int_t nThreads, AliHLTTPCCATrack
 {
   for( Int_t iB=0; iB<nBlocks; iB++ ){
     typename TProcess::AliHLTTPCCASharedMemory smem;
-    typename TProcess::AliHLTTPCCAThreadMemory rMem[nThreads];
-    AliHLTTPCCATrackParam tParam[nThreads];
+    typename TProcess::AliHLTTPCCAThreadMemory *rMem = new typename TProcess::AliHLTTPCCAThreadMemory[nThreads];
+    AliHLTTPCCATrackParam *tParam = new AliHLTTPCCATrackParam[ nThreads ];
     for( Int_t iS=0; iS<=TProcess::NThreadSyncPoints(); iS++){
       for( Int_t iT=0; iT<nThreads; iT++ )
        TProcess::Thread( nBlocks, nThreads, iB, iT, iS, smem, rMem[iT], tracker, tParam[iT]  );
     }
+    delete[] rMem;
+    delete[] tParam;
   }
 }
 
index 903500d..0e356b6 100644 (file)
@@ -12,7 +12,7 @@
 
 #include "AliHLTTPCCADef.h"
 
-class AliHLTTPCCASliceTrack;
+#include "AliHLTTPCCASliceTrack.h"
 
 /**
  * @class AliHLTTPCCASliceOutput
@@ -51,7 +51,12 @@ class AliHLTTPCCASliceOutput
   GPUhd() void SetClusterUnpackedYZ( Int_t i, float2 v ) {  fClusterUnpackedYZ[i] = v; }
 
  private:
-  
+
+  AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& )
+    : fNTracks(0),fNTrackClusters(0),fTracks(0),fClusterIDrc(0), fClusterPackedYZ(0),fClusterUnpackedYZ(0),fClusterPackedAmp(0){}
+
+  const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
+
   Int_t fNTracks;                 // number of reconstructed tracks
   Int_t fNTrackClusters;          // total number of track clusters
   AliHLTTPCCASliceTrack *fTracks; // pointer to reconstructed tracks
index 0f857fd..05ae8b9 100644 (file)
@@ -438,7 +438,8 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
     row.SetGrid( grid );
   }
 
-  AliHLTTPCCAHit ffHits[fNHitsTotal];
+  AliHLTTPCCAHit *ffHits = new AliHLTTPCCAHit[ fNHitsTotal ];
 
   Int_t rowDataOffset = 0;
 
@@ -446,10 +447,10 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
 
     AliHLTTPCCARow &row = fRows[iRow];
     const AliHLTTPCCAGrid &grid = row.Grid();
-
-    Int_t c[grid.N()+3+10];
-    Int_t bins[row.NHits()];
-    Int_t filled[ row.Grid().N() +3+10 ];
+    
+    Int_t *c = new Int_t [grid.N() + 3 + 10];
+    Int_t *bins = new Int_t [row.NHits()];
+    Int_t *filled = new Int_t [row.Grid().N() + 3 + 10 ];
 
     for( UInt_t bin=0; bin<row.Grid().N()+3; bin++ ) filled[bin] = 0;  
 
@@ -532,8 +533,12 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
       //cout<<iRow<<", "<<row.fNHits<<"= "<<size*16<<"b: "<<row.fFullOffset<<" "<<row.fFullSize<<" "<<row.fFullGridOffset<<" "<<row.fFullLinkOffset<<std::endl;
 
       rowDataOffset+=size;
-    }  
-  } 
+    }
+    if( c ) delete[] c;
+    if( bins ) delete[] bins;
+    if( filled ) delete[] filled;
+  }
+  delete[] ffHits;
 }
 
 
@@ -967,9 +972,10 @@ GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
     out<<fRows[iRow].FirstHit()<<" "<<fRows[iRow].NHits()<<std::endl;
   } 
   out<<fNHitsTotal<<std::endl;
+  
+  Float_t *y = new Float_t [fNHitsTotal];
+  Float_t *z = new Float_t [fNHitsTotal];
 
-  Float_t y[fNHitsTotal], z[fNHitsTotal];
   for( Int_t iRow=0; iRow<fParam.NRows(); iRow++){
     AliHLTTPCCARow &row = fRows[iRow];
     Float_t y0 = row.Grid().YMin();
@@ -989,23 +995,33 @@ GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
   for( Int_t ih=0; ih<fNHitsTotal; ih++ ){
     out<<y[ih]<<" "<<z[ih]<<std::endl;
   }
+  delete[] y;
+  delete[] z;
 }
 
 GPUh() void AliHLTTPCCATracker::ReadEvent( std::istream &in ) 
 {
   //* Read event from file 
+  
+  Int_t *rowFirstHit = new Int_t[ Param().NRows()];
+  Int_t *rowNHits = new Int_t [ Param().NRows()];
 
-  Int_t rowFirstHit[Param().NRows()], rowNHits[Param().NRows()];  
   for( Int_t iRow=0; iRow<Param().NRows(); iRow++ ){
     in>>rowFirstHit[iRow]>>rowNHits[iRow];
   }
   Int_t nHits;
   in >> nHits;
-  Float_t y[nHits], z[nHits];
+
+  Float_t *y = new Float_t[ nHits ];
+  Float_t *z = new Float_t[ nHits ];
   for( Int_t ih=0; ih<nHits; ih++ ){
     in>>y[ih]>>z[ih];
   }
   ReadEvent( rowFirstHit, rowNHits, y, z, nHits );
+  if( rowFirstHit ) delete[] rowFirstHit;
+  if( rowNHits )delete[] rowNHits;
+  if( y )delete[] y;
+  if( z )delete[] z;
 } 
 
 GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out ) 
index b70a1cf..e18b93f 100644 (file)
@@ -49,17 +49,21 @@ using namespace std;
 #include "AliCDBManager.h"
 #include "TObjString.h"
 #include "TObjArray.h"
+#include "AliHLTTPCCASliceOutput.h"
+
+const AliHLTComponentDataType AliHLTTPCCADefinitions::fgkTrackletsDataType = AliHLTComponentDataTypeInitializer( "CATRACKL", kAliHLTDataOriginTPC );
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTTPCCATrackerComponent)
 
 /** global object for registration 
  * Matthias 2009-01-13 temporarily using the global object approach again.
  * CA cade had to be disabled because of various compilation problems, so
  * the global object approach fits better for the moment.
  */
+  
 AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
 
-/** ROOT macro for the implementation of ROOT specific class methods */
-ClassImp(AliHLTTPCCATrackerComponent)
-
 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
   :
   fTracker(NULL),
@@ -68,7 +72,8 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
   fClusterZCut(500.),
   fFullTime(0),
   fRecoTime(0),
-  fNEvents(0)
+  fNEvents(0),
+  fNewOutputType(0)
 {
   // see header file for class documentation
   // or
@@ -86,7 +91,8 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent(const AliHLTTPCCATracke
   fClusterZCut(500.),
   fFullTime(0),
   fRecoTime(0),
-  fNEvents(0)
+  fNEvents(0),
+  fNewOutputType(0)
 {
   // see header file for class documentation
   HLTFatal("copy constructor untested");
@@ -126,7 +132,8 @@ void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataT
 AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType() 
 {
   // see header file for class documentation
-  return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
+  if( fNewOutputType ) return AliHLTTPCCADefinitions::fgkTrackletsDataType;
+  else return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
 }
 
 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) 
@@ -152,6 +159,7 @@ Int_t AliHLTTPCCATrackerComponent::DoInit( Int_t argc, const char** argv )
   fFullTime = 0;
   fRecoTime = 0;
   fNEvents = 0;
+  fNewOutputType = 0;
 
   if ( fTracker ) return EINPROGRESS;
   fTracker = new AliHLTTPCCATracker();
@@ -181,10 +189,16 @@ Int_t AliHLTTPCCATrackerComponent::DoDeinit()
   return 0;
 }
 
-Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
+Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
 {
   // see header file for class documentation
+  HLTWarning("dummy Reconfigure() method called" );
+
+  return EINVAL;
 
+  /*
+  
   Int_t iResult=EINVAL;
   const char* path="HLT/ConfigTPC/CATrackerComponent";
   const char* defaultNotify="";
@@ -194,7 +208,7 @@ Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* cdbEntry, const char*
   }
   if (path) {
     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
-    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
+    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);//,GetRunNo());
     if (pEntry) {
       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
       if (pString) {
@@ -212,7 +226,7 @@ Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* cdbEntry, const char*
   
   if (pathBField) {
     HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
-    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/);
+    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
     if (pEntry) {
       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
       if (pString) {
@@ -226,6 +240,7 @@ Int_t AliHLTTPCCATrackerComponent::Reconfigure(const char* cdbEntry, const char*
     }
   }  
   return iResult;  
+*/
 }
 
 
@@ -273,6 +288,10 @@ Int_t AliHLTTPCCATrackerComponent::Configure( const char* arguments )
       fClusterZCut = TMath::Abs( ((TObjString*)pTokens->At(i))->GetString().Atof());
       HLTInfo("ClusterZCut set to: %f", fClusterZCut );
     }
+    else if ( argument.CompareTo("-newOutputType")==0 ){
+      fNewOutputType = 1;
+      HLTInfo("NewOutputType is set");
+    }
     else {
       HLTError("Unknown option %s ", argument.Data());
       iResult=-EINVAL;
@@ -315,7 +334,7 @@ Int_t AliHLTTPCCATrackerComponent::DoEvent
   //Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA::DoEvent()" );
   if ( evtData.fBlockCnt<=0 )
     {
-      Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "no blocks in event" );
+      HLTWarning("no blocks in event" );
       return 0;
     }
   
@@ -381,7 +400,7 @@ Int_t AliHLTTPCCATrackerComponent::DoEvent
   }
   
   if( slice<0 ){
-    Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "CA:: no slices found in event" );
+    HLTWarning("no slices found in event" );
     return 0;
   }
 
@@ -551,124 +570,143 @@ Int_t AliHLTTPCCATrackerComponent::DoEvent
   Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
           "%d tracks found for slice %d",fTracker->NOutTracks(), slice);
 
-  // write reconstructed tracks
-
-  AliHLTTPCTrackletData* outPtr = (AliHLTTPCTrackletData*)(outputPtr);
 
-  AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
+  // write reconstructed tracks
 
+  UInt_t mySize = 0;
   Int_t ntracks = *fTracker->NOutTracks();
 
-  UInt_t mySize =   ((AliHLTUInt8_t *)currOutTracklet) -  ((AliHLTUInt8_t *)outputPtr);
-
-  outPtr->fTrackletCnt = 0; 
+  
+  if( !fNewOutputType ){
 
-  for( Int_t itr=0; itr<ntracks; itr++ ){
+    AliHLTTPCTrackletData* outPtr = (AliHLTTPCTrackletData*)(outputPtr);
     
-    AliHLTTPCCAOutTrack &t = fTracker->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
-
-    UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
+    AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;    
     
-    if( mySize + dSize > maxBufferSize ){
-      Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "Wrtite output","Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, ntracks-itr+1);
-      ret = -ENOSPC;
-      break;
-    }
+    mySize =   ((AliHLTUInt8_t *)currOutTracklet) -  ((AliHLTUInt8_t *)outputPtr);
     
-    // convert CA track parameters to HLT Track Segment
-    Int_t iFirstRow = 1000;
-    Int_t iLastRow = -1;
-    Int_t iFirstHit = fTracker->OutTrackHits()[t.FirstHitRef()];
-    Int_t iLastHit = iFirstHit;
-    for( Int_t ih=0; ih<t.NHits(); ih++ ){
-      Int_t hitID = fTracker->OutTrackHits()[t.FirstHitRef() + ih ];
-      Int_t iRow = vHitRowID[hitID];
-      if( iRow<iFirstRow ){  iFirstRow = iRow; iFirstHit = hitID; }
-      if( iRow>iLastRow ){ iLastRow = iRow; iLastHit = hitID; }
-    }   
-
-    AliHLTTPCCATrackParam par = t.StartPoint();
-
-    par.TransportToX( vHitStoreX[iFirstHit], .99 );
-
-    AliExternalTrackParam tp;
-    AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0, fSolenoidBz );
-
-    currOutTracklet->fX = tp.GetX();
-    currOutTracklet->fY = tp.GetY();
-    currOutTracklet->fZ = tp.GetZ();
-    currOutTracklet->fCharge = (Int_t ) tp.GetSign();
-    currOutTracklet->fPt = TMath::Abs(tp.GetSignedPt());
-    Float_t 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_t h = -currOutTracklet->fPt*currOutTracklet->fPt;
-    currOutTracklet->fPterr = h*h*tp.GetSigma1Pt2();
-    h = 1./TMath::Sqrt(1-snp*snp);
-    currOutTracklet->fPsierr = h*h*tp.GetSigmaSnp2();
-    currOutTracklet->fTglerr = tp.GetSigmaTgl2();
+    outPtr->fTrackletCnt = 0; 
     
-    if( par.TransportToX( vHitStoreX[iLastHit],.99 ) ){     
-      currOutTracklet->fLastX = par.GetX();
-      currOutTracklet->fLastY = par.GetY();
-      currOutTracklet->fLastZ = par.GetZ();
-    } else {
-      currOutTracklet->fLastX = vHitStoreX[iLastHit];
-      currOutTracklet->fLastY = vHitStoreY[iLastHit];
-      currOutTracklet->fLastZ = vHitStoreZ[iLastHit];
-    }
-    //if( currOutTracklet->fLastX<10. ) {
-    //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",vHitStoreX[iLastHit],vHitStoreY[iLastHit],vHitStoreZ[iLastHit],
-    //par.GetX(), par.GetY(),par.GetZ(),currOutTracklet->fLastX,currOutTracklet->fLastY ,currOutTracklet->fLastZ, t.NHits());
-    //}
+    for( Int_t itr=0; itr<ntracks; itr++ ){
+      
+      AliHLTTPCCAOutTrack &t = fTracker->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
+      
+      UInt_t dSize = sizeof(AliHLTTPCTrackSegmentData) + t.NHits()*sizeof(UInt_t);
+      
+      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;
+       break;
+      }
+      
+      // convert CA track parameters to HLT Track Segment
+      
+      Int_t iFirstRow = 1000;
+      Int_t iLastRow = -1;
+      Int_t iFirstHit = fTracker->OutTrackHits()[t.FirstHitRef()];
+      Int_t iLastHit = iFirstHit;
+      for( Int_t ih=0; ih<t.NHits(); ih++ ){
+       Int_t hitID = fTracker->OutTrackHits()[t.FirstHitRef() + ih ];
+       Int_t iRow = vHitRowID[hitID];
+       if( iRow<iFirstRow ){  iFirstRow = iRow; iFirstHit = hitID; }
+       if( iRow>iLastRow ){ iLastRow = iRow; iLastHit = hitID; }
+      }   
+      
+      AliHLTTPCCATrackParam par = t.StartPoint();
+      
+      par.TransportToX( vHitStoreX[iFirstHit], .99 );
+      
+      AliExternalTrackParam tp;
+      AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0, fSolenoidBz );
+      
+      currOutTracklet->fX = tp.GetX();
+      currOutTracklet->fY = tp.GetY();
+      currOutTracklet->fZ = tp.GetZ();
+      currOutTracklet->fCharge = (Int_t ) tp.GetSign();
+      currOutTracklet->fPt = TMath::Abs(tp.GetSignedPt());
+      Float_t 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_t h = -currOutTracklet->fPt*currOutTracklet->fPt;
+      currOutTracklet->fPterr = h*h*tp.GetSigma1Pt2();
+      h = 1./TMath::Sqrt(1-snp*snp);
+      currOutTracklet->fPsierr = h*h*tp.GetSigmaSnp2();
+      currOutTracklet->fTglerr = tp.GetSigmaTgl2();
+      
+      if( par.TransportToX( vHitStoreX[iLastHit],.99 ) ){     
+       currOutTracklet->fLastX = par.GetX();
+       currOutTracklet->fLastY = par.GetY();
+       currOutTracklet->fLastZ = par.GetZ();
+      } else {
+       currOutTracklet->fLastX = vHitStoreX[iLastHit];
+       currOutTracklet->fLastY = vHitStoreY[iLastHit];
+       currOutTracklet->fLastZ = vHitStoreZ[iLastHit];
+      }
+      //if( currOutTracklet->fLastX<10. ) {
+      //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",vHitStoreX[iLastHit],vHitStoreY[iLastHit],vHitStoreZ[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 = vHitRowID[iFirstHit];
-    currOutTracklet->fRowRange2 = vHitRowID[iLastHit];
-    currOutTracklet->fSector = slice;
-    currOutTracklet->fPID = 211;
+      currOutTracklet->fTrackID = 0;
+      currOutTracklet->fRowRange1 = vHitRowID[iFirstHit];
+      currOutTracklet->fRowRange2 = vHitRowID[iLastHit];
+      currOutTracklet->fSector = slice;
+      currOutTracklet->fPID = 211;
 #endif
 #endif // INCLUDE_TPC_HOUGH
-
-
-    currOutTracklet->fNPoints = t.NHits();
-
-    for( Int_t i=0; i<t.NHits(); i++ ){
-      currOutTracklet->fPointIDs[i] = vHitStoreID[fTracker->OutTrackHits()[t.FirstHitRef()+i]];
+      
+      
+      currOutTracklet->fNPoints = t.NHits();
+      
+      for( Int_t i=0; i<t.NHits(); i++ ){
+       currOutTracklet->fPointIDs[i] = vHitStoreID[fTracker->OutTrackHits()[t.FirstHitRef()+i]];
+      }
+      
+      currOutTracklet = (AliHLTTPCTrackSegmentData*)( (Byte_t *)currOutTracklet + dSize );
+      mySize+=dSize;
+      outPtr->fTrackletCnt++; 
+    }
+  } else { // new output type
+
+    mySize = fTracker->Output()->EstimateSize( fTracker->Output()->NTracks(), 
+                                              fTracker->Output()->NTrackClusters() );
+    if( mySize <= maxBufferSize ){
+      const AliHLTUInt8_t* outputevent = reinterpret_cast<const AliHLTUInt8_t*>(fTracker->Output());
+      for( UInt_t i=0; i<mySize; i++ ) outputPtr[i] = outputevent[i];
+    } else {    
+      HLTWarning("Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
+      mySize = 0;
+      ret = -ENOSPC;
     }
-
-    currOutTracklet = (AliHLTTPCTrackSegmentData*)( (Byte_t *)currOutTracklet + dSize );
-    mySize+=dSize;
-    outPtr->fTrackletCnt++; 
   }
-
   if( vHitStoreX ) delete[] vHitStoreX;
   if( vHitStoreY ) delete[] vHitStoreY;
   if( vHitStoreZ ) delete[] vHitStoreZ;
   if( vHitStoreIntID ) delete[] vHitStoreIntID;
   if( vHitStoreID ) delete[] vHitStoreID;
   if( vHitRowID ) delete[] vHitRowID;
-  
-  AliHLTComponentBlockData bd;
-  FillBlockData( bd );
-  bd.fOffset = 0;
-  bd.fSize = mySize;
-  bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );      
-  outputBlocks.push_back( bd );
-  
+
+  if( mySize>0 ){
+    AliHLTComponentBlockData bd;
+    FillBlockData( bd );
+    bd.fOffset = 0;
+    bd.fSize = mySize;
+    bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch ); 
+    outputBlocks.push_back( bd );
+  }
   size = mySize;
   
   timer.Stop();
@@ -680,9 +718,8 @@ Int_t AliHLTTPCCATrackerComponent::DoEvent
   // Set log level to "Warning" for on-line system monitoring
   Int_t hz = (Int_t) (fFullTime>1.e-10 ?fNEvents/fFullTime :100000);
   Int_t hz1 = (Int_t) (fRecoTime>1.e-10 ?fNEvents/fRecoTime :100000);
-  Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Tracks",
-          "CATracker slice %d: output %d tracks;  input %d clusters, patches %d..%d, rows %d..%d; reco time %d/%d Hz", 
-          slice, ntracks, nClusters, minPatch, maxPatch, row[0], row[1], hz, hz1 );
+  HLTInfo( "CATracker slice %d: output %d tracks;  input %d clusters, patches %d..%d, rows %d..%d; reco time %d/%d Hz", 
+           slice, ntracks, nClusters, minPatch, maxPatch, row[0], row[1], hz, hz1 );
 
   return ret;
 }
index 416fc73..330f05b 100644 (file)
@@ -84,6 +84,7 @@ private:
   Double_t fFullTime; //* total time for DoEvent() [s]
   Double_t fRecoTime; //* total reconstruction time [s]
   Long_t    fNEvents;  //* number of reconstructed events
+  Bool_t fNewOutputType; //* use new type of output (temporary flag)
 
   static Bool_t CompareClusters(AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b);
 
index 9118004..b75ca94 100644 (file)
@@ -459,7 +459,7 @@ Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
       Float_t sdedx = tTPC.GetSDEDX(0);
       Float_t dedx  = tTPC.GetdEdx();
       tESD.SetTPCsignal(dedx, sdedx, ndedx); 
-      //tESD.myTPC = tTPC;            
+      tESD.myTPC = tTPC;            
 
       event->AddTrack(&tESD);
     }