Eff C++

diff --git a/TPC/AliClusters.cxx b/TPC/AliClusters.cxx
index 189a801474104993533387e6d782b76d466f368d..085f14d14ebfbc5db6791794901fad32f6d9cbf3 100644 (file)
--- a/TPC/AliClusters.cxx
+++ b/TPC/AliClusters.cxx
@@ -40,16 +40,37 @@ ClassImp(AliClusters)
 //*****************************************************************************
 //
 //_____________________________________________________________________________
-AliClusters::AliClusters() 
+AliClusters::AliClusters()
+            :AliSegmentID(), 
+            fClusters(0),
+             fNclusters(0),
+             fClass(0)
 {  
   //
   //default constructor
   //
-  fNclusters=0;
-  fClusters =0;
-  fClass =0;
-}
 
+}
+//________________________________________________________________________
+AliClusters::AliClusters(const AliClusters &param)
+            :AliSegmentID(), 
+            fClusters(0),
+             fNclusters(0),
+             fClass(0)
+{
+  //
+  //  copy constructor - dummy
+  //
+  fNclusters = param.fNclusters;
+}
+AliClusters & AliClusters::operator =(const AliClusters & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fNclusters=param.fNclusters;
+  return (*this);
+}
 //________________________________________________________________________
 AliClusters::~AliClusters()
 {

diff --git a/TPC/AliClusters.h b/TPC/AliClusters.h
index c3013f1f370bbe11c194aafe49df4e0569d84598..0aef7d40e7ede9c36edcdc9ffe13c4e7efbf5b4a 100644 (file)
--- a/TPC/AliClusters.h
+++ b/TPC/AliClusters.h
@@ -18,7 +18,9 @@ class TObjArray;
 
 class AliClusters : public AliSegmentID{
 public:
-  AliClusters(); 
+  AliClusters();
+  AliClusters(const AliClusters &param); // copy constructor
+  AliClusters &operator = (const AliClusters & param); 
   ~AliClusters();
   virtual TObject* InsertCluster(const TObject* c ); //insert copy of cluster  
   const TObject* operator[](Int_t i); 

diff --git a/TPC/AliClustersArray.cxx b/TPC/AliClustersArray.cxx
index 253834e4814283f5ac516ac8f680e786e713563a..d17c8071a3d3016fbebad618870c0ed4f39fb844 100644 (file)
--- a/TPC/AliClustersArray.cxx
+++ b/TPC/AliClustersArray.cxx
@@ -39,14 +39,15 @@
 ClassImp(AliClustersArray)
 //
 
-AliClustersArray::AliClustersArray()
+  AliClustersArray::AliClustersArray():AliSegmentArray(),
+                                      fParam(0),
+                                      fClFinder(0),
+                                      fClusterType(0)
 {
   //
   //Default constructor
   //
-  fParam = 0;
-  fClusterType = 0;
-  fClFinder = 0;
+
 }
 
 Bool_t  AliClustersArray::SetClusterType(const char * classname) 

diff --git a/TPC/AliComplexCluster.cxx b/TPC/AliComplexCluster.cxx
index 24a01ca8a22251bfef4d1fcffad939ffb7d4c56a..c3e0e8ed5b1acbae3815aeb6c66728bdf6aea0a4 100644 (file)
--- a/TPC/AliComplexCluster.cxx
+++ b/TPC/AliComplexCluster.cxx
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.8  2004/03/30 14:09:22  kowal2
+Changes due to the coding conventions
+
 Revision 1.7  2003/11/24 09:48:28  kowal2
 Changes to obey the coding conventions
 
@@ -61,6 +64,23 @@ New class replacing AliCluster
 
 
 ClassImp(AliComplexCluster)
+  //__________________________________________________________________
+  AliComplexCluster::AliComplexCluster()
+                    :TObject(),
+                    fX(0.),
+                    fY(0.),
+                     fQ(0.),
+                    fSigmaX2(0.),
+                    fSigmaY2(0.),
+                    fSigmaXY(0.),
+                    fArea(0.),
+                    fMax(0.)
+{
+  //
+  // default constructor
+  //
+   fTracks[0]=fTracks[1]=fTracks[2]=0;
+}
 //_____________________________________________________________________________
 Int_t AliComplexCluster::Compare(const TObject * o) const
 {
@@ -85,5 +105,5 @@ ClassImp(AliTPCTrackerPoint)
 ClassImp(AliTPCTrackPoint)
 ClassImp(AliTPCTrackPoint2)
 ClassImp(AliTPCTrackPointRef)
-
+  //_______________________________________________________________
 

diff --git a/TPC/AliComplexCluster.h b/TPC/AliComplexCluster.h
index f062b3e24f4cd634b84cbfd4345777a6e9ce5736..28e9202208ea979c1dc0b410f9feca36640f0342 100644 (file)
--- a/TPC/AliComplexCluster.h
+++ b/TPC/AliComplexCluster.h
@@ -18,10 +18,7 @@
 class AliComplexCluster : public TObject {
 public:
 
-  AliComplexCluster() {
-    fTracks[0]=fTracks[1]=fTracks[2]=0; 
-    fX=fY=fQ=fSigmaX2=fSigmaY2=fSigmaXY=fArea=fMax=0.;
-  }
+  AliComplexCluster();
   virtual ~AliComplexCluster() {;}
   Bool_t    IsSortable() const;
   Int_t Compare(const TObject *o) const;
@@ -110,7 +107,14 @@ class AliTPCTrackerPoint  {
 
 class AliTPCClusterPoint  {
  public:
-  AliTPCClusterPoint(){fCZ=fCY=fSigmaZ=fSigmaY=fQ=fMax=fCType=0;}
+  AliTPCClusterPoint():
+                      fCZ(0),
+                      fCY(0), 
+                      fSigmaZ(0),
+                      fSigmaY(0),
+                      fQ(0),
+                      fMax(0),
+                      fCType(0){}
   virtual ~AliTPCClusterPoint(){}
   Float_t  GetZ() const    {return (fCZ*0.01);}
   Float_t  GetY() const   {return (fCY*0.01);}
@@ -144,7 +148,17 @@ class AliTPCClusterPoint  {
 
 class AliTPCExactPoint : public TObject{
  public:
-  AliTPCExactPoint(){fEZ=fEY=fEAngleZ=fEAngleY=fEAmp=fEPrim=fTrackID=0;}
+  AliTPCExactPoint():TObject(),
+    fEZ(0.),
+    fEY(0.),
+    fEX(0.),
+    fEAngleZ(0.),
+    fEAngleY(0.),
+    fEAmp(0.),
+    fEPrim(0.),
+    fTrackID(0),
+    fRow(0),
+    fSec(0){}
  private:
   Float_t fEZ;       // current "exact" position according simulation
   Float_t fEY;       // current "exact" position according simulation
@@ -162,7 +176,10 @@ class AliTPCExactPoint : public TObject{
 
 class AliTPCTrackPoint: public TObject{
  public:
-  AliTPCTrackPoint(){}
+  AliTPCTrackPoint():TObject(),
+    fTPoint(),
+    fCPoint(){}
+
   // AliTPCClusterPoint & GetCPoint(){return fCPoint;}
   AliTPCTrackerPoint & GetTPoint(){return fTPoint;}
   AliTPCclusterMI & GetCPoint(){return fCPoint;}  
@@ -176,7 +193,20 @@ class AliTPCTrackPoint: public TObject{
 
 class AliTPCTrackPoint2: public AliTPCTrackPoint{
  public:
-  AliTPCTrackPoint2(){}
+  AliTPCTrackPoint2():AliTPCTrackPoint(),
+    fGX(0.),
+    fGY(0.),
+    fGZ(0.),
+    fDY(0.),
+    fDZ(0.),
+    fDYU(0.),
+    fDYD(0),
+    fDZU(0.),
+    fDZD(0.),
+    fDDY(0),
+    fDDZ(0.),
+    fID(0),
+    fLab(0){}
  private: 
   Float_t fGX;    //global poition of the point
   Float_t fGY;    //global poition of the point

diff --git a/TPC/AliDetectorParam.cxx b/TPC/AliDetectorParam.cxx
index a4a66ff93b36390ee9198263e9f128296c1f9f2f..e78ac8d2ba83ef6986e481fede40cb72bf2bf1a9 100644 (file)
--- a/TPC/AliDetectorParam.cxx
+++ b/TPC/AliDetectorParam.cxx
@@ -26,7 +26,16 @@
 #include "AliDetectorParam.h"
 
 
-
+AliDetectorParam::AliDetectorParam()
+                   :TNamed(),
+                    fBField(0.),
+                    fNPrimLoss(0.),
+                    fNTotalLoss(0.)
+{
+  //
+  //  default constructor
+  //
+}
 
 Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/, Float_t *momentum, Float_t *angle)
 {

diff --git a/TPC/AliDetectorParam.h b/TPC/AliDetectorParam.h
index 577888c76d435d1410c775b54e5ca72920f4e2ee..11e61fe35dd97b8cdccbc59801fdbb0e776b5453 100644 (file)
--- a/TPC/AliDetectorParam.h
+++ b/TPC/AliDetectorParam.h
@@ -12,7 +12,7 @@
 #include <TNamed.h>
 class AliDetectorParam : public TNamed {
 public:
-  AliDetectorParam(){;}
+  AliDetectorParam();
   virtual Int_t GetNSegmentsTotal() const {return 0;} //get total nuber of segments
   virtual Bool_t Get1DIndex(Int_t */*index*/, const Int_t * /*arrindex*/) {return kFALSE;} 
   //transform multidimensional index to one dimesional

diff --git a/TPC/AliDigits.cxx b/TPC/AliDigits.cxx
index bcb170a474dfbd9a98ba9ad863240cd9162a4656..9dc17623a2c447c2a07358cc524e59ec64fb073c 100644 (file)
--- a/TPC/AliDigits.cxx
+++ b/TPC/AliDigits.cxx
@@ -49,21 +49,41 @@
 ClassImp(AliDigits)
 
 
-AliDigits::AliDigits()
+ AliDigits::AliDigits()
+           :AliSegmentID(),
+            fNrows(0),
+            fNcols(0),
+           fElements(0),
+            fIndex(0),
+            fBufType(0),
+            fThreshold(0),
+            fNelems(0),
+            fCurrentRow(0),
+            fCurrentCol(0),
+            fCurrentIndex(0) 
 {
   // 
   //default constructor
-  fIndex = 0;
-  fElements = 0;
-  fThreshold =0;
+  //
   Invalidate();
 }
 
-AliDigits::AliDigits(const AliDigits& digits):
-  AliSegmentID(digits)
+AliDigits::AliDigits(const AliDigits& digits)
+          :AliSegmentID(digits),
+            fNrows(0),
+            fNcols(0),
+           fElements(0),
+            fIndex(0),
+            fBufType(0),
+            fThreshold(0),
+            fNelems(0),
+            fCurrentRow(0),
+            fCurrentCol(0),
+            fCurrentIndex(0)
 {
   //
   //copy constructor
+  //
   fNrows = digits.fNrows;
   fNcols = digits.fNcols;
   fElements = new TArrayS(*(digits.fElements));

diff --git a/TPC/AliDigitsArray.cxx b/TPC/AliDigitsArray.cxx
index 192b3c384e6601c00738c23aaeb6b958214a797a..086c1adc754b33e96554faf1a92afe546e20d1e7 100644 (file)
--- a/TPC/AliDigitsArray.cxx
+++ b/TPC/AliDigitsArray.cxx
@@ -39,10 +39,32 @@ ClassImp(AliDigitsArray)
 //
 
 AliDigitsArray::AliDigitsArray()
+               :AliSegmentArray(),
+               fParam(0)
 {
-  fParam = 0;
+  //
+  // default constructor
+  //
 }
-
+AliDigitsArray::AliDigitsArray(const AliDigitsArray &param)
+             :AliSegmentArray(),
+             fParam(0)
+{
+  //
+  // dummy
+  //
+  fParam = param.fParam;
+}
+//
+AliDigitsArray & AliDigitsArray::operator =(const AliDigitsArray & param)
+{
+  //
+  // dummy
+  //
+ fParam = param.fParam;
+ return (*this);
+}
+//
 AliDigitsArray::~AliDigitsArray()
 {
   // if (fParam != 0) delete fParam;

diff --git a/TPC/AliDigitsArray.h b/TPC/AliDigitsArray.h
index 44f9100c4fe2b28bb41e995db45b82b77c9667cc..d0e69fc5a7d06ad89fb3f68bf75dfa42105ad28e 100644 (file)
--- a/TPC/AliDigitsArray.h
+++ b/TPC/AliDigitsArray.h
@@ -15,6 +15,8 @@ class AliDetectorParam;
 class AliDigitsArray : public AliSegmentArray {
 public:
   AliDigitsArray();
+  AliDigitsArray(const AliDigitsArray &param); // copy constructor
+ AliDigitsArray &operator = (const AliDigitsArray & param);
   virtual ~AliDigitsArray();  
   virtual   Bool_t Setup(AliDetectorParam *param);  //setup array according parameters
   const AliDetectorParam *  GetParam() {return fParam;} 

diff --git a/TPC/AliSegmentArray.cxx b/TPC/AliSegmentArray.cxx
index bf1db264695f59c853d0ffcfba72f0c2b74d9243..aff63818b8d6699e4e84aa94a4c8a7d94f44fc78 100644 (file)
--- a/TPC/AliSegmentArray.cxx
+++ b/TPC/AliSegmentArray.cxx
@@ -41,21 +41,31 @@
 //_____________________________________________________________________________
 ClassImp(AliSegmentArray)
   
-AliSegmentArray::AliSegmentArray()
+  AliSegmentArray::AliSegmentArray()
+                  :TNamed(),
+                   fSegment(0),
+                   fTreeIndex(0),
+                   fNSegment(0),
+                   fTree(0),
+                   fTreeOwner(kFALSE),
+                   fBranch(0),
+                   fClass(0)                                      
 {
   //
+  // constructor
   //
-  //
-  fNSegment=0;
-  fSegment =0; 
-  fTreeIndex = 0;
-  fTree  = 0;
-  fClass = 0;
-  fBranch = 0;
-  fTreeOwner = kFALSE;
+
 }
 
 AliSegmentArray::AliSegmentArray(const char *classname, Int_t n)
+                :TNamed("SegmentArray","SegmentArray"),
+                 fSegment(0),
+                 fTreeIndex(0),
+                 fNSegment(0),
+                 fTree(0),
+                 fTreeOwner(kFALSE),
+                 fBranch(0),
+                 fClass(0) 
 {
   //
   //constructor which 
@@ -63,14 +73,7 @@ AliSegmentArray::AliSegmentArray(const char *classname, Int_t n)
   //  Create an array of objects of classname. The class must inherit from
   //  AliSegmentID .  The second argument adjust number of entries in 
   //  the array.
-  fTreeOwner = kFALSE;
-  fNSegment=0;
-  fSegment =0; 
-  fTreeIndex = 0;
-  fTree  = 0;
-  fClass = 0;
-  SetName("SegmentArray");
-  SetTitle("SegmentArray");
+ 
 
   SetClass(classname);
   if (MakeArray(n)==kFALSE){
@@ -79,8 +82,16 @@ AliSegmentArray::AliSegmentArray(const char *classname, Int_t n)
    }
 }
 
-AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment):
-  TNamed(segment)
+AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment)
+                :TNamed(segment),
+                 fSegment(0),
+                 fTreeIndex(0),
+                 fNSegment(0),
+                 fTree(0),
+                 fTreeOwner(kFALSE),
+                 fBranch(0),
+                 fClass(0)                                      
+               
 {
   //
   //copy constructor

diff --git a/TPC/AliSegmentID.cxx b/TPC/AliSegmentID.cxx
index 9e5a4c14420c3204dfca7acbe1e865708fecc828..c93259b9b09a0e48374c6285340eab39b6df4713 100644 (file)
--- a/TPC/AliSegmentID.cxx
+++ b/TPC/AliSegmentID.cxx
@@ -25,8 +25,6 @@
 
 
 #include "AliSegmentID.h"
-AliSegmentID::AliSegmentID()
-{
-}
+
 
 ClassImp(AliSegmentID)

diff --git a/TPC/AliSegmentID.h b/TPC/AliSegmentID.h
index 3da7ee3832f6676d5b0db761365a1032404df037..8fd0ea811982ae5be095c5518c6ecde3cf880f72 100644 (file)
--- a/TPC/AliSegmentID.h
+++ b/TPC/AliSegmentID.h
@@ -14,8 +14,8 @@
 
 class AliSegmentID: public TObject{
 public:
-  AliSegmentID();
-  AliSegmentID(Int_t index){fSegmentID = index;}
+  AliSegmentID() : fSegmentID(0) {}
+  AliSegmentID(Int_t index) : fSegmentID(index) {}
   Int_t GetID() {return fSegmentID;}
   void  SetID(Int_t index){fSegmentID = index;} 
 protected:

diff --git a/TPC/AliSimDigits.cxx b/TPC/AliSimDigits.cxx
index 72ac33882b67e49a7eca88dac8e2cf63ec7b2efb..6340493a62daa9c81edadd66998f64c0f10d02c9 100644 (file)
--- a/TPC/AliSimDigits.cxx
+++ b/TPC/AliSimDigits.cxx
@@ -44,12 +44,30 @@
 ClassImp(AliSimDigits)
 
 AliSimDigits::AliSimDigits()
+             :AliDigits(),
+             fTracks(0),
+             fTrIndex(0),
+             fNlevel(0),
+             fTrBufType(0)  
 {
   //  AliDigits::Invalite();
-  fTracks = 0;
-  fTrIndex = 0;  
+ 
   InvalidateTrack();
 }
+//
+AliSimDigits::AliSimDigits(const AliSimDigits &param)
+             :AliDigits(),
+             fTracks(0),
+             fTrIndex(0),
+             fNlevel(0),
+             fTrBufType(0) 
+{
+  //
+  // dummy
+  //
+  fTrIndex = param.fTrIndex;
+}
+//
 AliSimDigits::~AliSimDigits()
 {
 
@@ -61,7 +79,16 @@ AliSimDigits::~AliSimDigits()
   } 
 
 }
+AliSimDigits & AliSimDigits::operator =(const AliSimDigits & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fTrIndex=param.fTrIndex;
+  return (*this);
+}
 
+//__________________________________________________________________
 void AliSimDigits::InvalidateTrack() 
 { 
   //

diff --git a/TPC/AliSimDigits.h b/TPC/AliSimDigits.h
index 14b269a87e52fef11ddaa29a3d57fa048eeb3119..43a10917170008dd5644b86e76cfa81177e08818 100644 (file)
--- a/TPC/AliSimDigits.h
+++ b/TPC/AliSimDigits.h
@@ -20,6 +20,8 @@ class AliH2F;
 class AliSimDigits : public AliDigits{
 public: 
   AliSimDigits();
+  AliSimDigits(const AliSimDigits &param);
+  AliSimDigits &operator = (const AliSimDigits & digits); 
   virtual ~AliSimDigits();
   void AllocateTrack(Int_t length);  //construct empty buffer fTracks with size rows x column x length (number of tracks for one digit)
   Int_t *GetTracks(){return fTracks->GetArray();}

diff --git a/TPC/AliTPC.cxx b/TPC/AliTPC.cxx
index fd11f41d0c7af43193ae54ce9410db1c3ed5afde..50a64d09984afa9af8ad4896142654bc69a5762c 100644 (file)
--- a/TPC/AliTPC.cxx
+++ b/TPC/AliTPC.cxx
@@ -81,34 +81,53 @@
 
 ClassImp(AliTPC) 
 //_____________________________________________________________________________
-AliTPC::AliTPC()
+  AliTPC::AliTPC():AliDetector(),
+                  fDefaults(0),
+                  fSens(0),
+                  fNsectors(0),
+                  fDigitsArray(0),
+                  fTPCParam(0),
+                  fTrackHits(0),
+                  fHitType(0),
+                  fDigitsSwitch(0),
+                  fSide(0),
+                  fNoiseDepth(0),
+                  fNoiseTable(0),
+                  fCurrentNoise(0),
+                  fActiveSectors(0)
+
 {
   //
   // Default constructor
   //
   fIshunt   = 0;
-  fHits     = 0;
-  fDigits   = 0;
-  fNsectors = 0;
-  fDigitsArray = 0;
-  fDefaults = 0;
-  fTrackHits = 0; 
+ 
   //  fTrackHitsOld = 0;   
 #if ROOT_VERSION_CODE >= ROOT_VERSION(4,0,1)
   fHitType = 4; // ROOT containers
 #else
   fHitType = 2; //default CONTAINERS - based on ROOT structure
 #endif 
-  fTPCParam = 0;    
-  fNoiseTable = 0;
-  fActiveSectors =0;
-  fSens = 0;
+
 
 }
  
 //_____________________________________________________________________________
 AliTPC::AliTPC(const char *name, const char *title)
-      : AliDetector(name,title)
+  : AliDetector(name,title),
+                   fDefaults(0),
+                  fSens(0),
+                  fNsectors(0),
+                  fDigitsArray(0),
+                  fTPCParam(0),
+                  fTrackHits(0),
+                  fHitType(0),
+                  fDigitsSwitch(0),
+                  fSide(0),
+                  fNoiseDepth(0),
+                  fNoiseTable(0),
+                  fCurrentNoise(0),
+                  fActiveSectors(0)
 {
   //
   // Standard constructor
@@ -118,8 +137,6 @@ AliTPC::AliTPC(const char *name, const char *title)
   // Initialise arrays of hits and digits 
   fHits     = new TClonesArray("AliTPChit",  176);
   gAlice->GetMCApp()->AddHitList(fHits); 
-  fDigitsArray = 0;
-  fDefaults = 0;
   //
   fTrackHits = new AliTPCTrackHitsV2;  
   fTrackHits->SetHitPrecision(0.002);
@@ -131,17 +148,14 @@ AliTPC::AliTPC(const char *name, const char *title)
   //fTrackHitsOld->SetStepPrecision(0.003);  
   //fTrackHitsOld->SetMaxDistance(100); 
 
-  fNoiseTable =0;
 
 #if ROOT_VERSION_CODE >= ROOT_VERSION(4,0,1)
   fHitType = 4; // ROOT containers
 #else
   fHitType = 2;
 #endif
-  fActiveSectors = 0;
-  //
-  // Initialise counters
-  fNsectors = 0;
+
+
 
   //
   fIshunt     =  0;
@@ -160,16 +174,41 @@ AliTPC::AliTPC(const char *name, const char *title)
     AliWarning("In Config.C you must set non-default parameters.");
     fTPCParam=0;
   }
-  fSens = 0;
+
 
 }
 
 //_____________________________________________________________________________
-AliTPC::AliTPC(const AliTPC& t):AliDetector(t){
+AliTPC::AliTPC(const AliTPC& t):AliDetector(t),
+                  fDefaults(0),
+                  fSens(0),
+                  fNsectors(0),
+                  fDigitsArray(0),
+                  fTPCParam(0),
+                  fTrackHits(0),
+                  fHitType(0),
+                  fDigitsSwitch(0),
+                  fSide(0),
+                  fNoiseDepth(0),
+                  fNoiseTable(0),
+                  fCurrentNoise(0),
+                  fActiveSectors(0)
+{
   //
   // dummy copy constructor
   //
 }
+//
+AliTPC & AliTPC::operator =(const AliTPC & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fDefaults=param.fDefaults;
+  return (*this);
+}
+
+//
 AliTPC::~AliTPC()
 {
   //
@@ -2052,10 +2091,26 @@ void AliTPC::TransportElectron(Float_t *xyz, Int_t *index)
 }
   
 ClassImp(AliTPChit)
- 
+  //______________________________________________________________________
+  AliTPChit::AliTPChit()
+            :AliHit(),
+            fSector(0),
+            fPadRow(0),
+            fQ(0),
+            fTime(0)
+{
+  //
+  // default
+  //
+
+}
 //_____________________________________________________________________________
-AliTPChit::AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-AliHit(shunt,track)
+AliTPChit::AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
+          :AliHit(shunt,track),
+            fSector(0),
+            fPadRow(0),
+            fQ(0),
+            fTime(0)
 {
   //
   // Creates a TPC hit object

diff --git a/TPC/AliTPC.h b/TPC/AliTPC.h
index cfb1dcdf18d93bcda02d2ba6b910760b007bdd90..ae46b868543deb340fd8bfea449428ee525f6ed7 100644 (file)
--- a/TPC/AliTPC.h
+++ b/TPC/AliTPC.h
@@ -31,6 +31,7 @@ public:
   AliTPC(); 
   AliTPC(const char *name, const char *title);
   AliTPC(const AliTPC& t);
+  AliTPC &operator = (const AliTPC & param);
   
   virtual AliLoader* MakeLoader(const char* topfoldername);
   
@@ -149,7 +150,7 @@ public:
    Float_t   fTime;       //hit time
  
 public:
-   AliTPChit() {fTime = 0.;}
+   AliTPChit();
    AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
    virtual ~AliTPChit() {}
    void SetX(Float_t x){fX = x;}

diff --git a/TPC/AliTPCBuffer.cxx b/TPC/AliTPCBuffer.cxx
index 247c9d0a410a9469efe1caa80e2bf43e2a1b0877..2c459b6a9f625f73519280e6b2312f19170b5a80 100644 (file)
--- a/TPC/AliTPCBuffer.cxx
+++ b/TPC/AliTPCBuffer.cxx
@@ -30,7 +30,22 @@
 
 ClassImp(AliTPCBuffer)
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const char* fileName){
+//___________________________________________________________
+  AliTPCBuffer::AliTPCBuffer():TObject(),
+    fVerbose(0),
+    fNumberOfDigits(0),
+    f()
+{
+  //
+  // default
+  //
+}
+//____________________________________________________________
+  AliTPCBuffer::AliTPCBuffer(const char* fileName):TObject(),
+    fVerbose(0),
+    fNumberOfDigits(0),
+    f()
+{
   // Constructor
 #ifndef __DECCXX
   f.open(fileName,ios::binary|ios::out);
@@ -39,8 +54,7 @@ AliTPCBuffer::AliTPCBuffer(const char* fileName){
 #endif
   // fout=new TFile(fileName,"recreate");
   // tree=new TTree("tree","Values");
-  fNumberOfDigits=0;
-  fVerbose=0;
+
   remove("TPCdigits.txt");
 }
 
@@ -52,7 +66,11 @@ AliTPCBuffer::~AliTPCBuffer(){
   //delete fout;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source){
+AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
+    fVerbose(0),
+    fNumberOfDigits(0),
+    f()
+{
   // Copy Constructor
   this->fVerbose=source.fVerbose;
   return;

diff --git a/TPC/AliTPCBuffer.h b/TPC/AliTPCBuffer.h
index 8bd8ff78a24ec0deb362452721c6c4cfcb5bef92..bd110ad0eb822e2b4de994db6416623b7f95ba5b 100644 (file)
--- a/TPC/AliTPCBuffer.h
+++ b/TPC/AliTPCBuffer.h
@@ -19,9 +19,9 @@ class AliSimDigits;
 //class TFile;
 class AliTPCBuffer:public TObject{
 public:
-  AliTPCBuffer(){
-    //default constructor
-  }
+  AliTPCBuffer();
+ 
+  //
   AliTPCBuffer(const char* fileName);//constructor
   virtual ~AliTPCBuffer();//destructor
   AliTPCBuffer(const AliTPCBuffer &source); // copy constructor
@@ -32,10 +32,11 @@ public:
   void    SetVerbose(Int_t val){fVerbose=val;}
 private:
   Int_t fVerbose; //Verbosity level: 0-silent, 1:cout msg, 2: txt files for checking
-  fstream f;      //The IO file name
+
   //TFile *fout;
   //TTree *tree;
   UInt_t  fNumberOfDigits; //Number of TPC digits
+  fstream f;      //The IO file name
   ClassDef(AliTPCBuffer,1)
 };
 

diff --git a/TPC/AliTPCCalROC.cxx b/TPC/AliTPCCalROC.cxx
index 5e53a06e020ab009d93c2f14962fd57bee1d3d96..81d43923963ff668d11ee168f7ba3e4a9ebf0b72 100644 (file)
--- a/TPC/AliTPCCalROC.cxx
+++ b/TPC/AliTPCCalROC.cxx
@@ -31,19 +31,28 @@ ClassImp(AliTPCCalROC)
 
 
 //_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC():TObject()
+AliTPCCalROC::AliTPCCalROC()
+             :TObject(),
+             fSector(0),
+             fNChannels(0),
+             fNRows(0),
+             fIndexes(0),
+             fData(0)
 {
   //
   // Default constructor
   //
-  fSector       =  0;
-  fNChannels    =  0;
-  fNRows        =  0;
-  fData         =  0;
+
 }
 
 //_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC(UInt_t  sector):TObject()
+AliTPCCalROC::AliTPCCalROC(UInt_t  sector)
+             :TObject(),
+             fSector(0),
+             fNChannels(0),
+             fNRows(0),
+             fIndexes(0),
+             fData(0)
 {
   //
   // Constructor that initializes a given sector
@@ -57,7 +66,13 @@ AliTPCCalROC::AliTPCCalROC(UInt_t  sector):TObject()
 }
 
 //_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c):TObject(c)
+AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c)
+             :TObject(c),
+             fSector(0),
+             fNChannels(0),
+             fNRows(0),
+             fIndexes(0),
+             fData(0)
 {
   //
   // AliTPCCalROC copy constructor
@@ -70,6 +85,16 @@ AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c):TObject(c)
   fData   = new Float_t[fNChannels];
   for (UInt_t  idata = 0; idata< fNChannels; idata++) fData[idata] = c.fData[idata];
 }
+//____________________________________________________________________________
+AliTPCCalROC & AliTPCCalROC::operator =(const AliTPCCalROC & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fData=param.fData;
+  return (*this);
+}
+
 
 //_____________________________________________________________________________
 AliTPCCalROC::~AliTPCCalROC()

diff --git a/TPC/AliTPCCalROC.h b/TPC/AliTPCCalROC.h
index 12e35d57a0a54ff2f106ef23a39edb4b4a5a21b1..2f38dcd69bff72bb58878a1be59354ad6b091485 100644 (file)
--- a/TPC/AliTPCCalROC.h
+++ b/TPC/AliTPCCalROC.h
@@ -22,6 +22,7 @@ class AliTPCCalROC : public TObject {
   AliTPCCalROC();
   AliTPCCalROC(UInt_t sector);
   AliTPCCalROC(const AliTPCCalROC &c);
+ AliTPCCalROC &operator = (const AliTPCCalROC & param);
   virtual           ~AliTPCCalROC();  
   UInt_t        GetNrows() const               { return fNRows;};
   UInt_t        GetNchannels()       const     { return fNChannels;};

diff --git a/TPC/AliTPCDDLRawData.cxx b/TPC/AliTPCDDLRawData.cxx
index 5bb95a42ee32232a81e45faa5ce232abd90c22ba..a248730965f7df1111289fa33dc87b2f50f74297 100644 (file)
--- a/TPC/AliTPCDDLRawData.cxx
+++ b/TPC/AliTPCDDLRawData.cxx
@@ -37,7 +37,8 @@ ClassImp(AliTPCDDLRawData)
 ////////////////////////////////////////////////////////////////////////////////////////
 
 AliTPCDDLRawData::AliTPCDDLRawData(const AliTPCDDLRawData &source):
-  TObject(source)
+  TObject(source),
+  fVerbose(0)
 {
   // Copy Constructor
   fVerbose=source.fVerbose;

diff --git a/TPC/AliTPCDDLRawData.h b/TPC/AliTPCDDLRawData.h
index d2bcf6fefd3fb0187810f25947ee503aa2439e00..b8a294ef2f558d2f977457145e580d01d40b0eda 100644 (file)
--- a/TPC/AliTPCDDLRawData.h
+++ b/TPC/AliTPCDDLRawData.h
@@ -11,7 +11,8 @@
 
 class AliTPCDDLRawData:public TObject{
  public:
-  AliTPCDDLRawData(){fVerbose=0;}//default constructor
+  AliTPCDDLRawData():TObject(),
+    fVerbose(0){}//default constructor
   virtual ~AliTPCDDLRawData(){;}//destructor
   AliTPCDDLRawData(const AliTPCDDLRawData &source); // copy constructor
   AliTPCDDLRawData& operator=(const AliTPCDDLRawData &source); // ass. op.

diff --git a/TPC/AliTPCDigitizer.cxx b/TPC/AliTPCDigitizer.cxx
index fb7e1bb206e181edb1012e45093fbaa921460783..da806e16859c30ea1aee309a436fd6a719e511b6 100644 (file)
--- a/TPC/AliTPCDigitizer.cxx
+++ b/TPC/AliTPCDigitizer.cxx
@@ -40,18 +40,21 @@
 ClassImp(AliTPCDigitizer)
 
 //___________________________________________
-AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer()
+  AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer(),fDebug(0)
 {
+  //
 // Default ctor - don't use it
-  fDebug =0;
+//
+  
 }
 
 //___________________________________________
 AliTPCDigitizer::AliTPCDigitizer(AliRunDigitizer* manager) 
-    :AliDigitizer(manager)
+  :AliDigitizer(manager),fDebug(0)
 {
+  //
 // ctor which should be used
-  fDebug =0;
+//  
   AliDebug(2,"(AliRunDigitizer* manager) was processed");
 }
 

diff --git a/TPC/AliTPCDigitsArray.cxx b/TPC/AliTPCDigitsArray.cxx
index 65b8b758ef511fa15da24bbe67c667e38ac651a5..88513d455ad1ce38405cc1006f6bd5a5ef876be1 100644 (file)
--- a/TPC/AliTPCDigitsArray.cxx
+++ b/TPC/AliTPCDigitsArray.cxx
@@ -44,6 +44,10 @@
 ClassImp(AliTPCDigitsArray) 
 
 AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
+                  :AliDigitsArray(),
+                  fBSim(kFALSE),
+                  fCompression(0),
+                  fTrackLevel(0)
 {
   //
   //default constructor

diff --git a/TPC/AliTPCFast.cxx b/TPC/AliTPCFast.cxx
index 96801e807c0917872f0bb3e862d25d0619b3d615..09ee16796679410fe5d507798be7c0fa28e40e12 100644 (file)
--- a/TPC/AliTPCFast.cxx
+++ b/TPC/AliTPCFast.cxx
@@ -37,7 +37,24 @@
 #include "AliLog.h"
 
 ClassImp(AliTPCFast)
+  //____________________________________________________________________
+AliTPCFast::AliTPCFast(const AliTPCFast &param)
+              :TObject(param),fParam(0)
 
+{
+  //
+  //  copy constructor - dummy
+  //
+  fParam = param.fParam;
+}
+AliTPCFast & AliTPCFast::operator =(const AliTPCFast & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fParam=param.fParam;
+  return (*this);
+}
 
 //_____________________________________________________________________________
 void AliTPCFast::Hits2Clusters(AliRunLoader* runLoader) const

diff --git a/TPC/AliTPCFast.h b/TPC/AliTPCFast.h
index 82a56b194b25c0ef8c223ea6fd043df6717073eb..b20dfbd90aac8291cdf63250c5537bc257f025e8 100644 (file)
--- a/TPC/AliTPCFast.h
+++ b/TPC/AliTPCFast.h
@@ -19,6 +19,9 @@ class AliTPCParam;
 class AliTPCFast : public TObject {
 
 public:
+  AliTPCFast():TObject(),fParam(0){}
+  AliTPCFast(const AliTPCFast &param); // copy constructor
+  AliTPCFast &operator = (const AliTPCFast & param); //assignment
   void Hits2Clusters(AliRunLoader* runLoader) const;
   void Hits2ExactClusters(AliRunLoader* runLoader) const;
   void Hits2ExactClustersSector(AliRunLoader* runLoader,

diff --git a/TPC/AliTPCPRF2D.cxx b/TPC/AliTPCPRF2D.cxx
index 81cee46219d34f56e6304eae21ccbbed1cab7d7b..929faeebec3e1718f8e37df4536a24ac985a609e 100644 (file)
--- a/TPC/AliTPCPRF2D.cxx
+++ b/TPC/AliTPCPRF2D.cxx
@@ -96,23 +96,45 @@ static Double_t funGati2D(Double_t *x, Double_t * par)
 ClassImp(AliTPCPRF2D)
 
 AliTPCPRF2D::AliTPCPRF2D()
+            :TObject(),
+             fcharge(0),
+             fY1(0.),
+             fY2(0.),
+             fNYdiv(0),
+             fNChargeArray(0),
+             fChargeArray(0),
+             fHeightFull(0.),
+             fHeightS(0.),
+             fShiftY(0.),
+             fWidth(0.),
+             fK(0.),
+             fNPRF(0),
+             fNdiv(5),
+             fDStep(0.),
+             fKNorm(1.),
+             fInteg(0.),
+             fGRF(0),
+             fK3X(0.),
+             fK3Y(0.),
+             fPadDistance(0.),
+             fOrigSigmaX(0.),
+             fOrigSigmaY(0.),
+             fChargeAngle(0.),
+             fPadAngle(0.),
+             fSigmaX(0.),
+             fSigmaY(0.),
+             fMeanX(0.),
+             fMeanY(0.),
+             fInterX(0),
+             fInterY(0),
+             fCurrentY(0.),
+             fDYtoWire(0.),
+             fDStepM1(0.)             
 {
   //default constructor for response function object
-  fcharge = 0;
-  fNChargeArray = 0;
-  fChargeArray = 0;
+
   fNPRF =fgkNPRF ;
-  fSigmaX = 0;
-  fSigmaY = 0;
 
-  fGRF = 0;
-  fKNorm = 1;
-  fOrigSigmaY=0;
-  fOrigSigmaX=0;
-  fNdiv = 5;
-  //set daault angels
-  fChargeAngle = 0;
-  fPadAngle = 0;
   //chewron default values   
   SetPad(0.8,0.8);
   SetChevron(0.2,0.0,1.0);

diff --git a/TPC/AliTPCParam.cxx b/TPC/AliTPCParam.cxx
index fd82bd4dad29d4bc99ec8bb208bab0fbea084234..cedd07c377af3861e5142d9d03714c2a2dc0cda6 100644 (file)
--- a/TPC/AliTPCParam.cxx
+++ b/TPC/AliTPCParam.cxx
@@ -41,15 +41,94 @@ ClassImp(AliTPCParam)
 
 //___________________________________________
 AliTPCParam::AliTPCParam()
+            :AliDetectorParam(),
+            fbStatus(kFALSE),
+             fInnerRadiusLow(0.),
+             fInnerRadiusUp(0.),
+             fOuterRadiusUp(0.),
+             fOuterRadiusLow(0.),
+            fInnerAngle(0.),
+            fInnerAngleShift(0.),
+            fOuterAngle(0.),
+            fOuterAngleShift(0.),
+            fInnerFrameSpace(0.),
+            fOuterFrameSpace(0.),
+            fInnerWireMount(0.),
+            fOuterWireMount(0.),
+            fNInnerSector(0),
+            fNOuterSector(0),
+            fNSector(0),
+            fZLength(0),
+            fRotAngle(),
+            fGeometryType(0),
+            fTrackingMatrix(0),
+            fClusterMatrix(0), 
+            fGlobalMatrix(0),
+            fNInnerWiresPerPad(0),
+            fInnerWWPitch(0),
+            fInnerDummyWire(0),
+            fInnerOffWire(0.),
+            fRInnerFirstWire(0.),
+            fRInnerLastWire(0.),
+            fLastWireUp1(0.),
+            fNOuter1WiresPerPad(0),
+            fNOuter2WiresPerPad(0),
+            fOuterWWPitch(0.),
+            fOuterDummyWire(0),
+            fOuterOffWire(0.),
+            fROuterFirstWire(0.),
+            fROuterLastWire(0.),
+            fInnerPadPitchLength(0.),
+            fInnerPadPitchWidth(0.),
+            fInnerPadLength(0.),
+            fInnerPadWidth(0.),
+            fOuter1PadPitchLength(0.),
+            fOuter2PadPitchLength(0.),
+            fOuterPadPitchWidth(0.),
+            fOuter1PadLength(0.),
+            fOuter2PadLength(0.),
+            fOuterPadWidth(0.),
+            fBMWPCReadout(kFALSE),
+            fNCrossRows(0),
+            fNRowLow(0),
+            fNRowUp1(0),
+            fNRowUp2(0),
+            fNRowUp(0),
+            fNtRows(0),
+            fDiffT(0.),
+            fDiffL(0.),
+            fGasGain(0.),
+            fDriftV(0.),
+            fOmegaTau(0.),
+            fAttCoef(0.),
+            fOxyCont(0.),
+            fPadCoupling(0.),
+            fZeroSup(0),
+            fNoise(0.),
+            fChipGain(0.),
+            fChipNorm(0.),
+            fTSample(0.),
+            fZWidth(0.),
+            fTSigma(0.),
+            fMaxTBin(0),
+            fADCSat(0),
+            fADCDynRange(0.),
+            fTotalNormFac(0.),
+            fNoiseNormFac(0.),
+            fNResponseMax(0),
+            fResponseThreshold(0.),
+            fCurrentMax(0),
+            fResponseBin(0),
+            fResponseWeight(0),
+            fGateDelay(0.),
+            fL1Delay(0.),
+            fNTBinsBeforeL1(0),
+            fNTBinsL1(0.)   
 {   
   //
   //constructor sets the default parameters
   //
 
-  fResponseBin = 0;
-  fResponseWeight = 0;
-  fRotAngle = 0;
-  fTrackingMatrix = fClusterMatrix = fGlobalMatrix = 0;
   SetTitle("75x40_100x60_150x60");
   SetDefault();  
 }

diff --git a/TPC/AliTPCParamCR.cxx b/TPC/AliTPCParamCR.cxx
index 28b1079eece94834ef2588a0579c25a885b483f2..42a4cb284cd9102cdfb8f1d032dce2723040ed5b 100644 (file)
--- a/TPC/AliTPCParamCR.cxx
+++ b/TPC/AliTPCParamCR.cxx
@@ -42,18 +42,41 @@ static const  Int_t kMaxRows=600;
 static const  Float_t  kEdgeSectorSpace = 2.5;
 
 AliTPCParamCR::AliTPCParamCR()
+              :AliTPCParam(),
+              fInnerPRF(0),
+              fOuter1PRF(0),
+              fOuter2PRF(0),
+               fTimeRF(0),
+              fFacSigma(0.)
 {   
   //
   //constructor set the default parameters
-  fInnerPRF=0;
-  fOuter1PRF=0;
-  fOuter2PRF=0;
-  fTimeRF = 0;
+
   fFacSigma = Float_t(2.);
   SetDefault();
   Update();
 }
-
+AliTPCParamCR::AliTPCParamCR(const AliTPCParamCR &param)
+              :AliTPCParam(),
+              fInnerPRF(0),
+              fOuter1PRF(0),
+              fOuter2PRF(0),
+               fTimeRF(0),
+              fFacSigma(0.)
+{
+  //
+  // copy constructor - dummy
+  //
+  fFacSigma= param.fFacSigma;
+}
+AliTPCParamCR & AliTPCParamCR::operator =(const AliTPCParamCR & param)
+{
+  //
+  // assignment operator - dummy
+  //
+   fFacSigma= param.fFacSigma;
+  return (*this); 
+}
 AliTPCParamCR::~AliTPCParamCR()
 {
   //

diff --git a/TPC/AliTPCParamCR.h b/TPC/AliTPCParamCR.h
index f6deb3e0442e0fd36411b218d5f7572bc0037b54..bc0ced463698536440258df68ff9092ae4dbee31 100644 (file)
--- a/TPC/AliTPCParamCR.h
+++ b/TPC/AliTPCParamCR.h
@@ -16,6 +16,8 @@ class AliTPCPRF2D;
 class AliTPCParamCR : public AliTPCParam {
 public:
   AliTPCParamCR();
+  AliTPCParamCR(const AliTPCParamCR &param); // copy constructor
+  AliTPCParamCR &operator = (const AliTPCParamCR & param); //assignment operator
   virtual ~AliTPCParamCR();
   Int_t  CalcResponse(Float_t* x, Int_t * index, Int_t dummy=0);
   //calculate bin response as function of the input position -x 

diff --git a/TPC/AliTPCParamSR.cxx b/TPC/AliTPCParamSR.cxx
index f3c35f87d329096bf35ad7c61c93405020aab577..77ad0cfda796fbe193c8819b1b566bbf6ebb0df5 100644 (file)
--- a/TPC/AliTPCParamSR.cxx
+++ b/TPC/AliTPCParamSR.cxx
@@ -46,19 +46,48 @@ static const Float_t kFacSigmaTime=3.;
 
 
 AliTPCParamSR::AliTPCParamSR()
+              :AliTPCParam(),
+              fInnerPRF(0),
+              fOuter1PRF(0),
+              fOuter2PRF(0),
+              fTimeRF(0),
+              fFacSigmaPadRow(0),
+              fFacSigmaPad(0),
+              fFacSigmaTime(0)
 {   
   //
   //constructor set the default parameters
-  fInnerPRF=0;
-  fOuter1PRF=0;
-  fOuter2PRF=0;
-  fTimeRF = 0;
+  //
+
   fFacSigmaPadRow = Float_t(kFacSigmaPadRow);
   fFacSigmaPad = Float_t(kFacSigmaPad);
   fFacSigmaTime = Float_t(kFacSigmaTime);
   SetDefault();
   Update();
 }
+AliTPCParamSR::AliTPCParamSR(const AliTPCParamSR &param)
+              :AliTPCParam(),
+              fInnerPRF(0),
+              fOuter1PRF(0),
+              fOuter2PRF(0),
+              fTimeRF(0),
+              fFacSigmaPadRow(0),
+              fFacSigmaPad(0),
+              fFacSigmaTime(0)
+{
+  //
+  //  copy constructor - dummy
+  //
+  fFacSigmaPadRow = param.fFacSigmaPadRow;
+}
+AliTPCParamSR & AliTPCParamSR::operator =(const AliTPCParamSR & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fZLength=param.fZLength;
+  return (*this);
+}
 
 AliTPCParamSR::~AliTPCParamSR()
 {

diff --git a/TPC/AliTPCParamSR.h b/TPC/AliTPCParamSR.h
index 8dac3fcc5b061bc6a3169bee8add238e639f6d99..a914eb32d691f8bd212058da58c0089454bbab3b 100644 (file)
--- a/TPC/AliTPCParamSR.h
+++ b/TPC/AliTPCParamSR.h
@@ -16,6 +16,8 @@ class AliTPCPRF2D;
 class AliTPCParamSR : public AliTPCParam {
 public:
   AliTPCParamSR();
+  AliTPCParamSR(const AliTPCParamSR &param); // copy constructor
+  AliTPCParamSR &operator = (const AliTPCParamSR & param); //assignment operator
   virtual ~AliTPCParamSR();
 
   Int_t  CalcResponse(Float_t* x, Int_t * index, Int_t row);

diff --git a/TPC/AliTPCPid.cxx b/TPC/AliTPCPid.cxx
index e588c06e38fed51c0ec22cda596f0ebfb7750266..5cb6ff7bbf6b51ce9f3a2a2cbd75930b001af1a4 100644 (file)
--- a/TPC/AliTPCPid.cxx
+++ b/TPC/AliTPCPid.cxx
@@ -30,8 +30,26 @@ ClassImp(AliTPCPid)
 // pid class by B. Batyunya
 // stupid corrections by M.K.
 //
+//_______________________________________________________
 //________________________________________________________
-  AliTPCPid::AliTPCPid( const AliTPCPid& r):TObject(r)
+AliTPCPid::AliTPCPid( const AliTPCPid& r):TObject(r),
+                 fCutKa(0),
+                 fCutPr(0),
+                 fCutKaTune(0.),
+                 fCutPrTune(0.),
+                 fSigmin(0.),
+                 fSilent(0),
+                 fmxtrs(0),
+                 trs(0),
+                 fqtot(0.),
+                 fWpi(0.),
+                 fWk(0.),
+                 fWp(0.),
+                 fRpik(0.),
+                 fRppi(0.),
+                 fRpka(0.),
+                 fRp(0.),
+                 fPcode(0)
 {
   // dummy copy constructor
 }
@@ -46,6 +64,15 @@ Float_t AliTPCPid::Qcorr(Float_t xc)
   if(fcorr<=0.1)fcorr=0.1;
 return fqtot/fcorr;
 }
+//__________________________________________________________
+AliTPCPid & AliTPCPid::operator =(const AliTPCPid & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fSigmin=param.fSigmin;
+  return (*this);
+}
 //-----------------------------------------------------------
 Float_t AliTPCPid::Qtrm(Int_t track) const
 {
@@ -435,12 +462,29 @@ void AliTPCPid::Reset(void)
   }
 }
 //-----------------------------------------------------------
-AliTPCPid::AliTPCPid(Int_t ntrack)
+AliTPCPid::AliTPCPid(Int_t ntrack):TObject(),
+                 fCutKa(0),
+                 fCutPr(0),
+                 fCutKaTune(0.),
+                 fCutPrTune(0.),
+                 fSigmin(0.),
+                 fSilent(0),
+                 fmxtrs(0),
+                 trs(0),
+                 fqtot(0.),
+                 fWpi(0.),
+                 fWk(0.),
+                 fWp(0.),
+                 fRpik(0.),
+                 fRppi(0.),
+                 fRpka(0.),
+                 fRp(0.),
+                 fPcode(0)
 {
     trs = new TClonesArray("TVector",ntrack);
     TClonesArray &arr=*trs;
     for(Int_t i=0;i<ntrack;i++)new(arr[i])TVector(0,11);
-    fmxtrs=0;
+
 
     //fCutKa = new TF1("fkaons","[0]/x/x+[1]",0.1,1.2);
     //fCutPr = new TF1("fprotons","[0]/x/x +[1]",0.2,1.2);

diff --git a/TPC/AliTPCPid.h b/TPC/AliTPCPid.h
index 4d69586e369efe33867e404d467c29e42e6cfb05..58336916623d6dbbb294877941bc8e34bf990c33 100644 (file)
--- a/TPC/AliTPCPid.h
+++ b/TPC/AliTPCPid.h
@@ -22,9 +22,10 @@ class  AliTPCPid :
   public TObject {
 
 public:
-               AliTPCPid(Int_t ntrs=1000);
+                AliTPCPid(Int_t ntrs=1000);
                virtual ~AliTPCPid(){}
                 AliTPCPid( const AliTPCPid& r);
+                AliTPCPid &operator = (const AliTPCPid & param); //assignment
        void    SetEdep(Int_t track,Float_t Edep);
        void    SetPmom(Int_t track,Float_t Pmom);
        void    SetPcod(Int_t track,Int_t Pcod);

diff --git a/TPC/AliTPCRF1D.cxx b/TPC/AliTPCRF1D.cxx
index dd1c4c249eecd291af063fe94325caabcd647967..d869ce0569d625468423558b0173480a672c63a9 100644 (file)
--- a/TPC/AliTPCRF1D.cxx
+++ b/TPC/AliTPCRF1D.cxx
@@ -76,6 +76,19 @@ ClassImp(AliTPCRF1D)
 
 
 AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
+           :TObject(),
+           fNRF(0),
+            fDSTEPM1(0.),
+            fcharge(0),
+            forigsigma(0.),
+            fpadWidth(3.5),
+            fkNorm(0.5),
+            fInteg(0.),
+            fGRF(0),
+            fSigma(0.),
+            fOffset(0.),
+            fDirect(kFALSE),
+            fPadDistance(0.)
 {
   //default constructor for response function object
   fDirect=direct;
@@ -84,15 +97,22 @@ AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
   fcharge = new Float_t[fNRF];
   if (step>0) fDSTEPM1=1./step;
   else fDSTEPM1 = 1./fgRFDSTEP;
-  fSigma = 0;
-  fGRF = 0;
-  fkNorm = 0.5;
-  fpadWidth = 3.5;
-  forigsigma=0.;
-  fOffset = 0.;
 }
 
-AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf):TObject(prf)
+AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf)
+           :TObject(prf),
+           fNRF(0),
+            fDSTEPM1(0.),
+            fcharge(0),
+            forigsigma(0.),
+            fpadWidth(3.5),
+            fkNorm(0.5),
+            fInteg(0.),
+            fGRF(0),
+            fSigma(0.),
+            fOffset(0.),
+            fDirect(kFALSE),
+            fPadDistance(0.)
 {
   
   //

diff --git a/TPC/AliTPCROC.cxx b/TPC/AliTPCROC.cxx
index 1b8c39db4a624d346ca49aa1a724b954b5b33f8f..c4bb00ecfa445ea63faf4da73bcc8b88d5aa81eb 100644 (file)
--- a/TPC/AliTPCROC.cxx
+++ b/TPC/AliTPCROC.cxx
@@ -203,7 +203,49 @@ void AliTPCROC::SetGeometry()
 
 
 //_____________________________________________________________________________
-AliTPCROC::AliTPCROC():TObject(), fNSectorsAll(0)
+AliTPCROC::AliTPCROC()
+          :TObject(), 
+           fNSectorsAll(0),
+          fInnerRadiusLow(0.),
+          fInnerRadiusUp(0.),
+          fOuterRadiusUp(0.),
+          fOuterRadiusLow(0.),
+          fInnerFrameSpace(0.),
+          fOuterFrameSpace(0.),
+          fInnerWireMount(0.),
+          fOuterWireMount(0.),
+          fZLength(0.),
+          fInnerAngle(0.),
+          fOuterAngle(0.),
+          fNInnerWiresPerPad(0),
+          fInnerWWPitch(0.),
+          fInnerDummyWire(0),
+          fInnerOffWire(0.),
+          fRInnerFirstWire(0.),
+          fRInnerLastWire(0.),
+          fLastWireUp1(0.),
+          fNOuter1WiresPerPad(0),
+          fNOuter2WiresPerPad(0),
+          fOuterWWPitch(0.),
+          fOuterDummyWire(0),
+          fOuterOffWire(0),
+          fROuterFirstWire(0.),
+          fROuterLastWire(0),
+          fInnerPadPitchLength(0.),
+          fInnerPadPitchWidth(0.),
+          fInnerPadLength(0.),
+          fInnerPadWidth(0.),
+          fOuter1PadPitchLength(0.),
+          fOuter2PadPitchLength(0),
+          fOuterPadPitchWidth(0),
+          fOuter1PadLength(0.),
+          fOuter2PadLength(0),
+          fOuterPadWidth(0),
+          fNRowLow(0),
+          fNRowUp1(0),
+          fNRowUp2(0),
+          fNRowUp(0),
+          fNtRows(0)
 {
   //
   // Default constructor
@@ -218,7 +260,50 @@ AliTPCROC::AliTPCROC():TObject(), fNSectorsAll(0)
 
 
 //_____________________________________________________________________________
-AliTPCROC::AliTPCROC(const AliTPCROC &roc):TObject(roc)
+AliTPCROC::AliTPCROC(const AliTPCROC &roc)
+          :TObject(roc),
+           fNSectorsAll(0),
+          fInnerRadiusLow(0.),
+          fInnerRadiusUp(0.),
+          fOuterRadiusUp(0.),
+          fOuterRadiusLow(0.),
+          fInnerFrameSpace(0.),
+          fOuterFrameSpace(0.),
+          fInnerWireMount(0.),
+          fOuterWireMount(0.),
+          fZLength(0.),
+          fInnerAngle(0.),
+          fOuterAngle(0.),
+          fNInnerWiresPerPad(0),
+          fInnerWWPitch(0.),
+          fInnerDummyWire(0),
+          fInnerOffWire(0.),
+          fRInnerFirstWire(0.),
+          fRInnerLastWire(0.),
+          fLastWireUp1(0.),
+          fNOuter1WiresPerPad(0),
+          fNOuter2WiresPerPad(0),
+          fOuterWWPitch(0.),
+          fOuterDummyWire(0),
+          fOuterOffWire(0),
+          fROuterFirstWire(0.),
+          fROuterLastWire(0),
+          fInnerPadPitchLength(0.),
+          fInnerPadPitchWidth(0.),
+          fInnerPadLength(0.),
+          fInnerPadWidth(0.),
+          fOuter1PadPitchLength(0.),
+          fOuter2PadPitchLength(0),
+          fOuterPadPitchWidth(0),
+          fOuter1PadLength(0.),
+          fOuter2PadLength(0),
+          fOuterPadWidth(0),
+          fNRowLow(0),
+          fNRowUp1(0),
+          fNRowUp2(0),
+          fNRowUp(0),
+          fNtRows(0)
+
 {
   //
   // AliTPCROC copy constructor
@@ -249,7 +334,15 @@ AliTPCROC::AliTPCROC(const AliTPCROC &roc):TObject(roc)
     fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
   }
 }
-
+//____________________________________________________________________________
+AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
+{
+  //
+  // assignment operator - dummy
+  //
+  fZLength = roc.fZLength;
+  return (*this);
+}
 //_____________________________________________________________________________
 AliTPCROC::~AliTPCROC()
 {

diff --git a/TPC/AliTPCROC.h b/TPC/AliTPCROC.h
index 921930754a7ed80fe93ad95fd1cb4aaed664f131..231dfb53ede17d9b8ccb8506b8226031ab55e739 100644 (file)
--- a/TPC/AliTPCROC.h
+++ b/TPC/AliTPCROC.h
@@ -19,6 +19,7 @@ class AliTPCROC : public TObject {
   static AliTPCROC* Instance();
   AliTPCROC();
   AliTPCROC(const AliTPCROC &roc);
+  AliTPCROC &operator = (const AliTPCROC & roc); //assignment operator
   void Init(); 
   virtual           ~AliTPCROC();
 

diff --git a/TPC/AliTPCTrackHitsV2.cxx b/TPC/AliTPCTrackHitsV2.cxx
index 6639834d930b311da5c615e75b8b1b6bde1d557d..6d3f95af9059a0eb979999d0ea34b9c9d96e7867 100644 (file)
--- a/TPC/AliTPCTrackHitsV2.cxx
+++ b/TPC/AliTPCTrackHitsV2.cxx
@@ -130,6 +130,20 @@ protected:
 
 
 AliTPCTempHitInfoV2::AliTPCTempHitInfoV2()
+  :fSumDr(0.),
+   fSumDr2(0.),
+   fSumDr3(0.),
+   fSumDr4(0.),
+   fSumDFi(0.),
+   fSumDFiDr(0.),
+   fSumDFiDr2(0.),
+   fSumDZ(0.),
+   fSumDZDr(0.),
+   fSumDZDr2(0.),
+   fOldR(0.),
+   fStackIndex(0),
+   fParamIndex(0),
+   fParam(0)
 {
   //
   // Standard constructor
@@ -290,17 +304,26 @@ void   AliTPCTempHitInfoV2::Fit(AliTrackHitsParamV2 * param)
   
 }
 
-AliTrackHitsParamV2::AliTrackHitsParamV2()
+AliTrackHitsParamV2::AliTrackHitsParamV2():TObject(),
+   fTrackID(0), 
+   fVolumeID(0),
+   fR(0.),  
+   fZ(0.),  
+   fFi(0.), 
+   fAn(0.), 
+   fAd(0.), 
+   fTheta(0.), 
+   fThetaD(0.), 
+   fNHits(0), 
+   fHitDistance(0), 
+   fCharge(0),
+   fTime(0)
 {
   //
   // default constructor
   //
   fgCounter1++;
   fgCounter2++;
-  fHitDistance=0;
-  fCharge=0;
-  fTime=0;
-  fNHits=0;
 }
 
 AliTrackHitsParamV2::~AliTrackHitsParamV2()
@@ -332,7 +355,17 @@ Float_t AliTrackHitsParamV2::Eta() const
 }
 
 
-AliTPCTrackHitsV2::AliTPCTrackHitsV2()
+AliTPCTrackHitsV2::AliTPCTrackHitsV2():TObject(),
+  fArray(0),  
+  fSize(0),           
+  fPrecision(0.),  
+  fStep(0.),       
+  fMaxDistance(0),   
+  fNVolumes(0),        
+  fVolumes(0),   
+  fTempInfo(0), 
+  fCurrentHit(0),  
+  fHit(0)  
 {
   //
   //default constructor
@@ -344,16 +377,12 @@ AliTPCTrackHitsV2::AliTPCTrackHitsV2()
   fPrecision=kHitPrecision; //precision in cm
   fStep = kStep; //step size
   fMaxDistance = kMaxDistance; //maximum distance
-  fTempInfo =0;
-  fSize=0;
+
   //fTrackHitsInfo = new AliObjectArray("AliTrackHitsInfo"); 
   //fTrackHitsParam = new AliObjectArray("AliTrackHitsParamV2");
   //fHitsPosAndQ = new TArrayOfArrayVStack("AliHitInfo");
   fArray  = new TClonesArray("AliTrackHitsParamV2");
   fCurrentHit = new AliTPCCurrentHitV2;
-  fVolumes =0;
-  fNVolumes =0;
-  fHit =0;
   fgCounter1++;
   fgCounter2++;
 

diff --git a/TPC/AliTPCTrackHitsV2.h b/TPC/AliTPCTrackHitsV2.h
index 225bb19c3f6f7cf9e659af233bbfca063129a29d..d3853d1159287f47c22682315bb709a22ae188aa 100644 (file)
--- a/TPC/AliTPCTrackHitsV2.h
+++ b/TPC/AliTPCTrackHitsV2.h
@@ -19,9 +19,24 @@ class AliHit;
 
 class AliTrackHitsParamV2 : public TObject {
 
+
 public:
   AliTrackHitsParamV2();
-  AliTrackHitsParamV2(const AliTrackHitsParamV2 &hit):  TObject(hit)
+
+   AliTrackHitsParamV2(const AliTrackHitsParamV2 &hit):  TObject(hit),
+   fTrackID(0), 
+   fVolumeID(0),
+   fR(0.),  
+   fZ(0.),  
+   fFi(0.), 
+   fAn(0.), 
+   fAd(0.), 
+   fTheta(0.), 
+   fThetaD(0.), 
+   fNHits(0), 
+   fHitDistance(0), 
+   fCharge(0),
+   fTime(0) 
     {hit.Copy(*this);}
   AliTrackHitsParamV2& operator = (const AliTrackHitsParamV2 &hit)
      {hit.Copy(*this); return (*this);}
@@ -113,9 +128,19 @@ public:
 class AliTPCTrackHitsV2 : public TObject {
 
 public:
-  AliTPCTrackHitsV2(); 
+  AliTPCTrackHitsV2();
   ~AliTPCTrackHitsV2();
-  AliTPCTrackHitsV2(const AliTPCTrackHitsV2 &hit):  TObject(hit)
+  AliTPCTrackHitsV2(const AliTPCTrackHitsV2 &hit):  TObject(hit),
+  fArray(0),  
+  fSize(0),           
+  fPrecision(0.),  
+  fStep(0.),       
+  fMaxDistance(0),   
+  fNVolumes(0),        
+  fVolumes(0),   
+  fTempInfo(0), 
+  fCurrentHit(0),  
+  fHit(0) 
     {hit.Copy(*this);}
   AliTPCTrackHitsV2& operator = (const AliTPCTrackHitsV2 &hit)
      {hit.Copy(*this); return (*this);}

diff --git a/TPC/AliTPCcalibDB.h b/TPC/AliTPCcalibDB.h
index 72da2c28099c0c452c203f8081ad2656e91af72c..25fa91ac4c32703670f1c2394b94f6e5e2a6ca9a 100644 (file)
--- a/TPC/AliTPCcalibDB.h
+++ b/TPC/AliTPCcalibDB.h
@@ -21,6 +21,8 @@ class AliTPCcalibDB : public TObject
  public: 
   static AliTPCcalibDB* Instance();
   AliTPCcalibDB();
+  AliTPCcalibDB(const AliTPCcalibDB &param); // copy constructor
+  AliTPCcalibDB &operator = (const AliTPCcalibDB & param);
   virtual ~AliTPCcalibDB();
   static void Terminate();
   void   SetRun(Long64_t run);   

diff --git a/TPC/AliTPCcluster.cxx b/TPC/AliTPCcluster.cxx
index 69296d0757576c28fcb161ccf0bcd06a7a2d4330..4d9a3253b605aa016d4e65c315dbfa7b6aa1456b 100644 (file)
--- a/TPC/AliTPCcluster.cxx
+++ b/TPC/AliTPCcluster.cxx
@@ -24,7 +24,17 @@
 #include "AliTPCcluster.h"
 
 ClassImp(AliTPCcluster)
-
+//
+AliTPCcluster:: AliTPCcluster(Int_t *lab, Float_t *hit)
+              :AliCluster(lab,hit),
+               fQ(0.)
+{
+  //
+  // constructor
+  //
+  fQ=hit[4];
+}
+ 
 //____________________________________________________________________________
 Double_t AliTPCcluster::SigmaY2(Double_t r, Double_t tgl, Double_t pt)
 {

diff --git a/TPC/AliTPCcluster.h b/TPC/AliTPCcluster.h
index 2b83bfece3be1a9f9049323cbfd4cc3670b1b629..f3bfaaf0dcf1abb0abf13fb0bb3a80b4a66fa537 100644 (file)
--- a/TPC/AliTPCcluster.h
+++ b/TPC/AliTPCcluster.h
@@ -17,8 +17,8 @@
 //_____________________________________________________________________________
 class AliTPCcluster : public AliCluster {
 public:
-  AliTPCcluster():AliCluster(){fQ=0;}
-  AliTPCcluster(Int_t *lab, Float_t *hit) : AliCluster(lab,hit) {fQ = hit[4];}
+  AliTPCcluster():AliCluster(),fQ(0){}
+  AliTPCcluster(Int_t *lab, Float_t *hit);
   void Use(Int_t = 0) {fQ=-fQ;}
   void SetQ(Float_t q) {fQ=q;}
 

diff --git a/TPC/AliTPCclusterer.cxx b/TPC/AliTPCclusterer.cxx
index e511bdfcdee50e8e09f67671ebe79c99f98adfa1..f2e5815276853a1519020019c08cb0893a385d5f 100644 (file)
--- a/TPC/AliTPCclusterer.cxx
+++ b/TPC/AliTPCclusterer.cxx
@@ -33,13 +33,27 @@
 
 ClassImp(AliTPCclusterer)
 
-AliTPCclusterer::AliTPCclusterer(const AliTPCParam *par) { 
-//-------------------------------------------------------
-//  The main constructor
-//-------------------------------------------------------
-  fPar=par;
-}
 
+//____________________________________________________
+AliTPCclusterer::AliTPCclusterer(const AliTPCclusterer &param)
+                :TObject(),
+                 fPar(0)
+{
+  //
+  // dummy
+  //
+  fPar = param.fPar;
+}
+//-----------------------------------------------------
+AliTPCclusterer & AliTPCclusterer::operator =(const AliTPCclusterer & param)
+{
+  //
+  // assignment operator - dummy
+  //
+    fPar = param.fPar;
+  return (*this);
+}
+//____________________________________________________
 void AliTPCclusterer::FindPeaks(Int_t k,Int_t max,
 AliBin *b,Int_t *idx,UInt_t *msk,Int_t& n) {
   //find local maxima

diff --git a/TPC/AliTPCclusterer.h b/TPC/AliTPCclusterer.h
index 3835d94f3744aa14678b30a67a68629fcaaa867e..06b8d218a650b5223e574779086e98adab19aebe 100644 (file)
--- a/TPC/AliTPCclusterer.h
+++ b/TPC/AliTPCclusterer.h
@@ -18,7 +18,10 @@ class AliTPCcluster;
 
 class AliTPCclusterer : public TObject {
 public:
-  AliTPCclusterer(const AliTPCParam *par);
+  AliTPCclusterer():TObject(),fPar(0){};
+  AliTPCclusterer(const AliTPCParam *par):TObject(), fPar(par){};
+  AliTPCclusterer(const AliTPCclusterer &param); // copy constructor
+  AliTPCclusterer &operator = (const AliTPCclusterer & param);
   Int_t Digits2Clusters(TTree *dig, TTree *clu);
 
 private:

diff --git a/TPC/AliTPCdigit.cxx b/TPC/AliTPCdigit.cxx
index 97ff00b088a0f3665102143d158bfdcec1445e5f..ab0876e41ee2fb87ee2453777e183469aa305a5b 100644 (file)
--- a/TPC/AliTPCdigit.cxx
+++ b/TPC/AliTPCdigit.cxx
@@ -25,10 +25,27 @@
 
 
 ClassImp(AliTPCdigit)
- 
+  //_____________________________________________________________________
+  AliTPCdigit::AliTPCdigit()
+              :AliDigit(),
+              fSector(0),
+               fPadRow(0),
+               fPad(0),
+               fTime(0),
+               fSignal(0)
+{
+  //
+  //   default constructor
+  //
+} 
 //_____________________________________________________________________________
-AliTPCdigit::AliTPCdigit(Int_t *tracks, Int_t *digits):
-  AliDigit(tracks)
+AliTPCdigit::AliTPCdigit(Int_t *tracks, Int_t *digits)
+            :AliDigit(tracks),
+              fSector(0),
+               fPadRow(0),
+               fPad(0),
+              fTime(0),
+               fSignal(0)
 {
   //
   // Creates a TPC digit object

diff --git a/TPC/AliTPCdigit.h b/TPC/AliTPCdigit.h
index 2ca2f4ec6444414aed6a2988918f764af96a41cf..d3e9ad55a99914ef690ace461e58c83c88477e1a 100644 (file)
--- a/TPC/AliTPCdigit.h
+++ b/TPC/AliTPCdigit.h
@@ -20,7 +20,7 @@ public:
    Int_t     fSignal;     //Signal amplitude
  
 public:
-   AliTPCdigit() {}
+   AliTPCdigit();
    AliTPCdigit(Int_t *tracks, Int_t *digits);
    virtual ~AliTPCdigit() {}
  

diff --git a/TPC/AliTPCkineGrid.cxx b/TPC/AliTPCkineGrid.cxx
index 6ea805972b901f9904644efe330923b069bff034..0ec62f7b7e94bbaf5f1a63a9b87d6ed085f3ae55 100644 (file)
--- a/TPC/AliTPCkineGrid.cxx
+++ b/TPC/AliTPCkineGrid.cxx
@@ -37,24 +37,33 @@
 ClassImp(AliTPCkineGrid)
 
 //------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid() {
+  AliTPCkineGrid::AliTPCkineGrid()
+    :TNamed(),
+     fNpt(0),
+     fNeta(0),
+     fPt(0),
+     fEta(0),
+     fParams(0) 
+{
 //------------------------------------------------------------------------
 // Default constructor
 //------------------------------------------------------------------------
-  fNpt = 0;
-  fNeta = 0;
-  fPt = 0;
-  fEta = 0;
-  fParams = 0;
+
 }
 //------------------------------------------------------------------------
 AliTPCkineGrid::AliTPCkineGrid(Int_t npt,Int_t neta,
-                              Double_t* pt,Double_t* eta) {
+                              Double_t* pt,Double_t* eta)
+  :TNamed(),
+    fNpt(npt),
+    fNeta(neta),
+    fPt(0),
+    fEta(0),
+    fParams(0) 
+{
 //------------------------------------------------------------------------
 // Standard constructor
 //------------------------------------------------------------------------
-  fNpt  = npt;
-  fNeta = neta;
+
 
   fPt   = new TArrayD(fNpt);
   fEta  = new TArrayD(fNeta);
@@ -65,7 +74,13 @@ AliTPCkineGrid::AliTPCkineGrid(Int_t npt,Int_t neta,
   fParams = new TMatrixD(fNpt,fNeta);
 }
 //-------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid) {
+AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid),
+     fNpt(0),
+     fNeta(0),
+     fPt(0),
+     fEta(0),
+     fParams(0) 
+{
 //-------------------------------------------------------------------------
 // Copy constructor
 //-------------------------------------------------------------------------
@@ -90,6 +105,15 @@ AliTPCkineGrid::~AliTPCkineGrid() {
   delete fEta;
   delete fParams;
 }
+//__________________________________________________________________________
+AliTPCkineGrid & AliTPCkineGrid::operator =(const AliTPCkineGrid & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fNpt=param.fNpt;
+  return (*this);
+}
 //--------------------------------------------------------------------------
 void AliTPCkineGrid::GetArrayEta(Double_t* eta) const {
 //--------------------------------------------------------------------------

diff --git a/TPC/AliTPCkineGrid.h b/TPC/AliTPCkineGrid.h
index 72f6f233a501a5082666ef172f7ee1f30a3f9e41..aab4d1c59b8c14dac71f6cc976a8ef2c448b0c1c 100644 (file)
--- a/TPC/AliTPCkineGrid.h
+++ b/TPC/AliTPCkineGrid.h
@@ -26,6 +26,7 @@ class AliTPCkineGrid : public TNamed {
   AliTPCkineGrid();
   AliTPCkineGrid(Int_t npt,Int_t neta,Double_t* pt,Double_t* eta);
   AliTPCkineGrid(const AliTPCkineGrid& grid);
+  AliTPCkineGrid &operator = (const AliTPCkineGrid & param);
   virtual ~AliTPCkineGrid();
   void     GetArrayEta(Double_t* eta) const;
   void     GetArrayPt(Double_t* pt) const;

diff --git a/TPC/AliTPCpidESD.cxx b/TPC/AliTPCpidESD.cxx
index 1b43f43f950824251152a74b95012585d53ab882..460278f85016f4552d44574bb8c85943502a6101 100644 (file)
--- a/TPC/AliTPCpidESD.cxx
+++ b/TPC/AliTPCpidESD.cxx
@@ -26,7 +26,10 @@
 ClassImp(AliTPCpidESD)
 
 //_________________________________________________________________________
-AliTPCpidESD::AliTPCpidESD(Double_t *param)
+  AliTPCpidESD::AliTPCpidESD(Double_t *param):
+    fMIP(0.),
+    fRes(0.),
+    fRange(0.)
 {
   //
   //  The main constructor

diff --git a/TPC/AliTPCpidESD.h b/TPC/AliTPCpidESD.h
index 1b39af640ef0e985f44a14dcfb3b5ee5b358eead..0e74ad253ebc3f5f125e473b914c4e7deff59b88 100644 (file)
--- a/TPC/AliTPCpidESD.h
+++ b/TPC/AliTPCpidESD.h
@@ -14,6 +14,7 @@ class AliESD;
 
 class AliTPCpidESD {
 public:
+  AliTPCpidESD():fMIP(0.),fRes(0.),fRange(0.){}
   AliTPCpidESD(Double_t *param);
   virtual ~AliTPCpidESD() {}
   Int_t MakePID(AliESD *event);

diff --git a/TPC/AliTPCpolyTrack.cxx b/TPC/AliTPCpolyTrack.cxx
index da9d788afd7d934b6293b68852fb7bdd709240ed..20fc39983935f96bf86bd71ed396d14d42f6874c 100644 (file)
--- a/TPC/AliTPCpolyTrack.cxx
+++ b/TPC/AliTPCpolyTrack.cxx
@@ -26,6 +26,27 @@ ClassImp(AliTPCpolyTrack)
 
 
 AliTPCpolyTrack::AliTPCpolyTrack()
+  :TObject(),
+   fA(0), 
+   fB(0), 
+   fC(0), 
+   fD(0), 
+   fE(0), 
+   fF(0), 
+   fMaxX(0), 
+   fMinX(0), 
+   fSumW(0),    
+   fSumX(0),    
+   fSumX2(0),   
+   fSumX3(0),    
+   fSumX4(0),   
+   fSumY(0),    
+   fSumYX(0),   
+   fSumYX2(0),  
+   fSumZ(0),     
+   fSumZX(0),   
+   fSumZX2(0), 
+   fNPoints(0)
 {
   Reset();
 }

diff --git a/TPC/AliTPCseed.cxx b/TPC/AliTPCseed.cxx
index bdfaa40f72ce95c335d014e2c4e68a420adac0e3..536f551639fb6dace0e39c43d84e47b0d14883e4 100644 (file)
--- a/TPC/AliTPCseed.cxx
+++ b/TPC/AliTPCseed.cxx
@@ -223,7 +223,16 @@ AliTPCseed::~AliTPCseed(){
     }
   }
 }
-
+//_________________________________________________
+AliTPCseed & AliTPCseed::operator =(const AliTPCseed & param)
+{
+  //
+  // assignment operator - dummy
+  //
+  fRow=param.fRow;
+  return (*this);
+}
+//____________________________________________________
 AliTPCTrackerPoint * AliTPCseed::GetTrackPoint(Int_t i)
 {
   //

diff --git a/TPC/AliTPCseed.h b/TPC/AliTPCseed.h
index 2acec0c3e1b8bbbf6b8bca70e24f6eb17822e9ae..a4941aacae173cfe4c1ec3550a20da26034a99b1 100644 (file)
--- a/TPC/AliTPCseed.h
+++ b/TPC/AliTPCseed.h
@@ -35,7 +35,8 @@ class AliTPCseed : public AliTPCtrack {
      AliTPCseed(const AliTPCseed &s, Bool_t clusterOwner = kFALSE);
      //AliTPCseed(const AliTPCseed &t, Double_t a);
      AliTPCseed(Double_t xr, Double_t alpha, const Double_t xx[5], 
-                const Double_t cc[15], Int_t i);     
+                const Double_t cc[15], Int_t i);   
+     AliTPCseed &operator = (const AliTPCseed & param);  
      Int_t Compare(const TObject *o) const;
      void Reset(Bool_t all = kTRUE);
      Int_t GetProlongation(Double_t xr, Double_t &y, Double_t & z) const;

diff --git a/TPC/AliTPCtrackPid.cxx b/TPC/AliTPCtrackPid.cxx
index acdbfdc8418bc21c98eabbb4c61dd8626a53a802..5a01514491d6ee4c4594839641b042a2445dee79 100644 (file)
--- a/TPC/AliTPCtrackPid.cxx
+++ b/TPC/AliTPCtrackPid.cxx
@@ -27,7 +27,28 @@
 ClassImp(AliTPCtrackPid)
 
 AliTPCtrackPid::AliTPCtrackPid()
+  :TObject(),
+     fWpi(0.),     
+     fWk(0.),      
+     fWp(0.),      
+     fSignal(0.),  
+     fMom(0.),     
+     fPhi(0.),     
+     fLam(0.),     
+     fPcode(0),   
+     fLabel(0),
+     fGSignal(0.), 
+     fGMom(0.),    
+     fGpx(0.),     
+     fGpy(0.),     
+     fGpz(0.),     
+     fGx(0.),      
+     fGy(0.),      
+     fGz(0.),      
+     fGcode(0),   
+     fGlab(0)       
 {
-    fWpi=fWk=fWp=0.;
-    fPcode=0; fMom=0.; fSignal=0;
+  //
+  // default costructor
+  //
 }

diff --git a/TPC/AliTPCtrackerParam.cxx b/TPC/AliTPCtrackerParam.cxx
index bd4c3c72cb7334db042108d65b6faf83dde2b1db..413bc5d3967f3aa19c031ff7313ed9bb27da28eb 100644 (file)
--- a/TPC/AliTPCtrackerParam.cxx
+++ b/TPC/AliTPCtrackerParam.cxx
@@ -120,15 +120,53 @@ ClassImp(AliTPCtrackerParam)
 
 //-----------------------------------------------------------------------------
 AliTPCtrackerParam::AliTPCtrackerParam(Int_t kcoll, Double_t kBz,
-                                      const char* evfoldname):
-  fEvFolderName(evfoldname) {
+                                      const char* evfoldname):TObject(),
+    fEvFolderName(evfoldname),
+    fBz(kBz),
+    fColl(kcoll),
+    fSelAndSmear(kTRUE),
+    fDBfileName(""),
+    fTrack(),
+    fCovTree(0),
+    fDBgrid(0),
+    fDBgridPi(),
+    fDBgridKa(),
+    fDBgridPr(),
+    fDBgridEl(),
+    fDBgridMu(),
+    fEff(0),
+    fEffPi(),
+    fEffKa(),
+    fEffPr(),
+    fEffEl(),
+    fEffMu(),
+    fPulls(0),
+    fRegPar(0),
+    fRegParPi(),
+    fRegParKa(),
+    fRegParPr(),
+    fRegParEl(),
+    fRegParMu(),
+    fdEdxMean(0),
+    fdEdxMeanPi(),
+    fdEdxMeanKa(),
+    fdEdxMeanPr(),
+    fdEdxMeanEl(),
+    fdEdxMeanMu(),
+    fdEdxRMS(0),
+    fdEdxRMSPi(),
+    fdEdxRMSKa(),
+    fdEdxRMSPr(),
+    fdEdxRMSEl(),
+    fdEdxRMSMu() 
+{
 //-----------------------------------------------------------------------------
 // This is the class conctructor 
 //-----------------------------------------------------------------------------
 
-  fBz = kBz;             // value of the z component of L3 field (Tesla)
-  fColl = kcoll;         // collision code (0: PbPb6000; 1: pp)
-  fSelAndSmear = kTRUE; // by default selection and smearing are done
+  // fBz = kBz;             // value of the z component of L3 field (Tesla)
+  //  fColl = kcoll;         // collision code (0: PbPb6000; 1: pp)
+  //  fSelAndSmear = kTRUE; // by default selection and smearing are done
 
   if(fBz!=0.4 && fBz!=0.5) {
     Fatal("AliTPCtrackerParam","AliTPCtrackerParam::AliTPCtrackerParam:  Invalid field!\n      Available:  0.4 or 0.5");
@@ -149,7 +187,46 @@ AliTPCtrackerParam::AliTPCtrackerParam(Int_t kcoll, Double_t kBz,
 //-----------------------------------------------------------------------------
 AliTPCtrackerParam::~AliTPCtrackerParam() {}
 //____________________________________________________________________________
-AliTPCtrackerParam::AliTPCtrackerParam( const AliTPCtrackerParam& p):TObject(p)
+AliTPCtrackerParam::AliTPCtrackerParam( const AliTPCtrackerParam& p)
+    :TObject(p),
+    fEvFolderName(""),
+    fBz(0.),
+    fColl(0),
+    fSelAndSmear(0),
+    fDBfileName(""),
+    fTrack(),
+    fCovTree(0),
+    fDBgrid(0),
+    fDBgridPi(),
+    fDBgridKa(),
+    fDBgridPr(),
+    fDBgridEl(),
+    fDBgridMu(),
+    fEff(0),
+    fEffPi(),
+    fEffKa(),
+    fEffPr(),
+    fEffEl(),
+    fEffMu(),
+    fPulls(0),
+    fRegPar(0),
+    fRegParPi(),
+    fRegParKa(),
+    fRegParPr(),
+    fRegParEl(),
+    fRegParMu(),
+    fdEdxMean(0),
+    fdEdxMeanPi(),
+    fdEdxMeanKa(),
+    fdEdxMeanPr(),
+    fdEdxMeanEl(),
+    fdEdxMeanMu(),
+    fdEdxRMS(0),
+    fdEdxRMSPi(),
+    fdEdxRMSKa(),
+    fdEdxRMSPr(),
+    fdEdxRMSEl(),
+    fdEdxRMSMu() 
 {
   // dummy copy constructor
 }
@@ -157,17 +234,23 @@ AliTPCtrackerParam::AliTPCtrackerParam( const AliTPCtrackerParam& p):TObject(p)
 AliTPCtrackerParam::AliTPCseedGeant::AliTPCseedGeant(
                    Double_t x,Double_t y,Double_t z,
                    Double_t px,Double_t py,Double_t pz,
-                   Int_t lab) {
+                   Int_t lab)
+                    :TObject(),
+      fXg(x),
+      fYg(y),
+      fZg(z),
+      fPx(px),
+      fPy(py),
+      fPz(pz),
+      fAlpha(0.),
+      fLabel(lab),
+      fSector(0)
+ 
+{
 //----------------------------------------------------------------------------
 // Constructor of the geant seeds
 //----------------------------------------------------------------------------
-      fXg = x;
-      fYg = y;
-      fZg = z;
-      fPx = px;
-      fPy = py;
-      fPz = pz;
-      fLabel = lab;
+
       Double_t a = TMath::ATan2(y,x)*180./TMath::Pi();
       if(a<0) a += 360.;
       fSector = (Int_t)(a/20.);

diff --git a/TPC/AliTPCtrackerParam.h b/TPC/AliTPCtrackerParam.h
index d790347f806ec9af8e4487d8cf03be3560de006e..0b8be8ab34c50d6aef62ca08dd7f08c6f17ae227 100644 (file)
--- a/TPC/AliTPCtrackerParam.h
+++ b/TPC/AliTPCtrackerParam.h
@@ -37,9 +37,9 @@ class AliTPC;
 
 class AliTPCtrackerParam:
   public TObject
-{
-   
+{   
  public:
+  
   AliTPCtrackerParam(Int_t coll=0, Double_t Bz=0.4,
                     const char* evfoldname = AliConfig::GetDefaultEventFolderName());
   virtual ~AliTPCtrackerParam();
@@ -85,6 +85,17 @@ class AliTPCtrackerParam:
   //********* Internal class definition *******
   class AliTPCseedGeant : public TObject {
   public:
+    AliTPCseedGeant():TObject(),
+      fXg(0.),
+      fYg(0.),
+      fZg(0.),
+      fPx(0.),
+      fPy(0.),
+      fPz(0.),
+      fAlpha(0.),
+      fLabel(0),
+      fSector(0){}
+
     AliTPCseedGeant(Double_t x=0.,Double_t y=0.,Double_t z=0.,
                    Double_t px=0.,Double_t py=0.,Double_t pz=0.,
                    Int_t lab=0);

diff --git a/TPC/AliTPCv1.cxx b/TPC/AliTPCv1.cxx
index d016aead72b2e5b71dd8a3f295edf1423de73d8f..0209c58625a40bbeddfdd1dc28d2d2e01815fe0b 100644 (file)
--- a/TPC/AliTPCv1.cxx
+++ b/TPC/AliTPCv1.cxx
@@ -61,7 +61,8 @@ ClassImp(AliTPCv1)
 
 //_____________________________________________________________________________
 
-  AliTPCv1::AliTPCv1(){
+  AliTPCv1::AliTPCv1():AliTPC(),fIdSens(0)
+{
 
   fHitType = 1;
 
@@ -69,11 +70,11 @@ ClassImp(AliTPCv1)
  
 //_____________________________________________________________________________
 AliTPCv1::AliTPCv1(const char *name, const char *title) 
-  :AliTPC(name, title) {
+  :AliTPC(name, title),fIdSens(0)
+ {
   //
   // Standard constructor for Time Projection Chamber
   //
-  fIdSens=0;
 
 
   if (fTPCParam)

diff --git a/TPC/AliTPCv3.cxx b/TPC/AliTPCv3.cxx
index a3deb7b2415ed9f2d2770749f8449220a6196b56..a6119da0fcbe1e07d3d690bfb0b38697a4d84ef6 100644 (file)
--- a/TPC/AliTPCv3.cxx
+++ b/TPC/AliTPCv3.cxx
@@ -59,7 +59,8 @@
 ClassImp(AliTPCv3)
 //_____________________________________________________________________________
 
-  AliTPCv3::AliTPCv3(){
+  AliTPCv3::AliTPCv3():AliTPC(),fIdSens(0)
+{
 
   fHitType = 1;
 
@@ -67,15 +68,13 @@ ClassImp(AliTPCv3)
 
 //_____________________________________________________________________________
 AliTPCv3::AliTPCv3(const char *name, const char *title) :
-  AliTPC(name, title) 
+  AliTPC(name, title), fIdSens(0)
 {
   //
   // Standard constructor for Time Projection Chamber version 3
   //
 
   SetBufferSize(128000);
-  fIdSens=0;
-
 
   if (fTPCParam)
      fTPCParam->Write(fTPCParam->GetTitle());