changes to cope with effC++
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 13 Oct 2006 17:04:06 +0000 (17:04 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 13 Oct 2006 17:04:06 +0000 (17:04 +0000)
16 files changed:
ITS/AliITSPid.cxx
ITS/AliITSPid.h
ITS/AliITSVertexerFast.cxx
ITS/AliITSVertexerIons.cxx
ITS/AliITSVertexerPPZ.cxx
ITS/AliITSVertexerTracks.cxx
ITS/AliITSVertexerTracks.h
ITS/AliITSVertexerZ.cxx
ITS/AliITSVertexerZ.h
ITS/AliITSreconstruction.cxx
ITS/AliITSreconstruction.h
ITS/AliITStrackMI.cxx
ITS/AliITStrackV2Pid.cxx
ITS/AliITStrackV2Pid.h
ITS/AliITStrackerMI.cxx
ITS/AliITStrackerMI.h

index e6a5045..8ed2704 100644 (file)
 ClassImp(AliITSPid)
 
 
-AliITSPid::AliITSPid(const AliITSPid &source) : TObject(source){
+AliITSPid::AliITSPid(const AliITSPid &source) : TObject(source),
+fMxtrs(source.fMxtrs),
+fTrs(source.fTrs),
+fWpi(source.fWpi),
+fWk(source.fWk),
+fWp(source.fWp),
+fRpik(source.fRpik),
+fRppi(source.fRppi),
+fRpka(source.fRpka),
+fRp(source.fRp),
+fPcode(source.fPcode),
+fSigmin(source.fSigmin),
+fSilent(source.fSilent),
+fCutKa(source.fCutKa),
+fCutPr(source.fCutPr),
+fggpi(source.fggpi),
+fggka(source.fggka),
+fggpr(source.fggpr){
     // Copy constructor. This is a function which is not allowed to be
-    // done: protected It exits with an error.
-    // Inputs:
-    //      AliITSPid &source  An AliITSPid class.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
 
-  Error("AliITSPid","You are not allowed to make a copy of the AliITSPid\n");
+  
 }
+  
 //______________________________________________________________________
-AliITSPid& AliITSPid::operator=(const AliITSPid& /* source */){
-    // Assignment operator. This is a function which is not allowed to be
-    // done to the ITS. It exits with an error.
-    // Inputs:
-    //      AliITSPid &source  An AliITSPid class.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-  Error("=operator","Assignment operator not allowed for this class\n");
+AliITSPid& AliITSPid::operator=(const AliITSPid& source){
+  // Assignment operator. This is a function which is not allowed to be
+  this->~AliITSPid();
+  new(this) AliITSPid(source);
   return *this;
 }
 
@@ -376,15 +380,30 @@ void AliITSPid::Reset(void)
   }
 }
 //-----------------------------------------------------------
-AliITSPid::AliITSPid(Int_t ntrack)
-{
+AliITSPid::AliITSPid(Int_t ntrack):
+fMxtrs(0),
+fTrs(0),
+fWpi(0),
+fWk(0),
+fWp(0),
+fRpik(0),
+fRppi(0),
+fRpka(0),
+fRp(0),
+fPcode(0),
+fSigmin(0.01),
+fSilent(0),
+fCutKa(0),
+fCutPr(0),
+fggpi(0),
+fggka(0),
+fggpr(0){
   //Constructor for AliITSPid class
-  fSigmin=0.01;
     fTrs = new TClonesArray("TVector",ntrack);
     TClonesArray &arr=*fTrs;
     for(Int_t i=0;i<ntrack;i++)new(arr[i])TVector(0,11);
-    fMxtrs=0;
-    //   
+     //   
     fCutKa=new TF1("fcutka","pol4",0.05,0.4);
     Double_t ka[5]={25.616, -161.59, 408.97, -462.17, 192.86};
     fCutKa->SetParameters(ka);
index 16e8152..e8e3935 100644 (file)
@@ -48,7 +48,7 @@ protected:
        // copy constructor and assignment operator are protected
        // since they are not allowed
         AliITSPid(const AliITSPid &source); // copy constructor. 
-        AliITSPid& operator=(const AliITSPid& /* source */); // = operator.
+        AliITSPid& operator=(const AliITSPid&  source); // = operator.
 
        int     Qcomp(Float_t* qa,Float_t* qb) const {return qa[0]>qb[0]?1:0;}
        Float_t Qtrm(Int_t track);
index 44be20d..21caef5 100644 (file)
@@ -35,13 +35,17 @@ ClassImp(AliITSVertexerFast)
 
 
 //______________________________________________________________________
-AliITSVertexerFast::AliITSVertexerFast():AliITSVertexer() {
+AliITSVertexerFast::AliITSVertexerFast():AliITSVertexer(),
+fSmear(0) 
+{
   // Default Constructor
   fSmear = 0;
 }
 
 //______________________________________________________________________
-AliITSVertexerFast::AliITSVertexerFast(Double_t *smear):AliITSVertexer() {
+AliITSVertexerFast::AliITSVertexerFast(Double_t *smear):AliITSVertexer(),
+fSmear(0)
+{
   // Standard constructor
   fSmear = new Double_t[3];
   for(Int_t i=0;i<3;i++)fSmear[i]=smear[i];
index c15202e..591eeae 100644 (file)
 ClassImp(AliITSVertexerIons)
   
 //______________________________________________________________________
-  AliITSVertexerIons::AliITSVertexerIons():AliITSVertexer() {
+  AliITSVertexerIons::AliITSVertexerIons():AliITSVertexer(),
+fNpThreshold(0),
+fMaxDeltaPhi(0),
+fMaxDeltaZ(0){
   // Default Constructor
 
   //fITS = 0;
@@ -39,7 +42,10 @@ ClassImp(AliITSVertexerIons)
 }
 
 //______________________________________________________________________
-AliITSVertexerIons::AliITSVertexerIons(TString fn):AliITSVertexer(fn) {
+AliITSVertexerIons::AliITSVertexerIons(TString fn):AliITSVertexer(fn),
+fNpThreshold(0),
+fMaxDeltaPhi(0),
+fMaxDeltaZ(0) {
   // Standard constructor
   
   //fITS = 0;
@@ -47,21 +53,21 @@ AliITSVertexerIons::AliITSVertexerIons(TString fn):AliITSVertexer(fn) {
   SetMaxDeltaPhi();
   SetMaxDeltaZ();
 }
-
+/*
 //______________________________________________________________________
 AliITSVertexerIons::AliITSVertexerIons(const AliITSVertexerIons &source):AliITSVertexer(source) {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
   Error("AliITSVertexerIons","Copy constructor not allowed\n");
 }
-
+*/
 //_________________________________________________________________________
-AliITSVertexerIons& AliITSVertexerIons::operator=(const AliITSVertexerIons &/*source*/) {
+//AliITSVertexerIons& AliITSVertexerIons::operator=(const AliITSVertexerIons &/*source*/) {
   // Assignment operator
   // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
+  //Error("= operator","Assignment operator not allowed\n");
+  //return *this;
+//}
 
 
 //______________________________________________________________________
index 6cef614..63c16e7 100644 (file)
@@ -36,29 +36,43 @@ ClassImp(AliITSVertexerPPZ)
 
 
 //______________________________________________________________________
-AliITSVertexerPPZ::AliITSVertexerPPZ():AliITSVertexer() {
+AliITSVertexerPPZ::AliITSVertexerPPZ():AliITSVertexer(),
+fFirstL1(0),
+fLastL1(0),
+fFirstL2(0),
+fLastL2(0),
+fDiffPhiMax(0),
+fX0(0),
+fY0(0),
+fZFound(0),
+fZsig(0),
+fWindow(0){
   // Default Constructor
 
   SetDiffPhiMax(0);
-  fX0 = 0.;
-  fY0 = 0.;
   SetFirstLayerModules(0);
   SetSecondLayerModules(0);
-  fZFound = 0;
-  fZsig = 0.;
   //fITS = 0;
   SetWindow(0);
 }
 
-AliITSVertexerPPZ::AliITSVertexerPPZ(TString fn, Float_t x0, Float_t y0):AliITSVertexer(fn) {
+AliITSVertexerPPZ::AliITSVertexerPPZ(TString fn, Float_t x0, Float_t y0):AliITSVertexer(fn),
+fFirstL1(0),
+fLastL1(0),
+fFirstL2(0),
+fLastL2(0),
+fDiffPhiMax(0),
+fX0(x0),
+fY0(y0),
+fZFound(0),
+fZsig(0),
+fWindow(0) {
   // Standard constructor
   SetDiffPhiMax();
   fX0 = x0;
   fY0 = y0;
   SetFirstLayerModules();
   SetSecondLayerModules();
-  fZFound = 0;
-  fZsig = 0.;
   //fITS = 0;
   SetWindow();
 }
index 9e44cf5..37bf244 100644 (file)
@@ -41,62 +41,78 @@ ClassImp(AliITSVertexerTracks)
 
 
 //----------------------------------------------------------------------------
-AliITSVertexerTracks::AliITSVertexerTracks():AliITSVertexer() {
+AliITSVertexerTracks::AliITSVertexerTracks():AliITSVertexer(),
+fInFile(0),
+fOutFile(0),
+fMinTracks(0),
+fMaxChi2PerTrack(0),
+fTrkArray(0),
+fTrksToSkip(0),
+fNTrksToSkip(0) {
 //
 // Default constructor
 //
-  fInFile  = 0;
-  fOutFile = 0;
   SetVtxStart();
   SetMinTracks();
-  fTrksToSkip = 0;
-  fNTrksToSkip = 0;
 
 }
 //----------------------------------------------------------------------------
 AliITSVertexerTracks::AliITSVertexerTracks(TFile *inFile,TFile *outFile,
                                            Int_t fEv,Int_t lEv,
-                                           Double_t xStart,Double_t yStart) {
+                                           Double_t xStart,Double_t yStart):
+fInFile(inFile),
+fOutFile(outFile),
+fMinTracks(0),
+fMaxChi2PerTrack(0),
+fTrkArray(0),
+fTrksToSkip(0),
+fNTrksToSkip(0) {
 //
 // Standard constructor
 //
   fCurrentVertex = 0;
-  fInFile  = inFile;
-  fOutFile = outFile;
   SetFirstEvent(fEv);
   SetLastEvent(lEv);
   SetVtxStart(xStart,yStart);
   SetMinTracks();
-  fTrksToSkip = 0;
-  fNTrksToSkip = 0;
   SetDebug();
 }
 //----------------------------------------------------------------------------
 AliITSVertexerTracks::AliITSVertexerTracks(TString fn,
                                           Double_t xStart,Double_t yStart)
-                                          :AliITSVertexer(fn) {
+                                          :AliITSVertexer(fn),
+fInFile(0),
+fOutFile(0),
+fMinTracks(0),
+fMaxChi2PerTrack(0),
+fTrkArray(0),
+fTrksToSkip(0),
+fNTrksToSkip(0) {
 //
 // Alternative constructor
 //
-  fInFile  = 0;
-  fOutFile = 0;
   SetVtxStart(xStart,yStart);
   SetMinTracks();
-  fTrksToSkip = 0;
-  fNTrksToSkip = 0;
 }
+
 //______________________________________________________________________
-AliITSVertexerTracks::AliITSVertexerTracks(const AliITSVertexerTracks &vtxr) : AliITSVertexer(vtxr) {
+AliITSVertexerTracks::AliITSVertexerTracks(const AliITSVertexerTracks &vtxr) : AliITSVertexer(vtxr),
+fInFile(vtxr.fInFile),
+fOutFile(vtxr.fOutFile),
+fMinTracks(vtxr.fMinTracks),
+fMaxChi2PerTrack(vtxr.fMaxChi2PerTrack),
+fTrkArray(vtxr.fTrkArray),
+fTrksToSkip(vtxr.fTrksToSkip),
+fNTrksToSkip(vtxr.fNTrksToSkip) {
   // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSVertexerTracks","Copy constructor not allowed\n");
+
 }
 
 //______________________________________________________________________
-AliITSVertexerTracks& AliITSVertexerTracks::operator=(const AliITSVertexerTracks& /* vtxr */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
+AliITSVertexerTracks& AliITSVertexerTracks::operator=(const AliITSVertexerTracks&  vtxr ){
+  //Assignment operator
+  this->~AliITSVertexerTracks();
+  new(this) AliITSVertexerTracks(vtxr);
   return *this;
 }
 
index 537cf9c..a5e7e68 100644 (file)
@@ -74,12 +74,12 @@ class AliITSVertexerTracks : public AliITSVertexer {
   void  SetVtxStart(Double_t x=0,Double_t y=0) 
     { fNominalPos[0]=x; fNominalPos[1]=y; return; }
   
- private:
-    // copy constructor (NO copy allowed: the constructor is protected
-    // to avoid misuse)
+ protected:
     AliITSVertexerTracks(const AliITSVertexerTracks& vtxr);
-    // assignment operator (NO assignment allowed)
-    AliITSVertexerTracks& operator=(const AliITSVertexerTracks& /* vtxr */);
+    AliITSVertexerTracks& operator=(const AliITSVertexerTracks& vtxr);
+
+ private:
+
   TFile    *fInFile;          // input file (with tracks)
   TFile    *fOutFile;         // output file for vertices
   Double_t  fNominalPos[2];   // initial knowledge on vertex position
index 5388e17..dd189ae 100644 (file)
@@ -35,18 +35,29 @@ ClassImp(AliITSVertexerZ)
 
 
 //______________________________________________________________________
-AliITSVertexerZ::AliITSVertexerZ():AliITSVertexer() {
+AliITSVertexerZ::AliITSVertexerZ():AliITSVertexer(),
+fFirstL1(0),
+fLastL1(0),
+fFirstL2(0),
+fLastL2(0),
+fDiffPhiMax(0),
+fX0(0.),
+fY0(0.),
+fZFound(0),
+fZsig(0.),
+fZCombc(0),
+fZCombv(0),
+fZCombf(0),
+fLowLim(0.),
+fHighLim(0.),
+fStepCoarse(0),
+fStepFine(0),
+fTolerance(0.),
+fMaxIter(0){
   // Default constructor
   SetDiffPhiMax(0);
-  fX0 = 0.;
-  fY0 = 0.;
   SetFirstLayerModules(0);
   SetSecondLayerModules(0);
-  fZFound = 0;
-  fZsig = 0.;
-  fZCombc = 0;
-  fZCombf = 0;
-  fZCombv = 0;
   SetLowLimit(0.);
   SetHighLimit(0.);
   SetBinWidthCoarse(0.);
@@ -57,18 +68,29 @@ AliITSVertexerZ::AliITSVertexerZ():AliITSVertexer() {
 }
 
 //______________________________________________________________________
-AliITSVertexerZ::AliITSVertexerZ(TString fn, Float_t x0, Float_t y0):AliITSVertexer(fn) {
+AliITSVertexerZ::AliITSVertexerZ(TString fn, Float_t x0, Float_t y0):AliITSVertexer(fn),
+fFirstL1(0),
+fLastL1(0),
+fFirstL2(0),
+fLastL2(0),
+fDiffPhiMax(0),
+fX0(x0),
+fY0(y0),
+fZFound(0),
+fZsig(0.),
+fZCombc(0),
+fZCombv(0),
+fZCombf(0),
+fLowLim(0.),
+fHighLim(0.),
+fStepCoarse(0),
+fStepFine(0),
+fTolerance(0.),
+fMaxIter(0) {
   // Standard Constructor
   SetDiffPhiMax();
-  fX0 = x0;
-  fY0 = y0;
   SetFirstLayerModules();
   SetSecondLayerModules();
-  fZFound = 0;
-  fZsig = 0.;
-  fZCombc = 0;
-  fZCombf = 0;
-  fZCombv = 0;
   SetLowLimit();
   SetHighLimit();
   SetBinWidthCoarse();
@@ -80,17 +102,35 @@ AliITSVertexerZ::AliITSVertexerZ(TString fn, Float_t x0, Float_t y0):AliITSVerte
 }
 
 //______________________________________________________________________
-AliITSVertexerZ::AliITSVertexerZ(const AliITSVertexerZ &vtxr) : AliITSVertexer(vtxr) {
+AliITSVertexerZ::AliITSVertexerZ(const AliITSVertexerZ &vtxr) : AliITSVertexer(vtxr),
+fFirstL1(vtxr.fFirstL1),
+fLastL1(vtxr.fLastL1),
+fFirstL2(vtxr.fFirstL2),
+fLastL2(vtxr.fLastL2),
+fDiffPhiMax(vtxr.fDiffPhiMax),
+fX0(vtxr.fX0),
+fY0(vtxr.fY0),
+fZFound(vtxr.fZFound),
+fZsig(vtxr.fZsig),
+fZCombc(vtxr.fZCombc),
+fZCombv(vtxr.fZCombv),
+fZCombf(vtxr.fZCombf),
+fLowLim(vtxr.fLowLim),
+fHighLim(vtxr.fHighLim),
+fStepCoarse(vtxr.fStepCoarse),
+fStepFine(vtxr.fStepFine),
+fTolerance(vtxr.fTolerance),
+fMaxIter(vtxr.fMaxIter) {
   // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSVertexerZ","Copy constructor not allowed\n");
+
 }
 
 //______________________________________________________________________
-AliITSVertexerZ& AliITSVertexerZ::operator=(const AliITSVertexerZ& /* vtxr */){
+AliITSVertexerZ& AliITSVertexerZ::operator=(const AliITSVertexerZ&  vtxr ){
   // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
+
+  this->~AliITSVertexerZ();
+  new(this) AliITSVertexerZ(vtxr);
   return *this;
 }
 
index 9d0945e..403d63e 100644 (file)
@@ -49,7 +49,7 @@ class AliITSVertexerZ : public AliITSVertexer {
 
  protected:
   AliITSVertexerZ(const AliITSVertexerZ& vtxr);
-  AliITSVertexerZ& operator=(const AliITSVertexerZ& /* vtxr */);
+  AliITSVertexerZ& operator=(const AliITSVertexerZ& vtxr );
   void ResetHistograms();
   void VertexZFinder(Int_t evnumber);
   Float_t GetPhiMaxIter(Int_t i) const {return fPhiDiffIter[i];}
index 92d791a..dd4dbd0 100644 (file)
@@ -36,8 +36,9 @@ AliITSreconstruction::AliITSreconstruction():
  fInit(kFALSE),
  fEnt(0),
  fEnt0(0),
- //fITS(0x0),
+ fDetTypeRec(0x0),
  fDfArp(kFALSE),
+ fITSgeom(0x0),
  fLoader(0x0),
  fRunLoader(0x0)
 {
@@ -56,8 +57,9 @@ AliITSreconstruction::AliITSreconstruction(AliRunLoader *rl):
  fInit(kFALSE),
  fEnt(0),
  fEnt0(0),
- //fITS(0x0),
+ fDetTypeRec(0x0),
  fDfArp(kFALSE),
+ fITSgeom(0x0),
  fLoader(0x0),
  fRunLoader(rl)
 {
@@ -68,8 +70,9 @@ AliITSreconstruction::AliITSreconstruction(const char* filename):
  fInit(kFALSE),
  fEnt(0),
  fEnt0(0),
- //fITS(0x0),
+ fDetTypeRec(0x0),
  fDfArp(kFALSE),
+ fITSgeom(0x0),
  fLoader(0x0),
  fRunLoader(0x0)
 {
@@ -103,19 +106,30 @@ AliITSreconstruction::AliITSreconstruction(const char* filename):
       } // end if !gAlice
 
 }
+
 //______________________________________________________________________
-AliITSreconstruction::AliITSreconstruction(const AliITSreconstruction &/*rec*/):TTask(/*rec*/){
+AliITSreconstruction::AliITSreconstruction(const AliITSreconstruction &rec):TTask(rec),
+fInit(rec.fInit),
+fEnt(rec.fEnt),
+fEnt0(rec.fEnt0),
+fDetTypeRec(rec.fDetTypeRec),
+fDfArp(rec.fDfArp),
+fITSgeom(rec.fITSgeom),
+fLoader(rec.fLoader),
+fRunLoader(rec.fRunLoader)
+{
     // Copy constructor. 
 
-  Error("Copy constructor","Copy constructor not allowed");
   
 }
+
 //______________________________________________________________________
-AliITSreconstruction& AliITSreconstruction::operator=(const AliITSreconstruction& /*source*/){
-    // Assignment operator. This is a function which is not allowed to be
-    // done.
-    Error("operator=","Assignment operator not allowed\n");
-    return *this; 
+AliITSreconstruction& AliITSreconstruction::operator=(const AliITSreconstruction& source){
+    // Assignment operator. 
+  this->~AliITSreconstruction();
+  new(this) AliITSreconstruction(source);
+  return *this;
+
 }
 
 //______________________________________________________________________
index 2501321..d1d53a8 100644 (file)
@@ -22,8 +22,6 @@ class AliITSreconstruction : public TTask{
     AliITSreconstruction(); // default constructor
     AliITSreconstruction(const char *filename); // standard constructor
     AliITSreconstruction(AliRunLoader *rl); // standard constructor
-    AliITSreconstruction(const AliITSreconstruction& rec);
-    AliITSreconstruction& operator=(const AliITSreconstruction &source);
     virtual ~AliITSreconstruction();//Destructor
     virtual Bool_t Init();
     virtual void Exec(const Option_t *opt="ALL");
@@ -31,6 +29,10 @@ class AliITSreconstruction : public TTask{
  private:
     Bool_t InitRec();  // Standard Reconstrution initilization.
  private:
+
+    AliITSreconstruction(const AliITSreconstruction& rec);
+    AliITSreconstruction& operator=(const AliITSreconstruction &source);
+
     Bool_t  fDet[3];   //! logical specifing which detectors to reconstruct.
     Bool_t  fInit;     //! True if Init was sucessfull, else false.
     Int_t   fEnt;      //! Number of events to processevent index.
index 634b6a7..b4a712f 100644 (file)
@@ -34,43 +34,44 @@ const Int_t kWARN=5;
 
 //____________________________________________________________________________
 AliITStrackMI::AliITStrackMI():AliITStrackV2(),
-  fNUsed(0),
-  fNSkipped(0),
-  fNDeadZone(0),
-  fDeadZoneProbability(0),                            
-  fReconstructed(kFALSE),
-  fConstrain(kFALSE)
+fNUsed(0),
+fNSkipped(0),
+fNDeadZone(0),
+fDeadZoneProbability(0),                              
+fReconstructed(kFALSE),
+fExpQ(40),
+fChi22(0),
+fdEdxMismatch(0),
+fConstrain(kFALSE),
+fGoldV0(kFALSE)
 {
+  //constructor
     for(Int_t i=0; i<kMaxLayer; i++) fClIndex[i]=-1;
     for(Int_t i=0; i<6; i++) { fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
     for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0; fChi2MIP[i]=0;}
     fD[0]=0; fD[1]=0;
-    fExpQ=40;
-    fdEdxMismatch=0;
-    fChi22=0;
-    fGoldV0 = kFALSE;
 }
 
 //____________________________________________________________________________
 AliITStrackMI::AliITStrackMI(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
-AliITStrackV2(t,c) {
+AliITStrackV2(t,c),
+fNUsed(0),
+fNSkipped(0),
+fNDeadZone(0),
+fDeadZoneProbability(0),                              
+fReconstructed(kFALSE),
+fExpQ(40),
+fChi22(0),
+fdEdxMismatch(0),
+fConstrain(kFALSE),
+fGoldV0(kFALSE) {
   //------------------------------------------------------------------
   // Conversion ESD track -> ITS track.
   // If c==kTRUE, create the ITS track out of the constrained params.
   //------------------------------------------------------------------
-  fNUsed = 0;
-  fReconstructed = kFALSE;
-  fNSkipped =0; 
-  fNDeadZone = 0;
-  fDeadZoneProbability = 0;
   for(Int_t i=0; i<6; i++) {fClIndex[i]=-1; fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
   for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0;fChi2MIP[i]=0;}
   fD[0]=0; fD[1]=0;
-  fExpQ=40;
-  fConstrain = kFALSE;
-  fdEdxMismatch=0;
-  fChi22 =0;
-  fGoldV0 = kFALSE;
   //if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
 
 }
@@ -81,30 +82,30 @@ void AliITStrackMI::UpdateESDtrack(ULong_t flags) {
 }
 
 //____________________________________________________________________________
-AliITStrackMI::AliITStrackMI(const AliITStrackMI& t) : AliITStrackV2(t) {
+AliITStrackMI::AliITStrackMI(const AliITStrackMI& t) : AliITStrackV2(t),
+fNUsed(t.fNUsed),
+fNSkipped(t.fNSkipped),
+fNDeadZone(t.fNDeadZone),
+fDeadZoneProbability(t.fDeadZoneProbability),                         
+fReconstructed(t.fReconstructed),
+fExpQ(t.fExpQ),
+fChi22(t.fChi22),
+fdEdxMismatch(t.fdEdxMismatch),
+fConstrain(t.fConstrain),
+fGoldV0(t.fGoldV0) {
   //------------------------------------------------------------------
   //Copy constructor
   //------------------------------------------------------------------
-  fNUsed = t.fNUsed;
-  fReconstructed = t.fReconstructed;
-  fNSkipped = t.fNSkipped;
-  fNDeadZone = t.fNDeadZone;
-  fDeadZoneProbability = t.fDeadZoneProbability;
   fLab = t.fLab;
   fFakeRatio = t.fFakeRatio;
-  fdEdxMismatch = t.fdEdxMismatch;
-  fChi22 = t.fChi22;
-  fGoldV0 = t.fGoldV0;;
 
   fD[0]=t.fD[0]; fD[1]=t.fD[1];
   fDnorm[0] = t.fDnorm[0]; fDnorm[1]=t.fDnorm[1];
-  fExpQ= t.fExpQ;
   for(Int_t i=0; i<6; i++) {
     fClIndex[i]= t.fClIndex[i]; fNy[i]=t.fNy[i]; fNz[i]=t.fNz[i]; fNormQ[i]=t.fNormQ[i]; fNormChi2[i] = t.fNormChi2[i];
   }
   for(Int_t i=0; i<12; i++) {fDy[i]=t.fDy[i]; fDz[i]=t.fDz[i]; 
     fSigmaY[i]=t.fSigmaY[i]; fSigmaZ[i]=t.fSigmaZ[i];fChi2MIP[i]=t.fChi2MIP[i];}
-  fConstrain = t.fConstrain;
   //memcpy(fDy,t.fDy,6*sizeof(Float_t));
   //memcpy(fDz,t.fDz,6*sizeof(Float_t));
   //memcpy(fSigmaY,t.fSigmaY,6*sizeof(Float_t));
index 09e81a1..a1123af 100644 (file)
@@ -1,10 +1,40 @@
 #include "AliITStrackV2Pid.h"
-
+//////////////////////////////////
+// ITS track V2 pid             //
+//                              //
+//                              //
+//////////////////////////////////
 ClassImp(AliITStrackV2Pid)
 
 
-AliITStrackV2Pid::AliITStrackV2Pid()
-{
-    fWpi=fWk=fWp=0.;
-    fPcode=0; fMom=0.; fSignal=0;
+AliITStrackV2Pid::AliITStrackV2Pid():
+fWpi(0.),
+fWk(0.),
+fWp(0.),
+fSignal(0),
+fMom(0.),
+fPhi(0),
+fLam(0),
+fPcode(0),
+fGSignal(0),
+fGMom(0),
+fGpx(0),
+fGpy(0),
+fGpz(0),
+fGx(0),
+fGy(0),
+fGz(0),
+fGcode(0),
+fGlab(0),
+fFound(0),
+fQ1(0),
+fQ2(0),
+fQ3(0),
+fQ4(0),
+fQ5(0),
+fQ6(0),
+fD(0),
+fZ(0){
+  //standard constructor
+
 }
index 4127636..3a4074c 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef ALIITSTRACKV2PID_H
 #define ALIITSTRACKV2PID_H
-
+/////////////////////////////////////////
+// ITS trackV2 pid class               //
+/////////////////////////////////////////                     
 #include <TMath.h>
 #include <Riostream.h>
 #include "AliITStrackV2.h"
index 4dcc5d0..6ead043 100644 (file)
@@ -43,8 +43,38 @@ ClassImp(AliITStrackerMI)
 
 
 AliITStrackerMI::AliITSlayer AliITStrackerMI::fgLayers[kMaxLayer]; // ITS layers
+AliITStrackerMI::AliITStrackerMI():AliTracker(),
+fI(0),
+fBestTrack(),
+fTrackToFollow(),
+fTrackHypothesys(),
+fBestHypothesys(),
+fOriginal(),
+fCurrentEsdTrack(),
+fPass(0),
+fAfterV0(kFALSE),
+fLastLayerToTrackTo(0),
+fCoeficients(0),
+fEsd(0),
+fDebugStreamer(0){
+  //Default constructor
+}
+
 
-AliITStrackerMI::AliITStrackerMI(const AliITSgeom *geom) : AliTracker() {
+AliITStrackerMI::AliITStrackerMI(const AliITSgeom *geom) : AliTracker(),
+fI(kMaxLayer),
+fBestTrack(),
+fTrackToFollow(),
+fTrackHypothesys(),
+fBestHypothesys(),
+fOriginal(),
+fCurrentEsdTrack(),
+fPass(0),
+fAfterV0(kFALSE),
+fLastLayerToTrackTo(kLastLayerToTrackTo),
+fCoeficients(0),
+fEsd(0),
+fDebugStreamer(0){
   //--------------------------------------------------------------------
   //This is the AliITStrackerMI constructor
   //--------------------------------------------------------------------
@@ -108,6 +138,31 @@ AliITStrackerMI::AliITStrackerMI(const AliITSgeom *geom) : AliTracker() {
 
 }
 
+AliITStrackerMI::AliITStrackerMI(const AliITStrackerMI &tracker):AliTracker(tracker),
+fI(tracker.fI),
+fBestTrack(tracker.fBestTrack),
+fTrackToFollow(tracker.fTrackToFollow),
+fTrackHypothesys(tracker.fTrackHypothesys),
+fBestHypothesys(tracker.fBestHypothesys),
+fOriginal(tracker.fOriginal),
+fCurrentEsdTrack(tracker.fCurrentEsdTrack),
+fPass(tracker.fPass),
+fAfterV0(tracker.fAfterV0),
+fLastLayerToTrackTo(tracker.fLastLayerToTrackTo),
+fCoeficients(tracker.fCoeficients),
+fEsd(tracker.fEsd),
+fDebugStreamer(tracker.fDebugStreamer){
+  //Copy constructor
+}
+
+AliITStrackerMI & AliITStrackerMI::operator=(const AliITStrackerMI &tracker){
+  //Assignment operator
+  this->~AliITStrackerMI();
+  new(this) AliITStrackerMI(tracker);
+  return *this;
+}
+
+
 AliITStrackerMI::~AliITStrackerMI()
 {
   //
@@ -948,14 +1003,35 @@ AliITStrackerMI::AliITSlayer & AliITStrackerMI::GetLayer(Int_t layer) const
   //
   return fgLayers[layer];
 }
-AliITStrackerMI::AliITSlayer::AliITSlayer() {
+
+AliITStrackerMI::AliITSlayer::AliITSlayer():
+fR(0),
+fPhiOffset(0),
+fNladders(0),
+fZOffset(0),
+fNdetectors(0),
+fDetectors(0),
+fN(0),
+fDy5(0),
+fDy10(0),
+fDy20(0),
+fClustersCs(0),
+fClusterIndexCs(0),
+fYcs(0),
+fZcs(0),
+fNcs(0),
+fCurrentSlice(-1),
+fZmax(0),
+fYmin(0),
+fYmax(0),
+fI(0),
+fImax(0),
+fSkip(0),
+fAccepted(0),
+fRoad(0){
   //--------------------------------------------------------------------
   //default AliITSlayer constructor
   //--------------------------------------------------------------------
-  fN=0;
-  fDetectors=0;
-  fSkip = 0;
-  fCurrentSlice=-1;
   for (Int_t i=0; i<kMaxClusterPerLayer;i++) {
     fClusterWeight[i]=0;
     fClusterTracks[0][i]=-1;
@@ -966,20 +1042,67 @@ AliITStrackerMI::AliITSlayer::AliITSlayer() {
 }
 
 AliITStrackerMI::AliITSlayer::
-AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd) {
+AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd):
+fR(r),
+fPhiOffset(p),
+fNladders(nl),
+fZOffset(z),
+fNdetectors(nd),
+fDetectors(0),
+fN(0),
+fDy5(0),
+fDy10(0),
+fDy20(0),
+fClustersCs(0),
+fClusterIndexCs(0),
+fYcs(0),
+fZcs(0),
+fNcs(0),
+fCurrentSlice(-1),
+fZmax(0),
+fYmin(0),
+fYmax(0),
+fI(0),
+fImax(0),
+fSkip(0),
+fAccepted(0),
+fRoad(0) {
   //--------------------------------------------------------------------
   //main AliITSlayer constructor
   //--------------------------------------------------------------------
-  fR=r; fPhiOffset=p; fZOffset=z;
-  fNladders=nl; fNdetectors=nd;
   fDetectors=new AliITSdetector[fNladders*fNdetectors];
-
-  fN=0;
-  fI=0;
-  fSkip = 0;
   fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster
 }
 
+AliITStrackerMI::AliITSlayer::AliITSlayer(const AliITSlayer& layer):
+fR(layer.fR),
+fPhiOffset(layer.fPhiOffset),
+fNladders(layer.fNladders),
+fZOffset(layer.fZOffset),
+fNdetectors(layer.fNdetectors),
+fDetectors(layer.fDetectors),
+fN(layer.fN),
+fDy5(layer.fDy5),
+fDy10(layer.fDy10),
+fDy20(layer.fDy20),
+fClustersCs(layer.fClustersCs),
+fClusterIndexCs(layer.fClusterIndexCs),
+fYcs(layer.fYcs),
+fZcs(layer.fZcs),
+fNcs(layer.fNcs),
+fCurrentSlice(layer.fCurrentSlice),
+fZmax(layer.fZmax),
+fYmin(layer.fYmin),
+fYmax(layer.fYmax),
+fI(layer.fI),
+fImax(layer.fImax),
+fSkip(layer.fSkip),
+fAccepted(layer.fAccepted),
+fRoad(layer.fRoad){
+  //Copy constructor
+}
+
+
 AliITStrackerMI::AliITSlayer::~AliITSlayer() {
   //--------------------------------------------------------------------
   // AliITSlayer destructor
index dc0b784..1d443e7 100644 (file)
@@ -25,9 +25,9 @@ class AliITSgeom;
 //-------------------------------------------------------------------------
 class AliITStrackerMI : public AliTracker {
 public:
-  AliITStrackerMI():AliTracker(){}
+  AliITStrackerMI();
   AliITStrackerMI(const AliITSgeom *geom);
-  ~AliITStrackerMI();
+  virtual ~AliITStrackerMI();
   AliCluster *GetCluster(Int_t index) const;
   virtual Bool_t GetTrackPoint(Int_t index, AliTrackPoint& p) const;
   AliITSRecPoint *GetClusterLayer(Int_t layn, Int_t ncl) const
@@ -56,9 +56,8 @@ public:
   Int_t UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t layer) const;
   class AliITSdetector { 
   public:
-    AliITSdetector(){}
-    AliITSdetector(Double_t r,Double_t phi) {fR=r; fPhi=phi; fSinPhi = TMath::Sin(phi); fCosPhi = TMath::Cos(phi);
-    fYmin=10000;fYmax=-1000; fZmin=10000;fZmax=-1000;}
+    AliITSdetector():fR(0),fPhi(0),fSinPhi(0),fCosPhi(0),fYmin(0),fYmax(0),fZmin(0),fZmax(0){}
+    AliITSdetector(Double_t r,Double_t phi):fR(r),fPhi(phi),fSinPhi(TMath::Sin(phi)),fCosPhi(TMath::Cos(phi)),fYmin(10000),fYmax(-1000),fZmin(10000),fZmax(-1000) {}
     inline void GetGlobalXYZ( const AliITSRecPoint *cl, Double_t xyz[3]) const;
     Double_t GetR()   const {return fR;}
     Double_t GetPhi() const {return fPhi;}
@@ -112,8 +111,10 @@ public:
     Int_t GetClusterTracks(Int_t i, Int_t j) const {return fClusterTracks[i][j];}
     void SetClusterTracks(Int_t i, Int_t j, Int_t c) {fClusterTracks[i][j]=c;}
   protected:
-    AliITSlayer(const AliITSlayer& /*layer*/);
-    AliITSlayer & operator=(const AliITSlayer& /*layer*/);
+    AliITSlayer(const AliITSlayer& layer);
+    AliITSlayer & operator=(const AliITSlayer& layer){
+      this->~AliITSlayer();new(this) AliITSlayer(layer);
+      return *this;}
     Double_t fR;                // mean radius of this layer
     Double_t fPhiOffset;        // offset of the first detector in Phi
     Int_t fNladders;            // number of ladders
@@ -233,8 +234,8 @@ protected:
   AliESD  * fEsd;                        //! pointer to the ESD event
   TTreeSRedirector *fDebugStreamer;     //!debug streamer
 private:
-  AliITStrackerMI(const AliITStrackerMI &);
-  AliITStrackerMI & operator=(const AliITStrackerMI &);
+  AliITStrackerMI(const AliITStrackerMI &tracker);
+  AliITStrackerMI & operator=(const AliITStrackerMI &tracker);
   ClassDef(AliITStrackerMI,2)   //ITS tracker MI
 };