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