[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizer.cxx

// $Id$\r
\r
/**************************************************************************\r
 * This file is property of and copyright by the ALICE HLT Project        *\r
 * All rights reserved.                                                   *\r
 *                                                                        *\r
 * Primary Authors: Oystein Djuvsland                                     *\r
 *                                                                        *\r
 * Permission to use, copy, modify and distribute this software and its   *\r
 * documentation strictly for non-commercial purposes is hereby granted   *\r
 * without fee, provided that the above copyright notice appears in all   *\r
 * copies and that both the copyright notice and this permission notice   *\r
 * appear in the supporting documentation. The authors make no claims     *\r
 * about the suitability of this software for any purpose. It is          *\r
 * provided "as is" without express or implied warranty.                  *\r
 **************************************************************************/\r
\r
/**\r
 * @file   AliHLTCaloClusterizer.cxx\r
 * @author Oystein Djuvsland\r
 * @date\r
 * @brief  Clusterizer for PHOS HLT\r
 */\r
\r
// see header file for class documentation\r
// or\r
// refer to README to build package\r
// or\r
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
\r
#include "AliHLTCaloClusterizer.h"\r
#include "AliHLTLogging.h"\r
#include "TMath.h"\r
#include "AliHLTCaloRecPointDataStruct.h"\r
#include "AliHLTCaloDigitDataStruct.h"\r
#include "AliHLTCaloDigitContainerDataStruct.h"\r
#include "AliHLTCaloConstantsHandler.h"\r
\r
ClassImp(AliHLTCaloClusterizer);\r
\r
AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):\r
        AliHLTCaloConstantsHandler(det),\r
        fCompareFunction(CompareDigitsByPosition),\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(0),\r
        fDigitsInCluster(0),\r
        fDigitsPointerArray(0),\r
        fDigitContainerPtr(0),\r
        fMaxDigitIndexDiff(0),\r
        fNDigits(0),\r
        fSortedByPosition(false),\r
        fSortedByEnergy(false),\r
        fSortDigits(false)\r
{\r
    //See header file for documentation\r
    //fEmcClusteringThreshold = 0.2;\r
    //fEmcMinEnergyThreshold = 0.03;\r
\r
    fEmcClusteringThreshold = 0.1;\r
    fEmcMinEnergyThreshold = 0.01;\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
    fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);\r
    fRecPointDataPtr = fFirstRecPointPtr;\r
\r
}//end\r
\r
AliHLTCaloClusterizer::~AliHLTCaloClusterizer()\r
{\r
    //See header file for documentation\r
  delete [] fRecPointDataPtr;\r
  delete [] fRecPointArray;\r
}\r
\r
void\r
AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)\r
{\r
    // See header file for documentation\r
    fRecPointDataPtr = recPointDataPtr;\r
}\r
\r
Int_t\r
AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)\r
{\r
    //see header file for documentation\r
    Int_t nRecPoints = 0;\r
    fNRecPoints = 0;\r
    fUsedSize = 0;\r
    fNDigits = nDigits;\r
    fRecPointDataPtr = fFirstRecPointPtr;\r
\r
    // Sort our digits\r
    SortDigits();\r
\r
    //Clusterization starts\r
    for (Int_t i = 0; i < nDigits; i++)\r
    {\r
        fDigitsInCluster = 0;\r
\r
	 HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);\r
	\r
        if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)\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
        CheckBuffer();\r
\r
        // First digit is placed at the fDigits member variable in the recpoint\r
        fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
\r
        fRecPointDataPtr->fAmp = 0;\r
        fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;\r
\r
        // Assigning the digit to this rec point\r
        fRecPointDataPtr->fDigits = i;\r
        fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
\r
        // Incrementing the pointer to be ready for new entry\r
        fDigitIndexPtr++;\r
\r
        fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;\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
        if (ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)\r
        {\r
            return -1;\r
        }\r
\r
        //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);\r
\r
        fRecPointDataPtr->fMultiplicity = fDigitsInCluster;\r
        fRecPointArray[fNRecPoints] = fRecPointDataPtr;\r
\r
        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
\r
        fNRecPoints++;\r
\r
    }//end of clusterization\r
\r
    return nRecPoints;\r
}\r
\r
Int_t\r
AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)\r
{\r
    //see header file for documentation\r
\r
    // The following cuts can be used if we sort by posisiton. Not tested, but it should be fine...\r
    Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);\r
    Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));\r
\r
    // All digits for now\r
    max = fNDigits;\r
    min = 0;\r
\r
    for (Int_t j = min; j < max; j++)\r
    {\r
        if (fDigitsPointerArray[j]->fAssociatedCluster == -1 &&  fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
        {\r
            if (j != index)\r
            {\r
                if (AreNeighbours(fDigitsPointerArray[index],\r
                                  fDigitsPointerArray[j]))\r
                {\r
                    // Check that the buffer is large enough for adding a digit (can be heavily improved wrt performance)\r
                    CheckBuffer();\r
\r
                    // Assigning index to digit\r
                    *fDigitIndexPtr = j;\r
                    fUsedSize += sizeof(Int_t);\r
\r
                    // Incrementing digit pointer to be ready for new entry\r
                    fDigitIndexPtr++;\r
\r
                    // Adding the digit energy to the rec point\r
                    fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;\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
                    ScanForNeighbourDigits(j, recPoint);\r
                }\r
            }\r
        }\r
    }\r
    return 0;\r
}\r
\r
Int_t\r
AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,\r
                                     AliHLTCaloDigitDataStruct* digit2)\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
\r
        // As in the offline code we define neighbours as cells that share an edge, a corner is not  enough\r
	//        if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))\r
        if (( coldiff <= 1) || ( rowdiff <= 1 ))\r
        {\r
            // Check also for time\r
            if (TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
            {\r
                return 1;\r
            }\r
        }\r
    }\r
    return 0;\r
}\r
\r
\r
\r
Int_t AliHLTCaloClusterizer::CheckArray()\r
{\r
    // See header file for class documentation\r
    if (fArraySize == fNRecPoints)\r
    {\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
    if ((fAvailableSize - fUsedSize) < (Int_t)sizeof(AliHLTCaloRecPointDataStruct))\r
    {\r
        Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);\r
        Int_t digitIndexOffset = reinterpret_cast<UChar_t*>(fDigitIndexPtr) - reinterpret_cast<UChar_t*>(fRecPointDataPtr);\r
        UChar_t *tmp = new UChar_t[fAvailableSize*2];\r
\r
        memcpy(tmp, fFirstRecPointPtr, fUsedSize);\r
        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 [] fFirstRecPointPtr;\r
        fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);\r
        fDigitIndexPtr = reinterpret_cast<Int_t*>(reinterpret_cast<UChar_t*>(fRecPointDataPtr) + digitIndexOffset);\r
        //fUsedSize = 0;\r
    }\r
    return 0;\r
}\r
\r
void AliHLTCaloClusterizer::SetSortDigitsByPosition()\r
{\r
    // Sort the digit pointers by position\r
    fCompareFunction = &CompareDigitsByPosition;\r
    fSortDigits = true;\r
    fSortedByPosition = true;\r
}\r
\r
void AliHLTCaloClusterizer::SetSortDigitsByEnergy()\r
{\r
    // See header file for class documentation\r
    fCompareFunction = &CompareDigitsByEnergy;\r
    fSortDigits = true;\r
    fSortedByEnergy = true;\r
}\r
\r
void AliHLTCaloClusterizer::SortDigits()\r
{\r
    // See header file for class documentation\r
    if (fSortDigits) qsort(fDigitsPointerArray, fNDigits, sizeof(AliHLTCaloDigitDataStruct*), fCompareFunction);\r
}\r
\r
Int_t\r
AliHLTCaloClusterizer::CompareDigitsByPosition(const void *dig0, const void *dig1)\r
{\r
    // See header file for documentation\r
    return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;\r
}\r
\r
Int_t\r
AliHLTCaloClusterizer::CompareDigitsByEnergy(const void *dig0, const void *dig1)\r
{\r
    // See header file for documentation\r
  if ( ((*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy) < 0) return -1;\r
  return 1;\r
}\r
Commit	Line	Data
ef44ec64	1	// $Id$\r
	2	\r
	3	/**************************************************************************\r
31b89da4	4	* This file is property of and copyright by the ALICE HLT Project *\r
ef44ec64	5	* All rights reserved. *\r
	6	* *\r
	7	* Primary Authors: Oystein Djuvsland *\r
	8	* *\r
	9	* Permission to use, copy, modify and distribute this software and its *\r
	10	* documentation strictly for non-commercial purposes is hereby granted *\r
	11	* without fee, provided that the above copyright notice appears in all *\r
	12	* copies and that both the copyright notice and this permission notice *\r
	13	* appear in the supporting documentation. The authors make no claims *\r
31b89da4	14	* about the suitability of this software for any purpose. It is *\r
ef44ec64	15	* provided "as is" without express or implied warranty. *\r
	16	**************************************************************************/\r
	17	\r
31b89da4	18	/**\r
ef44ec64	19	* @file AliHLTCaloClusterizer.cxx\r
ef44ec64	20	* @author Oystein Djuvsland\r
31b89da4	21	* @date\r
31b89da4	22	* @brief Clusterizer for PHOS HLT\r
ef44ec64	23	*/\r
	24	\r
	25	// see header file for class documentation\r
	26	// or\r
	27	// refer to README to build package\r
	28	// or\r
	29	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
	30	\r
	31	#include "AliHLTCaloClusterizer.h"\r
ef44ec64	32	#include "AliHLTLogging.h"\r
ef44ec64	33	#include "TMath.h"\r
ef44ec64	34	#include "AliHLTCaloRecPointDataStruct.h"\r
	35	#include "AliHLTCaloDigitDataStruct.h"\r
	36	#include "AliHLTCaloDigitContainerDataStruct.h"\r
4f4b7ba4	37	#include "AliHLTCaloConstantsHandler.h"\r
ef44ec64	38	\r
	39	ClassImp(AliHLTCaloClusterizer);\r
	40	\r
	41	AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):\r
31b89da4	42	AliHLTCaloConstantsHandler(det),\r
	43	fCompareFunction(CompareDigitsByPosition),\r
	44	fRecPointArray(0),\r
	45	fRecPointDataPtr(0),\r
	46	fFirstRecPointPtr(0),\r
	47	fArraySize(0),\r
	48	fAvailableSize(0),\r
	49	fUsedSize(0),\r
	50	fNRecPoints(0),\r
	51	fDigitIndexPtr(0),\r
	52	fEmcClusteringThreshold(0),\r
	53	fEmcMinEnergyThreshold(0),\r
	54	fEmcTimeGate(0),\r
	55	fDigitsInCluster(0),\r
	56	fDigitsPointerArray(0),\r
	57	fDigitContainerPtr(0),\r
	58	fMaxDigitIndexDiff(0),\r
	59	fNDigits(0),\r
	60	fSortedByPosition(false),\r
	61	fSortedByEnergy(false),\r
	62	fSortDigits(false)\r
ef44ec64	63	{\r
31b89da4	64	//See header file for documentation\r
	65	//fEmcClusteringThreshold = 0.2;\r
	66	//fEmcMinEnergyThreshold = 0.03;\r
	67	\r
	68	fEmcClusteringThreshold = 0.1;\r
	69	fEmcMinEnergyThreshold = 0.01;\r
	70	fEmcTimeGate = 1.e-6 ;\r
	71	\r
	72	fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();\r
	73	\r
	74	\r
	75	fArraySize = 10;\r
	76	fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
	77	\r
	78	fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;\r
	79	fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);\r
	80	fRecPointDataPtr = fFirstRecPointPtr;\r
c375e15d	81	\r
c375e15d	82	}//end\r
c375e15d	83	\r
31b89da4	84	AliHLTCaloClusterizer::~AliHLTCaloClusterizer()\r
ef44ec64	85	{\r
31b89da4	86	//See header file for documentation\r
9991396c	87	delete [] fRecPointDataPtr;\r
9991396c	88	delete [] fRecPointArray;\r
ef44ec64	89	}\r
ef44ec64	90	\r
31b89da4	91	void\r
ef44ec64	92	AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)\r
ef44ec64	93	{\r
31b89da4	94	// See header file for documentation\r
31b89da4	95	fRecPointDataPtr = recPointDataPtr;\r
ef44ec64	96	}\r
ef44ec64	97	\r
31b89da4	98	Int_t\r
7c80a370	99	AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)\r
ef44ec64	100	{\r
31b89da4	101	//see header file for documentation\r
	102	Int_t nRecPoints = 0;\r
	103	fNRecPoints = 0;\r
	104	fUsedSize = 0;\r
	105	fNDigits = nDigits;\r
	106	fRecPointDataPtr = fFirstRecPointPtr;\r
	107	\r
	108	// Sort our digits\r
	109	SortDigits();\r
	110	\r
	111	//Clusterization starts\r
	112	for (Int_t i = 0; i < nDigits; i++)\r
	113	{\r
	114	fDigitsInCluster = 0;\r
	115	\r
f92543f5	116	HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);\r
	117	\r
	118	if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)\r
31b89da4	119	{\r
f92543f5	120	// Since we have sorted by energy the next digit will have even lower energy, so we return \r
	121	return fNRecPoints;\r
	122	}\r
	123	\r
	124	if(fDigitsPointerArray[i]->fAssociatedCluster != -1)\r
	125	{\r
	126	// The digit is added to a previous cluster, continue\r
	127	continue;\r
	128	}\r
31b89da4	129	\r
f92543f5	130	CheckArray();\r
31b89da4	131	CheckBuffer();\r
	132	\r
	133	// First digit is placed at the fDigits member variable in the recpoint\r
	134	fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
	135	\r
	136	fRecPointDataPtr->fAmp = 0;\r
	137	fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;\r
	138	\r
	139	// Assigning the digit to this rec point\r
	140	fRecPointDataPtr->fDigits = i;\r
	141	fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
	142	\r
	143	// Incrementing the pointer to be ready for new entry\r
	144	fDigitIndexPtr++;\r
	145	\r
	146	fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;\r
f92543f5	147	\r
	148	\r
	149	//fDigitsPointerArray[i]->fEnergy = 0;\r
	150	fDigitsPointerArray[i]->fAssociatedCluster = fNRecPoints;\r
	151	\r
	152	\r
	153	fDigitsInCluster++;\r
31b89da4	154	nRecPoints++;\r
	155	\r
	156	// Scanning for the neighbours\r
	157	if (ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)\r
	158	{\r
	159	return -1;\r
	160	}\r
	161	\r
	162	//fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);\r
	163	\r
	164	fRecPointDataPtr->fMultiplicity = fDigitsInCluster;\r
	165	fRecPointArray[fNRecPoints] = fRecPointDataPtr;\r
	166	\r
	167	fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
	168	\r
	169	fNRecPoints++;\r
	170	\r
ef44ec64	171	}//end of clusterization\r
70c86cde	172	\r
70c86cde	173	return nRecPoints;\r
ef44ec64	174	}\r
ef44ec64	175	\r
9bd6f29b	176	Int_t\r
ef44ec64	177	AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)\r
ef44ec64	178	{\r
31b89da4	179	//see header file for documentation\r
ef44ec64	180	\r
31b89da4	181	// The following cuts can be used if we sort by posisiton. Not tested, but it should be fine...\r
	182	Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);\r
	183	Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));\r
	184	\r
	185	// All digits for now\r
	186	max = fNDigits;\r
	187	min = 0;\r
	188	\r
	189	for (Int_t j = min; j < max; j++)\r
ef44ec64	190	{\r
f92543f5	191	if (fDigitsPointerArray[j]->fAssociatedCluster == -1 && fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
31b89da4	192	{\r
	193	if (j != index)\r
	194	{\r
	195	if (AreNeighbours(fDigitsPointerArray[index],\r
	196	fDigitsPointerArray[j]))\r
	197	{\r
	198	// Check that the buffer is large enough for adding a digit (can be heavily improved wrt performance)\r
	199	CheckBuffer();\r
	200	\r
	201	// Assigning index to digit\r
	202	*fDigitIndexPtr = j;\r
	203	fUsedSize += sizeof(Int_t);\r
	204	\r
	205	// Incrementing digit pointer to be ready for new entry\r
	206	fDigitIndexPtr++;\r
	207	\r
	208	// Adding the digit energy to the rec point\r
	209	fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;\r
	210	\r
f92543f5	211	// Setting energy to 0\r
	212	//fDigitsPointerArray[j]->fEnergy = 0;\r
	213	\r
	214	// Setting the associated cluster \r
	215	fDigitsPointerArray[j]->fAssociatedCluster = fNRecPoints;\r
	216	\r
	217	HLTDebug("Added digit with index: %d, energy: %f, to associated cluster: %d", fDigitsPointerArray[j]->fID, fDigitsPointerArray[j]->fEnergy, fDigitsPointerArray[j]->fAssociatedCluster);\r
	218	\r
31b89da4	219	fDigitsInCluster++;\r
	220	\r
	221	// Scan for neighbours of this digit\r
	222	ScanForNeighbourDigits(j, recPoint);\r
	223	}\r
	224	}\r
	225	}\r
ef44ec64	226	}\r
31b89da4	227	return 0;\r
ef44ec64	228	}\r
ef44ec64	229	\r
31b89da4	230	Int_t\r
	231	AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,\r
	232	AliHLTCaloDigitDataStruct* digit2)\r
ef44ec64	233	{\r
31b89da4	234	//see header file for documentation\r
	235	if ( (digit1->fModule == digit2->fModule) /&& (coord1[1]==coord2[1])/ ) // inside the same PHOS module\r
	236	{\r
	237	Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );\r
	238	Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX );\r
	239	\r
	240	// As in the offline code we define neighbours as cells that share an edge, a corner is not enough\r
c5688f76	241	// if (( coldiff <= 1 && rowdiff == 0 ) \|\| ( coldiff == 0 && rowdiff <= 1 ))\r
c5688f76	242	if (( coldiff <= 1) \|\| ( rowdiff <= 1 ))\r
31b89da4	243	{\r
	244	// Check also for time\r
	245	if (TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
	246	{\r
	247	return 1;\r
	248	}\r
	249	}\r
ef44ec64	250	}\r
31b89da4	251	return 0;\r
ef44ec64	252	}\r
7c80a370	253	\r
	254	\r
	255	\r
	256	Int_t AliHLTCaloClusterizer::CheckArray()\r
	257	{\r
31b89da4	258	// See header file for class documentation\r
	259	if (fArraySize == fNRecPoints)\r
	260	{\r
	261	fArraySize *= 2;\r
	262	AliHLTCaloRecPointDataStruct *tmp = new AliHLTCaloRecPointDataStruct[fArraySize];\r
	263	memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));\r
	264	delete [] fRecPointArray;\r
	265	fRecPointArray = tmp;\r
	266	}\r
	267	return 0;\r
7c80a370	268	}\r
	269	\r
	270	Int_t AliHLTCaloClusterizer::CheckBuffer()\r
	271	{\r
31b89da4	272	// See header file for class documentation\r
	273	if ((fAvailableSize - fUsedSize) < (Int_t)sizeof(AliHLTCaloRecPointDataStruct))\r
	274	{\r
	275	Int_t recPointOffset = reinterpret_cast<UChar_t>(fRecPointDataPtr) - reinterpret_cast<UChar_t>(fFirstRecPointPtr);\r
	276	Int_t digitIndexOffset = reinterpret_cast<UChar_t>(fDigitIndexPtr) - reinterpret_cast<UChar_t>(fRecPointDataPtr);\r
	277	UChar_t tmp = new UChar_t[fAvailableSize2];\r
	278	\r
	279	memcpy(tmp, fFirstRecPointPtr, fUsedSize);\r
	280	fAvailableSize *= 2;\r
	281	for (Int_t n = 0; n < fNRecPoints; n++)\r
	282	{\r
	283	fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct>(reinterpret_cast<UChar_t>(fRecPointArray[n]) - reinterpret_cast<UChar_t>(fFirstRecPointPtr) + reinterpret_cast<UChar_t>(tmp));\r
	284	}\r
	285	delete [] fFirstRecPointPtr;\r
	286	fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
	287	fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);\r
	288	fDigitIndexPtr = reinterpret_cast<Int_t>(reinterpret_cast<UChar_t>(fRecPointDataPtr) + digitIndexOffset);\r
	289	//fUsedSize = 0;\r
	290	}\r
	291	return 0;\r
7c80a370	292	}\r
7c80a370	293	\r
31b89da4	294	void AliHLTCaloClusterizer::SetSortDigitsByPosition()\r
7c80a370	295	{\r
31b89da4	296	// Sort the digit pointers by position\r
	297	fCompareFunction = &CompareDigitsByPosition;\r
	298	fSortDigits = true;\r
	299	fSortedByPosition = true;\r
7c80a370	300	}\r
7c80a370	301	\r
31b89da4	302	void AliHLTCaloClusterizer::SetSortDigitsByEnergy()\r
	303	{\r
	304	// See header file for class documentation\r
	305	fCompareFunction = &CompareDigitsByEnergy;\r
	306	fSortDigits = true;\r
	307	fSortedByEnergy = true;\r
	308	}\r
	309	\r
	310	void AliHLTCaloClusterizer::SortDigits()\r
	311	{\r
	312	// See header file for class documentation\r
	313	if (fSortDigits) qsort(fDigitsPointerArray, fNDigits, sizeof(AliHLTCaloDigitDataStruct*), fCompareFunction);\r
	314	}\r
	315	\r
	316	Int_t\r
	317	AliHLTCaloClusterizer::CompareDigitsByPosition(const void dig0, const void dig1)\r
	318	{\r
	319	// See header file for documentation\r
	320	return (((AliHLTCaloDigitDataStruct)(dig0)))->fID - (((AliHLTCaloDigitDataStruct**)(dig1)))->fID;\r
	321	}\r
	322	\r
	323	Int_t\r
	324	AliHLTCaloClusterizer::CompareDigitsByEnergy(const void dig0, const void dig1)\r
7c80a370	325	{\r
31b89da4	326	// See header file for documentation\r
02f2218d	327	if ( ((((AliHLTCaloDigitDataStruct)(dig1)))->fEnergy - (((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy) < 0) return -1;\r
02f2218d	328	return 1;\r
2a24cbbe	329	}\r