// and stores both reference data and spline fits results //
// in the CDB //
// //
-// Author: //
+// Authors: //
// R. Bailhache (R.Bailhache@gsi.de) //
// W. Monange (w.monange@gsi.de) //
+// F. Kramer (kramer@ikf.uni-frankfurt.de) //
// //
////////////////////////////////////////////////////////////////////////////
+#include <fstream>
+
#include <TFile.h>
#include <TProfile2D.h>
-#include <TStopwatch.h>
#include <TObjString.h>
#include <TString.h>
#include <TList.h>
-#include <TCollection.h>
-#include "TSAXParser.h"
+#include <TSAXParser.h>
#include "AliCDBMetaData.h"
#include "AliLog.h"
#include "AliTRDCalibraMode.h"
#include "AliTRDCalibPadStatus.h"
#include "AliTRDSaxHandler.h"
-#include "Cal/AliTRDCalDet.h"
+#include "AliTRDgeometry.h"
+#include "Cal/AliTRDCalPad.h"
#include "Cal/AliTRDCalPadStatus.h"
#include "Cal/AliTRDCalDCS.h"
+#include "Cal/AliTRDCalSingleChamberStatus.h"
+#include "Cal/AliTRDCalROC.h"
ClassImp(AliTRDPreprocessor)
// Constructor
//
- AddRunType("PHYSICS");
- AddRunType("STANDALONE");
- AddRunType("PEDESTAL");
-
+ AddRunType("PHYSICS");
+ AddRunType("STANDALONE");
+ AddRunType("PEDESTAL");
+ AddRunType("DAQ");
+
}
//______________________________________________________________________________________________
TString runType = GetRunType();
Log(Form("runtype %s\n",runType.Data()));
-
+
// always process the configuration data
- Int_t resultDCSC = ProcessDCSConfigData();
- // if there was an error, return with its code
- if (resultDCSC != 0) return resultDCSC;
-
+ if(ProcessDCSConfigData()) return 1;
+
if (runType=="PEDESTAL"){
if(ExtractPedestals()) return 1;
return 0;
}
- if ((runType=="PHYSICS") || (runType=="STANDALONE")){
+ if ((runType=="PHYSICS") || (runType=="STANDALONE") || (runType=="DAQ")){
// DCS
- if(ProcessDCS(dcsAliasMap)) return 1;
- // HLT if On
- //TString runPar = GetRunParameter("HLTStatus");
- //if(runPar=="1") {
- if(GetHLTStatus()) {
- if(ExtractHLT()) return 1;
- }
- // DAQ if HLT failed
- if(!fVdriftHLT) {
- if(ExtractDriftVelocityDAQ()) return 1;
+ if(ProcessDCS(dcsAliasMap)) return 1;
+ if(runType=="PHYSICS"){
+ // HLT if On
+ //TString runPar = GetRunParameter("HLTStatus");
+ //if(runPar=="1") {
+ if(GetHLTStatus()) {
+ if(ExtractHLT()) return 1; // for testing!
+ }
+ // DAQ if HLT failed
+ if(!fVdriftHLT) {
+ if(ExtractDriftVelocityDAQ()) return 1; // for testing!
+ }
}
}
return 0;
}
-
//______________________________________________________________________________
Bool_t AliTRDPreprocessor::ProcessDCS()
{
//
// Pedestal running on LDCs at the DAQ
//
-
+
+ //
+ // The reference data are stored in:
+ // PadStatus1 for sm-00-01-02-09-10-11
+ // PadStatus2 for sm-03-04-05-12-13-14
+ // PadStatus3 for sm-06-07-08-15-16-17
+ // PadStatus0 if nothing found..means problems
+ //
+
Bool_t error = kFALSE;
// Init a AliTRDCalibPadStatus
if(calPed){
- Int_t sm = -1;
+ Int_t ldc = 0;
// analyse
//calPed->AnalyseHisto();
AliTRDCalROC *rocMean = calPed->GetCalRocMean(idet, kFALSE);
if ( rocMean ) {
calPedSum.SetCalRocMean(rocMean,idet);
- sm = (Int_t) (idet / 30);
+ ldc = (Int_t) (idet / 30);
}
AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
if ( rocRMS ) {
}
}// det loop
+ if((ldc==0) || (ldc==1) || (ldc==2) || (ldc==9) || (ldc==10) || (ldc==11)) ldc = 1;
+ if((ldc==3) || (ldc==4) || (ldc==5) || (ldc==12) || (ldc==13) || (ldc==14)) ldc = 2;
+ if((ldc==6) || (ldc==7) || (ldc==8) || (ldc==15) || (ldc==16) || (ldc==17)) ldc = 3;
+
// store as reference data
TString name("PadStatus");
- name += sm;
+ name += ldc;
if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
error = kTRUE;
}
//
- // Store pedestal entry to OCDB
+ // Create pedestal
//
// Create Pad Status
AliTRDCalPadStatus *calPadStatus = calPedSum.CreateCalPadStatus();
+ // Create Noise
+ //Make the AliTRDCalPad
+ AliTRDCalPad *calPad2 = calPedSum.CreateCalPad();
+ //Make the AliTRDCalDet correspondant
+ AliTRDCalDet *calDet = calPedSum.CreateCalDet();
+
+ //
+ // Take the noise and Pad status from the previous OCDB
+ //
+
+ AliTRDCalPad *calPadPrevious=0;
+ AliCDBEntry* entry = GetFromOCDB("Calib", "PadNoise");
+ if (entry) calPadPrevious = (AliTRDCalPad*)entry->GetObject();
+ if ( calPadPrevious==NULL ) {
+ Log("AliTRDPreprocsessor: No previous TRD pad noise entry available.\n");
+ calPadPrevious = new AliTRDCalPad("PadNoise", "PadNoise");
+ }
+
+ AliTRDCalPadStatus *calPadStatusPrevious=0;
+ entry = GetFromOCDB("Calib", "PadStatus");
+ if (entry) calPadStatusPrevious = (AliTRDCalPadStatus*)entry->GetObject();
+ if ( calPadStatusPrevious==NULL ) {
+ Log("AliTRDPreprocsessor: No previous TRD pad status entry available.\n");
+ calPadStatusPrevious = new AliTRDCalPadStatus("padstatus", "padstatus");
+ for (Int_t idet=0; idet<540; ++idet)
+ {
+ AliTRDCalSingleChamberStatus *calROC = calPadStatusPrevious->GetCalROC(idet);
+ for(Int_t k = 0; k < calROC->GetNchannels(); k++){
+ calROC->SetStatus(k,AliTRDCalPadStatus::kMasked);
+ }
+ }
+ }
+
+
+ // Loop over detectors for check
+ for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det) {
+
+ // noise
+ AliTRDCalROC *calROCPreviousNoise = calPadPrevious->GetCalROC(det);
+ AliTRDCalROC *calROCNoise = calPad2->GetCalROC(det);
+
+ // padstatus
+ AliTRDCalSingleChamberStatus *calROCPreviousStatus = calPadStatusPrevious->GetCalROC(det);
+ AliTRDCalSingleChamberStatus *calROCStatus = calPadStatus->GetCalROC(det);
+
+
+ // loop over first half and second half chamber
+ for(Int_t half = 0; half < 2; half++){
+
+ Bool_t data = AreThereDataPedestal(calROCStatus,(Bool_t)half);
+ //printf("There are data for the detector %d the half %d: %d\n",det,half,data);
+ if(!data){
+ // look if data in the OCDB
+ Bool_t dataPrevious = AreThereDataPedestal(calROCPreviousStatus,(Bool_t)half);
+ // if no data at all, set to default value
+ if(!dataPrevious){
+ SetDefaultStatus(*calROCStatus,(Bool_t)half);
+ SetDefaultNoise(*calROCNoise,(Bool_t)half);
+ }
+ else{
+ // if data, set to previous value
+ SetStatus(*calROCStatus,calROCPreviousStatus,(Bool_t)half);
+ SetNoise(*calROCNoise,calROCPreviousNoise,(Bool_t)half);
+ }
+ }
+ }
+ }
+
+ //
+ // Store
+ //
+
AliCDBMetaData md3;
md3.SetObjectClassName("AliTRDCalPadStatus");
md3.SetResponsible("Raphaelle Bailhache");
return kTRUE;
}
- // Create Noise
- //Make the AliTRDCalPad
- AliTRDCalPad *calPad2 = calPedSum.CreateCalPad();
AliCDBMetaData md4;
md4.SetObjectClassName("AliTRDCalPad");
md4.SetResponsible("Raphaelle Bailhache");
delete listpad;
return kTRUE;
}
- //Make the AliTRDCalDet correspondant
- AliTRDCalDet *calDet = calPedSum.CreateCalDet();
+
AliCDBMetaData md5;
md5.SetObjectClassName("AliTRDCalDet");
md5.SetResponsible("Raphaelle Bailhache");
delete listpad;
return error;
+
+}
+
+//__________________________________________________________________
+Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus * const calROCStatus
+ , Bool_t second)
+{
+ //
+ // Data for this half chamber
+ //
+
+ Bool_t data = kFALSE;
+ Int_t nCols = calROCStatus->GetNcols();
+ Int_t nCol0 = 0;
+ Int_t nColE = (Int_t) nCols/2 - 2;
+ if(second) {
+ nCol0 = nColE + 4;
+ nColE = nCols;
+ }
+
+ Int_t totalnumberofpads = 0;
+ Int_t totalnumberofdata = 0;
+
+ for(Int_t col = nCol0; col < nColE; col++){
+ for(Int_t row = 0; row < calROCStatus->GetNrows(); row++){
+ totalnumberofpads++;
+ //printf("ismasked %d\n",(Int_t)calROCStatus->IsMasked(col,row));
+ if(!calROCStatus->GetStatus(col,row)) {
+ data = kTRUE;
+ totalnumberofdata++;
+ }
+ }
+ }
+ if(totalnumberofdata < (Int_t)(totalnumberofpads/2)) data = kFALSE;
+
+ return data;
+
+}
+//__________________________________________________________________
+void AliTRDPreprocessor::SetDefaultStatus(AliTRDCalSingleChamberStatus &calROCStatus, Bool_t second){
+
+ //
+ // default status for this half chamber
+ //
+
+ Int_t nCols = calROCStatus.GetNcols();
+ Int_t nCol0 = 0;
+ Int_t nColE = (Int_t) nCols/2;
+ if(second) {
+ nCol0 = nColE;
+ nColE = nCols;
+ }
+ for(Int_t col = nCol0; col < nColE; col++){
+ for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
+ calROCStatus.SetStatus(col,row,0);
+ }
+ }
+}
+//__________________________________________________________________
+void AliTRDPreprocessor::SetStatus(AliTRDCalSingleChamberStatus &calROCStatus, AliTRDCalSingleChamberStatus *calROCStatusPrevious,Bool_t second){
+
+ //
+ // previous status for this half chamber
+ //
+
+ Int_t nCols = calROCStatus.GetNcols();
+ Int_t nCol0 = 0;
+ Int_t nColE = (Int_t) nCols/2;
+ if(second) {
+ nCol0 = nColE;
+ nColE = nCols;
+ }
+ for(Int_t col = nCol0; col < nColE; col++){
+ for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
+ calROCStatus.SetStatus(col,row,calROCStatusPrevious->GetStatus(col,row));
+ }
+ }
}
+//__________________________________________________________________
+void AliTRDPreprocessor::SetDefaultNoise(AliTRDCalROC &calROCNoise, Bool_t second){
+
+ //
+ // default noise for this half chamber
+ //
+
+ Int_t nCols = calROCNoise.GetNcols();
+ Int_t nCol0 = 0;
+ Int_t nColE = (Int_t) nCols/2;
+ if(second) {
+ nCol0 = nColE;
+ nColE = nCols;
+ }
+ for(Int_t col = nCol0; col < nColE; col++){
+ for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
+ calROCNoise.SetValue(col,row,0.12);
+ }
+ }
+}
+//__________________________________________________________________
+void AliTRDPreprocessor::SetNoise(AliTRDCalROC &calROCNoise, AliTRDCalROC *calROCNoisePrevious, Bool_t second){
+
+ //
+ // previous noise for this half chamber
+ //
+ Int_t nCols = calROCNoise.GetNcols();
+ Int_t nCol0 = 0;
+ Int_t nColE = (Int_t) nCols/2;
+ if(second) {
+ nCol0 = nColE;
+ nColE = nCols;
+ }
+ for(Int_t col = nCol0; col < nColE; col++){
+ for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
+ calROCNoise.SetValue(col,row,calROCNoisePrevious->GetValue(col,row));
+ }
+ }
+}
//______________________________________________________________________________________________
Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
{
// if enough statistics store the results
if ((nbtg > 0) &&
- (nbfit >= 0.95*nbE)) {
+ (nbfit >= 0.5*nbE)) {
// create the cal objects
+ calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+ calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
TObjArray object = calibra->GetVectorFit();
AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
}
// analyse
Log("Take the CH reference data. Now we will try to fit\n");
- calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
+ calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
calibra->AnalyseCH(histogain);
Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
+ 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
Int_t nbE = calibra->GetNumberEnt();
// enough statistics
if ((nbtg > 0) &&
- (nbfit >= 0.95*nbE)) {
+ (nbfit >= 0.5*nbE)) {
// create the cal objects
+ calibra->PutMeanValueOtherVectorFit(1,kTRUE);
TObjArray object = calibra->GetVectorFit();
AliTRDCalDet *objgaindet = calibra->CreateDetObjectGain(&object);
TObject *objgainpad = calibra->CreatePadObjectGain();
}
// analyse
Log("Take the PH reference data. Now we will try to fit\n");
- calibra->SetMinEntries(1000*20); // If there is less than 20000
+ calibra->SetMinEntries(800*20); // If there is less than 20000
calibra->AnalysePH(histodriftvelocity);
Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
+ 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
Int_t nbE = calibra->GetNumberEnt();
// enough statistics
if ((nbtg > 0) &&
- (nbfit >= 0.95*nbE)) {
+ (nbfit >= 0.5*nbE)) {
// create the cal objects
+ calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+ calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
TObjArray object = calibra->GetVectorFit();
AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
{
//
// process the configuration of FEE, PTR and GTU
- // reteive XML file from the DCS FXS
- // parse it and store TObjArrays in the CDB
+ // reteive XML filei(s) from the DCS FXS
+ // parse it/them and store TObjArrays in the CDB
+ //
// return 0 for success, otherwise:
- // 5: could not get the file from the FXS
- // 6: ERROR in XML validation: something wrong with the file
- // 7: ERROR while creating calibration objects in the handler
- // 8: error while storing data in the CDB
+ // 5 : could not get the SOR file from the FXS
+ // 6 : could not get the EOR file from the FXS
+ // 7 :
+ // 8 : something wrong with the SOR file
+ // 9 : something wrong with the EOR file
+ // 10 : SOR XML is not well-formed
+ // 11 : EOR XML is not well-formed
+ // 12 : ERROR in XML SAX validation: something wrong with the content
+ // 13 :
+ // 14 : ERROR while creating calibration objects in the handler
+ // 15 : error while storing data in the CDB
//
- Log("Processing the DCS config summary file.");
-
- // get the XML file
- const char * nameFile = GetFile(kDCS,"CONFIGSUMMARY","");
- if (nameFile == NULL) {
+ Log("Processing the DCS config summary files.");
+
+ // get the XML files
+ Log("Requesting the 2 summaryfiles from the FXS..");
+ const char *xmlFileS = GetFile(kDCS,"CONFIGSUMMARYSOR","");
+ const char *xmlFileE = GetFile(kDCS,"CONFIGSUMMARYEOR","");
+ // for the time being just request BOTH files from the FXS
+ // THEN it can be created online (otherwise the FXS would be messed up)
+ // the next step is to actually read BOTH files and store their informations
+ if (xmlFileS == NULL) {
+ Log(Form("ERROR: SOR File %s not found!",xmlFileS));
return 5;
- Log(Form("File %s not found!",nameFile));
+ } else if (xmlFileE == NULL) {
+ Log(Form("ERROR: EOR File %s not found!",xmlFileE));
+ return 6;
+ } else {
+ Log(Form("Both Files (%s and %s) found.",xmlFileS,xmlFileE));
}
-
+
+ // test the files
+ std::ifstream fileTestS, fileTestE;
+ fileTestS.open(xmlFileS, std::ios_base::binary | std::ios_base::in);
+ fileTestE.open(xmlFileE, std::ios_base::binary | std::ios_base::in);
+ if (!fileTestS.good() || fileTestS.eof() || !fileTestS.is_open()) {
+ Log(Form("ERROR: File %s not valid!",xmlFileS));
+ return 8;
+ }
+ if (!fileTestE.good() || fileTestE.eof() || !fileTestE.is_open()) {
+ Log(Form("ERROR: File %s not valid!",xmlFileE));
+ return 9;
+ }
+ fileTestS.seekg(0, std::ios_base::end);
+ fileTestE.seekg(0, std::ios_base::end);
+ if (static_cast<int>(fileTestS.tellg()) < 2) {
+ Log(Form("ERROR: File %s is empty!",xmlFileS));
+ return 8;
+ }
+ if (static_cast<int>(fileTestE.tellg()) < 2) {
+ Log(Form("ERROR: File %s is empty!",xmlFileE));
+ return 9;
+ }
+ Log("Files are tested valid.");
+
+ // make a robust XML validation
+ TSAXParser testParser;
+ if (testParser.ParseFile(xmlFileS) < 0 ) {
+ Log("ERROR: XML content (SOR) is not well-formed.");
+ return 10;
+ } else if (testParser.ParseFile(xmlFileE) < 0 ) {
+ Log("ERROR: XML content (EOR) is not well-formed.");
+ return 11;
+ }
+ Log("XML contents are well-formed.");
+
// create parser and parse
- TSAXParser saxParser;
- AliTRDSaxHandler saxHandler;
- saxParser.ConnectToHandler("AliTRDSaxHandler", &saxHandler);
- saxParser.ParseFile(nameFile);
+ TSAXParser saxParserS, saxParserE;
+ AliTRDSaxHandler saxHandlerS, saxHandlerE;
+ saxParserS.ConnectToHandler("AliTRDSaxHandler", &saxHandlerS);
+ saxParserS.ParseFile(xmlFileS);
+ saxParserE.ConnectToHandler("AliTRDSaxHandler", &saxHandlerE);
+ saxParserE.ParseFile(xmlFileE);
// report errors if present
- if (saxParser.GetParseCode() == 0) {
- Log("XML file validation OK");
+ if ((saxParserS.GetParseCode() == 0) && (saxParserE.GetParseCode() == 0)) {
+ Log("XML file validation OK.");
} else {
- Log(Form("ERROR in XML file validation. Parsecode: %s", saxParser.GetParseCode()));
- return 6;
+ Log(Form("ERROR in XML file validation. Parsecodes: SOR: %s, EOR: %s", saxParserS.GetParseCode(), saxParserE.GetParseCode()));
+ return 12;
}
- if (saxHandler.GetHandlerStatus() != 0) {
- Log(Form("ERROR while creating calibration objects. Error code: %s", saxHandler.GetHandlerStatus()));
- return 7;
+ if ((saxHandlerS.GetHandlerStatus() == 0) && (saxHandlerE.GetHandlerStatus() == 0)) {
+ Log("SAX handler reports no errors.");
+ } else {
+ Log(Form("ERROR while creating calibration objects. Error codes: SOR: %s, EOR: %s", saxHandlerS.GetHandlerStatus(), saxHandlerE.GetHandlerStatus()));
+ return 14;
}
// get the calibration object storing the data from the handler
- AliTRDCalDCS* fCalDCSObj = saxHandler.GetCalDCSObj();
-
+ AliTRDCalDCS* fCalDCSObjSOR = saxHandlerS.GetCalDCSObj();
+ AliTRDCalDCS* fCalDCSObjEOR = saxHandlerE.GetCalDCSObj();
+ fCalDCSObjSOR->EvaluateGlobalParameters();
+ fCalDCSObjEOR->EvaluateGlobalParameters();
+
+ // put both objects in one TObjArray to store them
+ TObjArray* fCalObjArray = new TObjArray(2);
+ fCalObjArray->SetOwner();
+ fCalObjArray->AddAt(fCalDCSObjSOR,0);
+ fCalObjArray->AddAt(fCalDCSObjEOR,1);
+
// store the DCS calib data in the CDB
AliCDBMetaData metaData1;
metaData1.SetBeamPeriod(0);
metaData1.SetResponsible("Frederick Kramer");
- metaData1.SetComment("DCS configuration data in one AliTRDCalDCS object.");
- if (!Store("Calib", "DCSCONFIG", fCalDCSObj, &metaData1, 0, kTRUE)) {
+ metaData1.SetComment("DCS configuration data in two AliTRDCalDCS objects in one TObjArray (0:SOR, 1:EOR).");
+ if (!Store("Calib", "DCS", fCalObjArray, &metaData1, 0, kTRUE)) {
Log("problems while storing DCS config data object");
- return 8;
+ return 15;
+ } else {
+ Log("DCS config data object stored.");
}
+ //delete fCalObjArray;
+
+ Log("Processing of the DCS config summary file DONE.");
return 0;
}
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff