Using common HLT track data format for TRD tracks (Theodor)
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 27 Jul 2009 13:55:34 +0000 (13:55 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 27 Jul 2009 13:55:34 +0000 (13:55 +0000)
- output of HLTTRDTracker is now standard HLT Tracks Struct
- changes in GlobalEsdConverter to follow HLTTRD changes
- GlobalTrackMerger now handles standard HLT Tracks Struct

14 files changed:
HLT/TRD/AliHLTTRDClusterizer.cxx
HLT/TRD/AliHLTTRDClusterizer.h
HLT/TRD/AliHLTTRDClusterizerComponent.cxx
HLT/TRD/AliHLTTRDTrackerV1Component.cxx
HLT/TRD/AliHLTTRDUtils.cxx
HLT/TRD/AliHLTTRDUtils.h
HLT/global/AliHLTGlobalAgent.cxx
HLT/global/AliHLTGlobalEsdConverterComponent.cxx
HLT/global/AliHLTGlobalEsdConverterComponent.h
HLT/global/AliHLTGlobalTrackMerger.cxx
HLT/global/AliHLTGlobalTrackMerger.h
HLT/global/AliHLTGlobalTrackMergerComponent.cxx
HLT/global/AliHLTGlobalTrackMergerComponent.h
HLT/libAliHLTGlobal.pkg

index 1976f54..f1eab4b 100644 (file)
@@ -25,7 +25,7 @@
 #include "AliTRDReconstructor.h"
 #include <TClonesArray.h>
 
-ClassImp(AliHLTTRDClusterizer);
+ClassImp(AliHLTTRDClusterizer)
 
 //_____________________________________________________________________________
 AliHLTTRDClusterizer::AliHLTTRDClusterizer(const AliTRDReconstructor *const rec)
index 2b01fa3..a4171b4 100644 (file)
@@ -24,20 +24,17 @@ class AliHLTTRDClusterizer : public AliTRDclusterizer
   AliHLTTRDClusterizer(const AliHLTTRDClusterizer& c);
   AliHLTTRDClusterizer& operator=(const AliHLTTRDClusterizer& c);
 
-  void Copy(TObject& c) const;
-
+  void            Copy(TObject& c) const;
   void            SetMemBlock(AliHLTUInt8_t* ptr){fMemBlock=ptr;fNoOfClusters=0;}
   AliHLTUInt8_t*  GetMemBlock(){return fMemBlock;}
   UInt_t          GetAddedSize(){return fNoOfClusters*sizeof(AliHLTTRDCluster);}
 
  protected:
-  TClonesArray*   RecPoints(){return 0x0;}  //these are functions in the parents class. must not be used in hlt!
-  void SetClustersOwner(Bool_t own){        //if used accidentally it may give an compilation error because are protected,
-      if(own){ /*get rid of warning*/}      //but the error can also appear in run time
-  } 
-                                            
-  
   void            AddClusterToArray(AliTRDcluster *cluster);
+
+  TClonesArray*   RecPoints(){return 0x0;}  //these are functions in the parents class. must not be used in hlt!
+  void  SetClustersOwner(Bool_t /*own*/){}  //if used accidentally it may give an compilation error because are protected,
+                                            //but the error can also appear in run time
   
   AliHLTUInt8_t*  fMemBlock;
 
index 6acef86..abc4252 100644 (file)
@@ -60,7 +60,7 @@ using namespace std;
 #include <cerrno>
 #include <string>
 
-ClassImp(AliHLTTRDClusterizerComponent);
+ClassImp(AliHLTTRDClusterizerComponent)
    
 AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
   AliHLTProcessor(),
@@ -130,6 +130,7 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
 
   // the data type will become obsolete as soon as the formats are established
   Int_t iRecoDataType = -1; // default will be simulation
+  Int_t iyPosMethod = 1;     // 0=COG 1=LUT 2=Gauss 
   
   while ( i < argc )
     {
@@ -161,48 +162,36 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
          fStrorageDBpath = argv[i+1];
          HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
          i += 2;
-         
-       }      
-
+       }
       else if ( strcmp( argv[i], "-lowflux" ) == 0)
        {
          iRecoParamType = 0;     
          HLTDebug("Low flux reco selected.");
          i++;
-         
-       }      
-
+       }
       else if ( strcmp( argv[i], "-highflux" ) == 0)
        {
          iRecoParamType = 1;     
          HLTDebug("High flux reco selected.");
          i++;
-         
-       }      
-
+       }
       else if ( strcmp( argv[i], "-cosmics" ) == 0)
        {
          iRecoParamType = 2;     
          HLTDebug("Cosmic test reco selected.");
          i++;
-         
-       }      
-
+       }
       // raw data type - sim or experiment
       else if ( strcmp( argv[i], "-simulation" ) == 0)
        {
          iRecoDataType = 0;
          i++;
-         
        }
-
       else if ( strcmp( argv[i], "-experiment" ) == 0)
        {
          iRecoDataType = 1;
          i++;
-         
        }
-
       else if ( strcmp( argv[i], "-rawver" ) == 0)
        {
          if ( i+1 >= argc )
@@ -226,7 +215,28 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
          fGeometryFileName = argv[i+1];
          HLTInfo("GeomFile storage is %s", fGeometryFileName.c_str() );          
          i += 2;
-       }      
+       }
+
+      else if ( strcmp( argv[i], "-yPosMethod" ) == 0)
+       {
+         if ( i+1 >= argc )
+           {
+             HLTError("Missing -yPosMethod argument");
+             return ENOTSUP;         
+           }
+         if( strcmp(argv[i], "COG") )
+           iyPosMethod=0;
+         else if( strcmp(argv[i], "LUT") )
+           iyPosMethod=1;
+         else if( strcmp(argv[i], "Gauss") )
+           iyPosMethod=2;
+         else {
+           HLTError("Unknown -yPosMethod argument");
+           return ENOTSUP;           
+         }
+         i += 2;
+       }
+      
       else{
        HLTError("Unknown option '%s'", argv[i] );
        return EINVAL;
@@ -270,11 +280,16 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
   fReconstructor->SetRecoParam(fRecoParam);
   fReconstructor->SetStreamLevel(0, AliTRDReconstructor::kClusterizer); // default value
   HLTInfo("Not writing clusters. I.e. output is a TClonesArray of clusters");
-  TString recoOptions="hlt,!cw,sl_cf_0,!gs,!lut";
+  TString recoOptions="hlt,!cw,sl_cf_0";
   switch(iRecoDataType){
   case 0: recoOptions += ",tc"; break;
   case 1: recoOptions += ",!tc"; break;
   }
+  switch(iyPosMethod){
+  case 0: recoOptions += ",!gs,!lut"; break;
+  case 1: recoOptions += ",!gs,lut"; break;
+  case 2: recoOptions += ",gs,!lut"; break;
+  }
   
   fReconstructor->SetOption(recoOptions.Data());
   
@@ -389,7 +404,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
        CALLGRIND_START_INSTRUMENTATION;
       
       const AliHLTComponentBlockData &block = blocks[i];
-      offset = totalSize;
       // lets not use the internal TRD data types here : AliHLTTRDDefinitions::fgkDDLRawDataType
       // which is depreciated - we use HLT global defs instead
       //      if ( block.fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD) )
@@ -428,7 +442,7 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
 
       fMemReader->SetEquipmentID( id ); 
       
-      fClusterizer->SetMemBlock(outputPtr);
+      fClusterizer->SetMemBlock((AliHLTUInt8_t*)(outputPtr+offset));
       Bool_t iclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
       if (iclustered == kTRUE)
        {
@@ -464,8 +478,8 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
          bd.fSpecification = gkAliEventTypeData;
          bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType;
          outputBlocks.push_back( bd );
-         HLTDebug( "Block ; size %i; dataType %s; spec 0x%x ",
-                   bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+         HLTDebug( "BD fPtr 0x%x, fOffset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+         offset = totalSize;
              
        }
        else 
@@ -478,7 +492,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
   return 0;
 }
 
-
 void AliHLTTRDClusterizerComponent::PrintObject( TClonesArray* inClustersArray)
 {
   AliTRDcluster* cluster=0x0;
index 238e096..299f720 100644 (file)
@@ -56,7 +56,7 @@ using namespace std;
 #define CALLGRIND_STOP_INSTRUMENTATION do { } while (0)
 #endif
 
-ClassImp(AliHLTTRDTrackerV1Component);
+ClassImp(AliHLTTRDTrackerV1Component)
     
 AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
   AliHLTProcessor(),
@@ -95,7 +95,8 @@ void AliHLTTRDTrackerV1Component::GetInputDataTypes( vector<AliHLTComponent_Data
 AliHLTComponent_DataType AliHLTTRDTrackerV1Component::GetOutputDataType()
 {
   // Get the output data type
-  return AliHLTTRDDefinitions::fgkClusterDataType;
+  //return AliHLTTRDDefinitions::fgkClusterDataType;
+  return  kAliHLTDataTypeTrack | kAliHLTDataOriginTRD;
 }
 
 void AliHLTTRDTrackerV1Component::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
@@ -123,6 +124,7 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
   Int_t iRecoParamType = -1; // default will be the low flux
   Int_t iNtimeBins = -1;     // number of time bins for the tracker to use
   Int_t iMagneticField = -1; // magnetic field: 0==OFF and 1==ON
+  Int_t iPIDmethod = 1;      // 0=LikelyHood(LH) 1=NeuronalNetwork(NN) 2=TruncatedMean(TM)
   Bool_t bHLTMode = kTRUE, bWriteClusters = kFALSE;
   
   while ( i < argc )
@@ -144,9 +146,7 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
            }
          HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
          i += 2;
-         
        }
-
       else if ( !strcmp( argv[i], "-NTimeBins" ) )
        {
          if ( i+1>=argc )
@@ -161,10 +161,8 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
              HLTError("Wrong Argument. Cannot convert -NTimeBins parameter '%s'", argv[i+1] );
              return EINVAL;
            }     
-         i += 2;
-         
+         i += 2; 
        }
-
       else if ( strcmp( argv[i], "-cdb" ) == 0)
        {
          if ( i+1 >= argc )
@@ -175,9 +173,7 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
          fStrorageDBpath = argv[i+1];
          HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
          i += 2;
-         
-       }      
-
+       }
       else if ( strcmp( argv[i], "-geometry" ) == 0)
        {
          if ( i+1 >= argc )
@@ -189,32 +185,26 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
          HLTInfo("GeomFile storage is %s", 
                  fGeometryFileName.c_str() );    
          i += 2;
-         
-       }      
-
+       }
       // the flux parametrizations
       else if ( strcmp( argv[i], "-lowflux" ) == 0)
        {
          iRecoParamType = 0;     
          HLTDebug("Low flux reco selected.");
          i++;
-         
-       }      
-      
+       }
       else if ( strcmp( argv[i], "-highflux" ) == 0)
        {
          iRecoParamType = 1;     
          HLTDebug("Low flux reco selected.");
          i++;
-       }      
-
+       }
       else if ( strcmp( argv[i], "-cosmics" ) == 0)
        {
          iRecoParamType = 2;     
          HLTDebug("Cosmic test reco selected.");
          i++;
-       }      
-
+       }
       else if ( strcmp( argv[i], "-magnetic_field_ON" ) == 0)
        {
          iMagneticField = 1;
@@ -231,6 +221,26 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
          HLTDebug("Using standard offline tracking.");
          i++;
        }
+      else if ( strcmp( argv[i], "-PIDmethod" ) == 0)
+       {
+         if ( i+1 >= argc )
+           {
+             HLTError("Missing -PIDmethod argument");
+             return ENOTSUP;         
+           }
+         if( strcmp(argv[i], "LH") )
+           iPIDmethod=0;
+         else if( strcmp(argv[i], "NN") )
+           iPIDmethod=1;
+         else if( strcmp(argv[i], "TM") )
+           iPIDmethod=2;
+         else {
+           HLTError("Unknown -PIDmethod argument");
+           return ENOTSUP;           
+         }
+         i += 2;
+       }
+
       else {
        HLTError("Unknown option '%s'", argv[i] );
        return EINVAL;
@@ -352,6 +362,12 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
     }
   if (bHLTMode)
     recoOptions += ",hlt";
+
+  switch(iPIDmethod){
+  case 0: recoOptions += ",!nn"; break;
+  case 1: recoOptions += ",nn"; break;
+  case 2: recoOptions += ",!nn"; break;
+  }
   
   fReconstructor->SetOption(recoOptions.Data());
   HLTDebug("Reconstructor options are: %s",recoOptions.Data());
@@ -418,18 +434,18 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
 
   vector<AliHLTComponent_DataType> expectedDataTypes;
   GetInputDataTypes(expectedDataTypes);
-  if (evtData.fEventID == 1)
+  if (evtData.fEventID > 1)
     CALLGRIND_START_INSTRUMENTATION;
   for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ ) 
     {
       const AliHLTComponentBlockData &block = blocks[iBlock];
-      offset = totalSize;
       AliHLTComponentDataType inputDataType = block.fDataType;
       Bool_t correctDataType = kFALSE;
-      
-      for(UInt_t i = 0; i < expectedDataTypes.size(); i++)
+
+      for(UInt_t i = 0; i < expectedDataTypes.size(); i++){
        if( expectedDataTypes.at(i) == inputDataType)
          correctDataType = kTRUE;
+      }
       if (!correctDataType)
        {
          HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - Skipping",
@@ -439,10 +455,11 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
          continue;
        }
       else {
-         HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s",
-                  iBlock, evtData.fBlockCnt-1,
-                  evtData.fEventID, evtData.fEventID, 
-                  DataType2Text(inputDataType).c_str());
+       HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s; Block Size: %i",
+                iBlock, evtData.fBlockCnt-1,
+                evtData.fEventID, evtData.fEventID, 
+                DataType2Text(inputDataType).c_str(),
+                block.fSize);
       }
       
       
@@ -451,8 +468,6 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
       HLTDebug("TClonesArray of clusters: nbEntries = %i", clusterArray->GetEntriesFast());
       fTracker->LoadClusters(clusterArray);
 
-      
-      
       // maybe it is not so smart to create it each event? clear is enough ?
       AliESDEvent *esd = new AliESDEvent();
       esd->CreateStdContent();
@@ -461,14 +476,55 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
       Int_t nTracks = esd->GetNumberOfTracks();
       HLTInfo("Number of tracks  == %d ==", nTracks);  
 
-      TClonesArray* trdTracks = fTracker->GetListOfTracks();
-   
-      if (trdTracks)
-       totalSize += TransportTracks(trdTracks, outputPtr, outputBlocks, offset, dBlockSpecification);
-      else {
-         HLTDebug("Bad array trdTracks = 0x%x", trdTracks);
+      TClonesArray* trdTracks = 0x0;
+      //trdTracks = fTracker->GetListOfTracks();
+      
+      if(nTracks>0){
+       HLTDebug("We have an output ESDEvent: 0x%x with %i tracks", esd, nTracks);
+       AliHLTUInt32_t addedSize = AliHLTTRDUtils::AddESDToOutput(esd, (AliHLTUInt8_t*)(outputPtr+offset));
+       totalSize += addedSize;
+         
+       // Fill block 
+       AliHLTComponentBlockData bd;
+       FillBlockData( bd );
+       //bd.fPtr = outputPtr;
+       bd.fOffset = offset;
+       bd.fSize = addedSize;
+       bd.fSpecification = dBlockSpecification;
+       bd.fDataType = kAliHLTDataTypeTrack | kAliHLTDataOriginTRD;
+       outputBlocks.push_back( bd );
+       HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
+       offset = totalSize;
+
+       if (trdTracks){
+         //Int_t nbTracks=trdTracks->GetEntriesFast();
+         //if (nbTracks>0){
+         HLTDebug("We have an output array: pointer to trdTracks = 0x%x, nbEntries = %i", trdTracks, trdTracks->GetEntriesFast());
+         
+         AliHLTUInt32_t addedSize = AliHLTTRDUtils::AddTracksToOutput(trdTracks, (AliHLTUInt8_t*)(outputPtr+offset));
+         totalSize += addedSize;
+         
+         // Fill block 
+         AliHLTComponentBlockData bd;
+         FillBlockData( bd );
+         //bd.fPtr = outputPtr;
+         bd.fOffset = offset;
+         bd.fSize = addedSize;
+         bd.fSpecification = dBlockSpecification;
+         bd.fDataType = AliHLTTRDDefinitions::fgkTRDSATracksDataType;
+         outputBlocks.push_back( bd );
+         HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
+         offset = totalSize;
+       }
       }
       
+      
+      // if (trdTracks)
+      //       totalSize += TransportTracks(trdTracks, outputPtr, outputBlocks, offset, dBlockSpecification);
+      // else {
+      //         HLTDebug("Bad array trdTracks = 0x%x", trdTracks);
+      // }
+      
       HLTDebug("totalSize: %i", totalSize);
       
 //       if ( totalSize > allocSize )
@@ -480,7 +536,6 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
 
       //here we are deleting clusters (but not the TClonesArray itself)
       fTracker->UnloadClusters();
-
       AliTRDReconstructor::SetClusters(0x0);
       delete esd;
       clusterArray->Delete();
@@ -492,40 +547,3 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
   HLTDebug("Event is done. size written to the output is %i", size);
   return 0;
 }
-
-
-/**
- * Transport tracks to the next component
- * Return Numbers of bytes written to the output
- */
-//============================================================================
-AliHLTUInt32_t AliHLTTRDTrackerV1Component::TransportTracks(TClonesArray *inTracksArray, AliHLTUInt8_t* output,
-                                                   vector<AliHLTComponent_BlockData>& outputBlocks, AliHLTUInt32_t inOffset, AliHLTUInt32_t inSpec)
-{
-  Int_t nbTracks=inTracksArray->GetEntriesFast();
-  if (nbTracks>0)
-    {
-      HLTDebug("We have an output array: pointer to inTracksArray = 0x%x, nbEntries = %i", inTracksArray, nbTracks);
-      
-       // Using low-level interface 
-       // with interface classes
-       AliHLTUInt32_t addedSize = AliHLTTRDUtils::AddTracksToOutput(inTracksArray, output);
-       
-       // Fill block 
-       AliHLTComponentBlockData bd;
-       FillBlockData( bd );
-
-       bd.fPtr = output;
-       bd.fOffset = inOffset;
-       bd.fSize = addedSize;
-       bd.fSpecification = inSpec;
-       bd.fDataType = AliHLTTRDDefinitions::fgkTRDSATracksDataType;
-       outputBlocks.push_back( bd );
-       HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
-       
-       return addedSize;
-      
-      }
-  return 0;
-  
-}
index af35e86..f4c8d3c 100644 (file)
 #include <TClonesArray.h>
 #include "AliHLTTRDTrack.h"
 #include "AliHLTTRDCluster.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliPID.h"
+
+ClassImp(AliHLTTRDUtils)
 
 AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr)
 {
@@ -55,7 +61,7 @@ AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray,
 
 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
 {
-  cout << "\nWriting tracks to the Memory\n ============= \n";
+  //cout << "\nWriting tracks to the Memory\n ============= \n";
   AliTRDtrackV1* track = 0;
   AliHLTUInt32_t addedSize = 0;
   AliHLTUInt8_t *iterPtr = output;
@@ -143,3 +149,49 @@ AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr
   return counter;
 }
 
+AliHLTUInt32_t AliHLTTRDUtils::AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr)
+{
+  AliESDtrack* esdTrack = 0;
+  AliHLTUInt8_t* iterPtr = outBlockPtr;
+
+  AliHLTTracksData* trksData = new(iterPtr) AliHLTTracksData;
+  iterPtr += sizeof(AliHLTTracksData);
+  trksData->fCount=0;
+  
+  if(esd){
+    Double_t pid[5];
+    for(Int_t i=0; i<esd->GetNumberOfTracks(); i++){
+      esdTrack=esd->GetTrack(i);
+      if(!esdTrack)continue;
+      AliHLTExternalTrackParam* trk = new(iterPtr) AliHLTExternalTrackParam;
+      iterPtr += sizeof(AliHLTExternalTrackParam);
+      trk->fAlpha = esdTrack->GetAlpha();
+      trk->fX = esdTrack->GetX();
+      trk->fY = esdTrack->GetY();
+      trk->fZ = esdTrack->GetZ();
+      trk->fSinPsi = esdTrack->GetSnp();
+      trk->fTgl = esdTrack->GetTgl();
+      trk->fq1Pt = esdTrack->GetSigned1Pt();
+      trk->fC[0] = esdTrack->GetSigmaY2();
+      trk->fC[1] = esdTrack->GetSigmaZY();
+      trk->fC[2] = esdTrack->GetSigmaZ2();
+      trk->fC[3] = esdTrack->GetSigmaSnpY();
+      trk->fC[4] = esdTrack->GetSigmaSnpZ();
+      trk->fC[5] = esdTrack->GetSigmaSnp2();
+      trk->fC[6] = esdTrack->GetSigmaTglY();
+      trk->fC[7] = esdTrack->GetSigmaTglZ();
+      trk->fC[8] = esdTrack->GetSigmaTglSnp();
+      trk->fC[9] = esdTrack->GetSigmaTgl2();
+      trk->fC[10] = esdTrack->GetSigma1PtY();
+      trk->fC[11] = esdTrack->GetSigma1PtZ();
+      trk->fC[12] = esdTrack->GetSigma1PtSnp();
+      trk->fC[13] = esdTrack->GetSigma1PtTgl();
+      trk->fC[14] = esdTrack->GetSigma1Pt2();
+      esdTrack->GetTRDpid(pid);
+      //trk->fTRDpid = pid[AliPID::kElectron]; ...
+      trk->fNPoints = 0;
+      trksData->fCount++;
+    }
+  }
+  return iterPtr - outBlockPtr;
+}
index 808af0b..c2acbd5 100644 (file)
 
 
 #include "AliHLTDataTypes.h"
+#include "TObject.h"
+//#include "AliHLTProcessor.h"
 
 class TClonesArray;
-
+class AliESDEvent;
 class AliHLTTRDUtils
 {
 public:
-static AliHLTUInt32_t AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr);
-static AliHLTUInt32_t AddTracksToOutput(TClonesArray* inTrackArray,AliHLTUInt8_t* output);
-static AliHLTUInt32_t ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
-static AliHLTUInt32_t ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
+  static AliHLTUInt32_t AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr);
+  static AliHLTUInt32_t AddTracksToOutput(TClonesArray* inTrackArray,AliHLTUInt8_t* output);
+  static AliHLTUInt32_t ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
+  static AliHLTUInt32_t ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
+  static AliHLTUInt32_t AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr);
+
+  ClassDef(AliHLTTRDUtils, 0)
+
 
 };
 
index c62a665..30199f0 100644 (file)
@@ -29,7 +29,7 @@
 #include "TObjArray.h"
 
 // header files of library components
-//#include "AliHLTGlobalTrackMergerComponent.h"
+#include "AliHLTGlobalTrackMergerComponent.h"
 #include "AliHLTGlobalEsdConverterComponent.h"
 
 /** global instance for agent registration */
@@ -59,10 +59,7 @@ int AliHLTGlobalAgent::RegisterComponents(AliHLTComponentHandler* pHandler) cons
   // see header file for class documentation
   assert(pHandler);
   if (!pHandler) return -EINVAL;
-  // Matthias 2009-07-02 disable the AliHLTGlobalTrackMergerComponent
-  // until it is free of TPC and TRD dependencies, i.e. using only
-  // common data types as input
-  //pHandler->AddComponent(new AliHLTGlobalTrackMergerComponent);
+  pHandler->AddComponent(new AliHLTGlobalTrackMergerComponent);
   pHandler->AddComponent(new AliHLTGlobalEsdConverterComponent);
   return 0;
 }
index d23b1a1..8f89e73 100644 (file)
@@ -37,6 +37,7 @@
 #include "AliESDtrack.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
+#include "AliPID.h"
 #include "TTree.h"
 #include "TList.h"
 
@@ -333,6 +334,37 @@ int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent*
       }
     }
   }
+
+  // convert the HLT TRD tracks to ESD tracks                        
+  for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD);
+       pBlock!=NULL; pBlock=GetNextInputBlock()) {
+    vector<AliHLTGlobalBarrelTrack> tracks;
+    if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) {
+      for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
+          element!=tracks.end(); element++) {
+       
+       Double_t TRDpid[AliPID::kSPECIES], eProb(0.2), restProb((1-eProb)/(AliPID::kSPECIES-1)); //eprob(element->GetTRDpid...);
+       for(Int_t i=0; i<AliPID::kSPECIES; i++){
+         switch(i){
+         case AliPID::kElectron: TRDpid[AliPID::kElectron]=eProb; break;
+         default: TRDpid[i]=restProb; break;
+         }
+       }
+       
+       AliESDtrack iotrack;
+       iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTRDin);
+       iotrack.SetTRDpid(TRDpid);
+       
+       pESD->AddTrack(&iotrack);
+       if (fVerbosity>0) element->Print();
+      }
+      HLTInfo("converted %d track(s) to AliESDtrack and added to ESD", tracks.size());
+      iAddedDataBlocks++;
+    } else if (iResult<0) {
+      HLTError("can not extract tracks from data block of type %s (specification %08x) of size %d: error %d", 
+              DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, pBlock->fSize, iResult);
+    }
+  }
       
       // primary vertex & V0's 
       /*
index 182e5a3..415cdae 100644 (file)
@@ -42,7 +42,7 @@ class AliHLTGlobalEsdConverterComponent : public AliHLTProcessor
   /** standard constructor */
   AliHLTGlobalEsdConverterComponent();
   /** destructor */
-  ~AliHLTGlobalEsdConverterComponent();
+  virtual ~AliHLTGlobalEsdConverterComponent();
 
   // interface methods of base class
   const char* GetComponentID() {return "GlobalEsdConverter";};
@@ -88,18 +88,20 @@ class AliHLTGlobalEsdConverterComponent : public AliHLTProcessor
    */
   int Configure(const char* arguments);
 
-  /// the ESD
-  AliESDEvent* fESD; //! transient value
-
-  /// solenoid b field
-  Double_t fSolenoidBz; //! transient
-
   /// write object to TTree or directly
   int fWriteTree; //!transient
 
   /// verbosity level
   int fVerbosity; //!transient
 
+protected:
+
+  /// the ESD
+  AliESDEvent* fESD; //! transient value
+
+  /// solenoid b field
+  Double_t fSolenoidBz; //! transient
+
   ClassDef(AliHLTGlobalEsdConverterComponent, 0)
 };
 #endif
index 954abc9..614076c 100644 (file)
     @brief  The HLT global merger base class
 */
 
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackArray.h"
+//#include "AliTPCReconstructor.h"
 
-#include "AliTPCReconstructor.h"
-
-#include "AliTRDtrackV1.h"
 #include "AliESDEvent.h"
 #include "AliESDVertex.h"
 #include "AliTracker.h"
@@ -62,9 +55,9 @@ AliHLTGlobalTrackMerger::AliHLTGlobalTrackMerger()
   // V(0.,0.,0.), sigmaVx=sigmaVy=5.e-3 [cm], sigmaVz=5.3 [cm]    
   fVertex = new AliESDVertex;
 
-  if (AliTPCReconstructor::StreamLevel()>0) {
-    fDebugStreamer = new TTreeSRedirector("debugGlobalMerger.root");
-  }
+  // if (AliTPCReconstructor::StreamLevel()>0) {
+  //   fDebugStreamer = new TTreeSRedirector("debugGlobalMerger.root");
+  // }
 
 }
 
@@ -77,83 +70,6 @@ AliHLTGlobalTrackMerger::~AliHLTGlobalTrackMerger()
 }
 
 //_____________________________________________________________________________
-Bool_t AliHLTGlobalTrackMerger::LoadTracks(TClonesArray *aTRDTracks, AliESDEvent *esdEvent)
-{
-  // load TRD tracks
-  if(!aTRDTracks) return kFALSE;
-
-  Int_t entries = aTRDTracks->GetEntriesFast();
-  for(Int_t i=0; i<entries; ++i) {
-    AliTRDtrackV1 *track = (AliTRDtrackV1*)aTRDTracks->At(i);
-    if(!track) continue;
-
-    FillTRDESD(track,AliESDtrack::kTRDin,esdEvent); 
-  }
-
-return kTRUE;
-}
-
-//_____________________________________________________________________________
-Bool_t AliHLTGlobalTrackMerger::LoadTracks(AliHLTTPCTrackArray *aTPCTracks, AliESDEvent *esdEvent)
-{
-  // load TPC tracks
-  if(!aTPCTracks) return kFALSE;
-
-  for (Int_t i=0; i<aTPCTracks->GetNTracks();++i) {
-    AliHLTTPCTrack* track=(*aTPCTracks)[i];
-    if(!track) continue;
-
-    // convert to the AliKalmanTrack 
-    Int_t local=track->Convert2AliKalmanTrack();
-    if(local<0) continue;
-
-    FillTPCESD(track,AliESDtrack::kTPCin,esdEvent); 
-  }
-
-return kTRUE;
-}
-
-//_____________________________________________________________________________
-void AliHLTGlobalTrackMerger::FillTPCESD(AliHLTTPCTrack *tpcTrack, ULong_t flags, AliESDEvent* esdEvent)
-{
-  // create AliESDtracks from AliHLTTPCTracks 
-  // and add them to AliESDEvent
-
-  if(!tpcTrack) return;
-  if(!esdEvent) return;
-
-  AliESDtrack iotrack;
-  iotrack.UpdateTrackParams(tpcTrack,flags);
-
-  Float_t points[4]={tpcTrack->GetFirstPointX(),tpcTrack->GetFirstPointY(),tpcTrack->GetLastPointX(),tpcTrack->GetLastPointY()};
-  if(tpcTrack->GetSector() == -1){ // Set first and last points for global tracks
-    Double_t s = TMath::Sin( tpcTrack->GetAlpha() );
-    Double_t c = TMath::Cos( tpcTrack->GetAlpha() );
-    points[0] =  tpcTrack->GetFirstPointX()*c + tpcTrack->GetFirstPointY()*s;
-    points[1] = -tpcTrack->GetFirstPointX()*s + tpcTrack->GetFirstPointY()*c;
-    points[2] =  tpcTrack->GetLastPointX() *c + tpcTrack->GetLastPointY() *s;
-    points[3] = -tpcTrack->GetLastPointX() *s + tpcTrack->GetLastPointY() *c;
-  }
-  iotrack.SetTPCPoints(points);
-
-  esdEvent->AddTrack(&iotrack);
-}
-//_____________________________________________________________________________
-void AliHLTGlobalTrackMerger::FillTRDESD(AliTRDtrackV1* trdTrack, ULong_t flags, AliESDEvent* esdEvent)
-{
-  // create AliESDtracks from AliTRDtrackV1
-  // and add them to AliESDEvent
-
-  if(!trdTrack) return;
-  if(!esdEvent) return;
-
-  AliESDtrack iotrack;
-  iotrack.UpdateTrackParams(trdTrack,flags);
-  esdEvent->AddTrack(&iotrack);
-}
-
-//_____________________________________________________________________________
 Bool_t AliHLTGlobalTrackMerger::Merge(AliESDEvent* esdEvent)
 {
   // merge TPC and TRD tracks
@@ -347,23 +263,23 @@ Bool_t AliHLTGlobalTrackMerger::MatchTracks(AliExternalTrackParam *trackTPC, Ali
   Double_t signed1Pt_trd=trackTRD->GetSigned1Pt();
 
   // debug stream
-  if (AliTPCReconstructor::StreamLevel()>0) {
-  //TTreeSRedirector &cstream = *fDebugStreamer;
-  *fDebugStreamer<<"match"<<
-  "x_tpc="<<x_tpc<<
-  "y_tpc="<<y_tpc<<
-  "z_tpc="<<z_tpc<<
-  "snp_tpc="<<snp_tpc<<
-  "tgl_tpc="<<tgl_tpc<<
-  "signed1Pt_tpc="<<signed1Pt_tpc<<
-  "x_trd="<<x_trd<<
-  "y_trd="<<y_trd<<
-  "z_trd="<<z_trd<<
-  "snp_trd="<<snp_trd<<
-  "tgl_trd="<<tgl_trd<<
-  "signed1Pt_trd="<<signed1Pt_trd<<
-  "\n";
-  }
+  // if (AliTPCReconstructor::StreamLevel()>0) {
+  // //TTreeSRedirector &cstream = *fDebugStreamer;
+  // *fDebugStreamer<<"match"<<
+  // "x_tpc="<<x_tpc<<
+  // "y_tpc="<<y_tpc<<
+  // "z_tpc="<<z_tpc<<
+  // "snp_tpc="<<snp_tpc<<
+  // "tgl_tpc="<<tgl_tpc<<
+  // "signed1Pt_tpc="<<signed1Pt_tpc<<
+  // "x_trd="<<x_trd<<
+  // "y_trd="<<y_trd<<
+  // "z_trd="<<z_trd<<
+  // "snp_trd="<<snp_trd<<
+  // "tgl_trd="<<tgl_trd<<
+  // "signed1Pt_trd="<<signed1Pt_trd<<
+  // "\n";
+  // }
 
   if (TMath::Abs(y_tpc-y_trd) > fMaxY) return kFALSE;
   if (TMath::Abs(z_tpc-z_trd) > fMaxZ) return kFALSE;
index de0724c..cc9b018 100644 (file)
 */
 
 
-class AliHLTTPCTrack;
-class AliHLTTPCTrackSegmentData;
-class AliHLTTPCVertex;
-class AliHLTTPCTrackArray;
-class AliTRDtrackV1;
 class AliESDEvent;
 class AliESDVertex;
 class AliExternalTrackParam;
@@ -41,10 +36,6 @@ public:
   /** destructor */
   virtual ~AliHLTGlobalTrackMerger();
 
-  // load tracks
-  Bool_t LoadTracks(TClonesArray *aTRDTracks,AliESDEvent *esdEvent=0);
-  Bool_t LoadTracks(AliHLTTPCTrackArray *aTPCTracks,AliESDEvent *esdEvent=0);
-
   // set matching parameters
   void SetParameter(Double_t maxy=1., Double_t maxz=1., Double_t maxsnp=0.05, Double_t maxtgl=0.1, Double_t signed1Pt=0.001);
 
@@ -55,10 +46,6 @@ public:
   Bool_t Merge(AliESDEvent *esdEvent=0);
   Bool_t MergeTracks(AliESDtrack *trackTPC=0, AliESDtrack *trackTRD=0, AliESDEvent *esdEvent=0);
 
-  // create AliESDtrack objects
-  void FillTPCESD(AliHLTTPCTrack* tpcTrack=0, ULong_t flags=AliESDtrack::kTPCin, AliESDEvent* esdEvent=0); 
-  void FillTRDESD(AliTRDtrackV1*  trdTrack=0, ULong_t flags=AliESDtrack::kTRDin, AliESDEvent* esdEvent=0);
-
   // propagate tracks to DCA to primary vertex
   void PropagateTracksToDCA(AliESDEvent *esdEvent=0);
 
index 9276a1b..7d11701 100644 (file)
 using namespace std;
 #include <climits>
 #include <cassert>
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCGlobalMerger.h"
-#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCVertexData.h"
-#include "AliHLTTPCTrack.h"
-
-//#include "AliHLTTPCSpacePointData.h"
-//#include "AliHLTTPCClusterDataFormat.h"
-#include "AliHLTTPCTrackletDataFormat.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTrackArray.h"
-#include "AliHLTTPCDefinitions.h"
-#include "AliHLTTRDDefinitions.h"
 #include <cstdlib>
 #include <cerrno>
 
 #include "AliESDEvent.h"
 #include "AliTracker.h"
-#include "AliTRDtrackV1.h"
 #include "AliHLTGlobalTrackMerger.h"
-
 #include "AliHLTGlobalTrackMergerComponent.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
-ClassImp(AliHLTGlobalTrackMergerComponent);
+ClassImp(AliHLTGlobalTrackMergerComponent)
 
 //_____________________________________________________________________________
-AliHLTGlobalTrackMergerComponent::AliHLTGlobalTrackMergerComponent() : AliHLTProcessor(), 
-  fGlobalTrackMerger(0), 
-  fESD(0)
+AliHLTGlobalTrackMergerComponent::AliHLTGlobalTrackMergerComponent() : AliHLTGlobalEsdConverterComponent(), 
+  fGlobalTrackMerger(0)
 {
 }
 
@@ -75,26 +59,24 @@ const char* AliHLTGlobalTrackMergerComponent::GetComponentID()
 void AliHLTGlobalTrackMergerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
 {
   // see header file for class documentation
-  list.clear();
-  list.push_back( AliHLTTPCDefinitions::fgkTracksDataType );
-  list.push_back( AliHLTTRDDefinitions::fgkTRDSATracksDataType );
+  list.push_back( kAliHLTDataTypeTrack );
 }
 
 //_____________________________________________________________________________
-AliHLTComponentDataType AliHLTGlobalTrackMergerComponent::GetOutputDataType()
-{
-  // see header file for class documentation
-  return kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC;
-}
+// AliHLTComponentDataType AliHLTGlobalTrackMergerComponent::GetOutputDataType()
+// {
+//   // see header file for class documentation
+//   return kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC;
+// }
 
 //_____________________________________________________________________________
-void AliHLTGlobalTrackMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
-  // see header file for class documentation
-  // XXX TODO: Find more realistic values.
-  constBase = 20000;
-  inputMultiplier = 1.0;
-}
+// void AliHLTGlobalTrackMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+// {
+//   // see header file for class documentation
+//   // XXX TODO: Find more realistic values.
+//   constBase = 20000;
+//   inputMultiplier = 1.0;
+// }
 
 //_____________________________________________________________________________
 AliHLTComponent* AliHLTGlobalTrackMergerComponent::Spawn()
@@ -114,18 +96,15 @@ void AliHLTGlobalTrackMergerComponent::SetMergerParameters(Double_t maxy,Double_
 int AliHLTGlobalTrackMergerComponent::DoInit( int /*argc*/, const char** /*argv*/ )
 {
   // see header file for class documentation
+  const char* argv = "-notree";
+  AliHLTGlobalEsdConverterComponent::DoInit(1,&argv);
+
   int iResult = 0;
   
   // Init merger
   fGlobalTrackMerger = new AliHLTGlobalTrackMerger();
-  
-  // output of the component
-  fESD = new AliESDEvent();
-  if (fESD) {
-     fESD->CreateStdContent();
-  }
 
-  if (!fGlobalTrackMerger || !fESD ) {
+  if (!fGlobalTrackMerger ) {
      HLTError("failed creating internal objects");
      iResult=-ENOMEM;
      return iResult;
@@ -141,14 +120,13 @@ int AliHLTGlobalTrackMergerComponent::DoDeinit()
 {
   // see header file for class documentation
   if(fGlobalTrackMerger) delete fGlobalTrackMerger; fGlobalTrackMerger =0;
-  if(fESD) delete fESD; fESD = 0;
+  AliHLTGlobalEsdConverterComponent::DoDeinit();
   return 0;
 }
 
 //_____________________________________________________________________________
-int AliHLTGlobalTrackMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                                             AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* /*outputPtr*/, 
-                                             AliHLTUInt32_t& /*size*/, AliHLTComponentBlockDataList& /*outputBlocks*/ )
+int AliHLTGlobalTrackMergerComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, 
+                                             AliHLTComponentTriggerData& /*trigData*/)
 {
   //
   // global track merger function
@@ -165,92 +143,12 @@ int AliHLTGlobalTrackMergerComponent::DoEvent( const AliHLTComponentEventData& e
     return iResult;
   }
 
-  if(!blocks) {
-    HLTError("no blocks");
-    iResult=-EINVAL;
-    return iResult;
-  }
-
-  const AliHLTComponentBlockData* iter=0;
-  AliHLTTPCTrackletData* inPtr=0;
-  Bool_t bIsTRDTrackDataBlock=kFALSE;
-  Bool_t bIsTPCTrackDataBlock=kFALSE;
-  TClonesArray *aTRDTracks=0;
-  Int_t minSlice = INT_MAX, maxSlice = 0;
-  Int_t slice;
-
-  unsigned long ndx;
-  Int_t nTRDDataBlocks = 0;
-  Int_t nTPCDataBlocks = 0;
-  for ( ndx = 0; ndx < evtData.fBlockCnt && iResult>=0; ndx++ )
-  {
-      iter = blocks+ndx;
-      bIsTRDTrackDataBlock=kFALSE;
-      bIsTPCTrackDataBlock=kFALSE;
-
-      // check if TPC or TRD tracks
-      if(!(bIsTRDTrackDataBlock=(iter->fDataType==AliHLTTRDDefinitions::fgkTRDSATracksDataType)) &&
-         !(bIsTPCTrackDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkTracksDataType))) {
-       continue;
-      }
-
-      // collect TRD tracks from all SM
-      // one TClonesArray of tracks per SM
-      if(bIsTRDTrackDataBlock) 
-      {
-        nTRDDataBlocks++;
-       if(nTRDDataBlocks>1) continue;
-        for (TObject *pObj = (TObject *)GetFirstInputObject(AliHLTTRDDefinitions::fgkTRDSATracksDataType,"TClonesArray",0);
-         pObj !=0 && iResult>=0;
-         pObj = (TObject *)GetNextInputObject(0)) {
-          aTRDTracks = dynamic_cast<TClonesArray*>(pObj);
-          if (!aTRDTracks) continue;
-
-          HLTInfo("reading block %d, trdTracks %d", ndx, aTRDTracks->GetEntriesFast());
-
-         // load TRD tracks
-         if (fGlobalTrackMerger->LoadTracks(aTRDTracks,fESD) == kFALSE) {
-             HLTError("Cannot load TRD tracks");
-             iResult=-ENOMEM;
-             return iResult;
-         }
-       }
-       aTRDTracks->Delete();
-      } 
-      
-      // collect TPC tracks from whole TPC
-      if (bIsTPCTrackDataBlock) 
-      {
-        nTPCDataBlocks++;
-       if(nTPCDataBlocks>1) continue;
-
-        slice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
-       if(slice<minSlice) minSlice = slice;
-       if(slice>maxSlice) maxSlice = slice;
-       
-        //minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
-        //maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
-
-        AliHLTTPCTrackArray tracks;
-        inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
-
-        HLTInfo("reading block %d (slice %d): %d tracklets", ndx, slice, inPtr->fTrackletCnt);
-
-        // read TPC track segments from memory
-        if((iResult=tracks.FillTracksChecked(inPtr->fTracklets, inPtr->fTrackletCnt, iter->fSize, -1/*global track*/, 0/*don't rotate*/))>=0) 
-       {
-          // load TPC tracks
-          if (fGlobalTrackMerger->LoadTracks(&tracks,fESD) == kFALSE) {
-             HLTError("Cannot load TPC tracks");
-             iResult=-ENOMEM;
-             return iResult;
-         }
-        }
-      }
-   }
+  fESD->Reset(); 
+  fESD->SetMagneticField(fSolenoidBz);
+  //fESD->SetMagneticField(AliTracker::GetBz());
 
-   // set magnetic field 
-   fESD->SetMagneticField(AliTracker::GetBz());
+  if ((iResult=ProcessBlocks(NULL, fESD))<0) return iResult;
+  if(!fESD->GetNumberOfTracks()>0) return iResult;
 
    // merge tracks
    Bool_t isMerged = fGlobalTrackMerger->Merge(fESD);
@@ -267,7 +165,7 @@ int AliHLTGlobalTrackMergerComponent::DoEvent( const AliHLTComponentEventData& e
 
    // send output data
    //PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, iSpecification);
-   PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC);
+   PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginOut);
 
    // clean ESD event content
    fESD->Reset();
index 788efc9..ab3f260 100644 (file)
@@ -1,3 +1,4 @@
+//-*- Mode: C++ -*-
 // $Id$
 #ifndef ALIHLTGLOBALTRACKMERGERCOMPONENT_H
 #define ALIHLTGLOBALTRACKMERGERCOMPONENT_H
@@ -11,9 +12,8 @@
     @brief  HLT global track merger component.
 */
 
-#include "AliHLTProcessor.h"
+#include "AliHLTGlobalEsdConverterComponent.h"
 
-class AliESDEvent;
 class AliHLTGlobalTrackMerger;
 
 /**
@@ -23,7 +23,7 @@ class AliHLTGlobalTrackMerger;
  * @ingroup alihlt_global_components
  * @author Jacek.Otwinowski@gsi.de
  */
-class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
+class AliHLTGlobalTrackMergerComponent : public AliHLTGlobalEsdConverterComponent
     {
     public:
       /** standard constructor */
@@ -41,10 +41,10 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
        void GetInputDataTypes(AliHLTComponentDataTypeList& list);
 
       /** @see component interface AliHLTComponent::GetOutputDataType */
-       AliHLTComponentDataType GetOutputDataType();
+       // AliHLTComponentDataType GetOutputDataType();
 
       /** @see component interface AliHLTComponent::GetOutputDataSize */
-       virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+       // virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
 
       /** @see component interface AliHLTComponent::Spawn */
        AliHLTComponent* Spawn();
@@ -71,11 +71,10 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
        int DoDeinit();
 
       /** @see component interface @ref AliHLTProcessor::DoEvent */
-       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );
+        int DoEvent( const AliHLTComponentEventData& evtData,
+                    AliHLTComponentTriggerData& trigData);
 
-       using AliHLTProcessor::DoEvent;
+      using AliHLTProcessor::DoEvent;
        
     private:
       /** copy constructor prohibited */
@@ -84,7 +83,6 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
       AliHLTGlobalTrackMergerComponent& operator=(const AliHLTGlobalTrackMergerComponent&);
 
       AliHLTGlobalTrackMerger *fGlobalTrackMerger;  //! global track merger
-      AliESDEvent *fESD;                            //! AliESDEvent output from merger
 
       ClassDef(AliHLTGlobalTrackMergerComponent, 0)
 
index f075a1d..dde793e 100644 (file)
@@ -2,6 +2,8 @@
 # $Id$
 
 CLASS_HDRS:=   AliHLTGlobalEsdConverterComponent.h \
+               AliHLTGlobalTrackMergerComponent.h \
+               AliHLTGlobalTrackMerger.h \
                AliHLTGlobalAgent.h \
                AliHLTVertexer.h