/* $Id$ */
-#include <Riostream.h>
-#include <stdio.h>
-#include <stdlib.h>
+//#include <Riostream.h>
+//#include <stdio.h>
+//#include <stdlib.h>
#include <TFile.h>
-#include <TH1.h>
-#include <TH1F.h>
-#include <TH1S.h>
+//#include <TH1.h>
+//#include <TH1F.h>
+//#include <TH1S.h>
#include <TH2S.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TTimeStamp.h>
#include "AliCDBMetaData.h"
+#include "AliCDBEntry.h"
#include "AliLog.h"
#include "AliTOFChannelOnline.h"
+#include "AliTOFChannelOnlineStatus.h"
#include "AliTOFDataDCS.h"
#include "AliTOFGeometry.h"
#include "AliTOFPreprocessor.h"
+#include "AliTOFFEEReader.h"
-class TF1;
-class AliDCSValue;
-class AliTOFGeometry;
+//class TF1;
+//class AliDCSValue;
+//class AliTOFGeometry;
// TOF preprocessor class.
// It takes data from DCS and passes them to the class AliTOFDataDCS, which
// analogously, it takes data form DAQ (both at Run level and inclusive -
// of all the runs - level, processes them, and stores both Reference Data
// and Online Calibration files in the CDB.
-
+// Processing of Pulser/Noise Run data and of TOF FEE DCS map
+
+// return codes:
+// return=0 : all ok
+// return=1 : no DCS input data Map
+// return=2 : no DCS input data processing
+// return=3 : no DCS processed data was stored in Ref Data
+// return=4 : no DAQ input for Ref Data
+// return=5 : failed to store DAQ Ref Data
+// return=6 : failed to retrieve DAQ data for calibration
+// return=7 : problems in processing histos in the input DAQ file
+// return=8 : failed to store Online Delays
+// return=9 : failed to store Reference Data for Pulser
+// return=10: failed to retrieve Pulser data
+// return=11: failed to store Pulser map in OCDB
+// return=12: failed to store Reference Data for Noise
+// return=13: failed to retrieve Noise data
+// return=14: failed to store Noise map in OCDB
+// return=15: failed to retrieve FEE data from FXS
+// return=16: failed to retrieve FEE data from OCDB
+// return=17: failed to store FEE data in OCDB
+// return=18: failed to store FEE reference data in OCDB
ClassImp(AliTOFPreprocessor)
-const Int_t AliTOFPreprocessor::fgkBinRangeAve = 13; // number of bins where to calculate the mean
-const Double_t AliTOFPreprocessor::fgkThrPar = 0.013; // parameter used to trigger the calculation of the delay
+const Int_t AliTOFPreprocessor::fgkBinRangeAve = 13; // number of bins where to calculate the mean
+const Double_t AliTOFPreprocessor::fgkIntegralThr = 100; // min number of entries to perform computation of delay per channel
+const Double_t AliTOFPreprocessor::fgkThrPar = 0.013; // parameter used to trigger the calculation of the delay
//_____________________________________________________________________________
fData(0),
fh2(0),
fCal(0),
+ fCalStatus(0),
+ fFEEStatus(0),
fNChannels(0),
- fStoreRefData(kTRUE)
+ fStoreRefData(kTRUE),
+ fFDRFlag(kTRUE)
{
// constructor
delete fCal;
fCal = 0;
}
+ if (fCalStatus){
+ delete fCalStatus;
+ fCalStatus = 0;
+ }
+ if (fFEEStatus){
+ delete fFEEStatus;
+ fFEEStatus = 0;
+ }
}
//______________________________________________________________________________
TTimeStamp(endTime).AsString()));
fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime);
+ fData->SetFDRFlag(fFDRFlag);
fh2 = 0x0;
fNChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
fCal = new TObjArray(fNChannels);
AliTOFChannelOnline * calChOnline = new AliTOFChannelOnline();
fCal->AddAt(calChOnline,ich);
}
+ fCalStatus = new TObjArray(fNChannels);
+ fCalStatus->SetOwner();
+ for (Int_t ich = 0; ich<fNChannels; ich ++){
+ AliTOFChannelOnlineStatus * calChOnlineStatus = new AliTOFChannelOnlineStatus();
+ fCalStatus->AddAt(calChOnlineStatus,ich);
+ }
+ fFEEStatus = new TObjArray(fNChannels);
+ fFEEStatus->SetOwner();
+ for (Int_t ich = 0; ich<fNChannels; ich ++){
+ AliTOFChannelOnlineStatus * calChOnlineStatus = new AliTOFChannelOnlineStatus();
+ fFEEStatus->AddAt(calChOnlineStatus,ich);
+ }
}
+//_____________________________________________________________________________
+Bool_t AliTOFPreprocessor::ProcessDCS(){
+
+ // check whether DCS should be processed or not...
+
+ TString runType = GetRunType();
+ Log(Form("RunType %s",runType.Data()));
+
+ if (runType != "PHYSICS"){
+ return kFALSE;
+ }
+ return kTRUE;
+}
//_____________________________________________________________________________
-UInt_t AliTOFPreprocessor::Process(TMap* dcsAliasMap)
+UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap* dcsAliasMap)
{
// Fills data into a AliTOFDataDCS object
- // return codes:
- // return=0 : all ok
- // return=1 : no DCS input data Map
- // return=2 : no DCS input data processing
- // return=3 : no DCS processed data was stored in Ref Data
- // return=4 : no DAQ input for Ref Data
- // return=5 : failed to store Ref Data
- // return=6 : failed to retrieve DAQ data for calibration
- // return=7 : problems in histos in the input DAQ file
- // return=8 : failed to store Online Delays
+
+ Log("Processing DCS DP");
TH1::AddDirectory(0);
Bool_t resultDCSMap=kFALSE;
Bool_t resultDCSStore=kFALSE;
- Bool_t resultDAQ=kFALSE;
- Bool_t resultDAQRef=kFALSE;
// processing DCS
}
}
}
-
+ return 0;
+}
+//_____________________________________________________________________________
+
+UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
+{
+ // Processing data from DAQ for online calibration
+
+ Log("Processing DAQ delays");
+
+ TH1::AddDirectory(0);
+
+ Bool_t resultDAQRef=kFALSE;
+ Bool_t resultTOFPP=kFALSE;
// processing DAQ
TFile * daqFile=0x0;
if(fStoreRefData){
//retrieving data at Run level
TList* list = GetFileSources(kDAQ, "RUNLevel");
- if (list)
+ if (list !=0x0 && list->GetEntries()!=0)
{
AliInfo("The following sources produced files with the id RUNLevel");
list->Print();
return 4;//return error code for failure in retrieving Ref Data
}
}
+ delete list;
}
else{
Log("The input data file list from DAQ (run-level) was not found, TOF exiting from Shuttle ");
//Total files, with cumulative histos
TList* listTot = GetFileSources(kDAQ, "DELAYS");
- if (listTot)
+ if (listTot !=0x0 && listTot->GetEntries()!=0)
{
AliInfo("The following sources produced files with the id DELAYS");
listTot->Print();
delete daqFile;
return 7; //return error code for histograms not existing/junky
}
+ Int_t nNotStatistics = 0; // number of channel with not enough statistics
for (Int_t ich=0;ich<kSize;ich++){
TH1S *h1 = new TH1S("h1","h1",kNBins,kXBinmin-0.5,kNBins*1.+kXBinmin-0.5);
for (Int_t ibin=0;ibin<kNBins;ibin++){
h1->SetBinContent(ibin+1,fh2->GetBinContent(ich+1,ibin+1));
}
- Bool_t found=kFALSE;
- Float_t minContent=h1->Integral()*fgkThrPar;
- Int_t nbinsX = h1->GetNbinsX();
- Int_t startBin=1;
- for (Int_t j=1; j<=nbinsX; j++){
- if ((
- h1->GetBinContent(j) +
- h1->GetBinContent(j+1)+
- h1->GetBinContent(j+2)+
- h1->GetBinContent(j+3))>minContent){
- found=kTRUE;
- startBin=j;
- break;
- }
- }
- if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
- // Now calculate the mean over the interval.
- Double_t mean = 0;
- Double_t sumw2 = 0;
- Double_t nent = 0;
- for(Int_t k=0;k<fgkBinRangeAve;k++){
- mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);
- nent=nent+h1->GetBinContent(startBin+k);
- sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
+ if(h1->Integral()<fgkIntegralThr) {
+ nNotStatistics++;
+ if (!fFDRFlag) Log(Form(" Not enough statistics for bin %i, skipping this channel",ich)); // printing message only if not in FDR runs
+ delete h1;
+ h1=0x0;
+ continue;
}
- mean= mean/nent; //<x>
- sumw2=sumw2/nent; //<x^2>
- Double_t rmsmean= 0;
- rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
- if (ich<fNChannels) {
- AliTOFChannelOnline * ch = (AliTOFChannelOnline *)fCal->At(ich);
- ch->SetDelay((Double_t)mean*AliTOFGeometry::TdcBinWidth()*1.E-3); // delay in ns
+ if (!fFDRFlag) { // not computing delays if in FDR runs
+ Bool_t found=kFALSE;
+ Float_t minContent=h1->Integral()*fgkThrPar;
+ Int_t nbinsX = h1->GetNbinsX();
+ Int_t startBin=1;
+ for (Int_t j=1; j<=nbinsX; j++){
+ if ((
+ h1->GetBinContent(j) +
+ h1->GetBinContent(j+1)+
+ h1->GetBinContent(j+2)+
+ h1->GetBinContent(j+3))>minContent){
+ found=kTRUE;
+ startBin=j;
+ break;
+ }
+ }
+ if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
+ // Now calculate the mean over the interval.
+ Double_t mean = 0;
+ Double_t sumw2 = 0;
+ Double_t nent = 0;
+ for(Int_t k=0;k<fgkBinRangeAve;k++){
+ mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);
+ nent=nent+h1->GetBinContent(startBin+k);
+ sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
+ }
+ mean= mean/nent; //<x>
+ sumw2=sumw2/nent; //<x^2>
+ Double_t rmsmean= 0;
+ rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
+ if (ich<fNChannels) {
+ AliTOFChannelOnline * ch = (AliTOFChannelOnline *)fCal->At(ich);
+ ch->SetDelay((Double_t)mean*AliTOFGeometry::TdcBinWidth()*1.E-3); // delay in ns
+ // ch->SetStatus(1); // calibrated channel, removed for the time being from AliTOFChannelOnline
+ }
}
delete h1;
h1=0x0;
}
+ if (nNotStatistics!=0) Log(Form("Too little statistics for %d channels!",nNotStatistics));
}
daqFile->Close();
delete daqFile;
- AliCDBMetaData metaData;
- metaData.SetBeamPeriod(0);
- metaData.SetResponsible("Chiara Zampolli");
- metaData.SetComment("This preprocessor fills an AliTOFCal object.");
- AliInfo("Storing Calibration Data");
- resultDAQ = Store("Calib","ParOnline",fCal, &metaData);
- if(!resultDAQ){
- Log("Some problems occurred while storing DAQ data processing results");
- return 8;//return error code for problems in storing DAQ data
- }
}
else{
Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle");
return 6;//return error code for problems in retrieving DAQ data
}
}
+ delete listTot;
}
else{
Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
}
daqFile=0;
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Chiara Zampolli");
+ metaData.SetComment("This preprocessor fills a TObjArray object.");
+ AliInfo("Storing Calibration Data");
+ resultTOFPP = Store("Calib","ParOnline",fCal, &metaData,0,kTRUE);
+ if(!resultTOFPP){
+ Log("Some problems occurred while storing online object resulting from DAQ data processing");
+ return 8;//return error code for problems in storing DAQ data
+ }
+
+ return 0;
+}
+//_____________________________________________________________________________
+
+UInt_t AliTOFPreprocessor::ProcessPulserData()
+{
+ // Processing Pulser Run data for TOF channel status
+
+ Log("Processing Pulser");
+
+ TH1::AddDirectory(0);
+
+ Bool_t resultPulserRef=kFALSE;
+ Bool_t resultPulser=kFALSE;
+
+ static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
+ TH1S * htofPulser = new TH1S("hTOFpulser","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
+ for (Int_t ibin =1;ibin<=kSize;ibin++){
+ htofPulser->SetBinContent(ibin,-1);
+ }
+
+ // retrieving last stored pulser object, and copying
+
+ AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Pulser");
+ if (cdbEntry!=0x0){
+ TObjArray *currentCalStatus = (TObjArray*)cdbEntry->GetObject();
+ for (Int_t ich = 0; ich<fNChannels; ich ++){
+ AliTOFChannelOnlineStatus * calChOnlineSt = (AliTOFChannelOnlineStatus*)fCalStatus->At(ich);
+ calChOnlineSt->SetStatus(((AliTOFChannelOnlineStatus*)currentCalStatus->At(ich))->GetStatus());
+ }
+ }
+
+ // processing pulser
+
+ TFile * daqFile=0x0;
+ TH1S *h1=0x0;
+
+ //retrieving Pulser data
+ TList* listPulser = GetFileSources(kDAQ, "PULSER");
+ if (listPulser !=0x0 && listPulser->GetEntries()!=0)
+ {
+ AliInfo("The following sources produced files with the id PULSER");
+ listPulser->Print();
+ for (Int_t jj=0;jj<listPulser->GetEntries();jj++){
+ TObjString * str = dynamic_cast<TObjString*> (listPulser->At(jj));
+ AliInfo(Form("found source %s", str->String().Data()));
+ // file to be stored run per run
+ TString fileNamePulser = GetFile(kDAQ, "PULSER", str->GetName());
+ if (fileNamePulser.Length()>0){
+ // storing refernce data
+ AliInfo(Form("Got the file %s, now we can process pulser data.", fileNamePulser.Data()));
+ daqFile = new TFile(fileNamePulser.Data(),"READ");
+ h1 = (TH1S*) daqFile->Get("hTOFpulser");
+ for (Int_t ibin=0;ibin<kSize;ibin++){
+ if ((h1->GetBinContent(ibin+1))!=-1){
+ if ((htofPulser->GetBinContent(ibin+1))==-1){
+ htofPulser->SetBinContent(ibin+1,h1->GetBinContent(ibin+1));
+ }
+ else {
+ Log(Form("Something strange occurred during Pulser run, channel %i already read by another LDC, please check!",ibin));
+ }
+ }
+ }
+
+ // elaborating infos
+ Double_t mean =0;
+ Int_t nread=0;
+ Int_t nreadNotEmpty=0;
+ for (Int_t ientry=1;ientry<=h1->GetNbinsX();ientry++){
+
+ /* check whether channel has been read out during current run.
+ * if the status is bad it means it has not been read out.
+ * in this case skip channel in order to not affect the mean */
+ if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ientry-1))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
+ continue;
+
+ if (h1->GetBinContent(ientry)==-1) continue;
+ else {
+ if (h1->GetBinContent(ientry)>0) {
+ nreadNotEmpty++;
+ AliDebug(1,Form(" channel %i is ok with entry = %f; so far %i channels added ",ientry-1,h1->GetBinContent(ientry),nreadNotEmpty));
+ }
+ mean+=h1->GetBinContent(ientry);
+ nread++;
+ }
+ }
+ if (nread!=0) {
+ mean/=nread;
+ AliDebug(1,Form(" nread = %i , mean = %f",nread,mean));
+ for (Int_t ich =0;ich<fNChannels;ich++){
+ AliTOFChannelOnlineStatus * chSt = (AliTOFChannelOnlineStatus *)fCalStatus->At(ich);
+ if (h1->GetBinContent(ich+1)==-1) continue;
+ AliDebug(1,Form(" channel %i ",ich));
+ AliDebug(1,Form(" channel status before pulser = %i",(Int_t)chSt->GetStatus()));
+
+ /* check whether channel has been read out during current run.
+ * if the status is bad it means it has not been read out.
+ * in this case skip channel in order to leave its status
+ * unchanged */
+ if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ich))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
+ continue;
+
+ if (h1->GetBinContent(ich+1)<0.05*mean){
+ chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFPulserBad); // bad status for pulser
+ AliDebug(1,Form(" channel status after pulser = %i",(Int_t)chSt->GetStatus()));
+ }
+ else {
+ chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFPulserOk); // bad status for pulser
+ AliDebug(1,Form(" channel status after pulser = %i",(Int_t)chSt->GetStatus()));
+ }
+ }
+ }
+ else {
+ Log("No channels read!! No action taken, keeping old status");
+ }
+
+ daqFile->Close();
+ delete daqFile;
+ delete h1;
+ }
+
+ else{
+ Log("The input data file from DAQ (pulser) was not found, TOF exiting from Shuttle ");
+ return 10;//return error code for failure in retrieving Ref Data
+ }
+
+ }
+ delete listPulser;
+ }
+
+ else{
+ Log("The input data file list from DAQ (pulser) was not found, TOF exiting from Shuttle ");
+ return 10;//return error code for failure in retrieving Ref Data
+ }
+
+ //storing in OCDB
+
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Chiara Zampolli");
+ metaData.SetComment("This preprocessor fills a TObjArray object for Pulser data.");
+ AliInfo("Storing Calibration Data from Pulser Run");
+ resultPulser = Store("Calib","Pulser",fCalStatus, &metaData,0,kTRUE);
+ if(!resultPulser){
+ Log("Some problems occurred while storing online object resulting from Pulser data processing");
+ return 11;//return error code for problems in storing Pulser data
+ }
+
+ if(fStoreRefData){
+
+ AliCDBMetaData metaDataHisto;
+ metaDataHisto.SetBeamPeriod(0);
+ metaDataHisto.SetResponsible("Chiara Zampolli");
+ char comment[200];
+ sprintf(comment,"This preprocessor stores the result of the pulser run");
+ metaDataHisto.SetComment(comment);
+ AliInfo("Storing Reference Data");
+ resultPulserRef = StoreReferenceData("Calib","PulserData",htofPulser, &metaDataHisto);
+ if (!resultPulserRef){
+ Log("some problems occurred::No Reference Data for pulser stored, TOF exiting from Shuttle");
+ return 9;//return error code for failure in storing Ref Data
+ }
+ }
+
+ daqFile=0;
+
+ return 0;
+}
+//_____________________________________________________________________________
+
+UInt_t AliTOFPreprocessor::ProcessNoiseData()
+{
+
+ // Processing Noise Run data for TOF channel status
+
+ Log("Processing Noise");
+
+ TH1::AddDirectory(0);
+
+ Bool_t resultNoiseRef=kFALSE;
+ Bool_t resultNoise=kFALSE;
+
+ static const Int_t kSize = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
+ TH1F * htofNoise = new TH1F("hTOFnoise","histo with signals on TOF during pulser", kSize,-0.5,kSize-0.5);
+ for (Int_t ibin =1;ibin<=kSize;ibin++){
+ htofNoise->SetBinContent(ibin,-1);
+ }
+
+ // retrieving last stored noise object, and copying
+
+ AliCDBEntry *cdbEntry = GetFromOCDB("Calib","Noise");
+ if (cdbEntry!=0x0){
+ TObjArray *currentCalStatus = (TObjArray*)cdbEntry->GetObject();
+ for (Int_t ich = 0; ich<fNChannels; ich ++){
+ AliTOFChannelOnlineStatus * calChOnlineSt = (AliTOFChannelOnlineStatus*)fCalStatus->At(ich);
+ calChOnlineSt->SetStatus(((AliTOFChannelOnlineStatus*)currentCalStatus->At(ich))->GetStatus());
+ }
+ }
+
+ // processing noise
+
+ TFile * daqFile=0x0;
+ TH1F * h1=0x0;
+
+ //retrieving Noise data
+ TList* listNoise = GetFileSources(kDAQ, "NOISE");
+ if (listNoise !=0x0 && listNoise->GetEntries()!=0)
+ {
+ AliInfo("The following sources produced files with the id NOISE");
+ listNoise->Print();
+ for (Int_t jj=0;jj<listNoise->GetEntries();jj++){
+ TObjString * str = dynamic_cast<TObjString*> (listNoise->At(jj));
+ AliInfo(Form("found source %s", str->String().Data()));
+ // file to be stored run per run
+ TString fileNameNoise = GetFile(kDAQ, "NOISE", str->GetName());
+ if (fileNameNoise.Length()>0){
+ // storing refernce data
+ AliInfo(Form("Got the file %s, now we can process noise data.", fileNameNoise.Data()));
+ daqFile = new TFile(fileNameNoise.Data(),"READ");
+ h1 = (TH1F*) daqFile->Get("hTOFnoise");
+ for (Int_t ibin=0;ibin<kSize;ibin++){
+ if ((h1->GetBinContent(ibin+1))!=-1){
+ if ((htofNoise->GetBinContent(ibin+1))==-1){
+ htofNoise->SetBinContent(ibin+1,h1->GetBinContent(ibin+1));
+ }
+ else {
+ Log(Form("Something strange occurred during Noise run, channel %i already read by another LDC, please check!",ibin));
+ }
+ }
+ }
+ // elaborating infos
+ for (Int_t ich =0;ich<fNChannels;ich++){
+ AliTOFChannelOnlineStatus * chSt = (AliTOFChannelOnlineStatus *)fCalStatus->At(ich);
+ if (h1->GetBinContent(ich+1)==-1) continue;
+ AliDebug(1,Form( " channel %i",ich));
+ AliDebug(1,Form( " channel status before noise = %i",(Int_t)chSt->GetStatus()));
+
+ /* check whether channel has been read out during current run.
+ * if the status is bad it means it has not been read out.
+ * in this case skip channel in order to leave its status
+ * unchanged */
+ if (((AliTOFChannelOnlineStatus *)fFEEStatus->At(ich))->GetStatus() == AliTOFChannelOnlineStatus::kTOFHWBad)
+ continue;
+
+ if (h1->GetBinContent(ich+1)>=1){ // setting limit for noise to 1 kHz
+ chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFNoiseBad); // bad status for noise
+ AliDebug(1,Form( " channel status after noise = %i",(Int_t)chSt->GetStatus()));
+ }
+ else {
+ chSt->SetStatus(chSt->GetStatus()|AliTOFChannelOnlineStatus::kTOFNoiseOk); // bad status for noise
+ AliDebug(1,Form(" channel status after noise = %i",(Int_t)chSt->GetStatus()));
+ }
+ }
+
+ daqFile->Close();
+ delete daqFile;
+ delete h1;
+
+ }
+
+ else{
+ Log("The input data file from DAQ (noise) was not found, TOF exiting from Shuttle ");
+ return 13;//return error code for failure in retrieving Ref Data
+ }
+
+ }
+ delete listNoise;
+ }
+ else{
+ Log("The input data file list from DAQ (noise) was not found, TOF exiting from Shuttle ");
+ return 13;//return error code for failure in retrieving Ref Data
+ }
+
+ daqFile=0;
+
+ //storing in OCDB
+
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Chiara Zampolli");
+ metaData.SetComment("This preprocessor fills a TObjArray object for Noise data.");
+ AliInfo("Storing Calibration Data from Noise Run");
+ resultNoise = Store("Calib","Noise",fCalStatus, &metaData,0,kTRUE);
+ if(!resultNoise){
+ Log("Some problems occurred while storing online object resulting from Noise data processing");
+ return 14;//return error code for problems in storing Noise data
+ }
+
+ if(fStoreRefData){
+
+ AliCDBMetaData metaDataHisto;
+ metaDataHisto.SetBeamPeriod(0);
+ metaDataHisto.SetResponsible("Chiara Zampolli");
+ char comment[200];
+ sprintf(comment,"This preprocessor stores the result of the noise run, TOF exiting from Shuttle ");
+ metaDataHisto.SetComment(comment);
+ AliInfo("Storing Reference Data");
+ resultNoiseRef = StoreReferenceData("Calib","NoiseData",htofNoise, &metaDataHisto);
+ if (!resultNoiseRef){
+ Log("some problems occurred::No Reference Data for noise stored");
+ return 12;//return error code for failure in storing Ref Data
+ }
+ }
+
+ return 0;
+}
+//_____________________________________________________________________________
+
+UInt_t AliTOFPreprocessor::ProcessFEEData()
+{
+ // Processing Pulser Run data for TOF channel status
+ // dummy for the time being
+
+ Log("Processing FEE");
+
+ Bool_t updateOCDB = kFALSE;
+ AliTOFFEEReader feeReader;
+ AliTOFChannelOnlineStatus *currentChannel = NULL, *storedChannel = NULL;
+ TObjArray *currentFEE = fFEEStatus;
+
+ TH1C hCurrentFEE("hCurrentFEE","histo with current FEE channel status", fNChannels, 0, fNChannels);
+
+ /* load current TOF FEE config from DCS FXS, parse,
+ * fill current FEE histogram and set FEE status */
+
+ const char * nameFile = GetFile(kDCS,"TofFeeMap","");
+ AliInfo(Form("nameFile = %s",nameFile));
+ if (nameFile == NULL) {
+ return 15;
+ }
+ feeReader.LoadFEEConfig(nameFile);
+ feeReader.ParseFEEConfig();
+ /* loop over channels */
+ for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
+ currentChannel = (AliTOFChannelOnlineStatus *)currentFEE->At(iChannel);
+ if (!currentChannel)
+ continue;
+ /* channel enabled. set FEE channel status ok */
+ if (feeReader.IsChannelEnabled(iChannel)) {
+ currentChannel->SetStatus(AliTOFChannelOnlineStatus::kTOFHWOk);
+ hCurrentFEE.SetBinContent(iChannel + 1, 1);
+ }
+ /* channel disabled. set FEE channel status bad */
+ else {
+ currentChannel->SetStatus(AliTOFChannelOnlineStatus::kTOFHWBad);
+ }
+ }
+
+ /* load stored TOF FEE from OCDB and compare it with current FEE.
+ * if stored FEE is different from current FEE set update flag.
+ * if there is no stored FEE in OCDB set update flag */
+
+ AliCDBEntry *cdbEntry = GetFromOCDB("Calib","FEE");
+ /* no CDB entry found. set update flag */
+ if (cdbEntry == NULL) {
+ updateOCDB = kTRUE;
+ }
+ /* CDB entry OK. loop over channels */
+ else {
+ TObjArray *storedFEE = (TObjArray *)cdbEntry->GetObject();
+ for (Int_t iChannel = 0; iChannel < fNChannels; iChannel++){
+ currentChannel = (AliTOFChannelOnlineStatus *)currentFEE->At(iChannel);
+ storedChannel = (AliTOFChannelOnlineStatus *)storedFEE->At(iChannel);
+ /* compare current FEE channel status with stored one
+ * if different set update flag and break loop */
+ if (currentChannel->GetStatus() != storedChannel->GetStatus()) {
+ updateOCDB = kTRUE;
+ break;
+ }
+ }
+ }
+
+ /* check whether we don't have to store reference data.
+ * in this case we return without errors. */
+ if (fStoreRefData) {
+ /* store reference data */
+ AliCDBMetaData metaDataHisto;
+ metaDataHisto.SetBeamPeriod(0);
+ metaDataHisto.SetResponsible("Roberto Preghenella");
+ metaDataHisto.SetComment("This preprocessor stores the FEE referece data of the current run.");
+ AliInfo("Storing FEE reference data");
+ /* store FEE reference data */
+ if (!StoreReferenceData("Calib", "FEEData", &hCurrentFEE, &metaDataHisto)) {
+ /* failed */
+ Log("problems while storing FEE reference data");
+ return 18; /* error return code for problems while storing FEE reference data */
+ }
+ }
+
+ /* check whether we don't need to update OCDB.
+ * in this case we can return without errors and
+ * the current FEE is stored in the fFEEStatus TObjArray. */
+ if (!updateOCDB) {
+ AliInfo("TOF FEE config has not changed. Do not overwrite stored file.");
+ return 0; /* return ok */
+ }
+
+ /* update the OCDB with the current FEE since even
+ * a little difference has been detected. */
+
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Roberto Preghenella");
+ metaData.SetComment("This preprocessor fills a TObjArray object for FEE data.");
+ AliInfo("Storing FEE data from current run");
+ /* store FEE data */
+ if (!Store("Calib", "FEE", fFEEStatus, &metaData, 0, kTRUE)) {
+ /* failed */
+ Log("problems while storing FEE data object");
+ return 17; /* return error code for problems while storing FEE data */
+ }
+
+ /* everything fine. return */
+
+ return 0;
+
+}
+
+//_____________________________________________________________________________
+
+UInt_t AliTOFPreprocessor::Process(TMap* dcsAliasMap)
+{
+ //
+ //
+ //
+
+ TString runType = GetRunType();
+ Log(Form("RunType %s",runType.Data()));
+
+ // processing
+
+ /* always process FEE data */
+ Int_t iresultFEE = ProcessFEEData();
+ if (iresultFEE != 0)
+ return iresultFEE;
+
+ if (runType == "PULSER") {
+ Int_t iresultPulser = ProcessPulserData();
+ return iresultPulser;
+ }
+
+ if (runType == "NOISE") { // for the time being associating noise runs with pedestal runs; proper run type to be defined
+ Int_t iresultNoise = ProcessNoiseData();
+ return iresultNoise;
+ }
+
+ if (runType == "PHYSICS") {
+ Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
+ if (iresultDCS != 0) {
+ return iresultDCS;
+ }
+ else {
+ Int_t iresultDAQ = ProcessOnlineDelays();
+ return iresultDAQ;
+ }
+ }
+ // storing
return 0;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff