1 /***************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 //-----------------------------------------------------//
17 // Source File : PMDDigitizer.cxx, Version 00 //
19 // Date : September 20 2002 //
21 //-----------------------------------------------------//
23 #include <Riostream.h>
27 #include <TGeometry.h>
28 #include <TObjArray.h>
29 #include <TClonesArray.h>
32 #include <TParticle.h>
38 #include "AliDetector.h"
39 #include "AliRunLoader.h"
40 #include "AliLoader.h"
41 #include "AliConfig.h"
43 #include "AliRunDigitizer.h"
44 #include "AliDigitizer.h"
45 #include "AliHeader.h"
46 #include "AliCDBManager.h"
47 #include "AliCDBStorage.h"
48 #include "AliCDBEntry.h"
52 #include "AliPMDhit.h"
53 #include "AliPMDcell.h"
54 #include "AliPMDsdigit.h"
55 #include "AliPMDdigit.h"
56 #include "AliPMDCalibData.h"
57 #include "AliPMDPedestal.h"
58 #include "AliPMDDigitizer.h"
61 ClassImp(AliPMDDigitizer)
63 AliPMDDigitizer::AliPMDDigitizer() :
68 fCalibGain(GetCalibGain()),
69 fCalibPed(GetCalibPed()),
77 fZPos(361.5) // in units of cm, default position of PMD
79 // Default Constructor
81 for (Int_t i = 0; i < fgkTotUM; i++)
83 for (Int_t j = 0; j < fgkRow; j++)
85 for (Int_t k = 0; k < fgkCol; k++)
89 fCPVCounter[i][j][k] = 0;
90 fPRECounter[i][j][k] = 0;
91 fCPVTrackNo[i][j][k] = -1;
92 fPRETrackNo[i][j][k] = -1;
93 fCPVTrackPid[i][j][k] = -1;
94 fPRETrackPid[i][j][k] = -1;
100 //____________________________________________________________________________
101 AliPMDDigitizer::AliPMDDigitizer(const AliPMDDigitizer& digitizer):
102 AliDigitizer(digitizer),
107 fCalibGain(GetCalibGain()),
108 fCalibPed(GetCalibPed()),
116 fZPos(361.5) // in units of cm, default position of PMD
119 AliError("Copy constructor not allowed ");
122 //____________________________________________________________________________
123 AliPMDDigitizer & AliPMDDigitizer::operator=(const AliPMDDigitizer& /*digitizer*/)
125 // Assignment operator
126 AliError("Assignement operator not allowed ");
130 //____________________________________________________________________________
131 AliPMDDigitizer::AliPMDDigitizer(AliRunDigitizer* manager):
132 AliDigitizer(manager),
137 fCalibGain(GetCalibGain()),
138 fCalibPed(GetCalibPed()),
139 fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
140 fDigits(new TClonesArray("AliPMDdigit", 1000)),
146 fZPos(361.5)// in units of cm, This is the default position of PMD
148 // ctor which should be used
151 for (Int_t i = 0; i < fgkTotUM; i++)
153 for (Int_t j = 0; j < fgkRow; j++)
155 for (Int_t k = 0; k < fgkCol; k++)
159 fCPVCounter[i][j][k] = 0;
160 fPRECounter[i][j][k] = 0;
161 fCPVTrackNo[i][j][k] = -1;
162 fPRETrackNo[i][j][k] = -1;
163 fCPVTrackPid[i][j][k] = -1;
164 fPRETrackPid[i][j][k] = -1;
170 //____________________________________________________________________________
171 AliPMDDigitizer::~AliPMDDigitizer()
173 // Default Destructor
191 //____________________________________________________________________________
192 void AliPMDDigitizer::OpengAliceFile(const char *file, Option_t *option)
194 // Loads galice.root file and corresponding header, kinematics
195 // hits and sdigits or digits depending on the option
198 TString evfoldname = AliConfig::GetDefaultEventFolderName();
199 fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
201 fRunLoader = AliRunLoader::Open(file,AliConfig::GetDefaultEventFolderName(), "UPDATE");
205 AliError(Form("Can not open session for file %s.",file));
208 const char *cHS = strstr(option,"HS");
209 const char *cHD = strstr(option,"HD");
210 const char *cSD = strstr(option,"SD");
214 if (!fRunLoader->GetAliRun()) fRunLoader->LoadgAlice();
215 if (!fRunLoader->TreeE()) fRunLoader->LoadHeader();
216 if (!fRunLoader->TreeK()) fRunLoader->LoadKinematics();
218 gAlice = fRunLoader->GetAliRun();
222 AliDebug(1,"Alirun object found");
226 AliError("Could not found Alirun object");
229 fPMD = (AliPMD*)gAlice->GetDetector("PMD");
232 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
233 if (fPMDLoader == 0x0)
235 AliError("Can not find PMDLoader");
241 fPMDLoader->LoadHits("READ");
242 fPMDLoader->LoadSDigits("recreate");
246 fPMDLoader->LoadHits("READ");
247 fPMDLoader->LoadDigits("recreate");
251 fPMDLoader->LoadSDigits("READ");
252 fPMDLoader->LoadDigits("recreate");
255 //____________________________________________________________________________
256 void AliPMDDigitizer::Hits2SDigits(Int_t ievt)
258 // This reads the PMD Hits tree and assigns the right track number
259 // to a cell and stores in the summable digits tree
262 const Int_t kPi0 = 111;
263 const Int_t kGamma = 22;
271 Float_t xPos, yPos, zPos;
272 Int_t xpad = -1, ypad = -1;
274 Float_t vx = -999.0, vy = -999.0, vz = -999.0;
277 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
280 AliDebug(1,Form("Event Number = %d",ievt));
281 Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
282 AliDebug(1,Form("Number of Particles = %d",nparticles));
286 fRunLoader->GetEvent(ievt);
287 // ------------------------------------------------------- //
288 // Pointer to specific detector hits.
289 // Get pointers to Alice detectors and Hits containers
291 TTree* treeH = fPMDLoader->TreeH();
293 Int_t ntracks = (Int_t) treeH->GetEntries();
294 AliDebug(1,Form("Number of Tracks in the TreeH = %d", ntracks));
295 TTree* treeS = fPMDLoader->TreeS();
298 fPMDLoader->MakeTree("S");
299 treeS = fPMDLoader->TreeS();
301 Int_t bufsize = 16000;
302 treeS->Branch("PMDSDigit", &fSDigits, bufsize);
304 TClonesArray* hits = 0;
305 if (fPMD) hits = fPMD->Hits();
307 // Start loop on tracks in the hits containers
309 for (Int_t track=0; track<ntracks;track++)
311 gAlice->GetMCApp()->ResetHits();
312 treeH->GetEvent(track);
315 npmd = hits->GetEntriesFast();
316 for (Int_t ipmd = 0; ipmd < npmd; ipmd++)
318 fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
319 trackno = fPMDHit->GetTrack();
320 // get kinematics of the particles
322 TParticle* mparticle = gAlice->GetMCApp()->Particle(trackno);
323 trackpid = mparticle->GetPdgCode();
324 Int_t ks = mparticle->GetStatusCode();
326 Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
328 if (mparticle->GetFirstMother() == -1)
330 tracknoOld = trackno;
331 trackpidOld = trackpid;
336 Int_t trnotemp = trackno; // Modified on 25th Nov 2009
337 if(ks==1||(imo = mparticle->GetFirstMother())<0 ){
338 vx = mparticle->Vx();
339 vy = mparticle->Vy();
340 vz = mparticle->Vz();
342 if(trackpid==kGamma||trackpid==11||trackpid==-11||
343 trackpid==kPi0)igstatus=1;
347 while(((imo = mparticle->GetFirstMother()) >= 0)&&
348 (ks = mparticle->GetStatusCode() <1) )
350 mparticle = gAlice->GetMCApp()->Particle(imo);
351 trackpid = mparticle->GetPdgCode();
352 ks = mparticle->GetStatusCode();
353 vx = mparticle->Vx();
354 vy = mparticle->Vy();
355 vz = mparticle->Vz();
357 // Modified on 25th Nov 2009
368 // end of modification on 25th Nov 2009
371 if(trackpid==kGamma||trackpid==11||trackpid==-11||
372 trackpid==kPi0)igstatus=1;
375 trackpid=trackpidOld;
378 //-----------------end of modification----------------
383 edep = fPMDHit->GetEnergy();
384 Int_t vol1 = fPMDHit->GetVolume(1); // Column
385 Int_t vol2 = fPMDHit->GetVolume(2); // Row
386 Int_t vol7 = fPMDHit->GetVolume(4); // Serial Module No
389 // -----------------------------------------//
390 // In new geometry after adding electronics //
391 // For Super Module 1 & 2 //
392 // nrow = 48, ncol = 96 //
393 // For Super Module 3 & 4 //
394 // nrow = 96, ncol = 48 //
395 // -----------------------------------------//
403 smnumber = vol7 - 24;
405 Int_t vol8 = smnumber/6 + 1; // fake supermodule
407 if (vol8 == 1 || vol8 == 2)
412 else if (vol8 == 3 || vol8 == 4)
418 AliDebug(2,Form("Zposition = %f Edeposition = %f",zPos,edep));
419 //Float_t zposition = TMath::Abs(zPos);
425 else if (zPos > fZPos)
431 Int_t smn = smnumber;
432 Int_t ixx = xpad - 1;
433 Int_t iyy = ypad - 1;
436 fPRE[smn][ixx][iyy] += edep;
437 fPRECounter[smn][ixx][iyy]++;
439 AliPMDcell* cell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
444 fCPV[smn][ixx][iyy] += edep;
445 fCPVCounter[smn][ixx][iyy]++;
446 AliPMDcell* cpvcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
447 fCPVCell.Add(cpvcell);
451 } // Track Loop ended
452 TrackAssignment2CPVCell();
453 TrackAssignment2Cell();
461 for (Int_t idet = 0; idet < 2; idet++)
463 for (Int_t ism = 0; ism < fgkTotUM; ism++)
465 for (Int_t jrow = 0; jrow < fgkRow; jrow++)
467 for (Int_t kcol = 0; kcol < fgkCol; kcol++)
471 deltaE = fPRE[ism][jrow][kcol];
472 trno = fPRETrackNo[ism][jrow][kcol];
477 deltaE = fCPV[ism][jrow][kcol];
478 trno = fCPVTrackNo[ism][jrow][kcol];
484 TParticle *mparticle = gAlice->GetMCApp()->Particle(trno);
485 trpid = mparticle->GetPdgCode();
486 AddSDigit(trno,trpid,detno,ism,jrow,kcol,deltaE);
494 fPMDLoader->WriteSDigits("OVERWRITE");
497 //____________________________________________________________________________
499 void AliPMDDigitizer::Hits2Digits(Int_t ievt)
501 // This reads the PMD Hits tree and assigns the right track number
502 // to a cell and stores in the digits tree
504 const Int_t kPi0 = 111;
505 const Int_t kGamma = 22;
513 Float_t xPos, yPos, zPos;
514 Int_t xpad = -1, ypad = -1;
516 Float_t vx = -999.0, vy = -999.0, vz = -999.0;
518 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
521 AliDebug(1,Form("Event Number = %d",ievt));
522 Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
523 AliDebug(1,Form("Number of Particles = %d", nparticles));
525 fRunLoader->GetEvent(ievt);
526 // ------------------------------------------------------- //
527 // Pointer to specific detector hits.
528 // Get pointers to Alice detectors and Hits containers
530 fPMD = (AliPMD*)gAlice->GetDetector("PMD");
531 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
533 if (fPMDLoader == 0x0)
535 AliError("Can not find PMD or PMDLoader");
537 TTree* treeH = fPMDLoader->TreeH();
538 Int_t ntracks = (Int_t) treeH->GetEntries();
539 AliDebug(1,Form("Number of Tracks in the TreeH = %d", ntracks));
540 fPMDLoader->LoadDigits("recreate");
541 TTree* treeD = fPMDLoader->TreeD();
544 fPMDLoader->MakeTree("D");
545 treeD = fPMDLoader->TreeD();
547 Int_t bufsize = 16000;
548 treeD->Branch("PMDDigit", &fDigits, bufsize);
550 TClonesArray* hits = 0;
551 if (fPMD) hits = fPMD->Hits();
553 // Start loop on tracks in the hits containers
555 for (Int_t track=0; track<ntracks;track++)
557 gAlice->GetMCApp()->ResetHits();
558 treeH->GetEvent(track);
562 npmd = hits->GetEntriesFast();
563 for (Int_t ipmd = 0; ipmd < npmd; ipmd++)
565 fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
566 trackno = fPMDHit->GetTrack();
568 // get kinematics of the particles
570 TParticle* mparticle = gAlice->GetMCApp()->Particle(trackno);
571 trackpid = mparticle->GetPdgCode();
572 Int_t ks = mparticle->GetStatusCode();
574 Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
575 if (mparticle->GetFirstMother() == -1)
577 tracknoOld = trackno;
578 trackpidOld = trackpid;
584 Int_t trnotemp = trackno; // modified on 25th Nov 2009
585 if(ks==1||(imo = mparticle->GetFirstMother())<0 ){
586 vx = mparticle->Vx();
587 vy = mparticle->Vy();
588 vz = mparticle->Vz();
590 if(trackpid==kGamma||trackpid==11||trackpid==-11||trackpid==kPi0)
595 while(((imo = mparticle->GetFirstMother()) >= 0)&&
596 (ks = mparticle->GetStatusCode() <1) )
598 mparticle = gAlice->GetMCApp()->Particle(imo);
599 trackpid = mparticle->GetPdgCode();
600 ks = mparticle->GetStatusCode();
601 vx = mparticle->Vx();
602 vy = mparticle->Vy();
603 vz = mparticle->Vz();
605 // Modified on 25th Nov 2009
618 if(trackpid==kGamma||trackpid==11||trackpid==-11||trackpid==kPi0)
622 trackpid=trackpidOld;
628 edep = fPMDHit->GetEnergy();
629 Int_t vol1 = fPMDHit->GetVolume(1); // Column
630 Int_t vol2 = fPMDHit->GetVolume(2); // Row
631 Int_t vol7 = fPMDHit->GetVolume(4); // Serial Module No
633 // -----------------------------------------//
634 // In new geometry after adding electronics //
635 // For Super Module 1 & 2 //
636 // nrow = 48, ncol = 96 //
637 // For Super Module 3 & 4 //
638 // nrow = 96, ncol = 48 //
639 // -----------------------------------------//
647 smnumber = vol7 - 24;
649 Int_t vol8 = smnumber/6 + 1; // fake supermodule
651 if (vol8 == 1 || vol8 == 2)
656 else if (vol8 == 3 || vol8 == 4)
662 AliDebug(2,Form("ZPosition = %f Edeposition = %d",zPos,edep));
669 else if (zPos > fZPos)
675 Int_t smn = smnumber;
676 Int_t ixx = xpad - 1;
677 Int_t iyy = ypad - 1;
680 fPRE[smn][ixx][iyy] += edep;
681 fPRECounter[smn][ixx][iyy]++;
683 AliPMDcell* cell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
689 fCPV[smn][ixx][iyy] += edep;
690 fCPVCounter[smn][ixx][iyy]++;
691 AliPMDcell* cpvcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
692 fCPVCell.Add(cpvcell);
696 } // Track Loop ended
697 TrackAssignment2CPVCell();
698 TrackAssignment2Cell();
708 for (Int_t idet = 0; idet < 2; idet++)
710 for (Int_t ism = 0; ism < fgkTotUM; ism++)
712 for (Int_t jrow = 0; jrow < fgkRow; jrow++)
714 for (Int_t kcol = 0; kcol < fgkCol; kcol++)
718 deltaE = fPRE[ism][jrow][kcol];
719 trno = fPRETrackNo[ism][jrow][kcol];
724 deltaE = fCPV[ism][jrow][kcol];
725 trno = fCPVTrackNo[ism][jrow][kcol];
732 // To decalibrate the adc values
734 gain1 = Gain(idet,ism,jrow,kcol);
737 Int_t adcDecalib = (Int_t)(adc/gain1);
738 adc = (Float_t) adcDecalib;
745 // Pedestal Decalibration
747 fCalibPed->GetPedMeanRms(idet,ism,jrow,kcol);
748 Int_t pedrms1 = (Int_t) pedmeanrms%100;
749 Float_t pedrms = (Float_t)pedrms1/10.;
751 (Float_t) (pedmeanrms - pedrms1)/1000.0;
754 adc += (pedmean + 3.0*pedrms);
756 = gAlice->GetMCApp()->Particle(trno);
757 trpid = mparticle->GetPdgCode();
759 AddDigit(trno,trpid,detno,ism,jrow,kcol,adc);
766 } // supermodule loop
769 fPMDLoader->WriteDigits("OVERWRITE");
773 //____________________________________________________________________________
776 void AliPMDDigitizer::SDigits2Digits(Int_t ievt)
778 // This reads the PMD sdigits tree and converts energy deposition
779 // in a cell to ADC and stores in the digits tree
782 fRunLoader->GetEvent(ievt);
784 TTree* treeS = fPMDLoader->TreeS();
785 AliPMDsdigit *pmdsdigit;
786 TBranch *branch = treeS->GetBranch("PMDSDigit");
789 AliError("PMD Sdigit branch does not exist");
792 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
793 branch->SetAddress(&fSDigits);
795 TTree* treeD = fPMDLoader->TreeD();
798 fPMDLoader->MakeTree("D");
799 treeD = fPMDLoader->TreeD();
801 Int_t bufsize = 16000;
802 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
803 treeD->Branch("PMDDigit", &fDigits, bufsize);
805 Int_t trno, trpid, det, smn;
809 Int_t nmodules = (Int_t) treeS->GetEntries();
810 AliDebug(1,Form("Number of modules = %d",nmodules));
812 for (Int_t imodule = 0; imodule < nmodules; imodule++)
814 treeS->GetEntry(imodule);
815 Int_t nentries = fSDigits->GetLast();
816 AliDebug(2,Form("Number of entries per module = %d",nentries+1));
817 for (Int_t ient = 0; ient < nentries+1; ient++)
819 pmdsdigit = (AliPMDsdigit*)fSDigits->UncheckedAt(ient);
820 trno = pmdsdigit->GetTrackNumber();
821 trpid = pmdsdigit->GetTrackPid();
822 det = pmdsdigit->GetDetector();
823 smn = pmdsdigit->GetSMNumber();
824 irow = pmdsdigit->GetRow();
825 icol = pmdsdigit->GetColumn();
826 edep = pmdsdigit->GetCellEdep();
830 // To decalibrte the adc values
832 Float_t gain1 = Gain(det,smn,irow,icol);
835 Int_t adcDecalib = (Int_t)(adc/gain1);
836 adc = (Float_t) adcDecalib;
842 // Pedestal Decalibration
843 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,irow,icol);
844 Int_t pedrms1 = (Int_t) pedmeanrms%100;
845 Float_t pedrms = (Float_t)pedrms1/10.;
846 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
849 adc += (pedmean + 3.0*pedrms);
850 AddDigit(trno,trpid,det,smn,irow,icol,adc);
857 fPMDLoader->WriteDigits("OVERWRITE");
860 //____________________________________________________________________________
861 void AliPMDDigitizer::Exec(Option_t *option)
863 // Does the event merging and digitization
864 const char *cdeb = strstr(option,"deb");
867 AliDebug(100," *** PMD Exec is called ***");
870 Int_t ninputs = fManager->GetNinputs();
871 AliDebug(1,Form("Number of files to be processed = %d",ninputs));
874 for (Int_t i = 0; i < ninputs; i++)
876 Int_t troffset = fManager->GetMask(i);
877 MergeSDigits(i, troffset);
880 fRunLoader = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
881 fPMD = (AliPMD*)gAlice->GetDetector("PMD");
882 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
883 if (fPMDLoader == 0x0)
885 AliError("Can not find PMD or PMDLoader");
887 fPMDLoader->LoadDigits("update");
888 TTree* treeD = fPMDLoader->TreeD();
891 fPMDLoader->MakeTree("D");
892 treeD = fPMDLoader->TreeD();
894 Int_t bufsize = 16000;
895 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
896 treeD->Branch("PMDDigit", &fDigits, bufsize);
904 for (Int_t idet = 0; idet < 2; idet++)
906 for (Int_t ism = 0; ism < fgkTotUM; ism++)
908 for (Int_t jrow = 0; jrow < fgkRow; jrow++)
910 for (Int_t kcol = 0; kcol < fgkCol; kcol++)
914 deltaE = fPRE[ism][jrow][kcol];
915 trno = fPRETrackNo[ism][jrow][kcol];
916 trpid = fPRETrackPid[ism][jrow][kcol];
921 deltaE = fCPV[ism][jrow][kcol];
922 trno = fCPVTrackNo[ism][jrow][kcol];
923 trpid = fCPVTrackPid[ism][jrow][kcol];
931 // Gain decalibration
933 Float_t gain1 = Gain(idet,ism,jrow,kcol);
937 Int_t adcDecalib = (Int_t)(adc/gain1);
938 adc = (Float_t) adcDecalib;
944 // Pedestal Decalibration
946 fCalibPed->GetPedMeanRms(idet,ism,jrow,kcol);
947 Int_t pedrms1 = (Int_t) pedmeanrms%100;
948 Float_t pedrms = (Float_t)pedrms1/10.;
950 (Float_t) (pedmeanrms - pedrms1)/1000.0;
953 adc += (pedmean + 3.0*pedrms);
954 AddDigit(trno,trpid,detno,ism,jrow,kcol,adc);
962 } // supermodule loop
964 fPMDLoader->WriteDigits("OVERWRITE");
965 fPMDLoader->UnloadDigits();
968 //____________________________________________________________________________
969 void AliPMDDigitizer::TrackAssignment2CPVCell()
971 // This block assigns the cell id when there are
972 // multiple tracks in a cell according to the
974 // This method added by Ajay
975 Bool_t jsort = false;
988 cpvTrack = new Int_t ***[fgkTotUM];
989 cpvEdep = new Float_t ***[fgkTotUM];
990 for (i=0; i<fgkTotUM; i++)
992 cpvTrack[i] = new Int_t **[fgkRow];
993 cpvEdep[i] = new Float_t **[fgkRow];
996 for (i = 0; i < fgkTotUM; i++)
998 for (j = 0; j < fgkRow; j++)
1000 cpvTrack[i][j] = new Int_t *[fgkCol];
1001 cpvEdep[i][j] = new Float_t *[fgkCol];
1004 for (i = 0; i < fgkTotUM; i++)
1006 for (j = 0; j < fgkRow; j++)
1008 for (k = 0; k < fgkCol; k++)
1010 Int_t nn = fCPVCounter[i][j][k];
1013 cpvTrack[i][j][k] = new Int_t[nn];
1014 cpvEdep[i][j][k] = new Float_t[nn];
1019 cpvTrack[i][j][k] = new Int_t[nn];
1020 cpvEdep[i][j][k] = new Float_t[nn];
1022 fCPVCounter[i][j][k] = 0;
1028 Int_t nentries = fCPVCell.GetEntries();
1030 Int_t mtrackno, ism, ixp, iyp;
1032 for (i = 0; i < nentries; i++)
1034 AliPMDcell* cpvcell = (AliPMDcell*)fCPVCell.UncheckedAt(i);
1036 mtrackno = cpvcell->GetTrackNumber();
1037 ism = cpvcell->GetSMNumber();
1038 ixp = cpvcell->GetX();
1039 iyp = cpvcell->GetY();
1040 edep = cpvcell->GetEdep();
1041 Int_t nn = fCPVCounter[ism][ixp][iyp];
1042 cpvTrack[ism][ixp][iyp][nn] = (Int_t) mtrackno;
1043 cpvEdep[ism][ixp][iyp][nn] = edep;
1044 fCPVCounter[ism][ixp][iyp]++;
1050 for (im=0; im<fgkTotUM; im++)
1052 for (ix=0; ix<fgkRow; ix++)
1054 for (iy=0; iy<fgkCol; iy++)
1056 nn = fCPVCounter[im][ix][iy];
1059 // This block handles if a cell is fired
1060 // many times by many tracks
1061 status1 = new Int_t[nn];
1062 status2 = new Int_t[nn];
1063 trnarray = new Int_t[nn];
1064 for (iz = 0; iz < nn; iz++)
1066 status1[iz] = cpvTrack[im][ix][iy][iz];
1068 TMath::Sort(nn,status1,status2,jsort);
1069 Int_t trackOld = -99999;
1070 Int_t track, trCount = 0;
1071 for (iz = 0; iz < nn; iz++)
1073 track = status1[status2[iz]];
1074 if (trackOld != track)
1076 trnarray[trCount] = track;
1083 Float_t totEdp = 0.;
1084 trEdp = new Float_t[trCount];
1085 fracEdp = new Float_t[trCount];
1086 for (il = 0; il < trCount; il++)
1089 track = trnarray[il];
1090 for (iz = 0; iz < nn; iz++)
1092 if (track == cpvTrack[im][ix][iy][iz])
1094 trEdp[il] += cpvEdep[im][ix][iy][iz];
1097 totEdp += trEdp[il];
1100 Float_t fracOld = 0.;
1102 for (il = 0; il < trCount; il++)
1104 fracEdp[il] = trEdp[il]/totEdp;
1105 if (fracOld < fracEdp[il])
1107 fracOld = fracEdp[il];
1111 fCPVTrackNo[im][ix][iy] = trnarray[ilOld];
1118 // This only handles if a cell is fired
1119 // by only one track
1121 fCPVTrackNo[im][ix][iy] = cpvTrack[im][ix][iy][0];
1126 // This is if no cell is fired
1127 fCPVTrackNo[im][ix][iy] = -999;
1133 // Delete all the pointers
1135 for (i = 0; i < fgkTotUM; i++)
1137 for (j = 0; j < fgkRow; j++)
1139 for (k = 0; k < fgkCol; k++)
1141 delete []cpvTrack[i][j][k];
1142 delete []cpvEdep[i][j][k];
1147 for (i = 0; i < fgkTotUM; i++)
1149 for (j = 0; j < fgkRow; j++)
1151 delete [] cpvTrack[i][j];
1152 delete [] cpvEdep[i][j];
1156 for (i = 0; i < fgkTotUM; i++)
1158 delete [] cpvTrack[i];
1159 delete [] cpvEdep[i];
1165 // End of the cell id assignment
1168 //____________________________________________________________________________
1170 void AliPMDDigitizer::MergeSDigits(Int_t filenumber, Int_t troffset)
1173 fRunLoader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(filenumber));
1174 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
1175 fPMDLoader->LoadSDigits("read");
1176 TTree* treeS = fPMDLoader->TreeS();
1177 AliPMDsdigit *pmdsdigit;
1178 TBranch *branch = treeS->GetBranch("PMDSDigit");
1179 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
1180 branch->SetAddress(&fSDigits);
1182 Int_t itrackno, itrackpid, idet, ism;
1185 Int_t nmodules = (Int_t) treeS->GetEntries();
1186 AliDebug(1,Form("Number of Modules in the treeS = %d",nmodules));
1187 AliDebug(1,Form("Track Offset = %d",troffset));
1188 for (Int_t imodule = 0; imodule < nmodules; imodule++)
1190 treeS->GetEntry(imodule);
1191 Int_t nentries = fSDigits->GetLast();
1192 AliDebug(2,Form("Number of Entries per Module = %d",nentries));
1193 for (Int_t ient = 0; ient < nentries+1; ient++)
1195 pmdsdigit = (AliPMDsdigit*)fSDigits->UncheckedAt(ient);
1196 itrackno = pmdsdigit->GetTrackNumber();
1197 itrackpid = pmdsdigit->GetTrackPid();
1198 idet = pmdsdigit->GetDetector();
1199 ism = pmdsdigit->GetSMNumber();
1200 ixp = pmdsdigit->GetRow();
1201 iyp = pmdsdigit->GetColumn();
1202 edep = pmdsdigit->GetCellEdep();
1205 if (fPRE[ism][ixp][iyp] < edep)
1207 fPRETrackNo[ism][ixp][iyp] = troffset + itrackno;
1208 fPRETrackPid[ism][ixp][iyp] = itrackpid;
1210 fPRE[ism][ixp][iyp] += edep;
1214 if (fCPV[ism][ixp][iyp] < edep)
1216 fCPVTrackNo[ism][ixp][iyp] = troffset + itrackno;
1217 fCPVTrackPid[ism][ixp][iyp] = itrackpid;
1219 fCPV[ism][ixp][iyp] += edep;
1225 // ----------------------------------------------------------------------
1226 void AliPMDDigitizer::TrackAssignment2Cell()
1229 // This block assigns the cell id when there are
1230 // multiple tracks in a cell according to the
1231 // energy deposition
1233 Bool_t jsort = false;
1244 Float_t ****pmdEdep;
1246 pmdTrack = new Int_t ***[fgkTotUM];
1247 pmdEdep = new Float_t ***[fgkTotUM];
1248 for (i=0; i<fgkTotUM; i++)
1250 pmdTrack[i] = new Int_t **[fgkRow];
1251 pmdEdep[i] = new Float_t **[fgkRow];
1254 for (i = 0; i < fgkTotUM; i++)
1256 for (j = 0; j < fgkRow; j++)
1258 pmdTrack[i][j] = new Int_t *[fgkCol];
1259 pmdEdep[i][j] = new Float_t *[fgkCol];
1263 for (i = 0; i < fgkTotUM; i++)
1265 for (j = 0; j < fgkRow; j++)
1267 for (k = 0; k < fgkCol; k++)
1269 Int_t nn = fPRECounter[i][j][k];
1272 pmdTrack[i][j][k] = new Int_t[nn];
1273 pmdEdep[i][j][k] = new Float_t[nn];
1278 pmdTrack[i][j][k] = new Int_t[nn];
1279 pmdEdep[i][j][k] = new Float_t[nn];
1281 fPRECounter[i][j][k] = 0;
1287 Int_t nentries = fCell.GetEntries();
1289 Int_t mtrackno, ism, ixp, iyp;
1292 for (i = 0; i < nentries; i++)
1294 AliPMDcell* cell = (AliPMDcell*)fCell.UncheckedAt(i);
1296 mtrackno = cell->GetTrackNumber();
1297 ism = cell->GetSMNumber();
1300 edep = cell->GetEdep();
1301 Int_t nn = fPRECounter[ism][ixp][iyp];
1302 pmdTrack[ism][ixp][iyp][nn] = (Int_t) mtrackno;
1303 pmdEdep[ism][ixp][iyp][nn] = edep;
1304 fPRECounter[ism][ixp][iyp]++;
1311 for (im=0; im<fgkTotUM; im++)
1313 for (ix=0; ix<fgkRow; ix++)
1315 for (iy=0; iy<fgkCol; iy++)
1317 nn = fPRECounter[im][ix][iy];
1320 // This block handles if a cell is fired
1321 // many times by many tracks
1322 status1 = new Int_t[nn];
1323 status2 = new Int_t[nn];
1324 trnarray = new Int_t[nn];
1325 for (iz = 0; iz < nn; iz++)
1327 status1[iz] = pmdTrack[im][ix][iy][iz];
1329 TMath::Sort(nn,status1,status2,jsort);
1330 Int_t trackOld = -99999;
1331 Int_t track, trCount = 0;
1332 for (iz = 0; iz < nn; iz++)
1334 track = status1[status2[iz]];
1335 if (trackOld != track)
1337 trnarray[trCount] = track;
1344 Float_t totEdp = 0.;
1345 trEdp = new Float_t[trCount];
1346 fracEdp = new Float_t[trCount];
1347 for (il = 0; il < trCount; il++)
1350 track = trnarray[il];
1351 for (iz = 0; iz < nn; iz++)
1353 if (track == pmdTrack[im][ix][iy][iz])
1355 trEdp[il] += pmdEdep[im][ix][iy][iz];
1358 totEdp += trEdp[il];
1361 Float_t fracOld = 0.;
1363 for (il = 0; il < trCount; il++)
1365 fracEdp[il] = trEdp[il]/totEdp;
1366 if (fracOld < fracEdp[il])
1368 fracOld = fracEdp[il];
1372 fPRETrackNo[im][ix][iy] = trnarray[ilOld];
1379 // This only handles if a cell is fired
1380 // by only one track
1382 fPRETrackNo[im][ix][iy] = pmdTrack[im][ix][iy][0];
1387 // This is if no cell is fired
1388 fPRETrackNo[im][ix][iy] = -999;
1394 // Delete all the pointers
1396 for (i = 0; i < fgkTotUM; i++)
1398 for (j = 0; j < fgkRow; j++)
1400 for (k = 0; k < fgkCol; k++)
1402 delete [] pmdTrack[i][j][k];
1403 delete [] pmdEdep[i][j][k];
1408 for (i = 0; i < fgkTotUM; i++)
1410 for (j = 0; j < fgkRow; j++)
1412 delete [] pmdTrack[i][j];
1413 delete [] pmdEdep[i][j];
1417 for (i = 0; i < fgkTotUM; i++)
1419 delete [] pmdTrack[i];
1420 delete [] pmdEdep[i];
1425 // End of the cell id assignment
1428 //____________________________________________________________________________
1429 void AliPMDDigitizer::MeV2ADC(Float_t mev, Float_t & adc) const
1431 // This converts the simulated edep to ADC according to the
1433 //PS Test in May 2009, Voltage @ 1350 V
1434 // KeV - ADC conversion for 12bit ADC
1435 // MPV data used for the fit and taken here
1437 const Float_t kConstant = -0.1602;
1438 const Float_t kErConstant = 0.9914;
1439 const Float_t kSlope = 77.47;
1440 const Float_t kErSlope = 3.16;
1442 Float_t cons = gRandom->Gaus(kConstant,kErConstant);
1443 Float_t slop = gRandom->Gaus(kSlope,kErSlope);
1445 Float_t adc12bit = slop*mev*0.001 + cons;
1447 if (adc12bit < 0.) adc12bit = 0.;
1449 if(adc12bit < 1600.0)
1451 adc = (Float_t) adc12bit;
1453 else if (adc12bit >= 1600.0)
1458 //____________________________________________________________________________
1459 void AliPMDDigitizer::AddSDigit(Int_t trnumber, Int_t trpid, Int_t det,
1460 Int_t smnumber, Int_t irow, Int_t icol,
1465 if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
1466 TClonesArray &lsdigits = *fSDigits;
1467 new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,trpid,det,smnumber,irow,icol,adc);
1469 //____________________________________________________________________________
1471 void AliPMDDigitizer::AddDigit(Int_t trnumber, Int_t trpid, Int_t det,
1472 Int_t smnumber, Int_t irow, Int_t icol,
1477 if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
1478 TClonesArray &ldigits = *fDigits;
1479 new(ldigits[fNdigit++]) AliPMDdigit(trnumber,trpid, det,smnumber,irow,icol,adc);
1481 //____________________________________________________________________________
1483 void AliPMDDigitizer::SetZPosition(Float_t zpos)
1487 //____________________________________________________________________________
1488 Float_t AliPMDDigitizer::GetZPosition() const
1492 //____________________________________________________________________________
1494 void AliPMDDigitizer::ResetCell()
1496 // clears the cell array and also the counter
1501 for (Int_t i = 0; i < fgkTotUM; i++)
1503 for (Int_t j = 0; j < fgkRow; j++)
1505 for (Int_t k = 0; k < fgkCol; k++)
1507 fCPVCounter[i][j][k] = 0;
1508 fPRECounter[i][j][k] = 0;
1513 //____________________________________________________________________________
1514 void AliPMDDigitizer::ResetSDigit()
1518 if (fSDigits) fSDigits->Delete();
1520 //____________________________________________________________________________
1521 void AliPMDDigitizer::ResetDigit()
1525 if (fDigits) fDigits->Delete();
1527 //____________________________________________________________________________
1529 void AliPMDDigitizer::ResetCellADC()
1531 // Clears individual cells edep and track number
1532 for (Int_t i = 0; i < fgkTotUM; i++)
1534 for (Int_t j = 0; j < fgkRow; j++)
1536 for (Int_t k = 0; k < fgkCol; k++)
1540 fCPVTrackNo[i][j][k] = 0;
1541 fPRETrackNo[i][j][k] = 0;
1542 fCPVTrackPid[i][j][k] = -1;
1543 fPRETrackPid[i][j][k] = -1;
1548 //____________________________________________________________________________
1550 void AliPMDDigitizer::UnLoad(Option_t *option)
1552 // Unloads all the root files
1554 const char *cS = strstr(option,"S");
1555 const char *cD = strstr(option,"D");
1557 fRunLoader->UnloadgAlice();
1558 fRunLoader->UnloadHeader();
1559 fRunLoader->UnloadKinematics();
1563 fPMDLoader->UnloadHits();
1567 fPMDLoader->UnloadHits();
1568 fPMDLoader->UnloadSDigits();
1572 //----------------------------------------------------------------------
1573 Float_t AliPMDDigitizer::Gain(Int_t det, Int_t smn, Int_t row, Int_t col) const
1575 // returns of the gain of the cell
1576 // Added this method by ZA
1578 //cout<<" I am here in gain "<<fCalibData<< "smn,row, col "<<smn
1579 //<<" "<<row<<" "<<col<<endl;
1582 AliError("No calibration data loaded from CDB!!!");
1587 GainFact = fCalibGain->GetGainFact(det,smn,row,col);
1590 //----------------------------------------------------------------------
1591 AliPMDCalibData* AliPMDDigitizer::GetCalibGain() const
1593 // The run number will be centralized in AliCDBManager,
1594 // you don't need to set it here!
1595 // Added this method by ZA
1596 // Cleaned up by Alberto
1597 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
1599 if(!entry) AliFatal("Calibration object retrieval failed!");
1601 AliPMDCalibData *calibdata=0;
1602 if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
1604 if (!calibdata) AliFatal("No calibration data from calibration database !");
1608 //----------------------------------------------------------------------
1609 AliPMDPedestal* AliPMDDigitizer::GetCalibPed() const
1611 // The run number will be centralized in AliCDBManager,
1612 // you don't need to set it here!
1614 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ped");
1616 if(!entry) AliFatal("Pedestal object retrieval failed!");
1618 AliPMDPedestal *pedestal=0;
1619 if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
1621 if (!pedestal) AliFatal("No pedestal data from calibration database !");