[u/mrichter/AliRoot.git] / EMCAL / AliEMCALDigit.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/* $Id$ */

//_________________________________________________________________________
//  EMCAL digit: 
//      A Digit is the sum of the energy lost in an EMCAL Tower
//      It also stores information on Primary, and enterring particle
//      tracknumbers Digits are created using AliEMCALSDigitizer, followed
//      by AliEMCALDigitizer 
//
//*-- Author: Sahal Yacoob (LBL)
// based on : AliPHOSDigit
//__________________________________________________________________________

// --- ROOT system ---
#include <Riostream.h>
#include <TMath.h>

// --- Standard library ---

// --- AliRoot header files ---

#include "AliEMCALDigit.h"
#include "AliEMCALGeometry.h"

ClassImp(AliEMCALDigit)

//____________________________________________________________________________
AliEMCALDigit::AliEMCALDigit() :  
  AliDigitNew(),
  fNprimary(0),
  fNMaxPrimary(5),
  fPrimary(0x0),
  fDEPrimary(0x0),
  fNiparent(0),
  fNMaxiparent(5), 
  fIparent(0x0),
  fDEParent(0x0),
  fMaxIter(0),
  fTime(0.), 
  fTimeR(0.) 

{
  // default ctor 

  // Need to initialise for reading old files
  fPrimary = new Int_t[fNMaxPrimary] ;
  fDEPrimary = new Float_t[fNMaxPrimary] ;
  fIparent = new Int_t[fNMaxiparent] ; 
  fDEParent = new Float_t[fNMaxiparent] ; 
  for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
    fPrimary[i]  = -1 ;
    fDEPrimary[i]  = 0 ;
  } 

  for ( Int_t i = 0; i < fNMaxiparent ; i++) {
    fIparent[i] = -1 ;
    fDEParent[i] = 0 ;
  }
}

//____________________________________________________________________________
AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Int_t DigEnergy, Float_t time, Int_t index, Float_t dE) 
  : AliDigitNew(),
    fNprimary(0),
    fNMaxPrimary(25),
    fPrimary(0x0),
    fDEPrimary(0x0),
    fNiparent(0),
    fNMaxiparent(150),
    fIparent(0x0),
    fDEParent(0x0),
    fMaxIter(5),
    fTime(time),
    fTimeR(time)
{  
  // ctor with all data 

  // data memebrs of the base class (AliNewDigit)
  fAmp         = DigEnergy ;
  fId          = id ;
  fIndexInList = index ; 

  // data members
  fPrimary = new Int_t[fNMaxPrimary] ;
  fDEPrimary = new Float_t[fNMaxPrimary] ;
  fIparent = new Int_t[fNMaxiparent] ; 
  fDEParent = new Float_t[fNMaxiparent] ; 
  if( primary != -1){
    fNprimary    = 1 ; 
    fPrimary[0]  = primary ;  
    fDEPrimary[0] = dE ;  
    fNiparent   = 1 ;
    fIparent[0] = iparent ;    
    fDEParent[0] = dE ;  
  }
  else{  //If the contribution of this primary smaller than fDigitThreshold (AliEMCALv1)
    fNprimary    = 0 ; 
    fPrimary[0]  = -1 ;
    fDEPrimary[0]  = 0 ;
    fNiparent   = 0 ;
    fIparent[0] = -1 ;  
    fDEParent[0]  = 0 ;  
  }
  Int_t i ;
  for ( i = 1; i < fNMaxPrimary ; i++) {
    fPrimary[i]  = -1 ; 
    fDEPrimary[i]  = 0 ;
  } 

  for ( i = 1; i< fNMaxiparent ; i++) {
    fIparent[i] = -1 ;  
    fDEParent[i] = 0 ;
  }  
}

//____________________________________________________________________________
AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit) 
  : AliDigitNew(digit),
    fNprimary(digit.fNprimary),
    fNMaxPrimary(digit.fNMaxPrimary),
    fPrimary(0x0),
    fDEPrimary(0x0),
    fNiparent(digit.fNiparent),
    fNMaxiparent(digit.fNMaxiparent),
    fIparent(0x0),
    fDEParent(0x0),
    fMaxIter(digit.fMaxIter),
    fTime(digit.fTime),
    fTimeR(digit.fTimeR)
{
  // copy ctor
  
  // data memebrs of the base class (AliNewDigit)
  fAmp         = digit.fAmp ;
  fId          = digit.fId;
  fIndexInList = digit.fIndexInList ; 

  // data members
  fPrimary = new Int_t[fNMaxPrimary] ;  
  fDEPrimary = new Float_t[fNMaxPrimary] ;
  fIparent = new Int_t[fNMaxiparent] ;
  fDEParent = new Float_t[fNMaxiparent] ;
  Int_t i ;
  for ( i = 0; i < fNMaxPrimary ; i++) {
    fPrimary[i]  = digit.fPrimary[i] ;
    fDEPrimary[i]  = digit.fDEPrimary[i] ;
  }
  Int_t j ;
  for (j = 0; j< fNMaxiparent ; j++) {
    fIparent[j]  = digit.fIparent[j] ;
    fDEParent[j]  = digit.fDEParent[j] ;
  }
}

//____________________________________________________________________________
AliEMCALDigit::~AliEMCALDigit() 
{
  // Delete array of primiries if any
    delete [] fPrimary ;
    delete [] fDEPrimary ;
    delete [] fIparent ; 
    delete [] fDEParent ;
}

//____________________________________________________________________________
Int_t AliEMCALDigit::Compare(const TObject * obj) const
{
  // Compares two digits with respect to its Id
  // to sort according increasing Id

  Int_t rv ;

  AliEMCALDigit * digit = (AliEMCALDigit *)obj ; 

  Int_t iddiff = fId - digit->GetId() ; 

  if ( iddiff > 0 ) 
    rv = 1 ;
  else if ( iddiff < 0 )
    rv = -1 ; 
  else
    rv = 0 ;
  
  return rv ; 

}

//____________________________________________________________________________
Float_t AliEMCALDigit::GetEta() const
{ 
  //return pseudorapidity for this digit
  // should be change in EMCALGeometry - 19-nov-04
  Float_t eta=-10., phi=-10.;
  Int_t id = GetId();
  const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
  g->EtaPhiFromIndex(id,eta,phi);
  return eta ;
}

//____________________________________________________________________________
Float_t AliEMCALDigit::GetPhi() const
{ 
  //return phi coordinate of digit
  // should be change in EMCALGeometry - 19-nov-04
  Float_t eta=-10., phi=-10.;
  Int_t id = GetId();
  const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
  g->EtaPhiFromIndex(id,eta,phi);
  return phi ;
}

//____________________________________________________________________________
Int_t AliEMCALDigit::GetPrimary(Int_t index) const
{
  // retrieves the primary particle number given its index in the list 
  if ( (index <= fNprimary) && (index > 0)){
    return fPrimary[index-1] ;
  } 

  return -1 ; 
}

//____________________________________________________________________________
Float_t AliEMCALDigit::GetDEPrimary(Int_t index) const
{
  // retrieves the primary particle energy contribution 
  // given its index in the list 
  if ( (index <= fNprimary) && (index > 0)){
    return fDEPrimary[index-1] ;
  } 

  return 0 ; 
  
}

//____________________________________________________________________________
Int_t AliEMCALDigit::GetIparent(Int_t index) const
{
  // retrieves the primary particle number given its index in the list 
  if ( index <= fNiparent && index > 0){
    return fIparent[index-1] ;
  } 

  return -1 ; 
  
}

//____________________________________________________________________________
Float_t AliEMCALDigit::GetDEParent(Int_t index) const
{
  // retrieves the parent particle energy contribution 
  // given its index in the list 
  if ( (index <= fNiparent) && (index > 0)){
    return fDEParent[index-1] ;
  } 

  return 0; 
}

//____________________________________________________________________________
void AliEMCALDigit::ShiftPrimary(Int_t shift){
  //shifts primary number to BIG offset, to separate primary in different TreeK
  Int_t index  ;
  for(index = 0; index <fNprimary; index++ ){
    fPrimary[index] = fPrimary[index]+ shift * 10000000   ;}
  for(index =0; index <fNiparent; index++){
    fIparent[index] = fIparent[index] + shift * 10000000 ;}
}
//____________________________________________________________________________
Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const 
{
  // Two digits are equal if they have the same Id
  
  if ( fId == digit.fId ) 
    return kTRUE ;
  else 
    return kFALSE ;
}
 
//____________________________________________________________________________
AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit) 
{
  // Adds the amplitude of digits and completes the list of primary particles
  // if amplitude is larger than 
  
  fAmp += digit.fAmp ;
  if(fTime > digit.fTime)
    fTime = digit.fTime ;
  if (digit.fTimeR < fTimeR)
    fTimeR = digit.fTimeR ; 

  Int_t max1 = fNprimary ; 
  Int_t max2 = fNiparent ;  
  Int_t index ; 
  for (index = 0 ; index < digit.fNprimary  ; index++){
    Bool_t newPrim = kTRUE ;
    Int_t old ;
    for ( old = 0 ; (old < max1) && newPrim; old++) { //already have this primary?
      if(fPrimary[old] == digit.fPrimary[index]) {
	newPrim = kFALSE;
	fDEPrimary[old] += digit.fDEPrimary[index];
      }
    }
    if (newPrim) {
      if(max1<fNMaxPrimary){ 
	fPrimary[max1] = digit.fPrimary[index] ; 
	fDEPrimary[max1] = digit.fDEPrimary[index] ; 
	fNprimary++ ;
	max1++;
      }
      if(fNprimary==fNMaxPrimary) {
	
	TString mess = " NMaxPrimary  =  " ; 
	mess += fNMaxPrimary ; 
	mess += " is too small" ; 
	Fatal("AliEMCALDigit::Operator+ -->" , mess.Data()) ; 

      }
    }
  }
  
  for (index = 0 ; index < digit.fNiparent ; index++){
    Bool_t newParent = kTRUE ;
    Int_t old ;
    for ( old = 0 ; (old < max2) && newParent; old++) { //already have this primary?
      if(fIparent[old] == digit.fIparent[index]) {
	newParent = kFALSE;
	fDEParent[old] += digit.fDEParent[index];
      }
    }
    if(newParent){
      if(max2<fNMaxiparent) { 
	fIparent[max2] = digit.fIparent[index] ; 
	fDEParent[max2] = digit.fDEParent[index] ; 
	fNiparent++ ;
	max2++;
      }
      if(fNiparent==fNMaxiparent) {
	
	TString mess = " NMaxiparent  =  " ; 
	mess += fNMaxiparent ; 
	mess += " is too small" ; 
	Fatal("AliEMCALDigit::Operator+ -->", mess.Data()) ; 

      }
    }
  }
  
  return *this ;
}

//____________________________________________________________________________
AliEMCALDigit AliEMCALDigit::operator*(Float_t factor) 
{
  // Multiplies the amplitude by a factor
  
  Float_t tempo = static_cast<Float_t>(fAmp) ; 
  tempo *= factor ; 
  fAmp = static_cast<Int_t>(TMath::Ceil(tempo)) ; 
  for(Int_t i=0; i < fNprimary; i++) 
    fDEPrimary[i] *= factor;
  for(Int_t i=0; i < fNiparent; i++) 
    fDEParent[i] *= factor;

  return *this ;
}

//____________________________________________________________________________
ostream& operator << ( ostream& out , const AliEMCALDigit & digit)
{
  // Prints the data of the digit
  
  out << "ID " << digit.fId << " Energy = " << digit.fAmp <<  " Time = " << digit.fTime << endl ; 
  Int_t i,j ;
  for(i=0;i<digit.fNprimary;i++) 
    out << "Primary " << i+1 << " = " << digit.fPrimary[i] 
	<< " : DE " << digit.fDEPrimary[i] << endl ;
   
  for(j=0;j<digit.fNiparent;j++)
    out << "Iparent " << j+1 << " = " << digit.fIparent[j] 
	<< " : DE " << digit.fDEParent[j] << endl ;
  out << "Position in list = " << digit.fIndexInList << endl ; 
  return out ;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	//_________________________________________________________________________
	19	// EMCAL digit:
	20	// A Digit is the sum of the energy lost in an EMCAL Tower
	21	// It also stores information on Primary, and enterring particle
	22	// tracknumbers Digits are created using AliEMCALSDigitizer, followed
	23	// by AliEMCALDigitizer
	24	//
	25	//*-- Author: Sahal Yacoob (LBL)
	26	// based on : AliPHOSDigit
	27	//__________________________________________________________________________
	28
	29	// --- ROOT system ---
	30	#include <Riostream.h>
	31	#include <TMath.h>
	32
	33	// --- Standard library ---
	34
	35	// --- AliRoot header files ---
	36
	37	#include "AliEMCALDigit.h"
	38	#include "AliEMCALGeometry.h"
	39
	40	ClassImp(AliEMCALDigit)
	41
	42	//____________________________________________________________________________
	43	AliEMCALDigit::AliEMCALDigit() :
	44	AliDigitNew(),
	45	fNprimary(0),
	46	fNMaxPrimary(5),
	47	fPrimary(0x0),
	48	fDEPrimary(0x0),
	49	fNiparent(0),
	50	fNMaxiparent(5),
	51	fIparent(0x0),
	52	fDEParent(0x0),
	53	fMaxIter(0),
	54	fTime(0.),
	55	fTimeR(0.)
	56
	57	{
	58	// default ctor
	59
	60	// Need to initialise for reading old files
	61	fPrimary = new Int_t[fNMaxPrimary] ;
	62	fDEPrimary = new Float_t[fNMaxPrimary] ;
	63	fIparent = new Int_t[fNMaxiparent] ;
	64	fDEParent = new Float_t[fNMaxiparent] ;
	65	for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
	66	fPrimary[i] = -1 ;
	67	fDEPrimary[i] = 0 ;
	68	}
	69
	70	for ( Int_t i = 0; i < fNMaxiparent ; i++) {
	71	fIparent[i] = -1 ;
	72	fDEParent[i] = 0 ;
	73	}
	74	}
	75
	76	//____________________________________________________________________________
	77	AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Int_t DigEnergy, Float_t time, Int_t index, Float_t dE)
	78	: AliDigitNew(),
	79	fNprimary(0),
	80	fNMaxPrimary(25),
	81	fPrimary(0x0),
	82	fDEPrimary(0x0),
	83	fNiparent(0),
	84	fNMaxiparent(150),
	85	fIparent(0x0),
	86	fDEParent(0x0),
	87	fMaxIter(5),
	88	fTime(time),
	89	fTimeR(time)
	90	{
	91	// ctor with all data
	92
	93	// data memebrs of the base class (AliNewDigit)
	94	fAmp = DigEnergy ;
	95	fId = id ;
	96	fIndexInList = index ;
	97
	98	// data members
	99	fPrimary = new Int_t[fNMaxPrimary] ;
	100	fDEPrimary = new Float_t[fNMaxPrimary] ;
	101	fIparent = new Int_t[fNMaxiparent] ;
	102	fDEParent = new Float_t[fNMaxiparent] ;
	103	if( primary != -1){
	104	fNprimary = 1 ;
	105	fPrimary[0] = primary ;
	106	fDEPrimary[0] = dE ;
	107	fNiparent = 1 ;
	108	fIparent[0] = iparent ;
	109	fDEParent[0] = dE ;
	110	}
	111	else{ //If the contribution of this primary smaller than fDigitThreshold (AliEMCALv1)
	112	fNprimary = 0 ;
	113	fPrimary[0] = -1 ;
	114	fDEPrimary[0] = 0 ;
	115	fNiparent = 0 ;
	116	fIparent[0] = -1 ;
	117	fDEParent[0] = 0 ;
	118	}
	119	Int_t i ;
	120	for ( i = 1; i < fNMaxPrimary ; i++) {
	121	fPrimary[i] = -1 ;
	122	fDEPrimary[i] = 0 ;
	123	}
	124
	125	for ( i = 1; i< fNMaxiparent ; i++) {
	126	fIparent[i] = -1 ;
	127	fDEParent[i] = 0 ;
	128	}
	129	}
	130
	131	//____________________________________________________________________________
	132	AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit)
	133	: AliDigitNew(digit),
	134	fNprimary(digit.fNprimary),
	135	fNMaxPrimary(digit.fNMaxPrimary),
	136	fPrimary(0x0),
	137	fDEPrimary(0x0),
	138	fNiparent(digit.fNiparent),
	139	fNMaxiparent(digit.fNMaxiparent),
	140	fIparent(0x0),
	141	fDEParent(0x0),
	142	fMaxIter(digit.fMaxIter),
	143	fTime(digit.fTime),
	144	fTimeR(digit.fTimeR)
	145	{
	146	// copy ctor
	147
	148	// data memebrs of the base class (AliNewDigit)
	149	fAmp = digit.fAmp ;
	150	fId = digit.fId;
	151	fIndexInList = digit.fIndexInList ;
	152
	153	// data members
	154	fPrimary = new Int_t[fNMaxPrimary] ;
	155	fDEPrimary = new Float_t[fNMaxPrimary] ;
	156	fIparent = new Int_t[fNMaxiparent] ;
	157	fDEParent = new Float_t[fNMaxiparent] ;
	158	Int_t i ;
	159	for ( i = 0; i < fNMaxPrimary ; i++) {
	160	fPrimary[i] = digit.fPrimary[i] ;
	161	fDEPrimary[i] = digit.fDEPrimary[i] ;
	162	}
	163	Int_t j ;
	164	for (j = 0; j< fNMaxiparent ; j++) {
	165	fIparent[j] = digit.fIparent[j] ;
	166	fDEParent[j] = digit.fDEParent[j] ;
	167	}
	168	}
	169
	170	//____________________________________________________________________________
	171	AliEMCALDigit::~AliEMCALDigit()
	172	{
	173	// Delete array of primiries if any
	174	delete [] fPrimary ;
	175	delete [] fDEPrimary ;
	176	delete [] fIparent ;
	177	delete [] fDEParent ;
	178	}
	179
	180	//____________________________________________________________________________
	181	Int_t AliEMCALDigit::Compare(const TObject * obj) const
	182	{
	183	// Compares two digits with respect to its Id
	184	// to sort according increasing Id
	185
	186	Int_t rv ;
	187
	188	AliEMCALDigit * digit = (AliEMCALDigit *)obj ;
	189
	190	Int_t iddiff = fId - digit->GetId() ;
	191
	192	if ( iddiff > 0 )
	193	rv = 1 ;
	194	else if ( iddiff < 0 )
	195	rv = -1 ;
	196	else
	197	rv = 0 ;
	198
	199	return rv ;
	200
	201	}
	202
	203	//____________________________________________________________________________
	204	Float_t AliEMCALDigit::GetEta() const
	205	{
	206	//return pseudorapidity for this digit
	207	// should be change in EMCALGeometry - 19-nov-04
	208	Float_t eta=-10., phi=-10.;
	209	Int_t id = GetId();
	210	const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
	211	g->EtaPhiFromIndex(id,eta,phi);
	212	return eta ;
	213	}
	214
	215	//____________________________________________________________________________
	216	Float_t AliEMCALDigit::GetPhi() const
	217	{
	218	//return phi coordinate of digit
	219	// should be change in EMCALGeometry - 19-nov-04
	220	Float_t eta=-10., phi=-10.;
	221	Int_t id = GetId();
	222	const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
	223	g->EtaPhiFromIndex(id,eta,phi);
	224	return phi ;
	225	}
	226
	227	//____________________________________________________________________________
	228	Int_t AliEMCALDigit::GetPrimary(Int_t index) const
	229	{
	230	// retrieves the primary particle number given its index in the list
	231	if ( (index <= fNprimary) && (index > 0)){
	232	return fPrimary[index-1] ;
	233	}
	234
	235	return -1 ;
	236	}
	237
	238	//____________________________________________________________________________
	239	Float_t AliEMCALDigit::GetDEPrimary(Int_t index) const
	240	{
	241	// retrieves the primary particle energy contribution
	242	// given its index in the list
	243	if ( (index <= fNprimary) && (index > 0)){
	244	return fDEPrimary[index-1] ;
	245	}
	246
	247	return 0 ;
	248
	249	}
	250
	251	//____________________________________________________________________________
	252	Int_t AliEMCALDigit::GetIparent(Int_t index) const
	253	{
	254	// retrieves the primary particle number given its index in the list
	255	if ( index <= fNiparent && index > 0){
	256	return fIparent[index-1] ;
	257	}
	258
	259	return -1 ;
	260
	261	}
	262
	263	//____________________________________________________________________________
	264	Float_t AliEMCALDigit::GetDEParent(Int_t index) const
	265	{
	266	// retrieves the parent particle energy contribution
	267	// given its index in the list
	268	if ( (index <= fNiparent) && (index > 0)){
	269	return fDEParent[index-1] ;
	270	}
	271
	272	return 0;
	273	}
	274
	275	//____________________________________________________________________________
	276	void AliEMCALDigit::ShiftPrimary(Int_t shift){
	277	//shifts primary number to BIG offset, to separate primary in different TreeK
	278	Int_t index ;
	279	for(index = 0; index <fNprimary; index++ ){
	280	fPrimary[index] = fPrimary[index]+ shift * 10000000 ;}
	281	for(index =0; index <fNiparent; index++){
	282	fIparent[index] = fIparent[index] + shift * 10000000 ;}
	283	}
	284	//____________________________________________________________________________
	285	Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const
	286	{
	287	// Two digits are equal if they have the same Id
	288
	289	if ( fId == digit.fId )
	290	return kTRUE ;
	291	else
	292	return kFALSE ;
	293	}
	294
	295	//____________________________________________________________________________
	296	AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
	297	{
	298	// Adds the amplitude of digits and completes the list of primary particles
	299	// if amplitude is larger than
	300
	301	fAmp += digit.fAmp ;
	302	if(fTime > digit.fTime)
	303	fTime = digit.fTime ;
	304	if (digit.fTimeR < fTimeR)
	305	fTimeR = digit.fTimeR ;
	306
	307	Int_t max1 = fNprimary ;
	308	Int_t max2 = fNiparent ;
	309	Int_t index ;
	310	for (index = 0 ; index < digit.fNprimary ; index++){
	311	Bool_t newPrim = kTRUE ;
	312	Int_t old ;
	313	for ( old = 0 ; (old < max1) && newPrim; old++) { //already have this primary?
	314	if(fPrimary[old] == digit.fPrimary[index]) {
	315	newPrim = kFALSE;
	316	fDEPrimary[old] += digit.fDEPrimary[index];
	317	}
	318	}
	319	if (newPrim) {
	320	if(max1<fNMaxPrimary){
	321	fPrimary[max1] = digit.fPrimary[index] ;
	322	fDEPrimary[max1] = digit.fDEPrimary[index] ;
	323	fNprimary++ ;
	324	max1++;
	325	}
	326	if(fNprimary==fNMaxPrimary) {
	327
	328	TString mess = " NMaxPrimary = " ;
	329	mess += fNMaxPrimary ;
	330	mess += " is too small" ;
	331	Fatal("AliEMCALDigit::Operator+ -->" , mess.Data()) ;
	332
	333	}
	334	}
	335	}
	336
	337	for (index = 0 ; index < digit.fNiparent ; index++){
	338	Bool_t newParent = kTRUE ;
	339	Int_t old ;
	340	for ( old = 0 ; (old < max2) && newParent; old++) { //already have this primary?
	341	if(fIparent[old] == digit.fIparent[index]) {
	342	newParent = kFALSE;
	343	fDEParent[old] += digit.fDEParent[index];
	344	}
	345	}
	346	if(newParent){
	347	if(max2<fNMaxiparent) {
	348	fIparent[max2] = digit.fIparent[index] ;
	349	fDEParent[max2] = digit.fDEParent[index] ;
	350	fNiparent++ ;
	351	max2++;
	352	}
	353	if(fNiparent==fNMaxiparent) {
	354
	355	TString mess = " NMaxiparent = " ;
	356	mess += fNMaxiparent ;
	357	mess += " is too small" ;
	358	Fatal("AliEMCALDigit::Operator+ -->", mess.Data()) ;
	359
	360	}
	361	}
	362	}
	363
	364	return *this ;
	365	}
	366
	367	//____________________________________________________________________________
	368	AliEMCALDigit AliEMCALDigit::operator*(Float_t factor)
	369	{
	370	// Multiplies the amplitude by a factor
	371
	372	Float_t tempo = static_cast<Float_t>(fAmp) ;
	373	tempo *= factor ;
	374	fAmp = static_cast<Int_t>(TMath::Ceil(tempo)) ;
	375	for(Int_t i=0; i < fNprimary; i++)
	376	fDEPrimary[i] *= factor;
	377	for(Int_t i=0; i < fNiparent; i++)
	378	fDEParent[i] *= factor;
	379
	380	return *this ;
	381	}
	382
	383	//____________________________________________________________________________
	384	ostream& operator << ( ostream& out , const AliEMCALDigit & digit)
	385	{
	386	// Prints the data of the digit
	387
	388	out << "ID " << digit.fId << " Energy = " << digit.fAmp << " Time = " << digit.fTime << endl ;
	389	Int_t i,j ;
	390	for(i=0;i<digit.fNprimary;i++)
	391	out << "Primary " << i+1 << " = " << digit.fPrimary[i]
	392	<< " : DE " << digit.fDEPrimary[i] << endl ;
	393
	394	for(j=0;j<digit.fNiparent;j++)
	395	out << "Iparent " << j+1 << " = " << digit.fIparent[j]
	396	<< " : DE " << digit.fDEParent[j] << endl ;
	397	out << "Position in list = " << digit.fIndexInList << endl ;
	398	return out ;
	399	}
	400
	401