]>
Commit | Line | Data |
---|---|---|
ba030c0e | 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 | ||
88cb7938 | 16 | /* $Id$ */ |
ba030c0e | 17 | |
18 | // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay | |
19 | // | |
20 | // Class AliMUONSt1Segmentation | |
21 | // ------------------------------ | |
5f1df83a | 22 | // Segmentation for MUON station 1 using the external |
ba030c0e | 23 | // mapping package |
5f1df83a | 24 | // Included in AliRoot 2003/01/28 |
ba030c0e | 25 | |
ba030c0e | 26 | #include <TError.h> |
be13daff | 27 | #include <TF1.h> |
ba030c0e | 28 | #include <TObjArray.h> |
29 | #include <TVector2.h> | |
ba030c0e | 30 | |
be13daff | 31 | #include "AliMpPad.h" |
3c25381f | 32 | #include "AliMpPlane.h" |
3c25381f | 33 | #include "AliMpPlaneAreaPadIterator.h" |
be13daff | 34 | #include "AliMpPlaneSegmentation.h" |
ba030c0e | 35 | |
36 | #include "AliMUONSt1Segmentation.h" | |
37 | #include "AliRun.h" | |
38 | #include "AliMUON.h" | |
39 | #include "AliMUONChamber.h" | |
40 | ||
41 | ClassImp(AliMUONSt1Segmentation) | |
42 | ||
43 | const Float_t AliMUONSt1Segmentation::fgkWireD = 0.20; | |
44 | const Float_t AliMUONSt1Segmentation::fgkLengthUnit = 0.1; | |
45 | ||
46 | //______________________________________________________________________________ | |
5f91c9e8 | 47 | AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMpPlaneType planeType) |
ba030c0e | 48 | : AliSegmentation(), |
49 | fPlane(0), | |
50 | fPlaneSegmentation(0), | |
51 | fPlaneIterator(0), | |
52 | fWireD(fgkWireD), | |
53 | fChamber(0), | |
54 | fId(0), | |
55 | fRmin(0.), | |
56 | fRmax(0.), | |
57 | fZ(0.), | |
58 | fIx(0), | |
59 | fIy(0), | |
60 | fX(0.), | |
61 | fY(0.), | |
62 | fSector(0), | |
63 | fXhit(0.), | |
64 | fYhit(0.), | |
65 | fIxt(0), | |
66 | fIyt(0), | |
67 | fIwt(0), | |
68 | fXt(0.), | |
69 | fYt(0.), | |
70 | fCorrA(0) | |
71 | { | |
72 | // Normal constructor | |
4a147321 | 73 | fPlane = AliMpPlane::Create(kStation1, planeType); |
5f91c9e8 | 74 | fPlaneSegmentation = new AliMpPlaneSegmentation(fPlane); |
ba030c0e | 75 | |
76 | fCorrA = new TObjArray(3); | |
77 | fCorrA->AddAt(0,0); | |
78 | fCorrA->AddAt(0,1); | |
79 | fCorrA->AddAt(0,2); | |
80 | } | |
81 | ||
82 | //______________________________________________________________________________ | |
83 | AliMUONSt1Segmentation::AliMUONSt1Segmentation() | |
84 | : AliSegmentation(), | |
85 | fPlane(0), | |
86 | fPlaneSegmentation(0), | |
87 | fPlaneIterator(0), | |
88 | fWireD(fgkWireD), | |
89 | fChamber(0), | |
90 | fId(0), | |
91 | fRmin(0.), | |
92 | fRmax(0.), | |
93 | fZ(0.), | |
94 | fIx(0), | |
95 | fIy(0), | |
96 | fX(0.), | |
97 | fY(0.), | |
98 | fSector(0), | |
99 | fXhit(0.), | |
100 | fYhit(0.), | |
101 | fIxt(0), | |
102 | fIyt(0), | |
103 | fIwt(0), | |
104 | fXt(0.), | |
105 | fYt(0.), | |
106 | fCorrA(0) { | |
107 | // Default Constructor | |
108 | } | |
109 | ||
110 | //______________________________________________________________________________ | |
30178c30 | 111 | AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs) |
112 | : AliSegmentation(rhs) | |
ba030c0e | 113 | { |
114 | // Copy constructor | |
115 | Fatal("Copy constructor", | |
116 | "Copy constructor is not implemented."); | |
117 | } | |
118 | ||
119 | //______________________________________________________________________________ | |
120 | AliMUONSt1Segmentation::~AliMUONSt1Segmentation() { | |
121 | // Destructor | |
122 | ||
123 | delete fPlane; | |
124 | delete fPlaneSegmentation; | |
125 | delete fPlaneIterator; | |
126 | } | |
127 | ||
128 | // | |
129 | // operators | |
130 | // | |
131 | ||
132 | //______________________________________________________________________________ | |
133 | AliMUONSt1Segmentation& | |
134 | AliMUONSt1Segmentation::operator=(const AliMUONSt1Segmentation& rhs) | |
135 | { | |
136 | // Copy operator | |
137 | ||
138 | // check assignement to self | |
139 | if (this == &rhs) return *this; | |
140 | ||
141 | Fatal("operator=", | |
142 | "Assignment operator is not implemented."); | |
143 | ||
144 | return *this; | |
145 | } | |
146 | ||
147 | // | |
148 | // private methods | |
149 | // | |
150 | ||
151 | //______________________________________________________________________________ | |
5f91c9e8 | 152 | void AliMUONSt1Segmentation::UpdateCurrentPadValues(const AliMpPad& pad) |
ba030c0e | 153 | { |
154 | // Updates current pad values. | |
155 | // --- | |
156 | ||
157 | fIx = pad.GetIndices().GetFirst(); | |
158 | fIy = pad.GetIndices().GetSecond(); | |
159 | fX = pad.Position().X() * fgkLengthUnit; | |
160 | fY = pad.Position().Y() * fgkLengthUnit; | |
161 | fSector = fPlaneSegmentation->Zone(pad); | |
162 | } | |
163 | ||
164 | // | |
165 | // public methods | |
166 | // | |
167 | ||
168 | //______________________________________________________________________________ | |
6aaf81e6 | 169 | void AliMUONSt1Segmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/) |
ba030c0e | 170 | { |
171 | // Set pad size Dx*Dy | |
172 | // --- | |
173 | ||
174 | Fatal("SetPadSize", "Not uniform pad size."); | |
175 | } | |
176 | ||
177 | //______________________________________________________________________________ | |
178 | void AliMUONSt1Segmentation::SetDAnod(Float_t d) | |
179 | { | |
180 | // Set anod pitch | |
181 | // --- | |
182 | ||
183 | fWireD = d; | |
184 | } | |
185 | ||
186 | //______________________________________________________________________________ | |
187 | Float_t AliMUONSt1Segmentation::GetAnod(Float_t xhit) const | |
188 | { | |
189 | // Anod wire coordinate closest to xhit | |
190 | // Returns for a hit position xhit the position of the nearest anode wire | |
191 | // From AliMUONSegmentationV01. | |
192 | // --- | |
193 | ||
194 | Float_t wire= (xhit>0) ? Int_t(xhit/fWireD) + 0.5 | |
195 | : Int_t(xhit/fWireD) - 0.5; | |
196 | return fWireD*wire; | |
197 | ||
198 | } | |
199 | ||
200 | //______________________________________________________________________________ | |
6aaf81e6 | 201 | void AliMUONSt1Segmentation::GetPadI(Float_t x, Float_t y, Float_t /*z*/, |
ba030c0e | 202 | Int_t& ix, Int_t& iy) |
203 | { | |
204 | // Returns pad coordinates (ix,iy) for given real coordinates (x,y) | |
205 | // --- | |
206 | ||
207 | GetPadI(x, y, ix, iy); | |
208 | } | |
209 | ||
210 | //______________________________________________________________________________ | |
211 | void AliMUONSt1Segmentation::GetPadI(Float_t x, Float_t y, | |
212 | Int_t& ix, Int_t& iy) | |
213 | { | |
214 | // Returns pad coordinates (ix,iy) for given real coordinates (x,y) | |
215 | // If there is no pad, ix = 0, iy = 0 are returned. | |
216 | // --- | |
217 | ||
5f91c9e8 | 218 | AliMpPad pad = fPlaneSegmentation |
ba030c0e | 219 | ->PadByPosition(TVector2(x/fgkLengthUnit, y/fgkLengthUnit), false); |
220 | ||
221 | ix = pad.GetIndices().GetFirst(); | |
222 | iy = pad.GetIndices().GetSecond(); | |
223 | } | |
224 | ||
225 | //______________________________________________________________________________ | |
226 | void AliMUONSt1Segmentation::GetPadC(Int_t ix, Int_t iy, | |
227 | Float_t& x, Float_t& y, Float_t& z) | |
228 | { | |
229 | // Transform from pad to real coordinates | |
230 | // --- | |
231 | ||
232 | z = fZ; | |
233 | GetPadC(ix, iy, x , y); | |
234 | } | |
235 | ||
236 | //______________________________________________________________________________ | |
237 | void AliMUONSt1Segmentation::GetPadC(Int_t ix, Int_t iy, | |
238 | Float_t& x, Float_t& y) | |
239 | { | |
240 | // Transform from pad to real coordinates | |
241 | // If there is no pad, x = 0., y = 0. are returned. | |
242 | // --- | |
243 | ||
5f91c9e8 | 244 | AliMpPad pad = fPlaneSegmentation->PadByIndices(AliMpIntPair(ix,iy)); |
ba030c0e | 245 | |
246 | x = pad.Position().X() * fgkLengthUnit; | |
247 | y = pad.Position().Y() * fgkLengthUnit; | |
248 | } | |
249 | ||
250 | ||
251 | //______________________________________________________________________________ | |
252 | void AliMUONSt1Segmentation::Init(Int_t chamber) | |
253 | { | |
254 | // Initialize segmentation | |
255 | // --- | |
256 | ||
257 | // find Npx, Npy and save this info | |
258 | ||
259 | // reference to chamber | |
260 | AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON"); | |
261 | fChamber = &(pMUON->Chamber(chamber)); | |
262 | fRmin=fChamber->RInner(); | |
263 | fRmax=fChamber->ROuter(); | |
264 | fZ = fChamber->Z(); | |
265 | fId=chamber; | |
266 | } | |
267 | ||
268 | //______________________________________________________________________________ | |
269 | Float_t AliMUONSt1Segmentation::Dpx() const | |
270 | { | |
271 | // Get pad size in x | |
272 | // --- | |
273 | ||
274 | Fatal("Dpx", "Not uniform pad size."); | |
275 | return 0.; | |
276 | } | |
277 | ||
278 | //______________________________________________________________________________ | |
279 | Float_t AliMUONSt1Segmentation::Dpy() const | |
280 | { | |
281 | // Get pad size in y | |
282 | // --- | |
283 | ||
284 | Fatal("Dpy", "Not uniform pad size."); | |
285 | return 0.; | |
286 | } | |
287 | ||
288 | //______________________________________________________________________________ | |
289 | Float_t AliMUONSt1Segmentation::Dpx(Int_t isector) const | |
290 | { | |
291 | // Pad size in x by sector | |
292 | // --- | |
293 | ||
294 | return fPlaneSegmentation->PadDimensions(isector).X()*2.*fgkLengthUnit; | |
295 | } | |
296 | ||
297 | //______________________________________________________________________________ | |
298 | Float_t AliMUONSt1Segmentation::Dpy(Int_t isector) const | |
299 | { | |
300 | // Pad size in x, y by Sector | |
301 | // --- | |
302 | ||
303 | return fPlaneSegmentation->PadDimensions(isector).Y()*2.*fgkLengthUnit; | |
304 | } | |
305 | ||
306 | //______________________________________________________________________________ | |
307 | Int_t AliMUONSt1Segmentation::Npx() const | |
308 | { | |
309 | // Maximum number of Pads in x | |
310 | // --- | |
311 | ||
312 | //Fatal("Npx", "Not yet implemented."); | |
313 | return 142; //hard coded for the time being | |
314 | } | |
315 | ||
316 | //______________________________________________________________________________ | |
317 | Int_t AliMUONSt1Segmentation::Npy() const | |
318 | { | |
319 | // Maximum number of Pads in y | |
320 | // --- | |
321 | ||
322 | //Fatal("Npy", "Not yet implemented."); | |
323 | return 213; //hard coded for the time being | |
324 | } | |
325 | ||
326 | //______________________________________________________________________________ | |
327 | void AliMUONSt1Segmentation::SetPad(Int_t ix, Int_t iy) | |
328 | { | |
329 | // Set pad position. | |
330 | // Sets virtual pad coordinates, needed for evaluating pad response | |
331 | // outside the tracking program. | |
332 | // From AliMUONSegmentationV01. | |
333 | // --- | |
334 | ||
335 | GetPadC(ix, iy, fX, fY); | |
336 | fSector = Sector(ix, iy); | |
337 | } | |
338 | ||
339 | //______________________________________________________________________________ | |
6aaf81e6 | 340 | void AliMUONSt1Segmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/) |
ba030c0e | 341 | { |
342 | // Set hit position | |
343 | // Sets virtual hit position, needed for evaluating pad response | |
344 | // outside the tracking program | |
345 | // From AliMUONSegmentationV01. | |
346 | ||
347 | fXhit = xhit; | |
348 | fYhit = yhit; | |
349 | } | |
350 | ||
351 | //______________________________________________________________________________ | |
6aaf81e6 | 352 | void AliMUONSt1Segmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, |
ba030c0e | 353 | Float_t dx, Float_t dy) |
354 | { | |
355 | // Iterate over pads - initialiser | |
356 | // --- | |
357 | ||
358 | // Sets the current pad to that located in the hit position | |
359 | ||
360 | SetHit(GetAnod(xhit), yhit, 0.); | |
361 | ||
362 | // Enable iterating in one dimension | |
363 | if (dx == 0.) dx = 0.01; | |
364 | if (dy == 0.) dy = 0.01; | |
365 | ||
366 | fPlaneIterator | |
367 | = fPlaneSegmentation | |
5f91c9e8 | 368 | ->CreateIterator(AliMpArea(TVector2(fXhit/fgkLengthUnit, fYhit/fgkLengthUnit), |
369 | TVector2(dx/fgkLengthUnit, dy/fgkLengthUnit))); | |
ba030c0e | 370 | |
371 | fPlaneIterator->First(); | |
372 | ||
373 | if (! fPlaneIterator->IsDone()) | |
374 | UpdateCurrentPadValues(fPlaneIterator->CurrentItem()); | |
375 | } | |
376 | ||
377 | //______________________________________________________________________________ | |
378 | void AliMUONSt1Segmentation::NextPad() | |
379 | { | |
380 | // Iterate over pads - stepper | |
381 | // --- | |
382 | ||
383 | fPlaneIterator->Next(); | |
384 | ||
385 | if (! fPlaneIterator->IsDone()) | |
386 | UpdateCurrentPadValues(fPlaneIterator->CurrentItem()); | |
387 | } | |
388 | ||
389 | //______________________________________________________________________________ | |
390 | Int_t AliMUONSt1Segmentation::MorePads() | |
391 | { | |
392 | // Iterate over pads - condition | |
393 | // --- | |
394 | ||
395 | if (fPlaneIterator->IsDone()) | |
396 | return 0; | |
397 | else | |
398 | return 1; | |
399 | } | |
400 | ||
401 | //______________________________________________________________________________ | |
402 | Float_t AliMUONSt1Segmentation::Distance2AndOffset(Int_t iX, Int_t iY, | |
6aaf81e6 | 403 | Float_t x, Float_t y, Int_t* /*dummy*/) |
ba030c0e | 404 | { |
405 | // Returns the square of the distance between 1 pad | |
406 | // labelled by its channel numbers and a coordinate | |
407 | // --- | |
408 | ||
5f91c9e8 | 409 | AliMpPad pad = fPlaneSegmentation->PadByIndices(AliMpIntPair(iX, iY)); |
ba030c0e | 410 | |
411 | if (!pad.IsValid()) | |
412 | Fatal("Distance2AndOffset", "Cannot locate pad."); | |
413 | ||
414 | return (pad.Position()*fgkLengthUnit - TVector2(x, y)).Mod2(); | |
415 | } | |
416 | ||
417 | //______________________________________________________________________________ | |
6aaf81e6 | 418 | void AliMUONSt1Segmentation::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, |
419 | Int_t* /*Nparallel*/, Int_t* /*Offset*/) | |
ba030c0e | 420 | { |
421 | // Number of pads read in parallel and offset to add to x | |
422 | // (specific to LYON, but mandatory for display) | |
423 | // --- | |
424 | ||
425 | Fatal("GetNParallelAndOffset", "Not yet implemented."); | |
426 | } | |
427 | ||
428 | ||
429 | //______________________________________________________________________________ | |
430 | void AliMUONSt1Segmentation::Neighbours(Int_t iX, Int_t iY, | |
431 | Int_t* Nlist, | |
432 | Int_t Xlist[10], Int_t Ylist[10]) | |
433 | { | |
434 | // Get next neighbours | |
435 | // --- | |
436 | ||
5f91c9e8 | 437 | AliMpPad pad = fPlaneSegmentation->PadByIndices(AliMpIntPair(iX,iY)); |
ba030c0e | 438 | Int_t &i = *Nlist; |
439 | i=0; | |
5f91c9e8 | 440 | AliMpVPadIterator* iter |
ba030c0e | 441 | = fPlaneSegmentation |
5f91c9e8 | 442 | ->CreateIterator(AliMpArea(pad.Position(),2.*pad.Dimensions()*1.1)); |
ba030c0e | 443 | |
444 | for( iter->First(); !iter->IsDone() && i<10; iter->Next()) { | |
445 | Xlist[i] = iter->CurrentItem().GetIndices().GetFirst(); | |
446 | Ylist[i] = iter->CurrentItem().GetIndices().GetSecond(); | |
447 | i++; | |
448 | } | |
449 | ||
450 | delete iter; | |
451 | } | |
452 | ||
453 | //______________________________________________________________________________ | |
454 | Int_t AliMUONSt1Segmentation::Ix() | |
455 | { | |
456 | // Current pad cursor during disintegration | |
457 | // x, y-coordinate | |
458 | // --- | |
459 | ||
460 | return fPlaneIterator->CurrentItem().GetIndices().GetFirst(); | |
461 | } | |
462 | ||
463 | //______________________________________________________________________________ | |
464 | Int_t AliMUONSt1Segmentation::Iy() | |
465 | { | |
466 | // Current pad cursor during disintegration | |
467 | // x, y-coordinate | |
468 | // --- | |
469 | ||
470 | return fPlaneIterator->CurrentItem().GetIndices().GetSecond(); | |
471 | } | |
472 | ||
473 | //______________________________________________________________________________ | |
474 | Int_t AliMUONSt1Segmentation::ISector() | |
475 | { | |
476 | // Current sector | |
477 | // --- | |
478 | ||
479 | return fSector; | |
480 | } | |
481 | ||
482 | //______________________________________________________________________________ | |
483 | Int_t AliMUONSt1Segmentation::Sector(Int_t ix, Int_t iy) | |
484 | { | |
485 | // Calculate sector from pad coordinates | |
486 | // --- | |
487 | ||
488 | return fPlaneSegmentation | |
5f91c9e8 | 489 | ->Zone(fPlaneSegmentation->PadByIndices(AliMpIntPair(ix, iy))); |
ba030c0e | 490 | } |
491 | ||
492 | //______________________________________________________________________________ | |
493 | Int_t AliMUONSt1Segmentation::Sector(Float_t x, Float_t y) | |
494 | { | |
495 | // Calculate sector from pad coordinates | |
496 | // --- | |
497 | ||
498 | return fPlaneSegmentation | |
499 | ->Zone(fPlaneSegmentation | |
500 | ->PadByPosition(TVector2(x/fgkLengthUnit, y/fgkLengthUnit))); | |
501 | } | |
502 | ||
503 | //______________________________________________________________________________ | |
504 | void AliMUONSt1Segmentation::IntegrationLimits(Float_t& x1, Float_t& x2, | |
505 | Float_t& y1, Float_t& y2) | |
506 | { | |
507 | // Current integration limits | |
508 | // --- | |
509 | ||
510 | x1 = fXhit - fX - Dpx(fSector)/2.; | |
511 | x2 = x1 + Dpx(fSector); | |
512 | ||
513 | y1 = fYhit - fY - Dpy(fSector)/2.; | |
514 | y2 = y1 + Dpy(fSector); | |
515 | } | |
516 | ||
517 | //______________________________________________________________________________ | |
6aaf81e6 | 518 | Int_t AliMUONSt1Segmentation::SigGenCond(Float_t x, Float_t y, Float_t /*z*/) |
ba030c0e | 519 | { |
520 | // Signal Generation Condition during Stepping | |
521 | // 0: don't generate signal | |
522 | // 1: generate signal | |
523 | // Comments: | |
524 | // | |
525 | // Crossing of pad boundary and mid plane between neighbouring wires is checked. | |
526 | // To correctly simulate the dependence of the spatial resolution on the angle | |
527 | // of incidence signal must be generated for constant steps on | |
528 | // the projection of the trajectory along the anode wire. | |
529 | // | |
530 | // Signal will be generated if particle crosses pad boundary or | |
531 | // boundary between two wires. | |
532 | // | |
533 | // From AliMUONSegmentationV01 | |
534 | // --- | |
535 | ||
536 | Int_t ixt, iyt; | |
537 | GetPadI(x, y, ixt, iyt); | |
538 | Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1; | |
539 | ||
540 | if ((ixt != fIxt) || (iyt !=fIyt) || (iwt != fIwt)) { | |
541 | return 1; | |
542 | } | |
543 | else { | |
544 | return 0; | |
545 | } | |
546 | } | |
547 | ||
548 | ||
549 | //______________________________________________________________________________ | |
6aaf81e6 | 550 | void AliMUONSt1Segmentation::SigGenInit(Float_t x, Float_t y, Float_t /*z*/) |
ba030c0e | 551 | { |
552 | // Initialise signal generation at coord (x,y,z) | |
553 | // Initialises pad and wire position during stepping. | |
554 | // From AliMUONSegmentationV01 | |
555 | // --- | |
556 | ||
557 | fXt = x; | |
558 | fYt = y; | |
559 | GetPadI(x, y, fIxt, fIyt); | |
560 | fIwt = (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ; | |
561 | } | |
562 | ||
563 | //______________________________________________________________________________ | |
564 | void AliMUONSt1Segmentation::GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const | |
565 | { | |
566 | // Test points for auto calibration | |
567 | // Returns test point on the pad plane. | |
568 | // Used during determination of the segmoid correction of the COG-method | |
569 | // From AliMUONSegmentationV01 | |
570 | // --- | |
571 | ||
572 | n=1; | |
573 | x[0] = (fRmax+fRmin)/2/TMath::Sqrt(2.); | |
574 | y[0] = x[0]; | |
575 | } | |
576 | ||
577 | //______________________________________________________________________________ | |
6aaf81e6 | 578 | void AliMUONSt1Segmentation::Draw(const char * /*opt*/) const |
ba030c0e | 579 | { |
580 | // Draw the segmentation zones. | |
581 | // (Called from AliMUON::BuildGeometry) | |
582 | // --- | |
583 | ||
584 | Warning("Draw", "Not yet implemented."); | |
585 | } | |
586 | ||
587 | //______________________________________________________________________________ | |
588 | void AliMUONSt1Segmentation::SetCorrFunc(Int_t isec, TF1* func) | |
589 | { | |
590 | // Set the correction function. | |
591 | // From AliMUONSegmentationV01 | |
592 | // --- | |
593 | ||
594 | fCorrA->AddAt(func, isec); | |
595 | } | |
596 | ||
597 | //______________________________________________________________________________ | |
598 | TF1* AliMUONSt1Segmentation::CorrFunc(Int_t isec) const | |
599 | { | |
600 | // Get the correction Function. | |
601 | // From AliMUONSegmentationV01 | |
602 | // --- | |
603 | ||
604 | return (TF1*) fCorrA->At(isec); | |
605 | } | |
606 |