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

/*


This class provides access to STU DDL raw data.
Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
*/

#include "AliEMCALTriggerSTURawStream.h"
#include "AliRawReader.h"
#include "AliLog.h"

#include "Riostream.h"
#include "TBits.h"

#include <cstdlib>

namespace
{
	const Int_t kPayLoadSizeV0     = 236;
	const Int_t kPayLoadSizeV1     = 245;        
	const Int_t kPayLoadSizeV2     = 390;        
}

ClassImp(AliEMCALTriggerSTURawStream)

//_____________________________________________________________________________
AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
fRawReader(0x0),
fL1JetThreshold(),
fL1GammaThreshold(),
fL0GammaPatchIndex(),
fL1GammaPatchIndex(),
fL1JetPatchIndex(),
fNL0GammaPatch(0),
fNL1JetPatch(),
fNL1GammaPatch(),
fGetRawData(0),
fV0A(0),
fV0C(0),
fG(),
fJ(),
fRegionEnable(0),
fFrameReceived(0),
fFwVersion(0)
{
	//
	for (int i = 0; i < 2; i++) {
		//
		fL1JetThreshold[i] = fL1GammaThreshold[i] = 0;
		
		fNL1JetPatch[i] = fNL1GammaPatch[i] = 0;
	}
	
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 2; j++) {
			//
			fG[i][j] = fJ[i][j] = 0;
		}
	}
	
	for (int i = 0; i < 3100; i++) {
		//
		fL0GammaPatchIndex[i] = 0;
		
		for (int j = 0; j < 2; j++) {
			
			fL1GammaPatchIndex[i][j] = 0;
		}
	}
	
	for (int i = 0; i < 200; i++) {
		for (int j = 0; j < 2; j++) {
			
			fL1JetPatchIndex[i][j] = 0;
		}
	}
}

//_____________________________________________________________________________
AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
fRawReader(rawReader),
fL1JetThreshold(),
fL1GammaThreshold(),
fL0GammaPatchIndex(),
fL1GammaPatchIndex(),
fL1JetPatchIndex(),
fNL0GammaPatch(0),
fNL1JetPatch(),
fNL1GammaPatch(),
fGetRawData(0),
fV0A(0),
fV0C(0),
fG(),
fJ(),
fRegionEnable(0),
fFrameReceived(0),
fFwVersion(0)
{
	//
	fRawReader->Reset();
	fRawReader->Select("EMCAL",44);
	//
	for (int i = 0; i < 2; i++) {
		//
		fL1JetThreshold[i] = fL1GammaThreshold[i] = 0;
		
		fNL1JetPatch[i] = fNL1GammaPatch[i] = 0;
	}
	
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 2; j++) {
			//
			fG[i][j] = fJ[i][j] = 0;
		}
	}
	
	for (int i = 0; i < 3100; i++) {
		//
		fL0GammaPatchIndex[i] = 0;
		
		for (int j = 0; j < 2; j++) {
			
			fL1GammaPatchIndex[i][j] = 0;
		}
	}
	
	for (int i = 0; i < 200; i++) {
		for (int j = 0; j < 2; j++) {
			
			fL1JetPatchIndex[i][j] = 0;
		}
	}
}

//_____________________________________________________________________________
AliEMCALTriggerSTURawStream::~AliEMCALTriggerSTURawStream()
{
	// destructor
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::Reset()
{
	// Reset
	
	if (fRawReader) fRawReader->Reset();
	
	fNL0GammaPatch = 0;
	fNL1GammaPatch[0] = fNL1GammaPatch[1] = 0;
	fNL1JetPatch[0] = fNL1JetPatch[1] = 0;
}

//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
{
	// STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
	// bourrion_at_lpsc_dot_in2p3_dot_fr
	
	UInt_t word32[kPayLoadSizeV2 + 1536]; // 32b words
	for (Int_t i = 0;i < kPayLoadSizeV2 + 1536; i++) word32[i] = 0;
	
	Int_t iword = 0;
	
	fNL0GammaPatch = 0;
	fNL1GammaPatch[0] = fNL1GammaPatch[1] = 0;
	fNL1JetPatch[0] = fNL1JetPatch[1] = 0;
	
	Int_t eqId = -1, eqSize = 0;
	
	UInt_t w32;
	
	while (fRawReader->ReadNextInt(w32)) 
	{
		if (!iword)
		{
			eqId   = fRawReader->GetEquipmentId();
			eqSize = fRawReader->GetEquipmentSize();
		}
		
		word32[iword++] = w32;
	}
 
	if (iword != kPayLoadSizeV0 && iword != kPayLoadSizeV1 && iword != kPayLoadSizeV2 
		&& 
		iword != (kPayLoadSizeV0 + 1536) && iword != (kPayLoadSizeV1 + 1536) && iword != (kPayLoadSizeV2 + 1536))
	{
		AliError(Form("STU payload (eqId: %d, eqSize: %d) doesn't match expected size! %d word32",
					  eqId, eqSize, iword));
		return kFALSE;
	}
	
	AliDebug(1, Form("STU (eqId: %d, eqSize: %d) payload size: %d word32",
					 eqId, eqSize, iword));
	
	int offset = 1;//, jetSize = 2;
	
	int nthres = 1;
	
	switch (iword) 
	{
		case kPayLoadSizeV0:
		case kPayLoadSizeV0 + 1536:
		{
			fL1JetThreshold[0]   = ((word32[0]>>16) & 0xFFFF);
			fL1GammaThreshold[0] =  (word32[0]      & 0xFFFF);
			
			break;
		}
		case kPayLoadSizeV1:
		case kPayLoadSizeV1 + 1536:
		{
			fV0A = ((word32[0]>>16) & 0xFFFF);
			fV0C =  (word32[0]      & 0xFFFF);
			
			fG[0][0]       = word32[1];
			fG[1][0]       = word32[2];
			fG[2][0]       = word32[3];
			fJ[0][0]       = word32[4];
			fJ[1][0]       = word32[5];
			fJ[2][0]       = word32[6];		
			fRegionEnable  = word32[7];
			fFrameReceived = word32[8];
			fFwVersion     = word32[9];
			
			fL1JetThreshold[0]   = GetThreshold(fJ[0][0], fJ[1][0], fJ[2][0], fV0A, fV0C);
			fL1GammaThreshold[0] = GetThreshold(fG[0][0], fG[1][0], fG[2][0], fV0A, fV0C); 
			
			offset = 10;
			
			break;
		}
		case kPayLoadSizeV2:
		case kPayLoadSizeV2 + 1536:
		{
			fV0A = ((word32[0]>>16) & 0xFFFF);
			fV0C =  (word32[0]      & 0xFFFF);
			
			fG[0][0]       = word32[1];
			fG[1][0]       = word32[2];
			fG[2][0]       = word32[3];
			fJ[0][0]       = word32[4];
			fJ[1][0]       = word32[5];
			fJ[2][0]       = word32[6];		
			
			fG[0][1]       = word32[7];
			fG[1][1]       = word32[8];
			fG[2][1]       = word32[9];
			fJ[0][1]       = word32[10];
			fJ[1][1]       = word32[11];
			fJ[2][1]       = word32[12];		
			
			fRegionEnable  = word32[13];
			fFrameReceived = word32[14];
			fFwVersion     = word32[15];
			
			for (int i = 0; i < 2; i++) {
				//
				fL1JetThreshold[i]   = GetThreshold(fJ[0][i], fJ[1][i], fJ[2][i], fV0A, fV0C);
				fL1GammaThreshold[i] = GetThreshold(fG[0][i], fG[1][i], fG[2][i], fV0A, fV0C); 
			}
			
			offset = 16;			
			
			nthres = 2;
			
			break;
		}
	}
	
//	jetSize += (fFwVersion >> 16);
	
	///////////
	// START DECODING
	//////////

	for (int i = 0; i < nthres; i++) {
		DecodeL1JetPatchIndexes(i, word32, offset);
		
		offset += 11;
	}
	
	DecodeL0GammaPatchIndexes(word32, offset);
	
	offset += 96;
	
	for (int i = 0; i < nthres; i++) {
		DecodeL1GammaPatchIndexes(i, word32, offset);	
		
		offset += 128;
	}
	
	if (iword == kPayLoadSizeV0 || iword == kPayLoadSizeV1 || iword == kPayLoadSizeV2) {
		fGetRawData = 0;
		return kTRUE;
	}
	
	fGetRawData = 1;
	
	DecodeTRUADC(word32, offset);
	
	return kTRUE;
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::DecodeL0GammaPatchIndexes(UInt_t *word32, const int offset)
{
	//////////////////////////////////////////////////////////
	// index des L0                                         //
	//////////////////////////////////////////////////////////
	// FIXME: sounds like not valid data
	
	unsigned short truL0indexes[32][6];
	
	// extraction from stream
	for (Int_t index=0;index<6;index++)
	{
		for (Int_t tru_num=0;tru_num<16;tru_num++)
		{
			truL0indexes[2*tru_num  ][index] = ( word32[offset + index * 16 + tru_num]        & 0xFFFF);
			truL0indexes[2*tru_num+1][index] = ((word32[offset + index * 16 + tru_num] >> 16) & 0xFFFF);
		}
	}
	
	for (Int_t tru_num=0;tru_num<32;tru_num++) 
	{
		for (Int_t index=0;index<6;index++) 
		{
			for (Int_t bit_num=0;bit_num<12;bit_num++)
			{
				if ((truL0indexes[tru_num][index] & (1 << bit_num)))
				{
					Int_t idx = 12 * index + bit_num;
					
					fNL0GammaPatch++;
					
					fL0GammaPatchIndex[fNL0GammaPatch-1] = (((idx << 5) & 0x7E0) | (tru_num & 0x1F));
				}
			}
		}
	}
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::DecodeL1JetPatchIndexes(const int i, UInt_t *word32, const int offset)
{
	//////////////////////////////////////////////////////////
	// index des L1 jet                                     //
	//////////////////////////////////////////////////////////
	
	int jetSize = 2 + (fFwVersion >> 16);
	
	for (Int_t jet_row = 0; jet_row < 12 - (jetSize - 1); jet_row++)
	{
		UInt_t currentrow = word32[offset + jet_row];
		
		for (Int_t jet_col = 0; jet_col < 15; jet_col++)
		{
			if (currentrow & (1 << jet_col))
			{
				fNL1JetPatch[i] = fNL1JetPatch[i] + 1;
				
				fL1JetPatchIndex[fNL1JetPatch[i] - 1][i] = ((jet_row << 8) & 0xFF00) | (jet_col & 0xFF);
			}
		}
	}
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::DecodeL1GammaPatchIndexes(const int i, UInt_t *word32, const int offset)
{
	//////////////////////////////////////////////////////////
	// index des L1 gamma                                   //
	//////////////////////////////////////////////////////////
	
	unsigned short truL1indexes[32][8];
	
	// extraction from stream
	for (Int_t index=0;index<8;index++)
	{
		for (Int_t tru_num=0;tru_num<16;tru_num++)
		{
			truL1indexes[2*tru_num  ][index] = ( word32[offset + index * 16 + tru_num]        & 0xFFFF);
			truL1indexes[2*tru_num+1][index] = ((word32[offset + index * 16 + tru_num] >> 16) & 0xFFFF);
		}
	}	
	
	// interpretation
	int gammacolnum;
	short indexcopy;
	
	for (Int_t tru_num=0;tru_num<32;tru_num++)
	{
		for (Int_t index=0;index<8;index++)
		{
			for (Int_t bit_num=0; bit_num<12; bit_num++)
			{
				if ((truL1indexes[tru_num][index] & (1<<bit_num)) != 0)
				{
					if (index<4) // Even
					{
						gammacolnum = (2*bit_num  );
						indexcopy   = index;
					}
					else         // Odd
					{
						gammacolnum = (2*bit_num+1);
						indexcopy   = index-4;
					}						
					
					fNL1GammaPatch[i] = fNL1GammaPatch[i] + 1;
					
					fL1GammaPatchIndex[fNL1GammaPatch[i] - 1][i] = (((indexcopy << 10) & 0xC00) | ((gammacolnum << 5) & 0x3E0) | (tru_num & 0x1F));
				}
			}
		}
	}	
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::DecodeTRUADC(UInt_t *word32, const int offset)
{
	// extraction from stream
	for (Int_t index=0;index<96;index++)
	{
		for (Int_t tru_num=0;tru_num<16;tru_num++)
		{
			fADC[2*tru_num  ][index] = ( word32[offset + index * 16 + tru_num]        & 0xFFFF);
			fADC[2*tru_num+1][index] = ((word32[offset + index * 16 + tru_num] >> 16) & 0xFFFF);
		}
	}	
	
	for (Int_t tru_num=16;tru_num<32;tru_num++) // A side
	{
		Int_t v[96];
		for (Int_t index=0;index<96;index++) v[index] = fADC[tru_num][95-index];
		
		for (Int_t index=0;index<96;index++) fADC[tru_num][index] = v[index];
	}
}


//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::GetL0GammaPatch(const Int_t i, Int_t& tru, Int_t& idx) const
{
	// L0 gamma patches sent to STU (original access to L0 patch indexes)
	
	if (i > fNL0GammaPatch) return kFALSE;
	
	tru =  fL0GammaPatchIndex[i] & 0x1F;
	idx = (fL0GammaPatchIndex[i] & 0x7E0) >> 5;
	
	return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::GetL1GammaPatch(const Int_t i, const Int_t j, Int_t& tru, Int_t& col, Int_t& row) const
{
	// L1 gamma patch indexes
	
	if (j >= 2 || i > fNL1GammaPatch[j]) return kFALSE;
	
	tru =  fL1GammaPatchIndex[i][j] & 0x1F;
	col = (fL1GammaPatchIndex[i][j] & 0x3E0) >> 5;
	row = (fL1GammaPatchIndex[i][j] & 0xC00) >> 10;
	
	return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, const Int_t j, Int_t& col, Int_t& row) const
{
	// L1 jet patch indexes
	
	if (j >= 2 || i > fNL1JetPatch[j]) return kFALSE;
	
	col =  fL1JetPatchIndex[i][j] & 0xFF;
	row = (fL1JetPatchIndex[i][j] & 0xFF00) >> 8;
	
	return kTRUE;
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::GetADC(Int_t iTRU, UInt_t ADC[])
{
	// Time sums
	
	for (Int_t i=0; i<96; i++) ADC[i] = fADC[iTRU][i];
}

//_____________________________________________________________________________
void AliEMCALTriggerSTURawStream::DumpPayLoad(const Option_t *option) const
{
	// Dump STU payload
	
	TString op = option;
	
	printf("V0A:             %d\n", fV0A);
	printf("V0C:             %d\n", fV0C);

	printf("RawData:         %d\n", fGetRawData);
	printf("RegionEnable:    %8x\n", fRegionEnable); 
	printf("FrameReceived:   %8x\n", fFrameReceived);
	printf("FwVersion:       %x\n", fFwVersion);
	printf("Number of L0:    %d\n", fNL0GammaPatch);

	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			printf("G[%d][%d]: %d\n", j, i, fG[j][i]);
			printf("J[%d][%d]: %d\n", j, i, fJ[j][i]);
		}
		
		printf("Gamma threshold[%d]: %d\n", i, fL1GammaThreshold[i]);
		printf("Jet Threshold[%d]:   %d\n", i, fL1JetThreshold[i]);

		printf("Number of L1-g[%d]: %d\n", i, fNL1GammaPatch[i]);
		printf("Number of L1-j[%d]: %d\n", i, fNL1JetPatch[i]);
	}
	
	Int_t itru, col, row;
	
	if (op.Contains("L0") || op.Contains("ALL"))
	{
		for (Int_t i = 0;i < fNL0GammaPatch; i++) {
			if (GetL0GammaPatch(i,itru,col)) 
				cout << "> Found L0 gamma in TRU #" << setw(2) << itru <<  " at idx: " << setw(2) << col << endl;
		}
	}
	
	if (op.Contains("L1") || op.Contains("ALL")) {
		for (int j = 0; j < 2; j++) {
			for (Int_t i = 0; i < fNL1GammaPatch[j]; i++) {
				if (GetL1GammaPatch(i, j, itru, col, row)) 
					cout << "> Found L1 gamma " << j << " in TRU #" << setw(2) << itru <<  " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
			}
			
			for (Int_t i = 0; i < fNL1JetPatch[j]; i++) {
				if (GetL1JetPatch(i, j, col, row)) cout << "> Found L1 jet " << j << " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
			}
		}
	}
	
	if ((op.Contains("ADC") || op.Contains("ALL")) && fGetRawData) {
		for (Int_t i = 0; i < 32; i++) {
			cout << "--------\n";
			cout << "TRU #" << setw(2) << i << ":";
			for (Int_t j = 0;j < 96; j++) { 
				//TBits xadc(12); xadc.Set(12,&fADC[i][j]); 
				if ((j % 4) == 0) cout << endl;
				//cout << setw(2) << j << ": " << xadc << " ";
				printf("%2d: %3x / ",j,fADC[i][j]); 
			}
			cout << "\n";
		}
	}
}

//_____________________________________________________________________________
UShort_t AliEMCALTriggerSTURawStream::GetThreshold(Short_t A, Short_t B, Short_t C, UShort_t V0A, UShort_t V0C) const
{
	// Get threshold 
  ULong64_t v0sum = V0A + V0C;
  
  ULong64_t sqrV0 = v0sum * v0sum;					
					
  sqrV0 *= A;
					
  sqrV0 >>= 32;
				
  v0sum *= B;
					
  v0sum >>= 16;
					
  return (UShort_t)(sqrV0 + v0sum + C);
}
Commit	Line	Data
4bd37bd4	1
916f1e76	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	/*
	18
	19
	20
	21	This class provides access to STU DDL raw data.
	22	Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
	23	*/
	24
	25	#include "AliEMCALTriggerSTURawStream.h"
	26	#include "AliRawReader.h"
	27	#include "AliLog.h"
	28
	29	#include "Riostream.h"
	30	#include "TBits.h"
	31
c58cfdff	32	#include <cstdlib>
c58cfdff	33
916f1e76	34	namespace
916f1e76	35	{
63c22917	36	const Int_t kPayLoadSizeV0 = 236;
	37	const Int_t kPayLoadSizeV1 = 245;
	38	const Int_t kPayLoadSizeV2 = 390;
916f1e76	39	}
	40
	41	ClassImp(AliEMCALTriggerSTURawStream)
	42
	43	//_____________________________________________________________________________
	44	AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
	45	fRawReader(0x0),
63c22917	46	fL1JetThreshold(),
63c22917	47	fL1GammaThreshold(),
de39a0ff	48	fL0GammaPatchIndex(),
	49	fL1GammaPatchIndex(),
	50	fL1JetPatchIndex(),
916f1e76	51	fNL0GammaPatch(0),
63c22917	52	fNL1JetPatch(),
63c22917	53	fNL1GammaPatch(),
648b8b91	54	fGetRawData(0),
	55	fV0A(0),
	56	fV0C(0),
63c22917	57	fG(),
63c22917	58	fJ(),
648b8b91	59	fRegionEnable(0),
	60	fFrameReceived(0),
	61	fFwVersion(0)
916f1e76	62	{
916f1e76	63	//
63c22917	64	for (int i = 0; i < 2; i++) {
	65	//
	66	fL1JetThreshold[i] = fL1GammaThreshold[i] = 0;
	67
	68	fNL1JetPatch[i] = fNL1GammaPatch[i] = 0;
	69	}
	70
	71	for (int i = 0; i < 3; i++) {
	72	for (int j = 0; j < 2; j++) {
	73	//
	74	fG[i][j] = fJ[i][j] = 0;
	75	}
	76	}
	77
	78	for (int i = 0; i < 3100; i++) {
	79	//
	80	fL0GammaPatchIndex[i] = 0;
	81
	82	for (int j = 0; j < 2; j++) {
	83
	84	fL1GammaPatchIndex[i][j] = 0;
	85	}
	86	}
	87
	88	for (int i = 0; i < 200; i++) {
	89	for (int j = 0; j < 2; j++) {
	90
	91	fL1JetPatchIndex[i][j] = 0;
	92	}
	93	}
916f1e76	94	}
	95
	96	//_____________________________________________________________________________
	97	AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
	98	fRawReader(rawReader),
63c22917	99	fL1JetThreshold(),
63c22917	100	fL1GammaThreshold(),
de39a0ff	101	fL0GammaPatchIndex(),
	102	fL1GammaPatchIndex(),
	103	fL1JetPatchIndex(),
916f1e76	104	fNL0GammaPatch(0),
63c22917	105	fNL1JetPatch(),
63c22917	106	fNL1GammaPatch(),
648b8b91	107	fGetRawData(0),
	108	fV0A(0),
	109	fV0C(0),
63c22917	110	fG(),
63c22917	111	fJ(),
648b8b91	112	fRegionEnable(0),
	113	fFrameReceived(0),
	114	fFwVersion(0)
916f1e76	115	{
	116	//
	117	fRawReader->Reset();
	118	fRawReader->Select("EMCAL",44);
63c22917	119	//
	120	for (int i = 0; i < 2; i++) {
	121	//
	122	fL1JetThreshold[i] = fL1GammaThreshold[i] = 0;
	123
	124	fNL1JetPatch[i] = fNL1GammaPatch[i] = 0;
	125	}
	126
	127	for (int i = 0; i < 3; i++) {
	128	for (int j = 0; j < 2; j++) {
	129	//
	130	fG[i][j] = fJ[i][j] = 0;
	131	}
	132	}
	133
	134	for (int i = 0; i < 3100; i++) {
	135	//
	136	fL0GammaPatchIndex[i] = 0;
	137
	138	for (int j = 0; j < 2; j++) {
	139
	140	fL1GammaPatchIndex[i][j] = 0;
	141	}
	142	}
	143
	144	for (int i = 0; i < 200; i++) {
	145	for (int j = 0; j < 2; j++) {
	146
	147	fL1JetPatchIndex[i][j] = 0;
	148	}
	149	}
916f1e76	150	}
	151
	152	//_____________________________________________________________________________
	153	AliEMCALTriggerSTURawStream::~AliEMCALTriggerSTURawStream()
	154	{
	155	// destructor
	156	}
	157
	158	//_____________________________________________________________________________
	159	void AliEMCALTriggerSTURawStream::Reset()
	160	{
c1147445	161	// Reset
c1147445	162
916f1e76	163	if (fRawReader) fRawReader->Reset();
de39a0ff	164
fff39dd1	165	fNL0GammaPatch = 0;
63c22917	166	fNL1GammaPatch[0] = fNL1GammaPatch[1] = 0;
63c22917	167	fNL1JetPatch[0] = fNL1JetPatch[1] = 0;
916f1e76	168	}
	169
	170	//_____________________________________________________________________________
	171	Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
	172	{
	173	// STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
4bd37bd4	174	// bourrion_at_lpsc_dot_in2p3_dot_fr
916f1e76	175
63c22917	176	UInt_t word32[kPayLoadSizeV2 + 1536]; // 32b words
63c22917	177	for (Int_t i = 0;i < kPayLoadSizeV2 + 1536; i++) word32[i] = 0;
de39a0ff	178
916f1e76	179	Int_t iword = 0;
fff39dd1	180
fff39dd1	181	fNL0GammaPatch = 0;
63c22917	182	fNL1GammaPatch[0] = fNL1GammaPatch[1] = 0;
63c22917	183	fNL1JetPatch[0] = fNL1JetPatch[1] = 0;
fff39dd1	184
de39a0ff	185	Int_t eqId = -1, eqSize = 0;
916f1e76	186
916f1e76	187	UInt_t w32;
648b8b91	188
de39a0ff	189	while (fRawReader->ReadNextInt(w32))
	190	{
	191	if (!iword)
	192	{
	193	eqId = fRawReader->GetEquipmentId();
	194	eqSize = fRawReader->GetEquipmentSize();
	195	}
	196
	197	word32[iword++] = w32;
	198	}
804b828a	199
63c22917	200	if (iword != kPayLoadSizeV0 && iword != kPayLoadSizeV1 && iword != kPayLoadSizeV2
	201	&&
	202	iword != (kPayLoadSizeV0 + 1536) && iword != (kPayLoadSizeV1 + 1536) && iword != (kPayLoadSizeV2 + 1536))
916f1e76	203	{
648b8b91	204	AliError(Form("STU payload (eqId: %d, eqSize: %d) doesn't match expected size! %d word32",
de39a0ff	205	eqId, eqSize, iword));
916f1e76	206	return kFALSE;
de39a0ff	207	}
648b8b91	208
63c22917	209	AliDebug(1, Form("STU (eqId: %d, eqSize: %d) payload size: %d word32",
de39a0ff	210	eqId, eqSize, iword));
916f1e76	211
63c22917	212	int offset = 1;//, jetSize = 2;
	213
	214	int nthres = 1;
648b8b91	215
	216	switch (iword)
	217	{
63c22917	218	case kPayLoadSizeV0:
63c22917	219	case kPayLoadSizeV0 + 1536:
648b8b91	220	{
63c22917	221	fL1JetThreshold[0] = ((word32[0]>>16) & 0xFFFF);
63c22917	222	fL1GammaThreshold[0] = (word32[0] & 0xFFFF);
648b8b91	223
	224	break;
	225	}
63c22917	226	case kPayLoadSizeV1:
63c22917	227	case kPayLoadSizeV1 + 1536:
648b8b91	228	{
46e461b8	229	fV0A = ((word32[0]>>16) & 0xFFFF);
46e461b8	230	fV0C = (word32[0] & 0xFFFF);
648b8b91	231
63c22917	232	fG[0][0] = word32[1];
	233	fG[1][0] = word32[2];
	234	fG[2][0] = word32[3];
	235	fJ[0][0] = word32[4];
	236	fJ[1][0] = word32[5];
	237	fJ[2][0] = word32[6];
648b8b91	238	fRegionEnable = word32[7];
	239	fFrameReceived = word32[8];
	240	fFwVersion = word32[9];
	241
63c22917	242	fL1JetThreshold[0] = GetThreshold(fJ[0][0], fJ[1][0], fJ[2][0], fV0A, fV0C);
	243	fL1GammaThreshold[0] = GetThreshold(fG[0][0], fG[1][0], fG[2][0], fV0A, fV0C);
	244
	245	offset = 10;
	246
	247	break;
	248	}
	249	case kPayLoadSizeV2:
	250	case kPayLoadSizeV2 + 1536:
	251	{
	252	fV0A = ((word32[0]>>16) & 0xFFFF);
	253	fV0C = (word32[0] & 0xFFFF);
ad9ab1c9	254
63c22917	255	fG[0][0] = word32[1];
	256	fG[1][0] = word32[2];
	257	fG[2][0] = word32[3];
	258	fJ[0][0] = word32[4];
	259	fJ[1][0] = word32[5];
	260	fJ[2][0] = word32[6];
	261
	262	fG[0][1] = word32[7];
	263	fG[1][1] = word32[8];
	264	fG[2][1] = word32[9];
	265	fJ[0][1] = word32[10];
	266	fJ[1][1] = word32[11];
	267	fJ[2][1] = word32[12];
	268
	269	fRegionEnable = word32[13];
	270	fFrameReceived = word32[14];
	271	fFwVersion = word32[15];
	272
	273	for (int i = 0; i < 2; i++) {
	274	//
	275	fL1JetThreshold[i] = GetThreshold(fJ[0][i], fJ[1][i], fJ[2][i], fV0A, fV0C);
	276	fL1GammaThreshold[i] = GetThreshold(fG[0][i], fG[1][i], fG[2][i], fV0A, fV0C);
	277	}
648b8b91	278
63c22917	279	offset = 16;
	280
	281	nthres = 2;
648b8b91	282
	283	break;
	284	}
648b8b91	285	}
648b8b91	286
63c22917	287	// jetSize += (fFwVersion >> 16);
63c22917	288
648b8b91	289	///////////
	290	// START DECODING
	291	//////////
ad9ab1c9	292
63c22917	293	for (int i = 0; i < nthres; i++) {
63c22917	294	DecodeL1JetPatchIndexes(i, word32, offset);
916f1e76	295
63c22917	296	offset += 11;
916f1e76	297	}
63c22917	298
	299	DecodeL0GammaPatchIndexes(word32, offset);
	300
	301	offset += 96;
	302
	303	for (int i = 0; i < nthres; i++) {
	304	DecodeL1GammaPatchIndexes(i, word32, offset);
648b8b91	305
63c22917	306	offset += 128;
63c22917	307	}
916f1e76	308
63c22917	309	if (iword == kPayLoadSizeV0 \|\| iword == kPayLoadSizeV1 \|\| iword == kPayLoadSizeV2) {
	310	fGetRawData = 0;
	311	return kTRUE;
	312	}
	313
	314	fGetRawData = 1;
	315
	316	DecodeTRUADC(word32, offset);
	317
	318	return kTRUE;
	319	}
	320
	321	//_____________________________________________________________________________
	322	void AliEMCALTriggerSTURawStream::DecodeL0GammaPatchIndexes(UInt_t *word32, const int offset)
	323	{
916f1e76	324	//////////////////////////////////////////////////////////
	325	// index des L0 //
	326	//////////////////////////////////////////////////////////
648b8b91	327	// FIXME: sounds like not valid data
916f1e76	328
c1147445	329	unsigned short truL0indexes[32][6];
916f1e76	330
	331	// extraction from stream
	332	for (Int_t index=0;index<6;index++)
	333	{
	334	for (Int_t tru_num=0;tru_num<16;tru_num++)
	335	{
63c22917	336	truL0indexes[2tru_num ][index] = ( word32[offset + index 16 + tru_num] & 0xFFFF);
63c22917	337	truL0indexes[2tru_num+1][index] = ((word32[offset + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	338	}
916f1e76	339	}
63c22917	340
916f1e76	341	for (Int_t tru_num=0;tru_num<32;tru_num++)
	342	{
	343	for (Int_t index=0;index<6;index++)
	344	{
	345	for (Int_t bit_num=0;bit_num<12;bit_num++)
	346	{
c1147445	347	if ((truL0indexes[tru_num][index] & (1 << bit_num)))
916f1e76	348	{
916f1e76	349	Int_t idx = 12 * index + bit_num;
63c22917	350
916f1e76	351	fNL0GammaPatch++;
916f1e76	352
de39a0ff	353	fL0GammaPatchIndex[fNL0GammaPatch-1] = (((idx << 5) & 0x7E0) \| (tru_num & 0x1F));
916f1e76	354	}
	355	}
	356	}
	357	}
63c22917	358	}
	359
	360	//_____________________________________________________________________________
	361	void AliEMCALTriggerSTURawStream::DecodeL1JetPatchIndexes(const int i, UInt_t *word32, const int offset)
	362	{
	363	//////////////////////////////////////////////////////////
	364	// index des L1 jet //
	365	//////////////////////////////////////////////////////////
	366
	367	int jetSize = 2 + (fFwVersion >> 16);
	368
	369	for (Int_t jet_row = 0; jet_row < 12 - (jetSize - 1); jet_row++)
	370	{
	371	UInt_t currentrow = word32[offset + jet_row];
	372
	373	for (Int_t jet_col = 0; jet_col < 15; jet_col++)
	374	{
	375	if (currentrow & (1 << jet_col))
	376	{
	377	fNL1JetPatch[i] = fNL1JetPatch[i] + 1;
	378
	379	fL1JetPatchIndex[fNL1JetPatch[i] - 1][i] = ((jet_row << 8) & 0xFF00) \| (jet_col & 0xFF);
	380	}
	381	}
	382	}
	383	}
916f1e76	384
63c22917	385	//_____________________________________________________________________________
	386	void AliEMCALTriggerSTURawStream::DecodeL1GammaPatchIndexes(const int i, UInt_t *word32, const int offset)
	387	{
916f1e76	388	//////////////////////////////////////////////////////////
	389	// index des L1 gamma //
	390	//////////////////////////////////////////////////////////
	391
c1147445	392	unsigned short truL1indexes[32][8];
916f1e76	393
	394	// extraction from stream
	395	for (Int_t index=0;index<8;index++)
	396	{
	397	for (Int_t tru_num=0;tru_num<16;tru_num++)
	398	{
63c22917	399	truL1indexes[2tru_num ][index] = ( word32[offset + index 16 + tru_num] & 0xFFFF);
63c22917	400	truL1indexes[2tru_num+1][index] = ((word32[offset + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	401	}
916f1e76	402	}
63c22917	403
916f1e76	404	// interpretation
	405	int gammacolnum;
	406	short indexcopy;
	407
	408	for (Int_t tru_num=0;tru_num<32;tru_num++)
	409	{
	410	for (Int_t index=0;index<8;index++)
	411	{
	412	for (Int_t bit_num=0; bit_num<12; bit_num++)
	413	{
c1147445	414	if ((truL1indexes[tru_num][index] & (1<<bit_num)) != 0)
916f1e76	415	{
	416	if (index<4) // Even
	417	{
	418	gammacolnum = (2*bit_num );
	419	indexcopy = index;
	420	}
	421	else // Odd
	422	{
	423	gammacolnum = (2*bit_num+1);
	424	indexcopy = index-4;
	425	}
	426
63c22917	427	fNL1GammaPatch[i] = fNL1GammaPatch[i] + 1;
916f1e76	428
63c22917	429	fL1GammaPatchIndex[fNL1GammaPatch[i] - 1][i] = (((indexcopy << 10) & 0xC00) \| ((gammacolnum << 5) & 0x3E0) \| (tru_num & 0x1F));
916f1e76	430	}
	431	}
	432	}
	433	}
63c22917	434	}
916f1e76	435
63c22917	436	//_____________________________________________________________________________
	437	void AliEMCALTriggerSTURawStream::DecodeTRUADC(UInt_t *word32, const int offset)
	438	{
916f1e76	439	// extraction from stream
	440	for (Int_t index=0;index<96;index++)
	441	{
	442	for (Int_t tru_num=0;tru_num<16;tru_num++)
	443	{
63c22917	444	fADC[2tru_num ][index] = ( word32[offset + index 16 + tru_num] & 0xFFFF);
63c22917	445	fADC[2tru_num+1][index] = ((word32[offset + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	446	}
916f1e76	447	}
63c22917	448
916f1e76	449	for (Int_t tru_num=16;tru_num<32;tru_num++) // A side
916f1e76	450	{
de39a0ff	451	Int_t v[96];
	452	for (Int_t index=0;index<96;index++) v[index] = fADC[tru_num][95-index];
	453
	454	for (Int_t index=0;index<96;index++) fADC[tru_num][index] = v[index];
916f1e76	455	}
916f1e76	456	}
916f1e76	457
63c22917	458
916f1e76	459	//_____________________________________________________________________________
de39a0ff	460	Bool_t AliEMCALTriggerSTURawStream::GetL0GammaPatch(const Int_t i, Int_t& tru, Int_t& idx) const
916f1e76	461	{
c1147445	462	// L0 gamma patches sent to STU (original access to L0 patch indexes)
c1147445	463
916f1e76	464	if (i > fNL0GammaPatch) return kFALSE;
	465
	466	tru = fL0GammaPatchIndex[i] & 0x1F;
de39a0ff	467	idx = (fL0GammaPatchIndex[i] & 0x7E0) >> 5;
916f1e76	468
	469	return kTRUE;
	470	}
	471
	472	//_____________________________________________________________________________
63c22917	473	Bool_t AliEMCALTriggerSTURawStream::GetL1GammaPatch(const Int_t i, const Int_t j, Int_t& tru, Int_t& col, Int_t& row) const
916f1e76	474	{
c1147445	475	// L1 gamma patch indexes
c1147445	476
9c024499	477	if (j >= 2 \|\| i > fNL1GammaPatch[j]) return kFALSE;
916f1e76	478
63c22917	479	tru = fL1GammaPatchIndex[i][j] & 0x1F;
	480	col = (fL1GammaPatchIndex[i][j] & 0x3E0) >> 5;
	481	row = (fL1GammaPatchIndex[i][j] & 0xC00) >> 10;
916f1e76	482
	483	return kTRUE;
	484	}
	485
	486	//_____________________________________________________________________________
63c22917	487	Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, const Int_t j, Int_t& col, Int_t& row) const
916f1e76	488	{
c1147445	489	// L1 jet patch indexes
c1147445	490
9c024499	491	if (j >= 2 \|\| i > fNL1JetPatch[j]) return kFALSE;
916f1e76	492
63c22917	493	col = fL1JetPatchIndex[i][j] & 0xFF;
63c22917	494	row = (fL1JetPatchIndex[i][j] & 0xFF00) >> 8;
916f1e76	495
	496	return kTRUE;
	497	}
	498
	499	//_____________________________________________________________________________
	500	void AliEMCALTriggerSTURawStream::GetADC(Int_t iTRU, UInt_t ADC[])
	501	{
c1147445	502	// Time sums
c1147445	503
916f1e76	504	for (Int_t i=0; i<96; i++) ADC[i] = fADC[iTRU][i];
	505	}
	506
	507	//_____________________________________________________________________________
80e5a1ae	508	void AliEMCALTriggerSTURawStream::DumpPayLoad(const Option_t *option) const
916f1e76	509	{
c1147445	510	// Dump STU payload
c1147445	511
916f1e76	512	TString op = option;
916f1e76	513
648b8b91	514	printf("V0A: %d\n", fV0A);
648b8b91	515	printf("V0C: %d\n", fV0C);
63c22917	516
648b8b91	517	printf("RawData: %d\n", fGetRawData);
	518	printf("RegionEnable: %8x\n", fRegionEnable);
	519	printf("FrameReceived: %8x\n", fFrameReceived);
	520	printf("FwVersion: %x\n", fFwVersion);
	521	printf("Number of L0: %d\n", fNL0GammaPatch);
63c22917	522
	523	for (int i = 0; i < 2; i++) {
	524	for (int j = 0; j < 3; j++) {
	525	printf("G[%d][%d]: %d\n", j, i, fG[j][i]);
	526	printf("J[%d][%d]: %d\n", j, i, fJ[j][i]);
	527	}
	528
	529	printf("Gamma threshold[%d]: %d\n", i, fL1GammaThreshold[i]);
	530	printf("Jet Threshold[%d]: %d\n", i, fL1JetThreshold[i]);
	531
	532	printf("Number of L1-g[%d]: %d\n", i, fNL1GammaPatch[i]);
	533	printf("Number of L1-j[%d]: %d\n", i, fNL1JetPatch[i]);
	534	}
916f1e76	535
916f1e76	536	Int_t itru, col, row;
916f1e76	537
	538	if (op.Contains("L0") \|\| op.Contains("ALL"))
	539	{
63c22917	540	for (Int_t i = 0;i < fNL0GammaPatch; i++) {
de39a0ff	541	if (GetL0GammaPatch(i,itru,col))
de39a0ff	542	cout << "> Found L0 gamma in TRU #" << setw(2) << itru << " at idx: " << setw(2) << col << endl;
916f1e76	543	}
	544	}
	545
63c22917	546	if (op.Contains("L1") \|\| op.Contains("ALL")) {
	547	for (int j = 0; j < 2; j++) {
	548	for (Int_t i = 0; i < fNL1GammaPatch[j]; i++) {
	549	if (GetL1GammaPatch(i, j, itru, col, row))
	550	cout << "> Found L1 gamma " << j << " in TRU #" << setw(2) << itru << " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
	551	}
	552
	553	for (Int_t i = 0; i < fNL1JetPatch[j]; i++) {
	554	if (GetL1JetPatch(i, j, col, row)) cout << "> Found L1 jet " << j << " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
	555	}
916f1e76	556	}
	557	}
	558
63c22917	559	if ((op.Contains("ADC") \|\| op.Contains("ALL")) && fGetRawData) {
63c22917	560	for (Int_t i = 0; i < 32; i++) {
916f1e76	561	cout << "--------\n";
916f1e76	562	cout << "TRU #" << setw(2) << i << ":";
63c22917	563	for (Int_t j = 0;j < 96; j++) {
	564	//TBits xadc(12); xadc.Set(12,&fADC[i][j]);
	565	if ((j % 4) == 0) cout << endl;
916f1e76	566	//cout << setw(2) << j << ": " << xadc << " ";
	567	printf("%2d: %3x / ",j,fADC[i][j]);
	568	}
	569	cout << "\n";
	570	}
	571	}
	572	}
222f9c45	573
222f9c45	574	//_____________________________________________________________________________
79b05051	575	UShort_t AliEMCALTriggerSTURawStream::GetThreshold(Short_t A, Short_t B, Short_t C, UShort_t V0A, UShort_t V0C) const
222f9c45	576	{
79b05051	577	// Get threshold
79b05051	578	ULong64_t v0sum = V0A + V0C;
222f9c45	579
79b05051	580	ULong64_t sqrV0 = v0sum * v0sum;
222f9c45	581
	582	sqrV0 *= A;
	583
	584	sqrV0 >>= 32;
	585
79b05051	586	v0sum *= B;
222f9c45	587
79b05051	588	v0sum >>= 16;
222f9c45	589
79b05051	590	return (UShort_t)(sqrV0 + v0sum + C);
222f9c45	591	}