Eff C++
authorkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 6 Nov 2006 16:07:16 +0000 (16:07 +0000)
committerkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 6 Nov 2006 16:07:16 +0000 (16:07 +0000)
59 files changed:
TPC/AliClusters.cxx
TPC/AliClusters.h
TPC/AliClustersArray.cxx
TPC/AliComplexCluster.cxx
TPC/AliComplexCluster.h
TPC/AliDetectorParam.cxx
TPC/AliDetectorParam.h
TPC/AliDigits.cxx
TPC/AliDigitsArray.cxx
TPC/AliDigitsArray.h
TPC/AliSegmentArray.cxx
TPC/AliSegmentID.cxx
TPC/AliSegmentID.h
TPC/AliSimDigits.cxx
TPC/AliSimDigits.h
TPC/AliTPC.cxx
TPC/AliTPC.h
TPC/AliTPCBuffer.cxx
TPC/AliTPCBuffer.h
TPC/AliTPCCalROC.cxx
TPC/AliTPCCalROC.h
TPC/AliTPCDDLRawData.cxx
TPC/AliTPCDDLRawData.h
TPC/AliTPCDigitizer.cxx
TPC/AliTPCDigitsArray.cxx
TPC/AliTPCFast.cxx
TPC/AliTPCFast.h
TPC/AliTPCPRF2D.cxx
TPC/AliTPCParam.cxx
TPC/AliTPCParamCR.cxx
TPC/AliTPCParamCR.h
TPC/AliTPCParamSR.cxx
TPC/AliTPCParamSR.h
TPC/AliTPCPid.cxx
TPC/AliTPCPid.h
TPC/AliTPCRF1D.cxx
TPC/AliTPCROC.cxx
TPC/AliTPCROC.h
TPC/AliTPCTrackHitsV2.cxx
TPC/AliTPCTrackHitsV2.h
TPC/AliTPCcalibDB.h
TPC/AliTPCcluster.cxx
TPC/AliTPCcluster.h
TPC/AliTPCclusterer.cxx
TPC/AliTPCclusterer.h
TPC/AliTPCdigit.cxx
TPC/AliTPCdigit.h
TPC/AliTPCkineGrid.cxx
TPC/AliTPCkineGrid.h
TPC/AliTPCpidESD.cxx
TPC/AliTPCpidESD.h
TPC/AliTPCpolyTrack.cxx
TPC/AliTPCseed.cxx
TPC/AliTPCseed.h
TPC/AliTPCtrackPid.cxx
TPC/AliTPCtrackerParam.cxx
TPC/AliTPCtrackerParam.h
TPC/AliTPCv1.cxx
TPC/AliTPCv3.cxx

index 189a801..085f14d 100644 (file)
@@ -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()
 {
index c3013f1..0aef7d4 100644 (file)
@@ -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); 
index 253834e..d17c807 100644 (file)
 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) 
index 24a01ca..c3e0e8e 100644 (file)
@@ -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)
-
+  //_______________________________________________________________
 
index f062b3e..28e9202 100644 (file)
 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
index a4a66ff..e78ac8d 100644 (file)
 #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)
 {
index 577888c..11e61fe 100644 (file)
@@ -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
index bcb170a..9dc1762 100644 (file)
 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));
index 192b3c3..086c1ad 100644 (file)
@@ -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;
index 44f9100..d0e69fc 100644 (file)
@@ -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;} 
index bf1db26..aff6381 100644 (file)
 //_____________________________________________________________________________
 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
index 9e5a4c1..c93259b 100644 (file)
@@ -25,8 +25,6 @@
 
 
 #include "AliSegmentID.h"
-AliSegmentID::AliSegmentID()
-{
-}
+
 
 ClassImp(AliSegmentID)
index 3da7ee3..8fd0ea8 100644 (file)
@@ -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:
index 72ac338..6340493 100644 (file)
 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() 
 { 
   //
index 14b269a..43a1091 100644 (file)
@@ -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();}
index fd11f41..50a64d0 100644 (file)
 
 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
index cfb1dcd..ae46b86 100644 (file)
@@ -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;}
index 247c9d0..2c459b6 100644 (file)
 
 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;
index 8bd8ff7..bd110ad 100644 (file)
@@ -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)
 };
 
index 5e53a06..81d4392 100644 (file)
@@ -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()
index 12e35d5..2f38dcd 100644 (file)
@@ -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;};
index 5bb95a4..a248730 100644 (file)
@@ -37,7 +37,8 @@ ClassImp(AliTPCDDLRawData)
 ////////////////////////////////////////////////////////////////////////////////////////
 
 AliTPCDDLRawData::AliTPCDDLRawData(const AliTPCDDLRawData &source):
-  TObject(source)
+  TObject(source),
+  fVerbose(0)
 {
   // Copy Constructor
   fVerbose=source.fVerbose;
index d2bcf6f..b8a294e 100644 (file)
@@ -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.
index fb7e1bb..da806e1 100644 (file)
 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");
 }
 
index 65b8b75..88513d4 100644 (file)
 ClassImp(AliTPCDigitsArray) 
 
 AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
+                  :AliDigitsArray(),
+                  fBSim(kFALSE),
+                  fCompression(0),
+                  fTrackLevel(0)
 {
   //
   //default constructor
index 96801e8..09ee167 100644 (file)
 #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
index 82a56b1..b20dfbd 100644 (file)
@@ -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,
index 81cee46..929faee 100644 (file)
@@ -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);
index fd82bd4..cedd07c 100644 (file)
@@ -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();  
 }
index 28b1079..42a4cb2 100644 (file)
@@ -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()
 {
   //
index f6deb3e..bc0ced4 100644 (file)
@@ -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 
index f3c35f8..77ad0cf 100644 (file)
@@ -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()
 {
index 8dac3fc..a914eb3 100644 (file)
@@ -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);
index e588c06..5cb6ff7 100644 (file)
@@ -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);
index 4d69586..5833691 100644 (file)
@@ -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);
index dd1c4c2..d869ce0 100644 (file)
@@ -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.)
 {
   
   //
index 1b8c39d..c4bb00e 100644 (file)
@@ -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()
 {
index 9219307..231dfb5 100644 (file)
@@ -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();
 
index 6639834..6d3f95a 100644 (file)
@@ -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++;
 
index 225bb19..d3853d1 100644 (file)
@@ -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);}
index 72da2c2..25fa91a 100644 (file)
@@ -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);   
index 69296d0..4d9a325 100644 (file)
 #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)
 {
index 2b83bfe..f3bfaaf 100644 (file)
@@ -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;}
 
index e511bdf..f2e5815 100644 (file)
 
 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
index 3835d94..06b8d21 100644 (file)
@@ -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:
index 97ff00b..ab0876e 100644 (file)
 
 
 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
index 2ca2f4e..d3e9ad5 100644 (file)
@@ -20,7 +20,7 @@ public:
    Int_t     fSignal;     //Signal amplitude
  
 public:
-   AliTPCdigit() {}
+   AliTPCdigit();
    AliTPCdigit(Int_t *tracks, Int_t *digits);
    virtual ~AliTPCdigit() {}
  
index 6ea8059..0ec62f7 100644 (file)
 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 {
 //--------------------------------------------------------------------------
index 72f6f23..aab4d1c 100644 (file)
@@ -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;
index 1b43f43..460278f 100644 (file)
 ClassImp(AliTPCpidESD)
 
 //_________________________________________________________________________
-AliTPCpidESD::AliTPCpidESD(Double_t *param)
+  AliTPCpidESD::AliTPCpidESD(Double_t *param):
+    fMIP(0.),
+    fRes(0.),
+    fRange(0.)
 {
   //
   //  The main constructor
index 1b39af6..0e74ad2 100644 (file)
@@ -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);
index da9d788..20fc399 100644 (file)
@@ -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();
 }
index bdfaa40..536f551 100644 (file)
@@ -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)
 {
   //
index 2acec0c..a4941aa 100644 (file)
@@ -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;
index acdbfdc..5a01514 100644 (file)
 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
+  //
 }
index bd4c3c7..413bc5d 100644 (file)
@@ -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.);
index d790347..0b8be8a 100644 (file)
@@ -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);
index d016aea..0209c58 100644 (file)
@@ -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)
index a3deb7b..a6119da 100644 (file)
@@ -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());