[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(), 
  fAmpFloat(0.),
  fNSamples(0),
  fSamples(0x0),
  fNSamplesHG(0),
  fSamplesHG(0x0),
  fNprimary(0),
  fNMaxPrimary(5),
  fPrimary(0x0),
  fDEPrimary(0x0),
  fNiparent(0),
  fNMaxiparent(5), 
  fIparent(0x0),
  fDEParent(0x0),
  fMaxIter(0),
  fTime(0.), 
  fTimeR(0.),
  fChi2(0.),
  fNDF(0),
  fDigitType(kUnknown),
  fAmpCalib(-1)
{
  // 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, Float_t digEnergy, Float_t time, Int_t type, Int_t index, Float_t chi2, Int_t ndf, Float_t dE) 
  : AliDigitNew(),
    fAmpFloat(digEnergy),
    fNSamples(0),
    fSamples(0x0),
    fNSamplesHG(0),
    fSamplesHG(0x0),
    fNprimary(0),
    fNMaxPrimary(25),
    fPrimary(0x0),
    fDEPrimary(0x0),
    fNiparent(0),
    fNMaxiparent(150),
    fIparent(0x0),
    fDEParent(0x0),
    fMaxIter(5),
    fTime(time),
    fTimeR(time),
    fChi2(chi2),
    fNDF(ndf),
    fDigitType(type),
    fAmpCalib(-1)
{  
  // ctor with all data 

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

  // data member  
  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),
    fAmpFloat(digit.fAmpFloat),	
    fNSamples(digit.fNSamples),
    fSamples(),
    fNSamplesHG(digit.fNSamplesHG),
    fSamplesHG(),
    fNprimary(digit.fNprimary),
    fNMaxPrimary(digit.fNMaxPrimary),
    fPrimary(),
    fDEPrimary(),
    fNiparent(digit.fNiparent),
    fNMaxiparent(digit.fNMaxiparent),
    fIparent(),
    fDEParent(),
    fMaxIter(digit.fMaxIter),
    fTime(digit.fTime),
    fTimeR(digit.fTimeR), 
    fChi2(digit.fChi2), 
    fNDF(digit.fNDF),
    fDigitType(digit.fDigitType),
    fAmpCalib(digit.fAmpCalib)
{
  // copy ctor
  // data memebrs of the base class (AliNewDigit)
  fAmp         = digit.fAmp ;
  fId          = digit.fId;
  fIndexInList = digit.fIndexInList ; 

  // data members  
  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;

  if (fNSamples){
    fSamples     = new Int_t[fNSamples]; 
    for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
  }
  
  if (fNSamplesHG){
    fSamplesHG   = new Int_t[fNSamplesHG]; 
    for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
  }
  
 
  if (fNMaxPrimary){
    fPrimary   = new Int_t  [fNMaxPrimary] ;  
    fDEPrimary = new Float_t[fNMaxPrimary] ;
    for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
      fPrimary[i]   = digit.fPrimary[i] ;
      fDEPrimary[i] = digit.fDEPrimary[i] ;
    }
  }
  
  if (fNMaxiparent){
    fIparent  = new Int_t  [fNMaxiparent] ;
    fDEParent = new Float_t[fNMaxiparent] ;
    for (Int_t j = 0; j< fNMaxiparent ; j++) {
    fIparent[j]  = digit.fIparent[j] ;
    fDEParent[j] = digit.fDEParent[j] ;
    }
  }  
 
}

//____________________________________________________________________________
AliEMCALDigit::~AliEMCALDigit() 
{
  // Delete array of primaries if any

  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;

}


//____________________________________________________________________________
void AliEMCALDigit::Clear(const Option_t*) 
{
  // Delete array of primaries if any
  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;

}

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

  Int_t rv = 2 ;

  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 ;
}

//____________________________________________________________________________
Bool_t AliEMCALDigit::GetFALTROSample(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
{
	//Get FALTRO sample in time bin iSample
	if (iSample >= fNSamples || iSample < 0 || fDigitType==kTrigger) return kFALSE;
	
	amp     =  fSamples[iSample] & 0xFFF;
	timeBin = (fSamples[iSample] >> 12) & 0xFF;
	
	return kTRUE;
}
//____________________________________________________________________________
Bool_t AliEMCALDigit::GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
{
	//Get Low Gain ALTRO sample in time bin iSample
	if (iSample >= fNSamples || iSample < 0 || fDigitType==kLG) return kFALSE;
	
	amp     =  fSamples[iSample] & 0xFFF;
	timeBin = (fSamples[iSample] >> 12) & 0xFF;
	
	return kTRUE;
}

//____________________________________________________________________________
void AliEMCALDigit::SetALTROSamplesLG(const Int_t nSamples, Int_t *samples)
{
    //Set array of ALTRO samples, Low Gain or FALTRO 
	fNSamples = nSamples;
	fSamples  = new Int_t[fNSamples]; 
	for (Int_t i=0; i < fNSamples; i++) fSamples[i] = samples[i];
}

//____________________________________________________________________________
void AliEMCALDigit::SetALTROSamplesHG(const Int_t nSamples, Int_t *samples)
{
	//Set array of ALTRO samples, High Gain.
	fNSamplesHG = nSamples;
	fSamplesHG  = new Int_t[fNSamplesHG]; 
	for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = samples[i];
}


//____________________________________________________________________________
Bool_t AliEMCALDigit::GetALTROSampleHG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
{
	//Get High Gain ALTRO sample in time bin iSample
	if (iSample >= fNSamplesHG || iSample < 0 || fDigitType==kHG) return kFALSE;
	
	amp     =  fSamplesHG[iSample] & 0xFFF;
	timeBin = (fSamplesHG[iSample] >> 12) & 0xFF;
	
	return kTRUE;
}


//____________________________________________________________________________
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 
  
  fAmpFloat += digit.fAmpFloat ;
  for (Int_t i=0; i < fNSamples  ; i++) fSamples[i]   += digit.fSamples[i];
  for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] += digit.fSamplesHG[i];
  
  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" ; 
        AliFatal(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" ; 
        AliFatal(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::Floor(tempo)) ; 
	
  fAmpFloat *= factor;
  for (Int_t i=0; i < fNSamples  ; i++) fSamples[i]   = Int_t(factor*fSamples[i]);
  for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = Int_t(factor*fSamplesHG[i]);

  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 ; 
  for(Int_t i=0;i<digit.fNprimary;i++) 
    out << "Primary " << i+1 << " = " << digit.fPrimary[i] 
	<< " : DE " << digit.fDEPrimary[i] << endl ;
   
  for(Int_t 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 ;
}

//____________________________________________________________________________
void AliEMCALDigit::Print(const Option_t* /*opt*/) const
{
    //Print
	printf("===\nDigit id: %4d / Energy %2.3f ; Time %e ; Time samples %d ; Chi2 %2.3f, NDF %d, Type? %d \n",
		   fId, fAmpFloat,fTime, fNSamples, fChi2, fNDF, fDigitType);
	if(fDigitType==kTrigger){
		printf("FALTRO: ");
		for (Int_t i=0; i < GetNFALTROSamples(); i++) 
		{
			Int_t timeBin, amp;
			GetFALTROSample(i, timeBin, amp);
			printf(" (%d,%d) ",timeBin,amp);
		}
		printf("\n");
	}//trigger
	else{
		printf("ALTRO, Low Gain: ");
		for (Int_t i=0; i < GetNALTROSamplesLG(); i++) 
		{
			Int_t timeBin, amp;
			GetALTROSampleLG(i, timeBin, amp);
			printf(" (%d,%d) ",timeBin,amp);
		}
		printf("\n");
		printf("ALTRO, High Gain: ");
		for (Int_t i=0; i < GetNALTROSamplesHG(); i++) 
		{
			Int_t timeBin, amp;
			GetALTROSampleHG(i, timeBin, amp);
			printf(" (%d,%d) ",timeBin,amp);
		}
		printf("\n");
	}//trigger
	
}
Commit	Line	Data
61e0abb5	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
090026bf	16	/* $Id$ */
61e0abb5	17
61e0abb5	18	//_________________________________________________________________________
ffa6d63b	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
61e0abb5	24	//
ffa6d63b	25	//*-- Author: Sahal Yacoob (LBL)
ffa6d63b	26	// based on : AliPHOSDigit
814ad4bf	27	//__________________________________________________________________________
61e0abb5	28
61e0abb5	29	// --- ROOT system ---
090026bf	30	#include <Riostream.h>
090026bf	31	#include <TMath.h>
61e0abb5	32
	33	// --- Standard library ---
	34
61e0abb5	35	// --- AliRoot header files ---
	36
	37	#include "AliEMCALDigit.h"
814ad4bf	38	#include "AliEMCALGeometry.h"
61e0abb5	39
	40	ClassImp(AliEMCALDigit)
	41
	42	//____________________________________________________________________________
514da33c	43	AliEMCALDigit::AliEMCALDigit() :
829ba234	44	AliDigitNew(),
	45	fAmpFloat(0.),
	46	fNSamples(0),
	47	fSamples(0x0),
	48	fNSamplesHG(0),
	49	fSamplesHG(0x0),
514da33c	50	fNprimary(0),
	51	fNMaxPrimary(5),
	52	fPrimary(0x0),
af5bdd85	53	fDEPrimary(0x0),
514da33c	54	fNiparent(0),
	55	fNMaxiparent(5),
	56	fIparent(0x0),
af5bdd85	57	fDEParent(0x0),
514da33c	58	fMaxIter(0),
514da33c	59	fTime(0.),
829ba234	60	fTimeR(0.),
	61	fChi2(0.),
	62	fNDF(0),
8a84b948	63	fDigitType(kUnknown),
8a84b948	64	fAmpCalib(-1)
61e0abb5	65	{
	66	// default ctor
	67
af5bdd85	68	// Need to initialise for reading old files
f4a4dc82	69	fPrimary = new Int_t[fNMaxPrimary] ;
af5bdd85	70	fDEPrimary = new Float_t[fNMaxPrimary] ;
f4a4dc82	71	fIparent = new Int_t[fNMaxiparent] ;
f4a4dc82	72	fDEParent = new Float_t[fNMaxiparent] ;
af5bdd85	73	for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
f4a4dc82	74	fPrimary[i] = -1 ;
af5bdd85	75	fDEPrimary[i] = 0 ;
	76	}
	77
0ae8ae77	78	for ( Int_t i = 0; i < fNMaxiparent ; i++) {
f4a4dc82	79	fIparent[i] = -1 ;
af5bdd85	80	fDEParent[i] = 0 ;
af5bdd85	81	}
61e0abb5	82	}
	83
	84	//____________________________________________________________________________
2cd0ffda	85	AliEMCALDigit::AliEMCALDigit(Int_t primary, Int_t iparent, Int_t id, Float_t digEnergy, Float_t time, Int_t type, Int_t index, Float_t chi2, Int_t ndf, Float_t dE)
18a21c7c	86	: AliDigitNew(),
829ba234	87	fAmpFloat(digEnergy),
829ba234	88	fNSamples(0),
f4a4dc82	89	fSamples(0x0),
829ba234	90	fNSamplesHG(0),
829ba234	91	fSamplesHG(0x0),
18a21c7c	92	fNprimary(0),
	93	fNMaxPrimary(25),
	94	fPrimary(0x0),
af5bdd85	95	fDEPrimary(0x0),
18a21c7c	96	fNiparent(0),
	97	fNMaxiparent(150),
	98	fIparent(0x0),
af5bdd85	99	fDEParent(0x0),
18a21c7c	100	fMaxIter(5),
18a21c7c	101	fTime(time),
829ba234	102	fTimeR(time),
2cd0ffda	103	fChi2(chi2),
2cd0ffda	104	fNDF(ndf),
8a84b948	105	fDigitType(type),
8a84b948	106	fAmpCalib(-1)
61e0abb5	107	{
	108	// ctor with all data
	109
514da33c	110	// data memebrs of the base class (AliNewDigit)
829ba234	111	fAmp = 0;
514da33c	112	fId = id ;
	113	fIndexInList = index ;
	114
829ba234	115	// data member
f4a4dc82	116	fPrimary = new Int_t[fNMaxPrimary] ;
af5bdd85	117	fDEPrimary = new Float_t[fNMaxPrimary] ;
f4a4dc82	118	fIparent = new Int_t[fNMaxiparent] ;
f4a4dc82	119	fDEParent = new Float_t[fNMaxiparent] ;
61e0abb5	120	if( primary != -1){
61e0abb5	121	fNprimary = 1 ;
7b62cd84	122	fPrimary[0] = primary ;
af5bdd85	123	fDEPrimary[0] = dE ;
61e0abb5	124	fNiparent = 1 ;
61e0abb5	125	fIparent[0] = iparent ;
af5bdd85	126	fDEParent[0] = dE ;
af5bdd85	127	}
61e0abb5	128	else{ //If the contribution of this primary smaller than fDigitThreshold (AliEMCALv1)
	129	fNprimary = 0 ;
	130	fPrimary[0] = -1 ;
af5bdd85	131	fDEPrimary[0] = 0 ;
61e0abb5	132	fNiparent = 0 ;
af5bdd85	133	fIparent[0] = -1 ;
af5bdd85	134	fDEParent[0] = 0 ;
61e0abb5	135	}
61e0abb5	136	Int_t i ;
af5bdd85	137	for ( i = 1; i < fNMaxPrimary ; i++) {
61e0abb5	138	fPrimary[i] = -1 ;
af5bdd85	139	fDEPrimary[i] = 0 ;
af5bdd85	140	}
61e0abb5	141
af5bdd85	142	for ( i = 1; i< fNMaxiparent ; i++) {
f807c3bd	143	fIparent[i] = -1 ;
af5bdd85	144	fDEParent[i] = 0 ;
af5bdd85	145	}
61e0abb5	146	}
	147
	148	//____________________________________________________________________________
18a21c7c	149	AliEMCALDigit::AliEMCALDigit(const AliEMCALDigit & digit)
18a21c7c	150	: AliDigitNew(digit),
f4a4dc82	151	fAmpFloat(digit.fAmpFloat),
f4a4dc82	152	fNSamples(digit.fNSamples),
e0dc3f7d	153	fSamples(),
829ba234	154	fNSamplesHG(digit.fNSamplesHG),
e0dc3f7d	155	fSamplesHG(),
18a21c7c	156	fNprimary(digit.fNprimary),
18a21c7c	157	fNMaxPrimary(digit.fNMaxPrimary),
e0dc3f7d	158	fPrimary(),
e0dc3f7d	159	fDEPrimary(),
18a21c7c	160	fNiparent(digit.fNiparent),
18a21c7c	161	fNMaxiparent(digit.fNMaxiparent),
e0dc3f7d	162	fIparent(),
e0dc3f7d	163	fDEParent(),
18a21c7c	164	fMaxIter(digit.fMaxIter),
18a21c7c	165	fTime(digit.fTime),
829ba234	166	fTimeR(digit.fTimeR),
	167	fChi2(digit.fChi2),
	168	fNDF(digit.fNDF),
8a84b948	169	fDigitType(digit.fDigitType),
8a84b948	170	fAmpCalib(digit.fAmpCalib)
61e0abb5	171	{
61e0abb5	172	// copy ctor
514da33c	173	// data memebrs of the base class (AliNewDigit)
	174	fAmp = digit.fAmp ;
	175	fId = digit.fId;
	176	fIndexInList = digit.fIndexInList ;
61e0abb5	177
829ba234	178	// data members
e0dc3f7d	179	if (fSamples ) delete [] fSamples ; fSamples = NULL ;
	180	if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
	181	if (fPrimary ) delete [] fPrimary ; fPrimary = NULL ;
	182	if (fDEPrimary) delete [] fDEPrimary ; fDEPrimary = NULL ;
	183	if (fIparent ) delete [] fIparent ; fIparent = NULL ;
	184	if (fDEParent) delete [] fDEParent ; fDEParent = NULL ;
	185
	186	if (fNSamples){
84f6f119	187	fSamples = new Int_t[fNSamples];
	188	for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
	189	}
e0dc3f7d	190
e0dc3f7d	191	if (fNSamplesHG){
84f6f119	192	fSamplesHG = new Int_t[fNSamplesHG];
84f6f119	193	for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
af5bdd85	194	}
e0dc3f7d	195
	196
	197	if (fNMaxPrimary){
84f6f119	198	fPrimary = new Int_t [fNMaxPrimary] ;
	199	fDEPrimary = new Float_t[fNMaxPrimary] ;
	200	for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
	201	fPrimary[i] = digit.fPrimary[i] ;
	202	fDEPrimary[i] = digit.fDEPrimary[i] ;
	203	}
	204	}
e0dc3f7d	205
e0dc3f7d	206	if (fNMaxiparent){
84f6f119	207	fIparent = new Int_t [fNMaxiparent] ;
	208	fDEParent = new Float_t[fNMaxiparent] ;
	209	for (Int_t j = 0; j< fNMaxiparent ; j++) {
af5bdd85	210	fIparent[j] = digit.fIparent[j] ;
84f6f119	211	fDEParent[j] = digit.fDEParent[j] ;
84f6f119	212	}
e0dc3f7d	213	}
e0dc3f7d	214
61e0abb5	215	}
	216
	217	//____________________________________________________________________________
	218	AliEMCALDigit::~AliEMCALDigit()
	219	{
e0dc3f7d	220	// Delete array of primaries if any
	221
	222	if (fSamples ) delete [] fSamples ; fSamples = NULL ;
	223	if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
	224	if (fPrimary ) delete [] fPrimary ; fPrimary = NULL ;
	225	if (fDEPrimary) delete [] fDEPrimary ; fDEPrimary = NULL ;
	226	if (fIparent ) delete [] fIparent ; fIparent = NULL ;
	227	if (fDEParent) delete [] fDEParent ; fDEParent = NULL ;
	228
	229	}
	230
	231
	232	//____________________________________________________________________________
	233	void AliEMCALDigit::Clear(const Option_t*)
	234	{
	235	// Delete array of primaries if any
	236	if (fSamples ) delete [] fSamples ; fSamples = NULL ;
	237	if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
	238	if (fPrimary ) delete [] fPrimary ; fPrimary = NULL ;
	239	if (fDEPrimary) delete [] fDEPrimary ; fDEPrimary = NULL ;
	240	if (fIparent ) delete [] fIparent ; fIparent = NULL ;
	241	if (fDEParent) delete [] fDEParent ; fDEParent = NULL ;
829ba234	242
61e0abb5	243	}
	244
	245	//____________________________________________________________________________
	246	Int_t AliEMCALDigit::Compare(const TObject * obj) const
	247	{
	248	// Compares two digits with respect to its Id
	249	// to sort according increasing Id
	250
53e430a3	251	Int_t rv = 2 ;
61e0abb5	252
	253	AliEMCALDigit * digit = (AliEMCALDigit *)obj ;
	254
	255	Int_t iddiff = fId - digit->GetId() ;
	256
	257	if ( iddiff > 0 )
	258	rv = 1 ;
	259	else if ( iddiff < 0 )
	260	rv = -1 ;
	261	else
	262	rv = 0 ;
	263
	264	return rv ;
	265
	266	}
	267
814ad4bf	268	//____________________________________________________________________________
88cb7938	269	Float_t AliEMCALDigit::GetEta() const
14ce0a6e	270	{
	271	//return pseudorapidity for this digit
	272	// should be change in EMCALGeometry - 19-nov-04
814ad4bf	273	Float_t eta=-10., phi=-10.;
563aa66c	274	Int_t id = GetId();
5dee926e	275	const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
563aa66c	276	g->EtaPhiFromIndex(id,eta,phi);
814ad4bf	277	return eta ;
	278	}
	279
	280	//____________________________________________________________________________
88cb7938	281	Float_t AliEMCALDigit::GetPhi() const
14ce0a6e	282	{
	283	//return phi coordinate of digit
	284	// should be change in EMCALGeometry - 19-nov-04
814ad4bf	285	Float_t eta=-10., phi=-10.;
563aa66c	286	Int_t id = GetId();
5dee926e	287	const AliEMCALGeometry *g = AliEMCALGeometry::GetInstance();
563aa66c	288	g->EtaPhiFromIndex(id,eta,phi);
814ad4bf	289	return phi ;
	290	}
	291
829ba234	292	//____________________________________________________________________________
	293	Bool_t AliEMCALDigit::GetFALTROSample(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
	294	{
	295	//Get FALTRO sample in time bin iSample
f4a4dc82	296	if (iSample >= fNSamples \|\| iSample < 0 \|\| fDigitType==kTrigger) return kFALSE;
829ba234	297
	298	amp = fSamples[iSample] & 0xFFF;
	299	timeBin = (fSamples[iSample] >> 12) & 0xFF;
	300
	301	return kTRUE;
	302	}
	303	//____________________________________________________________________________
	304	Bool_t AliEMCALDigit::GetALTROSampleLG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
	305	{
	306	//Get Low Gain ALTRO sample in time bin iSample
f4a4dc82	307	if (iSample >= fNSamples \|\| iSample < 0 \|\| fDigitType==kLG) return kFALSE;
829ba234	308
	309	amp = fSamples[iSample] & 0xFFF;
	310	timeBin = (fSamples[iSample] >> 12) & 0xFF;
	311
	312	return kTRUE;
	313	}
	314
	315	//____________________________________________________________________________
	316	void AliEMCALDigit::SetALTROSamplesLG(const Int_t nSamples, Int_t *samples)
	317	{
	318	//Set array of ALTRO samples, Low Gain or FALTRO
	319	fNSamples = nSamples;
	320	fSamples = new Int_t[fNSamples];
	321	for (Int_t i=0; i < fNSamples; i++) fSamples[i] = samples[i];
	322	}
	323
	324	//____________________________________________________________________________
	325	void AliEMCALDigit::SetALTROSamplesHG(const Int_t nSamples, Int_t *samples)
	326	{
	327	//Set array of ALTRO samples, High Gain.
	328	fNSamplesHG = nSamples;
	329	fSamplesHG = new Int_t[fNSamplesHG];
	330	for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = samples[i];
	331	}
	332
	333
	334	//____________________________________________________________________________
	335	Bool_t AliEMCALDigit::GetALTROSampleHG(const Int_t iSample, Int_t& timeBin, Int_t& amp) const
	336	{
	337	//Get High Gain ALTRO sample in time bin iSample
f4a4dc82	338	if (iSample >= fNSamplesHG \|\| iSample < 0 \|\| fDigitType==kHG) return kFALSE;
829ba234	339
	340	amp = fSamplesHG[iSample] & 0xFFF;
	341	timeBin = (fSamplesHG[iSample] >> 12) & 0xFF;
	342
	343	return kTRUE;
	344	}
	345
	346
61e0abb5	347	//____________________________________________________________________________
	348	Int_t AliEMCALDigit::GetPrimary(Int_t index) const
	349	{
	350	// retrieves the primary particle number given its index in the list
fdebddeb	351	if ( (index <= fNprimary) && (index > 0)){
af5bdd85	352	return fPrimary[index-1] ;
61e0abb5	353	}
61e0abb5	354
af5bdd85	355	return -1 ;
	356	}
	357
	358	//____________________________________________________________________________
	359	Float_t AliEMCALDigit::GetDEPrimary(Int_t index) const
	360	{
	361	// retrieves the primary particle energy contribution
	362	// given its index in the list
	363	if ( (index <= fNprimary) && (index > 0)){
	364	return fDEPrimary[index-1] ;
	365	}
	366
	367	return 0 ;
61e0abb5	368
	369	}
	370
	371	//____________________________________________________________________________
	372	Int_t AliEMCALDigit::GetIparent(Int_t index) const
	373	{
	374	// retrieves the primary particle number given its index in the list
af5bdd85	375	if ( index <= fNiparent && index > 0){
af5bdd85	376	return fIparent[index-1] ;
61e0abb5	377	}
61e0abb5	378
af5bdd85	379	return -1 ;
61e0abb5	380
	381	}
	382
af5bdd85	383	//____________________________________________________________________________
	384	Float_t AliEMCALDigit::GetDEParent(Int_t index) const
	385	{
	386	// retrieves the parent particle energy contribution
	387	// given its index in the list
	388	if ( (index <= fNiparent) && (index > 0)){
	389	return fDEParent[index-1] ;
	390	}
	391
	392	return 0;
	393	}
	394
61e0abb5	395	//____________________________________________________________________________
61e0abb5	396	void AliEMCALDigit::ShiftPrimary(Int_t shift){
fdebddeb	397	//shifts primary number to BIG offset, to separate primary in different TreeK
61e0abb5	398	Int_t index ;
	399	for(index = 0; index <fNprimary; index++ ){
	400	fPrimary[index] = fPrimary[index]+ shift * 10000000 ;}
	401	for(index =0; index <fNiparent; index++){
	402	fIparent[index] = fIparent[index] + shift * 10000000 ;}
	403	}
	404	//____________________________________________________________________________
	405	Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const
	406	{
	407	// Two digits are equal if they have the same Id
	408
	409	if ( fId == digit.fId )
	410	return kTRUE ;
	411	else
	412	return kFALSE ;
	413	}
	414
	415	//____________________________________________________________________________
0a4cb131	416	AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
61e0abb5	417	{
	418	// Adds the amplitude of digits and completes the list of primary particles
	419	// if amplitude is larger than
	420
829ba234	421	fAmpFloat += digit.fAmpFloat ;
	422	for (Int_t i=0; i < fNSamples ; i++) fSamples[i] += digit.fSamples[i];
	423	for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] += digit.fSamplesHG[i];
d8c2bd69	424
829ba234	425	fAmp += digit.fAmp ;
814ad4bf	426	if(fTime > digit.fTime)
814ad4bf	427	fTime = digit.fTime ;
3c80fef6	428	if (digit.fTimeR < fTimeR)
3c80fef6	429	fTimeR = digit.fTimeR ;
d8c2bd69	430
61e0abb5	431	Int_t max1 = fNprimary ;
	432	Int_t max2 = fNiparent ;
	433	Int_t index ;
7b62cd84	434	for (index = 0 ; index < digit.fNprimary ; index++){
af5bdd85	435	Bool_t newPrim = kTRUE ;
61e0abb5	436	Int_t old ;
af5bdd85	437	for ( old = 0 ; (old < max1) && newPrim; old++) { //already have this primary?
af5bdd85	438	if(fPrimary[old] == digit.fPrimary[index]) {
d8c2bd69	439	newPrim = kFALSE;
d8c2bd69	440	fDEPrimary[old] += digit.fDEPrimary[index];
af5bdd85	441	}
61e0abb5	442	}
af5bdd85	443	if (newPrim) {
af5bdd85	444	if(max1<fNMaxPrimary){
d8c2bd69	445	fPrimary[max1] = digit.fPrimary[index] ;
	446	fDEPrimary[max1] = digit.fDEPrimary[index] ;
	447	fNprimary++ ;
	448	max1++;
af5bdd85	449	}
7b62cd84	450	if(fNprimary==fNMaxPrimary) {
d8c2bd69	451
	452	TString mess = " NMaxPrimary = " ;
	453	mess += fNMaxPrimary ;
	454	mess += " is too small" ;
	455	AliFatal(mess.Data()) ;
	456
61e0abb5	457	}
	458	}
	459	}
	460
	461	for (index = 0 ; index < digit.fNiparent ; index++){
af5bdd85	462	Bool_t newParent = kTRUE ;
61e0abb5	463	Int_t old ;
af5bdd85	464	for ( old = 0 ; (old < max2) && newParent; old++) { //already have this primary?
af5bdd85	465	if(fIparent[old] == digit.fIparent[index]) {
d8c2bd69	466	newParent = kFALSE;
d8c2bd69	467	fDEParent[old] += digit.fDEParent[index];
af5bdd85	468	}
61e0abb5	469	}
af5bdd85	470	if(newParent){
af5bdd85	471	if(max2<fNMaxiparent) {
d8c2bd69	472	fIparent[max2] = digit.fIparent[index] ;
	473	fDEParent[max2] = digit.fDEParent[index] ;
	474	fNiparent++ ;
	475	max2++;
af5bdd85	476	}
7b62cd84	477	if(fNiparent==fNMaxiparent) {
d8c2bd69	478
	479	TString mess = " NMaxiparent = " ;
	480	mess += fNMaxiparent ;
	481	mess += " is too small" ;
	482	AliFatal(mess.Data()) ;
	483
61e0abb5	484	}
	485	}
	486	}
	487
	488	return *this ;
	489	}
	490
563aa66c	491	//____________________________________________________________________________
0a4cb131	492	AliEMCALDigit AliEMCALDigit::operator*(Float_t factor)
563aa66c	493	{
	494	// Multiplies the amplitude by a factor
	495
829ba234	496	//Float_t tempo = static_cast<Float_t>(fAmp) ;
	497	//tempo *= factor ;
	498	//fAmp = static_cast<Int_t>(TMath::Floor(tempo)) ;
	499
	500	fAmpFloat *= factor;
	501	for (Int_t i=0; i < fNSamples ; i++) fSamples[i] = Int_t(factor*fSamples[i]);
	502	for (Int_t i=0; i < fNSamplesHG; i++) fSamplesHG[i] = Int_t(factor*fSamplesHG[i]);
	503
af5bdd85	504	for(Int_t i=0; i < fNprimary; i++)
	505	fDEPrimary[i] *= factor;
	506	for(Int_t i=0; i < fNiparent; i++)
	507	fDEParent[i] *= factor;
	508
563aa66c	509	return *this ;
	510	}
	511
61e0abb5	512	//____________________________________________________________________________
	513	ostream& operator << ( ostream& out , const AliEMCALDigit & digit)
	514	{
	515	// Prints the data of the digit
	516
814ad4bf	517	out << "ID " << digit.fId << " Energy = " << digit.fAmp << " Time = " << digit.fTime << endl ;
53e430a3	518	for(Int_t i=0;i<digit.fNprimary;i++)
af5bdd85	519	out << "Primary " << i+1 << " = " << digit.fPrimary[i]
af5bdd85	520	<< " : DE " << digit.fDEPrimary[i] << endl ;
61e0abb5	521
53e430a3	522	for(Int_t j=0;j<digit.fNiparent;j++)
af5bdd85	523	out << "Iparent " << j+1 << " = " << digit.fIparent[j]
	524	<< " : DE " << digit.fDEParent[j] << endl ;
	525	out << "Position in list = " << digit.fIndexInList << endl ;
61e0abb5	526	return out ;
	527	}
	528
829ba234	529	//____________________________________________________________________________
	530	void AliEMCALDigit::Print(const Option_t* /opt/) const
	531	{
	532	//Print
f4a4dc82	533	printf("===\nDigit id: %4d / Energy %2.3f ; Time %e ; Time samples %d ; Chi2 %2.3f, NDF %d, Type? %d \n",
	534	fId, fAmpFloat,fTime, fNSamples, fChi2, fNDF, fDigitType);
	535	if(fDigitType==kTrigger){
829ba234	536	printf("FALTRO: ");
	537	for (Int_t i=0; i < GetNFALTROSamples(); i++)
	538	{
	539	Int_t timeBin, amp;
	540	GetFALTROSample(i, timeBin, amp);
	541	printf(" (%d,%d) ",timeBin,amp);
	542	}
	543	printf("\n");
	544	}//trigger
	545	else{
	546	printf("ALTRO, Low Gain: ");
	547	for (Int_t i=0; i < GetNALTROSamplesLG(); i++)
	548	{
	549	Int_t timeBin, amp;
	550	GetALTROSampleLG(i, timeBin, amp);
	551	printf(" (%d,%d) ",timeBin,amp);
	552	}
	553	printf("\n");
	554	printf("ALTRO, High Gain: ");
	555	for (Int_t i=0; i < GetNALTROSamplesHG(); i++)
	556	{
	557	Int_t timeBin, amp;
	558	GetALTROSampleHG(i, timeBin, amp);
	559	printf(" (%d,%d) ",timeBin,amp);
	560	}
	561	printf("\n");
	562	}//trigger
	563
	564	}
	565
	566
61e0abb5	567