X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=FMD%2FAliFMDPreprocessor.cxx;h=98654f22e94702eb18279ddc9030ee4311705220;hb=2d8b837d12840f659688d4854f57def35eabfbd6;hp=6c5df9dc1bcbf90ef58f92e4551eb13c9e40c4ba;hpb=f6449cc00230641bdb4dcdfa9d6f1220b5c2261c;p=u%2Fmrichter%2FAliRoot.git diff --git a/FMD/AliFMDPreprocessor.cxx b/FMD/AliFMDPreprocessor.cxx index 6c5df9dc1bc..98654f22e94 100644 --- a/FMD/AliFMDPreprocessor.cxx +++ b/FMD/AliFMDPreprocessor.cxx @@ -51,15 +51,21 @@ // error Error on gain // chi2 Chi^2 per degrees of freedom of fit // +// See also +// +// http://aliceinfo.cern.ch/Offline/Activities/Shuttle.html +// // Latest changes by Christian Holm Christensen // -// #include + #include #include #include "AliFMDPreprocessor.h" #include "AliFMDCalibPedestal.h" #include "AliFMDCalibGain.h" +#include "AliFMDCalibStripRange.h" +#include "AliFMDCalibSampleRate.h" #include "AliFMDParameters.h" #include "AliCDBMetaData.h" #include "AliCDBManager.h" @@ -77,6 +83,52 @@ ClassImp(AliFMDPreprocessor) ; #endif + +//____________________________________________________ +AliFMDPreprocessor::AliFMDPreprocessor(AliShuttleInterface* shuttle) + : AliPreprocessor("FMD", shuttle) +{ + AddRunType("PHYSICS"); + AddRunType("STANDALONE"); + AddRunType("PEDESTAL"); + AddRunType("GAIN"); +} + + +//____________________________________________________ +Bool_t AliFMDPreprocessor::GetAndCheckFileSources(TList*& list, + Int_t system, + const char* id) +{ + // Convinience function + // Parameters: + // list On return, list of files. + // system Alice system (DAQ, DCS, ...) + // id File id + // Return: + // kTRUE on success. + list = GetFileSources(system, id); + if (!list) { + TString sys; + switch (system) { + case kDAQ: sys = "DAQ"; break; + case kDCS: sys = "DCS"; break; + default: sys = "unknown"; break; + } + Log(Form("Failed to get file sources for %s/%d", sys.Data(), system)); + return kFALSE; + } + return kTRUE; +} + +//____________________________________________________ +AliCDBEntry* +AliFMDPreprocessor::GetFromCDB(const char* second, const char* third) +{ + return GetFromOCDB(second, third); +} + + //____________________________________________________ UInt_t AliFMDPreprocessor::Process(TMap* /* dcsAliasMap */) { @@ -84,24 +136,70 @@ UInt_t AliFMDPreprocessor::Process(TMap* /* dcsAliasMap */) // Parameters: // dcsAliassMap Map of DCS data point aliases. // Return - // ? - + // 0 on success, >0 otherwise + Bool_t resultPed = kTRUE; + Bool_t resultGain = kTRUE; + Bool_t resultRange = kTRUE; + Bool_t resultRate = kTRUE; + Bool_t resultZero = kTRUE; + Bool_t infoCalib = kTRUE; + Bool_t resultDead = kTRUE; // Do we need this ? // if(!dcsAliasMap) return 1; // // Invoking the cdb manager and the FMD parameters class // AliCDBManager* cdb = AliCDBManager::Instance(); - // cdb->SetDefaultStorage("local://$ALICE_ROOT"); + // cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); // cdb->SetRun(0); + + // Get the run type + TString runType(GetRunType()); + AliFMDParameters* pars = AliFMDParameters::Instance(); - pars->Init(false, AliFMDParameters::kAltroMap); + if(runType.Contains("PEDESTAL", TString::kIgnoreCase)) + pars->Init(this, false, AliFMDParameters::kAltroMap|AliFMDParameters::kPulseGain); + else if(runType.Contains("GAIN", TString::kIgnoreCase)) + pars->Init(this, false, AliFMDParameters::kAltroMap|AliFMDParameters::kPedestal); + else + pars->Init(this, false, AliFMDParameters::kAltroMap); - //Creating calibration objects - TList* pedFiles = GetFileSources(kDAQ,"pedestal"); - TList* gainFiles = GetFileSources(kDAQ, "gain"); - AliFMDCalibPedestal* calibPed = GetPedestalCalibration(pedFiles); - AliFMDCalibGain* calibGain = GetGainCalibration(gainFiles); + // This is if the SOR contains Fee parameters, and we run a DA to + // extract these parameters. The same code could work if we get + // the information from DCS via the FXS + TList* files = 0; + AliFMDCalibSampleRate* calibRate = 0; + AliFMDCalibStripRange* calibRange = 0; + AliFMDCalibZeroSuppression* calibZero = 0; + + if (GetAndCheckFileSources(files, kDAQ,pars->GetConditionsShuttleID())) + infoCalib = GetInfoCalibration(files, calibRate, calibRange, calibZero); + + resultRate = (!calibRate ? kFALSE : kTRUE); + resultRange = (!calibRange ? kFALSE : kTRUE); + resultZero = (!calibZero ? kFALSE : kTRUE); + + + //Creating calibration objects + AliFMDCalibPedestal* calibPed = 0; + AliFMDCalibGain* calibGain = 0; + AliFMDCalibDeadMap* calibDead = 0; + if (runType.Contains("PEDESTAL", TString::kIgnoreCase)) { + if (GetAndCheckFileSources(files, kDAQ, pars->GetPedestalShuttleID())) { + if(files->GetSize()) + calibPed = GetPedestalCalibration(files); + } + resultPed = (calibPed ? kTRUE : kFALSE); + } + if (runType.Contains("GAIN", TString::kIgnoreCase)) { + if (GetAndCheckFileSources(files, kDAQ, pars->GetGainShuttleID())) { + if(files->GetSize()) + calibGain = GetGainCalibration(files); + } + resultGain = (calibGain ? kTRUE : kFALSE); + } + if(runType.Contains("PEDESTAL", TString::kIgnoreCase) || runType.Contains("GAIN", TString::kIgnoreCase)) + calibDead = GetDeadChannelMap(calibPed,calibGain); //Storing Calibration objects AliCDBMetaData metaData; @@ -109,18 +207,81 @@ UInt_t AliFMDPreprocessor::Process(TMap* /* dcsAliasMap */) metaData.SetResponsible("Hans H. Dalsgaard"); metaData.SetComment("Preprocessor stores pedestals and gains for the FMD."); - Bool_t resultPed = kFALSE, resultGain = kFALSE; - if(calibPed) resultPed = Store("Calib","Pedestal", calibPed, &metaData); - if(calibGain) resultGain = Store("Calib","PulseGain", calibGain, &metaData); - if (calibPed) delete calibPed; - if (calibGain) delete calibGain; + if(calibPed) { + resultPed = Store("Calib","Pedestal", calibPed, &metaData, 0, kTRUE); + delete calibPed; + } + if(calibGain) { + resultGain = Store("Calib","PulseGain", calibGain, &metaData, 0, kTRUE); + delete calibGain; + } + if(calibRange) { + resultRange = Store("Calib","StripRange", calibRange, &metaData, 0, kTRUE); + delete calibRange; + } + if(calibRate) { + resultRate = Store("Calib","SampleRate", calibRate, &metaData, 0, kTRUE); + delete calibRate; + } + if(calibZero) { + resultZero = Store("Calib","ZeroSuppression", calibZero,&metaData,0,kTRUE); + delete calibZero; + } + if(calibDead) { + resultDead = Store("Calib","Dead", calibDead,&metaData,0,kTRUE); + delete calibDead; + } + + Bool_t success = (resultPed && resultGain && resultRange && + resultRate && resultZero && resultDead && infoCalib); - return (resultPed && resultGain ? 0 : 1); + Log(Form("FMD preprocessor was %s", (success ? "successful" : "failed"))); + return (success ? 0 : 1); } +//____________________________________________________________________ +Bool_t +AliFMDPreprocessor::GetInfoCalibration(TList* files, + AliFMDCalibSampleRate*& s, + AliFMDCalibStripRange*& r, + AliFMDCalibZeroSuppression*& z) +{ + // Get info calibrations. + // Parameters: + // files List of files. + // s On return, newly allocated object + // r On return, newly allocated object + // z On return, newly allocated object + // Return: + // kTRUE on success + if (!files) return kFALSE; // Should really be false + if (files->GetEntries() <= 0) return kFALSE; + + s = new AliFMDCalibSampleRate(); + r = new AliFMDCalibStripRange(); + z = new AliFMDCalibZeroSuppression(); + + AliFMDParameters* pars = AliFMDParameters::Instance(); + TIter iter(files); + TObjString* fileSource; + + while((fileSource = dynamic_cast(iter.Next()))) { + const Char_t* filename = GetFile(kDAQ, pars->GetConditionsShuttleID(), fileSource->GetName()); + std::ifstream in(filename); + if(!in) { + Log(Form("File %s not found!", filename)); + continue; + } + s->ReadFromFile(in); + r->ReadFromFile(in); + } + return kTRUE; +} + + //____________________________________________________________________ AliFMDCalibPedestal* -AliFMDPreprocessor::GetPedestalCalibration(TList* pedFiles) +AliFMDPreprocessor::GetPedestalCalibration(const TList* pedFiles) { // Read DAQ DA produced CSV files of pedestals, and return a // calibration object. @@ -137,59 +298,65 @@ AliFMDPreprocessor::GetPedestalCalibration(TList* pedFiles) TObjString* fileSource; while((fileSource = dynamic_cast(iter.Next()))) { - const Char_t* filename = GetFile(kDAQ, "pedestal", fileSource->GetName()); + const Char_t* filename = GetFile(kDAQ, pars->GetPedestalShuttleID(), + fileSource->GetName()); std::ifstream in(filename); if(!in) { - AliError(Form("File %s not found!", filename)); + Log(Form("File %s not found!", filename)); continue; } - - // Get header (how long is it ?) - TString header; - header.ReadLine(in); - header.ToLower(); - if(!header.Contains("pedestal")) { - AliError("File header is not from pedestal!"); - continue; - } - Log("File contains data from pedestals"); - - // Read columns line - int lineno = 2; - header.ReadLine(in); - // Loop until EOF - while(!in.eof()) { + int lineno = 0; + char cc; + while((cc = in.peek())!=EOF) { if(in.bad()) { - AliError(Form("Bad read at line %d in %s", lineno, filename)); + Log(Form("Bad read at line %d in %s", lineno, filename)); break; } - UInt_t ddl=2, board, chip, channel, strip, tb; + if (cc == '#') { + TString line; + line.ReadLine(in); + lineno++; + if (lineno == 1) { + line.ToLower(); + if(!line.Contains(pars->GetPedestalShuttleID())) { + Log(Form("File header is not from pedestal!: %s", line.Data())); + break; + } + Log("File contains data from pedestals"); + } + continue; + } + UShort_t det, sec, strip; + Char_t ring; Float_t ped, noise, mu, sigma, chi2ndf; - Char_t c[10]; + Char_t c[8]; - in // >> ddl >> c[0] - >> board >> c[1] - >> chip >> c[2] - >> channel >> c[3] - >> strip >> c[4] - >> tb >> c[5] - >> ped >> c[6] - >> noise >> c[7] - >> mu >> c[8] - >> sigma >> c[9] + in >> det >> c[0] + >> ring >> c[1] + >> sec >> c[2] + >> strip >> c[3] + >> ped >> c[4] + >> noise >> c[5] + >> mu >> c[6] + >> sigma >> c[7] >> chi2ndf; lineno++; + // Ignore trailing garbage - if (strip > 127) continue; + // if (strip > 127) continue; + //Setting DDL to comply with the FMD in DAQ + // UInt_t FmdDDLBase = 3072; + // ddl = ddl - FmdDDLBase; //Setting the pedestals via the hardware address - UShort_t det, sec, str; - Char_t ring; - - pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str); - strip += str; + + + // pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str); + // strip += str; + calibPed->Set(det,ring,sec,strip,ped,noise); + } } return calibPed; @@ -197,7 +364,7 @@ AliFMDPreprocessor::GetPedestalCalibration(TList* pedFiles) //____________________________________________________________________ AliFMDCalibGain* -AliFMDPreprocessor::GetGainCalibration(TList* gainFiles) +AliFMDPreprocessor::GetGainCalibration(const TList* gainFiles) { // Read DAQ DA produced CSV files of pedestals, and return a // calibration object. @@ -213,61 +380,109 @@ AliFMDPreprocessor::GetGainCalibration(TList* gainFiles) TIter iter(gainFiles); TObjString* fileSource; while((fileSource = dynamic_cast(iter.Next()))) { - const Char_t* filename = GetFile(kDAQ, "gain", fileSource->GetName()); + const Char_t* filename = GetFile(kDAQ, pars->GetGainShuttleID(), + fileSource->GetName()); std::ifstream in(filename); if(!in) { - AliError(Form("File %s not found!", filename)); - continue; - } - - //Get header (how long is it ?) - TString header; - header.ReadLine(in); - header.ToLower(); - if(!header.Contains("gain")) { - AliError("File header is not from gain!"); + Log(Form("File %s not found!", filename)); continue; } - Log("File contains data from pulse gain"); - - // Read column headers - header.ReadLine(in); - - int lineno = 2; - // Read until EOF - while(!in.eof()) { - if(in.bad()) { - AliError(Form("Bad read at line %d in %s", lineno, filename)); - break; + // Loop until EOF + int lineno = 0; + char cc; + while((cc = in.peek())!=EOF) { + if(in.bad()) { + Log(Form("Bad read at line %d in %s", lineno, filename)); + break; } - UInt_t ddl=2, board, chip, channel, strip; + if (cc == '#') { + TString line; + line.ReadLine(in); + lineno++; + if (lineno == 1) { + line.ToLower(); + if(!line.Contains(pars->GetGainShuttleID())) { + Log(Form("File header is not from gains!: %s", line.Data())); + break; + } + Log("File contains data from gains"); + } + continue; + } + UShort_t det, sec, strip; + Char_t ring; + Float_t gain,error, chi2ndf; - Char_t c[7]; - - in // >> ddl >> c[0] - >> board >> c[1] - >> chip >> c[2] - >> channel >> c[3] - >> strip >> c[4] - >> gain >> c[5] - >> error >> c[6] + Char_t c[6]; + + in >> det >> c[0] + >> ring >> c[1] + >> sec >> c[2] + >> strip >> c[3] + >> gain >> c[4] + >> error >> c[5] >> chi2ndf; lineno++; // Ignore trailing garbage - if(strip > 127) continue; + //if(strip > 127) continue; + //Setting DDL to comply with the FMD in DAQ + // UInt_t FmdDDLBase = 3072; + // ddl = ddl - FmdDDLBase; //Setting the pedestals via the hardware address - UShort_t det, sec, str; - Char_t ring; - pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str); + // pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str); - strip += str; + // strip += str; calibGain->Set(det,ring,sec,strip,gain); } } return calibGain; } +//____________________________________________________________________ +AliFMDCalibDeadMap* +AliFMDPreprocessor::GetDeadChannelMap(AliFMDCalibPedestal* pedcalib, + AliFMDCalibGain* gaincalib) { + //creating dead channel map. '0' means 51200 entries + AliFMDCalibDeadMap* deadmap = new AliFMDCalibDeadMap(0); + //deadmap->Reset(kTRUE); + Float_t noise = 0; + Float_t gain = 0; + + AliFMDParameters* pars = AliFMDParameters::Instance(); + //Looping over the channels. + for(UShort_t det=1;det<=3;det++) { + Int_t nRings = (det==1 ? 1 : 2); + for (UShort_t ir = 0; ir < nRings; ir++) { + Char_t ring = (ir == 0 ? 'I' : 'O'); + UShort_t nsec = (ir == 0 ? 20 : 40); + UShort_t nstr = (ir == 0 ? 512 : 256); + + for(UShort_t sec =0; sec < nsec; sec++) { + + for(UShort_t strip = 0; strip < nstr; strip++) { + + Bool_t isDead = kFALSE; + if(pedcalib) + noise = pedcalib->Width(det, ring, sec, strip); + else + noise = pars->GetPedestalWidth(det, ring, sec, strip); + + if(gaincalib) + gain = gaincalib->Value(det, ring, sec, strip); + else + gain = pars->GetPulseGain(det, ring, sec, strip); + + //marking these channels dead. + if (gain < 0.5 || gain > 5 || noise > 10 || noise == 0) isDead = kTRUE; + + deadmap->operator()(det, ring, sec, strip) = isDead; + } + } + } + } + return deadmap; +} //____________________________________________________________________ // // EOF