- moving the cluster parameter evalution from own component to clusterizer
authorodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Feb 2010 01:13:28 +0000 (01:13 +0000)
committerodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Feb 2010 01:13:28 +0000 (01:13 +0000)
- fixing nasty bug in clusterizer
- cosmetics
- adding geometry classes to build system

13 files changed:
HLT/BASE/util/AliHLTCaloClusterDataStruct.h
HLT/CALO/AliHLTCaloClusterAnalyser.cxx
HLT/CALO/AliHLTCaloClusterAnalyser.h
HLT/CALO/AliHLTCaloClusterizer.cxx
HLT/CALO/AliHLTCaloClusterizer.h
HLT/CALO/AliHLTCaloClusterizerComponent.cxx
HLT/CALO/AliHLTCaloClusterizerComponent.h
HLT/CALO/AliHLTCaloDigitMaker.cxx
HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx
HLT/PHOS/AliHLTPHOSClusterizerComponent.h
HLT/PHOS/macros/rec-hlt-calo-phos.C
HLT/libAliHLTCalo.pkg
HLT/libAliHLTPHOS.pkg

index c4322c8..73bd99b 100644 (file)
@@ -45,6 +45,7 @@
 struct AliHLTCaloClusterHeaderStruct
 {
   Short_t fNClusters;
+  Short_t fNDigits;
 };
 
 /**
index d074694..a1be568 100644 (file)
 #include "AliHLTCaloRecPointDataStruct.h"
 #include "AliHLTCaloClusterDataStruct.h"
 //#include "AliHLTCaloPhysicsAnalyzer.h"
-#include "AliPHOSGeoUtils.h"
+#include "AliHLTCaloGeometry.h"
 #include "AliESDCaloCluster.h"
 #include "TMath.h"
 #include "TVector3.h"
+#include "AliHLTCaloClusterizer.h"
 
 ClassImp(AliHLTCaloClusterAnalyser);
 
-AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() :
+AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() : 
   //  AliHLTCaloBase(),
-  fLogWeight(0),
-  fRecPointDataPtr(0),
+  fLogWeight(4.5),
+  fRecPointArray(0),
+  fDigitDataArray(0),
   fNRecPoints(0),
   fCaloClusterDataPtr(0),
   fCaloClusterHeaderPtr(0),
-  fPHOSGeometry(0),
   //fAnalyzerPtr(0),
   fDoClusterFit(false),
   fHaveCPVInfo(false),
   fDoPID(false),
-  fHaveDistanceToBadChannel(false)
+  fHaveDistanceToBadChannel(false),
+  fGeometry(0)
 {
   //See header file for documentation
-  fLogWeight = 4.5;
-
-  //  fAnalyzerPtr = new AliHLTCaloPhysicsAnalyzer();
-  //  fPHOSGeometry = AliPHOSGeometry::GetInstance("noCPV");
-  fPHOSGeometry = new AliPHOSGeoUtils("PHOS", "noCPV");
 }
 
 AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser() 
@@ -67,16 +64,26 @@ AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser()
 }
 
 void 
-AliHLTCaloClusterAnalyser::SetCaloClusterDataPtr(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
+AliHLTCaloClusterAnalyser::SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
 { 
   //see header file for documentation
   fCaloClusterDataPtr = caloClusterDataPtr; 
 }
+
 void
-AliHLTCaloClusterAnalyser::SetRecPointDataPtr(AliHLTCaloRecPointHeaderStruct *recPointDataPtr)
+AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints)
 { 
-  fNRecPoints = recPointDataPtr->fNRecPoints;
-  fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<Char_t*>(recPointDataPtr)+sizeof(AliHLTCaloRecPointHeaderStruct)); 
+  fRecPointArray = recPointDataPtr; 
+  fNRecPoints = nRecPoints;
+}
+
+void 
+AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct *digits) 
+{ 
+//   AliHLTCaloClusterizer cl("PHOS");
+  // cl.CheckDigits(fRecPointArray, digits, fNRecPoints);
+   fDigitDataArray = digits; 
+   //cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
 }
 
 Int_t
@@ -91,17 +98,27 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
 
   AliHLTCaloDigitDataStruct *digit = 0;
   //AliPHOSGeometry * phosgeom =  AliPHOSGeometry::GetInstance() ;
-
-  AliHLTCaloRecPointDataStruct *recPoint = fRecPointDataPtr;
+   
+  
+  //AliHLTCaloClusterizer      cl("PHOS");
+  //cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
 
   UInt_t iDigit = 0;
 
   for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++) 
     {
+      AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
       //      digit = &(recPoint->fDigits);
+      cout << "COG: Rec point multiplicity: " << recPoint->fMultiplicity << ", rec point energy: " << recPoint->fAmp << endl;
+      Int_t *digitIndexPtr = &(recPoint->fDigits);
+
       for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
        {
-         
+         //cout << "1. Digit array: " << fDigitDataArray << ", Digit: " << digit << ", Index: " << *digitIndexPtr << ", ID: " << digit->fID << endl;
+
+         digit = &(fDigitDataArray[*digitIndexPtr]);
+         cout << "COG: 2. Digit array: " << fDigitDataArray << ", Digit: " << digit << ", Index: " << *digitIndexPtr << ", index pointer: " << digitIndexPtr<<  endl;
+         cout << ", dig Energy: " << digit->fEnergy << ", Index: " << *digitIndexPtr << ", ID: " << digit->fID << endl;        
          xi = digit->fX;
          zi = digit->fZ;
          //  cout << "COG digits (x:z:E:time): " << xi << " : " << zi << " : " << digit->fEnergy << " : " << digit->fTime << endl;
@@ -112,7 +129,7 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
              z    += zi * w ;
              wtot += w ;
            }
-         digit++;
+         digitIndexPtr++;
        }
       //cout << endl;
       if (wtot>0) 
@@ -124,7 +141,6 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
        {
          recPoint->fAmp = 0;
        }
-      recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digit);
     }
   return 0;
 }
@@ -153,13 +169,21 @@ AliHLTCaloClusterAnalyser::DeconvoluteClusters()
 }
 
 Int_t 
-AliHLTCaloClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
+AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize)
 {
   //See header file for documentation
 
+  fNRecPoints = nRecPoints;
+
+  if(fGeometry == 0)
+  {
+     HLTError("No geometry object is initialised, creation of clusters stopped");
+  }
+
+  CalculateCenterOfGravity();
+
   UInt_t maxClusterSize = sizeof(AliHLTCaloClusterDataStruct) + (6 << 7); //Reasonable estimate... (6 = sizeof(Short_t) + sizeof(Float_t)
 
-  AliHLTCaloRecPointDataStruct* recPointPtr = fRecPointDataPtr;
   //  AliHLTCaloDigitDataStruct* digitPtr = &(recPointPtr->fDigits);  
   AliHLTCaloDigitDataStruct* digitPtr = 0;
 
@@ -172,18 +196,22 @@ AliHLTCaloClusterAnalyser::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
     {
-      
+//      if(availableSize
+      AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
+      cout << "CA: rec point energy: " << recPointPtr->fAmp << ", rec point multiplicity: " << recPointPtr->fMultiplicity << endl;
       if(availableSize < (totSize + maxClusterSize)) 
        {
          return -1; //Might get out of buffer, exiting
        }
       //      cout << "Local Position (x:z:module): " << recPointPtr->fX << " : "<< recPointPtr->fZ << " : " << recPointPtr->fModule << endl;
-      fPHOSGeometry->Local2Global(recPointPtr->fModule, recPointPtr->fX, recPointPtr->fZ, globalPos);
+      
+      AliHLTCaloGlobalCoordinate globalCoord;
+      fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);
       // cout << "Global Position (x:y:z): " << globalPos[0] << " : "<< globalPos[1] << " : " << globalPos[2] << endl << endl;
 
-      caloClusterPtr->fGlobalPos[0] = globalPos[0];
-      caloClusterPtr->fGlobalPos[1] = globalPos[1];
-      caloClusterPtr->fGlobalPos[2] = globalPos[2];
+      caloClusterPtr->fGlobalPos[0] = globalCoord.fX;
+      caloClusterPtr->fGlobalPos[1] = globalCoord.fY;
+      caloClusterPtr->fGlobalPos[2] = globalCoord.fZ;
 
       caloClusterPtr->fNCells = recPointPtr->fMultiplicity;
   
@@ -192,16 +220,17 @@ AliHLTCaloClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
      
       for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
        {
-         fPHOSGeometry->RelPosToAbsId((Int_t)(recPointPtr->fModule), (double)(digitPtr->fX), (double)(digitPtr->fZ), id);
-         *cellIDPtr = id;
+        // fPHOSGeometry->RelPosToAbsId((Int_t)(recPointPtr->fModule), (double)(digitPtr->fX), (double)(digitPtr->fZ), id);
+/*       *cellIDPtr = id;
          *cellAmpFracPtr = digitPtr->fEnergy/recPointPtr->fAmp;
          digitPtr++;
          cellIDPtr = reinterpret_cast<UShort_t*>(reinterpret_cast<char*>(cellAmpFracPtr) + sizeof(Float_t)); 
-         cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Short_t)); 
+         cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Short_t)); */
        }
 
       caloClusterPtr->fEnergy = recPointPtr->fAmp;
-
+      cout << "CA: cluster energy: " << caloClusterPtr->fEnergy << endl;
+      cout << "CA: recpoint energy: " << recPointPtr->fAmp << endl;
       if(fDoClusterFit)
        {
          FitCluster(recPointPtr);
@@ -246,8 +275,10 @@ AliHLTCaloClusterAnalyser::CreateClusters(UInt_t availableSize, UInt_t& totSize)
       //      totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells)*(sizeof(Short_t) +sizeof(Float_t)-1);   
       totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));   
 
+     
       //      caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellAmpFracPtr);
       caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
+
       recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
       ///digitPtr = &(recPointPtr->fDigits);  
     }
index 06f164c..82d3402 100644 (file)
@@ -19,7 +19,7 @@
 #ifndef ALIHLTCALOCLUSTERANALYSER_H
 #define ALIHLTCALOCLUSTERANALYSER_H
 
-#include "Rtypes.h"
+#include "AliHLTLogging.h"
 
 /**
  * Class calculates properties of rec points
 //class AliHLTCaloPhysicsAnalyzer;
 class AliHLTCaloRecPointHeaderStruct;
 class AliHLTCaloRecPointDataStruct;
+class AliHLTCaloDigitDataStruct;
 class AliHLTCaloClusterHeaderStruct;
 class AliHLTCaloClusterDataStruct;
-class AliPHOSGeoUtils;
+class AliHLTCaloGeometry;
 
 /** 
  * @class AliHLTCaloClusterAnalyser
@@ -54,7 +55,7 @@ class AliPHOSGeoUtils;
  * @ingroup alihlt_calo
  */
 //class AliHLTCaloClusterAnalyser : public AliHLTCaloBase
-class AliHLTCaloClusterAnalyser 
+class AliHLTCaloClusterAnalyser : public AliHLTLogging
 {
 public:
 
@@ -64,43 +65,17 @@ public:
   /** Destructor */
   virtual ~AliHLTCaloClusterAnalyser();
   
-  /** Copy constructor */
-  AliHLTCaloClusterAnalyser(const AliHLTCaloClusterAnalyser &) : 
-    //   AliHLTCaloBase(),
-    fLogWeight(0),
-    fRecPointDataPtr(0),
-    fNRecPoints(0),
-    fCaloClusterDataPtr(0),
-    fCaloClusterHeaderPtr(0),
-    fPHOSGeometry(0),
-    //fAnalyzerPtr(0),
-    fDoClusterFit(false),
-    fHaveCPVInfo(false),
-    fDoPID(false),
-    fHaveDistanceToBadChannel(false)
-    
-  {
-    //Copy constructor not implemented
-  }
-  
-  /** Assignment */
-  AliHLTCaloClusterAnalyser & operator = (const AliHLTCaloClusterAnalyser)
-    {
-      //Assignment
-      return *this; 
-    }
-  
   /**
    * Set the rec point data buffer
    * @param recPointDataPtr is a pointer to the rec points
    */
-  void SetRecPointDataPtr(AliHLTCaloRecPointHeaderStruct *recPointDataPtr);
+  void SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints);
 
   /** 
    * Set the calo cluster output buffer
    * @param caloClusterDataPtr is a pointer to the calo cluster buffer
    */
-  void SetCaloClusterDataPtr(AliHLTCaloClusterDataStruct *caloClusterDataPtr);
+  void SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr);
 
   /** 
    * Calculates the center of gravity for the reconstruction points in the container
@@ -130,7 +105,7 @@ public:
    * Convert the rec points into calo clusters
    * @return
    */
-  Int_t CreateClusters(UInt_t availableSize, UInt_t& totSize);
+  Int_t CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize);
 
   /**
    * Fit a cluster
@@ -180,13 +155,28 @@ public:
    */
   void SetHaveDistanceToBadChannel() { fHaveDistanceToBadChannel = true; }
 
+  /**
+  * Set the geometry object (different for EMCAL and PHOS)
+  */
+  void SetGeometry(AliHLTCaloGeometry *geometry) { fGeometry = geometry; }
+
+  /** 
+  * Set pointer to the digits
+  */
+  void SetDigitDataArray(AliHLTCaloDigitDataStruct *digits);
+
+  
+  void DoNothing() { printf("Do nothing\n");}
 private:
   
   /** Used for calculation of center of gravity */
   Float_t fLogWeight;                                       //COMMENT
   
   /** Pointer to the rec points */
-  AliHLTCaloRecPointDataStruct *fRecPointDataPtr;         //! transient
+  AliHLTCaloRecPointDataStruct **fRecPointArray;         //! transient
+
+  /** Pointer to the digits */
+  AliHLTCaloDigitDataStruct *fDigitDataArray;         //! transient
 
   /** Number of rec points */
   Int_t fNRecPoints;                                      //COMMENT
@@ -197,13 +187,6 @@ private:
   /** Pointer to the cluster header */
   AliHLTCaloClusterHeaderStruct *fCaloClusterHeaderPtr;   //! transient
 
-  /** Instance of the PHOS geometry */
-  AliPHOSGeoUtils *fPHOSGeometry;                           //! transient
-
-  //TODO: should not use PhysicsAnalyzer for global coord!
-  /** */
-  //  AliHLTCaloPhysicsAnalyzer *fAnalyzerPtr;                  //! transient
-
   /** Should we do cluster fitting? */
   Bool_t fDoClusterFit;                                     //COMMENT
   
@@ -216,6 +199,8 @@ private:
   /** Do we have distance to bad channel? */
   Bool_t fHaveDistanceToBadChannel;                         //COMMENT
   
+  /** The geometry object */
+  AliHLTCaloGeometry* fGeometry;                                   //COMMENT
   
 };
 
index 17c2b3b..455c435 100644 (file)
@@ -40,7 +40,13 @@ ClassImp(AliHLTCaloClusterizer);
 \r
 AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):\r
   AliHLTCaloConstantsHandler(det),\r
+  fRecPointArray(0),\r
   fRecPointDataPtr(0),\r
+  fFirstRecPointPtr(0),\r
+  fArraySize(0),\r
+  fAvailableSize(0),\r
+  fUsedSize(0),\r
+  fNRecPoints(0),\r
   fDigitIndexPtr(0),\r
   fEmcClusteringThreshold(0),\r
   fEmcMinEnergyThreshold(0),\r
@@ -57,26 +63,18 @@ AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):
   fEmcTimeGate = 1.e-6 ;\r
   \r
   fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();\r
+  \r
+  \r
+  fArraySize = 10;\r
+  fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
+  \r
+  fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;\r
+  fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);\r
+  fFirstRecPointPtr = fRecPointDataPtr;  \r
+  printf("Start of rec point data: %x, end of rec point data: %x\n", fRecPointDataPtr, reinterpret_cast<UChar_t*>(fRecPointDataPtr) + fAvailableSize);\r
 \r
 }//end\r
 \r
-\r
-//BALLE how do you set the right detector?\r
-// AliHLTCaloClusterizer::AliHLTCaloClusterizer(const AliHLTCaloClusterizer &) :\r
-//   AliHLTCaloConstantsHandler("BALLE"),\r
-//   fRecPointDataPtr(0),\r
-//   fDigitDataPtr(0),\r
-//   fEmcClusteringThreshold(0),\r
-//   fEmcMinEnergyThreshold(0),\r
-//   fEmcTimeGate(0),\r
-//   fDigitsInCluster(0),\r
-//   fDigitContainerPtr(0),\r
-//   fMaxDigitIndexDiff(0)\r
-// {\r
-//   // dummy copy constructor\r
-// }//end\r
-\r
-\r
 AliHLTCaloClusterizer::~AliHLTCaloClusterizer()  \r
 {\r
   //See header file for documentation\r
@@ -90,17 +88,14 @@ AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPoint
 }\r
 \r
 Int_t \r
-AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits, UInt_t availableSize, UInt_t& totSize)\r
+AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)\r
 {\r
   //see header file for documentation\r
   Int_t nRecPoints = 0;\r
-  \r
-  fAvailableSize = availableSize;\r
-  \r
+  fNRecPoints = 0;\r
+  fUsedSize = 0;\r
   fNDigits = nDigits;\r
-\r
-  UInt_t maxRecPointSize = sizeof(AliHLTCaloRecPointDataStruct) + (sizeof(AliHLTCaloDigitDataStruct) << 7); //Reasonable estimate... \r
-\r
+  fRecPointDataPtr = fFirstRecPointPtr;\r
   //Clusterization starts\r
   for(Int_t i = 0; i < nDigits; i++)\r
     { \r
@@ -110,13 +105,8 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits, UInt_t availableSize, UInt
        {\r
          continue;\r
        }\r
-       \r
-       if(fAvailableSize < (sizeof(AliHLTCaloRecPointDataStruct)))\r
-       {\r
-         HLTError("Out of buffer, stopping clusterisation");\r
-         return -1; \r
-       }\r
-       \r
+      CheckArray();\r
+      CheckBuffer();\r
       //            printf("cluster candidate!\n");\r
       // First digit is placed at the fDigits member variable in the recpoint\r
       fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
@@ -126,7 +116,9 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits, UInt_t availableSize, UInt
 \r
       // Assigning the digit to this rec point\r
       fRecPointDataPtr->fDigits = i;\r
-\r
+      printf("Clusterizier: adding digit:  index pointer: %x, index: %d\n", fDigitIndexPtr, *fDigitIndexPtr);\r
+      fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
+      \r
       // Incrementing the pointer to be ready for new entry\r
       fDigitIndexPtr++;\r
 \r
@@ -141,13 +133,17 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits, UInt_t availableSize, UInt
         return -1;\r
       }\r
 \r
-      totSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);   \r
+      //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);   \r
+      \r
       fRecPointDataPtr->fMultiplicity = fDigitsInCluster;     \r
-      //      printf("Rec point energy: %f\n", fRecPointDataPtr->fAmp);\r
+      printf("Rec point energy: %f\n", fRecPointDataPtr->fAmp);\r
+      printf("Multiplicity: %d\n", fDigitsInCluster);\r
+      fRecPointArray[fNRecPoints] = fRecPointDataPtr; \r
+      \r
       fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
-\r
+      \r
     }//end of clusterization\r
-\r
+   fNRecPoints = nRecPoints;\r
    return nRecPoints;\r
 }\r
 \r
@@ -169,13 +165,25 @@ AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDat
              if(AreNeighbours(fDigitsPointerArray[index],\r
                               fDigitsPointerArray[j]))\r
                {\r
-                 if(fAvailableSize < (sizeof(Int_t)))\r
-                    {\r
-                       HLTError("Out of buffer, stopping clusterisation");\r
-                       return -1; \r
-                    }  \r
+//               if((fAvailableSize - fUsedSize) < sizeof(Int_t))\r
+//                  {\r
+//                     UChar_t *tmp = new UChar_t[fAvailableSize*2];\r
+//                     memcpy(tmp, fRecPointDataPtr, fAvailableSize);\r
+//                     for(Int_t n = 0; n < fNRecPoints; n++)\r
+//                     {\r
+//                        fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));\r
+//                     }\r
+//                     fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
+//                     fFirstRecPointPtr = fRecPointDataPtr;\r
+//                     fUsedSize = 0;\r
+//                  }  \r
+                 CheckBuffer();\r
                  // Assigning index to digit\r
+                 printf("Digit index pointer: %x\n", fDigitIndexPtr);\r
                  *fDigitIndexPtr = j;\r
+                 fUsedSize += sizeof(Int_t);\r
+                 \r
+                 printf("Clusterizier: adding digit:  index pointer: %x, index: %d\n", fDigitIndexPtr, *fDigitIndexPtr); \r
                  // Incrementing digit pointer to be ready for new entry\r
                  fDigitIndexPtr++;\r
 \r
@@ -197,20 +205,20 @@ AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,
   //see header file for documentation\r
   if ( (digit1->fModule == digit2->fModule) /*&& (coord1[1]==coord2[1])*/ ) // inside the same PHOS module\r
     { \r
-//       Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );  \r
-//       Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX ); \r
-//       if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))\r
-//     {\r
-//       cout << "Are neighbours: digit (E = "  << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ << \r
-//         " is neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;\r
-\r
-//       if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
-//         {\r
-//           return 1; \r
-//         }\r
-//     }\r
-\r
-      Float_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );  \r
+      Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );  \r
+      Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX ); \r
+      if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))\r
+       {\r
+//       cout << "Are neighbours: digit (E = "  << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ << \r
+//         " is neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;\r
+\r
+         if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
+           {\r
+             return 1; \r
+           }\r
+       }\r
+\r
+   /*   Float_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );  \r
       Float_t coldiff = TMath::Abs( digit1->fX - digit2->fX ); \r
       if (( coldiff <= 2.4   &&  rowdiff < 0.4 ) || ( coldiff < 0.4 &&  rowdiff <= 2.4 ))\r
        {\r
@@ -222,11 +230,141 @@ AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,
              return 1; \r
            }\r
        }\r
+   */\r
       else\r
        {\r
-         //  cout << "Not neighbours: digit (E = "  << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ << \r
-         //  " is not neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;\r
+//         cout << "Not neighbours: digit (E = "  << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ << \r
+//         " is not neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;\r
        }\r
     }\r
   return 0;\r
 }\r
+\r
+\r
+\r
+Int_t AliHLTCaloClusterizer::CheckArray()\r
+{\r
+      printf("CheckArray: fArraySize: %d, fNRecPoints: %d\n", fArraySize, fNRecPoints);\r
+      if(fArraySize == fNRecPoints)\r
+       {\r
+          printf("Expanding array...");\r
+          fArraySize *= 2;\r
+          AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
+          memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));\r
+          delete fRecPointArray;\r
+          fRecPointArray = tmp;\r
+       }\r
+   return 0;\r
+}\r
+\r
+Int_t AliHLTCaloClusterizer::CheckBuffer()\r
+{\r
+   // See header file for class documentation \r
+        printf("CheckBuffer: Used size %d, fAvailableSize: %d\n", fUsedSize, fAvailableSize);\r
+       if((fAvailableSize - fUsedSize) < sizeof(AliHLTCaloRecPointDataStruct) )\r
+       {\r
+          printf("Expanding buffer...\n");\r
+           Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);\r
+           fAvailableSize *= 2;\r
+           UChar_t *tmp = new UChar_t[fAvailableSize];\r
+           memcpy(tmp, fRecPointDataPtr, fAvailableSize/2);\r
+           for(Int_t n = 0; n < fNRecPoints; n++)\r
+           {\r
+              fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));\r
+           }\r
+           delete fRecPointDataPtr;\r
+           fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
+           fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);\r
+           fUsedSize = 0;\r
+       }\r
+   return 0;\r
+}\r
+\r
+Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray, AliHLTCaloDigitDataStruct** digitArray, Int_t nRP)\r
+{\r
+  AliHLTCaloRecPointDataStruct **recpoints = recArray;\r
+  AliHLTCaloDigitDataStruct **digits = digitArray;\r
+  Int_t nRecPoints = nRP;\r
+  \r
+  if(recArray == 0)\r
+  {\r
+     recpoints = fRecPointArray;\r
+  }\r
+  if(digitArray == 0)\r
+  {\r
+     digits = fDigitsPointerArray;\r
+  }\r
+  if(nRP == 0)\r
+  {\r
+     nRecPoints = fNRecPoints;\r
+  }\r
+  printf("CL: CheckDigits: Number of rec points: %d\n", nRecPoints);\r
+  for(Int_t i = 0; i < nRecPoints; i++)\r
+  {\r
+          \r
+     AliHLTCaloRecPointDataStruct *recPoint = recpoints[i];\r
+\r
+     //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];\r
+     Int_t multiplicity = recPoint->fMultiplicity;\r
+     Int_t *digitIndexPtr = &(recPoint->fDigits);\r
+     printf("CL: Rec point with energy: %f, multiplicity: %d\n", recPoint->fAmp, recPoint->fMultiplicity);\r
+     for(Int_t j = 0; j < multiplicity; j++)\r
+     {\r
+       //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];\r
+       AliHLTCaloDigitDataStruct *digit = digits[*digitIndexPtr];\r
+       printf("CL: Digit ID: %d, energy: %f, index: %d, indexpointer: %x\n", digit->fID, digit->fEnergy, *digitIndexPtr, digitIndexPtr);\r
+       digitIndexPtr++;\r
+       //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);\r
+     }\r
+  }\r
+     \r
+     \r
+     \r
+     \r
+     \r
+     \r
+     \r
+}\r
+\r
+Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray, AliHLTCaloDigitDataStruct* digitArray, Int_t nRP)\r
+{\r
+  AliHLTCaloRecPointDataStruct **recpoints = recArray;\r
+  AliHLTCaloDigitDataStruct *digits = digitArray;\r
+  Int_t nRecPoints = nRP;\r
+  \r
+  if(recArray == 0)\r
+  {\r
+     recpoints = fRecPointArray;\r
+  }\r
+    if(nRP == 0)\r
+  {\r
+     nRecPoints = fNRecPoints;\r
+  }\r
+  printf("CL: CheckDigits: Number of rec points: %d\n", nRecPoints);\r
+  for(Int_t i = 0; i < nRecPoints; i++)\r
+  {\r
+          \r
+     AliHLTCaloRecPointDataStruct *recPoint = recpoints[i];\r
+\r
+     //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];\r
+     Int_t multiplicity = recPoint->fMultiplicity;\r
+     Int_t *digitIndexPtr = &(recPoint->fDigits);\r
+     printf("CL: Rec point with energy: %f, multiplicity: %d\n", recPoint->fAmp, recPoint->fMultiplicity);\r
+     for(Int_t j = 0; j < multiplicity; j++)\r
+     {\r
+       //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];\r
+       AliHLTCaloDigitDataStruct digit = digits[*digitIndexPtr];\r
+       printf("CL: digits: %x, recpoints: %x, digitIndexPtr: %x\n", digits, recpoints, digitIndexPtr);\r
+       printf("CL: Digit ID: %d, energy: %f, index: %d, indexpointer: %x\n", digit.fID, digit.fEnergy, *digitIndexPtr, digitIndexPtr);\r
+       digitIndexPtr++;\r
+       //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);\r
+     }\r
+  }\r
+     \r
+     \r
+     \r
+     \r
+     \r
+     \r
+     \r
+}
\ No newline at end of file
index d71996d..ebfb0c5 100644 (file)
@@ -99,7 +99,7 @@ public:
   void SetEmcTimeGate(Float_t gate) { fEmcTimeGate = gate; }\r
   \r
   /** Starts clusterization of the event */ \r
-  virtual Int_t ClusterizeEvent(Int_t nDigits, UInt_t availableSize, UInt_t& totSize);\r
+  virtual Int_t ClusterizeEvent(Int_t nDigits);\r
   \r
   /**\r
    * For a given digit this digit scans for neighbouring digits which \r
@@ -117,12 +117,48 @@ public:
    */\r
   virtual Int_t AreNeighbours(AliHLTCaloDigitDataStruct* d1, AliHLTCaloDigitDataStruct* d2);\r
 \r
+  /**\r
+  * Get pointer to the rec points array\r
+  */\r
+  AliHLTCaloRecPointDataStruct** GetRecPoints() const { return fRecPointArray; }\r
+\r
+  Int_t CheckDigits(AliHLTCaloRecPointDataStruct **recArray = 0, AliHLTCaloDigitDataStruct **digArray = 0, Int_t nRP = 0);\r
+\r
+  Int_t CheckDigits(AliHLTCaloRecPointDataStruct **recArray, AliHLTCaloDigitDataStruct *digArray, Int_t nRP = 0);\r
 \r
 protected:\r
 \r
-  /** Pointer to the rec point output */\r
-  AliHLTCaloRecPointDataStruct *fRecPointDataPtr;              //! transient\r
+   /** \r
+   * Check the rec point buffer size and resize the buffer if necessary\r
+   */\r
+  virtual Int_t CheckBuffer(); //COMMENT\r
+  \r
+   /** \r
+   * Check the rec point array size and resize the array if necessary\r
+   */\r
+  virtual Int_t CheckArray(); //COMMENT\r
+\r
+  /** Array of pointers to the rec point output */\r
+  AliHLTCaloRecPointDataStruct **fRecPointArray; //COMMENT\r
 \r
+   /** Pointer to the rec point output */\r
+  AliHLTCaloRecPointDataStruct *fRecPointDataPtr; //COMMENT\r
+\r
+  /** The first rec point in the list */\r
+  AliHLTCaloRecPointDataStruct *fFirstRecPointPtr; //COMMENT\r
+\r
+  /** Size of the rec point array */\r
+  Int_t fArraySize;\r
+  \r
+  /** Available size for the rec point output */\r
+  Int_t fAvailableSize;\r
+\r
+  /** The used size for the rec point output */\r
+  Int_t fUsedSize;\r
+  \r
+  /** Number of rec points created so far */\r
+  Int_t fNRecPoints;\r
+  \r
   /** Pointer to the digit index array in the rec point */\r
   Int_t* fDigitIndexPtr;                                       //! transient\r
 \r
@@ -151,18 +187,15 @@ protected:
   Int_t fNDigits;                                              //COMMENT\r
 \r
 private:\r
-   \r
-   /** Size of the available write buffer */\r
-  UInt_t fAvailableSize;                                 //COMMENT\r
 \r
   /** Default constructor, prohibited */\r
-  AliHLTCaloClusterizer();                          // COMMENT\r
+  //AliHLTCaloClusterizer();                          // COMMENT\r
   \r
   /** Copy constructor, prohibited */\r
-  AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
+  //AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
   \r
   /** Assignment operator, prohibited */\r
-  AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
+  //AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
 \r
   ClassDef(AliHLTCaloClusterizer, 0);\r
 \r
index 2b68cc2..6285be9 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-#include <iostream>
-
 #include "AliHLTCaloClusterizerComponent.h"
 #include "AliHLTCaloClusterizer.h"
+#include "AliHLTCaloClusterAnalyser.h" 
 #include "AliHLTCaloRecPointDataStruct.h"
 #include "AliHLTCaloRecPointHeaderStruct.h"
 #include "AliHLTCaloDigitDataStruct.h"
 #include "AliHLTCaloDigitContainerDataStruct.h"
 #include "AliHLTCaloDefinitions.h"
+#include "AliHLTCaloClusterDataStruct.h"
 #include "TString.h"
 
 /** @file   AliHLTCaloClusterizerComponent.cxx
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-
 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det): 
   AliHLTCaloProcessor(),
   AliHLTCaloConstantsHandler(det),
   fDigitsPointerArray(0), 
   fClusterizerPtr(0),
+  fAnalyserPtr(0),
   fDigitCount(0)
-
 {
   //See headerfile for documentation
 
@@ -53,7 +52,9 @@ AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
   fClusterizerPtr = new AliHLTCaloClusterizer(det);
 
   fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
-
+   
+  fAnalyserPtr = new AliHLTCaloClusterAnalyser();
+  
 }
 
 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
@@ -121,7 +122,7 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   Int_t nDigits           = 0;
   Int_t digCount          = 0;
 
-  //UInt_t availableSize = size;
+  UInt_t availableSize = size;
   AliHLTUInt8_t* outBPtr;
   outBPtr = outputPtr;
   const AliHLTComponentBlockData* iter = 0;
@@ -130,74 +131,89 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   UInt_t specification = 0;
   
   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
-
+  
+//   delete fAnalyserPtr;
+//   fAnalyserPtr  = new AliHLTCaloClusterAnalyser();
+//   
   // Adding together all the digits, should be put in standalone method  
   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
       iter = blocks+ndx;
       //            HLTError("Got block");
-      if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginPHOS))
+      if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
        {
-         // Get the digit header
 
+//       fDigitsPointerArray[digCount] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
+         
+         //cout << "Digits pointer array [" << digCount << "]: " << fDigitsPointerArray[digCount] << endl;
          // Update the number of digits
          nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
+//       digCount += nDigits;
          //      HLTError("Got %d digits", nDigits);
-
+         
+         availableSize -= iter->fSize;
+         
          specification = specification|iter->fSpecification;
 
-         digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
-         for (Int_t i = 0; i < nDigits; i++)
-           {
-             fDigitsPointerArray[digCount] = digitDataPtr;
-             digCount++;
-             digitDataPtr++;
-           }
-
+         digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
+         for (Int_t i = 0; i < nDigits; i++)
+           {
+             fDigitsPointerArray[digCount] = digitDataPtr;
+             digCount++;
+             digitDataPtr++;
+           }
        }
     }
 
   if(digCount > 0)
     {
-  
+       
+      AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
+      caloClusterHeaderPtr->fNDigits = digCount;
+      
       // Sort the digit pointers
       qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
 
       // Copy the digits to the output
+      fOutputDigitsArray = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
       for(Int_t n = 0; n < digCount; n++)
        {
          memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
+         //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
          outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
+         printf("CL: digit energy: %f, ID: %d\n", fOutputDigitsArray[n].fEnergy, fOutputDigitsArray[n].fID);
        }
   
-      mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
-
-      AliHLTComponentBlockData bdDigits;
-      FillBlockData( bdDigits );
-      bdDigits.fOffset = offset;
-      bdDigits.fSize = mysize;
-      bdDigits.fDataType = iter->fDataType;
-      bdDigits.fSpecification = specification;
-      outputBlocks.push_back( bdDigits );
-  
+       mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
 
-      AliHLTCaloRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTCaloRecPointHeaderStruct*>(outBPtr);
+//       AliHLTComponentBlockData bdDigits;
+//       FillBlockData( bdDigits );
+//       bdDigits.fOffset = offset;
+//       bdDigits.fSize = mysize;
+//       bdDigits.fDataType = iter->fDataType;
+//       bdDigits.fSpecification = specification;
+//       outputBlocks.push_back( bdDigits );
 
-      fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTCaloRecPointDataStruct*>(outBPtr+sizeof(AliHLTCaloRecPointHeaderStruct)));
-  
-      //  HLTError("Total number of digits: %d", digCount );
+      //HLTDebug("Total number of digits: %d", digCount );
 
-      printf("Total number of digits: %d\n", digCount);
+      nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
+      //fClusterizerPtr->CheckDigits();
+      //HLTDebug("Number of rec points found: %d", nRecPoints);
 
-      nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount, size, mysize);
+      fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr + sizeof(AliHLTCaloClusterHeaderStruct)));
+      
+      //fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
 
-      if(nRecPoints == -1)
-       {
-         //      HLTError("Running out of buffer, exiting for safety.");
-         return -ENOBUFS;
-       }
+      fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
 
-      recPointHeaderPtr->fNRecPoints = nRecPoints;
+      //fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
+
+      fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
+
+      fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
+
+      fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
+      
       mysize += sizeof(AliHLTCaloRecPointHeaderStruct);
   
       //  HLTError("Number of clusters: %d", nRecPoints);
@@ -206,7 +222,7 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
       FillBlockData( bd );
       bd.fOffset = offset;
       bd.fSize = mysize;
-      bd.fDataType = AliHLTCaloDefinitions::fgkClusterDataType;
+      bd.fDataType = AliHLTCaloDefinitions::fgkClusterDataType|fDataOrigin;
       bd.fSpecification = specification;
       outputBlocks.push_back( bd );
     }
@@ -282,4 +298,6 @@ AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1
 {
   // See header file for documentation
   return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
+
+  //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 }
index af58ebd..aa370a5 100644 (file)
@@ -44,6 +44,7 @@
 class AliHLTCaloDigitDataStruct;
 class AliHLTCaloDigitContainerDataStruct;
 class AliHLTCaloClusterizer;
+class AliHLTCaloClusterAnalyser;
 class AliHLTCaloRecPointDataStruct;
 
 /**
@@ -116,24 +117,6 @@ class AliHLTCaloClusterizerComponent : public AliHLTCaloProcessor, public AliHLT
     /** Destructor */
     virtual ~AliHLTCaloClusterizerComponent();
 
-//     /** Copy constructor */
-//     AliHLTCaloClusterizerComponent ( const AliHLTCaloClusterizerComponent & ) :
-//         AliHLTPHOSProcessor(),
-//         fAllDigitsPtr ( 0 ),
-//         fClusterizerPtr ( 0 ),
-//         //    fRecPointStructArrayPtr(0),
-//         fDigitCount ( 0 )
-//     {
-//       //Copy constructor not implemented
-//     }
-
-//     /** Assignment */
-//     AliHLTCaloClusterizerComponent & operator = ( const AliHLTCaloClusterizerComponent )
-//     {
-//       //Assignment
-//       return *this;
-//     }
-
 //     /** interface function, see @ref AliHLTComponent for description */
 //     void GetInputDataTypes ( std::vector<AliHLTComponentDataType>& list );
 
@@ -170,18 +153,27 @@ class AliHLTCaloClusterizerComponent : public AliHLTCaloProcessor, public AliHLT
 
     /** interface function, see @ref AliHLTComponent for description */
     int ScanConfigurationArgument ( int argc, const char** argv );
+    
+     /** The data origin */
+    char* fDataOrigin;                           //COMMENT
 
+    /** Pointer to the cluster analyser */
+    AliHLTCaloClusterAnalyser *fAnalyserPtr;                         //! transient
+    
   private:
 
     /** Array of pointers to our digits */
     AliHLTCaloDigitDataStruct **fDigitsPointerArray;              //! transient
-
+    
+    /** Array of pointers to our digits */
+    AliHLTCaloDigitDataStruct *fOutputDigitsArray;              //! transient
+    
     /** Pointer to the clusterizer it self */
     AliHLTCaloClusterizer* fClusterizerPtr;                       //! transient
 
     /** Number of digits in event */
     Int_t fDigitCount;                                            //COMMENT
-
+    
     /** Default constructor, not implemented */
     AliHLTCaloClusterizerComponent();                             //COMMENT
 
index 46f5416..6c6ae15 100644 (file)
@@ -235,12 +235,14 @@ void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, Al
   \r
   fChannelBook[coord.fX][coord.fZ] = fDigitStructPtr;\r
 \r
-  fDigitStructPtr->fID = fDigitStructPtr->fZ * fCaloConstants->GetNXCOLUMNSMOD() + fDigitStructPtr->fX;\r
-\r
\r
   fDigitStructPtr->fX = coord.fX;\r
   fDigitStructPtr->fZ = coord.fZ;\r
   fDigitStructPtr->fGain = coord.fGain;\r
   fDigitStructPtr->fOverflow = false;\r
+  \r
+  fDigitStructPtr->fID = fDigitStructPtr->fZ * fCaloConstants->GetNXCOLUMNSMOD() + fDigitStructPtr->fX;\r
+\r
   if(coord.fGain == fCaloConstants->GetHIGHGAIN() )\r
     {\r
       fDigitStructPtr->fEnergy = channelData->fEnergy*fHighGainFactors[coord.fX][coord.fZ];\r
@@ -270,7 +272,7 @@ void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, Al
 bool AliHLTCaloDigitMaker::UseDigit(AliHLTCaloCoordinate &channelCoordinates, AliHLTCaloChannelDataStruct *channel) \r
 {\r
   AliHLTCaloDigitDataStruct *tmpDigit = fChannelBook[channelCoordinates.fX][channelCoordinates.fZ];\r
-  //  printf("UseDigit: Got digit, x: %d, z: %d, gain: %d, amp: %f\n", channelCoordinates.fX, channelCoordinates.fZ, channelCoordinates.fGain, channel->fEnergy);\r
+  //printf("UseDigit: Got digit, x: %d, z: %d, gain: %d, amp: %f\n", channelCoordinates.fX, channelCoordinates.fZ, channelCoordinates.fGain, channel->fEnergy);\r
   if(tmpDigit)\r
     {\r
       if(channelCoordinates.fGain == fCaloConstants->GetLOWGAIN())\r
index c4c6afb..2b05b63 100644 (file)
@@ -19,6 +19,8 @@
 #include "AliHLTPHOSClusterizerComponent.h"
 #include "AliHLTCaloRecPointDataStruct.h"
 #include "AliHLTCaloRecPointHeaderStruct.h"
+#include "AliHLTPHOSGeometry.h"
+#include "AliHLTCaloClusterAnalyser.h"
 
 
 
@@ -34,7 +36,8 @@
 // refer to README to build package
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-#include <AliHLTCaloDefinitions.h>
+#include "AliHLTCaloDefinitions.h"
+#include "AliHLTPHOSGeometry.h"
 
 AliHLTPHOSClusterizerComponent gAliHLTPHOSClusterizerComponent;
 
@@ -42,6 +45,13 @@ AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent():
   AliHLTCaloClusterizerComponent("PHOS")
 {
   //See headerfile for documentation
+
+  fDataOrigin = const_cast<char*>(kAliHLTDataOriginPHOS);
+
+  AliHLTPHOSGeometry *geom = new AliHLTPHOSGeometry;
+  
+  fAnalyserPtr->SetGeometry(new AliHLTPHOSGeometry);
+  
 }
 
 AliHLTPHOSClusterizerComponent::~AliHLTPHOSClusterizerComponent()
@@ -88,5 +98,3 @@ AliHLTPHOSClusterizerComponent::Spawn()
 
   return new AliHLTPHOSClusterizerComponent();
 }
-
-
index 2d2f591..73528f0 100644 (file)
@@ -135,7 +135,9 @@ class AliHLTPHOSClusterizerComponent : public AliHLTCaloClusterizerComponent
   AliHLTComponent* Spawn();
 
 protected:
+   virtual int DoInit() {return 0; }
   virtual int DoDeinit(){ return 0;}
+  virtual int Deinit() {return 0; }
 
 private:
   
index 694a3fd..f65dd2b 100644 (file)
@@ -30,8 +30,8 @@ void rec_hlt_phos()//, char* opt="decoder ESD")
   //
   int moduleStart = 2;
   int moduleEnd = 2;
-  int rcuStart = 0;
-  int rcuEnd = 3;
+  int rcuStart = 2;
+  int rcuEnd = 2;
   //  TString option="libAliHLTUtil.so libAliHLTRCU.so libAliHLTPHOS.so libAliHLTGlobal.so loglevel=0x7f chains=ESD-FILE";
   //TString option="libAliHLTUtil.so libAliHLTRCU.so libAliHLTPHOS.so libAliHLTGlobal.so loglevel=0x7f chains=PHS-CA_02";
   TString option="libAliHLTUtil.so libAliHLTRCU.so libAliHLTCalo.so libAliHLTPHOS.so libAliHLTGlobal.so loglevel=0x7f chains=PHS-CL_02";
index 9e31ee1..9945b97 100644 (file)
@@ -21,7 +21,9 @@ AliHLTCaloClusterizerComponent.h \
 AliHLTCaloDigitMaker.h \
 AliHLTCaloClusterAnalyser.h \
 AliHLTCaloRcuProcessor.h \
-AliHLTCaloProcessor.h 
+AliHLTCaloConstants.h \
+AliHLTCaloProcessor.h \
+AliHLTCaloGeometry.h
 
 ## all source files of this module
 ## all source files corresponding to the class headers
index 54c6e3b..b8cfc2f 100644 (file)
@@ -32,7 +32,9 @@ CLASS_HDRS:=  AliHLTPHOSClusterizerComponent.h \
                  AliHLTPHOSMonitorTriggerComponent.h \
                  AliHLTPHOSESDEntriesMakerComponent.h \
                  AliHLTPHOSESDCaloClusterWriterComponent.h \
-                 AliHLTPHOSDigitReader.h
+                 AliHLTPHOSDigitReader.h \
+                 AliHLTPHOSConstants.h \
+                 AliHLTPHOSGeometry.h
 
 MODULE_SRCS:=    $(CLASS_HDRS:.h=.cxx)