- cleaning up debug output
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizerComponent.cxx
index 3e521443bb4e5d4cd17d81760863e5d8fdf30b6e..2359c82568a54c47d28c7a8dc4eeff263aac8e6b 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
     @author Oystein Djuvsland
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-AliHLTCaloClusterizerComponent gAliHLTCaloClusterizerComponent;
-
-AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(): 
-  AliHLTPHOSProcessor(), 
-  fAllDigitsPtr(0),
+AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det): 
+  AliHLTCaloProcessor(),
+  AliHLTCaloConstantsHandler(det),
+  fDataOrigin('\0'),
+  fAnalyserPtr(0),
+  fDigitsPointerArray(0), 
+  fOutputDigitsArray(0),
   fClusterizerPtr(0),
-  fDigitCount(0),
-  fNoCrazyness(0)
+  fDigitCount(0)
 {
   //See headerfile for documentation
+
+  fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSRCU()*fCaloConstants->GetNZROWSRCU()];
+
+  fClusterizerPtr = new AliHLTCaloClusterizer(det);
+
+  fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
+   
+  fAnalyserPtr = new AliHLTCaloClusterAnalyser();
+  
 }
 
 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
 {
   //See headerfile for documentation
-
+delete fAnalyserPtr;
   if(fClusterizerPtr)
     {
       delete fClusterizerPtr;
       fClusterizerPtr = 0;
     }
-  if(fAllDigitsPtr)
-    {
-      delete fAllDigitsPtr;
-      fAllDigitsPtr = 0;
-    }
 }
 
 
@@ -70,7 +76,7 @@ AliHLTCaloClusterizerComponent::Deinit()
 {
   //See headerfile for documentation
 
-  if (fClusterizerPtr)
+if (fClusterizerPtr)
     {
       delete fClusterizerPtr;
       fClusterizerPtr = 0;
@@ -79,30 +85,6 @@ AliHLTCaloClusterizerComponent::Deinit()
   return 0;
 }
 
-void
-AliHLTCaloClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
-{
-  //See headerfile for documentation
-  list.clear();
-  list.push_back(AliHLTPHOSDefinitions::fgkDigitDataType);
-}
-
-AliHLTComponentDataType
-AliHLTCaloClusterizerComponent::GetOutputDataType()
-{
-  //See headerfile for documentation
-  return AliHLTPHOSDefinitions::fgkRecPointDataType;
-}
-
-void
-AliHLTCaloClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
-
-{
-  //See headerfile for documentation
-  constBase = sizeof(AliHLTCaloRecPointHeaderStruct) + sizeof(AliHLTPHOSRecPointDataStruct) + (sizeof(AliHLTCaloDigitDataStruct) << 7); //Reasonable estimate... ;
-  inputMultiplier = 1.5;
-}
-
 int
 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
@@ -116,6 +98,7 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   UInt_t mysize           = 0;
   Int_t nRecPoints        = 0;
   Int_t nDigits           = 0;
+  Int_t digCount          = 0;
 
   UInt_t availableSize = size;
   AliHLTUInt8_t* outBPtr;
@@ -126,62 +109,82 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   UInt_t specification = 0;
   
   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
-
-  AliHLTCaloRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTCaloRecPointHeaderStruct*>(outBPtr);
-
-  fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTCaloRecPointDataStruct*>(outBPtr+sizeof(AliHLTCaloRecPointHeaderStruct)));
-
+  
   // Adding together all the digits, should be put in standalone method  
   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
       iter = blocks+ndx;
-      if (iter->fDataType == AliHLTCaloDefinitions::fgkDigitDataType)
+      //            HLTError("Got block");
+      if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
        {
-         // Get the digit header
 
          // Update the number of digits
-         nDigits += iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
-         // Get the specification
+         nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
+         
+         availableSize -= iter->fSize;
+         
          specification = specification|iter->fSpecification;
 
-         digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
-         for (Int_t i = 0; i < nDigits; i++)
-           {
-             fAllDigitsPtr->fDigitDataStruct[j].fX = digitDataPtr->fX;
-             fAllDigitsPtr->fDigitDataStruct[j].fZ = digitDataPtr->fZ;
-             fAllDigitsPtr->fDigitDataStruct[j].fEnergy = digitDataPtr->fEnergy;
-             //  HLTDebug("Digit energy: %f", digitDataPtr->fEnergy);
-             fAllDigitsPtr->fDigitDataStruct[j].fTime = digitDataPtr->fTime;
-             fAllDigitsPtr->fDigitDataStruct[j].fCrazyness = digitDataPtr->fCrazyness;
-             j++;
-             digitDataPtr++;
-           }
-
+         digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
+         for (Int_t i = 0; i < nDigits; i++)
+           {
+             fDigitsPointerArray[digCount] = digitDataPtr;
+             digCount++;
+             digitDataPtr++;
+           }
        }
     }
-  
-  fAllDigitsPtr->fNDigits = j;
-  nRecPoints = fClusterizerPtr->ClusterizeEvent(size, mysize);
 
-  if(nRecPoints == -1)
+  if(digCount > 0)
     {
-      HLTError("Running out of buffer, exiting for safety.");
-      return -ENOBUFS;
-    }
+       
+      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
+      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);
+       }
+  
+       mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
+
+      //HLTDebug("Total number of digits: %d", digCount );
+
+      nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
+
+      //HLTDebug("Number of rec points found: %d", nRecPoints);
+
+      fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
+      
+      fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
 
-  recPointHeaderPtr->fNRecPoints = nRecPoints;
-  mysize += sizeof(AliHLTCaloRecPointHeaderStruct);
+      fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
+
+      Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
   
-  HLTDebug("Number of clusters: %d", nRecPoints);
-
-  AliHLTComponentBlockData bd;
-  FillBlockData( bd );
-  bd.fOffset = offset;
-  bd.fSize = mysize;
-  bd.fDataType = AliHLTPHOSDefinitions::fgkClusterDataType;
-  bd.fSpecification = specification;
-  outputBlocks.push_back( bd );
-     
+      caloClusterHeaderPtr->fNClusters = nClusters;
+      
+      //HLTDebug("Number of clusters: %d", nRecPoints);
+      
+      AliHLTComponentBlockData bd;
+      FillBlockData( bd );
+      bd.fOffset = offset;
+      bd.fSize = mysize;
+      bd.fDataType = kAliHLTDataTypeCaloCluster | kAliHLTDataOriginPHOS;
+      bd.fSpecification = specification;
+      outputBlocks.push_back( bd );
+    }
+
   size = mysize;
   
   return 0;
@@ -233,10 +236,7 @@ AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
 {
   //See headerfile for documentation
 
-  fAllDigitsPtr = new AliHLTCaloDigitContainerDataStruct();
-  fClusterizerPtr = new AliHLTCaloClusterizer();
-  fClusterizerPtr->SetDigitContainer(fAllDigitsPtr);
-  fNoCrazyness = false;
+  
   //
 
   //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
@@ -251,10 +251,11 @@ AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
   return 0;
 }
 
-AliHLTComponent*
-AliHLTCaloClusterizerComponent::Spawn()
+Int_t 
+AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
 {
-  //See headerfile for documentation
+  // See header file for documentation
+  return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 
-  return new AliHLTCaloClusterizerComponent();
+  //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
 }