+ Float_t adc = 0.;
+ Float_t deltaE = 0.;
+ Int_t detno = 0;
+ Int_t trno = 1;
+ Int_t trpid = -99;
+
+ for (Int_t idet = 0; idet < 2; idet++)
+ {
+ for (Int_t ism = 0; ism < fgkTotUM; ism++)
+ {
+ for (Int_t jrow = 0; jrow < fgkRow; jrow++)
+ {
+ for (Int_t kcol = 0; kcol < fgkCol; kcol++)
+ {
+ if (idet == 0)
+ {
+ deltaE = fPRE[ism][jrow][kcol];
+ trno = fPRETrackNo[ism][jrow][kcol];
+ trpid = fPRETrackPid[ism][jrow][kcol];
+ detno = 0;
+ }
+ else if (idet == 1)
+ {
+ deltaE = fCPV[ism][jrow][kcol];
+ trno = fCPVTrackNo[ism][jrow][kcol];
+ trpid = fCPVTrackPid[ism][jrow][kcol];
+ detno = 1;
+ }
+ if (deltaE > 0.)
+ {
+ MeV2ADC(deltaE,adc);
+
+ //
+ // Gain decalibration
+ //
+ Float_t gain1 = Gain(idet,ism,jrow,kcol);
+
+ if (gain1 != 0.)
+ {
+ Int_t adcDecalib = (Int_t)(adc/gain1);
+ adc = (Float_t) adcDecalib;
+ }
+ else if(gain1 == 0.)
+ {
+ adc = 0.;
+ }
+ // Pedestal Decalibration
+ Int_t pedmeanrms =
+ fCalibPed->GetPedMeanRms(idet,ism,jrow,kcol);
+ Int_t pedrms1 = (Int_t) pedmeanrms%100;
+ Float_t pedrms = (Float_t)pedrms1/10.;
+ Float_t pedmean =
+ (Float_t) (pedmeanrms - pedrms1)/1000.0;
+ if (adc > 0.)
+ {
+ adc += (pedmean + 3.0*pedrms);
+ AddDigit(trno,trpid,detno,ism,jrow,kcol,adc);
+ }
+
+ }
+ } // column loop
+ } // row loop
+ treeD->Fill();
+ ResetDigit();
+ } // supermodule loop
+ } // detector loop
+ fPMDLoader->WriteDigits("OVERWRITE");
+ fPMDLoader->UnloadDigits();
+ ResetCellADC();
+}
+//____________________________________________________________________________
+void AliPMDDigitizer::TrackAssignment2CPVCell()
+{
+ // This block assigns the cell id when there are
+ // multiple tracks in a cell according to the
+ // energy deposition
+ // This method added by Ajay
+ Bool_t jsort = false;
+
+ Int_t i = 0, j = 0, k = 0;
+
+ Int_t *status1;
+ Int_t *status2;
+ Int_t *trnarray;
+ Float_t *fracEdp;
+ Float_t *trEdp;
+
+ Int_t ****cpvTrack;
+ Float_t ****cpvEdep;
+
+ cpvTrack = new Int_t ***[fgkTotUM];
+ cpvEdep = new Float_t ***[fgkTotUM];
+ for (i=0; i<fgkTotUM; i++)
+ {
+ cpvTrack[i] = new Int_t **[fgkRow];
+ cpvEdep[i] = new Float_t **[fgkRow];
+ }
+
+ for (i = 0; i < fgkTotUM; i++)
+ {
+ for (j = 0; j < fgkRow; j++)
+ {
+ cpvTrack[i][j] = new Int_t *[fgkCol];
+ cpvEdep[i][j] = new Float_t *[fgkCol];
+ }
+ }
+ for (i = 0; i < fgkTotUM; i++)
+ {
+ for (j = 0; j < fgkRow; j++)
+ {
+ for (k = 0; k < fgkCol; k++)
+ {
+ Int_t nn = fCPVCounter[i][j][k];
+ if(nn > 0)
+ {
+ cpvTrack[i][j][k] = new Int_t[nn];
+ cpvEdep[i][j][k] = new Float_t[nn];
+ }
+ else
+ {
+ nn = 1;
+ cpvTrack[i][j][k] = new Int_t[nn];
+ cpvEdep[i][j][k] = new Float_t[nn];
+ }
+ fCPVCounter[i][j][k] = 0;
+ }
+ }
+ }
+
+
+ Int_t nentries = fCPVCell.GetEntries();
+
+ Int_t mtrackno = 0, ism = 0, ixp = 0, iyp = 0;
+ Float_t edep = 0.;
+ for (i = 0; i < nentries; i++)
+ {
+ AliPMDcell* cpvcell = (AliPMDcell*)fCPVCell.UncheckedAt(i);
+
+ mtrackno = cpvcell->GetTrackNumber();
+ ism = cpvcell->GetSMNumber();
+ ixp = cpvcell->GetX();
+ iyp = cpvcell->GetY();
+ edep = cpvcell->GetEdep();
+ Int_t nn = fCPVCounter[ism][ixp][iyp];
+ cpvTrack[ism][ixp][iyp][nn] = (Int_t) mtrackno;
+ cpvEdep[ism][ixp][iyp][nn] = edep;
+ fCPVCounter[ism][ixp][iyp]++;
+ }
+
+ Int_t iz = 0, il = 0;
+ Int_t im = 0, ix = 0, iy = 0;
+ Int_t nn = 0;
+ for (im=0; im<fgkTotUM; im++)
+ {
+ for (ix=0; ix<fgkRow; ix++)
+ {
+ for (iy=0; iy<fgkCol; iy++)
+ {
+ nn = fCPVCounter[im][ix][iy];
+ if (nn > 1)
+ {
+ // This block handles if a cell is fired
+ // many times by many tracks
+ status1 = new Int_t[nn];
+ status2 = new Int_t[2*nn];
+ trnarray = new Int_t[nn];
+ for (iz = 0; iz < nn; iz++)
+ {
+ status1[iz] = cpvTrack[im][ix][iy][iz];
+ }
+ TMath::Sort(nn,status1,status2,jsort);
+ Int_t trackOld = -99999;
+ Int_t track, trCount = 0;
+ for (iz = 0; iz < nn; iz++)
+ {
+ track = status1[status2[iz]];
+ if (trackOld != track)
+ {
+ trnarray[trCount] = track;
+ trCount++;
+ }
+ trackOld = track;
+ }
+ delete [] status1;
+ delete [] status2;
+ Float_t totEdp = 0.;
+ trEdp = new Float_t[trCount];
+ fracEdp = new Float_t[trCount];
+ for (il = 0; il < trCount; il++)
+ {
+ trEdp[il] = 0.;
+ track = trnarray[il];
+ for (iz = 0; iz < nn; iz++)
+ {
+ if (track == cpvTrack[im][ix][iy][iz])
+ {
+ trEdp[il] += cpvEdep[im][ix][iy][iz];
+ }
+ }
+ totEdp += trEdp[il];
+ }
+ Int_t ilOld = 0;
+ Float_t fracOld = 0.;
+
+ for (il = 0; il < trCount; il++)
+ {
+ fracEdp[il] = trEdp[il]/totEdp;
+ if (fracOld < fracEdp[il])
+ {
+ fracOld = fracEdp[il];
+ ilOld = il;
+ }
+ }
+ fCPVTrackNo[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
+
+ fCPVTrackNo[im][ix][iy] = cpvTrack[im][ix][iy][0];
+
+ }
+ else if (nn ==0)
+ {
+ // This is if no cell is fired
+ fCPVTrackNo[im][ix][iy] = -999;
+ }
+ } // end of iy
+ } // end of ix
+ } // end of im
+
+ // Delete all the pointers
+
+ for (i = 0; i < fgkTotUM; i++)
+ {
+ for (j = 0; j < fgkRow; j++)
+ {
+ for (k = 0; k < fgkCol; k++)
+ {
+ delete []cpvTrack[i][j][k];
+ delete []cpvEdep[i][j][k];
+ }
+ }
+ }
+
+ for (i = 0; i < fgkTotUM; i++)
+ {
+ for (j = 0; j < fgkRow; j++)
+ {
+ delete [] cpvTrack[i][j];
+ delete [] cpvEdep[i][j];
+ }
+ }
+
+ for (i = 0; i < fgkTotUM; i++)
+ {
+ delete [] cpvTrack[i];
+ delete [] cpvEdep[i];
+ }
+ delete [] cpvTrack;
+ delete [] cpvEdep;
+
+ //
+ // End of the cell id assignment
+ //
+}
+//____________________________________________________________________________
+
+void AliPMDDigitizer::MergeSDigits(Int_t filenumber, Int_t troffset)
+{
+ // merging sdigits
+ fRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(filenumber));
+ fPMDLoader = fRunLoader->GetLoader("PMDLoader");
+ fPMDLoader->LoadSDigits("read");
+ TTree* treeS = fPMDLoader->TreeS();
+ AliPMDsdigit *pmdsdigit;
+ TBranch *branch = treeS->GetBranch("PMDSDigit");
+ if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
+ branch->SetAddress(&fSDigits);
+
+ Int_t itrackno = 1, itrackpid = 0, idet = 0, ism = 0;
+ Int_t ixp = 0, iyp = 0;
+ Float_t edep = 0.;
+ Int_t nmodules = (Int_t) treeS->GetEntries();
+ AliDebug(1,Form("Number of Modules in the treeS = %d",nmodules));
+ AliDebug(1,Form("Track Offset = %d",troffset));
+ for (Int_t imodule = 0; imodule < nmodules; imodule++)
+ {
+ treeS->GetEntry(imodule);
+ Int_t nentries = fSDigits->GetLast();
+ AliDebug(2,Form("Number of Entries per Module = %d",nentries));
+ for (Int_t ient = 0; ient < nentries+1; ient++)
+ {
+ pmdsdigit = (AliPMDsdigit*)fSDigits->UncheckedAt(ient);
+ itrackno = pmdsdigit->GetTrackNumber();
+ itrackpid = pmdsdigit->GetTrackPid();
+ idet = pmdsdigit->GetDetector();
+ ism = pmdsdigit->GetSMNumber();
+ ixp = pmdsdigit->GetRow();
+ iyp = pmdsdigit->GetColumn();
+ edep = pmdsdigit->GetCellEdep();
+ if (idet == 0)
+ {
+ if (fPRE[ism][ixp][iyp] < edep)
+ {
+ fPRETrackNo[ism][ixp][iyp] = troffset + itrackno;
+ fPRETrackPid[ism][ixp][iyp] = itrackpid;
+ }
+ fPRE[ism][ixp][iyp] += edep;
+ }
+ else if (idet == 1)
+ {
+ if (fCPV[ism][ixp][iyp] < edep)
+ {
+ fCPVTrackNo[ism][ixp][iyp] = troffset + itrackno;
+ fCPVTrackPid[ism][ixp][iyp] = itrackpid;
+ }
+ fCPV[ism][ixp][iyp] += edep;
+ }
+ }
+ }
+
+}
+// ----------------------------------------------------------------------