calibration parameters for SDD changed from double to float. Effective C++ warnings...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Aug 2006 15:16:25 +0000 (15:16 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Aug 2006 15:16:25 +0000 (15:16 +0000)
13 files changed:
ITS/AliITSCalibration.cxx
ITS/AliITSCalibration.h
ITS/AliITSCalibrationSDD.cxx
ITS/AliITSCalibrationSDD.h
ITS/AliITSgeom.cxx
ITS/AliITSgeom.h
ITS/AliITSgeomMatrix.cxx
ITS/AliITSgeomMatrix.h
ITS/AliITSresponse.cxx
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/Calib/CalibSDD/Run0_9999999_v0_s0.root
ITS/Calib/RespSDD/Run0_9999999_v0_s0.root

index 90505d9..8b05d89 100644 (file)
 ClassImp(AliITSCalibration)
 
 //______________________________________________________________________
-AliITSCalibration::AliITSCalibration(){
-    // Default Constructor
+AliITSCalibration::AliITSCalibration():
+TObject(),
+fDataType(),
+fdv(0.000375),
+fN(0.),
+fT(300.),
+fGeVcharge(0.),
+fResponse(){
+    // Default Constructor (300 microns and 80 volts)
 
-    fdv = 0.000375;  // 300 microns and 80 volts.
-    fN  = 0.0;
-    fT  = 300.0;
     SetGeVToCharge();
     fResponse = 0;
 }
 //______________________________________________________________________
-AliITSCalibration::AliITSCalibration(Double_t thickness){
+AliITSCalibration::AliITSCalibration(Double_t thickness):
+TObject(),
+fDataType(),
+fdv(0.),
+fN(0.),
+fT(300.),
+fGeVcharge(0.),
+fResponse(){
     // Default Constructor
 
     fdv = thickness/80.0;   // 80 volts.
-    fN  = 0.0;
-    fT  = 300.0;
     SetGeVToCharge();
     fResponse = 0;
 }
-//______________________________________________________________________
-AliITSCalibration::AliITSCalibration(const AliITSCalibration &ob) : TObject(ob) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSCalibration","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSCalibration& AliITSCalibration::operator=(const AliITSCalibration& /* ob */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
 
 //______________________________________________________________________
 Double_t AliITSCalibration::MobilityElectronSiEmp() const {
index 3ad0b37..b235718 100644 (file)
@@ -26,8 +26,7 @@ class AliITSCalibration : public TObject {
     AliITSCalibration();
     // Standard Constructor
     AliITSCalibration(Double_t Thickness);
-    AliITSCalibration(const AliITSCalibration &ob); // copy constructor
-    AliITSCalibration& operator=(const AliITSCalibration & /* source */); // ass.
+
     // Destructor.
     virtual ~AliITSCalibration() {;}
     //
@@ -149,6 +148,8 @@ class AliITSCalibration : public TObject {
     virtual Bool_t OutputOption() const {return fResponse->OutputOption();} 
 
  protected:
+    AliITSCalibration(const AliITSCalibration &ob); // copy constructor
+    AliITSCalibration& operator=(const AliITSCalibration & /* source */); // ass.
     void NotImplemented(const char *method) const {if(gDebug>0)
          Warning(method,"This method is not implemented for this sub-class");}
 
index a8bc37b..225c3dc 100644 (file)
 //                                                  //
 //////////////////////////////////////////////////////
 
-const Double_t AliITSCalibrationSDD::fgkTemperatureDefault = 296.;
-const Double_t AliITSCalibrationSDD::fgkNoiseDefault = 10.;
-const Double_t AliITSCalibrationSDD::fgkGainDefault = 1.;
-const Double_t AliITSCalibrationSDD::fgkBaselineDefault = 20.;
-const Double_t AliITSCalibrationSDD::fgkMinValDefault  = 4;
+const Float_t AliITSCalibrationSDD::fgkTemperatureDefault = 296.;
+const Float_t AliITSCalibrationSDD::fgkNoiseDefault = 10.;
+const Float_t AliITSCalibrationSDD::fgkGainDefault = 1.;
+const Float_t AliITSCalibrationSDD::fgkBaselineDefault = 20.;
+const Float_t AliITSCalibrationSDD::fgkMinValDefault  = 4;
 //______________________________________________________________________
 ClassImp(AliITSCalibrationSDD)
 
-AliITSCalibrationSDD::AliITSCalibrationSDD(){
+AliITSCalibrationSDD::AliITSCalibrationSDD():
+AliITSCalibration(),
+fDeadChips(0),
+fDeadChannels(0),
+fMinVal(fgkMinValDefault),
+fIsDead(kFALSE),
+fBadChannels()
+{
   // default constructor
 
   SetDeadChannels();
-  fBadChannels.Set(fDeadChannels);
   for(Int_t ian=0;ian<fgkWings*fgkChannels*fgkChips;ian++){
     fBaseline[ian]=fgkBaselineDefault;
     fNoise[ian]=fgkNoiseDefault;
@@ -62,11 +68,16 @@ AliITSCalibrationSDD::AliITSCalibrationSDD(){
   }
  }
 //______________________________________________________________________
-AliITSCalibrationSDD::AliITSCalibrationSDD(const char *dataType){
+AliITSCalibrationSDD::AliITSCalibrationSDD(const char *dataType):
+AliITSCalibration(),
+fDeadChips(0),
+fDeadChannels(0),
+fMinVal(fgkMinValDefault),
+fIsDead(kFALSE),
+fBadChannels(){
   // constructor
 
   SetDeadChannels();
-  fBadChannels.Set(fDeadChannels);
   for(Int_t ian=0;ian<fgkWings*fgkChannels*fgkChips;ian++){
     fBaseline[ian]=fgkBaselineDefault;
       fNoise[ian]=fgkNoiseDefault;
@@ -90,20 +101,7 @@ AliITSCalibrationSDD::AliITSCalibrationSDD(const char *dataType){
   }
 
  }
-//______________________________________________________________________
-AliITSCalibrationSDD::AliITSCalibrationSDD(const AliITSCalibrationSDD &ob) : AliITSCalibration(ob) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSCalibrationSDD","Copy constructor not allowed\n");
-}
 
-//______________________________________________________________________
-AliITSCalibrationSDD& AliITSCalibrationSDD::operator=(const AliITSCalibrationSDD& /* ob */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
 
 //______________________________________________________________________
 void AliITSCalibrationSDD::GiveCompressParam(Int_t  cp[8],Int_t ian) const {
index f4e5ab9..e0107ac 100644 (file)
@@ -28,9 +28,9 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     virtual void  GetNoiseParam(Double_t &/*n*/, Double_t &/*b*/) const {
       NotImplemented("GetNoiseParam");}
 
-    virtual Double_t GetBaseline(Int_t anode) const {return fBaseline[anode];}
+    virtual Float_t GetBaseline(Int_t anode) const {return fBaseline[anode];}
     virtual void SetBaseline(Int_t anode,Double_t bas) {fBaseline[anode]=bas;}
-    virtual Double_t GetNoise(Int_t anode) const {return fNoise[anode];}
+    virtual Float_t GetNoise(Int_t anode) const {return fNoise[anode];}
     virtual void SetNoise(Int_t anode, Double_t noise) {fNoise[anode]=noise;}
 
     virtual void   SetThresholds(Double_t  mv, Double_t /* b */){
@@ -44,14 +44,14 @@ class AliITSCalibrationSDD : public AliITSCalibration {
        // Noise after electronics (ADC units)
        // 2.36 for ALICE from beam test measurements 2001
        fNoiseAfterEl[anode]=n;}
-    Double_t  GetNoiseAfterElectronics(Int_t anode) const {
+    Float_t  GetNoiseAfterElectronics(Int_t anode) const {
        // Noise after electronics (ADC units)
        return fNoiseAfterEl[anode];} 
     //void SetDeadChannels(Int_t nchips=0, Int_t nchannels=0);
     void SetDeadChannels(Int_t ndead=0){fDeadChannels=ndead; fBadChannels.Set(ndead);}
     Int_t GetDeadChips() const { return fDeadChips; }
     Int_t GetDeadChannels() const { return fDeadChannels; }
-    Double_t Gain(Int_t wing,Int_t chip,Int_t ch)const 
+    Float_t Gain(Int_t wing,Int_t chip,Int_t ch)const 
         {return fGain[wing][chip][ch]; }
     virtual void SetGain(Double_t g,Int_t wing,Int_t chip, Int_t ch) 
       {fGain[wing][chip][ch]=g;}
@@ -93,26 +93,26 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     virtual void SetElectronics(Int_t p1=1) {((AliITSresponseSDD*)fResponse)->SetElectronics(p1);}
     virtual Int_t GetElectronics() const {return ((AliITSresponseSDD*)fResponse)->Electronics();}
     virtual void SetMaxAdc(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetMaxAdc(p1);}
-    virtual Double_t GetMaxAdc() const {return ((AliITSresponseSDD*)fResponse)->MaxAdc();} 
+    virtual Float_t GetMaxAdc() const {return ((AliITSresponseSDD*)fResponse)->MaxAdc();} 
     virtual void SetChargeLoss(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetChargeLoss(p1);}
-    virtual Double_t GetChargeLoss() const {return ((AliITSresponseSDD*)fResponse)->ChargeLoss();}
+    virtual Float_t GetChargeLoss() const {return ((AliITSresponseSDD*)fResponse)->ChargeLoss();}
     virtual void SetDynamicRange(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetDynamicRange(p1);}
-    virtual Double_t GetDynamicRange() const {return ((AliITSresponseSDD*)fResponse)->DynamicRange();} 
+    virtual Float_t GetDynamicRange() const {return ((AliITSresponseSDD*)fResponse)->DynamicRange();} 
     virtual void SetDriftSpeed(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetDriftSpeed(p1);}
-    virtual Double_t GetDriftSpeed() const {return ((AliITSresponseSDD*)fResponse)->DriftSpeed();}
+    virtual Float_t GetDriftSpeed() const {return ((AliITSresponseSDD*)fResponse)->DriftSpeed();}
     virtual void SetParamOptions(const char *opt1,const char *opt2) {((AliITSresponseSDD*)fResponse)->SetParamOptions(opt1,opt2);}
     virtual void GetParamOptions(char *opt1,char *opt2) const {((AliITSresponseSDD*)fResponse)->ParamOptions(opt1,opt2);}
     virtual Bool_t Do10to8() const {return ((AliITSresponseSDD*)fResponse)->Do10to8();}
     virtual void SetZeroSupp (const char *opt) {((AliITSresponseSDD*)fResponse)->SetZeroSupp(opt);} 
     virtual const char *GetZeroSuppOption() const {return ((AliITSresponseSDD*)fResponse)->ZeroSuppOption();}
     virtual void SetNSigmaIntegration(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetNSigmaIntegration(p1);}
-    virtual Double_t GetNSigmaIntegration() const {return ((AliITSresponseSDD*)fResponse)->NSigmaIntegration();}
+    virtual Float_t GetNSigmaIntegration() const {return ((AliITSresponseSDD*)fResponse)->NSigmaIntegration();}
     virtual void SetNLookUp(Int_t p1) {((AliITSresponseSDD*)fResponse)->SetNLookUp(p1);}
     virtual Int_t GetGausNLookUp() const {return ((AliITSresponseSDD*)fResponse)->GausNLookUp();}
-    virtual Double_t GetGausLookUp(Int_t i) const {return ((AliITSresponseSDD*)fResponse)->GausLookUp(i);}
+    virtual Float_t GetGausLookUp(Int_t i) const {return ((AliITSresponseSDD*)fResponse)->GausLookUp(i);}
     virtual Int_t Convert8to10(Int_t signal) const {return ((AliITSresponseSDD*)fResponse)->Convert8to10(signal);}
     virtual void  SetJitterError(Double_t jitter=20) {((AliITSresponseSDD*)fResponse)->SetJitterError(jitter);}
-    virtual Double_t GetJitterError() const {return ((AliITSresponseSDD*)fResponse)->JitterError();}
+    virtual Float_t GetJitterError() const {return ((AliITSresponseSDD*)fResponse)->JitterError();}
     virtual void  SetDo10to8(Bool_t bitcomp=kTRUE) {((AliITSresponseSDD*)fResponse)->SetDo10to8(bitcomp);}
  protected:
 
@@ -121,19 +121,19 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     static const Int_t fgkWings = 2;     // Number of wings per module
     static const Int_t fgkChips = 4;        // Number of chips/module
     static const Int_t fgkChannels = 64;    // Number of channels/chip
-    static const Double_t fgkTemperatureDefault; // default for fT (Kelvin)
-    static const Double_t fgkNoiseDefault; // default for fNoise
-    static const Double_t fgkBaselineDefault; // default for fBaseline
-    static const Double_t fgkMinValDefault; // default for fMinVal
-    static const Double_t fgkGainDefault; //default for gain
+    static const Float_t fgkTemperatureDefault; // default for fT (Kelvin)
+    static const Float_t fgkNoiseDefault; // default for fNoise
+    static const Float_t fgkBaselineDefault; // default for fBaseline
+    static const Float_t fgkMinValDefault; // default for fMinVal
+    static const Float_t fgkGainDefault; //default for gain
     static const Int_t fgkMapTimeNBin = 72; //map granularity along drift direction
     Int_t fDeadChips;                     // Number of dead chips
     Int_t fDeadChannels;                  // Number of dead channels
-    Double_t fGain[fgkWings][fgkChips][fgkChannels];//Array for channel gains
-    Double_t fNoise[fgkWings*fgkChips*fgkChannels];          // Noise array
-    Double_t fBaseline[fgkWings*fgkChips*fgkChannels];       // Baseline array
-    Double_t fNoiseAfterEl[fgkWings*fgkChips*fgkChannels];   // Noise after electronics
-    Double_t fMinVal;        // Min value used in 2D zero-suppression algo
+    Float_t fGain[fgkWings][fgkChips][fgkChannels];//Array for channel gains
+    Float_t fNoise[fgkWings*fgkChips*fgkChannels];          // Noise array
+    Float_t fBaseline[fgkWings*fgkChips*fgkChannels];       // Baseline array
+    Float_t fNoiseAfterEl[fgkWings*fgkChips*fgkChannels];   // Noise after electronics
+    Float_t fMinVal;        // Min value used in 2D zero-suppression algo
 
     Bool_t   fIsDead;  // module is dead or alive ?
     TArrayI  fBadChannels; //Array with bad anodes number (0-512) 
@@ -145,7 +145,7 @@ class AliITSCalibrationSDD : public AliITSCalibration {
     AliITSCalibrationSDD& operator=(const AliITSCalibrationSDD & /* source */); // ass. op.
 
 
-    ClassDef(AliITSCalibrationSDD,4) // SDD response 
+    ClassDef(AliITSCalibrationSDD,5) // SDD response 
     
     };
 #endif
index 80a8361..3f53ebd 100644 (file)
@@ -628,6 +628,7 @@ fShape(0,0)      // TObjArray of detector geom.
     } // end while ever loop
     fclose(pf);
 }
+/*
 //______________________________________________________________________
 AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source){
     //     The copy constructor for the AliITSgeom class. It calls the
@@ -686,6 +687,7 @@ AliITSgeom& AliITSgeom::operator=(const AliITSgeom &source){
         this->fGm.AddAt(new TObject(*(source.fGm.At(i))),i);
     return *this;
 }
+*/
 //______________________________________________________________________
 Int_t AliITSgeom::GetModuleIndex(Int_t lay,Int_t lad,Int_t det)const{
     //      This routine computes the module index number from the layer,
index f05916f..d3c315d 100644 (file)
@@ -38,8 +38,6 @@ class AliITSgeom : public TObject {
     AliITSgeom(const char *filename);  // Constructor
     AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,const Int_t *ndets,
                Int_t nmods); // Constructor
-    AliITSgeom(const AliITSgeom &source);    // Copy constructor
-    AliITSgeom& operator=(const AliITSgeom &source);// = operator
     virtual ~AliITSgeom();             // Default destructor
     // Zero and reinitilizes this class.
     void Init(Int_t itype,Int_t nlayers,const Int_t *nlads,
@@ -763,6 +761,10 @@ class AliITSgeom : public TObject {
 
     void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,Float_t &xout,Float_t &zout);
 
+ protected:
+    AliITSgeom(const AliITSgeom &source);    // Copy constructor
+    AliITSgeom& operator=(const AliITSgeom &source);// = operator
+
  private:
     TString    fVersion; // Transformation version.
     Int_t      fTrans;   // Flag to keep track of which transformation 
index b6a387c..ed8b6d5 100644 (file)
@@ -83,6 +83,7 @@ fPath(){     // Path in geometry to this module
     }// end for i
     fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
 }
+/*
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) : 
     TObject(sourse){
@@ -132,11 +133,12 @@ void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
        }// end for i
      this->fPath   = sourse.fPath;
 }
+*/
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
                         const Double_t rot[3],const Double_t tran[3]):
 TObject(),
-fDetectorIndex(0), // Detector type index (like fShapeIndex was)
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
 ftran(),     // Translation vector of module x,y,z.
@@ -169,7 +171,6 @@ fPath(){     // Path in geometry to this moduel
     //    A properly inilized AliITSgeomMatrix class.
     Int_t i;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        frot[i]  = rot[i];
@@ -185,7 +186,7 @@ AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt, const Int_t id[3],
                                    Double_t matrix[3][3],
                                    const Double_t tran[3]):
 TObject(),
-fDetectorIndex(0), // Detector type index (like fShapeIndex was)
+fDetectorIndex(idt), // Detector type index (like fShapeIndex was)
 fid(),       // layer, ladder, detector numbers.
 frot(),      //! vector of rotations about x,y,z [radians].
 ftran(),     // Translation vector of module x,y,z.
@@ -219,7 +220,6 @@ fPath(){     // Path in geometry to this module
     //    A properly inilized AliITSgeomMatrix class.
     Int_t i,j;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        ftran[i] = tran[i];
@@ -318,7 +318,12 @@ void AliITSgeomMatrix::MatrixFromSixAngles(const Double_t *ang){
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
                                    Int_t idt,const Int_t id[3],
-                                   const Double_t tran[3]){
+                                   const Double_t tran[3]):
+TObject(),
+fDetectorIndex(idt),
+fCylR(0.),
+fCylPhi(0.),
+fPath(){
     // This is a constructor for the AliITSgeomMatrix class. The matrix 
     // is defined by the 6 GEANT 3.21 rotation angles [degrees], and 
     // the translation vector tran [cm]. In addition the layer, ladder, 
@@ -341,7 +346,6 @@ AliITSgeomMatrix::AliITSgeomMatrix(const Double_t rotd[6]/*degrees*/,
     //    Double_t tran[3]  The translation vector
     Int_t i;
 
-    fDetectorIndex = idt; // a value never defined.
     for(i=0;i<3;i++){
        fid[i]   = id[i];
        ftran[i] = tran[i];
index f0f04a4..245b520 100644 (file)
@@ -29,10 +29,6 @@ class AliITSgeomMatrix : public TObject {
         AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
                          Int_t idt,const Int_t id[3],
                          const Double_t tran[3]);
-       // Copy operator
-       AliITSgeomMatrix(const AliITSgeomMatrix &source);
-       // Alignment operator
-       void operator=(const AliITSgeomMatrix &sourse); // copy
        virtual ~AliITSgeomMatrix(){}; // default constructor.
        // Prints a line describing the output format of the function Print.
        void PrintComment(ostream *os) const;
@@ -152,6 +148,10 @@ class AliITSgeomMatrix : public TObject {
      void MakeFigures() const;
      //
  private: // private functions
+       // Copy constructor
+       AliITSgeomMatrix(const AliITSgeomMatrix &source);
+       // Assignment operator
+       void operator=(const AliITSgeomMatrix &sourse); // copy
        // Given the rotation matrix fm it fills the rotation angles frot
        void MatrixFromAngle();
        // Given the rotation angles frot it fills the rotation matrix fm
index f40dcb5..e96886e 100644 (file)
 ClassImp(AliITSresponse)
 
 //______________________________________________________________________
-AliITSresponse::AliITSresponse(){
+AliITSresponse::AliITSresponse():
+TObject(),
+fFileName1(),
+fFileName2(),
+fFileName3(),
+fWrite(kFALSE),
+fDiffCoeff(0.),
+fDiffCoeff1(0.){
   
   // Default Constructor
 
-  SetFilenames();
-  SetOutputOption();
-  fDiffCoeff=0;
-  fDiffCoeff1=0;
 }
 
index 450de6c..af135bc 100644 (file)
 
 
 const Int_t AliITSresponseSDD::fgkMaxAdcDefault = 1024;
-const Double_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
-const Double_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
+const Float_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
+const Float_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
 const Float_t AliITSresponseSDD::fgkDiffCoeffDefault = 3.23;
 const Float_t AliITSresponseSDD::fgkDiffCoeff1Default = 30.;
 const TString AliITSresponseSDD::fgkParam1Default = "same";
 const TString AliITSresponseSDD::fgkParam2Default = "same";
 const TString AliITSresponseSDD::fgkOptionDefault = "1D";
-const Double_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
-const Double_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
+const Float_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
+const Float_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
 const Int_t AliITSresponseSDD::fgkNcompsDefault = 121;
 
 ClassImp(AliITSresponseSDD)
 
 //_________________________________________________________________________
-AliITSresponseSDD::AliITSresponseSDD():AliITSresponse(){
+AliITSresponseSDD::AliITSresponseSDD():
+AliITSresponse(),
+fJitterError(0.),
+fDynamicRange(0.),
+fChargeLoss(0.),
+fDriftSpeed(fgkDriftSpeedDefault),
+fElectronics(0),
+fMaxAdc(fgkMaxAdcDefault),
+fNsigmas(fgkNsigmasDefault),
+fGaus(),
+fNcomps(0),
+fBitComp(kFALSE),
+fOption(),
+fParam1(),
+fParam2() {
   // default constructor
   fGaus = 0;
-  SetMaxAdc(fgkMaxAdcDefault);
   SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
-  SetDriftSpeed(fgkDriftSpeedDefault);
-  SetNSigmaIntegration(fgkNsigmasDefault);
   //  SetNLookUp(fgkNcompsDefault);
 
   SetJitterError();
@@ -65,20 +76,6 @@ AliITSresponseSDD::~AliITSresponseSDD() {
   if(fGaus) delete fGaus;
 }
 
-//______________________________________________________________________
-AliITSresponseSDD::AliITSresponseSDD(const AliITSresponseSDD &ob) : AliITSresponse(ob) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSresponseSDD","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSresponseSDD& AliITSresponseSDD::operator=(const AliITSresponseSDD& /* ob */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
 
 //______________________________________________________________________
 Int_t AliITSresponseSDD::Convert8to10(Int_t signal) const {
@@ -115,7 +112,7 @@ void AliITSresponseSDD::SetNLookUp(Int_t p1){
   if (fGaus) delete fGaus;
   fGaus = new TArrayF(fNcomps+1);
   for(Int_t i=0; i<=fNcomps; i++) {
-    Double_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
+    Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
     (*fGaus)[i] = exp(-((x*x)/2));
   }
 }
index 26409f5..b92d846 100644 (file)
@@ -26,20 +26,20 @@ class AliITSresponseSDD : public AliITSresponse {
        return fElectronics;}
     virtual void    SetMaxAdc(Double_t p1) {// Adc-count saturation value
        fMaxAdc=p1;}
-    virtual Double_t MaxAdc() const  {// Get maximum Adc-count value
+    virtual Float_t MaxAdc() const  {// Get maximum Adc-count value
        return fMaxAdc;}
     virtual void    SetChargeLoss(Double_t p1) {
        // Set Linear Charge Loss Steepness  // 0.01 for 20%
        fChargeLoss=p1;}
-    virtual Double_t ChargeLoss() const {// Get Charge Loss Coefficient
+    virtual Float_t ChargeLoss() const {// Get Charge Loss Coefficient
        return fChargeLoss;}
     virtual void    SetDynamicRange(Double_t p1) {// Set Dynamic Range
        fDynamicRange = p1;}
-    virtual Double_t DynamicRange() const {// Get Dynamic Range
+    virtual Float_t DynamicRange() const {// Get Dynamic Range
        return fDynamicRange;}
     virtual void    SetDriftSpeed(Double_t p1) {// Drift velocity
        fDriftSpeed=p1;}
-    virtual Double_t DriftSpeed() const {// drift speed
+    virtual Float_t DriftSpeed() const {// drift speed
        return fDriftSpeed;}
     virtual void SetParamOptions(const char *opt1,const char *opt2) {
        // Parameters: "same" or read from "file" 
@@ -58,23 +58,23 @@ class AliITSresponseSDD : public AliITSresponse {
     virtual void    SetNSigmaIntegration(Double_t p1) {
        // Set number of sigmas over which cluster disintegration is performed
        fNsigmas=p1;}
-    virtual Double_t NSigmaIntegration() const {
+    virtual Float_t NSigmaIntegration() const {
        // Get number of sigmas over which cluster disintegration is performed
        return fNsigmas;}
     virtual void SetNLookUp(Int_t p1);
     // Get number of intervals in which the gaussian lookup table is divided
     virtual Int_t GausNLookUp() const {return fNcomps;}
-    virtual Double_t GausLookUp(Int_t i)  {
+    virtual Float_t GausLookUp(Int_t i)  {
       if (!fGaus) SetNLookUp(fgkNcompsDefault);
       if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);
     }
    
     Int_t Convert8to10(Int_t signal) const; //undo 10 to 8 bit SDD compresion
 
-    void  SetJitterError(Double_t jitter=20) {
+    void  SetJitterError(Float_t jitter=20) {
        // set Jitter error (20 um for ALICE from beam test measurements 2001)
        fJitterError=jitter;}
-    Double_t  JitterError() const {// set Jitter error
+    Float_t  JitterError() const {// set Jitter error
        return fJitterError;}
     void  SetDo10to8(Bool_t bitcomp=kTRUE) {
        // set the option for 10 to 8 bit compression
@@ -83,25 +83,25 @@ class AliITSresponseSDD : public AliITSresponse {
  protected:
 
     static const Int_t fgkMaxAdcDefault; // default for fMaxAdc
-    static const Double_t fgkDynamicRangeDefault; // default for fDynamicRange
-    static const Double_t fgkfChargeLossDefault; // default for fChargeLoss
+    static const Float_t fgkDynamicRangeDefault; // default for fDynamicRange
+    static const Float_t fgkfChargeLossDefault; // default for fChargeLoss
     static const Float_t fgkDiffCoeffDefault; // default for fDiffCoeff
     static const Float_t fgkDiffCoeff1Default; // default for fDiffCoeff1 
     static const TString fgkParam1Default; // default for fParam1
     static const TString fgkParam2Default; // default for fParam2
     static const TString fgkOptionDefault; // default for fOption
-    static const Double_t fgkDriftSpeedDefault; // default for fDriftSpeed
-    static const Double_t fgkNsigmasDefault; //default for fNsigmas
+    static const Float_t fgkDriftSpeedDefault; // default for fDriftSpeed
+    static const Float_t fgkNsigmasDefault; //default for fNsigmas
     static const Int_t fgkNcompsDefault; //default for fNcomps
     
 
-    Double_t  fJitterError;    // jitter error
-    Double_t  fDynamicRange;   // Set Dynamic Range 
-    Double_t  fChargeLoss;     // Set Linear Coefficient for Charge Loss 
-    Double_t  fDriftSpeed;     // Drift velocity
+    Float_t  fJitterError;    // jitter error
+    Float_t  fDynamicRange;   // Set Dynamic Range 
+    Float_t  fChargeLoss;     // Set Linear Coefficient for Charge Loss 
+    Float_t  fDriftSpeed;     // Drift velocity
     Int_t     fElectronics;    // Electronics
-    Double_t  fMaxAdc;         // Adc saturation value
-    Double_t  fNsigmas;   // Number of sigmas over which charge disintegration
+    Float_t  fMaxAdc;         // Adc saturation value
+    Float_t  fNsigmas;   // Number of sigmas over which charge disintegration
                           // is performed
     TArrayF   *fGaus;          // Gaussian lookup table for signal generation
     Int_t      fNcomps;        // Number of samplings along the gaussian
@@ -115,7 +115,7 @@ class AliITSresponseSDD : public AliITSresponse {
    AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor
    AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op.
 
-    ClassDef(AliITSresponseSDD,6) // Base response class 
+    ClassDef(AliITSresponseSDD,7) // Base response class 
     
     };
 #endif
index ae99cb9..e0cf6b4 100644 (file)
Binary files a/ITS/Calib/CalibSDD/Run0_9999999_v0_s0.root and b/ITS/Calib/CalibSDD/Run0_9999999_v0_s0.root differ
index 150686f..e8498e9 100644 (file)
Binary files a/ITS/Calib/RespSDD/Run0_9999999_v0_s0.root and b/ITS/Calib/RespSDD/Run0_9999999_v0_s0.root differ