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

// -*- 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 = 12*2; // 12 SM 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,43); // 43 = 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);
}
Commit	Line	Data
168c7b3c	1	// -- mode: c++ --
ee299369	2	/**************************************************************************
	3	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Author: The ALICE Off-line Project. *
	6	* Contributors are mentioned in the code where appropriate. *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/* $Id$ */
ee299369	18
de39a0ff	19
e5bbbc4e	20	//_________________________________________________________________________
	21	// Utility Class for handling Raw data
	22	// Does all transitions from Digits to Raw and vice versa,
	23	// for simu and reconstruction
	24	//
	25	// Note: the current version is still simplified. Only
	26	// one raw signal per digit is generated; either high-gain or low-gain
	27	// Need to add concurrent high and low-gain info in the future
	28	// No pedestal is added to the raw signal.
ee299369	29	//*-- Author: Marco van Leeuwen (LBL)
77eac271	30	//*-- Major refactoring by Per Thomas Hille
92d9f317	31
2d45a08f	32	//#include "AliCDBManager.h"
ee299369	33	#include "AliEMCALRawUtils.h"
72c58de0	34	#include "AliRun.h"
ee299369	35	#include "AliRunLoader.h"
ee299369	36	#include "AliAltroBuffer.h"
ee299369	37	#include "AliRawReader.h"
32cd4c24	38	#include "AliCaloRawStreamV3.h"
ee299369	39	#include "AliDAQ.h"
feedcab9	40	#include "AliEMCALRecParam.h"
ee299369	41	#include "AliEMCALLoader.h"
ee299369	42	#include "AliEMCALGeometry.h"
ee299369	43	#include "AliEMCALDigit.h"
916f1e76	44	#include "AliEMCALRawDigit.h"
20b636fc	45	#include "AliEMCAL.h"
5e3106bc	46	#include "AliCaloCalibPedestal.h"
16605c06	47	#include "AliCaloBunchInfo.h"
16605c06	48	#include "AliCaloFitResults.h"
de39a0ff	49	#include "AliEMCALTriggerRawDigitMaker.h"
	50	#include "AliEMCALTriggerSTURawStream.h"
	51	#include "AliEMCALTriggerData.h"
92d9f317	52	#include "AliCaloConstants.h"
	53	#include "AliCaloRawAnalyzer.h"
	54	#include "AliCaloRawAnalyzerFactory.h"
1f847d9f	55	#include "AliEMCALRawResponse.h"
9f467289	56
92d9f317	57	using namespace CALO;
92d9f317	58	using namespace EMCAL;
ee299369	59
0267cfa6	60	using std::vector;
92d9f317	61	ClassImp(AliEMCALRawUtils)
92d9f317	62
b4133f05	63
92d9f317	64	AliEMCALRawUtils::AliEMCALRawUtils( Algo::fitAlgorithm fitAlgo) : fNoiseThreshold(3),
	65	fNPedSamples(4),
	66	fGeom(0),
	67	fOption(""),
	68	fRemoveBadChannels(kFALSE),
77eac271	69	fFittingAlgorithm(fitAlgo),
92d9f317	70	fTimeMin(-1.),
	71	fTimeMax(1.),
	72	fUseFALTRO(kTRUE),
	73	fRawAnalyzer(0),
	74	fTriggerRawDigitMaker(0x0)
dab4328c	75	{ // ctor; set up fit algo etc
4fe71e02	76	SetFittingAlgorithm(fitAlgo);
65bdc82f	77	const TObjArray* maps = AliEMCALRecParam::GetMappings();
65bdc82f	78	if(!maps) AliFatal("Cannot retrieve ALTRO mappings!!");
77eac271	79	for(Int_t i = 0; i < 4; i++)
	80	{
	81	fMapping[i] = (AliAltroMapping*)maps->At(i);
	82	}
	83
33c3c91a	84	AliRunLoader *rl = AliRunLoader::Instance();
77eac271	85	if (rl && rl->GetAliRun())
77eac271	86	{
a2339fea	87	AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
77eac271	88	if(emcal)
	89	{
	90	fGeom = emcal->GetGeometry();
	91	}
	92	else
	93	{
	94	AliDebug(1, Form("Using default geometry in raw reco"));
	95	fGeom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
	96	}
	97	}
	98	else
	99	{
a2339fea	100	AliDebug(1, Form("Using default geometry in raw reco"));
	101	fGeom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
	102	}
92d9f317	103
5544799a	104	if(!fGeom) AliFatal(Form("Could not get geometry!"));
77eac271	105	fTriggerRawDigitMaker = new AliEMCALTriggerRawDigitMaker();
5544799a	106	}
5544799a	107
65bdc82f	108
92d9f317	109	AliEMCALRawUtils::~AliEMCALRawUtils()
65bdc82f	110	{
e5bbbc4e	111	//dtor
48b634ff	112	delete fRawAnalyzer;
48b634ff	113	delete fTriggerRawDigitMaker;
ee299369	114	}
65bdc82f	115
92d9f317	116
65bdc82f	117	void AliEMCALRawUtils::Digits2Raw()
ee299369	118	{
ee299369	119	// convert digits of the current event to raw data
33c3c91a	120	AliRunLoader *rl = AliRunLoader::Instance();
ee299369	121	AliEMCALLoader loader = dynamic_cast<AliEMCALLoader>(rl->GetDetectorLoader("EMCAL"));
ee299369	122	loader->LoadDigits("EMCAL");
	123	loader->GetEvent();
	124	TClonesArray* digits = loader->Digits() ;
	125
	126	if (!digits) {
	127	Warning("Digits2Raw", "no digits found !");
	128	return;
	129	}
a2339fea	130
ee299369	131	static const Int_t nDDL = 12*2; // 12 SM hardcoded for now. Buffers allocated dynamically, when needed, so just need an upper limit here
	132	AliAltroBuffer* buffers[nDDL];
	133	for (Int_t i=0; i < nDDL; i++)
	134	buffers[i] = 0;
a2339fea	135
92d9f317	136	TArrayI adcValuesLow( TIMEBINS );
92d9f317	137	TArrayI adcValuesHigh( TIMEBINS );
de39a0ff	138
ee299369	139	// loop over digits (assume ordered digits)
92d9f317	140	for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++)
	141	{
	142	AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
	143	if(!digit)
	144	{
	145	AliFatal("NULL Digit");
	146	}
	147	else
	148	{
1f847d9f	149	if (digit->GetAmplitude() < AliEMCALRawResponse::GetRawFormatThreshold() )
92d9f317	150	{
	151	continue;
	152	}
	153	//get cell indices
	154	Int_t nSM = 0;
	155	Int_t nIphi = 0;
	156	Int_t nIeta = 0;
	157	Int_t iphi = 0;
	158	Int_t ieta = 0;
	159	Int_t nModule = 0;
	160	fGeom->GetCellIndex(digit->GetId(), nSM, nModule, nIphi, nIeta);
	161	fGeom->GetCellPhiEtaIndexInSModule(nSM, nModule, nIphi, nIeta,iphi, ieta) ;
de39a0ff	162
92d9f317	163	//Check which is the RCU, 0 or 1, of the cell.
92d9f317	164	Int_t iRCU = -111;
77eac271	165	if (0<=iphi&&iphi<8) iRCU=0; // first cable row
	166	else if (8<=iphi&&iphi<16 && 0<=ieta&&ieta<24) iRCU=0; // first half;
	167	else if(8<=iphi&&iphi<16 && 24<=ieta&&ieta<48) iRCU=1; // second half;
	168	//second cable row
	169	else if(16<=iphi&&iphi<24) iRCU=1; // third cable row
	170
	171	if (nSM%2==1) iRCU = 1 - iRCU; // swap for odd=C side, to allow us to cable both sides the same
	172
	173	if (iRCU<0)
	174	Fatal("Digits2Raw()","Non-existent RCU number: %d", iRCU);
de39a0ff	175
77eac271	176	//Which DDL?
	177	Int_t iDDL = NRCUSPERMODULE*nSM + iRCU;
	178	if (iDDL < 0 \|\| iDDL >= nDDL){
	179	Fatal("Digits2Raw()","Non-existent DDL board number: %d", iDDL);
	180	}
	181	else{
	182	if (buffers[iDDL] == 0)
	183	{
	184	// open new file and write dummy header
	185	TString fileName = AliDAQ::DdlFileName("EMCAL",iDDL);
	186	//Select mapping file RCU0A, RCU0C, RCU1A, RCU1C
a2339fea	187	Int_t iRCUside=iRCU+(nSM%2)*2;
	188	//iRCU=0 and even (0) SM -> RCU0A.data 0
	189	//iRCU=1 and even (0) SM -> RCU1A.data 1
	190	//iRCU=0 and odd (1) SM -> RCU0C.data 2
	191	//iRCU=1 and odd (1) SM -> RCU1C.data 3
77eac271	192	buffers[iDDL] = new AliAltroBuffer(fileName.Data(),fMapping[iRCUside]);
a2339fea	193	buffers[iDDL]->WriteDataHeader(kTRUE, kFALSE); //Dummy;
	194	}
	195
	196	// out of time range signal (?)
92d9f317	197	if (digit->GetTimeR() > TIMEBINMAX ) {
a2339fea	198	AliInfo("Signal is out of time range.\n");
a2339fea	199	buffers[iDDL]->FillBuffer((Int_t)digit->GetAmplitude());
92d9f317	200	buffers[iDDL]->FillBuffer( TIMEBINS ); // time bin
a2339fea	201	buffers[iDDL]->FillBuffer(3); // bunch length
	202	buffers[iDDL]->WriteTrailer(3, ieta, iphi, nSM); // trailer
	203	// calculate the time response function
	204	} else {
1f847d9f	205	Bool_t lowgain = AliEMCALRawResponse::RawSampledResponse(digit->GetTimeR(), digit->GetAmplitude(),
	206	adcValuesHigh.GetArray(), adcValuesLow.GetArray()) ;
	207
	208	if (lowgain)
	209	buffers[iDDL]->WriteChannel(ieta, iphi, 0, TIMEBINS, adcValuesLow.GetArray(), AliEMCALRawResponse::GetRawFormatThreshold() );
a2339fea	210	else
1f847d9f	211	buffers[iDDL]->WriteChannel(ieta,iphi, 1, TIMEBINS, adcValuesHigh.GetArray(), AliEMCALRawResponse::GetRawFormatThreshold() );
a2339fea	212	}
a2339fea	213	}// iDDL under the limits
de39a0ff	214	}//digit exists
de39a0ff	215	}//Digit loop
a2339fea	216
ee299369	217	// write headers and close files
	218	for (Int_t i=0; i < nDDL; i++) {
	219	if (buffers[i]) {
	220	buffers[i]->Flush();
	221	buffers[i]->WriteDataHeader(kFALSE, kFALSE);
	222	delete buffers[i];
	223	}
	224	}
de39a0ff	225
ee299369	226	loader->UnloadDigits();
	227	}
	228
92d9f317	229
77eac271	230
92d9f317	231	void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time, Float_t chi2, Int_t ndf)
92d9f317	232	{
77eac271	233	// comment
92d9f317	234	AliEMCALDigit digit = 0, tmpdigit = 0;
	235	TIter nextdigit(digitsArr);
	236
	237	while (digit == 0 && (tmpdigit = (AliEMCALDigit*) nextdigit()))
	238	{
	239	if (tmpdigit->GetId() == id) digit = tmpdigit;
	240	}
	241
	242	if (!digit) { // no digit existed for this tower; create one
	243	Int_t type = AliEMCALDigit::kHG; // use enum in AliEMCALDigit
	244	if (lowGain)
	245	{
	246	amp *= HGLGFACTOR;
	247	type = AliEMCALDigit::kLGnoHG;
	248	}
	249
	250	Int_t idigit = digitsArr->GetEntries();
	251	new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, type, idigit, chi2, ndf);
	252	AliDebug(2,Form("Add digit Id %d for the first time, type %d", id, type));
	253	}//digit added first time
	254	else
	255	{ // a digit already exists, check range
	256	// (use high gain if signal < cut value, otherwise low gain)
	257	if (lowGain)
	258	{ // new digit is low gain
	259	if (digit->GetAmplitude() > OVERFLOWCUT )
	260	{ // use if previously stored (HG) digit is out of range
	261	digit->SetAmplitude( HGLGFACTOR * amp);
	262	digit->SetTime(time);
	263	digit->SetType(AliEMCALDigit::kLG);
	264	AliDebug(2,Form("Add LG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
	265	}
	266	}//new low gain digit
	267	else { // new digit is high gain
	268
	269	if (amp < OVERFLOWCUT )
	270	{ // new digit is high gain; use if not out of range
	271	digit->SetAmplitude(amp);
	272	digit->SetTime(time);
	273	digit->SetType(AliEMCALDigit::kHG);
	274	AliDebug(2,Form("Add HG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
	275	}
	276	else
	277	{ // HG out of range, just change flag value to show that HG did exist
	278	digit->SetType(AliEMCALDigit::kLG);
	279	AliDebug(2,Form("Change LG digit to HG, ID %d, type %d", digit->GetId(), digit->GetType()));
	280	}
	281	}//new high gain digit
	282	}//digit existed replace it
	283	}
	284
	285
de39a0ff	286	void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray digitsArr, const AliCaloCalibPedestal pedbadmap, TClonesArray digitsTRG, AliEMCALTriggerData trgData)
ee299369	287	{
77eac271	288	//conversion of raw data to digits
de39a0ff	289	if(digitsArr) digitsArr->Clear("C");
92d9f317	290	if (!digitsArr) { Error("Raw2Digits", "no digits found !");return;}
92d9f317	291	if (!reader) {Error("Raw2Digits", "no raw reader found !");return;}
de39a0ff	292	AliEMCALTriggerSTURawStream inSTU(reader);
de39a0ff	293	AliCaloRawStreamV3 in(reader,"EMCAL",fMapping);
7643e728	294	reader->Select("EMCAL",0,43); // 43 = AliEMCALGeoParams::fgkLastAltroDDL
de39a0ff	295	fTriggerRawDigitMaker->Reset();
de39a0ff	296	fTriggerRawDigitMaker->SetIO(reader, in, inSTU, digitsTRG, trgData);
16605c06	297	fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
92d9f317	298
829ba234	299	Int_t lowGain = 0;
e5bbbc4e	300	Int_t caloFlag = 0; // low, high gain, or TRU, or LED ref.
a2339fea	301
74867dce	302	Float_t bcTimePhaseCorr = 0; // for BC-based L1 phase correction
74867dce	303	Int_t bcMod4 = (reader->GetBCID() % 4); // LHC uses 40 MHz, EMCal uses 10 MHz clock
2d45a08f	304
	305	//AliCDBManager* man = AliCDBManager::Instance();
	306	//Int_t runNumber = man->GetRun();
	307
	308	Int_t runNumber = reader->GetRunNumber();
	309
	310	if ((runNumber >130850 ) && (bcMod4==0 \|\| bcMod4==1))
74867dce	311	bcTimePhaseCorr = -1e-7; // subtract 100 ns for certain BC values
74867dce	312
92d9f317	313	while (in.NextDDL())
92d9f317	314	{
92d9f317	315	while (in.NextChannel())
92d9f317	316	{
92d9f317	317	caloFlag = in.GetCaloFlag();
	318	if (caloFlag > 2) continue; // Work with ALTRO and FALTRO
	319	if(caloFlag < 2 && fRemoveBadChannels && pedbadmap->IsBadChannel(in.GetModule(),in.GetColumn(),in.GetRow()))
	320	{
	321	continue;
	322	}
	323	vector<AliCaloBunchInfo> bunchlist;
	324	while (in.NextBunch())
	325	{
	326	bunchlist.push_back( AliCaloBunchInfo(in.GetStartTimeBin(), in.GetBunchLength(), in.GetSignals() ) );
	327	}
	328	if (bunchlist.size() == 0) continue;
	329	if ( caloFlag < 2 )
	330	{ // ALTRO
	331	Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
	332	lowGain = in.IsLowGain();
	333	fRawAnalyzer->SetL1Phase( in.GetL1Phase() );
	334	AliCaloFitResults res = fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
	335	if(res.GetAmp() >= fNoiseThreshold )
	336	{
74867dce	337	AddDigit(digitsArr, id, lowGain, res.GetAmp(), res.GetTime()+bcTimePhaseCorr, res.GetChi2(), res.GetNdf() );
92d9f317	338	}
	339	}//ALTRO
	340	else if(fUseFALTRO)
	341	{// Fake ALTRO
	342	fTriggerRawDigitMaker->Add( bunchlist );
	343	}//Fake ALTRO
	344	} // end while over channel
	345	} //end while over DDL's, of input stream
de39a0ff	346	fTriggerRawDigitMaker->PostProcess();
f4a4dc82	347	TrimDigits(digitsArr);
ee299369	348	}
ee299369	349
f4a4dc82	350
f4a4dc82	351	void AliEMCALRawUtils::TrimDigits(TClonesArray *digitsArr)
dab4328c	352	{ // rm entries with LGnoHG (unphysical), out of time window, and too bad chi2
f4a4dc82	353	AliEMCALDigit *digit = 0;
	354	Int_t n = 0;
	355	Int_t nDigits = digitsArr->GetEntriesFast();
	356	TIter nextdigit(digitsArr);
	357	while ((digit = (AliEMCALDigit*) nextdigit())) {
f4a4dc82	358	if (digit->GetType() == AliEMCALDigit::kLGnoHG) {
92d9f317	359	AliDebug(1,Form("Remove digit with id %d, LGnoHG",digit->GetId()));
f4a4dc82	360	digitsArr->Remove(digit);
82cbdfca	361	}
f4a4dc82	362	else if(fTimeMin > digit->GetTime() \|\| fTimeMax < digit->GetTime()) {
f4a4dc82	363	digitsArr->Remove(digit);
92d9f317	364	AliDebug(1,Form("Remove digit with id %d, Bad Time %e",digit->GetId(), digit->GetTime()));
82cbdfca	365	}
2cd0ffda	366	else if (0 > digit->GetChi2()) {
2cd0ffda	367	digitsArr->Remove(digit);
92d9f317	368	AliDebug(1,Form("Remove digit with id %d, Bad Chi2 %e",digit->GetId(), digit->GetChi2()));
2cd0ffda	369	}
f4a4dc82	370	else {
	371	digit->SetIndexInList(n);
	372	n++;
	373	}
	374	}//while
	375
	376	digitsArr->Compress();
	377	AliDebug(1,Form("N Digits before trimming : %d; after array compression %d",nDigits,digitsArr->GetEntriesFast()));
16605c06	378	}
8cb998bd	379
16605c06	380
4fe71e02	381	void AliEMCALRawUtils::SetFittingAlgorithm(Int_t fitAlgo)
dab4328c	382	{ // select which fitting algo should be used
48b634ff	383	delete fRawAnalyzer; // delete doesn't do anything if the pointer is 0x0
92d9f317	384	fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer( fitAlgo );
	385	fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done, for the new methods
	386	fRawAnalyzer->SetOverflowCut ( OVERFLOWCUT );
	387	fRawAnalyzer->SetAmpCut(fNoiseThreshold);
	388	fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
4fe71e02	389	}
	390
	391
92d9f317	392