ROOT logo
// -*- mode: c++ -*-
/**************************************************************************
 * 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$ */


//_________________________________________________________________________
//  Utility Class for handling Raw data
//  Does all transitions from Digits to Raw and vice versa, 
//  for simu and reconstruction
//
//  Note: the current version is still simplified. Only 
//    one raw signal per digit is generated; either high-gain or low-gain
//    Need to add concurrent high and low-gain info in the future
//    No pedestal is added to the raw signal.
//*-- Author: Marco van Leeuwen (LBL)
//*-- Major refactoring by Per Thomas Hille

//#include "AliCDBManager.h"
#include "AliEMCALRawUtils.h"
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliAltroBuffer.h"
#include "AliRawReader.h"
#include "AliCaloRawStreamV3.h"
#include "AliDAQ.h"
#include "AliEMCALRecParam.h"
#include "AliEMCALLoader.h"
#include "AliEMCALGeometry.h"
#include "AliEMCALDigit.h"
#include "AliEMCALRawDigit.h"
#include "AliEMCAL.h"
#include "AliCaloCalibPedestal.h"  
#include "AliCaloBunchInfo.h"
#include "AliCaloFitResults.h"
#include "AliEMCALTriggerRawDigitMaker.h"
#include "AliEMCALTriggerSTURawStream.h"
#include "AliEMCALTriggerData.h"
#include "AliCaloConstants.h"
#include "AliCaloRawAnalyzer.h"
#include "AliCaloRawAnalyzerFactory.h"
#include "AliEMCALRawResponse.h"

using namespace CALO;
using namespace EMCAL;

using std::vector;
ClassImp(AliEMCALRawUtils)


AliEMCALRawUtils::AliEMCALRawUtils( Algo::fitAlgorithm fitAlgo) : fNoiseThreshold(3),
								  fNPedSamples(4), 
								  fGeom(0), 
								  fOption(""),
								  fRemoveBadChannels(kFALSE),
								  fFittingAlgorithm(fitAlgo),  
								  fTimeMin(-1.),
								  fTimeMax(1.),
								  fUseFALTRO(kTRUE),
								  fRawAnalyzer(0),
								  fTriggerRawDigitMaker(0x0)
{
  // ctor; set up fit algo etc
  
  SetFittingAlgorithm(fitAlgo);
  
  const TObjArray* maps = AliEMCALRecParam::GetMappings();
  
  if(!maps) AliFatal("Cannot retrieve ALTRO mappings!!");
  
  for(Int_t i = 0; i < 4; i++)
  {
    fMapping[i] = (AliAltroMapping*)maps->At(i);
  }
  
  AliRunLoader *rl = AliRunLoader::Instance();
  if (rl && rl->GetAliRun())
  {
    AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
    if(emcal)
    {
      fGeom = emcal->GetGeometry();
    }
    else
    {
      AliDebug(1, Form("Using default geometry in raw reco"));
      fGeom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
    }
  }
  else
  {
    AliDebug(1, Form("Using default geometry in raw reco"));
    fGeom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
  }
  
  if(!fGeom) AliFatal(Form("Could not get geometry!"));
  fTriggerRawDigitMaker = new AliEMCALTriggerRawDigitMaker();
}


AliEMCALRawUtils::~AliEMCALRawUtils()
{
  //dtor
  delete fRawAnalyzer;
  delete fTriggerRawDigitMaker;
}


void AliEMCALRawUtils::Digits2Raw()
{
  // convert digits of the current event to raw data
  AliRunLoader *rl = AliRunLoader::Instance();
  AliEMCALLoader *loader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
  loader->LoadDigits("EMCAL");
  loader->GetEvent();
  TClonesArray* digits = loader->Digits() ;
  
  if (!digits) {
    Warning("Digits2Raw", "no digits found !");
    return;
  }
  
  static const Int_t nDDL = 20*2; // 20 SM for EMCal + DCal hardcoded for now. Buffers allocated dynamically, when needed, so just need an upper limit here  
  AliAltroBuffer* buffers[nDDL];
  for (Int_t i=0; i < nDDL; i++)
    buffers[i] = 0;
  
  TArrayI adcValuesLow( TIMEBINS );
  TArrayI adcValuesHigh( TIMEBINS );
  
  // loop over digits (assume ordered digits)
  for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
    AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
    if(!digit) {
      AliFatal("NULL Digit");
    } else {
      if (digit->GetAmplitude() <  AliEMCALRawResponse::GetRawFormatThreshold() ) {
        continue;
      }
      //get cell indices
      Int_t nSM = 0;
      Int_t nIphi = 0;
      Int_t nIeta = 0;
      Int_t iphi = 0;
      Int_t ieta = 0;
      Int_t nModule = 0;
      fGeom->GetCellIndex(digit->GetId(), nSM, nModule, nIphi, nIeta);
      fGeom->GetCellPhiEtaIndexInSModule(nSM, nModule, nIphi, nIeta,iphi, ieta) ;
    
      //Check which is the RCU, 0 or 1, of the cell.
      Int_t iRCU = -111;
      if (0<=iphi&&iphi<8) iRCU=0; // first cable row
      else if (8<=iphi&&iphi<16 && 0<=ieta&&ieta<24) iRCU=0; // first half; 
      else if(8<=iphi&&iphi<16 && 24<=ieta&&ieta<48) iRCU=1; // second half; 
      //second cable row
      else if(16<=iphi&&iphi<24) iRCU=1; // third cable row
      
      if (nSM%2==1) iRCU = 1 - iRCU; // swap for odd=C side, to allow us to cable both sides the same
      
      if (iRCU<0) 
        Fatal("Digits2Raw()","Non-existent RCU number: %d", iRCU);
    
      //Which DDL?
      Int_t iDDL = NRCUSPERMODULE*nSM + iRCU;
      if (iDDL < 0 || iDDL >= nDDL){
        Fatal("Digits2Raw()","Non-existent DDL board number: %d", iDDL);
      } else {
        if (buffers[iDDL] == 0) {      
          // open new file and write dummy header
          TString fileName = AliDAQ::DdlFileName("EMCAL",iDDL);
          //Select mapping file RCU0A, RCU0C, RCU1A, RCU1C
          Int_t iRCUside=iRCU+(nSM%2)*2;
          //iRCU=0 and even (0) SM -> RCU0A.data   0
          //iRCU=1 and even (0) SM -> RCU1A.data   1
          //iRCU=0 and odd  (1) SM -> RCU0C.data   2
          //iRCU=1 and odd  (1) SM -> RCU1C.data   3
          buffers[iDDL] = new AliAltroBuffer(fileName.Data(),fMapping[iRCUside]);
          buffers[iDDL]->WriteDataHeader(kTRUE, kFALSE);  //Dummy;
        }
        
        // out of time range signal (?)
        if (digit->GetTimeR() >  TIMEBINMAX  ) {
          AliInfo("Signal is out of time range.\n");
          buffers[iDDL]->FillBuffer((Int_t)digit->GetAmplitude());
          buffers[iDDL]->FillBuffer( TIMEBINS );  // time bin
          buffers[iDDL]->FillBuffer(3);          // bunch length      
          buffers[iDDL]->WriteTrailer(3, ieta, iphi, nSM);  // trailer
          // calculate the time response function
        } else {
          Bool_t lowgain = AliEMCALRawResponse::RawSampledResponse(digit->GetTimeR(), digit->GetAmplitude(),
                                                                   adcValuesHigh.GetArray(), adcValuesLow.GetArray()) ; 
      
          if (lowgain) 
            buffers[iDDL]->WriteChannel(ieta, iphi, 0, TIMEBINS, adcValuesLow.GetArray(),  AliEMCALRawResponse::GetRawFormatThreshold()  );
          else 
            buffers[iDDL]->WriteChannel(ieta,iphi, 1, TIMEBINS, adcValuesHigh.GetArray(),  AliEMCALRawResponse::GetRawFormatThreshold()  );
        }
      }// iDDL under the limits
    }//digit exists
  }//Digit loop
  
  // write headers and close files
  for (Int_t i=0; i < nDDL; i++) {
    if (buffers[i]) {
      buffers[i]->Flush();
      buffers[i]->WriteDataHeader(kFALSE, kFALSE);
      delete buffers[i];
    }
  }
  
  loader->UnloadDigits();
}



void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time, Float_t chi2, Int_t ndf) 
{
  // comment
  AliEMCALDigit *digit = 0, *tmpdigit = 0;
  TIter nextdigit(digitsArr);
 
  while (digit == 0 && (tmpdigit = (AliEMCALDigit*) nextdigit())) 
    {
      if (tmpdigit->GetId() == id) digit = tmpdigit;
    }
  
  if (!digit) { // no digit existed for this tower; create one
    Int_t type = AliEMCALDigit::kHG; // use enum in AliEMCALDigit
    if (lowGain) 
      { 
	amp *= HGLGFACTOR;
	type = AliEMCALDigit::kLGnoHG;
      } 
    
    Int_t idigit = digitsArr->GetEntries();
    new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, type, idigit, chi2, ndf); 
    AliDebug(2,Form("Add digit Id %d for the first time, type %d", id, type));
  }//digit added first time
  else 
    { // a digit already exists, check range 
		// (use high gain if signal < cut value, otherwise low gain)
      if (lowGain) 
	{ // new digit is low gain
	  if (digit->GetAmplitude() >  OVERFLOWCUT ) 
	    {  // use if previously stored (HG) digit is out of range
	      digit->SetAmplitude( HGLGFACTOR * amp);
	      digit->SetTime(time);
	      digit->SetType(AliEMCALDigit::kLG);
	      AliDebug(2,Form("Add LG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
	    }
	}//new low gain digit
      else { // new digit is high gain 
	
	if (amp <  OVERFLOWCUT  ) 
	  { // new digit is high gain; use if not out of range
	    digit->SetAmplitude(amp);
	    digit->SetTime(time);
	    digit->SetType(AliEMCALDigit::kHG);
	    AliDebug(2,Form("Add HG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
	  }
	else 
	  { // HG out of range, just change flag value to show that HG did exist
	    digit->SetType(AliEMCALDigit::kLG);
	    AliDebug(2,Form("Change LG digit to HG, ID %d, type %d", digit->GetId(), digit->GetType()));
	  }
      }//new high gain digit
    }//digit existed replace it
}


void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray *digitsArr, const AliCaloCalibPedestal* pedbadmap, TClonesArray *digitsTRG, AliEMCALTriggerData* trgData)
{
  //conversion of raw data to digits
  if ( digitsArr) digitsArr->Clear("C"); 
  if (!digitsArr) { Error("Raw2Digits", "no digits found !");return;}
  if (!reader) {Error("Raw2Digits", "no raw reader found !");return;}
  AliEMCALTriggerSTURawStream inSTU(reader);
  AliCaloRawStreamV3 in(reader,"EMCAL",fMapping);	
  reader->Select("EMCAL",0,39); // 39 = AliEMCALGeoParams::fgkLastAltroDDL
  fTriggerRawDigitMaker->Reset();	
  fTriggerRawDigitMaker->SetIO(reader, in, inSTU, digitsTRG, trgData);
  fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
    
  Int_t lowGain  = 0;
  Int_t caloFlag = 0; // low, high gain, or TRU, or LED ref.
  
  Float_t bcTimePhaseCorr = 0; // for BC-based L1 phase correction
  Int_t bcMod4 = (reader->GetBCID() % 4); // LHC uses 40 MHz, EMCal uses 10 MHz clock
	
  //AliCDBManager* man = AliCDBManager::Instance();
  //Int_t runNumber = man->GetRun();
	
 Int_t runNumber = reader->GetRunNumber();

  if ((runNumber >130850 ) && (bcMod4==0 || bcMod4==1)) 
    bcTimePhaseCorr = -1e-7; // subtract 100 ns for certain BC values

  while (in.NextDDL()) 
    {
      while (in.NextChannel()) 
	{
    	  caloFlag = in.GetCaloFlag();
	  if (caloFlag > 2) continue; // Work with ALTRO and FALTRO 
    	  if(caloFlag < 2 && fRemoveBadChannels && pedbadmap->IsBadChannel(in.GetModule(),in.GetColumn(),in.GetRow()))
	    {
	      continue;
	    }  
      	  vector<AliCaloBunchInfo> bunchlist; 
	  while (in.NextBunch()) 
	    {
	      bunchlist.push_back( AliCaloBunchInfo(in.GetStartTimeBin(), in.GetBunchLength(), in.GetSignals() ) );
	    } 
	  if (bunchlist.size() == 0) continue;
      	  if ( caloFlag < 2 )
	    { // ALTRO
	      Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
	      lowGain  = in.IsLowGain();
	      fRawAnalyzer->SetL1Phase( in.GetL1Phase() );
	      AliCaloFitResults res =  fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());  
	      if(res.GetAmp() >= fNoiseThreshold )
		{
		  AddDigit(digitsArr, id, lowGain, res.GetAmp(),  res.GetTime()+bcTimePhaseCorr, res.GetChi2(),  res.GetNdf() ); 
		}
	    }//ALTRO
	  else if(fUseFALTRO)
	    {// Fake ALTRO
	      fTriggerRawDigitMaker->Add( bunchlist );
	    }//Fake ALTRO
	} // end while over channel   
    } //end while over DDL's, of input stream 
  fTriggerRawDigitMaker->PostProcess();	
  TrimDigits(digitsArr);
}


void AliEMCALRawUtils::TrimDigits(TClonesArray *digitsArr) 
{ // rm entries with LGnoHG (unphysical), out of time window, and too bad chi2
  AliEMCALDigit *digit = 0;
  Int_t n = 0;
  Int_t nDigits = digitsArr->GetEntriesFast();
  TIter nextdigit(digitsArr);
  while ((digit = (AliEMCALDigit*) nextdigit())) {
    if (digit->GetType() == AliEMCALDigit::kLGnoHG) {
      AliDebug(1,Form("Remove digit with id %d, LGnoHG",digit->GetId()));
      digitsArr->Remove(digit);
    }
    else if(fTimeMin > digit->GetTime() || fTimeMax < digit->GetTime()) {
      digitsArr->Remove(digit);
      AliDebug(1,Form("Remove digit with id %d, Bad Time %e",digit->GetId(), digit->GetTime()));
    }
    else if (0 > digit->GetChi2()) {
      digitsArr->Remove(digit);
      AliDebug(1,Form("Remove digit with id %d, Bad Chi2 %e",digit->GetId(), digit->GetChi2()));
    }
    else {
      digit->SetIndexInList(n);	
      n++;
    }    
  }//while
  
  digitsArr->Compress();
  AliDebug(1,Form("N Digits before trimming : %d; after array compression %d",nDigits,digitsArr->GetEntriesFast()));
}


void AliEMCALRawUtils::SetFittingAlgorithm(Int_t fitAlgo)              
{ // select which fitting algo should be used
  delete fRawAnalyzer; // delete doesn't do anything if the pointer is 0x0
  fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer( fitAlgo );
  fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done, for the new methods
  fRawAnalyzer->SetOverflowCut ( OVERFLOWCUT );
  fRawAnalyzer->SetAmpCut(fNoiseThreshold);
  fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
}



 AliEMCALRawUtils.cxx:1
 AliEMCALRawUtils.cxx:2
 AliEMCALRawUtils.cxx:3
 AliEMCALRawUtils.cxx:4
 AliEMCALRawUtils.cxx:5
 AliEMCALRawUtils.cxx:6
 AliEMCALRawUtils.cxx:7
 AliEMCALRawUtils.cxx:8
 AliEMCALRawUtils.cxx:9
 AliEMCALRawUtils.cxx:10
 AliEMCALRawUtils.cxx:11
 AliEMCALRawUtils.cxx:12
 AliEMCALRawUtils.cxx:13
 AliEMCALRawUtils.cxx:14
 AliEMCALRawUtils.cxx:15
 AliEMCALRawUtils.cxx:16
 AliEMCALRawUtils.cxx:17
 AliEMCALRawUtils.cxx:18
 AliEMCALRawUtils.cxx:19
 AliEMCALRawUtils.cxx:20
 AliEMCALRawUtils.cxx:21
 AliEMCALRawUtils.cxx:22
 AliEMCALRawUtils.cxx:23
 AliEMCALRawUtils.cxx:24
 AliEMCALRawUtils.cxx:25
 AliEMCALRawUtils.cxx:26
 AliEMCALRawUtils.cxx:27
 AliEMCALRawUtils.cxx:28
 AliEMCALRawUtils.cxx:29
 AliEMCALRawUtils.cxx:30
 AliEMCALRawUtils.cxx:31
 AliEMCALRawUtils.cxx:32
 AliEMCALRawUtils.cxx:33
 AliEMCALRawUtils.cxx:34
 AliEMCALRawUtils.cxx:35
 AliEMCALRawUtils.cxx:36
 AliEMCALRawUtils.cxx:37
 AliEMCALRawUtils.cxx:38
 AliEMCALRawUtils.cxx:39
 AliEMCALRawUtils.cxx:40
 AliEMCALRawUtils.cxx:41
 AliEMCALRawUtils.cxx:42
 AliEMCALRawUtils.cxx:43
 AliEMCALRawUtils.cxx:44
 AliEMCALRawUtils.cxx:45
 AliEMCALRawUtils.cxx:46
 AliEMCALRawUtils.cxx:47
 AliEMCALRawUtils.cxx:48
 AliEMCALRawUtils.cxx:49
 AliEMCALRawUtils.cxx:50
 AliEMCALRawUtils.cxx:51
 AliEMCALRawUtils.cxx:52
 AliEMCALRawUtils.cxx:53
 AliEMCALRawUtils.cxx:54
 AliEMCALRawUtils.cxx:55
 AliEMCALRawUtils.cxx:56
 AliEMCALRawUtils.cxx:57
 AliEMCALRawUtils.cxx:58
 AliEMCALRawUtils.cxx:59
 AliEMCALRawUtils.cxx:60
 AliEMCALRawUtils.cxx:61
 AliEMCALRawUtils.cxx:62
 AliEMCALRawUtils.cxx:63
 AliEMCALRawUtils.cxx:64
 AliEMCALRawUtils.cxx:65
 AliEMCALRawUtils.cxx:66
 AliEMCALRawUtils.cxx:67
 AliEMCALRawUtils.cxx:68
 AliEMCALRawUtils.cxx:69
 AliEMCALRawUtils.cxx:70
 AliEMCALRawUtils.cxx:71
 AliEMCALRawUtils.cxx:72
 AliEMCALRawUtils.cxx:73
 AliEMCALRawUtils.cxx:74
 AliEMCALRawUtils.cxx:75
 AliEMCALRawUtils.cxx:76
 AliEMCALRawUtils.cxx:77
 AliEMCALRawUtils.cxx:78
 AliEMCALRawUtils.cxx:79
 AliEMCALRawUtils.cxx:80
 AliEMCALRawUtils.cxx:81
 AliEMCALRawUtils.cxx:82
 AliEMCALRawUtils.cxx:83
 AliEMCALRawUtils.cxx:84
 AliEMCALRawUtils.cxx:85
 AliEMCALRawUtils.cxx:86
 AliEMCALRawUtils.cxx:87
 AliEMCALRawUtils.cxx:88
 AliEMCALRawUtils.cxx:89
 AliEMCALRawUtils.cxx:90
 AliEMCALRawUtils.cxx:91
 AliEMCALRawUtils.cxx:92
 AliEMCALRawUtils.cxx:93
 AliEMCALRawUtils.cxx:94
 AliEMCALRawUtils.cxx:95
 AliEMCALRawUtils.cxx:96
 AliEMCALRawUtils.cxx:97
 AliEMCALRawUtils.cxx:98
 AliEMCALRawUtils.cxx:99
 AliEMCALRawUtils.cxx:100
 AliEMCALRawUtils.cxx:101
 AliEMCALRawUtils.cxx:102
 AliEMCALRawUtils.cxx:103
 AliEMCALRawUtils.cxx:104
 AliEMCALRawUtils.cxx:105
 AliEMCALRawUtils.cxx:106
 AliEMCALRawUtils.cxx:107
 AliEMCALRawUtils.cxx:108
 AliEMCALRawUtils.cxx:109
 AliEMCALRawUtils.cxx:110
 AliEMCALRawUtils.cxx:111
 AliEMCALRawUtils.cxx:112
 AliEMCALRawUtils.cxx:113
 AliEMCALRawUtils.cxx:114
 AliEMCALRawUtils.cxx:115
 AliEMCALRawUtils.cxx:116
 AliEMCALRawUtils.cxx:117
 AliEMCALRawUtils.cxx:118
 AliEMCALRawUtils.cxx:119
 AliEMCALRawUtils.cxx:120
 AliEMCALRawUtils.cxx:121
 AliEMCALRawUtils.cxx:122
 AliEMCALRawUtils.cxx:123
 AliEMCALRawUtils.cxx:124
 AliEMCALRawUtils.cxx:125
 AliEMCALRawUtils.cxx:126
 AliEMCALRawUtils.cxx:127
 AliEMCALRawUtils.cxx:128
 AliEMCALRawUtils.cxx:129
 AliEMCALRawUtils.cxx:130
 AliEMCALRawUtils.cxx:131
 AliEMCALRawUtils.cxx:132
 AliEMCALRawUtils.cxx:133
 AliEMCALRawUtils.cxx:134
 AliEMCALRawUtils.cxx:135
 AliEMCALRawUtils.cxx:136
 AliEMCALRawUtils.cxx:137
 AliEMCALRawUtils.cxx:138
 AliEMCALRawUtils.cxx:139
 AliEMCALRawUtils.cxx:140
 AliEMCALRawUtils.cxx:141
 AliEMCALRawUtils.cxx:142
 AliEMCALRawUtils.cxx:143
 AliEMCALRawUtils.cxx:144
 AliEMCALRawUtils.cxx:145
 AliEMCALRawUtils.cxx:146
 AliEMCALRawUtils.cxx:147
 AliEMCALRawUtils.cxx:148
 AliEMCALRawUtils.cxx:149
 AliEMCALRawUtils.cxx:150
 AliEMCALRawUtils.cxx:151
 AliEMCALRawUtils.cxx:152
 AliEMCALRawUtils.cxx:153
 AliEMCALRawUtils.cxx:154
 AliEMCALRawUtils.cxx:155
 AliEMCALRawUtils.cxx:156
 AliEMCALRawUtils.cxx:157
 AliEMCALRawUtils.cxx:158
 AliEMCALRawUtils.cxx:159
 AliEMCALRawUtils.cxx:160
 AliEMCALRawUtils.cxx:161
 AliEMCALRawUtils.cxx:162
 AliEMCALRawUtils.cxx:163
 AliEMCALRawUtils.cxx:164
 AliEMCALRawUtils.cxx:165
 AliEMCALRawUtils.cxx:166
 AliEMCALRawUtils.cxx:167
 AliEMCALRawUtils.cxx:168
 AliEMCALRawUtils.cxx:169
 AliEMCALRawUtils.cxx:170
 AliEMCALRawUtils.cxx:171
 AliEMCALRawUtils.cxx:172
 AliEMCALRawUtils.cxx:173
 AliEMCALRawUtils.cxx:174
 AliEMCALRawUtils.cxx:175
 AliEMCALRawUtils.cxx:176
 AliEMCALRawUtils.cxx:177
 AliEMCALRawUtils.cxx:178
 AliEMCALRawUtils.cxx:179
 AliEMCALRawUtils.cxx:180
 AliEMCALRawUtils.cxx:181
 AliEMCALRawUtils.cxx:182
 AliEMCALRawUtils.cxx:183
 AliEMCALRawUtils.cxx:184
 AliEMCALRawUtils.cxx:185
 AliEMCALRawUtils.cxx:186
 AliEMCALRawUtils.cxx:187
 AliEMCALRawUtils.cxx:188
 AliEMCALRawUtils.cxx:189
 AliEMCALRawUtils.cxx:190
 AliEMCALRawUtils.cxx:191
 AliEMCALRawUtils.cxx:192
 AliEMCALRawUtils.cxx:193
 AliEMCALRawUtils.cxx:194
 AliEMCALRawUtils.cxx:195
 AliEMCALRawUtils.cxx:196
 AliEMCALRawUtils.cxx:197
 AliEMCALRawUtils.cxx:198
 AliEMCALRawUtils.cxx:199
 AliEMCALRawUtils.cxx:200
 AliEMCALRawUtils.cxx:201
 AliEMCALRawUtils.cxx:202
 AliEMCALRawUtils.cxx:203
 AliEMCALRawUtils.cxx:204
 AliEMCALRawUtils.cxx:205
 AliEMCALRawUtils.cxx:206
 AliEMCALRawUtils.cxx:207
 AliEMCALRawUtils.cxx:208
 AliEMCALRawUtils.cxx:209
 AliEMCALRawUtils.cxx:210
 AliEMCALRawUtils.cxx:211
 AliEMCALRawUtils.cxx:212
 AliEMCALRawUtils.cxx:213
 AliEMCALRawUtils.cxx:214
 AliEMCALRawUtils.cxx:215
 AliEMCALRawUtils.cxx:216
 AliEMCALRawUtils.cxx:217
 AliEMCALRawUtils.cxx:218
 AliEMCALRawUtils.cxx:219
 AliEMCALRawUtils.cxx:220
 AliEMCALRawUtils.cxx:221
 AliEMCALRawUtils.cxx:222
 AliEMCALRawUtils.cxx:223
 AliEMCALRawUtils.cxx:224
 AliEMCALRawUtils.cxx:225
 AliEMCALRawUtils.cxx:226
 AliEMCALRawUtils.cxx:227
 AliEMCALRawUtils.cxx:228
 AliEMCALRawUtils.cxx:229
 AliEMCALRawUtils.cxx:230
 AliEMCALRawUtils.cxx:231
 AliEMCALRawUtils.cxx:232
 AliEMCALRawUtils.cxx:233
 AliEMCALRawUtils.cxx:234
 AliEMCALRawUtils.cxx:235
 AliEMCALRawUtils.cxx:236
 AliEMCALRawUtils.cxx:237
 AliEMCALRawUtils.cxx:238
 AliEMCALRawUtils.cxx:239
 AliEMCALRawUtils.cxx:240
 AliEMCALRawUtils.cxx:241
 AliEMCALRawUtils.cxx:242
 AliEMCALRawUtils.cxx:243
 AliEMCALRawUtils.cxx:244
 AliEMCALRawUtils.cxx:245
 AliEMCALRawUtils.cxx:246
 AliEMCALRawUtils.cxx:247
 AliEMCALRawUtils.cxx:248
 AliEMCALRawUtils.cxx:249
 AliEMCALRawUtils.cxx:250
 AliEMCALRawUtils.cxx:251
 AliEMCALRawUtils.cxx:252
 AliEMCALRawUtils.cxx:253
 AliEMCALRawUtils.cxx:254
 AliEMCALRawUtils.cxx:255
 AliEMCALRawUtils.cxx:256
 AliEMCALRawUtils.cxx:257
 AliEMCALRawUtils.cxx:258
 AliEMCALRawUtils.cxx:259
 AliEMCALRawUtils.cxx:260
 AliEMCALRawUtils.cxx:261
 AliEMCALRawUtils.cxx:262
 AliEMCALRawUtils.cxx:263
 AliEMCALRawUtils.cxx:264
 AliEMCALRawUtils.cxx:265
 AliEMCALRawUtils.cxx:266
 AliEMCALRawUtils.cxx:267
 AliEMCALRawUtils.cxx:268
 AliEMCALRawUtils.cxx:269
 AliEMCALRawUtils.cxx:270
 AliEMCALRawUtils.cxx:271
 AliEMCALRawUtils.cxx:272
 AliEMCALRawUtils.cxx:273
 AliEMCALRawUtils.cxx:274
 AliEMCALRawUtils.cxx:275
 AliEMCALRawUtils.cxx:276
 AliEMCALRawUtils.cxx:277
 AliEMCALRawUtils.cxx:278
 AliEMCALRawUtils.cxx:279
 AliEMCALRawUtils.cxx:280
 AliEMCALRawUtils.cxx:281
 AliEMCALRawUtils.cxx:282
 AliEMCALRawUtils.cxx:283
 AliEMCALRawUtils.cxx:284
 AliEMCALRawUtils.cxx:285
 AliEMCALRawUtils.cxx:286
 AliEMCALRawUtils.cxx:287
 AliEMCALRawUtils.cxx:288
 AliEMCALRawUtils.cxx:289
 AliEMCALRawUtils.cxx:290
 AliEMCALRawUtils.cxx:291
 AliEMCALRawUtils.cxx:292
 AliEMCALRawUtils.cxx:293
 AliEMCALRawUtils.cxx:294
 AliEMCALRawUtils.cxx:295
 AliEMCALRawUtils.cxx:296
 AliEMCALRawUtils.cxx:297
 AliEMCALRawUtils.cxx:298
 AliEMCALRawUtils.cxx:299
 AliEMCALRawUtils.cxx:300
 AliEMCALRawUtils.cxx:301
 AliEMCALRawUtils.cxx:302
 AliEMCALRawUtils.cxx:303
 AliEMCALRawUtils.cxx:304
 AliEMCALRawUtils.cxx:305
 AliEMCALRawUtils.cxx:306
 AliEMCALRawUtils.cxx:307
 AliEMCALRawUtils.cxx:308
 AliEMCALRawUtils.cxx:309
 AliEMCALRawUtils.cxx:310
 AliEMCALRawUtils.cxx:311
 AliEMCALRawUtils.cxx:312
 AliEMCALRawUtils.cxx:313
 AliEMCALRawUtils.cxx:314
 AliEMCALRawUtils.cxx:315
 AliEMCALRawUtils.cxx:316
 AliEMCALRawUtils.cxx:317
 AliEMCALRawUtils.cxx:318
 AliEMCALRawUtils.cxx:319
 AliEMCALRawUtils.cxx:320
 AliEMCALRawUtils.cxx:321
 AliEMCALRawUtils.cxx:322
 AliEMCALRawUtils.cxx:323
 AliEMCALRawUtils.cxx:324
 AliEMCALRawUtils.cxx:325
 AliEMCALRawUtils.cxx:326
 AliEMCALRawUtils.cxx:327
 AliEMCALRawUtils.cxx:328
 AliEMCALRawUtils.cxx:329
 AliEMCALRawUtils.cxx:330
 AliEMCALRawUtils.cxx:331
 AliEMCALRawUtils.cxx:332
 AliEMCALRawUtils.cxx:333
 AliEMCALRawUtils.cxx:334
 AliEMCALRawUtils.cxx:335
 AliEMCALRawUtils.cxx:336
 AliEMCALRawUtils.cxx:337
 AliEMCALRawUtils.cxx:338
 AliEMCALRawUtils.cxx:339
 AliEMCALRawUtils.cxx:340
 AliEMCALRawUtils.cxx:341
 AliEMCALRawUtils.cxx:342
 AliEMCALRawUtils.cxx:343
 AliEMCALRawUtils.cxx:344
 AliEMCALRawUtils.cxx:345
 AliEMCALRawUtils.cxx:346
 AliEMCALRawUtils.cxx:347
 AliEMCALRawUtils.cxx:348
 AliEMCALRawUtils.cxx:349
 AliEMCALRawUtils.cxx:350
 AliEMCALRawUtils.cxx:351
 AliEMCALRawUtils.cxx:352
 AliEMCALRawUtils.cxx:353
 AliEMCALRawUtils.cxx:354
 AliEMCALRawUtils.cxx:355
 AliEMCALRawUtils.cxx:356
 AliEMCALRawUtils.cxx:357
 AliEMCALRawUtils.cxx:358
 AliEMCALRawUtils.cxx:359
 AliEMCALRawUtils.cxx:360
 AliEMCALRawUtils.cxx:361
 AliEMCALRawUtils.cxx:362
 AliEMCALRawUtils.cxx:363
 AliEMCALRawUtils.cxx:364
 AliEMCALRawUtils.cxx:365
 AliEMCALRawUtils.cxx:366
 AliEMCALRawUtils.cxx:367
 AliEMCALRawUtils.cxx:368
 AliEMCALRawUtils.cxx:369
 AliEMCALRawUtils.cxx:370
 AliEMCALRawUtils.cxx:371
 AliEMCALRawUtils.cxx:372
 AliEMCALRawUtils.cxx:373
 AliEMCALRawUtils.cxx:374
 AliEMCALRawUtils.cxx:375
 AliEMCALRawUtils.cxx:376
 AliEMCALRawUtils.cxx:377
 AliEMCALRawUtils.cxx:378
 AliEMCALRawUtils.cxx:379
 AliEMCALRawUtils.cxx:380
 AliEMCALRawUtils.cxx:381
 AliEMCALRawUtils.cxx:382
 AliEMCALRawUtils.cxx:383
 AliEMCALRawUtils.cxx:384
 AliEMCALRawUtils.cxx:385
 AliEMCALRawUtils.cxx:386
 AliEMCALRawUtils.cxx:387
 AliEMCALRawUtils.cxx:388
 AliEMCALRawUtils.cxx:389
 AliEMCALRawUtils.cxx:390