Removed a non-informative warning.
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerSegmentationV2.cxx
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
20 #include "AliMpPCB.h"
21 #include "AliMpTrigger.h"
22 #include "AliMpTriggerSegmentation.h"
23 #include "AliMpSlat.h"
24
25 #include "AliLog.h"
26
27 #include "Riostream.h"
28 #include "TClass.h"
29 #include "TString.h"
30
31 ClassImp(AliMUONTriggerSegmentationV2)
32
33 namespace
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 //_____________________________________________________________________________
53 AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2() 
54 : AliMUONVGeometryDESegmentation(),
55 fDetElemId(-1),
56 fPlaneType(kNonBendingPlane),
57 fSlat(0),
58 fSlatSegmentation(0),
59 fXhit(FMAX),
60 fYhit(FMAX),
61 fLineNumber(-1)
62 {
63   //
64   // Default ctor (empty).
65   //
66   AliDebug(1,Form("this=%p default (empty) ctor",this));
67 }
68
69 //_____________________________________________________________________________
70 AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(
71                                    AliMpVSegmentation* segmentation,
72                                    Int_t detElemId, AliMpPlaneType bendingOrNonBending)
73 : AliMUONVGeometryDESegmentation(),
74 fDetElemId(detElemId),
75 fPlaneType(bendingOrNonBending),
76 fSlat(0),
77 fSlatSegmentation(0),
78 fXhit(FMAX),
79 fYhit(FMAX),
80 fLineNumber(-1)
81 {
82   //
83   // Normal ctor.
84   //
85
86   fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>(segmentation);
87   if (fSlatSegmentation)
88     fSlat = fSlatSegmentation->Slat();
89   else 
90     AliFatal("Wrong mapping segmentation type");
91                 
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();
99                 
100   AliDebug(1,Form("this=%p detElemId=%3d %s fSlatSegmentation=%p",this,detElemId,
101                                                                         ( (bendingOrNonBending==kBendingPlane)?"Bending":"NonBending" ),
102                                                                         fSlatSegmentation));
103 }
104
105 //_____________________________________________________________________________
106 AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(const AliMUONTriggerSegmentationV2& rhs) : AliMUONVGeometryDESegmentation(rhs)
107 {
108   AliFatal("Not implemented.");
109 }
110
111 //_____________________________________________________________________________
112 AliMUONTriggerSegmentationV2::~AliMUONTriggerSegmentationV2() 
113
114   AliDebug(1,Form("this=%p",this));                     
115   // Destructor
116 }
117
118 //_____________________________________________________________________________
119 AliMUONTriggerSegmentationV2& 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 //_____________________________________________________________________________
128 TF1*
129 AliMUONTriggerSegmentationV2::CorrFunc(Int_t) const
130 {
131   AliFatal("Not implemented");
132   return 0x0;
133 }
134
135 //_____________________________________________________________________________
136 Float_t
137 AliMUONTriggerSegmentationV2::Distance2AndOffset(Int_t, Int_t, 
138                                                  Float_t, Float_t, Int_t*)
139 {
140   AliFatal("Not implemented");
141   return 0;
142 }
143
144 //_____________________________________________________________________________
145 void
146 AliMUONTriggerSegmentationV2::Draw(Option_t*)
147 {
148   AliFatal("Not Implemented");
149 }
150
151 //_____________________________________________________________________________
152 Float_t
153 AliMUONTriggerSegmentationV2::Dpx() const
154 {
155   AliFatal("Not Implemented");
156   return 0.0;
157 }
158
159 //_____________________________________________________________________________
160 Float_t
161 AliMUONTriggerSegmentationV2::Dpy() const
162 {
163   AliFatal("Not Implemented");
164   return 0.0;
165 }
166
167 //_____________________________________________________________________________
168 Float_t
169 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
179 Float_t
180 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
190 void
191 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
199 Float_t
200 AliMUONTriggerSegmentationV2::GetAnod(Float_t) const
201 {
202   AliFatal("Not implemented");
203   return 0.0;
204 }
205
206 //_____________________________________________________________________________
207 AliMUONGeometryDirection
208 AliMUONTriggerSegmentationV2::GetDirection()
209 {
210   //AliWarning("Not Implemented");
211   return kDirUndefined;
212 }
213
214 //______________________________________________________________________________
215 const AliMpVSegmentation*  
216 AliMUONTriggerSegmentationV2::GetMpSegmentation() const
217 {
218 // Returns the mapping segmentation
219 // (provides access to electronics info)
220
221   return fSlatSegmentation;
222 }  
223
224 //_____________________________________________________________________________
225 void 
226 AliMUONTriggerSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
227 {
228   AliFatal("Not Implemented");
229 }
230
231 //_____________________________________________________________________________
232 void
233 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
241 void
242 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
253 void
254 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
261 void
262 AliMUONTriggerSegmentationV2::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   
269   AliMpPad pad = 
270     fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
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 //_____________________________________________________________________________
286 void
287 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
317 void
318 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
351 void 
352 AliMUONTriggerSegmentationV2::GiveTestPoints(Int_t&,Float_t*,Float_t*) const
353 {
354   AliFatal("Not Implemented");
355 }
356
357 //_____________________________________________________________________________
358 Bool_t
359 AliMUONTriggerSegmentationV2::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 = 
377   fSlatSegmentation->PadByPosition(TVector2(x,y),kFALSE);
378   return pad.IsValid();
379 }
380
381 //_____________________________________________________________________________
382 Bool_t
383 AliMUONTriggerSegmentationV2::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 //_____________________________________________________________________________
391 void
392 AliMUONTriggerSegmentationV2::IGlo2ILoc(Int_t ixGlo, Int_t iyGlo,
393                                         Int_t& ixLA, Int_t& iyLA) const
394 {
395   Int_t ixPC, iyPC;
396   GetPadGlo2Loc(ixGlo,iyGlo,ixPC,iyPC);
397   PC2LA(ixPC,iyPC,ixLA,iyLA);
398 }
399
400 //_____________________________________________________________________________
401 void
402 AliMUONTriggerSegmentationV2::ILoc2IGlo(Int_t ixLA, Int_t iyLA,
403                                         Int_t& ixGlo, Int_t& iyGlo) const
404 {
405   Int_t ixPC, iyPC;
406   LA2PC(ixLA,iyLA,ixPC,iyPC);
407   GetPadLoc2Glo(ixPC,iyPC,ixGlo,iyGlo);
408 }
409
410 //_____________________________________________________________________________
411 Int_t
412 AliMUONTriggerSegmentationV2::ISector()
413 {
414   // FIXME: remove the usage of ISector from all the code.
415   return -10;
416 }
417
418 //_____________________________________________________________________________
419 void AliMUONTriggerSegmentationV2::IntegrationLimits(Float_t& x1, 
420                                                      Float_t& x2,
421                                                      Float_t& x3, 
422                                                      Float_t& x4) 
423 {
424   // x1 : hit x(y) position
425   // x2 : x(y) coordinate of the main strip
426   // x3 : current strip real x(y) coordinate  
427   // x4 : dist. between x(y) hit pos. and the closest border of the current strip
428   //
429   // Note : need to return (only) x4.
430   
431   AliFatal("Check me before usage. ResponseTrigger does not use me, while"
432            "ResponseTriggerV1 does ?");
433     
434   AliMpPad strip = 
435   fSlatSegmentation->PadByPosition(TVector2(fXhit,fYhit),kFALSE);
436   if ( !strip.IsValid() )
437   {
438     AliWarning(Form("%s got invalid fXhit,fYhit=%e,%e\n",
439                     fSlatSegmentation->GetName(),fXhit,fYhit));
440     x1=x2=x3=x4=0;
441   }
442   else
443   {
444     Double_t xstrip = strip.Position().X();
445     Double_t ystrip = strip.Position().Y();
446     AliDebug(1,Form("fXhit,Yhit=%e,%e xstrip,ystrip=%e,%e\n",
447                     fXhit,fYhit,xstrip,ystrip));
448     x1 = (fPlaneType==kBendingPlane) ? fYhit : fXhit;
449     x2 = (fPlaneType==kBendingPlane) ? ystrip : xstrip;
450     x3 = (fPlaneType==kBendingPlane) ? 
451       fCurrentPad.Position().Y() : fCurrentPad.Position().X();
452     Double_t xmin = 0.0;
453     Double_t xmax = 0.0;
454     if (fPlaneType==kBendingPlane)
455     {
456       xmin = x3 - fCurrentPad.Dimensions().X();
457       xmax = x3 + fCurrentPad.Dimensions().X();
458     }
459     else
460     {
461       xmin = x3 - fCurrentPad.Dimensions().Y();
462       xmax = x3 + fCurrentPad.Dimensions().Y();
463     }
464     // dist. between the hit and the closest border of the current strip
465     x4 = (TMath::Abs(xmax-x1) > TMath::Abs(xmin-x1)) ? 
466       TMath::Abs(xmin-x1):TMath::Abs(xmax-x1);    
467     
468     AliDebug(1,Form("Bending %d x1=%e x2=%e x3=%e x4=%e xmin,max=%e,%e\n",
469                     fPlaneType,x1,x2,x3,x4,xmin,xmax));
470
471   }
472 }  
473
474 //_____________________________________________________________________________
475 Int_t 
476 AliMUONTriggerSegmentationV2::Ix()
477 {
478   if ( fCurrentPad.IsValid() )
479   {
480     Int_t ixGlo,iyGlo;
481     ILoc2IGlo(fCurrentPad.GetIndices().GetFirst(),
482               fCurrentPad.GetIndices().GetSecond(),ixGlo,iyGlo);
483     return ixGlo;
484   }
485   return -1;
486 }
487
488 //_____________________________________________________________________________
489 Int_t 
490 AliMUONTriggerSegmentationV2::Iy()
491 {
492   if ( fCurrentPad.IsValid() )
493   {
494     Int_t ixGlo,iyGlo;
495     ILoc2IGlo(fCurrentPad.GetIndices().GetFirst(),
496               fCurrentPad.GetIndices().GetSecond(),ixGlo,iyGlo);
497     return iyGlo;
498   }
499   return -1;
500 }
501
502
503 //_____________________________________________________________________________
504 void
505 AliMUONTriggerSegmentationV2::LA2PC(Int_t ixLA, Int_t iyLA,
506                                     Int_t& ixPC, Int_t& iyPC) const
507 {
508   //
509   // From LA to PC conventions for integers indices.
510   //
511   ixPC=iyPC=-1;
512   
513   if ( ixLA<0 || iyLA<0 ) return;
514   
515   ixPC = ixLA + 1;
516   iyPC = iyLA + 1;
517   
518   if ( fPlaneType == kBendingPlane )
519   {
520     if ( LineNumber()==5 )
521     {
522       ++ixPC;
523     }
524     if ( LineNumber()==4 && ixLA==0 )
525     {
526       iyPC -= 16;
527     }
528   }
529   
530   AliDebug(3,Form("ix,iy LA (%d,%d) -> PC (%d,%d)",ixLA,iyLA,ixPC,iyPC));
531   
532 }
533
534 //_____________________________________________________________________________
535 Int_t
536 AliMUONTriggerSegmentationV2::LineNumber() const
537 {
538   return 10-fLineNumber;
539 }
540
541 //_____________________________________________________________________________
542 Int_t
543 AliMUONTriggerSegmentationV2::ModuleColNum(Int_t ixGlo) const
544 {
545   // returns column number (from 0 to 6) in which the (global) module 
546   // ix is sitting (could return 7 if ix=isec)
547   return TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10-1;
548 }
549
550 //_____________________________________________________________________________
551 Int_t
552 AliMUONTriggerSegmentationV2::MorePads()
553 {
554   AliFatal("Not implemented");
555   return 0;
556 }
557
558 //_____________________________________________________________________________
559 void AliMUONTriggerSegmentationV2::Neighbours(Int_t /*iX*/, Int_t /*iY*/, 
560                                               Int_t* /*Nlist*/, 
561                                               Int_t /*Xlist*/[10], 
562                                               Int_t /*Ylist*/[10]) 
563 {
564   //-----------------BENDING-----------------------------------------
565   // Returns list of 10 next neighbours for given X strip (ix, iy)  
566   // neighbour number 4 in the list -                     
567   // neighbour number 3 in the list  |                    
568   // neighbour number 2 in the list  |_ Upper part             
569   // neighbour number 1 in the list  |            
570   // neighbour number 0 in the list -           
571   //      X strip (ix, iy) 
572   // neighbour number 5 in the list -       
573   // neighbour number 6 in the list  | _ Lower part
574   // neighbour number 7 in the list  |
575   // neighbour number 8 in the list  | 
576   // neighbour number 9 in the list -
577   
578   //-----------------NON-BENDING-------------------------------------
579   // Returns list of 10 next neighbours for given Y strip (ix, iy)  
580   // neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
581   //                  \_______/                    \_______/
582   //                    left                         right
583   AliFatal("Please implement me");
584 }
585
586 //_____________________________________________________________________________
587 void
588 AliMUONTriggerSegmentationV2::NextPad()
589 {
590   AliFatal("Not implemented");
591 }
592
593 //_____________________________________________________________________________
594 Int_t
595 AliMUONTriggerSegmentationV2::Npx() const
596 {
597   return 124;// FIXME: this should not have to be done, if only we'd stick 
598   // to a local (ix,iy) convention !!! 
599   // return fSlatSegmentation->MaxPadIndexX()+1;
600 }
601
602 //_____________________________________________________________________________
603 Int_t
604 AliMUONTriggerSegmentationV2::Npy() const
605 {
606   return 64;
607 //  return fSlatSegmentation->MaxPadIndexY()+1;
608 }
609
610 //_____________________________________________________________________________
611 void
612 AliMUONTriggerSegmentationV2::PC2LA(Int_t ixPC, Int_t iyPC,
613                                     Int_t& ixLA, Int_t& iyLA) const
614 {
615   //
616   // From PC to LA conventions for integers indices.
617   //
618   ixLA=iyLA=-1;
619   
620   if ( ixPC<0 || iyPC<0 ) return;
621   
622   ixLA = ixPC - 1;
623   iyLA = iyPC - 1;
624   
625   if ( fPlaneType == kBendingPlane )
626   {
627     if ( LineNumber()==5 )
628     {
629       --ixLA;
630     }
631     if ( LineNumber()==4 && ixLA==0 )
632     {
633       iyLA += 16;
634     }
635   }
636   
637   AliDebug(3,Form("ix,iy PC (%d,%d) -> LA (%d,%d)",ixPC,iyPC,ixLA,iyLA));
638 }
639
640 //_____________________________________________________________________________
641 void
642 AliMUONTriggerSegmentationV2::Print(Option_t* opt) const
643 {
644   TString sopt(opt);
645   
646   cout << "DetElemId=" << fDetElemId << " PlaneType=" 
647     << fPlaneType << " Npx=" << Npx() << " Npy=" << Npy() << endl;
648   if ( ( sopt.Contains("SEG") || sopt.Contains("ALL") ) && fSlatSegmentation )
649   {
650     fSlatSegmentation->Print();
651   }
652   if ( sopt.Contains("ALL") && fSlat )
653   {
654     fSlat->Print();
655   }
656 }
657
658 //_____________________________________________________________________________
659 Int_t
660 AliMUONTriggerSegmentationV2::Sector(Int_t ix, Int_t iy)
661 {
662   Int_t ixLA, iyLA;
663   IGlo2ILoc(ix,iy,ixLA,iyLA);
664   AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
665   if ( !pad.IsValid() ) return -1;
666   return Code(ixLA,iyLA);
667   
668 //  AliMpPCB* pcb = fSlat->GetLayer(0)->FindPCB(ixLA);
669 //  if (!pcb)
670 //  {
671 //    AliError(Form("Could not find a pcb at (%d,%d) for slat %s",
672 //             ix,iy,fSlat->GetName()));
673 //    return -1;
674 //  }
675 //  if ( pcb->PadSizeX()==-1.0 )
676 //  {
677 //    // special case of column 7 non-bending.
678 //    return SPECIAL_SECTOR;
679 //  }
680 //  return fSlat->GetLayer(0)->FindPCBIndex(ixLA);
681 }
682
683 //_____________________________________________________________________________
684 Int_t
685 AliMUONTriggerSegmentationV2::Sector(Float_t, Float_t)
686 {
687   AliFatal("Not implemented");
688   return 0;
689 }
690
691 //_____________________________________________________________________________
692 void
693 AliMUONTriggerSegmentationV2::SetCorrFunc(Int_t,TF1*)
694 {
695   AliFatal("Not Implemented");
696 }
697
698 //_____________________________________________________________________________
699 void
700 AliMUONTriggerSegmentationV2::SetDAnod(float)
701 {
702   AliFatal("Not Implemented");
703 }
704
705 //_____________________________________________________________________________
706 void
707 AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y)
708 {
709   fXhit = x;
710   fYhit = y;
711         
712   //
713   // insure we're within the slat limits. If not, issue an error and sets
714   // the current hit to slat center.
715   // FIXME: this should probably a) not happen at all b) be a fatal error
716   //
717   if ( fXhit < -fSlat->DX() || fXhit > fSlat->DX() ||
718        fYhit < -fSlat->DY() || fYhit > fSlat->DY() )
719         {
720                 AliError(Form("Hit outside slat %s limits (x,y)hit = (%e,%e)."
721                   " Forcing to (0,0)",fSlat->GetID(),fXhit,fYhit));
722                 fXhit = 0.0;
723                 fYhit = 0.0;
724         }
725   
726 }
727
728 //_____________________________________________________________________________
729 void
730 AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
731 {
732   SetHit(x,y);
733 }
734
735 //_____________________________________________________________________________
736 void
737 AliMUONTriggerSegmentationV2::SetPad(Int_t ix, Int_t iy)
738 {
739   Int_t ixLA, iyLA;
740   IGlo2ILoc(ix,iy,ixLA,iyLA);
741   fCurrentPad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kTRUE);
742   if ( !fCurrentPad.IsValid() )
743         {
744                 AliError(Form("Setting current pad to invalid ! (ix,iy)=(%4d,%4d)",ix,iy));
745         }
746 }
747
748 //_____________________________________________________________________________
749 void
750 AliMUONTriggerSegmentationV2::SetPadSize(float,float)
751 {
752   AliFatal("Not Implemented");
753 }
754
755 //_____________________________________________________________________________
756 Int_t 
757 AliMUONTriggerSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
758 {
759   AliFatal("Not Implemented");
760   return 0;
761 }
762
763 //_____________________________________________________________________________
764 void 
765 AliMUONTriggerSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
766 {
767   AliFatal("Not Implemented");
768 }
769
770
771
772
773