Adding dump and analysis of syswatch logs
[u/mrichter/AliRoot.git] / STEER / AliGRPPreprocessor.cxx
CommitLineData
33c82fbf 1/**************************************************************************
3dedb44a 2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
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 **************************************************************************/
15
7ca4655f 16/* $Id$ */
17
3dedb44a 18//-------------------------------------------------------------------------
19// Class AliGRPPreprocessor
20// Global Run Parameters (GRP) preprocessor
21// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
e7a6790f 22// Modified: Ernesto.Lopez.Torres@cern.ch CEADEN-CERN
e75e6e01 23// Modified: Chiara.Zampolli@cern.ch CERN
3dedb44a 24//-------------------------------------------------------------------------
25
836d8b4f 26#include <TChain.h>
7ca4655f 27#include <TList.h>
28#include <TMap.h>
29#include <TObjString.h>
44e45fac 30#include <TGraph.h>
7ca4655f 31
fe726709 32#include <float.h>
33
3dedb44a 34#include "AliGRPPreprocessor.h"
44e45fac 35#include "AliGRPObject.h"
36#include "AliDCSSensor.h"
37#include "AliSplineFit.h"
17984b61 38#include "AliDCSSensorArray.h"
ea4a87ee 39#include "AliRawEventHeaderVersions.h"
3dedb44a 40
48b1b444 41#include "AliTriggerConfiguration.h"
42#include "AliTriggerRunScalers.h"
43
3dedb44a 44#include "AliCDBMetaData.h"
45#include "AliLog.h"
46
3dedb44a 47class AliDCSValue;
48class AliShuttleInterface;
49
1e27bb6b 50// needed for ReceivePromptRecoParameters
39e3007b 51
1e27bb6b 52#include <TSQLServer.h>
53#include <TSQLResult.h>
54#include <TSQLRow.h>
55#include <AliCDBManager.h>
56#include <AliCDBMetaData.h>
57#include <AliCDBId.h>
58#include <AliTriggerConfiguration.h>
59
17984b61 60const Double_t kFitFraction = 0.7; // Fraction of DCS sensor fits required
61
3dedb44a 62ClassImp(AliGRPPreprocessor)
63
64//_______________________________________________________________
44e45fac 65
132a16a1 66 const Int_t AliGRPPreprocessor::fgknDAQLbPar = 8; // num parameters in the logbook for PHYSICS runs, when beamType from DAQ logbook == NULL
e75e6e01 67 const Int_t AliGRPPreprocessor::fgknDAQLbParReduced = 7; // num parameters in the logbook for the other cases
44e45fac 68 const Int_t AliGRPPreprocessor::fgknDCSDP = 50; // number of dcs dps
39e3007b 69 const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40; // number of dcs dps
e7a6790f 70 const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
1676baf1 71 "LHCState", // missing in DCS
e7a6790f 72 "L3Polarity",
73 "DipolePolarity",
1676baf1 74 "LHCLuminosity", // missing in DCS
75 "BeamIntensity", // missing in DCS
e7a6790f 76 "L3Current",
77 "DipoleCurrent",
44e45fac 78 "L3_BSF17_H1",
79 "L3_BSF17_H2",
80 "L3_BSF17_H3",
81 "L3_BSF17_Temperature",
82 "L3_BSF4_H1",
83 "L3_BSF4_H2",
84 "L3_BSF4_H3",
85 "L3_BSF4_Temperature",
86 "L3_BKF17_H1",
87 "L3_BKF17_H2",
88 "L3_BKF17_H3",
89 "L3_BKF17_Temperature",
90 "L3_BKF4_H1",
91 "L3_BKF4_H2",
92 "L3_BKF4_H3",
93 "L3_BKF4_Temperature",
94 "L3_BSF13_H1",
95 "L3_BSF13_H2",
96 "L3_BSF13_H3",
97 "L3_BSF13_Temperature",
98 "L3_BSF8_H1",
99 "L3_BSF8_H2",
100 "L3_BSF8_H3",
101 "L3_BSF8_Temperature",
102 "L3_BKF13_H1",
103 "L3_BKF13_H2",
104 "L3_BKF13_H3",
105 "L3_BKF13_Temperature",
106 "L3_BKF8_H1",
107 "L3_BKF8_H2",
108 "L3_BKF8_H3",
109 "L3_BKF8_Temperature",
110 "Dipole_Inside_H1",
111 "Dipole_Inside_H2",
112 "Dipole_Inside_H3",
113 "Dipole_Inside_Temperature",
114 "Dipole_Outside_H1",
115 "Dipole_Outside_H2",
116 "Dipole_Outside_H3",
117 "Dipole_Outside_Temperature",
e7a6790f 118 "CavernTemperature",
119 "CavernAtmosPressure",
6240e6a4 120 "SurfaceAtmosPressure"
e7a6790f 121 };
44e45fac 122
39e3007b 123 const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
44e45fac 124 "L3_BSF17_H1",
125 "L3_BSF17_H2",
126 "L3_BSF17_H3",
127 "L3_BSF17_Temperature",
128 "L3_BSF4_H1",
129 "L3_BSF4_H2",
130 "L3_BSF4_H3",
131 "L3_BSF4_Temperature",
132 "L3_BKF17_H1",
133 "L3_BKF17_H2",
134 "L3_BKF17_H3",
135 "L3_BKF17_Temperature",
136 "L3_BKF4_H1",
137 "L3_BKF4_H2",
138 "L3_BKF4_H3",
139 "L3_BKF4_Temperature",
140 "L3_BSF13_H1",
141 "L3_BSF13_H2",
142 "L3_BSF13_H3",
143 "L3_BSF13_Temperature",
144 "L3_BSF8_H1",
145 "L3_BSF8_H2",
146 "L3_BSF8_H3",
147 "L3_BSF8_Temperature",
148 "L3_BKF13_H1",
149 "L3_BKF13_H2",
150 "L3_BKF13_H3",
151 "L3_BKF13_Temperature",
152 "L3_BKF8_H1",
153 "L3_BKF8_H2",
154 "L3_BKF8_H3",
155 "L3_BKF8_Temperature",
156 "Dipole_Inside_H1",
157 "Dipole_Inside_H2",
158 "Dipole_Inside_H3",
159 "Dipole_Inside_Temperature",
160 "Dipole_Outside_H1",
161 "Dipole_Outside_H2",
162 "Dipole_Outside_H3",
163 "Dipole_Outside_Temperature",
164 };
e7a6790f 165
44e45fac 166 const Short_t kSensors = 48; // start index position of sensor in DCS DPs
167 const Short_t kNumSensors = 2; // Number of sensors in DCS DPs
e7a6790f 168
169 const char* AliGRPPreprocessor::fgkLHCState[20] = {
170 "P", "PREPARE",
171 "J", "PREINJECTION",
172 "I", "INJECTION",
173 "F", "FILLING",
174 "A", "ADJUST",
175 "U", "UNSTABLE BEAMS",
176 "S", "STABLE BEAMS",
177 "D", "BEAM DUMP",
178 "R", "RECOVER",
179 "C", "PRECYCLE"
180 };
181
182 const char* kppError[] = {
183 "",
184 "(DAQ logbook ERROR)",
185 "(DAQ FXS ERROR)",
161a4dc3 186 "(Trigger Scalers not found in DCS FXS - ERROR)",
7e1a6c0b 187 "(DCS data points ERROR)",
e75e6e01 188 "(Trigger Configuration ERROR)",
189 "(DAQ logbook ERROR determining partition of the run)"
e7a6790f 190 };
17984b61 191
192//_______________________________________________________________
44e45fac 193
3dedb44a 194AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
fe726709 195 AliPreprocessor("GRP",shuttle), fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0)
e7a6790f 196{
44e45fac 197 // constructor - shuttle must be instantiated!
ad103e84 198
7eaa854b 199 AddRunType("COSMIC");
200 AddRunType("LASER");
44e45fac 201 AddRunType("PHYSICS");
c2ad5069 202 AddRunType("CALIBRATION_BC");
203 AddRunType("CALIBRATION_CENTRAL");
204 AddRunType("CALIBRATION_EMD");
205 AddRunType("CALIBRATION_MB");
206 AddRunType("CALIBRATION_SEMICENTRAL");
69bf9b19 207 AddRunType("CALIBRATION");
208 AddRunType("PEDESTAL");
7be24dea 209 AddRunType("STANDALONE");
210 AddRunType("GAIN");
3242245e 211 AddRunType("NOISE");
212 AddRunType("PULSER");
b7a928fe 213 AddRunType("STANDALONE_PULSER");
fe726709 214
215 fmaxFloat = FLT_MAX;
216 fminFloat = -FLT_MAX;
217 fmaxDouble = DBL_MAX;
218 fminDouble = -DBL_MAX;
219 fmaxInt = kMaxInt;
220 fminInt = kMinInt;
221 fmaxUInt = kMaxUInt;
222 fminUInt = 0;
223
224 AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
225 AliInfo(Form("Min allowed float = %6.5e",fminFloat));
226 AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
227 AliInfo(Form("Min allowed double = %6.5e",fminDouble));
228 AliInfo(Form("Max allowed integer = %d",fmaxInt));
229 AliInfo(Form("Min allowed integer = %d",fminInt));
230 AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
231 AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
232
3dedb44a 233}
234
235//_______________________________________________________________
44e45fac 236
e7a6790f 237AliGRPPreprocessor::~AliGRPPreprocessor()
238{
44e45fac 239 //destructor
240
241 delete fPressure;
3dedb44a 242}
243
244//_______________________________________________________________
44e45fac 245
e7a6790f 246void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
247{
3dedb44a 248 // Initialize preprocessor
5a5052e5 249
250 AliPreprocessor::Initialize(run, startTime, endTime);
e7a6790f 251
17984b61 252 AliInfo("Initialization of the GRP preprocessor.");
fe726709 253 AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
254 AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
6240e6a4 255 TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
256 for(Int_t j = 0; j < kNumSensors; j++) {
17984b61 257 AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
e7a6790f 258 sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
17984b61 259 }
260 AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
261
563f2a84 262 fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
3dedb44a 263}
264
265//_______________________________________________________________
44e45fac 266
e7a6790f 267UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
268{
44e45fac 269 // process data retrieved by the Shuttle
270
e75e6e01 271 // retrieving "partition" and "detector" fields from DAQ logbook to
272 // determine the partition in which the run was taken
273 // the partition is used to decide how to react in case of errors for CTP
274
275 TString partition = (TString)GetRunParameter("partition");
276 TString detector = (TString)GetRunParameter("detector");
277
44e45fac 278 AliGRPObject *grpobj = new AliGRPObject(); // object to store data
279
280 //=================//
281 // DAQ logbook //
282 //=================//
283 UInt_t error = 0;
284
e75e6e01 285 Int_t iDaqLB = ProcessDaqLB(grpobj);
286 TString runType = (TString)GetRunType();
287 TString beamType = (TString)GetRunParameter("beamType");
132a16a1 288 //if((runType == "PHYSICS" && iDaqLB == fgknDAQLbPar && beamType!="Cosmics") || (runType == "PHYSICS" && iDaqLB == fgknDAQLbParReduced && beamType=="Cosmics") || (runType != "PHYSICS" && iDaqLB == fgknDAQLbParReduced)) {
289 if((runType == "PHYSICS" && iDaqLB == fgknDAQLbPar && !beamType.IsNull()) || (runType == "PHYSICS" && iDaqLB == fgknDAQLbParReduced && beamType.IsNull()) || (runType != "PHYSICS" && iDaqLB == fgknDAQLbParReduced)) {
e75e6e01 290 Log(Form("DAQ Logbook, successful!"));
291 } else {
292 Log(Form("DAQ Logbook, could not get all expected entries!!!"));
293 error |= 1;
294 }
44e45fac 295
296 //=================//
297 // DAQ FXS //
298 //=================//
299 UInt_t iDaqFxs = ProcessDaqFxs();
300 if( iDaqFxs == 0 ) {
301 Log(Form("DAQ FXS, successful!"));
302 } else {
303 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
304 error |= 2;
305 }
306
307 //=================//
308 // DCS FXS //
309 //=================//
e75e6e01 310 UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
44e45fac 311 if( iDcsFxs == 0 ) {
312 Log(Form("DCS FXS, successful!"));
e75e6e01 313 } else if (iDcsFxs ==1) {
76820ec2 314 Log(Form("DCS FXS, Could not store CTP scalers!!!"));
44e45fac 315 error |= 4;
e75e6e01 316 } else{
317 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
318 error |= 32;
44e45fac 319 }
320
321 //=================//
322 // DCS data points //
323 //=================//
7e6f5523 324 Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
44e45fac 325 Int_t entries = ProcessDcsDPs( valueMap, grpobj );
fe726709 326 Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-4));
24c16c5d 327 if( entries < fgknDCSDP-4 ) { // FIXME (!= ) LHState, LHCLuminosity, BeamIntensity, LH3_BSF4_H3 are not working yet...
fe726709 328 Log(Form("Problem with the DCS data points!!! Only %d/%d entries found",entries,fgknDCSDP-4));
44e45fac 329 error |= 8;
330 } else Log(Form("DCS data points, successful!"));
331
332 //=======================//
333 // Trigger Configuration //
334 //=======================//
e75e6e01 335
44e45fac 336 const char * triggerConf = GetTriggerConfiguration();
e75e6e01 337
338 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
339 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
340 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
341 if (!cdbEntry) {
342 Log(Form("No dummy CTP configuration entry found, going into error..."));
44e45fac 343 error |= 16;
344 }
e75e6e01 345 else{
346 AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
347 if (!runcfg){
348 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
44e45fac 349 error |= 16;
350 }
e75e6e01 351 else {
352 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
353 runcfg->SetTitle(titleCTPcfg);
354 AliCDBMetaData metaData;
355 metaData.SetResponsible("Roman Lietava");
356 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
357 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
358 Log("Unable to store the dummy CTP run configuration object to OCDB!");
359 error |= 16;
360 }
361 }
44e45fac 362 }
363 }
a453acbf 364
e75e6e01 365 else if (!partition.IsNull() && detector.IsNull()){ // global partition
366 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
367 if (triggerConf!= NULL) {
368 Log("Found trigger configuration in DAQ logbook");
369 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
44e45fac 370 if (!runcfg) {
e75e6e01 371 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
372 error |= 16;
44e45fac 373 }
374 else {
e75e6e01 375 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
44e45fac 376 runcfg->SetTitle(titleCTPcfg);
377 AliCDBMetaData metaData;
378 metaData.SetBeamPeriod(0);
379 metaData.SetResponsible("Roman Lietava");
e75e6e01 380 metaData.SetComment("CTP run configuration from DAQ logbook");
44e45fac 381 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
382 Log("Unable to store the CTP run configuration object to OCDB!");
383 error |= 16;
384 }
385 }
386 }
e75e6e01 387
388 else {
389 Log("Trigger configuration NULL in DAQ logbook");
390 error |= 16;
391 }
392 }
393
394 else {
395 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
396 error |= 32;
44e45fac 397 }
e75e6e01 398
399 // storing AliGRPObject in OCDB
400
44e45fac 401 AliCDBMetaData md;
15a700f5 402 md.SetResponsible("Chiara Zampolli");
44e45fac 403 md.SetComment("Output parameters from the GRP preprocessor.");
404
405 Bool_t result = kTRUE;
44e45fac 406 result = Store("GRP", "Data", grpobj, &md);
407 delete grpobj;
408
409 if (result && !error ) {
410 Log("GRP Preprocessor Success");
411 return 0;
412 } else {
e75e6e01 413 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s",
44e45fac 414 kppError[(error&1)?1:0],
415 kppError[(error&2)?2:0],
416 kppError[(error&4)?3:0],
417 kppError[(error&8)?4:0],
e75e6e01 418 kppError[(error&16)?5:0],
419 kppError[(error&32)?6:0]
44e45fac 420 ));
421 return error;
422 }
17984b61 423}
424
425//_______________________________________________________________
17984b61 426
e75e6e01 427Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
44e45fac 428{
429 //Getting the DAQ lb information
430
e75e6e01 431 time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
432 time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
433 Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
44e45fac 434 TString beamType = (TString)GetRunParameter("beamType");
435 Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
e75e6e01 436 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
44e45fac 437 TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
438 TString runType = (TString)GetRunType();
439
e75e6e01 440 UInt_t nparameter = 0;
44e45fac 441 if (timeStart != 0){
442 grpObj->SetTimeStart(timeStart);
443 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
e75e6e01 444 nparameter++;
44e45fac 445 }
446 else {
447 Log(Form("Start time not put in logbook, setting to invalid in GRP entry!"));
448 }
449
450 if (timeEnd != 0){
451 grpObj->SetTimeEnd(timeEnd);
452 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
e75e6e01 453 nparameter++;
44e45fac 454 }
455 else {
456 Log(Form("End time not put in logbook, setting to invalid in GRP entry!"));
457 }
458
459 if (beamEnergy != 0){
460 grpObj->SetBeamEnergy(beamEnergy);
461 Log(Form("Beam Energy for run %d: %f",fRun, beamEnergy));
132a16a1 462 //if ((runType == "PHYSICS" && beamType!="Cosmics")){
463 if ((runType == "PHYSICS" && !beamType.IsNull())){ // if beamType is NOT Null, then we're not in a Cosmics run
464 nparameter++; // increasing nparameters only in case we're in PHYSICS runs with beamType != NULL
e75e6e01 465 }
44e45fac 466 }
467 else {
132a16a1 468 //if ((runType == "PHYSICS" && beamType!="Cosmics")){
469 if ((runType == "PHYSICS" && !beamType.IsNull())){ // if beamType is NOT Null, then we're not in a Cosmics run
e75e6e01 470 Log(Form("Beam Energy not put in logbook, setting to invalid in GRP entry, and producing an error (beamType = %s, runType = %s)",beamType.Data(), runType.Data()));
471 }
472 else{
132a16a1 473 Log(Form("Beam Energy not put in logbook, setting to invalid in GRP entry, but not producing any error (beamType = NULL, runType = %s)", runType.Data()));
e75e6e01 474 }
44e45fac 475 }
476
44e45fac 477
478 if (beamType.Length() != 0){
479 grpObj->SetBeamType(beamType);
480 Log(Form("Beam Type for run %d: %s",fRun, beamType.Data()));
e75e6e01 481 nparameter++;
44e45fac 482 }
483 else {
132a16a1 484 Log(Form("Beam Type not put in logbook, setting to invalid in GRP entry! Not producing any error, considering this as a Cosmics run"));
485 nparameter++;
44e45fac 486 }
487
488 if (numberOfDetectors != 0){
489 grpObj->SetNumberOfDetectors(numberOfDetectors);
490 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
e75e6e01 491 nparameter++;
44e45fac 492 }
493 else {
494 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry!"));
495 }
496
497 if (detectorMask != 0){
498 grpObj->SetDetectorMask(detectorMask);
499 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
e75e6e01 500 nparameter++;
44e45fac 501 }
502 else {
503 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry!"));
504 }
505
506 if (lhcPeriod.Length() != 0) {
507 grpObj->SetLHCPeriod(lhcPeriod);
508 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
e75e6e01 509 nparameter++;
510 }
511 else {
44e45fac 512 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry!"));
513 }
514 if (runType.Length() != 0) {
515 grpObj->SetRunType(runType);
516 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
e75e6e01 517 nparameter++;
518 }
519 else {
44e45fac 520 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry!"));
521 }
522
e75e6e01 523 return nparameter;
44e45fac 524}
17984b61 525
44e45fac 526//_______________________________________________________________
17984b61 527
44e45fac 528UInt_t AliGRPPreprocessor::ProcessDaqFxs()
529{
530 //======DAQ FXS======//
531
ea4a87ee 532 AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
44e45fac 533 TList* list = GetFileSources(kDAQ);
534 if (!list) {
535 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
536 return 1;
537 }
538
539 if (list->GetEntries() == 0) {
540 Log("no raw data tags in this run: nothing to merge!");
541 delete list; list=0;
542 return 0;
543 }
544
545 TChain *fRawTagChain = new TChain("T");
546 Int_t nFiles=0;
547 TIterator* iter = list->MakeIterator();
548 TObject* obj = 0;
549 while ((obj = iter->Next())) {
550 TObjString* objStr = dynamic_cast<TObjString*> (obj);
551 if (objStr) {
552 Log(Form("Found source %s", objStr->String().Data()));
553 TList* list2 = GetFileIDs(kDAQ, objStr->String());
554 if (!list2) {
555 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
556 delete fRawTagChain; fRawTagChain=0;
557 return 1;
558 }
559 Log(Form("Number of ids: %d",list2->GetEntries()));
560 for(Int_t i = 0; i < list2->GetEntries(); i++) {
561 TObjString *idStr = (TObjString *)list2->At(i);
562 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
563 if (fileName.Length() > 0) {
564 Log(Form("Adding file in the chain: %s",fileName.Data()));
565 fRawTagChain->Add(fileName.Data());
566 nFiles++;
567 } else {
568 Log(Form("Could not retrieve file with id %s from source %s: "
569 "connection problems with DAQ FXS!",
570 idStr->String().Data(), objStr->String().Data()));
571 delete list; list=0;
572 delete list2; list2=0;
573 delete fRawTagChain; fRawTagChain=0;
574 return 2;
575 }
576 }
577 delete list2;
578 }
579 }
580
581 TString fRawDataFileName = "GRP_Merged.tag.root";
582 Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
7e6f5523 583
44e45fac 584 if( fRawTagChain->Merge(fRawDataFileName) < 1 ) {
585 Log("Error merging raw data files!!!");
586 return 3;
587 }
7e6f5523 588
44e45fac 589 TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
590 Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
591
592 if (!result) {
593 Log("Problem storing raw data tags in local file!!!");
594 } else {
595 Log("Raw data tags merged successfully!!");
596 }
597
598 delete iter;
599 delete list;
600 delete fRawTagChain; fRawTagChain=0;
601
602 if (result == kFALSE) {
603 return 4;
604 }
605
606 return 0;
607
608}
17984b61 609
44e45fac 610//_______________________________________________________________
e75e6e01 611UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
44e45fac 612{
39e3007b 613
614 // processing the info
615 // stored in the DCS FXS
616 // coming from the trigger
617
e75e6e01 618 // Get the CTP counters information
619
620 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
161a4dc3 621 Log("STANDALONE partition for current run, using Trigger Scalers dummy value");
e75e6e01 622 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyScalers");
623 if (!cdbEntry) {
624 Log(Form("No dummy CTP scalers entry found, going into error..."));
44e45fac 625 return 1;
626 }
e75e6e01 627 else{
628 AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntry->GetObject();
629 if (!scalers){
630 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
631 return 1;
632 }
633 else {
634 AliCDBMetaData metaData;
635 metaData.SetResponsible("Roman Lietava");
636 metaData.SetComment("CTP scalers from dummy entry in OCDB");
637 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
638 Log("Unable to store the dummy CTP scalers object to OCDB!");
639 return 1;
640 }
641 }
642 }
643 }
644
645 else if (!partition.IsNull() && detector.IsNull()){ // global partition
646 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
647 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
648 if (countersfile.IsNull()) {
649 Log("No CTP counters files has been found: empty source!");
44e45fac 650 return 1;
651 }
652 else {
e75e6e01 653 Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
654 AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
655 if (!scalers) {
656 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
657 return 1;
658 }
659 else {
660 AliCDBMetaData metaData;
661 metaData.SetBeamPeriod(0);
662 metaData.SetResponsible("Roman Lietava");
663 metaData.SetComment("CTP scalers");
664 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
665 Log("Unable to store the CTP scalers object to OCDB!");
666 return 1;
44e45fac 667 }
668 }
669 }
44e45fac 670 }
671
e75e6e01 672
673 else{
674 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
675 return 2;
676 }
677
44e45fac 678 return 0;
e75e6e01 679
44e45fac 680}
681//_______________________________________________________________
17984b61 682
44e45fac 683Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
684{
17984b61 685
44e45fac 686 //
687 // processing DCS DPs
688 //
689
26c1dff2 690 Int_t entries = 0; // counting the entries that are in the DCS DB, not taking care whether they have values or not
44e45fac 691 Int_t nLHCEntries = 0;
692 Int_t nL3Entries = 0;
693 Int_t nDipoleEntries = 0;
694 Int_t nEnvEntries = 0;
695 Int_t nHallProbesEntries = 0;
696 nLHCEntries = ProcessLHCDPs(valueMap, grpObj);
697 nL3Entries = ProcessL3DPs(valueMap, grpObj);
698 nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
699 nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
700 nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
fab61587 701 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
44e45fac 702 entries = nLHCEntries + nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
703 return entries;
17984b61 704
17984b61 705}
706
707//_______________________________________________________________
29cc8704 708
39e3007b 709Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 710{
39e3007b 711
712 // processing DPs
713 // related to
714 // L3 info
715
44e45fac 716 Int_t nL3Entries = 0;
717 TObjArray *array = 0x0;
718 Int_t indexDP = -1;
fe726709 719 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
44e45fac 720
fe726709 721 AliInfo(Form("==========L3Current==========="));
722 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
723 indexDP = kL3Current;
44e45fac 724 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
725 if(!array) {
726 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
727 }
728 else {
26c1dff2 729 if (array->GetEntries() == 0){
fe726709 730 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
26c1dff2 731 }
732 else {
fe726709 733 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
734 if (floatDCS != NULL){
735 grpObj->SetL3Current(floatDCS);
736 }
737 else{
738 outOfRange = kTRUE;
739 }
03672227 740 if (floatDCS){
741 delete[] floatDCS;
742 floatDCS = 0x0;
743 }
26c1dff2 744 }
fe726709 745 if (!outOfRange) nL3Entries++;
44e45fac 746 }
747
748 if (array) array = 0x0;
749
fe726709 750 AliInfo(Form("==========L3Polarity==========="));
751 indexDP = kL3Polarity;
44e45fac 752 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
753 if(!array) {
754 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
755 }
756 else {
26c1dff2 757 if (array->GetEntries() == 0){
fe726709 758 AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
26c1dff2 759 }
760 else {
fe726709 761 Bool_t change = kFALSE;
762 Char_t charDCS = ProcessBool(array,change);
01920f0c 763 if (change == kFALSE){
fe726709 764 grpObj->SetL3Polarity(charDCS);
765 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
766 nL3Entries++;
767 }
768 else if (isZero){
ac833e7a 769 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
fe726709 770 nL3Entries++;
771 }
772 else {
ac833e7a 773 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]));
fe726709 774 }
26c1dff2 775 }
44e45fac 776 }
777
778 return nL3Entries;
e7a6790f 779
44e45fac 780}
781//_______________________________________________________________
ff97356e 782
39e3007b 783Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 784{
39e3007b 785 // processing DPs
786 // related to
787 // the Dipole info
788
44e45fac 789 Int_t nDipoleEntries = 0;
790 TObjArray *array = 0x0;
791 Int_t indexDP = -1;
fe726709 792 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
44e45fac 793
fe726709 794 AliInfo(Form("==========DipoleCurrent==========="));
795 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
796 indexDP = kDipoleCurrent;
44e45fac 797 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
44e45fac 798 if(!array) {
799 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
800 }
801 else {
26c1dff2 802 if (array->GetEntries() == 0){
803 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
804 }
805 else {
fe726709 806 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
807 if (floatDCS != NULL){
808 grpObj->SetDipoleCurrent(floatDCS);
809 }
810 else{
811 outOfRange=kTRUE;
812 }
03672227 813 if (floatDCS){
814 delete[] floatDCS;
815 floatDCS = 0x0;
816 }
26c1dff2 817 }
fe726709 818 if (!outOfRange) nDipoleEntries++;
44e45fac 819 }
820
821 if (array) array = 0x0;
822
fe726709 823 AliInfo(Form("==========DipolePolarity==========="));
824 indexDP = kDipolePolarity;
44e45fac 825 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
826 if(!array) {
827 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
828 }
829 else {
26c1dff2 830 if (array->GetEntries() == 0){
831 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
832 }
833 else {
fe726709 834 Bool_t change = kFALSE;
835 Char_t charDCS = ProcessBool(array,change);
836 if (!change){
837 grpObj->SetDipolePolarity(charDCS);
838 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
839 nDipoleEntries++;
840 }
841 else if (isZero){
ac833e7a 842 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
fe726709 843 nDipoleEntries++;
844 }
845 else{
ac833e7a 846 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]));
fe726709 847 }
26c1dff2 848 }
44e45fac 849 }
850
851 return nDipoleEntries;
e7a6790f 852
44e45fac 853}
854//_______________________________________________________________
e7a6790f 855
44e45fac 856Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
857{
39e3007b 858 // processing DPs
859 // related to
860 // evironment conditions (temperature, pressure) info
861
44e45fac 862 Int_t nEnvEntries = 0;
863 TObjArray *array = 0x0;
864 Int_t indexDP = -1;
865
866 AliInfo(Form("==========CavernTemperature==========="));
fe726709 867 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
44e45fac 868 indexDP = kCavernTemperature;
869 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
870 if(!array) {
871 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
872 }
873 else {
26c1dff2 874 if (array->GetEntries() == 0){
875 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
876 }
877 else {
878 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 879 if (floatDCS != NULL){
880 grpObj->SetCavernTemperature(floatDCS);
881 }
882 else{
883 outOfRange = kTRUE;
884 }
03672227 885 if (floatDCS){
886 delete[] floatDCS;
887 floatDCS = 0x0;
888 }
26c1dff2 889 }
fe726709 890 if (!outOfRange) nEnvEntries++;
44e45fac 891 }
892
893 if (array) array = 0x0;
894
895 AliInfo(Form("==========AtmosPressures (Cavern + Surface)==========="));
896 AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
897 dcsSensorArray->Print();
44e45fac 898 if( fPressure->NumFits()==0 ) {
899 Log("Problem with the pressure sensor values!!!");
900 }
901 else {
902 AliInfo(Form("==========CavernAtmosPressure==========="));
903 indexDP = kCavernAtmosPressure;
904 AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
905 AliDebug(2,Form("sensorCavernP2 = %p", sensorCavernP2));
906 if( sensorCavernP2->GetFit() ) {
907 Log(Form("<%s> for run %d: Sensor Fit found",fgkDCSDataPoints[indexDP], fRun));
908 grpObj->SetCavernAtmosPressure(sensorCavernP2);
909 nEnvEntries++;
910 }
911 //if (sensorP2) delete sensorP2;
912 else {
ac833e7a 913 Log(Form("ERROR Sensor Fit for %s not found ", fgkDCSDataPoints[indexDP] ));
44e45fac 914 }
915 AliInfo(Form("==========SurfaceAtmosPressure==========="));
916 indexDP = kSurfaceAtmosPressure;
917 AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
918 AliDebug(2,Form("sensorP2 = %p", sensorP2));
919 if( sensorP2->GetFit() ) {
920 Log(Form("<%s> for run %d: Sensor Fit found",fgkDCSDataPoints[indexDP], fRun));
921 grpObj->SetSurfaceAtmosPressure(sensorP2);
922 nEnvEntries++;
923 }
924 //if (sensorP2) delete sensorP2;
925 else {
ac833e7a 926 Log(Form("ERROR Sensor Fit for %s not found ", fgkDCSDataPoints[indexDP] ));
44e45fac 927 }
928
929 }
930
44e45fac 931 return nEnvEntries;
932}
933//_______________________________________________________________
e7a6790f 934
39e3007b 935Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 936{
39e3007b 937 // processing DPs
938 // related to
939 // Hall Probes info
940
44e45fac 941 Int_t nHPEntries = 0;
942 TObjArray *array = 0x0;
943 Int_t indexDP = -1;
fe726709 944 Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
44e45fac 945
39e3007b 946 if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
947 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()));
44e45fac 948 }
949 for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
fe726709 950 outOfRange = kFALSE; // resetting outOfRange flag at each HP
44e45fac 951 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
952 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
953 if(!array) {
954 Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
955 }
956 else {
26c1dff2 957 if (array->GetEntries() == 0){
958 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
959 }
960 else {
961 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 962 if (floatDCS != NULL){
963 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]));
964 grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
965 for (Int_t kk = 0 ; kk< 5; kk++){
966 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
967 }
968 }
969 else{
970 outOfRange = kTRUE;
26c1dff2 971 }
03672227 972 if (floatDCS){
973 delete[] floatDCS;
974 floatDCS = 0x0;
975 }
44e45fac 976 }
fe726709 977 if (!outOfRange) nHPEntries++;
44e45fac 978 }
979 }
980
7e6f5523 981 Log(Form("Hall Probes = %d ", nHPEntries));
982 return nHPEntries;
17984b61 983}
984
985//_______________________________________________________________
44e45fac 986
39e3007b 987Int_t AliGRPPreprocessor::ProcessLHCDPs(const TMap* valueMap, AliGRPObject* grpObj)
e7a6790f 988{
48b1b444 989
44e45fac 990 //
991 // processing of LHC related DCS DPs, i.e.:
992 // LHCState
993 // LHCLuminosity
994 // BeamIntensity
995 //
996
997 Int_t nLHCEntries = 0;
998 TObjArray *array = 0x0;
999 Int_t indexDP = -1;
1000
1001 AliInfo(Form("==========LHCState==========="));
1002 indexDP = kLHCState;
1003 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1004 if(!array) {
1005 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1006 }
1007 else {
26c1dff2 1008 if (array->GetEntries() == 0){
1009 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1010 }
1011 else {
1012 TString stringDCS = ProcessChar(array);
1013 if (stringDCS.Length()!=0) {
1014 Bool_t found = kFALSE;
1015 for( Int_t i=0; i<20; i+=2 ) {
1016 if( stringDCS.CompareTo(fgkLHCState[i]) == 0 ) {
1017 stringDCS = fgkLHCState[i+1];
1018 found = kTRUE;
1019 break;
1020 }
44e45fac 1021 }
26c1dff2 1022 if (found){
1023 Log(Form("<%s> for run %d: %s",fgkDCSDataPoints[indexDP],fRun, stringDCS.Data()));
1024 grpObj->SetLHCState(stringDCS);
1025 }
1026 else{
1027 Log(Form("%s values found not valid!",fgkDCSDataPoints[indexDP]));
1028 grpObj->SetLHCState(AliGRPObject::GetInvalidString());
1029 }
44e45fac 1030 }
26c1dff2 1031 else {
1032 Log(Form("%s not valid (null length), string set as invalid!",fgkDCSDataPoints[indexDP]));
44e45fac 1033 grpObj->SetLHCState(AliGRPObject::GetInvalidString());
26c1dff2 1034 }
44e45fac 1035 }
44e45fac 1036 nLHCEntries++;
1037 }
1038
1039 if (array) array = 0x0;
1040
1041 AliInfo(Form("==========LHCLuminosity==========="));
fe726709 1042 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
44e45fac 1043 indexDP = kLHCLuminosity;
1044 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1045 if(!array) {
1046 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1047 }
1048 else {
26c1dff2 1049 if (array->GetEntries() == 0){
1050 AliError(Form("No entries found in array! setting %s and its Spline Fit to invalid...",fgkDCSDataPoints[indexDP]));
1051 }
1052 else {
1053 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 1054 if (floatDCS != NULL){
1055 grpObj->SetLHCLuminosity(floatDCS);
1056 AliSplineFit* splfit = GetSplineFit(array,fgkDCSDataPoints[indexDP]);
1057 grpObj->SetLHCLuminositySplineFit(splfit);
26c1dff2 1058 // delete splfit;
fe726709 1059 }
1060 else {
1061 outOfRange = kTRUE;
1062 }
03672227 1063 if (floatDCS){
1064 delete[] floatDCS;
1065 floatDCS = 0x0;
1066 }
26c1dff2 1067 }
fe726709 1068 if (!outOfRange) nLHCEntries++;
44e45fac 1069 }
1070
1071 if (array) array = 0x0;
1072
1073 AliInfo(Form("==========BeamIntensity==========="));
fe726709 1074 if (outOfRange) outOfRange = kFALSE; // resetting outOfRange if needed
44e45fac 1075 indexDP = kBeamIntensity;
1076 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1077 if(!array) {
1078 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1079 }
1080 else {
26c1dff2 1081 if (array->GetEntries() == 0){
1082 AliError(Form("No entries found in array! setting %s and its Spline Fit to invalid...",fgkDCSDataPoints[indexDP]));
1083 }
1084 else {
1085 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 1086 if (floatDCS != NULL){
1087 grpObj->SetBeamIntensity(floatDCS);
1088 AliSplineFit* splfit1 = GetSplineFit(array,fgkDCSDataPoints[indexDP]);
1089 grpObj->SetBeamIntensitySplineFit(splfit1);
1090 //delete splfit;
1091 }
1092 else{
1093 outOfRange = kTRUE;
1094 }
03672227 1095 if (floatDCS){
1096 delete[] floatDCS;
1097 floatDCS = 0x0;
1098 }
26c1dff2 1099 }
fe726709 1100 if (!outOfRange) nLHCEntries++;
44e45fac 1101 }
1102
1103 return nLHCEntries;
1104}
1105//_________________________________________________________________________
1106
39e3007b 1107AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
1108
1109
1110 //
1111 // returning Spline Fit
1112 //
44e45fac 1113
1114 Int_t entriesarray = array->GetEntries();
1115 Float_t* value = new Float_t[entriesarray];
1116 Float_t* time = new Float_t[entriesarray];
1117 AliDCSValue* v = 0x0;
1118 for (Int_t iarray = 0; iarray < entriesarray; iarray++){
1119 v = (AliDCSValue*)array->At(iarray);
1120 value[iarray] = v->GetFloat();
1121 time[iarray] = v->GetTimeStamp();
e75e6e01 1122 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
44e45fac 1123 }
1124 TGraph* gr = new TGraph(entriesarray,value,time);
1125 if (!gr ) {
1126 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
1127 return NULL;
1128 }
1129 AliSplineFit *fit = new AliSplineFit();
1130 fit->SetMinPoints(10);
1131 fit->InitKnots(gr,10,10,0.0);
1132 fit->SplineFit(2);
1133 fit->Cleanup();
1134 if (!fit) {
1135 AliWarning(Form("%s: no fit performed",stringID.Data()));
1136 return NULL;
1137 }
1138 return fit;
48b1b444 1139}
1140
44e45fac 1141//_________________________________________________________________________
1142
39e3007b 1143TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
e7a6790f 1144{
17984b61 1145
44e45fac 1146 //
1147 // processing char
1148 //
1149
1150 TString aDCSString="";
1151
1152 AliDCSValue *v = 0x0;
1153 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1154 v = (AliDCSValue *)array->At(iCount);
26c1dff2 1155 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1156 AliError(Form("DCS values for the parameter outside the queried interval"));
1157 continue;
1158 }
1159 if (iCount > 0) {
7e6f5523 1160 if (aDCSString != v->GetChar())
44e45fac 1161 AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
1162 }
1163 aDCSString = (TString)v->GetChar(); // keeping always last value in the array
1164 }
1165 return aDCSString;
1166}
e7a6790f 1167
44e45fac 1168//__________________________________________________________________________________________________________________
e7a6790f 1169
39e3007b 1170Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
44e45fac 1171{
1172 //
1173 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1174 //
1175 // parameters[0] = mean
1176 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1177 // parameters[2] = median
1178 // parameters[3] = standard deviation wrt mean
1179 // parameters[4] = standard deviation wrt median
1180 //
1181
5138cd05 1182 Float_t* parameters = new Float_t[5];
44e45fac 1183 Double_t aDCSArrayMean = 0; // Mean
1184 Double_t aDCSArrayTruncMean = 0;// Truncated Mean
1185 Double_t aDCSArrayMedian = 0; // Median
1186 Double_t aDCSArraySDMean = 0; // Standard Deviation wrt Mean
1187 Double_t aDCSArraySDMedian = 0; // Standard Deviation wrt Median
1188 Float_t aDCSArraySum = 0.0;
1189 Int_t iCounts = 0;
1190 Int_t iCounts1 = 0;
1191 Float_t temp = 0;
1192 Float_t temp1 = 0;
1193 Int_t nCounts = array->GetEntries();
1194 Float_t *tempArray = new Float_t[nCounts];
1195 for(Int_t i = 0; i < nCounts; i++) {
1196 AliDCSValue *v = (AliDCSValue *)array->At(i);
fe726709 1197 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1198 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1199 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1200 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1201 return NULL;
1202 }
1203 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
1204 aDCSArraySum += v->GetFloat();
1205 tempArray[i] = v->GetFloat();
1206 AliDebug(2,Form("%d-th entry = %f",i,tempArray[i]));
1207 iCounts += 1;
1208 }
1209 else {
1210 AliError(Form("DCS values for the parameter outside the queried interval"));
1211 }
1212 }
1213
1214 AliDebug(2,Form("Using %i entries, starting from %i entries",iCounts,nCounts));
1215 if(iCounts != 0) {
1216 aDCSArrayMean = TMath::Mean(iCounts,tempArray);
1217 aDCSArrayMedian = TMath::Median(iCounts,tempArray);
1218 aDCSArraySDMean = TMath::RMS(iCounts,tempArray);
1219 AliDebug(2,Form("SD = %f",aDCSArraySDMean));
1220 // computing standard deviation wrt median
1221 AliDebug(2,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1222 for (Int_t i = 0; i < iCounts; i++){
1223 AliDCSValue *v = (AliDCSValue *)array->At(i);
1224 AliDebug(3,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1225 AliDebug(3,Form("%i-th entry = %f",i, v->GetFloat()));
1226 if ((v->GetFloat()<=aDCSArrayMean+3*aDCSArraySDMean) && (v->GetFloat()>=aDCSArrayMean-3*aDCSArraySDMean)){
1227 temp1+=v->GetFloat();
1228 iCounts1++;
1229 AliDebug(3,Form("temp1 = %f, iCounts1 = %i",temp1,iCounts1));
1230 }
1231 temp += (v->GetFloat()-aDCSArrayMedian)*(v->GetFloat()-aDCSArrayMedian);
1232 }
1233 AliDebug(3,Form("temp before the ratio = %f, with %d counts", temp, iCounts));
1234 temp/=iCounts;
1235 AliDebug(3,Form("temp after the ratio = %f", temp));
1236 if (temp>0) {
1237 aDCSArraySDMedian = TMath::Sqrt(temp);
1238 }
1239 else if (temp==0) {
1240 AliInfo(Form("Radical = 0 in computing standard deviation wrt median! Setting it to zero...."));
1241 aDCSArraySDMedian = 0;
1242 }
1243 else{
1244 AliError(Form("Radical < 0 in computing standard deviation! Setting it to invalid...."));
1245 aDCSArraySDMedian = AliGRPObject::GetInvalidFloat();
1246 }
1247 }
1248 else {
1249 aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1250 aDCSArrayMedian = AliGRPObject::GetInvalidFloat();
1251 aDCSArraySDMean = AliGRPObject::GetInvalidFloat();
1252 }
1253 AliDebug(3,Form("iCounts1 = %d and temp1 = %f",iCounts1, temp1));
1254 if (iCounts1 > 0) {
1255 aDCSArrayTruncMean = temp1/iCounts1;
1256 }
1257 else{
1258 aDCSArrayTruncMean = AliGRPObject::GetInvalidFloat();
1259 }
1260
1261
1262
1263 AliDebug(2,Form("mean within %d counts = %f ",iCounts,aDCSArrayMean));
1264 AliDebug(2,Form("truncated mean within %d counts = %f (%i values used)",iCounts,aDCSArrayTruncMean,iCounts1));
1265 AliDebug(2,Form("median within %d counts = %f ",iCounts,aDCSArrayMedian));
1266 AliDebug(2,Form("standard deviation with mean within %d counts = %f ",iCounts,aDCSArraySDMean));
1267 AliDebug(2,Form("standard deviation with median within %d counts = %f ",iCounts,aDCSArraySDMedian));
1268
1269 parameters[0] = aDCSArrayMean;
1270 parameters[1] = aDCSArrayTruncMean;
1271 parameters[2] = aDCSArrayMedian;
1272 parameters[3] = aDCSArraySDMean;
1273 parameters[4] = aDCSArraySDMedian;
1274
1275 AliDebug(2,Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1276 //AliInfo(Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1277
1278 return parameters;
1279}
1280
1281
1282
1283//__________________________________________________________________________________________________________________
1284
1285Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
1286{
1287 //
1288 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1289 // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
ac833e7a 1290 // the flag is set according to the L3/Dipole current value
1291 // current threshold for L3 = 350 A (value provided by DCS)
1292 // current threshold for Dipole = 450 A (value provided by DCS)
fe726709 1293 //
1294 // parameters[0] = mean
1295 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1296 // parameters[2] = median
1297 // parameters[3] = standard deviation wrt mean
1298 // parameters[4] = standard deviation wrt median
1299 //
1300
1301 AliInfo(Form("indexDP = %d",indexDP));
1302 Float_t* parameters = new Float_t[5];
1303 Double_t aDCSArrayMean = 0; // Mean
1304 Double_t aDCSArrayTruncMean = 0;// Truncated Mean
1305 Double_t aDCSArrayMedian = 0; // Median
1306 Double_t aDCSArraySDMean = 0; // Standard Deviation wrt Mean
1307 Double_t aDCSArraySDMedian = 0; // Standard Deviation wrt Median
1308 Float_t aDCSArraySum = 0.0;
1309 Int_t iCounts = 0;
1310 Int_t iCounts1 = 0;
1311 Float_t temp = 0;
1312 Float_t temp1 = 0;
1313 Int_t nCounts = array->GetEntries();
1314 Float_t *tempArray = new Float_t[nCounts];
1315 for(Int_t i = 0; i < nCounts; i++) {
1316 AliDCSValue *v = (AliDCSValue *)array->At(i);
1317 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1318 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
535c05eb 1319 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1320 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
fe726709 1321 return NULL;
1322 }
26c1dff2 1323 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1324 aDCSArraySum += v->GetFloat();
1325 tempArray[i] = v->GetFloat();
1326 AliDebug(2,Form("%d-th entry = %f",i,tempArray[i]));
1327 iCounts += 1;
ac833e7a 1328 if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
1329 if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
fe726709 1330 }
1331 else {
1332 AliError(Form("DCS values for the parameter outside the queried interval"));
44e45fac 1333 }
1334 }
1335
26c1dff2 1336 AliDebug(2,Form("Using %i entries, starting from %i entries",iCounts,nCounts));
44e45fac 1337 if(iCounts != 0) {
26c1dff2 1338 aDCSArrayMean = TMath::Mean(iCounts,tempArray);
1339 aDCSArrayMedian = TMath::Median(iCounts,tempArray);
1340 aDCSArraySDMean = TMath::RMS(iCounts,tempArray);
1341 AliDebug(2,Form("SD = %f",aDCSArraySDMean));
44e45fac 1342 // computing standard deviation wrt median
1343 AliDebug(2,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1344 for (Int_t i = 0; i < iCounts; i++){
1345 AliDCSValue *v = (AliDCSValue *)array->At(i);
fe726709 1346 AliDebug(3,Form("maximum = %f, minimum = %f", aDCSArrayMean+3*aDCSArraySDMean, aDCSArrayMean-3*aDCSArraySDMean));
1347 AliDebug(3,Form("%i-th entry = %f",i, v->GetFloat()));
c135d475 1348 if ((v->GetFloat()<=aDCSArrayMean+3*aDCSArraySDMean) && (v->GetFloat()>=aDCSArrayMean-3*aDCSArraySDMean)){
44e45fac 1349 temp1+=v->GetFloat();
1350 iCounts1++;
fe726709 1351 AliDebug(3,Form("temp1 = %f, iCounts1 = %i",temp1,iCounts1));
44e45fac 1352 }
1353 temp += (v->GetFloat()-aDCSArrayMedian)*(v->GetFloat()-aDCSArrayMedian);
1354 }
c135d475 1355 AliDebug(3,Form("temp before the ratio = %f, with %d counts", temp, iCounts));
44e45fac 1356 temp/=iCounts;
c135d475 1357 AliDebug(3,Form("temp after the ratio = %f", temp));
44e45fac 1358 if (temp>0) {
1359 aDCSArraySDMedian = TMath::Sqrt(temp);
1360 }
c135d475 1361 else if (temp==0) {
1362 AliInfo(Form("Radical = 0 in computing standard deviation wrt median! Setting it to zero...."));
1363 aDCSArraySDMedian = 0;
1364 }
44e45fac 1365 else{
c135d475 1366 AliError(Form("Radical < 0 in computing standard deviation! Setting it to invalid...."));
44e45fac 1367 aDCSArraySDMedian = AliGRPObject::GetInvalidFloat();
1368 }
1369 }
1370 else {
1371 aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1372 aDCSArrayMedian = AliGRPObject::GetInvalidFloat();
1373 aDCSArraySDMean = AliGRPObject::GetInvalidFloat();
1374 }
fe726709 1375 AliDebug(3,Form("iCounts1 = %d and temp1 = %f",iCounts1, temp1));
44e45fac 1376 if (iCounts1 > 0) {
1377 aDCSArrayTruncMean = temp1/iCounts1;
1378 }
1379 else{
1380 aDCSArrayTruncMean = AliGRPObject::GetInvalidFloat();
1381 }
1382
1383
1384
26c1dff2 1385 AliDebug(2,Form("mean within %d counts = %f ",iCounts,aDCSArrayMean));
1386 AliDebug(2,Form("truncated mean within %d counts = %f (%i values used)",iCounts,aDCSArrayTruncMean,iCounts1));
1387 AliDebug(2,Form("median within %d counts = %f ",iCounts,aDCSArrayMedian));
1388 AliDebug(2,Form("standard deviation with mean within %d counts = %f ",iCounts,aDCSArraySDMean));
1389 AliDebug(2,Form("standard deviation with median within %d counts = %f ",iCounts,aDCSArraySDMedian));
44e45fac 1390
1391 parameters[0] = aDCSArrayMean;
1392 parameters[1] = aDCSArrayTruncMean;
1393 parameters[2] = aDCSArrayMedian;
1394 parameters[3] = aDCSArraySDMean;
1395 parameters[4] = aDCSArraySDMedian;
1396
e75e6e01 1397 AliDebug(2,Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
1398 //AliInfo(Form("mean = %f, truncated mean = %f, median = %f, SD wrt mean = %f, SD wrt median = %f ",parameters[0],parameters[1],parameters[2],parameters[3],parameters[4]));
44e45fac 1399
1400 return parameters;
1401}
125567f8 1402
e97cc90e 1403
44e45fac 1404//_______________________________________________________________
e97cc90e 1405
fe726709 1406Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
44e45fac 1407{
1408 //
1409 // processing Boolean values
1410 //
1411
1412 Bool_t aDCSBool = kTRUE;
1413
1414 AliDCSValue *v = 0x0;
26c1dff2 1415
44e45fac 1416 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1417 v = (AliDCSValue *)array->At(iCount);
26c1dff2 1418 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1419 AliError(Form("DCS values for the parameter outside the queried interval"));
1420 continue;
1421 }
1422 if (iCount > 0) {
01920f0c 1423 if (aDCSBool != v->GetBool()) {
1424 AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
1425 change = kTRUE;
1426 }
44e45fac 1427 }
1428 aDCSBool = v->GetBool(); // always keeping last value
26c1dff2 1429 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
44e45fac 1430 }
1431
26c1dff2 1432 Char_t caDCSBool = (Char_t) aDCSBool;
44e45fac 1433 return caDCSBool;
1434
1435}
e97cc90e 1436
44e45fac 1437//_______________________________________________________________
e97cc90e 1438
39e3007b 1439Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
44e45fac 1440{
1441 //
1442 // processing Int values, returning mean
fe726709 1443 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
1444 // are outside the queried time interval or their value is out of range
44e45fac 1445 //
1446
1447 Float_t aDCSArraySum = 0.0;
1448 Float_t aDCSArrayMean = 0.0;
1449 Int_t iCounts = 0;
1450 AliDCSValue* v = 0x0;
1451
1452 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1453 v = (AliDCSValue *)array->At(iCount);
fe726709 1454 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
1455 AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",iCount, v->GetInt()));
1456 return AliGRPObject::GetInvalidFloat();
1457 }
26c1dff2 1458 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1459 aDCSArraySum += v->GetInt();
1460 iCounts += 1;
1461 }
1462 }
1463
1464 if(iCounts != 0) aDCSArrayMean = aDCSArraySum/iCounts;
1465 else aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1466
1467 return aDCSArrayMean;
e97cc90e 1468
44e45fac 1469}
1470//_______________________________________________________________
e7a6790f 1471
39e3007b 1472Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
44e45fac 1473{
1474 //
fe726709 1475 // processing Int values, returning mean
1476 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
1477 // are outside the queried time interval or their value is out of range
44e45fac 1478 //
1479
1480 Float_t aDCSArraySum = 0.0;
1481 Float_t aDCSArrayMean = 0.0;
1482 Int_t iCounts = 0;
1483 AliDCSValue* v = 0x0;
1484
1485 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1486 v = (AliDCSValue *)array->At(iCount);
fe726709 1487 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
1488 AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",iCount,v->GetUInt()));
1489 return AliGRPObject::GetInvalidFloat();
1490 }
26c1dff2 1491 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1492 aDCSArraySum += v->GetUInt();
1493 iCounts += 1;
1494 }
1495 }
1496
1497 if(iCounts != 0) aDCSArrayMean = aDCSArraySum/iCounts;
1498 else aDCSArrayMean = AliGRPObject::GetInvalidFloat();
1499
1500 return aDCSArrayMean;
e7a6790f 1501
17984b61 1502}
125567f8 1503
44e45fac 1504
17984b61 1505//_______________________________________________________________
44e45fac 1506
3ba92a38 1507AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
e7a6790f 1508{
44e45fac 1509 // extract DCS pressure maps. Perform fits to save space
1510
44e45fac 1511 TMap *map = fPressure->ExtractDCS(dcsAliasMap);
1512 if (map) {
1513 fPressure->MakeSplineFit(map);
1514 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
1515 if (fitFraction > kFitFraction ) {
1516 AliInfo(Form("Pressure values extracted, %d fits performed.", fPressure->NumFits()));
1517 } else {
1518 AliInfo("Too few pressure maps fitted!!!");
1519 }
1520 } else {
1521 AliInfo("no atmospheric pressure map extracted!!!");
1522 }
1523 delete map;
1524
1525 return fPressure;
17984b61 1526}
e97cc90e 1527
1e27bb6b 1528
1529
1530//_______________________________________________________________
03e5ee4f 1531Int_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)
1e27bb6b 1532{
44e45fac 1533 //
1534 // Retrieves logbook and trigger information from the online logbook
1535 // This information is needed for prompt reconstruction
1536 //
1537 // Parameters are:
1538 // Run number
1539 // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
1540 // cdbRoot
1541 //
1542 // returns:
1543 // positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
1544 // 0 on success and no run was found
1545 // negative on error
1546 //
1547 // This function is NOT called during the preprocessor run in the Shuttle!
1548 //
1549
1550 // defaults
1551 if (dbPort == 0)
1552 dbPort = 3306;
1553
1554 // CDB connection
1555 AliCDBManager* cdb = AliCDBManager::Instance();
1556 cdb->SetDefaultStorage(cdbRoot);
1557
1558 // SQL connection
1559 TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
1560
1561 if (!server)
1562 {
1563 Printf("ERROR: Could not connect to DAQ LB");
1564 return -1;
1565 }
1566
1567 // main logbook
1568 TString sqlQuery;
26c1dff2 1569 sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent FROM logbook WHERE run = %d", run);
44e45fac 1570 TSQLResult* result = server->Query(sqlQuery);
1571 if (!result)
1572 {
1573 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1574 return -2;
1575 }
1576
1577 if (result->GetRowCount() == 0)
1578 {
1579 Printf("ERROR: Run %d not found", run);
1580 delete result;
1581 return -3;
1582 }
1583
1584 TSQLRow* row = result->Next();
1585 if (!row)
1586 {
1587 Printf("ERROR: Could not receive data from run %d", run);
1588 delete result;
1589 return -4;
1590 }
1591
26c1dff2 1592 TString timeStartString(row->GetField(0));
44e45fac 1593 TString runType(row->GetField(1));
26c1dff2 1594 TString detectorMaskString(row->GetField(2));
1595 TString l3CurrentString(row->GetField(3));
1596 TString dipoleCurrentString(row->GetField(4));
1597 time_t timeStart = (time_t)(timeStartString.Atoi());
1598 UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
1599 Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
1600 Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
03e5ee4f 1601 Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
1602 Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
44e45fac 1603
26c1dff2 1604 AliGRPObject * grpObj = new AliGRPObject();
1605 grpObj->SetTimeStart(timeStart);
1606 grpObj->SetRunType((TString)(row->GetField(1)));
1607 grpObj->SetDetectorMask(detectorMask);
1608 grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
1609 grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
03e5ee4f 1610 grpObj->SetL3Polarity(l3Polarity);
1611 grpObj->SetDipolePolarity(dipolePolarity);
26c1dff2 1612
44e45fac 1613 delete row;
1614 row = 0;
1615
1616 delete result;
1617 result = 0;
1618
1619 Printf("Storing GRP/GRP/Data object with the following content");
26c1dff2 1620 grpObj->Dump();
44e45fac 1621
1622 AliCDBMetaData metadata;
26c1dff2 1623 metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
44e45fac 1624 metadata.SetComment("GRP Output parameters received during online running");
1625
1626 AliCDBId id("GRP/GRP/Data", run, run);
26c1dff2 1627 Bool_t success = cdb->Put(grpObj, id, &metadata);
44e45fac 1628
26c1dff2 1629 delete grpObj;
44e45fac 1630
1631 if (!success)
1632 {
1633 Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
1634 return -5;
1635 }
1636
1637 // Receive trigger information
1638 sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
1639 result = server->Query(sqlQuery);
1640 if (!result)
1641 {
1642 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1643 return -11;
1644 }
1645
1646 if (result->GetRowCount() == 0)
1647 {
1648 Printf("ERROR: Run %d not found in logbook_trigger_config", run);
1649 delete result;
1650 return -12;
1651 }
1652
1653 row = result->Next();
1654 if (!row)
1655 {
1656 Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
1657 delete result;
1658 return -13;
1659 }
1660
1661 TString triggerConfig(row->GetField(0));
1662
1663 delete row;
1664 row = 0;
1665
1666 delete result;
1667 result = 0;
1668
1669 Printf("Found trigger configuration: %s", triggerConfig.Data());
1670
1671 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
1672 if (!runcfg)
1673 {
1674 Printf("ERROR: Could not create CTP configuration object");
1675 return -14;
1676 }
1677
1678 metadata.SetComment("CTP run configuration received during online running");
1679
1680 AliCDBId id2("GRP/CTP/Config", run, run);
1681 success = cdb->Put(runcfg, id2, &metadata);
1682
1683 delete runcfg;
1684 runcfg = 0;
1685
1686 if (!success)
1687 {
1688 Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
1689 return -15;
1690 }
1691
03e5ee4f 1692
1693 // Receive list of GDCs for this run
1694 sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
1695 result = server->Query(sqlQuery);
1696 if (!result)
1697 {
1698 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1699 return -24;
1700 }
1701
1702 if (result->GetRowCount() == 0)
1703 {
1704 Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
1705 delete result;
1706 return -25;
1707 }
2b81b7d0 1708
1709 gdc = "";
1710 for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
1711 row = result->Next();
1712 if (!row)
1713 {
1714 Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
1715 delete result;
1716 return -26;
1717 }
1718 gdc += row->GetField(0);
1719 gdc += " ";
1720 }
1721
03e5ee4f 1722 delete row;
1723 row = 0;
1724
1725 delete result;
1726 result = 0;
1727
1728 Printf("Found GDC: %s", gdc.Data());
1729
44e45fac 1730 // get last run with same run type that was already processed by the SHUTTLE
1731
1732 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());
1733 result = server->Query(sqlQuery);
1734 if (!result)
1735 {
1736 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
1737 return -21;
1738 }
1739
1740 if (result->GetRowCount() == 0)
1741 {
1742 Printf("ERROR: No result with query <%s>", sqlQuery.Data());
1743 delete result;
1744 return -22;
1745 }
1746
1747 row = result->Next();
1748 if (!row)
1749 {
1750 Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
1751 delete result;
1752 return -23;
1753 }
1754
1755 TString lastRunStr(row->GetField(0));
1756 Int_t lastRun = lastRunStr.Atoi();
1757
1758 Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
1759
1760 delete row;
1761 row = 0;
1762
1763 delete result;
1764 result = 0;
1765
1766 server->Close();
1767 delete server;
1768 server = 0;
1769
1770 return lastRun;
1e27bb6b 1771}