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

// $Id: AliHLTCaloClusterAnalyser.cxx 35107 2009-09-30 01:45:06Z phille $

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors: Oystein Djuvsland                                     *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          * 
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** 
 * @file   AliHLTCaloClusterAnalyser.cxx
 * @author Oystein Djuvsland
 * @date 
 * @brief  Cluster analyser for Calo HLT 
 */

// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

#include "AliHLTCaloClusterAnalyser.h"
#include "AliHLTCaloRecPointHeaderStruct.h"
#include "AliHLTCaloRecPointDataStruct.h"
#include "AliHLTCaloClusterDataStruct.h"
//#include "AliHLTCaloPhysicsAnalyzer.h"
#include "AliHLTCaloGeometry.h"
#include "AliESDCaloCluster.h"
#include "TMath.h"
#include "TVector3.h"
#include "TH1F.h"
#include "TFile.h"
#include "AliHLTCaloClusterizer.h"

ClassImp(AliHLTCaloClusterAnalyser);

AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() : 
  //  AliHLTCaloBase(),
  fLogWeight(4.5),
  fRecPointArray(0),
  fDigitDataArray(0),
  fNRecPoints(0),
  fCaloClusterDataPtr(0),
  fCaloClusterHeaderPtr(0),
  //fAnalyzerPtr(0),
  fDoClusterFit(false),
  fHaveCPVInfo(false),
  fDoPID(false),
  fHaveDistanceToBadChannel(false),
  fGeometry(0),
  fClusterType(AliESDCaloCluster::kPHOSCluster)
{
  //See header file for documentation
}

AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser() 
{
  // See header file for class documentation
}

void 
AliHLTCaloClusterAnalyser::SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
{ 
  //see header file for documentation
  fCaloClusterDataPtr = caloClusterDataPtr; 
}

void
AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints)
{ 
  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
AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
{
  //see header file for documentation
  Float_t wtot = 0.;
  Float_t x = 0.;
  Float_t z = 0.;
  Float_t xi = 0.;
  Float_t zi = 0.;

  AliHLTCaloDigitDataStruct *digit = 0;

  UInt_t iDigit = 0;

  for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++) 
    {
      AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
      //      digit = &(recPoint->fDigits);

      Int_t *digitIndexPtr = &(recPoint->fDigits);

      for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
	{

	  digit = &(fDigitDataArray[*digitIndexPtr]);

	  xi = digit->fX+0.5;
	  zi = digit->fZ+0.5;

	  if (recPoint->fAmp > 0 && digit->fEnergy > 0) 
	    {
	      Float_t w = TMath::Max( 0., fLogWeight + TMath::Log( digit->fEnergy / recPoint->fAmp ) ) ;
	      x    += xi * w ;
	      z    += zi * w ;
	      wtot += w ;
	    }
	  digitIndexPtr++;
	}

      if (wtot>0) 
	{
	  recPoint->fX = x/wtot ;
	  recPoint->fZ = z/wtot ;
	}
      else
	{
	  recPoint->fAmp = 0;
	}
    }
  return 0;
}


Int_t 
AliHLTCaloClusterAnalyser::CalculateRecPointMoments()
{	
  //See header file for documentation
  return 0;
}

Int_t 
AliHLTCaloClusterAnalyser::CalculateClusterMoments(AliHLTCaloRecPointDataStruct */*recPointPtr*/, AliHLTCaloClusterDataStruct* /*clusterPtr*/)
{
  //See header file for documentation
  return 0;
}


Int_t 
AliHLTCaloClusterAnalyser::DeconvoluteClusters()
{
  //See header file for documentation
  return 0;
}

Int_t 
AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize)
{
  //See header file for documentation

   
  totSize += sizeof(AliHLTCaloClusterDataStruct);
  fNRecPoints = nRecPoints;

  if(fGeometry == 0)
  {
     HLTError("No geometry object is initialised, creation of clusters stopped");
  }

  CalculateCenterOfGravity();

  //  AliHLTCaloDigitDataStruct* digitPtr = &(recPointPtr->fDigits);  
  AliHLTCaloDigitDataStruct* digitPtr = 0;

  AliHLTCaloClusterDataStruct* caloClusterPtr = 0;
  UShort_t* cellIDPtr = 0;
  Float_t* cellAmpFracPtr = 0;;
  
//  Int_t id = -1;
  TVector3 globalPos;

  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 - totSize)  < sizeof(AliHLTCaloClusterDataStruct))
      {
	 HLTError("Out of buffer: available size is: %d, total size used: %d", availableSize, totSize);
	 return -ENOBUFS;
      }
      
      caloClusterPtr = fCaloClusterDataPtr;
     
      cellIDPtr = &(caloClusterPtr->fCellsAbsId);
      cellAmpFracPtr = &(caloClusterPtr->fCellsAmpFraction);
     
      AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
      
      AliHLTCaloGlobalCoordinate globalCoord;
      fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);

      caloClusterPtr->fGlobalPos[0] =  globalCoord.fX;
      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);
      
      caloClusterPtr->fNCells = 0;//recPointPtr->fMultiplicity;
      //caloClusterPtr->fNCells = recPointPtr->fMultiplicity;

      caloClusterPtr->fClusterType = fClusterType;
      Int_t tmpSize = 0;//totSize + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));

      //TODO remove hardcoded 10; 
      memset(caloClusterPtr->fTracksMatched, 0xff, sizeof(Int_t)*10);

      //Int_t tmpSize = totSize + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
//      Int_t tmpSize = (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));

      if((availableSize - totSize)  < tmpSize)
      {
	 HLTError("Out of buffer, available size is: %d, total size used: %d, extra size needed: %d", availableSize, totSize, tmpSize);
	 return -ENOBUFS;
      }
      Int_t *digitIndexPtr = &(recPointPtr->fDigits);
      Int_t id = 0;

      for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
	{
 	   digitPtr = &(fDigitDataArray[*digitIndexPtr]);
	   id++;
	   fGeometry->GetCellAbsId(recPointPtr->fModule, digitPtr->fX, digitPtr->fZ, id);
 	  *cellIDPtr = id;
 	  *cellAmpFracPtr = digitPtr->fEnergy/recPointPtr->fAmp;
	  //printf("Cell ID pointer: %x\n", cellIDPtr);
 	 //printf("Cell Amp Pointer: %x\n", cellAmpFracPtr);
	 //printf("Cell pos: x = %d, z = %d\n", digitPtr->fX, digitPtr->fZ);
	 //printf("Cell ID: %d, pointer: %x\n", *cellIDPtr, cellIDPtr);
 	 //printf("Cell Amp: %f, pointer: %x\n", *cellAmpFracPtr, cellAmpFracPtr);
	  digitPtr++;
 	  cellIDPtr = reinterpret_cast<UShort_t*>(reinterpret_cast<char*>(cellAmpFracPtr) + sizeof(Float_t)); 
	 // cellIDPtr = reinterpret_cast<UShort_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Float_t) + sizeof(Short_t)); 
	  //cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellAmpFracPtr) + sizeof(Short_t) + sizeof(Float_t));
 	  cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Short_t));
 	  
	  digitIndexPtr++;
	  
	}

      totSize += tmpSize;

      caloClusterPtr->fEnergy = recPointPtr->fAmp;

      if(fDoClusterFit)
	{
	  FitCluster(recPointPtr);
	}
      else
	{
	  caloClusterPtr->fDispersion = 0;
	  caloClusterPtr->fFitQuality = 0;
	  caloClusterPtr->fM20 = 0;
	  caloClusterPtr->fM02 = 0;

	}
      if(fHaveCPVInfo)
	{
	  caloClusterPtr->fEmcCpvDistance = GetCPVDistance(recPointPtr);
	}
      else
	{
	  caloClusterPtr->fEmcCpvDistance = -1;
	}
      if(fDoPID)
	{
	  DoParticleIdentification(caloClusterPtr);
	}
      else
	{
	  for(Int_t k = 0; k < AliPID::kSPECIESN; k++)
	    {
	      caloClusterPtr->fPID[k] = 0;
	    }
	}
      if(fHaveDistanceToBadChannel)
	{
	  caloClusterPtr->fDistanceToBadChannel = GetDistanceToBadChannel(caloClusterPtr);
	}
      else
	{
	  caloClusterPtr->fDistanceToBadChannel = -1;
	}

      caloClusterPtr->fClusterType = fClusterType;
	  //totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells)*(sizeof(Short_t) +sizeof(Float_t)-1);   
      //totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));   
      //printf("CaloClusterPtr: %x, energy: %f\n", caloClusterPtr, caloClusterPtr->fEnergy);
      
      //      caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellAmpFracPtr);
      //caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
      fCaloClusterDataPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
      recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
      //digitPtr = &(recPointPtr->fDigits);  
    }

return fNRecPoints;

}
Commit	Line	Data
ea367f6a	1	// $Id: AliHLTCaloClusterAnalyser.cxx 35107 2009-09-30 01:45:06Z phille $
	2
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* All rights reserved. *
	6	* *
	7	* Primary Authors: Oystein Djuvsland *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/**
	19	* @file AliHLTCaloClusterAnalyser.cxx
	20	* @author Oystein Djuvsland
	21	* @date
	22	* @brief Cluster analyser for Calo HLT
	23	*/
	24
	25	// see header file for class documentation
	26	// or
	27	// refer to README to build package
	28	// or
	29	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	30
	31	#include "AliHLTCaloClusterAnalyser.h"
	32	#include "AliHLTCaloRecPointHeaderStruct.h"
	33	#include "AliHLTCaloRecPointDataStruct.h"
	34	#include "AliHLTCaloClusterDataStruct.h"
	35	//#include "AliHLTCaloPhysicsAnalyzer.h"
7c80a370	36	#include "AliHLTCaloGeometry.h"
ea367f6a	37	#include "AliESDCaloCluster.h"
	38	#include "TMath.h"
	39	#include "TVector3.h"
73d6f579	40	#include "TH1F.h"
73d6f579	41	#include "TFile.h"
7c80a370	42	#include "AliHLTCaloClusterizer.h"
ea367f6a	43
	44	ClassImp(AliHLTCaloClusterAnalyser);
	45
7c80a370	46	AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() :
ea367f6a	47	// AliHLTCaloBase(),
7c80a370	48	fLogWeight(4.5),
	49	fRecPointArray(0),
	50	fDigitDataArray(0),
ea367f6a	51	fNRecPoints(0),
	52	fCaloClusterDataPtr(0),
	53	fCaloClusterHeaderPtr(0),
ea367f6a	54	//fAnalyzerPtr(0),
	55	fDoClusterFit(false),
	56	fHaveCPVInfo(false),
	57	fDoPID(false),
7c80a370	58	fHaveDistanceToBadChannel(false),
73d6f579	59	fGeometry(0),
73d6f579	60	fClusterType(AliESDCaloCluster::kPHOSCluster)
ea367f6a	61	{
ea367f6a	62	//See header file for documentation
ea367f6a	63	}
	64
	65	AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser()
	66	{
98baf84d	67	// See header file for class documentation
ea367f6a	68	}
	69
	70	void
7c80a370	71	AliHLTCaloClusterAnalyser::SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
ea367f6a	72	{
	73	//see header file for documentation
	74	fCaloClusterDataPtr = caloClusterDataPtr;
	75	}
7c80a370	76
ea367f6a	77	void
7c80a370	78	AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints)
ea367f6a	79	{
7c80a370	80	fRecPointArray = recPointDataPtr;
	81	fNRecPoints = nRecPoints;
	82	}
	83
	84	void
	85	AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct *digits)
	86	{
	87	// AliHLTCaloClusterizer cl("PHOS");
	88	// cl.CheckDigits(fRecPointArray, digits, fNRecPoints);
	89	fDigitDataArray = digits;
	90	//cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
ea367f6a	91	}
	92
	93	Int_t
	94	AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
	95	{
	96	//see header file for documentation
	97	Float_t wtot = 0.;
	98	Float_t x = 0.;
	99	Float_t z = 0.;
	100	Float_t xi = 0.;
	101	Float_t zi = 0.;
	102
	103	AliHLTCaloDigitDataStruct *digit = 0;
ea367f6a	104
	105	UInt_t iDigit = 0;
	106
	107	for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++)
	108	{
7c80a370	109	AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
ad44d760	110	// digit = &(recPoint->fDigits);
98baf84d	111
7c80a370	112	Int_t *digitIndexPtr = &(recPoint->fDigits);
7c80a370	113
ea367f6a	114	for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
ea367f6a	115	{
7c80a370	116
7c80a370	117	digit = &(fDigitDataArray[*digitIndexPtr]);
98baf84d	118
a6db7bcd	119	xi = digit->fX+0.5;
a6db7bcd	120	zi = digit->fZ+0.5;
98baf84d	121
ea367f6a	122	if (recPoint->fAmp > 0 && digit->fEnergy > 0)
	123	{
	124	Float_t w = TMath::Max( 0., fLogWeight + TMath::Log( digit->fEnergy / recPoint->fAmp ) ) ;
	125	x += xi * w ;
	126	z += zi * w ;
	127	wtot += w ;
	128	}
7c80a370	129	digitIndexPtr++;
ea367f6a	130	}
98baf84d	131
ea367f6a	132	if (wtot>0)
	133	{
	134	recPoint->fX = x/wtot ;
	135	recPoint->fZ = z/wtot ;
	136	}
	137	else
	138	{
	139	recPoint->fAmp = 0;
	140	}
ea367f6a	141	}
	142	return 0;
	143	}
	144
	145
	146	Int_t
	147	AliHLTCaloClusterAnalyser::CalculateRecPointMoments()
cd9e2797	148	{
ea367f6a	149	//See header file for documentation
	150	return 0;
	151	}
	152
	153	Int_t
	154	AliHLTCaloClusterAnalyser::CalculateClusterMoments(AliHLTCaloRecPointDataStruct /recPointPtr/, AliHLTCaloClusterDataStruct /clusterPtr/)
	155	{
	156	//See header file for documentation
	157	return 0;
	158	}
	159
	160
	161	Int_t
	162	AliHLTCaloClusterAnalyser::DeconvoluteClusters()
	163	{
	164	//See header file for documentation
	165	return 0;
	166	}
	167
	168	Int_t
7c80a370	169	AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize)
ea367f6a	170	{
	171	//See header file for documentation
	172
73d6f579	173
b4479a87	174	totSize += sizeof(AliHLTCaloClusterDataStruct);
7c80a370	175	fNRecPoints = nRecPoints;
	176
	177	if(fGeometry == 0)
	178	{
	179	HLTError("No geometry object is initialised, creation of clusters stopped");
	180	}
	181
	182	CalculateCenterOfGravity();
	183
ad44d760	184	// AliHLTCaloDigitDataStruct* digitPtr = &(recPointPtr->fDigits);
	185	AliHLTCaloDigitDataStruct* digitPtr = 0;
	186
73d6f579	187	AliHLTCaloClusterDataStruct* caloClusterPtr = 0;
	188	UShort_t* cellIDPtr = 0;
	189	Float_t* cellAmpFracPtr = 0;;
ea367f6a	190
98baf84d	191	// Int_t id = -1;
ea367f6a	192	TVector3 globalPos;
	193
	194	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
	195	{
73d6f579	196	if((availableSize - totSize) < sizeof(AliHLTCaloClusterDataStruct))
73d6f579	197	{
9a0cbaba	198	HLTError("Out of buffer: available size is: %d, total size used: %d", availableSize, totSize);
73d6f579	199	return -ENOBUFS;
	200	}
	201
	202	caloClusterPtr = fCaloClusterDataPtr;
	203
	204	cellIDPtr = &(caloClusterPtr->fCellsAbsId);
	205	cellAmpFracPtr = &(caloClusterPtr->fCellsAmpFraction);
	206
7c80a370	207	AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
7c80a370	208
	209	AliHLTCaloGlobalCoordinate globalCoord;
	210	fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);
ea367f6a	211
a6db7bcd	212	caloClusterPtr->fGlobalPos[0] = globalCoord.fX;
cd9e2797	213	caloClusterPtr->fGlobalPos[1] = globalCoord.fY;
a6db7bcd	214	caloClusterPtr->fGlobalPos[2] = globalCoord.fZ;
ea367f6a	215
ee72b4e5	216	HLTDebug("Cluster local position: x = %f, z = %f, module = %d", recPointPtr->fX, recPointPtr->fZ, recPointPtr->fModule);
	217	HLTDebug("Cluster global position: x = %f, y = %f, z = %f", globalCoord.fX, globalCoord.fY, globalCoord.fZ);
	218
9a0cbaba	219	caloClusterPtr->fNCells = 0;//recPointPtr->fMultiplicity;
9a0cbaba	220	//caloClusterPtr->fNCells = recPointPtr->fMultiplicity;
cd9e2797	221
a6db7bcd	222	caloClusterPtr->fClusterType = fClusterType;
9a0cbaba	223	Int_t tmpSize = 0;//totSize + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
a6db7bcd	224
2a24cbbe	225	//TODO remove hardcoded 10;
	226	memset(caloClusterPtr->fTracksMatched, 0xff, sizeof(Int_t)*10);
	227
9a0cbaba	228	//Int_t tmpSize = totSize + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
9a0cbaba	229	// Int_t tmpSize = (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
cd9e2797	230
73d6f579	231	if((availableSize - totSize) < tmpSize)
73d6f579	232	{
9a0cbaba	233	HLTError("Out of buffer, available size is: %d, total size used: %d, extra size needed: %d", availableSize, totSize, tmpSize);
73d6f579	234	return -ENOBUFS;
73d6f579	235	}
cd9e2797	236	Int_t *digitIndexPtr = &(recPointPtr->fDigits);
	237	Int_t id = 0;
	238
ea367f6a	239	for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
ea367f6a	240	{
cd9e2797	241	digitPtr = &(fDigitDataArray[*digitIndexPtr]);
cd9e2797	242	id++;
936dbe15	243	fGeometry->GetCellAbsId(recPointPtr->fModule, digitPtr->fX, digitPtr->fZ, id);
cd9e2797	244	*cellIDPtr = id;
	245	*cellAmpFracPtr = digitPtr->fEnergy/recPointPtr->fAmp;
	246	//printf("Cell ID pointer: %x\n", cellIDPtr);
	247	//printf("Cell Amp Pointer: %x\n", cellAmpFracPtr);
9a0cbaba	248	//printf("Cell pos: x = %d, z = %d\n", digitPtr->fX, digitPtr->fZ);
	249	//printf("Cell ID: %d, pointer: %x\n", *cellIDPtr, cellIDPtr);
	250	//printf("Cell Amp: %f, pointer: %x\n", *cellAmpFracPtr, cellAmpFracPtr);
	251	digitPtr++;
	252	cellIDPtr = reinterpret_cast<UShort_t>(reinterpret_cast<char>(cellAmpFracPtr) + sizeof(Float_t));
	253	// cellIDPtr = reinterpret_cast<UShort_t>(reinterpret_cast<char>(cellIDPtr) + sizeof(Float_t) + sizeof(Short_t));
	254	//cellAmpFracPtr = reinterpret_cast<Float_t>(reinterpret_cast<char>(cellAmpFracPtr) + sizeof(Short_t) + sizeof(Float_t));
	255	cellAmpFracPtr = reinterpret_cast<Float_t>(reinterpret_cast<char>(cellIDPtr) + sizeof(Short_t));
cd9e2797	256
	257	digitIndexPtr++;
	258
ea367f6a	259	}
ea367f6a	260
73d6f579	261	totSize += tmpSize;
73d6f579	262
ea367f6a	263	caloClusterPtr->fEnergy = recPointPtr->fAmp;
73d6f579	264
ea367f6a	265	if(fDoClusterFit)
	266	{
	267	FitCluster(recPointPtr);
	268	}
	269	else
	270	{
	271	caloClusterPtr->fDispersion = 0;
	272	caloClusterPtr->fFitQuality = 0;
	273	caloClusterPtr->fM20 = 0;
	274	caloClusterPtr->fM02 = 0;
	275
	276	}
	277	if(fHaveCPVInfo)
	278	{
	279	caloClusterPtr->fEmcCpvDistance = GetCPVDistance(recPointPtr);
	280	}
	281	else
	282	{
	283	caloClusterPtr->fEmcCpvDistance = -1;
	284	}
	285	if(fDoPID)
	286	{
	287	DoParticleIdentification(caloClusterPtr);
	288	}
	289	else
	290	{
	291	for(Int_t k = 0; k < AliPID::kSPECIESN; k++)
	292	{
	293	caloClusterPtr->fPID[k] = 0;
	294	}
	295	}
	296	if(fHaveDistanceToBadChannel)
	297	{
	298	caloClusterPtr->fDistanceToBadChannel = GetDistanceToBadChannel(caloClusterPtr);
	299	}
	300	else
	301	{
	302	caloClusterPtr->fDistanceToBadChannel = -1;
	303	}
	304
73d6f579	305	caloClusterPtr->fClusterType = fClusterType;
cd9e2797	306	//totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells)*(sizeof(Short_t) +sizeof(Float_t)-1);
73d6f579	307	//totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
cd9e2797	308	//printf("CaloClusterPtr: %x, energy: %f\n", caloClusterPtr, caloClusterPtr->fEnergy);
cd9e2797	309
ea367f6a	310	// caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellAmpFracPtr);
cd9e2797	311	//caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
cd9e2797	312	fCaloClusterDataPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
ea367f6a	313	recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
73d6f579	314	//digitPtr = &(recPointPtr->fDigits);
ea367f6a	315	}
98baf84d	316
98baf84d	317	return fNRecPoints;
ea367f6a	318
	319	}
	320