HLT TRD update and cleanup, changes according to offline TRD (Theodor)
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Sep 2009 13:28:51 +0000 (13:28 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Sep 2009 13:28:51 +0000 (13:28 +0000)
AliHLTTRDCluster, -Tracklet, -Track:
 - change Data Containers to meet calibration requirements

AliHLTTRDClusterizerComponent, -TrackerV1Component,
-CalibrationComponent, -Utils:
 - use number of timebins information from data
 - several bugfixes (substract baseline from raw data)

AliHLTTRDCalibrationComponent:
 - implement ShipDataToFXS

AliHLTTRDDefinition:
 - remove unused DataType

AliHLTTRDClusterHistoComponent:
 - add histogramms
 - pushback only every 20th event (can be changed with: -everyNevent X)

22 files changed:
HLT/TRD/AliHLTTRDAgent.h
HLT/TRD/AliHLTTRDCalibrationComponent.cxx
HLT/TRD/AliHLTTRDCalibrationComponent.h
HLT/TRD/AliHLTTRDCluster.cxx
HLT/TRD/AliHLTTRDCluster.h
HLT/TRD/AliHLTTRDClusterHistoComponent.cxx
HLT/TRD/AliHLTTRDClusterHistoComponent.h
HLT/TRD/AliHLTTRDClusterizer.h
HLT/TRD/AliHLTTRDClusterizerComponent.cxx
HLT/TRD/AliHLTTRDClusterizerComponent.h
HLT/TRD/AliHLTTRDDefinitions.cxx
HLT/TRD/AliHLTTRDDefinitions.h
HLT/TRD/AliHLTTRDEsdWriterComponent.h
HLT/TRD/AliHLTTRDTrack.cxx
HLT/TRD/AliHLTTRDTrack.h
HLT/TRD/AliHLTTRDTrackerV1Component.cxx
HLT/TRD/AliHLTTRDTrackerV1Component.h
HLT/TRD/AliHLTTRDTracklet.cxx
HLT/TRD/AliHLTTRDTracklet.h
HLT/TRD/AliHLTTRDTrackletWordArray.h
HLT/TRD/AliHLTTRDUtils.cxx
HLT/TRD/AliHLTTRDUtils.h

index e4efda3..dbc0295 100644 (file)
@@ -1,7 +1,11 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDAGENT_H
 #define ALIHLTTRDAGENT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 /** @file   AliHLTTRDAgent.h
     @author Matthias Richter
index 5ef5504..e2d4530 100644 (file)
@@ -43,15 +43,17 @@ using namespace std;
 #include <cerrno>
 #include <string>
 
-// this is a global object used for automatic component registration, do not use this
-AliHLTTRDCalibrationComponent gAliHLTTRDCalibrationComponent;
-
 ClassImp(AliHLTTRDCalibrationComponent);
 
-AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent():
-  AliHLTCalibrationProcessor(),
+AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent()
+: AliHLTCalibrationProcessor(),
   fTRDCalibraFillHisto(NULL),
-  fOutputPercentage(100) // By default we copy to the output exactly what we got as input
+  fOutputSize(50000),
+  fTracksArray(NULL),
+  fOutArray(NULL),
+  fNevent(0),
+  feveryNevent(20),
+  fRecievedTimeBins(kFALSE)
 {
   // Default constructor
 }
@@ -59,7 +61,6 @@ AliHLTTRDCalibrationComponent::AliHLTTRDCalibrationComponent():
 AliHLTTRDCalibrationComponent::~AliHLTTRDCalibrationComponent()
 {
   // Destructor
-  ;
 }
 
 const char* AliHLTTRDCalibrationComponent::GetComponentID()
@@ -68,14 +69,14 @@ const char* AliHLTTRDCalibrationComponent::GetComponentID()
   return "TRDCalibration"; // The ID of this component
 }
 
-void AliHLTTRDCalibrationComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTRDCalibrationComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& 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 );
+  list.push_back(AliHLTTRDDefinitions::fgkTRDSATracksDataType);
 }
 
-AliHLTComponent_DataType AliHLTTRDCalibrationComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTRDCalibrationComponent::GetOutputDataType()
 {
   // Get the output data type
   return AliHLTTRDDefinitions::fgkCalibrationDataType;
@@ -84,8 +85,8 @@ AliHLTComponent_DataType AliHLTTRDCalibrationComponent::GetOutputDataType()
 void AliHLTTRDCalibrationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 {
   // Get the output data size
-  constBase = 0;
-  inputMultiplier = ((double)fOutputPercentage)/100.0;
+  constBase = fOutputSize;
+  inputMultiplier = 0;
 }
 
 AliHLTComponent* AliHLTTRDCalibrationComponent::Spawn()
@@ -102,24 +103,43 @@ Int_t AliHLTTRDCalibrationComponent::ScanArgument( int argc, const char** argv )
   while ( i < argc )
     {
       HLTDebug("argv[%d] == %s", i, argv[i] );
-      if ( !strcmp( argv[i], "output_percentage" ) )
+      if ( !strcmp( argv[i], "output_size" ) )
         {
           if ( i+1>=argc )
             {
-              HLTError("Missing output_percentage parameter");
+              HLTError("Missing output_size parameter");
               return ENOTSUP;
             }
           HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
-          fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
+          fOutputSize = strtoul( argv[i+1], &cpErr, 0 );
           if ( *cpErr )
             {
-              HLTError("Cannot convert output_percentage parameter '%s'", argv[i+1] );
+              HLTError("Cannot convert output_size parameter '%s'", argv[i+1] );
               return EINVAL;
             }
-          HLTInfo("Output percentage set to %lu %%", fOutputPercentage );
+          HLTInfo("Output size set to %lu %%", fOutputSize );
           i += 2;
           continue;
         }
+      if ( !strcmp( argv[i], "-everyNevent" ) )
+        {
+          if ( i+1>=argc )
+            {
+              HLTError("Missing everyNevent parameter");
+              return ENOTSUP;
+            }
+          HLTDebug("argv[%d+1] == %s", i, argv[i+1] );
+          fOutputSize = strtoul( argv[i+1], &cpErr, 0 );
+          if ( *cpErr )
+            {
+              HLTError("Cannot convert everyNevent parameter '%s'", argv[i+1] );
+              return EINVAL;
+            }
+          HLTInfo("Pushing back every %d event", feveryNevent);
+          i += 2;
+          continue;
+        }
+
       else {
         HLTError("Unknown option '%s'", argv[i] );
         return EINVAL;
@@ -131,39 +151,41 @@ Int_t AliHLTTRDCalibrationComponent::ScanArgument( int argc, const char** argv )
 Int_t AliHLTTRDCalibrationComponent::InitCalibration()
 {
   if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
-    HLTError("DefaultStorage is not Set in CDBManager");
-    return -1;
+    HLTError("DefaultStorage is not set in CDBManager");
+    return -EINVAL;
   }
   if(AliCDBManager::Instance()->GetRun()<0){
-    AliCDBManager *cdb = AliCDBManager::Instance();
-    if (cdb)
-      {
-       cdb->SetRun(0);
-       HLTWarning("Setting CDB Runnumber to 0. CDB instance 0x%x", cdb);
-      }
-    else
-      {
-       HLTError("Could not get CDB instance", "cdb 0x%x", cdb);
-       return -1;
-      }
+    HLTError("Run Number is not set in CDBManager");
+    return -EINVAL;
   }
   HLTInfo("CDB default storage: %s; RunNo: %i", (AliCDBManager::Instance()->GetDefaultStorage()->GetBaseFolder()).Data(), AliCDBManager::Instance()->GetRun());
-  
 
   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
+  fTRDCalibraFillHisto->SetIsHLT(); // per detector
+  //fTRDCalibraFillHisto->SetDebugLevel(1);// debug
+  fTRDCalibraFillHisto->SetFillWithZero(kTRUE);
+
+  fTracksArray = new TClonesArray("AliTRDtrackV1");
+  fOutArray = new TObjArray(3);
+
   return 0;
 }
 
 Int_t AliHLTTRDCalibrationComponent::DeinitCalibration()
 {
-  HLTDebug("DeinitCalibration");
-
+  
   // Deinitialization of the component
+  
+  HLTDebug("DeinitCalibration");
+  fTracksArray->Delete();
+  delete fTracksArray;
+  fTRDCalibraFillHisto->Destroy();
+  //fOutArray->Delete();
+  delete fOutArray;
 
   return 0;
 }
@@ -198,61 +220,64 @@ Int_t AliHLTTRDCalibrationComponent::ProcessCalibration(const AliHLTComponent_Ev
         continue;
       }
       else {
-        HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s",
+        HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s; Block Size: %i",
                  iBlock, evtData.fBlockCnt-1,
                  evtData.fEventID, evtData.fEventID,
-                 DataType2Text(inputDataType).c_str());
+                 DataType2Text(inputDataType).c_str(),
+                block.fSize);
       }
 
-      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);
-        }
+      Int_t nTimeBins;
+      AliHLTTRDUtils::ReadTracks(fTracksArray, block.fPtr, block.fSize, &nTimeBins);
+      
+      if(!fRecievedTimeBins){
+       HLTDebug("Reading number of time bins from input block. Value is: %d", nTimeBins);
+       fTRDCalibraFillHisto->Init2Dhistos(); // initialise the histos
+       fTRDCalibraFillHisto->SetNumberClusters(0); // At least 1 clusters
+       fTRDCalibraFillHisto->SetNumberClustersf(nTimeBins); // Not more than %d  clusters
+       fRecievedTimeBins=kTRUE;
       }
 
-
-      TObjArray *outArray = FormOutput();
-      if (outArray) {
-        PushBack(outArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
-        delete outArray;
+      Int_t nbEntries = fTracksArray->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*)fTracksArray->At(i);
+       trdTrack->Print();
+       fTRDCalibraFillHisto->UpdateHistogramsV1(trdTrack);
+      }
+      
+      if(!fOutArray->At(0))FormOutput();
+      if (fNevent%feveryNevent==0 && fOutArray) {
+        PushBack(fOutArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
       }
 
+      fTracksArray->Delete();
+      fNevent++;
+
     }
   return 0;
 
 }
 
-
 /**
  * Form output array of histrograms
  */
 //============================================================================
-TObjArray* AliHLTTRDCalibrationComponent::FormOutput()
+void AliHLTTRDCalibrationComponent::FormOutput()
 {
-  TObjArray *outArray=new TObjArray(3);
-
   // gain histo
   TH2I *hCH2d = fTRDCalibraFillHisto->GetCH2d();
-  outArray->Add(hCH2d);
+  fOutArray->Add(hCH2d);
 
   // drift velocity histo
   TProfile2D *hPH2d = fTRDCalibraFillHisto->GetPH2d();
-  outArray->Add(hPH2d);
+  fOutArray->Add(hPH2d);
 
   // PRF histo
   TProfile2D *hPRF2d = fTRDCalibraFillHisto->GetPRF2d();
-  outArray->Add(hPRF2d);
+  fOutArray->Add(hPRF2d);
 
   HLTDebug("GetCH2d = 0x%x; NEntries = %i; size = %i", hCH2d, hCH2d->GetEntries(), sizeof(hCH2d));
   hCH2d->Print();
@@ -260,11 +285,11 @@ TObjArray* AliHLTTRDCalibrationComponent::FormOutput()
   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;
-
+  HLTDebug("output Array: pointer = 0x%x; NEntries = %i; size = %i", fOutArray, fOutArray->GetEntries(), sizeof(fOutArray));
 }
 
+Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
+{
+  //fTRDCalibraFillHisto->DestroyDebugStreamer();
+  PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF");
+}
index dc69538..d844580 100644 (file)
@@ -1,7 +1,11 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDCALIBRATIONCOMPONENT_H
 #define ALIHLTTRDCALIBRATIONCOMPONENT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 /** @file   AliHLTTRDCalibrationComponent.h
     @author Timm Steinbeck, Matthias Richter
@@ -12,6 +16,7 @@
 #include "AliHLTCalibrationProcessor.h"
 class AliCDBManager;
 class AliTRDCalibraFillHisto;
+class TClonesArray;
 
 /**
  * @class AliHLTTRDCalibrationComponent
@@ -30,54 +35,57 @@ class AliTRDCalibraFillHisto;
  * @ingroup alihlt_tutorial
  */
 class AliHLTTRDCalibrationComponent : public AliHLTCalibrationProcessor
-    {
-    public:
-       AliHLTTRDCalibrationComponent();
-       virtual ~AliHLTTRDCalibrationComponent();
+{
+public:
+  AliHLTTRDCalibrationComponent();
+  virtual ~AliHLTTRDCalibrationComponent();
 
-       // Public functions to implement AliHLTComponent's interface.
-       // These functions are required for the registration process
+  // 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();
+  const char* GetComponentID();
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
+  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+  AliHLTComponent* Spawn();
        
-    protected:
+protected:
        
-       // Protected functions to implement AliHLTComponent's interface.
-       // These functions provide initialization as well as the actual processing
-       // capabilities of the component. 
+  // Protected functions to implement AliHLTComponent's interface.
+  // These functions provide initialization as well as the actual processing
+  // capabilities of the component. 
        
-       AliTRDCalibraFillHisto *fTRDCalibraFillHisto;
+  AliTRDCalibraFillHisto *fTRDCalibraFillHisto;
        
-       virtual Int_t InitCalibration();
-       virtual Int_t ScanArgument(int argc, const char** argv);
-       virtual Int_t DeinitCalibration();
-       virtual Int_t ProcessCalibration(const AliHLTComponent_EventData& evtData,
-                                        const AliHLTComponent_BlockData* blocks,
-                                        AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
-                                        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 InitCalibration();
+  virtual Int_t ScanArgument(int argc, const char** argv);
+  virtual Int_t DeinitCalibration();
+  virtual Int_t ProcessCalibration(const AliHLTComponent_EventData& evtData,
+                                  const AliHLTComponent_BlockData* blocks,
+                                  AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
+                                  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);
        
-       using AliHLTCalibrationProcessor::ProcessCalibration;
-//     using AliHLTCalibrationProcessor::ShipDataToFXS;
+  using AliHLTCalibrationProcessor::ProcessCalibration;
+  //using AliHLTCalibrationProcessor::ShipDataToFXS;
 
-    private:
-       /** copy constructor prohibited */
-       AliHLTTRDCalibrationComponent(const AliHLTTRDCalibrationComponent&);
-       /** assignment operator prohibited */
-       AliHLTTRDCalibrationComponent& operator=(const AliHLTTRDCalibrationComponent&);
-       TObjArray* FormOutput();
+private:
+  /** copy constructor prohibited */
+  AliHLTTRDCalibrationComponent(const AliHLTTRDCalibrationComponent&);
+  /** assignment operator prohibited */
+  AliHLTTRDCalibrationComponent& operator=(const AliHLTTRDCalibrationComponent&);
+  void FormOutput();
 
-       // 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
-       
-       ClassDef(AliHLTTRDCalibrationComponent, 1)
+  AliHLTUInt32_t fOutputSize;    // output size
+  TClonesArray* fTracksArray;    // array containing the input
+  TObjArray* fOutArray;          // array containing the output
+  UInt_t fNevent;                 // number of processed events
+  UInt_t feveryNevent;            // push back every nth event
+  Bool_t fRecievedTimeBins;      // already recived the number of time bins?
+
+  ClassDef(AliHLTTRDCalibrationComponent, 1)
 
-    };
+};
 #endif
index 50d85ff..5621c0d 100644 (file)
@@ -9,14 +9,14 @@ AliHLTTRDCluster::AliHLTTRDCluster():
   fY(0),
   fZ(0),
   fQ(0),
-  fIsInChamber(kFALSE),
-  fIsShared(kFALSE),
   fDetector(-1),
   fLocalTimeBin(0),
   fClusterMasking(0),
   fPadCol(0),
   fPadRow(0),
-  fPadTime(0)
+  fPadTime(0),
+  fIsInChamber(kFALSE),
+  fIsShared(kFALSE)
 {
 }
 
@@ -24,22 +24,22 @@ AliHLTTRDCluster::AliHLTTRDCluster():
  * Main Constructor
  */
 //============================================================================
-AliHLTTRDCluster::AliHLTTRDCluster(AliTRDcluster * inCluster):
+AliHLTTRDCluster::AliHLTTRDCluster(const AliTRDcluster* const inCluster):
   fX (inCluster->GetX()),
   fY (inCluster->GetY()),
   fZ (inCluster->GetZ()),
-  fQ (inCluster->GetQ()),
+  fQ (inCluster->fQ),
+  fDetector (inCluster->fDetector),
+  fLocalTimeBin (inCluster->fLocalTimeBin),
+  fClusterMasking (inCluster->fClusterMasking),
+  fPadCol (inCluster->fPadCol),
+  fPadRow (inCluster->fPadRow),
+  fPadTime (inCluster->fPadTime),
   fIsInChamber(inCluster->IsInChamber()),
-  fIsShared (inCluster->IsShared()),
-  fDetector (inCluster->GetDetector()),
-  fLocalTimeBin (inCluster->GetLocalTimeBin()),
-  fClusterMasking (inCluster->IsMasked()),
-  fPadCol (inCluster->GetPadCol()),
-  fPadRow (inCluster->GetPadRow()),
-  fPadTime ( inCluster->GetPadTime())
+  fIsShared (inCluster->IsShared())
 {
-  //  fNPads = inCluster->GetNPads();
-  //  fCenter = inCluster->GetCenter();
+  for(int i=0; i<3; i++)
+    fSignals[i]=inCluster->fSignals[i+2];
 }
 
 
@@ -47,35 +47,32 @@ AliHLTTRDCluster::AliHLTTRDCluster(AliTRDcluster * inCluster):
  * Copy data to the output TRDcluster
  */
 //============================================================================
-void AliHLTTRDCluster::ExportTRDCluster(AliTRDcluster *outCluster)
+void AliHLTTRDCluster::ExportTRDCluster(AliTRDcluster* const outCluster) const
 {
   //  Print();
   outCluster->SetX(fX);
   outCluster->SetY(fY);
   outCluster->SetZ(fZ);
-  outCluster->SetQ(fQ);
+  outCluster->fQ=fQ;
   outCluster->SetInChamber(fIsInChamber);
   outCluster->SetShared(fIsShared);
-  outCluster->SetDetector(fDetector);
-  outCluster->SetLocalTimeBin(fLocalTimeBin);
-  outCluster->SetClusterMasking(fClusterMasking);
+  outCluster->fDetector=fDetector;
+  outCluster->fLocalTimeBin=fLocalTimeBin;
+  outCluster->fClusterMasking=fClusterMasking;
+  outCluster->fPadCol=fPadCol;
+  outCluster->fPadRow=fPadRow;
+  outCluster->fPadTime=fPadTime;
 
-  outCluster->SetPadCol(fPadCol);
-  outCluster->SetPadRow(fPadRow);
-  outCluster->SetPadTime(fPadTime);
-  //  outCluster->SetNPads(fNPads);
-  //  outCluster->SetCenter(fCenter);
-  
-  
+  for(int i=0; i<3; i++)
+    outCluster->fSignals[i+2]=fSignals[i];
 }
 
 /**
  * Prints main info about cluster
  */
 //============================================================================
-void AliHLTTRDCluster::Print()
+void AliHLTTRDCluster::Print() const
 {
-  //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);
-  
+  printf("   --hltCluster-- addr %p; sizeof(*this) %i\n", (void*)this, sizeof(*this));
+  printf("     fX %f; fY %f; fZ %f\n",fX,fY,fZ);
 }
index 9cc5b6e..dd2bb48 100644 (file)
@@ -1,5 +1,11 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDCLUSTER_H
 #define ALIHLTTRDCLUSTER_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 #include "AliTRDcluster.h"
 #include "AliHLTDataTypes.h"
@@ -8,24 +14,19 @@ class AliHLTTRDCluster
 {
  public:
   AliHLTTRDCluster();
-  AliHLTTRDCluster(AliTRDcluster* inCluster);
-  void ExportTRDCluster(AliTRDcluster* outCluster);
-
-  AliHLTUInt8_t *GetEndPointer() // Returns pointer to the end of the cluster
-  { return ((AliHLTUInt8_t *) this + sizeof(*this)); };
-  AliHLTUInt32_t GetSize(){ return sizeof(*this); };
-  void Print();      
+  AliHLTTRDCluster(const AliTRDcluster* const inCluster);
+  void ExportTRDCluster(AliTRDcluster* const outCluster) const;
+  void Print() const;      
   
  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;
-  Short_t fDetector;       //  TRD detector number
+  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 
+
+  Short_t fSignals[3];     //  Signals in the cluster
+  Short_t fDetector;       //  TRD detector number 
   Char_t  fLocalTimeBin;   //  T0-calibrated time bin number
   UChar_t fClusterMasking; //  Bit field containing cluster status information;
 
@@ -33,10 +34,13 @@ class AliHLTTRDCluster
   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 
+
+  Bool_t fIsInChamber;
+  Bool_t fIsShared;
+
   //   UChar_t fNPads;          //  Number of pads in cluster 
   //   Float_t fCenter;         //  Center of the cluster relative to the pad  
-   
+
 };
 
 #endif
index 6969a34..103e138 100644 (file)
@@ -23,6 +23,8 @@
 using namespace std;
 #endif
 
+#include <time.h>
+
 #include "AliHLTTRDClusterHistoComponent.h"
 #include "AliHLTTRDDefinitions.h"
 #include "AliHLTTRDCluster.h"
@@ -33,7 +35,9 @@ using namespace std;
 #include <TString.h>
 #include "TObjString.h"
 #include "TClonesArray.h"
+#include "TTimeStamp.h"
 #include "AliHLTTRDUtils.h"
+#include "TH2F.h"
 
 //#include "AliHLTTRD.h"
 //#include <stdlib.h>
@@ -43,13 +47,20 @@ using namespace std;
 ClassImp(AliHLTTRDClusterHistoComponent)
 
 AliHLTTRDClusterHistoComponent::AliHLTTRDClusterHistoComponent()
-: fClusterArray(NULL),
+: AliHLTProcessor(),
+  fOutputSize(100000),
+  fClusterArray(NULL),
+  fNevent(0),
+  feveryNevent(20),
   fNClsDet(NULL),
   fClsAmp(NULL),
   fClsAmpDrift(NULL),
   fClsTB(NULL),
   fClsAmpDist(NULL),
-  fSClsDist(NULL)
+  fSClsDist(NULL),
+  fNScls(NULL),
+  fClusterDist(NULL),
+  fClusterCandCharge(NULL)
 {
   // see header file for class documentation
   // or
@@ -91,8 +102,8 @@ AliHLTComponentDataType AliHLTTRDClusterHistoComponent::GetOutputDataType()
 void AliHLTTRDClusterHistoComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 {
   // see header file for class documentation
-  constBase = 5000;
-  inputMultiplier = 3;
+  constBase = fOutputSize;
+  inputMultiplier = 0;
 }
 
 AliHLTComponent* AliHLTTRDClusterHistoComponent::Spawn()
@@ -101,9 +112,22 @@ AliHLTComponent* AliHLTTRDClusterHistoComponent::Spawn()
   return new AliHLTTRDClusterHistoComponent;
 }
 
-int AliHLTTRDClusterHistoComponent::DoInit(int /*argc*/, const char** /*argv*/ )
+int AliHLTTRDClusterHistoComponent::DoInit(int argc, const char** argv)
 {
   // Initialize histograms
+  int iResult=0;
+  
+  TString configuration="";
+  TString argument="";
+  for (int i=0; i<argc && iResult>=0; i++) {
+    argument=argv[i];
+    if (!configuration.IsNull()) configuration+=" ";
+    configuration+=argument;
+  }
+
+  if (!configuration.IsNull()) {
+    iResult=Configure(configuration.Data());
+  } 
 
   fClusterArray = new TClonesArray("AliTRDcluster");
 
@@ -113,11 +137,16 @@ int AliHLTTRDClusterHistoComponent::DoInit(int /*argc*/, const char** /*argv*/ )
   fClsTB = new TH1D("trdClsTB", ";time bin", 35, -0.5, 34.5);
   fClsAmpDist = new TH1D("trdClsAmpDist", "mean amplitude", 200, 0, 1000);
   fSClsDist = new TH1D("sclsdist", "Super cluster spectrum", 200, 0, 8000);
+  fNScls = new TH1D("nscls", "No. of Kr clusters per event", 540, 0, 540);
+  fClusterDist = new TH2F("cldist", "Cluster distribution;padrow;padcol", 16*5, -0.5, 79.5, 8*6*18, -0.5, 863.5);
+  fClusterCandCharge = new TH1D("qClsCand", "Cluster candidate charge;charge (ADC counts);counts", 200, 0, 8000);
 
-  for(int i=0; i<540; i++)
+  for(int i=0; i<540; i++) {
     fClsAmpDriftDet[i] = new TH1D(Form("trdClsDriftDet_%d",i), "", 200, -0.5, 199.5);
-    
-    return 0;
+    fSlidingWindow[i].SetBins(9, -0.5, 8.5, 17, -0.5, 16.5);
+  }
+  
+  return 0;
 }
   
 int AliHLTTRDClusterHistoComponent::DoDeinit()
@@ -134,6 +163,9 @@ int AliHLTTRDClusterHistoComponent::DoDeinit()
   if (fClsTB) delete fClsTB;
   if (fClsAmpDist) delete fClsAmpDist;
   if (fSClsDist) delete fSClsDist;
+  if (fClusterDist) delete fClusterDist;
+  if (fClusterCandCharge) delete fClusterCandCharge;
+  if (fNScls) delete fNScls;
 
   for(int i=0; i<540; i++)
     if (fClsAmpDriftDet[i]) delete fClsAmpDriftDet[i];
@@ -141,15 +173,40 @@ int AliHLTTRDClusterHistoComponent::DoDeinit()
   return 0;
 }
 
-int AliHLTTRDClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, 
+int AliHLTTRDClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/,
                                            AliHLTComponentTriggerData& /*trigData*/)
 {
 
+  // if (GetFirstInputBlock(kAliHLTDataTypeSOR)) return 0;
+  // else if (GetFirstInputBlock(kAliHLTDataTypeEOR))
+  //   {
+  //     TString fileName="/tmp/ClusterHistoDump_run";
+  //     fileName+=AliCDBManager::Instance()->GetRun();
+  //     fileName+=".root";
+  //     HLTInfo("Dumping Histogram file to %s",fileName.Data());
+  //     TFile* file = TFile::Open(fileName, "RECREATE");
+  //     fNClsDet->Write();
+  //     fClsAmp->Write();
+  //     fClsAmpDrift->Write();
+  //     fClsTB->Write();
+  //     fClsAmpDist->Write(); 
+  //     fSClsDist->Write();
+  //     fNScls->Write();
+  //     fClusterDist->Write();
+  //     fClusterCandCharge->Write();
+  //     file->Close();
+  //     HLTInfo("Histogram file dumped");
+  //     return 0;
+  //   }
+
   if (GetFirstInputBlock(kAliHLTDataTypeSOR) || GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;
-  
+
   const AliHLTComponentBlockData* iter = NULL;
   
   Float_t sClusterCharge[540] = { 0 };
+  for (Int_t iDet = 0; iDet < 540; iDet++) {
+    fSlidingWindow[iDet].Reset();
+  }
 
   for ( iter = GetFirstInputBlock(AliHLTTRDDefinitions::fgkClusterDataType); 
        iter != NULL; iter = GetNextInputBlock() ) {
@@ -168,7 +225,6 @@ int AliHLTTRDClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*ev
       cls=(AliTRDcluster*)fClusterArray->At(i);
       
       fNClsDet->Fill(cls->GetDetector());
-      sClusterCharge[cls->GetDetector()] += cls->GetQ();
       fClsAmp->Fill(cls->GetQ());
       
       int tb = cls->GetPadTime();
@@ -177,6 +233,14 @@ int AliHLTTRDClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*ev
        fClsAmpDrift->Fill(cls->GetQ()); 
       
       fClsAmpDriftDet[cls->GetDetector()]->Fill(cls->GetQ());
+
+      Int_t det = cls->GetDetector();
+      sClusterCharge[det] += cls->GetQ();
+
+      fSlidingWindow[det].Fill((cls->GetPadCol() / 18), cls->GetPadRow(), cls->GetQ());
+      fSlidingWindow[det].Fill((cls->GetPadCol() / 18), cls->GetPadRow() + 1, cls->GetQ());
+      fSlidingWindow[det].Fill((cls->GetPadCol() / 18) + 1, cls->GetPadRow(), cls->GetQ());
+      fSlidingWindow[det].Fill((cls->GetPadCol() / 18) + 1, cls->GetPadRow() + 1, cls->GetQ());
     }
     
     fClusterArray->Delete();
@@ -184,18 +248,79 @@ int AliHLTTRDClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*ev
   }
    
   fClsAmpDist->Reset();
+  Int_t nSClusters = 0;
   for(int det=0; det<540; det++) {
     if (fClsAmpDriftDet[det]->GetSum() > 0) 
       fClsAmpDist->Fill(fClsAmpDriftDet[det]->GetMean());
     fSClsDist->Fill(sClusterCharge[det]);
+
+    Int_t xmax;
+    Int_t ymax;
+    Int_t zmax;
+    fSlidingWindow[det].GetMaximumBin(xmax, ymax, zmax);
+    Float_t charge = fSlidingWindow[det].GetBinContent(xmax, ymax);
+    fClusterCandCharge->Fill(charge);
+    if (charge > 2000. && charge < 6500.) {
+      nSClusters++;
+      fClusterDist->Fill((ymax-1) + 16 * ((det % 30) / 6), (det / 30) * 48 + 8 * (det % 6) + (xmax-1));
+    }
   }
 
-  PushBack((TObject*)fNClsDet, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);   
-  PushBack((TObject*)fClsAmp, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
-  PushBack((TObject*)fClsAmpDrift, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);   
-  PushBack((TObject*)fClsTB, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
-  PushBack((TObject*)fClsAmpDist, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
-  PushBack((TObject*)fSClsDist, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
-    
+  fNScls->Fill(nSClusters);
+
+  if(fNevent%feveryNevent==0){
+    PushBack((TObject*)fNClsDet, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);   
+    PushBack((TObject*)fClsAmp, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
+    //  PushBack((TObject*)fClsAmpDrift, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);   
+    //  PushBack((TObject*)fClsTB, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
+    //  PushBack((TObject*)fClsAmpDist, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
+    PushBack((TObject*)fNScls, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
+    PushBack((TObject*)fSClsDist, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);  
+    PushBack((TObject*)fClusterDist, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);
+    PushBack((TObject*)fClusterCandCharge, kAliHLTDataTypeHistogram | kAliHLTDataOriginTRD, 0);
+  }
+  
+  fNevent++;
   return 0;
 }
+
+int AliHLTTRDClusterHistoComponent::Configure(const char* arguments){
+  int iResult=0;
+  if (!arguments) return iResult;
+  
+  TString allArgs=arguments;
+  TString argument;
+  int bMissingParam=0;
+
+  TObjArray* pTokens=allArgs.Tokenize(" ");
+  if (pTokens) {
+    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
+      argument=((TObjString*)pTokens->At(i))->GetString();
+      if (argument.IsNull()) continue;
+      
+      if (argument.CompareTo("output_size")==0) {
+       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       HLTInfo("Setting output size to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
+       fOutputSize=((TObjString*)pTokens->At(i))->GetString().Atoi();
+       continue;
+      } 
+      if (argument.CompareTo("-everyNevent")==0) {
+       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       HLTInfo("Pushing back every %s event.", ((TObjString*)pTokens->At(i))->GetString().Data());
+       feveryNevent=((TObjString*)pTokens->At(i))->GetString().Atoi();
+       continue;
+      } 
+      else {
+       HLTError("unknown argument: %s", argument.Data());
+       iResult=-EINVAL;
+       break;
+      }
+    }
+    delete pTokens;
+  }
+  if (bMissingParam) {
+    HLTError("missing parameter for argument %s", argument.Data());
+    iResult=-EINVAL;
+  }
+  return iResult;
+}
index e37ab33..66bdf06 100644 (file)
@@ -1,3 +1,6 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDCLUSTERHISTOCOMPONENT_H
 #define ALIHLTTRDCLUSTERHISTOCOMPONENT_H
 //* This file is property of and copyright by the ALICE HLT Project        * 
@@ -7,6 +10,7 @@
 
 #include "AliHLTProcessor.h"
 #include "TH1D.h"
+#include "TH2F.h"
 
 /**
  * @class AliHLTTRDQHistoComponent
@@ -57,9 +61,11 @@ protected:
   /** interface function, see AliHLTComponent for description */
   int DoDeinit();
   /** interface function, see AliHLTComponent for description */
-  int DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& trigData );
+  int DoEvent( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
 
   using AliHLTProcessor::DoEvent;
+
+  int Configure(const char* arguments);
   
 private:
   /** copy constructor prohibited */
@@ -72,7 +78,10 @@ private:
    * properties.
    */ 
 
-  TClonesArray* fClusterArray;
+  AliHLTUInt32_t fOutputSize;   // output size
+  TClonesArray* fClusterArray;  // input array
+  UInt_t fNevent;               // number of processed events
+  UInt_t feveryNevent;          // push back every nth event
 
   TH1D *fNClsDet;
   TH1D *fClsAmp;
@@ -83,6 +92,12 @@ private:
   TH1D *fClsAmpDist; 
 
   TH1D *fSClsDist;
+  TH1D *fNScls;
+
+  // kryptogramm
+  TH2F fSlidingWindow[540];
+  TH2F *fClusterDist;
+  TH1D *fClusterCandCharge;
 
   ClassDef(AliHLTTRDClusterHistoComponent, 0);
 };
index 06f23e7..514908e 100644 (file)
@@ -1,7 +1,11 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDCLUSTERIZER_H
 #define ALIHLTTRDCLUSTERIZER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 ////////////////////////////////////////////////////////////////////////////
 //                                                                        //
@@ -15,8 +19,6 @@
 #include "AliHLTDataTypes.h"
 #include "AliHLTTRDTrackletWordArray.h"
 
-class AliHLTTRDTrackletWord;
-
 class AliHLTTRDClusterizer : public AliTRDclusterizer
 {
  public:
@@ -29,16 +31,18 @@ class AliHLTTRDClusterizer : public AliTRDclusterizer
   void            SetMemBlock(AliHLTUInt8_t* ptr){
     if(fReconstructor->IsProcessingTracklets()){
       fTrMemBlock=ptr; fTrMemCurrPtr=ptr;
-      fClMemBlock=ptr+GetTrMemBlockSize(); fNoOfClusters=0;  //if IsProcessingTracklets() is enabled we always reserve a data block of size GetTrMemBlockSize() for the tracklets
+      fClMemBlock=ptr+GetTrMemBlockSize();  //if IsProcessingTracklets() is enabled we always reserve a data block of size GetTrMemBlockSize() for the tracklets
     }else{
-      fClMemBlock=ptr; fNoOfClusters=0;
+      fClMemBlock=ptr;
     }
+    fNoOfClusters=0;
   }
   AliHLTUInt8_t*  GetClMemBlock(){return fClMemBlock;}
   AliHLTUInt8_t*  GetTrMemBlock(){return fTrMemBlock;}
   UInt_t          GetAddedClSize(){return fNoOfClusters*sizeof(AliHLTTRDCluster);}
   UInt_t          GetAddedTrSize(){return (AliHLTUInt8_t*)fTrMemCurrPtr-(AliHLTUInt8_t*)fTrMemBlock;}
   UInt_t          GetTrMemBlockSize(){return 30*(sizeof(AliHLTTRDTrackletWordArray)+512*sizeof(UInt_t));}
+  Int_t           GetNTimeBins() const {return fTimeTotal;}
 
  protected:
   void            AddClusterToArray(AliTRDcluster *cluster);
index d1bb8df..39d5277 100644 (file)
@@ -63,10 +63,13 @@ using namespace std;
 #include <cerrno>
 #include <string>
 
+#include "AliTRDrawStream.h"
+#include "AliTRDrawFastStream.h"
+
 ClassImp(AliHLTTRDClusterizerComponent)
    
-AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
-  AliHLTProcessor(),
+AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
+: AliHLTProcessor(),
   fOutputPercentage(500),
   fOutputConst(0),
   fClusterizer(NULL),
@@ -79,7 +82,7 @@ AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
   fyPosMethod(1),
   fgeometryFileName(""),
   fProcessTracklets(kFALSE),
-  fHLTstreamer(kFALSE)
+  fHLTstreamer(kTRUE)
 {
   // Default constructor
 
@@ -102,10 +105,10 @@ void AliHLTTRDClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_Da
 {
   // Get the list of input data
   list.clear(); // We do not have any requirements for our input data type(s).
-  list.push_back( (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD) );
+  list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
 }
 
-AliHLTComponent_DataType AliHLTTRDClusterizerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTRDClusterizerComponent::GetOutputDataType()
 {
   // Get the output data type
   return kAliHLTMultipleDataType;
@@ -169,7 +172,10 @@ int AliHLTTRDClusterizerComponent::DoInit( int argc, const char** argv )
 
   if(fReconstructor->IsProcessingTracklets())
     fOutputConst = fClusterizer->GetTrMemBlockSize();
-  
+
+  AliTRDrawStream::SetSubtractBaseline(10);
+  AliTRDrawFastStream::SetSubtractBaseline(10);
+
   return iResult;
 }
 
@@ -270,10 +276,10 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
       fMemReader->SetEquipmentID( id ); 
       
       fClusterizer->SetMemBlock(outputPtr+offset);
-      Bool_t iclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
-      if (iclustered == kTRUE)
+      Bool_t bclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
+      if(bclustered)
        {
-         HLTDebug( "Clustered successfully");
+         HLTDebug("Clustered successfully");
        }
       else
        {
@@ -281,9 +287,6 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
          return -1;
        }
 
-      // put the tree into output
-      //fcTree->Print();
-      
       AliHLTUInt32_t addedSize;
       if(fReconstructor->IsProcessingTracklets()){
        addedSize = fClusterizer->GetAddedTrSize();
@@ -306,15 +309,18 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
          bd.fSpecification = block.fSpecification;
          bd.fDataType = AliHLTTRDDefinitions::fgkMCMtrackletDataType;
          outputBlocks.push_back( bd );
-         HLTDebug( "BD fPtr 0x%x, fOffset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+         HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
        }
        offset = totalSize;
       }
 
       addedSize = fClusterizer->GetAddedClSize();
       if (addedSize > 0){
-       // Using low-level interface 
-       // with interface classes
+       
+       Int_t* nTimeBins = (Int_t*)(outputPtr+offset+fClusterizer->GetAddedClSize());
+       *nTimeBins = fClusterizer->GetNTimeBins();
+       addedSize += sizeof(*nTimeBins);
+
        totalSize += addedSize;
        if ( totalSize > size )
          {
@@ -322,7 +328,7 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
                     totalSize, size );
            return EMSGSIZE;
          }
-               
+
        // Fill block 
        AliHLTComponentBlockData bd;
        FillBlockData( bd );
@@ -331,9 +337,8 @@ int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtD
        bd.fSpecification = block.fSpecification;
        bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType;
        outputBlocks.push_back( bd );
-       HLTDebug( "BD fPtr 0x%x, fOffset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+       HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
        offset = totalSize;
-             
       }
       else 
        HLTDebug("Array of clusters is empty!");
@@ -385,46 +390,51 @@ int AliHLTTRDClusterizerComponent::Configure(const char* arguments){
        fgeometryFileName=((TObjString*)pTokens->At(i))->GetString();
        continue;
       } 
-      if (argument.CompareTo("-lowflux")==0) {
+      else if (argument.CompareTo("-lowflux")==0) {
        fRecoParamType = 0;
        HLTInfo("Low flux reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-highflux")==0) {
+      else if (argument.CompareTo("-highflux")==0) {
        fRecoParamType = 1;
        HLTInfo("High flux reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-cosmics")==0) {
+      else if (argument.CompareTo("-cosmics")==0) {
        fRecoParamType = 2;
        HLTInfo("Cosmics reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-simulation")==0) {
+      else if (argument.CompareTo("-simulation")==0) {
        fRecoDataType = 0;
        HLTInfo("Awaiting simulated data");
        continue;
       }
-      if (argument.CompareTo("-experiment")==0) {
+      else if (argument.CompareTo("-experiment")==0) {
        fRecoDataType = 1;
        HLTInfo("Awaiting real data");
        continue;
       }
-      if (argument.CompareTo("-processTracklets")==0) {
+      else if (argument.CompareTo("-processTracklets")==0) {
        fProcessTracklets = kTRUE;
-       HLTInfo("Processing L1 Tracklets");
+       HLTInfo("Writing L1 tracklets to output");
        continue;
       }
-      if (argument.CompareTo("-noZS")==0) {
+      else if (argument.CompareTo("-noZS")==0) {
        fOutputPercentage = 100;
        HLTInfo("Awaiting non zero surpressed data");
        continue;
       }
-      if (argument.CompareTo("-faststreamer")==0) {
+      else if (argument.CompareTo("-faststreamer")==0) {
        fHLTstreamer = kTRUE;
        HLTInfo("Useing fast raw streamer");
        continue;
       }
+      else if (argument.CompareTo("-nofaststreamer")==0) {
+       fHLTstreamer = kFALSE;
+       HLTInfo("Don't use fast raw streamer");
+       continue;
+      }
       else if (argument.CompareTo("-rawver")==0) {
        if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
        HLTInfo("Raw data version is: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
@@ -452,7 +462,7 @@ int AliHLTTRDClusterizerComponent::Configure(const char* arguments){
          break;
        }
        continue;
-      } 
+      }
       
       else {
        HLTError("unknown argument: %s", argument.Data());
index 99bb70b..4f4295f 100644 (file)
@@ -40,8 +40,8 @@ public:
   // These functions are required for the registration process
 
   const char* GetComponentID();
-  void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-  AliHLTComponent_DataType GetOutputDataType();
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
   int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
   AliHLTComponent* Spawn();
@@ -87,8 +87,8 @@ private:
   Int_t fRawDataVersion;
   Int_t fyPosMethod;        // 0=COG 1=LUT 2=Gauss 
   TString fgeometryFileName;
-  Bool_t fProcessTracklets;
-  Bool_t fHLTstreamer;
+  Bool_t fProcessTracklets; // write the L! tracklets to output
+  Bool_t fHLTstreamer;      // use FastStreamer
 
   ClassDef(AliHLTTRDClusterizerComponent, 3)
 
index a92d5fb..fa957bc 100644 (file)
@@ -27,8 +27,6 @@
 
 ClassImp(AliHLTTRDDefinitions)
 
-const AliHLTComponentDataType AliHLTTRDDefinitions::fgkDDLRawDataType = { sizeof(AliHLTComponentDataType), {'D','D','L','_','R','A','W',' '},{'T','R','D',' '}};;
-
 const AliHLTComponentDataType AliHLTTRDDefinitions::fgkClusterDataType = { sizeof(AliHLTComponentDataType), {'C','L','U','S','T','E','R','S'},{'T','R','D',' '}};;
 
 const AliHLTComponentDataType AliHLTTRDDefinitions::fgkTRDSATracksDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','C','K','S','S','A'},{'T','R','D',' '}};;
index 5151197..adee672 100644 (file)
@@ -1,10 +1,11 @@
-// XEmacs -*-C++-*-
-// @(#) $Id$
+//-*- Mode: C++ -*-
+// $Id$
 
 #ifndef ALIHLTTRDDEFINITIONS_H
 #define ALIHLTTRDDEFINITIONS_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 /* AliHLTTRDDefinitions
  */
@@ -27,7 +28,6 @@ public:
   AliHLTTRDDefinitions();
   virtual ~AliHLTTRDDefinitions();
   
-  static const AliHLTComponentDataType fgkDDLRawDataType; // Raw Data
   static const AliHLTComponentDataType fgkClusterDataType; // TRD Cluster Data
   static const AliHLTComponentDataType fgkTRDSATracksDataType; // Stand Alone tracks
   static const AliHLTComponentDataType fgkTRDSAEsdDataType; // Stand Alone tracks
index c403e77..5b4ac83 100644 (file)
@@ -1,7 +1,11 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDESDWRITERCOMPONENT_H
 #define ALIHLTTRDESDWRITERCOMPONENT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 /** @file   AliHLTTRDEsdWriterComponent.h
     @author Mateusz Ploskon
index ee5f31f..c0bdd3a 100644 (file)
@@ -7,18 +7,14 @@
  */
 //============================================================================
 AliHLTTRDTrack::AliHLTTRDTrack():
-  fSize(sizeof(AliHLTTRDTrack)),
-  fTRDtrack(NULL),
-  fPIDquality(0),
   fDE(-1),
   fFakeRatio(-1),
   fChi2(-1),
-  fMass(-1),
-  fLab(-1),
   fN(-1),
   fIntegratedLength(-1),
   fX(-1),
-  fAlpha(-1)
+  fAlpha(-1),
+  fSize(sizeof(AliHLTTRDTrack))
 {
   InitArrays();
   // not to be used
@@ -29,28 +25,17 @@ AliHLTTRDTrack::AliHLTTRDTrack():
  * Creates hltTrack from TRDtrackV1
  */
 //============================================================================
-AliHLTTRDTrack::AliHLTTRDTrack(AliTRDtrackV1 * inTrack):
-  fSize(sizeof(AliHLTTRDTrack)),
-  fTRDtrack(NULL),
-  fPIDquality(0),
-  fDE(-1),
-  fFakeRatio(-1),
-  fChi2(-1),
-  fMass(-1),
-  fLab(-1),
-  fN(-1),
-  fIntegratedLength(-1),
-  fX(-1),
-  fAlpha(-1)
+AliHLTTRDTrack::AliHLTTRDTrack(const AliTRDtrackV1* const inTrack):
+  fDE(inTrack->fDE),
+  fFakeRatio(inTrack->fFakeRatio),
+  fChi2(inTrack->fChi2),
+  fN(inTrack->fN),
+  fIntegratedLength(inTrack->GetIntegratedLength()),
+  fX(inTrack->GetX()),
+  fAlpha(inTrack->GetAlpha()),
+  fSize(sizeof(AliHLTTRDTrack))
 {
-  InitArrays();
-  
-  fTRDtrack = inTrack;
-
-  CopyDataMembers();
-  
-  AddTracklets();
-  
+  CopyDataMembers(inTrack);
 }
 
 /**
@@ -64,106 +49,81 @@ AliHLTTRDTrack::~AliHLTTRDTrack()
 }
 
 /**
- * Copy tracklets to the HLTTRDTrack
- */
-//============================================================================
-void AliHLTTRDTrack::AddTracklets()
-{
-  for (Int_t iTracklet = 0; iTracklet < kNplane; iTracklet++)
-    {
-      //      if (fTracklet[iTracklet])
-       //      HLTWarning("Trying to rewrite tracklets in the Track. Not good.");
-      AliTRDseedV1 * trdTracklet = fTRDtrack->GetTracklet(iTracklet);
-      if (trdTracklet){
-       AliHLTTRDTracklet * hltTracklet = new (GetEndPointer()) AliHLTTRDTracklet(trdTracklet);
-       fSize += hltTracklet->GetSize();
-       //HLTDebug("tracklet %i; adr 0x%x; endPointer 0x%x; fSize %i", iTracklet, hltTracklet, hltTracklet->GetEndPointer(), fSize);
-       fTracklet[iTracklet] = hltTracklet;
-      }
-      else 
-       fTracklet[iTracklet] = NULL;
-    }
-}
-
-
-/**
  * Copy data members (except tracklets) from TRDtrackV1 to HLTTRDTrack.
  */
 //============================================================================
-void AliHLTTRDTrack::CopyDataMembers()
+void AliHLTTRDTrack::CopyDataMembers(const AliTRDtrackV1* const inTrack)
 {
-
-  fPIDquality = fTRDtrack->GetNumberOfTrackletsPID();
-  
   for(Int_t i = 0; i < AliPID::kSPECIES; i++)
     {
-      fPID[i] = fTRDtrack->GetPID(i);
+      fPID[i] = inTrack->fPID[i];
     }
   
   for (Int_t i = 0; i < 3; i++)
     {
-      fBudget[i] = fTRDtrack->GetBudget(i);
+      fBudget[i] = inTrack->GetBudget(i);
     }
-  fDE = fTRDtrack->GetEdep();
-  fFakeRatio = fTRDtrack->GetFakeRatio();
-  fChi2 = fTRDtrack->GetChi2();
-  fMass = fTRDtrack->GetMass();
-  fLab = fTRDtrack->GetLabel();
-  fN = fTRDtrack->GetNumberOfClusters();
-  fIntegratedLength = fTRDtrack->GetIntegratedLength();
   
-  fX = fTRDtrack->GetX();
-  fAlpha = fTRDtrack->GetAlpha();
-  const Double_t *Ptemp = fTRDtrack->GetParameter();
+  const Double_t* const Ptemp = inTrack->GetParameter();
   for (Int_t i = 0; i < 5; i++)
     {
       fP[i] = Ptemp[i];
     }
-  const Double_t *Ctemp = fTRDtrack->GetCovariance();
+  const Double_t* const Ctemp = inTrack->GetCovariance();
   for (Int_t i = 0; i < 15; i++)
     {
       fC[i] = Ctemp[i];
     }
-  
+
+  for (Int_t iTracklet = 0; iTracklet < AliTRDtrackV1::kNplane; iTracklet++)
+    {
+      AliTRDseedV1* trdTracklet = inTrack->GetTracklet(iTracklet);
+      if (trdTracklet){
+       AliHLTTRDTracklet* hltTracklet = new (GetEndPointer()) AliHLTTRDTracklet(trdTracklet);
+       fSize += hltTracklet->GetSize();
+       fTrackletAtPlane[iTracklet] = kTRUE;
+      }
+      else fTrackletAtPlane[iTracklet] = kFALSE;
+    }
 }
 
 /**
  * Copy data to the output TRDtrackV1
  */
 //============================================================================
-void AliHLTTRDTrack::ExportTRDTrack(AliTRDtrackV1 *outTrack)
+void AliHLTTRDTrack::ExportTRDTrack(AliTRDtrackV1* const outTrack) const
 {
-  outTrack->Reset();
+  //outTrack->Reset(); we always use a new fresh trdtrack as input, so this is useless
   
-  //Set members from AliTRDtrackV1
-  outTrack->SetPIDquality(fPIDquality);
-  outTrack->SetEdep(fDE);
+  outTrack->fDE=fDE;
+  outTrack->fFakeRatio=fFakeRatio;
+  outTrack->fChi2=fChi2;
+  outTrack->fN=fN;
+  outTrack->SetIntegratedLength(fIntegratedLength);
+  outTrack->Set(fX, fAlpha, fP, fC);
+
   for(Int_t i = 0; i < AliPID::kSPECIES; i++)
     {
-      outTrack->SetPID(i,fPID[i]);
+      outTrack->fPID[i] = fPID[i];
     }
   for (Int_t i = 0; i < 3; i++)
     {
       outTrack->SetBudget(i, fBudget[i]);
     }
-  for (Int_t iTracklet = 0; iTracklet < kNplane; iTracklet++){
-    if (fTracklet[iTracklet]){
+
+  AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*)this+sizeof(*this);
+  AliHLTTRDTracklet* hltTracklet;
+  
+  for (Int_t iTracklet = 0; iTracklet < AliTRDtrackV1::kNplane; iTracklet++){
+    if (fTrackletAtPlane[iTracklet]){
       AliTRDseedV1* trdTracklet = new AliTRDseedV1();
-      fTracklet[iTracklet]->ExportTRDTracklet(trdTracklet);
+      hltTracklet = (AliHLTTRDTracklet*) iterPtr;
+      hltTracklet->ExportTRDTracklet(trdTracklet);
       outTrack->SetTracklet(trdTracklet,iTracklet);
+      iterPtr += hltTracklet->GetSize();
     }
   }
 
-  //Set members from AliKalmanTrack
-  outTrack->SetFakeRatio(fFakeRatio);
-  //outTrack->SetChi2(fChi2);
-  outTrack->SetMass(fMass);
-  outTrack->SetLabel(fLab);
-  (dynamic_cast<AliKalmanTrack*>(outTrack))->SetNumberOfClusters(fN);
-  outTrack->SetIntegratedLength(fIntegratedLength);
-  
-  //Set members from AliExternalTrackParam
-  outTrack->Set(fX, fAlpha, fP, fC);
 }
   
 
@@ -173,8 +133,8 @@ void AliHLTTRDTrack::ExportTRDTrack(AliTRDtrackV1 *outTrack)
 //============================================================================
 void AliHLTTRDTrack::InitArrays()
 {
-  for(Int_t i = 0; i < kNplane; i++){
-    fTracklet[i]=NULL;
+  for(Int_t i = 0; i < AliTRDtrackV1::kNplane; i++){
+    fTrackletAtPlane[i]=kFALSE;
   }
 
   for(Int_t i = 0; i < AliPID::kSPECIES; i++)
@@ -200,10 +160,10 @@ void AliHLTTRDTrack::InitArrays()
  * Print main values for HLTTrack
  */
 //============================================================================
-void AliHLTTRDTrack::Print(Bool_t printTracklets)
+void AliHLTTRDTrack::Print(Bool_t printTracklets) const
 {
-  //printf("--hltTrack-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
-  //printf("   fPIDquality = %s; fX = %f; fAlpha = %f\n", fPIDquality, fX, fAlpha);
+  printf("--hltTrack-- addr 0x%p(%i); fSize %i\n", this, this, fSize);
+  printf("   fX = %f; fAlpha = %f\n", fX, fAlpha);
   printf("   ");
   
   for(Int_t i = 0; i < AliPID::kSPECIES; i++)
@@ -220,10 +180,15 @@ void AliHLTTRDTrack::Print(Bool_t printTracklets)
 
   if (printTracklets)
     {
-      for (Int_t i = 0; i < kNplane; i++){
-       if (fTracklet[i]){
+      AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*)this+sizeof(*this);
+      AliHLTTRDTracklet* hltTracklet;
+
+      for (Int_t i = 0; i < AliTRDtrackV1::kNplane; i++){
+       if (fTrackletAtPlane[i]){
          printf("[%i]",i);
-         fTracklet[i]->Print();
+         hltTracklet = (AliHLTTRDTracklet*) iterPtr;
+         hltTracklet->Print();
+         iterPtr += hltTracklet->GetSize();
        }
        else
          printf(" NULL ");
@@ -238,18 +203,18 @@ void AliHLTTRDTrack::Print(Bool_t printTracklets)
  * Number of tracklets should be already known
  */
 //============================================================================
-void AliHLTTRDTrack::ReadTrackletsFromMemory(void* input)
-{
-  AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*) input;
-  AliHLTTRDTracklet* hltTracklet = NULL;
+// void AliHLTTRDTrack::ReadTrackletsFromMemory(void* input)
+// {
+//   AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*) input;
+//   AliHLTTRDTracklet* hltTracklet = NULL;
   
-  for (Int_t iTracklet = 0; iTracklet < kNplane; iTracklet++){
-    if (fTracklet[iTracklet]){
-      hltTracklet = (AliHLTTRDTracklet*) iterPtr;
-      hltTracklet->ReadClustersFromMemory(iterPtr+sizeof(AliHLTTRDTracklet));
-      fTracklet[iTracklet] = hltTracklet;
-      iterPtr += hltTracklet->GetSize();
-      //hltTracklet->Print(kFALSE);
-    }
-  }
-}
+//   for (Int_t iTracklet = 0; iTracklet < AliTRDtrackV1::kNplane; iTracklet++){
+//     if (fTracklet[iTracklet]){
+//       hltTracklet = (AliHLTTRDTracklet*) iterPtr;
+//       //hltTracklet->ReadClustersFromMemory(iterPtr+sizeof(AliHLTTRDTracklet));
+//       fTracklet[iTracklet] = hltTracklet;
+//       iterPtr += hltTracklet->GetSize();
+//       //hltTracklet->Print(kFALSE);
+//     }
+//   }
+// }
index 187ab10..81d6358 100644 (file)
@@ -1,76 +1,71 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDTRACK_H
 #define ALIHLTTRDTRACK_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
-#include "AliESDtrack.h"
 #include "AliTRDtrackV1.h"
 #include "AliHLTLogging.h"
-class AliHLTTRDTracklet;
 
+class AliHLTTRDTracklet;
 
 class AliHLTTRDTrack
 {
  public:
   AliHLTTRDTrack();
+  AliHLTTRDTrack(const AliTRDtrackV1* const inTrack);
   ~AliHLTTRDTrack();
-  AliHLTTRDTrack( AliTRDtrackV1* inTrack);
 
-  void AddTracklets();
-  void CopyDataMembers();
-  void ExportTRDTrack(AliTRDtrackV1* outTrack);
-  AliHLTUInt8_t *GetEndPointer() // Returns pointer to the end of the track
+  void CopyDataMembers(const AliTRDtrackV1* const inTrack);
+  void ExportTRDTrack(AliTRDtrackV1* const outTrack) const;
+  AliHLTUInt8_t *GetEndPointer() const // Returns pointer to the end of the track
     { return ((AliHLTUInt8_t *) this + fSize); };
-  AliHLTUInt32_t GetSize(){return fSize;};
-  void Print(Bool_t printTracklets = kTRUE);
-  void ReadTrackletsFromMemory(void* );
+  AliHLTUInt32_t GetSize() const {return fSize;};
+  void Print(Bool_t printTracklets = kTRUE) const;
+  // void ReadTrackletsFromMemory(void* );
   
  private:
   AliHLTTRDTrack(const AliHLTTRDTrack& inTrack);
   AliHLTTRDTrack& operator=(const AliHLTTRDTrack& inTrack);
   void InitArrays();
   
-  AliHLTUInt32_t fSize; // Size of the track with tracklets and clusters in the memory
-  AliTRDtrackV1* fTRDtrack;
-  
-  /* ======== From AliTRDtrackV1 ======== */
-    enum { kNdet      = 540
-        , kNstacks   =  90
-        , kNplane    =   AliESDtrack::kTRDnPlanes
-        , kNcham     =   5
-        , kNsect     =  18
-        , kNslice    =   3
-        , kNMLPslice =   8 };
-
   /* Defenitely need */
-  UChar_t      fPIDquality;           //  No of planes used for PID calculation        
-  AliHLTTRDTracklet *fTracklet[kNplane];   //  Tracklets array defining the track
+  //UChar_t      fPIDquality;         //  No of planes used for PID calculation        
   
   /* Probably need */
-  Double32_t   fPID[AliPID::kSPECIES];//  PID probabilities
-  Double32_t   fBudget[3];            //  Integrated material budget
-  Double32_t   fDE;                   //  Integrated delta energy
+  Float_t      fPID[AliPID::kSPECIES];//  PID probabilities
+  Float_t      fBudget[3];            //  Integrated material budget
+  Float_t      fDE;                   //  Integrated delta energy
 
   /* ======== From AliKalmanTrack ======== */
   
   /* Defenitely need */
-  Double32_t fFakeRatio;  // fake ratio
-  Double32_t fChi2;       // total chi2 value for this track
-  Double32_t fMass;       // mass hypothesis
-  Int_t fLab;             // track label
+  Float_t      fFakeRatio;            // fake ratio
+  Float_t      fChi2;                 // total chi2 value for this track
+  //Float_t      fMass;                 // mass hypothesis
+  //Int_t        fLab;                  // track label
 
   /* Probably need */
-  Int_t fN;               // number of associated clusters
-  Double32_t fIntegratedLength;        // integrated length  // variables for time integration (S.Radomski@gsi.de)
+  Int_t        fN;                    // number of associated clusters
+  Float_t      fIntegratedLength;     // integrated length  // variables for time integration (S.Radomski@gsi.de)
 
   /* ======= From AliExternalTrackParam ======== */
 
   /* Defenitely need */
-  Double32_t           fX;     // X coordinate for the point of parametrisation
-  Double32_t           fAlpha; // Local <-->global coor.system rotation angle
-  Double32_t           fP[5];  // The track parameters
-  Double32_t           fC[15]; // The track parameter covariance matrix
+  Float_t      fX;                    // X coordinate for the point of parametrisation
+  Float_t      fAlpha;                // Local <-->global coor.system rotation angle
+  Float_t      fP[5];                 // The track parameters
+  Float_t      fC[15];                // The track parameter covariance matrix
+
+  /* Not need */
+  //  static Float_t    fgMostProbablePt; // "Most probable" pt (to be used if Bz=0)
+
+  AliHLTUInt32_t fSize;               // Size of the track with tracklets and clusters in the memory
+  Bool_t       fTrackletAtPlane[AliTRDtrackV1::kNplane];   // Used positions in the original array of tracklets
 
-  /* Probably need */
-  //  static Double32_t    fgMostProbablePt; // "Most probable" pt (to be used if Bz=0)
 
 };
 
index c20dea5..1bae8e1 100644 (file)
@@ -75,7 +75,8 @@ AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
   fPIDmethod(1),
   fgeometryFileName(""),
   fieldStrength(-101),
-  fSlowTracking(kFALSE)
+  fSlowTracking(kFALSE),
+  fOutputV1Tracks(kTRUE)
 {
   // Default constructor
 
@@ -96,14 +97,23 @@ void AliHLTTRDTrackerV1Component::GetInputDataTypes( vector<AliHLTComponent_Data
 {
   // 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 );
+  list.push_back(AliHLTTRDDefinitions::fgkClusterDataType);
 }
 
-AliHLTComponent_DataType AliHLTTRDTrackerV1Component::GetOutputDataType()
+AliHLTComponentDataType AliHLTTRDTrackerV1Component::GetOutputDataType()
 {
   // Get the output data type
-  //return AliHLTTRDDefinitions::fgkClusterDataType;
-  return  kAliHLTDataTypeTrack | kAliHLTDataOriginTRD;
+  return kAliHLTMultipleDataType;
+}
+
+int AliHLTTRDTrackerV1Component::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
+{
+  // Get the output data types
+  tgtList.clear();
+  //tgtList.push_back(AliHLTTRDDefinitions::fgkTimeBinPropagationDataType);
+  tgtList.push_back(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD);
+  tgtList.push_back(AliHLTTRDDefinitions::fgkTRDSATracksDataType);
+  return tgtList.size();
 }
 
 void AliHLTTRDTrackerV1Component::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
@@ -162,18 +172,19 @@ int AliHLTTRDTrackerV1Component::DoDeinit()
 
   fTracker->SetClustersOwner(kFALSE);
   delete fTracker;
-  fTracker = 0x0;
+  fTracker = NULL;
 
   fClusterArray->Delete();
   delete fClusterArray;
+  fClusterArray = NULL;
   
   // We need to set clusters in Reconstructor to null to prevent from 
-  // double deleting, since we delete TClonesArray by ourself in DoEvent.
+  // double deleting, since we delete TClonesArray by ourself.
   fReconstructor->SetClusters(0x0);
   delete fReconstructor;
-  fReconstructor = 0x0;
+  fReconstructor = NULL;
   delete fESD;
-  fESD=NULL;
+  fESD = NULL;
   
   AliTRDcalibDB::Terminate();
 
@@ -198,7 +209,6 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
   //fESD->SetMagneticField(fSolenoidBz);
 
   AliHLTUInt32_t totalSize = 0, offset = 0;
-  AliHLTUInt32_t dBlockSpecification = 0;
 
   vector<AliHLTComponent_DataType> expectedDataTypes;
   GetInputDataTypes(expectedDataTypes);
@@ -227,7 +237,7 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
                 DataType2Text(inputDataType).c_str(),
                 block.fSize);
       }
-      
+
 #ifndef NDEBUG
       unsigned long constBase;
       double inputMultiplier;
@@ -237,7 +247,10 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
       }
 #endif      
 
-      AliHLTTRDUtils::ReadClusters(fClusterArray, block.fPtr, block.fSize);
+      AliHLTTRDUtils::ReadClusters(fClusterArray, block.fPtr, block.fSize, &fNtimeBins);
+      HLTDebug("Reading number of time bins from input block. Changing number of timebins to %d", fNtimeBins);
+      AliTRDtrackerV1::SetNTimeBins(fNtimeBins);
+
       HLTDebug("TClonesArray of clusters: nbEntries = %i", fClusterArray->GetEntriesFast());
       fTracker->LoadClusters(fClusterArray);
 
@@ -246,8 +259,8 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
       Int_t nTracks = fESD->GetNumberOfTracks();
       HLTInfo("Number of tracks  == %d ==", nTracks);  
 
-      TClonesArray* trdTracks = 0x0;
-      //trdTracks = fTracker->GetListOfTracks();
+      TClonesArray* trdTracks;
+      trdTracks = fTracker->GetListOfTracks();
       
       if(nTracks>0){
        HLTDebug("We have an output ESDEvent: 0x%x with %i tracks", fESD, nTracks);
@@ -263,15 +276,13 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
        bd.fSpecification = block.fSpecification;
        bd.fDataType = kAliHLTDataTypeTrack | kAliHLTDataOriginTRD;
        outputBlocks.push_back( bd );
-       HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
+       HLTDebug("BD ptr 0x%x, offset %i, size %i, datav1Type %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), bd.fSpecification);
        offset = totalSize;
 
-       if (trdTracks){
-         //Int_t nbTracks=trdTracks->GetEntriesFast();
-         //if (nbTracks>0){
+       if (fOutputV1Tracks && trdTracks){
          HLTDebug("We have an output array: pointer to trdTracks = 0x%x, nbEntries = %i", trdTracks, trdTracks->GetEntriesFast());
          
-         addedSize = AliHLTTRDUtils::AddTracksToOutput(trdTracks, outputPtr+offset);
+         addedSize = AliHLTTRDUtils::AddTracksToOutput(trdTracks, outputPtr+offset, fNtimeBins);
          totalSize += addedSize;
          
          // Fill block 
@@ -282,7 +293,7 @@ int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtDat
          bd.fSpecification = block.fSpecification;
          bd.fDataType = AliHLTTRDDefinitions::fgkTRDSATracksDataType;
          outputBlocks.push_back( bd );
-         HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
+         HLTDebug("BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), bd.fSpecification);
          offset = totalSize;
        }
       }
@@ -346,36 +357,54 @@ int AliHLTTRDTrackerV1Component::Configure(const char* arguments){
        fgeometryFileName=((TObjString*)pTokens->At(i))->GetString();
        continue;
       } 
-      if (argument.CompareTo("-lowflux")==0) {
+      else if (argument.CompareTo("-lowflux")==0) {
        fRecoParamType = 0;
        HLTInfo("Low flux reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-highflux")==0) {
+      else if (argument.CompareTo("-highflux")==0) {
        fRecoParamType = 1;
        HLTInfo("High flux reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-cosmics")==0) {
+      else if (argument.CompareTo("-cosmics")==0) {
        fRecoParamType = 2;
        HLTInfo("Cosmics reconstruction selected");
        continue;
       }
-      if (argument.CompareTo("-magnetic_field_ON")==0) {
+      else if (argument.CompareTo("-magnetic_field_ON")==0) {
        fMagneticField = 1;
        HLTInfo("Reconstructon with magnetic field");
        continue;
       }
-      if (argument.CompareTo("-magnetic_field_OFF")==0) {
+      else if (argument.CompareTo("-magnetic_field_OFF")==0) {
        fMagneticField = 0;
        HLTInfo("Reconstructon without magnetic field");
        continue;
       }
-      if (argument.CompareTo("-slowTracking")==0) {
+      else if (argument.CompareTo("-slowTracking")==0) {
        fSlowTracking = kTRUE;
        HLTInfo("Using slow tracking");
        continue;
       }
+      else if (argument.CompareTo("-outputV1Tracks")==0) {
+       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
+       if (toCompareTo.CompareTo("yes")==0){
+         HLTInfo("Setting OutputV1Tracks to: %s", toCompareTo.Data());
+         fOutputV1Tracks=kTRUE;
+       }
+       else if (toCompareTo.CompareTo("no")==0){
+         HLTInfo("Setting OutputV1Tracks to: %s", toCompareTo.Data());
+         fOutputV1Tracks=kFALSE;
+       }
+       else {
+         HLTError("unknown argument for OutputV1Tracks: %s", toCompareTo.Data());
+         iResult=-EINVAL;
+         break;
+       }
+       continue;
+      } 
       else if (argument.CompareTo("-PIDmethod")==0) {
        if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
        TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
index afcd076..8752d41 100644 (file)
@@ -41,8 +41,9 @@ public:
   // These functions are required for the registration process
 
   const char* GetComponentID();
-  void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-  AliHLTComponent_DataType GetOutputDataType();
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
+  int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
   AliHLTComponent* Spawn();
        
@@ -92,6 +93,7 @@ private:
   TString fgeometryFileName;
   Double_t fieldStrength;
   Bool_t fSlowTracking;
+  Bool_t fOutputV1Tracks;
 
   ClassDef(AliHLTTRDTrackerV1Component, 3)
 
index 7a25469..60dcae9 100644 (file)
 #include "AliHLTTRDTracklet.h"
-#include "AliHLTTRDCluster.h"
-
 /**
  * Default Constructor
  */
 //============================================================================
 AliHLTTRDTracklet::AliHLTTRDTracklet():
-  fTRDtracklet(NULL),
-  fSize(sizeof(AliHLTTRDTracklet)),
-  //fSigmaY(-1),
-  fSigmaY2(-1),
-  fTilt(-1),
-  fPadLength(-1),
-  fX0(-1),
-  //fMeanz(-1),
-  //fZProb(-1),
-  //fN(-1),
-  fN2(-1),
-  fNUsed(-1),
-  //fFreq(-1),
-  //fNChange(-1),
-  //fMPads(-1),
-  fC(-1),
-  //fCC(-1),
-  fChi2(-1),
-  //fChi2Z(-1),
+  fN(0),
   fDet(-1),
+  fdX(-1),
+  fS2Y(-1),
   fPt(-1),
-  fdX(-1)
-{
-  InitArrays();
-}
-
-/**
- * Main Constructor
- */
-//============================================================================
-AliHLTTRDTracklet::AliHLTTRDTracklet(AliTRDseedV1 * inTracklet):
-  fTRDtracklet(NULL),
-  fSize(sizeof(AliHLTTRDTracklet)),
-  //fSigmaY(-1),
-  fSigmaY2(-1),
-  fTilt(-1),
-  fPadLength(-1),
+  fPad3(-1),
+  fPad2(-1),
   fX0(-1),
-  //fMeanz(-1),
-  //fZProb(-1),
-  //fN(-1),
-  fN2(-1),
-  fNUsed(-1),
-  //fFreq(-1),
-  //fNChange(-1),
-  //fMPads(-1),
   fC(-1),
-  //fCC(-1),
   fChi2(-1),
-  //fChi2Z(-1),
-  fDet(-1),
-  fPt(-1),
-  fdX(-1)
+#if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
+  fSize(sizeof(AliHLTTRDTracklet)-sizeof(IndexAndCluster)),
+#else
+  fSize(sizeof(AliHLTTRDTracklet)),
+#endif
+  fCount(0)
 {
   InitArrays();
-  fTRDtracklet = inTracklet;
-  CopyDataMembers();
-  //  Print(kFALSE);
-  AddClusters();
 }
 
 /**
- * Add clusters to the HLTTRDTracklet
+ * Main Constructor
  */
 //============================================================================
-void AliHLTTRDTracklet::AddClusters()
+AliHLTTRDTracklet::AliHLTTRDTracklet(const AliTRDseedV1* const inTracklet):
+  fN(inTracklet->fN),
+  fDet(inTracklet->fDet),
+  fdX(inTracklet->fdX),
+  fS2Y(inTracklet->fS2Y),
+  fPt(inTracklet->fPt),
+  fPad3(inTracklet->fPad[3]),
+  fPad2(inTracklet->fPad[2]),
+  fX0(inTracklet->fX0),
+  fC(inTracklet->fC),
+  fChi2(inTracklet->fChi2),
+#if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
+  fSize(sizeof(AliHLTTRDTracklet)-sizeof(IndexAndCluster)),
+#else
+  fSize(sizeof(AliHLTTRDTracklet)),
+#endif
+  fCount(0)
 {
-  for (Int_t iTimeBin = 0; iTimeBin < AliTRDseedV1::kNclusters; iTimeBin++)
-    {
-//       if (fClusters[iTimeBin])
-//     HLTWarning("Trying to rewrite cluster in tracklet. Not good.");
-      AliTRDcluster* trdCluster = fTRDtracklet->GetClusters(iTimeBin);
-      if (trdCluster){
-       AliHLTTRDCluster * hltCluster = new (GetEndPointer()) AliHLTTRDCluster(trdCluster);
-       fSize += hltCluster->GetSize();
-       //HLTInfo("cluster %i; adr 0x%x; endPointer 0x%x; fSize %i", iTimeBin, hltCluster, GetEndPointer(), fSize);
-       fClusters[iTimeBin] = hltCluster;
-      }
-      else 
-       fClusters[iTimeBin] = NULL;
-      
-    }
+  CopyDataMembers(inTracklet);
 }
 
 /**
  * Copy simple (non-pointer) data members from TRDTracklet to HLTTRDTracklet 
  */
 //============================================================================  
-void AliHLTTRDTracklet::CopyDataMembers()
+void AliHLTTRDTracklet::CopyDataMembers(const AliTRDseedV1* const inTracklet)
 {
+  //fChi2Z = inTracklet->GetChi2Z();
+
   for (Int_t i=0; i < 2; i++){
-    fYref[i] = fTRDtracklet->GetYref(i);
-    fZref[i] = fTRDtracklet->GetZref(i);
+    fYref[i]   = inTracklet->fYref[i];
+    fZref[i]   = inTracklet->fZref[i];
+    fYfit[i]   = inTracklet->fYfit[i];
+    fZfit[i]   = inTracklet->fZfit[i];
   }
-  //fSigmaY = fTRDtracklet->GetSigmaY();
-  fSigmaY2 = fTRDtracklet->GetS2Y();
-  fTilt = fTRDtracklet->GetTilt();
-  fPadLength = fTRDtracklet->GetPadLength();
   
-  fX0 = fTRDtracklet->GetX0();
-  for (Int_t i = 0; i < AliTRDseedV1::kNclusters; i++){
-//     fX[i] = fTRDtracklet->GetX(i);
-//     fY[i] = fTRDtracklet->GetY(i);
-//     fZ[i] = fTRDtracklet->GetZ(i);
-    fIndexes[i] = fTRDtracklet->GetIndexes(i);
+  for (Int_t i=0; i < AliPID::kSPECIES; i++){
+    fProb[i] = inTracklet->fProb[i];
   }
 
-  for (Int_t i=0; i < 2; i++){
-    fYfit[i] = fTRDtracklet->GetYfit(i);
-    fZfit[i] = fTRDtracklet->GetZfit(i);
-    fLabels[i] = fTRDtracklet->GetLabels(i);
-  }
-  fLabels[2] = fTRDtracklet->GetLabels(2);
-  fN2      = fTRDtracklet->GetN2();
-  fNUsed   = fTRDtracklet->GetNUsed();
-   
-  fC = fTRDtracklet->GetC();
-  fChi2 = fTRDtracklet->GetChi2();
-  //fChi2Z = fTRDtracklet->GetChi2Z();
+  for (Int_t iTimeBin = 0; iTimeBin < AliTRDseedV1::kNclusters; iTimeBin++)
+    {
+      AliTRDcluster* trdCluster = inTracklet->GetClusters(iTimeBin);
+      if (trdCluster){
+       fClusters[fCount].Index = inTracklet->fIndexes[iTimeBin];
+       new (&fClusters[fCount].Cluster) AliHLTTRDCluster(trdCluster);
+       fCount++;
+       fSize += sizeof(IndexAndCluster);
+      }
+    }
   
-  fDet = fTRDtracklet->GetDetector();
-  fPt  = fTRDtracklet->GetPt();
-  fdX = fTRDtracklet->GetdX();
+  //if((void*)&fClusters[fCount].Index!=(void*)GetEndPointer()){printf("ERRR");return;}
 }
 
 /**
  * Copy data to the output TRDseedV1
  */
 //============================================================================
-void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1 *outTracklet)
+void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1* const outTracklet) const
 {
-  outTracklet->Reset();
-  /* ======= From AliTRDseedV1 ======== */
-  outTracklet->SetDetector(fDet);
-  outTracklet->SetPt(fPt);
-  outTracklet->SetDX(fdX);
-  
-  /* ======= From AliTRDseed ======== */
+  //outTracklet->Reset(); we always use a fresh trdtracklet as input, so this is useless
+
+  outTracklet->fN      = fN;
+  outTracklet->fDet    = fDet;
+  outTracklet->fPad[3] = fPad3;
+  outTracklet->fPad[2] = fPad2;
+  outTracklet->fdX     = fdX;
+  outTracklet->fX0     = fX0;
+  outTracklet->fS2Y    = fS2Y;
+  outTracklet->fPt     = fPt;
+  outTracklet->fC      = fC;
+  outTracklet->fChi2   = fChi2;
+
   for (Int_t i=0; i < 2; i++){
-    outTracklet->SetYref(i, fYref[i]);
-    outTracklet->SetZref(i, fZref[i]);
+    outTracklet->fYref[i]   = fYref[i];
+    outTracklet->fZref[i]   = fZref[i];
+    outTracklet->fYfit[i]   = fYfit[i];
+    outTracklet->fZfit[i]   = fZfit[i];
   }
-  
-  //outTracklet->SetSigmaY(fSigmaY);
-  //outTracklet->SetSigmaY2(fSigmaY2);
-  outTracklet->SetTilt(fTilt);
-  outTracklet->SetPadLength(fPadLength);
-  outTracklet->SetX0(fX0);
 
-  for (Int_t i=0; i < AliTRDseedV1::kNclusters; i++){
-//     outTracklet->SetX(i,fX[i]);
-//     outTracklet->SetX(i,fY[i]);
-//     outTracklet->SetX(i,fZ[i]);
-    outTracklet->SetIndexes(i, fIndexes[i]);
+  for (Int_t i=0; i < AliPID::kSPECIES; i++){
+    outTracklet->fProb[i] = fProb[i];
   }
 
-//   for (Int_t i=0; i < 2; i++){
-//     outTracklet->SetYfit(i,fYfit[i]);
-//     outTracklet->SetZfit(i,fZfit[i]);
-//   }
-  outTracklet->SetLabels(fLabels);
-  
-  //outTracklet->SetN2(fN2);
-  //outTracklet->SetNUsed(fNUsed);
-  outTracklet->SetC(fC);
-  outTracklet->SetChi2(fChi2);
-
-  for (Int_t iCluster = 0; iCluster < AliTRDseedV1::kNclusters; iCluster++){
-    if (fClusters[iCluster]){
-      AliTRDcluster *trdCluster = new AliTRDcluster();
-      fClusters[iCluster]->ExportTRDCluster(trdCluster);
-      //outTracklet->SetClusters(iCluster, trdCluster);
-    }
+  for (UInt_t iCluster=0; iCluster < fCount; iCluster++){
+    AliTRDcluster *trdCluster = new AliTRDcluster();
+    fClusters[iCluster].Cluster.ExportTRDCluster(trdCluster);
+    outTracklet->fClusters[iCluster] = trdCluster;
+    outTracklet->fIndexes[iCluster] = fClusters[iCluster].Index;
+    iCluster++;
   }
 }
 
@@ -190,45 +128,30 @@ void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1 *outTracklet)
 //============================================================================
 void AliHLTTRDTracklet::InitArrays()
 {
-  for (Int_t i=0; i < AliTRDseedV1::kNclusters; i++){
-    fClusters[i] = NULL;
-  }
-
   for (Int_t i=0; i < 2; i++){
     fYref[i] = -1;
     fZref[i] = -1;
-  }
-  for (Int_t i = 0; i < AliTRDseedV1::kNclusters; i++){
-//     fX[i] = -1;
-//     fY[i] = -1;
-//     fZ[i] = -1;
-    fIndexes[i] = -1;
-  }
-
-  for (Int_t i=0; i < 2; i++){
     fYfit[i] = -1;
     fZfit[i] = -1;
-//     fYfitR[i] = -1;
-//     fZfitR[i] = -1;
-    fLabels[i] = -1;
   }
-  fLabels[2] = 0;
+  for (Int_t i=0; i < AliPID::kSPECIES; i++)
+    fProb[i]=0;
 }
 
 /**
  * Prints main info about tracklet
  */
 //============================================================================
-void AliHLTTRDTracklet::Print(Bool_t printClusters)
+void AliHLTTRDTracklet::Print(Bool_t printClusters) const
 {
   //printf("--hltTracklet-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
-  printf("      fDet %i; fPt %f; fdX %f fN %i\n", fDet, fPt, fdX, fN2);
+  printf("      fDet %i; fPt %f; fdX %f fN %i\n", fDet, fPt, fdX, fN);
 
   if(!printClusters) return;
-  for (Int_t iCluster = 0; iCluster < AliTRDseedV1::kNclusters; iCluster++){
-    printf(" [%i] ",iCluster);
-    if (fClusters[iCluster]) fClusters[iCluster]->Print();
-    else printf("      NULL\n");
+  for (UInt_t iCount=0, iCluster = 0; iCluster < fCount; iCount++){
+    printf(" [%i] ",iCount);
+    fClusters[iCluster].Cluster.Print();
+    iCluster++;
   }
 }
 
@@ -236,20 +159,20 @@ void AliHLTTRDTracklet::Print(Bool_t printClusters)
  * Read clusters to TRDtracklet from the memory
  */
 //============================================================================
-void AliHLTTRDTracklet::ReadClustersFromMemory(void *input)
-{
-  AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*) input;
-  AliHLTTRDCluster* hltCluster = NULL;
+// void AliHLTTRDTracklet::ReadClustersFromMemory(void *input)
+// {
+//   AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*) input;
+//   AliHLTTRDCluster* hltCluster = NULL;
   
-  for (Int_t iCluster = 0; iCluster < AliTRDseedV1::kNclusters; iCluster++){
-    // if we had something in the fClusters[iCluster] before copying,
-    // then this entry in the array should not be empty. Fill it.
-    if (fClusters[iCluster]){
-      hltCluster = (AliHLTTRDCluster*) iterPtr;
-      fClusters[iCluster] = hltCluster;
-      iterPtr += hltCluster->GetSize();
-      //hltCluster->Print();
-    }
+//   for (Int_t iCluster = 0; iCluster < AliTRDseedV1::kNclusters; iCluster++){
+//     // if we had something in the fClusters[iCluster] before copying,
+//     // then this entry in the array should not be empty. Fill it.
+//     if (fClusters[iCluster]){
+//       hltCluster = (AliHLTTRDCluster*) iterPtr;
+//       fClusters[iCluster] = hltCluster;
+//       iterPtr += hltCluster->GetSize();
+//       //hltCluster->Print();
+//     }
     
-  }
-}
+//   }
+// }
index b19bdc8..5c84615 100644 (file)
@@ -1,76 +1,84 @@
+//-*- Mode: C++ -*-
+// $Id$
+
 #ifndef ALIHLTTRDTRACKLET_H
 #define ALIHLTTRDTRACKLET_H
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 #include "AliTRDseedV1.h"
 #include "AliHLTDataTypes.h"
 #include "AliHLTLogging.h"
-class AliHLTTRDCluster;
+#include "AliHLTTRDCluster.h"
 
 class AliHLTTRDTracklet
 {
  public:
   AliHLTTRDTracklet();
-  AliHLTTRDTracklet(AliTRDseedV1* inTracklet);
+  AliHLTTRDTracklet(const AliTRDseedV1* const inTracklet);
   
-  void ExportTRDTracklet(AliTRDseedV1* outTracklet);
-  void AddClusters();
-  void CopyDataMembers();
-  AliHLTUInt8_t *GetEndPointer() // Returns pointer to the end of the tracklet
-    { return ((AliHLTUInt8_t *) this + fSize); };
-  AliHLTUInt32_t GetSize(){ return fSize; };
-  void Print(Bool_t printClusters = kTRUE);
-  void ReadClustersFromMemory(void *input);
+  void CopyDataMembers(const AliTRDseedV1* const inTracklet);
+  void ExportTRDTracklet(AliTRDseedV1* const outTracklet) const;
+  AliHLTUInt8_t *GetEndPointer() const // Returns pointer to the end of the tracklet
+    { return ((AliHLTUInt8_t *)this + fSize); };
+  AliHLTUInt32_t GetSize() const { return fSize; };
+  void Print(Bool_t printClusters = kTRUE) const;
+  // void ReadClustersFromMemory(void *input);
   
  private:
   AliHLTTRDTracklet(const AliHLTTRDTracklet&);
   AliHLTTRDTracklet& operator=(const AliHLTTRDTracklet&);
   void InitArrays();
-  
-  AliTRDseedV1* fTRDtracklet;
-  AliHLTUInt32_t fSize; // Size of the tracklet with clusters in the memory
-  
-  /* Defenitely need */
-  AliHLTTRDCluster *fClusters[AliTRDseedV1::kNclusters]; // Clusters
-  Float_t        fYref[2];              //  Reference y
-  Float_t        fZref[2];              //  Reference z
-  //Float_t        fSigmaY;               //  "Robust" sigma in Y - constant fit
-  Float_t        fSigmaY2;              //  "Robust" sigma in Y - line fit
 
+  /* Defenitely need */
+  UShort_t       fN;                     // number of clusters attached/used/shared
+  Short_t        fDet;                   //  TRD detector
+  Float_t        fdX;                    // length of time bin
+  Float_t        fYref[2];               //  Reference y
+  Float_t        fZref[2];               //  Reference z
+  Float_t        fS2Y;                   //  "Robust" sigma in Y - line fit
+  Float_t        fPt;                    //  Momentum estimate for tracklet [GeV/c]
   /* Probably need */
-  Float_t        fTilt;                 //  Tilting angle
-  Float_t        fPadLength;            //  Pad length
-  Float_t        fX0;                   //  X0 position
-//  Float_t        fX[knTimebins];        //! X position
-//  Float_t        fY[knTimebins];        //! Y position
-//  Float_t        fZ[knTimebins];        //! Z position
-  Int_t          fIndexes[AliTRDseedV1::kNclusters];  //! Indexes
-  Float_t        fYfit[2];              //  Y fit position +derivation
+  Float_t        fPad3;                  //  Tilting angle
+  Float_t        fPad2;                  //  Pad length
+  Float_t        fX0;                    //  X0 position
+  Float_t        fYfit[2];               //  Y fit position +derivation
+  Float_t        fZfit[2];               //  Z fit position
+  Float_t        fC;                     //  Curvature
+  Float_t        fChi2;                  //  Global chi2
+  Float_t        fProb[AliPID::kSPECIES];// PID probabilities
+
+  /* Not needed */
+  //Int_t          fLabels[3];            //  Labels
+  //Float_t        fX[knTimebins];        //! X position
+  //Float_t        fY[knTimebins];        //! Y position
+  //Float_t        fZ[knTimebins];        //! Z position
   //Float_t        fYfitR[2];             //  Y fit position +derivation
-  Float_t        fZfit[2];              //  Z fit position
   //Float_t        fZfitR[2];             //  Z fit position
   //Float_t        fMeanz;                //  Mean vaue of z
   //Float_t        fZProb;                //  Max probbable z
-  Int_t          fLabels[3];            //  Labels
-  //Int_t          fN;                    //  Number of associated clusters
-  Int_t          fN2;                   //  Number of not crossed
-  Int_t          fNUsed;                //  Number of used clusters
   //Int_t          fFreq;                 //  Frequency
   //Int_t          fNChange;              //  Change z counter
   //Float_t        fMPads;                //  Mean number of pads per cluster
 
-  Float_t        fC;                    //  Curvature
   //Float_t        fCC;                   //  Curvature with constrain
-  Float_t        fChi2;                 //  Global chi2
   //Float_t        fChi2Z;                //  Global chi2
 
-  /* ======= From AliTRDseedV1 ======== */
-
-  /* Defenitely need */
-  Int_t            fDet;                    //  TRD detector
-  Float_t          fPt;                     //  Momentum estimate for  tracklet [GeV/c]
-  Float_t          fdX;                     // length of time bin
+  AliHLTUInt32_t fSize;                   // Size of the tracklet with clusters in the memory
+  AliHLTUInt32_t fCount;                  // Number of clusters saved in the open array
 
-  /* Probably need */
+  struct IndexAndCluster{
+    Int_t            Index;
+    AliHLTTRDCluster Cluster;
+    IndexAndCluster():Index(-1),Cluster() {}
+  }
+#if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
+    fClusters[1];                         // Open array of clusters and their index
+#else
+    fClusters[0];                         // Open array of clusters and their index
+#endif
 
 };
 
index 7a2a71c..112f0a6 100644 (file)
@@ -4,7 +4,7 @@
 //* See cxx source for full Copyright notice                               *
 
 #ifndef _ALIHLTTRDTRACKLETWORDARRAY_H_
-#define _ALITHLTTRDTRACKLETWORDARRAY_H_
+#define _ALIHLTTRDTRACKLETWORDARRAY_H_
 
 #include "AliHLTDataTypes.h"
 #include "AliHLTStdIncludes.h"
index 7b120f0..0ed7465 100644 (file)
@@ -1,4 +1,4 @@
-// $Id:$
+// $Id$
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
 
 ClassImp(AliHLTTRDUtils)
 
-AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr)
+AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins)
 {
   AliTRDcluster* cluster = 0;
   AliHLTUInt32_t addedSize = 0;
   //  == OUTdatatype pointer
-  AliHLTTRDCluster * outPtr = (AliHLTTRDCluster*)outBlockPtr;
+  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));
+      cluster = (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;
+      addedSize += sizeof(*hltCluster);
+      outBlockPtr += sizeof(*hltCluster);
       outPtr = (AliHLTTRDCluster*)outBlockPtr;
     }
   }
+
+  Int_t *TBptr = (Int_t*)outPtr;
+  *TBptr = nTimeBins;
+  
+  addedSize += sizeof(*TBptr);
+  outBlockPtr += sizeof(*TBptr);
+
   return addedSize;
   
 }
 
-AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
+AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins)
 {
   //cout << "\nWriting tracks to the Memory\n ============= \n";
+
+  Int_t *TBptr = (Int_t*)output;
+  *TBptr = nTimeBins;
+
   AliTRDtrackV1* track = 0;
-  AliHLTUInt32_t addedSize = 0;
-  AliHLTUInt8_t *iterPtr = output;
-  AliHLTTRDTrack * outPtr = (AliHLTTRDTrack*)iterPtr;
-  
+  AliHLTUInt32_t addedSize = sizeof(*TBptr);
+  AliHLTUInt8_t* iterPtr = output+addedSize;
+  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 = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
       //track->Print();
       
       AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
@@ -93,13 +101,19 @@ AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, Ali
  * Read cluster to the TClonesArray from the memory 
  */
 //============================================================================
-AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
 {
   //HLTDebug("\nReading clusters from the Memory\n ============= \n");
   AliHLTTRDCluster * curCluster;
   UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
   Int_t i=0;
-  
+
+  if(nTimeBins){
+    *nTimeBins=*(Int_t*)(((AliHLTUInt8_t*)inputPtr)+size-sizeof(Int_t));
+    //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
+  }
+  size-=sizeof(*nTimeBins);
+
   curCluster = (AliHLTTRDCluster*) inputPtr;
   while (curSize + clusterSize <= size)
     {
@@ -118,14 +132,19 @@ AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputP
   return i;
 }
 
-AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
 {
-  AliHLTUInt8_t* iterPtr = (AliHLTUInt8_t* )inputPtr;
+  if(nTimeBins){
+    *nTimeBins=*(Int_t*)inputPtr;
+    //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
+  }
+
+  AliHLTUInt8_t* iterPtr = ((AliHLTUInt8_t*)inputPtr)+sizeof(*nTimeBins);
   
   //cout << "\nReading tracks from the Memory\n ============= \n";
   //HLTDebug ("\nReading tracks from the Memory\n ============= \n");
   AliHLTTRDTrack * hltTrack;
-  AliHLTUInt32_t trackSize = 0, curSize = 0;
+  AliHLTUInt32_t trackSize = 0, curSize = sizeof(*nTimeBins);
   Int_t counter=0;
   
   while (curSize < size)
@@ -136,7 +155,7 @@ AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr
       trackSize = hltTrack->GetSize();
       //HLTDebug("GetSize() %i", trackSize);
 
-      hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
+      // hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
 
       AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
       hltTrack->ExportTRDTrack(curTRDTrack);
index 59f4e35..f00bf61 100644 (file)
@@ -1,8 +1,9 @@
 // $Id$
 #ifndef ALIHLTTRDUTILS_H
 #define ALIHLTTRDUTILS_H
-/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 ////////////////////////////////////////////////////////////////////////////
 //                                                                        //
@@ -21,10 +22,10 @@ class AliHLTTRDUtils
 {
 public:
   virtual ~AliHLTTRDUtils(){}
-  static AliHLTUInt32_t AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr);
-  static AliHLTUInt32_t AddTracksToOutput(TClonesArray* inTrackArray,AliHLTUInt8_t* output);
-  static AliHLTUInt32_t ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
-  static AliHLTUInt32_t ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size);
+  static AliHLTUInt32_t AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins=24);
+  static AliHLTUInt32_t AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins=24);
+  static AliHLTUInt32_t ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins=0x0);
+  static AliHLTUInt32_t ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins=0x0);
   static AliHLTUInt32_t AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr);
 
   ClassDef(AliHLTTRDUtils, 0)