Fixes for some mem-leaks: most changes where pretty basic (i.e. adding deletes).
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Sep 2007 06:48:11 +0000 (06:48 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Sep 2007 06:48:11 +0000 (06:48 +0000)
In some cases affecting AliESDEvent and AliTPCtrackerMI memory leaks introduced by placement-new were fixed. The placement-new sometimes overwrote pointers to memory allocated by the class itself.The placement-new was replaced with assigments where it was considered appropiate (for this some operator= were modified) or an explicit call to the destructor before was used.

Christian

21 files changed:
HMPID/AliHMPIDCluster.cxx
ITS/AliITStrackerMI.cxx
PHOS/AliPHOSTrigger.cxx
PHOS/AliPHOSTrigger.h
PMD/AliPMDEmpDiscriminator.cxx
PMD/AliPMDtracker.cxx
STEER/AliESDCaloTrigger.cxx
STEER/AliESDEvent.cxx
STEER/AliESDFMD.cxx
STEER/AliESDVertex.cxx
STEER/AliKalmanTrack.cxx
STEER/AliKalmanTrack.h
STEER/AliMagFMaps.cxx
STEER/AliMultiplicity.cxx
STEER/AliVertex.cxx
TPC/AliComplexCluster.cxx
TPC/AliComplexCluster.h
TPC/AliTPCseed.cxx
TPC/AliTPCtrack.cxx
TPC/AliTPCtrack.h
TPC/AliTPCtrackerMI.cxx

index 7ce3a5d..28db82b 100644 (file)
@@ -144,7 +144,7 @@ void AliHMPIDCluster::FitFunc(Int_t &iNpars, Double_t* deriv, Double_t &chi2, Do
     }
   }
   //delete array...
-  for(Int_t i=0;i<iNpars;i++) delete derivPart[i]; delete derivPart;
+  for(Int_t i=0;i<iNpars;i++) delete [] derivPart[i]; delete [] derivPart;
   
 }//FitFunction()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
index ec10d2b..9599f79 100644 (file)
@@ -4438,6 +4438,7 @@ void  AliITStrackerMI::FindV02(AliESDEvent *event)
   //
   // delete temporary arrays
   //  
+  delete[] forbidden;
   delete[] minPointAngle;
   delete[] maxr;
   delete[] minr;
index 596ae18..5e5d539 100644 (file)
@@ -121,6 +121,17 @@ AliPHOSTrigger::AliPHOSTrigger(const AliPHOSTrigger & trig) :
   // cpy ctor
 }
 
+AliPHOSTrigger::~AliPHOSTrigger() 
+{
+  // dtor
+  
+  if(fADCValuesHighnxn)delete [] fADCValuesHighnxn;
+  if(fADCValuesLownxn)delete [] fADCValuesLownxn;
+  if(fADCValuesHigh2x2)delete []  fADCValuesHigh2x2;
+  if(fADCValuesLow2x2)delete [] fADCValuesLow2x2;
+  // fDigitsList is now ours...
+}
+
 //_________________________________________________________________________
 AliPHOSTrigger & AliPHOSTrigger::operator = (const AliPHOSTrigger &)
 {
@@ -555,8 +566,9 @@ void AliPHOSTrigger::SetTriggers(const TClonesArray * ampmatrix, const Int_t iMo
     //Transform digit amplitude in Raw Samples
     if (fADCValuesLow2x2 == 0) {
       fADCValuesLow2x2  = new Int_t[nTimeBins];
-      fADCValuesHigh2x2 = new Int_t[nTimeBins];
     }
+    if(!fADCValuesHigh2x2) fADCValuesHigh2x2 = new Int_t[nTimeBins];
+
     
     pulse.SetAmplitude(f2x2MaxAmp);
     pulse.SetTZero(maxtimeR2);
index c042a1a..eb93c77 100644 (file)
@@ -43,8 +43,7 @@ class AliPHOSTrigger : public AliTriggerDetector {
   
   AliPHOSTrigger() ; //  ctor
   AliPHOSTrigger(const AliPHOSTrigger & trig) ; // cpy ctor
-  virtual ~AliPHOSTrigger(){}; //virtual dtor
-
+  virtual ~AliPHOSTrigger();
 
   virtual void    CreateInputs(); //Define trigger inputs for Central Trigger Processor
   void            Print(const Option_t * opt ="") const ;  
index 562d49d..1f5de06 100644 (file)
@@ -242,6 +242,7 @@ void AliPMDEmpDiscriminator::Discrimination(TObjArray *pmdcontin, TObjArray *pmd
       delete [] adcpre;
       delete [] ncellpre;
       delete [] radpre;
+      delete [] sortcoord;
       delete [] clupidpre;
       delete [] xpadcpv;
       delete [] ypadcpv;
index 7b96263..bca4091 100644 (file)
@@ -121,6 +121,7 @@ AliPMDtracker::~AliPMDtracker()
       delete fPMDcontout;
       fPMDcontout=0;
     }
+  delete fPMDutil;
 }
 //--------------------------------------------------------------------//
 void AliPMDtracker::LoadClusters(TTree *treein)
index d0ec92c..b83fc1b 100644 (file)
@@ -51,19 +51,11 @@ AliESDCaloTrigger& AliESDCaloTrigger::operator=(const AliESDCaloTrigger& ctrig)
   if(this!=&ctrig) {
     TNamed::operator=(ctrig);
     // CKB dont't want to create leak if fTriggerAmp points to 
-    // somthing already, use new with placement
-    if(fTriggerAmplitudes){
-      fTriggerAmplitudes = new(fTriggerAmplitudes) TArrayF(*ctrig.fTriggerAmplitudes);
-    }
-    else{
-      fTriggerAmplitudes = new TArrayF(*ctrig.fTriggerAmplitudes);
-    }
-    if(fTriggerPosition){
-      fTriggerPosition = new(fTriggerPosition) TArrayF(*ctrig.fTriggerPosition);
-    }
-    else{
-      fTriggerPosition = new TArrayF(*ctrig.fTriggerPosition);
-    }
+    // something already 
+    delete fTriggerAmplitudes;
+    fTriggerAmplitudes = new TArrayF(*ctrig.fTriggerAmplitudes);
+    delete fTriggerPosition;    
+    fTriggerPosition = new TArrayF(*ctrig.fTriggerPosition);
   } 
   return *this;
 }
index 27a8b77..0460f61 100644 (file)
@@ -278,14 +278,19 @@ void AliESDEvent::ResetStdContent()
   if(fESDTZERO) fESDTZERO->Reset(); 
   // CKB no clear/reset implemented
   if(fSPDVertex){
+    fSPDVertex->~AliESDVertex();
     new (fSPDVertex) AliESDVertex();
     fSPDVertex->SetName(fESDListName[kSPDVertex]);
   }
   if(fPrimaryVertex){
+    fPrimaryVertex->~AliESDVertex();
     new (fPrimaryVertex) AliESDVertex();
     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
   }
-  if(fSPDMult)new (fSPDMult) AliMultiplicity();
+  if(fSPDMult){
+    fSPDMult->~AliMultiplicity();
+    new (fSPDMult) AliMultiplicity();
+  }
   if(fPHOSTrigger)fPHOSTrigger->Reset(); 
   if(fEMCALTrigger)fEMCALTrigger->Reset(); 
   if(fTracks)fTracks->Delete();
@@ -453,22 +458,21 @@ Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c) {
 void  AliESDEvent::SetVertex(const AliESDVertex *vertex) {
   // use already allocated space
   if(fSPDVertex){
-    new(fSPDVertex)  AliESDVertex(*vertex);
+    *fSPDVertex = *vertex;
     fSPDVertex->SetName(fESDListName[kSPDVertex]);
   }
 }
 
 void  AliESDEvent::SetPrimaryVertex(const AliESDVertex *vertex) {
-  // use already allocated space
   if(fPrimaryVertex){
-    new(fPrimaryVertex)  AliESDVertex(*vertex);
+    *fPrimaryVertex = *vertex;
     fPrimaryVertex->SetName(fESDListName[kPrimaryVertex]);
   }
 }
 
 void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) {
   if(fSPDMult){
-    new (fSPDMult) AliMultiplicity(*mul);
+    *fSPDMult = *mul;
   }
 }
 
@@ -476,7 +480,7 @@ void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul) {
 void AliESDEvent::SetFMDData(AliESDFMD * obj) { 
   // use already allocated space
   if(fESDFMD){
-    new(fESDFMD) AliESDFMD(*obj); 
+    *fESDFMD = *obj;
   }
 }
 
index 9439282..fed4be7 100755 (executable)
@@ -63,8 +63,11 @@ AliESDFMD&
 AliESDFMD::operator=(const AliESDFMD& other)
 {
   // Default CTOR
-  fMultiplicity = other.fMultiplicity;
-  fEta          = other.fEta;
+  if(this!=&other){
+    TObject::operator=(other);
+    fMultiplicity = other.fMultiplicity;
+    fEta          = other.fEta;
+  }
   return *this;
 }
 
index 6a40928..a2a320b 100644 (file)
@@ -161,26 +161,16 @@ AliESDVertex &AliESDVertex::operator=(const AliESDVertex &source){
   //
   // assignment operator
   //
-  if(&source == this) return *this;
-  this->SetName(source.GetName());
-  this->SetTitle(source.GetTitle());
-  for(Int_t i=0;i<3;i++) {
-    fPosition[i] = source.fPosition[i];
-    fSNR[i] = source.fSNR[i];
-  }
-  fCovXX = source.fCovXX;
-  fCovXY = source.fCovXY;
-  fCovYY = source.fCovYY;
-  fCovXZ = source.fCovXZ;
-  fCovYZ = source.fCovYZ;
-  fCovZZ = source.fCovZZ;
-  fChi2 = source.fChi2;
-  fSigma = source.GetDispersion();
-  fNContributors = source.GetNContributors();
-  fNIndices = source.GetNIndices();
-  if(source.fNIndices>0) {
-    fIndices = new UShort_t[fNIndices];
-    memcpy(fIndices,source.fIndices,fNIndices*sizeof(UShort_t));
+  if(&source != this){
+    AliVertex::operator=(source);
+    for(Int_t i=0;i<3;++i)fSNR[i] = source.fSNR[i];
+    fCovXX = source.fCovXX;
+    fCovXY = source.fCovXY;
+    fCovYY = source.fCovYY;
+    fCovXZ = source.fCovXZ;
+    fCovYZ = source.fCovYZ;
+    fCovZZ = source.fCovZZ;
+    fChi2 = source.fChi2;
   }
   return *this;
 }
index b3958e6..c6548e6 100644 (file)
@@ -43,7 +43,6 @@ ClassImp(AliKalmanTrack)
   for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;
 }
 
-//_______________________________________________________________________
 AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
   AliExternalTrackParam(t),
   fLab(t.fLab),
@@ -62,6 +61,21 @@ AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
       fIntegratedTime[i] = t.fIntegratedTime[i];
 }
 
+AliKalmanTrack& AliKalmanTrack::operator=(const AliKalmanTrack&o){
+  if(this!=&o){
+    AliExternalTrackParam::operator=(o);
+    fLab = o.fLab;
+    fFakeRatio = o.fFakeRatio;
+    fChi2 = o.fChi2;
+    fMass = o.fMass;
+    fN = o.fN;
+    fStartTimeIntegral = o.fStartTimeIntegral;
+    for(Int_t i = 0;i<AliPID::kSPECIES;++i)fIntegratedTime[i] = o.fIntegratedTime[i];
+    fIntegratedLength = o.fIntegratedLength;
+  }
+  return *this;
+}
+
 //_______________________________________________________________________
 void AliKalmanTrack::StartTimeIntegral() 
 {
index 82a767b..db57443 100644 (file)
@@ -23,7 +23,7 @@ public:
   AliKalmanTrack();
   AliKalmanTrack(const AliKalmanTrack &t);
   virtual ~AliKalmanTrack(){};
-
+  AliKalmanTrack& operator=(const AliKalmanTrack &o);
   void SetLabel(Int_t lab) {fLab=lab;}
 
   virtual Double_t GetPredictedChi2(const AliCluster *c) const = 0;
index 1789d15..c80bca9 100644 (file)
@@ -107,7 +107,7 @@ void AliMagFMaps::ReadField()
   //    
    
 
-  char* fname;
+  char* fname = 0;
   TFile* file = 0;
   if (fMap == k2kG) {
       fSolenoid = 2.;
@@ -116,17 +116,19 @@ void AliMagFMaps::ReadField()
       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B02"));
       file->Close();
       delete file;
+      delete fname; // see documentation to expand filenam
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB02.root");
       file = new TFile(fname);
       fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB02"));
       file->Close();
       delete file;;
-      
+      delete fname;
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB02.root");
       file = new TFile(fname);
       fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB02"));
       file->Close();
       delete file;
+      delete fname;
   } else if (fMap == k4kG) {
       fSolenoid = 4.;
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/L3B04.root");
@@ -134,16 +136,19 @@ void AliMagFMaps::ReadField()
       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B04"));
       file->Close();
       delete file;
+      delete fname;
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB04.root");
       file = new TFile(fname);
       fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB04"));
       file->Close();
+      delete fname;
       delete file;
       
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB04.root");
       file = new TFile(fname);
       fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB04"));
       file->Close();
+      delete fname;
       delete file;
   } else if (fMap == k5kG) {
       fSolenoid = 5.;
@@ -151,18 +156,20 @@ void AliMagFMaps::ReadField()
       file = new TFile(fname);
       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B05"));
       file->Close();
-      delete file;
+      delete file;      
+      delete fname;
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB05.root");
       file = new TFile(fname);
       fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB05"));
       file->Close();
       delete file;
-      
+      delete fname;
       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB05.root");
       file = new TFile(fname);
       fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB05"));
       file->Close();
       delete file;
+      delete fname;
   }
 
   if (!fL3Option) fSolenoidUser = fSolenoid;
index f8cdb3b..a92ebae 100644 (file)
@@ -17,7 +17,6 @@ AliMultiplicity::AliMultiplicity():
 
 {
   // Default Constructor
-
   fFiredChips[0] = -1;
   fFiredChips[1] = -1;
 }
@@ -55,7 +54,6 @@ AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *d
       fPhisingle[i]=ps[i];
     }
   }
-
   fFiredChips[0] = -1;
   fFiredChips[1] = -1;
 }
@@ -73,9 +71,7 @@ AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
   fPhisingle(0)
 {
   // copy constructor
-
   Duplicate(m);
-
 }
 
 //______________________________________________________________________
@@ -84,12 +80,12 @@ AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
   if(this == &m)return *this;
   ((TObject *)this)->operator=(m);
 
-  if (fTh)delete [] fTh;
-  if(fPhi)delete [] fPhi;
-  if(fDeltPhi)delete [] fDeltPhi;
-  if(fLabels)delete [] fLabels;
-  if(fThsingle)delete [] fThsingle;
-  if(fPhisingle)delete [] fPhisingle;
+  if(fTh)delete [] fTh;fTh = 0;
+  if(fPhi)delete [] fPhi;fPhi = 0; 
+  if(fDeltPhi)delete [] fDeltPhi;fDeltPhi = 0; 
+  if(fLabels)delete [] fLabels;fLabels = 0;
+  if(fThsingle)delete [] fThsingle;fThsingle = 0;
+  if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
   Duplicate(m);
 
   return *this;
@@ -100,9 +96,9 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
   // used by copy constructor and assignment operator
   fNtracks = m.fNtracks;
   if(fNtracks>0){
-    fTh = new Float_t [fNtracks];
-    fPhi = new Float_t [fNtracks];
-    fDeltPhi = new Float_t [fNtracks];
+    fTh = new Float_t[fNtracks];
+    fPhi = new Float_t[fNtracks];
+    fDeltPhi = new Float_t[fNtracks];
     fLabels = new Int_t[fNtracks];
   }
   else {
@@ -113,8 +109,8 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
   }
   fNsingle = m.fNsingle;
   if(fNsingle>0){
-    fThsingle = new Float_t [fNsingle];
-    fPhisingle = new Float_t [fNsingle];
+    fThsingle = new Float_t[fNsingle];
+    fPhisingle = new Float_t[fNsingle];
   }
   else {
     fThsingle = 0;
@@ -134,12 +130,13 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
 //______________________________________________________________________
 AliMultiplicity::~AliMultiplicity(){
   // Destructor
-  if (fTh)delete [] fTh;
-  if(fPhi)delete [] fPhi;
-  if(fDeltPhi)delete [] fDeltPhi;
-  if(fLabels)delete [] fLabels;
-  if(fThsingle)delete [] fThsingle;
-  if(fPhisingle)delete [] fPhisingle;
+  if(fTh)delete [] fTh;fTh = 0;
+  if(fPhi)delete [] fPhi;fPhi = 0; 
+  if(fDeltPhi)delete [] fDeltPhi;fDeltPhi = 0; 
+  if(fLabels)delete [] fLabels;fLabels = 0;
+  if(fThsingle)delete [] fThsingle;fThsingle = 0;
+  if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
+
 }
 
 
index 2994601..593ff60 100644 (file)
@@ -81,17 +81,18 @@ AliVertex &AliVertex::operator=(const AliVertex &source){
   //
   // assignment operator
   //
-  if(&source == this) return *this;
-  this->SetName(source.GetName());
-  this->SetTitle(source.GetTitle());
-  for(Int_t i=0;i<3;i++)fPosition[i] = source.fPosition[i];
-  fSigma = source.GetDispersion();
-  fNContributors = source.GetNContributors();
-  fNIndices = source.GetNIndices();
-  fIndices = 0x0;
-  if(source.fNIndices>0) {
-    fIndices = new UShort_t[fNIndices];
-    memcpy(fIndices,source.fIndices,fNIndices*sizeof(UShort_t));
+  if(&source != this){
+    TNamed::operator=(source);
+    for(Int_t i=0;i<3;i++)fPosition[i] = source.fPosition[i];
+    fSigma = source.GetDispersion();
+    fNContributors = source.GetNContributors();
+    fNIndices = source.GetNIndices();
+    if(fIndices)delete [] fIndices;
+    fIndices = 0;
+    if(fNIndices>0) {
+      fIndices = new UShort_t[fNIndices];
+      memcpy(fIndices,source.fIndices,fNIndices*sizeof(UShort_t));
+    }
   }
   return *this;
 }
@@ -103,6 +104,7 @@ AliVertex::~AliVertex() {
 // Default Destructor
 //
   delete [] fIndices;
+  fIndices = 0;
 }
 //--------------------------------------------------------------------------
 void AliVertex::GetXYZ(Double_t position[3]) const {
index c3e0e8e..7554a65 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.9  2006/11/06 16:07:15  kowal2
+Eff C++
+
 Revision 1.8  2004/03/30 14:09:22  kowal2
 Changes due to the coding conventions
 
@@ -102,6 +105,23 @@ Bool_t AliComplexCluster::IsSortable() const
 ClassImp(AliTPCExactPoint)
 ClassImp(AliTPCClusterPoint)
 ClassImp(AliTPCTrackerPoint)
+
+AliTPCTrackerPoint& AliTPCTrackerPoint::operator=(const AliTPCTrackerPoint& o){
+  if(this!=&o){
+    fTX = o.fTX;
+    fTY = o.fTY;
+    fTZ = o.fTZ;
+    fTAngleZ = o.fTAngleZ;
+    fTAngleY = o.fTAngleY;
+    fSigmaZ = o.fSigmaZ;
+    fSigmaY = o.fSigmaY;
+    fErrZ   = o.fErrZ;
+    fErrY   = o.fErrY;
+    fIsShared = o.fIsShared;
+  }
+  return *this;
+}
+
 ClassImp(AliTPCTrackPoint)
 ClassImp(AliTPCTrackPoint2)
 ClassImp(AliTPCTrackPointRef)
index 28e9202..7b9d57a 100644 (file)
@@ -65,6 +65,7 @@ class AliTPCTrackerPoint  {
     fErrY(0),
     fIsShared(0){}
   virtual ~AliTPCTrackerPoint(){}
+  AliTPCTrackerPoint &operator=(const AliTPCTrackerPoint& o);
   Float_t  GetX() const  {return (fTX*0.01);}
   Float_t  GetZ() const {return (fTZ*0.01);}
   Float_t  GetY() const {return (fTY*0.01);}
@@ -102,7 +103,7 @@ class AliTPCTrackerPoint  {
   UShort_t  fErrY;       // y error estimate - in  mm - 50 mum precision 
   Char_t   fIsShared;     // indicate sharing of the point between several tracks
 
-  ClassDef(AliTPCTrackerPoint,1)  
+  ClassDef(AliTPCTrackerPoint,2)  
 };
 
 class AliTPCClusterPoint  {
index 77b7b39..8c2940d 100644 (file)
@@ -239,12 +239,51 @@ AliTPCseed::~AliTPCseed(){
   for (Int_t i=0;i<160;i++) fSharedMap[i]=kFALSE;
 }
 //_________________________________________________
-AliTPCseed & AliTPCseed::operator =(const AliTPCseed & param)
+AliTPCseed & AliTPCseed::operator=(const AliTPCseed &param)
 {
   //
-  // assignment operator - dummy
+  // assignment operator 
   //
-  fRow=param.fRow;
+  if(this!=&param){
+    AliTPCtrack::operator=(param);
+    fEsd =param.fEsd; 
+    for(Int_t i = 0;i<160;++i)fClusterPointer[i] = param.fClusterPointer[i]; // this is not allocated by AliTPCSeed
+    fClusterOwner = param.fClusterOwner;
+    // leave out fPoint, they are also not copied in the copy ctor...
+    // but deleted in the dtor... strange...
+    // fPoints =
+    // fEPoints =
+    fRow            = param.fRow;
+    fSector         = param.fSector;
+    fRelativeSector = param.fRelativeSector;
+    fCurrentSigmaY2 = param.fCurrentSigmaY2;
+    fCurrentSigmaZ2 = param.fCurrentSigmaZ2;
+    fErrorY2        = param.fErrorY2;
+    fErrorZ2        = param.fErrorZ2;
+    fCurrentCluster = param.fCurrentCluster; // this is not allocated by AliTPCSeed
+    fCurrentClusterIndex1 = param.fCurrentClusterIndex1; 
+    fInDead         = param.fInDead;
+    fIsSeeding      = param.fIsSeeding;
+    fNoCluster      = param.fNoCluster;
+    fSort           = param.fSort;
+    fBSigned        = param.fBSigned;
+    for(Int_t i = 0;i<4;++i){
+      fDEDX[i]   = param.fDEDX[i];
+      fSDEDX[i]  = param.fSDEDX[i];
+      fNCDEDX[i] = param.fNCDEDX[i];
+    }
+    for(Int_t i = 0;i<AliPID::kSPECIES;++i)fTPCr[i] = param.fTPCr[i];
+    
+    fSeedType = param.fSeedType;
+    fSeed1    = param.fSeed1;
+    fSeed2    = param.fSeed2;
+    for(Int_t i = 0;i<12;++i)fOverlapLabels[i] = param.fOverlapLabels[i];
+    fMAngular = param.fMAngular;
+    fCircular = param.fCircular;
+    for(int i = 0;i<160;++i)fTrackPoints[i] =  param.fTrackPoints[i];
+    fClusterMap = param.fClusterMap;
+    fSharedMap = param.fSharedMap;
+  }
   return (*this);
 }
 //____________________________________________________
index 872afa2..fff3a83 100644 (file)
@@ -180,6 +180,33 @@ AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) :
   for (Int_t i=0; i<3;i++) fV0Indexes[i]=t.fV0Indexes[i];
 }
 
+AliTPCtrack& AliTPCtrack::operator=(const AliTPCtrack& o){
+  if(this!=&o){
+    AliKalmanTrack::operator=(o);
+    fdEdx = o.fdEdx;
+    for(Int_t i = 0;i<kMaxRow;++i)fIndex[i] = o.fIndex[i];
+    for(Int_t i = 0;i<4;++i)fPoints[i] = o.fPoints[i];
+    fSdEdx = o.fSdEdx;
+    fNFoundable = o.fNFoundable;
+    fBConstrain = o.fBConstrain;
+    fLastPoint  = o.fLastPoint;
+    fFirstPoint = o.fFirstPoint;
+    fTrackType  = o.fTrackType;
+    fLab2       = o.fLab2;
+    fNShared    = o.fNShared;
+    fReference  = o.fReference;
+    for(Int_t i = 0;i<12;++i) fKinkPoint[i] = o.fKinkPoint[i];
+
+    for(Int_t i = 0;i<3;++i){
+      fKinkIndexes[i] = o.fKinkIndexes[i];
+      fV0Indexes[i] = o.fV0Indexes[i];
+    }
+  }
+  return *this;
+
+}
+
+
 //_____________________________________________________________________________
 Int_t AliTPCtrack::Compare(const TObject *o) const {
   //-----------------------------------------------------------------
index be5d47f..e618b0c 100644 (file)
@@ -34,6 +34,7 @@ public:
               const Double_t cov[15], Int_t index); 
   AliTPCtrack(const AliESDtrack& t);
   AliTPCtrack(const AliTPCtrack& t);
+  AliTPCtrack& operator=(const AliTPCtrack& o);
   virtual ~AliTPCtrack() {}
 
   Int_t Compare(const TObject *o) const;
@@ -111,7 +112,7 @@ protected:
   Int_t    fKinkIndexes[3];     // kink indexes - minus = mother + daughter
   Int_t    fV0Indexes[3];     // kink indexes - minus = mother + daughter
 
-  ClassDef(AliTPCtrack,3)   // Time Projection Chamber reconstructed tracks
+  ClassDef(AliTPCtrack,4)   // Time Projection Chamber reconstructed tracks
 };
 
 #endif
index 55ab506..89f261e 100644 (file)
@@ -2909,7 +2909,7 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
   Double_t x[5], c[15];
   //  Int_t di = i1-i2;
   //
-  AliTPCseed * seed = new AliTPCseed;
+  AliTPCseed * seed = new AliTPCseed();
   Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
   Double_t cs=cos(alpha), sn=sin(alpha);
   //
@@ -3119,6 +3119,7 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
        //      if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
        
         UInt_t index=kr1.GetIndex(is);
+       seed->~AliTPCseed(); // this does not set the pointer to 0...
        AliTPCseed *track=new(seed) AliTPCseed(x1, ns*alpha+shift, x, c, index);
        
        track->SetIsSeeding(kTRUE);
@@ -3184,7 +3185,7 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
            }
          }
        }
-       
+      
        track->SetSeedType(0);
        arr->AddLast(track); 
        seed = new AliTPCseed;  
@@ -3407,6 +3408,7 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
       //       if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
       
       UInt_t index=kr1.GetIndex(is);
+      seed->~AliTPCseed();
       AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index);
       
       track->SetIsSeeding(kTRUE);
@@ -3686,7 +3688,8 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
 
        UInt_t index=0;
        //kr0.GetIndex(is);
-       AliTPCseed *track=new (seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
+       seed->~AliTPCseed();
+       AliTPCseed *track=new(seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
        track->SetIsSeeding(kTRUE);
        Int_t rc=FollowProlongation(*track, i2);        
        if (constrain) track->SetBConstrain(1);
@@ -4421,7 +4424,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
       if (TMath::Abs(ktrack0->GetC())>5) continue; // cut on the curvature for mother particle
       AliExternalTrackParam paramm(*ktrack0);
       AliExternalTrackParam paramd(*ktrack1);
-      if (row0>60&&ktrack1->GetReference().GetX()>90.) new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
+      if (row0>60&&ktrack1->GetReference().GetX()>90.)new (&paramd) AliExternalTrackParam(ktrack1->GetReference()); 
       //
       //
       kink->SetMother(paramm);
@@ -4562,8 +4565,8 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
        if (RefitKink(*seed0,*seed1,*kink)) kink->SetStatus(1,9);
        row0 = GetRowNumber(kink->GetR());
        sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
-       new (&mothers[i])   AliTPCseed(*seed0);
-       new (&daughters[i]) AliTPCseed(*seed1); 
+       mothers[i] = *seed0;
+       daughters[i] = *seed1;
       }
       else{
        delete kinks->RemoveAt(i);
@@ -4678,8 +4681,8 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
     //
     if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) {  //best kink
       if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){
-       new (ktrack0) AliTPCseed(mothers[indexes[i]]);
-       new (ktrack1) AliTPCseed(daughters[indexes[i]]);
+       *ktrack0 = mothers[indexes[i]];
+       *ktrack1 = daughters[indexes[i]];
       }
     }
     //
@@ -5198,8 +5201,8 @@ Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliES
   for (Int_t irow=0;irow<kNdiv;irow++){
     FollowBackProlongation(mother, rows[irow]);
     FollowProlongation(daughter,rows[kNdiv-1-irow]);       
-    new(&param0[irow])     AliTPCseed(mother);
-    new(&param1[kNdiv-1-irow])   AliTPCseed(daughter);
+    param0[irow] = mother;
+    param1[kNdiv-1-irow] = daughter;
   }
   //
   // define kinks 
@@ -5232,8 +5235,8 @@ Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliES
   param0[index].Reset(kTRUE);
   FollowProlongation(param0[index],0);
   //
-  new (&mother) AliTPCseed(param0[index]);
-  new (&daughter) AliTPCseed(param1[index]);  // daughter in vertex
+  mother = param0[index];
+  daughter = param1[index];  // daughter in vertex
   //
   kink.SetMother(mother);
   kink.SetDaughter(daughter);
@@ -5349,8 +5352,8 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   for (Int_t irow=0;irow<20;irow++){
     FollowBackProlongation(*seed0, rows[irow]);
     FollowProlongation(*seed1,rows[19-irow]);       
-    new(&param0[irow])     AliTPCseed(*seed0);
-    new(&param1[19-irow])   AliTPCseed(*seed1);
+    param0[irow] = *seed0;
+    param1[19-irow] = *seed1;
   }
   //
   // define kinks 
@@ -5386,7 +5389,7 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   seed1->ResetCovariance(10.);
   FollowProlongation(*seed0,0);
   FollowBackProlongation(*seed1,158);
-  new (&mother) AliTPCseed(*seed0);  // backup mother at position 0
+  mother = *seed0; // backup mother at position 0
   seed0->Reset(kFALSE);  
   seed1->Reset(kFALSE);
   seed0->ResetCovariance(10.);
@@ -5403,8 +5406,8 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   for (Int_t irow=0;irow<20;irow++){
     FollowBackProlongation(*seed0, rows[irow]);
     FollowProlongation(*seed1,rows[19-irow]);       
-    new(&param0[irow])     AliTPCseed(*seed0);
-    new(&param1[19-irow])   AliTPCseed(*seed1);
+    param0[irow] = *seed0;
+    param1[19-irow] = *seed1;
   }
   //
   // define kinks 
@@ -5452,11 +5455,11 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   //
   //
   //  new (&mother) AliTPCseed(param0[index]);
-  new (&daughter) AliTPCseed(param1[index]);
+  daughter = param1[index];
   daughter.SetLabel(kink.GetLabel(1));  
   param0[index].Reset(kTRUE);
   FollowProlongation(param0[index],0);  
-  new (&mother) AliTPCseed(param0[index]);
+  mother = param0[index];
   mother.SetLabel(kink.GetLabel(0));
   delete seed0;
   delete seed1;
@@ -6295,7 +6298,12 @@ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const {
   //--------------------------------------------------------------------
   //This function "cooks" a track label. If label<0, this track is fake.
   //--------------------------------------------------------------------
-  AliTPCseed * t = (AliTPCseed*)tk;
+  AliTPCseed * t = dynamic_cast<AliTPCseed*>(tk);
+  if(!t){
+    printf("%s:%d wrong type \n",(char*)__FILE__,__LINE__);
+    return;
+  }
+
   Int_t noc=t->GetNumberOfClusters();
   if (noc<10){
     //printf("\nnot founded prolongation\n\n\n");
@@ -6504,6 +6512,7 @@ void AliTPCtrackerMI::AliTPCSector::Setup(const AliTPCParam *par, Int_t f) {
      fPadPitchWidth=par->GetInnerPadPitchWidth();
      fPadPitchLength=par->GetInnerPadPitchLength();
      fN=par->GetNRowLow();
+     if(fRow)delete [] fRow;fRow = 0;
      fRow=new AliTPCRow[fN];
      for (Int_t i=0; i<fN; i++) {
        fRow[i].SetX(par->GetPadRowRadiiLow(i));
@@ -6516,8 +6525,8 @@ void AliTPCtrackerMI::AliTPCSector::Setup(const AliTPCParam *par, Int_t f) {
      fPadPitchLength = par->GetOuter1PadPitchLength();
      f1PadPitchLength = par->GetOuter1PadPitchLength();
      f2PadPitchLength = par->GetOuter2PadPitchLength();
-
      fN=par->GetNRowUp();
+     if(fRow)delete [] fRow;fRow = 0;
      fRow=new AliTPCRow[fN];
      for (Int_t i=0; i<fN; i++) {
        fRow[i].SetX(par->GetPadRowRadiiUp(i));