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

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