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