]>
Commit | Line | Data |
---|---|---|
905654c2 | 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 | ||
bae1aa70 | 16 | // $Id$ |
17 | ||
3d1463c8 | 18 | //----------------------------------------------------------------------------- |
bae1aa70 | 19 | /// \class AliMUONTriggerGUIbdmap |
20 | /// | |
21 | /// The gui map of a single board object, strips/digits | |
22 | /// | |
23 | /// \author Bogdan Vulpescu, LPC Clermont-Ferrand | |
3d1463c8 | 24 | //----------------------------------------------------------------------------- |
905654c2 | 25 | |
26 | #include <TPolyLine.h> | |
27 | #include <TStyle.h> | |
905654c2 | 28 | #include <TGButton.h> |
29 | #include <TRootEmbeddedCanvas.h> | |
30 | #include <TBox.h> | |
31 | #include <TPaveText.h> | |
32 | #include <TGTextEdit.h> | |
33 | #include <TGText.h> | |
34 | #include <TTimer.h> | |
35 | #include <TObjArray.h> | |
36 | #include <TCanvas.h> | |
37 | ||
c93255fe | 38 | #include "AliLoader.h" |
8b067dfe | 39 | #include "AliRunLoader.h" |
bae1aa70 | 40 | #include "AliMUONVDigit.h" |
905654c2 | 41 | #include "AliMUONGeometryTransformer.h" |
905654c2 | 42 | #include "AliMUONLocalTrigger.h" |
43 | #include "AliMUONLocalTriggerBoard.h" | |
44 | #include "AliMUONTriggerCrateStore.h" | |
f9eb4448 | 45 | #include "AliMUONMCDataInterface.h" |
8b067dfe | 46 | #include "AliMUONTriggerStoreV1.h" |
47 | #include "AliMUONDigitStoreV1.h" | |
f9eb4448 | 48 | #include "AliMUONTriggerGUIboard.h" |
49 | #include "AliMUONTriggerGUIbdmap.h" | |
50 | ||
168e9c4d | 51 | #include "AliMpDEManager.h" |
52 | #include "AliMpDEIterator.h" | |
53 | #include "AliMpEncodePair.h" | |
54 | #include "AliMpVSegmentation.h" | |
55 | #include "AliMpSegmentation.h" | |
56 | ||
b785c4bd | 57 | #include <cstdio> |
58 | ||
168e9c4d | 59 | |
905654c2 | 60 | /// \cond CLASSIMP |
61 | ClassImp(AliMUONTriggerGUIbdmap) | |
62 | /// \endcond | |
63 | ||
64 | //__________________________________________________________________________ | |
9671bf76 | 65 | AliMUONTriggerGUIbdmap::AliMUONTriggerGUIbdmap(const TGWindow *p, const TGWindow *mainWindow, UInt_t w, UInt_t h) |
bae1aa70 | 66 | : TGFrame(0), |
905654c2 | 67 | fMain(0), |
68 | fLocTrigE(0), | |
69 | fBoard(0), | |
70 | fLoader(0), | |
f9eb4448 | 71 | fMCDataInterface(0), |
8b067dfe | 72 | fRawDigitStore(0), |
73 | fRawTriggerStore(0), | |
905654c2 | 74 | fXStrips(0), |
75 | fYStrips(0), | |
76 | fEditStrips(0), | |
77 | fXOn(0), | |
78 | fYOn(0), | |
79 | fLabelX(0), | |
80 | fLabelY(0), | |
81 | fIsEditable(0), | |
82 | fCanvasSize(0), | |
83 | fNStripX(0), | |
84 | fNStripY(0), | |
f9eb4448 | 85 | fBoards(0), |
d011bba5 | 86 | fCalibrationData(0x0), |
f9eb4448 | 87 | fCrateManager(0) |
905654c2 | 88 | { |
89 | /// frame constructor | |
90 | ||
91 | gStyle->SetPadLeftMargin(0.05); | |
92 | gStyle->SetPadRightMargin(0.05); | |
93 | gStyle->SetPadTopMargin(0.05); | |
94 | gStyle->SetPadBottomMargin(0.05); | |
95 | ||
9671bf76 | 96 | fMain = new TGTransientFrame(p, mainWindow, w, h, kVerticalFrame); |
905654c2 | 97 | fMain->Connect("CloseWindow()", "AliMUONTriggerGUIbdmap", this, "CloseWindow()"); |
98 | fMain->DontCallClose(); // to avoid double deletions. | |
99 | ||
100 | // use hierarchical cleaning | |
101 | fMain->SetCleanup(kDeepCleanup); | |
102 | ||
103 | fMain->ChangeOptions((fMain->GetOptions() & ~kVerticalFrame) | kHorizontalFrame); | |
104 | ||
105 | // strips/digits canvases | |
106 | ||
107 | fCanvasSize = 200; | |
108 | ||
109 | TRootEmbeddedCanvas *recanvas[4]; | |
b785c4bd | 110 | Char_t ecname[2]; |
905654c2 | 111 | for (Int_t i = 0; i < kNMT; i++) { |
112 | ||
b785c4bd | 113 | snprintf(ecname,2,"%1d",i+1); |
905654c2 | 114 | recanvas[i] = new TRootEmbeddedCanvas(ecname,fMain,fCanvasSize,fCanvasSize); |
115 | ||
116 | fCanvas[i] = recanvas[i]->GetCanvas(); | |
117 | ||
118 | fCanvas[i]->SetBorderMode(0); | |
119 | fCanvas[i]->SetBit(kNoContextMenu); | |
120 | ||
121 | fCanvas[i]->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)", | |
122 | "AliMUONTriggerGUIbdmap",this, | |
123 | "EditStrips(Int_t,Int_t,Int_t,TObject*)"); | |
124 | ||
125 | fMain->AddFrame(recanvas[i], | |
126 | /* | |
127 | new TGTableLayoutHints(2,5,2,6, | |
128 | kLHintsExpandX|kLHintsExpandY | | |
129 | kLHintsShrinkX|kLHintsShrinkY | | |
130 | kLHintsFillX|kLHintsFillY) | |
131 | */ | |
132 | new TGLayoutHints(kLHintsTop | | |
133 | kLHintsLeft, | |
134 | 2, 2, 2, 2) | |
135 | ); | |
136 | ||
137 | } | |
138 | ||
139 | //TGDimension size = fMain->GetDefaultSize(); | |
140 | //fMain->Resize(size); | |
141 | ||
142 | // the other frames | |
143 | ||
144 | TGCompositeFrame *cf0 = new TGCompositeFrame(fMain, 60, 20, kVerticalFrame); | |
145 | ||
146 | TGCompositeFrame *cf1 = new TGCompositeFrame(cf0, 60, 20, kVerticalFrame | kFixedWidth); | |
147 | ||
148 | cf1->AddFrame(fXStrips = new TGCheckButton(cf1, "Draw X strips and digits", 1), | |
149 | new TGLayoutHints(kLHintsTop | | |
150 | kLHintsLeft, | |
151 | 2, 2, 2, 2) | |
152 | ); | |
153 | ||
154 | cf1->Resize(fXStrips->GetDefaultWidth()+10, fMain->GetDefaultHeight()); | |
155 | ||
156 | cf1->AddFrame(fYStrips = new TGCheckButton(cf1, "Draw Y strips and digits", 2), | |
157 | new TGLayoutHints(kLHintsTop | | |
158 | kLHintsLeft, | |
159 | 2, 2, 2, 2) | |
160 | ); | |
161 | ||
162 | cf1->Resize(fYStrips->GetDefaultWidth()+10, fMain->GetDefaultHeight()); | |
163 | ||
164 | cf1->AddFrame(fEditStrips = new TGCheckButton(cf1, "Set/unset strips", 3), | |
165 | new TGLayoutHints(kLHintsTop | | |
166 | kLHintsLeft, | |
167 | 2, 2, 2, 2) | |
168 | ); | |
169 | ||
170 | fXStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleButtons()"); | |
171 | fYStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleButtons()"); | |
172 | fEditStrips->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "HandleEditButton()"); | |
173 | ||
174 | cf0->AddFrame(cf1, | |
175 | new TGLayoutHints(kLHintsTop | | |
176 | kLHintsExpandX, | |
177 | 2, 2, 2, 2) | |
178 | ); | |
179 | ||
180 | TGCompositeFrame *cf2 = new TGCompositeFrame(cf0, 60, 20, kHorizontalFrame | kFixedWidth); | |
181 | ||
182 | TGTextButton *digitsButton = new TGTextButton(cf2, "Digits", 4); | |
183 | digitsButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "DoDigits()"); | |
184 | ||
185 | //cf2->Resize(digitsButton->GetDefaultWidth()+40, fMain->GetDefaultHeight()); | |
186 | ||
187 | cf2->AddFrame(digitsButton, | |
188 | new TGLayoutHints(kLHintsTop | | |
189 | kLHintsLeft | | |
190 | kLHintsExpandX, | |
191 | 2, 2, 5, 5) | |
192 | ); | |
193 | ||
194 | TGTextButton *dresetButton = new TGTextButton(cf2, "Reset", 5); | |
195 | dresetButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "ResetDigits()"); | |
196 | ||
197 | //cf2->Resize(dresetButton->GetDefaultWidth()+40, fMain->GetDefaultHeight()); | |
198 | ||
199 | cf2->AddFrame(dresetButton, | |
200 | new TGLayoutHints(kLHintsTop | | |
201 | kLHintsLeft | | |
202 | kLHintsExpandX, | |
203 | 2, 2, 5, 5) | |
204 | ); | |
205 | ||
206 | TGTextButton *closeButton = new TGTextButton(cf2, "Close", 6); | |
207 | closeButton->Connect("Clicked()", "AliMUONTriggerGUIbdmap", this, "DoClose()"); | |
208 | ||
209 | //cf2->Resize(closeButton->GetDefaultWidth()+40, fMain->GetDefaultHeight()); | |
210 | ||
211 | cf2->AddFrame(closeButton, | |
212 | new TGLayoutHints(kLHintsTop | | |
213 | kLHintsLeft | | |
214 | kLHintsExpandX, | |
215 | 2, 2, 5, 5) | |
216 | ); | |
217 | ||
218 | cf0->AddFrame(cf2, | |
219 | new TGLayoutHints(kLHintsTop | | |
220 | kLHintsExpandX, | |
221 | 2, 2, 2, 2) | |
222 | ); | |
223 | ||
224 | // editor window for the local trigger | |
225 | ||
226 | TGCompositeFrame *cf3 = new TGCompositeFrame(cf0, 60, 20, kVerticalFrame | kFixedWidth); | |
227 | ||
228 | fLocTrigE = new TGTextEdit(cf3, 100, 100, kSunkenFrame | kDoubleBorder); | |
229 | cf3->AddFrame(fLocTrigE, | |
230 | new TGLayoutHints(kLHintsExpandX | | |
231 | kLHintsExpandY, | |
232 | 3, 3, 3, 3) | |
233 | ); | |
234 | ||
235 | cf0->AddFrame(cf3, | |
236 | new TGLayoutHints(kLHintsTop | | |
237 | kLHintsExpandX, | |
238 | 2, 2, 2, 2) | |
239 | ); | |
240 | ||
241 | fMain->AddFrame(cf0, | |
242 | new TGLayoutHints(kLHintsTop | | |
243 | kLHintsExpandX, | |
244 | 2, 2, 2, 2) | |
245 | ); | |
246 | ||
247 | fIsEditable = kFALSE; | |
248 | fLabelX = kFALSE; | |
249 | fLabelY = kFALSE; | |
250 | ||
251 | fMain->MapSubwindows(); | |
252 | fMain->Resize(); | |
253 | ||
254 | fMain->CenterOnParent(); | |
255 | ||
256 | //fMain->MapWindow(); | |
257 | //gClient->WaitFor(fMain); | |
258 | ||
259 | } | |
260 | ||
261 | //__________________________________________________________________________ | |
262 | AliMUONTriggerGUIbdmap::~AliMUONTriggerGUIbdmap() | |
263 | { | |
264 | /// frame destructor | |
265 | ||
266 | fMain->DeleteWindow(); | |
267 | ||
268 | } | |
269 | ||
905654c2 | 270 | //__________________________________________________________________________ |
271 | void AliMUONTriggerGUIbdmap::Show() | |
272 | { | |
273 | /// map the main frame | |
274 | ||
275 | fMain->MapWindow(); | |
276 | LocalTriggerInfo(); | |
277 | ||
278 | } | |
279 | ||
280 | //__________________________________________________________________________ | |
281 | void AliMUONTriggerGUIbdmap::LocalTriggerInfo() | |
282 | { | |
283 | /// print the local trigger | |
8b067dfe | 284 | |
905654c2 | 285 | TGText txt; |
286 | Char_t buffer[20]; | |
287 | ||
b785c4bd | 288 | snprintf(buffer,20,"Local trigger info\n"); |
905654c2 | 289 | fLocTrigE->LoadBuffer(buffer); |
290 | ||
8b067dfe | 291 | AliMUONVTriggerStore *triggerStore; |
905654c2 | 292 | |
8b067dfe | 293 | if (fLoader != 0x0) { |
294 | AliRunLoader *runLoader = fLoader->GetRunLoader(); | |
295 | triggerStore = fMCDataInterface->TriggerStore(runLoader->GetEventNumber()); | |
296 | } else if (fRawTriggerStore != 0x0) { | |
297 | triggerStore = static_cast<AliMUONVTriggerStore*>(fRawTriggerStore); | |
298 | } else { | |
b785c4bd | 299 | snprintf(buffer,20,"No data loaded yet...\n"); |
8b067dfe | 300 | txt.LoadBuffer(buffer); |
301 | fLocTrigE->AddText(&txt); | |
302 | return; | |
303 | } | |
f9eb4448 | 304 | |
905654c2 | 305 | Int_t circuitNumber = fBoard->GetIdCircuit(); |
306 | ||
905654c2 | 307 | UShort_t x2m, x2u, x2d; |
308 | ||
309 | Int_t loStripX, loStripY, loDev, loCircuit, iStripX, iStripY, loLpt, loHpt; | |
310 | AliMUONLocalTrigger *mlt; | |
bae1aa70 | 311 | |
312 | TIter next(triggerStore->CreateLocalIterator()); | |
905654c2 | 313 | |
bae1aa70 | 314 | while ( ( mlt = static_cast<AliMUONLocalTrigger*>(next()) ) ) |
315 | { | |
905654c2 | 316 | loCircuit = mlt->LoCircuit(); |
317 | ||
318 | if (loCircuit == circuitNumber) { | |
319 | ||
f9eb4448 | 320 | AliMUONLocalTriggerBoard* ltb = fCrateManager->LocalBoard(loCircuit); |
905654c2 | 321 | x2d = ltb->GetSwitch(0); |
322 | x2m = ltb->GetSwitch(1); | |
323 | x2u = ltb->GetSwitch(2); | |
324 | ||
325 | loStripX = mlt->LoStripX(); | |
326 | loStripY = mlt->LoStripY(); | |
327 | loDev = mlt->LoDev(); | |
328 | loLpt = mlt->LoLpt(); | |
329 | loHpt = mlt->LoHpt(); | |
330 | ||
331 | iStripX = loStripX/2; | |
332 | if ((x2u == 1 || x2m == 1 || x2d == 1) && x2m == 1) { | |
333 | iStripY = loStripY/2; | |
334 | } else { | |
335 | iStripY = loStripY; | |
336 | } | |
337 | ||
b785c4bd | 338 | snprintf(buffer,20,"Circuit = %03d",loCircuit); |
905654c2 | 339 | txt.LoadBuffer(buffer); |
340 | fLocTrigE->AddText(&txt); | |
341 | ||
b785c4bd | 342 | snprintf(buffer,20,"LoStripX = %2d",loStripX); |
905654c2 | 343 | txt.LoadBuffer(buffer); |
344 | fLocTrigE->AddText(&txt); | |
345 | ||
b785c4bd | 346 | snprintf(buffer,20,"LoStripY = %2d",loStripY); |
905654c2 | 347 | txt.LoadBuffer(buffer); |
348 | fLocTrigE->AddText(&txt); | |
349 | ||
b785c4bd | 350 | snprintf(buffer,20,"LoDev = %2d",loDev); |
905654c2 | 351 | txt.LoadBuffer(buffer); |
352 | fLocTrigE->AddText(&txt); | |
353 | ||
b785c4bd | 354 | snprintf(buffer,20,"--------------------"); |
905654c2 | 355 | txt.LoadBuffer(buffer); |
356 | fLocTrigE->AddText(&txt); | |
357 | ||
b785c4bd | 358 | snprintf(buffer,20,"X-strip = %2d ( %2d )",iStripX,(loStripX+loDev+1)/2); |
905654c2 | 359 | txt.LoadBuffer(buffer); |
360 | fLocTrigE->AddText(&txt); | |
361 | ||
b785c4bd | 362 | snprintf(buffer,20,"Y-strip = %2d",iStripY); |
905654c2 | 363 | txt.LoadBuffer(buffer); |
364 | fLocTrigE->AddText(&txt); | |
365 | ||
b785c4bd | 366 | snprintf(buffer,20,"--------------------"); |
905654c2 | 367 | txt.LoadBuffer(buffer); |
368 | fLocTrigE->AddText(&txt); | |
369 | ||
b785c4bd | 370 | snprintf(buffer,20,"LoLpt = %2d",loLpt); |
905654c2 | 371 | txt.LoadBuffer(buffer); |
372 | fLocTrigE->AddText(&txt); | |
373 | ||
b785c4bd | 374 | snprintf(buffer,20,"LoHpt = %2d",loHpt); |
905654c2 | 375 | txt.LoadBuffer(buffer); |
376 | fLocTrigE->AddText(&txt); | |
377 | ||
378 | break; | |
379 | ||
380 | } | |
381 | ||
382 | } | |
383 | ||
384 | } | |
385 | ||
386 | //__________________________________________________________________________ | |
387 | void AliMUONTriggerGUIbdmap::Init() | |
388 | { | |
389 | /// initialize the boards in the four MT | |
390 | ||
905654c2 | 391 | for (Int_t i = 0; i < kNMT; i++) { |
392 | ||
8b067dfe | 393 | fXWidth[i] = fBoard->GetXWidth(i); |
394 | fYWidth[i] = fBoard->GetYWidth(i); | |
395 | fXCenter[i] = fBoard->GetXCenter(i); | |
396 | fYCenter[i] = fBoard->GetYCenter(i); | |
397 | ||
905654c2 | 398 | } |
399 | ||
400 | Float_t xw, yw; | |
401 | for (Int_t i = 0; i < kNMT; i++) { | |
402 | xw = 1.20*fXWidth[i]; | |
403 | yw = 1.20*fYWidth[i]; | |
404 | fCanvas[i]->Range(-xw/2,-yw/2,+xw/2,+yw/2); | |
405 | for (Int_t is = 0; is < kNS; is++) { | |
406 | ||
407 | fXDigPL[i][is] = new TPolyLine(5); | |
408 | fYDigPL[i][is] = new TPolyLine(5); | |
409 | fXDigPL[i][is]->SetBit(kCannotPick); | |
410 | fYDigPL[i][is]->SetBit(kCannotPick); | |
411 | fXDigPL[i][is]->SetLineColor(4); | |
412 | fYDigPL[i][is]->SetLineColor(4); | |
413 | ||
414 | fXDigBox[i][is] = new TBox(0,0,0,0); | |
415 | fYDigBox[i][is] = new TBox(0,0,0,0); | |
416 | fXDigBox[i][is]->SetBit(kCannotPick); | |
417 | fYDigBox[i][is]->SetBit(kCannotPick); | |
418 | fXDigBox[i][is]->SetFillStyle(0); | |
419 | fYDigBox[i][is]->SetFillStyle(0); | |
420 | fXDigBox[i][is]->SetLineColor(4); | |
421 | fYDigBox[i][is]->SetLineColor(4); | |
422 | ||
423 | fXLabelL[i][is] = 0; | |
424 | fXLabelR[i][is] = 0; | |
425 | fYLabelL[i][is] = 0; | |
426 | fYLabelR[i][is] = 0; | |
427 | ||
428 | } | |
429 | } | |
430 | ||
431 | ||
432 | fXOn = kFALSE; | |
433 | fYOn = kFALSE; | |
434 | ||
435 | fNStripX = fBoard->GetXSiy2() - fBoard->GetXSiy1() + 1; | |
436 | fNStripY = fBoard->GetYSix2() - fBoard->GetYSix1() + 1; | |
437 | ||
438 | } | |
439 | ||
440 | //__________________________________________________________________________ | |
441 | void AliMUONTriggerGUIbdmap::HandleEditButton() | |
442 | { | |
443 | /// handle the editable check button | |
444 | ||
445 | if (((fXOn && !fYOn) || (!fXOn && fYOn)) && | |
446 | (fEditStrips->GetState() == kButtonDown)) { | |
447 | fIsEditable = kTRUE; | |
448 | } else { | |
449 | fIsEditable = kFALSE; | |
450 | } | |
451 | ||
452 | } | |
453 | ||
454 | //__________________________________________________________________________ | |
455 | void AliMUONTriggerGUIbdmap::EditStrips(Int_t event, Int_t x, Int_t y, TObject *sel) | |
456 | { | |
457 | /// set/unset strips | |
458 | ||
459 | TString cs; | |
460 | Int_t iMT; | |
461 | Double_t *px, *py; | |
462 | Double_t xf1, yf1, xf2, yf2; | |
463 | Int_t np = 5; | |
464 | Double_t xMin, xMax, yMin, yMax; | |
465 | Float_t xd, yd, fxDim, fyDim, cDim; | |
b785c4bd | 466 | Char_t cln[3]; |
905654c2 | 467 | |
468 | cDim = (Float_t)fCanvasSize; | |
469 | ||
470 | // the (x,y) event does not really go up to the canvas size... | |
471 | cDim = 196.0; | |
472 | ||
473 | if (fIsEditable) { | |
474 | ||
475 | if (event == kButton1Down) { | |
476 | ||
477 | cs = TString(sel->GetName()); | |
478 | iMT = cs.Atoi()-1; | |
479 | ||
480 | fCanvas[iMT]->cd(); | |
481 | ||
482 | fCanvas[iMT]->GetRange(xf1,yf1,xf2,yf2); | |
483 | fxDim = (Float_t)xf2; | |
484 | fyDim = (Float_t)yf2; | |
485 | ||
486 | //xd = fxDim*(+2.0*(Float_t)(x)/cDim - 1.0); | |
487 | //yd = fyDim*(-2.0*(Float_t)(y)/cDim + 1.0); | |
488 | ||
489 | xd = +(2.0*fxDim*(Float_t)(x))/cDim - fxDim; | |
490 | yd = -(2.0*fyDim*(Float_t)(y))/cDim + fyDim; | |
491 | ||
492 | if (fXOn) { | |
493 | ||
494 | for (Int_t ix = 0; ix < fNStripX; ix++) { | |
495 | ||
496 | px = fXDigPL[iMT][ix]->GetX(); | |
497 | py = fXDigPL[iMT][ix]->GetY(); | |
498 | ||
499 | xMin = +9999.; | |
500 | xMax = -9999.; | |
501 | yMin = +9999.; | |
502 | yMax = -9999.; | |
503 | for (Int_t ip = 0; ip < np; ip++) { | |
504 | xMin = TMath::Min(xMin,px[ip]); | |
505 | xMax = TMath::Max(xMax,px[ip]); | |
506 | yMin = TMath::Min(yMin,py[ip]); | |
507 | yMax = TMath::Max(yMax,py[ip]); | |
508 | } | |
509 | ||
510 | if (yd > (Float_t)yMin && yd < (Float_t)yMax) { | |
511 | ||
512 | if (fXDigBox[iMT][ix]->GetFillStyle() == 0) { | |
513 | ||
514 | fXDigBox[iMT][ix]->SetFillStyle(1001); | |
515 | fXDigBox[iMT][ix]->SetFillColor(2); | |
516 | ||
b785c4bd | 517 | snprintf(cln,3,"%2d",ix); |
905654c2 | 518 | |
519 | fXLabelL[iMT][ix]->Clear(); | |
520 | fXLabelL[iMT][ix]->AddText(cln); | |
521 | fXLabelL[iMT][ix]->Draw(); | |
522 | ||
523 | fXLabelR[iMT][ix]->Clear(); | |
524 | fXLabelR[iMT][ix]->AddText(cln); | |
525 | fXLabelR[iMT][ix]->Draw(); | |
526 | ||
527 | fXDigBox[iMT][ix]->SetX1(xMin); | |
528 | fXDigBox[iMT][ix]->SetY1(yMin); | |
529 | fXDigBox[iMT][ix]->SetX2(xMax); | |
530 | fXDigBox[iMT][ix]->SetY2(yMax); | |
531 | ||
532 | fXDigBox[iMT][ix]->Draw(); | |
533 | ||
534 | } else if (fXDigBox[iMT][ix]->GetFillStyle() == 1001) { | |
535 | ||
536 | fXDigBox[iMT][ix]->SetFillStyle(0); | |
537 | ||
538 | fXLabelL[iMT][ix]->Clear(); | |
539 | fXLabelL[iMT][ix]->Draw(); | |
540 | ||
541 | fXLabelR[iMT][ix]->Clear(); | |
542 | fXLabelR[iMT][ix]->Draw(); | |
543 | ||
544 | fXDigBox[iMT][ix]->SetX1(-fBoard->GetXCenter(iMT)); | |
545 | fXDigBox[iMT][ix]->SetY1(-fBoard->GetYCenter(iMT)); | |
546 | fXDigBox[iMT][ix]->SetX2(-fBoard->GetXCenter(iMT)); | |
547 | fXDigBox[iMT][ix]->SetY2(-fBoard->GetYCenter(iMT)); | |
548 | ||
549 | fXDigBox[iMT][ix]->Draw(); | |
550 | ||
551 | } | |
552 | ||
553 | if (!fXDigBox[iMT][ix]->TestBit(kObjInCanvas)) | |
554 | fXDigBox[iMT][ix]->Draw(); | |
555 | ||
556 | fCanvas[iMT]->Modified(); | |
557 | fCanvas[iMT]->Update(); | |
558 | ||
559 | break; | |
560 | ||
561 | } | |
562 | } | |
563 | ||
564 | } | |
565 | ||
566 | if (fYOn) { | |
567 | ||
568 | for (Int_t iy = 0; iy < fNStripY; iy++) { | |
569 | ||
570 | px = fYDigPL[iMT][iy]->GetX(); | |
571 | py = fYDigPL[iMT][iy]->GetY(); | |
572 | ||
573 | xMin = +9999.; | |
574 | xMax = -9999.; | |
575 | yMin = +9999.; | |
576 | yMax = -9999.; | |
577 | for (Int_t ip = 0; ip < np; ip++) { | |
578 | xMin = TMath::Min(xMin,px[ip]); | |
579 | xMax = TMath::Max(xMax,px[ip]); | |
580 | yMin = TMath::Min(yMin,py[ip]); | |
581 | yMax = TMath::Max(yMax,py[ip]); | |
582 | } | |
583 | ||
584 | if (xd > (Float_t)xMin && xd < (Float_t)xMax) { | |
585 | ||
586 | if (fYDigBox[iMT][iy]->GetFillStyle() == 0) { | |
587 | ||
588 | fYDigBox[iMT][iy]->SetFillStyle(1001); | |
589 | fYDigBox[iMT][iy]->SetFillColor(2); | |
590 | ||
b785c4bd | 591 | snprintf(cln,3,"%2d",iy); |
905654c2 | 592 | |
593 | fYLabelL[iMT][iy]->Clear(); | |
594 | fYLabelL[iMT][iy]->AddText(cln); | |
595 | fYLabelL[iMT][iy]->Draw(); | |
596 | ||
597 | fYLabelR[iMT][iy]->Clear(); | |
598 | fYLabelR[iMT][iy]->AddText(cln); | |
599 | fYLabelR[iMT][iy]->Draw(); | |
600 | ||
601 | fYDigBox[iMT][iy]->SetX1(xMin); | |
602 | fYDigBox[iMT][iy]->SetY1(yMin); | |
603 | fYDigBox[iMT][iy]->SetX2(xMax); | |
604 | fYDigBox[iMT][iy]->SetY2(yMax); | |
605 | ||
8b067dfe | 606 | fYDigBox[iMT][iy]->Draw(); |
905654c2 | 607 | |
608 | } else if (fYDigBox[iMT][iy]->GetFillStyle() == 1001) { | |
609 | ||
610 | fYDigBox[iMT][iy]->SetFillStyle(0); | |
611 | ||
612 | fYLabelL[iMT][iy]->Clear(); | |
613 | fYLabelL[iMT][iy]->Draw(); | |
614 | ||
615 | fYLabelR[iMT][iy]->Clear(); | |
616 | fYLabelR[iMT][iy]->Draw(); | |
617 | ||
618 | fYDigBox[iMT][iy]->SetX1(-fBoard->GetXCenter(iMT)); | |
619 | fYDigBox[iMT][iy]->SetY1(-fBoard->GetYCenter(iMT)); | |
620 | fYDigBox[iMT][iy]->SetX2(-fBoard->GetXCenter(iMT)); | |
621 | fYDigBox[iMT][iy]->SetY2(-fBoard->GetYCenter(iMT)); | |
622 | ||
8b067dfe | 623 | fYDigBox[iMT][iy]->Draw(); |
905654c2 | 624 | |
625 | } | |
626 | ||
627 | if (!fYDigBox[iMT][iy]->TestBit(kObjInCanvas)) | |
628 | fYDigBox[iMT][iy]->Draw(); | |
629 | ||
630 | fCanvas[iMT]->Modified(); | |
631 | fCanvas[iMT]->Update(); | |
632 | ||
633 | break; | |
634 | ||
635 | } | |
636 | } | |
637 | ||
638 | } | |
639 | ||
640 | } // end button event | |
641 | ||
642 | } // end IsEditable | |
643 | ||
644 | } | |
645 | ||
646 | //__________________________________________________________________________ | |
647 | void AliMUONTriggerGUIbdmap::DoDigits() | |
648 | { | |
649 | /// set the board digits from GUI input (set/unset) | |
650 | ||
651 | Int_t amp = 0; | |
652 | Int_t number = fBoard->GetNumber(); | |
653 | Int_t pos, over; | |
654 | pos = fBoard->GetPosition(); | |
655 | over = fBoard->GetYOver(); | |
656 | AliMUONTriggerGUIboard *board; | |
657 | ||
658 | for (Int_t imt = 0; imt < kNMT; imt++) { | |
659 | ||
660 | for (Int_t ix = 0; ix < fNStripX; ix++) { | |
661 | if (fXDigBox[imt][ix]->GetFillStyle() == 0) { | |
662 | amp = 0; | |
663 | } | |
664 | if (fXDigBox[imt][ix]->GetFillStyle() == 1001) { | |
665 | amp = 1; | |
666 | } | |
667 | fBoard->SetDigitX(imt,ix,amp); | |
668 | } | |
669 | ||
670 | for (Int_t iy = 0; iy < fNStripY; iy++) { | |
671 | if (fYDigBox[imt][iy]->GetFillStyle() == 0) { | |
672 | amp = 0; | |
673 | } | |
674 | if (fYDigBox[imt][iy]->GetFillStyle() == 1001) { | |
675 | amp = 1; | |
676 | } | |
677 | fBoard->SetDigitY(imt,iy,amp); | |
678 | ||
679 | // extended y-strips | |
680 | for (Int_t io = 1; io <= over; io++) { | |
681 | if (io == pos) continue; | |
682 | board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos); | |
683 | board->SetDigitY(imt,iy,amp); | |
684 | } | |
685 | ||
686 | } | |
687 | ||
688 | } | |
689 | ||
690 | } | |
691 | ||
692 | //__________________________________________________________________________ | |
693 | void AliMUONTriggerGUIbdmap::ResetDigits() | |
694 | { | |
695 | /// set the board digits from GUI input (set/unset) | |
696 | ||
697 | Int_t amp = 0; | |
698 | Int_t number = fBoard->GetNumber(); | |
699 | AliMUONTriggerGUIboard *board; | |
700 | Int_t pos, over; | |
701 | pos = fBoard->GetPosition(); | |
702 | over = fBoard->GetYOver(); | |
703 | ||
704 | for (Int_t imt = 0; imt < kNMT; imt++) { | |
705 | for (Int_t ix = 0; ix < fNStripX; ix++) { | |
706 | fXDigBox[imt][ix]->SetFillStyle(0); | |
707 | fXDigBox[imt][ix]->SetX1(-fBoard->GetXCenter(imt)); | |
708 | fXDigBox[imt][ix]->SetY1(-fBoard->GetYCenter(imt)); | |
709 | fXDigBox[imt][ix]->SetX2(-fBoard->GetXCenter(imt)); | |
710 | fXDigBox[imt][ix]->SetY2(-fBoard->GetYCenter(imt)); | |
711 | ||
712 | fBoard->SetDigitX(imt,ix,amp); | |
713 | } | |
714 | for (Int_t iy = 0; iy < fNStripY; iy++) { | |
715 | fYDigBox[imt][iy]->SetFillStyle(0); | |
716 | fYDigBox[imt][iy]->SetX1(-fBoard->GetXCenter(imt)); | |
717 | fYDigBox[imt][iy]->SetY1(-fBoard->GetYCenter(imt)); | |
718 | fYDigBox[imt][iy]->SetX2(-fBoard->GetXCenter(imt)); | |
719 | fYDigBox[imt][iy]->SetY2(-fBoard->GetYCenter(imt)); | |
720 | ||
721 | fBoard->SetDigitY(imt,iy,amp); | |
722 | ||
723 | // extended y-strips | |
724 | for (Int_t io = 1; io <= over; io++) { | |
725 | if (io == pos) continue; | |
726 | board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos); | |
727 | ||
728 | board->SetDigitY(imt,iy,amp); | |
729 | ||
730 | } | |
731 | ||
732 | } | |
733 | } | |
734 | ||
735 | fBoard->ClearXDigits(); | |
736 | fBoard->ClearYDigits(); | |
737 | ||
738 | // extended y-strips | |
739 | for (Int_t io = 1; io <= over; io++) { | |
740 | if (io == pos) continue; | |
741 | board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos); | |
742 | board->ClearYDigits(); | |
743 | } | |
744 | ||
745 | fXStrips->SetState(kButtonUp); | |
746 | fYStrips->SetState(kButtonUp); | |
747 | fEditStrips->SetState(kButtonUp); | |
748 | fIsEditable = kFALSE; | |
749 | ||
750 | DrawClear(); | |
751 | fXOn = kFALSE; | |
752 | fYOn = kFALSE; | |
753 | ||
754 | } | |
755 | ||
756 | //__________________________________________________________________________ | |
757 | void AliMUONTriggerGUIbdmap::HandleButtons(Int_t id) | |
758 | { | |
759 | /// handle the check buttons | |
760 | ||
761 | if (id == -1) { | |
762 | TGButton *btn = (TGButton *) gTQSender; | |
763 | id = btn->WidgetId(); | |
764 | } | |
765 | ||
766 | // draw x and y | |
767 | if(fXStrips->GetState() == kButtonDown && | |
768 | fYStrips->GetState() == kButtonDown ) { | |
769 | ||
770 | DrawClear(); | |
771 | DrawStrips(kTRUE,kTRUE); | |
772 | DrawDigits(kTRUE,kTRUE); | |
773 | fXOn = kTRUE; | |
774 | fYOn = kTRUE; | |
775 | ||
776 | } | |
777 | ||
778 | // draw only x | |
779 | if(fXStrips->GetState() == kButtonDown && | |
780 | fYStrips->GetState() == kButtonUp ) { | |
781 | ||
782 | DrawClear(); | |
783 | DrawStrips(kTRUE,kFALSE); | |
784 | DrawDigits(kTRUE,kFALSE); | |
785 | fXOn = kTRUE; | |
786 | fYOn = kFALSE; | |
787 | ||
788 | } | |
789 | ||
790 | // draw only y | |
791 | if(fXStrips->GetState() == kButtonUp && | |
792 | fYStrips->GetState() == kButtonDown ) { | |
793 | ||
794 | DrawClear(); | |
795 | DrawStrips(kFALSE,kTRUE); | |
796 | DrawDigits(kFALSE,kTRUE); | |
797 | fXOn = kFALSE; | |
798 | fYOn = kTRUE; | |
799 | ||
800 | } | |
801 | ||
802 | // clear | |
803 | if(fXStrips->GetState() == kButtonUp && | |
804 | fYStrips->GetState() == kButtonUp ) { | |
805 | ||
806 | DrawClear(); | |
807 | fXOn = kFALSE; | |
808 | fYOn = kFALSE; | |
809 | ||
810 | } | |
811 | ||
812 | HandleEditButton(); | |
813 | ||
814 | } | |
815 | ||
816 | //__________________________________________________________________________ | |
817 | void AliMUONTriggerGUIbdmap::DrawClear() | |
818 | { | |
819 | /// draw the frame of the board image in the canvas | |
820 | ||
821 | for (Int_t i = 0; i < kNMT; i++) { | |
822 | ||
823 | fCanvas[i]->cd(); | |
824 | fCanvas[i]->Clear(); | |
825 | ||
826 | fCanvas[i]->Modified(); | |
827 | fCanvas[i]->Update(); | |
828 | ||
829 | } | |
830 | ||
831 | } | |
832 | ||
833 | //__________________________________________________________________________ | |
834 | void AliMUONTriggerGUIbdmap::DrawDigits(Bool_t bx, Bool_t by) | |
835 | { | |
836 | /// draw the digits in "x" or/and "y" | |
837 | ||
8b067dfe | 838 | Bool_t drawDigits = kTRUE; |
839 | Bool_t drawDigitsRaw = kTRUE; | |
840 | if (fLoader == 0x0) { | |
841 | drawDigits = kFALSE; | |
842 | } | |
843 | if (fRawDigitStore == 0x0) { | |
844 | drawDigitsRaw = kFALSE; | |
845 | } | |
905654c2 | 846 | |
847 | AliMUONTriggerGUIboard *board; | |
bae1aa70 | 848 | Int_t over, pos, number; |
905654c2 | 849 | const AliMpVSegmentation* seg; |
905654c2 | 850 | AliMpPad pad; |
851 | Int_t cathode, detElemId, ix, iy, charge; | |
852 | Int_t chamber, np = 5; | |
853 | AliMpDEIterator it; | |
854 | Float_t xpmin, xpmax, ypmin, ypmax; | |
855 | Float_t xg1, xg2, yg1, yg2, zg1; | |
856 | Float_t xdw, ydw, xcw, ycw; | |
857 | Double_t xc1, xc2, yc1, yc2; | |
270b8cf5 | 858 | Char_t cln[3]; |
905654c2 | 859 | TBox *boxd; |
860 | Double_t xMin, xMax, yMin, yMax; | |
861 | Double_t *px, *py; | |
8b067dfe | 862 | |
905654c2 | 863 | number = fBoard->GetNumber(); |
864 | pos = fBoard->GetPosition(); | |
865 | over = fBoard->GetYOver(); | |
bae1aa70 | 866 | |
8b067dfe | 867 | if (drawDigits || drawDigitsRaw) { |
905654c2 | 868 | |
8b067dfe | 869 | for (Int_t i = 0; i < kNMT; i++) { |
870 | ||
905654c2 | 871 | fCanvas[i]->cd(); |
872 | ||
873 | fCanvas[i]->GetRange(xc1,yc1,xc2,yc2); | |
874 | xcw = (Float_t)(0.5*(xc2-xc1)); | |
875 | ycw = (Float_t)(0.5*(yc2-yc1)); | |
876 | ||
8b067dfe | 877 | AliMUONVDigitStore *digitStore = 0x0; |
878 | AliMUONGeometryTransformer transformer; | |
879 | transformer.LoadGeometryData("transform.dat"); | |
905654c2 | 880 | |
8b067dfe | 881 | if (drawDigits) { |
882 | AliRunLoader *runLoader = fLoader->GetRunLoader(); | |
883 | digitStore = fMCDataInterface->DigitStore(runLoader->GetEventNumber()); | |
884 | } | |
885 | if (drawDigitsRaw) { | |
886 | digitStore = static_cast<AliMUONVDigitStore*>(fRawDigitStore); | |
887 | } | |
888 | ||
889 | chamber = 11+i; | |
890 | ||
168e9c4d | 891 | MpPair_t deRange = AliMpDEManager::GetDetElemIdRange(chamber-1); |
892 | TIter next(digitStore->CreateIterator(AliMp::PairFirst(deRange),AliMp::PairSecond(deRange))); | |
bae1aa70 | 893 | AliMUONVDigit *mdig; |
8b067dfe | 894 | |
bae1aa70 | 895 | while ( ( mdig = static_cast<AliMUONVDigit*>(next())) ) |
8b067dfe | 896 | { |
897 | cathode = mdig->Cathode(); | |
898 | ||
899 | ix = mdig->PadX(); | |
900 | iy = mdig->PadY(); | |
901 | detElemId = mdig->DetElemId(); | |
902 | charge = (Int_t)mdig->Charge(); | |
903 | ||
904 | Bool_t triggerBgn = kFALSE; | |
905 | Int_t schg = (Int_t)(charge + 0.5); | |
906 | // APPLY CONDITION ON SOFT BACKGROUND | |
907 | Int_t tchg = schg - (Int_t(schg/10))*10; | |
908 | if (schg<=10 || tchg>0) { | |
909 | triggerBgn = kFALSE; | |
910 | } else { | |
911 | triggerBgn = kTRUE; | |
912 | } | |
913 | ||
914 | if (detElemId%100 != fBoard->GetDetElemId()) continue; | |
915 | ||
916 | seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cathode)); | |
917 | ||
168e9c4d | 918 | pad = seg->PadByIndices(ix,iy,kTRUE); |
8b067dfe | 919 | |
920 | //if (cathode == 0) printf("GUI x: ix %d iy %d \n",ix,iy); | |
921 | //if (cathode == 1) printf("GUI y: ix %d iy %d \n",ix,iy); | |
922 | ||
923 | // get the pad position and dimensions | |
6e97fbb8 | 924 | Float_t xlocal1 = pad.GetPositionX(); |
925 | Float_t ylocal1 = pad.GetPositionY(); | |
926 | Float_t xlocal2 = pad.GetDimensionX(); | |
927 | Float_t ylocal2 = pad.GetDimensionY(); | |
8b067dfe | 928 | |
929 | transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1); | |
930 | // (no transformation for pad dimensions) | |
931 | xg2 = xlocal2; | |
932 | yg2 = ylocal2; | |
933 | ||
934 | // transform in the monitor coordinate system | |
935 | // ALICE SC | |
936 | xpmin = +(xg1-xg2); | |
937 | xpmax = +(xg1+xg2); | |
938 | ypmin = -(yg2-yg1); | |
939 | ypmax = +(yg2+yg1); | |
940 | ||
941 | xpmin -= fXCenter[i]; | |
942 | xpmax -= fXCenter[i]; | |
943 | ypmin -= fYCenter[i]; | |
944 | ypmax -= fYCenter[i]; | |
945 | ||
946 | xdw = xpmax-xpmin; | |
947 | ydw = ypmax-ypmin; | |
948 | ||
949 | // x-strips | |
950 | if ((xdw > ydw) && bx) { | |
951 | ||
952 | //printf("X strips mdig->Cathode() = %1d \n",mdig->Cathode()); | |
953 | ||
954 | Int_t iX, iY1, iY2; | |
955 | iX = fBoard->GetXSix(); | |
956 | iY1 = fBoard->GetXSiy1(); | |
957 | iY2 = fBoard->GetXSiy2(); | |
958 | if (ix == iX && iy >= iY1 && iy <= iY2) { | |
959 | //printf("Digit indices (x-strip) ix = %3d iy = %3d board = %s %d chamber = %2d \n",ix,iy,fBoard->GetBoardName(),fBoard->GetNumber(),chamber); | |
960 | /* | |
961 | xpmin += 0.01*fXWidth[i]; | |
962 | xpmax -= 0.01*fXWidth[i]; | |
963 | ypmin += 0.1*ydw; | |
964 | ypmax -= 0.1*ydw; | |
965 | */ | |
966 | boxd = new TBox(xpmin,ypmin,xpmax,ypmax); | |
967 | boxd->SetFillStyle(1001); | |
968 | if (triggerBgn) boxd->SetFillColor(6); | |
969 | else boxd->SetFillColor(5); | |
970 | boxd->SetBit(kCannotPick); | |
971 | boxd->Draw(); | |
972 | ||
973 | fXDigBox[i][iy-iY1]->SetFillStyle(1001); | |
974 | fXDigBox[i][iy-iY1]->SetFillColor(2); | |
975 | fXDigBox[i][iy-iY1]->SetX1(xpmin); | |
976 | fXDigBox[i][iy-iY1]->SetY1(ypmin); | |
977 | fXDigBox[i][iy-iY1]->SetX2(xpmax); | |
978 | fXDigBox[i][iy-iY1]->SetY2(ypmax); | |
979 | fXDigBox[i][iy-iY1]->Draw(); | |
980 | ||
b785c4bd | 981 | snprintf(cln,3,"%2d",(iy-iY1)); |
8b067dfe | 982 | fXLabelL[i][iy-iY1]->Clear(); |
983 | fXLabelL[i][iy-iY1]->AddText(cln); | |
984 | fXLabelL[i][iy-iY1]->Draw(); | |
985 | fXLabelR[i][iy-iY1]->Clear(); | |
986 | fXLabelR[i][iy-iY1]->AddText(cln); | |
987 | fXLabelR[i][iy-iY1]->Draw(); | |
988 | ||
989 | fBoard->SetDigitX(i,iy-iY1,charge); | |
990 | ||
991 | } | |
905654c2 | 992 | |
905654c2 | 993 | } |
8b067dfe | 994 | |
995 | // y-strips | |
996 | if ((xdw < ydw) && by) { | |
997 | ||
998 | //printf("Y strips mdig->Cathode() = %1d \n",mdig->Cathode()); | |
999 | ||
1000 | Int_t iX1, iX2, iY; | |
1001 | iX1 = fBoard->GetYSix1(); | |
1002 | iX2 = fBoard->GetYSix2(); | |
1003 | iY = fBoard->GetYSiy(); | |
1004 | if (ix >= iX1 && ix <= iX2 && iy == iY) { | |
1005 | //printf("Digit indices (y-strip) ix = %3d iy = %3d board = %s chamber = %2d \n",ix,iy,fBoard->GetBoardName(),chamber); | |
1006 | ypmin = -0.5*fYWidth[i]; | |
1007 | ypmax = +0.5*fYWidth[i]; | |
1008 | /* | |
1009 | ypmin = -0.5*fYWidth[i]; | |
1010 | ypmax = +0.5*fYWidth[i]; | |
1011 | ypmin += 0.01*fYWidth[i]; | |
1012 | ypmax -= 0.01*fYWidth[i]; | |
1013 | xpmin += 0.1*xdw; | |
1014 | xpmax -= 0.1*xdw; | |
1015 | */ | |
1016 | boxd = new TBox(xpmin,ypmin,xpmax,ypmax); | |
1017 | boxd->SetFillStyle(1001); | |
1018 | if (triggerBgn) boxd->SetFillColor(6); | |
1019 | else boxd->SetFillColor(5); | |
1020 | boxd->SetBit(kCannotPick); | |
1021 | boxd->Draw(); | |
1022 | ||
1023 | fYDigBox[i][ix-iX1]->SetFillStyle(1001); | |
1024 | fYDigBox[i][ix-iX1]->SetFillColor(2); | |
1025 | fYDigBox[i][ix-iX1]->SetX1(xpmin); | |
1026 | fYDigBox[i][ix-iX1]->SetY1(ypmin); | |
1027 | fYDigBox[i][ix-iX1]->SetX2(xpmax); | |
1028 | fYDigBox[i][ix-iX1]->SetY2(ypmax); | |
1029 | fYDigBox[i][ix-iX1]->Draw(); | |
1030 | ||
b785c4bd | 1031 | snprintf(cln,3,"%2d",(ix-iX1)); |
8b067dfe | 1032 | fYLabelL[i][ix-iX1]->Clear(); |
1033 | fYLabelL[i][ix-iX1]->AddText(cln); | |
1034 | fYLabelL[i][ix-iX1]->Draw(); | |
1035 | fYLabelR[i][ix-iX1]->Clear(); | |
1036 | fYLabelR[i][ix-iX1]->AddText(cln); | |
1037 | fYLabelR[i][ix-iX1]->Draw(); | |
1038 | ||
1039 | fBoard->SetDigitY(i,ix-iX1,charge); | |
1040 | ||
1041 | // extended y-strips | |
1042 | for (Int_t io = 1; io <= over; io++) { | |
1043 | if (io == pos) continue; | |
1044 | board = (AliMUONTriggerGUIboard*)fBoards->UncheckedAt(number+io-pos); | |
1045 | board->SetDigitY(i,ix-iX1,charge); | |
1046 | } | |
1047 | ||
1048 | } | |
1049 | } | |
1050 | ||
1051 | } // end digits loop | |
905654c2 | 1052 | |
8b067dfe | 1053 | } // end chamber loop |
905654c2 | 1054 | |
8b067dfe | 1055 | } // end drawDigits |
905654c2 | 1056 | |
8b067dfe | 1057 | // DSET digits |
1058 | for (Int_t i = 0; i < kNMT; i++) { | |
1059 | ||
1060 | fCanvas[i]->cd(); | |
1061 | ||
1062 | fCanvas[i]->GetRange(xc1,yc1,xc2,yc2); | |
1063 | xcw = (Float_t)(0.5*(xc2-xc1)); | |
1064 | ycw = (Float_t)(0.5*(yc2-yc1)); | |
905654c2 | 1065 | |
1066 | // x-strips DSET | |
1067 | if (bx) { | |
1068 | ||
94e6e78e | 1069 | for (ix = 0; ix < fNStripX; ix++) { |
905654c2 | 1070 | //if (fBoard->GetXDig(i,ix) > 0) { |
1071 | if (fXDigBox[i][ix]->GetFillStyle() == 1001 || | |
1072 | fBoard->GetXDig(i,ix) > 0) { | |
1073 | ||
1074 | px = fXDigPL[i][ix]->GetX(); | |
1075 | py = fXDigPL[i][ix]->GetY(); | |
1076 | ||
1077 | xMin = +9999.; | |
1078 | xMax = -9999.; | |
1079 | yMin = +9999.; | |
1080 | yMax = -9999.; | |
1081 | for (Int_t ip = 0; ip < np; ip++) { | |
1082 | xMin = TMath::Min(xMin,px[ip]); | |
1083 | xMax = TMath::Max(xMax,px[ip]); | |
1084 | yMin = TMath::Min(yMin,py[ip]); | |
1085 | yMax = TMath::Max(yMax,py[ip]); | |
1086 | } | |
1087 | ||
1088 | if (fXDigBox[i][ix]->GetFillStyle() == 0) { | |
1089 | fXDigBox[i][ix]->SetFillStyle(1001); | |
1090 | fXDigBox[i][ix]->SetFillColor(2); | |
1091 | fXDigBox[i][ix]->SetX1(xMin); | |
1092 | fXDigBox[i][ix]->SetY1(yMin); | |
1093 | fXDigBox[i][ix]->SetX2(xMax); | |
1094 | fXDigBox[i][ix]->SetY2(yMax); | |
1095 | } | |
1096 | ||
b785c4bd | 1097 | snprintf(cln,3,"%2d",ix); |
905654c2 | 1098 | |
1099 | fXLabelL[i][ix]->Clear(); | |
1100 | fXLabelL[i][ix]->AddText(cln); | |
1101 | fXLabelL[i][ix]->Draw(); | |
1102 | ||
1103 | fXLabelR[i][ix]->Clear(); | |
1104 | fXLabelR[i][ix]->AddText(cln); | |
1105 | fXLabelR[i][ix]->Draw(); | |
1106 | ||
1107 | fXDigBox[i][ix]->Draw(); | |
1108 | ||
1109 | } | |
1110 | ||
1111 | } | |
1112 | ||
1113 | } | |
1114 | ||
1115 | // y-strips DSET | |
1116 | if (by) { | |
1117 | ||
94e6e78e | 1118 | for (iy = 0; iy < fNStripY; iy++) { |
905654c2 | 1119 | //if (fBoard->GetYDig(i,iy) > 0) { |
1120 | if (fYDigBox[i][iy]->GetFillStyle() == 1001 || | |
1121 | fBoard->GetYDig(i,iy) > 0) { | |
1122 | ||
1123 | px = fYDigPL[i][iy]->GetX(); | |
1124 | py = fYDigPL[i][iy]->GetY(); | |
1125 | ||
1126 | xMin = +9999.; | |
1127 | xMax = -9999.; | |
1128 | yMin = +9999.; | |
1129 | yMax = -9999.; | |
1130 | for (Int_t ip = 0; ip < np; ip++) { | |
1131 | xMin = TMath::Min(xMin,px[ip]); | |
1132 | xMax = TMath::Max(xMax,px[ip]); | |
1133 | yMin = TMath::Min(yMin,py[ip]); | |
1134 | yMax = TMath::Max(yMax,py[ip]); | |
1135 | } | |
1136 | ||
1137 | if (fYDigBox[i][iy]->GetFillStyle() == 0) { | |
1138 | fYDigBox[i][iy]->SetFillStyle(1001); | |
1139 | fYDigBox[i][iy]->SetFillColor(2); | |
1140 | fYDigBox[i][iy]->SetX1(xMin); | |
1141 | fYDigBox[i][iy]->SetY1(yMin); | |
1142 | fYDigBox[i][iy]->SetX2(xMax); | |
1143 | fYDigBox[i][iy]->SetY2(yMax); | |
1144 | } | |
1145 | ||
b785c4bd | 1146 | snprintf(cln,3,"%2d",iy); |
905654c2 | 1147 | |
1148 | fYLabelL[i][iy]->Clear(); | |
1149 | fYLabelL[i][iy]->AddText(cln); | |
1150 | fYLabelL[i][iy]->Draw(); | |
1151 | ||
1152 | fYLabelR[i][iy]->Clear(); | |
1153 | fYLabelR[i][iy]->AddText(cln); | |
1154 | fYLabelR[i][iy]->Draw(); | |
1155 | ||
905654c2 | 1156 | fYDigBox[i][iy]->Draw(); |
1157 | ||
1158 | } | |
1159 | ||
1160 | } | |
1161 | ||
1162 | } | |
1163 | ||
1164 | fCanvas[i]->Modified(); | |
1165 | fCanvas[i]->Update(); | |
1166 | ||
8b067dfe | 1167 | } // end canvas (chamber) loop |
905654c2 | 1168 | |
1169 | fMain->MapWindow(); | |
1170 | ||
1171 | } | |
1172 | ||
1173 | //__________________________________________________________________________ | |
1174 | void AliMUONTriggerGUIbdmap::DrawStrips(Bool_t bx, Bool_t by) | |
1175 | { | |
1176 | /// draw the "x" or/and "y" strips | |
1177 | ||
8b067dfe | 1178 | AliMUONGeometryTransformer transformer; |
1179 | transformer.LoadGeometryData("transform.dat"); | |
905654c2 | 1180 | |
1181 | const AliMpVSegmentation* seg; | |
1182 | AliMpPad pad; | |
1183 | AliMpDEIterator it; | |
1184 | Int_t chamber; | |
1185 | Float_t xg1, xg2, yg1, yg2, zg1; | |
1186 | Float_t xlocal1, xlocal2, ylocal1, ylocal2; | |
8b067dfe | 1187 | Int_t detElemId, maxX, maxY; |
905654c2 | 1188 | Float_t xdw, ydw, xpmin, xpmax, ypmin, ypmax; |
1189 | Float_t ptx1, ptx2, pty1, pty2; | |
270b8cf5 | 1190 | Char_t cln[3]; |
905654c2 | 1191 | Double_t xc1, xc2, yc1, yc2; |
1192 | Float_t xcw, ycw; | |
1193 | ||
1194 | Bool_t makeLabelsX = kFALSE; | |
1195 | Bool_t makeLabelsY = kFALSE; | |
1196 | ||
1197 | if (bx && !fLabelX) { | |
1198 | makeLabelsX = kTRUE; | |
1199 | fLabelX = kTRUE; | |
1200 | } | |
1201 | ||
1202 | if (by && !fLabelY) { | |
1203 | makeLabelsY = kTRUE; | |
1204 | fLabelY = kTRUE; | |
1205 | } | |
1206 | ||
1207 | for (Int_t i = 0; i < kNMT; i++) { | |
1208 | ||
1209 | fCanvas[i]->cd(); | |
1210 | ||
1211 | fCanvas[i]->GetRange(xc1,yc1,xc2,yc2); | |
1212 | xcw = (Float_t)(0.5*(xc2-xc1)); | |
1213 | ycw = (Float_t)(0.5*(yc2-yc1)); | |
1214 | ||
1215 | chamber = 11+i; | |
1216 | ||
1217 | for ( it.First(chamber-1); ! it.IsDone(); it.Next() ) { | |
1218 | ||
1219 | detElemId = it.CurrentDEId(); | |
1220 | ||
1221 | if (detElemId%100 != fBoard->GetDetElemId()) continue; | |
1222 | ||
8b067dfe | 1223 | /*---------- y-pads ic = 1 ----------*/ |
905654c2 | 1224 | |
8b067dfe | 1225 | seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath1); |
905654c2 | 1226 | |
1227 | maxX = seg->MaxPadIndexX(); | |
1228 | maxY = seg->MaxPadIndexY(); | |
1229 | ||
1230 | for (Int_t ix = 0; ix <= maxX; ix++) { | |
1231 | for (Int_t iy = 0; iy <= maxY; iy++) { | |
1232 | ||
168e9c4d | 1233 | pad = seg->PadByIndices(ix,iy,kFALSE); |
905654c2 | 1234 | |
1235 | if (!pad.IsValid()) continue; | |
1236 | ||
1237 | // get the pad position and dimensions | |
6e97fbb8 | 1238 | xlocal1 = pad.GetPositionX(); |
1239 | ylocal1 = pad.GetPositionY(); | |
1240 | xlocal2 = pad.GetDimensionX(); | |
1241 | ylocal2 = pad.GetDimensionY(); | |
905654c2 | 1242 | |
8b067dfe | 1243 | transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1); |
905654c2 | 1244 | // (no transformation for pad dimensions) |
1245 | xg2 = xlocal2; | |
1246 | yg2 = ylocal2; | |
1247 | ||
1248 | // transform in the monitor coordinate system | |
905654c2 | 1249 | // ALICE SC |
1250 | xpmin = +(xg1-xg2); | |
1251 | xpmax = +(xg1+xg2); | |
1252 | ypmin = -(yg2-yg1); | |
1253 | ypmax = +(yg2+yg1); | |
1254 | ||
1255 | xpmin -= fXCenter[i]; | |
1256 | xpmax -= fXCenter[i]; | |
1257 | ypmin -= fYCenter[i]; | |
1258 | ypmax -= fYCenter[i]; | |
1259 | ||
1260 | xdw = xpmax-xpmin; | |
1261 | ydw = ypmax-ypmin; | |
1262 | ||
1263 | // y-strips | |
1264 | if (by) { | |
1265 | ||
1266 | Int_t iX1, iX2, iY, ixDig; | |
1267 | iX1 = fBoard->GetYSix1(); | |
1268 | iX2 = fBoard->GetYSix2(); | |
1269 | iY = fBoard->GetYSiy(); | |
1270 | if (ix >= iX1 && ix <= iX2 && iy == iY) { | |
1271 | ||
1272 | ypmin = -0.5*fYWidth[i]; | |
1273 | ypmax = +0.5*fYWidth[i]; | |
1274 | /* | |
1275 | ypmin += 0.01*fYWidth[i]; | |
1276 | ypmax -= 0.01*fYWidth[i]; | |
1277 | xpmin += 0.1*xdw; | |
1278 | xpmax -= 0.1*xdw; | |
1279 | */ | |
1280 | ixDig = ix - iX1; | |
1281 | fYDigPL[i][ixDig]->SetPoint(0,xpmin,ypmin); | |
1282 | fYDigPL[i][ixDig]->SetPoint(1,xpmax,ypmin); | |
1283 | fYDigPL[i][ixDig]->SetPoint(2,xpmax,ypmax); | |
1284 | fYDigPL[i][ixDig]->SetPoint(3,xpmin,ypmax); | |
1285 | fYDigPL[i][ixDig]->SetPoint(4,xpmin,ypmin); | |
1286 | fYDigPL[i][ixDig]->Draw(); | |
1287 | /* | |
1288 | fYDigBox[i][ixDig]->SetFillStyle(1001); | |
1289 | fYDigBox[i][ixDig]->SetFillColor(5); | |
1290 | fYDigBox[i][ixDig]->DrawBox(xpmin,ypmin,xpmax,ypmax); | |
1291 | */ | |
1292 | if (makeLabelsY) { | |
b785c4bd | 1293 | snprintf(cln,3,"%2d",(ix-iX1)); |
905654c2 | 1294 | ptx1 = xpmin; |
1295 | ptx2 = xpmax; | |
1296 | ||
1297 | pty1 = 1.065*ypmin - 0.04*ycw; | |
1298 | pty2 = 1.065*ypmin + 0.04*ycw; | |
1299 | fYLabelL[i][ix-iX1] = new TPaveText(ptx1,pty1,ptx2,pty2); | |
1300 | fYLabelL[i][ix-iX1]->SetBorderSize(0); | |
1301 | fYLabelL[i][ix-iX1]->SetBit(kCannotPick); | |
1302 | ||
1303 | pty1 = 1.065*ypmax - 0.04*ycw; | |
1304 | pty2 = 1.065*ypmax + 0.04*ycw; | |
1305 | fYLabelR[i][ix-iX1] = new TPaveText(ptx1,pty1,ptx2,pty2); | |
1306 | fYLabelR[i][ix-iX1]->SetBorderSize(0); | |
1307 | fYLabelR[i][ix-iX1]->SetBit(kCannotPick); | |
1308 | } | |
1309 | ||
1310 | } | |
1311 | ||
1312 | } | |
1313 | ||
1314 | } // end maxY | |
1315 | ||
1316 | } // end maxX | |
1317 | ||
8b067dfe | 1318 | /*---------- x-pads ic = 0 ----------*/ |
905654c2 | 1319 | |
8b067dfe | 1320 | seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0); |
905654c2 | 1321 | |
1322 | maxX = seg->MaxPadIndexX(); | |
1323 | maxY = seg->MaxPadIndexY(); | |
1324 | ||
1325 | for (Int_t ix = 0; ix <= maxX; ix++) { | |
1326 | for (Int_t iy = 0; iy <= maxY; iy++) { | |
1327 | ||
168e9c4d | 1328 | pad = seg->PadByIndices(ix,iy,kFALSE); |
905654c2 | 1329 | |
1330 | if (!pad.IsValid()) continue; | |
1331 | ||
1332 | // get the pad position and dimensions | |
6e97fbb8 | 1333 | xlocal1 = pad.GetPositionX(); |
1334 | ylocal1 = pad.GetPositionY(); | |
1335 | xlocal2 = pad.GetDimensionX(); | |
1336 | ylocal2 = pad.GetDimensionY(); | |
905654c2 | 1337 | |
8b067dfe | 1338 | transformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1); |
905654c2 | 1339 | // (no transformation for pad dimensions) |
1340 | xg2 = xlocal2; | |
1341 | yg2 = ylocal2; | |
1342 | ||
1343 | // transform in the monitor coordinate system | |
905654c2 | 1344 | // ALICE SC |
1345 | xpmin = +(xg1-xg2); | |
1346 | xpmax = +(xg1+xg2); | |
1347 | ypmin = -(yg2-yg1); | |
1348 | ypmax = +(yg2+yg1); | |
1349 | ||
1350 | xpmin -= fXCenter[i]; | |
1351 | xpmax -= fXCenter[i]; | |
1352 | ypmin -= fYCenter[i]; | |
1353 | ypmax -= fYCenter[i]; | |
1354 | xdw = xpmax-xpmin; | |
1355 | ydw = ypmax-ypmin; | |
1356 | ||
1357 | // x-strips | |
1358 | if (bx) { | |
1359 | ||
1360 | Int_t iX, iY1, iY2, iyDig; | |
1361 | iX = fBoard->GetXSix(); | |
1362 | iY1 = fBoard->GetXSiy1(); | |
1363 | iY2 = fBoard->GetXSiy2(); | |
1364 | if (ix == iX && iy >= iY1 && iy <= iY2) { | |
1365 | /* | |
1366 | xpmin += 0.01*fXWidth[i]; | |
1367 | xpmax -= 0.01*fXWidth[i]; | |
1368 | ypmin += 0.1*ydw; | |
1369 | ypmax -= 0.1*ydw; | |
1370 | */ | |
1371 | iyDig = iy - iY1; | |
1372 | fXDigPL[i][iyDig]->SetPoint(0,xpmin,ypmin); | |
1373 | fXDigPL[i][iyDig]->SetPoint(1,xpmax,ypmin); | |
1374 | fXDigPL[i][iyDig]->SetPoint(2,xpmax,ypmax); | |
1375 | fXDigPL[i][iyDig]->SetPoint(3,xpmin,ypmax); | |
1376 | fXDigPL[i][iyDig]->SetPoint(4,xpmin,ypmin); | |
1377 | fXDigPL[i][iyDig]->Draw(); | |
1378 | /* | |
1379 | fXDigBox[i][iyDig]->SetFillStyle(1001); | |
1380 | fXDigBox[i][iyDig]->SetFillColor(5); | |
1381 | fXDigBox[i][iyDig]->DrawBox(xpmin,ypmin,xpmax,ypmax); | |
1382 | */ | |
1383 | if (makeLabelsX) { | |
b785c4bd | 1384 | snprintf(cln,3,"%2d",(iy-iY1)); |
905654c2 | 1385 | pty1 = ypmin; |
1386 | pty2 = ypmax; | |
1387 | ||
1388 | ptx1 = 1.065*xpmin - 0.04*xcw; | |
1389 | ptx2 = 1.065*xpmin + 0.04*xcw; | |
1390 | fXLabelL[i][iy-iY1] = new TPaveText(ptx1,pty1,ptx2,pty2); | |
1391 | fXLabelL[i][iy-iY1]->SetBorderSize(0); | |
1392 | fXLabelL[i][iy-iY1]->SetBit(kCannotPick); | |
1393 | ||
1394 | ptx1 = 1.065*xpmax - 0.04*xcw; | |
1395 | ptx2 = 1.065*xpmax + 0.04*xcw; | |
1396 | fXLabelR[i][iy-iY1] = new TPaveText(ptx1,pty1,ptx2,pty2); | |
1397 | fXLabelR[i][iy-iY1]->SetBorderSize(0); | |
1398 | fXLabelR[i][iy-iY1]->SetBit(kCannotPick); | |
1399 | } | |
1400 | ||
1401 | } | |
1402 | ||
1403 | } | |
1404 | ||
1405 | } // end maxY | |
1406 | ||
1407 | } // end maxX | |
1408 | ||
1409 | } // end DEIterator | |
1410 | ||
1411 | fCanvas[i]->Modified(); | |
1412 | fCanvas[i]->Update(); | |
1413 | ||
1414 | } | |
1415 | ||
1416 | fMain->MapWindow(); | |
1417 | ||
1418 | } | |
1419 | ||
1420 | //__________________________________________________________________________ | |
8b067dfe | 1421 | void AliMUONTriggerGUIbdmap::CloseWindow() const |
905654c2 | 1422 | { |
1423 | /// close dialog in response to window manager close. | |
1424 | ||
1425 | delete this; | |
1426 | ||
1427 | } | |
1428 | ||
1429 | //__________________________________________________________________________ | |
1430 | void AliMUONTriggerGUIbdmap::DoClose() | |
1431 | { | |
1432 | /// handle Close button. | |
1433 | ||
1434 | fBoard->SetOpen(kFALSE); | |
1435 | TTimer::SingleShot(150,"AliMUONTriggerGUIbdmap",this,"CloseWindow()"); | |
1436 | ||
1437 | } | |
1438 | ||
1439 |