Copy constructors and asignment operators implemented (R. Shahoyan)
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 23 May 2007 15:29:09 +0000 (15:29 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 23 May 2007 15:29:09 +0000 (15:29 +0000)
STEER/AliCheb3D.cxx
STEER/AliCheb3D.h
STEER/AliMagFCheb.cxx
STEER/AliMagFCheb.h

index 41246b2..0fc4fab 100644 (file)
@@ -126,28 +126,80 @@ AliCheb3DCalc::AliCheb3DCalc(FILE* stream):
     LoadData(stream);
 }
 
-AliCheb3DCalc::AliCheb3DCalc(const AliCheb3DCalc& cheb):
-    TNamed("", ""),
-    fNCoefs(0),  
-    fNRows(0),
-    fNCols(0),
-    fNElemBound2D(0),
-    fNColsAtRow(0),
-    fColAtRowBg(0),
-    fCoefBound2D0(0),
-    fCoefBound2D1(0),
-    fCoefs(0),
-    fTmpCf1(0),
+
+AliCheb3DCalc::AliCheb3DCalc(const AliCheb3DCalc& src) :
+    TNamed(src), 
+    fNCoefs(src.fNCoefs), 
+    fNRows(src.fNRows), 
+    fNCols(src.fNCols),
+    fNElemBound2D(src.fNElemBound2D), 
+    fNColsAtRow(0), 
+    fColAtRowBg(0), 
+    fCoefBound2D0(0), 
+    fCoefBound2D1(0), 
+    fCoefs(0), 
+    fTmpCf1(0), 
     fTmpCf0(0)
 {
     // Copy constructor
-    cheb.Copy(*this);
+    if (src.fNColsAtRow) {
+       fNColsAtRow = new Int_t[fNRows]; 
+       for (int i=fNRows;i--;) fNColsAtRow[i] = src.fNColsAtRow[i];
+    }
+    if (src.fColAtRowBg) {
+       fColAtRowBg = new Int_t[fNRows]; 
+       for (int i=fNRows;i--;) fColAtRowBg[i] = src.fColAtRowBg[i];
+    }
+    if (src.fCoefBound2D0) {
+       fCoefBound2D0 = new Int_t[fNElemBound2D];
+       for (int i=fNElemBound2D;i--;) fCoefBound2D0[i] = src.fCoefBound2D0[i];
+    }
+    if (src.fCoefBound2D1) {
+       fCoefBound2D1 = new Int_t[fNElemBound2D];
+       for (int i=fNElemBound2D;i--;) fCoefBound2D1[i] = src.fCoefBound2D1[i];
+    }
+    if (src.fCoefs) {
+       fCoefs = new Float_t[fNCoefs];
+       for (int i=fNCoefs;i--;) fCoefs[i] = src.fCoefs[i];
+    }
+    if (src.fTmpCf1) fTmpCf1 = new Float_t[fNCols];
+    if (src.fTmpCf0) fTmpCf0 = new Float_t[fNRows];
 }
 
-void AliCheb3DCalc::Copy(TObject &) const
+AliCheb3DCalc& AliCheb3DCalc::operator=(const AliCheb3DCalc& rhs)
 {
-  //dummy Copy function
-  AliFatal("Not implemented!");
+    // Assignment operator
+    if (this != &rhs) {
+       Clear();
+       SetName(rhs.GetName());
+       SetTitle(rhs.GetTitle());
+       fNCoefs = rhs.fNCoefs;
+       fNRows  = rhs.fNRows;
+       fNCols  = rhs.fNCols;    
+       if (rhs.fNColsAtRow) {
+           fNColsAtRow = new Int_t[fNRows]; 
+           for (int i=fNRows;i--;) fNColsAtRow[i] = rhs.fNColsAtRow[i];
+       }
+       if (rhs.fColAtRowBg) {
+           fColAtRowBg = new Int_t[fNRows]; 
+           for (int i=fNRows;i--;) fColAtRowBg[i] = rhs.fColAtRowBg[i];
+       }
+       if (rhs.fCoefBound2D0) {
+           fCoefBound2D0 = new Int_t[fNElemBound2D];
+           for (int i=fNElemBound2D;i--;) fCoefBound2D0[i] = rhs.fCoefBound2D0[i];
+       }
+       if (rhs.fCoefBound2D1) {
+           fCoefBound2D1 = new Int_t[fNElemBound2D];
+           for (int i=fNElemBound2D;i--;) fCoefBound2D1[i] = rhs.fCoefBound2D1[i];
+       }
+       if (rhs.fCoefs) {
+           fCoefs = new Float_t[fNCoefs];
+           for (int i=fNCoefs;i--;) fCoefs[i] = rhs.fCoefs[i];
+       }
+       if (rhs.fTmpCf1) fTmpCf1 = new Float_t[fNCols];
+       if (rhs.fTmpCf0) fTmpCf0 = new Float_t[fNRows];    
+    }
+    return *this;
 }
 
 //__________________________________________________________________________________________
@@ -409,21 +461,59 @@ AliCheb3D::AliCheb3D(FILE* stream):
     LoadData(stream);
 }
 
-AliCheb3D::AliCheb3D(const AliCheb3D& cheb):
-    TNamed("", ""),
-    fDimOut(0),
-    fPrec(0.),
-    fChebCalc(),
-    fMaxCoefs(0),
-    fResTmp(0),
-    fGrid(0),
-    fUsrFunName(),
-    fUsrMacro(0)            
+AliCheb3D::AliCheb3D(const AliCheb3D& src) : 
+    TNamed(src),
+    fDimOut(src.fDimOut), 
+    fPrec(src.fPrec), 
+    fChebCalc(1), 
+    fMaxCoefs(src.fMaxCoefs), 
+                                          fResTmp(0),
+    fGrid(0), 
+    fUsrFunName(src.fUsrFunName), 
+    fUsrMacro(0)
 {
     // Copy constructor
-    cheb.Copy(*this);
+    // read coefs from text file
+    for (int i=3;i--;) {
+       fBMin[i]    = src.fBMin[i];
+       fBMax[i]    = src.fBMax[i];
+       fBScale[i]  = src.fBScale[i];
+       fBOffset[i] = src.fBOffset[i];
+       fNPoints[i] = src.fNPoints[i];
+    }
+    for (int i=0;i<fDimOut;i++) {
+       AliCheb3DCalc* cbc = src.GetChebCalc(i);
+       if (cbc) fChebCalc.AddAtAndExpand(new AliCheb3DCalc(*cbc),i);
+    }
 }
 
+AliCheb3D& AliCheb3D::operator=(const AliCheb3D& rhs)
+{
+    // Assignment operator
+    if (this != &rhs) {
+       Clear();
+       fDimOut   = rhs.fDimOut;
+       fPrec     = rhs.fPrec;
+       fMaxCoefs = rhs.fMaxCoefs;
+       fUsrFunName = rhs.fUsrFunName;
+       fUsrMacro   = 0;
+       for (int i=3;i--;) {
+           fBMin[i]    = rhs.fBMin[i];
+           fBMax[i]    = rhs.fBMax[i];
+           fBScale[i]  = rhs.fBScale[i];
+           fBOffset[i] = rhs.fBOffset[i];
+           fNPoints[i] = rhs.fNPoints[i];
+       } 
+       for (int i=0;i<fDimOut;i++) {
+           AliCheb3DCalc* cbc = rhs.GetChebCalc(i);
+           if (cbc) fChebCalc.AddAtAndExpand(new AliCheb3DCalc(*cbc),i);
+       }    
+    }
+    return *this;
+    //
+}
+
+
 //__________________________________________________________________________________________
 #ifdef _INC_CREATION_ALICHEB3D_
 AliCheb3D::AliCheb3D(const char* funName, int DimOut, Float_t  *bmin,Float_t  *bmax, Int_t *npoints, Float_t prec) : TNamed(funName,funName)
@@ -473,12 +563,6 @@ AliCheb3D::AliCheb3D(void (*ptr)(float*,float*), int DimOut, Float_t  *bmin,Floa
 #endif
 
 
-void AliCheb3D::Copy(TObject &) const
-{
-  //dummy Copy function
-  AliFatal("Not implemented!");
-}
-
 //__________________________________________________________________________________________
 void AliCheb3D::Clear(Option_t*)
 {
index b2193a9..e2c3d99 100644 (file)
@@ -89,13 +89,8 @@ class AliCheb3DCalc: public TNamed
  public:
   AliCheb3DCalc();
   AliCheb3DCalc(FILE* stream); // read coefs from text file
-  AliCheb3DCalc(const AliCheb3DCalc &cheb);
-  AliCheb3DCalc& operator= (const AliCheb3DCalc &cheb) {
-      // Assignment operator
-      cheb.Copy(*this);
-      return *this;
-  }
-  
+  AliCheb3DCalc(const AliCheb3DCalc &src);
+  AliCheb3DCalc& operator= (const AliCheb3DCalc &rhs);
   ~AliCheb3DCalc() {Clear();}
   //
   void       Print(Option_t* opt="")                                   const;
@@ -108,8 +103,6 @@ class AliCheb3DCalc: public TNamed
 #endif
   //
   static void ReadLine(TString& str,FILE* stream);
- private:
-  void Copy (TObject &mc) const;
   //
  protected:
   //
@@ -150,12 +143,8 @@ class AliCheb3D: public TNamed
     AliCheb3D();
     AliCheb3D(const char* inpFile); // read coefs from text file
     AliCheb3D(FILE*);               // read coefs from stream
-    AliCheb3D(const AliCheb3D &cheb);
-    AliCheb3D& operator= (const AliCheb3D &cheb) {
-       // Assignment operator
-       cheb.Copy(*this);
-       return *this;
-    }
+    AliCheb3D(const AliCheb3D &src);
+    AliCheb3D& operator= (const AliCheb3D &rhs);
   
   //
 #ifdef _INC_CREATION_ALICHEB3D_
@@ -208,8 +197,6 @@ class AliCheb3D: public TNamed
   Float_t      MapToInternal(Float_t  x,Int_t d) const {return (x-fBOffset[d])*fBScale[d];} // map x to [-1:1]
   Float_t      MapToExternal(Float_t  x,Int_t d) const {return x/fBScale[d]+fBOffset[d];}   // map from [-1:1] to x
   //
- private:
-  void Copy (TObject &mc) const;
  protected:
   Int_t        fDimOut;            // dimension of the ouput array
   Float_t      fPrec;              // requested precision
index 1ebeb95..fcc42b3 100644 (file)
@@ -80,34 +80,110 @@ AliMagFCheb::AliMagFCheb(const char* inputFile) :
   LoadData(inputFile);
 }
 
-AliMagFCheb::AliMagFCheb(const AliMagFCheb &cheb) :
-    TNamed(),
-    fNParamsSol(0),
-    fNSegZSol(0),
-    fNParamsDip(0),
-    fSegZSol(0),
-    fSegRSol(0),
-    fNSegRSol(0),
-    fSegZIdSol(0),
-    fMinZSol(0.),
-    fMaxZSol(0.),
-    fMaxRSol(0.),
-    fParamsSol(0),
-    fParamsDip(0)
+//__________________________________________________________________________________________
+AliMagFCheb::AliMagFCheb(const AliMagFCheb& src)
+    : TNamed(src), 
+      fNParamsSol(src.fNParamsSol),
+      fNSegZSol(src.fNSegZSol), 
+      fNParamsDip(src.fNParamsDip), 
+      fSegZSol(0), 
+      fSegRSol(0), 
+      fNSegRSol(0), 
+      fSegZIdSol(0),
+      fMinZSol(src.fMinZSol), 
+      fMaxZSol(src.fMaxZSol), 
+      fMaxRSol(src.fMaxRSol), 
+      fParamsSol(0), 
+      fParamsDip(0)
 {
+// Copy constructor
+  if (src.fSegZSol) {
+    fSegZSol = new Float_t[fNSegZSol];
+    for (int i=fNSegZSol;i--;) fSegZSol[i] = src.fSegZSol[i];
+  }
+  if (src.fSegRSol) {
+    fSegRSol = new Float_t[fNParamsSol];
+    for (int i=fNParamsSol;i--;) fSegRSol[i] = src.fSegRSol[i];
+  }
+  if (src.fNSegRSol) {
+    fNSegRSol = new Int_t[fNSegZSol];
+    for (int i=fNSegZSol;i--;) fNSegRSol[i] = src.fNSegRSol[i];
+  }
+  if (src.fSegZIdSol) {
+    fSegZIdSol = new Int_t[fNSegZSol];
+    for (int i=fNSegZSol;i--;) fSegZIdSol[i] = src.fSegZIdSol[i];
+  }
+  if (src.fParamsSol) {
+    fParamsSol = new TObjArray(fNParamsSol);
+    for (int i=0;i<fNParamsSol;i++) {
+      AliCheb3D* pr = src.GetParamSol(i);
+      if (pr) fParamsSol->AddAtAndExpand(new AliCheb3D(*pr),i);
+    }
+  }
+  if (src.fParamsDip) {
+    fParamsDip = new TObjArray(fNParamsDip);
+    for (int i=0;i<fNParamsDip;i++) {
+      AliCheb3D* pr = src.GetParamDip(i);
+      if (pr) fParamsDip->AddAtAndExpand(new AliCheb3D(*pr),i);
+    }
+  }
   //
-  // Copy constructor for AliMC
-  //
-  cheb.Copy(*this);
 }
 
-//_______________________________________________________________________
-void AliMagFCheb::Copy(TObject &) const
+
+AliMagFCheb& AliMagFCheb::operator=(const AliMagFCheb& rhs)
 {
-  //dummy Copy function
-  AliFatal("Not implemented!");
+// Assignment operator
+    if (this != &rhs) {  
+       Clear();
+       SetName(rhs.GetName());
+       SetTitle(rhs.GetTitle());
+       fNParamsSol = rhs.fNParamsSol;
+       fNSegZSol   = rhs.fNSegZSol;
+       fMinZSol    = rhs.fMinZSol;
+       fMaxZSol    = rhs.fMaxZSol;
+       fMaxRSol    = rhs.fMaxRSol;
+       fNParamsDip = rhs.fNParamsDip;
+       fSegZSol    = fSegRSol    = 0; 
+       fNSegRSol   = fSegZIdSol  = 0;
+       fParamsSol  = fParamsDip  = 0;  
+       //
+       if (rhs.fSegZSol) {
+           fSegZSol = new Float_t[fNSegZSol];
+           for (int i=fNSegZSol;i--;) fSegZSol[i] = rhs.fSegZSol[i];
+       }
+       if (rhs.fSegRSol) {
+           fSegRSol = new Float_t[fNParamsSol];
+           for (int i=fNParamsSol;i--;) fSegRSol[i] = rhs.fSegRSol[i];
+       }
+       if (rhs.fNSegRSol) {
+           fNSegRSol = new Int_t[fNSegZSol];
+           for (int i=fNSegZSol;i--;) fNSegRSol[i] = rhs.fNSegRSol[i];
+       }
+       if (rhs.fSegZIdSol) {
+           fSegZIdSol = new Int_t[fNSegZSol];
+           for (int i=fNSegZSol;i--;) fSegZIdSol[i] = rhs.fSegZIdSol[i];
+       }
+       if (rhs.fParamsSol) {
+           fParamsSol = new TObjArray(fNParamsSol);
+           for (int i=0;i<fNParamsSol;i++) {
+               AliCheb3D* pr = rhs.GetParamSol(i);
+               if (pr) fParamsSol->AddAtAndExpand(new AliCheb3D(*pr),i);
+           }
+       }
+       if (rhs.fParamsDip) {
+           fParamsDip = new TObjArray(fNParamsDip);
+           for (int i=0;i<fNParamsDip;i++) {
+               AliCheb3D* pr = rhs.GetParamDip(i);
+               if (pr) fParamsDip->AddAtAndExpand(new AliCheb3D(*pr),i);
+           }
+       }
+    }
+    return *this;  
+    //
 }
 
+
 //__________________________________________________________________________________________
 AliMagFCheb::~AliMagFCheb()
 {
index 492ec4f..715fd62 100644 (file)
@@ -38,13 +38,9 @@ class AliMagFCheb: public TNamed
  public:
     AliMagFCheb();
     AliMagFCheb(const char* inputFile);
-    AliMagFCheb(const AliMagFCheb &cheb);
-    AliMagFCheb& operator= (const AliMagFCheb &cheb) {
-       // Assignment operator
-       cheb.Copy(*this);
-       return *this;
-    }
-
+    AliMagFCheb(const AliMagFCheb &src);
+    AliMagFCheb& operator= (const AliMagFCheb &rhs);
+    
    ~AliMagFCheb();
   //
   void       AddParamSol(AliCheb3D* param);
@@ -77,8 +73,6 @@ class AliMagFCheb: public TNamed
  protected:
   void         Init0();
   virtual void FieldCylSol(Float_t *rphiz, Float_t *b)    const;
- private:
-  void Copy (TObject &cheb) const;
   //
  protected:
   //