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

/*
 
 
EMCal trigger electronics manager L0/L1
can handle both simulated digits and raw data
Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
*/

#include "AliEMCALTriggerElectronics.h"
#include "AliEMCALTriggerTRU.h"
#include "AliEMCALTriggerSTU.h"
#include "AliEMCALGeometry.h"
#include "AliRunLoader.h"
#include "AliEMCAL.h" 
#include "AliRun.h" 
#include "AliEMCALTriggerDCSConfig.h"
#include "AliEMCALTriggerData.h"
#include "AliEMCALDigit.h"
#include "AliCaloRawStreamV3.h"
#include "AliEMCALTriggerSTURawStream.h"
#include "AliEMCALDigit.h"
#include "AliEMCALTriggerRawDigit.h"
#include "AliEMCALTriggerPatch.h"

#include <TVector2.h>
#include <TClonesArray.h>

namespace
{
	const Int_t kNTRU = 32;
}

ClassImp(AliEMCALTriggerElectronics)

//__________________
AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(const AliEMCALTriggerDCSConfig *dcsConf) : TObject(),
fTRU(new TClonesArray("AliEMCALTriggerTRU",32)),
fSTU(0x0)
{
	TVector2 rSize;
	
	rSize.Set( 24.,  4. );

	// 32 TRUs
	for (Int_t i=0;i<kNTRU;i++) 
	{
		AliEMCALTriggerTRUDCSConfig* truConf = dcsConf->GetTRUDCSConfig(i);
		new ((*fTRU)[i]) AliEMCALTriggerTRU(truConf, rSize, i % 2);
	}
	
	rSize.Set( 48., 64. );
	
	// 1 STU
	AliEMCALTriggerSTUDCSConfig* stuConf = dcsConf->GetSTUDCSConfig();
	fSTU = new AliEMCALTriggerSTU(stuConf, rSize);
	
	TString str = "map";
	for (Int_t i=0;i<kNTRU;i++) fSTU->Build(str,
											i,
											(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Map(),
											(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize() 
										    );
}

//________________
AliEMCALTriggerElectronics::~AliEMCALTriggerElectronics()
{
	//
	fTRU->Delete();
 	delete fSTU;
}

//__________________
void AliEMCALTriggerElectronics::Digits2Trigger(TClonesArray* digits, const Int_t V0M[], AliEMCALTriggerData* data)
{
	//
	AliEMCALGeometry* geom = 0x0;
	
	AliRunLoader *rl = AliRunLoader::Instance();
	if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")){
	  AliEMCAL* emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
	  if(emcal)geom = emcal->GetGeometry();
	}
	
	if(!geom) geom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
	
	if(!geom) AliError("Cannot access geometry!");
	
	//	digits->Sort();
	
	Int_t region[48][64], posMap[48][64];
	for (Int_t i = 0; i < 48; i++) for (Int_t j = 0; j < 64; j++) 
	{
		region[i][j] =  0;
		posMap[i][j] = -1;
	}
	
	for (Int_t i = 0; i < digits->GetEntriesFast(); i++)
	{
		AliEMCALTriggerRawDigit* digit = (AliEMCALTriggerRawDigit*)digits->At(i);
		
		Int_t id = digit->GetId();
		
		Int_t iTRU, iADC;
		
		Bool_t isOK1 = geom->GetTRUFromAbsFastORIndex(id, iTRU, iADC);
		
		for (Int_t j = 0; j < digit->GetNSamples(); j++)
		{
			Int_t time, amp;
			Bool_t isOK2 = digit->GetTimeSample(j, time, amp);
			
			if (isOK1 && isOK2 && amp) (static_cast<AliEMCALTriggerTRU*>(fTRU->At(iTRU)))->SetADC(iADC, time, amp);
		}
		
		Int_t px, py;
		if (geom->GetPositionInEMCALFromAbsFastORIndex(id, px, py))
		{
			posMap[px][py] = i;
			
			if (fSTU->GetRawData() && digit->GetL1TimeSum() >= 0) 
			{
				region[px][py] = digit->GetL1TimeSum();
			}
		}
	}

	Int_t iL0 = 0;

	for (Int_t i=0; i<kNTRU; i++) 
	{
		AliDebug(999, Form("===========< TRU %2d >============\n", i));
		
		AliEMCALTriggerTRU* iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));

		// L0 is always computed from F-ALTRO
		if (iTRU->L0()) 
		{
			iL0 += iTRU->L0();
			
			Int_t sizeX = (Int_t) ((iTRU->PatchSize())->X() * (iTRU->SubRegionSize())->X());
			
			Int_t sizeY = (Int_t) ((iTRU->PatchSize())->Y() * (iTRU->SubRegionSize())->Y());
			
			// transform local to global 
			TIter Next(&iTRU->Patches());
			while (AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)Next())
			{
				Int_t px, py, id; p->Position(px, py);
				
				if (geom->GetAbsFastORIndexFromPositionInTRU(i, px, py, id) 
					&& 
					geom->GetPositionInEMCALFromAbsFastORIndex(id, px, py)) p->SetPosition(px, py);
				
				if (!data->GetMode())
				{
					Int_t peaks = p->Peaks();
					
					for (Int_t j = 0; j < sizeX * sizeY; j++)
					{
						if (peaks & (1 << j))
						{
							
							Int_t pos = posMap[px + j % sizeX][py + j / sizeX];
							
//							cout << "px: " << px << " py: " << py << " j: " << j << " mod: " << j%sizeX << " ratio: " << j / sizeX << " pos: " << pos << endl;
							
							AliEMCALTriggerRawDigit* dig = 0x0;
							
							if (pos == -1)
							{
								new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
								
								dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
							}
							else
							{
								dig = (AliEMCALTriggerRawDigit*)digits->At(pos);
							}
							
							dig->SetL0Time(p->Time());
						}
					}								
				}
			}
			
			data->SetL0Trigger(0, i, 1);
						
	        data->SetPatches(kL0, 0, iTRU->Patches());
		}
		else
			data->SetL0Trigger(0, i, 0);
	}

	// A L0 has been issued, run L1
	// Depending on raw data enabled or not in STU data: L1 computation 
	// should be done from F-ALTRO or directly on TRU time sums in STU raw data
	if (iL0) 
	{
		// Use L1 threshold from raw data when reconstructing raw data
		if (data->GetMode())
		{
			fSTU->SetThreshold(kL1Gamma, data->GetL1GammaThreshold());
			fSTU->SetThreshold(kL1Jet,   data->GetL1JetThreshold()  );			
		}
		else
		{
			fSTU->ComputeThFromV0(V0M); // C/A
			data->SetL1GammaThreshold(fSTU->GetThreshold(kL1Gamma));
			data->SetL1JetThreshold(  fSTU->GetThreshold(kL1Jet)  );
		}
		
		if (fSTU->GetRawData())
		{
			// Compute L1 from STU raw data
			fSTU->SetRegion(region);
		}
		else
		{
			// Build STU raw data from F-ALTRO
			TString str = "region";
			for (Int_t i = 0; i < kNTRU; i++) fSTU->Build(str,
														  i, 
														  (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Region(), 
														  (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize());
		}

		fSTU->L1(kL1Gamma);
		
		data->SetPatches(kL1Gamma, 0, fSTU->Patches());

		fSTU->Reset();

		fSTU->L1(kL1Jet);
		
		data->SetPatches(kL1Jet,   0, fSTU->Patches());
		
		Int_t** reg = fSTU->Region();
		
		if (!fSTU->GetRawData())
		{
			// Update digits w/ L1 time sum
			// Done in raw digit maker when raw data enabled
			for (Int_t i = 0; i < 48; i++)
			{
				for (Int_t j = 0; j < 64; j++)
				{
					if (reg[i][j])
					{
						Int_t id;
						if (geom->GetAbsFastORIndexFromPositionInEMCAL(i, j, id))
						{
							AliEMCALTriggerRawDigit* dig = 0x0;

							if (posMap[i][j] == -1)
							{
								// Add a new digit with L1 time sum
								new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
								
								dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
							} 
							else
							{
								dig = (AliEMCALTriggerRawDigit*)digits->At(posMap[i][j]);								
							}
							
							dig->SetL1TimeSum(reg[i][j]);
						}
					}
				}
			}
		}
	}

	if (AliDebugLevel() >= 999) data->Scan();
	
	// Now reset the electronics for a fresh start with next event
	Reset();
}

//__________________
void AliEMCALTriggerElectronics::Reset()
{
	//
	TIter NextTRU(fTRU);
	while ( AliEMCALTriggerTRU *TRU = (AliEMCALTriggerTRU*)NextTRU() ) TRU->Reset();
	
	fSTU->Reset();
}
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	EMCal trigger electronics manager L0/L1
	20	can handle both simulated digits and raw data
	21	Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
	22	*/
	23
	24	#include "AliEMCALTriggerElectronics.h"
	25	#include "AliEMCALTriggerTRU.h"
	26	#include "AliEMCALTriggerSTU.h"
	27	#include "AliEMCALGeometry.h"
	28	#include "AliRunLoader.h"
	29	#include "AliEMCAL.h"
	30	#include "AliRun.h"
fff39dd1	31	#include "AliEMCALTriggerDCSConfig.h"
916f1e76	32	#include "AliEMCALTriggerData.h"
	33	#include "AliEMCALDigit.h"
	34	#include "AliCaloRawStreamV3.h"
916f1e76	35	#include "AliEMCALTriggerSTURawStream.h"
916f1e76	36	#include "AliEMCALDigit.h"
de39a0ff	37	#include "AliEMCALTriggerRawDigit.h"
de39a0ff	38	#include "AliEMCALTriggerPatch.h"
916f1e76	39
	40	#include <TVector2.h>
	41	#include <TClonesArray.h>
916f1e76	42
	43	namespace
	44	{
	45	const Int_t kNTRU = 32;
	46	}
	47
	48	ClassImp(AliEMCALTriggerElectronics)
	49
	50	//__________________
fff39dd1	51	AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(const AliEMCALTriggerDCSConfig *dcsConf) : TObject(),
916f1e76	52	fTRU(new TClonesArray("AliEMCALTriggerTRU",32)),
	53	fSTU(0x0)
	54	{
	55	TVector2 rSize;
	56
	57	rSize.Set( 24., 4. );
	58
	59	// 32 TRUs
fff39dd1	60	for (Int_t i=0;i<kNTRU;i++)
	61	{
	62	AliEMCALTriggerTRUDCSConfig* truConf = dcsConf->GetTRUDCSConfig(i);
de39a0ff	63	new ((*fTRU)[i]) AliEMCALTriggerTRU(truConf, rSize, i % 2);
fff39dd1	64	}
fff39dd1	65
916f1e76	66	rSize.Set( 48., 64. );
	67
	68	// 1 STU
fff39dd1	69	AliEMCALTriggerSTUDCSConfig* stuConf = dcsConf->GetSTUDCSConfig();
fff39dd1	70	fSTU = new AliEMCALTriggerSTU(stuConf, rSize);
916f1e76	71
de39a0ff	72	TString str = "map";
	73	for (Int_t i=0;i<kNTRU;i++) fSTU->Build(str,
	74	i,
	75	(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Map(),
	76	(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize()
	77	);
916f1e76	78	}
	79
	80	//________________
	81	AliEMCALTriggerElectronics::~AliEMCALTriggerElectronics()
	82	{
	83	//
	84	fTRU->Delete();
	85	delete fSTU;
	86	}
	87
	88	//__________________
de39a0ff	89	void AliEMCALTriggerElectronics::Digits2Trigger(TClonesArray* digits, const Int_t V0M[], AliEMCALTriggerData* data)
916f1e76	90	{
	91	//
	92	AliEMCALGeometry* geom = 0x0;
	93
	94	AliRunLoader *rl = AliRunLoader::Instance();
a51e676d	95	if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")){
	96	AliEMCAL* emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
	97	if(emcal)geom = emcal->GetGeometry();
	98	}
	99
	100	if(!geom) geom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
	101
	102	if(!geom) AliError("Cannot access geometry!");
916f1e76	103
de39a0ff	104	// digits->Sort();
	105
	106	Int_t region[48][64], posMap[48][64];
	107	for (Int_t i = 0; i < 48; i++) for (Int_t j = 0; j < 64; j++)
	108	{
	109	region[i][j] = 0;
	110	posMap[i][j] = -1;
	111	}
	112
	113	for (Int_t i = 0; i < digits->GetEntriesFast(); i++)
916f1e76	114	{
de39a0ff	115	AliEMCALTriggerRawDigit* digit = (AliEMCALTriggerRawDigit*)digits->At(i);
	116
	117	Int_t id = digit->GetId();
	118
	119	Int_t iTRU, iADC;
	120
	121	Bool_t isOK1 = geom->GetTRUFromAbsFastORIndex(id, iTRU, iADC);
	122
	123	for (Int_t j = 0; j < digit->GetNSamples(); j++)
916f1e76	124	{
de39a0ff	125	Int_t time, amp;
de39a0ff	126	Bool_t isOK2 = digit->GetTimeSample(j, time, amp);
916f1e76	127
de39a0ff	128	if (isOK1 && isOK2 && amp) (static_cast<AliEMCALTriggerTRU*>(fTRU->At(iTRU)))->SetADC(iADC, time, amp);
	129	}
	130
	131	Int_t px, py;
	132	if (geom->GetPositionInEMCALFromAbsFastORIndex(id, px, py))
	133	{
	134	posMap[px][py] = i;
916f1e76	135
de39a0ff	136	if (fSTU->GetRawData() && digit->GetL1TimeSum() >= 0)
916f1e76	137	{
de39a0ff	138	region[px][py] = digit->GetL1TimeSum();
916f1e76	139	}
	140	}
	141	}
916f1e76	142
de39a0ff	143	Int_t iL0 = 0;
916f1e76	144
	145	for (Int_t i=0; i<kNTRU; i++)
	146	{
de39a0ff	147	AliDebug(999, Form("===========< TRU %2d >============\n", i));
916f1e76	148
de39a0ff	149	AliEMCALTriggerTRU* iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
916f1e76	150
de39a0ff	151	// L0 is always computed from F-ALTRO
de39a0ff	152	if (iTRU->L0())
916f1e76	153	{
de39a0ff	154	iL0 += iTRU->L0();
de39a0ff	155
ddd131cc	156	Int_t sizeX = (Int_t) ((iTRU->PatchSize())->X() * (iTRU->SubRegionSize())->X());
de39a0ff	157
ddd131cc	158	Int_t sizeY = (Int_t) ((iTRU->PatchSize())->Y() * (iTRU->SubRegionSize())->Y());
de39a0ff	159
	160	// transform local to global
	161	TIter Next(&iTRU->Patches());
	162	while (AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)Next())
	163	{
	164	Int_t px, py, id; p->Position(px, py);
	165
	166	if (geom->GetAbsFastORIndexFromPositionInTRU(i, px, py, id)
	167	&&
	168	geom->GetPositionInEMCALFromAbsFastORIndex(id, px, py)) p->SetPosition(px, py);
	169
	170	if (!data->GetMode())
	171	{
	172	Int_t peaks = p->Peaks();
	173
	174	for (Int_t j = 0; j < sizeX * sizeY; j++)
	175	{
	176	if (peaks & (1 << j))
	177	{
	178
	179	Int_t pos = posMap[px + j % sizeX][py + j / sizeX];
	180
	181	// cout << "px: " << px << " py: " << py << " j: " << j << " mod: " << j%sizeX << " ratio: " << j / sizeX << " pos: " << pos << endl;
	182
	183	AliEMCALTriggerRawDigit* dig = 0x0;
	184
	185	if (pos == -1)
	186	{
	187	new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
	188
	189	dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
	190	}
	191	else
	192	{
	193	dig = (AliEMCALTriggerRawDigit*)digits->At(pos);
	194	}
	195
	196	dig->SetL0Time(p->Time());
	197	}
	198	}
	199	}
	200	}
	201
	202	data->SetL0Trigger(0, i, 1);
	203
	204	data->SetPatches(kL0, 0, iTRU->Patches());
	205	}
	206	else
	207	data->SetL0Trigger(0, i, 0);
916f1e76	208	}
	209
	210	// A L0 has been issued, run L1
de39a0ff	211	// Depending on raw data enabled or not in STU data: L1 computation
	212	// should be done from F-ALTRO or directly on TRU time sums in STU raw data
	213	if (iL0)
916f1e76	214	{
de39a0ff	215	// Use L1 threshold from raw data when reconstructing raw data
	216	if (data->GetMode())
	217	{
	218	fSTU->SetThreshold(kL1Gamma, data->GetL1GammaThreshold());
	219	fSTU->SetThreshold(kL1Jet, data->GetL1JetThreshold() );
	220	}
	221	else
	222	{
	223	fSTU->ComputeThFromV0(V0M); // C/A
	224	data->SetL1GammaThreshold(fSTU->GetThreshold(kL1Gamma));
	225	data->SetL1JetThreshold( fSTU->GetThreshold(kL1Jet) );
	226	}
916f1e76	227
de39a0ff	228	if (fSTU->GetRawData())
	229	{
	230	// Compute L1 from STU raw data
	231	fSTU->SetRegion(region);
	232	}
	233	else
	234	{
	235	// Build STU raw data from F-ALTRO
	236	TString str = "region";
	237	for (Int_t i = 0; i < kNTRU; i++) fSTU->Build(str,
	238	i,
	239	(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Region(),
	240	(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize());
	241	}
916f1e76	242
de39a0ff	243	fSTU->L1(kL1Gamma);
916f1e76	244
de39a0ff	245	data->SetPatches(kL1Gamma, 0, fSTU->Patches());
916f1e76	246
	247	fSTU->Reset();
	248
de39a0ff	249	fSTU->L1(kL1Jet);
916f1e76	250
de39a0ff	251	data->SetPatches(kL1Jet, 0, fSTU->Patches());
	252
	253	Int_t** reg = fSTU->Region();
	254
	255	if (!fSTU->GetRawData())
	256	{
	257	// Update digits w/ L1 time sum
	258	// Done in raw digit maker when raw data enabled
	259	for (Int_t i = 0; i < 48; i++)
	260	{
	261	for (Int_t j = 0; j < 64; j++)
	262	{
	263	if (reg[i][j])
	264	{
	265	Int_t id;
	266	if (geom->GetAbsFastORIndexFromPositionInEMCAL(i, j, id))
	267	{
	268	AliEMCALTriggerRawDigit* dig = 0x0;
916f1e76	269
de39a0ff	270	if (posMap[i][j] == -1)
	271	{
	272	// Add a new digit with L1 time sum
	273	new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
	274
	275	dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
	276	}
	277	else
	278	{
	279	dig = (AliEMCALTriggerRawDigit*)digits->At(posMap[i][j]);
	280	}
	281
	282	dig->SetL1TimeSum(reg[i][j]);
	283	}
	284	}
	285	}
	286	}
	287	}
916f1e76	288	}
916f1e76	289
de39a0ff	290	if (AliDebugLevel() >= 999) data->Scan();
39c05eac	291
916f1e76	292	// Now reset the electronics for a fresh start with next event
	293	Reset();
	294	}
	295
	296	//__________________
	297	void AliEMCALTriggerElectronics::Reset()
	298	{
	299	//
	300	TIter NextTRU(fTRU);
	301	while ( AliEMCALTriggerTRU TRU = (AliEMCALTriggerTRU)NextTRU() ) TRU->Reset();
	302
	303	fSTU->Reset();
	304	}