struct AliHLTCaloClusterHeaderStruct
{
Short_t fNClusters;
+ Short_t fNDigits;
};
/**
#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()
}
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
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;
z += zi * w ;
wtot += w ;
}
- digit++;
+ digitIndexPtr++;
}
//cout << endl;
if (wtot>0)
{
recPoint->fAmp = 0;
}
- recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digit);
}
return 0;
}
}
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;
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;
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);
// 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);
}
#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
* @ingroup alihlt_calo
*/
//class AliHLTCaloClusterAnalyser : public AliHLTCaloBase
-class AliHLTCaloClusterAnalyser
+class AliHLTCaloClusterAnalyser : public AliHLTLogging
{
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
* 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
*/
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
/** 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
/** Do we have distance to bad channel? */
Bool_t fHaveDistanceToBadChannel; //COMMENT
+ /** The geometry object */
+ AliHLTCaloGeometry* fGeometry; //COMMENT
};
\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
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
}\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
{\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
\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
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
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
//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
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
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
*/\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
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
* 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
fClusterizerPtr = new AliHLTCaloClusterizer(det);
fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
-
+
+ fAnalyserPtr = new AliHLTCaloClusterAnalyser();
+
}
AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
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;
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);
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = mysize;
- bd.fDataType = AliHLTCaloDefinitions::fgkClusterDataType;
+ bd.fDataType = AliHLTCaloDefinitions::fgkClusterDataType|fDataOrigin;
bd.fSpecification = specification;
outputBlocks.push_back( bd );
}
{
// See header file for documentation
return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
+
+ //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
}
class AliHLTCaloDigitDataStruct;
class AliHLTCaloDigitContainerDataStruct;
class AliHLTCaloClusterizer;
+class AliHLTCaloClusterAnalyser;
class AliHLTCaloRecPointDataStruct;
/**
/** 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 );
/** 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
\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
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
#include "AliHLTPHOSClusterizerComponent.h"
#include "AliHLTCaloRecPointDataStruct.h"
#include "AliHLTCaloRecPointHeaderStruct.h"
+#include "AliHLTPHOSGeometry.h"
+#include "AliHLTCaloClusterAnalyser.h"
// 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;
AliHLTCaloClusterizerComponent("PHOS")
{
//See headerfile for documentation
+
+ fDataOrigin = const_cast<char*>(kAliHLTDataOriginPHOS);
+
+ AliHLTPHOSGeometry *geom = new AliHLTPHOSGeometry;
+
+ fAnalyserPtr->SetGeometry(new AliHLTPHOSGeometry);
+
}
AliHLTPHOSClusterizerComponent::~AliHLTPHOSClusterizerComponent()
return new AliHLTPHOSClusterizerComponent();
}
-
-
AliHLTComponent* Spawn();
protected:
+ virtual int DoInit() {return 0; }
virtual int DoDeinit(){ return 0;}
+ virtual int Deinit() {return 0; }
private:
//
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";
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
AliHLTPHOSMonitorTriggerComponent.h \
AliHLTPHOSESDEntriesMakerComponent.h \
AliHLTPHOSESDCaloClusterWriterComponent.h \
- AliHLTPHOSDigitReader.h
+ AliHLTPHOSDigitReader.h \
+ AliHLTPHOSConstants.h \
+ AliHLTPHOSGeometry.h
MODULE_SRCS:= $(CLASS_HDRS:.h=.cxx)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff