Using common HLT track data format for TRD tracks (Theodor)

- output of HLTTRDTracker is now standard HLT Tracks Struct
- changes in GlobalEsdConverter to follow HLTTRD changes
- GlobalTrackMerger now handles standard HLT Tracks Struct

diff --git a/HLT/TRD/AliHLTTRDClusterizer.cxx b/HLT/TRD/AliHLTTRDClusterizer.cxx
index 1976f54d90f4a66a9570df2889f0441722a42031..f1eab4b3d4cd0497f284091fc326637115abc6ae 100644 (file)
--- a/HLT/TRD/AliHLTTRDClusterizer.cxx
+++ b/HLT/TRD/AliHLTTRDClusterizer.cxx
@@ -25,7 +25,7 @@
 #include "AliTRDReconstructor.h"
 #include <TClonesArray.h>
 
 #include "AliTRDReconstructor.h"
 #include <TClonesArray.h>
 

-ClassImp(AliHLTTRDClusterizer);
+ClassImp(AliHLTTRDClusterizer)

 
 //_____________________________________________________________________________
 AliHLTTRDClusterizer::AliHLTTRDClusterizer(const AliTRDReconstructor *const rec)
 
 //_____________________________________________________________________________
 AliHLTTRDClusterizer::AliHLTTRDClusterizer(const AliTRDReconstructor *const rec)

diff --git a/HLT/TRD/AliHLTTRDClusterizer.h b/HLT/TRD/AliHLTTRDClusterizer.h
index 2b01fa3531057cda77a57d923bc179abf285800b..a4171b4c2c0198df2f9012e169911622be731076 100644 (file)
--- a/HLT/TRD/AliHLTTRDClusterizer.h
+++ b/HLT/TRD/AliHLTTRDClusterizer.h
@@ -24,20 +24,17 @@ class AliHLTTRDClusterizer : public AliTRDclusterizer
   AliHLTTRDClusterizer(const AliHLTTRDClusterizer& c);
   AliHLTTRDClusterizer& operator=(const AliHLTTRDClusterizer& c);
 
   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:
   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);
   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;
 
   
   AliHLTUInt8_t*  fMemBlock;
 

diff --git a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
index 6acef86b82d37631fa3be061728431739909f2a5..abc425297a6fc56a48748c3ef013939f58dcee42 100644 (file)
--- a/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
+++ b/HLT/TRD/AliHLTTRDClusterizerComponent.cxx
@@ -60,7 +60,7 @@ using namespace std;
 #include <cerrno>
 #include <string>
 
 #include <cerrno>
 #include <string>
 

-ClassImp(AliHLTTRDClusterizerComponent);
+ClassImp(AliHLTTRDClusterizerComponent)

    
 AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
   AliHLTProcessor(),
    
 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
 
   // 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 )
     {
   
   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;
          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], "-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], "-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++;
       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++;
       // 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], "-experiment" ) == 0)
        {
          iRecoDataType = 1;
          i++;

-         

        }
        }

-

       else if ( strcmp( argv[i], "-rawver" ) == 0)
        {
          if ( i+1 >= argc )
       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;
          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;
       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");
   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(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());
   
   
   fReconstructor->SetOption(recoOptions.Data());
   


@@ -389,7 +404,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
        CALLGRIND_START_INSTRUMENTATION;
       
       const AliHLTComponentBlockData &block = blocks[i];
        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) )
       // 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 ); 
       
 
       fMemReader->SetEquipmentID( id ); 
       

-      fClusterizer->SetMemBlock(outputPtr);
+      fClusterizer->SetMemBlock((AliHLTUInt8_t*)(outputPtr+offset));

       Bool_t iclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
       if (iclustered == kTRUE)
        {
       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 );
          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 
              
        }
        else 


@@ -478,7 +492,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
   return 0;
 }
 
   return 0;
 }
 

-

 void AliHLTTRDClusterizerComponent::PrintObject( TClonesArray* inClustersArray)
 {
   AliTRDcluster* cluster=0x0;
 void AliHLTTRDClusterizerComponent::PrintObject( TClonesArray* inClustersArray)
 {
   AliTRDcluster* cluster=0x0;

diff --git a/HLT/TRD/AliHLTTRDTrackerV1Component.cxx b/HLT/TRD/AliHLTTRDTrackerV1Component.cxx
index 238e0968ccc52cbf176ddef02d2d9e1d7d276707..299f720e7d1f67626ea4fdb88e44bf64d236f9fd 100644 (file)
--- a/HLT/TRD/AliHLTTRDTrackerV1Component.cxx
+++ b/HLT/TRD/AliHLTTRDTrackerV1Component.cxx
@@ -56,7 +56,7 @@ using namespace std;
 #define CALLGRIND_STOP_INSTRUMENTATION do { } while (0)
 #endif
 
 #define CALLGRIND_STOP_INSTRUMENTATION do { } while (0)
 #endif
 

-ClassImp(AliHLTTRDTrackerV1Component);
+ClassImp(AliHLTTRDTrackerV1Component)

     
 AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
   AliHLTProcessor(),
     
 AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
   AliHLTProcessor(),


@@ -95,7 +95,8 @@ void AliHLTTRDTrackerV1Component::GetInputDataTypes( vector<AliHLTComponent_Data
 AliHLTComponent_DataType AliHLTTRDTrackerV1Component::GetOutputDataType()
 {
   // Get the output data type
 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 )
 }
 
 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 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 )
   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;
            }
          HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
          i += 2;

-         

        }
        }

-

       else if ( !strcmp( argv[i], "-NTimeBins" ) )
        {
          if ( i+1>=argc )
       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;
            }     
              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 )
       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;
          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 )
       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;
          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++;
       // 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], "-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], "-cosmics" ) == 0)
        {
          iRecoParamType = 2;     
          HLTDebug("Cosmic test reco selected.");
          i++;

-       }      
-
+       }

       else if ( strcmp( argv[i], "-magnetic_field_ON" ) == 0)
        {
          iMagneticField = 1;
       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++;
        }
          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;
       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";
     }
   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());
   
   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);
 
   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];
     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;
       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( expectedDataTypes.at(i) == inputDataType)
          correctDataType = kTRUE;

+      }

       if (!correctDataType)
        {
          HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - Skipping",
       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 {
          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);
 
       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();
       // 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);  
 
       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 )
       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();
 
       //here we are deleting clusters (but not the TClonesArray itself)
       fTracker->UnloadClusters();

-

       AliTRDReconstructor::SetClusters(0x0);
       delete esd;
       clusterArray->Delete();
       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;
 }
   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;
-  
-}

diff --git a/HLT/TRD/AliHLTTRDUtils.cxx b/HLT/TRD/AliHLTTRDUtils.cxx
index af35e863256db2200830d29164f21f5b567ae693..f4c8d3c1adb43eef95242f024de1b05b0510ffc5 100644 (file)
--- a/HLT/TRD/AliHLTTRDUtils.cxx
+++ b/HLT/TRD/AliHLTTRDUtils.cxx
@@ -23,6 +23,12 @@
 #include <TClonesArray.h>
 #include "AliHLTTRDTrack.h"
 #include "AliHLTTRDCluster.h"
 #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)
 {
 
 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)
 {
 
 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;
   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;
 }
 
   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;
+}

diff --git a/HLT/TRD/AliHLTTRDUtils.h b/HLT/TRD/AliHLTTRDUtils.h
index 808af0b4ac1fbdd3e3764fb0eb369e39859a54de..c2acbd59b7aa4fc927306196ad95f461f6cfffd5 100644 (file)
--- a/HLT/TRD/AliHLTTRDUtils.h
+++ b/HLT/TRD/AliHLTTRDUtils.h
@@ -11,16 +11,22 @@
 
 
 #include "AliHLTDataTypes.h"
 
 
 #include "AliHLTDataTypes.h"

+#include "TObject.h"
+//#include "AliHLTProcessor.h"

 
 class TClonesArray;
 
 class TClonesArray;

-
+class AliESDEvent;

 class AliHLTTRDUtils
 {
 public:
 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)
+

 
 };
 
 
 };
 

diff --git a/HLT/global/AliHLTGlobalAgent.cxx b/HLT/global/AliHLTGlobalAgent.cxx
index c62a66524afb4605b195c467c2097e81462a3124..30199f0dbe4ed3f4b81935595950877f15e384ae 100644 (file)
--- a/HLT/global/AliHLTGlobalAgent.cxx
+++ b/HLT/global/AliHLTGlobalAgent.cxx
@@ -29,7 +29,7 @@
 #include "TObjArray.h"
 
 // header files of library components
 #include "TObjArray.h"
 
 // header files of library components

-//#include "AliHLTGlobalTrackMergerComponent.h"
+#include "AliHLTGlobalTrackMergerComponent.h"

 #include "AliHLTGlobalEsdConverterComponent.h"
 
 /** global instance for agent registration */
 #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;
   // 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;
 }
   pHandler->AddComponent(new AliHLTGlobalEsdConverterComponent);
   return 0;
 }

diff --git a/HLT/global/AliHLTGlobalEsdConverterComponent.cxx b/HLT/global/AliHLTGlobalEsdConverterComponent.cxx
index d23b1a1203e568806b6a020a2d21c4d59f68a4cd..8f89e73aad4bc426183e56391ad60d112af4c18a 100644 (file)
--- a/HLT/global/AliHLTGlobalEsdConverterComponent.cxx
+++ b/HLT/global/AliHLTGlobalEsdConverterComponent.cxx
@@ -37,6 +37,7 @@
 #include "AliESDtrack.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
 #include "AliESDtrack.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"

+#include "AliPID.h"

 #include "TTree.h"
 #include "TList.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 
       /*
       
       // primary vertex & V0's 
       /*

diff --git a/HLT/global/AliHLTGlobalEsdConverterComponent.h b/HLT/global/AliHLTGlobalEsdConverterComponent.h
index 182e5a35ecae0a18736b5c68ff4de4b91f253eda..415cdae01bcfd7abc7ab1b69cd4c6fd4bce09a7d 100644 (file)
--- a/HLT/global/AliHLTGlobalEsdConverterComponent.h
+++ b/HLT/global/AliHLTGlobalEsdConverterComponent.h
@@ -42,7 +42,7 @@ class AliHLTGlobalEsdConverterComponent : public AliHLTProcessor
   /** standard constructor */
   AliHLTGlobalEsdConverterComponent();
   /** destructor */
   /** standard constructor */
   AliHLTGlobalEsdConverterComponent();
   /** destructor */

-  ~AliHLTGlobalEsdConverterComponent();
+  virtual ~AliHLTGlobalEsdConverterComponent();

 
   // interface methods of base class
   const char* GetComponentID() {return "GlobalEsdConverter";};
 
   // interface methods of base class
   const char* GetComponentID() {return "GlobalEsdConverter";};


@@ -88,18 +88,20 @@ class AliHLTGlobalEsdConverterComponent : public AliHLTProcessor
    */
   int Configure(const char* arguments);
 
    */
   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
 
   /// 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
   ClassDef(AliHLTGlobalEsdConverterComponent, 0)
 };
 #endif

diff --git a/HLT/global/AliHLTGlobalTrackMerger.cxx b/HLT/global/AliHLTGlobalTrackMerger.cxx
index 954abc9aaace1e1220c9de005d1c59c113e49ffd..614076c938288f3f7dd7658d62b9acdab7defdad 100644 (file)
--- a/HLT/global/AliHLTGlobalTrackMerger.cxx
+++ b/HLT/global/AliHLTGlobalTrackMerger.cxx
@@ -22,15 +22,8 @@
     @brief  The HLT global merger base class
 */
 
     @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"
 #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;
 
   // 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");
+  // }

 
 }
 
 
 }
 


@@ -76,83 +69,6 @@ AliHLTGlobalTrackMerger::~AliHLTGlobalTrackMerger()
   if(fDebugStreamer) delete fDebugStreamer; fDebugStreamer =0;
 }
 
   if(fDebugStreamer) delete fDebugStreamer; fDebugStreamer =0;
 }
 

-//_____________________________________________________________________________
-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)
 {
 //_____________________________________________________________________________
 Bool_t AliHLTGlobalTrackMerger::Merge(AliESDEvent* esdEvent)
 {


@@ -347,23 +263,23 @@ Bool_t AliHLTGlobalTrackMerger::MatchTracks(AliExternalTrackParam *trackTPC, Ali
   Double_t signed1Pt_trd=trackTRD->GetSigned1Pt();
 
   // debug stream
   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;
 
   if (TMath::Abs(y_tpc-y_trd) > fMaxY) return kFALSE;
   if (TMath::Abs(z_tpc-z_trd) > fMaxZ) return kFALSE;

diff --git a/HLT/global/AliHLTGlobalTrackMerger.h b/HLT/global/AliHLTGlobalTrackMerger.h
index de0724c16e8b7ffc4e7bdd12794d5c76a7222670..cc9b0186410c13a501af8942d42effe97cfc8631 100644 (file)
--- a/HLT/global/AliHLTGlobalTrackMerger.h
+++ b/HLT/global/AliHLTGlobalTrackMerger.h
@@ -12,11 +12,6 @@
 */
 
 
 */
 
 

-class AliHLTTPCTrack;
-class AliHLTTPCTrackSegmentData;
-class AliHLTTPCVertex;
-class AliHLTTPCTrackArray;
-class AliTRDtrackV1;

 class AliESDEvent;
 class AliESDVertex;
 class AliExternalTrackParam;
 class AliESDEvent;
 class AliESDVertex;
 class AliExternalTrackParam;


@@ -41,10 +36,6 @@ public:
   /** destructor */
   virtual ~AliHLTGlobalTrackMerger();
 
   /** 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);
 
   // 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);
 
   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);
 
   // propagate tracks to DCA to primary vertex
   void PropagateTracksToDCA(AliESDEvent *esdEvent=0);
 

diff --git a/HLT/global/AliHLTGlobalTrackMergerComponent.cxx b/HLT/global/AliHLTGlobalTrackMergerComponent.cxx
index 9276a1bbd159986ba56d021ccbaa9ab359795f82..7d1170157b8a632a0228fefbb3fa9475cf9fd47d 100644 (file)
--- a/HLT/global/AliHLTGlobalTrackMergerComponent.cxx
+++ b/HLT/global/AliHLTGlobalTrackMergerComponent.cxx
@@ -25,36 +25,20 @@
 using namespace std;
 #include <climits>
 #include <cassert>
 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 <cstdlib>
 #include <cerrno>
 
 #include "AliESDEvent.h"
 #include "AliTracker.h"

-#include "AliTRDtrackV1.h"

 #include "AliHLTGlobalTrackMerger.h"
 #include "AliHLTGlobalTrackMerger.h"

-

 #include "AliHLTGlobalTrackMergerComponent.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 #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
 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()
 
 //_____________________________________________________________________________
 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
 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();
   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;
      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;
 {
   // see header file for class documentation
   if(fGlobalTrackMerger) delete fGlobalTrackMerger; fGlobalTrackMerger =0;

-  if(fESD) delete fESD; fESD = 0;
+  AliHLTGlobalEsdConverterComponent::DoDeinit();

   return 0;
 }
 
 //_____________________________________________________________________________
   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
 {
   //
   // global track merger function


@@ -165,92 +143,12 @@ int AliHLTGlobalTrackMergerComponent::DoEvent( const AliHLTComponentEventData& e
     return iResult;
   }
 
     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);
 
    // 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);
 
    // send output data
    //PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, iSpecification);

-   PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC);
+   PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginOut);

 
    // clean ESD event content
    fESD->Reset();
 
    // clean ESD event content
    fESD->Reset();

diff --git a/HLT/global/AliHLTGlobalTrackMergerComponent.h b/HLT/global/AliHLTGlobalTrackMergerComponent.h
index 788efc9e957da7fe210f0fd088d5919a33506a90..ab3f260ce50c833cd3a844b16afaba9aae612f12 100644 (file)
--- a/HLT/global/AliHLTGlobalTrackMergerComponent.h
+++ b/HLT/global/AliHLTGlobalTrackMergerComponent.h
@@ -1,3 +1,4 @@
+//-*- Mode: C++ -*-

 // $Id$
 #ifndef ALIHLTGLOBALTRACKMERGERCOMPONENT_H
 #define ALIHLTGLOBALTRACKMERGERCOMPONENT_H
 // $Id$
 #ifndef ALIHLTGLOBALTRACKMERGERCOMPONENT_H
 #define ALIHLTGLOBALTRACKMERGERCOMPONENT_H


@@ -11,9 +12,8 @@
     @brief  HLT global track merger component.
 */
 
     @brief  HLT global track merger component.
 */
 

-#include "AliHLTProcessor.h"
+#include "AliHLTGlobalEsdConverterComponent.h"

 
 

-class AliESDEvent;

 class AliHLTGlobalTrackMerger;
 
 /**
 class AliHLTGlobalTrackMerger;
 
 /**


@@ -23,7 +23,7 @@ class AliHLTGlobalTrackMerger;
  * @ingroup alihlt_global_components
  * @author Jacek.Otwinowski@gsi.de
  */
  * @ingroup alihlt_global_components
  * @author Jacek.Otwinowski@gsi.de
  */

-class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
+class AliHLTGlobalTrackMergerComponent : public AliHLTGlobalEsdConverterComponent

     {
     public:
       /** standard constructor */
     {
     public:
       /** standard constructor */


@@ -41,10 +41,10 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
        void GetInputDataTypes(AliHLTComponentDataTypeList& list);
 
       /** @see component interface AliHLTComponent::GetOutputDataType */
        void GetInputDataTypes(AliHLTComponentDataTypeList& list);
 
       /** @see component interface AliHLTComponent::GetOutputDataType */

-       AliHLTComponentDataType GetOutputDataType();
+       // AliHLTComponentDataType GetOutputDataType();

 
       /** @see component interface AliHLTComponent::GetOutputDataSize */
 
       /** @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();
 
       /** @see component interface AliHLTComponent::Spawn */
        AliHLTComponent* Spawn();


@@ -71,11 +71,10 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
        int DoDeinit();
 
       /** @see component interface @ref AliHLTProcessor::DoEvent */
        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 */
        
     private:
       /** copy constructor prohibited */


@@ -84,7 +83,6 @@ class AliHLTGlobalTrackMergerComponent : public AliHLTProcessor
       AliHLTGlobalTrackMergerComponent& operator=(const AliHLTGlobalTrackMergerComponent&);
 
       AliHLTGlobalTrackMerger *fGlobalTrackMerger;  //! global track merger
       AliHLTGlobalTrackMergerComponent& operator=(const AliHLTGlobalTrackMergerComponent&);
 
       AliHLTGlobalTrackMerger *fGlobalTrackMerger;  //! global track merger

-      AliESDEvent *fESD;                            //! AliESDEvent output from merger

 
       ClassDef(AliHLTGlobalTrackMergerComponent, 0)
 
 
       ClassDef(AliHLTGlobalTrackMergerComponent, 0)
 

diff --git a/HLT/libAliHLTGlobal.pkg b/HLT/libAliHLTGlobal.pkg
index f075a1db8997dc443c644aeb3ffaf1dbb1be66c9..dde793e463a11e81f41ef6b6eef732c8f57da61e 100644 (file)
--- a/HLT/libAliHLTGlobal.pkg
+++ b/HLT/libAliHLTGlobal.pkg
@@ -2,6 +2,8 @@
 # $Id$
 
 CLASS_HDRS:=   AliHLTGlobalEsdConverterComponent.h \
 # $Id$
 
 CLASS_HDRS:=   AliHLTGlobalEsdConverterComponent.h \

+               AliHLTGlobalTrackMergerComponent.h \
+               AliHLTGlobalTrackMerger.h \

                AliHLTGlobalAgent.h \
                AliHLTVertexer.h
 
                AliHLTGlobalAgent.h \
                AliHLTVertexer.h