#include "AliLoader.h"
#include "AliConfig.h"
#include "AliMagF.h"
-#include "AliRunDigitizer.h"
+#include "AliDigitizationInput.h"
#include "AliDigitizer.h"
#include "AliHeader.h"
#include "AliCDBManager.h"
#include "AliPMDsdigit.h"
#include "AliPMDdigit.h"
#include "AliPMDCalibData.h"
+#include "AliPMDPedestal.h"
#include "AliPMDDigitizer.h"
fPMDHit(0),
fPMD(0),
fPMDLoader(0),
- fCalibData(GetCalibData()),
+ fCalibGain(GetCalibGain()),
+ fCalibPed(GetCalibPed()),
fSDigits(0),
fDigits(0),
+ fCPVCell(0),
fCell(0),
fNsdigit(0),
fNdigit(0),
{
for (Int_t k = 0; k < fgkCol; k++)
{
- fCPV[i][j][k] = 0.;
- fPRE[i][j][k] = 0.;
- fPRECounter[i][j][k] = 0;
- fPRETrackNo[i][j][k] = -1;
- fCPVTrackNo[i][j][k] = -1;
+ fCPV[i][j][k] = 0.;
+ fPRE[i][j][k] = 0.;
+ fCPVCounter[i][j][k] = 0;
+ fPRECounter[i][j][k] = 0;
+ fCPVTrackNo[i][j][k] = -1;
+ fPRETrackNo[i][j][k] = -1;
+ fCPVTrackPid[i][j][k] = -1;
+ fPRETrackPid[i][j][k] = -1;
}
}
}
-
}
//____________________________________________________________________________
AliPMDDigitizer::AliPMDDigitizer(const AliPMDDigitizer& digitizer):
fPMDHit(0),
fPMD(0),
fPMDLoader(0),
- fCalibData(GetCalibData()),
+ fCalibGain(GetCalibGain()),
+ fCalibPed(GetCalibPed()),
fSDigits(0),
fDigits(0),
+ fCPVCell(0),
fCell(0),
fNsdigit(0),
fNdigit(0),
return *this;
}
//____________________________________________________________________________
-AliPMDDigitizer::AliPMDDigitizer(AliRunDigitizer* manager):
- AliDigitizer(manager),
+AliPMDDigitizer::AliPMDDigitizer(AliDigitizationInput* digInput):
+ AliDigitizer(digInput),
fRunLoader(0),
fPMDHit(0),
fPMD(0),
fPMDLoader(0),
- fCalibData(GetCalibData()),
+ fCalibGain(GetCalibGain()),
+ fCalibPed(GetCalibPed()),
fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
fDigits(new TClonesArray("AliPMDdigit", 1000)),
+ fCPVCell(0),
fCell(0),
fNsdigit(0),
fNdigit(0),
{
for (Int_t k = 0; k < fgkCol; k++)
{
- fCPV[i][j][k] = 0.;
- fPRE[i][j][k] = 0.;
- fPRECounter[i][j][k] = 0;
- fPRETrackNo[i][j][k] = -1;
- fCPVTrackNo[i][j][k] = -1;
+ fCPV[i][j][k] = 0.;
+ fPRE[i][j][k] = 0.;
+ fCPVCounter[i][j][k] = 0;
+ fPRECounter[i][j][k] = 0;
+ fCPVTrackNo[i][j][k] = -1;
+ fPRETrackNo[i][j][k] = -1;
+ fCPVTrackPid[i][j][k] = -1;
+ fPRETrackPid[i][j][k] = -1;
}
}
}
delete fDigits;
fDigits=0;
}
+ fCPVCell.Delete();
fCell.Delete();
}
//
const Int_t kPi0 = 111;
const Int_t kGamma = 22;
- Int_t npmd;
- Int_t trackno;
- Int_t smnumber;
- Int_t trackpid;
- Int_t mtrackno;
- Int_t mtrackpid;
-
- Float_t xPos, yPos, zPos;
+ Int_t npmd = 0;
+ Int_t trackno = 0;
+ Int_t smnumber = 0;
+ Int_t trackpid = 0;
+ Int_t mtrackno = 0;
+ Int_t mtrackpid = 0;
+
+ Float_t xPos = 0., yPos = 0., zPos = 0.;
Int_t xpad = -1, ypad = -1;
- Float_t edep;
+ Float_t edep = 0.;
Float_t vx = -999.0, vy = -999.0, vz = -999.0;
AliDebug(1,Form("Event Number = %d",ievt));
Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
AliDebug(1,Form("Number of Particles = %d",nparticles));
+
+ //
+
fRunLoader->GetEvent(ievt);
// ------------------------------------------------------- //
// Pointer to specific detector hits.
for (Int_t track=0; track<ntracks;track++)
{
- gAlice->ResetHits();
+ gAlice->GetMCApp()->ResetHits();
treeH->GetEvent(track);
if (fPMD)
{
npmd = hits->GetEntriesFast();
- for (int ipmd = 0; ipmd < npmd; ipmd++)
+ for (Int_t ipmd = 0; ipmd < npmd; ipmd++)
{
fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
trackno = fPMDHit->GetTrack();
TParticle* mparticle = gAlice->GetMCApp()->Particle(trackno);
trackpid = mparticle->GetPdgCode();
-
- Int_t igatr = -999;
- Int_t ichtr = -999;
- Int_t igapid = -999;
+ Int_t ks = mparticle->GetStatusCode();
Int_t imo;
- Int_t igen = 0;
- Int_t idmo = -999;
-
Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
+
if (mparticle->GetFirstMother() == -1)
{
tracknoOld = trackno;
statusOld = -1;
}
Int_t igstatus = 0;
- while((imo = mparticle->GetFirstMother()) >= 0)
- {
- igen++;
+ Int_t trnotemp = trackno; // Modified on 25th Nov 2009
+ if(ks==1||(imo = mparticle->GetFirstMother())<0 ){
+ vx = mparticle->Vx();
+ vy = mparticle->Vy();
+ vz = mparticle->Vz();
+
+ if(trackpid==kGamma||trackpid==11||trackpid==-11||
+ trackpid==kPi0)igstatus=1;
+ }
+
+
+ while(((imo = mparticle->GetFirstMother()) >= 0)&&
+ (ks = mparticle->GetStatusCode() <1) )
+ {
mparticle = gAlice->GetMCApp()->Particle(imo);
- idmo = mparticle->GetPdgCode();
-
+ trackpid = mparticle->GetPdgCode();
+ ks = mparticle->GetStatusCode();
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, 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.)
+
+ // Modified on 25th Nov 2009
+
+ trnotemp = trackno;
+ if(trackpid == 111)
{
- igatr = imo;
- igapid = idmo;
- igstatus = 1;
+ trackno = trnotemp;
}
- if(igstatus == 0)
+ if(trackpid != 111)
{
- if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
- {
- igatr = imo;
- igapid = idmo;
- }
+ trackno=imo;
}
- ichtr = imo;
+ // end of modification on 25th Nov 2009
}
+
+ if(trackpid==kGamma||trackpid==11||trackpid==-11||
+ trackpid==kPi0)igstatus=1;
+ mtrackpid=trackpid;
+ mtrackno=trackno;
+ trackpid=trackpidOld;
+ trackno=tracknoOld;
+
+ //-----------------end of modification----------------
+ Float_t ptime = fPMDHit->GetTime()*1e6; // time in microsec
+ if (ptime < 0. || ptime > 1.2) continue;
- if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
- {
- mtrackno = igatr;
- mtrackpid = igapid;
- }
- else
- {
- mtrackno = ichtr;
- mtrackpid = idmo;
- }
- if (statusOld == -1)
- {
- mtrackno = tracknoOld;
- mtrackpid = trackpidOld;
- }
xPos = fPMDHit->X();
yPos = fPMDHit->Y();
zPos = fPMDHit->Z();
-
+
edep = fPMDHit->GetEnergy();
Int_t vol1 = fPMDHit->GetVolume(1); // Column
Int_t vol2 = fPMDHit->GetVolume(2); // Row
- Int_t vol7 = fPMDHit->GetVolume(7); // UnitModule
- Int_t vol8 = fPMDHit->GetVolume(8); // SuperModule
+ Int_t vol7 = fPMDHit->GetVolume(4); // Serial Module No
// -----------------------------------------//
// nrow = 96, ncol = 48 //
// -----------------------------------------//
-
-
- smnumber = (vol8-1)*6 + vol7;
+ if (vol7 < 24)
+ {
+ smnumber = vol7;
+ }
+ else
+ {
+ smnumber = vol7 - 24;
+ }
+ Int_t vol8 = smnumber/6 + 1; // fake supermodule
if (vol8 == 1 || vol8 == 2)
{
}
AliDebug(2,Form("Zposition = %f Edeposition = %f",zPos,edep));
- //Float_t zposition = TMath::Abs(zPos);
- if (zPos < fZPos)
+
+ if (vol7 < 24)
{
- // CPV
- fDetNo = 1;
+ // PRE
+ fDetNo = 0;
}
- else if (zPos > fZPos)
+ else
{
- // PMD
- fDetNo = 0;
+ // CPV
+ fDetNo = 1;
}
- Int_t smn = smnumber - 1;
+
+ Int_t smn = smnumber;
Int_t ixx = xpad - 1;
Int_t iyy = ypad - 1;
if (fDetNo == 0)
else if(fDetNo == 1)
{
fCPV[smn][ixx][iyy] += edep;
- fCPVTrackNo[smn][ixx][iyy] = mtrackno;
+ fCPVCounter[smn][ixx][iyy]++;
+ AliPMDcell* cpvcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
+ fCPVCell.Add(cpvcell);
}
}
}
} // Track Loop ended
-
+ TrackAssignment2CPVCell();
TrackAssignment2Cell();
ResetCell();
Float_t deltaE = 0.;
Int_t detno = 0;
Int_t trno = -1;
+ Int_t trpid = -99;
for (Int_t idet = 0; idet < 2; idet++)
{
}
if (deltaE > 0.)
{
- AddSDigit(trno,detno,ism,jrow,kcol,deltaE);
+ // Natasha
+ TParticle *mparticle = gAlice->GetMCApp()->Particle(trno);
+ trpid = mparticle->GetPdgCode();
+ AddSDigit(trno,trpid,detno,ism,jrow,kcol,deltaE);
}
}
}
//
const Int_t kPi0 = 111;
const Int_t kGamma = 22;
- Int_t npmd;
- Int_t trackno;
- Int_t smnumber;
- Int_t trackpid;
- Int_t mtrackno;
- Int_t mtrackpid;
-
- Float_t xPos, yPos, zPos;
+ Int_t npmd = 0;
+ Int_t trackno = 0;
+ Int_t smnumber = 0;
+ Int_t trackpid = 0;
+ Int_t mtrackno = 0;
+ Int_t mtrackpid = 0;
+
+ Float_t xPos = 0., yPos = 0., zPos = 0.;
Int_t xpad = -1, ypad = -1;
- Float_t edep;
+ Float_t edep = 0.;
Float_t vx = -999.0, vy = -999.0, vz = -999.0;
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
AliDebug(1,Form("Event Number = %d",ievt));
Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
AliDebug(1,Form("Number of Particles = %d", nparticles));
+
fRunLoader->GetEvent(ievt);
// ------------------------------------------------------- //
// Pointer to specific detector hits.
for (Int_t track=0; track<ntracks;track++)
{
- gAlice->ResetHits();
+ gAlice->GetMCApp()->ResetHits();
treeH->GetEvent(track);
if (fPMD)
{
npmd = hits->GetEntriesFast();
- for (int ipmd = 0; ipmd < npmd; ipmd++)
+ for (Int_t ipmd = 0; ipmd < npmd; ipmd++)
{
fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
trackno = fPMDHit->GetTrack();
TParticle* mparticle = gAlice->GetMCApp()->Particle(trackno);
trackpid = mparticle->GetPdgCode();
-
- Int_t igatr = -999;
- Int_t ichtr = -999;
- Int_t igapid = -999;
+ Int_t ks = mparticle->GetStatusCode();
Int_t imo;
- Int_t igen = 0;
- Int_t idmo = -999;
-
Int_t tracknoOld=0, trackpidOld=0, statusOld = 0;
if (mparticle->GetFirstMother() == -1)
{
}
Int_t igstatus = 0;
- while((imo = mparticle->GetFirstMother()) >= 0)
- {
- igen++;
+ Int_t trnotemp = trackno; // modified on 25th Nov 2009
+ if(ks==1||(imo = mparticle->GetFirstMother())<0 ){
+ vx = mparticle->Vx();
+ vy = mparticle->Vy();
+ vz = mparticle->Vz();
+
+ if(trackpid==kGamma||trackpid==11||trackpid==-11||trackpid==kPi0)
+ igstatus=1;
+ }
+
+
+ while(((imo = mparticle->GetFirstMother()) >= 0)&&
+ (ks = mparticle->GetStatusCode() <1) )
+ {
mparticle = gAlice->GetMCApp()->Particle(imo);
- idmo = mparticle->GetPdgCode();
-
+ trackpid = mparticle->GetPdgCode();
+ ks = mparticle->GetStatusCode();
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, 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.)
+
+ // Modified on 25th Nov 2009
+
+ trnotemp = trackno;
+ if(trackpid == 111)
{
- igatr = imo;
- igapid = idmo;
- igstatus = 1;
+ trackno = trnotemp;
}
- if(igstatus == 0)
+ if(trackpid != 111)
{
- if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
- {
- igatr = imo;
- igapid = idmo;
- }
+ trackno=imo;
}
- ichtr = imo;
- }
-
- if (idmo == kPi0 && vx == 0. && vy == 0. && vz == 0.)
- {
- mtrackno = igatr;
- mtrackpid = igapid;
- }
- else
- {
- mtrackno = ichtr;
- mtrackpid = idmo;
- }
- if (statusOld == -1)
- {
- mtrackno = tracknoOld;
- mtrackpid = trackpidOld;
}
+
+ if(trackpid==kGamma||trackpid==11||trackpid==-11||trackpid==kPi0)
+ igstatus=1;
+ mtrackpid=trackpid;
+ mtrackno=trackno;
+ trackpid=trackpidOld;
+ trackno=tracknoOld;
+
+ Float_t ptime = fPMDHit->GetTime()*1e6;
+ if (ptime < 0. || ptime > 1.2) continue;
xPos = fPMDHit->X();
yPos = fPMDHit->Y();
edep = fPMDHit->GetEnergy();
Int_t vol1 = fPMDHit->GetVolume(1); // Column
Int_t vol2 = fPMDHit->GetVolume(2); // Row
- Int_t vol7 = fPMDHit->GetVolume(7); // UnitModule
- Int_t vol8 = fPMDHit->GetVolume(8); // SuperModule
-
+ Int_t vol7 = fPMDHit->GetVolume(4); // Serial Module No
// -----------------------------------------//
// In new geometry after adding electronics //
// nrow = 96, ncol = 48 //
// -----------------------------------------//
- smnumber = (vol8-1)*6 + vol7;
+ if (vol7 < 24)
+ {
+ smnumber = vol7;
+ }
+ else
+ {
+ smnumber = vol7 - 24;
+ }
+ Int_t vol8 = smnumber/6 + 1; // fake supermodule
if (vol8 == 1 || vol8 == 2)
{
ypad = vol2;
}
- AliDebug(2,Form("ZPosition = %f Edeposition = %d",zPos,edep));
- //Float_t zposition = TMath::Abs(zPos);
+ AliDebug(2,Form("ZPosition = %f Edeposition = %f",zPos,edep));
- if (zPos < fZPos)
+ if (vol7 < 24)
{
- // CPV
- fDetNo = 1;
+ // PRE
+ fDetNo = 0;
}
- else if (zPos > fZPos)
+ else
{
- // PMD
- fDetNo = 0;
+ fDetNo = 1;
}
- Int_t smn = smnumber - 1;
+ Int_t smn = smnumber;
Int_t ixx = xpad - 1;
Int_t iyy = ypad - 1;
if (fDetNo == 0)
else if(fDetNo == 1)
{
fCPV[smn][ixx][iyy] += edep;
- fCPVTrackNo[smn][ixx][iyy] = mtrackno;
+ fCPVCounter[smn][ixx][iyy]++;
+ AliPMDcell* cpvcell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
+ fCPVCell.Add(cpvcell);
}
}
}
} // Track Loop ended
-
+ TrackAssignment2CPVCell();
TrackAssignment2Cell();
ResetCell();
- Float_t gain1;
- Float_t adc;
+ Float_t gain1 = 1.;
+ Float_t adc = 0. ;
Float_t deltaE = 0.;
- Int_t detno = 0;
- Int_t trno = 1;
+ 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++)
{
deltaE = fPRE[ism][jrow][kcol];
trno = fPRETrackNo[ism][jrow][kcol];
- detno = 0;
+ detno = 0;
}
else if (idet == 1)
{
deltaE = fCPV[ism][jrow][kcol];
trno = fCPVTrackNo[ism][jrow][kcol];
- detno = 1;
+ detno = 1;
}
if (deltaE > 0.)
{
{
adc = 0.;
}
- AddDigit(trno,detno,ism,jrow,kcol,adc);
+
+ // 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);
+ TParticle *mparticle
+ = gAlice->GetMCApp()->Particle(trno);
+ trpid = mparticle->GetPdgCode();
+
+ AddDigit(trno,trpid,detno,ism,jrow,kcol,adc);
+ }
}
} // column loop
} // row loop
fPMDLoader->WriteDigits("OVERWRITE");
ResetCellADC();
-
+
}
//____________________________________________________________________________
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
treeD->Branch("PMDDigit", &fDigits, bufsize);
- Int_t trno, det, smn;
- Int_t irow, icol;
- Float_t edep, adc;
+ Int_t trno = 1, trpid = 0, det = 0, smn = 0;
+ Int_t irow = 0, icol = 0;
+ Float_t edep = 0., adc = 0.;
Int_t nmodules = (Int_t) treeS->GetEntries();
AliDebug(1,Form("Number of modules = %d",nmodules));
{
pmdsdigit = (AliPMDsdigit*)fSDigits->UncheckedAt(ient);
trno = pmdsdigit->GetTrackNumber();
+ trpid = pmdsdigit->GetTrackPid();
det = pmdsdigit->GetDetector();
smn = pmdsdigit->GetSMNumber();
irow = pmdsdigit->GetRow();
Float_t gain1 = Gain(det,smn,irow,icol);
if (gain1 != 0.)
{
- Int_t adcDecalib = (Int_t)(adc/gain1);
- adc = (Float_t) adcDecalib;
+ Int_t adcDecalib = (Int_t)(adc/gain1);
+ adc = (Float_t) adcDecalib;
}
else if(gain1 == 0.)
{
adc = 0.;
}
+ // Pedestal Decalibration
+ Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,irow,icol);
+ 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,det,smn,irow,icol,adc);
+ }
- AddDigit(trno,det,smn,irow,icol,adc);
}
treeD->Fill();
ResetDigit();
}
//____________________________________________________________________________
-void AliPMDDigitizer::Exec(Option_t *option)
+void AliPMDDigitizer::Digitize(Option_t *option)
{
// Does the event merging and digitization
const char *cdeb = strstr(option,"deb");
AliDebug(100," *** PMD Exec is called ***");
}
- Int_t ninputs = fManager->GetNinputs();
+ Int_t ninputs = fDigInput->GetNinputs();
AliDebug(1,Form("Number of files to be processed = %d",ninputs));
ResetCellADC();
for (Int_t i = 0; i < ninputs; i++)
{
- Int_t troffset = fManager->GetMask(i);
+ Int_t troffset = fDigInput->GetMask(i);
MergeSDigits(i, troffset);
}
- fRunLoader = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+ fRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());
fPMD = (AliPMD*)gAlice->GetDetector("PMD");
fPMDLoader = fRunLoader->GetLoader("PMDLoader");
if (fPMDLoader == 0x0)
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
treeD->Branch("PMDDigit", &fDigits, bufsize);
- Float_t adc;
+ Float_t adc = 0.;
Float_t deltaE = 0.;
- Int_t detno = 0;
- Int_t trno = 1;
+ Int_t detno = 0;
+ Int_t trno = 1;
+ Int_t trpid = -99;
for (Int_t idet = 0; idet < 2; idet++)
{
{
deltaE = fPRE[ism][jrow][kcol];
trno = fPRETrackNo[ism][jrow][kcol];
- detno = 0;
+ trpid = fPRETrackPid[ism][jrow][kcol];
+ detno = 0;
}
else if (idet == 1)
{
deltaE = fCPV[ism][jrow][kcol];
trno = fCPVTrackNo[ism][jrow][kcol];
- detno = 1;
+ trpid = fCPVTrackPid[ism][jrow][kcol];
+ detno = 1;
}
if (deltaE > 0.)
{
MeV2ADC(deltaE,adc);
+
//
- // To decalibrte the adc values
+ // Gain decalibration
//
Float_t gain1 = Gain(idet,ism,jrow,kcol);
+
if (gain1 != 0.)
{
Int_t adcDecalib = (Int_t)(adc/gain1);
{
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);
+ }
- AddDigit(trno,detno,ism,jrow,kcol,adc);
}
} // column loop
} // row loop
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(fManager->GetInputFolderName(filenumber));
+ fRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(filenumber));
fPMDLoader = fRunLoader->GetLoader("PMDLoader");
fPMDLoader->LoadSDigits("read");
TTree* treeS = fPMDLoader->TreeS();
if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
branch->SetAddress(&fSDigits);
- Int_t itrackno, idet, ism;
- Int_t ixp, iyp;
- Float_t edep;
+ 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));
{
pmdsdigit = (AliPMDsdigit*)fSDigits->UncheckedAt(ient);
itrackno = pmdsdigit->GetTrackNumber();
+ itrackpid = pmdsdigit->GetTrackPid();
idet = pmdsdigit->GetDetector();
ism = pmdsdigit->GetSMNumber();
ixp = pmdsdigit->GetRow();
if (fPRE[ism][ixp][iyp] < edep)
{
fPRETrackNo[ism][ixp][iyp] = troffset + itrackno;
+ fPRETrackPid[ism][ixp][iyp] = itrackpid;
}
fPRE[ism][ixp][iyp] += edep;
}
if (fCPV[ism][ixp][iyp] < edep)
{
fCPVTrackNo[ism][ixp][iyp] = troffset + itrackno;
+ fCPVTrackPid[ism][ixp][iyp] = itrackpid;
}
fCPV[ism][ixp][iyp] += edep;
}
//
Bool_t jsort = false;
- Int_t i, j, k;
+ 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 *status1;
- Int_t *status2;
- Int_t *trnarray;
+
Int_t ****pmdTrack;
Float_t ****pmdEdep;
fPRECounter[ism][ixp][iyp]++;
}
- Int_t iz, il;
- Int_t im, ix, iy;
- Int_t nn;
+ Int_t iz = 0, il = 0;
+ Int_t im = 0, ix = 0, iy = 0;
+ Int_t nn = 0;
for (im=0; im<fgkTotUM; im++)
{
// This block handles if a cell is fired
// many times by many tracks
status1 = new Int_t[nn];
- status2 = new Int_t[nn];
+ status2 = new Int_t[2*nn];
trnarray = new Int_t[nn];
for (iz = 0; iz < nn; iz++)
{
{
// This converts the simulated edep to ADC according to the
// Test Beam Data
- // To be done
- //
-
- // PS Test in September 2003
- // MeV - ADC conversion for 10bit ADC
-
- const Float_t kConstant = 7.181;
- const Float_t kErConstant = 0.6899;
- const Float_t kSlope = 35.93;
- const Float_t kErSlope = 0.306;
-
- //gRandom->SetSeed();
+ // PS Test in June 2010, Voltage @ 1300 V
+ // KeV - ADC conversion for 12bit ADC
+ // MPV data used for the fit and taken here
- Float_t cons = gRandom->Gaus(kConstant,kErConstant);
- Float_t slop = gRandom->Gaus(kSlope,kErSlope);
-
- Float_t adc10bit = slop*mev*0.001 + cons;
+ // constants are from Test Beam 2010
+
+ const Float_t kConstant = 0.612796;
+ const Float_t kSlope = 130.158;
+
+ Float_t adc12bit = kSlope*mev*0.001 + kConstant;
+ if (adc12bit < 0.) adc12bit = 0.;
- // 12 bit adc
+ //Introducing Readout Resolution for ALICE-PMD
- Int_t adc12bit = (Int_t) (4.0*adc10bit);
+ Float_t sigrr = 0.605016 - 0.000273*adc12bit + 6.54e-8*adc12bit*adc12bit;
+ Float_t adcwithrr = gRandom->Gaus(adc12bit,sigrr);
- if(adc12bit < 3000)
+ if(adcwithrr < 0.)
+ {
+ adc = 0.;
+ }
+ else if(adcwithrr >= 0. && adcwithrr < 1600.0)
{
- adc = (Float_t) adc12bit;
+ adc = adcwithrr;
}
- else if (adc12bit >= 3000)
+ else if (adcwithrr >= 1600.0)
{
- adc = 3000.0;
+ adc = 1600.0;
}
}
//____________________________________________________________________________
-void AliPMDDigitizer::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
- Int_t irow, Int_t icol, Float_t adc)
+void AliPMDDigitizer::AddSDigit(Int_t trnumber, Int_t trpid, Int_t det,
+ Int_t smnumber, Int_t irow, Int_t icol,
+ Float_t adc)
{
// Add SDigit
//
if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
TClonesArray &lsdigits = *fSDigits;
- new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
+ new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,trpid,det,smnumber,irow,icol,adc);
}
//____________________________________________________________________________
-void AliPMDDigitizer::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
- Int_t irow, Int_t icol, Float_t adc)
+void AliPMDDigitizer::AddDigit(Int_t trnumber, Int_t trpid, Int_t det,
+ Int_t smnumber, Int_t irow, Int_t icol,
+ Float_t adc)
{
// Add Digit
//
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
TClonesArray &ldigits = *fDigits;
- new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
+ new(ldigits[fNdigit++]) AliPMDdigit(trnumber,trpid, det,smnumber,irow,icol,adc);
}
//____________________________________________________________________________
// clears the cell array and also the counter
// for each cell
//
+ fCPVCell.Delete();
fCell.Delete();
for (Int_t i = 0; i < fgkTotUM; i++)
{
{
for (Int_t k = 0; k < fgkCol; k++)
{
+ fCPVCounter[i][j][k] = 0;
fPRECounter[i][j][k] = 0;
}
}
{
for (Int_t k = 0; k < fgkCol; k++)
{
- fCPV[i][j][k] = 0.;
- fPRE[i][j][k] = 0.;
- fPRETrackNo[i][j][k] = 0;
- fCPVTrackNo[i][j][k] = 0;
+ fCPV[i][j][k] = 0.;
+ fPRE[i][j][k] = 0.;
+ fCPVTrackNo[i][j][k] = 0;
+ fPRETrackNo[i][j][k] = 0;
+ fCPVTrackPid[i][j][k] = -1;
+ fPRETrackPid[i][j][k] = -1;
}
}
}
//cout<<" I am here in gain "<<fCalibData<< "smn,row, col "<<smn
//<<" "<<row<<" "<<col<<endl;
- if(!fCalibData) {
+ if(!fCalibGain) {
AliError("No calibration data loaded from CDB!!!");
return 1;
}
Float_t GainFact;
- GainFact = fCalibData->GetGainFact(det,smn,row,col);
+ GainFact = fCalibGain->GetGainFact(det,smn,row,col);
return GainFact;
}
//----------------------------------------------------------------------
-AliPMDCalibData* AliPMDDigitizer::GetCalibData() const
+AliPMDCalibData* AliPMDDigitizer::GetCalibGain() const
{
// The run number will be centralized in AliCDBManager,
// you don't need to set it here!
// Added this method by ZA
- AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Data");
+ // Cleaned up by Alberto
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
- if(!entry){
- AliWarning("Calibration object retrieval failed! Dummy calibration will be used.");
-
- // this just remembers the actual default storage. No problem if it is null
- AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage();
- AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
-
- entry = AliCDBManager::Instance()->Get("PMD/Calib/Data");
-
- // now reset the original default storage to AliCDBManager...
- AliCDBManager::Instance()->SetDefaultStorage(origStorage);
- }
+ if(!entry) AliFatal("Calibration object retrieval failed!");
AliPMDCalibData *calibdata=0;
if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
- if (!calibdata) AliError("No calibration data from calibration database !");
+ if (!calibdata) AliFatal("No calibration data from calibration database !");
return calibdata;
}
+//----------------------------------------------------------------------
+AliPMDPedestal* AliPMDDigitizer::GetCalibPed() const
+{
+ // The run number will be centralized in AliCDBManager,
+ // you don't need to set it here!
+
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ped");
+
+ if(!entry) AliFatal("Pedestal object retrieval failed!");
+
+ AliPMDPedestal *pedestal=0;
+ if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
+
+ if (!pedestal) AliFatal("No pedestal data from calibration database !");
+
+ return pedestal;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff