1 | // ESAF : Euso Simulation and Analysis Framework |
---|
2 | // $Id: CellTrackingTrgEngine.cc 2920 2011-06-11 06:46:41Z mabl $ |
---|
3 | // M. Pallavicini created Oct, 24 2003 |
---|
4 | |
---|
5 | #include "CellTrackingTrgEngine.hh" |
---|
6 | #include "MacroCellData.hh" |
---|
7 | #include "TROOT.h" |
---|
8 | #include "TMarker.h" |
---|
9 | #include "TBox.h" |
---|
10 | #include "TCanvas.h" |
---|
11 | #include "TLine.h" |
---|
12 | #include "MacroCell.hh" |
---|
13 | #include "MacroCellHit.hh" |
---|
14 | #include "FrontEndChip.hh" |
---|
15 | #include "Photomultiplier.hh" |
---|
16 | #include "PmtGeometry.hh" |
---|
17 | #include <string> |
---|
18 | |
---|
19 | |
---|
20 | ClassImp(CellTrackingTrgEngine) |
---|
21 | |
---|
22 | //______________________________________________________________________________ |
---|
23 | CellTrackingTrgEngine::CellTrackingTrgEngine() : |
---|
24 | TriggerEngine(string("CellTrackingEngine"),kCellTrackingTrigger ) { |
---|
25 | // |
---|
26 | // Constructor |
---|
27 | // |
---|
28 | } |
---|
29 | |
---|
30 | |
---|
31 | //______________________________________________________________________________ |
---|
32 | CellTrackingTrgEngine::~CellTrackingTrgEngine() { |
---|
33 | // |
---|
34 | // Destructor |
---|
35 | // |
---|
36 | |
---|
37 | |
---|
38 | } |
---|
39 | |
---|
40 | //______________________________________________________________________________ |
---|
41 | void CellTrackingTrgEngine::Simulate( MacroCellData *pData ) { |
---|
42 | // |
---|
43 | // Do simulation |
---|
44 | // |
---|
45 | |
---|
46 | |
---|
47 | //get side of macrocell from config file --> alter to read from object |
---|
48 | Int_t l=(Int_t)Conf()->GetNum("CellTrackingTrgEngine.MacroSide"); |
---|
49 | Bool_t silent=(Bool_t)Conf()->GetNum("CellTrackingTrgEngine.Silent"); |
---|
50 | if (gROOT->IsBatch()) silent=true; |
---|
51 | Bool_t debug=(Bool_t)Conf()->GetNum("CellTrackingTrgEngine.Debug"); |
---|
52 | |
---|
53 | |
---|
54 | //catch a specific macrocell |
---|
55 | // if (silent) cout << "M#" << pData->Cell()->Id()<<" "<<flush; |
---|
56 | if (!silent) |
---|
57 | cout << "MACROCELL # "<<pData->Cell()->Id() <<" num hits="<<pData->NumMacroCellHits()<<endl; |
---|
58 | |
---|
59 | // if (pData->Cell()->Id() !=1) return; |
---|
60 | |
---|
61 | |
---|
62 | //catch macrocell not empty |
---|
63 | if (pData->IsEmpty()) |
---|
64 | { |
---|
65 | //cout << "nothing to do" << endl; |
---|
66 | return; |
---|
67 | } |
---|
68 | |
---|
69 | |
---|
70 | |
---|
71 | //__________________________________OBJECTS |
---|
72 | |
---|
73 | //create object to contain Wired or |
---|
74 | |
---|
75 | //X |
---|
76 | vector<vector<Bool_t> > WiredXGTU; |
---|
77 | vector<Bool_t> WiredX; |
---|
78 | //Y |
---|
79 | vector<vector<Bool_t> > WiredYGTU; |
---|
80 | vector<Bool_t> WiredY; |
---|
81 | |
---|
82 | //________________________________________ |
---|
83 | |
---|
84 | MacroCell *MCPARENT = pData->Cell(); //Parent Macrocell Pointer |
---|
85 | if (debug) cout<< "1"<<endl; |
---|
86 | |
---|
87 | //silent variables (display) |
---|
88 | Int_t minX; |
---|
89 | Int_t maxX; |
---|
90 | Int_t minY; |
---|
91 | Int_t maxY; |
---|
92 | TCanvas* MCD(0); |
---|
93 | map<Int_t,TMarker*> PMpix; |
---|
94 | |
---|
95 | if (debug) cout<< "2"<<endl; |
---|
96 | if (!silent){ |
---|
97 | //DISPLAY macrocell |
---|
98 | |
---|
99 | //create canvas |
---|
100 | char title [50]; |
---|
101 | sprintf(title,"Track Find Trigger - Macrocell #%d Display",pData->Cell()->Id()); |
---|
102 | |
---|
103 | MCD=new TCanvas("MCDisplay",title,1100,800); |
---|
104 | |
---|
105 | |
---|
106 | //draw macrocell according to PMTs |
---|
107 | |
---|
108 | const vector<Photomultiplier*>* PMTS =MCPARENT->Pmts(); |
---|
109 | //container for pixels : map (UID pixel) vs Pixel |
---|
110 | //silent map<Int_t,TMarker*> PMpix; |
---|
111 | |
---|
112 | |
---|
113 | // get min & max for canvas: start in PMO Pix0 |
---|
114 | |
---|
115 | minX=(Int_t)MCPARENT->GetPmt(0)->Geometry()->Position(0)[0]-10; |
---|
116 | maxX=(Int_t)MCPARENT->GetPmt(0)->Geometry()->Position(0)[0]+10; |
---|
117 | minY=(Int_t)MCPARENT->GetPmt(0)->Geometry()->Position(0)[1]-10; |
---|
118 | maxY=(Int_t)MCPARENT->GetPmt(0)->Geometry()->Position(0)[1]+10; |
---|
119 | |
---|
120 | |
---|
121 | //loop in PMTS |
---|
122 | for (Int_t PMTS_i=0;PMTS_i<(Int_t)PMTS->size(); PMTS_i++) |
---|
123 | { |
---|
124 | //get geometry |
---|
125 | Photomultiplier *PMT=(*PMTS)[PMTS_i]; |
---|
126 | PmtGeometry* PMgeo= PMT->Geometry(); |
---|
127 | |
---|
128 | //loop in pixels |
---|
129 | |
---|
130 | for (Int_t PMch=0;PMch<36;PMch++){ |
---|
131 | double pixX=PMgeo->Position(PMch)[0]; |
---|
132 | double pixY=PMgeo->Position(PMch)[1]; |
---|
133 | if (minX>pixX) minX=(Int_t)pixX-20; |
---|
134 | if (minY>pixY) minY=(Int_t)pixY-20; |
---|
135 | if (maxX<pixX) maxX=(Int_t)pixX+20; |
---|
136 | if (maxY<pixY) maxY=(Int_t)pixY+20; |
---|
137 | |
---|
138 | PMpix[PMgeo->GetUniqueId(PMch)]= new TMarker(pixX,pixY,8); |
---|
139 | |
---|
140 | // cout <<"*** "<<PMch << " x="<< pixX << " y="<<pixY<<endl; |
---|
141 | PMpix[PMgeo->GetUniqueId(PMch)]->Draw(); |
---|
142 | } |
---|
143 | } |
---|
144 | MCD->Range(minX,minY,maxX,maxY); |
---|
145 | |
---|
146 | gPad->SetFillColor(38); |
---|
147 | |
---|
148 | }//end draw macrocell |
---|
149 | |
---|
150 | if (debug) cout<< "3"<<endl; |
---|
151 | for(Int_t gtu = pData->GtuStart(); gtu < pData->GtuEnd(); gtu++) //loop nos GTU |
---|
152 | { |
---|
153 | |
---|
154 | vector<MacroCellHit*>* hitinhos =pData->Hits(gtu); |
---|
155 | |
---|
156 | //clean wired or for this GTU |
---|
157 | WiredX.assign(l,false); |
---|
158 | WiredY.assign(l,false); |
---|
159 | |
---|
160 | |
---|
161 | for (uint hi=0;hi < hitinhos->size();hi++) //loop in hits |
---|
162 | { |
---|
163 | //construct pixels of macrocell |
---|
164 | MacroCellHit *hitin = (*hitinhos)[hi]; |
---|
165 | Int_t C= hitin->Col(); |
---|
166 | Int_t R= hitin->Row(); |
---|
167 | |
---|
168 | //update wired or |
---|
169 | WiredX[C]=true; |
---|
170 | WiredY[R]=true; |
---|
171 | if (debug) cout<< "3.5"<<endl; |
---|
172 | if (!silent){ //draw HITS |
---|
173 | Int_t ID = MCPARENT->GetUniqueIdRowCol(R,C); |
---|
174 | PMpix[ID]->SetMarkerColor(PMpix[ID]->GetMarkerColor()+1); |
---|
175 | PMpix[ID]->Draw(); |
---|
176 | }//end draw hists |
---|
177 | }; |
---|
178 | WiredXGTU.push_back(WiredX); |
---|
179 | WiredYGTU.push_back(WiredY); |
---|
180 | if (debug) cout<< "4"<<endl; |
---|
181 | |
---|
182 | //to check buildup of signal |
---|
183 | //cout<<gtu<<flush; |
---|
184 | if (!silent) |
---|
185 | MCD->Update(); |
---|
186 | //getchar(); |
---|
187 | if (debug) cout<< "4.1"<<endl; |
---|
188 | } |
---|
189 | |
---|
190 | |
---|
191 | if (!silent){ //DISPLAY |
---|
192 | // MCD->Range(minX,minY,maxX,maxY); |
---|
193 | |
---|
194 | gPad->SetFillColor(38); |
---|
195 | MCD->Draw(); |
---|
196 | gPad->WaitPrimitive(); |
---|
197 | |
---|
198 | if (debug) cout<< "4.2"<<endl; |
---|
199 | //test loop for lines and columns |
---|
200 | for (Int_t line=1;line<49;line++) { |
---|
201 | for (Int_t column=1;column<49;column++) |
---|
202 | { |
---|
203 | //cout << "l= "<<line << " c= "<<column <<endl; |
---|
204 | Int_t IDTest = MCPARENT->GetUniqueIdRowCol(line,column); |
---|
205 | if (debug) cout<< "4.3"<<endl; |
---|
206 | if( PMpix.count(IDTest) == 0 ) continue; |
---|
207 | PMpix[IDTest]->SetMarkerStyle(28); |
---|
208 | PMpix[IDTest]->Draw(); |
---|
209 | // MCD->Update(); |
---|
210 | // getchar(); |
---|
211 | PMpix[IDTest]->SetMarkerStyle(24); |
---|
212 | PMpix[IDTest]->Draw(); |
---|
213 | } |
---|
214 | if (debug) cout<< "4.4"<<endl; |
---|
215 | MCD->Update(); |
---|
216 | } |
---|
217 | if (debug) cout<< "4.5"<<endl; |
---|
218 | }//DISPLAY |
---|
219 | |
---|
220 | // return; |
---|
221 | |
---|
222 | if (debug) cout<< "5"<<endl; |
---|
223 | |
---|
224 | |
---|
225 | |
---|
226 | |
---|
227 | |
---|
228 | // GTU number |
---|
229 | Int_t nGTU = WiredXGTU.size(); |
---|
230 | if (nGTU==0) {cout<< "######CELLTRACKING NGTU=0"<<endl; return;} |
---|
231 | if (!silent) {//display projections: |
---|
232 | //X |
---|
233 | TCanvas* Xproj=new TCanvas("XwiredOr","Track Find Trigger - X WiredOr",1100,800); |
---|
234 | Xproj->Range(-5,-5,l+5,nGTU+5); |
---|
235 | vector<vector<TMarker*> > pixWXGTU; //Pixels WXGTU |
---|
236 | vector<TMarker*> WX(l); //Pixels WX |
---|
237 | //loop in wired or |
---|
238 | for (Int_t G=0;G<(Int_t)WiredXGTU.size();G++) |
---|
239 | { |
---|
240 | for (Int_t CC=0;CC<(Int_t)WiredXGTU[G].size();CC++) |
---|
241 | { |
---|
242 | WX[CC]=new TMarker(CC,G,24); |
---|
243 | |
---|
244 | if (WiredXGTU[G][CC]) { |
---|
245 | WX[CC]->SetMarkerColor(2); |
---|
246 | WX[CC]->SetMarkerStyle(20); |
---|
247 | } |
---|
248 | WX[CC]->Draw(); |
---|
249 | |
---|
250 | } |
---|
251 | pixWXGTU.push_back(WX); |
---|
252 | } |
---|
253 | |
---|
254 | if (debug) cout<< "6"<<endl; |
---|
255 | //Y |
---|
256 | TCanvas* Yproj=new TCanvas("YwiredOr","Track Find Trigger - Y WiredOr",1100,800); |
---|
257 | Yproj->Range(-5,-5,l+5,nGTU+5); |
---|
258 | vector<vector<TMarker*> > pixWYGTU; //Pixels WYGTU |
---|
259 | vector<TMarker*> WY(l); //Pixels WY |
---|
260 | //loop in wired or |
---|
261 | for (Int_t G=0;G<(Int_t)WiredYGTU.size();G++) |
---|
262 | { |
---|
263 | for (Int_t RR=0;RR<(Int_t)WiredYGTU[G].size();RR++) |
---|
264 | { |
---|
265 | WY[RR]= new TMarker(RR,G,24); |
---|
266 | if (WiredYGTU[G][RR]) |
---|
267 | { |
---|
268 | WY[RR]->SetMarkerColor(2); |
---|
269 | WY[RR]->SetMarkerStyle(20); |
---|
270 | } |
---|
271 | WY[RR]->Draw(); |
---|
272 | } |
---|
273 | pixWYGTU.push_back(WY); |
---|
274 | } |
---|
275 | }//display project |
---|
276 | |
---|
277 | //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
---|
278 | //+++++ Start the algorithm ++++++ |
---|
279 | //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
---|
280 | if (debug) cout<< "7"<<endl; |
---|
281 | //variables |
---|
282 | // C register |
---|
283 | vector <Bool_t> CX; // *Macrocell Side |
---|
284 | vector <Bool_t> CY; |
---|
285 | //next -> DX,DY |
---|
286 | vector <Bool_t> DX; |
---|
287 | vector <Bool_t> DY; |
---|
288 | |
---|
289 | // L register |
---|
290 | vector <Bool_t> LX; |
---|
291 | vector <Bool_t> LY; |
---|
292 | //next -> DX,DY |
---|
293 | vector <Bool_t> MX; |
---|
294 | vector <Bool_t> MY; |
---|
295 | //stair left |
---|
296 | vector<vector<Bool_t> > SLX; |
---|
297 | vector<vector<Bool_t> > SLY; |
---|
298 | |
---|
299 | // R register |
---|
300 | vector <Bool_t> RX; |
---|
301 | vector <Bool_t> RY; |
---|
302 | //next -> DX,DY |
---|
303 | vector <Bool_t> SX; |
---|
304 | vector <Bool_t> SY; |
---|
305 | //stair Right |
---|
306 | vector<vector<Bool_t> > SRX; |
---|
307 | vector<vector<Bool_t> > SRY; |
---|
308 | |
---|
309 | // Time register |
---|
310 | vector <Bool_t> XT; |
---|
311 | vector <Bool_t> YT; |
---|
312 | vector <Bool_t> XYT; |
---|
313 | |
---|
314 | //auxiliar: |
---|
315 | // number of GTUS --> nGTU |
---|
316 | // side of macrocell: -->l |
---|
317 | // X projections X GTU -->WiredXGTU |
---|
318 | // Y projections X GTU -->WiredYGTU |
---|
319 | |
---|
320 | if (debug) cout<< "7.5"<<endl; |
---|
321 | if (debug) cout<< "nGTU="<<nGTU<<endl; |
---|
322 | //prepare the time registers |
---|
323 | XT.assign(nGTU-1,false); |
---|
324 | if (debug) cout<< "7.51"<<endl; |
---|
325 | YT.assign(nGTU-1,false); |
---|
326 | if (debug) cout<< "7.52"<<endl; |
---|
327 | XYT.assign(nGTU-1,false); |
---|
328 | if (debug) cout<< "8"<<endl; |
---|
329 | // trigger loop |
---|
330 | //__________________________________________________ |
---|
331 | //CX register |
---|
332 | CX=WiredXGTU[0]; |
---|
333 | |
---|
334 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
335 | { |
---|
336 | |
---|
337 | DX = WiredXGTU[cGTU]; |
---|
338 | |
---|
339 | //print cx |
---|
340 | //dbg cout<<endl <<" ## CX="; |
---|
341 | //dbg for (Int_t i1=0;i1<CX.size();i1++) cout << CX[i1]; |
---|
342 | //dbg cout <<" <-- CX"<< endl; |
---|
343 | |
---|
344 | //print dx |
---|
345 | //dbg cout<<endl <<" ## DX="; |
---|
346 | //dbg for (Int_t i2=0;i2<DX.size();i2++) cout << DX[i2]; |
---|
347 | //dbg cout <<" <-- DX"<< endl; |
---|
348 | |
---|
349 | |
---|
350 | CX = VecBitAnd(DX,CX); |
---|
351 | |
---|
352 | //print cxafter -->re |
---|
353 | //dbg cout<<endl <<" ## CX="; |
---|
354 | //dbg for (Int_t i3=0;i3<CX.size();i3++) cout << CX[i3]; |
---|
355 | //dbg cout <<" <-- result"<< endl; |
---|
356 | |
---|
357 | //dbg cout << "ISEMPTY? --> "<< VecEmpty(CX)<< endl; |
---|
358 | if (!VecEmpty(CX)) |
---|
359 | CX = DX; |
---|
360 | else XT[cGTU-1]=true; |
---|
361 | |
---|
362 | |
---|
363 | |
---|
364 | |
---|
365 | //dbg getchar(); |
---|
366 | } |
---|
367 | if (debug) cout<< "9"<<endl; |
---|
368 | //__________________________________________________ |
---|
369 | //LX register |
---|
370 | |
---|
371 | // shift to the left;"create stairway register" |
---|
372 | //the shift is circular then a line to the right is a center line |
---|
373 | SLX=WiredXGTU; |
---|
374 | for (Int_t SL1=1;SL1<(Int_t)SLX.size();SL1++) |
---|
375 | { |
---|
376 | for (Int_t SL2=SL1;SL2<(Int_t)SLX.size();SL2++) |
---|
377 | { |
---|
378 | SLX[SL2]=VecShift(SLX[SL2],-1); |
---|
379 | } |
---|
380 | } |
---|
381 | |
---|
382 | //detect the center line on SLX register |
---|
383 | LX=SLX[0]; |
---|
384 | |
---|
385 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
386 | { |
---|
387 | |
---|
388 | MX = SLX[cGTU]; |
---|
389 | |
---|
390 | //print cx |
---|
391 | //dbg cout<<endl <<" ## CX="; |
---|
392 | //dbg for (Int_t i1=0;i1<CX.size();i1++) cout << CX[i1]; |
---|
393 | //dbg cout <<" <-- CX"<< endl; |
---|
394 | |
---|
395 | //print dx |
---|
396 | //dbg cout<<endl <<" ## DX="; |
---|
397 | //dbg for (Int_t i2=0;i2<DX.size();i2++) cout << DX[i2]; |
---|
398 | //dbg cout <<" <-- DX"<< endl; |
---|
399 | |
---|
400 | |
---|
401 | LX = VecBitAnd(MX,LX); |
---|
402 | |
---|
403 | //print cxafter -->re |
---|
404 | //dbg cout<<endl <<" ## CX="; |
---|
405 | //dbg for (Int_t i3=0;i3<CX.size();i3++) cout << CX[i3]; |
---|
406 | //dbg cout <<" <-- result"<< endl; |
---|
407 | |
---|
408 | //dbg cout << "ISEMPTY? --> "<< VecEmpty(CX)<< endl; |
---|
409 | if (!VecEmpty(LX)) |
---|
410 | LX = MX; |
---|
411 | else XT[cGTU-1]=true; |
---|
412 | |
---|
413 | //dbg getchar(); |
---|
414 | } |
---|
415 | |
---|
416 | if (debug) cout<< "10"<<endl; |
---|
417 | |
---|
418 | //____________________________________________________________________ |
---|
419 | //RX register |
---|
420 | |
---|
421 | // shift to the RIGHT;"create stairway register" |
---|
422 | //the shift is circular then a line to the LEFT is a center line |
---|
423 | SRX=WiredXGTU; |
---|
424 | for (Int_t SR1=1;SR1<(Int_t)SRX.size();SR1++) |
---|
425 | { |
---|
426 | for (Int_t SR2=SR1;SR2<(Int_t)SRX.size();SR2++) |
---|
427 | { |
---|
428 | SRX[SR2]=VecShift(SRX[SR2],1); |
---|
429 | } |
---|
430 | } |
---|
431 | |
---|
432 | //detect the center line on SRX register |
---|
433 | RX=SRX[0]; |
---|
434 | |
---|
435 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
436 | { |
---|
437 | |
---|
438 | SX = SRX[cGTU]; |
---|
439 | |
---|
440 | //print cx |
---|
441 | //dbg cout<<endl <<" ## CX="; |
---|
442 | //dbg for (Int_t i1=0;i1<CX.size();i1++) cout << CX[i1]; |
---|
443 | //dbg cout <<" <-- CX"<< endl; |
---|
444 | |
---|
445 | //print dx |
---|
446 | //dbg cout<<endl <<" ## DX="; |
---|
447 | //dbg for (Int_t i2=0;i2<DX.size();i2++) cout << DX[i2]; |
---|
448 | //dbg cout <<" <-- DX"<< endl; |
---|
449 | |
---|
450 | |
---|
451 | RX = VecBitAnd(SX,RX); |
---|
452 | |
---|
453 | //print cxafter -->re |
---|
454 | //dbg cout<<endl <<" ## CX="; |
---|
455 | //dbg for (Int_t i3=0;i3<CX.size();i3++) cout << CX[i3]; |
---|
456 | //dbg cout <<" <-- result"<< endl; |
---|
457 | |
---|
458 | //dbg cout << "ISEMPTY? --> "<< VecEmpty(CX)<< endl; |
---|
459 | if (!VecEmpty(RX)) |
---|
460 | RX = SX; |
---|
461 | else XT[cGTU-1]=true; |
---|
462 | |
---|
463 | //dbg getchar(); |
---|
464 | } |
---|
465 | |
---|
466 | if (debug) cout<< "11"<<endl; |
---|
467 | //________________________________________________________ |
---|
468 | //CY register |
---|
469 | |
---|
470 | CY=WiredYGTU[0]; |
---|
471 | |
---|
472 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
473 | { |
---|
474 | DY = WiredYGTU[cGTU]; |
---|
475 | CY = VecBitAnd(DY, CY); |
---|
476 | if (!VecEmpty(CY)) |
---|
477 | CY = DY; |
---|
478 | else YT[cGTU-1]=true; |
---|
479 | } |
---|
480 | if (debug) cout<< "12"<<endl; |
---|
481 | //__________________________________________________ |
---|
482 | //LY register |
---|
483 | |
---|
484 | // shift to the left;"create stairway register" |
---|
485 | //the shift is circular then a line to the right is a center line |
---|
486 | SLY=WiredYGTU; |
---|
487 | for (Int_t SL1=1;SL1<(Int_t)SLY.size();SL1++) |
---|
488 | { |
---|
489 | for (Int_t SL2=SL1;SL2<(Int_t)SLY.size();SL2++) |
---|
490 | { |
---|
491 | SLY[SL2]=VecShift(SLY[SL2],-1); |
---|
492 | } |
---|
493 | } |
---|
494 | |
---|
495 | //detect the center line on SLY register |
---|
496 | LY=SLY[0]; |
---|
497 | |
---|
498 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
499 | { |
---|
500 | |
---|
501 | MY = SLY[cGTU]; |
---|
502 | |
---|
503 | //print cx |
---|
504 | //dbg cout<<endl <<" ## CX="; |
---|
505 | //dbg for (Int_t i1=0;i1<CX.size();i1++) cout << CX[i1]; |
---|
506 | //dbg cout <<" <-- CX"<< endl; |
---|
507 | |
---|
508 | //print dx |
---|
509 | //dbg cout<<endl <<" ## DX="; |
---|
510 | //dbg for (Int_t i2=0;i2<DX.size();i2++) cout << DX[i2]; |
---|
511 | //dbg cout <<" <-- DX"<< endl; |
---|
512 | |
---|
513 | |
---|
514 | LY = VecBitAnd(MY,LY); |
---|
515 | |
---|
516 | //print cxafter -->re |
---|
517 | //dbg cout<<endl <<" ## CX="; |
---|
518 | //dbg for (Int_t i3=0;i3<CX.size();i3++) cout << CX[i3]; |
---|
519 | //dbg cout <<" <-- result"<< endl; |
---|
520 | |
---|
521 | //dbg cout << "ISEMPTY? --> "<< VecEmpty(CX)<< endl; |
---|
522 | if (!VecEmpty(LY)) |
---|
523 | LY = MY; |
---|
524 | else YT[cGTU-1]=true; |
---|
525 | |
---|
526 | //dbg getchar(); |
---|
527 | } |
---|
528 | |
---|
529 | |
---|
530 | if (debug) cout<< "13"<<endl; |
---|
531 | //____________________________________________________________________ |
---|
532 | //RY register |
---|
533 | |
---|
534 | // shift to the RIGHT;"create stairway register" |
---|
535 | //the shift is circular then a line to the LEFT is a center line |
---|
536 | SRY=WiredYGTU; |
---|
537 | for (Int_t SR1=1;SR1<(Int_t)SRY.size();SR1++) |
---|
538 | { |
---|
539 | for (Int_t SR2=SR1;SR2<(Int_t)SRY.size();SR2++) |
---|
540 | { |
---|
541 | SRY[SR2]=VecShift(SRY[SR2],1); |
---|
542 | } |
---|
543 | } |
---|
544 | |
---|
545 | //detect the center line on SRY register |
---|
546 | RY=SRY[0]; |
---|
547 | |
---|
548 | for (Int_t cGTU=1 ; cGTU<nGTU ; cGTU++) |
---|
549 | { |
---|
550 | |
---|
551 | SY = SRY[cGTU]; |
---|
552 | |
---|
553 | //print cx |
---|
554 | //dbg cout<<endl <<" ## CX="; |
---|
555 | //dbg for (Int_t i1=0;i1<CX.size();i1++) cout << CX[i1]; |
---|
556 | //dbg cout <<" <-- CX"<< endl; |
---|
557 | |
---|
558 | //print dx |
---|
559 | //dbg cout<<endl <<" ## DX="; |
---|
560 | //dbg for (Int_t i2=0;i2<DX.size();i2++) cout << DX[i2]; |
---|
561 | //dbg cout <<" <-- DX"<< endl; |
---|
562 | |
---|
563 | |
---|
564 | RY = VecBitAnd(SY,RY); |
---|
565 | |
---|
566 | //print cxafter -->re |
---|
567 | //dbg cout<<endl <<" ## CX="; |
---|
568 | //dbg for (Int_t i3=0;i3<CX.size();i3++) cout << CX[i3]; |
---|
569 | //dbg cout <<" <-- result"<< endl; |
---|
570 | |
---|
571 | //dbg cout << "ISEMPTY? --> "<< VecEmpty(CX)<< endl; |
---|
572 | if (!VecEmpty(RY)) |
---|
573 | RY = SY; |
---|
574 | else YT[cGTU-1]=true; |
---|
575 | |
---|
576 | //dbg getchar(); |
---|
577 | } |
---|
578 | if (debug) cout<< "14"<<endl; |
---|
579 | //__________________________________________________ |
---|
580 | //generate the trigger if "YT and XT" contain more than "n" consecutive "true". n is the persistency |
---|
581 | |
---|
582 | // XT and YT |
---|
583 | XYT=VecBitAnd(XT,YT); |
---|
584 | |
---|
585 | |
---|
586 | if (!silent) |
---|
587 | for (Int_t temp1=0 ; temp1<(Int_t) YT.size() ; temp1++) |
---|
588 | {cout << "## "<< temp1<< " -XT-> "<< XT[temp1] << " -YT-> "<<YT[temp1]<< " -XYT-> "<< XYT[temp1]<<endl;} |
---|
589 | |
---|
590 | |
---|
591 | |
---|
592 | //count the XYT |
---|
593 | Int_t TrackTh=(Int_t)Conf()->GetNum("CellTrackingTrgEngine.Persistency")-1; |
---|
594 | Int_t AuxCount=0; |
---|
595 | |
---|
596 | if (!silent) cout<<endl<<"Required Track «"<<TrackTh<<"»"<<endl; |
---|
597 | for (Int_t temp2=0 ; temp2<(Int_t) XYT.size() ; temp2++) |
---|
598 | { |
---|
599 | |
---|
600 | AuxCount= (AuxCount+(Int_t) XYT[temp2])*(Int_t)XYT[temp2]; |
---|
601 | if (!silent) cout<< AuxCount; |
---|
602 | if (AuxCount >= TrackTh) |
---|
603 | { |
---|
604 | SetTrigger();//GENERATE THE TRIGGER |
---|
605 | SetGtuTrigger( pData->GtuStart()+1+temp2 ); |
---|
606 | cout << endl<<"=== TRIGGER! Cell:" << pData->Cell()->Id() |
---|
607 | << " Gtu:" << pData->GtuStart()+1+temp2 << " Engine:" << GetName() << endl; |
---|
608 | return; |
---|
609 | } |
---|
610 | } |
---|
611 | |
---|
612 | if (debug) cout<< "15"<<endl; |
---|
613 | |
---|
614 | } |
---|
615 | |
---|
616 | //______________________________________________________________________________ |
---|
617 | vector<Bool_t> CellTrackingTrgEngine::VecBitAnd(vector<Bool_t> A, vector<Bool_t> B) { |
---|
618 | // |
---|
619 | // routine to and registers |
---|
620 | // |
---|
621 | |
---|
622 | //test the registers |
---|
623 | if (A.size() != B.size() ) |
---|
624 | cout << "EERRRRRRRRRRRROOOOOOOOOOOOOOOOORRRRRRRRRRRRRRR in BitAnd in CelltrackingTrigger"; |
---|
625 | |
---|
626 | Int_t s = A.size(); |
---|
627 | vector<Bool_t> OUT; |
---|
628 | OUT.assign(s,false); |
---|
629 | |
---|
630 | for (Int_t i =0; i<s;i++) |
---|
631 | { |
---|
632 | OUT[i] = A[i] && B[i]; |
---|
633 | } |
---|
634 | |
---|
635 | return OUT; |
---|
636 | } |
---|
637 | |
---|
638 | |
---|
639 | Bool_t CellTrackingTrgEngine::VecEmpty (vector<Bool_t> A) { |
---|
640 | // |
---|
641 | // Routine to check register is empty |
---|
642 | // |
---|
643 | Int_t s = A.size(); |
---|
644 | Bool_t OUT; |
---|
645 | OUT=false; |
---|
646 | |
---|
647 | for (Int_t i =0; i<s;i++) |
---|
648 | { |
---|
649 | OUT = A[i] || OUT; |
---|
650 | } |
---|
651 | |
---|
652 | return OUT; |
---|
653 | } |
---|
654 | |
---|
655 | |
---|
656 | |
---|
657 | //______________________________________________________________________________ |
---|
658 | vector<Bool_t> CellTrackingTrgEngine::VecShift(vector<Bool_t> vec, Int_t shift) |
---|
659 | { |
---|
660 | // Routine to shift register |
---|
661 | // 0 - do not shift |
---|
662 | // 1 - shift one to the right |
---|
663 | // -1 - shift one to the left |
---|
664 | |
---|
665 | |
---|
666 | //-1 shift left |
---|
667 | //0 nothing |
---|
668 | // 1 shift right |
---|
669 | Bool_t temp; |
---|
670 | |
---|
671 | switch(shift) { |
---|
672 | case -1 : |
---|
673 | temp=vec[0]; |
---|
674 | for (Int_t i=1; i<(Int_t) vec.size();i++) |
---|
675 | vec[i-1]=vec[i]; |
---|
676 | vec[vec.size()-1]=temp; |
---|
677 | break; |
---|
678 | case 0 : |
---|
679 | break; |
---|
680 | case 1 : |
---|
681 | temp=vec[vec.size()-1]; |
---|
682 | for (Int_t i=(Int_t)vec.size()-1; i>-1;i--) |
---|
683 | vec[i+1]=vec[i]; |
---|
684 | vec[0]=temp; |
---|
685 | break; |
---|
686 | default : throw runtime_error("CellTracking: ERROR"); |
---|
687 | |
---|
688 | } |
---|
689 | return vec; |
---|
690 | } |
---|