HLT TRD update by Konstantin
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Mar 2009 14:27:36 +0000 (14:27 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Mar 2009 14:27:36 +0000 (14:27 +0000)
* Option to pass clusters and tracks between components in TClonesArray removed.
  We must use only low-level interface now.
* Restructure of the code
* AliTRDClusterizerHLT.[h,cxx] renamed to AliHLTTRDClusterizer.[h,cxx]
* AliHLTTRDUtils.[h,cxx] created, that contains class with commonly used functions in HLTTRD
* AliHLTTRDTrackerComponent.[h,cxx] removed, since we are using only TrackerV1

21 files changed:
HLT/AliHLTTRDLinkDef.h
HLT/TRD/AliHLTTRDAgent.cxx
HLT/TRD/AliHLTTRDCalibrationComponent.cxx
HLT/TRD/AliHLTTRDCalibrationComponent.h
HLT/TRD/AliHLTTRDCluster.cxx
HLT/TRD/AliHLTTRDCluster.h
HLT/TRD/AliHLTTRDClusterizer.cxx [new file with mode: 0644]
HLT/TRD/AliHLTTRDClusterizer.h [new file with mode: 0644]
HLT/TRD/AliHLTTRDClusterizerComponent.cxx
HLT/TRD/AliHLTTRDClusterizerComponent.h
HLT/TRD/AliHLTTRDEsdWriterComponent.cxx
HLT/TRD/AliHLTTRDEsdWriterComponent.h
HLT/TRD/AliHLTTRDTrackerComponent.cxx [deleted file]
HLT/TRD/AliHLTTRDTrackerComponent.h [deleted file]
HLT/TRD/AliHLTTRDTrackerV1Component.cxx
HLT/TRD/AliHLTTRDTrackerV1Component.h
HLT/TRD/AliHLTTRDUtils.cxx [new file with mode: 0644]
HLT/TRD/AliHLTTRDUtils.h [new file with mode: 0644]
HLT/TRD/AliTRDclusterizerHLT.cxx [deleted file]
HLT/TRD/AliTRDclusterizerHLT.h [deleted file]
HLT/libAliHLTTRD.pkg

index 1752b9916fe7691bff833b96d2c367b41c9ba608..0705b3977cc9b525ed337aeaedfa11424be9ae8d 100644 (file)
@@ -4,12 +4,12 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class AliTRDclusterizerHLT;
+#pragma link C++ class AliHLTTRDClusterizer;
 #pragma link C++ class AliHLTTRDClusterizerComponent;
-#pragma link C++ class AliHLTTRDTrackerComponent;
 #pragma link C++ class AliHLTTRDTrackerV1Component;
 #pragma link C++ class AliHLTTRDDefinitions;
 #pragma link C++ class AliHLTTRDEsdWriterComponent;
 #pragma link C++ class AliHLTTRDCalibrationComponent;
+#pragma link C++ class AliHLTTRDUtils;
 #endif
 
index de528de96c9acbf877f625103aa70121777ab7fe..1d554d94dae9e697983f4425a30fa2dad296693b 100644 (file)
@@ -33,7 +33,6 @@ AliHLTTRDAgent gAliHLTTRDAgent;
 
 // component headers
 #include "AliHLTTRDClusterizerComponent.h"
-#include "AliHLTTRDTrackerComponent.h"
 #include "AliHLTTRDTrackerV1Component.h"
 #include "AliHLTTRDCalibrationComponent.h"
 #include "AliHLTTRDEsdWriterComponent.h"
@@ -86,7 +85,6 @@ int AliHLTTRDAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
   // see header file for class documentation
   if (!pHandler) return -EINVAL;
   pHandler->AddComponent(new AliHLTTRDClusterizerComponent);
-  pHandler->AddComponent(new AliHLTTRDTrackerComponent);
   pHandler->AddComponent(new AliHLTTRDTrackerV1Component);
   pHandler->AddComponent(new AliHLTTRDCalibrationComponent);
   pHandler->AddComponent(new AliHLTTRDEsdWriterComponent);
index d3b8fd2edf3debe8cb0270dd2eb934731762c384..629a1ca7f9bb08cda7c956e530a3b4b3ca59c4a3 100644 (file)
 
 /** @file   AliHLTTRDCalibrationComponent.cxx
     @author Timm Steinbeck, Matthias Richter
-    @date   
+    @date
     @brief  A TRDCalibration processing component for the HLT. */
 
 #if __GNUC__ >= 3
-using namespace std;
+    using namespace std;
 #endif
 
 #include "TTree.h"
@@ -31,12 +31,12 @@ using namespace std;
 
 #include "AliHLTTRDCalibrationComponent.h"
 #include "AliHLTTRDDefinitions.h"
-#include "AliHLTTRDTrack.h"
+#include "AliHLTTRDUtils.h"
 
 #include "AliCDBManager.h"
-#include "AliTRDclusterizerHLT.h"
 #include "AliRawReaderMemory.h"
 #include "AliTRDCalibraFillHisto.h"
+#include "AliTRDtrackV1.h"
 
 #include <cstdlib>
 #include <cerrno>
@@ -46,315 +46,235 @@ using namespace std;
 AliHLTTRDCalibrationComponent gAliHLTTRDCalibrationComponent;
 
 ClassImp(AliHLTTRDCalibrationComponent);
-   
+
 AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent():
-  AliHLTCalibrationProcessor(),
-  fTRDCalibraFillHisto(NULL),
-  fUseHLTTracks(kFALSE),
-  fOutputPercentage(100), // By default we copy to the output exactly what we got as input  
-  fStrorageDBpath("local://$ALICE_ROOT/OCDB"),
-  fCDB(NULL)
+    AliHLTCalibrationProcessor(),
+    fTRDCalibraFillHisto(NULL),
+    fOutputPercentage(100), // By default we copy to the output exactly what we got as input
+    fStrorageDBpath("local://$ALICE_ROOT/OCDB"),
+    fCDB(NULL)
 {
-  // Default constructor
+    // Default constructor
 }
 
 AliHLTTRDCalibrationComponent::~AliHLTTRDCalibrationComponent()
 {
-  // Destructor
-  ;
+    // Destructor
+    ;
 }
 
 const char* AliHLTTRDCalibrationComponent::GetComponentID()
 {
-  // Return the component ID const char *
-  return "TRDCalibration"; // The ID of this component
+    // Return the component ID const char *
+    return "TRDCalibration"; // The ID of this component
 }
 
 void AliHLTTRDCalibrationComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
 {
-  // Get the list of input data
-  list.clear(); // We do not have any requirements for our input data type(s).
-  list.push_back( AliHLTTRDDefinitions::fgkTRDSATracksDataType );
+    // Get the list of input data
+    list.clear(); // We do not have any requirements for our input data type(s).
+    list.push_back( AliHLTTRDDefinitions::fgkTRDSATracksDataType );
 }
 
 AliHLTComponent_DataType AliHLTTRDCalibrationComponent::GetOutputDataType()
 {
-  // Get the output data type
-  return AliHLTTRDDefinitions::fgkCalibrationDataType;
+    // Get the output data type
+    return AliHLTTRDDefinitions::fgkCalibrationDataType;
 }
 
 void AliHLTTRDCalibrationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 {
-  // Get the output data size
-  constBase = 0;
-  inputMultiplier = ((double)fOutputPercentage)/100.0;
+    // Get the output data size
+    constBase = 0;
+    inputMultiplier = ((double)fOutputPercentage)/100.0;
 }
 
 AliHLTComponent* AliHLTTRDCalibrationComponent::Spawn()
 {
-  // Spawn function, return new instance of this class
-  return new AliHLTTRDCalibrationComponent;
+    // Spawn function, return new instance of this class
+    return new AliHLTTRDCalibrationComponent;
 };
 
 Int_t AliHLTTRDCalibrationComponent::ScanArgument( int argc, const char** argv )
 {
-  // perform initialization. We check whether our relative output size is specified in the arguments.
-  fOutputPercentage = 100;
-  int i = 0;
-  char* cpErr;
-  while ( i < argc )
-    {
-      HLTDebug("argv[%d] == %s", i, argv[i] );
-      if ( !strcmp( argv[i], "output_percentage" ) )
-       {
-         if ( i+1>=argc )
-           {
-             HLTError("Missing output_percentage parameter");
-             return ENOTSUP;
-           }
-         HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
-         fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
-         if ( *cpErr )
-           {
-             HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
-             return EINVAL;
-           }
-         HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
-         i += 2;
-         continue;
-       }
-      else if ( strcmp( argv[i], "-cdb" ) == 0)
-       {
-         if ( i+1 >= argc )
-           {
-             HLTError("Missing -cdb argument");
-             return ENOTSUP;         
-           }
-         fStrorageDBpath = argv[i+1];
-         HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
-         i += 2;
-         continue;
-       }  
-      else if ( strcmp( argv[i], "-useHLTTracks" ) == 0){
-       fUseHLTTracks = kTRUE;
-       i++;
-       HLTInfo("Expecting block of AliHLTTracks as input. Using low-level interface");
-      }
-      else{
-       HLTError("Unknown option '%s'", argv[i] );
-       return EINVAL;
-      }
-    }
-  return 0;
+    // perform initialization. We check whether our relative output size is specified in the arguments.
+    int i = 0;
+    char* cpErr;
+    while ( i < argc )
+        {
+            HLTDebug("argv[%d] == %s", i, argv[i] );
+            if ( !strcmp( argv[i], "output_percentage" ) )
+                {
+                    if ( i+1>=argc )
+                        {
+                            HLTError("Missing output_percentage parameter");
+                            return ENOTSUP;
+                        }
+                    HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
+                    fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
+                    if ( *cpErr )
+                        {
+                            HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
+                            return EINVAL;
+                        }
+                    HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
+                    i += 2;
+                    continue;
+                }
+            else if ( strcmp( argv[i], "-cdb" ) == 0)
+                {
+                    if ( i+1 >= argc )
+                        {
+                            HLTError("Missing -cdb argument");
+                            return ENOTSUP;
+                        }
+                    fStrorageDBpath = argv[i+1];
+                    HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );
+                    i += 2;
+                    continue;
+                }
+            else {
+                HLTError("Unknown option '%s'", argv[i] );
+                return EINVAL;
+            }
+        }
+    return 0;
 }
 
 Int_t AliHLTTRDCalibrationComponent::InitCalibration()
 {
-  //init the calibration
-  fCDB = AliCDBManager::Instance();
-  if (!fCDB)
-    {
-      HLTError("Could not get CDB instance, fCDB 0x%x", fCDB);
-    }
-  else
-    {
-      fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
-      fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
-      HLTDebug("fCDB 0x%x", fCDB);
-    }
-  fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
-  fTRDCalibraFillHisto->SetHisto2d(); // choose to use histograms
-  fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
-  fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
-  fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
-  fTRDCalibraFillHisto->Init2Dhistos(); // initialise the histos
-  return 0;
+    //init the calibration
+    fCDB = AliCDBManager::Instance();
+    if (!fCDB)
+        {
+            HLTError("Could not get CDB instance, fCDB 0x%x", fCDB);
+        }
+    else
+        {
+            fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
+            fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
+            HLTDebug("fCDB 0x%x", fCDB);
+        }
+    fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
+    fTRDCalibraFillHisto->SetHisto2d(); // choose to use histograms
+    fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
+    fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
+    fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
+    fTRDCalibraFillHisto->Init2Dhistos(); // initialise the histos
+    return 0;
 }
 
 Int_t AliHLTTRDCalibrationComponent::DeinitCalibration()
 {
-  HLTDebug("DeinitCalibration");
-  
-  // Deinitialization of the component
-
-  if (fCDB)
-    {
-      HLTDebug("destroy fCDB");
-      fCDB->Destroy();
-      fCDB = 0;
-    }
-  return 0;
+    HLTDebug("DeinitCalibration");
+
+    // Deinitialization of the component
+
+    if (fCDB)
+        {
+            HLTDebug("destroy fCDB");
+            fCDB->Destroy();
+            fCDB = 0;
+        }
+    return 0;
 }
 
 Int_t AliHLTTRDCalibrationComponent::ProcessCalibration(const AliHLTComponent_EventData& evtData,
-                                                       const AliHLTComponent_BlockData* blocks,
-                                                       AliHLTComponent_TriggerData& /*trigData*/,
-                                                       AliHLTUInt8_t* /*outputPtr*/,
-                                                       AliHLTUInt32_t& /*size*/,
-                                                       vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
+                                                        const AliHLTComponent_BlockData* blocks,
+                                                        AliHLTComponent_TriggerData& /*trigData*/,
+                                                        AliHLTUInt8_t* /*outputPtr*/,
+                                                        AliHLTUInt32_t& /*size*/,
+                                                        vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 {
-  // Process an event
-  //   Logging( kHLTLogInfo, "HLT::TRDCalibration::ProcessCalibration", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
-  HLTDebug("NofBlocks %lu", evtData.fBlockCnt );
-  // Process an event
-
-  // Loop over all input blocks in the event
-  vector<AliHLTComponent_DataType> expectedDataTypes;
-  GetInputDataTypes(expectedDataTypes);
-  for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
-    {
-      const AliHLTComponentBlockData &block = blocks[iBlock];
-      AliHLTComponentDataType inputDataType = block.fDataType;
-      Bool_t correctDataType = kFALSE;
-      
-      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",
-                   iBlock, evtData.fBlockCnt,
-                   evtData.fEventID, evtData.fEventID, 
-                   DataType2Text(inputDataType).c_str());
-         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());
-
-      TClonesArray* tracksArray = NULL;
-      int ibForce = 0;
-      if (fUseHLTTracks)
-       {
-         tracksArray = new TClonesArray("AliTRDtrackV1");
-         HLTDebug("BLOCK fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x, fDataType %s", block.fPtr, block.fOffset, block.fSize, block.fSpecification, DataType2Text(block.fDataType).c_str());
-         ReadTracks(tracksArray, block.fPtr, block.fSize);
-       }
-      else
-       {
-         TObject *objIn = NULL;
-         if (iBlock == 0)
-           objIn = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkTRDSATracksDataType, "TClonesArray", ibForce);
-         else
-           objIn = (TObject *)GetNextInputObject( ibForce );
-         HLTDebug("1stBLOCK, Pointer = 0x%x", objIn);
-         if (objIn){
-           tracksArray = (TClonesArray* )objIn;
-         }
-       }
-
-      if (tracksArray)
-       {
-         Int_t nbEntries = tracksArray->GetEntries();
-         HLTDebug(" %i TRDtracks in tracksArray", nbEntries);
-         AliTRDtrackV1* trdTrack = 0x0;
-         for (Int_t i = 0; i < nbEntries; i++){
-           HLTDebug("%i/%i: ", i+1, nbEntries);
-           trdTrack = (AliTRDtrackV1*)tracksArray->At(i);
-           trdTrack->Print();
-           fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
-         }
-       }
-      
-
-      TObjArray *outArray = FormOutput();
-      if (outArray){
-       PushBack(outArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
-       delete outArray;
-      }
-      
-    }
-  return 0;
-  
+    HLTDebug("NofBlocks %lu", evtData.fBlockCnt );
+    // Process an event
+
+    // Loop over all input blocks in the event
+    vector<AliHLTComponent_DataType> expectedDataTypes;
+    GetInputDataTypes(expectedDataTypes);
+    for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
+        {
+            const AliHLTComponentBlockData &block = blocks[iBlock];
+            AliHLTComponentDataType inputDataType = block.fDataType;
+            Bool_t correctDataType = kFALSE;
+
+            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",
+                          iBlock, evtData.fBlockCnt,
+                          evtData.fEventID, evtData.fEventID,
+                          DataType2Text(inputDataType).c_str());
+                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());
+
+            TClonesArray* tracksArray = NULL;
+            tracksArray = new TClonesArray("AliTRDtrackV1");
+            HLTDebug("BLOCK fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x, fDataType %s", block.fPtr, block.fOffset, block.fSize, block.fSpecification, DataType2Text(block.fDataType).c_str());
+            AliHLTTRDUtils::ReadTracks(tracksArray, block.fPtr, block.fSize);
+
+            if (tracksArray) {
+                Int_t nbEntries = tracksArray->GetEntries();
+                HLTDebug(" %i TRDtracks in tracksArray", nbEntries);
+                AliTRDtrackV1* trdTrack = 0x0;
+                for (Int_t i = 0; i < nbEntries; i++){
+                    HLTDebug("%i/%i: ", i+1, nbEntries);
+                    trdTrack = (AliTRDtrackV1*)tracksArray->At(i);
+                    trdTrack->Print();
+                    fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
+                }
+            }
+
+
+            TObjArray *outArray = FormOutput();
+            if (outArray) {
+                PushBack(outArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
+                delete outArray;
+            }
+
+        }
+    return 0;
+
 }
 
+
 /**
- * Read track to the TClonesArray from the memory 
+ * Form output array of histrograms
  */
 //============================================================================
-Int_t AliHLTTRDCalibrationComponent::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+TObjArray* AliHLTTRDCalibrationComponent::FormOutput()
 {
-  AliHLTUInt8_t* iterPtr = (AliHLTUInt8_t* )inputPtr;
-  
-  cout << "\nReading tracks from the Memory\n ============= \n";
-  AliHLTTRDTrack * hltTrack;
-  AliHLTUInt32_t trackSize = 0, curSize = 0;
-  Int_t counter=0;
-  
-  while (curSize < size)
-    {
-      hltTrack = (AliHLTTRDTrack*) iterPtr;
-      HLTDebug("curSize %i, size %i",curSize, size);
-      
-      trackSize = hltTrack->GetSize();
-      HLTDebug("GetSize() %i", trackSize);
-
-      hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
-
-      AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
-      hltTrack->ExportTRDTrack(curTRDTrack);
-      
-      curSize += trackSize; 
-      iterPtr += trackSize;
-      counter++;
-    }
-
-  //CheckTrackArray(outArray);
-  return counter;
-}
+    TObjArray *outArray=new TObjArray(3);
 
+    // gain histo
+    TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
+    outArray->Add(hCH2d);
 
-Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
-{
-//   //Int_t PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, const char* pDDLNumber = "");
-//   //ireturn = PushToFXS(object, "TRD ", "TRDCalib", "1024 ");
-
-  TObjArray *outArray = FormOutput();
-  HLTDebug("Shipping data. Dummy. outputArray: pointer = 0x%x; NEntries = %i;", outArray, outArray->GetEntries());
-  Int_t ireturn = PushToFXS(outArray, "TRD ", "TRDCalib");
-  
-  if (outArray){
-    outArray->Delete();
-    delete outArray;
-  }
-  
-  return ireturn;
-}
+    // drift velocity histo
+    TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
+    outArray->Add(hPH2d);
 
+    // PRF histo
+    TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d();
+    outArray->Add(hPRF2d);
+
+    HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(hCH2d));
+    hCH2d->Print();
+    HLTDebug("GetPH2d = 0x%x; NEntries = %i; size = %i", hPH2d, hPH2d->GetEntries(), sizeof(hPH2d));
+    hPH2d->Print();
+    HLTDebug("GetPRF2d = 0x%x; NEntries = %i; size = %i", hPRF2d, hPRF2d->GetEntries(), sizeof(hPRF2d));
+    hPRF2d->Print();
+    HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", outArray, outArray->GetEntries(), sizeof(outArray));
+
+
+
+    return outArray;
 
-/**
- * Form output array of histrograms 
- */
-//============================================================================
-TObjArray* AliHLTTRDCalibrationComponent::FormOutput()
-{
-  TObjArray *outArray=new TObjArray(3);
-
-  // gain histo
-  TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
-  outArray->Add(hCH2d);
-
-  // drift velocity histo
-  TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
-  outArray->Add(hPH2d);
-       
-  // PRF histo
-  TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d(); 
-  outArray->Add(hPRF2d);
-
-  HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(hCH2d));
-  hCH2d->Print();
-  HLTDebug("GetPH2d = 0x%x; NEntries = %i; size = %i", hPH2d, hPH2d->GetEntries(), sizeof(hPH2d));
-  hPH2d->Print();
-  HLTDebug("GetPRF2d = 0x%x; NEntries = %i; size = %i", hPRF2d, hPRF2d->GetEntries(), sizeof(hPRF2d));
-  hPRF2d->Print();
-  HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", outArray, outArray->GetEntries(), sizeof(outArray));
-    
-  
-  
-  return outArray;
-  
 }
 
index d0a0964e8998995ab54b654a34914fe04f6c3d78..11937244ce72bc6c2ac085c5ffd55794621bf55f 100644 (file)
@@ -61,23 +61,20 @@ class AliHLTTRDCalibrationComponent : public AliHLTCalibrationProcessor
                                         AliHLTUInt32_t& size,
                                         vector<AliHLTComponent_BlockData>& outputBlocks);
 /*     virtual Int_t ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData); */
-       virtual Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
+//     virtual Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
        
        using AliHLTCalibrationProcessor::ProcessCalibration;
-       using AliHLTCalibrationProcessor::ShipDataToFXS;
+//     using AliHLTCalibrationProcessor::ShipDataToFXS;
 
-       Bool_t fUseHLTTracks;
-       Int_t ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
-       
     private:
        /** copy constructor prohibited */
        AliHLTTRDCalibrationComponent(const AliHLTTRDCalibrationComponent&);
        /** assignment operator prohibited */
        AliHLTTRDCalibrationComponent& operator=(const AliHLTTRDCalibrationComponent&);
        TObjArray* FormOutput();
+
        // The size of the output data produced, as a percentage of the input data's size.
-       // Can be greater than 100 (%)
-       
+       // Can be greater than 100 (%)  
        unsigned fOutputPercentage; // Output volume in percentage of the input
        string fStrorageDBpath; // Default path for OCDB
        AliCDBManager *fCDB; //! Pointer to OCDB
index a62f11efd19ea47dc3c6f111ccbe582744584e4d..50d85ffc6f2aa0586e6a60656ece79ecc6a57b84 100644 (file)
@@ -1,20 +1,18 @@
 #include "AliHLTTRDCluster.h"
 
-
 /**
  * Default Constructor
  */
 //============================================================================
 AliHLTTRDCluster::AliHLTTRDCluster():
-  fSize(sizeof(AliHLTTRDCluster)),
   fX(0),
   fY(0),
   fZ(0),
+  fQ(0),
   fIsInChamber(kFALSE),
   fIsShared(kFALSE),
   fDetector(-1),
   fLocalTimeBin(0),
-  fQ(0),
   fClusterMasking(0),
   fPadCol(0),
   fPadRow(0),
@@ -27,15 +25,14 @@ AliHLTTRDCluster::AliHLTTRDCluster():
  */
 //============================================================================
 AliHLTTRDCluster::AliHLTTRDCluster(AliTRDcluster * inCluster):
-  fSize (sizeof(AliHLTTRDCluster)),
   fX (inCluster->GetX()),
   fY (inCluster->GetY()),
   fZ (inCluster->GetZ()),
+  fQ (inCluster->GetQ()),
   fIsInChamber(inCluster->IsInChamber()),
   fIsShared (inCluster->IsShared()),
   fDetector (inCluster->GetDetector()),
   fLocalTimeBin (inCluster->GetLocalTimeBin()),
-  fQ (inCluster->GetQ()),
   fClusterMasking (inCluster->IsMasked()),
   fPadCol (inCluster->GetPadCol()),
   fPadRow (inCluster->GetPadRow()),
@@ -56,11 +53,11 @@ void AliHLTTRDCluster::ExportTRDCluster(AliTRDcluster *outCluster)
   outCluster->SetX(fX);
   outCluster->SetY(fY);
   outCluster->SetZ(fZ);
+  outCluster->SetQ(fQ);
   outCluster->SetInChamber(fIsInChamber);
   outCluster->SetShared(fIsShared);
   outCluster->SetDetector(fDetector);
   outCluster->SetLocalTimeBin(fLocalTimeBin);
-  outCluster->SetQ(fQ);
   outCluster->SetClusterMasking(fClusterMasking);
 
   outCluster->SetPadCol(fPadCol);
@@ -78,7 +75,7 @@ void AliHLTTRDCluster::ExportTRDCluster(AliTRDcluster *outCluster)
 //============================================================================
 void AliHLTTRDCluster::Print()
 {
-  //printf("   --hltCluster-- addr 0x%x(%i); fSize %i\n", this, (int)this, this->GetSize());
+  //printf("   --hltCluster-- addr 0x%x(%i); sizeof(*this) %i\n", this, (int)this, this->GetSize());
   //printf("     fX %f; fY %f; fZ %f\n",fX,fY,fZ);
   
 }
index 7b3658f185e7828ae0db595475a82bc218996770..9cc5b6ea5b77cff90b4212e6bad1572eee44993d 100644 (file)
@@ -12,34 +12,30 @@ class AliHLTTRDCluster
   void ExportTRDCluster(AliTRDcluster* outCluster);
 
   AliHLTUInt8_t *GetEndPointer() // Returns pointer to the end of the cluster
-    { return ((AliHLTUInt8_t *) this + fSize); };
-  AliHLTUInt32_t GetSize(){ return fSize; };
-  void Print();
-  
-  AliHLTUInt32_t fSize; // Size of the Cluster
-      
+  { return ((AliHLTUInt8_t *) this + sizeof(*this)); };
+  AliHLTUInt32_t GetSize(){ return sizeof(*this); };
+  void Print();      
   
  private:
   // From AliCluster
   Float_t  fX;        // X of the cluster in the tracking c.s.
   Float_t  fY;        // Y of the cluster in the tracking c.s.
   Float_t  fZ;        // Z of the cluster in the tracking c.s.
+  Float_t  fQ;        //  Amplitude 
 
-  Bool_t fIsInChamber;
-  Bool_t fIsShared;
+  Bool_t  fIsInChamber;
+  Bool_t  fIsShared;
   Short_t fDetector;       //  TRD detector number
   Char_t  fLocalTimeBin;   //  T0-calibrated time bin number
-  Float_t fQ;              //  Amplitude 
   UChar_t fClusterMasking; //  Bit field containing cluster status information;
 
   // From AliTRDcluster
-   UChar_t fPadCol;         //  Central pad number in column direction 
-   UChar_t fPadRow;         //  Central pad number in row direction 
-   UChar_t fPadTime;        //  Uncalibrated time bin number 
-   //   Short_t fSignals[7];     //  Signals in the cluster 
-//   UChar_t fNPads;          //  Number of pads in cluster 
-//   Float_t fCenter;         //  Center of the cluster relative to the pad  
-
+  UChar_t fPadCol;         //  Central pad number in column direction 
+  UChar_t fPadRow;         //  Central pad number in row direction 
+  UChar_t fPadTime;        //  Uncalibrated time bin number 
+  //   Short_t fSignals[7];     //  Signals in the cluster 
+  //   UChar_t fNPads;          //  Number of pads in cluster 
+  //   Float_t fCenter;         //  Center of the cluster relative to the pad  
    
 };
 
diff --git a/HLT/TRD/AliHLTTRDClusterizer.cxx b/HLT/TRD/AliHLTTRDClusterizer.cxx
new file mode 100644 (file)
index 0000000..1976f54
--- /dev/null
@@ -0,0 +1,91 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// HLT TRD cluster finder                                                    //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliHLTTRDClusterizer.h"
+#include "AliTRDgeometry.h"
+#include "AliTRDcluster.h"
+#include "AliTRDReconstructor.h"
+#include <TClonesArray.h>
+
+ClassImp(AliHLTTRDClusterizer);
+
+//_____________________________________________________________________________
+AliHLTTRDClusterizer::AliHLTTRDClusterizer(const AliTRDReconstructor *const rec)
+  :AliTRDclusterizer(rec)
+  , fMemBlock(NULL)
+{
+  //
+  // AliHLTTRDClusterizer default constructor
+  //
+}
+
+//_____________________________________________________________________________
+AliHLTTRDClusterizer::AliHLTTRDClusterizer(const Text_t *const name, const Text_t *const title, const AliTRDReconstructor *const rec)
+  : AliTRDclusterizer(name,title,rec)
+  , fMemBlock(NULL)
+{
+  //
+  // AliHLTTRDClusterizer constructor
+  //
+}
+
+//_____________________________________________________________________________
+AliHLTTRDClusterizer::AliHLTTRDClusterizer(const AliHLTTRDClusterizer& c)
+  : AliTRDclusterizer(c)
+  , fMemBlock(NULL)
+{
+  //
+  // AliHLTTRDClusterizer copy constructor
+  //
+}
+
+//_____________________________________________________________________________
+AliHLTTRDClusterizer& AliHLTTRDClusterizer::operator=(const AliHLTTRDClusterizer& c)
+{
+  //
+  // Assignment operator
+  //
+  
+  if(this!=&c) 
+    c.Copy(*this);
+  return *this;
+}
+
+//_____________________________________________________________________________
+void AliHLTTRDClusterizer::Copy(TObject& c) const
+{
+  //
+  // Copy function
+  //
+
+  ((AliHLTTRDClusterizer&)c).fMemBlock  = NULL;
+}
+
+//_____________________________________________________________________________
+void AliHLTTRDClusterizer::AddClusterToArray(AliTRDcluster *cluster)
+{
+  //
+  // Add a cluster to the array
+  //
+
+  AliHLTTRDCluster *ptr = &(((AliHLTTRDCluster*)GetMemBlock())[fNoOfClusters]);
+  new(ptr) AliHLTTRDCluster(cluster);
+}
diff --git a/HLT/TRD/AliHLTTRDClusterizer.h b/HLT/TRD/AliHLTTRDClusterizer.h
new file mode 100644 (file)
index 0000000..2b01fa3
--- /dev/null
@@ -0,0 +1,47 @@
+#ifndef ALIHLTTRDCLUSTERIZER_H
+#define ALIHLTTRDCLUSTERIZER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+//  HLT TRD cluster finder                                                //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
+#include "AliTRDclusterizer.h"
+#include "AliHLTTRDCluster.h"
+#include "AliHLTDataTypes.h"
+
+class AliTRDReconstructor;
+class TClonesArray;
+
+class AliHLTTRDClusterizer : public AliTRDclusterizer
+{
+ public:
+  AliHLTTRDClusterizer(const AliTRDReconstructor *const rec = 0x0);
+  AliHLTTRDClusterizer(const Text_t *const name, const Text_t *const title, const AliTRDReconstructor *const rec = 0x0);
+  AliHLTTRDClusterizer(const AliHLTTRDClusterizer& c);
+  AliHLTTRDClusterizer& operator=(const AliHLTTRDClusterizer& c);
+
+  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);
+  
+  AliHLTUInt8_t*  fMemBlock;
+
+  ClassDef(AliHLTTRDClusterizer, 0)
+};
+
+#endif
index 38e8944cb8c4e1459c4a4e9c5f77710ea30d11d3..5f05fd468b92b99598bae7c445380059948a7880 100644 (file)
@@ -42,7 +42,7 @@ using namespace std;
 #include "AliGeomManager.h"
 #include "AliTRDReconstructor.h"
 #include "AliCDBManager.h"
-#include "AliTRDclusterizerHLT.h"
+#include "AliHLTTRDClusterizer.h"
 #include "AliTRDrecoParam.h"
 #include "AliTRDrawStreamBase.h"
 #include "AliTRDcluster.h"
@@ -71,8 +71,7 @@ AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
   fCDB(NULL),
   fMemReader(NULL),
   fReconstructor(NULL),
-  fGeometryFileName(""),
-  fUseHLTClusters(kFALSE)
+  fGeometryFileName("")
 {
   // Default constructor
 
@@ -86,41 +85,6 @@ AliHLTTRDClusterizerComponent::~AliHLTTRDClusterizerComponent()
   // Work is Done in DoDeInit()
 }
 
-/**
- * Convert AliTRDcluster to AliHLTTRDCluster 
- * Add HLTCluster to the output, defined by pointer
- * Fill block desctiptors 
- * Return size of the added to ouput objects
- */
-//============================================================================
-UInt_t AliHLTTRDClusterizerComponent::AddToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr)
-{
-  AliTRDcluster* cluster = 0;
-  AliHLTUInt32_t addedSize = 0;
-  //  == OUTdatatype pointer
-  AliHLTTRDCluster * outPtr = (AliHLTTRDCluster*)outBlockPtr;
-  
-  if (inClusterArray){
-    Int_t nbEntries  = inClusterArray->GetEntries();
-    for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
-      //cout << "Geting cluster #" << iCluster << endl;
-      UInt_t blockSize=0;
-      
-      cluster = dynamic_cast<AliTRDcluster*>(inClusterArray->At(iCluster));
-
-      AliHLTTRDCluster *hltCluster = new (outPtr) AliHLTTRDCluster(cluster);
-      //cout << Form("cluster added at 0x%x (%i)\n",outPtr,outPtr);
-
-      blockSize = sizeof(*hltCluster);
-
-      addedSize += blockSize;
-      outBlockPtr += blockSize;
-      outPtr = (AliHLTTRDCluster*)outBlockPtr;
-    }
-  }
-  return addedSize;
-  
-}
 
 const char* AliHLTTRDClusterizerComponent::GetComponentID()
 {
@@ -161,8 +125,6 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
   Int_t iRawDataVersion = 2;
   int i = 0;
   char* cpErr;
-  Bool_t bWriteClusters = kFALSE;
-  
 
   Int_t iRecoParamType = -1; // default will be the low flux
 
@@ -264,19 +226,7 @@ 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], "-writeClusters" ) == 0)
-       {
-         bWriteClusters = kTRUE;
-         i++;
-       }
-      else if ( strcmp( argv[i], "-useHLTClusters" ) == 0)
-       {
-         fUseHLTClusters = kTRUE;
-         i++;
-         HLTInfo("Using AliHLTCluster to pass data further in the chain");
-       }
       else{
        HLTError("Unknown option '%s'", argv[i] );
        return EINVAL;
@@ -319,16 +269,8 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
   fReconstructor = new AliTRDReconstructor();
   fReconstructor->SetRecoParam(fRecoParam);
   fReconstructor->SetStreamLevel(0, AliTRDReconstructor::kClusterizer); // default value
-  if (bWriteClusters)
-    {
-      HLTInfo("Writing clusters. I.e. output is a TTree with clusters");
-      fReconstructor->SetOption("cw,sl_cf_0");
-    }
-  else
-    {
-      HLTInfo("Not writing clusters. I.e. output is a TClonesArray of clusters");
-      fReconstructor->SetOption("!cw,sl_cf_0");
-    }
+  HLTInfo("Not writing clusters. I.e. output is a TClonesArray of clusters");
+  fReconstructor->SetOption("hlt,!cw,sl_cf_0");
   
   
   // init the raw data type to be used...
@@ -380,11 +322,10 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
   
   fMemReader = new AliRawReaderMemory;
 
-  fClusterizer = new AliTRDclusterizerHLT("TRDCclusterizer", "TRDCclusterizer");
+  fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer");
   fClusterizer->SetReconstructor(fReconstructor);
-
+  fClusterizer->SetAddLabels(kFALSE);
   fClusterizer->SetRawVersion(iRawDataVersion);
-  fClusterizer->InitClusterTree();
   return 0;
 }
 
@@ -428,7 +369,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
   HLTDebug( "NofBlocks %lu", evtData.fBlockCnt );
   // Process an event
   AliHLTUInt32_t totalSize = 0, offset = 0;
-  Bool_t bWriteClusters = fReconstructor->IsWritingClusters();
 
   //implement a usage of the following
   //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
@@ -483,7 +423,7 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
 
       fMemReader->SetEquipmentID( id ); 
       
-      fClusterizer->ResetTree();  
+      fClusterizer->SetMemBlock(outputPtr);
       Bool_t iclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
       if (iclustered == kTRUE)
        {
@@ -497,70 +437,35 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
 
       // put the tree into output
       //fcTree->Print();
-      if (bWriteClusters)
-       {
-         TTree *fcTree = fClusterizer->GetClusterTree();
-         if (fcTree)
+      
+      AliHLTUInt32_t addedSize = fClusterizer->GetAddedSize();
+       if (addedSize > 0){
+         // Using low-level interface 
+         // with interface classes
+         totalSize += addedSize;
+         if ( totalSize > size )
            {
-             Int_t nbEntries = fcTree->GetEntriesFast();
-             if (nbEntries > 0){
-               HLTDebug("fcTree: Entries - %i; Size - %i",nbEntries,sizeof(fcTree));
-               PushBack(fcTree, AliHLTTRDDefinitions::fgkClusterDataType, spec);
-             }
-             
+             HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+                      totalSize, size );
+             return EMSGSIZE;
            }
-         fClusterizer->RecPoints()->Delete();
-         
-       }
-      else
-       {
-         TClonesArray *clustersArray = fClusterizer->RecPoints();
-         fClusterizer->SetClustersOwner(kFALSE);
-         if (clustersArray){
-           Int_t nbEntries = clustersArray->GetEntriesFast();
-           if (nbEntries > 0){
-             if (fUseHLTClusters){
-               // Using low-level interface 
-                // with interface classes
-               AliHLTUInt32_t addedSize = AddToOutput(clustersArray, outputPtr);
-               totalSize += addedSize;
-               if ( totalSize > size )
-                 {
-                   HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
-                            totalSize, size );
-                   return EMSGSIZE;
-                 }
                
-               // Fill block 
-               AliHLTComponentBlockData bd;
-               FillBlockData( bd );
-               bd.fOffset = offset;
-               bd.fSize = addedSize;
-               //bd.fSpecification = spec;
-               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);
-
-             }
-             else{
-               // Using high-level interface
-                // pass TClonesArray with streamers
-               clustersArray->BypassStreamer(kFALSE);
-               HLTDebug("clustersArray: Entries - %i; Size - %i",clustersArray->GetEntriesFast(),sizeof(clustersArray));
-               PushBack(clustersArray, AliHLTTRDDefinitions::fgkClusterDataType, spec);
-               //PrintObject(clustersArray);
-             }
+         // Fill block 
+         AliHLTComponentBlockData bd;
+         FillBlockData( bd );
+         bd.fOffset = offset;
+         bd.fSize = addedSize;
+         //bd.fSpecification = spec;
+         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);
              
-             clustersArray->Delete();
-           }
-           delete clustersArray;
-         }
-         else 
-           HLTWarning("Array of clusters is empty!");
        }
-    }//  for ( unsigned long i = 0; i < evtData.fBlockCnt; i++ )
+       else 
+         HLTWarning("Array of clusters is empty!");
+    }
   fReconstructor->SetClusters(0x0);
 
   size = totalSize;
index 90978113818d53b429c8e7626ed8f230a34fc3b5..d0236d2386954b01b4140fe4355664187a9cd88c 100644 (file)
@@ -13,7 +13,7 @@
 
 #include "AliHLTProcessor.h"
 class AliCDBManager;
-class AliTRDclusterizerHLT;
+class AliHLTTRDClusterizer;
 class AliRawReaderMemory;
 class TFile;
 class AliTRDrecoParam;
@@ -65,8 +65,6 @@ class AliHLTTRDClusterizerComponent : public AliHLTProcessor
        /** assignment operator prohibited */
        AliHLTTRDClusterizerComponent& operator=(const AliHLTTRDClusterizerComponent&);
 
-       UInt_t AddToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr);
-
        // The size of the output data produced, as a percentage of the input data's size.
        // Can be greater than 100 (%)
 
@@ -74,7 +72,7 @@ class AliHLTTRDClusterizerComponent : public AliHLTProcessor
 
        string fStrorageDBpath; // Default path for OCDB
 
-       AliTRDclusterizerHLT *fClusterizer; //! Offline derived HLT clusterizer
+       AliHLTTRDClusterizer *fClusterizer; //! Offline derived HLT clusterizer
        AliTRDrecoParam *fRecoParam; //! Offline reco params
        AliCDBManager *fCDB; //! Pointer to OCDB
        AliRawReaderMemory *fMemReader; //! Input raw data reader
@@ -82,7 +80,6 @@ class AliHLTTRDClusterizerComponent : public AliHLTProcessor
        
 
        string fGeometryFileName; // Path to geometry file 
-       Bool_t fUseHLTClusters; // Use or not AliHLTCluster interface
        
        ClassDef(AliHLTTRDClusterizerComponent, 0)
 
index ef32444d5156fff1d38bd3cf806803b13b231f83..9b39e764cb20d14b57e1d624c85086cf7ffd9808 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliESDtrack.h"
 #include "TTree.h"
 #include "AliHLTTRDDefinitions.h"
+#include "AliHLTTRDUtils.h"                    \
 
 /** global instance for component registration */
 AliHLTTRDEsdWriterComponent gTRDEsdWriter;
@@ -36,6 +37,7 @@ AliHLTTRDEsdWriterComponent::AliHLTTRDEsdWriterComponent()
   :
   AliHLTRootFileWriterComponent(),
   fTree(NULL),
+  fOutputPercentage(100),
   fESD(NULL)
 {
   // see header file for class documentation
@@ -49,6 +51,7 @@ AliHLTTRDEsdWriterComponent::AliHLTTRDEsdWriterComponent(const AliHLTTRDEsdWrite
   :
   AliHLTRootFileWriterComponent(),
   fTree(NULL),
+  fOutputPercentage(100),
   fESD(NULL)
 {
 }
@@ -104,40 +107,35 @@ int AliHLTTRDEsdWriterComponent::CloseWriter()
   return iResult;
 }
 
-int AliHLTTRDEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& /*evtData*/,
-                                           const AliHLTComponentBlockData* /*blocks*/
-                                           AliHLTComponentTriggerData& trigData )
+int AliHLTTRDEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& evtData,
+                                           const AliHLTComponentBlockData*  blocks
+                                           AliHLTComponentTriggerData& /*trigData*/ )
 {
-  // see header file for class documentation
-  int iResult=0;
-  TTree* pTree=fTree;
-
-  AliHLTUInt32_t fDblock_Specification = 0;
+int result=0;
 
-  //implement a usage of the following
-  //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
-  //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
-  //   void *triggerData = trigData.fData;
-  Logging( kHLTLogDebug, "HLT::TRDEsdWriter::DumpEvent", "Trigger data received", 
-          "Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
-
-  //AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTTRDDefinitions::fgkTRDSAEsdDataType );
-  AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTTRDDefinitions::fgkTRDSATracksDataType );
-  if (dblock != 0)
+for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
     {
-      fDblock_Specification = dblock->fSpecification;
+    // HLTDebug("i am a debug message"); // y does it not print out debug messages???
+    /*HLTInfo("Block # %i/%i; Event 0x%08LX (%Lu)",
+                   iBlock, evtData.fBlockCnt,
+                   evtData.fEventID, evtData.fEventID);*/
+    
+
+    TClonesArray* tracksArray = NULL;
+    const AliHLTComponentBlockData &block = blocks[iBlock];
+    tracksArray = new TClonesArray("AliTRDtrackV1");
+    
+    //HLTInfo("BLOCK fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x, fDataType %s", block.fPtr, block.fOffset, block.fSize, block.fSpecification, DataType2Text(block.fDataType).c_str()); //HLTInfo instead of HLTDebug, because debug gives no output... -> strange
+
+    AliHLTTRDUtils::ReadTracks(tracksArray, block.fPtr, block.fSize); 
+
+    // give out number of tracklets in tracksArray
+    Int_t nbEntries = tracksArray->GetEntries();
+    HLTInfo(" %i TRDtracks in tracksArray", nbEntries); 
+    
     }
-  else
-    {
-      Logging( kHLTLogWarning, "HLT::TRDEsdWriter::DumpEvent", "DATAIN", "First Input Block not found! 0x%x", dblock);
-      return -1;
-    }
-
-  int ibForce = 1;
-  TObject *tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkTRDSATracksDataType, "AliESDtrack", ibForce);
-  Logging( kHLTLogInfo, "HLT::TRDEsdWriter::DumpEvent", "1stBLOCK", "Pointer = 0x%x", tobjin);
 
-  AliESDtrack* track = (AliESDtrack *)tobjin;
/*  AliESDtrack* track = (AliESDtrack *)tobjin;
   if (!track)
     {
       Logging( kHLTLogWarning, "HLT::TRDEsdWriter::DumpEvent", "DATAIN", "First Input Block not a ESDtrack! 0x%x", tobjin);
@@ -164,14 +162,62 @@ int AliHLTTRDEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& /*ev
 
   Logging( kHLTLogInfo, "HLT::TRDEsdWriter::DumpEvent", "Fill", "Ntracks: %d", nTracks);         
   pTree->Fill();
-  fESD->Reset();
+  fESD->Reset(); */
 
-  return iResult;
+  return result;
 }
 
-int AliHLTTRDEsdWriterComponent::ScanArgument(int argc, const char** argv)
+// int AliHLTTRDEsdWriterComponent::ScanArgument(int argc, const char** argv)
+// {
+//   // see header file for class documentation
+//   int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
+//   return iResult;
+// }
+
+int AliHLTTRDEsdWriterComponent::DoEvent(      const AliHLTComponent_EventData& /*evtData*/,
+                                               const AliHLTComponent_BlockData* /*blocks*/,
+                                               AliHLTComponent_TriggerData& /*trigData*/,
+                                               AliHLTUInt8_t* /*outputPtr*/,
+                                               AliHLTUInt32_t& /*size*/,
+                                               vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 {
-  // see header file for class documentation
-  int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
-  return iResult;
+HLTDebug("ignor me");
+return 0;
+
+}
+
+Int_t AliHLTTRDEsdWriterComponent::ScanArgument( int argc, const char** argv )
+{
+  // perform initialization. We check whether our relative output size is specified in the arguments.
+  int i = 0;
+  char* cpErr;
+  HLTDebug("argv[%d] == %s", i, argv[i] );
+      if ( !strcmp( argv[i], "output_percentage" ) )
+       {
+         if ( i+1>=argc )
+           {
+             HLTError("Missing output_percentage parameter");
+             return ENOTSUP;
+           }
+         HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
+         fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
+         if ( *cpErr )
+           {
+             HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
+             return EINVAL;
+           }
+         HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
+       
+    }
+    //AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
+
+  return 0;
+}
+
+
+void AliHLTTRDEsdWriterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
+{
+  // Get the output data size
+  constBase = 0;
+  inputMultiplier = ((double)fOutputPercentage)/100.0;
 }
index 60b6e4d8da22c174d6b47d8229cc3ff816b4a543..c403e776438eb9998599bccb6b701c703909bf48 100644 (file)
@@ -39,6 +39,7 @@ class AliHLTTRDEsdWriterComponent : public AliHLTRootFileWriterComponent
    * Spawn function.
    * @return new class instance
    */
+  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
   AliHLTComponent* Spawn() {return new AliHLTTRDEsdWriterComponent;}
 
  protected:
@@ -53,7 +54,7 @@ class AliHLTTRDEsdWriterComponent : public AliHLTRootFileWriterComponent
   virtual int DumpEvent( const AliHLTComponentEventData& evtData,
                         const AliHLTComponentBlockData* blocks, 
                         AliHLTComponentTriggerData& trigData );
-
+                        
   using AliHLTRootFileWriterComponent::DumpEvent;
 
   /**
@@ -65,6 +66,8 @@ class AliHLTTRDEsdWriterComponent : public AliHLTRootFileWriterComponent
    *         -EPROTO parameter for argument missing <br>
    */
   int ScanArgument(int argc, const char** argv);
+  
+  
 
  private:
   /** not a valid copy constructor, defined according to effective C++ style */
@@ -88,10 +91,21 @@ class AliHLTTRDEsdWriterComponent : public AliHLTRootFileWriterComponent
 
   /** the ESD tree */
   TTree* fTree; //! transient value
+  
+  /** output percentage descared*/
+  Int_t fOutputPercentage; 
 
   /** the ESD */
   AliESDEvent* fESD; //! transient value
 
+  int DoEvent( const AliHLTComponent_EventData& evtData,
+                                               const AliHLTComponent_BlockData* blocks,
+                                               AliHLTComponent_TriggerData& /*trigData*/,
+                                               AliHLTUInt8_t* /*outputPtr*/,
+                                               AliHLTUInt32_t& /*size*/,
+                                               vector<AliHLTComponent_BlockData>& /*outputBlocks*/);
+                                               
   ClassDef(AliHLTTRDEsdWriterComponent, 1)
+
 };
 #endif
diff --git a/HLT/TRD/AliHLTTRDTrackerComponent.cxx b/HLT/TRD/AliHLTTRDTrackerComponent.cxx
deleted file mode 100644 (file)
index 8f17832..0000000
+++ /dev/null
@@ -1,331 +0,0 @@
-// $Id$
-
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
- *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
- *          for The ALICE Off-line Project.                               *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/** @file   AliHLTTRDTrackerComponent.cxx
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  A TRDTracker processing component for the HLT. */
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-#include "TFile.h"
-#include "TChain.h"
-
-#include "AliHLTTRDTrackerComponent.h"
-#include "AliHLTTRDDefinitions.h"
-#include "AliCDBManager.h"
-
-#include "AliTRDReconstructor.h"
-#include "AliTRDrecoParam.h"
-#include "AliESDEvent.h"
-//#include "AliTRDtrackerHLT.h"
-#include "AliTRDtracker.h"
-#include "AliTRDCalibraFillHisto.h"
-#include "AliMagF.h"
-#include "AliTRDcluster.h"
-#include "AliESDfriend.h"
-#include <cstdlib>
-#include <cerrno>
-#include <string>
-
-// this is a global object used for automatic component registration, do not use this
-AliHLTTRDTrackerComponent gAliHLTTRDTrackerComponent;
-
-ClassImp(AliHLTTRDTrackerComponent);
-    
-AliHLTTRDTrackerComponent::AliHLTTRDTrackerComponent()
-  : AliHLTProcessor()
-  , fOutputPercentage(100) // By default we copy to the output exactly what we got as input  
-  , fStrorageDBpath("local://$ALICE_ROOT/OCDB")
-  , fCDB(NULL)
-  , fGeometryFileName("")
-  , fGeometryFile(NULL)
-  , fGeoManager(NULL)
-  , fTracker(NULL)
-{
-  // Default constructor
-
-  fGeometryFileName = getenv("ALICE_ROOT");
-  fGeometryFileName += "/HLT/TRD/geometry.root";
-}
-
-AliHLTTRDTrackerComponent::~AliHLTTRDTrackerComponent()
-{
-  // Destructor
-}
-
-const char* AliHLTTRDTrackerComponent::GetComponentID()
-{
-  // Return the component ID const char *
-  return "TRDTracker"; // The ID of this component
-}
-
-void AliHLTTRDTrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
-{
-  // Get the list of input data  
-  list.clear(); // We do not have any requirements for our input data type(s).
-  list.push_back( AliHLTTRDDefinitions::fgkClusterDataType );
-}
-
-AliHLTComponent_DataType AliHLTTRDTrackerComponent::GetOutputDataType()
-{
-  // Get the output data type
-  return AliHLTTRDDefinitions::fgkClusterDataType;
-}
-
-void AliHLTTRDTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
-  // Get the output data size
-  constBase = 0;
-  inputMultiplier = ((double)fOutputPercentage)/100.0;
-}
-
-// Spawn function, return new instance of this class
-AliHLTComponent* AliHLTTRDTrackerComponent::Spawn()
-{
-  // Spawn function, return new instance of this class
-  return new AliHLTTRDTrackerComponent;
-};
-
-int AliHLTTRDTrackerComponent::DoInit( int argc, const char** argv )
-{
-  // perform initialization. We check whether our relative output size is specified in the arguments.
-  fOutputPercentage = 100;
-  int i = 0;
-  char* cpErr;
-  while ( i < argc )
-    {
-      HLTDebug("argv[%d] == %s", i, argv[i] );
-      if ( !strcmp( argv[i], "output_percentage" ) )
-       {
-         if ( i+1>=argc )
-           {
-             HLTError("Missing output_percentage parameter");
-             return ENOTSUP;
-           }
-         HLTDebug("Arguments", "argv[%d+1] == %s", i, argv[i+1] );
-         fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
-         if ( *cpErr )
-           {
-             HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
-             return EINVAL;
-           }
-         HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
-         i += 2;
-         continue;
-       }
-
-      if ( strcmp( argv[i], "-cdb" ) == 0)
-       {
-         if ( i+1 >= argc )
-           {
-             HLTError("Missing -cdb argument");
-             return ENOTSUP;         
-           }
-         fStrorageDBpath = argv[i+1];
-         HLTInfo("DB storage is %s", fStrorageDBpath.c_str() );          
-         i += 2;
-         continue;
-       }      
-
-      if ( strcmp( argv[i], "-geometry" ) == 0)
-       {
-         if ( i+1 >= argc )
-           {
-             HLTError("Missing -geometry argument");
-             return ENOTSUP;         
-           }
-         fGeometryFileName = argv[i+1];
-         HLTInfo("GeomFile storage is %s", fGeometryFileName.c_str() );          
-         i += 2;
-         continue;
-       }      
-
-      HLTError("Unknown option '%s'", argv[i] );
-      return EINVAL;
-    }
-
-
-  fCDB = AliCDBManager::Instance();
-  if (!fCDB)
-    {
-      HLTError("Could not get CDB instance", "fCDB 0x%x", fCDB);
-    }
-  else
-    {
-      fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
-      fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
-      HLTDebug("fCDB 0x%x", fCDB);
-    }
-    
-  fGeometryFile = TFile::Open(fGeometryFileName.c_str());
-  if (fGeometryFile)
-    {
-      fGeoManager = (TGeoManager *)fGeometryFile->Get("Geometry");
-      //fTracker = new AliTRDtrackerHLT(fGeometryFile);
-      AliTRDrecoParam *fPars = AliTRDrecoParam::GetLowFluxParam();
-      //fPars->SetSeeding(kTRUE);
-      //fPars->SetStreamLevel(0);
-      AliTRDReconstructor reconstructor; reconstructor.SetRecoParam(fPars);
-      // write clusters [cw] = true
-      // track seeding (stand alone tracking) [sa] = true
-      // PID method in reconstruction (NN) [nn] = true
-      // write online tracklets [tw] = false
-      // drift gas [ar] = false
-      reconstructor.SetOption("cw,sa");
-      fTracker = new AliTRDtracker(fGeometryFile);
-      //fTracker = new AliTRDtracker(fGeometryFile);
-    }
-  else
-    {
-      HLTError("Unable to open file. FATAL!");
-      return -1;
-    }
-
-  AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
-  if (calibra == 0)
-    {
-      HLTError("Calibration Histos ::Instance failed");
-      return -1;      
-    }
-  else
-    {
-      calibra->Init2Dhistos();
-    }
-
-  return 0;
-}
-
-int AliHLTTRDTrackerComponent::DoDeinit()
-{
-  // Deinitialization of the component
-
-  delete fTracker;
-  fTracker = 0;
-  
-  if (fGeometryFile)
-    {
-      fGeometryFile->Close();
-      delete fGeometryFile;
-      fGeometryFile = 0;
-    }
-
-  AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
-  if (calibra)
-    {
-      // should not write in here!
-      calibra->Write2d();
-      calibra->Destroy();
-    }
-
-  return 0;
-}
-
-int AliHLTTRDTrackerComponent::DoEvent( const AliHLTComponentEventData & /*evtData*/,
-                                       AliHLTComponentTriggerData & /*trigData*/ )
-{
-  // Process an event
-  
-  HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
-  HLTInfo("NofBlocks %lu", GetNumberOfInputBlocks() );
-
-  AliHLTUInt32_t dBlockSpecification = 0;
-
-  //implement a usage of the following
-  //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
-  //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
-  //   void *triggerData = trigData.fData;
-  //HLTDebug("Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
-
-  AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTTRDDefinitions::fgkClusterDataType );
-  if (dblock != 0)
-    {
-      dBlockSpecification = dblock->fSpecification;
-    }
-  else
-    {
-      HLTWarning("First Input Block not found! 0x%x", dblock);
-      return -1;
-    }
-
-  int ibForce = 0;
-  TObject *tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TTree", ibForce);
-  HLTInfo("Pointer = 0x%x", tobjin);
-
-  TTree *clusterTree = (TTree*)tobjin;
-  if (!clusterTree)
-    {
-      HLTWarning("First Input Block not a tree! 0x%x", tobjin);
-      return -1;
-    }
-
-  HLTInfo("Pointer = 0x%x Name = %s", clusterTree, clusterTree->GetName());
-
-  while (tobjin != 0)
-    {
-      if (clusterTree)
-       {
-         HLTInfo("Pointer = 0x%x Name = %s", clusterTree, clusterTree->GetName());
-         Int_t iNentries = clusterTree->GetEntries();
-         HLTInfo("N of tree entries = %d", iNentries);
-         fTracker->LoadClusters(clusterTree);
-       }
-      else
-       {
-         HLTError("Tree Pointer = 0x%x", clusterTree);
-       }
-
-      tobjin = (TObject *)GetNextInputObject( ibForce );
-      HLTInfo("Pointer = 0x%x", tobjin);
-      clusterTree = (TTree*)tobjin;
-    }
-
-  fTracker->SetAddTRDseeds();
-
-  AliESDfriend *esdFriend = new AliESDfriend();
-
-  AliESDEvent *esd = new AliESDEvent();
-  esd->CreateStdContent();
-  fTracker->PropagateBack(esd);
-  fTracker->RefitInward(esd);
-  fTracker->Clusters2Tracks(esd);
-
-  esd->GetESDfriend(esdFriend);
-  //here transport the esd tracks further
-
-  Int_t nTracks = esd->GetNumberOfTracks();
-  Int_t nTRDTracks = esd->GetNumberOfTrdTracks();
-  HLTInfo( "Number of tracks %d Number of TRD tracks %d", nTracks, nTRDTracks);
-
-
-  for (Int_t it = 0; it < nTracks; it++)
-    {
-      AliESDtrack* track = esd->GetTrack(it);
-      HLTInfo("Track %d 0x%x Pt %1.2f", it, track, track->Pt());
-      PushBack(track, AliHLTTRDDefinitions::fgkTRDSATracksDataType, ++dBlockSpecification);
-    }
-
-  delete esd;
-  delete esdFriend;
-
-  delete clusterTree;
-
-  return 0;
-}
diff --git a/HLT/TRD/AliHLTTRDTrackerComponent.h b/HLT/TRD/AliHLTTRDTrackerComponent.h
deleted file mode 100644 (file)
index fcd89c0..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-// $Id$
-
-#ifndef ALIHLTTRDTRACKERCOMPONENT_H
-#define ALIHLTTRDTRACKERCOMPONENT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/** @file   AliHLTTRDTrackerComponent.h
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  Declaration of a TRDTracker component. */
-
-
-#include "AliHLTProcessor.h"
-class AliCDBManager;
-class TFile;
-class TGeoManager;
-//class AliTRDtrackerHLT;
-class AliTRDtracker;
-class AliMagF;
-
-/**
- * @class AliHLTTRDTrackerComponent
- * @brief A TRDTracker HLT processing component. 
- *
- * An implementiation of a TRDTracker component that just copies its input data
- * as a test, demonstration, and example of the HLT component scheme.
- * @ingroup alihlt_tutorial
- */
-class AliHLTTRDTrackerComponent : public AliHLTProcessor
-    {
-    public:
-       AliHLTTRDTrackerComponent();
-       virtual ~AliHLTTRDTrackerComponent();
-
-       // Public functions to implement AliHLTComponent's interface.
-       // These functions are required for the registration process
-
-       const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
-       virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
-       AliHLTComponent* Spawn();
-       
-    protected:
-       
-       // Protected functions to implement AliHLTComponent's interface.
-       // These functions provide initialization as well as the actual processing
-       // capabilities of the component. 
-
-       int DoInit( int argc, const char** argv );
-       int DoDeinit();
-/*     int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,  */
-/*                  AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,  */
-/*                  AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks ); */
-       int DoEvent( const AliHLTComponentEventData & evtData,
-                    AliHLTComponentTriggerData & trigData );
-
-       using AliHLTProcessor::DoEvent;
-       
-    private:
-       /** copy constructor prohibited */
-       AliHLTTRDTrackerComponent(const AliHLTTRDTrackerComponent&);
-       /** assignment operator prohibited */
-       AliHLTTRDTrackerComponent& operator=(const AliHLTTRDTrackerComponent&);
-
-       // The size of the output data produced, as a percentage of the input data's size.
-       // Can be greater than 100 (%)
-       unsigned fOutputPercentage; // Output volume in percentage of the input
-
-       string fStrorageDBpath; // Default path for OCDB
-       AliCDBManager *fCDB; //! Pointer to OCDB
-
-       string fGeometryFileName; // Path to geometry file 
-       TFile *fGeometryFile; //! // Pointer to the geom root file
-       TGeoManager *fGeoManager; //! Pointer to geometry manager 
-
-       //AliTRDtrackerHLT *fTracker;//! Offline-like/HLT tracker
-       AliTRDtracker *fTracker;//! Offline-pure/HLT tracker
-
-       ClassDef(AliHLTTRDTrackerComponent, 0)
-
-    };
-#endif
index 8296912930f9bd3a54ef847fde45a22dfb18ae68..fa8ca1352e1303949de7caa4c3c7c75f0d161121 100644 (file)
@@ -29,6 +29,7 @@ using namespace std;
 #include "AliHLTTRDDefinitions.h"
 #include "AliHLTTRDCluster.h"
 #include "AliHLTTRDTrack.h"
+#include "AliHLTTRDUtils.h"
 
 #include "TFile.h"
 #include "TChain.h"
@@ -63,8 +64,6 @@ AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
   fStrorageDBpath("local://$ALICE_ROOT/OCDB"),
   fCDB(NULL),
   fGeometryFileName(""),
-  fUseHLTClusters(kFALSE),
-  fUseHLTTracks(kFALSE),
   fTracker(NULL),
   fRecoParam(NULL),
   fReconstructor(NULL)
@@ -112,41 +111,6 @@ AliHLTComponent* AliHLTTRDTrackerV1Component::Spawn()
   return new AliHLTTRDTrackerV1Component;
 };
 
-/**
- * Convert AliTRDtrackV1 to AliHLTTRDTrack 
- * Add HLTTrack to the output, defined by pointer
- * Fill block desctiptors 
- * Return size of the added to ouput objects
- */
-//============================================================================
-AliHLTUInt32_t AliHLTTRDTrackerV1Component::AddToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
-{
-  cout << "\nWriting tracks to the Memory\n ============= \n";
-  AliTRDtrackV1* track = 0;
-  AliHLTUInt32_t addedSize = 0;
-  AliHLTUInt8_t *iterPtr = output;
-  AliHLTTRDTrack * outPtr = (AliHLTTRDTrack*)iterPtr;
-  
-  if (inTrackArray){
-    Int_t nbTracks  = inTrackArray->GetEntries();
-    for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
-      AliHLTUInt32_t trackSize=0;
-      
-      track = dynamic_cast<AliTRDtrackV1*>(inTrackArray->At(iTrack));
-      //track->Print();
-      
-      AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
-      trackSize = hltTrack->GetSize();
-      addedSize += trackSize;
-      HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
-      
-      iterPtr += trackSize;
-      outPtr = (AliHLTTRDTrack*)iterPtr;
-    }
-  }
-  return addedSize;
-  
-}
 
 int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
 {
@@ -261,30 +225,12 @@ int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
          iMagneticField = 0;
          i++;
        }
-      else if ( strcmp( argv[i], "-writeClusters" ) == 0)
-       {
-         bWriteClusters = kTRUE;
-         HLTDebug("input clusters are expected to be in a TTree.");
-         i++;
-       }
       else if ( strcmp( argv[i], "-offlineMode" ) == 0)
        {
          bHLTMode=kFALSE;
          HLTDebug("Using standard offline tracking.");
          i++;
        }
-      else if ( strcmp( argv[i], "-useHLTClusters" ) == 0)
-       {
-         fUseHLTClusters = kTRUE;
-         i++;
-         HLTInfo("expecting AliHLTCluster as input");
-       }
-      else if ( strcmp( argv[i], "-useHLTTracks" ) == 0)
-       {
-         fUseHLTTracks = kTRUE;
-         i++;
-         HLTInfo("Using AliHLTTrack to pass data further in the chain");
-       }
       else {
        HLTError("Unknown option '%s'", argv[i] );
        return EINVAL;
@@ -464,8 +410,7 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
                                          vector<AliHLTComponent_BlockData>& outputBlocks )
 {
   // Process an event
-  Bool_t bWriteClusters = fReconstructor->IsWritingClusters();
-
+  
   HLTDebug("NofBlocks %lu", evtData.fBlockCnt );
   
   AliHLTUInt32_t totalSize = 0, offset = 0;
@@ -500,19 +445,20 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
                    DataType2Text(inputDataType).c_str());
       
       
-      TTree *clusterTree = 0x0;
-      TClonesArray* clusterArray = 0x0;
-      ReadAndLoadClusters(clusterTree, clusterArray, &block);
+      TClonesArray* clusterArray = new TClonesArray("AliTRDcluster"); // would be nice to allocate memory for all clusters here.
+      AliHLTTRDUtils::ReadClusters(clusterArray, block.fPtr, block.fSize);
+      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();
       fTracker->Clusters2Tracks(esd);
 
-      //here transport the esd tracks further
       Int_t nTracks = esd->GetNumberOfTracks();
-      Int_t nTRDTracks = esd->GetNumberOfTrdTracks();
-      HLTInfo("Number of tracks  == %d == Number of TRD tracks %d", nTracks, nTRDTracks);  
+      HLTInfo("Number of tracks  == %d ==", nTracks);  
 
       TClonesArray* trdTracks = fTracker->GetListOfTracks();
    
@@ -534,102 +480,14 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
 
       AliTRDReconstructor::SetClusters(0x0);
       delete esd;
-      if (bWriteClusters)
-       delete clusterTree;
-      else{
-       //clusterArray->Delete();
-       delete clusterArray;
       }
       
-    }
   size = totalSize;
   HLTDebug("Event is done. size written to the output is %i", size);
-  //  CALLGRIND_STOP_INSTRUMENTATION();
   return 0;
 }
 
 
-/**
- * ReadClusters from the component input and load them to the tracker
- */
-//============================================================================
-void AliHLTTRDTrackerV1Component::ReadAndLoadClusters(TTree *inClusterTree, 
-                                                     TClonesArray *inClusterArray, const AliHLTComponentBlockData *inBlock)
-{
-  Bool_t bWriteClusters = fReconstructor->IsWritingClusters();
-  const AliHLTComponentBlockData &block = *inBlock;
-
-
-  TObject *tobjin = 0x0;
-  int ibForce = 0; // almost obsolet
-
-  if (bWriteClusters){
-    tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TTree", ibForce);
-    HLTDebug("1stBLOCK; Pointer = 0x%x", tobjin);
-    inClusterTree = (TTree*)tobjin;
-    if (inClusterTree)
-      {
-       HLTDebug("CLUSTERS; Pointer to TTree = 0x%x Name = %s", inClusterTree, inClusterTree->GetName());
-       HLTDebug("TTree of clusters: nbEntries = %i", inClusterTree->GetEntriesFast());
-       fTracker->LoadClusters(inClusterTree);
-      }
-    else
-      {
-       HLTError("First Input Block is not a TTree 0x%x", tobjin);
-      }
-  }
-  else if (fUseHLTClusters)
-    {
-      inClusterArray = new TClonesArray("AliTRDcluster"); // would be nice to allocate memory for all clusters here.
-      ReadClusters(inClusterArray, block.fPtr, block.fSize);
-      HLTDebug("TClonesArray of clusters: nbEntries = %i", inClusterArray->GetEntriesFast());
-      fTracker->LoadClusters(inClusterArray);
-    }
-  else
-    {
-      tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TClonesArray", ibForce);
-      HLTDebug("1stBLOCK; Pointer = 0x%x", tobjin);
-      inClusterArray = (TClonesArray*)tobjin;
-      if (inClusterArray)
-       {
-         HLTDebug("CLUSTERS; Pointer to TClonesArray = 0x%x Name = %s", inClusterArray, inClusterArray->GetName());
-         HLTDebug("TClonesArray of clusters: nbEntries = %i", inClusterArray->GetEntriesFast());
-         fTracker->LoadClusters(inClusterArray);
-       }
-      else
-       {
-         HLTError("First Input Block not a TClonesArray 0x%x", tobjin);
-       }
-    }
-}
-
-/**
- * Read cluster to the TClonesArray from the memory 
- */
-//============================================================================
-Int_t AliHLTTRDTrackerV1Component::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
-{
-  //HLTDebug("\nReading clusters from the Memory\n ============= \n");
-  AliHLTTRDCluster * curCluster;
-  UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
-  Int_t i=0;
-  
-  curCluster = (AliHLTTRDCluster*) inputPtr;
-  while (curSize + clusterSize <= size)
-    {
-      //  HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
-
-      AliTRDcluster* curTRDCluster = new((*outArray)[i]) AliTRDcluster();
-      curCluster->ExportTRDCluster(curTRDCluster);
-      //      HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
-      curSize += clusterSize; 
-      i++;
-      curCluster++;
-      //cout << " current readed size is " << curSize << "/" << size << endl;
-    }
-  
-  return i;
-}
 /**
  * Transport tracks to the next component
  * Return Numbers of bytes written to the output
@@ -642,10 +500,10 @@ AliHLTUInt32_t AliHLTTRDTrackerV1Component::TransportTracks(TClonesArray *inTrac
   if (nbTracks>0)
     {
       HLTDebug("We have an output array: pointer to inTracksArray = 0x%x, nbEntries = %i", inTracksArray, nbTracks);
-      if (fUseHLTTracks){
-       // Using low-level interface 
+      
+       // Using low-level interface 
        // with interface classes
-       AliHLTUInt32_t addedSize = AddToOutput(inTracksArray, output);
+       AliHLTUInt32_t addedSize = AliHLTTRDUtils::AddTracksToOutput(inTracksArray, output);
        
        // Fill block 
        AliHLTComponentBlockData bd;
@@ -660,14 +518,8 @@ AliHLTUInt32_t AliHLTTRDTrackerV1Component::TransportTracks(TClonesArray *inTrac
        HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
        
        return addedSize;
+      
       }
-      else{
-       inTracksArray->BypassStreamer(kFALSE);
-       PushBack(inTracksArray, AliHLTTRDDefinitions::fgkTRDSATracksDataType);
-       return 0;
-      }
-         
-    }
   return 0;
   
 }
index 68bea65dc752fefa92842fd718923a86c3786011..af129483f759bde8eea22bea640ba02e7d345e12 100644 (file)
@@ -3,7 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/** @file   AliHLTTRDTrackerComponent.h
+/** @file   AliHLTTRDTrackerV1Component.h
     @author Timm Steinbeck, Matthias Richter
     @date   
     @brief  Declaration of a TRDTracker component. */
@@ -21,7 +21,7 @@ class AliTRDrecoParam;
 class AliTRDReconstructor;
 
 /**
- * @class AliHLTTRDTrackerComponent
+ * @class AliHLTTRDTrackerV1Component
  * @brief A TRDTrackerV1 HLT processing component. 
  *
  * Uses the second generation TRD tracker AliTRDtrackerV1
@@ -43,9 +43,6 @@ class AliHLTTRDTrackerV1Component : public AliHLTProcessor
        AliHLTComponent* Spawn();
        
     protected:
-       AliHLTUInt32_t AddToOutput (TClonesArray* inTrackArray, AliHLTUInt8_t* output);
-       Int_t ReadClusters (TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
-       void ReadAndLoadClusters(TTree *inClusterTree, TClonesArray *inClusterArray, const AliHLTComponentBlockData *inBlock);
        AliHLTUInt32_t TransportTracks(TClonesArray *inTracksArray, AliHLTUInt8_t* output,
                                       vector<AliHLTComponent_BlockData>& outputBlocks, AliHLTUInt32_t inOffset, AliHLTUInt32_t inSpec);
        
@@ -77,9 +74,7 @@ class AliHLTTRDTrackerV1Component : public AliHLTProcessor
        AliCDBManager *fCDB; //! Pointer to OCDB
 
        string fGeometryFileName; // Path to geometry file 
-       Bool_t   fUseHLTClusters;
-       Bool_t   fUseHLTTracks;
-
+       
        AliTRDtrackerV1 *fTracker;//! Offline-pure/HLT tracker V1
        AliTRDrecoParam *fRecoParam; //! Offline reco params
        AliTRDReconstructor * fReconstructor;
diff --git a/HLT/TRD/AliHLTTRDUtils.cxx b/HLT/TRD/AliHLTTRDUtils.cxx
new file mode 100644 (file)
index 0000000..9bfe88e
--- /dev/null
@@ -0,0 +1,145 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// HLT TRD Utillities Class                                                  //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliHLTTRDUtils.h"
+#include <TClonesArray.h>
+#include "AliHLTTRDTrack.h"
+#include "AliHLTTRDCluster.h"
+
+AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr)
+{
+  AliTRDcluster* cluster = 0;
+  AliHLTUInt32_t addedSize = 0;
+  //  == OUTdatatype pointer
+  AliHLTTRDCluster * outPtr = (AliHLTTRDCluster*)outBlockPtr;
+  
+  if (inClusterArray){
+    Int_t nbEntries  = inClusterArray->GetEntries();
+    for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
+      //cout << "Geting cluster #" << iCluster << endl;
+      UInt_t blockSize=0;
+      
+      cluster = dynamic_cast<AliTRDcluster*>(inClusterArray->At(iCluster));
+
+      AliHLTTRDCluster *hltCluster = new (outPtr) AliHLTTRDCluster(cluster);
+      //cout << Form("cluster added at 0x%x (%i)\n",outPtr,outPtr);
+
+      blockSize = sizeof(*hltCluster);
+
+      addedSize += blockSize;
+      outBlockPtr += blockSize;
+      outPtr = (AliHLTTRDCluster*)outBlockPtr;
+    }
+  }
+  return addedSize;
+  
+}
+
+AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
+{
+  cout << "\nWriting tracks to the Memory\n ============= \n";
+  AliTRDtrackV1* track = 0;
+  AliHLTUInt32_t addedSize = 0;
+  AliHLTUInt8_t *iterPtr = output;
+  AliHLTTRDTrack * outPtr = (AliHLTTRDTrack*)iterPtr;
+  
+  if (inTrackArray){
+    Int_t nbTracks  = inTrackArray->GetEntries();
+    for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
+      AliHLTUInt32_t trackSize=0;
+      
+      track = dynamic_cast<AliTRDtrackV1*>(inTrackArray->At(iTrack));
+      //track->Print();
+      
+      AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
+      trackSize = hltTrack->GetSize();
+      addedSize += trackSize;
+      HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
+      
+      iterPtr += trackSize;
+      outPtr = (AliHLTTRDTrack*)iterPtr;
+    }
+  }
+  return addedSize;
+  
+}
+
+/**
+ * Read cluster to the TClonesArray from the memory 
+ */
+//============================================================================
+AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+{
+  //HLTDebug("\nReading clusters from the Memory\n ============= \n");
+  AliHLTTRDCluster * curCluster;
+  UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
+  Int_t i=0;
+  
+  curCluster = (AliHLTTRDCluster*) inputPtr;
+  while (curSize + clusterSize <= size)
+    {
+      //  HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
+
+      AliTRDcluster* curTRDCluster = new((*outArray)[i]) AliTRDcluster();
+      curCluster->ExportTRDCluster(curTRDCluster);
+      //      HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
+      curSize += clusterSize; 
+      i++;
+      curCluster++;
+      //cout << " current readed size is " << curSize << "/" << size << endl;
+    }
+  
+  return i;
+}
+
+AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+{
+  AliHLTUInt8_t* iterPtr = (AliHLTUInt8_t* )inputPtr;
+  
+  //cout << "\nReading tracks from the Memory\n ============= \n";
+  HLTDebug ("\nReading tracks from the Memory\n ============= \n");
+  AliHLTTRDTrack * hltTrack;
+  AliHLTUInt32_t trackSize = 0, curSize = 0;
+  Int_t counter=0;
+  
+  while (curSize < size)
+    {
+      hltTrack = (AliHLTTRDTrack*) iterPtr;
+      HLTDebug("curSize %i, size %i",curSize, size);
+      
+      trackSize = hltTrack->GetSize();
+      HLTDebug("GetSize() %i", trackSize);
+
+      hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
+
+      AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
+      hltTrack->ExportTRDTrack(curTRDTrack);
+      
+      curSize += trackSize; 
+      iterPtr += trackSize;
+      counter++;
+    }
+
+  //CheckTrackArray(outArray);
+  
+  return counter;
+}
+
diff --git a/HLT/TRD/AliHLTTRDUtils.h b/HLT/TRD/AliHLTTRDUtils.h
new file mode 100644 (file)
index 0000000..808af0b
--- /dev/null
@@ -0,0 +1,27 @@
+#ifndef ALIHLTTRDUTILS_H
+#define ALIHLTTRDUTILS_H
+/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+//  HLT TRD Utillities Class                                              //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
+
+#include "AliHLTDataTypes.h"
+
+class TClonesArray;
+
+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);
+
+};
+
+#endif
diff --git a/HLT/TRD/AliTRDclusterizerHLT.cxx b/HLT/TRD/AliTRDclusterizerHLT.cxx
deleted file mode 100644 (file)
index 41c51f0..0000000
+++ /dev/null
@@ -1,297 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// TRD cluster finder                                                        //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-#include <TF1.h>
-#include <TTree.h>
-#include <TH1.h>
-#include <TFile.h>
-
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-#include "AliRawReader.h"
-#include "AliLog.h"
-
-#include "AliTRDclusterizerHLT.h"
-#include "AliTRDgeometry.h"
-#include "AliTRDdigitsManager.h"
-#include "AliTRDfeeParam.h"
-#include "AliTRDpadPlane.h"
-#include "AliTRDrawData.h"
-#include "AliTRDcalibDB.h"
-#include "AliTRDSimParam.h"
-#include "AliTRDcluster.h"
-
-#include "Cal/AliTRDCalROC.h"
-#include "Cal/AliTRDCalDet.h"
-
-ClassImp(AliTRDclusterizerHLT)
-
-  //_____________________________________________________________________________
-  AliTRDclusterizerHLT::AliTRDclusterizerHLT() 
-    : AliTRDclusterizer()
-    , fTreeCreatedHere(kFALSE)
-    , fNclusters(-1)
-    , fRawDataSource(0)
-    , fFeeParams(0)
-{
-  //
-  // AliTRDclusterizerHLT default constructor
-  //
-}
-
-//_____________________________________________________________________________
-AliTRDclusterizerHLT::AliTRDclusterizerHLT(const Text_t *name, const Text_t *title, AliTRDReconstructor * rec) 
-  : AliTRDclusterizer(name,title,rec)
-   , fTreeCreatedHere(kFALSE)
-   , fNclusters(-1)
-   , fRawDataSource(0)
-   , fFeeParams(0)
-{
-  //
-  // AliTRDclusterizerHLT constructor
-  //
-}
-
-//_____________________________________________________________________________
-AliTRDclusterizerHLT::AliTRDclusterizerHLT(const Text_t *name, const Text_t *title) 
-  : AliTRDclusterizer(name,title)
-   , fTreeCreatedHere(kFALSE)
-   , fNclusters(-1)
-   , fRawDataSource(0)
-   , fFeeParams(0)
-{
-  //
-  // AliTRDclusterizerHLT constructor
-  //
-}
-
-//_____________________________________________________________________________
-AliTRDclusterizerHLT::AliTRDclusterizerHLT(const AliTRDclusterizerHLT &c)
-  : AliTRDclusterizer(c)
-  , fTreeCreatedHere(kFALSE)
-  , fNclusters(-1)
-  , fRawDataSource(0)
-  , fFeeParams(0)
-{
-  //
-  // AliTRDclusterizerHLT copy constructor
-  //
-}
-
-//_____________________________________________________________________________
-AliTRDclusterizerHLT::~AliTRDclusterizerHLT()
-{
-  //
-  // AliTRDclusterizerHLT destructor
-  //
-  if (fTreeCreatedHere == kTRUE)
-    delete fClusterTree;
-  
-  delete fRawDataSource;
-  
-}
-
-//_____________________________________________________________________________
-AliTRDclusterizerHLT &AliTRDclusterizerHLT::operator=(const AliTRDclusterizerHLT &c)
-{
-  //
-  // Assignment operator
-  //
-
-  this->fRawDataSource = 0;
-  if (this != &c) ((AliTRDclusterizerHLT &) c).Copy(*this);
-  return *this;
-
-}
-
-//_____________________________________________________________________________
-void AliTRDclusterizerHLT::Copy(TObject &c) const
-{
-  //
-  // Copy function
-  //
-
-  AliFatal("Not implemented");
-
-  //use the parameter c - no warning...
-  ((AliTRDclusterizerHLT &) c).fDigitsManager = 0;
-  //   ((AliTRDclusterizerHLT &) c).fDigitsManager = 0;
-  //   ((AliTRDclusterizerHLT &) c).fTreeCreatedHere = kFALSE;
-  //   AliTRDclusterizer::Copy(c);
-
-}
-
-void AliTRDclusterizerHLT::SetRawVersion(Int_t iver)
-{ 
-  //
-  // set the expected raw data version
-  //
-
-  AliTRDclusterizer::SetRawVersion(iver);  
-
-  if (fFeeParams == 0)
-    {
-      fFeeParams = AliTRDfeeParam::Instance();
-    }
-  
-  fFeeParams->SetRAWversion(iver);
-} 
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizerHLT::ReadDigits(AliRawReaderMemory *rawReader)
-{
-  //
-  // Reads the digits arrays from the ddl file
-  //
-
-  if (fRawDataSource == 0)
-    fRawDataSource = new AliTRDrawData;
-
-  //PH  fRawDataSource->SetRawVersion(fRawVersion);
-
-  fDigitsManager = fRawDataSource->Raw2Digits((AliRawReader*)rawReader);
-  //AliInfo(Form("Digits manager at 0x%x", fDigitsManager));
-  AliDebug(1, Form("Digits manager at 0x%x", fDigitsManager));
-  if (fDigitsManager)
-    return kTRUE;
-  else
-    return kFALSE;
-
-}
-
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizerHLT::InitClusterTree()
-{
-  //
-  // This has to be called on HLT - creation of the cluster Tree used by the offline clusterizer (base class)
-  //
-  Bool_t kReturn = kFALSE;
-  if (fClusterTree == 0)
-    {
-      fClusterTree = new TTree("TRDclusterTree", "TRDclusterTree");
-      fTreeCreatedHere = kTRUE;
-    }
-
-  if (fClusterTree != 0)
-    kReturn = kTRUE;    
-
-  return kReturn;
-}
-
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizerHLT::InsertClusters(TClonesArray *tobjarr, Int_t idet)
-{
-  //
-  // Fill the tree with clusters - from a different component for example
-  //
-
-  //clear the current
-  ResetRecPoints();
-  delete fRecPoints;
-  fRecPoints = 0;
-
-  //set the pointer used in WriteClusters
-  fRecPoints = tobjarr;  
-  Bool_t kRet = kFALSE;
-  if (InitClusterTree())
-    kRet = WriteClusters(idet);  
-
-  fRecPoints = 0;
-
-  return kRet;
-}
-//_____________________________________________________________________________
-Int_t AliTRDclusterizerHLT::GetNclusters()
-{
-  //
-  // Returns the number of clusters AliTRDclusterizerHLT::fNclusters
-  // Count them first if fNclusters < 0
-  //
-
-  if (fNclusters < 0)
-    {
-      CountClusters();
-    }
-  return fNclusters;
-}
-
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizerHLT::ResetTree()
-{
-  //
-  // Recreate the cluster tree
-  // 
-
-  //   if (fClusterTree != 0)
-  //     fClusterTree->Reset();
-  // well we'd better delete the whole tree and branches
-  delete fClusterTree;
-  fClusterTree = NULL;
-  fClusterTree = new TTree("TRDclusterTree", "TRDclusterTree");
-  if (fClusterTree)
-    {
-      fTreeCreatedHere = kTRUE;
-      fNclusters = -1;
-      //AliInfo("Tree Reset Successful");
-      AliDebug(1,Form("Tree Reset Successful"));
-    }
-  else
-    {
-      fTreeCreatedHere = kFALSE;
-      AliError("Reset Tree Error!\n");
-    }
-  
-  return fTreeCreatedHere;
-}
-
-//_____________________________________________________________________________
-Int_t AliTRDclusterizerHLT::CountClusters()
-{
-  //
-  // Count the clusters - runs over the cluster tree
-  //
-
-  fNclusters = -1;
-  if (fClusterTree == 0)
-    {
-      AliError("No tree to count clusters!\n");
-      return -1;
-    }
-  TList *lt = (TList*)fClusterTree->GetListOfBranches();
-  TIter it(lt);
-  it.Reset();
-  TBranch *tb = 0;
-  Int_t icount = 0;
-  while ((tb = (TBranch*)it.Next()) != 0)
-    {
-      TObjArray *clusters = 0;
-      tb->SetAddress(&clusters);
-      for (Int_t icb = 0; icb < tb->GetEntries(); icb++)
-       {
-         tb->GetEntry(icb);
-         icount += clusters->GetEntries();
-       }
-    }
-  fNclusters = icount;
-  //AliInfo(Form("Recounted clusters %d", fNclusters));
-  AliDebug(2, Form("Recounted clusters %d", fNclusters));
-
-  return fNclusters;
-}
diff --git a/HLT/TRD/AliTRDclusterizerHLT.h b/HLT/TRD/AliTRDclusterizerHLT.h
deleted file mode 100644 (file)
index fabdde9..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifndef ALITRDCLUSTERIZERHLT_H
-#define ALITRDCLUSTERIZERHLT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-//  TRD cluster finder                                                    //
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
-
-#include "AliTRDclusterizer.h"
-
-class AliRawReader;
-class AliRawReaderMemory;
-class AliTRDrawData;
-class AliTRDfeeParam;
-
-class AliTRDclusterizerHLT : public AliTRDclusterizer 
-{
- public:
-
-  AliTRDclusterizerHLT();
-  AliTRDclusterizerHLT(const Text_t* name, const Text_t* title, AliTRDReconstructor* reconstructor);
-  AliTRDclusterizerHLT(const Text_t* name, const Text_t* title);
-  AliTRDclusterizerHLT(const AliTRDclusterizerHLT &c);
-  virtual             ~AliTRDclusterizerHLT();
-  AliTRDclusterizerHLT &operator=(const AliTRDclusterizerHLT &c);
-
-  virtual void     Copy(TObject &c) const;
-  //virtual Bool_t   MakeClusters();
-  virtual Bool_t   ReadDigits(AliRawReaderMemory* rawReader);
-  using AliTRDclusterizer::ReadDigits;
-  //virtual Bool_t   TreeClusters(Int_t idet);
-  virtual Bool_t   InitClusterTree();
-  virtual Bool_t   InsertClusters(TClonesArray *tobjarr, Int_t idet);
-  virtual Int_t    CountClusters();
-  virtual Int_t    GetNclusters();
-
-  virtual Bool_t   ResetTree();
-  TTree *          GetClusterTree() {return fClusterTree;}
-  virtual Bool_t   IsTreeOwner() const {return fTreeCreatedHere;}
-
-  virtual void     SetRawVersion(Int_t iver);
-
- protected:
-  virtual Bool_t   ReadDigits() const {return kFALSE;} //this method not to be used on HLT
-  virtual Bool_t   ReadDigits(AliRawReader* /*rawReader*/) const {/*if (!rawReader) */ return kFALSE;} //this method not to be used on HLT
-
-  Bool_t            fTreeCreatedHere; //flag indicating that AliTRDclusterizerHLT has created the cluster tree
-
- private:
-
-  Int_t fNclusters; //number of clusters found - updated by ::GetNclusters()
-  AliTRDrawData  *fRawDataSource; //! pointer to the TRD raw data stream
-  AliTRDfeeParam *fFeeParams; //! fee parameters - this is singleton so watch out! with delete
-
-  ClassDef(AliTRDclusterizerHLT,1)           //  TRD-Cluster finder, slow simulator
-
-};
-
-#endif
index 21117443f8e4102384b7aaf09e5f53b85806d372..00f6c366eabfa61e1a4ebd9dbff006c9b8f5fa1e 100644 (file)
@@ -7,15 +7,15 @@
 CLASS_HDRS:= \
         AliHLTTRDClusterizerComponent.h \
         AliHLTTRDDefinitions.h \
-        AliHLTTRDTrackerComponent.h \
         AliHLTTRDTrackerV1Component.h \
-        AliTRDclusterizerHLT.h \
+       AliHLTTRDClusterizer.h \
        AliHLTTRDEsdWriterComponent.h \
        AliHLTTRDCalibrationComponent.h \
        AliHLTTRDCluster.h \
        AliHLTTRDTracklet.h \
        AliHLTTRDTrack.h \
-       AliHLTTRDAgent.h
+       AliHLTTRDAgent.h \
+       AliHLTTRDUtils.h
 
 # library sources
 MODULE_SRCS= \