]>
Commit | Line | Data |
---|---|---|
aef183f7 | 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 | // --- MUON header files --- | |
19 | #include "AliMUONTriggerDisplay.h" | |
aef183f7 | 20 | |
21 | #include "AliMpDDLStore.h" | |
22 | #include "AliMpVSegmentation.h" | |
23 | #include "AliMpSegmentation.h" | |
24 | #include "AliMpConstants.h" | |
25 | #include "AliMpPad.h" | |
26 | #include "AliMpLocalBoard.h" | |
27 | #include "AliMpCDB.h" | |
28 | ||
29 | // --- AliRoot header files --- | |
30 | #include "AliLog.h" | |
31 | ||
32 | // --- ROOT system --- | |
33 | #include <TH1.h> | |
34 | #include <TH2.h> | |
f3d288ab | 35 | #include <TGraph.h> |
aef183f7 | 36 | |
37 | //----------------------------------------------------------------------------- | |
38 | /// \class AliMUONTriggerDisplay | |
39 | /// | |
40 | /// MUON base class for converting histos as a function of strip/board/slat number | |
41 | /// into display histos showing the detection element position in the | |
49e110ec | 42 | /// trigger chamber. |
43 | /// | |
44 | /// Input histos can be given as: | |
45 | /// - TH2 with x -> board # [1-234] and y -> strip # in board [0-15]. Option: kDisplayStrips | |
46 | /// - TH1 with x -> board # [1-234] Option: kDisplayBoards | |
47 | /// - TH1 with x -> slat # [0-17] Option: kDisplaySlats | |
aef183f7 | 48 | /// |
49 | /// \author D. Stocco | |
50 | ||
51 | /// \cond CLASSIMP | |
52 | ClassImp(AliMUONTriggerDisplay) | |
53 | /// \endcond | |
54 | ||
55 | //____________________________________________________________________________ | |
56 | AliMUONTriggerDisplay::AliMUONTriggerDisplay() : | |
57 | TObject() | |
58 | { | |
59 | /// ctor | |
60 | } | |
61 | ||
62 | //__________________________________________________________________ | |
63 | AliMUONTriggerDisplay::~AliMUONTriggerDisplay() | |
64 | { | |
65 | /// dtor | |
66 | } | |
67 | ||
68 | ||
69 | //____________________________________________________________________________ | |
70 | TH2* AliMUONTriggerDisplay::GetEmptyDisplayHisto(TString displayHistoName, EDisplayType displayType, | |
71 | Int_t cathode, Int_t chamber, | |
72 | TString displayHistoTitle) | |
73 | { | |
74 | // | |
75 | /// Return the display histogram with optimized binning | |
76 | /// but do not fill it. | |
77 | // | |
78 | TH2F* displayHisto = new TH2F(); | |
79 | ||
80 | InitOrDisplayTriggerInfo(0x0, displayHisto, displayType, | |
81 | cathode, chamber, displayHistoName, displayHistoTitle); | |
82 | ||
83 | return displayHisto; | |
84 | } | |
85 | ||
86 | ||
87 | //____________________________________________________________________________ | |
88 | TH2* AliMUONTriggerDisplay::GetBoardNumberHisto(TString displayHistoName, | |
89 | Int_t chamber, | |
90 | TString displayHistoTitle) | |
91 | { | |
92 | // | |
93 | /// Return the display histogram with optimized binning | |
94 | /// and fill it with the board number | |
95 | // | |
96 | ||
97 | const Int_t kNboards = AliMpConstants::NofLocalBoards(); | |
98 | TH1F* inputHisto = new TH1F("boardNumbers","Board Numbers",kNboards,0.5,(Float_t)kNboards + 0.5); | |
99 | for(Int_t ibin=1; ibin<=kNboards; ibin++){ | |
100 | inputHisto->Fill(ibin,ibin); | |
101 | } | |
102 | ||
103 | TH2F* displayHisto = (TH2F*)GetEmptyDisplayHisto(displayHistoName, kDisplayBoards, 0, chamber, displayHistoTitle); | |
104 | FillDisplayHistogram(inputHisto,displayHisto,kDisplayBoards,0,chamber,kNumbered); | |
105 | ||
106 | delete inputHisto; | |
107 | ||
108 | displayHisto->SetStats(kFALSE); | |
109 | return displayHisto; | |
110 | } | |
111 | ||
112 | ||
113 | //____________________________________________________________________________ | |
114 | TH2* AliMUONTriggerDisplay::GetDisplayHistogram(TH1* inputHisto, TString displayHistoName, | |
115 | EDisplayType displayType, Int_t cathode, | |
116 | Int_t chamber, TString displayHistoTitle, | |
117 | EDisplayOption displayOpt) | |
118 | { | |
119 | // | |
120 | /// Get histogram displaying the information contained in the input histogram | |
121 | // | |
122 | TH2* displayHisto = GetEmptyDisplayHisto(displayHistoName, displayType, | |
123 | cathode, chamber, displayHistoTitle); | |
124 | ||
125 | FillDisplayHistogram(inputHisto, displayHisto, displayType, cathode, chamber, displayOpt); | |
126 | ||
127 | return displayHisto; | |
128 | } | |
129 | ||
f3d288ab | 130 | //____________________________________________________________________________ |
131 | TH2* AliMUONTriggerDisplay::GetDisplayHistogram(TGraph* inputGraph, TString displayHistoName, | |
132 | EDisplayType displayType, Int_t cathode, | |
133 | Int_t chamber, TString displayHistoTitle, | |
134 | EDisplayOption displayOpt) | |
135 | { | |
136 | // | |
137 | /// Get histogram displaying the information contained in the input graph | |
138 | // | |
139 | TH2* displayHisto = GetEmptyDisplayHisto(displayHistoName, displayType, | |
140 | cathode, chamber, displayHistoTitle); | |
141 | ||
142 | FillDisplayHistogram(inputGraph, displayHisto, displayType, cathode, chamber, displayOpt); | |
143 | ||
144 | return displayHisto; | |
145 | } | |
146 | ||
aef183f7 | 147 | //____________________________________________________________________________ |
148 | Bool_t AliMUONTriggerDisplay::FillDisplayHistogram(TH1* inputHisto, TH2* displayHisto, | |
149 | EDisplayType displayType, Int_t cathode, | |
150 | Int_t chamber, EDisplayOption displayOpt) | |
151 | { | |
152 | // | |
153 | /// Fill a previously initialized display histogram | |
154 | /// with the information contained in inputHisto. | |
155 | /// To get initialized display, please use GetEmptyDisplayHisto method | |
156 | // | |
157 | return InitOrDisplayTriggerInfo(inputHisto, displayHisto, displayType, | |
158 | cathode, chamber, "", "",displayOpt); | |
159 | } | |
160 | ||
161 | //____________________________________________________________________________ | |
f3d288ab | 162 | Bool_t AliMUONTriggerDisplay::FillDisplayHistogram(TGraph* inputGraph, TH2* displayHisto, |
163 | EDisplayType displayType, Int_t cathode, | |
164 | Int_t chamber, EDisplayOption displayOpt) | |
165 | { | |
166 | // | |
167 | /// Fill a previously initialized display histogram | |
168 | /// with the information contained in inputGraph. | |
169 | /// To get initialized display, please use GetEmptyDisplayHisto method | |
170 | // | |
171 | return InitOrDisplayTriggerInfo(inputGraph, displayHisto, displayType, | |
172 | cathode, chamber, "", "",displayOpt); | |
173 | } | |
174 | ||
175 | //____________________________________________________________________________ | |
176 | Bool_t AliMUONTriggerDisplay::InitOrDisplayTriggerInfo(TObject* inputObject, TH2* displayHisto, | |
aef183f7 | 177 | EDisplayType displayType, |
178 | Int_t cathode, Int_t chamber, | |
179 | TString displayHistoName, TString displayHistoTitle, | |
180 | EDisplayOption displayOpt) | |
181 | { | |
182 | // | |
183 | /// Initialize trigger information display histograms using mapping | |
184 | /// Trigger information is displayed in a user-friendly way: | |
185 | /// from local board and strip numbers to their position on chambers. | |
186 | // | |
187 | ||
188 | // Load mapping | |
189 | if ( ! AliMpSegmentation::Instance(kFALSE) ) { | |
190 | /// Load mapping | |
191 | if ( ! AliMpCDB::LoadDDLStore() ) { | |
192 | AliError("Could not access mapping from OCDB !"); | |
193 | AliError("Histograms are not initialized !"); | |
194 | return kFALSE; | |
195 | } | |
196 | } | |
197 | ||
198 | Int_t iCh = (chamber > AliMpConstants::NofTrackingChambers()) ? chamber - 11 : chamber; | |
199 | Int_t iCath = cathode; | |
200 | ||
201 | TArrayD xAxisStrip; | |
202 | TArrayD yAxisStrip; | |
203 | TArrayD xAxisBoard; | |
204 | TArrayD yAxisBoard; | |
205 | ||
206 | Float_t yOffsetLine, xOffsetLine = 0.; | |
207 | ||
208 | const Float_t kResetValue=1234567.; | |
209 | ||
f3d288ab | 210 | if(!inputObject){ |
aef183f7 | 211 | xAxisBoard.Set(55); |
212 | xAxisBoard.Reset(kResetValue); | |
213 | yAxisBoard.Set(50); | |
214 | yAxisBoard.Reset(kResetValue); | |
215 | ||
216 | xAxisStrip.Set(420); | |
217 | xAxisStrip.Reset(kResetValue); | |
218 | yAxisStrip.Set(710); | |
219 | yAxisStrip.Reset(kResetValue); | |
220 | } | |
221 | else if(!displayHisto){ | |
222 | AliWarning("Display histogram not initialized. Please initialize it first!"); | |
223 | return kFALSE; | |
224 | } | |
f3d288ab | 225 | else { |
226 | TH1* inputHisto = dynamic_cast<TH1*>(inputObject); | |
227 | if ( inputHisto ) { | |
228 | if ( inputHisto->GetEntries() == 0 ) { | |
229 | return kTRUE; | |
230 | } | |
231 | } | |
232 | else { | |
233 | TGraph* inputGraph = dynamic_cast<TGraph*>(inputObject); | |
32ceb7fa | 234 | if ( inputGraph ) { |
235 | if ( inputGraph->GetN() == 0 ){ | |
236 | return kTRUE; | |
237 | } | |
238 | } | |
239 | else { | |
240 | AliWarning("The object should inherit from TH1 or TGraph!"); | |
241 | return kFALSE; | |
f3d288ab | 242 | } |
243 | } | |
719914e0 | 244 | } |
aef183f7 | 245 | |
246 | Float_t xWidth, yWidth, yWidthSlat=0., xWidthCol=0.; | |
247 | Float_t x1,x2,y1,y2; | |
248 | Float_t x1b=0., x2b=0., y1b=0., y2b=0.; | |
249 | Float_t xcPad, ycPad; | |
250 | Int_t line=0, slat; | |
251 | Float_t sign = 1.; | |
252 | ||
253 | const Float_t kShiftB = 0.5; | |
254 | const Float_t kShiftS = 0.1; | |
255 | ||
256 | const Float_t kShiftX = (iCath==0) ? kShiftB : kShiftS; | |
257 | const Float_t kShiftY = (iCath==0) ? kShiftS : kShiftB; | |
258 | const Float_t kShiftEl = (displayType==kDisplaySlats) ? 0.01 : kShiftB; | |
259 | ||
260 | Int_t iChamber = iCh + AliMpConstants::NofTrackingChambers(); | |
261 | for(Int_t iLoc = 0; iLoc < AliMpConstants::NofLocalBoards(); iLoc++) { | |
262 | Int_t iBoard = iLoc+1; | |
263 | Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromLocalBoard(iBoard, iChamber); | |
264 | ||
265 | if (!detElemId) continue; | |
266 | ||
267 | AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(iBoard, kFALSE); | |
268 | ||
269 | // skip copy cards | |
270 | if( !localBoard->IsNotified()) | |
271 | continue; | |
272 | ||
273 | // get segmentation | |
274 | const AliMpVSegmentation* seg[2] = { | |
275 | AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(0)), | |
276 | AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(1))}; | |
277 | ||
278 | if(iLoc==0){ | |
168e9c4d | 279 | AliMpPad pad1 = seg[1]->PadByLocation(iBoard,0,kFALSE); |
6e97fbb8 | 280 | yWidthSlat = pad1.GetDimensionY(); |
168e9c4d | 281 | AliMpPad pad0 = seg[0]->PadByLocation(iBoard,0,kFALSE); |
6e97fbb8 | 282 | xOffsetLine = TMath::Abs(pad0.GetPositionX()) + pad0.GetDimensionX(); |
283 | xWidthCol = 2.* pad0.GetDimensionX(); | |
aef183f7 | 284 | } |
285 | ||
286 | // Get ideal global position of DetElemId center | |
287 | slat = detElemId%100; | |
288 | line = (4 + slat)%18; | |
289 | sign = 1.; | |
290 | if(line>8) { | |
291 | line = 17 - line; | |
292 | sign = -1.; | |
293 | } | |
294 | yOffsetLine = (Float_t)(line - 4) * 2. * yWidthSlat; | |
616d91d8 | 295 | |
296 | Int_t nLocations = 1; | |
aef183f7 | 297 | |
298 | for(Int_t cath=0; cath<AliMpConstants::NofCathodes(); cath++){ | |
299 | // Loop on cathodes: | |
300 | // necessary because strip info is read for each cathode | |
301 | // board info is read only from cathode 0 | |
302 | ||
303 | // loop over strips | |
616d91d8 | 304 | for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) { |
aef183f7 | 305 | // get pad from electronics |
32f0a7ea | 306 | |
307 | Int_t offset = 0; | |
dc5d3949 | 308 | if (cath && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) offset = -8; |
32f0a7ea | 309 | |
616d91d8 | 310 | AliMpPad pad = seg[cath]->PadByLocation(iBoard,ibitxy+offset,kFALSE); |
aef183f7 | 311 | |
312 | if (!pad.IsValid()) continue; | |
5bb523d1 | 313 | |
314 | // For non-bending plane fill only the first board covered by the strip | |
315 | // i.e. avoide filling many times the same information | |
316 | if ( cath == 1 && pad.GetLocalBoardId(0) != iBoard ) continue; | |
aef183f7 | 317 | |
6e97fbb8 | 318 | xWidth = pad.GetDimensionX(); |
319 | yWidth = pad.GetDimensionY(); | |
320 | xcPad = sign * (pad.GetPositionX() + xOffsetLine); | |
aef183f7 | 321 | if(line==4) xcPad += 0.75 * sign * xWidthCol; |
6e97fbb8 | 322 | ycPad = pad.GetPositionY() + yOffsetLine; |
616d91d8 | 323 | nLocations = pad.GetNofLocations(); |
324 | Int_t iStrip = pad.GetLocalBoardChannel(0); | |
aef183f7 | 325 | |
326 | if(cath==iCath){ | |
327 | x1 = xcPad - xWidth + kShiftX; | |
328 | y1 = ycPad - yWidth + kShiftY; | |
329 | x2 = xcPad + xWidth - kShiftX; | |
330 | y2 = ycPad + yWidth - kShiftY; | |
331 | ||
f3d288ab | 332 | if(!inputObject){ |
aef183f7 | 333 | AddSortedPoint(x1, xAxisStrip, kResetValue); |
334 | AddSortedPoint(x2, xAxisStrip, kResetValue); | |
335 | ||
336 | AddSortedPoint(y1, yAxisStrip, kResetValue); | |
337 | AddSortedPoint(y2, yAxisStrip, kResetValue); | |
338 | } | |
339 | else if(displayType==kDisplayStrips) | |
f3d288ab | 340 | FillBins(inputObject, displayHisto, iBoard, iStrip, x1, x2, y1, y2, kShiftX, kShiftY, displayOpt); |
aef183f7 | 341 | } |
342 | ||
343 | if(cath==0){ | |
616d91d8 | 344 | if(iStrip==0) { |
aef183f7 | 345 | x1b = xcPad - xWidth + kShiftEl; |
346 | y1b = ycPad - yWidth + kShiftEl; | |
347 | } | |
348 | x2b = xcPad + xWidth - kShiftEl; | |
349 | y2b = ycPad + yWidth - kShiftEl; | |
350 | } | |
616d91d8 | 351 | |
aef183f7 | 352 | } // loop on strips |
353 | ||
354 | // if iCath==0 strip info and board info are both filled -> break! | |
355 | // if iCath==1 board info is filled at cath==0. Strip info to be filled at cath==1 | |
356 | if(iCath==0) break; | |
357 | } // loop on cathodes | |
358 | ||
f3d288ab | 359 | if(!inputObject){ |
aef183f7 | 360 | // Per board |
361 | AddSortedPoint(x1b, xAxisBoard, kResetValue); | |
362 | AddSortedPoint(x2b, xAxisBoard, kResetValue); | |
363 | ||
364 | AddSortedPoint(y1b, yAxisBoard, kResetValue); | |
365 | AddSortedPoint(y2b, yAxisBoard, kResetValue); | |
366 | } | |
367 | else if(displayType==kDisplayBoards) | |
616d91d8 | 368 | FillBins(inputObject, displayHisto, iBoard, -nLocations, x1b, x2b, y1b, y2b, kShiftEl, kShiftEl, displayOpt); |
aef183f7 | 369 | else if(displayType==kDisplaySlats) |
f3d288ab | 370 | FillBins(inputObject, displayHisto, slat, -1, x1b, x2b, y1b, y2b, kShiftEl, kShiftEl, displayOpt); |
aef183f7 | 371 | } // loop on local boards |
372 | ||
f3d288ab | 373 | if ( inputObject ) return kTRUE; |
aef183f7 | 374 | |
375 | displayHisto->Reset(); | |
376 | ||
377 | // Book histos | |
378 | const Float_t kMinDiff = 0.1; | |
379 | ||
380 | TArrayD* currArray[4] = {&xAxisStrip, &yAxisStrip, | |
381 | &xAxisBoard, &yAxisBoard}; | |
382 | for(Int_t iaxis=0; iaxis<4; iaxis++){ | |
383 | Int_t ipoint=0; | |
384 | while(TMath::Abs((*currArray[iaxis])[ipoint]-kResetValue)>kMinDiff) { | |
385 | ipoint++; | |
386 | } | |
387 | if(ipoint>currArray[iaxis]->GetSize()-2) | |
388 | AliWarning(Form("Array size (%i) lower than the number of points!", currArray[iaxis]->GetSize())); | |
389 | currArray[iaxis]->Set(ipoint); | |
390 | } | |
391 | ||
392 | switch(displayType){ | |
393 | case kDisplayStrips: | |
394 | displayHisto->SetBins(xAxisStrip.GetSize()-1, xAxisStrip.GetArray(), | |
395 | yAxisStrip.GetSize()-1, yAxisStrip.GetArray()); | |
396 | break; | |
397 | case kDisplayBoards: | |
398 | case kDisplaySlats: | |
399 | displayHisto->SetBins(xAxisBoard.GetSize()-1, xAxisBoard.GetArray(), | |
400 | yAxisBoard.GetSize()-1, yAxisBoard.GetArray()); | |
401 | break; | |
402 | } | |
403 | ||
404 | displayHisto->SetName(displayHistoName.Data()); | |
405 | displayHisto->SetTitle(displayHistoTitle.Data()); | |
406 | displayHisto->SetXTitle("X (cm)"); | |
407 | displayHisto->SetYTitle("Y (cm)"); | |
408 | //displayHisto->SetStats(kFALSE); | |
409 | ||
410 | return kTRUE; | |
411 | } | |
412 | ||
413 | ||
414 | //____________________________________________________________________________ | |
415 | Bool_t AliMUONTriggerDisplay::AddSortedPoint(Float_t currVal, TArrayD& position, const Float_t kResetValue) | |
416 | { | |
417 | // | |
418 | /// Add sorted point in array according to an increasing order. | |
419 | /// Used to build display histograms axis. | |
420 | // | |
421 | Int_t nEntries = position.GetSize()-1; | |
422 | Float_t tmp1, tmp2; | |
423 | const Float_t kMinDiff = 0.1; | |
424 | for(Int_t i=0; i<nEntries; i++){ | |
425 | if(TMath::Abs(position[i]-currVal)<kMinDiff) return kFALSE; | |
426 | if(TMath::Abs(position[i]-kResetValue)<kMinDiff) { | |
427 | position[i] = currVal; | |
428 | return kTRUE; | |
429 | } | |
430 | if(currVal>position[i]) continue; | |
431 | tmp1 = position[i]; | |
432 | position[i] = currVal; | |
433 | for(Int_t j=i+1; j<nEntries; j++){ | |
434 | tmp2 = position[j]; | |
435 | position[j] = tmp1; | |
436 | tmp1 = tmp2; | |
437 | if(tmp1==kResetValue) break; | |
438 | } | |
439 | return kTRUE; | |
440 | } | |
441 | return kFALSE; | |
442 | } | |
443 | ||
444 | ||
445 | //____________________________________________________________________________ | |
f3d288ab | 446 | void AliMUONTriggerDisplay::FillBins(TObject* inputObject, TH2* displayHisto, |
aef183f7 | 447 | Int_t iElement1, Int_t iElement2, |
448 | Float_t x1, Float_t x2, Float_t y1, Float_t y2, | |
449 | const Float_t kShiftX, const Float_t kShiftY, | |
450 | EDisplayOption displayOpt) | |
451 | { | |
452 | // | |
453 | /// Given the bin in inputHisto, search the corresponding bins | |
454 | /// in display histo and fill it. | |
455 | // | |
aef183f7 | 456 | Int_t binY=0; |
457 | Float_t binContent=0; | |
32ceb7fa | 458 | TH1* inputHisto = dynamic_cast<TH1*>(inputObject); |
459 | if ( inputHisto ) { | |
f3d288ab | 460 | Int_t binX = inputHisto->GetXaxis()->FindBin(iElement1); |
32ceb7fa | 461 | if ( inputObject->IsA()->InheritsFrom("TH2") ) { |
f3d288ab | 462 | binY = inputHisto->GetYaxis()->FindBin(iElement2); |
463 | binContent = inputHisto->GetBinContent(binX, binY); | |
464 | } | |
465 | else binContent = inputHisto->GetBinContent(binX); | |
466 | } | |
467 | else { | |
468 | TGraph* inputGraph = dynamic_cast<TGraph*>(inputObject); | |
32ceb7fa | 469 | if ( inputGraph ) { |
470 | Double_t xpt, ypt; | |
471 | for ( Int_t ipt=0; ipt<inputGraph->GetN(); ipt++){ | |
472 | inputGraph->GetPoint(ipt, xpt, ypt); | |
473 | if ( TMath::Abs(xpt - iElement1) < 0.1 ) { | |
474 | binContent = ypt; | |
475 | break; | |
476 | } | |
f3d288ab | 477 | } |
478 | } | |
32ceb7fa | 479 | else return; |
480 | } | |
aef183f7 | 481 | |
482 | if(binContent==0) { | |
483 | if(displayOpt==kShowZeroes) binContent = 1e-5; | |
484 | else return; | |
485 | } | |
486 | ||
487 | Int_t binX1 = displayHisto->GetXaxis()->FindBin(x1 + 0.01*kShiftX); | |
488 | Int_t binX2 = displayHisto->GetXaxis()->FindBin(x2 - 0.01*kShiftX); | |
489 | Int_t binY1 = displayHisto->GetYaxis()->FindBin(y1 + 0.01*kShiftY); | |
490 | Int_t binY2 = displayHisto->GetYaxis()->FindBin(y2 - 0.01*kShiftY); | |
491 | ||
492 | if(displayOpt==kNumbered) { | |
493 | Int_t meanBin = (binX1+binX2)/2; | |
494 | binX1 = meanBin; | |
495 | binX2 = meanBin; | |
496 | ||
497 | meanBin = (binY1+binY2)/2; | |
498 | binY1 = meanBin; | |
499 | binY2 = meanBin; | |
500 | } | |
501 | ||
719914e0 | 502 | Float_t elementArea = 1.; |
503 | if(displayOpt == kNormalizeToArea) { | |
504 | elementArea = (x2 - x1 + 2*kShiftX) * | |
505 | (y2 - y1 + 2*kShiftY); // In InitOrDisplayTriggerInfo: | |
506 | // x2 = x_c + xHalfWidth - kShiftX | |
507 | // x1 = x_c - xHalfWidth + kShiftX | |
508 | // so x2 - x1 + 2*kShiftX returns the element width. | |
616d91d8 | 509 | |
510 | // If iElement2 is less than 0, then its meaning is the | |
511 | // number of boards covered by one strip | |
512 | // the area has therefore to be multiplied accordingly | |
513 | // This fixes the problem when filling the trigger rate per boards in non-bending plane | |
514 | // which is overestimated since the segmentation is always given by the bending-plane | |
515 | if ( iElement2 < 0 ) elementArea *= -(Double_t)iElement2; | |
719914e0 | 516 | |
517 | } | |
518 | ||
aef183f7 | 519 | for(Int_t ibinx=binX1; ibinx<=binX2; ibinx++){ |
520 | for(Int_t ibiny=binY1; ibiny<=binY2; ibiny++){ | |
719914e0 | 521 | displayHisto->SetBinContent(ibinx,ibiny,binContent/elementArea); |
aef183f7 | 522 | } |
523 | } | |
524 | } | |
525 |