[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTriggerTRU.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.                  *
 **************************************************************************/

/*


Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
*/


#include "AliEMCALTriggerTRU.h"
#include "AliEMCALTriggerPatch.h"
#include "AliEMCALTriggerTRUDCSConfig.h"
#include "AliLog.h"

#include <TClonesArray.h>
#include <TSystem.h>
#include <Riostream.h>

namespace
{
	const Int_t kTimeBins       = 16; // number of sampling bins of the FastOR signal
	const Int_t kTimeWindowSize =  4; // 
}

using std::ofstream;
using std::endl;
using std::ios_base;
ClassImp(AliEMCALTriggerTRU)

//________________
AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard(),
fDCSConfig(0x0),
fL0Time(0)
{
	// Ctor
	
	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
}

//________________
AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType) : 
AliEMCALTriggerBoard(rSize),
fDCSConfig(dcsConf),
fL0Time(0)
{
	// Ctor
	
	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
	
	TVector2 size;
	
	if (dcsConf->GetL0SEL() & 0x0001) // 4-by-4
	{
		size.Set( 1. , 1. );
		SetSubRegionSize( size );
		
		size.Set( 2. , 2. );
		SetPatchSize( size );
	}	
	else                              // 2-by-2
	{
		size.Set( 1. , 1. );
		SetSubRegionSize( size );
		
		size.Set( 1. , 1. );
		SetPatchSize( size );	
	}	
	
	for (Int_t ietam=0;ietam<24;ietam++)
	{
		for (Int_t iphim=0;iphim<4;iphim++)
		{
			// idx: 0..95 since iphim: 0..11 ietam: 0..23
			Int_t idx = ( !mapType ) ? ( 3 - iphim ) + ietam * 4 : iphim + (23 - ietam) * 4;	
	
			// Build a matrix used to get TRU digit id (ADC channel) from (eta,phi)|SM
			fMap[ietam][iphim] = idx; // [0..11][0..3] namely [eta][phi] in SM
		}
	}
}

//________________
AliEMCALTriggerTRU::~AliEMCALTriggerTRU()
{
	// Dtor
}

//________________
void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
{
	// Dump
	
	Int_t iChanF, iChanL;
	
	if (iChannel != -1) iChanF = iChanL = iChannel;
	else
	{
		iChanF =  0;
		iChanL = 95;
	}
	
	for (Int_t i=iChanF;i<iChanL+1;i++)
	{
		printf("\tChannel: %2d - ",i);
		for (Int_t j=0;j<60;j++) 
		{
			if (j == iTimeWindow)
				printf(" | %4d",fADC[i][j]);
			else if (j == iTimeWindow+kTimeWindowSize-1)
				printf(" %4d |",fADC[i][j]);
			else
				printf(" %4d",fADC[i][j]);
		}
		
		printf("\n");
	}
}

//________________
Int_t AliEMCALTriggerTRU::L0()
{
	// L0 algo depending on TRU fw version
	
	const Int_t xsize    = Int_t(fRegionSize->X());
	const Int_t ysize    = Int_t(fRegionSize->Y());

	Int_t asum = 0;
	for (Int_t j = 0; j < xsize; j++) {		
		for (Int_t k = 0; k < ysize; k++) {
			for (Int_t l = 0; l < kTimeBins; l++) {
				asum += fADC[fMap[j][k]][l];
			}
		}
	}	
	
	// TRU has no signal, return!
	if (!asum) {
		AliDebug(999,"=== TRU has no signal ===");
		return 0;
	}
	
	AliDebug(999,Form("=== TRU PF: %x",fDCSConfig->GetSELPF()));
	
	UInt_t ma = fDCSConfig->GetSELPF() & 0xffff;
	
//	int nb = 0;
//	for (int i = 0; i < 7; i++) {
//		UInt_t bit = ma & (1 << i);
//		if (bit) nb++;
//	}
	
	int nb = ma & 0x7f;
	
	ma = (ma >> 8) & 0x7f;
	
	AliDebug(999,Form("=== TRU fw version %x ===",fDCSConfig->GetFw()));
	
 	if (fDCSConfig->IsA()->GetClassVersion() >= 3) {
		if (fDCSConfig->GetFw() < 0x4d) {
			return L0v0(nb, ma);
		} else {
			return L0v1(nb, ma);
		}
	} else
		return L0v0(nb, ma);
}

//________________
Int_t AliEMCALTriggerTRU::L0v0(int mask, int pattern)
{
	// L0 issuing condition is: (2x2 PF) AND (4x4 > thres)
	
	AliDebug(999,"=== Running TRU L0 algorithm version 0 ===");

	const Int_t xsize    = Int_t(fRegionSize->X());
	const Int_t ysize    = Int_t(fRegionSize->Y());

	Int_t **othr = new Int_t*[xsize];
	Int_t **patt = new Int_t*[xsize];	
	Int_t **buff = new Int_t*[xsize];	
	
	for (Int_t x = 0; x < xsize; x++) {
		othr[x] = new Int_t[ysize];
		patt[x] = new Int_t[ysize];
		buff[x] = new Int_t[ysize];
	}
	
	for (Int_t i = 0; i < xsize; i++) {
		for (Int_t j = 0; j < ysize; j++) {
			othr[i][j] = 0;	
			patt[i][j] = 0;
			buff[i][j] = 0;
		}
	}
			
	// Time sliding window algorithm
	for (int i = 0; i <= (kTimeBins - kTimeWindowSize); i++) 
	{
		AliDebug(999,Form("----------- Time window: %d\n",i));
		
		if (AliDebugLevel()) ShowFastOR(i, -1);
		
		for (int j = 0; j < xsize; j++) {		
			for (int k = 0; k < ysize; k++) {
				
//				if (
//					!(j % int(fSubRegionSize->X())) 
//					&& 
//					!(k % int(fSubRegionSize->Y())) 
//					&& 
//					(j + int(fPatchSize->X() * fSubRegionSize->X()) <= xsize)
//					&& 
//					(k + int(fPatchSize->Y() * fSubRegionSize->Y()) <= ysize)
//					) 
//				{
//					int sum = 0;
//					
//					for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++) 
//						for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
//					
//					if (sum > int(fDCSConfig->GetGTHRL0())) {
//						AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
//						othr[j][k] = sum;
//					}
//				}
				
				buff[j][k] = fRegion[j][k];
				
				fRegion[j][k] = 0;
				for (Int_t l = i; l < i + kTimeWindowSize; l++) fRegion[j][k] += fADC[fMap[j][k]][l];	
				
				if (fRegion[j][k] > buff[j][k]) {
					patt[j][k] |= 0x1;
				}
				
				if (patt[j][k]) AliDebug(999,Form("----------- (%2d,%2d) New: %d Old: %d patt: %x / pattern: %x / mask: %x", j, k, fRegion[j][k], buff[j][k], patt[j][k], pattern, mask));
			}
		}
		
		for (int j = 0; j <= int(fRegionSize->X() - fPatchSize->X() * fSubRegionSize->X()); j += int(fSubRegionSize->X())) {
			for (int k = 0; k <= int(fRegionSize->Y() - fPatchSize->Y() * fSubRegionSize->Y()); k += int(fSubRegionSize->Y())) {
				
//				if (!othr[j][k]) continue;
				int sizeX = int(fPatchSize->X() * fSubRegionSize->X());				
				int sizeY = int(fPatchSize->Y() * fSubRegionSize->Y());
				
				int foundPeak = 0;
				int sum       = 0;
				
				for (int l = 0; l < sizeX; l++) {
					for (int m = 0; m < sizeY; m++) {
						sum += fRegion[j + l][k + m];
						
						if ((patt[j + l][k + m] & mask) == pattern) foundPeak++;
					}
				}
				
				if (sum > int(fDCSConfig->GetGTHRL0())) othr[j][k] = sum;
		
				if (foundPeak && othr[j][k]) {
					
					new((*fPatches)[fPatches->GetEntriesFast()]) AliEMCALTriggerPatch(j, k, othr[j][k], i);
					
					AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1);
					
					if (AliDebugLevel()) p->Print("");
					
					const Int_t psize =  sizeX * sizeY; // Number of FastOR in the patch
					
					Int_t* idx = new Int_t[psize];
					
					for (Int_t l = 0; l < sizeX; l++) 
					{
						for (Int_t m = 0; m < sizeY; m++) 
						{   
							Int_t index = l * sizeY + m;
							
							idx[index] = fMap[int(j * fSubRegionSize->X()) + l][int(k * fSubRegionSize->Y()) + m];
							
							if ((patt[j + l][k + m] & mask) == pattern) {
//								cout << "setting peak at " << l << " " << m << endl;
								p->SetPeak(l, m, sizeX, sizeY);
							}
							
							if (AliDebugLevel() >= 999) ShowFastOR(i, idx[index]);
						}
					}
					
					delete [] idx;
				}
			}
		}
		
		if (fPatches->GetEntriesFast() && !fL0Time) {			
			// Stop the algo when at least one patch is found ( thres & max )
			fL0Time = i;

//			break;
		}
		
		for (int j = 0; j < xsize; j++) 	
			for (int k = 0; k < ysize; k++) patt[j][k] <<= 1;
	}
	
	for (Int_t x = 0; x < xsize; x++) {
		delete [] othr[x];
		delete [] patt[x];
		delete [] buff[x];
	}

	delete [] othr;
	delete [] patt;
	delete [] buff;

	return fPatches->GetEntriesFast();
}

//________________
Int_t AliEMCALTriggerTRU::L0v1(int mask, int pattern)
{
	// L0 issuing condition is: (4x4 PF) AND (4x4 > thres)
	
	AliDebug(999,"=== Running TRU L0 algorithm version 1 ===");
	
	const Int_t xsize    = Int_t(fRegionSize->X());
	const Int_t ysize    = Int_t(fRegionSize->Y());
		
	Int_t **othr = new Int_t*[xsize];
	Int_t **buff = new Int_t*[xsize];
	Int_t **patt = new Int_t*[xsize];
	
	for (Int_t i = 0; i < xsize; i++) {
		buff[i] = new Int_t[ysize];
		patt[i] = new Int_t[ysize];
		othr[i] = new Int_t[ysize];
	}
	
	for (Int_t i = 0; i < xsize; i++) for (Int_t j = 0; j < ysize; j++) {
		othr[i][j] = 0;
		patt[i][j] = 0;
		buff[i][j] = 0;
	}
	
	// Time sliding window algorithm
	for (Int_t i = 0; i <= (kTimeBins - kTimeWindowSize); i++) {
		
		AliDebug(999,Form("----------- Time window: %d\n",i));
		
		for (int j = 0; j < xsize; j++) {		
			for (int k = 0; k < ysize; k++) {
				
//				if (
//					!(j % int(fSubRegionSize->X())) 
//					&& 
//					!(k % int(fSubRegionSize->Y())) 
//					&& 
//					(j + int(fPatchSize->X() * fSubRegionSize->X()) <= xsize)
//					&& 
//					(k + int(fPatchSize->Y() * fSubRegionSize->Y()) <= ysize)
//					) 
//				{
//					int sum = 0;
//					
//					for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++) 
//						for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
//					
//					if (sum > buff[j][k]) patt[j][k] |= 0x1;
//					
//					AliDebug(999,Form("----------- Patch (%2d,%2d) has sum %d while its whole time pattern is %x\n", j, k, sum, patt[j][k]));
//					
//					buff[j][k] = sum;
//					
//					if (sum > int(fDCSConfig->GetGTHRL0())) {
//						AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
//						othr[j][k] = sum;
//					}
//				}
				
				fRegion[j][k] = 0;
				for (Int_t l = i; l < i + kTimeWindowSize; l++) fRegion[j][k] += fADC[fMap[j][k]][l];	
			}
		}
		
		for (int j = 0; j <= int(fRegionSize->X() - fPatchSize->X() * fSubRegionSize->X()); j += int(fSubRegionSize->X())) {
			for (int k = 0; k <= int(fRegionSize->Y() - fPatchSize->Y() * fSubRegionSize->Y()); k += int(fSubRegionSize->Y())) {
					
				int sum = 0;
				
				for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++) 
					for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
				
				if (sum > buff[j][k]) patt[j][k] |= 0x1;
				
				if (sum > int(fDCSConfig->GetGTHRL0())) {
					AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
					
					othr[j][k] = sum;
				}
				
				AliDebug(999,Form("----------- Patch (%2d,%2d) has sum %d while its whole time pattern is %x\n", j, k, sum, patt[j][k]));
				
				buff[j][k] = sum;
				
				if (othr[j][k] && (patt[j][k] & mask) == pattern) {
					
					new((*fPatches)[fPatches->GetEntriesFast()]) AliEMCALTriggerPatch(j, k, othr[j][k], i);
					
//					AliDebug(999,Form("=== New L0 patch at (%2d,%2d) time: %2d",j, k, i));
					
					int sizeX = int(fPatchSize->X() * fSubRegionSize->X());					
					int sizeY = int(fPatchSize->Y() * fSubRegionSize->Y());
					
					for (int xx = 0; xx < sizeX; xx++) {
						for (int yy = 0; yy < sizeY; yy++) {
							((AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1))->SetPeak(xx, yy, sizeX, sizeY);
						}
					}
					
					AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1);
					
					if (AliDebugLevel()) p->Print("");
				}
			}
		}
		
		if (fPatches->GetEntriesFast() && !fL0Time) {
			fL0Time = i;
			
//			break;
		} 
		
		for (int j = 0; j < xsize; j++) 	
			for (int k = 0; k < ysize; k++) patt[j][k] <<= 1;
	}
	
	for (Int_t x = 0; x < xsize; x++) {
		delete [] othr[x];
		delete [] patt[x];
		delete [] buff[x];
	}
	
	delete [] othr;
	delete [] patt;
	delete [] buff;
	
	return fPatches->GetEntriesFast();
}

//________________
void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
{
  //Set ADC value
  if (channel > 95 || bin > 255) {
    AliError("TRU has 96 ADC channels and 256 bins only!");
  }
  else{ 
	if (((fDCSConfig->GetMaskReg(int(channel / 16)) >> (channel % 16)) & 0x1) == 0) fADC[channel][bin] = sig;
  }
}

//________________
void AliEMCALTriggerTRU::GetL0Region(const int time, Int_t arr[][4])
{
	Int_t r0 = time - fDCSConfig->GetRLBKSTU();
	
	if (r0 < 0) 
	{
		AliError(Form("TRU buffer not accessible! time: %d rollback: %d", time, fDCSConfig->GetRLBKSTU()));
		return;
	}
	
	for (Int_t i = 0; i < fRegionSize->X(); i++) 
	{
		for (Int_t j = 0; j < fRegionSize->Y(); j++) 
		{
			for (Int_t k = r0; k < r0 + kTimeWindowSize; k++)
			{
				arr[i][j] += fADC[fMap[i][j]][k];
			}
		}
	}
}

//________________
void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
{
	// O for STU Hw
	//
	gSystem->Exec(Form("mkdir -p Event%d",iEvent));
	
	ofstream outfile(Form("Event%d/data_TRU%d.txt",iEvent,iTRU),ios_base::trunc);
	
	for (Int_t i=0;i<96;i++) 
	{
		Int_t ietam = 23 - i/4;
	
		Int_t iphim =  3 - i%4;
		
		outfile << fRegion[ietam][iphim] << endl;
	}

	outfile.close();
}

//________________
void AliEMCALTriggerTRU::Reset()
{
	// Reset
	
	fPatches->Delete();
	
	ZeroRegion();
	
	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
}
Commit	Line	Data
916f1e76	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	/*
	17
	18
	19
	20
	21	Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
	22	*/
	23
	24
	25	#include "AliEMCALTriggerTRU.h"
	26	#include "AliEMCALTriggerPatch.h"
fff39dd1	27	#include "AliEMCALTriggerTRUDCSConfig.h"
916f1e76	28	#include "AliLog.h"
916f1e76	29
916f1e76	30	#include <TClonesArray.h>
	31	#include <TSystem.h>
	32	#include <Riostream.h>
63c22917	33
916f1e76	34	namespace
916f1e76	35	{
fff39dd1	36	const Int_t kTimeBins = 16; // number of sampling bins of the FastOR signal
916f1e76	37	const Int_t kTimeWindowSize = 4; //
916f1e76	38	}
916f1e76	39
0267cfa6	40	using std::ofstream;
	41	using std::endl;
	42	using std::ios_base;
916f1e76	43	ClassImp(AliEMCALTriggerTRU)
	44
	45	//________________
de39a0ff	46	AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard(),
804b828a	47	fDCSConfig(0x0),
804b828a	48	fL0Time(0)
916f1e76	49	{
79b05051	50	// Ctor
79b05051	51
916f1e76	52	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
	53	}
	54
	55	//________________
fff39dd1	56	AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType) :
de39a0ff	57	AliEMCALTriggerBoard(rSize),
804b828a	58	fDCSConfig(dcsConf),
804b828a	59	fL0Time(0)
916f1e76	60	{
79b05051	61	// Ctor
79b05051	62
916f1e76	63	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
63c22917	64
916f1e76	65	TVector2 size;
916f1e76	66
de39a0ff	67	if (dcsConf->GetL0SEL() & 0x0001) // 4-by-4
	68	{
	69	size.Set( 1. , 1. );
	70	SetSubRegionSize( size );
	71
	72	size.Set( 2. , 2. );
	73	SetPatchSize( size );
	74	}
	75	else // 2-by-2
	76	{
	77	size.Set( 1. , 1. );
	78	SetSubRegionSize( size );
	79
	80	size.Set( 1. , 1. );
	81	SetPatchSize( size );
	82	}
916f1e76	83
	84	for (Int_t ietam=0;ietam<24;ietam++)
	85	{
	86	for (Int_t iphim=0;iphim<4;iphim++)
	87	{
	88	// idx: 0..95 since iphim: 0..11 ietam: 0..23
	89	Int_t idx = ( !mapType ) ? ( 3 - iphim ) + ietam * 4 : iphim + (23 - ietam) * 4;
	90
	91	// Build a matrix used to get TRU digit id (ADC channel) from (eta,phi)\|SM
	92	fMap[ietam][iphim] = idx; // [0..11][0..3] namely [eta][phi] in SM
	93	}
	94	}
	95	}
	96
	97	//________________
	98	AliEMCALTriggerTRU::~AliEMCALTriggerTRU()
	99	{
79b05051	100	// Dtor
916f1e76	101	}
916f1e76	102
916f1e76	103	//________________
	104	void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
	105	{
79b05051	106	// Dump
79b05051	107
916f1e76	108	Int_t iChanF, iChanL;
	109
	110	if (iChannel != -1) iChanF = iChanL = iChannel;
	111	else
	112	{
	113	iChanF = 0;
63c22917	114	iChanL = 95;
916f1e76	115	}
	116
	117	for (Int_t i=iChanF;i<iChanL+1;i++)
	118	{
	119	printf("\tChannel: %2d - ",i);
	120	for (Int_t j=0;j<60;j++)
	121	{
	122	if (j == iTimeWindow)
	123	printf(" \| %4d",fADC[i][j]);
	124	else if (j == iTimeWindow+kTimeWindowSize-1)
	125	printf(" %4d \|",fADC[i][j]);
	126	else
	127	printf(" %4d",fADC[i][j]);
	128	}
	129
	130	printf("\n");
	131	}
	132	}
	133
	134	//________________
fff39dd1	135	Int_t AliEMCALTriggerTRU::L0()
916f1e76	136	{
63c22917	137	// L0 algo depending on TRU fw version
63c22917	138
8476b1c8	139	const Int_t xsize = Int_t(fRegionSize->X());
8b07b672	140	const Int_t ysize = Int_t(fRegionSize->Y());
8b07b672	141
63c22917	142	Int_t asum = 0;
	143	for (Int_t j = 0; j < xsize; j++) {
	144	for (Int_t k = 0; k < ysize; k++) {
	145	for (Int_t l = 0; l < kTimeBins; l++) {
	146	asum += fADC[fMap[j][k]][l];
	147	}
f4e2cc1e	148	}
63c22917	149	}
	150
	151	// TRU has no signal, return!
	152	if (!asum) {
	153	AliDebug(999,"=== TRU has no signal ===");
	154	return 0;
f4e2cc1e	155	}
916f1e76	156
63c22917	157	AliDebug(999,Form("=== TRU PF: %x",fDCSConfig->GetSELPF()));
	158
	159	UInt_t ma = fDCSConfig->GetSELPF() & 0xffff;
	160
	161	// int nb = 0;
	162	// for (int i = 0; i < 7; i++) {
	163	// UInt_t bit = ma & (1 << i);
	164	// if (bit) nb++;
	165	// }
	166
	167	int nb = ma & 0x7f;
	168
	169	ma = (ma >> 8) & 0x7f;
	170
	171	AliDebug(999,Form("=== TRU fw version %x ===",fDCSConfig->GetFw()));
	172
88b52ece	173	if (fDCSConfig->IsA()->GetClassVersion() >= 3) {
	174	if (fDCSConfig->GetFw() < 0x4d) {
	175	return L0v0(nb, ma);
	176	} else {
	177	return L0v1(nb, ma);
	178	}
	179	} else
63c22917	180	return L0v0(nb, ma);
63c22917	181	}
	182
	183	//________________
	184	Int_t AliEMCALTriggerTRU::L0v0(int mask, int pattern)
	185	{
	186	// L0 issuing condition is: (2x2 PF) AND (4x4 > thres)
	187
	188	AliDebug(999,"=== Running TRU L0 algorithm version 0 ===");
	189
	190	const Int_t xsize = Int_t(fRegionSize->X());
	191	const Int_t ysize = Int_t(fRegionSize->Y());
	192
	193	Int_t *othr = new Int_t[xsize];
	194	Int_t *patt = new Int_t[xsize];
	195	Int_t *buff = new Int_t[xsize];
	196
	197	for (Int_t x = 0; x < xsize; x++) {
	198	othr[x] = new Int_t[ysize];
	199	patt[x] = new Int_t[ysize];
	200	buff[x] = new Int_t[ysize];
	201	}
	202
	203	for (Int_t i = 0; i < xsize; i++) {
	204	for (Int_t j = 0; j < ysize; j++) {
	205	othr[i][j] = 0;
	206	patt[i][j] = 0;
	207	buff[i][j] = 0;
	208	}
	209	}
	210
fff39dd1	211	// Time sliding window algorithm
63c22917	212	for (int i = 0; i <= (kTimeBins - kTimeWindowSize); i++)
916f1e76	213	{
de39a0ff	214	AliDebug(999,Form("----------- Time window: %d\n",i));
fff39dd1	215
63c22917	216	if (AliDebugLevel()) ShowFastOR(i, -1);
	217
	218	for (int j = 0; j < xsize; j++) {
	219	for (int k = 0; k < ysize; k++) {
916f1e76	220
63c22917	221	// if (
	222	// !(j % int(fSubRegionSize->X()))
	223	// &&
	224	// !(k % int(fSubRegionSize->Y()))
	225	// &&
	226	// (j + int(fPatchSize->X() * fSubRegionSize->X()) <= xsize)
	227	// &&
	228	// (k + int(fPatchSize->Y() * fSubRegionSize->Y()) <= ysize)
	229	// )
	230	// {
	231	// int sum = 0;
	232	//
	233	// for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++)
	234	// for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
	235	//
	236	// if (sum > int(fDCSConfig->GetGTHRL0())) {
	237	// AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
	238	// othr[j][k] = sum;
	239	// }
	240	// }
916f1e76	241
63c22917	242	buff[j][k] = fRegion[j][k];
	243
	244	fRegion[j][k] = 0;
	245	for (Int_t l = i; l < i + kTimeWindowSize; l++) fRegion[j][k] += fADC[fMap[j][k]][l];
	246
	247	if (fRegion[j][k] > buff[j][k]) {
	248	patt[j][k] \|= 0x1;
fff39dd1	249	}
916f1e76	250
63c22917	251	if (patt[j][k]) AliDebug(999,Form("----------- (%2d,%2d) New: %d Old: %d patt: %x / pattern: %x / mask: %x", j, k, fRegion[j][k], buff[j][k], patt[j][k], pattern, mask));
916f1e76	252	}
	253	}
	254
63c22917	255	for (int j = 0; j <= int(fRegionSize->X() - fPatchSize->X() * fSubRegionSize->X()); j += int(fSubRegionSize->X())) {
63c22917	256	for (int k = 0; k <= int(fRegionSize->Y() - fPatchSize->Y() * fSubRegionSize->Y()); k += int(fSubRegionSize->Y())) {
fff39dd1	257
63c22917	258	// if (!othr[j][k]) continue;
	259	int sizeX = int(fPatchSize->X() * fSubRegionSize->X());
	260	int sizeY = int(fPatchSize->Y() * fSubRegionSize->Y());
fff39dd1	261
63c22917	262	int foundPeak = 0;
	263	int sum = 0;
	264
	265	for (int l = 0; l < sizeX; l++) {
	266	for (int m = 0; m < sizeY; m++) {
	267	sum += fRegion[j + l][k + m];
	268
	269	if ((patt[j + l][k + m] & mask) == pattern) foundPeak++;
	270	}
	271	}
	272
	273	if (sum > int(fDCSConfig->GetGTHRL0())) othr[j][k] = sum;
fff39dd1	274
63c22917	275	if (foundPeak && othr[j][k]) {
	276
	277	new((*fPatches)[fPatches->GetEntriesFast()]) AliEMCALTriggerPatch(j, k, othr[j][k], i);
	278
	279	AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1);
	280
	281	if (AliDebugLevel()) p->Print("");
	282
	283	const Int_t psize = sizeX * sizeY; // Number of FastOR in the patch
	284
	285	Int_t* idx = new Int_t[psize];
	286
	287	for (Int_t l = 0; l < sizeX; l++)
	288	{
	289	for (Int_t m = 0; m < sizeY; m++)
	290	{
	291	Int_t index = l * sizeY + m;
	292
	293	idx[index] = fMap[int(j * fSubRegionSize->X()) + l][int(k * fSubRegionSize->Y()) + m];
	294
	295	if ((patt[j + l][k + m] & mask) == pattern) {
	296	// cout << "setting peak at " << l << " " << m << endl;
	297	p->SetPeak(l, m, sizeX, sizeY);
	298	}
	299
	300	if (AliDebugLevel() >= 999) ShowFastOR(i, idx[index]);
	301	}
	302	}
	303
	304	delete [] idx;
916f1e76	305	}
916f1e76	306	}
916f1e76	307	}
63c22917	308
	309	if (fPatches->GetEntriesFast() && !fL0Time) {
	310	// Stop the algo when at least one patch is found ( thres & max )
	311	fL0Time = i;
fff39dd1	312
63c22917	313	// break;
	314	}
	315
	316	for (int j = 0; j < xsize; j++)
	317	for (int k = 0; k < ysize; k++) patt[j][k] <<= 1;
	318	}
	319
	320	for (Int_t x = 0; x < xsize; x++) {
	321	delete [] othr[x];
	322	delete [] patt[x];
	323	delete [] buff[x];
	324	}
4bd37bd4	325
63c22917	326	delete [] othr;
	327	delete [] patt;
	328	delete [] buff;
4bd37bd4	329
63c22917	330	return fPatches->GetEntriesFast();
	331	}
	332
	333	//________________
	334	Int_t AliEMCALTriggerTRU::L0v1(int mask, int pattern)
	335	{
	336	// L0 issuing condition is: (4x4 PF) AND (4x4 > thres)
	337
	338	AliDebug(999,"=== Running TRU L0 algorithm version 1 ===");
	339
	340	const Int_t xsize = Int_t(fRegionSize->X());
	341	const Int_t ysize = Int_t(fRegionSize->Y());
916f1e76	342
63c22917	343	Int_t *othr = new Int_t[xsize];
	344	Int_t *buff = new Int_t[xsize];
	345	Int_t *patt = new Int_t[xsize];
	346
	347	for (Int_t i = 0; i < xsize; i++) {
	348	buff[i] = new Int_t[ysize];
	349	patt[i] = new Int_t[ysize];
	350	othr[i] = new Int_t[ysize];
	351	}
	352
	353	for (Int_t i = 0; i < xsize; i++) for (Int_t j = 0; j < ysize; j++) {
	354	othr[i][j] = 0;
	355	patt[i][j] = 0;
	356	buff[i][j] = 0;
	357	}
	358
	359	// Time sliding window algorithm
	360	for (Int_t i = 0; i <= (kTimeBins - kTimeWindowSize); i++) {
916f1e76	361
63c22917	362	AliDebug(999,Form("----------- Time window: %d\n",i));
916f1e76	363
63c22917	364	for (int j = 0; j < xsize; j++) {
	365	for (int k = 0; k < ysize; k++) {
	366
	367	// if (
	368	// !(j % int(fSubRegionSize->X()))
	369	// &&
	370	// !(k % int(fSubRegionSize->Y()))
	371	// &&
	372	// (j + int(fPatchSize->X() * fSubRegionSize->X()) <= xsize)
	373	// &&
	374	// (k + int(fPatchSize->Y() * fSubRegionSize->Y()) <= ysize)
	375	// )
	376	// {
	377	// int sum = 0;
	378	//
	379	// for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++)
	380	// for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
	381	//
	382	// if (sum > buff[j][k]) patt[j][k] \|= 0x1;
	383	//
	384	// AliDebug(999,Form("----------- Patch (%2d,%2d) has sum %d while its whole time pattern is %x\n", j, k, sum, patt[j][k]));
	385	//
	386	// buff[j][k] = sum;
	387	//
	388	// if (sum > int(fDCSConfig->GetGTHRL0())) {
	389	// AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
	390	// othr[j][k] = sum;
	391	// }
	392	// }
	393
	394	fRegion[j][k] = 0;
	395	for (Int_t l = i; l < i + kTimeWindowSize; l++) fRegion[j][k] += fADC[fMap[j][k]][l];
	396	}
	397	}
916f1e76	398
63c22917	399	for (int j = 0; j <= int(fRegionSize->X() - fPatchSize->X() * fSubRegionSize->X()); j += int(fSubRegionSize->X())) {
63c22917	400	for (int k = 0; k <= int(fRegionSize->Y() - fPatchSize->Y() * fSubRegionSize->Y()); k += int(fSubRegionSize->Y())) {
916f1e76	401
63c22917	402	int sum = 0;
	403
	404	for (int l = 0; l < int(fPatchSize->X() * fSubRegionSize->X()); l++)
	405	for (int m = 0; m < int(fPatchSize->Y() * fSubRegionSize->Y()); m++) sum += fRegion[j + l][k + m];
	406
	407	if (sum > buff[j][k]) patt[j][k] \|= 0x1;
	408
	409	if (sum > int(fDCSConfig->GetGTHRL0())) {
	410	AliDebug(999,Form("----------- Patch (%2d,%2d) is over threshold\n", j, k));
916f1e76	411
63c22917	412	othr[j][k] = sum;
	413	}
	414
	415	AliDebug(999,Form("----------- Patch (%2d,%2d) has sum %d while its whole time pattern is %x\n", j, k, sum, patt[j][k]));
	416
	417	buff[j][k] = sum;
	418
	419	if (othr[j][k] && (patt[j][k] & mask) == pattern) {
	420
	421	new((*fPatches)[fPatches->GetEntriesFast()]) AliEMCALTriggerPatch(j, k, othr[j][k], i);
	422
	423	// AliDebug(999,Form("=== New L0 patch at (%2d,%2d) time: %2d",j, k, i));
	424
	425	int sizeX = int(fPatchSize->X() * fSubRegionSize->X());
	426	int sizeY = int(fPatchSize->Y() * fSubRegionSize->Y());
	427
	428	for (int xx = 0; xx < sizeX; xx++) {
	429	for (int yy = 0; yy < sizeY; yy++) {
	430	((AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1))->SetPeak(xx, yy, sizeX, sizeY);
	431	}
de39a0ff	432	}
fff39dd1	433
63c22917	434	AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At(fPatches->GetEntriesFast() - 1);
	435
	436	if (AliDebugLevel()) p->Print("");
916f1e76	437	}
916f1e76	438	}
916f1e76	439	}
fff39dd1	440
63c22917	441	if (fPatches->GetEntriesFast() && !fL0Time) {
804b828a	442	fL0Time = i;
804b828a	443
63c22917	444	// break;
	445	}
	446
	447	for (int j = 0; j < xsize; j++)
	448	for (int k = 0; k < ysize; k++) patt[j][k] <<= 1;
916f1e76	449	}
916f1e76	450
63c22917	451	for (Int_t x = 0; x < xsize; x++) {
	452	delete [] othr[x];
	453	delete [] patt[x];
	454	delete [] buff[x];
f4e2cc1e	455	}
63c22917	456
	457	delete [] othr;
	458	delete [] patt;
	459	delete [] buff;
8b07b672	460
916f1e76	461	return fPatches->GetEntriesFast();
	462	}
	463
916f1e76	464	//________________
	465	void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
	466	{
a51e676d	467	//Set ADC value
	468	if (channel > 95 \|\| bin > 255) {
	469	AliError("TRU has 96 ADC channels and 256 bins only!");
	470	}
	471	else{
63c22917	472	if (((fDCSConfig->GetMaskReg(int(channel / 16)) >> (channel % 16)) & 0x1) == 0) fADC[channel][bin] = sig;
a51e676d	473	}
916f1e76	474	}
916f1e76	475
804b828a	476	//________________
	477	void AliEMCALTriggerTRU::GetL0Region(const int time, Int_t arr[][4])
	478	{
63c22917	479	Int_t r0 = time - fDCSConfig->GetRLBKSTU();
804b828a	480
	481	if (r0 < 0)
	482	{
	483	AliError(Form("TRU buffer not accessible! time: %d rollback: %d", time, fDCSConfig->GetRLBKSTU()));
	484	return;
	485	}
	486
	487	for (Int_t i = 0; i < fRegionSize->X(); i++)
	488	{
	489	for (Int_t j = 0; j < fRegionSize->Y(); j++)
	490	{
	491	for (Int_t k = r0; k < r0 + kTimeWindowSize; k++)
	492	{
	493	arr[i][j] += fADC[fMap[i][j]][k];
	494	}
	495	}
	496	}
	497	}
	498
916f1e76	499	//________________
	500	void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
	501	{
	502	// O for STU Hw
	503	//
	504	gSystem->Exec(Form("mkdir -p Event%d",iEvent));
	505
	506	ofstream outfile(Form("Event%d/data_TRU%d.txt",iEvent,iTRU),ios_base::trunc);
	507
	508	for (Int_t i=0;i<96;i++)
	509	{
	510	Int_t ietam = 23 - i/4;
	511
	512	Int_t iphim = 3 - i%4;
	513
	514	outfile << fRegion[ietam][iphim] << endl;
	515	}
	516
	517	outfile.close();
	518	}
	519
916f1e76	520	//________________
	521	void AliEMCALTriggerTRU::Reset()
	522	{
79b05051	523	// Reset
79b05051	524
916f1e76	525	fPatches->Delete();
	526
	527	ZeroRegion();
	528
	529	for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
	530	}
	531