[u/mrichter/AliRoot.git] / HLT / MUON / macros / CreateTriggerRecoLookupTables.C

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * 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 macro is used to generate the lookup tables for the trigger reconstructor
 * component. All alignment and geometry data is taken from the CDB.
 */

#include <iostream>
#include <fstream>

#include "AliCDBManager.h"
#include "AliGeomManager.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONGeometryDetElement.h"
#include "AliMpCDB.h"
#include "AliMpDDLStore.h"
#include "AliMpPad.h"
#include "AliMpSegmentation.h"
#include "AliMpDEIterator.h"
#include "AliMpVSegmentation.h"
#include "AliMpDEManager.h"
#include "AliMpLocalBoard.h"
#include "AliMpTriggerCrate.h"
#include "AliHLTMUONDataTypes.h"

using namespace std;


struct TriggerRecoLookupTable
{
	// [regional header index][local board ID][chamber][cathode - X/Y][bit set in bit pattern]
	AliHLTMUONTriggerRecoLutRow fRow[8][16][4][2][16];
};


void CreateTriggerRecoLookupTables(const char* CDBpath = "local://$ALICE_ROOT")
{
	AliCDBManager* cdbManager = AliCDBManager::Instance();
	cdbManager->SetDefaultStorage(CDBpath);
	cdbManager->SetRun(0);
	AliGeomManager::LoadGeometry();
	
	AliMUONGeometryTransformer transformer;
	if (! transformer.LoadGeometryData())
	{
		cerr << "ERROR: Could not load geometry into transformer." << endl;
		return;
	}
	
	if (! AliMpCDB::LoadMpSegmentation())
	{
		cerr << "ERROR: Could not load segmentation mapping." << endl;
		return;
	}
	AliMpSegmentation* segmentation = AliMpSegmentation::Instance();
	if (segmentation == NULL)
	{
		cerr << "ERROR: AliMpSegmentation::Instance() was NULL." << endl;
		return;
	}
	if (! AliMpCDB::LoadDDLStore())
	{
		cerr << "ERROR: Could not load DDL mapping." << endl;
		return;
	}
	AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
	if (ddlStore == NULL)
	{
		cerr << "ERROR: AliMpDDLStore::Instance() was NULL." << endl;
		return;
	}
	
	cout << "Building LUTs..." << endl;
	
	TriggerRecoLookupTable* lookupTable21 = new TriggerRecoLookupTable;
	TriggerRecoLookupTable* lookupTable22 = new TriggerRecoLookupTable;
	
	for (Int_t i = 0; i < 8; i++)
	for (Int_t j = 0; j < 16; j++)
	for (Int_t k = 0; k < 4; k++)
	for (Int_t n = 0; n < 2; n++)
	for (Int_t m = 0; m < 16; m++)
	{
		lookupTable21->fRow[i][j][k][n][m].fX = 0;
		lookupTable21->fRow[i][j][k][n][m].fY = 0;
		lookupTable21->fRow[i][j][k][n][m].fZ = 0;
		lookupTable22->fRow[i][j][k][n][m].fX = 0;
		lookupTable22->fRow[i][j][k][n][m].fY = 0;
		lookupTable22->fRow[i][j][k][n][m].fZ = 0;
	}
	
	AliMpDEIterator detElemIter;
	for (Int_t iDDL = 20; iDDL <= 21; iDDL++)
	{
		for (Int_t iReg = 0; iReg < 8; iReg++)
		{
			AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(iDDL, iReg);
			if (crate == NULL)
			{
				cerr << "ERROR: Could not get crate for regional header = " << iReg
					<< ", and DDL ID = " << iDDL << endl;
				continue;
			}
			
			for (Int_t iLocBoard = 0; iLocBoard < 16; iLocBoard++)
			{
				Int_t boardId = crate->GetLocalBoardId(iLocBoard);
				if (boardId == 0) continue;
				
				AliMpLocalBoard* localBoard = ddlStore->GetLocalBoard(boardId);
				if (localBoard == NULL)
				{
					cerr << "ERROR: Could not get loacl board: " << boardId << endl;
					continue;
				}

				// skip copy cards
				if (! localBoard->IsNotified()) continue;
			
				for (Int_t iChamber = 0; iChamber < 4; iChamber++)
				{
					Int_t detElemId = ddlStore->GetDEfromLocalBoard(boardId, iChamber);
					
					const AliMUONGeometryDetElement* detElemTransform = transformer.GetDetElement(detElemId);
					if (detElemTransform == NULL)
					{
						cerr << "ERROR: Got NULL pointer for geometry transformer for detection element ID = "
							<< detElemId << endl;
						continue;
					}
					
					for (Int_t iCathode = 0; iCathode <= 1; iCathode++)
					{
						const AliMpVSegmentation* seg = segmentation->GetMpSegmentation(
								detElemId, AliMp::GetCathodType(iCathode)
							);
						
						for (Int_t bitxy = 0; bitxy < 16; bitxy++)
						{
							Int_t offset = 0;
							if (iCathode && localBoard->GetSwitch(6)) offset = -8;
							
							AliMpPad pad = seg->PadByLocation(AliMpIntPair(boardId, bitxy+offset), kFALSE);
						
							if (! pad.IsValid())
							{
								// There is no pad associated with the given local board and bit pattern.
								continue;
							}
							
							// Get the global coodinates of the pad.
							Float_t lx = pad.Position().X();
							Float_t ly = pad.Position().Y();
							Float_t gx, gy, gz;
							detElemTransform->Local2Global(lx, ly, 0, gx, gy, gz);
							
							// Fill the LUT
							if (crate->GetDdlId() == 20)
							{
								lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fX = gx;
								lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fY = gy;
								lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fZ = gz;
							}
							else
							{
								lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fX = gx;
								lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fY = gy;
								lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fZ = gz;
							}
						}
					}
				}
			}
		}
	}
	
	fstream file;
	file.open("Lut21.dat", fstream::out | fstream::binary | fstream::trunc);
	if (file)
	{
		file.write((char*)lookupTable21, sizeof(TriggerRecoLookupTable));
		if (! file)
		{
			cerr << "ERROR: There was a problem writing to file Lut21.dat" << endl;
		}
		file.close();
	}
	else
	{
		cerr << "ERROR: Could not open file Lut21.dat for writing." << endl;
	}
	
	file.open("Lut22.dat", fstream::out | fstream::binary | fstream::trunc);
	if (file)
	{
		file.write((char*)lookupTable22, sizeof(TriggerRecoLookupTable));
		if (! file)
		{
			cerr << "ERROR: There was a problem writing to file Lut22.dat" << endl;
		}
		file.close();
	}
	else
	{
		cerr << "ERROR: Could not open file Lut22.dat for writing." << endl;
	}
	
	delete lookupTable21;
	delete lookupTable22;
}
Commit	Line	Data
86665942	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* All rights reserved. *
	4	* *
	5	* Primary Authors: *
b39b98c8	6	* Artur Szostak <artursz@iafrica.com> *
86665942	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
b39b98c8	17	/**
	18	* This macro is used to generate the lookup tables for the trigger reconstructor
	19	* component. All alignment and geometry data is taken from the CDB.
	20	*/
86665942	21
b39b98c8	22	#include <iostream>
b39b98c8	23	#include <fstream>
86665942	24
86665942	25	#include "AliCDBManager.h"
b39b98c8	26	#include "AliGeomManager.h"
86665942	27	#include "AliMUONGeometryTransformer.h"
86665942	28	#include "AliMUONGeometryDetElement.h"
b39b98c8	29	#include "AliMpCDB.h"
b39b98c8	30	#include "AliMpDDLStore.h"
86665942	31	#include "AliMpPad.h"
	32	#include "AliMpSegmentation.h"
	33	#include "AliMpDEIterator.h"
	34	#include "AliMpVSegmentation.h"
	35	#include "AliMpDEManager.h"
b39b98c8	36	#include "AliMpLocalBoard.h"
b39b98c8	37	#include "AliMpTriggerCrate.h"
6ec6a7c1	38	#include "AliHLTMUONDataTypes.h"
86665942	39
	40	using namespace std;
	41
	42
b39b98c8	43	struct TriggerRecoLookupTable
	44	{
	45	// [regional header index][local board ID][chamber][cathode - X/Y][bit set in bit pattern]
6ec6a7c1	46	AliHLTMUONTriggerRecoLutRow fRow[8][16][4][2][16];
b39b98c8	47	};
86665942	48
86665942	49
b39b98c8	50	void CreateTriggerRecoLookupTables(const char* CDBpath = "local://$ALICE_ROOT")
	51	{
	52	AliCDBManager* cdbManager = AliCDBManager::Instance();
	53	cdbManager->SetDefaultStorage(CDBpath);
	54	cdbManager->SetRun(0);
	55	AliGeomManager::LoadGeometry();
86665942	56
b39b98c8	57	AliMUONGeometryTransformer transformer;
	58	if (! transformer.LoadGeometryData())
	59	{
	60	cerr << "ERROR: Could not load geometry into transformer." << endl;
	61	return;
	62	}
	63
	64	if (! AliMpCDB::LoadMpSegmentation())
	65	{
	66	cerr << "ERROR: Could not load segmentation mapping." << endl;
	67	return;
	68	}
	69	AliMpSegmentation* segmentation = AliMpSegmentation::Instance();
	70	if (segmentation == NULL)
	71	{
	72	cerr << "ERROR: AliMpSegmentation::Instance() was NULL." << endl;
	73	return;
	74	}
	75	if (! AliMpCDB::LoadDDLStore())
	76	{
	77	cerr << "ERROR: Could not load DDL mapping." << endl;
	78	return;
	79	}
	80	AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
	81	if (ddlStore == NULL)
	82	{
	83	cerr << "ERROR: AliMpDDLStore::Instance() was NULL." << endl;
	84	return;
	85	}
	86
	87	cout << "Building LUTs..." << endl;
	88
	89	TriggerRecoLookupTable* lookupTable21 = new TriggerRecoLookupTable;
	90	TriggerRecoLookupTable* lookupTable22 = new TriggerRecoLookupTable;
	91
	92	for (Int_t i = 0; i < 8; i++)
	93	for (Int_t j = 0; j < 16; j++)
	94	for (Int_t k = 0; k < 4; k++)
	95	for (Int_t n = 0; n < 2; n++)
	96	for (Int_t m = 0; m < 16; m++)
	97	{
	98	lookupTable21->fRow[i][j][k][n][m].fX = 0;
	99	lookupTable21->fRow[i][j][k][n][m].fY = 0;
	100	lookupTable21->fRow[i][j][k][n][m].fZ = 0;
	101	lookupTable22->fRow[i][j][k][n][m].fX = 0;
	102	lookupTable22->fRow[i][j][k][n][m].fY = 0;
	103	lookupTable22->fRow[i][j][k][n][m].fZ = 0;
	104	}
	105
	106	AliMpDEIterator detElemIter;
	107	for (Int_t iDDL = 20; iDDL <= 21; iDDL++)
	108	{
	109	for (Int_t iReg = 0; iReg < 8; iReg++)
	110	{
	111	AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(iDDL, iReg);
	112	if (crate == NULL)
	113	{
	114	cerr << "ERROR: Could not get crate for regional header = " << iReg
	115	<< ", and DDL ID = " << iDDL << endl;
	116	continue;
	117	}
	118
	119	for (Int_t iLocBoard = 0; iLocBoard < 16; iLocBoard++)
	120	{
121	Int_t boardId = crate->GetLocalBoardId(iLocBoard);
122	if (boardId == 0) continue;
123
124	AliMpLocalBoard* localBoard = ddlStore->GetLocalBoard(boardId);
125	if (localBoard == NULL)
126	{
127	cerr << "ERROR: Could not get loacl board: " << boardId << endl;
128	continue;
129	}
130
131	// skip copy cards
132	if (! localBoard->IsNotified()) continue;
133
134	for (Int_t iChamber = 0; iChamber < 4; iChamber++)
135	{
136	Int_t detElemId = ddlStore->GetDEfromLocalBoard(boardId, iChamber);
137
138	const AliMUONGeometryDetElement* detElemTransform = transformer.GetDetElement(detElemId);
139	if (detElemTransform == NULL)
140	{
141	cerr << "ERROR: Got NULL pointer for geometry transformer for detection element ID = "
142	<< detElemId << endl;
143	continue;
144	}
145
146	for (Int_t iCathode = 0; iCathode <= 1; iCathode++)
147	{
148	const AliMpVSegmentation* seg = segmentation->GetMpSegmentation(
149	detElemId, AliMp::GetCathodType(iCathode)
150	);
151
152	for (Int_t bitxy = 0; bitxy < 16; bitxy++)
153	{
154	Int_t offset = 0;
155	if (iCathode && localBoard->GetSwitch(6)) offset = -8;
156
157	AliMpPad pad = seg->PadByLocation(AliMpIntPair(boardId, bitxy+offset), kFALSE);
158
159	if (! pad.IsValid())
160	{
161	// There is no pad associated with the given local board and bit pattern.
162	continue;
163	}
164
165	// Get the global coodinates of the pad.
166	Float_t lx = pad.Position().X();
167	Float_t ly = pad.Position().Y();
168	Float_t gx, gy, gz;
169	detElemTransform->Local2Global(lx, ly, 0, gx, gy, gz);
170
171	// Fill the LUT
172	if (crate->GetDdlId() == 20)
173	{
174	lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fX = gx;
175	lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fY = gy;
176	lookupTable21->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fZ = gz;
177	}
178	else
179	{
180	lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fX = gx;
181	lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fY = gy;
182	lookupTable22->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fZ = gz;
183	}
184	}
185	}
186	}
187	}
188	}
189	}
190
191	fstream file;
192	file.open("Lut21.dat", fstream::out \| fstream::binary \| fstream::trunc);
193	if (file)
194	{
195	file.write((char*)lookupTable21, sizeof(TriggerRecoLookupTable));
196	if (! file)
197	{
198	cerr << "ERROR: There was a problem writing to file Lut21.dat" << endl;
199	}
200	file.close();
201	}
86665942	202	else
b39b98c8	203	{
	204	cerr << "ERROR: Could not open file Lut21.dat for writing." << endl;
	205	}
86665942	206
b39b98c8	207	file.open("Lut22.dat", fstream::out \| fstream::binary \| fstream::trunc);
	208	if (file)
	209	{
	210	file.write((char*)lookupTable22, sizeof(TriggerRecoLookupTable));
	211	if (! file)
	212	{
	213	cerr << "ERROR: There was a problem writing to file Lut22.dat" << endl;
	214	}
	215	file.close();
	216	}
	217	else
	218	{
	219	cerr << "ERROR: Could not open file Lut22.dat for writing." << endl;
	220	}
	221
	222	delete lookupTable21;
	223	delete lookupTable22;
86665942	224	}