X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=EMCAL%2FAliEMCALTriggerElectronics.cxx;h=f4cd53f11c76a5c116d7c34e157717c8d878b77c;hb=a261d8929b8eaaed9022182dc7c0b129f4ed8cd4;hp=e78c6b010b618326c2ea2a31772f4010c0eb4f31;hpb=916f1e76c5ffee7c7ed6214b883f65b4b6df3adf;p=u%2Fmrichter%2FAliRoot.git

diff --git a/EMCAL/AliEMCALTriggerElectronics.cxx b/EMCAL/AliEMCALTriggerElectronics.cxx
index e78c6b010b6..f4cd53f11c7 100644
--- a/EMCAL/AliEMCALTriggerElectronics.cxx
+++ b/EMCAL/AliEMCALTriggerElectronics.cxx
@@ -28,181 +28,399 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include "AliRunLoader.h"
 #include "AliEMCAL.h" 
 #include "AliRun.h" 
+#include "AliEMCALTriggerDCSConfig.h"
 #include "AliEMCALTriggerData.h"
 #include "AliEMCALDigit.h"
 #include "AliCaloRawStreamV3.h"
-//#include "AliVZERORawStream.h"
 #include "AliEMCALTriggerSTURawStream.h"
 #include "AliEMCALDigit.h"
-#include "AliEMCALRawDigit.h"
+#include "AliEMCALTriggerRawDigit.h"
+#include "AliEMCALTriggerPatch.h"
+#include "AliEMCALTriggerSTUDCSConfig.h"
 
 #include <TVector2.h>
-#include <TClonesArray.h>
-//#include <Riostream.h>
 
 namespace
 {
-	const Int_t kNTRU = 32;
+	const Int_t kNTRU = 32; // TODO: kNTRU should be set to / replaced by  fGeometry->GetNTotalTRU() (total number of TRU for a given geom)  after adding 1 STU for DCAL
 }
 
 ClassImp(AliEMCALTriggerElectronics)
 
 //__________________
-AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(AliEMCALCalibData *calibData) : TObject(),
+AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(const AliEMCALTriggerDCSConfig *dcsConf) : TObject(),
 fTRU(new TClonesArray("AliEMCALTriggerTRU",32)),
-fSTU(0x0)
+fSTU(0x0),
+fGeometry(0)
 {
+	// Ctor
+	
 	TVector2 rSize;
 	
 	rSize.Set( 24.,  4. );
-
+	
+	AliRunLoader *rl = AliRunLoader::Instance();
+	if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL")) {
+		AliEMCAL *emcal = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"));
+		if (emcal) fGeometry = emcal->GetGeometry();
+	}
+	
+	if (!fGeometry) {		
+		fGeometry =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
+		AliError("Cannot access geometry, create a new default one!");
+	}
+	
 	// 32 TRUs
-	for (Int_t i=0;i<kNTRU;i++) new ((*fTRU)[i]) AliEMCALTriggerTRU(calibData, rSize, int(i/3) % 2);
-   
+	for (Int_t i = 0; i < kNTRU; i++) {
+                if(i>=(fGeometry->GetNTotalTRU())) continue; //  i <= kNTRU < 62. Prevents fTRU to go out of bonds with EMCALFirstYEARV1 of EMCALCompleteV1 (NTRU<32) TODO: fix the logic
+		AliEMCALTriggerTRUDCSConfig *truConf = dcsConf->GetTRUDCSConfig(fGeometry->GetOnlineIndexFromTRUIndex(i));
+		if (truConf) new ((*fTRU)[i]) AliEMCALTriggerTRU(truConf, rSize, i % 2);
+	}
+	
 	rSize.Set( 48., 64. );
 	
 	// 1 STU
-	fSTU = new AliEMCALTriggerSTU(calibData, rSize);
+	AliEMCALTriggerSTUDCSConfig* stuConf = dcsConf->GetSTUDCSConfig();
+	fSTU = new AliEMCALTriggerSTU(stuConf, rSize);
 	
-	for (Int_t i=0;i<kNTRU;i++) fSTU->BuildMap( i, 
-											  (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Map(), 
-											  (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize() 
-											  );
+	TString str = "map";
+	for (Int_t i = 0; i < kNTRU; i++) {
+		AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
+		if (!iTRU) continue;
+
+		fSTU->Build(str,
+					i,
+					iTRU->Map(),
+					iTRU->RegionSize() 
+					);
+	}
 }
 
 //________________
 AliEMCALTriggerElectronics::~AliEMCALTriggerElectronics()
 {
-	//
+	// Dtor
+	
 	fTRU->Delete();
  	delete fSTU;
 }
 
 //__________________
-void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, const TTree* treeV0, AliEMCALTriggerData* data)
+void AliEMCALTriggerElectronics::Digits2Trigger(TClonesArray* digits, const Int_t V0M[], AliEMCALTriggerData* data)
 {
-	//
-	AliEMCALGeometry* geom = 0x0;
+	// Digits to trigger
 	
-	AliRunLoader *rl = AliRunLoader::Instance();
-	if (rl->GetAliRun() && rl->GetAliRun()->GetDetector("EMCAL"))
-		geom = dynamic_cast<AliEMCAL*>(rl->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
-	else 
-		geom =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
+	Int_t pos, px, py, id; 
+	
+	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);
+		
+		id = digit->GetId();
+		
+		Int_t iTRU, iADC;
+		
+		Bool_t isOK1 = fGeometry->GetTRUFromAbsFastORIndex(id, iTRU, iADC);
+		
+		if (!isOK1) continue;
 
-	if (!geom) AliError("Cannot access geometry!");
+		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) {
+				AliDebug(999, Form("=== TRU# %2d ADC# %2d time# %2d signal %d ===", iTRU, iADC, time, amp));
+  				if(iTRU>32) continue; // kNTRU < iTRU < 62. Prevents fTRU to go out of bonds with DCAL TODO: add STU for DCAL and fix the logic 
+				AliEMCALTriggerTRU * etr = (static_cast<AliEMCALTriggerTRU*>(fTRU->At(iTRU)));
+				if (etr) {
+				  if (data->GetMode())
+				    etr->SetADC(iADC, time, 4 * amp);
+				  else
+				    etr->SetADC(iADC, time,     amp);
+				}
+			}
+		}
+		
+		if (fGeometry->GetPositionInEMCALFromAbsFastORIndex(id, px, py)) posMap[px][py] = i;
+	}
+
+	Int_t iL0 = 0;
+
+	Int_t timeL0[kNTRU] = {0}, timeL0min = 999;
 	
-	TIter NextDigit(digits);
-	while (AliEMCALRawDigit* digit = (AliEMCALRawDigit*)NextDigit())
+	for (Int_t i = 0; i < kNTRU; i++) 
 	{
-		if ( digit )
+		AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
+		if (!iTRU) continue;
+		
+		AliDebug(999, Form("===========< TRU %2d >============", i));
+		
+		if (iTRU->L0()) // L0 recomputation: *ALWAYS* done from FALTRO
 		{
-			Int_t id = digit->GetId();
+			iL0++;
 			
-//			digit->Print();
+			timeL0[i] = iTRU->GetL0Time();
 			
-			Int_t iTRU, iADC;
-			Bool_t isOK1 = geom->GetTRUFromAbsFastORIndex(id, iTRU, iADC);
+			if (!timeL0[i]) AliWarning(Form("TRU# %d has 0 trigger time",i));
 			
-			for (Int_t i = 0; i < digit->GetNSamples(); i++)
-			{
-				Int_t time, amp;
-				Bool_t isOK2 = digit->GetTimeSample(i, time, amp);
-				
-				if (isOK1 && isOK2 && amp) (static_cast<AliEMCALTriggerTRU*>(fTRU->At(iTRU)))->SetADC(iADC, time, amp);
-			}
+			if (timeL0[i] < timeL0min) timeL0min = timeL0[i];
+			
+			data->SetL0Trigger(0, i, 1); // TRU# i has issued a L0
 		}
+		else
+			data->SetL0Trigger(0, i, 0);
 	}
-	/*
-	for (Int_t i=0; i<kNTRU; i++) 
+
+	AliDebug(999, Form("=== %2d TRU (out of %2d) has issued a L0 / Min L0 time: %d", iL0, fTRU->GetEntriesFast(), timeL0min));
+	
+	AliEMCALTriggerRawDigit* dig = 0x0;
+	
+	if (iL0 && (!data->GetMode() || !fSTU->GetDCSConfig()->GetRawData())) 
 	{
-		printf("===========< TRU %2d >============\n",i);
-		(static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Scan();
-	}
-	*/
-	Int_t iL0 = 0;
+		// Update digits after L0 calculation
+		for (Int_t i = 0; i < kNTRU; i++)
+		{
+			AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
+			if (!iTRU) continue;
+			
+			Int_t reg[24][4];
+			for (int j = 0; j < 24; j++) for (int k = 0; k < 4; k++) reg[j][k] = 0;
+					
+			iTRU->GetL0Region(timeL0min, reg);
+			
+			for (int j = 0; j < iTRU->RegionSize()->X(); j++)
+			{
+				for (int k = 0; k < iTRU->RegionSize()->Y(); k++)
+				{
+					if (reg[j][k]
+						&& 
+						fGeometry->GetAbsFastORIndexFromPositionInTRU(i, j, k, id)
+						&&
+						fGeometry->GetPositionInEMCALFromAbsFastORIndex(id, px, py))
+					{
+						pos = posMap[px][py];
+									
+						if (pos == -1)
+						{
+							// Add a new digit
+							posMap[px][py] = digits->GetEntriesFast();
 
-	// At this point all FastOR are available for digitization
-	// digitization is done in the TRU and produces time samples
-	// Now run the trigger algo & consecutively write trigger outputs in TreeD dedicated branch
+							new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
+										
+							dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);							
+						}
+						else
+						{
+							dig = (AliEMCALTriggerRawDigit*)digits->At(pos);
+						}
+						
+						// 14b to 12b STU time sums
+						reg[j][k] >>= 2; 
+						
+						dig->SetL1TimeSum(reg[j][k]);
+					}
+				}
+			}
+		}
+	}
 
-	for (Int_t i=0; i<kNTRU; i++) 
+	if (iL0 && !data->GetMode())
 	{
-		AliDebug(1,Form("===========< TRU %2d >============\n",i));
-		
-		AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
+		for (Int_t i = 0; i < kNTRU; i++)
+		{
+			AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
+			if (!iTRU) continue;
+			
+			AliDebug(999, Form("=== TRU# %2d found %d patches", i, (iTRU->Patches()).GetEntriesFast()));
+			
+			TIter next(&iTRU->Patches());
+			while (AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)next())
+			{
+				p->Position(px, py);
+			
+				// Local 2 Global
+				if (fGeometry->GetAbsFastORIndexFromPositionInTRU(i, px, py, id) 
+					&& 
+					fGeometry->GetPositionInEMCALFromAbsFastORIndex(id, px, py)) p->SetPosition(px, py);
+				
+				if (AliDebugLevel()) p->Print("");
+				
+				Int_t peaks = p->Peaks();
+								
+				Int_t sizeX = (Int_t) ((iTRU->PatchSize())->X() * (iTRU->SubRegionSize())->X());
+				Int_t sizeY = (Int_t) ((iTRU->PatchSize())->Y() * (iTRU->SubRegionSize())->Y());
+					
+				for (Int_t j = 0; j < sizeX * sizeY; j++)
+				{
+					if (peaks & (1 << j))
+					{
+						pos = posMap[px + j % sizeX][py + j / sizeX];
+							
+						if (pos == -1) {
+							// Add a new digit
+							posMap[px + j % sizeX][py + j / sizeX] = digits->GetEntriesFast();
 
-	  	iL0 += iTRU->L0v1();
+							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());
+					}
+				}
+					
+				pos = posMap[px][py];
+					
+				if (pos == -1) {
+					// Add a new digit
+					posMap[px][py] = digits->GetEntriesFast();
 
-		Int_t vL0Peaks[96][2]; iTRU->Peaks( vL0Peaks );
+					new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
+						
+					dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
+					
+				}
+				else
+				{
+					dig = (AliEMCALTriggerRawDigit*)digits->At(pos);
+				}
+					
+				dig->SetTriggerBit(kL0, 0);
+			}
+		}
+	}
+	
+	// Prepare STU for L1 calculation
+	for (int i = 0; i < (fSTU->RegionSize())->X(); i++) {
+		for (int j = 0; j < (fSTU->RegionSize())->Y(); j++) {
 			
-	   	data->SetL0Patches( i , iTRU->Patches() );			
-		data->SetL0Peaks(   i , vL0Peaks );
-
-		if ( !i ) // do it once since identical for all TRU 
-		{
-			data->SetL0RegionSize(    *iTRU->RegionSize()    );
-			data->SetL0SubRegionSize( *iTRU->SubRegionSize() );
-	        data->SetL0PatchSize(     *iTRU->PatchSize()     );
-		} 
+			pos = posMap[i][j];
 		
-		// 		if ( i == 31 ) i = 35;
-		//
-		// 		if ( ( i / 3 ) % 2 ) {
-		// 			TRU->Print( 15 - 2 + ( i - int( i / 3 ) * 3 ) - 3 * ( (i / 3) / 2 ) , runLoader->GetEventNumber() );
-		// 			printf("print data of TRU: from %2d to %2d\n",i,15 - 2 + ( i - int( i / 3 ) * 3 ) - 3 * ( (i / 3) / 2));
-		// 		}
-		// 		else
-		// 		{
-		// 			TRU->Print( 31 - i % 3 - 3 * ( (i / 3) / 2 ) , runLoader->GetEventNumber() );
-		// 			printf("print data of TRU: from %2d to %2d\n",i,31 - i % 3 - 3 * ( (i / 3) / 2 ));
-		// 		}		
+			if (pos >= 0) {
+				
+				AliEMCALTriggerRawDigit *digit = (AliEMCALTriggerRawDigit*)digits->At(pos);
+		
+				if (digit->GetL1TimeSum() > -1) region[i][j] = digit->GetL1TimeSum();
+			}
+		}
 	}
-
-	// A L0 has been issued, run L1
-	if ( iL0 ) 
+	
+	AliDebug(999,"==================== STU  ====================");
+	if (AliDebugLevel() >= 999) fSTU->Scan();
+	AliDebug(999,"==============================================");
+	
+	fSTU->SetRegion(region);
+	
+	if (data->GetMode()) 
+	{
+		for (int ithr = 0; ithr < 2; ithr++) {
+			AliDebug(999, Form(" THR %d / EGA %d / EJE %d", ithr, data->GetL1GammaThreshold(ithr), data->GetL1JetThreshold(ithr)));
+							   
+			fSTU->SetThreshold(kL1GammaHigh + ithr, data->GetL1GammaThreshold(ithr));
+			fSTU->SetThreshold(kL1JetHigh + ithr, data->GetL1JetThreshold(  ithr));
+		}
+	}
+	else
 	{
-		for (Int_t i=0; i<kNTRU; i++) fSTU->FetchFOR( i, 
-												    (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Region(), 
-												    (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize() 
-												    );
+		for (int ithr = 0; ithr < 2; ithr++) {
+			//
+			fSTU->ComputeThFromV0(kL1GammaHigh + ithr, V0M); 
+			data->SetL1GammaThreshold(ithr, fSTU->GetThreshold(kL1GammaHigh + ithr));
+			
+			fSTU->ComputeThFromV0(kL1JetHigh + ithr,   V0M);
+			data->SetL1JetThreshold(ithr, fSTU->GetThreshold(kL1JetHigh + ithr)  );
+			
+			AliDebug(999, Form("STU THR %d EGA %d EJE %d", ithr, fSTU->GetThreshold(kL1GammaHigh + ithr), fSTU->GetThreshold(kL1JetHigh + ithr)));
+		}
+	}
 
-//		fSTU->Scan();
+	for (int ithr = 0; ithr < 2; ithr++) {
+		//
+		fSTU->Reset();
 		
-		TTree* tr = const_cast<TTree*>(treeV0);
-		if ( tr ) fSTU->V0Multiplicity( *tr );
-
-		TVector2 size;
-
-		size.Set( 1. , 1. );
-		fSTU->SetSubRegionSize( size ); data->SetL1GammaSubRegionSize( size );
+		fSTU->L1(kL1GammaHigh + ithr);
+		
+		TIterator* nP = 0x0;
+		
+		nP = (fSTU->Patches()).MakeIterator();
+		
+		AliDebug(999, Form("=== STU found %d gamma patches", (fSTU->Patches()).GetEntriesFast()));
+		
+		while (AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)nP->Next()) 
+		{			
+			p->Position(px, py);
+			
+			if (AliDebugLevel()) p->Print("");
+			
+			if (fGeometry->GetAbsFastORIndexFromPositionInEMCAL(px, py, id))
+			{
+				if (posMap[px][py] == -1)
+				{
+					posMap[px][py] = digits->GetEntriesFast();
+					
+					// Add a new digit
+					new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
+					
+					dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
+				} 
+				else
+				{
+					dig = (AliEMCALTriggerRawDigit*)digits->At(posMap[px][py]);								
+				}
+				
+				if (AliDebugLevel()) dig->Print("");
+				
+				dig->SetTriggerBit(kL1GammaHigh + ithr, 0);
+			}
+		}
 		
-		size.Set( 2. , 2. );
-		fSTU->SetPatchSize( size );     data->SetL1GammaPatchSize(     size );
-
-		fSTU->L1( kGamma );
-
-		data->SetL1GammaPatches(       fSTU->Patches()       );
-
 		fSTU->Reset();
-
-		size.Set( 4. , 4. ); 
-		fSTU->SetSubRegionSize( size ); data->SetL1JetSubRegionSize( size );
 		
-		size.Set( 2. , 2. ); 
-		fSTU->SetPatchSize( size );     data->SetL1JetPatchSize(     size );
-
-		fSTU->L1( kJet );
-
-		data->SetL1JetPatches(         fSTU->Patches()       );
-		data->SetL1RegionSize(        *fSTU->RegionSize()    );
-
-		Int_t** region = fSTU->Region();
-		data->SetL1Region(      region      );
-		const Int_t* mv0 = fSTU->V0(); 
-		data->SetL1V0(          mv0         );
+		fSTU->L1(kL1JetHigh + ithr);
+		
+		nP = (fSTU->Patches()).MakeIterator();
+		
+		AliDebug(999, Form("=== STU found %d jet patches", (fSTU->Patches()).GetEntriesFast()));
+		
+		while (AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)nP->Next()) 
+		{			
+			p->Position(px, py);
+			
+			if (AliDebugLevel()) p->Print("");
+			
+			if (fGeometry->GetAbsFastORIndexFromPositionInEMCAL(px, py, id))
+			{
+				if (posMap[px][py] == -1)
+				{
+					posMap[px][py] = digits->GetEntriesFast();
+					
+					// Add a new digit
+					new((*digits)[digits->GetEntriesFast()]) AliEMCALTriggerRawDigit(id, 0x0, 0);
+					
+					dig = (AliEMCALTriggerRawDigit*)digits->At(digits->GetEntriesFast() - 1);
+				} 
+				else
+				{
+					dig = (AliEMCALTriggerRawDigit*)digits->At(posMap[px][py]);
+				}
+				
+				if (AliDebugLevel()) dig->Print("");
+				
+				dig->SetTriggerBit(kL1JetHigh + ithr, 0);
+			}
+		}
 	}
-
+	
 	// Now reset the electronics for a fresh start with next event
 	Reset();
 }
@@ -210,9 +428,10 @@ void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, cons
 //__________________
 void AliEMCALTriggerElectronics::Reset()
 {
-	//
-	TIter NextTRU(fTRU);
-	while ( AliEMCALTriggerTRU *TRU = (AliEMCALTriggerTRU*)NextTRU() ) TRU->Reset();
+	// Reset
+	
+	TIter nextTRU(fTRU);
+	while ( AliEMCALTriggerTRU *TRU = (AliEMCALTriggerTRU*)nextTRU() ) TRU->Reset();
 	
 	fSTU->Reset();
 }