// `Init'. Optionally, the class can serve hard-coded constants, if
// no CDB is available.
//
-#include "AliLog.h" // ALILOG_H
+#include "AliFMDDebug.h" // ALILOG_H
#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
#include "AliFMDRing.h" // ALIFMDRING_H
#include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
#include <AliCDBManager.h> // ALICDBMANAGER_H
#include <AliCDBEntry.h> // ALICDBMANAGER_H
+#include <AliFMDPreprocessor.h>
+#include <AliLog.h>
#include <Riostream.h>
#include <sstream>
+#include <TSystem.h>
#include <TArrayF.h>
#include <TH2D.h>
AliFMDParameters* AliFMDParameters::fgInstance = 0;
//____________________________________________________________________
-const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
-const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
-const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
-const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
-const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
-const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
-const char* AliFMDParameters::fgkStripRange = "FMD/Calib/StripRange";
-
+const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
+const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
+const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
+const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
+const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
+const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
+const char* AliFMDParameters::fgkStripRange = "FMD/Calib/StripRange";
+const char* AliFMDParameters::fkPedestalShuttleID = "pedestals";
+const char* AliFMDParameters::fkGainShuttleID = "gains";
+const char* AliFMDParameters::fkConditionsShuttleID = "conditions";
//____________________________________________________________________
AliFMDParameters*
fFixedMaxStrip(0),
fFixedPulseGain(0),
fEdepMip(0),
+ fHasRcuTrailer(kTRUE),
+ fHasCompleteHeader(kTRUE),
fZeroSuppression(0),
fSampleRate(0),
fPedestal(0),
SetPedestalFactor();
SetThreshold();
SetStripRange();
+ fAltroMap = new AliFMDAltroMapping;
}
//__________________________________________________________________
void
-AliFMDParameters::Init(Bool_t forceReInit)
+AliFMDParameters::Init(Bool_t forceReInit, UInt_t what)
{
// Initialize the parameters manager. We need to get stuff from the
// CDB here.
if (forceReInit) fIsInit = kFALSE;
if (fIsInit) return;
- InitPulseGain();
- InitPedestal();
- InitDeadMap();
- InitSampleRate();
- InitZeroSuppression();
- InitAltroMap();
+ if (what & kPulseGain) InitPulseGain();
+ if (what & kPedestal) InitPedestal();
+ if (what & kDeadMap) InitDeadMap();
+ if (what & kSampleRate) InitSampleRate();
+ if (what & kZeroSuppression) InitZeroSuppression();
+ if (what & kAltroMap) InitAltroMap();
+ fIsInit = kTRUE;
+}
+//__________________________________________________________________
+void
+AliFMDParameters::Init(AliFMDPreprocessor* pp, Bool_t forceReInit, UInt_t what)
+{
+ // Initialize the parameters manager. We need to get stuff from the
+ // CDB here.
+ if (forceReInit) fIsInit = kFALSE;
+ if (fIsInit) return;
+ if (what & kPulseGain) InitPulseGain(pp);
+ if (what & kPedestal) InitPedestal(pp);
+ if (what & kDeadMap) InitDeadMap(pp);
+ if (what & kSampleRate) InitSampleRate(pp);
+ if (what & kZeroSuppression) InitZeroSuppression(pp);
+ if (what & kAltroMap) InitAltroMap(pp);
fIsInit = kTRUE;
-
}
//__________________________________________________________________
size_t i = opt.Index("fmd",TString::kIgnoreCase);
size_t j = opt.Index("]",TString::kIgnoreCase);
enum {
- read_det,
- read_ring,
- read_lbrack,
- read_sector,
- read_comma,
- read_strip,
- read_rbrack,
- end
- } state = read_det;
+ kReadDet,
+ kReadRing,
+ kReadLbrack,
+ kReadSector,
+ kReadComma,
+ kReadStrip,
+ kReadRbrack,
+ kEnd
+ } state = kReadDet;
std::stringstream s(opt(i+4, j-i-3).Data());
- while (state != end) {
+ while (state != kEnd) {
Char_t tmp = s.peek();
if (tmp == ' ' || tmp == '\t') {
s.get();
continue;
}
switch (state) {
- case read_det: { // First, try to read the detector
+ case kReadDet: { // First, try to kRead the detector
if (tmp == '*') s.get();
else {
UShort_t det;
ds[1] = 0;
}
}
- state = (s.bad() ? end : read_ring);
+ state = (s.bad() ? kEnd : kReadRing);
} break;
- case read_ring: { // Then try to read the ring;
+ case kReadRing: { // Then try to read the ring;
Char_t ring;
s >> ring;
if (ring != '*' && !s.bad()) {
rs[0] = ring;
rs[1] = '\0';
}
- state = (s.bad() ? end : read_lbrack);
+ state = (s.bad() ? kEnd : kReadLbrack);
} break;
- case read_lbrack: { // Try to read a left bracket
+ case kReadLbrack: { // Try to read a left bracket
Char_t lbrack;
s >> lbrack;
- state = (s.bad() ? end : read_sector);
+ state = (s.bad() ? kEnd : kReadSector);
} break;
- case read_sector: { // Try to read a sector
+ case kReadSector: { // Try to read a sector
if (tmp == '*') s.get();
else {
UShort_t sec;
maxSector = sec + 1;
}
}
- state = (s.bad() ? end : read_comma);
+ state = (s.bad() ? kEnd : kReadComma);
} break;
- case read_comma: { // Try to read a left bracket
+ case kReadComma: { // Try to read a left bracket
Char_t comma;
s >> comma;
- state = (s.bad() ? end : read_strip);
+ state = (s.bad() ? kEnd : kReadStrip);
} break;
- case read_strip: { // Try to read a strip
+ case kReadStrip: { // Try to read a strip
if (tmp == '*') s.get();
else {
UShort_t str;
maxStrip = str + 1;
}
}
- state = (s.bad() ? end : read_rbrack);
+ state = (s.bad() ? kEnd : kReadRbrack);
} break;
- case read_rbrack: { // Try to read a left bracket
+ case kReadRbrack: { // Try to read a left bracket
Char_t rbrack;
s >> rbrack;
- state = end;
+ state = kEnd;
} break;
- case end:
+ case kEnd:
break;
}
}
fFixedMaxStrip = max;
}
+//__________________________________________________________________
+AliCDBEntry*
+AliFMDParameters::GetEntry(const char* path, AliFMDPreprocessor* pp,
+ Bool_t fatal) const
+{
+ // Get an entry from the CDB or via preprocessor
+ AliCDBEntry* entry = 0;
+ if (!pp) {
+ AliCDBManager* cdb = AliCDBManager::Instance();
+ entry = cdb->Get(path);
+ }
+ else {
+ const char* third = gSystem->BaseName(path);
+ const char* second = gSystem->BaseName(gSystem->DirName(path));
+ entry = pp->GetFromCDB(second, third);
+ }
+ if (!entry) {
+ TString msg(Form("No %s found in CDB, perhaps you need to "
+ "use AliFMDCalibFaker?", path));
+ if (fatal) { AliFatal(msg.Data()); }
+ else AliLog::Message(AliLog::kWarning, msg.Data(), "FMD",
+ "AliFMDParameters", "GetEntry", __FILE__,
+ __LINE__);
+ return 0;
+ }
+ return entry;
+}
+
+
//__________________________________________________________________
void
-AliFMDParameters::InitPulseGain()
+AliFMDParameters::InitPulseGain(AliFMDPreprocessor* pp)
{
// Get pulse gain from CDB or used fixed
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* gain = cdb->Get(fgkPulseGain);
- if (!gain) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkPulseGain));
- return;
- }
+ AliCDBEntry* gain = GetEntry(fgkPulseGain, pp);
+ if (!gain) return;
- AliDebug(1, Form("Got gain from CDB"));
+ AliFMDDebug(1, ("Got gain from CDB"));
fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
- if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
+ if (!fPulseGain) AliFatal("Invalid pulser gain object from CDB");
}
//__________________________________________________________________
void
-AliFMDParameters::InitPedestal()
+AliFMDParameters::InitPedestal(AliFMDPreprocessor* pp)
{
// Initialize the pedestals from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* pedestal = cdb->Get(fgkPedestal);
- if (!pedestal) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkPedestal));
- return;
- }
- AliDebug(1, Form("Got pedestal from CDB"));
+ AliCDBEntry* pedestal = GetEntry(fgkPedestal, pp);
+ if (!pedestal) return;
+
+ AliFMDDebug(1, ("Got pedestal from CDB"));
fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
- if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
+ if (!fPedestal) AliFatal("Invalid pedestal object from CDB");
}
//__________________________________________________________________
void
-AliFMDParameters::InitDeadMap()
+AliFMDParameters::InitDeadMap(AliFMDPreprocessor* pp)
{
// Get Dead-channel-map from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* deadMap = cdb->Get(fgkDead);
- if (!deadMap) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkDead));
- return;
- }
- AliDebug(1, Form("Got dead map from CDB"));
+ AliCDBEntry* deadMap = GetEntry(fgkDead, pp);
+ if (!deadMap) return;
+
+ AliFMDDebug(1, ("Got dead map from CDB"));
fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
- if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
+ if (!fDeadMap) AliFatal("Invalid dead map object from CDB");
}
//__________________________________________________________________
void
-AliFMDParameters::InitZeroSuppression()
+AliFMDParameters::InitZeroSuppression(AliFMDPreprocessor* pp)
{
// Get 0-suppression from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* zeroSup = cdb->Get(fgkZeroSuppression);
- if (!zeroSup) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkZeroSuppression));
- return;
- }
- AliDebug(1, Form("Got zero suppression from CDB"));
+ AliCDBEntry* zeroSup = GetEntry(fgkZeroSuppression, pp);
+ if (!zeroSup) return;
+ AliFMDDebug(1, ("Got zero suppression from CDB"));
fZeroSuppression =
dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
- if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
+ if (!fZeroSuppression)AliFatal("Invalid zero suppression object from CDB");
}
//__________________________________________________________________
void
-AliFMDParameters::InitSampleRate()
+AliFMDParameters::InitSampleRate(AliFMDPreprocessor* pp)
{
// get Sample rate from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* sampRat = cdb->Get(fgkSampleRate);
- if (!sampRat) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkSampleRate));
- return;
- }
- AliDebug(1, Form("Got zero suppression from CDB"));
+ AliCDBEntry* sampRat = GetEntry(fgkSampleRate, pp);
+ if (!sampRat) return;
+ AliFMDDebug(1, ("Got zero suppression from CDB"));
fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
- if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
+ if (!fSampleRate) AliFatal("Invalid zero suppression object from CDB");
}
//__________________________________________________________________
void
-AliFMDParameters::InitAltroMap()
+AliFMDParameters::InitAltroMap(AliFMDPreprocessor* pp)
{
// Get hardware mapping from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* hwMap = cdb->Get(fgkAltroMap);
- if (!hwMap) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkAltroMap));
- fAltroMap = new AliFMDAltroMapping;
- return;
+ if (fAltroMap) {
+ delete fAltroMap;
+ fAltroMap = 0;
}
- AliDebug(1, Form("Got ALTRO map from CDB"));
+ AliCDBEntry* hwMap = GetEntry(fgkAltroMap, pp);
+ if (!hwMap) return;
+
+ AliFMDDebug(1, ("Got ALTRO map from CDB"));
fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
if (!fAltroMap) {
- AliWarning("Invalid ALTRO map object from CDB");
+ AliFatal("Invalid ALTRO map object from CDB");
fAltroMap = new AliFMDAltroMapping;
}
}
//__________________________________________________________________
void
-AliFMDParameters::InitStripRange()
+AliFMDParameters::InitStripRange(AliFMDPreprocessor* pp)
{
// Get strips read-out from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- AliCDBEntry* range = cdb->Get(fgkStripRange);
- if (!range) {
- AliWarning(Form("No %s found in CDB, perhaps you need to "
- "use AliFMDCalibFaker?", fgkStripRange));
- return;
- }
- AliDebug(1, Form("Got strip range from CDB"));
+ AliCDBEntry* range = GetEntry(fgkStripRange, pp);
+ if (!range) return;
+ AliFMDDebug(1, ("Got strip range from CDB"));
fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
- if (!fStripRange) AliWarning("Invalid strip range object from CDB");
+ if (!fStripRange) AliFatal("Invalid strip range object from CDB");
}
fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
return fFixedPulseGain;
}
- AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
+ AliFMDDebug(50, ("pulse gain for FMD%d%c[%2d,%3d]=%f",
detector, ring, sector, strip,
fPulseGain->Value(detector, ring, sector, strip)));
return fPulseGain->Value(detector, ring, sector, strip);
{
// Check if the channel is dead
if (!fDeadMap) return kFALSE;
- AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
+ AliFMDDebug(50, ("Dead for FMD%d%c[%2d,%3d]=%s",
detector, ring, sector, strip,
fDeadMap->operator()(detector, ring, sector, strip) ?
"no" : "yes"));
// Get zero suppression threshold
if (!fZeroSuppression) return fFixedZeroSuppression;
// Need to map strip to ALTRO chip.
- AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
+ AliFMDDebug(50, ("zero sup. for FMD%d%c[%2d,%3d]=%f",
detector, ring, sector, strip,
fZeroSuppression->operator()(detector, ring,
sector, strip)));
if (!fSampleRate) return fFixedSampleRate;
// Need to map sector to digitizier card.
UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
- AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d",
+ AliFMDDebug(50, ("Sample rate for FMD%d%c[%2d,%3d]=%d",
det, ring, sector, str, ret));
return ret;
}
if (!fStripRange) return fFixedMinStrip;
// Need to map sector to digitizier card.
UInt_t ret = fStripRange->Min(det, ring, sector, str);
- AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d",
+ AliFMDDebug(50, ("Min strip # for FMD%d%c[%2d,%3d]=%d",
det, ring, sector, str, ret));
return ret;
}
if (!fStripRange) return fFixedMaxStrip;
// Need to map sector to digitizier card.
UInt_t ret = fStripRange->Max(det, ring, sector, str);
- AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d",
+ AliFMDDebug(50, ("Max strip # for FMD%d%c[%2d,%3d]=%d",
det, ring, sector, str, ret));
return ret;
}
{
// Get the pedesal
if (!fPedestal) return fFixedPedestal;
- AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
+ AliFMDDebug(50, ("pedestal for FMD%d%c[%2d,%3d]=%f",
detector, ring, sector, strip,
fPedestal->Value(detector, ring, sector, strip)));
return fPedestal->Value(detector, ring, sector, strip);
{
// Get the pedesal
if (!fPedestal) return fFixedPedestalWidth;
- AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
+ AliFMDDebug(50, ("pedetal width for FMD%d%c[%2d,%3d]=%f",
detector, ring, sector, strip,
fPedestal->Width(detector, ring, sector, strip)));
return fPedestal->Width(detector, ring, sector, strip);
//__________________________________________________________________
Bool_t
-AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
- Char_t& ring, UShort_t& sec,
- UShort_t& str) const
+AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t board,
+ UInt_t chip, UInt_t chan,
+ UShort_t& det, Char_t& ring,
+ UShort_t& sec, UShort_t& str) const
+{
+ // Map hardware address to detector index
+ if (!fAltroMap) return kFALSE;
+ return fAltroMap->Hardware2Detector(ddl,board,chip,chan, det,ring,sec,str);
+}
+//__________________________________________________________________
+Bool_t
+AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr,
+ UShort_t& det, Char_t& ring,
+ UShort_t& sec, UShort_t& str) const
{
// Map hardware address to detector index
if (!fAltroMap) return kFALSE;
//__________________________________________________________________
Bool_t
-AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec,
- UShort_t str, UInt_t& ddl,
- UInt_t& addr) const
+AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
+ UShort_t sec, UShort_t str,
+ UInt_t& ddl, UInt_t& board,
+ UInt_t& chip, UInt_t& chan) const
+{
+ // Map detector index to hardware address
+ if (!fAltroMap) return kFALSE;
+ return fAltroMap->Detector2Hardware(det,ring,sec,str, ddl,board,chip,chan);
+}
+
+//__________________________________________________________________
+Bool_t
+AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring,
+ UShort_t sec, UShort_t str,
+ UInt_t& ddl, UInt_t& addr) const
{
// Map detector index to hardware address
if (!fAltroMap) return kFALSE;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff