inline removed following PH request

diff --git a/RICH/AliRICH.h b/RICH/AliRICH.h
index 3a229df16953d3889d44b5c85c6739cc85dca7ab..8e9b4b519c3059007192215013d0c92f7587ad50 100644 (file)
--- a/RICH/AliRICH.h
+++ b/RICH/AliRICH.h
@@ -32,13 +32,13 @@ class AliRICHMerger;
 class AliRICH : public AliDetector 
 {
 public:
-                    AliRICH();                                            //default ctor
-                    AliRICH(const char *name, const char *title);         //named ctor
-  inline            AliRICH(const AliRICH& RICH)                    {;}   //copy ctor  
-          virtual  ~AliRICH();                                            //dtor
+            AliRICH();                                            //default ctor
+            AliRICH(const char *name, const char *title);         //named ctor
+            AliRICH(const AliRICH& RICH)                    {;}   //copy ctor  
+  virtual  ~AliRICH();                                            //dtor
           
-  inline  AliRICH& operator=(const AliRICH& rhs) { return *this;}
-          virtual Int_t  IsVersion() const =0;
+  AliRICH& operator=(const AliRICH& rhs) { return *this;}
+  virtual Int_t  IsVersion() const =0;
           
   virtual void  AddHit(Int_t track, Int_t *vol, Float_t *hits);
           void  AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs);
@@ -65,7 +65,7 @@ public:
   virtual void    CreateGeometry();  //GEANT volumes tree for simulation  
   virtual void    StepManager()=0;
    
-  inline Int_t    DistancetoPrimitive(Int_t px, Int_t py)      {return 9999;}
+          Int_t    DistancetoPrimitive(Int_t px, Int_t py)      {return 9999;}
    
   virtual void   MakeBranch(Option_t *opt=" ");
   virtual void   MakeBranchInTreeD(TTree *treeD, const char *file=0);
@@ -90,18 +90,18 @@ public:
   AliRICHChamber& Chamber(Int_t id) {return *((AliRICHChamber *) (*fChambers)[id]);}
   AliRICHChamber* GetChamber(Int_t iChamberN)     const{return (AliRICHChamber*) (*fChambers)[iChamberN];}
   
-  inline TObjArray     *Dchambers()                     {return fDchambers;}
-  inline TObjArray     *RecHits3D()                const{return fRecHits3D;}
-  inline TObjArray     *RecHits1D()                const{return fRecHits1D;}
-  inline Int_t         *Ndch()                          {return fNdch;}
-  inline Int_t         *Nrechits1D()                    {return fNrechits1D;} 
-  inline Int_t         *Nrechits3D()                    {return fNrechits3D;} 
-  inline TClonesArray  *SDigits()                  const{return fSDigits;}
-  inline TClonesArray  *Cerenkovs()                const{return fCerenkovs;}
-  inline TClonesArray  *DigitsAddress(Int_t id)         {return ((TClonesArray *) (*fDchambers)[id]);}
-  inline TClonesArray  *RecHitsAddress1D(Int_t id) const{return ((TClonesArray *) (*fRecHits1D)[id]);}
-  inline TClonesArray  *RecHitsAddress3D(Int_t id) const{return ((TClonesArray *) (*fRecHits3D)[id]);}
-  inline TClonesArray  *RawClustAddress(Int_t id)  const{return ((TClonesArray *) (*fRawClusters)[id]);}    
+  TObjArray     *Dchambers()                     {return fDchambers;}
+  TObjArray     *RecHits3D()                const{return fRecHits3D;}
+  TObjArray     *RecHits1D()                const{return fRecHits1D;}
+  Int_t         *Ndch()                          {return fNdch;}
+  Int_t         *Nrechits1D()                    {return fNrechits1D;} 
+  Int_t         *Nrechits3D()                    {return fNrechits3D;} 
+  TClonesArray  *SDigits()                  const{return fSDigits;}
+  TClonesArray  *Cerenkovs()                const{return fCerenkovs;}
+  TClonesArray  *DigitsAddress(Int_t id)         {return ((TClonesArray *) (*fDchambers)[id]);}
+  TClonesArray  *RecHitsAddress1D(Int_t id) const{return ((TClonesArray *) (*fRecHits1D)[id]);}
+  TClonesArray  *RecHitsAddress3D(Int_t id) const{return ((TClonesArray *) (*fRecHits3D)[id]);}
+  TClonesArray  *RawClustAddress(Int_t id)  const{return ((TClonesArray *) (*fRawClusters)[id]);}    
 
   void DiagnosticsFE(Int_t evNumber1=0,Int_t evNumber2=0);    // Full events
   void DiagnosticsSE(Int_t diaglevel,Int_t evNumber1=0,Int_t evNumber2=0);    // Single events

diff --git a/RICH/AliRICHParam.h b/RICH/AliRICHParam.h
index 109eaea7d636a8e91d5b1ed4b90591a5b8bf5ba5..09ca4fc928a7986d546813474d00f9e09f8988e4 100644 (file)
--- a/RICH/AliRICHParam.h
+++ b/RICH/AliRICHParam.h
@@ -8,76 +8,76 @@ class AliRICHParam :public TObject
 {
 public:
                  AliRICHParam();  
-         void    Recalc();//Recalculate dependent parameters after changes 
-  inline void    Segmentation(Int_t Nx, Int_t Ny)   {fNx=Nx;fNy=Ny;Recalc();}
-  inline Int_t   Nx()                          const{return fNx;}
-  inline Int_t   Ny()                          const{return fNy;}   
-  inline void    DeadZone(Float_t a)                {       fDeadZone=a;Recalc();}
-  inline Float_t DeadZone()                    const{return fDeadZone;}
-  inline void    PadSize(Float_t x,Float_t y)       {       fPadX=x;fPadY=y;Recalc();} 
-  inline Float_t PadX()                        const{return fPadX;}
-  inline Float_t PadY()                        const{return fPadY;}
-  inline Float_t PadPlaneWidth()               const{return fPadPlaneWidth;}
-  inline Float_t PadPlaneLength()              const{return fPadPlaneLength;}  
-  inline void    Size(Float_t x,Float_t y,Float_t z){fSizeX=x;fSizeY=y;fSizeZ=z;}
-  inline void    GeantSize(Float_t *pParam)    const{pParam[0]=fSizeX/2;pParam[1]=fSizeY/2;pParam[2]=fSizeZ/2;}  
-  inline Float_t SizeX()                       const{return fSizeX;}
-  inline Float_t SizeY()                       const{return fSizeY;}
-  inline Float_t SizeZ()                       const{return fSizeZ;}   
-  inline void    Offset(Float_t offset)             {       fOffset=offset;}  
-  inline Float_t Offset()                      const{return fOffset;}  
-  inline void    AnglesDeg(Float_t xy,Float_t yz)   {       fAngleXY=xy;fAngleYZ=yz;} 
-  inline Float_t AngleYZ()                     const{return fAngleYZ*d2r;} 
-  inline Float_t AngleXY()                     const{return fAngleXY*d2r;} 
-  inline void    AngleRot(Float_t angle)            {       fAngleRot=angle;}
-  inline Float_t AngleRot()                    const{return fAngleRot*d2r;}                
-  inline void    GapThickness(Float_t a)            {       fGapThickness=a;}    
-  inline Float_t GapThickness()                const{return fGapThickness;}      
-  inline void    ProximityGapThickness(Float_t a)   {       fProximityGapThickness=a;}
-  inline Float_t ProximityGapThickness()       const{return fProximityGapThickness;}    
-  inline void    QuartzLength(Float_t a)            {       fQuartzLength=a;}
-  inline Float_t QuartzLength()                const{return fQuartzLength;}   
-  inline void    QuartzWidth(Float_t a)             {       fQuartzWidth=a;}
-  inline Float_t QuartzWidth()                 const{return fQuartzWidth;}
-  inline void    QuartzThickness(Float_t a)         {       fQuartzThickness=a;}
-  inline Float_t QuartzThickness()             const{return fQuartzThickness;}   
-  inline void    OuterFreonLength(Float_t a)        {       fOuterFreonLength=a;}
-  inline Float_t OuterFreonLength()            const{return fOuterFreonLength;}   
-  inline void    OuterFreonWidth(Float_t a)         {       fOuterFreonWidth=a;}
-  inline Float_t OuterFreonWidth()             const{return fOuterFreonWidth;}   
-  inline void    InnerFreonLength(Float_t a)        {       fInnerFreonLength=a;}
-  inline Float_t InnerFreonLength()            const{return fInnerFreonLength;}   
-  inline void    InnerFreonWidth(Float_t a)         {       fInnerFreonWidth=a;}
-  inline Float_t InnerFreonWidth()             const{return fInnerFreonWidth;}   
-  inline void    FreonThickness(Float_t a)          {       fFreonThickness=a;}
-  inline Float_t FreonThickness()              const{return fFreonThickness;}   
-  inline void    RadiatorToPads(Float_t a)          {       fRadiatorToPads=a;}
-  inline Float_t RadiatorToPads()              const{return fRadiatorToPads;}   
-               
-  inline void    SigmaIntegration(Float_t a)        {       fSigmaIntegration=a;}    
-  inline Float_t SigmaIntegration()            const{return fSigmaIntegration;}    
-  inline void    ChargeSpreadX(Float_t a)           {       fChargeSpreadX=a;}
-  inline Float_t ChargeSpreadX()               const{return fChargeSpreadX;}    
-  inline void    ChargeSpreadY(Float_t a)           {       fChargeSpreadY=a;}
-  inline Float_t ChargeSpreadY()               const{return fChargeSpreadY;}   
-  inline void    ChargeSlope(Float_t a)             {       fChargeSlope=a;}
-  inline Float_t ChargeSlope()                      {return fChargeSlope;}
-  inline void    MaxAdc(Float_t a)                  {       fMaxAdc=a;}
-  inline Float_t MaxAdc()                      const{return fMaxAdc;}
-  inline void    Pitch(Float_t a)                   {       fPitch=a;};
-  inline Float_t Pitch()                       const{return fPitch;}
-  inline void    AlphaFeedback(Float_t a)           {       fAlphaFeedback=a;}
-  inline Float_t AlphaFeedback()               const{return fAlphaFeedback;}
-  inline void    EIonisation(Float_t a)             {       fEIonisation=a;}
-  inline Float_t EIonisation()                 const{return fEIonisation;}                            
-  inline void    SqrtKx3(Float_t a)                 {       fSqrtKx3=a;};
-  inline void    Kx2(Float_t a)                     {       fKx2=a;};
-  inline void    Kx4(Float_t a)                     {       fKx4=a;};
-  inline void    SqrtKy3(Float_t a)                 {       fSqrtKy3=a;};
-  inline void    Ky2(Float_t a)                     {       fKy2=a;};
-  inline void    Ky4(Float_t a)                     {       fKy4=a;};
-  inline void    WireSag(Int_t a)                   {       fWireSag=a;};
-  inline void    Voltage(Int_t a)                   {       fVoltage=a;};       
+  void    Recalc();//Recalculate dependent parameters after changes 
+  void    Segmentation(Int_t Nx, Int_t Ny)   {fNx=Nx;fNy=Ny;Recalc();}
+  Int_t   Nx()                          const{return fNx;}
+  Int_t   Ny()                          const{return fNy;}   
+  void    DeadZone(Float_t a)                {       fDeadZone=a;Recalc();}
+  Float_t DeadZone()                    const{return fDeadZone;}
+  void    PadSize(Float_t x,Float_t y)       {       fPadX=x;fPadY=y;Recalc();} 
+  Float_t PadX()                        const{return fPadX;}
+  Float_t PadY()                        const{return fPadY;}
+  Float_t PadPlaneWidth()               const{return fPadPlaneWidth;}
+  Float_t PadPlaneLength()              const{return fPadPlaneLength;}  
+  void    Size(Float_t x,Float_t y,Float_t z){fSizeX=x;fSizeY=y;fSizeZ=z;}
+  void    GeantSize(Float_t *pParam)    const{pParam[0]=fSizeX/2;pParam[1]=fSizeY/2;pParam[2]=fSizeZ/2;}  
+  Float_t SizeX()                       const{return fSizeX;}
+  Float_t SizeY()                       const{return fSizeY;}
+  Float_t SizeZ()                       const{return fSizeZ;}   
+  void    Offset(Float_t offset)             {       fOffset=offset;}  
+  Float_t Offset()                      const{return fOffset;}  
+  void    AnglesDeg(Float_t xy,Float_t yz)   {       fAngleXY=xy;fAngleYZ=yz;} 
+  Float_t AngleYZ()                     const{return fAngleYZ*d2r;} 
+  Float_t AngleXY()                     const{return fAngleXY*d2r;} 
+  void    AngleRot(Float_t angle)            {       fAngleRot=angle;}
+  Float_t AngleRot()                    const{return fAngleRot*d2r;}                
+  void    GapThickness(Float_t a)            {       fGapThickness=a;}    
+  Float_t GapThickness()                const{return fGapThickness;}      
+  void    ProximityGapThickness(Float_t a)   {       fProximityGapThickness=a;}
+  Float_t ProximityGapThickness()       const{return fProximityGapThickness;}    
+  void    QuartzLength(Float_t a)            {       fQuartzLength=a;}
+  Float_t QuartzLength()                const{return fQuartzLength;}   
+  void    QuartzWidth(Float_t a)             {       fQuartzWidth=a;}
+  Float_t QuartzWidth()                 const{return fQuartzWidth;}
+  void    QuartzThickness(Float_t a)         {       fQuartzThickness=a;}
+  Float_t QuartzThickness()             const{return fQuartzThickness;}   
+  void    OuterFreonLength(Float_t a)        {       fOuterFreonLength=a;}
+  Float_t OuterFreonLength()            const{return fOuterFreonLength;}   
+  void    OuterFreonWidth(Float_t a)         {       fOuterFreonWidth=a;}
+  Float_t OuterFreonWidth()             const{return fOuterFreonWidth;}   
+  void    InnerFreonLength(Float_t a)        {       fInnerFreonLength=a;}
+  Float_t InnerFreonLength()            const{return fInnerFreonLength;}   
+  void    InnerFreonWidth(Float_t a)         {       fInnerFreonWidth=a;}
+  Float_t InnerFreonWidth()             const{return fInnerFreonWidth;}   
+  void    FreonThickness(Float_t a)          {       fFreonThickness=a;}
+  Float_t FreonThickness()              const{return fFreonThickness;}   
+  void    RadiatorToPads(Float_t a)          {       fRadiatorToPads=a;}
+  Float_t RadiatorToPads()              const{return fRadiatorToPads;}   
+        
+  void    SigmaIntegration(Float_t a)        {       fSigmaIntegration=a;}    
+  Float_t SigmaIntegration()            const{return fSigmaIntegration;}    
+  void    ChargeSpreadX(Float_t a)           {       fChargeSpreadX=a;}
+  Float_t ChargeSpreadX()               const{return fChargeSpreadX;}    
+  void    ChargeSpreadY(Float_t a)           {       fChargeSpreadY=a;}
+  Float_t ChargeSpreadY()               const{return fChargeSpreadY;}   
+  void    ChargeSlope(Float_t a)             {       fChargeSlope=a;}
+  Float_t ChargeSlope()                      {return fChargeSlope;}
+  void    MaxAdc(Float_t a)                  {       fMaxAdc=a;}
+  Float_t MaxAdc()                      const{return fMaxAdc;}
+  void    Pitch(Float_t a)                   {       fPitch=a;};
+  Float_t Pitch()                       const{return fPitch;}
+  void    AlphaFeedback(Float_t a)           {       fAlphaFeedback=a;}
+  Float_t AlphaFeedback()               const{return fAlphaFeedback;}
+  void    EIonisation(Float_t a)             {       fEIonisation=a;}
+  Float_t EIonisation()                 const{return fEIonisation;}                            
+  void    SqrtKx3(Float_t a)                 {       fSqrtKx3=a;};
+  void    Kx2(Float_t a)                     {       fKx2=a;};
+  void    Kx4(Float_t a)                     {       fKx4=a;};
+  void    SqrtKy3(Float_t a)                 {       fSqrtKy3=a;};
+  void    Ky2(Float_t a)                     {       fKy2=a;};
+  void    Ky4(Float_t a)                     {       fKy4=a;};
+  void    WireSag(Int_t a)                   {       fWireSag=a;};
+  void    Voltage(Int_t a)                   {       fVoltage=a;};       
 protected:
   Int_t   fNx;                //number of pads along X
   Int_t   fNy;                //number of pads along Y

diff --git a/RICH/AliRICHv3.h b/RICH/AliRICHv3.h
index 9d71a2f09a55ef95623455c6c8648eb7d0f53219..0ffa15ef4cdd6a6695f2934160f9d780a184a61b 100644 (file)
--- a/RICH/AliRICHv3.h
+++ b/RICH/AliRICHv3.h
@@ -10,16 +10,16 @@ class AliRICHv3 : public AliRICH
 {    
 public:
     
- inline                AliRICHv3():AliRICH()                                {} 
-                       AliRICHv3(const char *pcName, const char *pcTitle);    
-        virtual       ~AliRICHv3();                             
- inline virtual Int_t  IsVersion()                                     const{return 3;}
-        virtual void   StepManager();     
-        virtual void   CreateGeometry();  
-        virtual void   BuildGeometry();   
-        virtual void   Init();            // Makes nothing for a while          
+                 AliRICHv3():AliRICH()                                {;} 
+                 AliRICHv3(const char *pcName, const char *pcTitle);    
+  virtual       ~AliRICHv3();                             
+  virtual Int_t  IsVersion()                                     const{return 3;}
+  virtual void   StepManager();     
+  virtual void   CreateGeometry();  
+  virtual void   BuildGeometry();   
+  virtual void   Init();            // Makes nothing for a while          
 private:
-            Double_t* RotateXY(const Double_t* r, Double_t a);   //Rotation in the X-Y plane in G3 notation
+  Double_t* RotateXY(const Double_t* r, Double_t a);//Rotation in the X-Y plane in G3 notation
   ClassDef(AliRICHv3,1)  //RICH full version, configurable with azimuthal rotation     
 };// class AliRICHv3