implementation of effc++

diff --git a/PMD/AliPMDBlockHeader.cxx b/PMD/AliPMDBlockHeader.cxx
index 8c82afa0f3968e43d909a3dba658099c7d7f6c0b..bae4812247e164ab0eae788cdefd18c77529338c 100644 (file)
--- a/PMD/AliPMDBlockHeader.cxx
+++ b/PMD/AliPMDBlockHeader.cxx
@@ -50,21 +50,21 @@ AliPMDBlockHeader::~AliPMDBlockHeader()
 }
 
 //___________________________________________
 }
 
 //___________________________________________

-AliPMDBlockHeader::AliPMDBlockHeader(const AliPMDBlockHeader & blockh)
-  :  TObject()
+AliPMDBlockHeader::AliPMDBlockHeader(const AliPMDBlockHeader & blockh):
+  TObject(),
+  fTotalLength(blockh.fTotalLength),
+  fRawDataLength(blockh.fRawDataLength),
+  fDspId(blockh.fDspId),
+  fTrWord1(blockh.fTrWord1),
+  fTrWord2(blockh.fTrWord2),
+  fTrWord3(blockh.fTrWord3),
+  fTrWord4(blockh.fTrWord4),
+  fPadWord(blockh.fPadWord)

 {
   //
   // copy ctor
   //
 
 {
   //
   // copy ctor
   //
 

-  fTotalLength = blockh.fTotalLength;
-  fRawDataLength      = blockh.fRawDataLength;
-  fDspId       = blockh.fDspId;
-  fTrWord1     = blockh.fTrWord1;
-  fTrWord2     = blockh.fTrWord2;
-  fTrWord3     = blockh.fTrWord3;
-  fTrWord4     = blockh.fTrWord4;
-  fPadWord     = blockh.fPadWord;

 }
 
 //___________________________________________
 }
 
 //___________________________________________


@@ -74,17 +74,17 @@ AliPMDBlockHeader::operator=(const AliPMDBlockHeader &blockh)
   // 
   // assignment operator
   //
   // 
   // assignment operator
   //

-  if (this == &blockh) return *this;
-
-  fTotalLength = blockh.fTotalLength;
-  fRawDataLength      = blockh.fRawDataLength;
-  fDspId       = blockh.fDspId;
-  fTrWord1     = blockh.fTrWord1;
-  fTrWord2     = blockh.fTrWord2;
-  fTrWord3     = blockh.fTrWord3;
-  fTrWord4     = blockh.fTrWord4;
-  fPadWord     = blockh.fPadWord;
-
+  if (this != &blockh)
+    {
+      fTotalLength   = blockh.fTotalLength;
+      fRawDataLength = blockh.fRawDataLength;
+      fDspId         = blockh.fDspId;
+      fTrWord1       = blockh.fTrWord1;
+      fTrWord2       = blockh.fTrWord2;
+      fTrWord3       = blockh.fTrWord3;
+      fTrWord4       = blockh.fTrWord4;
+      fPadWord       = blockh.fPadWord;
+    }

   return *this;
 }
 void AliPMDBlockHeader::SetHeader(Int_t *header)
   return *this;
 }
 void AliPMDBlockHeader::SetHeader(Int_t *header)

diff --git a/PMD/AliPMDCalibrator.cxx b/PMD/AliPMDCalibrator.cxx
index 4d2c50ffd00ed62df5d347bee74776adc7b48a6b..106076a52750c8b24a76d772f2aa145babff86ba 100644 (file)
--- a/PMD/AliPMDCalibrator.cxx
+++ b/PMD/AliPMDCalibrator.cxx
@@ -47,12 +47,10 @@ const Int_t kMaxSMN = 24;
 const Int_t kMaxRow =96;
 const Int_t kMaxCol =96;
 
 const Int_t kMaxRow =96;
 const Int_t kMaxCol =96;
 

-AliPMDCalibrator::AliPMDCalibrator()
+AliPMDCalibrator::AliPMDCalibrator():
+  fCalibData(new AliPMDCalibData())

 {
   // Standard Constructor
 {
   // Standard Constructor

-
-  fCalibData = new AliPMDCalibData();
-  

   for(Int_t d=0;d<2;d++)
     {
       for(Int_t i=0;i<24;i++)
   for(Int_t d=0;d<2;d++)
     {
       for(Int_t i=0;i<24;i++)


@@ -70,7 +68,52 @@ AliPMDCalibrator::AliPMDCalibrator()
     }
 }
 // ------------------------------------------------------------------------ //
     }
 }
 // ------------------------------------------------------------------------ //

+AliPMDCalibrator::AliPMDCalibrator(const AliPMDCalibrator &pmdcalibrator):
+  fCalibData(new AliPMDCalibData())
+{
+  for(Int_t d=0;d<2;d++)
+    {
+      for(Int_t i=0;i<24;i++)
+       {
+         fHsmIso[d][i] = pmdcalibrator.fHsmIso[d][i] ;
+         for(Int_t j=0;j<96;j++)
+           {
+             for(Int_t k=0;k<96;k++)
+               {
+                 fGainFact[d][i][j][k] = pmdcalibrator.fGainFact[d][i][j][k];
+                 fHadcIso[d][i][j][k]  = pmdcalibrator.fHadcIso[d][i][j][k];
+               }
+           }
+       }
+    }

 
 

+}
+// ------------------------------------------------------------------------ //
+AliPMDCalibrator &AliPMDCalibrator::operator=(const AliPMDCalibrator &pmdcalibrator)
+{
+  if(this != &pmdcalibrator)
+    {
+      for(Int_t d=0;d<2;d++)
+       {
+         for(Int_t i=0;i<24;i++)
+           {
+             fHsmIso[d][i] = pmdcalibrator.fHsmIso[d][i] ;
+             for(Int_t j=0;j<96;j++)
+               {
+                 for(Int_t k=0;k<96;k++)
+                   {
+                     fGainFact[d][i][j][k] =
+                       pmdcalibrator.fGainFact[d][i][j][k];
+                     fHadcIso[d][i][j][k]  =
+                       pmdcalibrator.fHadcIso[d][i][j][k];
+                   }
+               }
+           }
+       }
+    }
+  return *this;
+}
+// ------------------------------------------------------------------------ //

 AliPMDCalibrator::~AliPMDCalibrator()
 {
   // dtor
 AliPMDCalibrator::~AliPMDCalibrator()
 {
   // dtor

diff --git a/PMD/AliPMDCalibrator.h b/PMD/AliPMDCalibrator.h
index 81e00770dbfea7fc62b59a35950a9139c2fad780..23b09d500824ab6a2480555fb7535a9abf00ce44 100644 (file)
--- a/PMD/AliPMDCalibrator.h
+++ b/PMD/AliPMDCalibrator.h
@@ -13,6 +13,9 @@ class AliPMDCalibrator
 {
  public:
   AliPMDCalibrator() ;              // ctor
 {
  public:
   AliPMDCalibrator() ;              // ctor

+  AliPMDCalibrator(const AliPMDCalibrator &pmdcalibrator);  // copy constructor
+  AliPMDCalibrator &operator=(const AliPMDCalibrator &pmdcalibrator); // assignment op
+

   virtual ~AliPMDCalibrator() ;     // dtor
   virtual void Exec();
   void CalculateIsoCell();          //calculates gains
   virtual ~AliPMDCalibrator() ;     // dtor
   virtual void Exec();
   void CalculateIsoCell();          //calculates gains


@@ -25,6 +28,6 @@ class AliPMDCalibrator
   TH1F *fHadcIso[2][24][96][96];    // histos of isolated cells cellwise
   AliPMDCalibData *fCalibData;
 
   TH1F *fHadcIso[2][24][96][96];    // histos of isolated cells cellwise
   AliPMDCalibData *fCalibData;
 

-ClassDef(AliPMDCalibrator,1)        // description 
+ClassDef(AliPMDCalibrator,2)        // description 

 };
 #endif // AliPMDCALIBRATOR_H
 };
 #endif // AliPMDCALIBRATOR_H

diff --git a/PMD/AliPMDClusterFinder.cxx b/PMD/AliPMDClusterFinder.cxx
index 36b1bb10a9d972d88c6c0a5e19972bb1ea8e5a8c..439ed43580f991f5da1a6af547324d55558456ea 100644 (file)
--- a/PMD/AliPMDClusterFinder.cxx
+++ b/PMD/AliPMDClusterFinder.cxx
@@ -53,6 +53,7 @@ ClassImp(AliPMDClusterFinder)
 AliPMDClusterFinder::AliPMDClusterFinder():
   fRunLoader(0),
   fPMDLoader(0),
 AliPMDClusterFinder::AliPMDClusterFinder():
   fRunLoader(0),
   fPMDLoader(0),

+  fCalibData(GetCalibData()),

   fTreeD(0),
   fTreeR(0),
   fDigits(new TClonesArray("AliPMDdigit", 1000)),
   fTreeD(0),
   fTreeR(0),
   fDigits(new TClonesArray("AliPMDdigit", 1000)),


@@ -60,17 +61,18 @@ AliPMDClusterFinder::AliPMDClusterFinder():
   fRechits(new TClonesArray("AliPMDrechit", 1000)),
   fNpoint(0),
   fNhit(0),
   fRechits(new TClonesArray("AliPMDrechit", 1000)),
   fNpoint(0),
   fNhit(0),

+  fDetNo(0),

   fEcut(0.)
 {
 //
 // Constructor
 //
   fEcut(0.)
 {
 //
 // Constructor
 //

-  fCalibData = GetCalibData();

 }
 // ------------------------------------------------------------------------- //
 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
   fRunLoader(runLoader),
   fPMDLoader(runLoader->GetLoader("PMDLoader")),
 }
 // ------------------------------------------------------------------------- //
 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
   fRunLoader(runLoader),
   fPMDLoader(runLoader->GetLoader("PMDLoader")),

+  fCalibData(GetCalibData()),

   fTreeD(0),
   fTreeR(0),
   fDigits(new TClonesArray("AliPMDdigit", 1000)),
   fTreeD(0),
   fTreeR(0),
   fDigits(new TClonesArray("AliPMDdigit", 1000)),


@@ -78,12 +80,26 @@ AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
   fRechits(new TClonesArray("AliPMDrechit", 1000)),
   fNpoint(0),
   fNhit(0),
   fRechits(new TClonesArray("AliPMDrechit", 1000)),
   fNpoint(0),
   fNhit(0),

+  fDetNo(0),

   fEcut(0.)
 {
 //
 // Constructor
 //
   fEcut(0.)
 {
 //
 // Constructor
 //

-  fCalibData = GetCalibData();
+}
+// ------------------------------------------------------------------------- //
+AliPMDClusterFinder::AliPMDClusterFinder(const AliPMDClusterFinder & /*finder*/):
+  TObject(/*finder*/)
+{
+  // copy constructor
+  AliError("Copy constructor not allowed");
+}
+// ------------------------------------------------------------------------- //
+AliPMDClusterFinder &AliPMDClusterFinder::operator=(const AliPMDClusterFinder & /*finder*/)
+{
+ // assignment op
+  AliError("Assignment Operator not allowed");
+  return *this;

 }
 // ------------------------------------------------------------------------- //
 AliPMDClusterFinder::~AliPMDClusterFinder()
 }
 // ------------------------------------------------------------------------- //
 AliPMDClusterFinder::~AliPMDClusterFinder()


@@ -172,7 +188,6 @@ void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt)
          
          // CALIBRATION
          Float_t gain = fCalibData->GetGainFact(det,smn,xpos,ypos);
          
          // CALIBRATION
          Float_t gain = fCalibData->GetGainFact(det,smn,xpos,ypos);

-         

         // printf("adc = %d gain = %f\n",adc,gain);
          
          adc = adc*gain;
         // printf("adc = %d gain = %f\n",adc,gain);
          
          adc = adc*gain;

diff --git a/PMD/AliPMDClusterFinder.h b/PMD/AliPMDClusterFinder.h
index f9a2a216d2566c4cc234dec8df38337cae879dc4..720c242c76d2b1839833692a273b18265a4c9c1e 100644 (file)
--- a/PMD/AliPMDClusterFinder.h
+++ b/PMD/AliPMDClusterFinder.h
@@ -27,6 +27,8 @@ class AliPMDClusterFinder : public TObject
 
   AliPMDClusterFinder();
   AliPMDClusterFinder(AliRunLoader* runLoader);
 
   AliPMDClusterFinder();
   AliPMDClusterFinder(AliRunLoader* runLoader);

+  AliPMDClusterFinder(const AliPMDClusterFinder &finder);  // copy constructor
+  AliPMDClusterFinder &operator=(const AliPMDClusterFinder &finder); // assignment op

   virtual ~AliPMDClusterFinder();
 
   void Digits2RecPoints(Int_t ievt);
   virtual ~AliPMDClusterFinder();
 
   void Digits2RecPoints(Int_t ievt);


@@ -67,7 +69,7 @@ class AliPMDClusterFinder : public TObject
   static const Int_t fgkCol = 96; // Total number of cols in one unitmodule
   Double_t fCellADC[fgkRow][fgkCol]; // Array containing individual cell ADC
 
   static const Int_t fgkCol = 96; // Total number of cols in one unitmodule
   Double_t fCellADC[fgkRow][fgkCol]; // Array containing individual cell ADC
 

-  ClassDef(AliPMDClusterFinder,9) // To run PMD clustering
+  ClassDef(AliPMDClusterFinder,10) // To run PMD clustering

 };
 #endif
 
 };
 #endif
 

diff --git a/PMD/AliPMDClusteringV1.cxx b/PMD/AliPMDClusteringV1.cxx
index 2a15ac3a70db232a74f6777611f0deee72641388..24c30038b88c8796dcf7292c448dde869e968044 100644 (file)
--- a/PMD/AliPMDClusteringV1.cxx
+++ b/PMD/AliPMDClusteringV1.cxx
@@ -54,6 +54,7 @@ ClassImp(AliPMDClusteringV1)
 const Double_t AliPMDClusteringV1::fgkSqroot3by2=0.8660254;  // sqrt(3.)/2.
 
 AliPMDClusteringV1::AliPMDClusteringV1():
 const Double_t AliPMDClusteringV1::fgkSqroot3by2=0.8660254;  // sqrt(3.)/2.
 
 AliPMDClusteringV1::AliPMDClusteringV1():

+  fClno(0),

   fCutoff(0.0)
 {
   for(int i = 0; i < kNDIMX; i++)
   fCutoff(0.0)
 {
   for(int i = 0; i < kNDIMX; i++)

diff --git a/PMD/AliPMDClusteringV2.cxx b/PMD/AliPMDClusteringV2.cxx
index d8f446d61df7c7a361b2e23ef9f2344f9890e45e..8fd20829e15e7d072caa2b0702a70966eab90204 100644 (file)
--- a/PMD/AliPMDClusteringV2.cxx
+++ b/PMD/AliPMDClusteringV2.cxx
@@ -51,6 +51,7 @@ ClassImp(AliPMDClusteringV2)
 const Double_t AliPMDClusteringV2::fgkSqroot3by2=0.8660254;  // sqrt(3.)/2.
 
 AliPMDClusteringV2::AliPMDClusteringV2():
 const Double_t AliPMDClusteringV2::fgkSqroot3by2=0.8660254;  // sqrt(3.)/2.
 
 AliPMDClusteringV2::AliPMDClusteringV2():

+  fClno(0),

   fCutoff(0.0)
 {
   for(int i = 0; i < kNDIMX; i++)
   fCutoff(0.0)
 {
   for(int i = 0; i < kNDIMX; i++)

diff --git a/PMD/AliPMDDDLRawData.cxx b/PMD/AliPMDDDLRawData.cxx
index 7b611bf1719b6921736db110c8e61360d4a957d4..2ff1de970b15c322c695e3f7b7028870f3bc786b 100644 (file)
--- a/PMD/AliPMDDDLRawData.cxx
+++ b/PMD/AliPMDDDLRawData.cxx
@@ -38,6 +38,24 @@ AliPMDDDLRawData::AliPMDDDLRawData():
   //
 
 }
   //
 
 }

+//____________________________________________________________________________
+AliPMDDDLRawData::AliPMDDDLRawData(const AliPMDDDLRawData& ddlraw):
+  TObject(ddlraw),
+  fDigits(ddlraw.fDigits)
+{
+  //Copy Constructor 
+}
+//____________________________________________________________________________
+AliPMDDDLRawData & AliPMDDDLRawData::operator=(const AliPMDDDLRawData& ddlraw)
+{
+  //Assignment operator 
+  if(this != &ddlraw)
+    {
+      fDigits = ddlraw.fDigits;
+    }
+  return *this;
+}
+

 //____________________________________________________________________________
 
 AliPMDDDLRawData::~AliPMDDDLRawData()
 //____________________________________________________________________________
 
 AliPMDDDLRawData::~AliPMDDDLRawData()


@@ -401,6 +419,9 @@ void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
   Int_t nentries = fDigits->GetLast();
   Int_t totword = nentries+1;
 
   Int_t nentries = fDigits->GetLast();
   Int_t totword = nentries+1;
 

+  AliPMDdigit *fPMDdigit;
+
+

   for (Int_t ient = 0; ient < totword; ient++)
     {
       fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
   for (Int_t ient = 0; ient < totword; ient++)
     {
       fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);

diff --git a/PMD/AliPMDDDLRawData.h b/PMD/AliPMDDDLRawData.h
index d08062b429d6b123abd7ce475b6fb05d0bd195d5..1cf705ded1551f1c9ce2b895791d2ea0e4819e0f 100644 (file)
--- a/PMD/AliPMDDDLRawData.h
+++ b/PMD/AliPMDDDLRawData.h
@@ -22,6 +22,9 @@ class AliPMDDDLRawData:public TObject
  public:
 
   AliPMDDDLRawData();
  public:
 
   AliPMDDDLRawData();

+  AliPMDDDLRawData (const AliPMDDDLRawData &ddlraw);  // copy constructor
+  AliPMDDDLRawData &operator=(const AliPMDDDLRawData &ddlraw); // assignment op
+

   virtual ~AliPMDDDLRawData();
 
   void WritePMDRawData(TTree *treeD);
   virtual ~AliPMDDDLRawData();
 
   void WritePMDRawData(TTree *treeD);


@@ -38,9 +41,9 @@ class AliPMDDDLRawData:public TObject
  protected:
 
   TClonesArray *fDigits;    //! List of digits
  protected:
 
   TClonesArray *fDigits;    //! List of digits

-  AliPMDdigit  *fPMDdigit;  //! Pointer to digits
+  //  AliPMDdigit  *fPMDdigit;  //! Pointer to digits

 
 

-  ClassDef(AliPMDDDLRawData,4)    // To make RAW Data
+  ClassDef(AliPMDDDLRawData,6)    // To make RAW Data

 };
 #endif
 
 };
 #endif
 

diff --git a/PMD/AliPMDDigitizer.cxx b/PMD/AliPMDDigitizer.cxx
index 8f711a69b39de07c75bfebdd4212919557636565..7d76dbc590e9df95c296927506cba01faf8ca86c 100644 (file)
--- a/PMD/AliPMDDigitizer.cxx
+++ b/PMD/AliPMDDigitizer.cxx
@@ -91,6 +91,23 @@ AliPMDDigitizer::AliPMDDigitizer() :
 
 }
 //____________________________________________________________________________
 
 }
 //____________________________________________________________________________

+AliPMDDigitizer::AliPMDDigitizer(const AliPMDDigitizer& /*digitizer*/):
+  AliDigitizer(/* digitizer */)
+{
+  // copy constructor
+  AliError("Copy constructor not allowed ");
+  
+}
+//____________________________________________________________________________
+
+AliPMDDigitizer & AliPMDDigitizer::operator=(const AliPMDDigitizer& /*digitizer*/)
+{
+  // Assignment operator
+  AliError("Assignement operator not allowed ");
+
+  return *this;
+}
+//____________________________________________________________________________

 AliPMDDigitizer::AliPMDDigitizer(AliRunDigitizer* manager) 
   :AliDigitizer(manager),
   fRunLoader(0),
 AliPMDDigitizer::AliPMDDigitizer(AliRunDigitizer* manager) 
   :AliDigitizer(manager),
   fRunLoader(0),

diff --git a/PMD/AliPMDDigitizer.h b/PMD/AliPMDDigitizer.h
index da1b96bd479406fdd5fb63c46fb5de10f52edd15..4fdc918c2426749743020b9cf99870a4426b1d56 100644 (file)
--- a/PMD/AliPMDDigitizer.h
+++ b/PMD/AliPMDDigitizer.h
@@ -9,7 +9,8 @@
 //  Date   : September 20 2002                         //
 //                                                     //
 //-----------------------------------------------------//
 //  Date   : September 20 2002                         //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 
 #include "AliDigitizer.h"
 
 
 #include "AliDigitizer.h"
 


@@ -41,6 +42,8 @@ class AliPMDDigitizer:public AliDigitizer
  public:
 
   AliPMDDigitizer();
  public:
 
   AliPMDDigitizer();

+  AliPMDDigitizer(const AliPMDDigitizer &digitizer);  // copy constructor
+  AliPMDDigitizer &operator=(const AliPMDDigitizer &digitizer); // assign op

   AliPMDDigitizer(AliRunDigitizer *manager);
   virtual ~AliPMDDigitizer();
 
   AliPMDDigitizer(AliRunDigitizer *manager);
   virtual ~AliPMDDigitizer();
 

diff --git a/PMD/AliPMDDspHeader.cxx b/PMD/AliPMDDspHeader.cxx
index ab9305686ad91854ba7b53c6a2d06e0ac3e49d3e..d4c14cf20ff56d80fd41a99fade2448770cce68b 100644 (file)
--- a/PMD/AliPMDDspHeader.cxx
+++ b/PMD/AliPMDDspHeader.cxx
@@ -24,16 +24,16 @@ ClassImp(AliPMDDspHeader)
 const Int_t  AliPMDDspHeader::fgkHeaderLength = 8;
 
 //------------------------------------------------------------
 const Int_t  AliPMDDspHeader::fgkHeaderLength = 8;
 
 //------------------------------------------------------------

-AliPMDDspHeader::AliPMDDspHeader()
-  :  TObject(),
-     fTotalLength(0),
-     fRawDataLength(0),
-     fTrWord1(0),
-     fTrWord2(0),
-     fTrWord3(0),
-     fTrWord4(0),
-     fDspId(0),
-     fEvtWord(0)
+AliPMDDspHeader::AliPMDDspHeader():
+  TObject(),
+  fTotalLength(0),
+  fRawDataLength(0),
+  fTrWord1(0),
+  fTrWord2(0),
+  fTrWord3(0),
+  fTrWord4(0),
+  fDspId(0),
+  fEvtWord(0)

 {
   //
   // ctor
 {
   //
   // ctor


@@ -50,20 +50,20 @@ AliPMDDspHeader::~AliPMDDspHeader()
 }
 
 //___________________________________________
 }
 
 //___________________________________________

-AliPMDDspHeader::AliPMDDspHeader(const AliPMDDspHeader & dsph): TObject()
+AliPMDDspHeader::AliPMDDspHeader(const AliPMDDspHeader & dsph):
+  TObject(),
+  fTotalLength(dsph.fTotalLength),
+  fRawDataLength(dsph.fRawDataLength),
+  fTrWord1(dsph.fTrWord1),
+  fTrWord2(dsph.fTrWord2),
+  fTrWord3(dsph.fTrWord3),
+  fTrWord4(dsph.fTrWord4),
+  fDspId(dsph.fDspId),
+  fEvtWord(dsph.fEvtWord)

 {
   //
   // copy ctor
   //
 {
   //
   // copy ctor
   //

-
-  fTotalLength   = dsph.fTotalLength;
-  fRawDataLength = dsph.fRawDataLength;
-  fTrWord1       = dsph.fTrWord1;
-  fTrWord2       = dsph.fTrWord2;
-  fTrWord3       = dsph.fTrWord3;
-  fTrWord4       = dsph.fTrWord4;
-  fDspId         = dsph.fDspId;
-  fEvtWord       = dsph.fEvtWord;

 }
 
 //___________________________________________
 }
 
 //___________________________________________


@@ -72,17 +72,17 @@ AliPMDDspHeader& AliPMDDspHeader::operator=(const AliPMDDspHeader &dsph)
   // 
   // assignment operator
   //
   // 
   // assignment operator
   //

-  if (this == &dsph) return *this;
-
-  fTotalLength   = dsph.fTotalLength;
-  fRawDataLength = dsph.fRawDataLength;
-  fTrWord1       = dsph.fTrWord1;
-  fTrWord2       = dsph.fTrWord2;
-  fTrWord3       = dsph.fTrWord3;
-  fTrWord4       = dsph.fTrWord4;
-  fDspId         = dsph.fDspId;
-  fEvtWord       = dsph.fEvtWord;
-
+  if (this != &dsph)
+    {
+      fTotalLength   = dsph.fTotalLength;
+      fRawDataLength = dsph.fRawDataLength;
+      fTrWord1       = dsph.fTrWord1;
+      fTrWord2       = dsph.fTrWord2;
+      fTrWord3       = dsph.fTrWord3;
+      fTrWord4       = dsph.fTrWord4;
+      fDspId         = dsph.fDspId;
+      fEvtWord       = dsph.fEvtWord;
+    }

   return *this;
 }
 void AliPMDDspHeader::SetHeader(Int_t *header)
   return *this;
 }
 void AliPMDDspHeader::SetHeader(Int_t *header)

diff --git a/PMD/AliPMDPatchBusHeader.cxx b/PMD/AliPMDPatchBusHeader.cxx
index a8f083965382ca2bfeb384b076ae518fed716532..52df42318be434afc11af496f5f07124fd49e447 100644 (file)
--- a/PMD/AliPMDPatchBusHeader.cxx
+++ b/PMD/AliPMDPatchBusHeader.cxx
@@ -46,17 +46,16 @@ AliPMDPatchBusHeader::~AliPMDPatchBusHeader()
 }
 
 //___________________________________________
 }
 
 //___________________________________________

-AliPMDPatchBusHeader::AliPMDPatchBusHeader(const AliPMDPatchBusHeader & pbush)
-  :  TObject()
+AliPMDPatchBusHeader::AliPMDPatchBusHeader(const AliPMDPatchBusHeader & pbush):
+  TObject(),
+  fTotalLength(pbush.fTotalLength),
+  fRawDataLength(pbush.fRawDataLength),
+  fPatchBusId(pbush.fPatchBusId),
+  fTrWord(pbush.fTrWord)

 {
   //
   // copy ctor
   //
 {
   //
   // copy ctor
   //

-
-  fTotalLength   = pbush.fTotalLength;
-  fRawDataLength = pbush.fRawDataLength;
-  fPatchBusId    = pbush.fPatchBusId;
-  fTrWord        = pbush.fTrWord;

 }
 
 //___________________________________________
 }
 
 //___________________________________________


@@ -66,13 +65,13 @@ AliPMDPatchBusHeader::operator=(const AliPMDPatchBusHeader &pbush)
   // 
   // assignment operator
   //
   // 
   // assignment operator
   //

-  if (this == &pbush) return *this;
-
-  fTotalLength   = pbush.fTotalLength;
-  fRawDataLength = pbush.fRawDataLength;
-  fPatchBusId    = pbush.fPatchBusId;
-  fTrWord        = pbush.fTrWord;
-
+  if (this != &pbush)
+    {
+      fTotalLength   = pbush.fTotalLength;
+      fRawDataLength = pbush.fRawDataLength;
+      fPatchBusId    = pbush.fPatchBusId;
+      fTrWord        = pbush.fTrWord;
+    }

   return *this;
 }
 void AliPMDPatchBusHeader::SetHeader(Int_t *header)
   return *this;
 }
 void AliPMDPatchBusHeader::SetHeader(Int_t *header)


@@ -82,4 +81,4 @@ void AliPMDPatchBusHeader::SetHeader(Int_t *header)
   fPatchBusId    = header[2];
   fTrWord        = header[3];
 }
   fPatchBusId    = header[2];
   fTrWord        = header[3];
 }

-      
+

diff --git a/PMD/AliPMDcell.cxx b/PMD/AliPMDcell.cxx
index b9f5982b30d568edddc194a8ed8c56fc7c90c0f3..b24866cf9675f31c0e39070cc44ea6b127099a35 100644 (file)
--- a/PMD/AliPMDcell.cxx
+++ b/PMD/AliPMDcell.cxx
@@ -27,47 +27,59 @@
 
 ClassImp(AliPMDcell)
 
 
 ClassImp(AliPMDcell)
 

-AliPMDcell::AliPMDcell()
+AliPMDcell::AliPMDcell():
+  fTrNumber(0),
+  fSMNumber(0),
+  fXpos(0),
+  fYpos(0),
+  fEdep(0.)

 {
   // Standard constructor
 {
   // Standard constructor

-  fTrNumber = 0;
-  fSMNumber = 0;
-  fXpos     = 0;
-  fYpos     = 0;
-  fEdep     = 0.;

 }
 
 AliPMDcell::AliPMDcell(Int_t trnumber, Int_t smnumber, 
 }
 
 AliPMDcell::AliPMDcell(Int_t trnumber, Int_t smnumber, 

-                        Int_t xpos, Int_t ypos, Float_t edep)
+                      Int_t xpos, Int_t ypos, Float_t edep):
+  fTrNumber(trnumber),
+  fSMNumber(smnumber),
+  fXpos(xpos),
+  fYpos(ypos),
+  fEdep(edep)

 {
   // Constructor
 {
   // Constructor

-  fTrNumber = trnumber;
-  fSMNumber = smnumber;
-  fXpos     = xpos;
-  fYpos     = ypos;
-  fEdep     = edep;
+}

 
 

+AliPMDcell::AliPMDcell(AliPMDcell *pmdcell):
+  fTrNumber(0),
+  fSMNumber(0),
+  fXpos(0),
+  fYpos(0),
+  fEdep(0.)
+{
+  *this = *pmdcell;

 }
 
 }
 

-AliPMDcell::AliPMDcell(const AliPMDcell& source):TObject(source) {
+AliPMDcell::AliPMDcell(const AliPMDcell& source):
+  TObject(source),
+  fTrNumber(source.fTrNumber),
+  fSMNumber(source.fSMNumber),
+  fXpos(source.fXpos),
+  fYpos(source.fYpos),
+  fEdep(source.fEdep)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&source == this) return;
-  this->fTrNumber = source.fTrNumber;
-  this->fSMNumber = source.fSMNumber;
-  this->fXpos = source.fXpos;
-  this->fYpos = source.fYpos;
-  this->fEdep = source.fEdep;
-  return;

 }
 
 }
 

-AliPMDcell& AliPMDcell::operator=(const AliPMDcell& source) {
+AliPMDcell& AliPMDcell::operator=(const AliPMDcell& source)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&source == this) return *this;
-  this->fTrNumber = source.fTrNumber;
-  this->fSMNumber = source.fSMNumber;
-  this->fXpos = source.fXpos;
-  this->fYpos = source.fYpos;
-  this->fEdep = source.fEdep;
+  if(this != &source)
+    {
+      fTrNumber = source.fTrNumber;
+      fSMNumber = source.fSMNumber;
+      fXpos = source.fXpos;
+      fYpos = source.fYpos;
+      fEdep = source.fEdep;
+    }

   return *this;
 }
 
   return *this;
 }
 

diff --git a/PMD/AliPMDcell.h b/PMD/AliPMDcell.h
index 0a6e8cd445d89e42231787eb1d9ea3f1f6ab1ad8..e22c50757c3448b110785c64e7b667c6494374af 100644 (file)
--- a/PMD/AliPMDcell.h
+++ b/PMD/AliPMDcell.h
@@ -10,7 +10,8 @@
 //  the correct track number to a multiple hit cell    //
 //                                                     //
 //-----------------------------------------------------//
 //  the correct track number to a multiple hit cell    //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 #include "TObject.h"
 class TClonesArray;
 
 #include "TObject.h"
 class TClonesArray;
 


@@ -20,7 +21,7 @@ class AliPMDcell : public TObject
   AliPMDcell();
   AliPMDcell(Int_t trnumber, Int_t smnumber,
              Int_t xpos, Int_t ypos, Float_t edep);
   AliPMDcell();
   AliPMDcell(Int_t trnumber, Int_t smnumber,
              Int_t xpos, Int_t ypos, Float_t edep);

-  AliPMDcell(AliPMDcell *pmdcell) {*this = *pmdcell;}
+  AliPMDcell(AliPMDcell *pmdcell);

   AliPMDcell (const AliPMDcell &alipmdcell);  // copy constructor
   AliPMDcell &operator=(const AliPMDcell &alipmdcell); // assignment op
 
   AliPMDcell (const AliPMDcell &alipmdcell);  // copy constructor
   AliPMDcell &operator=(const AliPMDcell &alipmdcell); // assignment op
 


@@ -39,7 +40,7 @@ class AliPMDcell : public TObject
   Int_t   fYpos;         // y-position of the cell
   Float_t fEdep;         // Energy deposition in a cell
   
   Int_t   fYpos;         // y-position of the cell
   Float_t fEdep;         // Energy deposition in a cell
   

-  ClassDef(AliPMDcell,2) // To keep cell information
+  ClassDef(AliPMDcell,4) // To keep cell information

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDclupid.cxx b/PMD/AliPMDclupid.cxx
index 9b79aaef28bf2ced74c400803b470e35db6de288..b30f6e114e7de52f5bc6e7327dbb0eeb6657c2df 100644 (file)
--- a/PMD/AliPMDclupid.cxx
+++ b/PMD/AliPMDclupid.cxx
@@ -38,39 +38,48 @@ AliPMDclupid::AliPMDclupid():
     }
 }
 // ------------------------------------------------------------------ //
     }
 }
 // ------------------------------------------------------------------ //

-AliPMDclupid::AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata)
+AliPMDclupid::AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata):
+  fDet(idet),
+  fSMN(ismn)

 {
   // Constructor
 {
   // Constructor

-  fDet = idet;
-  fSMN = ismn;

   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];
     }
 }
 // ------------------------------------------------------------------ //
   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];
     }
 }
 // ------------------------------------------------------------------ //

-AliPMDclupid::AliPMDclupid(const AliPMDclupid &pmdclupid):TObject(pmdclupid)
+AliPMDclupid::AliPMDclupid(AliPMDclupid *pmdclupid):
+  fDet(0),
+  fSMN(0)
+{
+  *this = *pmdclupid;
+}
+
+// ------------------------------------------------------------------ //
+AliPMDclupid::AliPMDclupid(const AliPMDclupid &pmdclupid):
+  TObject(pmdclupid),
+  fDet(pmdclupid.fDet),
+  fSMN(pmdclupid.fSMN)

 {
   //Copy Constructor 
 {
   //Copy Constructor 

-  if(&pmdclupid == this) return;
-  this->fDet = pmdclupid.fDet;
-  this->fSMN = pmdclupid.fSMN;

   for(Int_t i=0; i<6; i++)
     {
   for(Int_t i=0; i<6; i++)
     {

-      this->fClusData[i] = pmdclupid.fClusData[i];
+      fClusData[i] = pmdclupid.fClusData[i];

     }
     }

-  return;

 }
 // ------------------------------------------------------------------ //
 AliPMDclupid & AliPMDclupid::operator=(const AliPMDclupid &pmdclupid)
 {
   // Assignment operator 
 }
 // ------------------------------------------------------------------ //
 AliPMDclupid & AliPMDclupid::operator=(const AliPMDclupid &pmdclupid)
 {
   // Assignment operator 

-  if(&pmdclupid == this) return *this;
-  this->fDet = pmdclupid.fDet;
-  this->fSMN = pmdclupid.fSMN;
-  for(Int_t i=0; i<6; i++)
+  if(this != &pmdclupid)

     {
     {

-      this->fClusData[i] = pmdclupid.fClusData[i];
+      fDet = pmdclupid.fDet;
+      fSMN = pmdclupid.fSMN;
+      for(Int_t i=0; i<6; i++)
+       {
+         fClusData[i] = pmdclupid.fClusData[i];
+       }

     }
   return *this;
 }
     }
   return *this;
 }

diff --git a/PMD/AliPMDclupid.h b/PMD/AliPMDclupid.h
index fb7c44444338e53eaa7feaf3ea40804072cde42d..30abc4b4669cb20d201dc0de9809b17bf8bc4768 100644 (file)
--- a/PMD/AliPMDclupid.h
+++ b/PMD/AliPMDclupid.h
@@ -10,7 +10,8 @@
 //  after Discrimination                               //
 //                                                     //
 //-----------------------------------------------------//
 //  after Discrimination                               //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 #include "Rtypes.h"
 #include "TObject.h"
 class TClonesArray;
 #include "Rtypes.h"
 #include "TObject.h"
 class TClonesArray;


@@ -20,7 +21,7 @@ class AliPMDclupid : public TObject
  public:
   AliPMDclupid();
   AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata);
  public:
   AliPMDclupid();
   AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata);

-  AliPMDclupid(AliPMDclupid *pmdclupid) {*this = *pmdclupid;}
+  AliPMDclupid(AliPMDclupid *pmdclupid);

   AliPMDclupid (const AliPMDclupid &pmdclupid);  // copy constructor
   AliPMDclupid &operator=(const AliPMDclupid &pmdclupid); // assignment op
   
   AliPMDclupid (const AliPMDclupid &pmdclupid);  // copy constructor
   AliPMDclupid &operator=(const AliPMDclupid &pmdclupid); // assignment op
   


@@ -47,7 +48,7 @@ class AliPMDclupid : public TObject
     fClusData[4] : Cluster radius    , fClusData[5] : Cluster pid
   */
   
     fClusData[4] : Cluster radius    , fClusData[5] : Cluster pid
   */
   

-  ClassDef(AliPMDclupid,1) // Keep Cluster information
+  ClassDef(AliPMDclupid,2) // Keep Cluster information

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDcluster.cxx b/PMD/AliPMDcluster.cxx
index 9fe697f01a31e02b7bd9c58d914a702c3942bf0b..865fd36224d4764d2a1222b9fced1bfa3af78191 100644 (file)
--- a/PMD/AliPMDcluster.cxx
+++ b/PMD/AliPMDcluster.cxx
@@ -42,12 +42,13 @@ AliPMDcluster::AliPMDcluster():
     }
 
 }
     }
 
 }

+// --------------------------------------------------------------------- //

 AliPMDcluster::AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata,
 AliPMDcluster::AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata,

-                            Int_t *celldataX, Int_t *celldataY)
+                            Int_t *celldataX, Int_t *celldataY):
+  fDet(idet),
+  fSMN(ismn)

 {
   // Constructor
 {
   // Constructor

-  fDet = idet;
-  fSMN = ismn;

   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];
   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];


@@ -59,12 +60,21 @@ AliPMDcluster::AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata,
     }
 
 }
     }
 
 }

-AliPMDcluster::AliPMDcluster(const AliPMDcluster &pmdcluster):TObject(pmdcluster)
+// --------------------------------------------------------------------- //
+AliPMDcluster::AliPMDcluster(AliPMDcluster *pmdcluster):
+  fDet(0),
+  fSMN(0)
+{
+  *this = *pmdcluster;
+}
+// --------------------------------------------------------------------- //
+
+AliPMDcluster::AliPMDcluster(const AliPMDcluster &pmdcluster):
+  TObject(pmdcluster),
+  fDet(pmdcluster.fDet),
+  fSMN(pmdcluster.fSMN)

 {
   //Copy Constructor 
 {
   //Copy Constructor 

-  if(&pmdcluster == this) return;
-  this->fDet = pmdcluster.fDet;
-  this->fSMN = pmdcluster.fSMN;

   for(Int_t i=0; i<6; i++)
     {
       this->fClusData[i] = pmdcluster.fClusData[i];
   for(Int_t i=0; i<6; i++)
     {
       this->fClusData[i] = pmdcluster.fClusData[i];


@@ -74,69 +84,83 @@ AliPMDcluster::AliPMDcluster(const AliPMDcluster &pmdcluster):TObject(pmdcluster
       this->fClusCellDataX[i] = pmdcluster.fClusCellDataX[i];
       this->fClusCellDataY[i] = pmdcluster.fClusCellDataY[i];
     }
       this->fClusCellDataX[i] = pmdcluster.fClusCellDataX[i];
       this->fClusCellDataY[i] = pmdcluster.fClusCellDataY[i];
     }

-  return;

 }
 }

+// --------------------------------------------------------------------- //

 
 AliPMDcluster & AliPMDcluster::operator=(const AliPMDcluster &pmdcluster)
 {
   // Assignment operator 
 
 AliPMDcluster & AliPMDcluster::operator=(const AliPMDcluster &pmdcluster)
 {
   // Assignment operator 

-  if(&pmdcluster == this) return *this;
-  this->fDet = pmdcluster.fDet;
-  this->fSMN = pmdcluster.fSMN;
-  for(Int_t i=0; i<6; i++)
+  if(this != &pmdcluster)

     {
     {

-      this->fClusData[i] = pmdcluster.fClusData[i];
-    }
-  for(Int_t i=0; i<15; i++)
-    {
-      this->fClusCellDataX[i] = pmdcluster.fClusCellDataX[i];
-      this->fClusCellDataY[i] = pmdcluster.fClusCellDataY[i];
+      this->fDet = pmdcluster.fDet;
+      this->fSMN = pmdcluster.fSMN;
+      for(Int_t i=0; i<6; i++)
+       {
+         this->fClusData[i] = pmdcluster.fClusData[i];
+       }
+      for(Int_t i=0; i<15; i++)
+       {
+         this->fClusCellDataX[i] = pmdcluster.fClusCellDataX[i];
+         this->fClusCellDataY[i] = pmdcluster.fClusCellDataY[i];
+       }

     }
   return *this;
 }
     }
   return *this;
 }

+// --------------------------------------------------------------------- //

 
 AliPMDcluster::~AliPMDcluster()
 {
   // Destructor
 }
 
 AliPMDcluster::~AliPMDcluster()
 {
   // Destructor
 }

+// --------------------------------------------------------------------- //

 
 Int_t AliPMDcluster::GetDetector() const
 {
   return fDet;
 }
 
 Int_t AliPMDcluster::GetDetector() const
 {
   return fDet;
 }

+// --------------------------------------------------------------------- //

 Int_t AliPMDcluster::GetSMN() const
 {
   return fSMN;
 }
 Int_t AliPMDcluster::GetSMN() const
 {
   return fSMN;
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusX() const
 {
   return fClusData[0];
 }
 Float_t AliPMDcluster::GetClusX() const
 {
   return fClusData[0];
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusY() const
 {
   return fClusData[1];
 }
 Float_t AliPMDcluster::GetClusY() const
 {
   return fClusData[1];
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusADC() const
 {
   return fClusData[2];
 }
 Float_t AliPMDcluster::GetClusADC() const
 {
   return fClusData[2];
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusCells() const
 {
   return fClusData[3];
 }
 Float_t AliPMDcluster::GetClusCells() const
 {
   return fClusData[3];
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusSigmaX() const
 {
   return fClusData[4];
 }
 Float_t AliPMDcluster::GetClusSigmaX() const
 {
   return fClusData[4];
 }

+// --------------------------------------------------------------------- //

 Float_t AliPMDcluster::GetClusSigmaY() const
 {
   return fClusData[5];
 }
 Float_t AliPMDcluster::GetClusSigmaY() const
 {
   return fClusData[5];
 }

+// --------------------------------------------------------------------- //

 Int_t AliPMDcluster::GetClusCellX(Int_t i) const
 {
   return fClusCellDataX[i];
 }
 Int_t AliPMDcluster::GetClusCellX(Int_t i) const
 {
   return fClusCellDataX[i];
 }

+// --------------------------------------------------------------------- //

 Int_t AliPMDcluster::GetClusCellY(Int_t i) const
 {
   return fClusCellDataY[i];
 }
 Int_t AliPMDcluster::GetClusCellY(Int_t i) const
 {
   return fClusCellDataY[i];
 }

+// --------------------------------------------------------------------- //

diff --git a/PMD/AliPMDcluster.h b/PMD/AliPMDcluster.h
index e27e98cc396d387c9bd111f7b860f154bdfaf03e..b2f56b2ba794ed45a49dd9645ff7f45e0706c592 100644 (file)
--- a/PMD/AliPMDcluster.h
+++ b/PMD/AliPMDcluster.h
@@ -9,7 +9,8 @@
 //  Store cluster informations for PMD                 //
 //                                                     //
 //-----------------------------------------------------//
 //  Store cluster informations for PMD                 //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 #include "Rtypes.h"
 #include "TObject.h"
 class TClonesArray;
 #include "Rtypes.h"
 #include "TObject.h"
 class TClonesArray;


@@ -20,7 +21,7 @@ class AliPMDcluster : public TObject
   AliPMDcluster();
   AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata,
                Int_t *celldataX, Int_t *celldataY);
   AliPMDcluster();
   AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata,
                Int_t *celldataX, Int_t *celldataY);

-  AliPMDcluster(AliPMDcluster *pmdcluster) {*this = *pmdcluster;}
+  AliPMDcluster(AliPMDcluster *pmdcluster);

   AliPMDcluster (const AliPMDcluster &pmdcluster);  // copy constructor
   AliPMDcluster &operator=(const AliPMDcluster &pmdcluster); // assignment op
   
   AliPMDcluster (const AliPMDcluster &pmdcluster);  // copy constructor
   AliPMDcluster &operator=(const AliPMDcluster &pmdcluster); // assignment op
   


@@ -51,7 +52,7 @@ class AliPMDcluster : public TObject
     fClusData[4] : Cluster SigmaX    , fClusData[5] : Cluster SigmaY
   */
   
     fClusData[4] : Cluster SigmaX    , fClusData[5] : Cluster SigmaY
   */
   

-  ClassDef(AliPMDcluster,3) // Keep Cluster information
+  ClassDef(AliPMDcluster,4) // Keep Cluster information

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDddldata.cxx b/PMD/AliPMDddldata.cxx
index dd791a6441a2700b15a4ce4313438a20b1ccae4c..7b086e69c99ad1ce49cbc2ab416566aca0d5ca11 100644 (file)
--- a/PMD/AliPMDddldata.cxx
+++ b/PMD/AliPMDddldata.cxx
@@ -16,11 +16,8 @@
  
 #include "AliPMDddldata.h"
 
  
 #include "AliPMDddldata.h"
 

-
-

 ClassImp(AliPMDddldata)
 
 ClassImp(AliPMDddldata)
 

-

 //------------------------------------------------------------
 AliPMDddldata::AliPMDddldata():
   fDetector(-1),
 //------------------------------------------------------------
 AliPMDddldata::AliPMDddldata():
   fDetector(-1),


@@ -49,22 +46,22 @@ AliPMDddldata::~AliPMDddldata()
 }
 
 //___________________________________________
 }
 
 //___________________________________________

-AliPMDddldata::AliPMDddldata(const AliPMDddldata & ddl) :  TObject()
+AliPMDddldata::AliPMDddldata(const AliPMDddldata & ddl) :
+  TObject(),
+  fDetector(ddl.fDetector),
+  fSMN(ddl.fSMN),
+  fModule(ddl.fModule),
+  fPatchBus(ddl.fPatchBus),
+  fMCM(ddl.fMCM),
+  fChannel(ddl.fChannel),
+  fRow(ddl.fRow),
+  fCol(ddl.fCol),
+  fSignal(ddl.fSignal),
+  fBit(ddl.fBit)

 {
   //
   // copy ctor
   //
 {
   //
   // copy ctor
   //

-  fDetector = ddl.fDetector;
-  fSMN   = ddl.fSMN;
-  fModule   = ddl.fModule;
-  fPatchBus = ddl.fPatchBus;
-  fMCM      = ddl.fMCM;
-  fChannel  = ddl.fChannel;
-  fRow      = ddl.fRow;
-  fCol      = ddl.fCol;
-  fSignal   = ddl.fSignal;
-  fBit      = ddl.fBit;
-

 }
 
 //___________________________________________
 }
 
 //___________________________________________


@@ -73,18 +70,18 @@ AliPMDddldata& AliPMDddldata::operator=(const AliPMDddldata &ddl)
   // 
   // assignment operator
   //
   // 
   // assignment operator
   //

-  if (this == &ddl) return *this;
-
-  fDetector = ddl.fDetector;
-  fSMN   = ddl.fSMN;
-  fModule   = ddl.fModule;
-  fPatchBus = ddl.fPatchBus;
-  fMCM      = ddl.fMCM;
-  fChannel  = ddl.fChannel;
-  fRow      = ddl.fRow;
-  fCol      = ddl.fCol;
-  fSignal   = ddl.fSignal;
-  fBit      = ddl.fBit;
-
+  if (this != &ddl)
+    {
+      fDetector = ddl.fDetector;
+      fSMN   = ddl.fSMN;
+      fModule   = ddl.fModule;
+      fPatchBus = ddl.fPatchBus;
+      fMCM      = ddl.fMCM;
+      fChannel  = ddl.fChannel;
+      fRow      = ddl.fRow;
+      fCol      = ddl.fCol;
+      fSignal   = ddl.fSignal;
+      fBit      = ddl.fBit;
+    }

   return *this;
 }
   return *this;
 }

diff --git a/PMD/AliPMDdigit.cxx b/PMD/AliPMDdigit.cxx
index db53b437ac18f3e7f92f1f6bab7c5df302955033..8dab143b531e10f06638faf583591dfb9b1d2124 100644 (file)
--- a/PMD/AliPMDdigit.cxx
+++ b/PMD/AliPMDdigit.cxx
@@ -26,48 +26,61 @@
 
 ClassImp(AliPMDdigit)
 
 
 ClassImp(AliPMDdigit)
 

-AliPMDdigit::AliPMDdigit()
+AliPMDdigit::AliPMDdigit():
+  fTrNumber(0),
+  fDet(0),
+  fSMNumber(0),
+  fRow(0),
+  fColumn(0),
+  fADC(0.)

 {
   // Default Constructor
 {
   // Default Constructor

-  fTrNumber   = 0;
-  fDet        = 0;
-  fSMNumber   = 0;
-  fRow        = 0;
-  fColumn     = 0;
-  fADC        = 0.;

 }
 
 AliPMDdigit::AliPMDdigit(Int_t trnumber, Int_t det, Int_t smnumber, 
 }
 
 AliPMDdigit::AliPMDdigit(Int_t trnumber, Int_t det, Int_t smnumber, 

-                        Int_t irow, Int_t icol, Float_t adc)
+                        Int_t irow, Int_t icol, Float_t adc):
+  fTrNumber(trnumber),
+  fDet(det),
+  fSMNumber(smnumber),
+  fRow(irow),
+  fColumn(icol),
+  fADC(adc)

 {
   // Constructor
 {
   // Constructor

-  fTrNumber   = trnumber;
-  fDet        = det;
-  fSMNumber   = smnumber;
-  fRow        = irow;
-  fColumn     = icol;
-  fADC        = adc;

 }
 }

-AliPMDdigit::AliPMDdigit(const AliPMDdigit& pmddigit):TObject(pmddigit) {
+AliPMDdigit::AliPMDdigit(AliPMDdigit *pmddigit):
+  fTrNumber(0),
+  fDet(0),
+  fSMNumber(0),
+  fRow(0),
+  fColumn(0),
+  fADC(0.)
+{
+  *this = *pmddigit;
+}
+
+AliPMDdigit::AliPMDdigit(const AliPMDdigit& pmddigit):
+  TObject(pmddigit),
+  fTrNumber(pmddigit.fTrNumber),
+  fDet(pmddigit.fDet),
+  fSMNumber(pmddigit.fSMNumber),
+  fRow(pmddigit.fRow),
+  fColumn(pmddigit.fColumn),
+  fADC(pmddigit.fADC)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&pmddigit == this) return;
-  this->fTrNumber   = pmddigit.fTrNumber;
-  this->fDet        = pmddigit.fDet;
-  this->fSMNumber   = pmddigit.fSMNumber;
-  this->fRow        = pmddigit.fRow;
-  this->fColumn     = pmddigit.fColumn;
-  this->fADC        = pmddigit.fADC;
-  return;

 }
 AliPMDdigit & AliPMDdigit::operator=(const AliPMDdigit& pmddigit) {
   //Assignment operator 
 }
 AliPMDdigit & AliPMDdigit::operator=(const AliPMDdigit& pmddigit) {
   //Assignment operator 

-  if(&pmddigit == this) return *this;
-  this->fTrNumber   = pmddigit.fTrNumber;
-  this->fDet        = pmddigit.fDet;
-  this->fSMNumber   = pmddigit.fSMNumber;
-  this->fRow        = pmddigit.fRow;
-  this->fColumn     = pmddigit.fColumn;
-  this->fADC        = pmddigit.fADC;
+  if(this != &pmddigit)
+    {
+      fTrNumber   = pmddigit.fTrNumber;
+      fDet        = pmddigit.fDet;
+      fSMNumber   = pmddigit.fSMNumber;
+      fRow        = pmddigit.fRow;
+      fColumn     = pmddigit.fColumn;
+      fADC        = pmddigit.fADC;
+    }

   return *this;
 }
 AliPMDdigit::~AliPMDdigit()
   return *this;
 }
 AliPMDdigit::~AliPMDdigit()

diff --git a/PMD/AliPMDdigit.h b/PMD/AliPMDdigit.h
index 474b4a4cd59701fadbfd4564d373f44d602b7e77..d12e9ad879d229bea4db092dacb093f2d62279a6 100644 (file)
--- a/PMD/AliPMDdigit.h
+++ b/PMD/AliPMDdigit.h
@@ -19,7 +19,7 @@ class AliPMDdigit : public TObject
   AliPMDdigit();
   AliPMDdigit(Int_t trnumber, Int_t det, Int_t smnumber,
              Int_t irow, Int_t icol, Float_t adc);
   AliPMDdigit();
   AliPMDdigit(Int_t trnumber, Int_t det, Int_t smnumber,
              Int_t irow, Int_t icol, Float_t adc);

-  AliPMDdigit(AliPMDdigit *pmddigit) {*this = *pmddigit;}
+  AliPMDdigit(AliPMDdigit *pmddigit);

   AliPMDdigit (const AliPMDdigit &pmddigit);  // copy constructor
   AliPMDdigit &operator=(const AliPMDdigit &pmddigit); // assignment op
 
   AliPMDdigit (const AliPMDdigit &pmddigit);  // copy constructor
   AliPMDdigit &operator=(const AliPMDdigit &pmddigit); // assignment op
 


@@ -40,7 +40,7 @@ class AliPMDdigit : public TObject
   Int_t   fColumn;      // Cell Column Number (0-95)
   Float_t fADC;         // Energy deposition(ADC) in a hexagonal cell
   
   Int_t   fColumn;      // Cell Column Number (0-95)
   Float_t fADC;         // Energy deposition(ADC) in a hexagonal cell
   

-  ClassDef(AliPMDdigit,3) // Digits object for Detector set:PMD
+  ClassDef(AliPMDdigit,4) // Digits object for Detector set:PMD

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDrechit.cxx b/PMD/AliPMDrechit.cxx
index 8592b237a115f37da4586e5fde62b6b9da601a54..33386ef7829d3b184ede092fd64522db4a5aab7a 100644 (file)
--- a/PMD/AliPMDrechit.cxx
+++ b/PMD/AliPMDrechit.cxx
@@ -33,26 +33,37 @@ AliPMDrechit::AliPMDrechit():
   // Standard constructor
 }
 
   // Standard constructor
 }
 

-AliPMDrechit::AliPMDrechit(Int_t cellx, Int_t celly)
+AliPMDrechit::AliPMDrechit(Int_t cellx, Int_t celly):
+  fXcell(cellx),
+  fYcell(celly)
+

 {
   // Constructor
 {
   // Constructor

-  fXcell     = cellx;
-  fYcell     = celly;
+}
+AliPMDrechit::AliPMDrechit(AliPMDrechit *pmdrechit):
+  fXcell(0),
+  fYcell(0)
+{
+  *this = *pmdrechit;

 }
 
 }
 

-AliPMDrechit::AliPMDrechit(const AliPMDrechit& source):TObject(source) {
+AliPMDrechit::AliPMDrechit(const AliPMDrechit& source):
+  TObject(source),
+  fXcell(source.fXcell),
+  fYcell(source.fYcell)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&source == this) return;
-  this->fXcell = source.fXcell;
-  this->fYcell = source.fYcell;
-  return;
+

 }
 
 }
 

-AliPMDrechit& AliPMDrechit::operator=(const AliPMDrechit& source) {
+AliPMDrechit& AliPMDrechit::operator=(const AliPMDrechit& source)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&source == this) return *this;
-  this->fXcell = source.fXcell;
-  this->fYcell = source.fYcell;
+  if(this != &source)
+    {
+      fXcell = source.fXcell;
+      fYcell = source.fYcell;
+    }

   return *this;
 }
 
   return *this;
 }
 

diff --git a/PMD/AliPMDrechit.h b/PMD/AliPMDrechit.h
index 6843b2515fdab7bdca7b94794843c046a45155c9..266b8f6be544de4814fba447f23816a74feb4b34 100644 (file)
--- a/PMD/AliPMDrechit.h
+++ b/PMD/AliPMDrechit.h
@@ -9,7 +9,8 @@
 //  Store cellhits associated to a cluster             //
 //                                                     //
 //-----------------------------------------------------//
 //  Store cellhits associated to a cluster             //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 #include "TObject.h"
 class TClonesArray;
 
 #include "TObject.h"
 class TClonesArray;
 


@@ -18,7 +19,7 @@ class AliPMDrechit : public TObject
  public:
   AliPMDrechit();
   AliPMDrechit(Int_t cellx, Int_t celly);
  public:
   AliPMDrechit();
   AliPMDrechit(Int_t cellx, Int_t celly);

-  AliPMDrechit(AliPMDrechit *pmdrechit) {*this = *pmdrechit;}
+  AliPMDrechit(AliPMDrechit *pmdrechit);

   AliPMDrechit (const AliPMDrechit &alipmdrechit);  // copy constructor
   AliPMDrechit &operator=(const AliPMDrechit &alipmdrechit); // assignment op
 
   AliPMDrechit (const AliPMDrechit &alipmdrechit);  // copy constructor
   AliPMDrechit &operator=(const AliPMDrechit &alipmdrechit); // assignment op
 


@@ -31,7 +32,7 @@ class AliPMDrechit : public TObject
   Int_t   fXcell;         // x-position of the cell
   Int_t   fYcell;         // y-position of the cell
   
   Int_t   fXcell;         // x-position of the cell
   Int_t   fYcell;         // y-position of the cell
   

-  ClassDef(AliPMDrechit,1) // To keep cell hit information
+  ClassDef(AliPMDrechit,2) // To keep cell hit information

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDrecpoint1.cxx b/PMD/AliPMDrecpoint1.cxx
index 6ba6f79afc6ee6b67b44ebbce9904fcdecf7b15f..271d197c6670c93d8ca0c92a2150c41559c7bea1 100644 (file)
--- a/PMD/AliPMDrecpoint1.cxx
+++ b/PMD/AliPMDrecpoint1.cxx
@@ -38,39 +38,48 @@ AliPMDrecpoint1::AliPMDrecpoint1():
     }
 }
 // ------------------------------------------------------------------------- //
     }
 }
 // ------------------------------------------------------------------------- //

-AliPMDrecpoint1::AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata)
+AliPMDrecpoint1::AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata):
+  fDet(idet),
+  fSMN(ismn)

 {
   // Constructor
 {
   // Constructor

-  fDet = idet;
-  fSMN = ismn;

   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];
     }
 }
 // ------------------------------------------------------------------------- //
   for (Int_t i = 0; i < 6; i++)
     {
       fClusData[i] = clusdata[i];
     }
 }
 // ------------------------------------------------------------------------- //

-AliPMDrecpoint1::AliPMDrecpoint1(const AliPMDrecpoint1 &pmdrecpoint):TObject(pmdrecpoint)
+AliPMDrecpoint1::AliPMDrecpoint1(AliPMDrecpoint1 *pmdrecpoint):
+  fDet(0),
+  fSMN(0)
+{
+  *this = *pmdrecpoint;
+}
+
+// ------------------------------------------------------------------------- //
+AliPMDrecpoint1::AliPMDrecpoint1(const AliPMDrecpoint1 &pmdrecpoint):
+  TObject(pmdrecpoint),
+  fDet(pmdrecpoint.fDet),
+  fSMN(pmdrecpoint.fSMN)

 {
   //Copy Constructor 
 {
   //Copy Constructor 

-  if(&pmdrecpoint == this) return;
-  this->fDet = pmdrecpoint.fDet;
-  this->fSMN = pmdrecpoint.fSMN;

   for(Int_t i=0; i<6; i++)
     {
   for(Int_t i=0; i<6; i++)
     {

-      this->fClusData[i] = pmdrecpoint.fClusData[i];
+      fClusData[i] = pmdrecpoint.fClusData[i];

     }
     }

-  return;

 }
 // ------------------------------------------------------------------------- //
 AliPMDrecpoint1 & AliPMDrecpoint1::operator=(const AliPMDrecpoint1 &pmdrecpoint)
 {
   // Assignment operator 
 }
 // ------------------------------------------------------------------------- //
 AliPMDrecpoint1 & AliPMDrecpoint1::operator=(const AliPMDrecpoint1 &pmdrecpoint)
 {
   // Assignment operator 

-  if(&pmdrecpoint == this) return *this;
-  this->fDet = pmdrecpoint.fDet;
-  this->fSMN = pmdrecpoint.fSMN;
-  for(Int_t i=0; i<6; i++)
+  if(this != &pmdrecpoint)

     {
     {

-      this->fClusData[i] = pmdrecpoint.fClusData[i];
+      fDet = pmdrecpoint.fDet;
+      fSMN = pmdrecpoint.fSMN;
+      for(Int_t i=0; i<6; i++)
+       {
+         fClusData[i] = pmdrecpoint.fClusData[i];
+       }

     }
   return *this;
 }
     }
   return *this;
 }

diff --git a/PMD/AliPMDrecpoint1.h b/PMD/AliPMDrecpoint1.h
index 389bb384a0a8eb8bda977fa1fa5d73331fa2c5df..10cdb67f84cb5bb6d196c2bf9e8b71fe81ba16b9 100644 (file)
--- a/PMD/AliPMDrecpoint1.h
+++ b/PMD/AliPMDrecpoint1.h
@@ -21,7 +21,7 @@ class AliPMDrecpoint1 : public TObject
  public:
   AliPMDrecpoint1();
   AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata);
  public:
   AliPMDrecpoint1();
   AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata);

-  AliPMDrecpoint1(AliPMDrecpoint1 *pmdrecpoint) {*this = *pmdrecpoint;}
+  AliPMDrecpoint1(AliPMDrecpoint1 *pmdrecpoint);

   AliPMDrecpoint1 (const AliPMDrecpoint1 &pmdrecpoint);  // copy constructor
   AliPMDrecpoint1 &operator=(const AliPMDrecpoint1 &pmdrecpoint); // assignment op
   
   AliPMDrecpoint1 (const AliPMDrecpoint1 &pmdrecpoint);  // copy constructor
   AliPMDrecpoint1 &operator=(const AliPMDrecpoint1 &pmdrecpoint); // assignment op
   


@@ -48,7 +48,7 @@ class AliPMDrecpoint1 : public TObject
     fClusData[4] : Cluster SigmaX ,  fClusData[5] : Cluster SigmaY
   */
   
     fClusData[4] : Cluster SigmaX ,  fClusData[5] : Cluster SigmaY
   */
   

-  ClassDef(AliPMDrecpoint1,3) // keep reconstructed points info
+  ClassDef(AliPMDrecpoint1,4) // keep reconstructed points info

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDsdigit.cxx b/PMD/AliPMDsdigit.cxx
index 27b2de1862206e38bfe2532c613bdce926f1fa4b..c0833aeee82809013ed372fc2a36498dabecface 100644 (file)
--- a/PMD/AliPMDsdigit.cxx
+++ b/PMD/AliPMDsdigit.cxx
@@ -25,48 +25,63 @@
 
 ClassImp(AliPMDsdigit)
 
 
 ClassImp(AliPMDsdigit)
 

-AliPMDsdigit::AliPMDsdigit()
+AliPMDsdigit::AliPMDsdigit():
+  fTrNumber(0),
+  fDet(0),
+  fSMN(0),
+  fRow(0),
+  fColumn(0),
+  fEdep(0.)

 {
   // Default Constructor
 {
   // Default Constructor

-  fTrNumber   = 0;
-  fDet        = 0;
-  fSMN        = 0;
-  fRow        = 0;
-  fColumn     = 0;
-  fEdep       = 0.;

 }
 
 AliPMDsdigit::AliPMDsdigit(Int_t trnumber, Int_t det, Int_t smn,
 }
 
 AliPMDsdigit::AliPMDsdigit(Int_t trnumber, Int_t det, Int_t smn,

-                          Int_t irow, Int_t icol, Float_t edep)
+                          Int_t irow, Int_t icol, Float_t edep):
+  fTrNumber(trnumber),
+  fDet(det),
+  fSMN(smn),
+  fRow(irow),
+  fColumn(icol),
+  fEdep(edep)

 {
   // Constructor
 {
   // Constructor

-  fTrNumber   = trnumber;
-  fDet        = det;
-  fSMN        = smn;
-  fRow        = irow;
-  fColumn     = icol;
-  fEdep       = edep;

 }
 }

-AliPMDsdigit::AliPMDsdigit(const AliPMDsdigit& pmdsdigit):TObject(pmdsdigit) {
+
+AliPMDsdigit::AliPMDsdigit(AliPMDsdigit *pmdsdigit):
+  fTrNumber(0),
+  fDet(0),
+  fSMN(0),
+  fRow(0),
+  fColumn(0),
+  fEdep(0.)
+{
+  *this = *pmdsdigit;
+}
+
+AliPMDsdigit::AliPMDsdigit(const AliPMDsdigit& pmdsdigit):
+  TObject(pmdsdigit),
+  fTrNumber(pmdsdigit.fTrNumber),
+  fDet(pmdsdigit.fDet),
+  fSMN(pmdsdigit.fSMN),
+  fRow(pmdsdigit.fRow),
+  fColumn(pmdsdigit.fColumn),
+  fEdep(pmdsdigit.fEdep)
+{

   //Copy Constructor 
   //Copy Constructor 

-  if(&pmdsdigit == this) return;
-  this->fTrNumber   = pmdsdigit.fTrNumber;
-  this->fDet        = pmdsdigit.fDet;
-  this->fSMN        = pmdsdigit.fSMN;
-  this->fRow        = pmdsdigit.fRow;
-  this->fColumn     = pmdsdigit.fColumn;
-  this->fEdep       = pmdsdigit.fEdep;
-  return;

 }
 }

-AliPMDsdigit & AliPMDsdigit::operator=(const AliPMDsdigit& pmdsdigit) {
+AliPMDsdigit & AliPMDsdigit::operator=(const AliPMDsdigit& pmdsdigit)
+{

   //Assignment operator 
   //Assignment operator 

-  if(&pmdsdigit == this) return *this;
-  this->fTrNumber   = pmdsdigit.fTrNumber;
-  this->fDet        = pmdsdigit.fDet;
-  this->fSMN        = pmdsdigit.fSMN;
-  this->fRow        = pmdsdigit.fRow;
-  this->fColumn     = pmdsdigit.fColumn;
-  this->fEdep       = pmdsdigit.fEdep;
+  if(this != &pmdsdigit)
+    {
+      fTrNumber   = pmdsdigit.fTrNumber;
+      fDet        = pmdsdigit.fDet;
+      fSMN        = pmdsdigit.fSMN;
+      fRow        = pmdsdigit.fRow;
+      fColumn     = pmdsdigit.fColumn;
+      fEdep       = pmdsdigit.fEdep;
+    }

   return *this;
 }
 
   return *this;
 }
 

diff --git a/PMD/AliPMDsdigit.h b/PMD/AliPMDsdigit.h
index 77c7d8e89ffb1ff9e35203a2e6224cf4f09ab517..7ca69988e705fad3853492f638d89431c902d6ea 100644 (file)
--- a/PMD/AliPMDsdigit.h
+++ b/PMD/AliPMDsdigit.h
@@ -9,7 +9,8 @@
 //  used to store the info into TreeS                  //
 //                                                     //
 //-----------------------------------------------------//
 //  used to store the info into TreeS                  //
 //                                                     //
 //-----------------------------------------------------//

-
+// Author - B.K. Nandi
+//

 #include "TObject.h"
 class TClonesArray;
 
 #include "TObject.h"
 class TClonesArray;
 


@@ -20,7 +21,7 @@ class AliPMDsdigit : public TObject
   AliPMDsdigit();
   AliPMDsdigit(Int_t trnumber, Int_t det, Int_t smn,
               Int_t irow, Int_t icol, Float_t edep);
   AliPMDsdigit();
   AliPMDsdigit(Int_t trnumber, Int_t det, Int_t smn,
               Int_t irow, Int_t icol, Float_t edep);

-  AliPMDsdigit(AliPMDsdigit *pmdsdigit) {*this = *pmdsdigit;}
+  AliPMDsdigit(AliPMDsdigit *pmdsdigit);

   AliPMDsdigit (const AliPMDsdigit &pmdsdigit);  // copy constructor
   AliPMDsdigit &operator=(const AliPMDsdigit &pmdsdigit); // assignment op
 
   AliPMDsdigit (const AliPMDsdigit &pmdsdigit);  // copy constructor
   AliPMDsdigit &operator=(const AliPMDsdigit &pmdsdigit); // assignment op
 


@@ -42,7 +43,7 @@ class AliPMDsdigit : public TObject
   Int_t   fColumn;     // Cell Column Number (0-95)
   Float_t fEdep;       // Energy deposition in a hexagonal cell
   
   Int_t   fColumn;     // Cell Column Number (0-95)
   Float_t fEdep;       // Energy deposition in a hexagonal cell
   

-  ClassDef(AliPMDsdigit,3) // SDigits object for Detector set:PMD
+  ClassDef(AliPMDsdigit,4) // SDigits object for Detector set:PMD

 };
 
 #endif
 };
 
 #endif

diff --git a/PMD/AliPMDtracker.cxx b/PMD/AliPMDtracker.cxx
index 279aaddd2f55b54ce101cffcee707b2c1d71666f..2c8ee7b0a432ee4ede506465723474d490494871 100644 (file)
--- a/PMD/AliPMDtracker.cxx
+++ b/PMD/AliPMDtracker.cxx
@@ -69,6 +69,22 @@ AliPMDtracker::AliPMDtracker():
   // Default Constructor
   //
 }
   // Default Constructor
   //
 }

+//--------------------------------------------------------------------//
+AliPMDtracker:: AliPMDtracker(const AliPMDtracker & /* tracker */):
+  TObject(/* tracker */)
+{
+  // copy constructor
+  AliError("Copy constructor not allowed");
+}
+
+//--------------------------------------------------------------------//
+AliPMDtracker& AliPMDtracker::operator=(const AliPMDtracker & /* tracker */)
+{
+ // assignment operator
+  AliError("Assignment operator not allowed");
+  return *this;
+}
+

 //--------------------------------------------------------------------//
 AliPMDtracker::~AliPMDtracker()
 {
 //--------------------------------------------------------------------//
 AliPMDtracker::~AliPMDtracker()
 {

diff --git a/PMD/AliPMDtracker.h b/PMD/AliPMDtracker.h
index 42b9724e0b7367c9d47c0253e5c64a3e4c0eec0a..604153fca3dc15ea6da7fe680fd0e7de4a36d99e 100644 (file)
--- a/PMD/AliPMDtracker.h
+++ b/PMD/AliPMDtracker.h
@@ -29,6 +29,9 @@ class AliPMDtracker:public TObject
  public:
 
   AliPMDtracker();
  public:
 
   AliPMDtracker();

+  AliPMDtracker(const AliPMDtracker &tracker);  // copy constructor
+  AliPMDtracker &operator=(const AliPMDtracker &tracker); // assignment op
+

   virtual ~AliPMDtracker();
 
   void LoadClusters(TTree *treein);
   virtual ~AliPMDtracker();
 
   void LoadClusters(TTree *treein);


@@ -55,7 +58,7 @@ class AliPMDtracker:public TObject
   Double_t fSigmaY;         // Y-vertex error
   Double_t fSigmaZ;         // Z-vertex error
 
   Double_t fSigmaY;         // Y-vertex error
   Double_t fSigmaZ;         // Z-vertex error
 

-  ClassDef(AliPMDtracker,3) // To run PMD clustering
+  ClassDef(AliPMDtracker,4) // To run PMD clustering

 };
 #endif
 
 };
 #endif
 

diff --git a/PMD/AliPMDv0.cxx b/PMD/AliPMDv0.cxx
index 6fb03647b111da013e98547e715a24fe65dd16df..15b1b695c45df5982f7b6ee18c2b2c65c87318f9 100644 (file)
--- a/PMD/AliPMDv0.cxx
+++ b/PMD/AliPMDv0.cxx
@@ -56,22 +56,28 @@ const Float_t AliPMDv0::fgkPi         = 3.14159;  // pi
 ClassImp(AliPMDv0)
  
 //_____________________________________________________________________________
 ClassImp(AliPMDv0)
  
 //_____________________________________________________________________________

-  AliPMDv0::AliPMDv0()
+AliPMDv0::AliPMDv0():
+  fSMthick(0.),
+  fSMLength(0.),
+  fMedSens(0),
+  fNcellSM(0)

 {
   //
   // Default constructor 
   //
 {
   //
   // Default constructor 
   //

-  fMedSens=0;

 }
  
 //_____________________________________________________________________________
 }
  
 //_____________________________________________________________________________

-AliPMDv0::AliPMDv0(const char *name, const char *title)
-  : AliPMD(name,title)
+AliPMDv0::AliPMDv0(const char *name, const char *title):
+  AliPMD(name,title),
+  fSMthick(0.),
+  fSMLength(0.),
+  fMedSens(0),
+  fNcellSM(0)

 {
   //
   // Standard constructor
   //
 {
   //
   // Standard constructor
   //

-  fMedSens=0;

 }
 
 //_____________________________________________________________________________
 }
 
 //_____________________________________________________________________________

diff --git a/PMD/AliPMDv1.cxx b/PMD/AliPMDv1.cxx
index 43f4266b748243a1df451cc367a1094e31072470..65eab38883edce589a590acbfe54353ab3588596 100644 (file)
--- a/PMD/AliPMDv1.cxx
+++ b/PMD/AliPMDv1.cxx
@@ -61,23 +61,49 @@ const Float_t AliPMDv1::fgkThSS       = 1.03;
 const Float_t AliPMDv1::fgkThG10      = 1.03;
 ClassImp(AliPMDv1)
  
 const Float_t AliPMDv1::fgkThG10      = 1.03;
 ClassImp(AliPMDv1)
  

-  //_____________________________________________________________________________
-  AliPMDv1::AliPMDv1()
+//_____________________________________________________________________________
+AliPMDv1::AliPMDv1():
+  fSMthick(0.),
+  fDthick(0.),
+  fSMLengthax(0.),
+  fSMLengthay(0.),
+  fSMLengthbx(0.),
+  fSMLengthby(0.),
+  fMedSens(0)

 {
   //
   // Default constructor 
   //
 {
   //
   // Default constructor 
   //

-  fMedSens=0;
+  for (Int_t i = 0; i < 3; i++)
+    {
+      fDboxmm1[i]  = 0.;
+      fDboxmm12[i] = 0.;
+      fDboxmm2[i]  = 0.;
+      fDboxmm22[i] = 0.;
+    }

 }
  
 //_____________________________________________________________________________
 }
  
 //_____________________________________________________________________________

-AliPMDv1::AliPMDv1(const char *name, const char *title)
-  : AliPMD(name,title)
+AliPMDv1::AliPMDv1(const char *name, const char *title):
+  AliPMD(name,title),
+  fSMthick(0.),
+  fDthick(0.),
+  fSMLengthax(0.),
+  fSMLengthay(0.),
+  fSMLengthbx(0.),
+  fSMLengthby(0.),
+  fMedSens(0)

 {
   //
   // Standard constructor
   //
 {
   //
   // Standard constructor
   //

-  fMedSens=0;
+  for (Int_t i = 0; i < 3; i++)
+    {
+      fDboxmm1[i]  = 0.;
+      fDboxmm12[i] = 0.;
+      fDboxmm2[i]  = 0.;
+      fDboxmm22[i] = 0.;
+    }

 }
 
 //_____________________________________________________________________________
 }
 
 //_____________________________________________________________________________