Removing circular dependences, work in progress (Ch. Finck)

[u/mrichter/AliRoot.git] / MUON / AliMUONResponse.h

diff --git a/MUON/AliMUONResponse.h b/MUON/AliMUONResponse.h
index a7ed4a97b6d8825bce9f66c9d4914c1b3ada45ca..4bd92b0cd211e71ef316d2a955e92aff0f2bc0cc 100644 (file)
--- a/MUON/AliMUONResponse.h
+++ b/MUON/AliMUONResponse.h
@@ -16,55 +16,55 @@ class AliMUONResponse : public TObject
 {
  public:
     AliMUONResponse();
-    virtual ~AliMUONResponse();
+    ~AliMUONResponse();
  
     //
     // Configuration methods
     //
     // Set number of sigmas over which cluster disintegration is performed
-    virtual void    SetSigmaIntegration(Float_t p1)           =0;
+    virtual void    SetSigmaIntegration(Float_t)           {return;}
     // Get number of sigmas over which cluster disintegration is performed
-    virtual Float_t SigmaIntegration() const                  =0;
+    virtual Float_t SigmaIntegration() const                  {return 1.;}
     // Set single electron pulse height (ADCcounts/e)
-    virtual void    SetChargeSlope(Float_t p1)                =0;
+    virtual void    SetChargeSlope(Float_t )                {return;}
     // Get single electron pulse height (ADCcounts/e)
-    virtual Float_t ChargeSlope() const                       =0;
+    virtual Float_t ChargeSlope() const                       {return 1.;}
     // Set sigmas of the charge spread function
-    virtual void    SetChargeSpread(Float_t p1, Float_t p2)   =0;
+    virtual void    SetChargeSpread(Float_t , Float_t )   {return;}
     // Get sigma_X of the charge spread function
-    virtual Float_t ChargeSpreadX() const                     =0;
+    virtual Float_t ChargeSpreadX() const                     {return 1.;}
     // Get sigma_Y of the charge spread function
-    virtual Float_t ChargeSpreadY() const                     =0;
+    virtual Float_t ChargeSpreadY() const                     {return 1.;}
     // Set maximum Adc-count value
-    virtual void    SetMaxAdc(Int_t p1)                       =0;
+    virtual void    SetMaxAdc(Int_t )                       {return;}
     // Set saturation value
-    virtual void    SetSaturation(Int_t p1)                   =0;
+    virtual void    SetSaturation(Int_t )                   {return;}
     // Set zero suppression threshold
-    virtual void    SetZeroSuppression(Int_t val)             =0;
+    virtual void    SetZeroSuppression(Int_t )             {return;}
     // Get maximum Adc-count value
-    virtual Int_t MaxAdc() const                              =0;
+    virtual Int_t MaxAdc() const                              {return kTRUE;}
     // Get saturation value
-    virtual Int_t Saturation() const                          =0;
+    virtual Int_t Saturation() const                          {return kTRUE;}
     // Get maximum zero suppression threshold
-    virtual Int_t ZeroSuppression() const                     =0;
+    virtual Int_t ZeroSuppression() const                     {return kTRUE;}
     // Set anode cathode Pitch
-    virtual void    SetPitch(Float_t)                         =0;
+    virtual void    SetPitch(Float_t)                         {return;}
     // Get anode cathode Pitch
-    virtual Float_t Pitch() const                             =0;
+    virtual Float_t Pitch() const                             {return 1.;}
     // Set the charge correlation
-    virtual void SetChargeCorrel(Float_t correl)              =0;
+    virtual void SetChargeCorrel(Float_t)              {return;}
     // Get the charge correlation
-    virtual Float_t ChargeCorrel() const                      =0;
+    virtual Float_t ChargeCorrel() const                      {return 1.;}
     //  
     // Chamber response methods
     // Pulse height from scored quantity (eloss)
-    virtual Float_t IntPH(Float_t eloss)                      =0;
+    virtual Float_t IntPH(Float_t)                      {return 1.;}
     // Charge disintegration 
-    virtual Float_t IntXY(AliSegmentation *)                  =0;
+    virtual Float_t IntXY(AliSegmentation *)                  {return 1.;}
     // Noise, zero-suppression, adc saturation
-    //virtual Int_t DigitResponse(Int_t digit)                =0;
-    virtual Int_t DigitResponse(Int_t digit, 
-                                AliMUONTransientDigit* where) =0;
+    //virtual Int_t DigitResponse(Int_t )                {return kTRUE;}
+    virtual Int_t DigitResponse(Int_t , 
+                                AliMUONTransientDigit* ) {return kTRUE;}
     // 
     ClassDef(AliMUONResponse,1) // Chamber response virtual base class 
 };