Correct material budget for tracks stopped at TRD (S.Arcelli)

[u/mrichter/AliRoot.git] / ITS / AliITSresponseSSD.h

diff --git a/ITS/AliITSresponseSSD.h b/ITS/AliITSresponseSSD.h
index 770152b2b0d1c41ce7777f4f0ad4d339acc6ce50..0d442ce2fcd39e0f2c7d360c336fbdadd4be46ca 100644 (file)
--- a/ITS/AliITSresponseSSD.h
+++ b/ITS/AliITSresponseSSD.h
@@ -15,19 +15,19 @@ class AliITSresponseSSD : public AliITSresponse {
     virtual ~AliITSresponseSSD();
 
 // Implementation of virtual member functions declared in AliITSresponse 
-    virtual void    SetDiffCoeff(Float_t p1,Float_t /* dummy */) {
+    virtual void    SetDiffCoeff(Double_t p1,Double_t /* dummy */) {
        // Diffusion coefficient
       fDiffCoeff=p1; }
-    virtual void    DiffCoeff(Float_t &diffc,Float_t & /* dummy */) const {
+    virtual void    DiffCoeff(Double_t &diffc,Double_t & /* dummy */) const {
        // Get diffusion coefficient
        diffc= fDiffCoeff;
     }
 
-    virtual  void   SetNoiseParam(Float_t np, Float_t nn) {
+    virtual  void   SetNoiseParam(Double_t np, Double_t nn) {
        // set noise par
        fNoiseP=np; fNoiseN=nn;
     }
-    virtual void    GetNoiseParam(Float_t &np, Float_t &nn) const {
+    virtual void    GetNoiseParam(Double_t &np, Double_t &nn) const {
        // get noise par
        np=fNoiseP; nn=fNoiseN;
     }
@@ -48,21 +48,21 @@ class AliITSresponseSSD : public AliITSresponse {
        fNPar=npar;
     }
 
-    virtual  void   SetDetParam(Float_t *par);
+    virtual  void   SetDetParam(Double_t *par);
 
     // Parameters options
     virtual Int_t   NDetParam() const {
        // number of param
        return fNPar;
     }
-    virtual void    GetDetParam(Float_t *dpar) const; 
+    virtual void    GetDetParam(Double_t *dpar) const; 
 
-    virtual void    SetSigmaSpread(Float_t p1, Float_t p2) {
+    virtual void    SetSigmaSpread(Double_t p1, Double_t p2) {
        // Set sigmas of the charge spread function: Pside-Nside
        // square of (microns)
        fSigmaP=p1; fSigmaN=p2;
     }
-    virtual void    SigmaSpread(Float_t &sP, Float_t &sN) const {
+    virtual void    SigmaSpread(Double_t &sP, Double_t &sN) const {
        // Get sigmas for the charge spread 
        sP=fSigmaP; sN=fSigmaN;
     }
@@ -72,7 +72,7 @@ class AliITSresponseSSD : public AliITSresponse {
 // Sets electron-hole pairs to ADC value conversion factor
 // are rather arbitrary (need tuning)
 // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
-    void SetADCpereV(Float_t a=50./30000.0){fADCpereV = a;}
+    void SetADCpereV(Double_t a=50./30000.0){fADCpereV = a;}
 // Converts electron-hole pairs to
 // ADC value conversion factor are rather arbitrary (need tuning)
 // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
@@ -82,60 +82,49 @@ class AliITSresponseSSD : public AliITSresponse {
        return ((Int_t) DEvToADC(eV)); }
 
  //abstract methods in AliITSresponse not implemented in this class
-    virtual void    SetDriftSpeed(Float_t /* p1 */)
+    virtual void    SetDriftSpeed(Double_t /* p1 */)
       {NotImplemented("SetDriftSpeed");}
-    virtual Float_t DriftSpeed() const 
+    virtual Double_t DriftSpeed() const 
       {NotImplemented("DrifSpeed"); return 0.;}
-    virtual void   SetElectronics(Int_t /* i */) 
-                    {NotImplemented("SetElectronics");}
-    virtual Int_t Electronics() const {NotImplemented("Electronics"); return 0;}
     virtual void    GiveCompressParam(Int_t *) const
       {NotImplemented("GiveCompressParam");}
-    virtual void SetMaxAdc(Float_t /* adc */) {NotImplemented("SetMaxAdc");}
-    virtual Float_t MaxAdc() const {NotImplemented("MaxAdc"); return 0.;}
-    virtual void    SetDynamicRange(Float_t /*dr */) 
-      {NotImplemented("SetDynamicRange");}
-    virtual Float_t DynamicRange() const 
-      {NotImplemented("DynamicRange"); return 0.;}
-    virtual void    SetChargeLoss(Float_t /* cl */)
-      {NotImplemented("SetChargeLoss"); }
-    virtual Float_t ChargeLoss() const 
+    virtual Double_t ChargeLoss() const 
       {NotImplemented("ChargeLoss"); return 0.;}
-    virtual void   SetThresholds(Float_t /* a */, Float_t /* b */)
+    virtual void   SetThresholds(Double_t /* a */, Double_t /* b */)
       {NotImplemented("SetThresholds");}
-    virtual void   Thresholds(Float_t & /* a */, Float_t & /* b */) const 
+    virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const 
       {NotImplemented("Thresholds");}
     virtual void   SetZeroSupp(const char*)
       {NotImplemented("SetZeroSupp");}
     virtual const char *ZeroSuppOption() const 
       {NotImplemented("ZeroSuppression"); return "";}
-    virtual void    SetNSigmaIntegration(Float_t)
+    virtual void    SetNSigmaIntegration(Double_t)
       {NotImplemented("SetNSigmaIntegration");}
-    virtual Float_t NSigmaIntegration() const
+    virtual Double_t NSigmaIntegration() const
       {NotImplemented("NSigmaIntegration"); return 0.;}
     virtual void    SetNLookUp(Int_t) 
       {NotImplemented("SetNLookUp");}
   
  protected:
-    static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
+    static const Double_t fgkDiffCoeffDefault; //default for fDiffCoeff
     static const TString fgkOption1Default; // default for fOption1
     static const TString fgkOption2Default; // default for fOption2
-    static const Float_t fgkNoiseNDefault; // default for fNoiseN
-    static const Float_t fgkNoisePDefault; // default for fNoiseP
+    static const Double_t fgkNoiseNDefault; // default for fNoiseN
+    static const Double_t fgkNoisePDefault; // default for fNoiseP
     static const Int_t fgkNParDefault; // default for fNPar
-    static const Float_t fgkSigmaPDefault; //default for fSigmaP
-    static const Float_t fgkSigmaNDefault; //default for fSigmaP
+    static const Double_t fgkSigmaPDefault; //default for fSigmaP
+    static const Double_t fgkSigmaNDefault; //default for fSigmaP
     Int_t   fNPar;            // Number of detector param 
-    Float_t *fDetPar;         //[fNPar] Array of parameters
+    Double_t *fDetPar;         //[fNPar] Array of parameters
 
-    Float_t fNoiseP;          // Noise on Pside
-    Float_t fNoiseN;          // Noise on Nside
+    Double_t fNoiseP;          // Noise on Pside
+    Double_t fNoiseN;          // Noise on Nside
 
-    Float_t fSigmaP;          // Sigma charge spread on Pside
-    Float_t fSigmaN;          // Sigma charge spread on Nside
-    Float_t fDiffCoeff;       // Diffusion Coefficient
+    Double_t fSigmaP;          // Sigma charge spread on Pside
+    Double_t fSigmaN;          // Sigma charge spread on Nside
+    Double_t fDiffCoeff;       // Diffusion Coefficient
 
-    Float_t fADCpereV;        // Constant to convert eV to ADC.
+    Double_t fADCpereV;        // Constant to convert eV to ADC.
 
     TString fOption1;         // Simulate invalid strips option
     TString fOption2;         // Not used for the moment