TRD module
[u/mrichter/AliRoot.git] / TRD / TRDsim / AliTRDptrgCBB.cxx
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"
37 #include "AliLog.h"
38 ClassImp(AliTRDptrgCBB)
39
40 AliTRDptrgCBB::AliTRDptrgCBB(AliRunLoader *rl) 
41   : TObject(),
42   fRunLoader(rl),
43   fParam(0),
44   fOperatingMode(AliTRDptrgParam::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                              AliTRDptrgParam::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, AliTRDptrgParam::kA, operatingMode, param);
70   this->fCBC = new AliTRDptrgCBAC(rl, AliTRDptrgParam::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);
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
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>
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);
138     // the following lines are only needed for test reasons
139     Int_t* initData = new Int_t[4096]; // 2^12
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
146     }
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
153     }
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 
161     }
162     delete [] initData;
163
164     AliTRDptrgParam::AliTRDptrgPTmasks* masks = 
165       new AliTRDptrgParam::AliTRDptrgPTmasks();  
166     masks->fLUTs[0] = kTRUE;
167     masks->fLUTs[1] = kTRUE;
168     masks->fLUTs[2] = kTRUE;
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   
196   // combine partResults and create inputVectors  
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
214     AliTRDptrgLUT *lutTmp = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT]);
215     if (lutTmp) {
216       result[iLUT + 1] = lutTmp->LookUp(inputVector);
217     }
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   }
239   if (this->fPTmasks->fLUTs[2] && result[3]) { // CB-B (third own LUT)
240     result[nLUTs + 1]++;
241   }
242
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]));
250
251   delete [] partResults;
252
253   return result;
254
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 }