mev2adc defined to be const
[u/mrichter/AliRoot.git] / PMD / AliPMDDigitizer.cxx
index 153f1e3cde27c39a819071f816bc9f3c3b12b4b4..26633dde83687d0090ff09f7a7282f14cc0afe8f 100644 (file)
@@ -1,11 +1,26 @@
+/***************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
 //-----------------------------------------------------//
 //                                                     //
-//  Source File : PMDDigitization.cxx, Version 00      //
+//  Source File : PMDDigitizer.cxx, Version 00         //
 //                                                     //
 //  Date   : September 20 2002                         //
 //                                                     //
 //-----------------------------------------------------//
 
+#include <Riostream.h>
 #include <TBRIK.h>
 #include <TNode.h>
 #include <TTree.h>
 #include "AliPMDdigit.h"
 #include "AliPMDDigitizer.h"
 #include "AliPMDClustering.h"
-#include "AliPMDContainer.h"
-#include "AliPMDrecpoint.h"
-
+#include "AliMC.h"
 
 ClassImp(AliPMDDigitizer)
-//
-// Constructor
-//
+
 AliPMDDigitizer::AliPMDDigitizer()
 {
+  // Default Constructor
+  //
   if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);  
   fNsdigit = 0;
   if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);  
   fNdigit = 0;
 
-  for (Int_t i = 0; i < fTotSM; i++)
+  for (Int_t i = 0; i < fgkTotUM; i++)
     {
-      for (Int_t j = 0; j < fNCell; j++)
+      for (Int_t j = 0; j < fgkRow; j++)
        {
-         for (Int_t k = 0; k < fNCell; k++)
+         for (Int_t k = 0; k < fgkCol; k++)
            {
              fCPV[i][j][k] = 0.; 
-             fPMD[i][j][k] = 0.; 
+             fPRE[i][j][k] = 0.; 
            }
        }
     }
@@ -62,10 +75,11 @@ AliPMDDigitizer::AliPMDDigitizer()
   if (!fCell) fCell = new TObjArray();
 
   fZPos = 361.5; // in units of cm, This is the default position of PMD
-
 }
 AliPMDDigitizer::~AliPMDDigitizer()
 {
+  // Default Destructor
+  //
   delete fSDigits;
   delete fDigits;
   delete fCell;
@@ -75,7 +89,9 @@ AliPMDDigitizer::~AliPMDDigitizer()
 //
 void AliPMDDigitizer::OpengAliceFile(Char_t *file, Option_t *option)
 {
-
+  // Loads galice.root file and corresponding header, kinematics
+  // hits and sdigits or digits depending on the option
+  //
   fRunLoader = AliRunLoader::Open(file,AliConfig::fgkDefaultEventFolderName,
                                  "UPDATE");
   
@@ -101,9 +117,9 @@ void AliPMDDigitizer::OpengAliceFile(Char_t *file, Option_t *option)
       printf("Could not find AliRun object.\n");
     }
 
-  PMD  = (AliPMD*)gAlice->GetDetector("PMD");
-  pmdloader = fRunLoader->GetLoader("PMDLoader");
-  if (pmdloader == 0x0)
+  fPMD  = (AliPMD*)gAlice->GetDetector("PMD");
+  fPMDLoader = fRunLoader->GetLoader("PMDLoader");
+  if (fPMDLoader == 0x0)
     {
       cerr<<"Hits2Digits : Can not find PMD or PMDLoader\n";
     }
@@ -114,41 +130,44 @@ void AliPMDDigitizer::OpengAliceFile(Char_t *file, Option_t *option)
 
   if (cHS)
     {
-      pmdloader->LoadHits("READ");
-      pmdloader->LoadSDigits("recreate");
+      fPMDLoader->LoadHits("READ");
+      fPMDLoader->LoadSDigits("recreate");
     }
   else if (cHD)
     {
-      pmdloader->LoadHits("READ");
-      pmdloader->LoadDigits("recreate");
+      fPMDLoader->LoadHits("READ");
+      fPMDLoader->LoadDigits("recreate");
     }
   else if (cSD)
     {
-      pmdloader->LoadSDigits("READ");
-      pmdloader->LoadDigits("recreate");
+      fPMDLoader->LoadSDigits("READ");
+      fPMDLoader->LoadDigits("recreate");
     }
 
 }
 void AliPMDDigitizer::Hits2SDigits(Int_t ievt)
 {
-  cout << " -------- Beginning of Hits2SDigits ----------- " << endl;
+  // This reads the PMD Hits tree and assigns the right track number
+  // to a cell and stores in the summable digits tree
+  //
+  // cout << " -------- Beginning of Hits2SDigits ----------- " << endl;
 
-  Int_t kPi0 = 111;
-  Int_t kGamma = 22;
+  const Int_t kPi0 = 111;
+  const Int_t kGamma = 22;
   Int_t npmd;
   Int_t trackno;
-  Int_t cellnumber;
-  Int_t smnumber1;
   Int_t smnumber;
   Int_t trackpid;
   Int_t mtrackno;
   Int_t mtrackpid;
 
   Float_t xPos, yPos, zPos;
-  Int_t xpad, ypad;
+  Int_t xpad = -1, ypad = -1;
   Float_t edep;
   Float_t vx = -999.0, vy = -999.0, vz = -999.0;
 
+
+  FILE *fpw = fopen("junk_digit1.dat","w");
   
   ResetSDigit();
 
@@ -156,165 +175,191 @@ void AliPMDDigitizer::Hits2SDigits(Int_t ievt)
   Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
   printf("Number of Particles = %d \n", nparticles);
   fRunLoader->GetEvent(ievt);
-  Particles = gAlice->Particles();
+  //  fPArray = gAlice->GetMCApp()->Particles();
   // ------------------------------------------------------- //
   // Pointer to specific detector hits.
   // Get pointers to Alice detectors and Hits containers
 
-  treeH = pmdloader->TreeH();
+  fTreeH = fPMDLoader->TreeH();
   
-  Int_t ntracks    = (Int_t) treeH->GetEntries();
+  Int_t ntracks    = (Int_t) fTreeH->GetEntries();
   printf("Number of Tracks in the TreeH = %d \n", ntracks);
 
-  treeS = pmdloader->TreeS();
-  if (treeS == 0x0)
+  fTreeS = fPMDLoader->TreeS();
+  if (fTreeS == 0x0)
     {
-      pmdloader->MakeTree("S");
-      treeS = pmdloader->TreeS();
+      fPMDLoader->MakeTree("S");
+      fTreeS = fPMDLoader->TreeS();
     }
   Int_t bufsize = 16000;
-  treeS->Branch("PMDSDigit", &fSDigits, bufsize); 
+  fTreeS->Branch("PMDSDigit", &fSDigits, bufsize); 
   
-  if (PMD) PMDhits   = PMD->Hits();
+  if (fPMD) fHits   = fPMD->Hits();
 
   // Start loop on tracks in the hits containers
 
-  
   for (Int_t track=0; track<ntracks;track++) 
     {
       gAlice->ResetHits();
-      treeH->GetEvent(track);
-      
-      if (PMD) 
+      fTreeH->GetEvent(track);
+      if (fPMD) 
        {
-         npmd = PMDhits->GetEntriesFast();
+         npmd = fHits->GetEntriesFast();
          for (int ipmd = 0; ipmd < npmd; ipmd++) 
            {
-             pmdHit = (AliPMDhit*) PMDhits->UncheckedAt(ipmd);
-             trackno = pmdHit->GetTrack();
-
+             fPMDHit = (AliPMDhit*) fHits->UncheckedAt(ipmd);
+             trackno = fPMDHit->GetTrack();
              //  get kinematics of the particles
-             
-             particle = gAlice->Particle(trackno);
-             trackpid  = particle->GetPdgCode();
 
+             fParticle = gAlice->GetMCApp()->Particle(trackno);
+             trackpid  = fParticle->GetPdgCode();
+
+             fprintf(fpw,"track =%d trackno = %d trackpid = %d\n",
+                     track, trackno, trackpid);
              Int_t igatr = -999;
              Int_t ichtr = -999;
-
+             Int_t igapid = -999;
              Int_t imo;
              Int_t igen = 0;
-             Int_t id_mo = -999;
-             TParticle*  mparticle = particle;
-             
+             Int_t idmo = -999;
+
+             TParticle*  mparticle = fParticle;
+             Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
+             if (mparticle->GetFirstMother() == -1)
+               {
+                 tracknoOld  = trackno;
+                 trackpidOld = trackpid;
+                 statusOld   = -1;
+               }
+             Int_t igstatus = 0;
              while((imo = mparticle->GetFirstMother()) >= 0)
                {
                  igen++;
-                 mparticle =  gAlice->Particle(imo);
-                 id_mo = mparticle->GetPdgCode();
+
+                 mparticle =  gAlice->GetMCApp()->Particle(imo);
+                 idmo = mparticle->GetPdgCode();
                  
                  vx = mparticle->Vx();
                  vy = mparticle->Vy();
                  vz = mparticle->Vz();
                
-                 //printf("==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, id_mo, vx, vy, vz);
-                 //fprintf(ftest1,"==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, id_mo, vx, vy, vz);
-                 
-                 if (id_mo == kGamma && vx == 0. && vy == 0. && vz == 0.)
+                 //printf("==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, idmo, vx, vy, vz);
+                 //fprintf(fpw1,"==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, idmo, vx, vy, vz);
+                 if ((idmo == kGamma || idmo == -11 || idmo == 11) && vx == 0. && vy == 0. && vz == 0.)
                    {
                      igatr = imo;
+                     igapid = idmo;
+                     igstatus = 1;
+                   }
+                 if(igstatus == 0)
+                   {
+                     if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
+                       {
+                         igatr = imo;
+                         igapid = idmo;
+                       }
                    }
                  ichtr = imo;
                }
 
-             if (id_mo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
+             if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
                {
                  mtrackno = igatr;
-                 mtrackpid = kGamma;
+                 mtrackpid = igapid;
                }
              else
                {
                  mtrackno  = ichtr;
-                 mtrackpid = id_mo;
+                 mtrackpid = idmo;
                }
-
-             xPos = pmdHit->X();
-             yPos = pmdHit->Y();
-             zPos = pmdHit->Z();
-             cellnumber = pmdHit->fVolume[1];
-             smnumber1  = pmdHit->fVolume[4];
-             edep       = pmdHit->fEnergy;
+             if (statusOld == -1)
+               {
+                 mtrackno  = tracknoOld;
+                 mtrackpid = trackpidOld;
+               }
+             xPos = fPMDHit->X();
+             yPos = fPMDHit->Y();
+             zPos = fPMDHit->Z();
+             edep       = fPMDHit->fEnergy;
+             Int_t vol1 = fPMDHit->fVolume[1]; // Column
+             Int_t vol2 = fPMDHit->fVolume[2]; // Row
+             Int_t vol3 = fPMDHit->fVolume[3]; // UnitModule
+             Int_t vol6 = fPMDHit->fVolume[6]; // SuperModule
+             // -----------------------------------------//
+             // For Super Module 1 & 2                   //
+             //  nrow = 96, ncol = 48                    //
+             // For Super Module 3 & 4                   //
+             //  nrow = 48, ncol = 96                    //
+             // -----------------------------------------//
              
-             if (smnumber1 > 3 && smnumber1 <= 6)
+             smnumber = (vol6-1)*6 + vol3;
+
+             if (vol6 == 1 || vol6 == 2)
+               {
+                 xpad = vol1;
+                 ypad = vol2;
+               }
+             else if (vol6 == 3 || vol6 == 4)
                {
-                 Int_t ny = (cellnumber-1)/48 + 1;
-                 Int_t nx = cellnumber - (ny-1)*48;
-                 Int_t nx1 = nx + 24;
-                 Int_t ny1 = ny + 48;
-                 Int_t ncell1 = (ny1 - 1)* 72 + nx1;
-                 cellnumber = ncell1;
+                 xpad = vol2;
+                 ypad = vol1;
                }
-             smnumber = Convert2RealSMNumber(smnumber1);
-             ypad = (cellnumber - 1)/fNCell + 1;
-             xpad = cellnumber - (ypad-1)*fNCell;
 
-             //cout << "-zpos = " << -zPos << endl;
+             //cout << "zpos = " << zPos << " edep = " << edep << endl;
 
-             if (-zPos < fZPos)
+             Float_t zposition = TMath::Abs(zPos);
+             if (zposition < fZPos)
                {
                  // CPV
                  fDetNo = 1;
                }
-             else if (-zPos > fZPos)
+             else if (zposition > fZPos)
                {
                  // PMD
                  fDetNo = 0;
                }
-
+             Int_t smn = smnumber - 1;
+             Int_t ixx = xpad     - 1;
+             Int_t iyy = ypad     - 1;
              if (fDetNo == 0)
                {
-                 fPMD[smnumber-1][xpad-1][ypad-1] += edep;
-                 fPMDCounter[smnumber-1][xpad-1][ypad-1]++;
-                 Int_t smn = smnumber - 1;
-                 Int_t ixx = xpad     - 1;
-                 Int_t iyy = ypad     - 1;
+                 fPRE[smn][ixx][iyy] += edep;
+                 fPRECounter[smn][ixx][iyy]++;
 
-                 pmdcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
+                 fPMDcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
 
-                 fCell->Add(pmdcell);
+                 fCell->Add(fPMDcell);
                }
              else if(fDetNo == 1)
                {
-                 fCPV[smnumber-1][xpad-1][ypad-1] += edep;
-                 fCPVTrackNo[smnumber-1][xpad-1][ypad-1] = mtrackno;
+                 fCPV[smn][ixx][iyy] += edep;
+                 fCPVTrackNo[smn][ixx][iyy] = mtrackno;
                }
            }
        }
     } // Track Loop ended
-  
-  
+
   TrackAssignment2Cell();
-  
   ResetCell();
 
   Float_t deltaE      = 0.;
   Int_t   detno       = 0;
-  Int_t   count_digit = 0;
   Int_t   trno        = -1;
   Int_t   cellno      = 0;
 
   for (Int_t idet = 0; idet < 2; idet++)
     {
-      for (Int_t ism = 0; ism < fTotSM; ism++)
+      for (Int_t ism = 0; ism < fgkTotUM; ism++)
        {
-         for (Int_t jrow = 0; jrow < fNCell; jrow++)
+         for (Int_t jrow = 0; jrow < fgkRow; jrow++)
            {
-             for (Int_t kcol = 0; kcol < fNCell; kcol++)
+             for (Int_t kcol = 0; kcol < fgkCol; kcol++)
                {
-                 cellno = jrow + kcol*fNCell;
+                 cellno = jrow*fgkCol + kcol;
                  if (idet == 0)
                    {
-                     deltaE = fPMD[ism][jrow][kcol];
-                     trno   = fPMDTrackNo[ism][jrow][kcol];
+                     deltaE = fPRE[ism][jrow][kcol];
+                     trno   = fPRETrackNo[ism][jrow][kcol];
                      detno = 0;
                    }
                  else if (idet == 1)
@@ -325,17 +370,15 @@ void AliPMDDigitizer::Hits2SDigits(Int_t ievt)
                    }
                  if (deltaE > 0.)
                    {
-                     count_digit++;
                      AddSDigit(trno,detno,ism,cellno,deltaE);
                    }
                }
            }
-         treeS->Fill();
+         fTreeS->Fill();
          ResetSDigit();
        }
     }
-  pmdloader->WriteSDigits("OVERWRITE");
-
+  fPMDLoader->WriteSDigits("OVERWRITE");
   ResetCellADC();
 
   //  cout << " -------- End of Hits2SDigit ----------- " << endl;
@@ -343,23 +386,23 @@ void AliPMDDigitizer::Hits2SDigits(Int_t ievt)
 
 void AliPMDDigitizer::Hits2Digits(Int_t ievt)
 {
-  Int_t kPi0 = 111;
-  Int_t kGamma = 22;
+  // This reads the PMD Hits tree and assigns the right track number
+  // to a cell and stores in the digits tree
+  //
+  const Int_t kPi0 = 111;
+  const Int_t kGamma = 22;
   Int_t npmd;
   Int_t trackno;
-  Int_t cellnumber;
-  Int_t smnumber1;
   Int_t smnumber;
   Int_t trackpid;
   Int_t mtrackno;
   Int_t mtrackpid;
 
   Float_t xPos, yPos, zPos;
-  Int_t xpad, ypad;
+  Int_t xpad = -1, ypad = -1;
   Float_t edep;
   Float_t vx = -999.0, vy = -999.0, vz = -999.0;
 
-  
   ResetDigit();
 
   printf("Event Number =  %d \n",ievt); 
@@ -367,133 +410,176 @@ void AliPMDDigitizer::Hits2Digits(Int_t ievt)
   Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
   printf("Number of Particles = %d \n", nparticles);
   fRunLoader->GetEvent(ievt);
-  Particles = gAlice->Particles();
+  //  fPArray = gAlice->GetMCApp()->Particles();
   // ------------------------------------------------------- //
   // Pointer to specific detector hits.
   // Get pointers to Alice detectors and Hits containers
 
-  PMD  = (AliPMD*)gAlice->GetDetector("PMD");
-  pmdloader = fRunLoader->GetLoader("PMDLoader");
+  fPMD  = (AliPMD*)gAlice->GetDetector("PMD");
+  fPMDLoader = fRunLoader->GetLoader("PMDLoader");
 
-  if (pmdloader == 0x0)
+  if (fPMDLoader == 0x0)
     {
       cerr<<"Hits2Digits method : Can not find PMD or PMDLoader\n";
     }
-  treeH = pmdloader->TreeH();
-  Int_t ntracks    = (Int_t) treeH->GetEntries();
+  fTreeH = fPMDLoader->TreeH();
+  Int_t ntracks    = (Int_t) fTreeH->GetEntries();
   printf("Number of Tracks in the TreeH = %d \n", ntracks);
-  pmdloader->LoadDigits("recreate");
-  treeD = pmdloader->TreeD();
-  if (treeD == 0x0)
+  fPMDLoader->LoadDigits("recreate");
+  fTreeD = fPMDLoader->TreeD();
+  if (fTreeD == 0x0)
     {
-      pmdloader->MakeTree("D");
-      treeD = pmdloader->TreeD();
+      fPMDLoader->MakeTree("D");
+      fTreeD = fPMDLoader->TreeD();
     }
   Int_t bufsize = 16000;
-  treeD->Branch("PMDDigit", &fDigits, bufsize); 
+  fTreeD->Branch("PMDDigit", &fDigits, bufsize); 
   
-  if (PMD) PMDhits   = PMD->Hits();
+  if (fPMD) fHits   = fPMD->Hits();
 
   // Start loop on tracks in the hits containers
 
   for (Int_t track=0; track<ntracks;track++) 
     {
       gAlice->ResetHits();
-      treeH->GetEvent(track);
+      fTreeH->GetEvent(track);
       
-      if (PMD) 
+      if (fPMD) 
        {
-         npmd = PMDhits->GetEntriesFast();
+         npmd = fHits->GetEntriesFast();
          for (int ipmd = 0; ipmd < npmd; ipmd++) 
            {
-             pmdHit = (AliPMDhit*) PMDhits->UncheckedAt(ipmd);
-             trackno = pmdHit->GetTrack();
+             fPMDHit = (AliPMDhit*) fHits->UncheckedAt(ipmd);
+             trackno = fPMDHit->GetTrack();
              
              //  get kinematics of the particles
              
-             particle = gAlice->Particle(trackno);
-             trackpid  = particle->GetPdgCode();
+             fParticle = gAlice->GetMCApp()->Particle(trackno);
+             trackpid  = fParticle->GetPdgCode();
 
              Int_t igatr = -999;
              Int_t ichtr = -999;
-
+             Int_t igapid = -999;
              Int_t imo;
              Int_t igen = 0;
-             Int_t id_mo = -999;
-             TParticle*  mparticle = particle;
-             
+             Int_t idmo = -999;
+
+             TParticle*  mparticle = fParticle;
+             Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
+             if (mparticle->GetFirstMother() == -1)
+               {
+                 tracknoOld  = trackno;
+                 trackpidOld = trackpid;
+                 statusOld   = -1;
+               }
+
+             Int_t igstatus = 0;
              while((imo = mparticle->GetFirstMother()) >= 0)
                {
                  igen++;
-                 mparticle =  gAlice->Particle(imo);
-                 id_mo = mparticle->GetPdgCode();
+
+                 mparticle =  gAlice->GetMCApp()->Particle(imo);
+                 idmo = mparticle->GetPdgCode();
                  
                  vx = mparticle->Vx();
                  vy = mparticle->Vy();
                  vz = mparticle->Vz();
                
-                 //printf("==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, id_mo, vx, vy, vz);
-                 //fprintf(ftest1,"==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, id_mo, vx, vy, vz);
-                 
-                 if (id_mo == kGamma && vx == 0. && vy == 0. && vz == 0.)
+                 //printf("==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, idmo, vx, vy, vz);
+                 //fprintf(fpw1,"==> Mother ID %5d %5d %5d Vertex: %13.3f %13.3f %13.3f\n", igen, imo, idmo, vx, vy, vz);
+                 if ((idmo == kGamma || idmo == -11 || idmo == 11) && vx == 0. && vy == 0. && vz == 0.)
                    {
                      igatr = imo;
+                     igapid = idmo;
+                     igstatus = 1;
+                   }
+                 if(igstatus == 0)
+                   {
+                     if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
+                       {
+                         igatr = imo;
+                         igapid = idmo;
+                       }
                    }
                  ichtr = imo;
                }
 
-             if (id_mo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
+             if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
                {
                  mtrackno = igatr;
-                 mtrackpid = kGamma;
+                 mtrackpid = igapid;
                }
              else
                {
                  mtrackno  = ichtr;
-                 mtrackpid = id_mo;
+                 mtrackpid = idmo;
+               }
+             if (statusOld == -1)
+               {
+                 mtrackno  = tracknoOld;
+                 mtrackpid = trackpidOld;
                }
              
-             xPos = pmdHit->X();
-             yPos = pmdHit->Y();
-             zPos = pmdHit->Z();
-             cellnumber = pmdHit->fVolume[1];
-             smnumber1  = pmdHit->fVolume[4];
-             edep       = pmdHit->fEnergy;
+             xPos = fPMDHit->X();
+             yPos = fPMDHit->Y();
+             zPos = fPMDHit->Z();
+             edep       = fPMDHit->fEnergy;
+             Int_t vol1 = fPMDHit->fVolume[1]; // Column
+             Int_t vol2 = fPMDHit->fVolume[2]; // Row
+             Int_t vol3 = fPMDHit->fVolume[3]; // UnitModule
+             Int_t vol6 = fPMDHit->fVolume[6]; // SuperModule
+
+             // -----------------------------------------//
+             // For Super Module 1 & 2                   //
+             //  nrow = 96, ncol = 48                    //
+             // For Super Module 3 & 4                   //
+             //  nrow = 48, ncol = 96                    //
+             // -----------------------------------------//
              
-             if (smnumber1 > 3 && smnumber1 <= 6)
+             smnumber = (vol6-1)*6 + vol3;
+
+             if (vol6 == 1 || vol6 == 2)
                {
-                 Int_t ny = (cellnumber-1)/48 + 1;
-                 Int_t nx = cellnumber - (ny-1)*48;
-                 Int_t nx1 = nx + 24;
-                 Int_t ny1 = ny + 48;
-                 Int_t ncell1 = (ny1 - 1)* 72 + nx1;
-                 cellnumber = ncell1;
+                 xpad = vol1;
+                 ypad = vol2;
+               }
+             else if (vol6 == 3 || vol6 == 4)
+               {
+                 xpad = vol2;
+                 ypad = vol1;
                }
-             
-             smnumber = Convert2RealSMNumber(smnumber1);
-             ypad = (cellnumber - 1)/fNCell + 1;
-             xpad = cellnumber - (ypad-1)*fNCell;
 
              //cout << "-zpos = " << -zPos << endl;
-             if (-zPos < fZPos)
+
+             Float_t zposition = TMath::Abs(zPos);
+
+             if (zposition < fZPos)
                {
                  // CPV
                  fDetNo = 1;
                }
-             else if (-zPos > fZPos)
+             else if (zposition > fZPos)
                {
                  // PMD
                  fDetNo = 0;
                }
-             
-             if(fDetNo == 1)
+
+             Int_t smn = smnumber - 1;
+             Int_t ixx = xpad     - 1;
+             Int_t iyy = ypad     - 1;
+             if (fDetNo == 0)
                {
-                 fCPV[smnumber-1][xpad-1][ypad-1] += edep;
+                 fPRE[smn][ixx][iyy] += edep;
+                 fPRECounter[smn][ixx][iyy]++;
+
+                 fPMDcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
+
+                 fCell->Add(fPMDcell);
                }
-             else if (fDetNo == 0)
+             else if(fDetNo == 1)
                {
-                 fPMD[smnumber-1][xpad-1][ypad-1] += edep;
-                 fPMDCounter[smnumber-1][xpad-1][ypad-1]++;
+                 fCPV[smn][ixx][iyy] += edep;
+                 fCPVTrackNo[smn][ixx][iyy] = mtrackno;
                }
            }
        }
@@ -504,43 +590,42 @@ void AliPMDDigitizer::Hits2Digits(Int_t ievt)
 
   Float_t deltaE = 0.;
   Int_t detno = 0;
-  Int_t count_digit = 0;
   Int_t trno = 1;
   Int_t cellno;
 
   for (Int_t idet = 0; idet < 2; idet++)
     {
-      for (Int_t ism = 0; ism < fTotSM; ism++)
+      for (Int_t ism = 0; ism < fgkTotUM; ism++)
        {
-         for (Int_t jrow = 0; jrow < fNCell; jrow++)
+         for (Int_t jrow = 0; jrow < fgkRow; jrow++)
            {
-             for (Int_t kcol = 0; kcol < fNCell; kcol++)
+             for (Int_t kcol = 0; kcol < fgkCol; kcol++)
                {
-                 cellno = jrow + kcol*fNCell;
+                 cellno = jrow*fgkCol + kcol;
                  if (idet == 0)
                    {
-                     deltaE = fPMD[ism][jrow][kcol];
+                     deltaE = fPRE[ism][jrow][kcol];
+                     trno   = fPRETrackNo[ism][jrow][kcol];
                      detno = 0;
                    }
                  else if (idet == 1)
                    {
                      deltaE = fCPV[ism][jrow][kcol];
+                     trno   = fCPVTrackNo[ism][jrow][kcol];
                      detno = 1;
                    }
                  if (deltaE > 0.)
                    {
-                     count_digit++;
                      AddDigit(trno,detno,ism,cellno,deltaE);
                    }
                } // column loop
            } // row    loop
        } // supermodule loop
-      treeD->Fill();
+      fTreeD->Fill();
       ResetDigit();
     } // detector loop
 
-  pmdloader->WriteDigits("OVERWRITE");
-
+  fPMDLoader->WriteDigits("OVERWRITE");
   ResetCellADC();
   
   //  cout << " -------- End of Hits2Digit ----------- " << endl;
@@ -549,32 +634,35 @@ void AliPMDDigitizer::Hits2Digits(Int_t ievt)
 
 void AliPMDDigitizer::SDigits2Digits(Int_t ievt)
 {
+  // This reads the PMD sdigits tree and converts energy deposition
+  // in a cell to ADC and stores in the digits tree
+  //
   //  cout << " -------- Beginning of SDigits2Digit ----------- " << endl;
   fRunLoader->GetEvent(ievt);
 
-  treeS = pmdloader->TreeS();
+  fTreeS = fPMDLoader->TreeS();
   AliPMDsdigit  *pmdsdigit;
-  TBranch *branch = treeS->GetBranch("PMDSDigit");
+  TBranch *branch = fTreeS->GetBranch("PMDSDigit");
   branch->SetAddress(&fSDigits);
 
-  treeD = pmdloader->TreeD();
-  if (treeD == 0x0)
+  fTreeD = fPMDLoader->TreeD();
+  if (fTreeD == 0x0)
     {
-      pmdloader->MakeTree("D");
-      treeD = pmdloader->TreeD();
+      fPMDLoader->MakeTree("D");
+      fTreeD = fPMDLoader->TreeD();
     }
   Int_t bufsize = 16000;
-  treeD->Branch("PMDDigit", &fDigits, bufsize); 
+  fTreeD->Branch("PMDDigit", &fDigits, bufsize); 
 
   Int_t   trno, det, smn;
   Int_t   cellno;
   Float_t edep, adc;
 
-  Int_t nmodules = (Int_t) treeS->GetEntries();
+  Int_t nmodules = (Int_t) fTreeS->GetEntries();
 
   for (Int_t imodule = 0; imodule < nmodules; imodule++)
     {
-      treeS->GetEntry(imodule); 
+      fTreeS->GetEntry(imodule); 
       Int_t nentries = fSDigits->GetLast();
       //cout << " nentries = " << nentries << endl;
       for (Int_t ient = 0; ient < nentries+1; ient++)
@@ -587,69 +675,70 @@ void AliPMDDigitizer::SDigits2Digits(Int_t ievt)
          edep   = pmdsdigit->GetCellEdep();
 
          MeV2ADC(edep,adc);
-
          AddDigit(trno,det,smn,cellno,adc);      
        }
-      treeD->Fill();
+      fTreeD->Fill();
       ResetDigit();
     }
-  pmdloader->WriteDigits("OVERWRITE");
+  fPMDLoader->WriteDigits("OVERWRITE");
   //  cout << " -------- End of SDigits2Digit ----------- " << endl;
 }
 
 void AliPMDDigitizer::TrackAssignment2Cell()
 {
-  // To be checked again
   // 
-  // This blocks assign the cell id when there is 
+  // This block assigns the cell id when there are
   // multiple tracks in a cell according to the
   // energy deposition
   //
+  Bool_t jsort = false;
 
   Int_t i, j, k;
 
-  Float_t *frac_edp;
-  Float_t *tr_edp;
-  Int_t *status;
-  Int_t   ****PMDTrack;
-  Float_t ****PMDEdep;
-
-  PMDTrack = new Int_t ***[27];
-  PMDEdep  = new Float_t ***[27];
-  for (i=0; i<fTotSM; i++)
+  Float_t *fracEdp;
+  Float_t *trEdp;
+  Int_t *status1;
+  Int_t *status2;
+  Int_t *trnarray;
+  Int_t   ****pmdTrack;
+  Float_t ****pmdEdep;
+
+  pmdTrack = new Int_t ***[fgkTotUM];
+  pmdEdep  = new Float_t ***[fgkTotUM];
+  for (i=0; i<fgkTotUM; i++)
     {
-      PMDTrack[i] = new Int_t **[72];
-      PMDEdep[i]  = new Float_t **[72];
+      pmdTrack[i] = new Int_t **[fgkRow];
+      pmdEdep[i]  = new Float_t **[fgkRow];
     }
 
-  for (i = 0; i < fTotSM; i++)
+  for (i = 0; i < fgkTotUM; i++)
     {
-      for (j = 0; j < fNCell; j++)
+      for (j = 0; j < fgkRow; j++)
        {
-         PMDTrack[i][j] = new Int_t *[72];
-         PMDEdep[i][j]  = new Float_t *[72];
+         pmdTrack[i][j] = new Int_t *[fgkCol];
+         pmdEdep[i][j]  = new Float_t *[fgkCol];
        }
     }
   
-  for (i = 0; i < fTotSM; i++)
+  for (i = 0; i < fgkTotUM; i++)
     {
-      for (j = 0; j < fNCell; j++)
+      for (j = 0; j < fgkRow; j++)
        {
-         for (k = 0; k < fNCell; k++)
+         for (k = 0; k < fgkCol; k++)
            {
-             Int_t nn = fPMDCounter[i][j][k];
+             Int_t nn = fPRECounter[i][j][k];
              if(nn > 0)
                {
-                 PMDTrack[i][j][k] = new Int_t[nn];
-                 PMDEdep[i][j][k] = new Float_t[nn];
+                 pmdTrack[i][j][k] = new Int_t[nn];
+                 pmdEdep[i][j][k] = new Float_t[nn];
                }
              else
                {
                  nn = 1;
-                 PMDTrack[i][j][k] = new Int_t[nn];
-                 PMDEdep[i][j][k] = new Float_t[nn];
+                 pmdTrack[i][j][k] = new Int_t[nn];
+                 pmdEdep[i][j][k] = new Float_t[nn];
                }                     
-             fPMDCounter[i][j][k] = 0;
+             fPRECounter[i][j][k] = 0;
            }
        }
     }
@@ -662,104 +751,102 @@ void AliPMDDigitizer::TrackAssignment2Cell()
 
   for (i = 0; i < nentries; i++)
     {
-      pmdcell = (AliPMDcell*)fCell->UncheckedAt(i);
+      fPMDcell = (AliPMDcell*)fCell->UncheckedAt(i);
       
-      mtrackno = pmdcell->GetTrackNumber();
-      ism = pmdcell->GetSMNumber();
-      ixp = pmdcell->GetX();
-      iyp = pmdcell->GetY();
-      edep = pmdcell->GetEdep();
-
-      Int_t nn = fPMDCounter[ism][ixp][iyp];
-
+      mtrackno = fPMDcell->GetTrackNumber();
+      ism      = fPMDcell->GetSMNumber();
+      ixp      = fPMDcell->GetX();
+      iyp      = fPMDcell->GetY();
+      edep     = fPMDcell->GetEdep();
+      Int_t nn = fPRECounter[ism][ixp][iyp];
       //      cout << " nn = " << nn << endl;
-      
-      PMDTrack[ism][ixp][iyp][nn] = (Int_t) mtrackno;
-      PMDEdep[ism][ixp][iyp][nn] = edep;
-      fPMDCounter[ism][ixp][iyp]++;
+      pmdTrack[ism][ixp][iyp][nn] = (Int_t) mtrackno;
+      pmdEdep[ism][ixp][iyp][nn] = edep;
+      fPRECounter[ism][ixp][iyp]++;
     }
   
   Int_t iz, il;
   Int_t im, ix, iy;
   Int_t nn;
   
-  for (im=0; im<27; im++)
+  for (im=0; im<fgkTotUM; im++)
     {
-      for (ix=0; ix<72; ix++)
+      for (ix=0; ix<fgkRow; ix++)
        {
-         for (iy=0; iy<72; iy++)
+         for (iy=0; iy<fgkCol; iy++)
            {
-             nn = fPMDCounter[im][ix][iy];
+             nn = fPRECounter[im][ix][iy];
              if (nn > 1)
                {
                  // This block handles if a cell is fired
                  // many times by many tracks
-                 
-                 status = new Int_t[nn];
+                 status1  = new Int_t[nn];
+                 status2  = new Int_t[nn];
+                 trnarray = new Int_t[nn];
                  for (iz = 0; iz < nn; iz++)
                    {
-                     status[iz] = PMDTrack[im][ix][iy][iz];
+                     status1[iz] = pmdTrack[im][ix][iy][iz];
                    }
-                 sort(status,status+nn);
-                 Int_t track_old = -99999;
-                 Int_t track, tr_count = 0;
+                 TMath::Sort(nn,status1,status2,jsort);
+                 Int_t trackOld = -99999;
+                 Int_t track, trCount = 0;
                  for (iz = 0; iz < nn; iz++)
                    {
-                     track = status[iz];
-                     if (track_old != track)
+                     track = status1[status2[iz]];
+                     if (trackOld != track)
                        {
-                         tr_count++;
-                         vjunkTRN.push_back(track);
+                         trnarray[trCount] = track;
+                         trCount++;
                        }                             
-                     track_old = track;
+                     trackOld = track;
                    }
-                 delete status;
-                 Float_t tot_edp = 0.;
-                 tr_edp = new Float_t[tr_count];
-                 frac_edp = new Float_t[tr_count];
-                 for (il = 0; il < tr_count; il++)
+                 delete status1;
+                 delete status2;
+                 Float_t totEdp = 0.;
+                 trEdp = new Float_t[trCount];
+                 fracEdp = new Float_t[trCount];
+                 for (il = 0; il < trCount; il++)
                    {
-                     tr_edp[il] = 0.;
-                     track = vjunkTRN[il];
+                     trEdp[il] = 0.;
+                     track = trnarray[il];
                      for (iz = 0; iz < nn; iz++)
                        {
-                         if (track == PMDTrack[im][ix][iy][iz])
+                         if (track == pmdTrack[im][ix][iy][iz])
                            {
-                             tr_edp[il] += PMDEdep[im][ix][iy][iz];
+                             trEdp[il] += pmdEdep[im][ix][iy][iz];
                            }
                        }
-                     tot_edp += tr_edp[il];
+                     totEdp += trEdp[il];
                    }
-                 vjunkTRN.clear();
-                 Int_t il_old = 0;
-                 Float_t frac_old = 0.;
+                 Int_t ilOld = 0;
+                 Float_t fracOld = 0.;
                  
-                 for (il = 0; il < tr_count; il++)
+                 for (il = 0; il < trCount; il++)
                    {
-                     frac_edp[il] = tr_edp[il]/tot_edp;
-                     if (frac_old < frac_edp[il])
+                     fracEdp[il] = trEdp[il]/totEdp;
+                     if (fracOld < fracEdp[il])
                        {
-                         frac_old = frac_edp[il];
-                         il_old = il;
+                         fracOld = fracEdp[il];
+                         ilOld = il;
                        }
                    }
-                 delete frac_edp;
-                 delete tr_edp;
-                 
-                 fPMDTrackNo[im][ix][iy] = vjunkTRN[il_old];
+                 fPRETrackNo[im][ix][iy] = trnarray[ilOld];
+                 delete fracEdp;
+                 delete trEdp;
+                 delete trnarray;
                }
              else if (nn == 1)
                {
                  // This only handles if a cell is fired
                  // by only one track
                  
-                 fPMDTrackNo[im][ix][iy] = PMDTrack[im][ix][iy][0];
+                 fPRETrackNo[im][ix][iy] = pmdTrack[im][ix][iy][0];
                  
                }
              else if (nn ==0)
                {
                  // This is if no cell is fired
-                 fPMDTrackNo[im][ix][iy] = -999;
+                 fPRETrackNo[im][ix][iy] = -999;
                }
            } // end of iy
        } // end of ix
@@ -767,49 +854,53 @@ void AliPMDDigitizer::TrackAssignment2Cell()
   
   // Delete all the pointers
   
-  for (i = 0; i < fTotSM; i++)
+  for (i = 0; i < fgkTotUM; i++)
     {
-      for (j = 0; j < fNCell; j++)
+      for (j = 0; j < fgkRow; j++)
        {
-         for (k = 0; k < fNCell; k++)
+         for (k = 0; k < fgkCol; k++)
            {
-             delete [] PMDTrack[i][j][k];
-             delete [] PMDEdep[i][j][k];
+             delete [] pmdTrack[i][j][k];
+             delete [] pmdEdep[i][j][k];
            }
        }
     }
   
-  for (i = 0; i < fTotSM; i++)
+  for (i = 0; i < fgkTotUM; i++)
     {
-      for (j = 0; j < fNCell; j++)
+      for (j = 0; j < fgkRow; j++)
        {
-         delete [] PMDTrack[i][j];
-         delete [] PMDEdep[i][j];
+         delete [] pmdTrack[i][j];
+         delete [] pmdEdep[i][j];
        }
     }
   
-  for (i = 0; i < fTotSM; i++)
+  for (i = 0; i < fgkTotUM; i++)
     {
-      delete [] PMDTrack[i];
-      delete [] PMDEdep[i];
+      delete [] pmdTrack[i];
+      delete [] pmdEdep[i];
     }
-  delete PMDTrack;
-  delete PMDEdep;
+  delete pmdTrack;
+  delete pmdEdep;
   // 
   // End of the cell id assignment
   //
 }
 
 
-void AliPMDDigitizer::MeV2ADC(Float_t mev, Float_t & adc)
+void AliPMDDigitizer::MeV2ADC(Float_t mev, Float_t & adc) const
 {
+  // This converts the simulated edep to ADC according to the
+  // Test Beam Data
   // To be done
-
+  //
   adc = mev*1.;
 }
 void AliPMDDigitizer::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber, 
   Int_t cellnumber, Float_t adc)
 {
+  // Add SDigit
+  //
   TClonesArray &lsdigits = *fSDigits;
   AliPMDsdigit *newcell;
   newcell = new AliPMDsdigit(trnumber,det,smnumber,cellnumber,adc);
@@ -820,6 +911,8 @@ void AliPMDDigitizer::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
 void AliPMDDigitizer::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber, 
   Int_t cellnumber, Float_t adc)
 {
+  // Add Digit
+  //
   TClonesArray &ldigits = *fDigits;
   AliPMDdigit *newcell;
   newcell = new AliPMDdigit(trnumber,det,smnumber,cellnumber,adc);
@@ -827,43 +920,6 @@ void AliPMDDigitizer::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
   delete newcell;
 }
 
-Int_t AliPMDDigitizer::Convert2RealSMNumber(Int_t smnumber1)
-{
-  Int_t smnumber = -999;
-
-  if (smnumber1==1)  smnumber =  1;
-  if (smnumber1==2)  smnumber = 10;
-  if (smnumber1==3)  smnumber = 19;
-  if (smnumber1==4)  smnumber =  1;
-  if (smnumber1==5)  smnumber = 10;
-  if (smnumber1==6)  smnumber = 19;
-  if (smnumber1==7)  smnumber =  2;
-  if (smnumber1==8)  smnumber =  3;
-  if (smnumber1==9)  smnumber =  4;
-  if (smnumber1==10) smnumber =  5;
-  if (smnumber1==11) smnumber =  6;
-  if (smnumber1==12) smnumber =  7;
-  if (smnumber1==13) smnumber =  8;
-  if (smnumber1==14) smnumber =  9;
-  if (smnumber1==15) smnumber = 11;
-  if (smnumber1==16) smnumber = 12;
-  if (smnumber1==17) smnumber = 13;
-  if (smnumber1==18) smnumber = 14;
-  if (smnumber1==19) smnumber = 15;
-  if (smnumber1==20) smnumber = 16;
-  if (smnumber1==21) smnumber = 17;
-  if (smnumber1==22) smnumber = 18;
-  if (smnumber1==23) smnumber = 20;
-  if (smnumber1==24) smnumber = 21;
-  if (smnumber1==25) smnumber = 22;
-  if (smnumber1==26) smnumber = 23;
-  if (smnumber1==27) smnumber = 24;
-  if (smnumber1==28) smnumber = 25;
-  if (smnumber1==29) smnumber = 26;
-  if (smnumber1==30) smnumber = 27;
-
-  return smnumber;
-}
 void AliPMDDigitizer::SetZPosition(Float_t zpos)
 {
   fZPos = zpos;
@@ -875,39 +931,45 @@ Float_t AliPMDDigitizer::GetZPosition() const
 
 void AliPMDDigitizer::ResetCell()
 {
+  // clears the cell array and also the counter
+  //  for each cell
+  //
   fCell->Clear();
-  for (Int_t i = 0; i < fTotSM; i++)
+  for (Int_t i = 0; i < fgkTotUM; i++)
     {
-      for (Int_t j = 0; j < fNCell; j++)
+      for (Int_t j = 0; j < fgkRow; j++)
        {
-         for (Int_t k = 0; k < fNCell; k++)
+         for (Int_t k = 0; k < fgkCol; k++)
            {
-             fPMDCounter[i][j][k] = 0; 
+             fPRECounter[i][j][k] = 0; 
            }
        }
     }
 }
 void AliPMDDigitizer::ResetSDigit()
 {
+  // Clears SDigits
   fNsdigit = 0;
   if (fSDigits) fSDigits->Clear();
 }
 void AliPMDDigitizer::ResetDigit()
 {
+  // Clears Digits
   fNdigit = 0;
   if (fDigits) fDigits->Clear();
 }
 
 void AliPMDDigitizer::ResetCellADC()
 {
-  for (Int_t i = 0; i < fTotSM; i++)
+  // Clears individual cells edep
+  for (Int_t i = 0; i < fgkTotUM; i++)
     {
-      for (Int_t j = 0; j < fNCell; j++)
+      for (Int_t j = 0; j < fgkRow; j++)
        {
-         for (Int_t k = 0; k < fNCell; k++)
+         for (Int_t k = 0; k < fgkCol; k++)
            {
              fCPV[i][j][k] = 0.; 
-             fPMD[i][j][k] = 0.; 
+             fPRE[i][j][k] = 0.; 
            }
        }
     }
@@ -915,6 +977,8 @@ void AliPMDDigitizer::ResetCellADC()
 
 void AliPMDDigitizer::UnLoad(Option_t *option)
 {
+  // Unloads all the root files
+  //
   const char *cS = strstr(option,"S");
   const char *cD = strstr(option,"D");
 
@@ -924,11 +988,11 @@ void AliPMDDigitizer::UnLoad(Option_t *option)
 
   if (cS)
     {
-      pmdloader->UnloadHits();
+      fPMDLoader->UnloadHits();
     }
   if (cD)
     {
-      pmdloader->UnloadHits();
-      pmdloader->UnloadSDigits();
+      fPMDLoader->UnloadHits();
+      fPMDLoader->UnloadSDigits();
     }
 }