[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 kPayLoadSizeOld     = 236;
	const Int_t kPayLoadSizeNew     = 245;
}

ClassImp(AliEMCALTriggerSTURawStream)

//_____________________________________________________________________________
AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
fRawReader(0x0),
fL1JetThreshold(0),
fL1GammaThreshold(0),
fL0GammaPatchIndex(),
fL1GammaPatchIndex(),
fL1JetPatchIndex(),
fNL0GammaPatch(0),
fNL1JetPatch(0),
fNL1GammaPatch(0),
fGetRawData(0),
fV0A(0),
fV0C(0),
fGA(0),
fGB(0),
fGC(0),
fJA(0),
fJB(0),
fJC(0),
fRegionEnable(0),
fFrameReceived(0),
fFwVersion(0)
{
	//
}

//_____________________________________________________________________________
AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
fRawReader(rawReader),
fL1JetThreshold(0),
fL1GammaThreshold(0),
fL0GammaPatchIndex(),
fL1GammaPatchIndex(),
fL1JetPatchIndex(),
fNL0GammaPatch(0),
fNL1JetPatch(0),
fNL1GammaPatch(0),
fGetRawData(0),
fV0A(0),
fV0C(0),
fGA(0),
fGB(0),
fGC(0),
fJA(0),
fJB(0),
fJC(0),
fRegionEnable(0),
fFrameReceived(0),
fFwVersion(0)
{
	//
	fRawReader->Reset();
	fRawReader->Select("EMCAL",44);
}

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

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

//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
{
	// STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
	// bourrion_at_lpsc_dot_in2p3_dot_fr
	
	UInt_t word32[kPayLoadSizeNew + 1536]; // 32b words
	for (Int_t i = 0;i < kPayLoadSizeNew + 1536; i++) word32[i] = 0;
	
	Int_t iword = 0;
	
	fNL0GammaPatch = 0;
	fNL1GammaPatch = 0;
	fNL1JetPatch   = 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 != kPayLoadSizeOld && iword != kPayLoadSizeNew && iword != (kPayLoadSizeOld + 1536) && iword != (kPayLoadSizeNew + 1536))
	{
		AliError(Form("STU payload (eqId: %d, eqSize: %d) doesn't match expected size! %d word32",
					  eqId, eqSize, iword));
		return kFALSE;
	}
	
	if (AliDebugLevel())
	{
		AliInfo(Form("STU (eqId: %d, eqSize: %d) payload size: %d word32",
					 eqId, eqSize, iword));
	}
	
	int offset = 0, jetSize = 2;
	
	switch (iword) 
	{
		case kPayLoadSizeOld:
		case kPayLoadSizeOld + 1536:
		{
			fL1JetThreshold   = ((word32[0]>>16) & 0xFFF);
			fL1GammaThreshold =  (word32[0]      & 0xFFF);
			
			break;
		}
		case kPayLoadSizeNew:
		case kPayLoadSizeNew + 1536:
		{
			fV0A = ((word32[0]>>16) & 0xFFF);
			fV0C =  (word32[0]      & 0xFFF);
			
			UInt_t sV0 = fV0A + fV0C;
			
			fGA            = word32[1];
			fGB            = word32[2];
			fGC            = word32[3];
			fJA            = word32[4];
			fJB            = word32[5];
			fJC            = word32[6];		
			fRegionEnable  = word32[7];
			fFrameReceived = word32[8];
			fFwVersion     = word32[9];
			
			jetSize += (fFwVersion >> 16);
			
			fL1JetThreshold   = fJA * sV0 * sV0 + fJB * sV0 + fJC;
			fL1GammaThreshold = fGA * sV0 * sV0 + fGB * sV0 + fGC;		
			
			offset = 9;
			
			break;
		}
	}
	
	///////////
	// START DECODING
	//////////

	for (Int_t jet_row = 0; jet_row < 12 - (jetSize - 1); jet_row++)
	{
		UInt_t currentrow = word32[offset + 1 + jet_row];
		
		for (Int_t jet_col = 0; jet_col < 15; jet_col++)
		{
			if (currentrow & (1 << jet_col))
			{
				fNL1JetPatch++;
				
				fL1JetPatchIndex[fNL1JetPatch-1] = ((jet_row << 8) & 0xFF00) | (jet_col & 0xFF);
			}
		}
	}
		
	
	//////////////////////////////////////////////////////////
	// 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 + 12 + index * 16 + tru_num]        & 0xFFFF);
			truL0indexes[2*tru_num+1][index] = ((word32[offset + 12 + 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));
				}
			}
		}
	}

	//////////////////////////////////////////////////////////
	// 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 + 108 + index * 16 + tru_num]        & 0xFFFF);
			truL1indexes[2*tru_num+1][index] = ((word32[offset + 108 + 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++;
					
					fL1GammaPatchIndex[fNL1GammaPatch-1] = (((indexcopy << 10) & 0xC00) | ((gammacolnum << 5) & 0x3E0) | (tru_num & 0x1F));
				}
			}
		}
	}	

	//////////////////////////////////////////////////////////
	// raw output                                           //
	//////////////////////////////////////////////////////////
	
	if (iword == kPayLoadSizeOld || iword == kPayLoadSizeNew) 
	{
		fGetRawData = 0;
		return kTRUE;
	}
	
	fGetRawData = 1;
	
	// 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 + 236 + index * 16 + tru_num]        & 0xFFFF);
			fADC[2*tru_num+1][index] = ((word32[offset + 236 + 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];
	}
	
	return kTRUE;
}

//_____________________________________________________________________________
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, Int_t& tru, Int_t& col, Int_t& row) const
{
	// L1 gamma patch indexes
	
	if (i > fNL1GammaPatch) return kFALSE;
	
	tru =  fL1GammaPatchIndex[i] & 0x1F;
	col = (fL1GammaPatchIndex[i] & 0x3E0) >> 5;
	row = (fL1GammaPatchIndex[i] & 0xC00) >> 10;
	
	return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, Int_t& col, Int_t& row) const
{
	// L1 jet patch indexes
	
	if (i > fNL1JetPatch) return kFALSE;
	
	col =  fL1JetPatchIndex[i] & 0xFF;
	row = (fL1JetPatchIndex[i] & 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("G_A:             %d\n", fGA);
	printf("G_B:             %d\n", fGB);
	printf("G_C:             %d\n", fGC);
	printf("Gamma threshold: %d\n", fL1GammaThreshold);
	printf("J_A:             %d\n", fJA);
	printf("J_B:             %d\n", fJB);
	printf("J_C:             %d\n", fJC);
	printf("Jet Threshold:   %d\n", fL1JetThreshold);
	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);
	printf("Number of L1-g:  %d\n", fNL1GammaPatch);
	printf("Number of L1-j:  %d\n", fNL1JetPatch);
	
	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_t i=0;i<fNL1GammaPatch;i++)
		{
			if (GetL1GammaPatch(i,itru,col,row)) 
				cout << "> Found L1 gamma in TRU #" << setw(2) << itru <<  " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
		}

		for (Int_t i=0;i<fNL1JetPatch;i++)
		{
			if (GetL1JetPatch(i,col,row)) cout << "> Found L1 jet 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";
		}
	}
}
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	{
648b8b91	36	const Int_t kPayLoadSizeOld = 236;
648b8b91	37	const Int_t kPayLoadSizeNew = 245;
916f1e76	38	}
	39
	40	ClassImp(AliEMCALTriggerSTURawStream)
	41
	42	//_____________________________________________________________________________
	43	AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
	44	fRawReader(0x0),
	45	fL1JetThreshold(0),
	46	fL1GammaThreshold(0),
de39a0ff	47	fL0GammaPatchIndex(),
	48	fL1GammaPatchIndex(),
	49	fL1JetPatchIndex(),
916f1e76	50	fNL0GammaPatch(0),
	51	fNL1JetPatch(0),
	52	fNL1GammaPatch(0),
648b8b91	53	fGetRawData(0),
	54	fV0A(0),
	55	fV0C(0),
	56	fGA(0),
	57	fGB(0),
	58	fGC(0),
	59	fJA(0),
	60	fJB(0),
	61	fJC(0),
	62	fRegionEnable(0),
	63	fFrameReceived(0),
	64	fFwVersion(0)
916f1e76	65	{
	66	//
	67	}
	68
	69	//_____________________________________________________________________________
	70	AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
	71	fRawReader(rawReader),
	72	fL1JetThreshold(0),
	73	fL1GammaThreshold(0),
de39a0ff	74	fL0GammaPatchIndex(),
	75	fL1GammaPatchIndex(),
	76	fL1JetPatchIndex(),
916f1e76	77	fNL0GammaPatch(0),
916f1e76	78	fNL1JetPatch(0),
de39a0ff	79	fNL1GammaPatch(0),
648b8b91	80	fGetRawData(0),
	81	fV0A(0),
	82	fV0C(0),
	83	fGA(0),
	84	fGB(0),
	85	fGC(0),
	86	fJA(0),
	87	fJB(0),
	88	fJC(0),
	89	fRegionEnable(0),
	90	fFrameReceived(0),
	91	fFwVersion(0)
916f1e76	92	{
	93	//
	94	fRawReader->Reset();
	95	fRawReader->Select("EMCAL",44);
	96	}
	97
	98	//_____________________________________________________________________________
	99	AliEMCALTriggerSTURawStream::~AliEMCALTriggerSTURawStream()
	100	{
	101	// destructor
	102	}
	103
	104	//_____________________________________________________________________________
	105	void AliEMCALTriggerSTURawStream::Reset()
	106	{
c1147445	107	// Reset
c1147445	108
916f1e76	109	if (fRawReader) fRawReader->Reset();
de39a0ff	110
fff39dd1	111	fNL0GammaPatch = 0;
	112	fNL1GammaPatch = 0;
	113	fNL1JetPatch = 0;
916f1e76	114	}
	115
	116	//_____________________________________________________________________________
	117	Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
	118	{
	119	// STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
4bd37bd4	120	// bourrion_at_lpsc_dot_in2p3_dot_fr
916f1e76	121
648b8b91	122	UInt_t word32[kPayLoadSizeNew + 1536]; // 32b words
648b8b91	123	for (Int_t i = 0;i < kPayLoadSizeNew + 1536; i++) word32[i] = 0;
de39a0ff	124
916f1e76	125	Int_t iword = 0;
fff39dd1	126
	127	fNL0GammaPatch = 0;
	128	fNL1GammaPatch = 0;
	129	fNL1JetPatch = 0;
	130
de39a0ff	131	Int_t eqId = -1, eqSize = 0;
916f1e76	132
916f1e76	133	UInt_t w32;
648b8b91	134
de39a0ff	135	while (fRawReader->ReadNextInt(w32))
	136	{
	137	if (!iword)
	138	{
	139	eqId = fRawReader->GetEquipmentId();
	140	eqSize = fRawReader->GetEquipmentSize();
	141	}
	142
	143	word32[iword++] = w32;
	144	}
916f1e76	145
648b8b91	146	if (iword != kPayLoadSizeOld && iword != kPayLoadSizeNew && iword != (kPayLoadSizeOld + 1536) && iword != (kPayLoadSizeNew + 1536))
916f1e76	147	{
648b8b91	148	AliError(Form("STU payload (eqId: %d, eqSize: %d) doesn't match expected size! %d word32",
de39a0ff	149	eqId, eqSize, iword));
916f1e76	150	return kFALSE;
de39a0ff	151	}
648b8b91	152
648b8b91	153	if (AliDebugLevel())
916f1e76	154	{
de39a0ff	155	AliInfo(Form("STU (eqId: %d, eqSize: %d) payload size: %d word32",
de39a0ff	156	eqId, eqSize, iword));
916f1e76	157	}
916f1e76	158
ad9ab1c9	159	int offset = 0, jetSize = 2;
648b8b91	160
	161	switch (iword)
	162	{
	163	case kPayLoadSizeOld:
	164	case kPayLoadSizeOld + 1536:
	165	{
	166	fL1JetThreshold = ((word32[0]>>16) & 0xFFF);
	167	fL1GammaThreshold = (word32[0] & 0xFFF);
	168
	169	break;
	170	}
	171	case kPayLoadSizeNew:
	172	case kPayLoadSizeNew + 1536:
	173	{
	174	fV0A = ((word32[0]>>16) & 0xFFF);
	175	fV0C = (word32[0] & 0xFFF);
	176
	177	UInt_t sV0 = fV0A + fV0C;
	178
	179	fGA = word32[1];
	180	fGB = word32[2];
	181	fGC = word32[3];
	182	fJA = word32[4];
	183	fJB = word32[5];
	184	fJC = word32[6];
	185	fRegionEnable = word32[7];
	186	fFrameReceived = word32[8];
	187	fFwVersion = word32[9];
	188
ad9ab1c9	189	jetSize += (fFwVersion >> 16);
ad9ab1c9	190
648b8b91	191	fL1JetThreshold = fJA * sV0 * sV0 + fJB * sV0 + fJC;
	192	fL1GammaThreshold = fGA * sV0 * sV0 + fGB * sV0 + fGC;
	193
	194	offset = 9;
	195
	196	break;
	197	}
648b8b91	198	}
	199
	200	///////////
	201	// START DECODING
	202	//////////
ad9ab1c9	203
ad9ab1c9	204	for (Int_t jet_row = 0; jet_row < 12 - (jetSize - 1); jet_row++)
916f1e76	205	{
648b8b91	206	UInt_t currentrow = word32[offset + 1 + jet_row];
916f1e76	207
648b8b91	208	for (Int_t jet_col = 0; jet_col < 15; jet_col++)
916f1e76	209	{
	210	if (currentrow & (1 << jet_col))
	211	{
	212	fNL1JetPatch++;
916f1e76	213
	214	fL1JetPatchIndex[fNL1JetPatch-1] = ((jet_row << 8) & 0xFF00) \| (jet_col & 0xFF);
	215	}
	216	}
	217	}
648b8b91	218
916f1e76	219
	220	//////////////////////////////////////////////////////////
	221	// index des L0 //
	222	//////////////////////////////////////////////////////////
648b8b91	223	// FIXME: sounds like not valid data
916f1e76	224
c1147445	225	unsigned short truL0indexes[32][6];
916f1e76	226
	227	// extraction from stream
	228	for (Int_t index=0;index<6;index++)
	229	{
	230	for (Int_t tru_num=0;tru_num<16;tru_num++)
	231	{
648b8b91	232	truL0indexes[2tru_num ][index] = ( word32[offset + 12 + index 16 + tru_num] & 0xFFFF);
648b8b91	233	truL0indexes[2tru_num+1][index] = ((word32[offset + 12 + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	234	}
	235	}
	236
	237	for (Int_t tru_num=0;tru_num<32;tru_num++)
	238	{
	239	for (Int_t index=0;index<6;index++)
	240	{
	241	for (Int_t bit_num=0;bit_num<12;bit_num++)
	242	{
c1147445	243	if ((truL0indexes[tru_num][index] & (1 << bit_num)))
916f1e76	244	{
916f1e76	245	Int_t idx = 12 * index + bit_num;
de39a0ff	246
916f1e76	247	fNL0GammaPatch++;
916f1e76	248
de39a0ff	249	fL0GammaPatchIndex[fNL0GammaPatch-1] = (((idx << 5) & 0x7E0) \| (tru_num & 0x1F));
916f1e76	250	}
	251	}
	252	}
	253	}
	254
	255	//////////////////////////////////////////////////////////
	256	// index des L1 gamma //
	257	//////////////////////////////////////////////////////////
	258
c1147445	259	unsigned short truL1indexes[32][8];
916f1e76	260
	261	// extraction from stream
	262	for (Int_t index=0;index<8;index++)
	263	{
	264	for (Int_t tru_num=0;tru_num<16;tru_num++)
	265	{
648b8b91	266	truL1indexes[2tru_num ][index] = ( word32[offset + 108 + index 16 + tru_num] & 0xFFFF);
648b8b91	267	truL1indexes[2tru_num+1][index] = ((word32[offset + 108 + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	268	}
	269	}
	270
	271	// interpretation
	272	int gammacolnum;
	273	short indexcopy;
	274
	275	for (Int_t tru_num=0;tru_num<32;tru_num++)
	276	{
	277	for (Int_t index=0;index<8;index++)
	278	{
	279	for (Int_t bit_num=0; bit_num<12; bit_num++)
	280	{
c1147445	281	if ((truL1indexes[tru_num][index] & (1<<bit_num)) != 0)
916f1e76	282	{
	283	if (index<4) // Even
	284	{
	285	gammacolnum = (2*bit_num );
	286	indexcopy = index;
	287	}
	288	else // Odd
	289	{
	290	gammacolnum = (2*bit_num+1);
	291	indexcopy = index-4;
	292	}
	293
	294	fNL1GammaPatch++;
916f1e76	295
	296	fL1GammaPatchIndex[fNL1GammaPatch-1] = (((indexcopy << 10) & 0xC00) \| ((gammacolnum << 5) & 0x3E0) \| (tru_num & 0x1F));
	297	}
	298	}
	299	}
	300	}
	301
	302	//////////////////////////////////////////////////////////
	303	// raw output //
	304	//////////////////////////////////////////////////////////
	305
648b8b91	306	if (iword == kPayLoadSizeOld \|\| iword == kPayLoadSizeNew)
39c05eac	307	{
39c05eac	308	fGetRawData = 0;
de39a0ff	309	return kTRUE;
39c05eac	310	}
	311
	312	fGetRawData = 1;
916f1e76	313
	314	// extraction from stream
	315	for (Int_t index=0;index<96;index++)
	316	{
	317	for (Int_t tru_num=0;tru_num<16;tru_num++)
	318	{
648b8b91	319	fADC[2tru_num ][index] = ( word32[offset + 236 + index 16 + tru_num] & 0xFFFF);
648b8b91	320	fADC[2tru_num+1][index] = ((word32[offset + 236 + index 16 + tru_num] >> 16) & 0xFFFF);
916f1e76	321	}
	322	}
	323
	324	for (Int_t tru_num=16;tru_num<32;tru_num++) // A side
	325	{
de39a0ff	326	Int_t v[96];
	327	for (Int_t index=0;index<96;index++) v[index] = fADC[tru_num][95-index];
	328
	329	for (Int_t index=0;index<96;index++) fADC[tru_num][index] = v[index];
916f1e76	330	}
916f1e76	331
de39a0ff	332	return kTRUE;
916f1e76	333	}
	334
	335	//_____________________________________________________________________________
de39a0ff	336	Bool_t AliEMCALTriggerSTURawStream::GetL0GammaPatch(const Int_t i, Int_t& tru, Int_t& idx) const
916f1e76	337	{
c1147445	338	// L0 gamma patches sent to STU (original access to L0 patch indexes)
c1147445	339
916f1e76	340	if (i > fNL0GammaPatch) return kFALSE;
	341
	342	tru = fL0GammaPatchIndex[i] & 0x1F;
de39a0ff	343	idx = (fL0GammaPatchIndex[i] & 0x7E0) >> 5;
916f1e76	344
	345	return kTRUE;
	346	}
	347
	348	//_____________________________________________________________________________
	349	Bool_t AliEMCALTriggerSTURawStream::GetL1GammaPatch(const Int_t i, Int_t& tru, Int_t& col, Int_t& row) const
	350	{
c1147445	351	// L1 gamma patch indexes
c1147445	352
916f1e76	353	if (i > fNL1GammaPatch) return kFALSE;
	354
	355	tru = fL1GammaPatchIndex[i] & 0x1F;
	356	col = (fL1GammaPatchIndex[i] & 0x3E0) >> 5;
	357	row = (fL1GammaPatchIndex[i] & 0xC00) >> 10;
	358
	359	return kTRUE;
	360	}
	361
	362	//_____________________________________________________________________________
	363	Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, Int_t& col, Int_t& row) const
	364	{
c1147445	365	// L1 jet patch indexes
c1147445	366
916f1e76	367	if (i > fNL1JetPatch) return kFALSE;
	368
	369	col = fL1JetPatchIndex[i] & 0xFF;
	370	row = (fL1JetPatchIndex[i] & 0xFF00) >> 8;
	371
	372	return kTRUE;
	373	}
	374
	375	//_____________________________________________________________________________
	376	void AliEMCALTriggerSTURawStream::GetADC(Int_t iTRU, UInt_t ADC[])
	377	{
c1147445	378	// Time sums
c1147445	379
916f1e76	380	for (Int_t i=0; i<96; i++) ADC[i] = fADC[iTRU][i];
	381	}
	382
	383	//_____________________________________________________________________________
80e5a1ae	384	void AliEMCALTriggerSTURawStream::DumpPayLoad(const Option_t *option) const
916f1e76	385	{
c1147445	386	// Dump STU payload
c1147445	387
916f1e76	388	TString op = option;
916f1e76	389
648b8b91	390	printf("V0A: %d\n", fV0A);
	391	printf("V0C: %d\n", fV0C);
	392	printf("G_A: %d\n", fGA);
	393	printf("G_B: %d\n", fGB);
	394	printf("G_C: %d\n", fGC);
	395	printf("Gamma threshold: %d\n", fL1GammaThreshold);
	396	printf("J_A: %d\n", fJA);
	397	printf("J_B: %d\n", fJB);
	398	printf("J_C: %d\n", fJC);
	399	printf("Jet Threshold: %d\n", fL1JetThreshold);
	400	printf("RawData: %d\n", fGetRawData);
	401	printf("RegionEnable: %8x\n", fRegionEnable);
	402	printf("FrameReceived: %8x\n", fFrameReceived);
	403	printf("FwVersion: %x\n", fFwVersion);
	404	printf("Number of L0: %d\n", fNL0GammaPatch);
	405	printf("Number of L1-g: %d\n", fNL1GammaPatch);
	406	printf("Number of L1-j: %d\n", fNL1JetPatch);
916f1e76	407
916f1e76	408	Int_t itru, col, row;
916f1e76	409
	410	if (op.Contains("L0") \|\| op.Contains("ALL"))
	411	{
	412	for (Int_t i=0;i<fNL0GammaPatch;i++)
	413	{
de39a0ff	414
	415	if (GetL0GammaPatch(i,itru,col))
	416	cout << "> Found L0 gamma in TRU #" << setw(2) << itru << " at idx: " << setw(2) << col << endl;
916f1e76	417	}
	418	}
	419
	420	if (op.Contains("L1") \|\| op.Contains("ALL"))
	421	{
	422	for (Int_t i=0;i<fNL1GammaPatch;i++)
	423	{
de39a0ff	424	if (GetL1GammaPatch(i,itru,col,row))
de39a0ff	425	cout << "> Found L1 gamma in TRU #" << setw(2) << itru << " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
916f1e76	426	}
	427
	428	for (Int_t i=0;i<fNL1JetPatch;i++)
	429	{
de39a0ff	430	if (GetL1JetPatch(i,col,row)) cout << "> Found L1 jet at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
916f1e76	431	}
	432	}
	433
648b8b91	434
39c05eac	435
39c05eac	436	if ( (op.Contains("ADC") \|\| op.Contains("ALL")) && fGetRawData )
916f1e76	437	{
	438	for (Int_t i=0;i<32;i++)
	439	{
	440	cout << "--------\n";
	441	cout << "TRU #" << setw(2) << i << ":";
	442	for (Int_t j=0;j<96;j++)
	443	{
	444	TBits xadc(12); xadc.Set(12,&fADC[i][j]);
	445	if ((j%4)==0) cout << endl;
	446	//cout << setw(2) << j << ": " << xadc << " ";
	447	printf("%2d: %3x / ",j,fADC[i][j]);
	448	}
	449	cout << "\n";
	450	}
	451	}
	452	}