implementation of effc++
authorbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Aug 2006 08:20:00 +0000 (08:20 +0000)
committerbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Aug 2006 08:20:00 +0000 (08:20 +0000)
32 files changed:
PMD/AliPMDBlockHeader.cxx
PMD/AliPMDCalibrator.cxx
PMD/AliPMDCalibrator.h
PMD/AliPMDClusterFinder.cxx
PMD/AliPMDClusterFinder.h
PMD/AliPMDClusteringV1.cxx
PMD/AliPMDClusteringV2.cxx
PMD/AliPMDDDLRawData.cxx
PMD/AliPMDDDLRawData.h
PMD/AliPMDDigitizer.cxx
PMD/AliPMDDigitizer.h
PMD/AliPMDDspHeader.cxx
PMD/AliPMDPatchBusHeader.cxx
PMD/AliPMDcell.cxx
PMD/AliPMDcell.h
PMD/AliPMDclupid.cxx
PMD/AliPMDclupid.h
PMD/AliPMDcluster.cxx
PMD/AliPMDcluster.h
PMD/AliPMDddldata.cxx
PMD/AliPMDdigit.cxx
PMD/AliPMDdigit.h
PMD/AliPMDrechit.cxx
PMD/AliPMDrechit.h
PMD/AliPMDrecpoint1.cxx
PMD/AliPMDrecpoint1.h
PMD/AliPMDsdigit.cxx
PMD/AliPMDsdigit.h
PMD/AliPMDtracker.cxx
PMD/AliPMDtracker.h
PMD/AliPMDv0.cxx
PMD/AliPMDv1.cxx

index 8c82afa..bae4812 100644 (file)
@@ -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
   //
 
-  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
   //
-  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)
index 4d2c50f..106076a 100644 (file)
@@ -47,12 +47,10 @@ const Int_t kMaxSMN = 24;
 const Int_t kMaxRow =96;
 const Int_t kMaxCol =96;
 
-AliPMDCalibrator::AliPMDCalibrator()
+AliPMDCalibrator::AliPMDCalibrator():
+  fCalibData(new AliPMDCalibData())
 {
   // Standard Constructor
-
-  fCalibData = new AliPMDCalibData();
-  
   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
index 81e0077..23b09d5 100644 (file)
@@ -13,6 +13,9 @@ class AliPMDCalibrator
 {
  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
@@ -25,6 +28,6 @@ class AliPMDCalibrator
   TH1F *fHadcIso[2][24][96][96];    // histos of isolated cells cellwise
   AliPMDCalibData *fCalibData;
 
-ClassDef(AliPMDCalibrator,1)        // description 
+ClassDef(AliPMDCalibrator,2)        // description 
 };
 #endif // AliPMDCALIBRATOR_H
index 36b1bb1..439ed43 100644 (file)
@@ -53,6 +53,7 @@ ClassImp(AliPMDClusterFinder)
 AliPMDClusterFinder::AliPMDClusterFinder():
   fRunLoader(0),
   fPMDLoader(0),
+  fCalibData(GetCalibData()),
   fTreeD(0),
   fTreeR(0),
   fDigits(new TClonesArray("AliPMDdigit", 1000)),
@@ -60,17 +61,18 @@ AliPMDClusterFinder::AliPMDClusterFinder():
   fRechits(new TClonesArray("AliPMDrechit", 1000)),
   fNpoint(0),
   fNhit(0),
+  fDetNo(0),
   fEcut(0.)
 {
 //
 // Constructor
 //
-  fCalibData = GetCalibData();
 }
 // ------------------------------------------------------------------------- //
 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
   fRunLoader(runLoader),
   fPMDLoader(runLoader->GetLoader("PMDLoader")),
+  fCalibData(GetCalibData()),
   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),
+  fDetNo(0),
   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()
@@ -172,7 +188,6 @@ void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt)
          
          // CALIBRATION
          Float_t gain = fCalibData->GetGainFact(det,smn,xpos,ypos);
-         
         // printf("adc = %d gain = %f\n",adc,gain);
          
          adc = adc*gain;
index f9a2a21..720c242 100644 (file)
@@ -27,6 +27,8 @@ class AliPMDClusterFinder : public TObject
 
   AliPMDClusterFinder();
   AliPMDClusterFinder(AliRunLoader* runLoader);
+  AliPMDClusterFinder(const AliPMDClusterFinder &finder);  // copy constructor
+  AliPMDClusterFinder &operator=(const AliPMDClusterFinder &finder); // assignment op
   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
 
-  ClassDef(AliPMDClusterFinder,9) // To run PMD clustering
+  ClassDef(AliPMDClusterFinder,10) // To run PMD clustering
 };
 #endif
 
index 2a15ac3..24c3003 100644 (file)
@@ -54,6 +54,7 @@ ClassImp(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++)
index d8f446d..8fd2082 100644 (file)
@@ -51,6 +51,7 @@ ClassImp(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++)
index 7b611bf..2ff1de9 100644 (file)
@@ -39,6 +39,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()
 {
@@ -401,6 +419,9 @@ void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
   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);
index d08062b..1cf705d 100644 (file)
@@ -22,6 +22,9 @@ class AliPMDDDLRawData:public TObject
  public:
 
   AliPMDDDLRawData();
+  AliPMDDDLRawData (const AliPMDDDLRawData &ddlraw);  // copy constructor
+  AliPMDDDLRawData &operator=(const AliPMDDDLRawData &ddlraw); // assignment op
+
   virtual ~AliPMDDDLRawData();
 
   void WritePMDRawData(TTree *treeD);
@@ -38,9 +41,9 @@ class AliPMDDDLRawData:public TObject
  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
 
index 8f711a6..7d76dbc 100644 (file)
@@ -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),
index da1b96b..4fdc918 100644 (file)
@@ -9,7 +9,8 @@
 //  Date   : September 20 2002                         //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 
 #include "AliDigitizer.h"
 
@@ -41,6 +42,8 @@ class AliPMDDigitizer:public AliDigitizer
  public:
 
   AliPMDDigitizer();
+  AliPMDDigitizer(const AliPMDDigitizer &digitizer);  // copy constructor
+  AliPMDDigitizer &operator=(const AliPMDDigitizer &digitizer); // assign op
   AliPMDDigitizer(AliRunDigitizer *manager);
   virtual ~AliPMDDigitizer();
 
index ab93056..d4c14cf 100644 (file)
@@ -24,16 +24,16 @@ ClassImp(AliPMDDspHeader)
 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
@@ -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
   //
-
-  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
   //
-  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)
index a8f0839..52df423 100644 (file)
@@ -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
   //
-
-  fTotalLength   = pbush.fTotalLength;
-  fRawDataLength = pbush.fRawDataLength;
-  fPatchBusId    = pbush.fPatchBusId;
-  fTrWord        = pbush.fTrWord;
 }
 
 //___________________________________________
@@ -66,13 +65,13 @@ AliPMDPatchBusHeader::operator=(const AliPMDPatchBusHeader &pbush)
   // 
   // 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)
@@ -82,4 +81,4 @@ void AliPMDPatchBusHeader::SetHeader(Int_t *header)
   fPatchBusId    = header[2];
   fTrWord        = header[3];
 }
-      
+
index b9f5982..b24866c 100644 (file)
 
 ClassImp(AliPMDcell)
 
-AliPMDcell::AliPMDcell()
+AliPMDcell::AliPMDcell():
+  fTrNumber(0),
+  fSMNumber(0),
+  fXpos(0),
+  fYpos(0),
+  fEdep(0.)
 {
   // Standard constructor
-  fTrNumber = 0;
-  fSMNumber = 0;
-  fXpos     = 0;
-  fYpos     = 0;
-  fEdep     = 0.;
 }
 
 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
-  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 
-  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 
-  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;
 }
 
index 0a6e8cd..e22c507 100644 (file)
@@ -10,7 +10,8 @@
 //  the correct track number to a multiple hit cell    //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 #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 *pmdcell) {*this = *pmdcell;}
+  AliPMDcell(AliPMDcell *pmdcell);
   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
   
-  ClassDef(AliPMDcell,2) // To keep cell information
+  ClassDef(AliPMDcell,4) // To keep cell information
 };
 
 #endif
index 9b79aae..b30f6e1 100644 (file)
@@ -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
-  fDet = idet;
-  fSMN = ismn;
   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 
-  if(&pmdclupid == this) return;
-  this->fDet = pmdclupid.fDet;
-  this->fSMN = pmdclupid.fSMN;
   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 
-  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;
 }
index fb7c444..30abc4b 100644 (file)
@@ -10,7 +10,8 @@
 //  after Discrimination                               //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 #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);
-  AliPMDclupid(AliPMDclupid *pmdclupid) {*this = *pmdclupid;}
+  AliPMDclupid(AliPMDclupid *pmdclupid);
   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
   */
   
-  ClassDef(AliPMDclupid,1) // Keep Cluster information
+  ClassDef(AliPMDclupid,2) // Keep Cluster information
 };
 
 #endif
index 9fe697f..865fd36 100644 (file)
@@ -42,12 +42,13 @@ AliPMDcluster::AliPMDcluster():
     }
 
 }
+// --------------------------------------------------------------------- //
 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
-  fDet = idet;
-  fSMN = ismn;
   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 
-  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];
@@ -74,69 +84,83 @@ AliPMDcluster::AliPMDcluster(const AliPMDcluster &pmdcluster):TObject(pmdcluster
       this->fClusCellDataX[i] = pmdcluster.fClusCellDataX[i];
       this->fClusCellDataY[i] = pmdcluster.fClusCellDataY[i];
     }
-  return;
 }
+// --------------------------------------------------------------------- //
 
 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;
 }
+// --------------------------------------------------------------------- //
 
 AliPMDcluster::~AliPMDcluster()
 {
   // Destructor
 }
+// --------------------------------------------------------------------- //
 
 Int_t AliPMDcluster::GetDetector() const
 {
   return fDet;
 }
+// --------------------------------------------------------------------- //
 Int_t AliPMDcluster::GetSMN() const
 {
   return fSMN;
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusX() const
 {
   return fClusData[0];
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusY() const
 {
   return fClusData[1];
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusADC() const
 {
   return fClusData[2];
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusCells() const
 {
   return fClusData[3];
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusSigmaX() const
 {
   return fClusData[4];
 }
+// --------------------------------------------------------------------- //
 Float_t AliPMDcluster::GetClusSigmaY() const
 {
   return fClusData[5];
 }
+// --------------------------------------------------------------------- //
 Int_t AliPMDcluster::GetClusCellX(Int_t i) const
 {
   return fClusCellDataX[i];
 }
+// --------------------------------------------------------------------- //
 Int_t AliPMDcluster::GetClusCellY(Int_t i) const
 {
   return fClusCellDataY[i];
 }
+// --------------------------------------------------------------------- //
index e27e98c..b2f56b2 100644 (file)
@@ -9,7 +9,8 @@
 //  Store cluster informations for PMD                 //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 #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 *pmdcluster) {*this = *pmdcluster;}
+  AliPMDcluster(AliPMDcluster *pmdcluster);
   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
   */
   
-  ClassDef(AliPMDcluster,3) // Keep Cluster information
+  ClassDef(AliPMDcluster,4) // Keep Cluster information
 };
 
 #endif
index dd791a6..7b086e6 100644 (file)
  
 #include "AliPMDddldata.h"
 
-
-
 ClassImp(AliPMDddldata)
 
-
 //------------------------------------------------------------
 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
   //
-  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
   //
-  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;
 }
index db53b43..8dab143 100644 (file)
 
 ClassImp(AliPMDdigit)
 
-AliPMDdigit::AliPMDdigit()
+AliPMDdigit::AliPMDdigit():
+  fTrNumber(0),
+  fDet(0),
+  fSMNumber(0),
+  fRow(0),
+  fColumn(0),
+  fADC(0.)
 {
   // 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, 
-                        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
-  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 
-  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 
-  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()
index 474b4a4..d12e9ad 100644 (file)
@@ -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 *pmddigit) {*this = *pmddigit;}
+  AliPMDdigit(AliPMDdigit *pmddigit);
   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
   
-  ClassDef(AliPMDdigit,3) // Digits object for Detector set:PMD
+  ClassDef(AliPMDdigit,4) // Digits object for Detector set:PMD
 };
 
 #endif
index 8592b23..33386ef 100644 (file)
@@ -33,26 +33,37 @@ AliPMDrechit::AliPMDrechit():
   // Standard constructor
 }
 
-AliPMDrechit::AliPMDrechit(Int_t cellx, Int_t celly)
+AliPMDrechit::AliPMDrechit(Int_t cellx, Int_t celly):
+  fXcell(cellx),
+  fYcell(celly)
+
 {
   // 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 
-  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 
-  if(&source == this) return *this;
-  this->fXcell = source.fXcell;
-  this->fYcell = source.fYcell;
+  if(this != &source)
+    {
+      fXcell = source.fXcell;
+      fYcell = source.fYcell;
+    }
   return *this;
 }
 
index 6843b25..266b8f6 100644 (file)
@@ -9,7 +9,8 @@
 //  Store cellhits associated to a cluster             //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 #include "TObject.h"
 class TClonesArray;
 
@@ -18,7 +19,7 @@ class AliPMDrechit : public TObject
  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
 
@@ -31,7 +32,7 @@ class AliPMDrechit : public TObject
   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
index 6ba6f79..271d197 100644 (file)
@@ -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
-  fDet = idet;
-  fSMN = ismn;
   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 
-  if(&pmdrecpoint == this) return;
-  this->fDet = pmdrecpoint.fDet;
-  this->fSMN = pmdrecpoint.fSMN;
   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 
-  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;
 }
index 389bb38..10cdb67 100644 (file)
@@ -21,7 +21,7 @@ class AliPMDrecpoint1 : public TObject
  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
   
@@ -48,7 +48,7 @@ class AliPMDrecpoint1 : public TObject
     fClusData[4] : Cluster SigmaX ,  fClusData[5] : Cluster SigmaY
   */
   
-  ClassDef(AliPMDrecpoint1,3) // keep reconstructed points info
+  ClassDef(AliPMDrecpoint1,4) // keep reconstructed points info
 };
 
 #endif
index 27b2de1..c0833ae 100644 (file)
 
 ClassImp(AliPMDsdigit)
 
-AliPMDsdigit::AliPMDsdigit()
+AliPMDsdigit::AliPMDsdigit():
+  fTrNumber(0),
+  fDet(0),
+  fSMN(0),
+  fRow(0),
+  fColumn(0),
+  fEdep(0.)
 {
   // 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,
-                          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
-  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 
-  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 
-  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;
 }
 
index 77c7d8e..7ca6998 100644 (file)
@@ -9,7 +9,8 @@
 //  used to store the info into TreeS                  //
 //                                                     //
 //-----------------------------------------------------//
-
+// Author - B.K. Nandi
+//
 #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 *pmdsdigit) {*this = *pmdsdigit;}
+  AliPMDsdigit(AliPMDsdigit *pmdsdigit);
   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
   
-  ClassDef(AliPMDsdigit,3) // SDigits object for Detector set:PMD
+  ClassDef(AliPMDsdigit,4) // SDigits object for Detector set:PMD
 };
 
 #endif
index 279aadd..2c8ee7b 100644 (file)
@@ -70,6 +70,22 @@ AliPMDtracker::AliPMDtracker():
   //
 }
 //--------------------------------------------------------------------//
+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()
 {
   // Destructor
index 42b9724..604153f 100644 (file)
@@ -29,6 +29,9 @@ class AliPMDtracker:public TObject
  public:
 
   AliPMDtracker();
+  AliPMDtracker(const AliPMDtracker &tracker);  // copy constructor
+  AliPMDtracker &operator=(const AliPMDtracker &tracker); // assignment op
+
   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
 
-  ClassDef(AliPMDtracker,3) // To run PMD clustering
+  ClassDef(AliPMDtracker,4) // To run PMD clustering
 };
 #endif
 
index 6fb0364..15b1b69 100644 (file)
@@ -56,22 +56,28 @@ const Float_t AliPMDv0::fgkPi         = 3.14159;  // pi
 ClassImp(AliPMDv0)
  
 //_____________________________________________________________________________
-  AliPMDv0::AliPMDv0()
+AliPMDv0::AliPMDv0():
+  fSMthick(0.),
+  fSMLength(0.),
+  fMedSens(0),
+  fNcellSM(0)
 {
   //
   // 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
   //
-  fMedSens=0;
 }
 
 //_____________________________________________________________________________
index 43f4266..65eab38 100644 (file)
@@ -61,23 +61,49 @@ const Float_t AliPMDv1::fgkThSS       = 1.03;
 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 
   //
-  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
   //
-  fMedSens=0;
+  for (Int_t i = 0; i < 3; i++)
+    {
+      fDboxmm1[i]  = 0.;
+      fDboxmm12[i] = 0.;
+      fDboxmm2[i]  = 0.;
+      fDboxmm22[i] = 0.;
+    }
 }
 
 //_____________________________________________________________________________