- adding use of associated cluster for digits
authorodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Jun 2010 11:28:31 +0000 (11:28 +0000)
committerodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 Jun 2010 11:28:31 +0000 (11:28 +0000)
- the energy of used digits are no longer set to 0

HLT/CALO/AliHLTCaloClusterAnalyser.cxx
HLT/CALO/AliHLTCaloClusterAnalyser.h
HLT/CALO/AliHLTCaloClusterizer.cxx
HLT/CALO/AliHLTCaloClusterizerComponent.cxx
HLT/CALO/AliHLTCaloClusterizerComponent.h
HLT/CALO/AliHLTCaloDigitMaker.cxx

index f0ab614..9122850 100644 (file)
@@ -85,7 +85,7 @@ AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPo
 }
 
 void 
-AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct *digits) 
+AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct **digits) 
 { 
 //   AliHLTCaloClusterizer cl("PHOS");
   // cl.CheckDigits(fRecPointArray, digits, fNRecPoints);
@@ -123,7 +123,7 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
       for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
        {
 
-         digit = &(fDigitDataArray[*digitIndexPtr]);
+         digit = fDigitDataArray[*digitIndexPtr];
 
          xi = digit->fX+0.5;
          zi = digit->fZ+0.5;
@@ -249,8 +249,8 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
       caloClusterPtr->fGlobalPos[1] =  globalCoord.fY;
       caloClusterPtr->fGlobalPos[2] =  globalCoord.fZ;
 
-      HLTDebug("Cluster local position: x = %f, z = %f, module = %d", recPointPtr->fX, recPointPtr->fZ, recPointPtr->fModule);
-      HLTDebug("Cluster global position: x = %f, y = %f, z = %f", globalCoord.fX, globalCoord.fY, globalCoord.fZ);
+      HLTError("Cluster local position: x = %f, z = %f, module = %d", recPointPtr->fX, recPointPtr->fZ, recPointPtr->fModule);
+      HLTError("Cluster global position: x = %f, y = %f, z = %f", globalCoord.fX, globalCoord.fY, globalCoord.fZ);
       
       //caloClusterPtr->fNCells = 0;//recPointPtr->fMultiplicity;
       caloClusterPtr->fNCells = recPointPtr->fMultiplicity;
@@ -277,7 +277,7 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
        
       for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
        {
-          digitPtr = &(fDigitDataArray[*digitIndexPtr]);
+          digitPtr = fDigitDataArray[*digitIndexPtr];
           fGeometry->GetCellAbsId(recPointPtr->fModule, digitPtr->fX, digitPtr->fZ, id);
           
          cellPtr->fCellsAbsId= id;
index e5f0ba3..bd7eb0b 100644 (file)
@@ -167,7 +167,7 @@ public:
   /** 
   * Set pointer to the digits
   */
-  void SetDigitDataArray(AliHLTCaloDigitDataStruct *digits);
+  void SetDigitDataArray(AliHLTCaloDigitDataStruct **digits);
 
   /**
   * Set the cluster type 
@@ -192,7 +192,7 @@ private:
   AliHLTCaloRecPointDataStruct **fRecPointArray;         //! transient
 
   /** Pointer to the digits */
-  AliHLTCaloDigitDataStruct *fDigitDataArray;         //! transient
+  AliHLTCaloDigitDataStruct **fDigitDataArray;         //! transient
 
   /** Number of rec points */
   Int_t fNRecPoints;                                      //COMMENT
index 882aa3d..0b142a4 100644 (file)
@@ -111,12 +111,21 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
     {\r
         fDigitsInCluster = 0;\r
 \r
-        if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold)\r
+        HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);\r
+       \r
+        if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)\r
         {\r
-            continue;\r
-        }\r
+          // Since we have sorted by energy the next digit will have even lower energy, so we return \r
+          return fNRecPoints;\r
+       }\r
+\r
+       if(fDigitsPointerArray[i]->fAssociatedCluster != -1)\r
+       {\r
+          // The digit is added to a previous cluster, continue\r
+          continue;\r
+       }\r
 \r
-        CheckArray();\r
+       CheckArray();\r
         CheckBuffer();\r
 \r
         // First digit is placed at the fDigits member variable in the recpoint\r
@@ -133,8 +142,13 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
         fDigitIndexPtr++;\r
 \r
         fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;\r
-        fDigitsPointerArray[i]->fEnergy = 0;\r
-        fDigitsInCluster++;\r
+    \r
+       \r
+       //fDigitsPointerArray[i]->fEnergy = 0;\r
+        fDigitsPointerArray[i]->fAssociatedCluster = fNRecPoints;\r
+       \r
+       \r
+       fDigitsInCluster++;\r
         nRecPoints++;\r
 \r
         // Scanning for the neighbours\r
@@ -172,7 +186,7 @@ AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDat
 \r
     for (Int_t j = min; j < max; j++)\r
     {\r
-        if (fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
+        if (fDigitsPointerArray[j]->fAssociatedCluster == -1 &&  fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
         {\r
             if (j != index)\r
             {\r
@@ -192,9 +206,14 @@ AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDat
                     // Adding the digit energy to the rec point\r
                     fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;\r
 \r
-                    // Setting the digit energy to 0 (not included in clusterisation anymore)\r
-                    fDigitsPointerArray[j]->fEnergy = 0;\r
-\r
+                    // Setting energy to 0\r
+                   //fDigitsPointerArray[j]->fEnergy = 0;\r
+                   \r
+                   // Setting the associated cluster \r
+                   fDigitsPointerArray[j]->fAssociatedCluster = fNRecPoints;\r
+                   \r
+                   HLTDebug("Added digit with index: %d, energy: %f, to associated cluster: %d", fDigitsPointerArray[j]->fID, fDigitsPointerArray[j]->fEnergy, fDigitsPointerArray[j]->fAssociatedCluster);\r
+                   \r
                     fDigitsInCluster++;\r
 \r
                     // Scan for neighbours of this digit\r
index 139062b..794cf49 100644 (file)
@@ -16,7 +16,7 @@
 
 #include "AliHLTCaloClusterizerComponent.h"
 #include "AliHLTCaloClusterizer.h"
-#include "AliHLTCaloClusterAnalyser.h" 
+#include "AliHLTCaloClusterAnalyser.h"
 #include "AliHLTCaloRecPointDataStruct.h"
 #include "AliHLTCaloRecPointHeaderStruct.h"
 #include "AliHLTCaloDigitDataStruct.h"
@@ -28,7 +28,7 @@
 
 /** @file   AliHLTCaloClusterizerComponent.cxx
     @author Oystein Djuvsland
-    @date   
+    @date
     @brief  A clusterizer component for PHOS HLT
 */
 
 
 ClassImp(AliHLTCaloClusterizerComponent);
 
-AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det): 
-  AliHLTCaloProcessor(),
-  AliHLTCaloConstantsHandler(det),
-  fDataOrigin('\0'),
-  fAnalyserPtr(0),
-  fRecoParamsPtr(0),
-  fDigitsPointerArray(0), 
-  fOutputDigitsArray(0),
-  fClusterizerPtr(0),
-  fDigitCount(0)
+AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
+        AliHLTCaloProcessor(),
+        AliHLTCaloConstantsHandler(det),
+        fDataOrigin('\0'),
+        fAnalyserPtr(0),
+        fRecoParamsPtr(0),
+        fDigitsPointerArray(0),
+        fOutputDigitsArray(0),
+        fClusterizerPtr(0),
+        fDigitCount(0),
+        fCopyDigitsToOuput(kTRUE)
 {
-  //See headerfile for documentation
-  
-  
+    //See headerfile for documentation
+
+
+
 }
 
 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
 {
-  //See headerfile for documentation
-delete fAnalyserPtr;
-  if(fClusterizerPtr)
+    //See headerfile for documentation
+    delete fAnalyserPtr;
+    if (fClusterizerPtr)
     {
-      delete fClusterizerPtr;
-      fClusterizerPtr = 0;
+        delete fClusterizerPtr;
+        fClusterizerPtr = 0;
     }
 }
 
@@ -73,253 +74,258 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
 {
-  //See headerfile for documentation
-
-  if(blocks == 0) return 0;
-  
-  UInt_t offset           = 0;
-  UInt_t mysize           = 0;
-  Int_t nRecPoints        = 0;
-  Int_t nDigits           = 0;
-  Int_t digCount          = 0;
-
-  UInt_t availableSize = size;
-  AliHLTUInt8_t* outBPtr;
-  outBPtr = outputPtr;
-  const AliHLTComponentBlockData* iter = 0;
-  unsigned long ndx;
-  
-  UInt_t specification = 0;
-  
-  AliHLTCaloDigitDataStruct *digitDataPtr = 0;
-
-  // Adding together all the digits, should be put in standalone method  
-  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+    //See headerfile for documentation
+
+    if (blocks == 0) return 0;
+
+    UInt_t offset           = 0;
+    UInt_t mysize           = 0;
+    Int_t nRecPoints        = 0;
+    Int_t nDigits           = 0;
+    Int_t digCount          = 0;
+
+    UInt_t availableSize = size;
+    AliHLTUInt8_t* outBPtr;
+    outBPtr = outputPtr;
+    const AliHLTComponentBlockData* iter = 0;
+    unsigned long ndx;
+
+    UInt_t specification = 0;
+
+    AliHLTCaloDigitDataStruct *digitDataPtr = 0;
+
+    // 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|fDataOrigin))
-       {
-
-          // Update the number of digits
-         nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);
-         availableSize -= iter->fSize;
-         
-         specification = specification|iter->fSpecification;
-
-         digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
-         
-         // We copy the digits to the digit buffer used by the clusterizer
-         // This is convinient since we want the digits from all DDLs before starting
-         // Could be changed if this is a bottle neck. 
-         for (Int_t i = 0; i < nDigits; i++)
-           {
-             fDigitsPointerArray[digCount] = digitDataPtr;
-             digCount++;
-             digitDataPtr++;
-           }
-       }
+        iter = blocks+ndx;
+
+       if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
+        {
+
+            // Update the number of digits
+            nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);
+            availableSize -= iter->fSize;
+
+            specification = specification|iter->fSpecification;
+
+            digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
+
+            // We copy the digits to the digit buffer used by the clusterizer
+            // This is convinient since we want the digits from all DDLs before starting
+            // Could be changed if this is a bottle neck.
+            for (Int_t i = 0; i < nDigits; i++)
+            {
+                fDigitsPointerArray[digCount] = digitDataPtr;
+                digCount++;
+                digitDataPtr++;
+            }
+        }
     }
 
-  if(digCount > 0)
+    if (digCount > 0)
     {
-       
-      AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
-      caloClusterHeaderPtr->fNDigits = digCount;
-      
-      outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
-      mysize += sizeof(AliHLTCaloClusterHeaderStruct);
-      
-      // Sort the digit pointers
+
+        AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
+        caloClusterHeaderPtr->fNDigits = digCount;
+
+        outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
+        mysize += sizeof(AliHLTCaloClusterHeaderStruct);
+
+        // Sort the digit pointers
 //      qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
 
-      // Copy the digits to the output
-      // If we don't want the digits in the output we currently need to copy them to another buffer
-      // The reason is that the clusterizer sets the energy of the digits in the input buffer to 0,
-      // but we want to use the digits in the cluster analyser. 
-      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);
-       }
-      
-      // Update the size of the output we have used, needs to be removed if we don't push the digits 
-      mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
-
-      // Do the clusterisation
-      nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
-
-      // Give the cluster output to the analyser
-      fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
-      
-      // Give the rec points to the analyser (input)
-      fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
-
-      // Give the digits to the analyser 
-      fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
-      
-      // Then we create the clusters
-      Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
-      
-      if (nClusters < 0) 
-       {
-          HLTError("Error in clusterisation");
-         caloClusterHeaderPtr->fNClusters = 0;
-       } 
-      else 
-       {
-         caloClusterHeaderPtr->fNClusters = nClusters;
-       }
-     
-      HLTDebug("Number of clusters: %d", nRecPoints);
-      
-      AliHLTComponentBlockData bd;
-      FillBlockData( bd );
-      bd.fOffset = offset;
-      bd.fSize = mysize;
-      bd.fDataType = kAliHLTDataTypeCaloCluster | fDataOrigin;
-      bd.fSpecification = specification;
-      outputBlocks.push_back( bd );
+
+        if (fCopyDigitsToOuput)
+        {
+            // 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);
+            }
+        }
+        
+        // Update the size of the output we have used, needs to be removed if we don't push the digits
+        mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
+
+        // Do the clusterisation
+        nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
+
+        HLTDebug("Number of rec points found: %d", nRecPoints);
+
+        // Give the cluster output to the analyser
+        fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
+
+        // Give the rec points to the analyser (input)
+        fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
+
+        // Give the digits to the analyser
+        //fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
+        fAnalyserPtr->SetDigitDataArray(fDigitsPointerArray);
+
+        // Then we create the clusters
+        Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
+
+        if (nClusters < 0)
+        {
+            HLTError("Error in clusterisation");
+            caloClusterHeaderPtr->fNClusters = 0;
+        }
+        else
+        {
+            caloClusterHeaderPtr->fNClusters = nClusters;
+        }
+
+        HLTDebug("Number of clusters: %d", nRecPoints);
+
+        AliHLTComponentBlockData bd;
+        FillBlockData( bd );
+        bd.fOffset = offset;
+        bd.fSize = mysize;
+        bd.fDataType = kAliHLTDataTypeCaloCluster | fDataOrigin;
+        bd.fSpecification = specification;
+        outputBlocks.push_back( bd );
     }
 
-  size = mysize;
-  
-  return 0;
+    size = mysize;
+
+    return 0;
 }
 
-int 
+int
 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
-{  
-  // see header file for class documentation
+{
+    // see header file for class documentation
 
-  const char* path="HLT/ConfigPHOS/ClusterizerComponent";
+    const char* path="HLT/ConfigPHOS/ClusterizerComponent";
 
-  if (cdbEntry) path = cdbEntry;
+    if (cdbEntry) path = cdbEntry;
 
-  return ConfigureFromCDBTObjString(cdbEntry);
+    return ConfigureFromCDBTObjString(cdbEntry);
 }
 
-int 
+int
 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
 {
-  //See header file for documentation
+    //See header file for documentation
 
-  if(argc <= 0) return 0;
+    if (argc <= 0) return 0;
 
-  int i=0;
+    int i=0;
 
-  TString argument=argv[i];
+    TString argument=argv[i];
 
-  if (argument.CompareTo("-digitthreshold") == 0)
+    if (argument.CompareTo("-digitthreshold") == 0)
     {
-      if (++i >= argc) return -EPROTO;
-      argument = argv[i];
-      fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
-      return 1;
+        if (++i >= argc) return -EPROTO;
+        argument = argv[i];
+        fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
+        return 1;
     }
 
-  if (argument.CompareTo("-recpointthreshold") == 0)
+    if (argument.CompareTo("-recpointthreshold") == 0)
     {
-      if (++i >= argc) return -EPROTO;
-      argument = argv[i];
-      fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
-      return 1;
+        if (++i >= argc) return -EPROTO;
+        argument = argv[i];
+        fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
+        return 1;
     }
-  
-  if (argument.CompareTo("-cutonsinglecell") == 0)
+
+    if (argument.CompareTo("-cutonsinglecell") == 0)
     {
-      if (++i >= argc) return -EPROTO;
-      argument = argv[i];
-      fAnalyserPtr->SetCutOnSingleCellClusters(true, argument.Atof());
-      return 1;
+        if (++i >= argc) return -EPROTO;
+        argument = argv[i];
+        fAnalyserPtr->SetCutOnSingleCellClusters(true, argument.Atof());
+        return 1;
     }
-  if (argument.CompareTo("-sortbyposition") == 0)
+    if (argument.CompareTo("-sortbyposition") == 0)
     {
-      fClusterizerPtr->SetSortDigitsByPosition();
-       return 1;
+        fClusterizerPtr->SetSortDigitsByPosition();
+        return 1;
     }
-    
-  return 0;
+
+    return 0;
 }
 
 int
 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
 {
-  //See headerfile for documentation
-
-  fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
-
-  fClusterizerPtr = new AliHLTCaloClusterizer(fCaloConstants->GetDETNAME());
-
-  fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
-  
-  fClusterizerPtr->SetSortDigitsByEnergy();
-   
-  fAnalyserPtr = new AliHLTCaloClusterAnalyser();
-  
-  if(fCaloConstants->GetDETNAME() == "PHOS")
-  {
-     fAnalyserPtr->SetClusterType(kPHOSCluster);
-  }
-  else if(fCaloConstants->GetDETNAME() == "EMCAL")
-  {
-     fAnalyserPtr->SetClusterType(kEMCALClusterv1);
-  }
-  else
-  {
-     fAnalyserPtr->SetClusterType(kUndef);
-  }
-   InitialiseGeometry();
-  if(fRecoParamsPtr)
-  {
-     if(!fRecoParamsPtr->GetParametersFromCDB())
-     {
-        fAnalyserPtr->SetRecoParamHandler(fRecoParamsPtr);
-        fClusterizerPtr->SetEmcClusteringThreshold(fRecoParamsPtr->GetRecPointThreshold());
-        fClusterizerPtr->SetEmcMinEnergyThreshold(fRecoParamsPtr->GetRecPointMemberThreshold());
-     }
-  }
-  //
-
-  //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
-
-  //  ConfigureFromCDBTObjString(path);
-
-  for (int i = 0; i < argc; i++)
+    //See headerfile for documentation
+
+    fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
+
+    fClusterizerPtr = new AliHLTCaloClusterizer(fCaloConstants->GetDETNAME());
+
+    fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
+
+    fClusterizerPtr->SetSortDigitsByEnergy();
+
+    fAnalyserPtr = new AliHLTCaloClusterAnalyser();
+
+    if (fCaloConstants->GetDETNAME() == "PHOS")
+    {
+        fAnalyserPtr->SetClusterType(kPHOSCluster);
+    }
+    else if (fCaloConstants->GetDETNAME() == "EMCAL")
+    {
+        fAnalyserPtr->SetClusterType(kEMCALClusterv1);
+    }
+    else
+    {
+        fAnalyserPtr->SetClusterType(kUndef);
+    }
+    InitialiseGeometry();
+    if (fRecoParamsPtr)
     {
-      ScanConfigurationArgument(i, argv);
+        if (!fRecoParamsPtr->GetParametersFromCDB())
+        {
+            fAnalyserPtr->SetRecoParamHandler(fRecoParamsPtr);
+            fClusterizerPtr->SetEmcClusteringThreshold(fRecoParamsPtr->GetRecPointThreshold());
+            fClusterizerPtr->SetEmcMinEnergyThreshold(fRecoParamsPtr->GetRecPointMemberThreshold());
+        }
     }
+    //
 
-  return 0;
+    //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
+
+    //  ConfigureFromCDBTObjString(path);
+
+    for (int i = 0; i < argc; i++)
+    {
+        ScanConfigurationArgument(i, argv);
+    }
+
+    return 0;
 }
 int AliHLTCaloClusterizerComponent::DoDeinit()
 {
-   // See header file for documentation
-   if(fDigitsPointerArray)
-   {
-      delete []  fDigitsPointerArray;
-      fDigitsPointerArray = 0;
-   }
-   if(fClusterizerPtr)
-   {
-      delete fClusterizerPtr;
-      fClusterizerPtr = 0;
-   }
-   if(fAnalyserPtr)
-   {
-      delete fAnalyserPtr;
-      fAnalyserPtr = 0;
-   }
-   return 0;
+    // See header file for documentation
+    if (fDigitsPointerArray)
+    {
+        delete []  fDigitsPointerArray;
+        fDigitsPointerArray = 0;
+    }
+    if (fClusterizerPtr)
+    {
+        delete fClusterizerPtr;
+        fClusterizerPtr = 0;
+    }
+    if (fAnalyserPtr)
+    {
+        delete fAnalyserPtr;
+        fAnalyserPtr = 0;
+    }
+    return 0;
 }
 
-Int_t 
+Int_t
 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
 {
-  // See header file for documentation
-  return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
+    // See header file for documentation
+    return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 
-  //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
+    //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 }
index debe425..036a3c6 100644 (file)
@@ -172,6 +172,10 @@ class AliHLTCaloClusterizerComponent : public AliHLTCaloProcessor, public AliHLT
     /** Number of digits in event */
     Int_t fDigitCount;                                            //COMMENT
     
+    /** Copy digits to output? */
+    Bool_t fCopyDigitsToOuput; //COMMENT
+  
+    
     /** Default constructor, not implemented */
     AliHLTCaloClusterizerComponent();                             //COMMENT
 
index f783c4d..7370efa 100644 (file)
@@ -244,6 +244,7 @@ void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, Al
   fDigitStructPtr->fZ = coord.fZ;\r
   fDigitStructPtr->fGain = coord.fGain;\r
   fDigitStructPtr->fOverflow = false;\r
+  fDigitStructPtr->fAssociatedCluster = -1;\r
   \r
   fDigitStructPtr->fID = fDigitStructPtr->fZ * fCaloConstants->GetNXCOLUMNSMOD() + fDigitStructPtr->fX;\r
   \r