1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 //-------------------------------------------------------------------------
19 // Class AliGRPPreprocessor
20 // Global Run Parameters (GRP) preprocessor
21 // Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
22 // Modified: Ernesto.Lopez.Torres@cern.ch CEADEN-CERN
23 // Modified: Chiara.Zampolli@cern.ch CERN
24 //-------------------------------------------------------------------------
29 #include <THashList.h>
30 #include <TObjString.h>
31 #include <TObjArray.h>
40 #include "AliGRPPreprocessor.h"
41 #include "AliGRPObject.h"
42 #include "AliDCSSensor.h"
43 #include "AliSplineFit.h"
44 #include "AliDCSSensorArray.h"
45 #include "AliRawEventHeaderVersions.h"
47 #include "AliTriggerConfiguration.h"
48 #include "AliTriggerRunScalers.h"
49 #include "AliTriggerInput.h"
51 #include "AliCDBMetaData.h"
52 #include "AliESDVertex.h"
53 #include "AliLHCReader.h"
54 #include "AliLHCData.h"
55 #include "AliDCSArray.h"
57 #include "AliLTUConfig.h"
58 #include "AliQAThresholds.h"
62 class AliShuttleInterface;
64 // needed for ReceivePromptRecoParameters
66 #include <TSQLServer.h>
67 #include <TSQLResult.h>
69 #include <AliCDBManager.h>
70 #include <AliCDBMetaData.h>
72 #include <AliTriggerConfiguration.h>
73 #include "AliCTPTimeParams.h"
74 #include "AliLHCClockPhase.h"
77 ClassImp(AliGRPPreprocessor)
80 const Double_t kFitFraction = -1.; // Fraction of DCS sensor fits required
82 //_______________________________________________________________
84 const Int_t AliGRPPreprocessor::fgknDAQLbPar = 6; // num parameters in the logbook used to fill the GRP object
85 const Int_t AliGRPPreprocessor::fgknDCSDP = 48; // number of dcs dps
86 const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40; // number of dcs dps
87 const Int_t AliGRPPreprocessor::fgknLHCDP = 9; // number of dcs dps from LHC data
88 const Int_t AliGRPPreprocessor::fgkDCSDPHallTopShift = 4; // shift from the top to get tp the Hall Probes names in the list of DCS DPs
89 const Int_t AliGRPPreprocessor::fgkDCSDPNonWorking = 5; // number of non working DCS DPs
90 const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
98 "L3_BSF17_Temperature",
102 "L3_BSF4_Temperature",
106 "L3_BKF17_Temperature",
110 "L3_BKF4_Temperature",
114 "L3_BSF13_Temperature",
118 "L3_BSF8_Temperature",
122 "L3_BKF13_Temperature",
126 "L3_BKF8_Temperature",
130 "Dipole_Inside_Temperature",
134 "Dipole_Outside_Temperature",
136 "CavernAtmosPressure",
137 "SurfaceAtmosPressure",
138 "CavernAtmosPressure2"
141 const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
145 "L3_BSF17_Temperature",
149 "L3_BSF4_Temperature",
153 "L3_BKF17_Temperature",
157 "L3_BKF4_Temperature",
161 "L3_BSF13_Temperature",
165 "L3_BSF8_Temperature",
169 "L3_BKF13_Temperature",
173 "L3_BKF8_Temperature",
177 "Dipole_Inside_Temperature",
181 "Dipole_Outside_Temperature"
184 const Short_t kSensors = 45; // start index position of sensor in DCS DPs
185 const Short_t kNumSensors = 3; // Number of sensors in DCS DPs (CavernAtmosPressure, SurfaceAtmosPressure, CavernAtmosPressure2)
188 const char* AliGRPPreprocessor::fgkLHCDataPoints[AliGRPPreprocessor::fgknLHCDP] = {
192 "LHC_Beams_Particle_Type",
193 "BPTX_Phase_Shift_B1",
194 "BPTX_Phase_Shift_B2",
195 "LHC_Particle_Type_B1",
196 "LHC_Particle_Type_B2",
197 "LHC_Data_Quality_Flag"
200 const char* kppError[] = {
202 "(DAQ logbook ERROR)",
204 "(Trigger Scalers not found in FXS - ERROR)",
205 "(DCS data points ERROR)",
206 "(Trigger Configuration ERROR)",
207 "(DAQ logbook ERROR determining partition of the run)",
208 "(CTP timing ERROR)",
209 "(SPD Mean Vertex ERROR)",
210 "(FXS Error for LHC Data)",
212 "(LHC Clock Phase Error (from LHC Data))",
213 "(LTU Configuration Error)",
215 "(Trigger Aliases wrong or not found in DCS FXS - ERROR)"
218 //_______________________________________________________________
220 AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
221 AliPreprocessor("GRP",shuttle), fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0),fdaqStartEndTimeOk(kTRUE),ffailedDPs(new TObjArray(fgknDCSDP))
223 // constructor - shuttle must be instantiated!
225 AddRunType("COSMIC");
227 AddRunType("PHYSICS");
228 AddRunType("CALIBRATION_BC");
229 AddRunType("CALIBRATION_CENTRAL");
230 AddRunType("CALIBRATION_EMD");
231 AddRunType("CALIBRATION_MB");
232 AddRunType("CALIBRATION_SEMICENTRAL");
233 AddRunType("CALIBRATION");
234 AddRunType("PEDESTAL");
235 AddRunType("STANDALONE");
238 AddRunType("PULSER");
239 AddRunType("STANDALONE_PULSER");
240 AddRunType("STANDALONE_BC");
243 fminFloat = -FLT_MAX;
244 fmaxDouble = DBL_MAX;
245 fminDouble = -DBL_MAX;
251 AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
252 AliInfo(Form("Min allowed float = %6.5e",fminFloat));
253 AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
254 AliInfo(Form("Min allowed double = %6.5e",fminDouble));
255 AliInfo(Form("Max allowed integer = %d",fmaxInt));
256 AliInfo(Form("Min allowed integer = %d",fminInt));
257 AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
258 AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
260 ffailedDPs->SetOwner(kTRUE);
263 //_______________________________________________________________
265 AliGRPPreprocessor::~AliGRPPreprocessor()
274 //_______________________________________________________________
276 void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
278 // Initialize preprocessor
280 AliPreprocessor::Initialize(run, startTime, endTime);
282 AliInfo("Initialization of the GRP preprocessor.");
283 AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
284 AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
285 TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
286 for(Int_t j = 0; j < kNumSensors; j++) {
287 AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
288 sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
290 AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
292 fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
294 ffailedDPs->Clear(); // cleaning ffailedDPs for current run
295 for (Int_t iDP=0; iDP < fgknDCSDP; iDP++){
296 TObjString* dp = new TObjString(fgkDCSDataPoints[iDP]);
297 ffailedDPs->AddAt(dp,iDP);
302 //_______________________________________________________________
304 UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
306 // process data retrieved by the Shuttle
308 // retrieving "partition" and "detector" fields from DAQ logbook to
309 // determine the partition in which the run was taken
310 // the partition is used to decide how to react in case of errors for CTP
312 TString partition = (TString)GetRunParameter("partition");
313 TString detector = (TString)GetRunParameter("detector");
315 AliGRPObject *grpobj = new AliGRPObject(); // object to store data
316 grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format
318 //=================//
320 //=================//
322 Log("*************** Processing DAQ logbook");
326 Int_t iDaqLB = ProcessDaqLB(grpobj);
327 TString runType = (TString)GetRunType();
328 TString beamType = (TString)GetRunParameter("beamType");
329 if(iDaqLB == fgknDAQLbPar) {
330 Log(Form("DAQ Logbook, successful! Retrieved %d/%d entries",iDaqLB,fgknDAQLbPar));
332 Log(Form("DAQ Logbook, could not get all expected entries!!! Retrieved only %d/%d entries",iDaqLB,fgknDAQLbPar));
336 //=================//
338 //=================//
340 Log("*************** Processing DAQ FXS");
342 UInt_t iDaqFxs = ProcessDaqFxs();
344 Log(Form("DAQ FXS, successful!"));
346 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
350 //=================//
352 //=================//
354 Log("*************** Processing DCS FXS");
356 UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
358 Log(Form("DCS FXS, successful!"));
359 } else if (iDcsFxs ==1) {
360 Log(Form("Could not store CTP scalers!!!"));
362 } else if (iDcsFxs == 2) {
363 Log(Form("Could not store CTP aliases!!!"));
366 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
370 //=================//
371 // DCS data points //
372 //=================//
374 Log("*************** Processing DCS DPs");
376 Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
377 Int_t entries = ProcessDcsDPs( valueMap, grpobj );
378 Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-fgkDCSDPNonWorking));
379 if (fdaqStartEndTimeOk){
380 if( entries < fgknDCSDP - fgkDCSDPNonWorking ) { // L3_BSF4_H3, L3_BSF17_H1, L3_BSF17_H2, L3_BSF17_H3, L3_BSF17_Temperature are not working yet...
381 Log(Form("Possible problem with the DCS data points!!! Only %d/%d entries found - Please read further for more details",entries,fgknDCSDP-fgkDCSDPNonWorking));
382 Log(Form("The DPs giving problems were:"));
383 for (Int_t iDP = 0; iDP < fgknDCSDP; iDP++){
384 TObjString *dpString = (TObjString*)ffailedDPs->At(iDP);
386 TString name = dpString->String();
387 if (name != "L3_BSF4_H3" && name != "L3_BSF17_H1" && name != "L3_BSF17_H2" && name != "L3_BSF17_H3" && name != "L3_BSF17_Temperature" ){
388 Log(Form("******** %s ******** not present, but foreseen --> causing an ERROR",name.Data()));
391 Log(Form(" %s is not present, but was not generating any error since it is not ready in DCS - check the other DPs in this list!",name.Data()));
397 else Log(Form("DCS data points, successful!"));
399 else Log(Form("Statistical values for DCS DPs could not be computed due to missing DAQ_time_start and DAQ_time_end fields in DAQ logbook"));
401 //=======================//
402 // Trigger Configuration //
403 //=======================//
405 Log("*************** Processing Trigger Configuration");
407 const char * triggerConf = GetTriggerConfiguration();
409 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
410 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
411 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
413 Log(Form("No dummy CTP configuration entry found, going into error..."));
417 AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
419 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
423 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
424 runcfg->SetTitle(titleCTPcfg);
425 AliCDBMetaData metaData;
426 metaData.SetResponsible("Roman Lietava");
427 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
428 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
429 Log("Unable to store the dummy CTP run configuration object to OCDB!");
436 else if (!partition.IsNull() && detector.IsNull()){ // global partition
437 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
438 if (triggerConf!= NULL) {
439 Log("Found trigger configuration in DAQ logbook");
440 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
442 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
446 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
447 runcfg->SetTitle(titleCTPcfg);
448 AliCDBMetaData metaData;
449 metaData.SetBeamPeriod(0);
450 metaData.SetResponsible("Roman Lietava");
451 metaData.SetComment("CTP run configuration from DAQ logbook");
452 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
453 Log("Unable to store the CTP run configuration object to OCDB!");
460 Log("Trigger configuration NULL in DAQ logbook");
466 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
470 //===========================//
471 // Trigger Timing Parameters //
472 //===========================//
474 Log("*************** Processing Trigger Time Params");
476 const char * triggerCTPtiming = GetCTPTimeParams();
478 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
479 Log("STANDALONE partition for current run, using CTP timing params dummy value");
480 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyCTPtime");
482 Log(Form("No dummy CTP timing parameters entry found, going into error..."));
486 AliCTPTimeParams *runCTPtiming = (AliCTPTimeParams*)cdbEntry->GetObject();
488 Log(Form("dummy CTP timing parameters not found in OCDB entry, going into error..."));
492 TString titleCTPtiming = Form("CTP timing params for run %i from Dummy entry in OCDB",fRun);
493 runCTPtiming->SetTitle(titleCTPtiming);
494 AliCDBMetaData metadata;
495 metadata.SetResponsible("Roman Lietava");
496 metadata.SetComment("CTP run timing parameters from dummy entry in OCDB");
497 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
498 Log("Unable to store the dummy CTP timing params object to OCDB!");
505 else if (!partition.IsNull() && detector.IsNull()){ // global partition
506 Log("GLOBAL partition for current run, using Trigger Timing Parameters from DAQ Logbook");
507 if (triggerCTPtiming!= NULL) {
508 Log("Found trigger timing params in DAQ logbook");
509 AliDebug(2,Form("%s",triggerCTPtiming));
510 AliCTPTimeParams *runCTPtiming = AliCTPTimeParams::LoadCTPTimeParamsFromString(triggerCTPtiming);
512 Log("Bad CTP trigger timing params file from DAQ logbook! The corresponding CDB entry will not be filled!");
516 TString titleCTPtiming = Form("CTP timing params for run %i from DAQ",fRun);
517 runCTPtiming->SetTitle(titleCTPtiming);
518 AliCDBMetaData metadata;
519 metadata.SetBeamPeriod(0);
520 metadata.SetResponsible("Roman Lietava");
521 metadata.SetComment("CTP timing params from DAQ logbook");
522 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
523 Log("Unable to store the CTP timing params object to OCDB!");
530 Log("Trigger timing params NULL in DAQ logbook");
536 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
540 //===========================//
541 // LTU Configuration //
542 //===========================//
544 Log("*************** Processing LTU Configuration");
546 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
547 Log("STANDALONE partition for current run, using LTU configuration dummy value");
548 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyLTUConfig");
550 Log(Form("No dummy LTU Config entry found, going into error..."));
554 TObjArray *ltuConfig = (TObjArray*)cdbEntry->GetObject();
556 Log(Form("dummy LTU Config not found in OCDB entry, going into error..."));
560 AliCDBMetaData metadata;
561 metadata.SetResponsible("Roman Lietava");
562 metadata.SetComment("LTU Config from dummy entry in OCDB");
563 if (!Store("CTP","LTUConfig", ltuConfig, &metadata, 0, 0)) {
564 Log("Unable to store the dummy LTU Config object to OCDB!");
571 else if (!partition.IsNull() && detector.IsNull()){ // global partition
573 Log("GLOBAL partition for current run, getting LTU Config from DAQ Logbook (logbook_detectors table)");
574 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
575 Printf ("detectormask = %d",detectorMask);
576 TObjArray * ltuarray = new TObjArray();
577 ltuarray->SetOwner(1);
578 Bool_t isLTUok = kTRUE;
579 for(Int_t i = 0; i<AliDAQ::kNDetectors-2; i++){
580 if ((detectorMask >> i) & 0x1) {
581 TString det = AliDAQ::OfflineModuleName(i);
582 TString detCTPName = AliTriggerInput::fgkCTPDetectorName[i];
583 if (detCTPName == "CTP") {
584 detCTPName="TRG"; // converting according to what is found in DAQ logbook_detectors
585 Printf("Processing CTP (CTP Detector name %s) --> SKIPPING, CTP does not have any LTU!!!!!!",detCTPName.Data());
588 Printf("Processing detector %s (CTP Detector name %s)",det.Data(),detCTPName.Data());
589 TString* ltu = GetLTUConfig(detCTPName.Data());
591 Log(Form("No LTU Configuration from DAQ logbook for detector %s (BUT it was expected)! The corresponding CDB entry will not be filled!",detCTPName.Data()));
597 Float_t ltuFineDelay1 = ltu[0].Atof();
598 Float_t ltuFineDelay2 = ltu[1].Atof();
599 Float_t ltuBCDelayAdd = ltu[2].Atof();
600 const char* name = AliDAQ::DetectorName(i);
601 AliLTUConfig* ltuConfig = new AliLTUConfig((UChar_t)AliDAQ::DetectorID(name),ltuFineDelay1,ltuFineDelay2,ltuBCDelayAdd);
602 ltuarray->AddAtAndExpand(ltuConfig,i);
607 AliCDBMetaData metadata;
608 metadata.SetBeamPeriod(0);
609 metadata.SetResponsible("Roman Lietava");
610 metadata.SetComment("LTU Configuration for current run");
611 if (!Store("CTP","LTUConfig", ltuarray, &metadata, 0, 0)) {
612 Log("Unable to store the LTU Config object to OCDB!");
620 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
625 //=================//
627 //=================//
629 if (runType == "PHYSICS"){ // processing the LHC file only in PHYSICS runs
630 Log("*************** Processing LHC Data");
632 UInt_t iLHCData = ProcessLHCData(grpobj);
634 if( iLHCData == 0 ) {
635 Log(Form("LHC Data from FXS, successful!"));
636 } else if (iLHCData == 1) {
637 Log(Form("LHC Data, problems with FXS!"));
639 } else if (iLHCData == 2) {
640 Log(Form("LHC Data, problems with DAQ_time_start/DAQ_time_end!"));
642 } else if (iLHCData ==3){
643 Log(Form("Problems in storing LHC Phase - going into Error"));
645 } else if (iLHCData ==4){
646 Log(Form("Problems with LHC Phase - going into Error"));
649 Log(Form("LHC Data problems"));
655 //==================//
656 // SPD Mean Vertex //
657 //==================//
659 Log("*************** Processing SPD Mean Vertex");
661 if (runType == "PHYSICS"){
662 UInt_t iSPDMeanVertex = ProcessSPDMeanVertex();
663 if( iSPDMeanVertex == 1 ) {
664 Log(Form("SPD Mean Vertex, successful!"));
666 Log(Form("SPD Mean Vertex failed!!!"));
671 Log("SPD Mean Vertex not processed since runType != PHYSICS");
674 //=================//
676 //=================//
678 Log("*************** Processing DQM FXS");
680 UInt_t iDqmFxs = ProcessDqmFxs();
682 Log(Form("DQM FXS, successful!"));
684 Log(Form("DQM FXS failed!!!"));
688 // storing AliGRPObject in OCDB
691 md.SetResponsible("Chiara Zampolli");
692 md.SetComment("Output parameters from the GRP preprocessor.");
694 Bool_t result = kTRUE;
695 result = Store("GRP", "Data", grpobj, &md);
698 if (result && !error ) {
699 Log("GRP Preprocessor Success");
702 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s%s%s%s%s%s%s%s%s",
703 kppError[(error&1)?1:0],
704 kppError[(error&2)?2:0],
705 kppError[(error&4)?3:0],
706 kppError[(error&8)?4:0],
707 kppError[(error&16)?5:0],
708 kppError[(error&32)?6:0],
709 kppError[(error&64)?7:0],
710 kppError[(error&128)?8:0],
711 kppError[(error&256)?9:0],
712 kppError[(error&512)?10:0],
713 kppError[(error&1024)?11:0],
714 kppError[(error&2048)?12:0],
715 kppError[(error&4096)?13:0],
716 kppError[(error&8192)?14:0]
724 //_______________________________________________________________
726 UInt_t AliGRPPreprocessor::ProcessLHCData(AliGRPObject *grpobj)
729 //Getting the LHC Data from DCS FXS
732 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
733 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
734 if (timeStartString.IsNull() || timeEndString.IsNull()){
735 if (timeStartString.IsNull()){
736 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
738 else if (timeEndString.IsNull()){
739 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
744 Double_t timeStart = timeStartString.Atof();
745 Double_t timeEnd = timeEndString.Atof();
747 TString fileName = GetFile(kDCS, "LHCData","");
748 if (fileName.Length()>0){
749 AliInfo("Got The LHC Data file");
750 AliLHCReader lhcReader;
752 // Processing data to be put in AliGRPObject
755 Log("*************Energy ");
756 TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
758 Float_t energy = ProcessEnergy(energyArray,timeStart);
760 grpobj->SetBeamEnergy(energy);
761 grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
766 AliError("Energy not found in LHC Data file!!!");
769 Double_t timeBeamModeEnd = timeEnd; // max validity for Beam Mode
770 Double_t timeMachineModeEnd = timeEnd; // max validity for Machine Mode
771 Double_t timeBeamEnd = timeEnd; // max validity for Beam Type
772 Double_t timeBeamTypeEnd[2] = {timeEnd, timeEnd}; // max validity for Beam Type1,2
773 Double_t timeBeamModeStart = -1; // min validity for Beam Mode
774 Double_t timeMachineModeStart = -1; // min validity for Machine Mode
775 Double_t timeBeamStart = -1; // min validity for Beam Type
776 Double_t timeBeamTypeStart[2] = {-1,-1}; // min validity for Beam Type1,2
777 Int_t indexBeamMode = -1; // index of measurement used to set Beam Mode
778 Int_t indexMachineMode = -1; // index of measurement used to set Machine Mode
779 Int_t indexBeam = -1; // index of measurement used to set Beam Type
780 Int_t indexBeamType[2] = {-1, -1}; // index of measurement used to set Beam Type1,2
781 Bool_t foundBeamModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
782 Bool_t foundMachineModeStart = kFALSE; // flag to be set in case an entry for the Machine Mode is found before (or at) SOR
783 Bool_t foundBeamStart = kFALSE; // flag to be set in case an entry for the Beam Type is found before (or at) SOR
784 Bool_t foundBeamTypeStart[2] = {kFALSE, kFALSE}; // flag to be set in case an entry for the Beam Type1,2 is found before (or at) SOR
785 Bool_t flagBeamMode = kFALSE; //flag set true if a changed occurred in BeamMode
786 Bool_t flagMachineMode = kFALSE; //flag set true if a changed occurred in MachineMode
787 Bool_t flagBeam = kFALSE; //flag set true if a changed occurred in BeamType
788 Bool_t flagBeamType[2] = {kFALSE, kFALSE}; //flag set true if a changed occurred in BeamType1,2
790 Double_t arrayTimes[5]={2.E9, 2.E9, 2.E9, 2.E9, 2.E9}; // array to keep track of the times of the possible changes of the LHC DPs; each entry set to Wed May 18 2033, 03:33:20 GMT (ALICE should not be running anymore...)
791 // arrayTimes elements order correspond to the one used in the array of the strings fgkLHCDataPoints, i.e.:
792 // arrayTimes[0] --> MachineMode
793 // arrayTimes[1] --> BeamMode
794 // arrayTimes[2] --> BeamType (when written together)
795 // arrayTimes[3] --> BeamType1 (when written separate)
796 // arrayTimes[4] --> BeamType2 (when written separate)
799 Log("*************BeamMode (LHCState) ");
800 TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
801 Int_t nBeamMode = -1;
803 nBeamMode = beamModeArray->GetEntries();
805 AliInfo("Found zero entries for the Beam Mode, leaving it empty");
808 for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
809 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
811 if (beamMode->GetTimeStamp()<=timeStart && beamMode->GetTimeStamp()>=timeBeamModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
812 timeBeamModeStart = beamMode->GetTimeStamp();
813 indexBeamMode = iBeamMode;
814 foundBeamModeStart = kTRUE;
822 if (!foundBeamModeStart){
823 AliInfo("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
826 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
827 TObjString* beamModeString = beamMode->GetStringArray(0);
828 AliInfo(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
829 grpobj->SetLHCState(beamModeString->String());
830 if (indexBeamMode < nBeamMode-1){
831 AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
833 if (beamMode1->GetTimeStamp()<=timeStart){
834 AliError("you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
836 else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
837 timeBeamModeEnd = beamMode1->GetTimeStamp();
838 TObjString* beamModeString1 = beamMode1->GetStringArray(0);
839 TString bmString0 = beamModeString->String();
840 TString bmString1 = beamModeString1->String();
841 if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
842 AliWarning(Form("The beam mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",bmString0.Data(), bmString1.Data(), timeBeamModeEnd, bmString0.Data()));
843 flagBeamMode = kTRUE;
844 arrayTimes[1]=timeBeamModeEnd;
850 AliInfo("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
855 delete beamModeArray;
858 AliError("Beam mode array not found in LHC Data file!!!");
862 Log("*************MachineMode ");
863 TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
864 Int_t nMachineMode = -1;
865 if (machineModeArray){
866 nMachineMode = machineModeArray->GetEntries();
867 if (nMachineMode==0){
868 AliInfo("No Machine Mode found, leaving it empty");
871 for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
872 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
874 if (machineMode->GetTimeStamp()<=timeStart && machineMode->GetTimeStamp()>=timeMachineModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
875 timeMachineModeStart = machineMode->GetTimeStamp();
876 indexMachineMode = iMachineMode;
877 foundMachineModeStart = kTRUE;
884 if (!foundMachineModeStart){
885 AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
888 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
889 TObjString* machineModeString = machineMode->GetStringArray(0);
890 AliInfo(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
891 grpobj->SetMachineMode(machineModeString->String());
892 if (indexMachineMode < nMachineMode-1){
893 AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
895 if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
896 timeMachineModeEnd = machineMode1->GetTimeStamp();
897 TObjString* machineModeString1 = machineMode1->GetStringArray(0);
898 TString mmString0 = machineModeString->String();
899 TString mmString1 = machineModeString1->String();
900 if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
901 AliWarning(Form("The machine mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",mmString0.Data(),mmString1.Data(),timeMachineModeEnd,mmString0.Data()));
902 flagMachineMode = kTRUE;
903 arrayTimes[0]=timeMachineModeEnd;
908 AliInfo("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
913 delete machineModeArray;
916 AliError("Machine mode array not found in LHC Data file!!!");
919 // BeamType1 and BeamType2 - both put in the same string
920 Log("*************BeamType ");
921 TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
923 Int_t nBeam = beamArray->GetEntries();
925 AliInfo("No Beam Type found, leaving it empty");
928 for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
929 AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
931 if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
932 timeBeamStart = beam->GetTimeStamp();
934 foundBeamStart = kTRUE;
941 if (!foundBeamStart){
942 AliInfo("No value for the Beam Type found before start of run, the (common) Beam Type will remain empty");
945 AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
946 TObjString* beamString = beam->GetStringArray(0);
947 TString beamType = beamString->String();
948 AliInfo(Form("Beam Type = %s",beamType.Data()));
949 if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
950 AliInfo("Setting beam type to p-p");
951 grpobj->SetBeamType("p-p");
953 else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
954 AliInfo("Setting beam type to A-A");
955 grpobj->SetBeamType("A-A");
958 else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
959 AliInfo("Setting beam type to Pb-Pb");
960 grpobj->SetBeamType("Pb-Pb");
963 AliError("Beam Type not known, leaving it empty");
966 if (indexBeam < nBeam-1){
967 AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
969 if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
970 timeBeamEnd = beam1->GetTimeStamp();
971 TObjString* beamString1 = beam1->GetStringArray(0);
972 TString beamType1 = beamString1->String();
973 if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
974 AliWarning(Form("The Beam Type changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data()));
976 arrayTimes[2] = timeBeamEnd;
981 AliInfo("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
989 AliError("Beam Type array not found in LHC Data file!!!");
992 // BeamType1 and BeamType2 - in separete string
993 Log("*************BeamType, 1 and 2 ");
994 Int_t indexBeamTypeString = 6; // index of the string with the alias of BeanType1 in the array fgkLHCDataPoints
995 TString combinedBeamType = "-"; // combined beam type, built from beam type 1 and beam type 2
996 TString combinedBeamTypeFromLHC = "-"; // combined beam type, built from beam type 1 and beam type 2 AS SENT FROM LHC
997 for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
998 beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[indexBeamTypeString+ibeamType]);
1000 Int_t nBeam = beamArray->GetEntries();
1002 AliInfo(Form("No Beam Type %s found, leaving it empty",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
1005 for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
1006 AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
1008 if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamTypeStart[ibeamType]){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
1009 timeBeamTypeStart[ibeamType] = beam->GetTimeStamp();
1010 indexBeamType[ibeamType] = iBeam;
1011 foundBeamTypeStart[ibeamType] = kTRUE;
1018 if (!foundBeamTypeStart[ibeamType]){
1019 AliInfo(Form("No value for the Beam Type %s found before start of run, the Beam Type %d will remain empty", fgkLHCDataPoints[indexBeamTypeString+ibeamType], ibeamType));
1022 AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
1023 TObjString* beamString = beam->GetStringArray(0);
1024 TString beamType = beamString->String();
1025 AliInfo(Form("Beam Type (for %s) = %s", fgkLHCDataPoints[indexBeamTypeString+ibeamType], beamType.Data()));
1026 TString singleBeam = ParseBeamTypeString(beamType,ibeamType);
1027 AliInfo(Form("Single Beam Type for beam %d set to %s", ibeamType, singleBeam.Data()));
1028 grpobj->SetSingleBeamType(ibeamType, singleBeam);
1029 if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
1030 AliInfo(Form("Setting beam %d for combined beam type to p", ibeamType));
1031 if (ibeamType == 0) combinedBeamType.Prepend("p");
1032 else combinedBeamType.Append("p");
1034 else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
1035 AliInfo(Form("Setting beam %d for combined beam type to A",ibeamType));
1036 if (ibeamType == 0) combinedBeamType.Prepend("A");
1037 else combinedBeamType.Append("A");
1039 if (ibeamType == 0) combinedBeamTypeFromLHC.Prepend(beamType);
1040 else combinedBeamTypeFromLHC.Append(beamType);
1042 else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
1043 AliInfo("Setting beam type to Pb-Pb");
1044 grpobj->SetSingleBeamType(ibeamType, "Pb-Pb");
1047 AliError("Beam Type not known, leaving it empty");
1050 if (indexBeamType[ibeamType] < nBeam-1){
1051 AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
1053 if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
1054 timeBeamTypeEnd[ibeamType] = beam1->GetTimeStamp();
1055 TObjString* beamString1 = beam1->GetStringArray(0);
1056 TString beamType1 = beamString1->String();
1057 if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
1058 AliWarning(Form("The Beam Type for %s changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",fgkLHCDataPoints[indexBeamTypeString+ibeamType],beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data()));
1059 flagBeamType[ibeamType] = kTRUE;
1060 arrayTimes[3+ibeamType] = timeBeamTypeEnd[ibeamType];
1065 AliInfo(Form("Invalid pointer for the first entry for Beam Type %s after the first valid one, not considering anything after what has already been found",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
1073 AliError(Form("Beam Type %s array not found in LHC Data file!!!",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
1076 AliInfo(Form("Setting combined beam type to %s",combinedBeamType.Data()));
1077 grpobj->SetBeamType(combinedBeamType);
1078 AliInfo(Form("Setting combined beam type form LHC to %s",combinedBeamTypeFromLHC.Data()));
1079 grpobj->SetBeamTypeFromLHC(combinedBeamTypeFromLHC);
1081 // Setting minTimeLHCValidity
1082 if (flagBeamMode == kTRUE || flagMachineMode == kTRUE || flagBeam == kTRUE || flagBeamType[0] == kTRUE || flagBeamType[1] == kTRUE){
1083 Double_t minTimeLHCValidity= TMath::MinElement(5,arrayTimes);
1084 AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
1085 grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
1088 // Old way to determine the Maximum Time during which the LHC info is valid
1089 if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
1090 Double_t minTimeLHCValidity;
1091 if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true --> it is the only one that changed
1092 minTimeLHCValidity = timeBeamEnd;
1094 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
1095 minTimeLHCValidity = timeMachineModeEnd;
1097 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
1098 minTimeLHCValidity = timeBeamModeEnd;
1100 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
1101 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
1103 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
1104 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
1106 else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
1107 minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
1110 Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam
1111 minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
1113 AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
1114 grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
1118 // Data Quality Flag --> storing start and end values of periods within the run during which the value was found to be FALSE
1119 Log("*************Data Quality Flag ");
1120 TObjArray* dataQualityArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[8]);
1121 Int_t nDataQuality = -1;
1122 Double_t timeDataQualityStart = -1; // min validity for Data Quality Flag
1123 Int_t indexDataQuality = -1; // index of first measurement used to set Data Quality Flag
1124 Bool_t foundDataQualityStart = kFALSE; // flag to be set in case an entry for the Data Quality Flag is found before (or at) SOR
1126 if (dataQualityArray){
1127 nDataQuality = dataQualityArray->GetEntries();
1128 if (nDataQuality==0){
1129 AliInfo("No Data Quality Flag found, leaving it empty");
1132 for (Int_t iDataQuality = 0; iDataQuality<nDataQuality; iDataQuality++){
1133 AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
1135 if (dataQuality->GetTimeStamp()<=timeStart && dataQuality->GetTimeStamp()>=timeDataQualityStart){// taking always the very last entry: if two measurements have the same timestamp, the last one is taken
1136 timeDataQualityStart = dataQuality->GetTimeStamp();
1137 indexDataQuality = iDataQuality;
1138 foundDataQualityStart = kTRUE;
1141 // we suppose here that if the first measurement is not before SOR, then none will be (they MUST be in chronological order!!!)
1146 if (!foundDataQualityStart){
1147 // The Data Quality Flag should be found and TRUE at the start of the run. For the time being, if it is not found, don't do anything, but it means there is a problem..
1148 AliInfo("No value for the Data Quality Flag found before start of run, the Data Quality Flag will remain empty");
1151 // counting how many FALSE values there are
1152 Bool_t foundEndOfFalse = kFALSE;
1154 for (Int_t iDataQuality = indexDataQuality; iDataQuality < nDataQuality; iDataQuality ++){
1155 AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
1156 AliDebug(4,Form("dataQuality->GetTimeStamp() = %f, timeDataQualityStart = %f, timeEnd = %f", dataQuality->GetTimeStamp(), timeDataQualityStart, timeEnd ));
1157 if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
1158 Bool_t dataQualityFlag = dataQuality->GetBool(0);
1159 AliDebug(3,Form("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp()));
1160 if (dataQualityFlag != kTRUE){
1161 if (iDataQuality == indexDataQuality) { // the first Data Quality value should be TRUE, but ignoring the problem now...
1162 AliError("The first value for the Data Quality MUST be TRUE! Ignoring for now...");
1169 AliInfo(Form("Found %d FALSE values for the Data Quality Flag",nFalse));
1170 Double_t falses[nFalse*2]; // dimensioning this to the maximum possible, as if each false value was followed by a true one --> the false periods correspond to the number of falses
1172 Int_t iDataQuality = indexDataQuality;
1175 // filling the info about the periods when the flag was set to FALSE
1176 // starting, like for the other DPS, from the measurement closest to SOR (the index of which is iDataQuality)
1177 while (iDataQuality < nDataQuality){
1178 AliDebug(3,Form("iDataQuality = %d",iDataQuality));
1179 AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
1180 if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
1181 Bool_t dataQualityFlag = dataQuality->GetBool(0);
1182 AliDebug(3,Form("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp()));
1183 if (dataQualityFlag == kTRUE){
1184 // found TRUE value, continuing
1190 // the check was already done before
1191 if (iDataQuality == indexDataQuality) { // the first Data Quality value should be TRUE, but ignoring the problem now...
1192 AliError("The first value for the Data Quality MUST be TRUE! Ignoring for now...");
1195 falses[iFalse*2] = dataQuality->GetTimeStamp();
1196 foundEndOfFalse = kFALSE;
1197 Int_t iDataQualityNext = iDataQuality+1;
1198 while (iDataQualityNext < nDataQuality){
1199 AliDCSArray* dataQualityNext = (AliDCSArray*)dataQualityArray->At(iDataQualityNext);
1200 if (dataQualityNext->GetTimeStamp()>timeDataQualityStart && dataQualityNext->GetTimeStamp()<=timeEnd && dataQualityNext->GetTimeStamp() > dataQuality->GetTimeStamp()){ // considering only values between the first valid and the end of the run, and subsequent to the current value
1201 Bool_t dataQualityFlagNext = dataQualityNext->GetBool(0);
1202 AliDebug(3,Form("DataQualityNext = %d (set at %f)",(Int_t)dataQualityFlagNext,dataQualityNext->GetTimeStamp()));
1203 if (dataQualityFlagNext == kTRUE){
1204 // found TRUE value, first FALSE period completed
1205 foundEndOfFalse = kTRUE;
1206 falses[iFalse*2+1] = dataQualityNext->GetTimeStamp();
1213 if (!foundEndOfFalse) {
1214 AliInfo("Please, note that the last FALSE value lasted until the end of the run");
1215 falses[iFalse*2+1] = timeEnd;
1219 iDataQuality = iDataQualityNext+1;
1223 grpobj->SetNFalseDataQualityFlag(iFalse);
1224 grpobj->SetFalseDataQualityFlagPeriods(falses);
1228 delete dataQualityArray;
1231 AliError("Data Quality Flag array not found in LHC Data file!!!");
1234 // Processing data to go to AliLHCData object
1235 AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
1236 // storing AliLHCData in OCDB
1238 AliInfo(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
1240 md.SetResponsible("Ruben Shahoyan");
1241 md.SetComment("LHC data from the GRP preprocessor.");
1242 Bool_t result = kTRUE;
1243 result = Store("GRP", "LHCData", dt, &md);
1246 Log(Form("Problems in storing LHC Data - but not going into Error"));
1250 // processing LHC Phase
1252 TObjArray *beam1phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[4]);
1253 TObjArray *beam2phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[5]);
1254 if (beam1phase == 0x0 || beam2phase == 0x0){
1255 Log(Form("Problems in retrieving LHC Clock data from LHC file"));
1258 AliLHCClockPhase *phaseObj = ProcessLHCClockPhase(beam1phase,beam2phase,timeEnd);
1262 AliInfo(Form("LHC Phase found"));
1263 AliCDBMetaData mdPhase;
1264 mdPhase.SetResponsible("Cvetan Cheshkov");
1265 mdPhase.SetComment("LHC Clock Phase");
1266 Bool_t result = kTRUE;
1267 result = Store("Calib", "LHCClockPhase", phaseObj, &mdPhase);
1269 if (!result) return 3;
1275 AliError("No LHCData file found in FXS");
1282 //_______________________________________________________________
1284 UInt_t AliGRPPreprocessor::ProcessSPDMeanVertex()
1287 //Getting the SPD Mean Vertex
1290 TList* list = GetForeignFileSources("SPD", kDAQ, "VertexDiamond");
1291 Bool_t storeResult = kTRUE;
1292 if (list !=0x0 && list->GetEntries()!=0)
1294 AliInfo("The following sources produced files with the id VertexDiamond from SPD");
1296 for (Int_t jj=0;jj<list->GetEntries();jj++){
1297 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
1299 AliError(Form("Expecting a TObjString in the list for the %d-th source, but something else was found.",jj));
1302 AliInfo(Form("found source %s", str->String().Data()));
1303 TString fileNameRun = GetForeignFile("SPD", kDAQ, "VertexDiamond", str->GetName());
1304 if (fileNameRun.Length()>0){
1305 AliInfo(Form("Got the file %s", fileNameRun.Data()));
1306 TFile daqFile(fileNameRun.Data(),"READ");
1307 if (daqFile.IsOpen()) {
1308 AliESDVertex* meanVtx = dynamic_cast<AliESDVertex*>(daqFile.Get("MeanVertexPos"));
1311 // storing in the OCDB
1313 md.SetResponsible("Cvetan Cheshkov");
1314 md.SetComment("SPD Mean Vertex");
1315 storeResult = Store("Calib", "MeanVertexSPD", meanVtx, &md, 0, kTRUE);
1318 AliWarning("No SPD Mean Vertex object found in file");
1322 AliError("Can't open file");
1323 storeResult = kFALSE;
1327 AliWarning("No file found for current source for SPD Mean Vertex");
1332 AliWarning("No list found for SPD Mean Vertex");
1335 if (list) delete list;
1339 //_______________________________________________________________
1341 UInt_t AliGRPPreprocessor::ProcessDqmFxs()
1344 // Processing DQM fxs information
1347 // TriggerClassesAndHistosToClone
1348 TList* list = GetFileSources(kDQM, "TriggerClassesAndHistosToClone");
1349 Bool_t openFileResult = kTRUE;
1350 Bool_t storeResultQAThr = kTRUE;
1351 if (list !=0x0 && list->GetEntries()!=0){
1352 AliInfo("The following sources produced files with the id TriggerClassesAndHistosToClone for GRP");
1354 for (Int_t jj=0;jj<list->GetEntries();jj++){
1355 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
1357 AliError(Form("Expecting a TObjString in the list for the %d-th source, but something else was found.",jj));
1360 AliInfo(Form("found source %s", str->String().Data()));
1361 TString fileNameRun = GetFile(kDQM, "TriggerClassesAndHistosToClone", str->GetName());
1362 if (fileNameRun.Length()>0){
1363 AliInfo(Form("Got the file %s", fileNameRun.Data()));
1364 TFile dqmFile(fileNameRun.Data(),"READ");
1365 if (dqmFile.IsOpen()) {
1369 AliError("Can't open file");
1370 openFileResult = kFALSE;
1374 AliWarning("No file found for current source for DQM TriggerClassesAndHistosToClone");
1379 AliWarning("No list found for DQM TriggerClassesAndHistosToClone");
1382 if (list) delete list;
1385 TObjArray* qaThrArray = new TObjArray();
1386 for (Int_t idet = 0; idet < AliDAQ::kNDetectors; idet++){
1387 TString detName = AliDAQ::OnlineName(idet);
1388 if (detName == "TRI" || detName == "HLT" || detName == "TST") continue; // skipping TRI, HLT, TST since they do not produce QAThresholds
1389 AliDebug(2, Form("Processing QAThreshold for detector %s",detName.Data()));
1390 TList* listQAThr = GetForeignFileSources(detName.Data(), kDQM, "QAThresholds");
1391 if (listQAThr !=0x0){
1392 if (listQAThr->GetEntries() > 1){
1393 AliError(Form("More than one sources found for QAThresholds from detector %s, skipping",detName.Data()));
1396 else if (listQAThr->GetEntries()==1){
1397 AliInfo(Form("The following source produced files with the id QAThresholds for GRP, coming from detector %s:",detName.Data()));
1399 TObjString * str = dynamic_cast<TObjString*> (listQAThr->At(0));
1401 AliError(Form("Expecting a TObjString in the list for detector %s, but something else was found.",detName.Data()));
1405 AliInfo(Form("found source %s", str->String().Data()));
1406 TString fileNameRun = GetForeignFile(detName.Data(), kDQM, "QAThresholds", str->GetName());
1407 if (fileNameRun.Length()>0){
1408 AliInfo(Form("Got the file %s", fileNameRun.Data()));
1409 TFile dqmFile(fileNameRun.Data(),"READ");
1410 if (dqmFile.IsOpen()) {
1411 AliQAThresholds* qaThr = dynamic_cast<AliQAThresholds*>(dqmFile.Get(detName.Data()));
1413 Int_t qaThrId = qaThr->GetDetectorId();
1414 if (qaThrId != idet){
1415 AliError(Form("Expecting QA threshold for detector %s, but found that for detector %s, skipping",detName.Data(), AliDAQ::OnlineName(qaThrId)));
1420 qaThrArray->AddAtAndExpand(qaThr, qaThrId);
1425 AliError(Form("No QAThresholds object found in the file for detector %s, skipping",detName.Data()));
1431 AliError(Form("Can't open QAThreshold file for detector %s, skipping",detName.Data()));
1437 AliWarning(Form("No file found for DQM QAThreshold for detector %s, skipping",detName.Data()));
1443 AliError(Form("No sources found for QAThresholds from detector %s, skipping",detName.Data()));
1449 AliWarning(Form("No list found for DQM QAThreshold for detector %s, skipping",detName.Data()));
1453 if (qaThrArray->GetEntries() > 0){
1455 md.SetResponsible("Barthélémy von Haller");
1456 md.SetComment("QA Threshold TObjArray");
1457 storeResultQAThr = Store("Calib", "QAThresholds", qaThrArray, &md, 0, kTRUE);
1460 Printf("No valid QAThresholds entries found, storing nothing in the OCDB");
1463 Printf("openFileResult for QAThr processing would be %d, but we return kTRUE anyway", (Int_t)openFileResult);
1464 Printf("storeResultQAThr for QAThr processing would be %d, but we return kTRUE anyway", (Int_t)storeResultQAThr);
1465 // return storeResultQAThr;
1466 return kTRUE; // temporary!!
1470 //_______________________________________________________________
1472 Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
1474 //Getting the DAQ lb information
1476 time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
1477 time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
1478 Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
1479 TString beamType = (TString)GetRunParameter("beamType");
1480 Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
1481 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
1482 TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
1483 TString runType = (TString)GetRunType();
1485 if (timeEnd >= 2.E9) AliFatal("ALICE run finshed later than Wed May 18 2033, 03:33:20 GMT, maximum time allowed for LHC data --> fix the GRP preprocessor!!!");
1487 UInt_t nparameter = 0;
1488 if (timeStart != 0){
1489 grpObj->SetTimeStart(timeStart);
1490 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
1494 Log(Form("Start time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1498 grpObj->SetTimeEnd(timeEnd);
1499 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
1503 Log(Form("End time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1506 if (beamEnergy != 0){
1507 Log(Form("Beam Energy for run %d: %f (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamEnergy));
1510 Log(Form("Beam Energy not put in logbook, but not using it anyway for the GRP object (taking it from the LHC file)"));
1514 if (beamType.Length() != 0){
1515 Log(Form("Beam Type for run %d: %s (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamType.Data()));
1518 Log(Form("Beam Type not put in logbook, but not using it anyway for the GRP entry (taking it from the LHC file)"));
1521 if (numberOfDetectors != 0){
1522 grpObj->SetNumberOfDetectors(numberOfDetectors);
1523 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
1527 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1530 if (detectorMask != 0){
1531 grpObj->SetDetectorMask(detectorMask);
1532 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
1536 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1539 if (lhcPeriod.Length() != 0) {
1540 grpObj->SetLHCPeriod(lhcPeriod);
1541 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
1545 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1547 if (runType.Length() != 0) {
1548 grpObj->SetRunType(runType);
1549 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
1553 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry, and causing an error!"));
1558 //_______________________________________________________________
1560 UInt_t AliGRPPreprocessor::ProcessDaqFxs()
1562 //======DAQ FXS======//
1564 AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
1565 AliRawEventHeaderV3_11::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_11 - temporary fix
1566 AliRawEventHeaderV3_12::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_12 - temporary fix
1567 AliRawEventHeaderV3_13::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_13 - temporary fix
1568 Log("Processing DAQ FXS");
1569 TList* list = GetFileSources(kDAQ);
1571 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
1575 if (list->GetEntries() == 0) {
1576 Log("no raw data tags in this run: nothing to merge!");
1577 delete list; list=0;
1581 TChain *fRawTagChain = new TChain("T");
1583 Int_t nCorruptedFiles=0;
1584 TIterator* iter = list->MakeIterator();
1586 while ((obj = iter->Next())) {
1587 TObjString* objStr = dynamic_cast<TObjString*> (obj);
1589 Log(Form("Found source %s", objStr->String().Data()));
1590 TList* list2 = GetFileIDs(kDAQ, objStr->String());
1592 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
1593 delete fRawTagChain; fRawTagChain=0;
1596 Log(Form("Number of ids: %d",list2->GetEntries()));
1597 for(Int_t i = 0; i < list2->GetEntries(); i++) {
1598 TObjString *idStr = (TObjString *)list2->At(i);
1599 if (idStr->String().CompareTo("QAThreshold") == 0 || idStr->String().CompareTo("TriggerClassesAndHistosToClone") == 0) {
1600 Log(Form("Skipping file with Id %s",idStr->String().Data()));
1603 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
1604 if (fileName.Length() > 0) {
1605 if(!CheckFileRecords(fileName.Data())){
1606 Log(Form("The file records for \"%s\" are corrupted! The chain is skipping it.",fileName.Data()));
1609 Log(Form("Adding file in the chain: %s",fileName.Data()));
1610 fRawTagChain->Add(fileName.Data());
1614 Log(Form("Could not retrieve file with id %s from source %s: "
1615 "connection problems with DAQ FXS!",
1616 idStr->String().Data(), objStr->String().Data()));
1617 delete list; list=0;
1618 delete list2; list2=0;
1619 delete fRawTagChain; fRawTagChain=0;
1628 Log("no raw data tags in this run: it could be that one or more files were found in the DAQ FXS, but they were ignored, since not interesting for the raw data tag: nothing to merge!");
1633 delete fRawTagChain;
1638 TString fRawDataFileName = "GRP_Merged.tag.root";
1639 if(nCorruptedFiles!=0)
1640 Log(Form("Merging %d raw data tags into file: %s. %d corrupted files skipped", nFiles, fRawDataFileName.Data(), nCorruptedFiles));
1642 Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
1644 if (fRawTagChain->Merge(fRawDataFileName) < 1 ) {
1645 Log(Form("Error merging %d raw data files!!!",nFiles));
1650 delete fRawTagChain;
1655 TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
1656 Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
1659 Log("Problem storing raw data tags in local file!!!");
1661 Log("Raw data tags merged successfully!!");
1668 delete fRawTagChain; fRawTagChain=0;
1670 if (result == kFALSE) {
1678 //_______________________________________________________________
1679 UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
1682 // processing the info
1683 // stored in the DCS FXS
1684 // coming from the trigger
1686 // Get the CTP counters information
1688 // Get the CTP aliases information
1690 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
1691 Log("STANDALONE partition for current run, using Trigger Scalers and Trigger Aliases dummy values");
1693 AliCDBEntry *cdbEntryScalers = GetFromOCDB("CTP","DummyScalers");
1694 if (!cdbEntryScalers) {
1695 Log(Form("No dummy CTP scalers entry found, going into error..."));
1699 AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntryScalers->GetObject();
1701 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
1705 AliCDBMetaData metaData;
1706 metaData.SetResponsible("Roman Lietava");
1707 metaData.SetComment("CTP scalers from dummy entry in OCDB");
1708 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1709 Log("Unable to store the dummy CTP scalers object to OCDB!");
1716 AliCDBEntry *cdbEntryAliases = GetFromOCDB("CTP","DummyAliases");
1717 if (!cdbEntryAliases) {
1718 Log(Form("No dummy CTP aliases entry found, going into error..."));
1722 THashList *aliases = dynamic_cast<THashList*>(cdbEntryAliases->GetObject());
1724 Log(Form("CTP dummy aliases not found in OCDB entry, going into error..."));
1728 AliCDBMetaData metaData;
1729 metaData.SetResponsible("Evgeny Kryshen");
1730 metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
1731 if (!Store("CTP","Aliases", aliases, &metaData, 0, 0)) {
1732 Log("Unable to store the dummy CTP aliases object to OCDB!");
1740 else if (!partition.IsNull() && detector.IsNull()){ // global partition
1741 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
1742 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
1743 if (countersfile.IsNull()) {
1744 Log("No CTP counters files has been found: empty source!");
1748 Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
1749 AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
1751 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
1755 AliCDBMetaData metaData;
1756 metaData.SetBeamPeriod(0);
1757 metaData.SetResponsible("Roman Lietava");
1758 metaData.SetComment("CTP scalers");
1759 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1760 Log("Unable to store the CTP scalers object to OCDB!");
1770 TString aliasesFile = GetFile(kDCS, "CTP_aliases","");
1771 if (aliasesFile.IsNull()) {
1772 Log("No CTP aliases files has been found: empty source!");
1776 Log(Form("File with Id CTP_aliases found in DCS FXS! Copied to %s",aliasesFile.Data()));
1777 // We build the THashList of TNamed("triggerclass","comma_separated_list_of_corresponding_aliases")
1778 THashList* trClasses2Aliases = ProcessAliases(aliasesFile);
1779 if (!trClasses2Aliases) {
1780 Log("Bad CTP aliases file! The corresponding CDB entry will not be filled!");
1784 AliCDBMetaData metaData;
1785 metaData.SetBeamPeriod(0);
1786 metaData.SetResponsible("Evgeny Kryshen");
1787 metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
1788 if (!Store("CTP","Aliases", trClasses2Aliases, &metaData, 0, 0)) {
1789 Log("Unable to store the CTP aliases object to OCDB!");
1790 delete trClasses2Aliases;
1794 delete trClasses2Aliases;
1800 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
1808 //_______________________________________________________________
1809 THashList* AliGRPPreprocessor::ProcessAliases(const char* aliasesFile)
1813 // build the THashList of triggerclasses-to-triggeraliases from text file
1814 // each line of the file is supposed to be a string composed by
1815 // triggerclass+spaces+commaseparatedlistofcorrespondingaliases\n
1816 // it will add a TNamed("triggerclass","commaseparatedlistofcorrespondingaliases")
1820 if (gSystem->AccessPathName(aliasesFile)) {
1821 Printf("file (%s) not found", aliasesFile);
1825 ifstream *file = new ifstream(aliasesFile);
1827 Printf("Error opening file (%s) !",aliasesFile);
1833 THashList *hList = new THashList(10);
1834 hList->SetName("List of trigger classes to trigger aliases strings");
1837 while (strLine.ReadLine(*file)) {
1839 // safety for null lines, tabs instead of whitespaces, trailing carriage return, leading or trailing spaces/tabs
1840 if (strLine.IsNull()) continue;
1841 strLine.ReplaceAll('\t',' ');
1842 strLine.Remove(TString::kLeading,' ');
1843 strLine.Remove(TString::kTrailing,'\r');
1844 strLine.Remove(TString::kTrailing,' ');
1846 TObjArray* arr = strLine.Tokenize(' ');
1847 if(arr->GetEntries() != 2){
1848 Printf("The line:\n%s\nunexpectedly contains %d tokens, instead of two.",strLine.Data(),arr->GetEntries());
1852 TObjString *osTC = (TObjString*) arr->At(0);
1853 TObjString *osTAlist = (TObjString*) arr->At(1);
1854 TNamed *ctoa = new TNamed(osTC->GetName(),osTAlist->GetName());
1865 //_______________________________________________________________
1866 Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
1870 // processing DCS DPs
1873 Int_t entries = 0; // counting the entries that are in the DCS DB, not taking care whether they have values or not
1874 Int_t nL3Entries = 0;
1875 Int_t nDipoleEntries = 0;
1876 Int_t nEnvEntries = 0;
1877 Int_t nHallProbesEntries = 0;
1878 nL3Entries = ProcessL3DPs(valueMap, grpObj);
1879 nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
1880 nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
1881 nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
1882 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
1883 Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
1884 entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
1889 //_______________________________________________________________
1891 Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
1898 Int_t nL3Entries = 0;
1900 TObjArray *array = 0x0;
1902 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1904 AliInfo(Form("==========L3Current==========="));
1905 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1906 indexDP = kL3Current;
1907 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1909 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1912 if (array->GetEntries() == 0){
1913 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1916 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1917 if (floatDCS != NULL){
1918 grpObj->SetL3Current(floatDCS);
1930 ffailedDPs->RemoveAt(indexDP);
1934 if (array) array = 0x0;
1936 AliInfo(Form("==========L3Polarity==========="));
1937 indexDP = kL3Polarity;
1938 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1940 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1943 if (array->GetEntries() == 0){
1944 AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
1947 Bool_t change = kFALSE;
1948 Char_t charDCS = ProcessBool(array,change);
1949 if (change == kFALSE){
1950 grpObj->SetL3Polarity(charDCS);
1951 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
1952 ffailedDPs->RemoveAt(indexDP);
1956 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
1957 ffailedDPs->RemoveAt(indexDP);
1961 AliError(Form("%s value changed within the run, while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong",fgkDCSDataPoints[indexDP]));
1969 //_______________________________________________________________
1971 Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
1977 Int_t nDipoleEntries = 0;
1978 TObjArray *array = 0x0;
1980 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
1982 AliInfo(Form("==========DipoleCurrent==========="));
1983 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1984 indexDP = kDipoleCurrent;
1985 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1987 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1990 if (array->GetEntries() == 0){
1991 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1994 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1995 if (floatDCS != NULL){
1996 grpObj->SetDipoleCurrent(floatDCS);
2008 ffailedDPs->RemoveAt(indexDP);
2012 if (array) array = 0x0;
2014 AliInfo(Form("==========DipolePolarity==========="));
2015 indexDP = kDipolePolarity;
2016 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
2018 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
2021 if (array->GetEntries() == 0){
2022 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
2025 Bool_t change = kFALSE;
2026 Char_t charDCS = ProcessBool(array,change);
2028 grpObj->SetDipolePolarity(charDCS);
2029 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
2030 ffailedDPs->RemoveAt(indexDP);
2034 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
2035 ffailedDPs->RemoveAt(indexDP);
2039 AliError(Form("%s value changed within the run while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong", fgkDCSDataPoints[indexDP]));
2044 return nDipoleEntries;
2047 //_______________________________________________________________
2049 Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
2053 // evironment conditions (temperature, pressure) info
2055 Int_t nEnvEntries = 0;
2056 TObjArray *array = 0x0;
2059 AliInfo(Form("==========CavernTemperature==========="));
2060 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
2061 indexDP = kCavernTemperature;
2062 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
2064 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
2067 if (array->GetEntries() == 0){
2068 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
2071 Float_t *floatDCS = ProcessFloatAll(array);
2072 if (floatDCS != NULL){
2073 grpObj->SetCavernTemperature(floatDCS);
2084 ffailedDPs->RemoveAt(indexDP);
2089 if (array) array = 0x0;
2091 AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
2092 AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
2093 //dcsSensorArray->Print();
2094 if( fPressure->NumFits()<kNumSensors ) {
2095 Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
2097 Log(Form("Number of fits performed = %d",fPressure->NumFits()));
2099 AliInfo(Form("==========CavernAtmosPressure==========="));
2100 indexDP = kCavernAtmosPressure;
2101 AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2102 TGraph* graph = sensorCavernP2->GetGraph();
2103 AliDebug(3,Form("index = %d",indexDP));
2104 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2105 AliDebug(2,Form("graph = %p",graph));
2106 AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
2107 if(sensorCavernP2->GetFit() || graph) {
2108 if (sensorCavernP2->GetFit()){
2109 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2112 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2114 grpObj->SetCavernAtmosPressure(sensorCavernP2);
2115 ffailedDPs->RemoveAt(indexDP);
2118 //if (sensorP2) delete sensorP2;
2120 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
2123 AliInfo(Form("==========SurfaceAtmosPressure==========="));
2124 indexDP = kSurfaceAtmosPressure;
2125 AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2126 graph = sensorP2->GetGraph();
2127 AliDebug(3,Form("index = %d",indexDP));
2128 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2129 AliDebug(2,Form("graph = %p",graph));
2130 AliDebug(3,Form("sensorP2 = %p", sensorP2));
2131 if(sensorP2->GetFit() || graph) {
2132 if (sensorP2->GetFit()){
2133 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2136 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2138 grpObj->SetSurfaceAtmosPressure(sensorP2);
2139 ffailedDPs->RemoveAt(indexDP);
2142 //if (sensorP2) delete sensorP2;
2144 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
2147 AliInfo(Form("==========CavernAtmosPressure2==========="));
2148 indexDP = kCavernAtmosPressure2;
2149 AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
2150 graph = sensorCavernP22->GetGraph();
2151 AliDebug(3,Form("index = %d",indexDP));
2152 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
2153 AliDebug(2,Form("graph = %p",graph));
2154 AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
2155 if(sensorCavernP22->GetFit() || graph) {
2156 if (sensorCavernP22->GetFit()){
2157 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
2160 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
2162 grpObj->SetCavernAtmosPressure2(sensorCavernP22);
2163 ffailedDPs->RemoveAt(indexDP);
2166 //if (sensorP2) delete sensorP2;
2168 Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
2174 //_______________________________________________________________
2176 Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
2182 Int_t nHPEntries = 0;
2183 TObjArray *array = 0x0;
2185 Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
2187 if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
2188 AliError(Form("Number of Hall probes expected in GRP Preprocessor (i.e. %d) different from number of Hall Probes foreseen in GRP object (i.e. %d). Looping on entries from GRP object anyway.", fgknDCSDPHallProbes, AliGRPObject::GetNumberOfHP()));
2190 for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
2191 outOfRange = kFALSE; // resetting outOfRange flag at each HP
2192 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
2193 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
2195 Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
2198 if (array->GetEntries() == 0){
2199 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
2202 Float_t *floatDCS = ProcessFloatAll(array);
2203 if (floatDCS != NULL){
2204 AliDebug(2,Form("value[0] = %f, value[1] = %f, value[2] = %f, value[3] = %f, value[4] = %f",floatDCS[0],floatDCS[1],floatDCS[2],floatDCS[3],floatDCS[4]));
2205 grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
2206 for (Int_t kk = 0 ; kk< 5; kk++){
2207 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
2219 ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift); // 7 = shift in the complete list of DPs to get to the Hall Probes
2225 Log(Form("Hall Probes = %d ", nHPEntries));
2229 //_________________________________________________________________________
2231 AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
2235 // returning Spline Fit
2238 Int_t entriesarray = array->GetEntries();
2239 Float_t* value = new Float_t[entriesarray];
2240 Float_t* time = new Float_t[entriesarray];
2241 AliDCSValue* v = 0x0;
2242 for (Int_t iarray = 0; iarray < entriesarray; iarray++){
2243 v = (AliDCSValue*)array->At(iarray);
2244 value[iarray] = v->GetFloat();
2245 time[iarray] = v->GetTimeStamp();
2246 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
2248 TGraph* gr = new TGraph(entriesarray,value,time);
2250 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
2253 AliSplineFit *fit = new AliSplineFit();
2254 fit->SetMinPoints(10);
2255 fit->InitKnots(gr,10,10,0.0);
2261 //_________________________________________________________________________
2263 TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
2270 TString aDCSString="";
2272 AliDCSValue *v = 0x0;
2273 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
2274 v = (AliDCSValue *)array->At(iCount);
2275 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
2276 AliError(Form("DCS values for the parameter outside the queried interval"));
2280 if (aDCSString != v->GetChar())
2281 AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
2283 aDCSString = (TString)v->GetChar(); // keeping always last value in the array
2288 //__________________________________________________________________________________________________________________
2290 Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
2293 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
2295 // parameters[0] = mean
2296 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
2297 // parameters[2] = median
2298 // parameters[3] = standard deviation wrt mean
2299 // parameters[4] = standard deviation wrt median
2302 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2303 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2304 if (timeStartString.IsNull() || timeStartString.IsNull()){
2305 if (timeStartString.IsNull()){
2306 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2308 else if (timeStartString.IsNull()){
2309 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2311 fdaqStartEndTimeOk = kFALSE;
2315 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2316 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2317 Float_t* parameters = new Float_t[5];
2319 Int_t iCountsRun = 0;
2320 Int_t nCounts = array->GetEntries();
2321 Float_t valueBeforeSOR = 0;
2322 Float_t valueAfterEOR = 0;
2323 Int_t timestampBeforeSOR = -1;
2324 Int_t timestampAfterEOR = -1;
2325 Int_t ientrySOR = -1;
2326 Int_t ientryEOR = -1;
2327 Float_t* arrayValues = 0x0;
2328 Double_t* arrayWeights = 0x0;
2329 Bool_t truncMeanFlag = kTRUE; // flag to indicate whether Truncated Mean should be calculated or not
2330 Bool_t sdFlag = kTRUE; // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
2332 for(Int_t i = 0; i < nCounts; i++) {
2333 AliDCSValue *v = (AliDCSValue *)array->At(i);
2334 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
2335 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
2336 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
2337 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
2338 delete [] parameters;
2341 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2342 AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
2344 // look for the last value before SOR and the first value before EOR
2345 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2346 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2347 AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2348 valueBeforeSOR = v->GetFloat();
2350 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2351 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2352 valueAfterEOR = v->GetFloat();
2353 AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2355 // check if there are DPs between DAQ_time_start and DAQ_time_end
2356 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2357 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2358 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2359 AliDebug(2,Form("entry between SOR and EOR"));
2364 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2368 if (timestampBeforeSOR == -1){
2369 AliWarning("No value found before SOR");
2371 if (timestampAfterEOR == -1){
2372 AliWarning("No value found after EOR");
2375 AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
2376 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2377 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2378 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2379 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2380 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2382 Int_t nentriesUsed = 0;
2383 if (iCountsRun > 1){
2384 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2385 AliDebug(2,"Calculating (weighted) Mean and Median");
2386 arrayValues = new Float_t[iCountsRun];
2387 arrayWeights = new Double_t[iCountsRun];
2388 nentriesUsed = iCountsRun;
2389 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2390 AliDCSValue *v = (AliDCSValue *)array->At(i);
2391 Int_t timestamp2 = 0;
2393 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2394 timestamp2 = (Int_t)v1->GetTimeStamp();
2397 timestamp2 = timeEnd+1;
2399 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2400 arrayValues[i-ientrySOR] = v->GetFloat();
2402 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2403 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
2405 else if (iCountsRun == 1){
2406 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2408 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2409 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR. Truncated mean won't be calculated.");
2410 arrayValues = new Float_t[2];
2411 arrayWeights = new Double_t[2];
2412 arrayValues[0] = valueBeforeSOR;
2413 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2414 arrayValues[1] = v->GetFloat();
2415 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2416 AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2417 AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2418 parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
2419 parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
2420 truncMeanFlag = kFALSE;
2423 AliError("Cannot calculate mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2424 parameters[0] = AliGRPObject::GetInvalidFloat();
2425 parameters[1] = AliGRPObject::GetInvalidFloat();
2426 parameters[2] = AliGRPObject::GetInvalidFloat();
2427 parameters[3] = AliGRPObject::GetInvalidFloat();
2428 parameters[4] = AliGRPObject::GetInvalidFloat();
2432 else { // iCountsRun == 0, using only the point immediately before SOR
2433 if (timestampBeforeSOR == -1){
2434 AliError("Cannot set mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - no points during the run collected, and point before SOR missing");
2435 parameters[0] = AliGRPObject::GetInvalidFloat();
2436 parameters[1] = AliGRPObject::GetInvalidFloat();
2437 parameters[2] = AliGRPObject::GetInvalidFloat();
2438 parameters[3] = AliGRPObject::GetInvalidFloat();
2439 parameters[4] = AliGRPObject::GetInvalidFloat();
2443 AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
2444 AliDebug(2,Form("value = %f",valueBeforeSOR));
2445 parameters[0] = valueBeforeSOR;
2446 parameters[2] = valueBeforeSOR;
2447 truncMeanFlag = kFALSE;
2452 AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
2455 Float_t sumweights = 0;
2456 Int_t entriesTruncMean = 0;
2457 Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed];
2458 Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
2460 // calculating SD wrt Mean and Median
2461 AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
2463 for (Int_t i =0; i< nentriesUsed; i++){
2464 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
2465 temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
2466 temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
2467 sumweights += arrayWeights[i];
2469 // setting SD wrt Mean
2470 if (sumweights != 0 ){
2471 parameters[3] = TMath::Sqrt(temp1/sumweights);
2474 AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
2475 parameters[3] = AliGRPObject::GetInvalidFloat();
2477 // setting SD wrt Median
2478 if (nentriesUsed != 0){
2479 parameters[4] = TMath::Sqrt(temp/nentriesUsed);
2482 AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
2483 parameters[4] = AliGRPObject::GetInvalidFloat();
2487 parameters[3] = AliGRPObject::GetInvalidFloat();
2488 parameters[4] = AliGRPObject::GetInvalidFloat();
2491 // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
2493 AliDebug(2,"Calculating Truncated Mean");
2494 for (Int_t i =0; i< nentriesUsed; i++){
2495 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
2496 if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
2497 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
2498 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
2499 AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
2503 AliDebug(2,"Discarding entry");
2506 // setting truncated mean
2507 if (entriesTruncMean >1){
2508 AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
2509 parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
2512 AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
2513 parameters[1] = AliGRPObject::GetInvalidFloat();
2517 parameters[1] = AliGRPObject::GetInvalidFloat();
2521 delete [] arrayValues;
2524 delete [] arrayWeights;
2526 delete [] arrayValuesTruncMean;
2527 delete [] arrayWeightsTruncMean;
2529 AliInfo(Form("(weighted) mean = %f ",parameters[0]));
2530 AliInfo(Form("(weighted) truncated mean = %f ",parameters[1]));
2531 AliInfo(Form("median = %f ",parameters[2]));
2532 AliInfo(Form("(weighted) standard deviation with (weighted) mean = %f ",parameters[3]));
2533 AliInfo(Form("standard deviation with median = %f ",parameters[4]));
2538 //__________________________________________________________________________________________________________________
2540 Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
2543 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
2544 // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
2545 // the flag is set according to the L3/Dipole current value
2546 // current threshold for L3 = 350 A (value provided by DCS)
2547 // current threshold for Dipole = 450 A (value provided by DCS)
2549 // parameters[0] = mean
2550 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
2551 // parameters[2] = median
2552 // parameters[3] = standard deviation wrt mean
2553 // parameters[4] = standard deviation wrt median
2556 AliInfo(Form("indexDP = %d",indexDP));
2558 Int_t nCounts = array->GetEntries();
2559 for(Int_t i = 0; i < nCounts; i++) {
2560 AliDCSValue *v = (AliDCSValue *)array->At(i);
2561 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
2562 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
2563 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
2564 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
2567 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2568 AliDebug(2,Form("%d-th entry = %f",i,v->GetFloat()));
2569 if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
2570 if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
2573 AliError(Form("DCS values for the parameter outside the queried interval"));
2577 return ProcessFloatAll(array);
2581 //_______________________________________________________________
2583 Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
2586 // processing Boolean values
2589 Bool_t aDCSBool = kTRUE;
2591 AliDCSValue *v = 0x0;
2593 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
2594 v = (AliDCSValue *)array->At(iCount);
2595 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
2596 AliError(Form("DCS values for the parameter outside the queried interval"));
2600 if (aDCSBool != v->GetBool()) {
2601 AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
2605 aDCSBool = v->GetBool(); // always keeping last value
2606 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
2609 Char_t caDCSBool = (Char_t) aDCSBool;
2614 //_______________________________________________________________
2616 Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
2619 // processing Int values, returning mean
2620 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2621 // are outside the queried time interval or their value is out of range
2624 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2625 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2626 if (timeStartString.IsNull() || timeStartString.IsNull()){
2627 if (timeStartString.IsNull()){
2628 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2630 else if (timeStartString.IsNull()){
2631 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2636 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2637 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2638 Float_t aDCSArrayMean = 0.0;
2640 Float_t valueBeforeSOR = 0;
2641 Float_t valueAfterEOR = 0;
2642 Int_t timestampBeforeSOR = -1;
2643 Int_t timestampAfterEOR = -1;
2644 Int_t ientrySOR = -1;
2645 Int_t ientryEOR = -1;
2646 Float_t* arrayValues = 0x0;
2647 Double_t* arrayWeights = 0x0;
2648 Int_t iCountsRun = 0;
2649 Int_t nCounts = array->GetEntries();
2651 for(Int_t i = 0; i < nCounts; i++) {
2652 AliDCSValue* v = (AliDCSValue *)array->At(i);
2653 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
2654 AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",i, v->GetInt()));
2655 return AliGRPObject::GetInvalidFloat();
2657 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2658 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetInt(),v->GetTimeStamp()));
2660 // look for the last value before SOR and the first value before EOR
2661 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2662 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2663 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2664 valueBeforeSOR = (Float_t) v->GetInt();
2666 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2667 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2668 valueAfterEOR = (Float_t) v->GetInt();
2669 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2671 // check if there are DPs between DAQ_time_start and DAQ_time_end
2672 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2673 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2674 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2675 AliDebug(2,Form("entry between SOR and EOR"));
2680 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2684 if (timestampBeforeSOR == -1){
2685 AliWarning("No value found before SOR!");
2687 if (timestampAfterEOR == -1){
2688 AliWarning("No value found after EOR!");
2691 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2692 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2693 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2694 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2695 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2696 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2698 Int_t nentriesUsed = 0;
2699 if (iCountsRun > 1){
2700 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2701 AliDebug(2,"Calculating (weighted) Mean");
2702 arrayValues = new Float_t[iCountsRun];
2703 arrayWeights = new Double_t[iCountsRun];
2704 nentriesUsed = iCountsRun;
2705 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2706 AliDCSValue *v = (AliDCSValue *)array->At(i);
2707 Int_t timestamp2 = 0;
2709 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2710 timestamp2 = (Int_t)v1->GetTimeStamp();
2713 timestamp2 = timeEnd+1;
2715 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2716 arrayValues[i-ientrySOR] = (Float_t)v->GetInt();
2718 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2719 delete [] arrayValues;
2720 delete [] arrayWeights;
2722 else if (iCountsRun == 1){
2723 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2725 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2726 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2727 arrayValues = new Float_t[2];
2728 arrayWeights = new Double_t[2];
2729 arrayValues[0] = valueBeforeSOR;
2730 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2731 arrayValues[1] = (Float_t)v->GetInt();
2732 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2733 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2734 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2735 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2736 delete [] arrayValues;
2737 delete [] arrayWeights;
2740 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2741 return AliGRPObject::GetInvalidFloat();
2744 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2745 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2746 if (timestampBeforeSOR == -1){
2747 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2749 if (timestampAfterEOR == -1){
2750 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2752 return AliGRPObject::GetInvalidFloat();
2755 AliWarning("Using last entry before SOR and first entry after EOR.");
2757 arrayValues = new Float_t[2];
2758 arrayWeights = new Double_t[2];
2759 arrayValues[0] = valueBeforeSOR;
2760 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2761 arrayValues[1] = valueAfterEOR;
2762 arrayWeights[1] = 1.;
2763 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2764 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2765 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2766 delete [] arrayValues;
2767 delete [] arrayWeights;
2771 AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
2772 AliInfo(Form("mean = %f ", aDCSArrayMean));
2773 return aDCSArrayMean;
2776 //_______________________________________________________________
2778 Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
2781 // processing Int values, returning mean
2782 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2783 // are outside the queried time interval or their value is out of range
2786 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2787 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2788 if (timeStartString.IsNull() || timeStartString.IsNull()){
2789 if (timeStartString.IsNull()){
2790 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2792 else if (timeStartString.IsNull()){
2793 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2798 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2799 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2800 Float_t aDCSArrayMean = 0.0;
2802 Float_t valueBeforeSOR = 0;
2803 Float_t valueAfterEOR = 0;
2804 Int_t timestampBeforeSOR = -1;
2805 Int_t timestampAfterEOR = -1;
2806 Int_t ientrySOR = -1;
2807 Int_t ientryEOR = -1;
2808 Float_t* arrayValues = 0x0;
2809 Double_t* arrayWeights = 0x0;
2810 Int_t iCountsRun = 0;
2811 Int_t nCounts = array->GetEntries();
2813 for(Int_t i = 0; i < nCounts; i++) {
2814 AliDCSValue* v = (AliDCSValue *)array->At(i);
2815 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
2816 AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",i,v->GetUInt()));
2817 return AliGRPObject::GetInvalidFloat();
2819 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
2820 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetUInt(),v->GetTimeStamp()));
2822 // look for the last value before SOR and the first value before EOR
2823 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2824 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2825 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2826 valueBeforeSOR = (Float_t)v->GetUInt();
2828 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2829 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2830 valueAfterEOR = (Float_t)v->GetUInt();
2831 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2833 // check if there are DPs between DAQ_time_start and DAQ_time_end
2834 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2835 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2836 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2837 AliDebug(2,Form("entry between SOR and EOR"));
2842 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
2846 if (timestampBeforeSOR == -1){
2847 AliWarning("No value found before SOR!");
2849 if (timestampAfterEOR == -1){
2850 AliWarning("No value found after EOR!");
2853 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2854 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2855 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2856 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2857 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2858 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2860 Int_t nentriesUsed = 0;
2861 if (iCountsRun > 1){
2862 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2863 AliDebug(2,"Calculating (weighted) Mean");
2864 arrayValues = new Float_t[iCountsRun];
2865 arrayWeights = new Double_t[iCountsRun];
2866 nentriesUsed = iCountsRun;
2867 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2868 AliDCSValue *v = (AliDCSValue *)array->At(i);
2869 Int_t timestamp2 = 0;
2871 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2872 timestamp2 = (Int_t)v1->GetTimeStamp();
2875 timestamp2 = timeEnd+1;
2877 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2878 arrayValues[i-ientrySOR] = (Float_t)v->GetUInt();
2880 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2881 delete [] arrayValues;
2882 delete [] arrayWeights;
2884 else if (iCountsRun == 1){
2885 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2887 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2888 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2889 arrayValues = new Float_t[2];
2890 arrayWeights = new Double_t[2];
2891 arrayValues[0] = valueBeforeSOR;
2892 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2893 arrayValues[1] = (Float_t)v->GetUInt();
2894 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2895 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2896 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2897 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2898 delete [] arrayValues;
2899 delete [] arrayWeights;
2902 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2903 return AliGRPObject::GetInvalidFloat();
2906 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2907 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2908 if (timestampBeforeSOR == -1){
2909 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2911 if (timestampAfterEOR == -1){
2912 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2914 return AliGRPObject::GetInvalidFloat();
2917 AliWarning("Using last entry before SOR and first entry after EOR.");
2919 arrayValues = new Float_t[2];
2920 arrayWeights = new Double_t[2];
2921 arrayValues[0] = valueBeforeSOR;
2922 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2923 arrayValues[1] = valueAfterEOR;
2924 arrayWeights[1] = 1.;
2925 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2926 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2927 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2928 delete [] arrayValues;
2929 delete [] arrayWeights;
2933 AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
2934 AliInfo(Form("mean = %f ",aDCSArrayMean));
2935 return aDCSArrayMean;
2940 //_______________________________________________________________
2942 AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
2944 // extract DCS pressure maps. Perform fits to save space
2946 TMap *map = fPressure->ExtractDCS(dcsAliasMap);
2948 AliDebug(2,Form("Map has %d entries",map->GetEntries()));
2949 fPressure->MakeSplineFit(map);
2950 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
2951 if (fitFraction > kFitFraction ) {
2952 AliInfo(Form("Pressure values extracted, %d fits performed for %d sensors.", fPressure->NumFits(),fPressure->NumSensors()));
2954 AliInfo("Too few pressure maps fitted!!!");
2957 AliInfo("no atmospheric pressure map extracted!!!");
2966 //_______________________________________________________________
2967 Int_t AliGRPPreprocessor::ReceivePromptRecoParameters(UInt_t run, const char* dbHost, Int_t dbPort, const char* dbName, const char* user, const char* password, const char *cdbRoot, TString &gdc)
2970 // Retrieves logbook and trigger information from the online logbook
2971 // This information is needed for prompt reconstruction
2975 // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
2979 // positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
2980 // 0 on success and no run was found
2981 // negative on error
2983 // This function is NOT called during the preprocessor run in the Shuttle!
2991 AliCDBManager* cdb = AliCDBManager::Instance();
2992 cdb->SetDefaultStorage(cdbRoot);
2995 TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
2999 Printf("ERROR: Could not connect to DAQ LB");
3005 sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent,beamType, DAQ_time_end FROM logbook WHERE run = %d", run);
3006 TSQLResult* result = server->Query(sqlQuery);
3009 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
3013 if (result->GetRowCount() == 0)
3015 Printf("ERROR: Run %d not found", run);
3020 TSQLRow* row = result->Next();
3023 Printf("ERROR: Could not receive data from run %d", run);
3028 TString timeStartString(row->GetField(0));
3029 TString runType(row->GetField(1));
3030 TString detectorMaskString(row->GetField(2));
3031 TString l3CurrentString(row->GetField(3));
3032 TString dipoleCurrentString(row->GetField(4));
3033 TString beamTypeString(row->GetField(5));
3034 TString timeEndString(row->GetField(6));
3036 time_t timeStart = (time_t)(timeStartString.Atoi());
3037 time_t timeEnd = (time_t)(timeEndString.Atoi());
3038 UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
3039 Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
3040 Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
3041 Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
3042 Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
3043 if (beamTypeString.CompareTo("Pb-Pb",TString::kIgnoreCase) == 0){
3044 beamTypeString="A-A";
3047 AliGRPObject * grpObj = new AliGRPObject();
3048 grpObj->SetTimeStart(timeStart);
3049 grpObj->SetTimeEnd((timeEnd!=0 && timeEnd>timeStart) ? timeEnd : timeStart+24*3600 );
3050 grpObj->SetRunType((TString)(row->GetField(1)));
3051 grpObj->SetDetectorMask(detectorMask);
3052 grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
3053 grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
3054 grpObj->SetL3Polarity(l3Polarity);
3055 grpObj->SetDipolePolarity(dipolePolarity);
3056 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
3057 grpObj->SetBeamType(beamTypeString);
3065 Printf("Storing GRP/GRP/Data object with the following content");
3068 AliCDBMetaData metadata;
3069 metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
3070 metadata.SetComment("GRP Output parameters received during online running");
3072 AliCDBId id("GRP/GRP/Data", run, run);
3073 Bool_t success = cdb->Put(grpObj, id, &metadata);
3079 Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
3083 // Receive trigger information
3084 sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
3085 result = server->Query(sqlQuery);
3088 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
3092 if (result->GetRowCount() == 0)
3094 Printf("ERROR: Run %d not found in logbook_trigger_config", run);
3099 row = result->Next();
3102 Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
3107 TString triggerConfig(row->GetField(0));
3115 Printf("Found trigger configuration: %s", triggerConfig.Data());
3117 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
3120 Printf("ERROR: Could not create CTP configuration object");
3124 metadata.SetComment("CTP run configuration received during online running");
3126 AliCDBId id2("GRP/CTP/Config", run, run);
3127 success = cdb->Put(runcfg, id2, &metadata);
3134 Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
3139 // Receive list of GDCs for this run
3140 sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
3141 result = server->Query(sqlQuery);
3144 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
3148 if (result->GetRowCount() == 0)
3150 Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
3156 for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
3157 row = result->Next();
3160 Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
3164 gdc += row->GetField(0);
3174 Printf("Found GDC: %s", gdc.Data());
3176 // get last run with same run type that was already processed by the SHUTTLE
3178 sqlQuery.Form("SELECT max(logbook.run) FROM logbook LEFT JOIN logbook_shuttle ON logbook_shuttle.run = logbook.run WHERE run_type = '%s' AND shuttle_done = 1", runType.Data());
3179 result = server->Query(sqlQuery);
3182 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
3186 if (result->GetRowCount() == 0)
3188 Printf("ERROR: No result with query <%s>", sqlQuery.Data());
3193 row = result->Next();
3196 Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
3201 TString lastRunStr(row->GetField(0));
3202 Int_t lastRun = lastRunStr.Atoi();
3204 Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
3218 //------------------------------------------------------------------------------------------------------
3219 Float_t AliGRPPreprocessor::ProcessEnergy(TObjArray* const array, Double_t timeStart){
3222 // Method to processo LHC Energy information
3223 // Only the first value is returned, provided that it is withing DAQ_time_start and DAQ_time_end
3226 Int_t nCounts = array->GetEntries();
3227 Float_t energy = -1;
3228 Double_t timeEnergy = -1;
3229 Int_t indexEnergy = -1;
3230 Bool_t foundEnergy = kFALSE;
3232 AliDebug(2,Form("Energy measurements = %d\n",nCounts));
3234 AliWarning("No Energy values found! Beam Energy remaining invalid!");
3237 for (Int_t i = 0; i < nCounts; i++){
3238 AliDCSArray *dcs = (AliDCSArray*)array->At(i);
3240 if (dcs->GetTimeStamp()<=timeStart && dcs->GetTimeStamp()>=timeEnergy){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
3241 timeEnergy = dcs->GetTimeStamp();
3243 foundEnergy = kTRUE;
3251 AliInfo("No value for the Energy found before start of run, the Energy will remain invalid");
3254 AliDCSArray* dcs = (AliDCSArray*)array->At(indexEnergy);
3255 energy = (Float_t)(TMath::Nint(((Double_t)(dcs->GetInt(0)))*120/1000)); // sqrt(s)/2 energy in GeV
3256 AliInfo(Form("Energy value found = %d (at %f), converting --> sqrt(s)/2 = %f (GeV)", dcs->GetInt(0),dcs->GetTimeStamp(),energy));
3262 //------------------------------------------------------------------------------------------------------
3263 AliLHCClockPhase* AliGRPPreprocessor::ProcessLHCClockPhase(TObjArray *beam1phase,TObjArray *beam2phase, Double_t timeEnd)
3266 // Method to process LHC-Clock Phase data
3267 // Only the values between DAQ_time_start and DAQ_time_end are kept
3269 AliLHCClockPhase *phaseObj = new AliLHCClockPhase;
3271 Bool_t foundBeam1Phase = kFALSE, foundBeam2Phase = kFALSE;
3272 const Float_t threshold = 0.050; // we store the measurement only in case they differ with more 50ps from the previous one
3274 TString timeCreatedStr = GetRunParameter("time_created");
3275 Double_t timeCreated = timeCreatedStr.Atof();
3277 Int_t nCounts = beam1phase->GetEntries();
3278 AliDebug(2,Form("Beam1 phase measurements = %d\n",nCounts));
3280 AliWarning("No beam1 LHC clock phase values found!");
3285 Double_t prevPhase = 0;
3286 for (Int_t i = 0; i < nCounts; i++){
3287 AliDCSArray *dcs = (AliDCSArray*)beam1phase->At(i);
3289 //if (dcs->GetTimeStamp()>=timeStart && dcs->GetTimeStamp()<=timeEnd) {
3290 if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
3291 if ((i == 0) || (i == (nCounts-1)) ||
3293 (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
3294 prevPhase = dcs->GetDouble(0);
3295 foundBeam1Phase = kTRUE;
3296 AliInfo(Form("B1 Clk Phase = %f at TS = %f",
3297 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
3298 phaseObj->AddPhaseB1DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
3303 if (!foundBeam1Phase){
3304 AliError("No beam1 LHC clock phase values found within the run!");
3310 nCounts = beam2phase->GetEntries();
3311 AliDebug(2,Form("Beam2 phase measurements = %d\n",nCounts));
3313 AliWarning("No beam2 LHC clock phase values found!");
3318 Double_t prevPhase = 0;
3319 for (Int_t i = 0; i < nCounts; i++){
3320 AliDCSArray *dcs = (AliDCSArray*)beam2phase->At(i);
3322 if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
3323 if ((i == 0) || (i == (nCounts-1)) ||
3325 (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
3326 prevPhase = dcs->GetDouble(0);
3327 foundBeam2Phase = kTRUE;
3328 AliInfo(Form("B2 Clk Phase = %f at TS = %f",
3329 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));
3330 phaseObj->AddPhaseB2DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
3335 if (!foundBeam2Phase){
3336 AliError("No beam2 LHC clock phase values found within the run!");
3344 //------------------------------------------------------------------------------------------------------
3345 TString AliGRPPreprocessor::ParseBeamTypeString(TString beamType, Int_t iBeamType)
3347 // Method to return the convention for the separate beam type
3348 // in the form A*1000+Z
3349 // e.g.: Pb82 --> 208000 + 82 = 208082
3350 // p --> 1000 + 1 = 1001
3354 TString separateString("");
3355 Log(Form("Setting Beam Type for beam %d to A*1000+Z",iBeamType));
3356 if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
3357 Log(Form("Beam type %d is PROTON --> The single beam type will be set to 1001 (A = 1, Z = 1)",iBeamType));
3358 separateString = "1001";
3359 return separateString;
3362 TPRegexp regexpA("\\D+");
3363 TPRegexp regexpZ("\\d+");
3364 TObjArray* arrayA = regexpA.MatchS(beamType);
3365 TObjArray* arrayZ = regexpZ.MatchS(beamType);
3366 if (arrayA->GetEntries() != 1 || arrayZ->GetEntries() != 1){
3367 Log(Form("The beamType string for beam %d does not contain the necessary information! Returning the info as published by LHC (i.e. %s)",iBeamType, beamType.Data()));
3371 TString strA = ((TObjString*)(arrayA->At(0)))->String();
3372 TString strZ = ((TObjString*)(arrayZ->At(0)))->String();
3373 if (strA.CompareTo("LEAD",TString::kIgnoreCase) == 0 || strA.CompareTo("PB",TString::kIgnoreCase) == 0){
3374 Log(Form("Beam %d is %s --> A = 208",iBeamType, strA.Data()));
3378 Log(Form("This beam was not foreseen so far, leaving A=0"));
3381 Log(Form("Beam %d has Z = %d",iBeamType, z));
3382 separateString = Form("%d",a*1000+z);
3383 return separateString;
3387 return separateString;
3391 //------------------------------------------------------------------------------------------------------
3392 Bool_t AliGRPPreprocessor::CheckFileRecords(const char* fileName) const
3394 // Check file logical records as in TFile::Map()
3395 // returning false in case the position of the final record is bigger than the file size
3396 // It should allow to mark as bad all and only raw tag files which would crash the chaining
3397 // done in ProcessDaqFxs
3399 TFile *f = TFile::Open(fileName);
3401 Printf("could not open file \"%s\"",fileName);
3405 Short_t keylen,cycle;
3407 Int_t nbytes,date,time,objlen,nwheader;
3410 Long64_t seekkey,seekpdir;
3413 const Int_t kBEGIN = 100;
3414 Long64_t fBEGIN = (Long64_t)kBEGIN; //First used word in file following the file header
3415 Long64_t idcur = fBEGIN;
3416 Long64_t fEND = f->GetEND(); //Last used byte in file
3419 Int_t nread = nwheader;
3421 char header[kBEGIN];
3422 char classname[512];
3424 while (idcur < fEND) {
3426 if (idcur+nread >= fEND) nread = fEND-idcur-1;
3427 if (f->ReadBuffer(header, nread)) {
3428 // ReadBuffer returns kTRUE in case of failure.
3429 Printf("%s: failed to read the key data from disk at %lld.",f->GetName(),idcur);
3434 frombuf(buffer, &nbytes);
3436 Printf("Address = %lld\tNbytes = %d\t=====E R R O R=======", idcur, nbytes);
3441 Printf("Address = %lld\tNbytes = %d\t=====G A P===========", idcur, nbytes);
3445 //return kFALSE; // these gaps are not always critical
3447 Version_t versionkey;
3448 frombuf(buffer, &versionkey);
3449 frombuf(buffer, &objlen);
3450 frombuf(buffer, &datime);
3451 frombuf(buffer, &keylen);
3452 frombuf(buffer, &cycle);
3453 if (versionkey > 1000) {
3454 frombuf(buffer, &seekkey);
3455 frombuf(buffer, &seekpdir);
3458 frombuf(buffer, &skey); seekkey = (Long64_t)skey;
3459 frombuf(buffer, &sdir); seekpdir = (Long64_t)sdir;
3461 frombuf(buffer, &nwhc);
3462 for (int i = 0;i < nwhc; i++) frombuf(buffer, &classname[i]);
3463 classname[(int)nwhc] = '\0'; //cast to avoid warning with gcc3.4
3464 Long64_t fSeekFree = f->GetSeekFree();
3465 Long64_t fSeekInfo = f->GetSeekInfo();
3466 Long64_t fSeekKeys = f->GetSeekKeys();
3467 if (idcur == fSeekFree) strlcpy(classname,"FreeSegments",512);
3468 if (idcur == fSeekInfo) strlcpy(classname,"StreamerInfo",512);
3469 if (idcur == fSeekKeys) strlcpy(classname,"KeysList",512);
3470 TDatime::GetDateTime(datime, date, time);
3472 if (objlen != nbytes-keylen) {
3473 Float_t cx = Float_t(objlen+keylen)/Float_t(nbytes);
3474 Printf("%d/%06d At:%lld N=%-8d %-14s CX = %5.2f",date,time,idcur,nbytes,classname,cx);
3476 Printf("%d/%06d At:%lld N=%-8d %-14s",date,time,idcur,nbytes,classname);
3481 //Printf("%d/%06d At:%lld N=%-8d %-14s",date,time,idcur,1,"END");
3482 if(idcur > f->GetSize()){
3483 AliWarning("Bad file: final record position bigger than file size");