Removing warnings ...

diff --git a/MUON/AliMUONSegmentationV0.cxx b/MUON/AliMUONSegmentationV0.cxx
index abc7866f0293ee8288913448d99ec470076e5ea8..0be385e849d951110bdf1d33733099867685aaa9 100644 (file)
--- a/MUON/AliMUONSegmentationV0.cxx
+++ b/MUON/AliMUONSegmentationV0.cxx
@@ -23,10 +23,10 @@
 #include "AliMUON.h"
 
 ClassImp(AliMUONSegmentationV0)
-    AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation)
-{
-// Dummy copy constructor
-}
+//     AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation)
+// {
+// // Dummy copy constructor
+// }
 
     void AliMUONSegmentationV0::Init(Int_t  chamber)
 {
@@ -54,7 +54,35 @@ Float_t AliMUONSegmentationV0::GetAnod(Float_t xhit) const
     Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
     return fWireD*wire;
 }
+//____________________________________________________________________________
+void   AliMUONSegmentationV0::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t *Nparallel, Int_t *Offset) 
+{
+  *Nparallel=1;
+  *Offset=0;
+}
+
 
+//____________________________________________________________________________
+void   AliMUONSegmentationV0::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)  
+{
+  GetPadI(x, y, ix, iy);
+}
+//____________________________________________________________________________
+void   AliMUONSegmentationV0::SetCorrFunc(Int_t /*dum*/, TF1* func) 
+{
+  fCorr=func;
+}
+//____________________________________________________________________________
+Int_t   AliMUONSegmentationV0::Sector(Int_t /*ix*/, Int_t /*iy*/)  
+{
+  return 1;
+}
+//____________________________________________________________________________
+Int_t   AliMUONSegmentationV0::Sector(Float_t /*x*/, Float_t /*y*/)  
+{
+  return 1;
+}
+//____________________________________________________________________________
 void AliMUONSegmentationV0::SetPadSize(Float_t p1, Float_t p2)
 {
 //  Sets the padsize 
@@ -93,9 +121,8 @@ GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
     x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)+fDpx/2.;
     y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
 }
-
-void AliMUONSegmentationV0::
-SetHit(Float_t xhit, Float_t yhit)
+//______________________________________________________________________
+void AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit)
 {
     //
     // Sets virtual hit position, needed for evaluating pad response 
@@ -103,6 +130,13 @@ SetHit(Float_t xhit, Float_t yhit)
     fXhit=xhit;
     fYhit=yhit;
 }
+//_______________________________________________________________________
+void     AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
+{
+  SetHit(xhit, yhit);
+}
+//_______________________________________________________________________
+
 
 void AliMUONSegmentationV0::
 SetPad(Int_t ix, Int_t iy)
@@ -112,9 +146,8 @@ SetPad(Int_t ix, Int_t iy)
     // outside the tracking program 
     GetPadC(ix,iy,fX,fY);
 }
-
-void AliMUONSegmentationV0::
-FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
+//____________________________________________________________________________________
+void AliMUONSegmentationV0::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
 {
 // Initialises iteration over pads for charge distribution algorithm
 //
@@ -139,6 +172,10 @@ FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
     fIy=fIymin;
     GetPadC(fIx,fIy,fX,fY);
 }
+//________________________________________________________________________
+void AliMUONSegmentationV0::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
+       {FirstPad(xhit, yhit, dx, dy);}
+
 
 void AliMUONSegmentationV0::NextPad()
 {
@@ -174,7 +211,7 @@ Int_t AliMUONSegmentationV0::MorePads()
     }
 }
 
-void AliMUONSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t z)
+void AliMUONSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t /*z*/)
 {
 //
 //  Initialises pad and wire position during stepping
@@ -184,7 +221,7 @@ void AliMUONSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t z)
     fIwt= (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
 }
  
-Int_t AliMUONSegmentationV0::SigGenCond(Float_t x,Float_t y,Float_t z) 
+Int_t AliMUONSegmentationV0::SigGenCond(Float_t x,Float_t y,Float_t /*z*/) 
 {
 //  Signal generation condition during stepping 
 //  0: don't generate signal
@@ -238,7 +275,7 @@ Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 }
 
 Float_t AliMUONSegmentationV0::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y
-, Int_t *dummy)
+                                                 , Int_t * /*dummy*/)
 {
 // Returns the square of the distance between 1 pad
 // labelled by its Channel numbers and a coordinate
@@ -275,7 +312,7 @@ void AliMUONSegmentationV0::Draw(const char *) const
     circle->Draw();
 }
 
-AliMUONSegmentationV0& AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & rhs)
+AliMUONSegmentationV0& AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & /*rhs*/)
 {
 // Dummy assignment operator
     return *this;

diff --git a/MUON/AliMUONSegmentationV0.h b/MUON/AliMUONSegmentationV0.h
index 49ee0d6250ca907a023b4dc87b6c2b7eff98dd04..517338e55a460e0d86c523fbd250974efa283491 100644 (file)
--- a/MUON/AliMUONSegmentationV0.h
+++ b/MUON/AliMUONSegmentationV0.h
@@ -33,8 +33,7 @@ public AliSegmentation {
     virtual Float_t GetAnod(Float_t xhit) const;
     // Transform from pad to real coordinates
     virtual void    GetPadI(Float_t x, Float_t y , Int_t &ix, Int_t &iy) ;
-    virtual void    GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy)  
-       {GetPadI(x, y, ix, iy);}
+    virtual void    GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy) ;
     // Transform from real to pad coordinates
     virtual void    GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) ;
     virtual void    GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z) 
@@ -61,14 +60,11 @@ public AliSegmentation {
     virtual void     SetPad(Int_t ix, Int_t iy);
     // Set hit position
     virtual void     SetHit(Float_t xhit, Float_t yhit);
-    virtual void     SetHit(Float_t xhit, Float_t yhit, Float_t zhit)
-       {SetHit(xhit, yhit);}
-    //
+    virtual void     SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
     // Iterate over pads
     // Initialiser
     virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy);
-    virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy)
-       {FirstPad(xhit, yhit, dx, dy);}
+    virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy);
     // Stepper
     virtual void  NextPad();
     // Condition
@@ -79,8 +75,7 @@ public AliSegmentation {
 dummy);
     // Number of pads read in parallel and offset to add to x 
     // (specific to LYON, but mandatory for display)
-    virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
-        Int_t *Nparallel, Int_t *Offset) {*Nparallel=1;*Offset=0;}
+    virtual void GetNParallelAndOffset(Int_t iX, Int_t iY, Int_t *Nparallel, Int_t *Offset);
     // Get next neighbours 
     virtual void Neighbours
        (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) ;
@@ -93,8 +88,8 @@ dummy);
     // current sector
     virtual Int_t  ISector() {return 1;}
     // calculate sector from pad coordinates
-    virtual Int_t  Sector(Int_t ix, Int_t iy)  {return 1;}
-    virtual Int_t  Sector(Float_t x, Float_t y)  {return 1;}
+    virtual Int_t  Sector(Int_t ix, Int_t iy);
+    virtual Int_t  Sector(Float_t x, Float_t y);
     //
     // Signal Generation Condition during Stepping
     virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) ;
@@ -109,7 +104,7 @@ dummy);
     virtual void Draw(const char *opt="") const;
     // Function for systematic corrections
     // Set the correction function
-    virtual void SetCorrFunc(Int_t dum, TF1* func) {fCorr=func;}
+    virtual void SetCorrFunc(Int_t dum, TF1* func);
     // Get the correction Function
     virtual TF1* CorrFunc(Int_t) const {return fCorr;}
     // assignment operator