#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),
fCell(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.;
+ fPRECounter[i][j][k] = 0;
+ fPRETrackNo[i][j][k] = -1;
+ fCPVTrackNo[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),
fCell(0),
}
//____________________________________________________________________________
-
AliPMDDigitizer & AliPMDDigitizer::operator=(const AliPMDDigitizer& /*digitizer*/)
{
// Assignment operator
fPMDHit(0),
fPMD(0),
fPMDLoader(0),
- fCalibData(GetCalibData()),
+ fCalibGain(GetCalibGain()),
+ fCalibPed(GetCalibPed()),
fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
fDigits(new TClonesArray("AliPMDdigit", 1000)),
fCell(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.;
+ fPRECounter[i][j][k] = 0;
+ fPRETrackNo[i][j][k] = -1;
+ fCPVTrackNo[i][j][k] = -1;
}
}
}
TString evfoldname = AliConfig::GetDefaultEventFolderName();
fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
if (!fRunLoader)
- fRunLoader = AliRunLoader::Open(file,AliConfig::GetDefaultEventFolderName(),
- "UPDATE");
+ fRunLoader = AliRunLoader::Open(file,AliConfig::GetDefaultEventFolderName(), "UPDATE");
if (!fRunLoader)
{
treeS = fPMDLoader->TreeS();
}
Int_t bufsize = 16000;
- treeS->Branch("PMDSDigit", &fSDigits, bufsize);
+ treeS->Branch("PMDSDigit", &fSDigits, bufsize);
TClonesArray* hits = 0;
if (fPMD) hits = fPMD->Hits();
// Start loop on tracks in the hits containers
- for (Int_t track=0; track<ntracks;track++)
+ for (Int_t track=0; track<ntracks;track++)
{
gAlice->ResetHits();
treeH->GetEvent(track);
- if (fPMD)
+ if (fPMD)
{
npmd = hits->GetEntriesFast();
- for (int ipmd = 0; ipmd < npmd; ipmd++)
+ for (int ipmd = 0; ipmd < npmd; ipmd++)
{
fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
trackno = fPMDHit->GetTrack();
fPRECounter[smn][ixx][iyy]++;
AliPMDcell* cell = new AliPMDcell(mtrackno,smn,ixx,iyy,edep);
-
fCell.Add(cell);
}
else if(fDetNo == 1)
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
ResetDigit();
- AliDebug(1,Form("Event Number = %d",ievt));
+ AliDebug(1,Form("Event Number = %d",ievt));
Int_t nparticles = fRunLoader->GetHeader()->GetNtrack();
AliDebug(1,Form("Number of Particles = %d", nparticles));
fRunLoader->GetEvent(ievt);
treeD = fPMDLoader->TreeD();
}
Int_t bufsize = 16000;
- treeD->Branch("PMDDigit", &fDigits, bufsize);
+ treeD->Branch("PMDDigit", &fDigits, bufsize);
TClonesArray* hits = 0;
if (fPMD) hits = fPMD->Hits();
// Start loop on tracks in the hits containers
- for (Int_t track=0; track<ntracks;track++)
+ for (Int_t track=0; track<ntracks;track++)
{
gAlice->ResetHits();
treeH->GetEvent(track);
- if (fPMD)
+ if (fPMD)
{
npmd = hits->GetEntriesFast();
- for (int ipmd = 0; ipmd < npmd; ipmd++)
+ for (int ipmd = 0; ipmd < npmd; ipmd++)
{
fPMDHit = (AliPMDhit*) hits->UncheckedAt(ipmd);
trackno = fPMDHit->GetTrack();
Int_t detno = 0;
Int_t trno = 1;
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)
- {
- gain1 = Gain(idet,ism,jrow,kcol);
-
- deltaE = fPRE[ism][jrow][kcol]*gain1;
+ {
+ deltaE = fPRE[ism][jrow][kcol];
trno = fPRETrackNo[ism][jrow][kcol];
detno = 0;
- }
+ }
else if (idet == 1)
- {
- gain1 = Gain(idet,ism,jrow,kcol);
- deltaE = fCPV[ism][jrow][kcol]*gain1;
+ {
+ deltaE = fCPV[ism][jrow][kcol];
trno = fCPVTrackNo[ism][jrow][kcol];
detno = 1;
- }
+ }
if (deltaE > 0.)
- {
+ {
MeV2ADC(deltaE,adc);
- AddDigit(trno,detno,ism,jrow,kcol,adc);
- }
- } // column loop
- } // row loop
+
+ // To decalibrate the adc values
+ //
+ 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%1000;
+ Float_t pedrms = (Float_t)pedrms1/10.;
+ Float_t pedmean =
+ (Float_t) (pedmeanrms - pedrms1)/1000.0;
+ //printf("%f %f\n",pedmean, pedrms);
+ if (adc > 0.)
+ {
+ adc += (pedmean + 3.0*pedrms);
+ AddDigit(trno,detno,ism,jrow,kcol,adc);
+ }
+ }
+ } // column loop
+ } // row loop
treeD->Fill();
ResetDigit();
- } // supermodule loop
- } // detector loop
+ } // supermodule loop
+ } // detector loop
fPMDLoader->WriteDigits("OVERWRITE");
ResetCellADC();
}
Int_t bufsize = 16000;
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
- treeD->Branch("PMDDigit", &fDigits, bufsize);
+ treeD->Branch("PMDDigit", &fDigits, bufsize);
Int_t trno, det, smn;
Int_t irow, icol;
for (Int_t imodule = 0; imodule < nmodules; imodule++)
{
- treeS->GetEntry(imodule);
+ treeS->GetEntry(imodule);
Int_t nentries = fSDigits->GetLast();
AliDebug(2,Form("Number of entries per module = %d",nentries+1));
for (Int_t ient = 0; ient < nentries+1; ient++)
edep = pmdsdigit->GetCellEdep();
MeV2ADC(edep,adc);
- AddDigit(trno,det,smn,irow,icol,adc);
+
+
+ // To decalibrte the adc values
+ //
+ Float_t gain1 = Gain(det,smn,irow,icol);
+ 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(det,smn,irow,icol);
+ Int_t pedrms1 = (Int_t) pedmeanrms%1000;
+ Float_t pedrms = (Float_t)pedrms1/10.;
+ Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
+ //printf("%f %f\n",pedmean, pedrms);
+ if(adc > 0.)
+ {
+ adc += (pedmean + 3.0*pedrms);
+ AddDigit(trno,det,smn,irow,icol,adc);
+ }
+
}
treeD->Fill();
ResetDigit();
}
Int_t bufsize = 16000;
if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
- treeD->Branch("PMDDigit", &fDigits, bufsize);
+ treeD->Branch("PMDDigit", &fDigits, bufsize);
Float_t adc;
Float_t deltaE = 0.;
if (deltaE > 0.)
{
MeV2ADC(deltaE,adc);
- AddDigit(trno,detno,ism,jrow,kcol,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%1000;
+ Float_t pedrms = (Float_t)pedrms1/10.;
+ Float_t pedmean =
+ (Float_t) (pedmeanrms - pedrms1)/1000.0;
+ //printf("%f %f\n",pedmean, pedrms);
+ if (adc > 0.)
+ {
+ adc += (pedmean + 3.0*pedrms);
+ AddDigit(trno,detno,ism,jrow,kcol,adc);
+ }
+
}
} // column loop
} // row loop
ResetDigit();
} // supermodule loop
} // detector loop
- fPMDLoader->WriteDigits("OVERWRITE");
+ fPMDLoader->WriteDigits("OVERWRITE");
fPMDLoader->UnloadDigits();
ResetCellADC();
}
AliDebug(1,Form("Track Offset = %d",troffset));
for (Int_t imodule = 0; imodule < nmodules; imodule++)
{
- treeS->GetEntry(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++)
nn = 1;
pmdTrack[i][j][k] = new Int_t[nn];
pmdEdep[i][j][k] = new Float_t[nn];
- }
+ }
fPRECounter[i][j][k] = 0;
}
}
{
trnarray[trCount] = track;
trCount++;
- }
+ }
trackOld = track;
}
delete [] status1;
}
//____________________________________________________________________________
-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 det, Int_t smnumber,
+ Int_t irow, Int_t icol, Float_t adc)
{
// Add SDigit
//
}
//____________________________________________________________________________
-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 det, Int_t smnumber,
+ Int_t irow, Int_t icol, Float_t adc)
{
// Add Digit
//
{
for (Int_t k = 0; k < fgkCol; k++)
{
- fPRECounter[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.;
+ fCPV[i][j][k] = 0.;
+ fPRE[i][j][k] = 0.;
fPRETrackNo[i][j][k] = 0;
fCPVTrackNo[i][j][k] = 0;
}
}
}
}
-//------------------------------------------------------
//____________________________________________________________________________
void AliPMDDigitizer::UnLoad(Option_t *option)
//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);
- printf("\t gain=%10.3f\n",GainFact);
+ 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