]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONTriggerSegmentation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Various fixes in order to compile the DA source code
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerSegmentation.cxx
CommitLineData
d5d35295 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18// -------------------------------------
19// Class AliMUONTriggerSegmentation
20// -------------------------------------
21// Segmentation for MUON trigger stations using
22// the mapping package
23
24#include "AliMUONTriggerSegmentation.h"
25
26#include "AliMpPCB.h"
27#include "AliMpTrigger.h"
28#include "AliMpTriggerSegmentation.h"
29#include "AliMpSlat.h"
30
31#include "AliLog.h"
32
33#include "Riostream.h"
34#include "TClass.h"
35#include "TString.h"
36
37/// \cond CLASSIMP
38ClassImp(AliMUONTriggerSegmentation)
39/// \endcond
40
41namespace
42{
43// Int_t SPECIAL_SECTOR = 8;
44 Int_t fgIntOffset(1);
45 Float_t FMAX(1E9);
46 Int_t CODEMAKER(1000);
47
48 Int_t Code(Int_t ixLA, Int_t iyLA)
49 {
50 return iyLA*CODEMAKER + ixLA;
51 }
52
53 void Decode(Int_t code, Int_t& ixLA, Int_t& iyLA)
54 {
55 iyLA = code/CODEMAKER;
56 ixLA = code - iyLA*CODEMAKER;
57 }
58}
59
60//_____________________________________________________________________________
61AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
62: AliMUONVGeometryDESegmentation(),
63 fDetElemId(-1),
866c3232 64 fPlaneType(AliMp::kBendingPlane),
d5d35295 65 fSlat(0),
66 fSlatSegmentation(0),
67 fCurrentPad(),
68 fXhit(FMAX),
69 fYhit(FMAX),
70 fLineNumber(-1)
71{
72/// Default ctor (empty).
73
74 AliDebug(1,Form("this=%p default (empty) ctor",this));
75}
76
77//_____________________________________________________________________________
78AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(
79 AliMpVSegmentation* segmentation,
866c3232 80 Int_t detElemId, AliMp::PlaneType bendingOrNonBending)
d5d35295 81 : AliMUONVGeometryDESegmentation(),
82 fDetElemId(detElemId),
83 fPlaneType(bendingOrNonBending),
84 fSlat(0),
85 fSlatSegmentation(0),
86 fCurrentPad(),
87 fXhit(FMAX),
88 fYhit(FMAX),
89 fLineNumber(-1)
90{
91/// Normal ctor.
92
93 fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>(segmentation);
94 if (fSlatSegmentation)
95 fSlat = fSlatSegmentation->Slat();
96 else
97 AliFatal("Wrong mapping segmentation type");
98
99 TString id(fSlat->GetID());
100 Ssiz_t pos = id.Last('L');
101 if ( pos <= 0 )
102 {
103 AliFatal(Form("Cannot infer line number for slat %s",id.Data()));
104 }
105 fLineNumber = TString(id(pos+1),1).Atoi();
106
107 AliDebug(1,Form("this=%p detElemId=%3d %s fSlatSegmentation=%p",this,detElemId,
866c3232 108 ( (bendingOrNonBending==AliMp::kBendingPlane)?"Bending":"NonBending" ),
d5d35295 109 fSlatSegmentation));
110}
111
112//_____________________________________________________________________________
113AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
114{
115/// Destructor
116
117 AliDebug(1,Form("this=%p",this));
118}
119
120//_____________________________________________________________________________
121TF1*
122AliMUONTriggerSegmentation::CorrFunc(Int_t) const
123{
124/// Not implemented
125
126 AliFatal("Not implemented");
127 return 0x0;
128}
129
130//_____________________________________________________________________________
131Float_t
132AliMUONTriggerSegmentation::Distance2AndOffset(Int_t, Int_t,
133 Float_t, Float_t, Int_t*)
134{
135/// Not implemented
136
137 AliFatal("Not implemented");
138 return 0;
139}
140
141//_____________________________________________________________________________
142void
143AliMUONTriggerSegmentation::Draw(Option_t*)
144{
145/// Not implemented
146
147 AliFatal("Not Implemented");
148}
149
150//_____________________________________________________________________________
151Float_t
152AliMUONTriggerSegmentation::Dpx() const
153{
154/// Not implemented
155
156 AliFatal("Not Implemented");
157 return 0.0;
158}
159
160//_____________________________________________________________________________
161Float_t
162AliMUONTriggerSegmentation::Dpy() const
163{
164/// Not implemented
165
166 AliFatal("Not Implemented");
167 return 0.0;
168}
169
170//_____________________________________________________________________________
171Float_t
172AliMUONTriggerSegmentation::Dpx(Int_t sectorCode) const
173{
174/// Get pad size in x
175
176 Int_t ixLA, iyLA;
177 Decode(sectorCode,ixLA,iyLA);
178 AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
179 if ( !pad.IsValid() ) return 0.0;
180 return pad.Dimensions().X()*2.0;
181}
182
183//_____________________________________________________________________________
184Float_t
185AliMUONTriggerSegmentation::Dpy(Int_t sectorCode) const
186{
187/// Get pad size in y
188
189 Int_t ixLA, iyLA;
190 Decode(sectorCode,ixLA,iyLA);
191 AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
192 if ( !pad.IsValid() ) return 0.0;
193 return pad.Dimensions().Y()*2.0;
194}
195
196//_____________________________________________________________________________
197void
198AliMUONTriggerSegmentation::FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*zhit*/,
199 Float_t /*dx*/, Float_t /*dy*/)
200{
201/// Not implemented
202
203 AliFatal("Not implemented");
204}
205
206//_____________________________________________________________________________
207Float_t
208AliMUONTriggerSegmentation::GetAnod(Float_t) const
209{
210/// Not implemented
211
212 AliFatal("Not implemented");
213 return 0.0;
214}
215
216//_____________________________________________________________________________
217AliMUONGeometryDirection
218AliMUONTriggerSegmentation::GetDirection()
219{
220/// Not implemented
221
222 //AliWarning("Not Implemented");
223 return kDirUndefined;
224}
225
226//______________________________________________________________________________
227const AliMpVSegmentation*
228AliMUONTriggerSegmentation::GetMpSegmentation() const
229{
230/// Returns the mapping segmentation
231/// (provides access to electronics info)
232
233 return fSlatSegmentation;
234}
235
236//_____________________________________________________________________________
237void
238AliMUONTriggerSegmentation::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
239{
240/// Not implemented
241
242 AliFatal("Not Implemented");
243}
244
245//_____________________________________________________________________________
246void
247AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy,
248 Float_t& x, Float_t& y, Float_t& z)
249{
250/// Transform from pad to real coordinates
251
252 z = 0;
253 GetPadC(ix,iy,x,y);
254}
255
256//_____________________________________________________________________________
257void
258AliMUONTriggerSegmentation::GetPadC(Int_t ixGlo, Int_t iyGlo,
259 Float_t& x, Float_t& y)
260{
261/// Transform from pad to real coordinates
262
263 Int_t ixLA,iyLA;
264 IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
265 AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kTRUE);
266 x = pad.Position().X();
267 y = pad.Position().Y();
268}
269
270//_____________________________________________________________________________
271void
272AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Float_t,
273 Int_t& ix, Int_t& iy)
274{
275/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
276
277 GetPadI(x,y,ix,iy);
278}
279
280//_____________________________________________________________________________
281void
282AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y,
283 Int_t& ixGlo, Int_t& iyGlo)
284{
285/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
286
287 AliDebug(2,Form("%s x=%e y=%e ixGlo,iyGlo=%d,%d\n",
288 fSlatSegmentation->GetName(),
289 x,y,ixGlo,iyGlo));
290
291 AliMpPad pad =
292 fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
293
294 if ( pad != AliMpPad::Invalid() )
295 {
296 Int_t ix = pad.GetIndices().GetFirst();
297 Int_t iy = pad.GetIndices().GetSecond();
298 ILoc2IGlo(ix,iy,ixGlo,iyGlo);
299 }
300 else
301 {
302 ixGlo=iyGlo=-1;
303 }
304 AliDebug(2,Form("ixGlo,iyGlo=%d,%d\n",ixGlo,iyGlo));
305}
306
307//_____________________________________________________________________________
308void
309AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ix, Int_t iy,
310 Int_t& ixGlo, Int_t& iyGlo) const
311{
312/// Converts from local (in PC convention) to (ix,iy) to global (ix,iy)
313
314 ixGlo=iyGlo=-1; // starts with invalid values
315
866c3232 316 if ( fPlaneType == AliMp::kBendingPlane )
d5d35295 317 {
318 ixGlo = 10*LineNumber() + ix;
319 iyGlo = iy - fgIntOffset;
320 }
866c3232 321 else if ( fPlaneType == AliMp::kNonBendingPlane )
d5d35295 322 {
323 Int_t i = fSlat->GetLayer(0)->FindPCBIndex(ix-fgIntOffset);
324 if (i<0)
325 {
326 AliError(Form("Invalid local (ix=%d,iy=%d) ?",ix,iy));
327 return ;
328 }
329 AliMpPCB* pcb = fSlat->GetLayer(0)->FindPCB(ix-fgIntOffset);
330 iyGlo = ix - pcb->Ixmin() - fgIntOffset;
331 if ( LineNumber() == 5 ) ++i;
332 ixGlo = 10*LineNumber() + i + fgIntOffset;
333 }
334}
335
336//_____________________________________________________________________________
337void
338AliMUONTriggerSegmentation::GetPadGlo2Loc(Int_t ixGlo, Int_t iyGlo,
339 Int_t& ix, Int_t& iy) const
340{
341/// Converts from global (ix,iy) to local (ix,iy) (in PC convention)
342
343 ix=iy=-1; // starts with invalid values
344
345 if ( abs(ixGlo) == 51 ) return;
346
347 Int_t column = ModuleColNum(ixGlo);
348
866c3232 349 if ( fPlaneType == AliMp::kBendingPlane )
d5d35295 350 {
351 ix = column + fgIntOffset;
352 iy = iyGlo + fgIntOffset;
353 }
866c3232 354 else if ( fPlaneType == AliMp::kNonBendingPlane )
d5d35295 355 {
356 if ( LineNumber()==5 ) --column;
357 AliMpPCB* pcb = fSlat->GetLayer(0)->GetPCB(column);
358 if (!pcb)
359 {
360 AliError(Form("Invalid global (ix=%d,iy=%d)",ixGlo,iyGlo));
361 return;
362 }
363 ix = pcb->Ixmin() + iyGlo + fgIntOffset;
364 iy = fgIntOffset;
365 }
366}
367
368//_____________________________________________________________________________
369void
370AliMUONTriggerSegmentation::GiveTestPoints(Int_t& /*n*/,
371 Float_t* /*x*/, Float_t*/*y*/) const
372{
71a2d3aa 373/// Not implemented
d5d35295 374
375 AliFatal("Not Implemented");
376}
377
378//_____________________________________________________________________________
379Bool_t
380AliMUONTriggerSegmentation::HasPad(Float_t x, Float_t y, Float_t /*z*/)
381{
382/// Returns true if a pad exists in the given position
383///
384/// Well, 2 implementations are possible here
385/// Either reuse HasPad(int,int), or get it from scratch using
386/// underlying fSlatSegmentation.
387/// Took second option, but w/o checking whether this is the faster.
388/// The second option is commented out below, for the record.
389
390// Int_t ix, iy;
391// GetPadI(x,y,z,ix,iy);
392// Int_t ixLA, iyLA;
393// IGlo2ILoc(ix,iy,ixLA,iyLA);
394// Int_t ixPC, iyPC;
395// LA2PC(ixLA,iyLA,ixPC,iyPC);
396// Bool_t ok1 = HasPad(ixPC,iyPC);
397
398 AliMpPad pad =
399 fSlatSegmentation->PadByPosition(TVector2(x,y),kFALSE);
400 return pad.IsValid();
401}
402
403//_____________________________________________________________________________
404Bool_t
405AliMUONTriggerSegmentation::HasPad(Int_t ixGlo, Int_t iyGlo)
406{
407/// Returns true if a pad with given indices exists
408
409 Int_t ixLA, iyLA;
410 IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
411 return fSlatSegmentation->HasPad(AliMpIntPair(ixLA,iyLA));
412}
413
414//_____________________________________________________________________________
415void
416AliMUONTriggerSegmentation::IGlo2ILoc(Int_t ixGlo, Int_t iyGlo,
417 Int_t& ixLA, Int_t& iyLA) const
418{
419/// \todo FIXME: add comment
420
421 Int_t ixPC, iyPC;
422 GetPadGlo2Loc(ixGlo,iyGlo,ixPC,iyPC);
423 PC2LA(ixPC,iyPC,ixLA,iyLA);
424}
425
426//_____________________________________________________________________________
427void
428AliMUONTriggerSegmentation::ILoc2IGlo(Int_t ixLA, Int_t iyLA,
429 Int_t& ixGlo, Int_t& iyGlo) const
430{
431/// \todo FIXME: add comment
432
433 Int_t ixPC, iyPC;
434 LA2PC(ixLA,iyLA,ixPC,iyPC);
435 GetPadLoc2Glo(ixPC,iyPC,ixGlo,iyGlo);
436}
437
438//_____________________________________________________________________________
439Int_t
440AliMUONTriggerSegmentation::ISector()
441{
442/// \todo FIXME: remove the usage of ISector from all the code.
443
444 return -10;
445}
446
447//_____________________________________________________________________________
448void AliMUONTriggerSegmentation::IntegrationLimits(Float_t& x1,
449 Float_t& x2,
450 Float_t& x3,
451 Float_t& x4)
452{
453/// \param x1 : hit x(y) position
71a2d3aa 454/// \param x2 : x(y) coordinate of the main strip
455/// \param x3 : current strip real x(y) coordinate
456/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
d5d35295 457///
458/// Note : need to return (only) x4.
459
460 AliFatal("Check me before usage. ResponseTrigger does not use me, while"
461 "ResponseTriggerV1 does ?");
462
463 AliMpPad strip =
464 fSlatSegmentation->PadByPosition(TVector2(fXhit,fYhit),kFALSE);
465 if ( !strip.IsValid() )
466 {
467 AliWarning(Form("%s got invalid fXhit,fYhit=%e,%e\n",
468 fSlatSegmentation->GetName(),fXhit,fYhit));
469 x1=x2=x3=x4=0;
470 }
471 else
472 {
473 Double_t xstrip = strip.Position().X();
474 Double_t ystrip = strip.Position().Y();
475 AliDebug(1,Form("fXhit,Yhit=%e,%e xstrip,ystrip=%e,%e\n",
476 fXhit,fYhit,xstrip,ystrip));
866c3232 477 x1 = (fPlaneType==AliMp::kBendingPlane) ? fYhit : fXhit;
478 x2 = (fPlaneType==AliMp::kBendingPlane) ? ystrip : xstrip;
479 x3 = (fPlaneType==AliMp::kBendingPlane) ?
d5d35295 480 fCurrentPad.Position().Y() : fCurrentPad.Position().X();
481 Double_t xmin = 0.0;
482 Double_t xmax = 0.0;
866c3232 483 if (fPlaneType==AliMp::kBendingPlane)
d5d35295 484 {
485 xmin = x3 - fCurrentPad.Dimensions().X();
486 xmax = x3 + fCurrentPad.Dimensions().X();
487 }
488 else
489 {
490 xmin = x3 - fCurrentPad.Dimensions().Y();
491 xmax = x3 + fCurrentPad.Dimensions().Y();
492 }
493 // dist. between the hit and the closest border of the current strip
494 x4 = (TMath::Abs(xmax-x1) > TMath::Abs(xmin-x1)) ?
495 TMath::Abs(xmin-x1):TMath::Abs(xmax-x1);
496
497 AliDebug(1,Form("Bending %d x1=%e x2=%e x3=%e x4=%e xmin,max=%e,%e\n",
498 fPlaneType,x1,x2,x3,x4,xmin,xmax));
499
500 }
501}
502
503//_____________________________________________________________________________
504Int_t
505AliMUONTriggerSegmentation::Ix()
506{
507/// Current pad cursor during disintegration
508/// x, y-coordinate
509
510 if ( fCurrentPad.IsValid() )
511 {
512 Int_t ixGlo,iyGlo;
513 ILoc2IGlo(fCurrentPad.GetIndices().GetFirst(),
514 fCurrentPad.GetIndices().GetSecond(),ixGlo,iyGlo);
515 return ixGlo;
516 }
517 return -1;
518}
519
520//_____________________________________________________________________________
521Int_t
522AliMUONTriggerSegmentation::Iy()
523{
524/// Current pad cursor during disintegration
525/// x, y-coordinate
526
527 if ( fCurrentPad.IsValid() )
528 {
529 Int_t ixGlo,iyGlo;
530 ILoc2IGlo(fCurrentPad.GetIndices().GetFirst(),
531 fCurrentPad.GetIndices().GetSecond(),ixGlo,iyGlo);
532 return iyGlo;
533 }
534 return -1;
535}
536
537
538//_____________________________________________________________________________
539void
540AliMUONTriggerSegmentation::LA2PC(Int_t ixLA, Int_t iyLA,
541 Int_t& ixPC, Int_t& iyPC) const
542{
543/// From LA to PC conventions for integers indices.
544
545 ixPC=iyPC=-1;
546
547 if ( ixLA<0 || iyLA<0 ) return;
548
549 ixPC = ixLA + 1;
550 iyPC = iyLA + 1;
551
866c3232 552 if ( fPlaneType == AliMp::kBendingPlane )
d5d35295 553 {
554 if ( LineNumber()==5 )
555 {
556 ++ixPC;
557 }
558 if ( LineNumber()==4 && ixLA==0 )
559 {
560 iyPC -= 16;
561 }
562 }
563
564 AliDebug(3,Form("ix,iy LA (%d,%d) -> PC (%d,%d)",ixLA,iyLA,ixPC,iyPC));
565
566}
567
568//_____________________________________________________________________________
569Int_t
570AliMUONTriggerSegmentation::LineNumber() const
571{
572/// \todo FIXME: add comment
573
574 return 10-fLineNumber;
575}
576
577//_____________________________________________________________________________
578Int_t
579AliMUONTriggerSegmentation::ModuleColNum(Int_t ixGlo) const
580{
581/// returns column number (from 0 to 6) in which the (global) module
582/// ix is sitting (could return 7 if ix=isec)
583
584 return TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10-1;
585}
586
587//_____________________________________________________________________________
588Int_t
589AliMUONTriggerSegmentation::MorePads()
590{
591/// Not implemented
592
593 AliFatal("Not implemented");
594 return 0;
595}
596
597//_____________________________________________________________________________
598void AliMUONTriggerSegmentation::Neighbours(Int_t /*iX*/, Int_t /*iY*/,
599 Int_t* /*Nlist*/,
600 Int_t /*Xlist*/[10],
601 Int_t /*Ylist*/[10])
602{
603/// Not implemented
604
605 //-----------------BENDING-----------------------------------------
606 // Returns list of 10 next neighbours for given X strip (ix, iy)
607 // neighbour number 4 in the list -
608 // neighbour number 3 in the list |
609 // neighbour number 2 in the list |_ Upper part
610 // neighbour number 1 in the list |
611 // neighbour number 0 in the list -
612 // X strip (ix, iy)
613 // neighbour number 5 in the list -
614 // neighbour number 6 in the list | _ Lower part
615 // neighbour number 7 in the list |
616 // neighbour number 8 in the list |
617 // neighbour number 9 in the list -
618
619 //-----------------NON-BENDING-------------------------------------
620 // Returns list of 10 next neighbours for given Y strip (ix, iy)
621 // neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
622 // \_______/ \_______/
623 // left right
624 AliFatal("Please implement me");
625}
626
627//_____________________________________________________________________________
628void
629AliMUONTriggerSegmentation::NextPad()
630{
631/// Not implemented
632
633 AliFatal("Not implemented");
634}
635
636//_____________________________________________________________________________
637Int_t
638AliMUONTriggerSegmentation::Npx() const
639{
640/// Maximum number of Pads in x
641/// hard coded for the time being
642
643 return 124;// FIXME: this should not have to be done, if only we'd stick
644 // to a local (ix,iy) convention !!!
645 // return fSlatSegmentation->MaxPadIndexX()+1;
646}
647
648//_____________________________________________________________________________
649Int_t
650AliMUONTriggerSegmentation::Npy() const
651{
652/// Maximum number of Pads in y
653/// hard coded for the time being
654
655 return 64;
656// return fSlatSegmentation->MaxPadIndexY()+1;
657}
658
659//_____________________________________________________________________________
660void
661AliMUONTriggerSegmentation::PC2LA(Int_t ixPC, Int_t iyPC,
662 Int_t& ixLA, Int_t& iyLA) const
663{
664/// From PC to LA conventions for integers indices.
665
666 ixLA=iyLA=-1;
667
668 if ( ixPC<0 || iyPC<0 ) return;
669
670 ixLA = ixPC - 1;
671 iyLA = iyPC - 1;
672
866c3232 673 if ( fPlaneType == AliMp::kBendingPlane )
d5d35295 674 {
675 if ( LineNumber()==5 )
676 {
677 --ixLA;
678 }
679 if ( LineNumber()==4 && ixLA==0 )
680 {
681 iyLA += 16;
682 }
683 }
684
685 AliDebug(3,Form("ix,iy PC (%d,%d) -> LA (%d,%d)",ixPC,iyPC,ixLA,iyLA));
686}
687
688//_____________________________________________________________________________
689void
690AliMUONTriggerSegmentation::Print(Option_t* opt) const
691{
692/// Printing
693
694 TString sopt(opt);
695
696 cout << "DetElemId=" << fDetElemId << " PlaneType="
697 << fPlaneType << " Npx=" << Npx() << " Npy=" << Npy() << endl;
698 if ( ( sopt.Contains("SEG") || sopt.Contains("ALL") ) && fSlatSegmentation )
699 {
700 fSlatSegmentation->Print();
701 }
702 if ( sopt.Contains("ALL") && fSlat )
703 {
704 fSlat->Print();
705 }
706}
707
708//_____________________________________________________________________________
709Int_t
710AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t iy)
711{
712/// Calculate sector from pad coordinates
713
714 Int_t ixLA, iyLA;
715 IGlo2ILoc(ix,iy,ixLA,iyLA);
716 AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
717 if ( !pad.IsValid() ) return -1;
718 return Code(ixLA,iyLA);
719
720// AliMpPCB* pcb = fSlat->GetLayer(0)->FindPCB(ixLA);
721// if (!pcb)
722// {
723// AliError(Form("Could not find a pcb at (%d,%d) for slat %s",
724// ix,iy,fSlat->GetName()));
725// return -1;
726// }
727// if ( pcb->PadSizeX()==-1.0 )
728// {
729// // special case of column 7 non-bending.
730// return SPECIAL_SECTOR;
731// }
732// return fSlat->GetLayer(0)->FindPCBIndex(ixLA);
733}
734
735//_____________________________________________________________________________
736Int_t
737AliMUONTriggerSegmentation::Sector(Float_t, Float_t)
738{
739/// Not implemented
740
741 AliFatal("Not implemented");
742 return 0;
743}
744
745//_____________________________________________________________________________
746void
747AliMUONTriggerSegmentation::SetCorrFunc(Int_t,TF1*)
748{
749/// Not implemented
750
751 AliFatal("Not Implemented");
752}
753
754//_____________________________________________________________________________
755void
756AliMUONTriggerSegmentation::SetDAnod(Float_t)
757{
758/// Not implemented
759
760 AliFatal("Not Implemented");
761}
762
763//_____________________________________________________________________________
764void
765AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
766{
767/// Set hit position
768/// Sets virtual hit position, needed for evaluating pad response
769/// outside the tracking program
770
771 fXhit = x;
772 fYhit = y;
773
774 //
775 // insure we're within the slat limits. If not, issue an error and sets
776 // the current hit to slat center.
777 // FIXME: this should probably a) not happen at all b) be a fatal error
778 //
779 if ( fXhit < -fSlat->DX() || fXhit > fSlat->DX() ||
780 fYhit < -fSlat->DY() || fYhit > fSlat->DY() )
781 {
782 AliError(Form("Hit outside slat %s limits (x,y)hit = (%e,%e)."
783 " Forcing to (0,0)",fSlat->GetID(),fXhit,fYhit));
784 fXhit = 0.0;
785 fYhit = 0.0;
786 }
787
788}
789
790//_____________________________________________________________________________
791void
792AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y, Float_t)
793{
794/// Set hit position
795/// Sets virtual hit position, needed for evaluating pad response
796/// outside the tracking program
797
798 SetHit(x,y);
799}
800
801//_____________________________________________________________________________
802void
803AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
804{
805/// Set pad position.
806/// Sets virtual pad coordinates, needed for evaluating pad response
807/// outside the tracking program.
808
809 Int_t ixLA, iyLA;
810 IGlo2ILoc(ix,iy,ixLA,iyLA);
811 fCurrentPad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kTRUE);
812 if ( !fCurrentPad.IsValid() )
813 {
814 AliError(Form("Setting current pad to invalid ! (ix,iy)=(%4d,%4d)",ix,iy));
815 }
816}
817
818//_____________________________________________________________________________
819void
820AliMUONTriggerSegmentation::SetPadSize(Float_t,Float_t)
821{
822/// Not implemented
823
824 AliFatal("Not Implemented");
825}
826
827//_____________________________________________________________________________
828Int_t
829AliMUONTriggerSegmentation::SigGenCond(Float_t,Float_t,Float_t)
830{
831/// Not implemented
832
833 AliFatal("Not Implemented");
834 return 0;
835}
836
837//_____________________________________________________________________________
838void
839AliMUONTriggerSegmentation::SigGenInit(Float_t,Float_t,Float_t)
840{
841/// Not implemented
842
843 AliFatal("Not Implemented");
844}
845
846
847
848
849