]>
Commit | Line | Data |
---|---|---|
f9720615 | 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 | /* $Id$ */ | |
17 | ||
18 | //////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Pre-Trigger Control-Box bottom class // | |
21 | // // | |
22 | // Authors: F. Reidt (Felix.Reidt@cern.ch) // | |
23 | // // | |
24 | //////////////////////////////////////////////////////////////////////////// | |
25 | ||
26 | ||
27 | #include "TROOT.h" | |
28 | ||
29 | #include "AliRun.h" | |
30 | #include "AliRunLoader.h" | |
31 | ||
32 | #include "AliTRDptrgLUT.h" | |
33 | #include "AliTRDptrgParam.h" | |
34 | #include "AliTRDptrgCBAC.h" | |
35 | #include "AliTRDptrgTLMU.h" | |
36 | #include "AliTRDptrgCBB.h" | |
c93255fe | 37 | #include "AliLog.h" |
f9720615 | 38 | ClassImp(AliTRDptrgCBB) |
39 | ||
40 | AliTRDptrgCBB::AliTRDptrgCBB(AliRunLoader *rl) | |
41 | : TObject(), | |
42 | fRunLoader(rl), | |
43 | fParam(0), | |
44 | fOperatingMode(kDigits), | |
45 | fCBA(0), | |
46 | fCBC(0), | |
47 | fTLMU(0), | |
48 | fLUTArray(0), | |
49 | fPTmasks(0x0) | |
50 | { | |
51 | // default ctor | |
52 | AliError("default ctor - usage not recommended\n"); | |
53 | } | |
54 | ||
55 | ||
56 | AliTRDptrgCBB::AliTRDptrgCBB(AliRunLoader *rl, AliTRDptrgParam* param, | |
57 | AliTRDptrgOperatingMode_t operatingMode) | |
58 | : TObject(), | |
59 | fRunLoader(rl), | |
60 | fParam(param), | |
61 | fOperatingMode(operatingMode), | |
62 | fCBA(0), | |
63 | fCBC(0), | |
64 | fTLMU(0), | |
65 | fLUTArray(0), | |
66 | fPTmasks(0x0) | |
67 | { | |
68 | // recommended ctor | |
69 | this->fCBA = new AliTRDptrgCBAC(rl, kA, operatingMode, param); | |
70 | this->fCBC = new AliTRDptrgCBAC(rl, kC, operatingMode, param); | |
71 | this->fTLMU = new AliTRDptrgTLMU(rl, param, operatingMode); | |
72 | ||
73 | this->LoadParams(); | |
74 | } | |
75 | ||
76 | AliTRDptrgCBB::~AliTRDptrgCBB() | |
77 | { | |
78 | // destructor | |
79 | ||
80 | if (this->fCBA != 0x0) { | |
81 | delete this->fCBA; | |
82 | this->fCBA = 0x0; | |
83 | } | |
84 | ||
85 | if (this->fCBC != 0x0) { | |
86 | delete this->fCBC; | |
87 | this->fCBC = 0x0; | |
88 | } | |
89 | ||
90 | if (this->fTLMU != 0x0) { | |
91 | delete this->fTLMU; | |
92 | this->fTLMU = 0x0; | |
93 | } | |
94 | ||
95 | this->fLUTArray.Delete(); | |
96 | } | |
97 | ||
98 | ||
99 | //______________________________________________________________________________ | |
100 | Bool_t AliTRDptrgCBB::LoadParams() | |
101 | { | |
102 | // load configuration parameters | |
103 | ||
104 | if (this->fParam != 0x0) { | |
105 | // read AliTRDptrgParam | |
106 | ||
107 | // get LUTs | |
108 | // 0 | |
109 | AliTRDptrgLUT* LUT = new AliTRDptrgLUT(); | |
110 | LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 0), kFALSE); | |
111 | // get CB-B_0 and do not copy lut content | |
112 | this->fLUTArray.AddLast(LUT); | |
113 | ||
114 | // 1 | |
115 | LUT = new AliTRDptrgLUT(); | |
116 | LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 1), kFALSE); | |
7788992c | 117 | // get CB-B_1 and do not copy lut content |
118 | this->fLUTArray.AddLast(LUT); | |
119 | ||
120 | // 2 | |
121 | LUT = new AliTRDptrgLUT(); | |
122 | LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 2), kFALSE); | |
123 | // get CB-B_2 and do not copy lut content | |
f9720615 | 124 | this->fLUTArray.AddLast(LUT); |
125 | ||
126 | // masks | |
127 | this->fPTmasks = this->fParam->GetPTmasks(); | |
128 | } | |
129 | else { | |
130 | // load default parameters | |
131 | // initialize LUTsoutputWidth=<value optimized out> | |
f21d3ce9 | 132 | AliTRDptrgLUT* lut = new AliTRDptrgLUT(); |
133 | this->fLUTArray.AddLast(lut); | |
134 | lut = new AliTRDptrgLUT(); // this->fRunLoader | |
135 | this->fLUTArray.AddLast(lut); | |
136 | lut = new AliTRDptrgLUT(); // this->fRunLoader | |
137 | this->fLUTArray.AddLast(lut); | |
f9720615 | 138 | // the following lines are only needed for test reasons |
f9720615 | 139 | Int_t* initData = new Int_t[4096]; // 2^12 |
f21d3ce9 | 140 | lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0)); |
141 | if (lut) { | |
142 | for (Int_t i = 0; i < 4096; i++ ) { | |
143 | initData[i] = i; | |
144 | } | |
145 | lut->InitTable(12, 12, initData, kTRUE); // make a copy | |
f9720615 | 146 | } |
f21d3ce9 | 147 | lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0)); |
148 | if (lut) { | |
149 | for (Int_t i = 0; i < 4096; i++ ) { | |
150 | initData[i] = i; | |
151 | } | |
152 | lut->InitTable(12, 12, initData, kTRUE); // make a copy | |
7788992c | 153 | } |
f21d3ce9 | 154 | lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1)); |
155 | if (lut) { | |
156 | //for (Int_t i = 4096; i >= 0; i--) { | |
157 | for (Int_t i = 4096; i > 0; i--) { | |
158 | initData[4096 - i] = i; // inverse ramp | |
159 | } | |
160 | lut->InitTable(12, 12, initData, kTRUE); // make a copy | |
f9720615 | 161 | } |
83c48644 | 162 | delete [] initData; |
f21d3ce9 | 163 | |
f9720615 | 164 | AliTRDptrgParam::AliTRDptrgPTmasks* masks = |
165 | new AliTRDptrgParam::AliTRDptrgPTmasks(); | |
166 | masks->fLUTs[0] = kTRUE; | |
167 | masks->fLUTs[1] = kTRUE; | |
7788992c | 168 | masks->fLUTs[2] = kTRUE; |
f9720615 | 169 | this->fPTmasks = masks; |
170 | } | |
171 | return false; | |
172 | } | |
173 | ||
174 | //______________________________________________________________________________ | |
175 | Int_t* AliTRDptrgCBB::Simulate() | |
176 | { | |
177 | // Simulate the CBB behavior of event | |
178 | // | |
179 | // returns array containing: | |
180 | // 0: array element count | |
181 | // 1..count-2: LUT results | |
182 | // count-1: pretrigger decision | |
183 | ||
184 | Int_t nLUTs = this->fLUTArray.GetEntries(); | |
185 | ||
186 | Int_t inputVector = 0x0; | |
187 | // initialize partResults | |
188 | Int_t** partResults = 0x0; | |
189 | partResults = new Int_t* [3]; // CB-A, CB-C, TLMU | |
190 | ||
191 | // get partResults | |
192 | partResults[0] = this->fCBA->Simulate(); // CB-A | |
193 | partResults[1] = this->fCBC->Simulate(); // CB-C | |
194 | partResults[2] = this->fTLMU->Simulate(); // TLMU | |
195 | ||
f9720615 | 196 | // combine partResults and create inputVectors |
f9720615 | 197 | Int_t mask = 0x1; |
198 | for (Int_t i = 0; i < 3 ; i++) { | |
199 | for (Int_t j = 1; j <= partResults[i][0]; j++) { | |
200 | if (partResults[i][j] > 0) { | |
201 | inputVector |= mask; // Add bit to the inputVector | |
202 | } | |
203 | mask <<= 1; | |
204 | } | |
205 | } | |
206 | ||
207 | AliDebug(5, Form("Inputvectors: 0x%x", inputVector)); | |
208 | ||
209 | // perform look up | |
210 | Int_t* result = new Int_t[nLUTs + 2]; // generate new return array | |
211 | result[0] = nLUTs + 1; // storage array length in the first array value | |
212 | for (Int_t iLUT = 0; iLUT < nLUTs; iLUT++) { | |
213 | // process the return value for each LUT and store the result in the array | |
f21d3ce9 | 214 | AliTRDptrgLUT *lutTmp = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT]); |
215 | if (lutTmp) { | |
216 | result[iLUT + 1] = lutTmp->LookUp(inputVector); | |
217 | } | |
f9720615 | 218 | AliDebug(4, Form("CBB result[%d] = 0x%x\n",(iLUT + 1),result[iLUT + 1])); |
219 | } | |
220 | ||
221 | // evaluate PT decision | |
222 | // stored in result[nLUTs + 1] | |
223 | result[nLUTs + 1] = 0; | |
224 | ||
225 | for (Int_t i = 0; i < 2; i++) { | |
226 | // CB-A | |
227 | if (this->fPTmasks->fCBA[i] && partResults[0][i + 1]) { | |
228 | result[nLUTs + 1]++; | |
229 | } | |
230 | // CB-C | |
231 | if (this->fPTmasks->fCBC[i] && partResults[1][i + 1]) { | |
232 | result[nLUTs + 1]++; | |
233 | } | |
234 | // CB-B (own LUTs) | |
235 | if (this->fPTmasks->fLUTs[i] && result[i + 1]) { | |
236 | result[nLUTs + 1]++; | |
237 | } | |
238 | } | |
7788992c | 239 | if (this->fPTmasks->fLUTs[2] && result[3]) { // CB-B (third own LUT) |
240 | result[nLUTs + 1]++; | |
241 | } | |
242 | ||
f9720615 | 243 | // TLMU |
244 | for (Int_t i = 0; i < 8; i++) { | |
245 | if (this->fPTmasks->fTLMU[i] && partResults[2][i + 1]) { | |
246 | result[nLUTs + 1]++; | |
247 | } | |
248 | } | |
249 | AliDebug(4, Form("CBB TRD Wake up result = %d", result[nLUTs + 1])); | |
f21d3ce9 | 250 | |
251 | delete [] partResults; | |
252 | ||
f9720615 | 253 | return result; |
f21d3ce9 | 254 | |
f9720615 | 255 | } |
256 | ||
257 | //______________________________________________________________________________ | |
258 | Bool_t AliTRDptrgCBB::GetPT() { | |
259 | // evaluates the pre trigger decision | |
260 | ||
261 | Int_t* LUTresults = this->Simulate(); | |
262 | if (LUTresults[(LUTresults[0] - 1)]) { | |
263 | delete[] LUTresults; | |
264 | return kTRUE; | |
265 | } | |
266 | else { | |
267 | delete[] LUTresults; | |
268 | return kFALSE; | |
269 | } | |
270 | } |