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