[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloDigitMaker.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
 * @file   AliHLTCALOClusterizer.cxx\r
 * @author Oystein Djuvsland\r
 * @date \r
 * @brief  Digit maker for CALO HLT  \r
 */\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 "AliHLTCaloDigitMaker.h"\r
#include "AliHLTCaloConstantsHandler.h"\r
#include "AliHLTCaloMapper.h"\r
#include "AliHLTCaloChannelDataStruct.h"\r
#include "AliHLTCaloChannelDataHeaderStruct.h"\r
#include "AliHLTCaloDigitDataStruct.h"\r
#include "AliHLTCaloCoordinate.h"\r
#include "AliHLTCaloSharedMemoryInterfacev2.h" // added by PTH\r
//#include "AliPHOSEMCAGeometry.h"\r
#include "TH2F.h"\r
#include "AliHLTCaloConstants.h"\r
#include "AliHLTLogging.h"\r
\r
ClassImp(AliHLTCaloDigitMaker);\r
\r
//using namespace CaloHLTConst;\r
\r
AliHLTCaloDigitMaker::AliHLTCaloDigitMaker(TString det) :\r
  AliHLTCaloConstantsHandler(det),\r
  AliHLTLogging(),\r
  fShmPtr(0),\r
  fDigitStructPtr(0),\r
  fDigitCount(0),\r
  fMapperPtr(0),\r
  fHighGainFactors(0),\r
  fLowGainFactors(0),\r
  fBadChannelMask(0),\r
  fChannelBook(0),\r
  fMaxEnergy(900),\r
  fMinTime(0.0),\r
  fMaxTime(1008.0)\r
{\r
  // See header file for documentation\r
\r
  fShmPtr = new AliHLTCaloSharedMemoryInterfacev2(det);\r
\r
  fHighGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];\r
  fLowGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];\r
  \r
  fBadChannelMask = new Bool_t**[fCaloConstants->GetNXCOLUMNSMOD()];\r
  \r
  fChannelBook= new AliHLTCaloDigitDataStruct**[fCaloConstants->GetNXCOLUMNSMOD()];\r
  \r
  for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
    {\r
      fHighGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];\r
      fLowGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];\r
\r
      fBadChannelMask[x] = new Bool_t*[fCaloConstants->GetNZROWSMOD()];\r
\r
      fChannelBook[x] = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNZROWSMOD()];\r
\r
      for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	{\r
\r
	  fHighGainFactors[x][z] = 0.0153;\r
	  fLowGainFactors[x][z] = 0.245;\r
	 \r
	  fBadChannelMask[x][z] = new Bool_t[fCaloConstants->GetNGAINS()];\r
	  fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;\r
	  fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false; \r
	  \r
	  fChannelBook[x][z] = 0;\r
	  \r
	}\r
    }	  \r
}\r
\r
AliHLTCaloDigitMaker::~AliHLTCaloDigitMaker() \r
{\r
  //See header file for documentation\r
  delete [] fHighGainFactors;\r
  delete [] fLowGainFactors;\r
  delete [] fBadChannelMask;  \r
  delete [] fChannelBook;\r
  delete fShmPtr;\r
\r
}\r
\r
Int_t\r
AliHLTCaloDigitMaker::MakeDigits(AliHLTCaloChannelDataHeaderStruct* channelDataHeader, AliHLTUInt32_t availableSize)\r
{\r
  //See header file for documentation\r
  \r
  Reset();\r
\r
  UInt_t totSize = sizeof(AliHLTCaloDigitDataStruct);\r
  \r
//   Int_t xMod = -1;\r
//   Int_t zMod = -1;\r
  \r
\r
  AliHLTCaloCoordinate coord;\r
  \r
  \r
  AliHLTCaloChannelDataStruct* currentchannel = 0;\r
  \r
  fShmPtr->SetMemory(channelDataHeader);\r
  currentchannel = fShmPtr->NextChannel();\r
\r
  while(currentchannel != 0)\r
    {\r
      if(availableSize < totSize) return -1;\r
\r
      fMapperPtr->ChannelId2Coordinate(currentchannel->fChannelID, coord);\r
      \r
      //      fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);\r
      if(UseDigit(coord, currentchannel))\r
      {\r
	AddDigit(currentchannel, coord);\r
	//	j++;	      \r
	totSize += sizeof(AliHLTCaloDigitDataStruct);\r
      }\r
      currentchannel = fShmPtr->NextChannel(); // Get the next channel\r
    }\r
//       if(currentchannel)\r
// 	{\r
// 	  fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);\r
// 	  if(UseDigit(coord1, currentchannel))\r
// 	    {\r
// 	      AddDigit(currentchannel, coord1, locCoord);\r
// 	      j++;	      \r
// 	      totSize += sizeof(AliHLTCaloDigitDataStruct);\r
// 	    }\r
// 	  currentchannel = fShmPtr->NextChannel(); // Get the next channel\r
// 	}\r
//     }\r
   \r
//   fDigitCount += j;\r
   return fDigitCount; \r
}\r
\r
void \r
AliHLTCaloDigitMaker::SetGlobalHighGainFactor(Float_t factor)\r
{\r
  //See header file for documentation\r
  for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
    {\r
      for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	{\r
	  fHighGainFactors[x][z] = factor;\r
	}\r
    }\r
}\r
\r
\r
void\r
AliHLTCaloDigitMaker::SetGlobalLowGainFactor(Float_t factor)\r
{\r
  //See header file for documentation\r
  for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
    {\r
      for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	{\r
	  fLowGainFactors[x][z] = factor;\r
	}\r
    }\r
}\r
\r
\r
void\r
AliHLTCaloDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)\r
{\r
 for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
    {\r
      for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	{\r
	  if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)\r
	    {\r
	      fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = true;\r
	    }\r
	  else\r
	    {\r
	      fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;\r
	    }\r
	  if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)\r
	    {\r
	      fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;\r
	    }\r
	  else\r
	    {\r
	      fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;\r
	    }\r
	}\r
    }\r
}\r
\r
void\r
AliHLTCaloDigitMaker::Reset()\r
{\r
  fDigitCount = 0;\r
  for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
    {\r
      for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	{\r
	  fChannelBook[x][z] = 0;\r
	}\r
    }	  \r
\r
}\r
\r
\r
void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, AliHLTCaloCoordinate &coord)\r
{\r
\r
  // Some book keeping of the pointers\r
  AliHLTCaloDigitDataStruct *tmpDigit = fDigitStructPtr + 1;\r
\r
  // Check if we already have a digit in this position, and correct the book keeping correspondently\r
  if(fChannelBook[coord.fX][coord.fZ]) \r
    {\r
      tmpDigit = fDigitStructPtr;\r
      fDigitStructPtr = fChannelBook[coord.fX][coord.fZ];\r
      fDigitCount--;\r
      //      printf("Going to overwrite digit: x = %d, z = %d, gain = %d, energy = %f\n", fDigitStructPtr->fX, fDigitStructPtr->fZ, fDigitStructPtr->fGain, fDigitStructPtr->fEnergy);\r
    }\r
  \r
  fChannelBook[coord.fX][coord.fZ] = fDigitStructPtr;\r
 \r
  fDigitStructPtr->fX = coord.fX;\r
  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
  if(coord.fGain == fCaloConstants->GetHIGHGAIN() )\r
    {\r
      fDigitStructPtr->fEnergy = channelData->fEnergy*fHighGainFactors[coord.fX][coord.fZ];\r
      fDigitStructPtr->fHgPresent = true;\r
      if(channelData->fEnergy >= fMaxEnergy)\r
	{\r
	  fDigitStructPtr->fOverflow = true;\r
	}\r
      \r
      HLTDebug("HG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f \n", \r
	       coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy);\r
    }\r
  else\r
    {\r
      fDigitStructPtr->fEnergy = channelData->fEnergy*fLowGainFactors[coord.fX][coord.fZ];\r
      if(channelData->fEnergy >= fMaxEnergy)\r
	{\r
	  fDigitStructPtr->fOverflow = true;\r
	}\r
      HLTDebug("LG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f\n", coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy); \r
    }\r
  fDigitStructPtr->fTime = channelData->fTime * 0.0000001; //TODO\r
  fDigitStructPtr->fCrazyness = channelData->fCrazyness;\r
  fDigitStructPtr->fModule = coord.fModuleId;\r
  fDigitStructPtr = tmpDigit;\r
  //  fDigitStructPtr++;\r
  fDigitCount++;\r
}\r
\r
bool AliHLTCaloDigitMaker::UseDigit(AliHLTCaloCoordinate &channelCoordinates, AliHLTCaloChannelDataStruct *channel) \r
{\r
   \r
   if(fBadChannelMask[channelCoordinates.fX][channelCoordinates.fZ][0] == true) return false;\r
   if(channel->fTime < fMinTime || channel->fTime > fMaxTime) return false;\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
  if(tmpDigit)\r
    {\r
      if(channelCoordinates.fGain == fCaloConstants->GetLOWGAIN())\r
	{\r
	  	  //printf("UseDigit: Already have digit with, x: %d, z: %d, with high gain \n", channelCoordinates.fX, channelCoordinates.fZ);\r
	  if(tmpDigit->fOverflow)\r
	    {\r
	      	     // printf("But it was in overflow! Let's use this low gain!\n");\r
	      return true;\r
	    }\r
	  return false;\r
	}\r
      else\r
	{\r
	  	  //printf("UseDigit: Already have digit with, x: %d, z: %d, with low gain: %d\n", channelCoordinates.fX, channelCoordinates.fZ);\r
	  if(channel->fEnergy > fMaxEnergy )\r
	    {\r
	      tmpDigit->fHgPresent = true;\r
	      return false;\r
	    }\r
	  return true;\r
	}\r
    }\r
  return true;\r
}\r
\r
void AliHLTCaloDigitMaker::SetBadChannel(Int_t x, Int_t z, Bool_t bad)\r
{\r
   // See header file for class documentation\r
   fBadChannelMask[x][z][0] = bad;\r
   fBadChannelMask[x][z][1] = bad;\r
}\r
\r
void AliHLTCaloDigitMaker::SetGain(Int_t x, Int_t z, Float_t ratio, Float_t gain)\r
{\r
   // See header file for class documentation\r
   HLTDebug("Applying gain: %f for channel x: %d, z: %d", gain, x, z); \r
   fHighGainFactors[x][z] = gain;\r
   fLowGainFactors[x][z] = gain * ratio;\r
   \r
}\r
Commit	Line	Data
	1	// $Id$\r
	2	\r
	3	/**************************************************************************\r
	4	* This file is property of and copyright by the ALICE HLT Project * \r
	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
	14	* about the suitability of this software for any purpose. It is * \r
	15	* provided "as is" without express or implied warranty. *\r
	16	**************************************************************************/\r
	17	/** \r
	18	* @file AliHLTCALOClusterizer.cxx\r
	19	* @author Oystein Djuvsland\r
	20	* @date \r
	21	* @brief Digit maker for CALO HLT \r
	22	*/\r
	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 "AliHLTCaloDigitMaker.h"\r
	32	#include "AliHLTCaloConstantsHandler.h"\r
	33	#include "AliHLTCaloMapper.h"\r
	34	#include "AliHLTCaloChannelDataStruct.h"\r
	35	#include "AliHLTCaloChannelDataHeaderStruct.h"\r
	36	#include "AliHLTCaloDigitDataStruct.h"\r
	37	#include "AliHLTCaloCoordinate.h"\r
	38	#include "AliHLTCaloSharedMemoryInterfacev2.h" // added by PTH\r
	39	//#include "AliPHOSEMCAGeometry.h"\r
	40	#include "TH2F.h"\r
	41	#include "AliHLTCaloConstants.h"\r
	42	#include "AliHLTLogging.h"\r
	43	\r
	44	ClassImp(AliHLTCaloDigitMaker);\r
	45	\r
	46	//using namespace CaloHLTConst;\r
	47	\r
	48	AliHLTCaloDigitMaker::AliHLTCaloDigitMaker(TString det) :\r
	49	AliHLTCaloConstantsHandler(det),\r
	50	AliHLTLogging(),\r
	51	fShmPtr(0),\r
	52	fDigitStructPtr(0),\r
	53	fDigitCount(0),\r
	54	fMapperPtr(0),\r
	55	fHighGainFactors(0),\r
	56	fLowGainFactors(0),\r
	57	fBadChannelMask(0),\r
	58	fChannelBook(0),\r
	59	fMaxEnergy(900),\r
	60	fMinTime(0.0),\r
	61	fMaxTime(1008.0)\r
	62	{\r
	63	// See header file for documentation\r
	64	\r
	65	fShmPtr = new AliHLTCaloSharedMemoryInterfacev2(det);\r
	66	\r
	67	fHighGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];\r
	68	fLowGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];\r
	69	\r
	70	fBadChannelMask = new Bool_t**[fCaloConstants->GetNXCOLUMNSMOD()];\r
	71	\r
	72	fChannelBook= new AliHLTCaloDigitDataStruct**[fCaloConstants->GetNXCOLUMNSMOD()];\r
	73	\r
	74	for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
	75	{\r
	76	fHighGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];\r
	77	fLowGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];\r
	78	\r
	79	fBadChannelMask[x] = new Bool_t*[fCaloConstants->GetNZROWSMOD()];\r
	80	\r
	81	fChannelBook[x] = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNZROWSMOD()];\r
	82	\r
	83	for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	84	{\r
	85	\r
	86	fHighGainFactors[x][z] = 0.0153;\r
	87	fLowGainFactors[x][z] = 0.245;\r
	88	\r
	89	fBadChannelMask[x][z] = new Bool_t[fCaloConstants->GetNGAINS()];\r
	90	fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;\r
	91	fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false; \r
	92	\r
	93	fChannelBook[x][z] = 0;\r
	94	\r
	95	}\r
	96	} \r
	97	}\r
	98	\r
	99	AliHLTCaloDigitMaker::~AliHLTCaloDigitMaker() \r
	100	{\r
	101	//See header file for documentation\r
	102	delete [] fHighGainFactors;\r
	103	delete [] fLowGainFactors;\r
	104	delete [] fBadChannelMask; \r
	105	delete [] fChannelBook;\r
	106	delete fShmPtr;\r
	107	\r
	108	}\r
	109	\r
	110	Int_t\r
	111	AliHLTCaloDigitMaker::MakeDigits(AliHLTCaloChannelDataHeaderStruct* channelDataHeader, AliHLTUInt32_t availableSize)\r
	112	{\r
	113	//See header file for documentation\r
	114	\r
	115	Reset();\r
	116	\r
	117	UInt_t totSize = sizeof(AliHLTCaloDigitDataStruct);\r
	118	\r
	119	// Int_t xMod = -1;\r
	120	// Int_t zMod = -1;\r
	121	\r
	122	\r
	123	AliHLTCaloCoordinate coord;\r
	124	\r
	125	\r
	126	AliHLTCaloChannelDataStruct* currentchannel = 0;\r
	127	\r
	128	fShmPtr->SetMemory(channelDataHeader);\r
	129	currentchannel = fShmPtr->NextChannel();\r
	130	\r
	131	while(currentchannel != 0)\r
	132	{\r
	133	if(availableSize < totSize) return -1;\r
	134	\r
	135	fMapperPtr->ChannelId2Coordinate(currentchannel->fChannelID, coord);\r
	136	\r
	137	// fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);\r
	138	if(UseDigit(coord, currentchannel))\r
	139	{\r
	140	AddDigit(currentchannel, coord);\r
	141	// j++; \r
	142	totSize += sizeof(AliHLTCaloDigitDataStruct);\r
	143	}\r
	144	currentchannel = fShmPtr->NextChannel(); // Get the next channel\r
	145	}\r
	146	// if(currentchannel)\r
	147	// {\r
	148	// fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);\r
	149	// if(UseDigit(coord1, currentchannel))\r
	150	// {\r
	151	// AddDigit(currentchannel, coord1, locCoord);\r
	152	// j++; \r
	153	// totSize += sizeof(AliHLTCaloDigitDataStruct);\r
	154	// }\r
	155	// currentchannel = fShmPtr->NextChannel(); // Get the next channel\r
	156	// }\r
	157	// }\r
	158	\r
	159	// fDigitCount += j;\r
	160	return fDigitCount; \r
	161	}\r
	162	\r
	163	void \r
	164	AliHLTCaloDigitMaker::SetGlobalHighGainFactor(Float_t factor)\r
	165	{\r
	166	//See header file for documentation\r
	167	for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
	168	{\r
	169	for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	170	{\r
	171	fHighGainFactors[x][z] = factor;\r
	172	}\r
	173	}\r
	174	}\r
	175	\r
	176	\r
	177	void\r
	178	AliHLTCaloDigitMaker::SetGlobalLowGainFactor(Float_t factor)\r
	179	{\r
	180	//See header file for documentation\r
	181	for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
	182	{\r
	183	for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	184	{\r
	185	fLowGainFactors[x][z] = factor;\r
	186	}\r
	187	}\r
	188	}\r
	189	\r
	190	\r
	191	void\r
	192	AliHLTCaloDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)\r
	193	{\r
	194	for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
	195	{\r
	196	for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	197	{\r
	198	if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)\r
	199	{\r
	200	fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = true;\r
	201	}\r
	202	else\r
	203	{\r
	204	fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;\r
	205	}\r
	206	if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)\r
	207	{\r
	208	fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;\r
	209	}\r
	210	else\r
	211	{\r
	212	fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;\r
	213	}\r
	214	}\r
	215	}\r
	216	}\r
	217	\r
	218	void\r
	219	AliHLTCaloDigitMaker::Reset()\r
	220	{\r
	221	fDigitCount = 0;\r
	222	for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)\r
	223	{\r
	224	for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)\r
	225	{\r
	226	fChannelBook[x][z] = 0;\r
	227	}\r
	228	} \r
	229	\r
	230	}\r
	231	\r
	232	\r
	233	void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, AliHLTCaloCoordinate &coord)\r
	234	{\r
	235	\r
	236	// Some book keeping of the pointers\r
	237	AliHLTCaloDigitDataStruct *tmpDigit = fDigitStructPtr + 1;\r
	238	\r
	239	// Check if we already have a digit in this position, and correct the book keeping correspondently\r
	240	if(fChannelBook[coord.fX][coord.fZ]) \r
	241	{\r
	242	tmpDigit = fDigitStructPtr;\r
	243	fDigitStructPtr = fChannelBook[coord.fX][coord.fZ];\r
	244	fDigitCount--;\r
	245	// printf("Going to overwrite digit: x = %d, z = %d, gain = %d, energy = %f\n", fDigitStructPtr->fX, fDigitStructPtr->fZ, fDigitStructPtr->fGain, fDigitStructPtr->fEnergy);\r
	246	}\r
	247	\r
	248	fChannelBook[coord.fX][coord.fZ] = fDigitStructPtr;\r
	249	\r
	250	fDigitStructPtr->fX = coord.fX;\r
	251	fDigitStructPtr->fZ = coord.fZ;\r
	252	fDigitStructPtr->fGain = coord.fGain;\r
	253	fDigitStructPtr->fOverflow = false;\r
	254	fDigitStructPtr->fAssociatedCluster = -1;\r
	255	\r
	256	fDigitStructPtr->fID = fDigitStructPtr->fZ * fCaloConstants->GetNXCOLUMNSMOD() + fDigitStructPtr->fX;\r
	257	\r
	258	if(coord.fGain == fCaloConstants->GetHIGHGAIN() )\r
	259	{\r
	260	fDigitStructPtr->fEnergy = channelData->fEnergy*fHighGainFactors[coord.fX][coord.fZ];\r
	261	fDigitStructPtr->fHgPresent = true;\r
	262	if(channelData->fEnergy >= fMaxEnergy)\r
	263	{\r
	264	fDigitStructPtr->fOverflow = true;\r
	265	}\r
	266	\r
	267	HLTDebug("HG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f \n", \r
	268	coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy);\r
	269	}\r
	270	else\r
	271	{\r
	272	fDigitStructPtr->fEnergy = channelData->fEnergy*fLowGainFactors[coord.fX][coord.fZ];\r
	273	if(channelData->fEnergy >= fMaxEnergy)\r
	274	{\r
	275	fDigitStructPtr->fOverflow = true;\r
	276	}\r
	277	HLTDebug("LG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f\n", coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy); \r
	278	}\r
	279	fDigitStructPtr->fTime = channelData->fTime * 0.0000001; //TODO\r
	280	fDigitStructPtr->fCrazyness = channelData->fCrazyness;\r
	281	fDigitStructPtr->fModule = coord.fModuleId;\r
	282	fDigitStructPtr = tmpDigit;\r
	283	// fDigitStructPtr++;\r
	284	fDigitCount++;\r
	285	}\r
	286	\r
	287	bool AliHLTCaloDigitMaker::UseDigit(AliHLTCaloCoordinate &channelCoordinates, AliHLTCaloChannelDataStruct *channel) \r
	288	{\r
	289	\r
	290	if(fBadChannelMask[channelCoordinates.fX][channelCoordinates.fZ][0] == true) return false;\r
	291	if(channel->fTime < fMinTime \|\| channel->fTime > fMaxTime) return false;\r
	292	\r
	293	AliHLTCaloDigitDataStruct *tmpDigit = fChannelBook[channelCoordinates.fX][channelCoordinates.fZ];\r
	294	//printf("UseDigit: Got digit, x: %d, z: %d, gain: %d, amp: %f\n", channelCoordinates.fX, channelCoordinates.fZ, channelCoordinates.fGain, channel->fEnergy);\r
	295	if(tmpDigit)\r
	296	{\r
	297	if(channelCoordinates.fGain == fCaloConstants->GetLOWGAIN())\r
	298	{\r
	299	//printf("UseDigit: Already have digit with, x: %d, z: %d, with high gain \n", channelCoordinates.fX, channelCoordinates.fZ);\r
	300	if(tmpDigit->fOverflow)\r
	301	{\r
	302	// printf("But it was in overflow! Let's use this low gain!\n");\r
	303	return true;\r
	304	}\r
	305	return false;\r
	306	}\r
	307	else\r
	308	{\r
	309	//printf("UseDigit: Already have digit with, x: %d, z: %d, with low gain: %d\n", channelCoordinates.fX, channelCoordinates.fZ);\r
	310	if(channel->fEnergy > fMaxEnergy )\r
	311	{\r
	312	tmpDigit->fHgPresent = true;\r
	313	return false;\r
	314	}\r
	315	return true;\r
	316	}\r
	317	}\r
	318	return true;\r
	319	}\r
	320	\r
	321	void AliHLTCaloDigitMaker::SetBadChannel(Int_t x, Int_t z, Bool_t bad)\r
	322	{\r
	323	// See header file for class documentation\r
	324	fBadChannelMask[x][z][0] = bad;\r
	325	fBadChannelMask[x][z][1] = bad;\r
	326	}\r
	327	\r
	328	void AliHLTCaloDigitMaker::SetGain(Int_t x, Int_t z, Float_t ratio, Float_t gain)\r
	329	{\r
	330	// See header file for class documentation\r
	331	HLTDebug("Applying gain: %f for channel x: %d, z: %d", gain, x, z); \r
	332	fHighGainFactors[x][z] = gain;\r
	333	fLowGainFactors[x][z] = gain * ratio;\r
	334	\r
	335	}\r