- bug fixes in the handling of digits

- small changes in CALO

diff --git a/HLT/CALO/AliHLTCaloClusterizer.h b/HLT/CALO/AliHLTCaloClusterizer.h
index 8118edb2866d1be7adac1a277ab3638272e1092e..92dfb1af91de04949d8ce66081f1fc486d7f22c9 100644 (file)
--- a/HLT/CALO/AliHLTCaloClusterizer.h
+++ b/HLT/CALO/AliHLTCaloClusterizer.h
@@ -71,7 +71,7 @@ public:
   \r
   /** Constructor */\r
   AliHLTCaloClusterizer(TString det);    \r
-  \r
+\r
   /** Destructor */\r
   virtual ~AliHLTCaloClusterizer();\r
 \r
@@ -97,7 +97,7 @@ public:
     //Assignment\r
     return *this; \r
   }\r
-  \r
+\r
   /** Set digit container */\r
   void SetDigitContainer(AliHLTCaloDigitContainerDataStruct* digitContainerPtr)\r
   { fDigitContainerPtr = digitContainerPtr; }\r
@@ -164,9 +164,10 @@ protected:
   Int_t fMaxDigitIndexDiff;                                    //COMMENT\r
 \r
 private:\r
+\r
   AliHLTCaloClusterizer();\r
 \r
-  AliHLTCaloClusterizer (const AliHLTCaloClusterizer  & );\r
+  //  AliHLTCaloClusterizer (const AliHLTCaloClusterizer  & );\r
   //  AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &);\r
 \r
 \r

diff --git a/HLT/CALO/AliHLTCaloConstant.h b/HLT/CALO/AliHLTCaloConstant.h
index 2fcbff8d6e2871bd16af867f778bddebd4b6566d..2b30e088f9c359e73f93affb781b0c6c6cf35b45 100644 (file)
--- a/HLT/CALO/AliHLTCaloConstant.h
+++ b/HLT/CALO/AliHLTCaloConstant.h
@@ -1,5 +1,5 @@
 //-*- Mode: C++ -*-
-// $Id: AliHLTPHOSConstants.h 34622 2009-09-04 13:22:01Z odjuvsla $
+// $Id$
 
 /**************************************************************************
  * This file is property of and copyright by the Experimental Nuclear     *

diff --git a/HLT/CALO/AliHLTCaloConstantsHandler.h b/HLT/CALO/AliHLTCaloConstantsHandler.h
index e004da9aeef33dc9241a5d3abea1c759534ed278..8dd6bca075b0007f857684a11a2f2304163019ed 100644 (file)
--- a/HLT/CALO/AliHLTCaloConstantsHandler.h
+++ b/HLT/CALO/AliHLTCaloConstantsHandler.h
@@ -34,10 +34,10 @@ private:
   AliHLTCaloConstantsHandler();
 
   /** Keep the copy constructor private since it should not be used */
-  AliHLTCaloConstantsHandler(const AliHLTCaloConstantsHandler & );
+  //  AliHLTCaloConstantsHandler(const AliHLTCaloConstantsHandler & );
 
   /** Keep the assignement operator private since it should not be used */
-  AliHLTCaloConstantsHandler & operator = (const AliHLTCaloConstantsHandler &);
+    AliHLTCaloConstantsHandler & operator = (const AliHLTCaloConstantsHandler &);
 
 
   void Initialize(TString det);

diff --git a/HLT/CALO/AliHLTCaloDigitMaker.h b/HLT/CALO/AliHLTCaloDigitMaker.h
index 35a15090a29e36a4d899fa6f71f205fceddfbabc..d4c8f4befb3ace4c9f8a7a2c5cffb0fbe7d29536 100644 (file)
--- a/HLT/CALO/AliHLTCaloDigitMaker.h
+++ b/HLT/CALO/AliHLTCaloDigitMaker.h
@@ -184,7 +184,7 @@ private:
   /** Channel book keeping variable */\r
   AliHLTCaloDigitDataStruct ***fChannelBook;                     //! transient\r
 \r
-  AliHLTCaloDigitMaker (const AliHLTCaloDigitMaker  & );\r
+  //  AliHLTCaloDigitMaker (const AliHLTCaloDigitMaker  & );\r
   //  AliHLTCaloDigitMaker & operator = (const AliHLTCaloDigitMaker &);\r
 \r
   ClassDef(AliHLTCaloDigitMaker, 0); \r

diff --git a/HLT/CALO/AliHLTCaloMapper.h b/HLT/CALO/AliHLTCaloMapper.h
index efea6d28a385d05116801649f848221e68fd36c8..ab7c7864978b927823eb71ea08fbe699c7911861 100644 (file)
--- a/HLT/CALO/AliHLTCaloMapper.h
+++ b/HLT/CALO/AliHLTCaloMapper.h
@@ -35,7 +35,7 @@ class AliHLTCaloConstants;
 class AliHLTCaloMapper : public AliHLTLogging, public AliHLTCaloConstantsHandler
 {
 public:
-  AliHLTCaloMapper(TString det);
+  
   AliHLTCaloMapper(const unsigned long specification, TString det);
   virtual ~AliHLTCaloMapper();
   virtual void InitAltroMapping( const unsigned long specification ) = 0; 

diff --git a/HLT/CMake_libAliHLTCalo.txt b/HLT/CMake_libAliHLTCalo.txt
index b25b8c05f7440b62a54622fef583f2982a5a414c..9952322b4b5d159a7722c6715bd12f99e4904647 100644 (file)
--- a/HLT/CMake_libAliHLTCalo.txt
+++ b/HLT/CMake_libAliHLTCalo.txt
@@ -1,5 +1,5 @@
 # -*- mode: cmake -*-
-# $Id: CMake_libAliHLTCALO.txt 34927 2009-09-22 12:48:47Z richterm $
+# $Id$
 
 set(SRCS
 CALO/AliHLTCaloMapper.cxx

diff --git a/HLT/PHOS/AliHLTPHOSClusterAnalyser.cxx b/HLT/PHOS/AliHLTPHOSClusterAnalyser.cxx
index ded7ba136eb07475985ac10f9223ac7bbbf39be2..9c9adedca4a605844af77a944b83b5ecd471f2c2 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSClusterAnalyser.cxx
+++ b/HLT/PHOS/AliHLTPHOSClusterAnalyser.cxx
@@ -72,6 +72,7 @@ void
 AliHLTPHOSClusterAnalyser::SetRecPointDataPtr(AliHLTPHOSRecPointHeaderStruct *recPointDataPtr, AliHLTPHOSDigitHeaderStruct *digitHeaderPtr)
 { 
   fNRecPoints = recPointDataPtr->fNRecPoints;
+
   fRecPointDataPtr = reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(reinterpret_cast<Char_t*>(recPointDataPtr)+sizeof(AliHLTPHOSRecPointHeaderStruct)); 
   fDigitHeaderPtr = digitHeaderPtr;
 }
@@ -90,19 +91,20 @@ AliHLTPHOSClusterAnalyser::CalculateCenterOfGravity()
   //AliPHOSGeometry * phosgeom =  AliPHOSGeometry::GetInstance() ;
 
   AliHLTPHOSRecPointDataStruct *recPoint = fRecPointDataPtr;
-
-  //  UInt_t iDigit = 0;
-
+  UInt_t iDigit = 0;
+  if(!recPoint) return 0;
   for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++) 
     {
-      digit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fDigitHeaderPtr) + recPoint->fStartDigitOffset);
+      //      cout << "CA: start digit offset: " << recPoint->fStartDigitOffset << endl;
+      digit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(fDigitHeaderPtr) + recPoint->fStartDigitOffset);
+  //      cout << "CA: digit offset: " << digit->fMemOffsetNext << endl;
       AliHLTPHOSDigitReader reader;
-      reader.SetCurrentDigit(digit);
+      reader.SetNextDigit(digit);
       while(digit)
        {
          xi = digit->fX;
          zi = digit->fZ;
-         //  cout << "COG digits (x:z:E:time): " << xi << " : " << zi << " : " << digit->fEnergy << " : " << digit->fTime << endl;
+         //      cout << "COG digits (x:z:E:time): " << xi << " : " << zi << " : " << digit->fEnergy << " : " << digit->fTime << endl;
          if (recPoint->fAmp > 0 && digit->fEnergy > 0) 
            {
              Float_t w = TMath::Max( 0., fLogWeight + TMath::Log( digit->fEnergy / recPoint->fAmp ) ) ;
@@ -117,12 +119,15 @@ AliHLTPHOSClusterAnalyser::CalculateCenterOfGravity()
          recPoint->fX = x/wtot ;
          recPoint->fZ = z/wtot ;
        }
+
       else
        {
          recPoint->fAmp = 0;
        }
-      recPoint = reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(digit);
-    }
+     recPoint++;
+}
+
+
   return 0;
 }
 
@@ -171,7 +176,7 @@ AliHLTPHOSClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
   for(Int_t i = 0; i < fNRecPoints; i++) //TODO needs fix when we start unfolding (number of clusters not necessarily same as number of recpoints gotten from the clusterizer
     {
       digitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fDigitHeaderPtr) + recPointPtr->fStartDigitOffset);
-      reader.SetCurrentDigit(digitPtr);
+      reader.SetNextDigit(digitPtr);
   
       if(availableSize < (totSize + maxClusterSize)) 
        {
@@ -182,7 +187,7 @@ AliHLTPHOSClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
       caloClusterPtr->fGlobalPos[0] = globalPos[0];
       caloClusterPtr->fGlobalPos[1] = globalPos[1];
       caloClusterPtr->fGlobalPos[2] = globalPos[2];
-
+      cout << "Global position: " << globalPos[0] << ", " << globalPos[1] << ", " << globalPos[2] << endl;
       caloClusterPtr->fNCells = recPointPtr->fMultiplicity;
   
       cellIDPtr = &(caloClusterPtr->fCellsAbsId);
@@ -245,7 +250,8 @@ AliHLTPHOSClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
       totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));   
 
       caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
-      recPointPtr = reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(digitPtr);
+      //      recPointPtr = reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(digitPtr);
+      recPointPtr++; 
  
     }
 

diff --git a/HLT/PHOS/AliHLTPHOSClusterAnalyserComponent.cxx b/HLT/PHOS/AliHLTPHOSClusterAnalyserComponent.cxx
index 13f759cb37fa1b0c22b75c50fa3bc813025f3418..009305ee69948296795e699980932600c63759af 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSClusterAnalyserComponent.cxx
+++ b/HLT/PHOS/AliHLTPHOSClusterAnalyserComponent.cxx
@@ -154,7 +154,6 @@ AliHLTPHOSClusterAnalyserComponent::DoEvent(const AliHLTComponentEventData& evtD
         }
       specification = specification|iter->fSpecification;
       AliHLTPHOSDigitHeaderStruct *digitHeader = reinterpret_cast<AliHLTPHOSDigitHeaderStruct*>(iter->fPtr);
-      
       fClusterAnalyserPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTPHOSRecPointHeaderStruct*>(reinterpret_cast<Long_t>(iter->fPtr) + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeader->fNDigits*sizeof(AliHLTPHOSDigitDataStruct)), digitHeader);
       if(fDoDeconvolution)
        {
@@ -264,13 +263,15 @@ AliHLTPHOSClusterAnalyserComponent::DoInit(int argc, const char** argv )
 
   //See headerfile for documentation
   
+  HLTError("Doing init...");
+
   fClusterAnalyserPtr = new AliHLTPHOSClusterAnalyser();
 
   const char *path = "HLT/ConfigPHOS/ClusterAnalyserComponent";
 
   GetGeometryFromCDB();
 
-  ConfigureFromCDBTObjString(path);
+  //  ConfigureFromCDBTObjString(path);
 
   for (int i = 0; i < argc; i++)
     {
@@ -283,6 +284,9 @@ AliHLTPHOSClusterAnalyserComponent::DoInit(int argc, const char** argv )
 int 
 AliHLTPHOSClusterAnalyserComponent::GetGeometryFromCDB()
 {
+  HLTError("Getting geometry...");
+
+  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 
   AliCDBPath path("GRP","Geometry","Data");
   if(path.GetPath())
@@ -298,9 +302,12 @@ AliHLTPHOSClusterAnalyserComponent::GetGeometryFromCDB()
            }
 
          gGeoManager = (TGeoManager*) pEntry->GetObject();
-  
-         fPHOSGeometry = new AliPHOSGeoUtils("PHOS", "noCPV");
-         fClusterAnalyserPtr->SetGeometry(fPHOSGeometry);
+         HLTError("gGeoManager = 0x%x", gGeoManager);
+         if(gGeoManager)
+           {
+             fPHOSGeometry = new AliPHOSGeoUtils("PHOS", "noCPV");
+             fClusterAnalyserPtr->SetGeometry(fPHOSGeometry);
+           }
 
        }
       else

diff --git a/HLT/PHOS/AliHLTPHOSClusterizer.cxx b/HLT/PHOS/AliHLTPHOSClusterizer.cxx
index 360002f90bb3cbdfd032bba93423b12daa9bf147..51da8695341a6e887b274f7565c9402775ad6420 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSClusterizer.cxx
+++ b/HLT/PHOS/AliHLTPHOSClusterizer.cxx
@@ -99,10 +99,12 @@ AliHLTPHOSClusterizer::ClusterizeEvent(AliHLTPHOSDigitHeaderStruct *digitHeader,
 
   //  UInt_t maxRecPointSize = sizeof(AliHLTPHOSRecPointDataStruct) + (sizeof(AliHLTPHOSDigitDataStruct) << 7); //Reasonable estimate... 
 
+  //  HLTError("Starting clusterisation");
+
   //Clusterization starts
   while((fCurrentDigit = fDigitReader->NextDigit()) != 0)
     { 
-
+      //      HLTError("Digit with energy: %f", fCurrentDigit->fEnergy); 
       fDigitsInCluster = 0;
       
       if(fCurrentDigit->fEnergy < fEmcClusteringThreshold)
@@ -110,6 +112,8 @@ AliHLTPHOSClusterizer::ClusterizeEvent(AliHLTPHOSDigitHeaderStruct *digitHeader,
          continue;
        }
 
+      //      HLTError("Have cluster candidate (x,z): %d, %d, with energy: %f", fCurrentDigit->fX, fCurrentDigit->fZ, fCurrentDigit->fEnergy); 
+
       if(fAvailableSize < (sizeof(AliHLTPHOSRecPointDataStruct)))
        {
          HLTError("Out of buffer, stopping clusterisation");
@@ -121,6 +125,8 @@ AliHLTPHOSClusterizer::ClusterizeEvent(AliHLTPHOSDigitHeaderStruct *digitHeader,
       fPreviousDigit = fStartDigit;
       // Get the offset of the digit starting the cluster relative to the start of the digit block
       fRecPointDataPtr->fStartDigitOffset = fDigitReader->GetCurrentDigitOffset();
+      //      HLTError("Start digit offset: %d", fRecPointDataPtr->fStartDigitOffset);
+      //      cout << "Start digit offset: " <<  fRecPointDataPtr->fStartDigitOffset << endl;
       fDigitReader->DropDigit();
 
       fRecPointDataPtr->fAmp = 0;
@@ -132,24 +138,28 @@ AliHLTPHOSClusterizer::ClusterizeEvent(AliHLTPHOSDigitHeaderStruct *digitHeader,
       nRecPoints++;
 
       // Scanning for the neighbours
-      if(ScanForNeighbourDigits(fRecPointDataPtr) < 0)
+      if(ScanForNeighbourDigits(fRecPointDataPtr, fCurrentDigit) < 0)
        {
          return -1;
        }
 
+      fPreviousDigit->fMemOffsetNext = 0;
+
       totSize += sizeof(AliHLTPHOSRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTPHOSDigitDataStruct);   
       HLTDebug("Initial available size: %d, used size: %d, remaining available size: %d, should be: %d", availableSize, totSize, fAvailableSize, availableSize-totSize);
       
       fRecPointDataPtr->fMultiplicity = fDigitsInCluster;     
-
+      HLTDebug("Number of digits in cluster: %d", fDigitsInCluster);
       fRecPointDataPtr++;
+
+      fDigitReader->Rewind(); // TODO: jump to the next instead of rewind
     }//end of clusterization
 
-   return nRecPoints;
+  return nRecPoints;
 }
 
 Int_t
-AliHLTPHOSClusterizer::ScanForNeighbourDigits(AliHLTPHOSRecPointDataStruct* recPoint)
+AliHLTPHOSClusterizer::ScanForNeighbourDigits(AliHLTPHOSRecPointDataStruct* recPoint, AliHLTPHOSDigitDataStruct *digit)
 {
   //see header file for documentation
 
@@ -159,19 +169,32 @@ AliHLTPHOSClusterizer::ScanForNeighbourDigits(AliHLTPHOSRecPointDataStruct* recP
   //  Int_t max = fDigitContainerPtr->fNDigits;
   //  Int_t min = 0;
 
+  AliHLTPHOSDigitDataStruct *tmpDigit = 0;
+
   fDigitReader->Rewind();
 
-  while((fCurrentDigit = fDigitReader->NextDigit()))
+  while((tmpDigit = fDigitReader->NextDigit()))
     {
-      if(fCurrentDigit->fEnergy > fEmcMinEnergyThreshold)
+      //HLTError("Checking digit (x,z): %d, %d, with energy: %f", tmpDigit->fX, tmpDigit->fZ, tmpDigit->fEnergy); 
+      //      HLTError("Checking digit (x,z): %d, %d, with energy: %f for neighbourship of digit (x,z): %d, %d", tmpDigit->fX, tmpDigit->fZ, tmpDigit->fEnergy, digit->fX, digit->fZ); 
+      //      if(tmpDigit->fEnergy > fEmcMinEnergyThreshold)
+      if(tmpDigit->fEnergy > 0.2)
        {
-         if(AreNeighbours(fStartDigit, fCurrentDigit))
+         //HLTError("Checking digit (x,z): %d, %d, with energy: %f for neighbourship of digit (x,z): %d, %d", tmpDigit->fX, tmpDigit->fZ, tmpDigit->fEnergy, digit->fX, digit->fZ); 
+
+         //      if(AreNeighbours(fStartDigit, tmpDigit))
+         if(AreNeighbours(digit, tmpDigit))
            {
+             //              HLTError("Adding digit (x,z): %d, %d, with energy: %f", tmpDigit->fX, tmpDigit->fZ, tmpDigit->fEnergy);
              fDigitReader->DropDigit();
-             fPreviousDigit->fMemOffsetNext = reinterpret_cast<Long_t>(fCurrentDigit) - reinterpret_cast<Long_t>(fPreviousDigit);
-             recPoint->fAmp += fCurrentDigit->fEnergy;
+             fPreviousDigit->fMemOffsetNext = reinterpret_cast<Long_t>(tmpDigit) - reinterpret_cast<Long_t>(fPreviousDigit);
+             //              cout << "Digit offset: " << fPreviousDigit->fMemOffsetNext << endl;
+             //   fPreviousDigit->fMemOffsetNext += tmpDigit->fMemOffsetNext;
+             recPoint->fAmp += tmpDigit->fEnergy;
+             fPreviousDigit = tmpDigit;
              fDigitsInCluster++;
-             ScanForNeighbourDigits(recPoint);
+             ScanForNeighbourDigits(recPoint, tmpDigit);
+             fDigitReader->SetCurrentDigit(tmpDigit);
            }
        }
     }
@@ -187,12 +210,13 @@ AliHLTPHOSClusterizer::AreNeighbours(AliHLTPHOSDigitDataStruct* digit1,
     { 
       Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );  
       Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX ); 
+      //      HLTError("coldiff: %d, rowdiff: %d, timediff: %f", coldiff, rowdiff, TMath::Abs(digit1->fTime - digit2->fTime ));
       if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))
        {
          //      cout << "Are neighbours: digit (E = "  << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ << 
            //      " is neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;
 
-         if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)
+         //      if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)
            {
              return 1; 
            }

diff --git a/HLT/PHOS/AliHLTPHOSClusterizer.h b/HLT/PHOS/AliHLTPHOSClusterizer.h
index 2a81bd82251ecabdad79e350c5a5df27d1b6b195..bf5046eb81bd2155ef8bb3568f353484477ea31e 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSClusterizer.h
+++ b/HLT/PHOS/AliHLTPHOSClusterizer.h
@@ -119,7 +119,7 @@ public:
    * it is added to the current rec point
    * @param recPoint pointer to the current rec point
    */
-  virtual Int_t ScanForNeighbourDigits(AliHLTPHOSRecPointDataStruct* recPoint);
+  virtual Int_t ScanForNeighbourDigits(AliHLTPHOSRecPointDataStruct* recPoint, AliHLTPHOSDigitDataStruct *digit);
 
   /**
    * Checks if two digits are neighbours

diff --git a/HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx b/HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx
index e7b4c411e192f2a7d3d97e2521de2fdb9812e0c8..a41eef0aa76d5a811860ba6767c4575184cee763 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx
+++ b/HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx
@@ -136,6 +136,8 @@ AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   AliHLTPHOSDigitHeaderStruct *digitHeaderPtr = 0;
   AliHLTPHOSDigitHeaderStruct *outputDigitHeaderPtr = reinterpret_cast<AliHLTPHOSDigitHeaderStruct*>(outBPtr);
 
+  //  HLTError("Header pointer before screwing around: 0x%x", outputDigitHeaderPtr);
+
   AliHLTPHOSDigitDataStruct *firstDigitPtr = 0;
   AliHLTPHOSDigitDataStruct *lastDigitPtr = 0;
   
@@ -145,15 +147,15 @@ AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
       iter = blocks+ndx;
       if (iter->fDataType == AliHLTPHOSDefinitions::fgkDigitDataType)
        {
+         // Get the digit header
+         digitHeaderPtr = reinterpret_cast<AliHLTPHOSDigitHeaderStruct*>(iter->fPtr);
+
          // Update the number of digits
          nDigits += digitHeaderPtr->fNDigits;
 
          // Get the specification
          specification = specification|iter->fSpecification;
          
-         // Get the digit header
-         digitHeaderPtr = reinterpret_cast<AliHLTPHOSDigitHeaderStruct*>(iter->fPtr);
-         
          // Check if we have the first buffer in the event
          if(!firstDigitPtr)
            {
@@ -167,9 +169,11 @@ AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
              memcpy(outBPtr, iter->fPtr, digitHeaderPtr->fNDigits*sizeof(AliHLTPHOSDigitDataStruct) + sizeof(AliHLTPHOSDigitHeaderStruct));
 
              // Set the pointer to the first digit in the list
-             firstDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fFirstDigitOffset);
+             //              firstDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fFirstDigitOffset);
+             firstDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + digitHeaderPtr->fFirstDigitOffset);
 
-             lastDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fLastDigitOffset);
+             //              lastDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fLastDigitOffset);
+             lastDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + digitHeaderPtr->fLastDigitOffset);
              
              // Update the amount of the output buffer we have used
              mysize += digitHeaderPtr->fNDigits*sizeof(AliHLTPHOSDigitDataStruct) + sizeof(AliHLTPHOSDigitHeaderStruct);
@@ -184,26 +188,32 @@ AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
                }
 
              // If we already have copied the first buffer to the output copy only the digits
-             memcpy(outBPtr, reinterpret_cast<const void*>(reinterpret_cast<Long_t>(iter->fPtr)+sizeof(AliHLTPHOSDigitHeaderStruct)), digitHeaderPtr->fNDigits*sizeof(AliHLTPHOSDigitDataStruct));
+             memcpy(outBPtr, reinterpret_cast<const void*>(reinterpret_cast<UChar_t*>(iter->fPtr)+sizeof(AliHLTPHOSDigitHeaderStruct)), digitHeaderPtr->fNDigits*sizeof(AliHLTPHOSDigitDataStruct));
 
              // Check if the first digit in this buffer has a ID less than the first digit in the previous
-             if(firstDigitPtr->fID > reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(iter->fPtr) + sizeof(AliHLTPHOSDigitDataStruct) + digitHeaderPtr->fFirstDigitOffset)->fID)
+             //              if(firstDigitPtr->fID > reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(iter->fPtr) + sizeof(AliHLTPHOSDigitDataStruct) + digitHeaderPtr->fFirstDigitOffset)->fID)
+             AliHLTPHOSDigitDataStruct *thisFirst = 
+               reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(iter->fPtr) + digitHeaderPtr->fFirstDigitOffset);
+             if(firstDigitPtr->fID > thisFirst->fID)
                {
                  // If that is the case we have to take care of the ordering
                                  
+                 HLTError("Re-ordering digit blocks...");
                  // The last digit in the current buffer has to link to the first digit in the previous buffer
-                 lastDigitPtr->fMemOffsetNext = reinterpret_cast<Long_t>(outBPtr) + digitHeaderPtr->fFirstDigitOffset - reinterpret_cast<Long_t>(lastDigitPtr);
+                 //              AliHLTPHOSDigitDataStruct *thisLast = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fLastDigitOffset);
+                 AliHLTPHOSDigitDataStruct *thisLast = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr - sizeof(AliHLTPHOSDigitHeaderStruct) + digitHeaderPtr->fLastDigitOffset);
+                 thisLast->fMemOffsetNext = reinterpret_cast<Long_t>(firstDigitPtr) - reinterpret_cast<Long_t>(thisLast);
 
                  // Setting the pointer to the new first digit
-                 firstDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + digitHeaderPtr->fFirstDigitOffset);
+                 firstDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(outBPtr + digitHeaderPtr->fFirstDigitOffset - sizeof(AliHLTPHOSDigitHeaderStruct));
                }
              else
                {
                  // Previous last digit need to link to the current first digit
-                 lastDigitPtr->fMemOffsetNext = reinterpret_cast<Long_t>(outBPtr) + digitHeaderPtr->fFirstDigitOffset;           
+                 lastDigitPtr->fMemOffsetNext = reinterpret_cast<Long_t>(lastDigitPtr) - (reinterpret_cast<Long_t>(outBPtr) + digitHeaderPtr->fFirstDigitOffset - sizeof(AliHLTPHOSDigitHeaderStruct));                  
                  
                  // We need to change the last digit pointer
-                 lastDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(outBPtr) + digitHeaderPtr->fLastDigitOffset);
+                 lastDigitPtr = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(outBPtr) + digitHeaderPtr->fLastDigitOffset - sizeof(AliHLTPHOSDigitHeaderStruct));
                }
              // Update the amount of the output buffer we have used
              mysize += digitHeaderPtr->fNDigits*sizeof(AliHLTPHOSDigitDataStruct);
@@ -213,26 +223,35 @@ AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
        }
     }
   
-  // The digit header in the output needs to know about the position of the new first digit (the last digit is still the same)
-  outputDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(firstDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
+  // The digit header in the output needs to know about the position of the new first digit
+  //  outputDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(firstDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
+  outputDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(firstDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr);
   
-  // The digit header in the output needs to know about the position of the new last digit (the first digit is still the same)
-  outputDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(lastDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
-                 
+  // The digit header in the output needs to know about the position of the new last digit
+  //  outputDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(lastDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
+  outputDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(lastDigitPtr) - reinterpret_cast<Long_t>(outputDigitHeaderPtr);
+  if(firstDigitPtr)
+    {
+      //      HLTError("Header pointer after screwing around: 0x%x", outputDigitHeaderPtr);
+      //      HLTError("First/last offset: %d / %d, first digit ID: %d, energy: %f", outputDigitHeaderPtr->fFirstDigitOffset, outputDigitHeaderPtr->fLastDigitOffset, firstDigitPtr->fID, firstDigitPtr->fEnergy);
+    }
 
   HLTDebug("Number of digits: %d", nDigits);
 
-  AliHLTPHOSRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTPHOSRecPointHeaderStruct*>(outBPtr);
+  if(nDigits > 0)
+    {
 
-  fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(outBPtr+sizeof(AliHLTPHOSRecPointHeaderStruct)));
+      AliHLTPHOSRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTPHOSRecPointHeaderStruct*>(outBPtr);
 
-  nRecPoints = fClusterizerPtr->ClusterizeEvent(outputDigitHeaderPtr, availableSize, mysize);
-  recPointHeaderPtr->fNRecPoints = nRecPoints;
+      fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTPHOSRecPointDataStruct*>(outBPtr+sizeof(AliHLTPHOSRecPointHeaderStruct)));
 
-  mysize += sizeof(AliHLTPHOSRecPointHeaderStruct);
-  
-  HLTDebug("Number of clusters: %d", nRecPoints);
+      nRecPoints = fClusterizerPtr->ClusterizeEvent(outputDigitHeaderPtr, availableSize, mysize);
+      recPointHeaderPtr->fNRecPoints = nRecPoints;
 
+      mysize += sizeof(AliHLTPHOSRecPointHeaderStruct);
+  
+      HLTDebug("Number of clusters: %d", nRecPoints);
+    }
   AliHLTComponentBlockData clusterBd;
   FillBlockData( clusterBd );
   clusterBd.fOffset = offset;

diff --git a/HLT/PHOS/AliHLTPHOSConstants.h b/HLT/PHOS/AliHLTPHOSConstants.h
index 8fbda161c6f70dfe2cf1a799cb8b9a4c293d9625..f6ddf9d26b9719d410dc71085bcbc9dff4ed532e 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSConstants.h
+++ b/HLT/PHOS/AliHLTPHOSConstants.h
@@ -27,8 +27,8 @@ namespace PhosHLTConst
   const int MAXHOSTS = 20;
   const int DEFAULTEVENTPORT = 42001;
   const int MAXBINVALUE = 1023;
-  const int HIGHGAIN    =   1;
-  const int LOWGAIN     =   0;
+  const int HIGHGAIN    =   0;
+  const int LOWGAIN     =   1;
 
   const int ALTROMAXSAMPLES = 1008;                           /**<The maximum number of samples of the ALTRO*/
   const int ALTROMAXPRESAMPLES = 15;        

diff --git a/HLT/PHOS/AliHLTPHOSDigitDataStruct.h b/HLT/PHOS/AliHLTPHOSDigitDataStruct.h
index d0ec12fd50520de8215f92315edbda4320040423..881f59f0d0bce66dbe407a8e6b8ae6d4d165978c 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitDataStruct.h
+++ b/HLT/PHOS/AliHLTPHOSDigitDataStruct.h
@@ -67,10 +67,10 @@ struct AliHLTPHOSDigitHeaderStruct
 struct AliHLTPHOSDigitDataStruct
 {
   /** The x coordinate */
-  Float_t fX;
+  Int_t fX;
 
   /** The z coordinate */
-  Float_t fZ;
+  Int_t fZ;
 
   /** The local x coordinate */
   Float_t fLocX;

diff --git a/HLT/PHOS/AliHLTPHOSDigitMaker.cxx b/HLT/PHOS/AliHLTPHOSDigitMaker.cxx
index 99bed8a33714db239ce46004890846ce91ac347e..8b8e3d5d22717827c4c7ce13e841f0a6479bdc67 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitMaker.cxx
+++ b/HLT/PHOS/AliHLTPHOSDigitMaker.cxx
@@ -231,7 +231,7 @@ AliHLTPHOSDigitMaker::MakeDigits(AliHLTPHOSChannelDataHeaderStruct* channelDataH
            }
        }
     }
-
+  if(fDigitCount > 1) SortDigits();
   return fDigitCount; 
 }
 
@@ -296,16 +296,26 @@ AliHLTPHOSDigitMaker::SortDigits()
   // See header file for documentation
 
   //  Int_t (*funcPtr)(const void*, const void*)  = &AliHLTPHOSDigitMaker::CompareDigits;
-
+  //  HLTError("fDigitPtrArray[0]: %lu, fDigitHeaderPtr: %lu, sizeof(AliHLTPHOSDigitHeaderStruct): %d", fDigitPtrArray[0], fDigitHeaderPtr, sizeof(AliHLTPHOSDigitHeaderStruct));
+  //  HLTError("First digit offset: %d, first digit ptr: %ld, sizeof(AliHLTPHOSDigitDataStruct) = %d", fDigitHeaderPtr->fFirstDigitOffset, fDigitPtrArray[0], sizeof(AliHLTPHOSDigitDataStruct));
   qsort(fDigitPtrArray, fDigitCount, sizeof(AliHLTPHOSDigitDataStruct*), CompareDigits);
 
-  fDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[0]) - reinterpret_cast<Long_t>(fDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
+  //  HLTError("fDigitPtrArray[0]: %lu, fDigitHeaderPtr: %lu, sizeof(AliHLTPHOSDigitHeaderStruct): %d", fDigitPtrArray[0], fDigitHeaderPtr, sizeof(AliHLTPHOSDigitHeaderStruct));
+  //  fDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[0]) - reinterpret_cast<Long_t>(fDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct);
+  fDigitHeaderPtr->fFirstDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[0]) - reinterpret_cast<Long_t>(fDigitHeaderPtr);
+  //  HLTError("First digit offset: %d, first digit ptr: %ld, sizeof(AliHLTPHOSDigitDataStruct) = %d", fDigitHeaderPtr->fFirstDigitOffset, fDigitPtrArray[0], sizeof(AliHLTPHOSDigitDataStruct));
   for(Int_t i = 0; i < fDigitCount-1; i++)
     {
-      fDigitPtrArray[0]->fMemOffsetNext = fDigitPtrArray[i+1] - fDigitPtrArray[i];
+      fDigitPtrArray[i]->fMemOffsetNext = reinterpret_cast<Long_t>(fDigitPtrArray[i+1]) - reinterpret_cast<Long_t>(fDigitPtrArray[i]);
+      //      HLTError("Adding digit with energy: %f, ID: %d, offset: %d and pointer %lu", fDigitPtrArray[i]->fEnergy, fDigitPtrArray[i]->fID, fDigitPtrArray[i]->fMemOffsetNext, fDigitPtrArray[i]);
     }
-  fDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[fDigitCount-1]) - (reinterpret_cast<Long_t>(fDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct));
+  //  fDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[fDigitCount-1]) - (reinterpret_cast<Long_t>(fDigitHeaderPtr) + sizeof(AliHLTPHOSDigitHeaderStruct));
+  fDigitHeaderPtr->fLastDigitOffset = reinterpret_cast<Long_t>(fDigitPtrArray[fDigitCount-1]) - reinterpret_cast<Long_t>(fDigitHeaderPtr);
+  //  HLTError("Last digit offset: %d, last digit ptr: %ld", fDigitHeaderPtr->fLastDigitOffset, fDigitPtrArray[fDigitCount-1]);
   fDigitPtrArray[fDigitCount-1]->fMemOffsetNext = 0;
+  //  HLTError("Number of digits: %d", fDigitCount);
+  fDigitHeaderPtr->fNDigits = fDigitCount;
+
 }
 
 Int_t

diff --git a/HLT/PHOS/AliHLTPHOSDigitMaker.h b/HLT/PHOS/AliHLTPHOSDigitMaker.h
index 20eafd192274afb114fd65cfb826548f5ed79a20..5f0cd5ad7a0b8d34d86b960398b806f10f4f8ffc 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitMaker.h
+++ b/HLT/PHOS/AliHLTPHOSDigitMaker.h
@@ -157,12 +157,16 @@ private:
    */
   bool AddDigit(AliHLTPHOSChannelDataStruct* channelData, UShort_t* channelCoordinates, Float_t* localCoordinates)
   {
+    //    HLTError("Available size: %d", fAvailableSize);
+
     if(fAvailableSize < sizeof(AliHLTPHOSDigitDataStruct))
       {
-       HLTError("Output buffer is full, stopping digit making");
+       HLTError("Output buffer is full, stopping digit making.");
        return false;
       }
 
+
+
     fAvailableSize -= sizeof(AliHLTPHOSDigitDataStruct);
 
     fDigitStructPtr->fX = channelCoordinates[0];
@@ -176,12 +180,12 @@ private:
     if(channelCoordinates[2] == HIGHGAIN)
       {
        fDigitStructPtr->fEnergy = channelData->fEnergy*fHighGainFactors[channelCoordinates[0]][channelCoordinates[1]];
-       //      HLTDebug("HG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f \n", channelCoordinates[0], channelCoordinates[1], channelData->fEnergy, fDigitStructPtr->fEnergy);
+       //      HLTError("HG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f \n", channelCoordinates[0], channelCoordinates[1], channelData->fEnergy, fDigitStructPtr->fEnergy);
       }
     else
       {
        fDigitStructPtr->fEnergy = channelData->fEnergy*fLowGainFactors[channelCoordinates[0]][channelCoordinates[1]];
-       //      HLTDebug("LG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f\n", channelCoordinates[0], channelCoordinates[1], channelData->fEnergy, fDigitStructPtr->fEnergy); 
+       //      HLTError("LG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f\n", channelCoordinates[0], channelCoordinates[1], channelData->fEnergy, fDigitStructPtr->fEnergy); 
       }
     fDigitStructPtr->fTime = channelData->fTime * 0.0000001; //TODO
     fDigitStructPtr->fCrazyness = channelData->fCrazyness;

diff --git a/HLT/PHOS/AliHLTPHOSDigitMakerComponent.cxx b/HLT/PHOS/AliHLTPHOSDigitMakerComponent.cxx
index 249735c10f421585678a1a99f4e6c0302b6185a2..df80ad24939c0141a170136c2e13cdbfa6f78cca 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitMakerComponent.cxx
+++ b/HLT/PHOS/AliHLTPHOSDigitMakerComponent.cxx
@@ -144,7 +144,7 @@ AliHLTPHOSDigitMakerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   
   mysize += digitCount*sizeof(AliHLTPHOSDigitDataStruct);
 
-  //  HLTDebug("# of digits: %d, used memory size: %d, available size: %d", digitCount, mysize, size);
+  HLTDebug("# of digits: %d, used memory size: %d, available size: %d", digitCount, mysize, size);
 
   if(mysize > 0) 
     {

diff --git a/HLT/PHOS/AliHLTPHOSDigitReader.cxx b/HLT/PHOS/AliHLTPHOSDigitReader.cxx
index ff4b55d61a639b7d4e46627257aecc589696f347..2f3d7468c76a2da60fa708e90dc057e98441d2f9 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitReader.cxx
+++ b/HLT/PHOS/AliHLTPHOSDigitReader.cxx
@@ -12,7 +12,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
+#include "AliHLTLogging.h"
 #include "AliHLTPHOSDigitReader.h"
 #include "AliHLTPHOSDigitDataStruct.h"
 
@@ -39,15 +39,17 @@ AliHLTPHOSDigitDataStruct* AliHLTPHOSDigitReader::NextDigit()
   fPrevDigit = fCurrentDigit;
   fCurrentDigit = fNextDigit;
 
+  if(fCurrentDigit == 0) return 0;
+
   if(fCurrentDigit->fMemOffsetNext != 0)
     {
-      fNextDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fCurrentDigit) + fCurrentDigit->fMemOffsetNext);
+      fNextDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(fCurrentDigit) + fCurrentDigit->fMemOffsetNext);
     }
   else
     {
       fNextDigit = 0;
     }
-
+  //  cout << "Digit is (x, z): " << fCurrentDigit->fX << ", " << fCurrentDigit->fZ << endl;
   return fCurrentDigit;
 }
 
@@ -55,12 +57,14 @@ void AliHLTPHOSDigitReader::DropDigit()
 {
   if(fCurrentDigit == fFirstDigit)
     {
-      fFirstDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fFirstDigit) + fFirstDigit->fMemOffsetNext);
+      fFirstDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(fFirstDigit) + fFirstDigit->fMemOffsetNext);
       fDigitHeader->fFirstDigitOffset += fCurrentDigit->fMemOffsetNext;
+      //      HLTError("Dropping digit (x,z): %d, %d was first in list", fCurrentDigit->fX, fCurrentDigit->fZ);
     }
   else if(fCurrentDigit != 0)
     {
       fPrevDigit->fMemOffsetNext = fPrevDigit->fMemOffsetNext + fCurrentDigit->fMemOffsetNext;
+      //      HLTError("Dropping digit (x,z): %d, %d, first digit is (x,z): %d, %d", fCurrentDigit->fX, fCurrentDigit->fZ, fFirstDigit->fX, fFirstDigit->fZ);
     }
   fCurrentDigit = fPrevDigit;
 }

diff --git a/HLT/PHOS/AliHLTPHOSDigitReader.h b/HLT/PHOS/AliHLTPHOSDigitReader.h
index 67c7806152ea4469075209318734526d6db354cf..9b4f8f4426aefc35aa3e89adaead16e7c527b107 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSDigitReader.h
+++ b/HLT/PHOS/AliHLTPHOSDigitReader.h
@@ -28,7 +28,7 @@
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-
+#include "AliHLTLogging.h"
 #include "AliHLTPHOSDigitDataStruct.h"
 
 /** 
@@ -37,7 +37,7 @@
  * the list of digits following the header
  * @ingroup alihlt_phos
  */
-class AliHLTPHOSDigitReader
+class AliHLTPHOSDigitReader : public AliHLTLogging
 {
 
 public:
@@ -49,7 +49,7 @@ public:
     fDigitHeader = digitHeader; 
     if(fDigitHeader->fNDigits != 0)
       {
-       fFirstDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fDigitHeader) + sizeof(AliHLTPHOSDigitHeaderStruct) + fDigitHeader->fFirstDigitOffset);
+       fFirstDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<Long_t>(fDigitHeader) + fDigitHeader->fFirstDigitOffset);
       }
     else 
       {
@@ -58,15 +58,31 @@ public:
     fNextDigit = fFirstDigit;
   }
     
-  void SetCurrentDigit(AliHLTPHOSDigitDataStruct *currentDigit) { fCurrentDigit = currentDigit; }
+  void SetCurrentDigit(AliHLTPHOSDigitDataStruct *currentDigit) 
+  { 
+    fCurrentDigit = currentDigit; 
+    //    fNextDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(fCurrentDigit) + fCurrentDigit->fMemOffsetNext);
+  }
+  void SetNextDigit(AliHLTPHOSDigitDataStruct *nextDigit) 
+  { 
+    fNextDigit = nextDigit; 
+    //    fNextDigit = reinterpret_cast<AliHLTPHOSDigitDataStruct*>(reinterpret_cast<UChar_t*>(fCurrentDigit) + fCurrentDigit->fMemOffsetNext);
+  }
 
   AliHLTPHOSDigitDataStruct* NextDigit();
 
   void DropDigit();
 
-  void Rewind() { fCurrentDigit = fFirstDigit; }
+  void Rewind() 
+  { 
+    fNextDigit = fFirstDigit; 
+    fPrevDigit = 0;
+  }
+
+  //  Int_t GetCurrentDigitOffset() { return reinterpret_cast<Long_t>(fCurrentDigit) - reinterpret_cast<Long_t>(fDigitHeader) + sizeof(AliHLTPHOSDigitHeaderStruct); }
+
+  Int_t GetCurrentDigitOffset() { return reinterpret_cast<Long_t>(fCurrentDigit) - reinterpret_cast<Long_t>(fDigitHeader); }
 
-  Int_t GetCurrentDigitOffset() { return reinterpret_cast<Long_t>(fCurrentDigit) - reinterpret_cast<Long_t>(fDigitHeader) + sizeof(AliHLTPHOSDigitHeaderStruct); }
 private:
   
   /** Pointer to the digit header */

diff --git a/HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.cxx b/HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.cxx
index 8f982deab50c06792d4eaa92c2b9e206cc4e357b..08df739db608b95846b40e34cbf6dda31eda2bc5 100644 (file)
--- a/HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.cxx
+++ b/HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.cxx
@@ -189,9 +189,11 @@ AliHLTPHOSRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
 
   // Then comes the channel data
   AliHLTPHOSChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTPHOSChannelDataStruct*>(outputPtr+sizeof(AliHLTPHOSChannelDataHeaderStruct)); 
+  
   //Adding to the total size of data written
   totSize += sizeof( AliHLTPHOSChannelDataHeaderStruct );
 
+
   fRawReaderMemoryPtr->SetMemory(reinterpret_cast<UChar_t*>(iter->fPtr), static_cast<ULong_t>(iter->fSize));
   fRawReaderMemoryPtr->SetEquipmentID(fMapperPtr->GetDDLFromSpec(iter->fSpecification) + 1792);
   fRawReaderMemoryPtr->Reset();
@@ -201,14 +203,16 @@ AliHLTPHOSRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
 //     {
 //       fRawDataWriter->NewEvent( );
 //     }
+
   if(fAltroRawStreamPtr != NULL)
     {
       delete fAltroRawStreamPtr;
       fAltroRawStreamPtr=NULL;
     }
+
+  fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
   
   //  fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, TString("PHOS"));
-  fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
 
   if(fAltroRawStreamPtr->NextDDL())
     {
@@ -232,13 +236,16 @@ AliHLTPHOSRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
 //             }
              while( fAltroRawStreamPtr->NextBunch() == true )
                {
-                 nSamples = fAltroRawStreamPtr->GetBunchLength();
-                 
+
 //               if( fDoPushRawData == true)
 //                 {
 //                   fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples,  fAltroRawStreamPtr->GetEndTimeBin()  );
 //                 }
+
                  firstBunchPtr = const_cast< UShort_t* >(  fAltroRawStreamPtr->GetSignals()  );
+                 
+                 nSamples = fAltroRawStreamPtr->GetBunchLength();
+
                }
              if(firstBunchPtr)
                {             

diff --git a/HLT/PHOS/OnlineDisplay/AliHLTPHOSOnlineDisplayTH2D.cxx b/HLT/PHOS/OnlineDisplay/AliHLTPHOSOnlineDisplayTH2D.cxx
index 9771de37f89ac08f598dfeb42733adf16ea511d2..60bea0b18382b786288e4bcc47d281480431bea0 100644 (file)
--- a/HLT/PHOS/OnlineDisplay/AliHLTPHOSOnlineDisplayTH2D.cxx
+++ b/HLT/PHOS/OnlineDisplay/AliHLTPHOSOnlineDisplayTH2D.cxx
@@ -1,4 +1,4 @@
-// $Id: AliHLTPHOSOnlineDisplayTH2D.cxx 31490 2009-03-15 16:27:11Z odjuvsla $
+// $Id$
 
 /**************************************************************************
  * This file is property of and copyright by the Experimental Nuclear     *

diff --git a/HLT/QA/AliHLTQADataMakerRec.cxx b/HLT/QA/AliHLTQADataMakerRec.cxx
index 92a247ceeb725bb0dc84542ab190e94433e26e1c..052d82ffc415e1d26452a272b779c758d21c8813 100644 (file)
--- a/HLT/QA/AliHLTQADataMakerRec.cxx
+++ b/HLT/QA/AliHLTQADataMakerRec.cxx
@@ -1,4 +1,4 @@
-// $Id:$
+// $Id$
 
 //**************************************************************************
 //* This file is property of and copyright by the ALICE HLT Project        * 

diff --git a/HLT/QA/AliHLTQADataMakerSim.cxx b/HLT/QA/AliHLTQADataMakerSim.cxx
index 81822a92755affc87c45598f8532437dd401448d..e557b26db82d402642d17e346af3cb4a0cec3d18 100644 (file)
--- a/HLT/QA/AliHLTQADataMakerSim.cxx
+++ b/HLT/QA/AliHLTQADataMakerSim.cxx
@@ -1,4 +1,4 @@
-// $Id:$
+// $Id$
 
 //**************************************************************************
 //* This file is property of and copyright by the ALICE HLT Project        * 

diff --git a/HLT/libAliHLTGlobal.pkg b/HLT/libAliHLTGlobal.pkg
index 8f7a7ee74060fd3397a0f67c5e1e2266f807656f..c8d02b01bc7df638420735d121c59a88972dba93 100644 (file)
--- a/HLT/libAliHLTGlobal.pkg
+++ b/HLT/libAliHLTGlobal.pkg
@@ -7,7 +7,14 @@ CLASS_HDRS:=   AliHLTGlobalEsdConverterComponent.h \
                AliHLTGlobalAgent.h \
                AliHLTGlobalVertexerComponent.h \
                AliHLTGlobalTrackMatcher.h \
-               physics/AliHLTV0HistoComponent.h
+               physics/AliHLTV0HistoComponent.h 
+#              physics/AliHLTPHOSHistoProdInvMass.h \
+#              physics/AliHLTPHOSHistoProdMatchedTracks.h \
+#              physics/AliHLTPHOSHistoProdClusterEnergy.h \
+#              physics/AliHLTPHOSHistoProdCellEnergy.h
+
+#              physics/AliHLTPHOSHistogramProducerComponent.h \
+#physics/AliHLTPHOSHistogramProducerComponent.h 
 
 #              
 MODULE_SRCS=   $(CLASS_HDRS:.h=.cxx)

diff --git a/HLT/libAliHLTPHOS.pkg b/HLT/libAliHLTPHOS.pkg
index d60247aca5c78d5ca9cda16b10358d603420faec..c9d864e9c41e68ad40099437222659fcd61da119 100644 (file)
--- a/HLT/libAliHLTPHOS.pkg
+++ b/HLT/libAliHLTPHOS.pkg
@@ -36,15 +36,9 @@ CLASS_HDRS:=   AliHLTPHOSClusterizer.h \
                  AliHLTPHOSRcuDAComponent.h \
                  AliHLTPHOSUtilities.h \
                  AliHLTPHOSHistogramProducer.h \
-                 AliHLTPHOSHistogramProducerComponent.h \
                  AliHLTPHOSMonitorTriggerComponent.h \
                  AliHLTPHOSESDEntriesMakerComponent.h \
                  AliHLTPHOSESDCaloClusterWriterComponent.h \
-                 AliHLTPHOSHistoProdInvMass.h \
-                 AliHLTPHOSHistoProdMatchedTracks.h \
-                 AliHLTPHOSHistoProdClusterEnergy.h \
-                 AliHLTPHOSHistoProdCellEnergy.h \
-                 AliHLTPHOSPhysicsHistogramProducer.h \
                  AliHLTPHOSFourier.h \
                  AliHLTPHOSDigitReader.h