// #include <AliRunDigitizer.h> // ALIRUNDIGITIZER_H
//#include <AliRun.h> // ALIRUN_H
#include <AliLoader.h> // ALILOADER_H
+#include <AliRun.h> // ALILOADER_H
#include <AliRunLoader.h> // ALIRUNLOADER_H
+#include <TRandom.h>
//====================================================================
ClassImp(AliFMDBaseDigitizer)
//____________________________________________________________________
AliFMDBaseDigitizer::AliFMDBaseDigitizer()
- : fRunLoader(0),
+ : fFMD(0),
+ fRunLoader(0),
fEdep(AliFMDMap::kMaxDetectors,
AliFMDMap::kMaxRings,
AliFMDMap::kMaxSectors,
AliFMDMap::kMaxStrips),
- fShapingTime(0)
+ fShapingTime(6)
{
+ AliFMDDebug(1, ("Constructed"));
// Default ctor - don't use it
}
//____________________________________________________________________
AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager)
: AliDigitizer(manager, "AliFMDBaseDigitizer", "FMD Digitizer base class"),
+ fFMD(0),
fRunLoader(0),
fEdep(AliFMDMap::kMaxDetectors,
AliFMDMap::kMaxRings,
AliFMDMap::kMaxSectors,
AliFMDMap::kMaxStrips),
- fShapingTime(0)
+ fShapingTime(6)
{
// Normal CTOR
- AliFMDDebug(1, (" processed"));
+ AliFMDDebug(1, ("Constructed"));
SetShapingTime();
}
AliFMDBaseDigitizer::AliFMDBaseDigitizer(const Char_t* name,
const Char_t* title)
: AliDigitizer(name, title),
+ fFMD(0),
fRunLoader(0),
fEdep(AliFMDMap::kMaxDetectors,
AliFMDMap::kMaxRings,
AliFMDMap::kMaxSectors,
- AliFMDMap::kMaxStrips)
+ AliFMDMap::kMaxStrips),
+ fShapingTime(6)
{
// Normal CTOR
- AliFMDDebug(1, (" processed"));
+ AliFMDDebug(1, (" Constructed"));
SetShapingTime();
}
Bool_t
AliFMDBaseDigitizer::Init()
{
- // Initialization
+ // Initialization. Get a pointer to the parameter manager, and
+ // initialize it.
AliFMDParameters::Instance()->Init();
+ if (AliLog::GetDebugLevel("FMD","") >= 15)
+ AliFMDParameters::Instance()->Print("");
return kTRUE;
}
-
//____________________________________________________________________
UShort_t
-AliFMDBaseDigitizer::MakePedestal(UShort_t,
- Char_t,
- UShort_t,
- UShort_t) const
+AliFMDBaseDigitizer::MakePedestal(UShort_t detector,
+ Char_t ring,
+ UShort_t sector,
+ UShort_t strip) const
{
- // Make a pedestal
- return 0;
+ // Make a pedestal. The pedestal value is drawn from a Gaussian
+ // distribution. The mean of the distribution is the measured
+ // pedestal, and the width is the measured noise.
+ AliFMDParameters* param =AliFMDParameters::Instance();
+ Float_t mean =param->GetPedestal(detector,ring,sector,strip);
+ Float_t width =param->GetPedestalWidth(detector,ring,sector,strip);
+ return UShort_t(TMath::Max(gRandom->Gaus(mean, width), 0.));
}
//____________________________________________________________________
void
-AliFMDBaseDigitizer::SumContributions(AliFMD* fmd)
+AliFMDBaseDigitizer::AddContribution(UShort_t detector,
+ Char_t ring,
+ UShort_t sector,
+ UShort_t strip,
+ Float_t edep)
{
- // Sum energy deposited contributions from each hit in a cache
- // (fEdep).
- if (!fRunLoader)
- Fatal("SumContributions", "no run loader");
-
- // Clear array of deposited energies
- fEdep.Reset();
-
- // Get the FMD loader
- AliLoader* inFMD = fRunLoader->GetLoader("FMDLoader");
- // And load the hits
- inFMD->LoadHits("READ");
-
- // Get the tree of hits
- TTree* hitsTree = inFMD->TreeH();
- if (!hitsTree) {
- // Try again
- inFMD->LoadHits("READ");
- hitsTree = inFMD->TreeH();
+ // Add edep contribution from (detector,ring,sector,strip) to cache
+ AliFMDParameters* param = AliFMDParameters::Instance();
+
+ // Check if strip is `dead'
+ if (param->IsDead(detector, ring, sector, strip)) {
+ AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is marked as dead",
+ detector, ring, sector, strip));
+ return;
}
+ // Check if strip is out-side read-out range
+ // if (strip < minstrip || strip > maxstrip) {
+ // AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]",
+ // detector,ring,sector,strip,minstrip,maxstrip));
+ // continue;
+ // }
- // Get the FMD branch
- TBranch* hitsBranch = hitsTree->GetBranch("FMD");
- if (hitsBranch) fmd->SetHitsAddressBranch(hitsBranch);
- else AliFatal("Branch FMD hit not found");
-
- // Get a list of hits from the FMD manager
- TClonesArray *fmdHits = fmd->Hits();
-
- // Get number of entries in the tree
- Int_t ntracks = Int_t(hitsTree->GetEntries());
-
- AliFMDParameters* param = AliFMDParameters::Instance();
- Int_t read = 0;
- // Loop over the tracks in the
- for (Int_t track = 0; track < ntracks; track++) {
- // Read in entry number `track'
- read += hitsBranch->GetEntry(track);
-
- // Get the number of hits
- Int_t nhits = fmdHits->GetEntries ();
- for (Int_t hit = 0; hit < nhits; hit++) {
- // Get the hit number `hit'
- AliFMDHit* fmdHit =
- static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));
-
- // Extract parameters
- UShort_t detector = fmdHit->Detector();
- Char_t ring = fmdHit->Ring();
- UShort_t sector = fmdHit->Sector();
- UShort_t strip = fmdHit->Strip();
- Float_t edep = fmdHit->Edep();
- // UShort_t minstrip = param->GetMinStrip(detector, ring, sector, strip);
- // UShort_t maxstrip = param->GetMaxStrip(detector, ring, sector, strip);
- // Check if strip is `dead'
- AliFMDDebug(2, ("Hit in FMD%d%c[%2d,%3d]=%f",
- detector, ring, sector, strip, edep));
- if (param->IsDead(detector, ring, sector, strip)) {
- AliFMDDebug(1, ("FMD%d%c[%2d,%3d] is marked as dead",
- detector, ring, sector, strip));
- continue;
- }
- // Check if strip is out-side read-out range
- // if (strip < minstrip || strip > maxstrip) {
- // AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]",
- // detector,ring,sector,strip,minstrip,maxstrip));
- // continue;
- // }
-
- // Give warning in case of double hit
- if (fEdep(detector, ring, sector, strip).fEdep != 0)
- AliFMDDebug(5, ("Double hit in %d%c(%d,%d)",
- detector, ring, sector, strip));
+ // Give warning in case of double sdigit
+ if (fEdep(detector, ring, sector, strip).fEdep != 0)
+ AliFMDDebug(5, ("Double digit in %d%c(%d,%d)",
+ detector, ring, sector, strip));
- // Sum energy deposition
- fEdep(detector, ring, sector, strip).fEdep += edep;
- fEdep(detector, ring, sector, strip).fN += 1;
- // Add this to the energy deposited for this strip
- } // hit loop
- } // track loop
- AliFMDDebug(1, ("Size of cache: %d bytes, read %d bytes",
- sizeof(fEdep), read));
+ // Sum energy deposition
+ fEdep(detector, ring, sector, strip).fEdep += edep;
+ fEdep(detector, ring, sector, strip).fN += 1;
}
//____________________________________________________________________
void
-AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
+AliFMDBaseDigitizer::DigitizeHits() const
{
// For the stored energy contributions in the cache (fEdep), convert
// the energy signal to ADC counts, and store the created digit in
// the digits array (AliFMD::fDigits)
//
+ AliFMDDebug(5, ("Will now digitize all the summed signals"));
AliFMDGeometry* geometry = AliFMDGeometry::Instance();
- TArrayI counts(3);
+ TArrayI counts(4);
for (UShort_t detector=1; detector <= 3; detector++) {
- AliFMDDebug(5, ("Processing hits in FMD%d", detector));
+ AliFMDDebug(10, ("Processing hits in FMD%d", detector));
// Get pointer to subdetector
AliFMDDetector* det = geometry->GetDetector(detector);
if (!det) continue;
for (UShort_t ringi = 0; ringi <= 1; ringi++) {
Char_t ring = ringi == 0 ? 'I' : 'O';
- AliFMDDebug(5, (" Processing hits in FMD%d%c", detector,ring));
+ AliFMDDebug(10, (" Processing hits in FMD%d%c", detector,ring));
// Get pointer to Ring
AliFMDRing* r = det->GetRing(ring);
if (!r) continue;
UShort_t nSectors = UShort_t(360. / r->GetTheta());
// Loop over the number of sectors
for (UShort_t sector = 0; sector < nSectors; sector++) {
- AliFMDDebug(5, (" Processing hits in FMD%d%c[%2d]",
+ AliFMDDebug(10, (" Processing hits in FMD%d%c[%2d]",
detector,ring,sector));
// Get number of strips
UShort_t nStrips = r->GetNStrips();
Float_t edep = fEdep(detector, ring, sector, strip).fEdep;
ConvertToCount(edep, last, detector, ring, sector, strip, counts);
last = edep;
- AddDigit(fmd, detector, ring, sector, strip, edep,
+
+ // The following line was introduced - wrongly - by Peter
+ // Hristov. It _will_ break the digitisation and the
+ // following reconstruction. The behviour of the
+ // digitisation models exactly the front-end as it should
+ // (no matter what memory concuption it may entail). The
+ // check should be on zero suppression, since that's what
+ // models the front-end - if zero suppression is turned on
+ // in the front-end, then we can suppress empty digits -
+ // otherwise we shoud never do that. Note, that the line
+ // affects _both_ normal digitisation and digitisation for
+ // summable digits, since the condition is on the energy
+ // deposition and not on the actual number of counts. If
+ // this line should go anywhere, it should be in the
+ // possible overloaded AliFMDSDigitizer::AddDigit - not
+ // here.
+ //
+ // if (edep<=0) continue;
+ AddDigit(detector, ring, sector, strip, edep,
UShort_t(counts[0]), Short_t(counts[1]),
- Short_t(counts[2]));
- AliFMDDebug(10, (" Adding digit in FMD%d%c[%2d,%3d]=%d",
+ Short_t(counts[2]), Short_t(counts[3]));
+ AliFMDDebug(15, (" Adding digit in FMD%d%c[%2d,%3d]=%d",
detector,ring,sector,strip,counts[0]));
#if 0
// This checks if the digit created will give the `right'
// = E + (l - E) * ext(-B * t)
//
AliFMDParameters* param = AliFMDParameters::Instance();
- Float_t convF = 1./param->GetPulseGain(detector,ring,sector,strip);
+ Float_t convF = (param->GetDACPerMIP()*param->GetPulseGain(detector,ring,sector,strip)) / param->GetEdepMip();
Int_t ped = MakePedestal(detector,ring,sector,strip);
Int_t maxAdc = param->GetAltroChannelSize()-1;
if (maxAdc < 0) {
maxAdc = 1023;
}
UShort_t rate = param->GetSampleRate(detector,ring,sector,strip);
- if (rate < 1 || rate > 3) rate = 1;
-
+ AliFMDDebug(15, ("Sample rate for FMD%d%c[%2d,%3d] = %d",
+ detector, ring, sector, strip, rate));
+ if (rate < 1 || rate > 4) {
+ AliWarning(Form("Invalid sample rate for for FMD%d%c[%2d,%3d] = %d",
+ detector, ring, sector, strip, rate));
+ rate = 1;
+ }
+
// In case we don't oversample, just return the end value.
if (rate == 1) {
Float_t a = edep * convF + ped;
if (a < 0) a = 0;
counts[0] = UShort_t(TMath::Min(a, Float_t(maxAdc)));
- AliFMDDebug(2, ("FMD%d%c[%2d,%3d]: converting ELoss %f to "
+ AliFMDDebug(15, ("FMD%d%c[%2d,%3d]: converting ELoss %f to "
"ADC %4d (%f,%d)",
detector,ring,sector,strip,edep,counts[0],convF,ped));
return;
// Create a pedestal
Float_t b = fShapingTime;
for (Ssiz_t i = 0; i < rate; i++) {
- Float_t t = Float_t(i) / rate;
+ Float_t t = Float_t(i) / rate + 1./rate;
Float_t s = edep + (last - edep) * TMath::Exp(-b * t);
Float_t a = Int_t(s * convF + ped);
if (a < 0) a = 0;
}
}
+//____________________________________________________________________
+void
+AliFMDBaseDigitizer::AddDigit(UShort_t detector,
+ Char_t ring,
+ UShort_t sector,
+ UShort_t strip,
+ Float_t /* edep */,
+ UShort_t count1,
+ Short_t count2,
+ Short_t count3,
+ Short_t count4) const
+{
+ // Add a digit or summable digit
+
+ fFMD->AddDigitByFields(detector, ring, sector, strip,
+ count1, count2, count3, count4);
+}
+
+//____________________________________________________________________
+TTree*
+AliFMDBaseDigitizer::MakeOutputTree(AliLoader* loader)
+{
+ // Create output tree using loader. If the passed loader differs
+ // from the currently set loader in the FMD object, reset the FMD
+ // loader to be the passed loader. This is for the cases wher the
+ // output is different from the output.
+ AliFMDDebug(5, ("Making digits tree"));
+ loader->LoadDigits("UPDATE"); // "RECREATE");
+ TTree* out = loader->TreeD();
+ if (!out) loader->MakeTree("D");
+ out = loader->TreeD();
+ if (out) {
+ out->Reset();
+ if (loader != fFMD->GetLoader())
+ fFMD->SetLoader(loader);
+ fFMD->MakeBranch("D");
+ }
+ return out;
+}
+//____________________________________________________________________
+void
+AliFMDBaseDigitizer::StoreDigits(AliLoader* loader)
+{
+ // Write the digits to disk
+ AliFMDDebug(5, ("Storing %d digits", fFMD->Digits()->GetEntries()));
+ loader->WriteDigits("OVERWRITE");
+ loader->UnloadDigits();
+ // Reset the digits in the AliFMD object
+ fFMD->ResetDigits();
+}
//____________________________________________________________________
//