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