]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliGRPPreprocessor.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Cosmetics
[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>
c5340e82 30#include <TObjArray.h>
44e45fac 31#include <TGraph.h>
c5340e82 32#include <TString.h>
6a150f83 33#include <TFile.h>
7ca4655f 34
fe726709 35#include <float.h>
36
3dedb44a 37#include "AliGRPPreprocessor.h"
44e45fac 38#include "AliGRPObject.h"
39#include "AliDCSSensor.h"
40#include "AliSplineFit.h"
17984b61 41#include "AliDCSSensorArray.h"
ea4a87ee 42#include "AliRawEventHeaderVersions.h"
3dedb44a 43
48b1b444 44#include "AliTriggerConfiguration.h"
45#include "AliTriggerRunScalers.h"
46
3dedb44a 47#include "AliCDBMetaData.h"
6a150f83 48#include "AliESDVertex.h"
0254e751 49#include "AliLHCReader.h"
50#include "AliLHCData.h"
51#include "AliDCSArray.h"
3dedb44a 52
ac152fdd 53class AliLog;
3dedb44a 54class AliDCSValue;
55class AliShuttleInterface;
56
1e27bb6b 57// needed for ReceivePromptRecoParameters
39e3007b 58
1e27bb6b 59#include <TSQLServer.h>
60#include <TSQLResult.h>
61#include <TSQLRow.h>
62#include <AliCDBManager.h>
63#include <AliCDBMetaData.h>
64#include <AliCDBId.h>
65#include <AliTriggerConfiguration.h>
6614fa48 66#include <AliCTPTimeParams.h>
1e27bb6b 67
d7edf69d 68const Double_t kFitFraction = -1.; // Fraction of DCS sensor fits required
17984b61 69
3dedb44a 70ClassImp(AliGRPPreprocessor)
71
17984b61 72//_______________________________________________________________
44e45fac 73
e3a2ac48 74 const Int_t AliGRPPreprocessor::fgknDAQLbPar = 6; // num parameters in the logbook used to fill the GRP object
0254e751 75 const Int_t AliGRPPreprocessor::fgknDCSDP = 48; // number of dcs dps
39e3007b 76 const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40; // number of dcs dps
e07d2728 77 const Int_t AliGRPPreprocessor::fgknLHCDP = 4; // number of dcs dps from LHC data
4bb7c769 78 const Int_t AliGRPPreprocessor::fgkDCSDPHallTopShift = 4; // shift from the top to get tp the Hall Probes names in the list of DCS DPs
9fae6417 79 const Int_t AliGRPPreprocessor::fgkDCSDPNonWorking = 5; // number of non working DCS DPs
e7a6790f 80 const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
e7a6790f 81 "L3Polarity",
82 "DipolePolarity",
e7a6790f 83 "L3Current",
84 "DipoleCurrent",
44e45fac 85 "L3_BSF17_H1",
86 "L3_BSF17_H2",
87 "L3_BSF17_H3",
88 "L3_BSF17_Temperature",
89 "L3_BSF4_H1",
90 "L3_BSF4_H2",
91 "L3_BSF4_H3",
92 "L3_BSF4_Temperature",
93 "L3_BKF17_H1",
94 "L3_BKF17_H2",
95 "L3_BKF17_H3",
96 "L3_BKF17_Temperature",
97 "L3_BKF4_H1",
98 "L3_BKF4_H2",
99 "L3_BKF4_H3",
100 "L3_BKF4_Temperature",
101 "L3_BSF13_H1",
102 "L3_BSF13_H2",
103 "L3_BSF13_H3",
104 "L3_BSF13_Temperature",
105 "L3_BSF8_H1",
106 "L3_BSF8_H2",
107 "L3_BSF8_H3",
108 "L3_BSF8_Temperature",
109 "L3_BKF13_H1",
110 "L3_BKF13_H2",
111 "L3_BKF13_H3",
112 "L3_BKF13_Temperature",
113 "L3_BKF8_H1",
114 "L3_BKF8_H2",
115 "L3_BKF8_H3",
116 "L3_BKF8_Temperature",
117 "Dipole_Inside_H1",
118 "Dipole_Inside_H2",
119 "Dipole_Inside_H3",
120 "Dipole_Inside_Temperature",
121 "Dipole_Outside_H1",
122 "Dipole_Outside_H2",
123 "Dipole_Outside_H3",
124 "Dipole_Outside_Temperature",
e7a6790f 125 "CavernTemperature",
126 "CavernAtmosPressure",
ce996d13 127 "SurfaceAtmosPressure",
3343d11b 128 "CavernAtmosPressure2"
e7a6790f 129 };
44e45fac 130
39e3007b 131 const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
44e45fac 132 "L3_BSF17_H1",
133 "L3_BSF17_H2",
134 "L3_BSF17_H3",
135 "L3_BSF17_Temperature",
136 "L3_BSF4_H1",
137 "L3_BSF4_H2",
138 "L3_BSF4_H3",
139 "L3_BSF4_Temperature",
140 "L3_BKF17_H1",
141 "L3_BKF17_H2",
142 "L3_BKF17_H3",
143 "L3_BKF17_Temperature",
144 "L3_BKF4_H1",
145 "L3_BKF4_H2",
146 "L3_BKF4_H3",
147 "L3_BKF4_Temperature",
148 "L3_BSF13_H1",
149 "L3_BSF13_H2",
150 "L3_BSF13_H3",
151 "L3_BSF13_Temperature",
152 "L3_BSF8_H1",
153 "L3_BSF8_H2",
154 "L3_BSF8_H3",
155 "L3_BSF8_Temperature",
156 "L3_BKF13_H1",
157 "L3_BKF13_H2",
158 "L3_BKF13_H3",
159 "L3_BKF13_Temperature",
160 "L3_BKF8_H1",
161 "L3_BKF8_H2",
162 "L3_BKF8_H3",
163 "L3_BKF8_Temperature",
164 "Dipole_Inside_H1",
165 "Dipole_Inside_H2",
166 "Dipole_Inside_H3",
167 "Dipole_Inside_Temperature",
168 "Dipole_Outside_H1",
169 "Dipole_Outside_H2",
170 "Dipole_Outside_H3",
3343d11b 171 "Dipole_Outside_Temperature"
44e45fac 172 };
e7a6790f 173
0254e751 174 const Short_t kSensors = 45; // start index position of sensor in DCS DPs
ce996d13 175 const Short_t kNumSensors = 3; // Number of sensors in DCS DPs (CavernAtmosPressure, SurfaceAtmosPressure, CavernAtmosPressure2)
176
e7a6790f 177
0254e751 178 const char* AliGRPPreprocessor::fgkLHCDataPoints[AliGRPPreprocessor::fgknLHCDP] = {
5fb8d1a1 179 "LHC_Beam_Energy",
180 "LHC_MachineMode",
181 "LHC_BeamMode",
e07d2728 182 "LHC_Beams_Particle_Type"
0254e751 183 };
e07d2728 184
e7a6790f 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)",
6a150f83 193 "(CTP timing ERROR)",
0254e751 194 "(SPD Mean Vertex ERROR)",
195 "(DCS FXS Error for LHC Data)",
196 "(LHC Data Error)"
e7a6790f 197 };
17984b61 198
3dedb44a 199//_______________________________________________________________
44e45fac 200
3dedb44a 201AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
c5340e82 202 AliPreprocessor("GRP",shuttle), fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0),fdaqStartEndTimeOk(kTRUE),ffailedDPs(new TObjArray(fgknDCSDP))
e7a6790f 203{
44e45fac 204 // constructor - shuttle must be instantiated!
ad103e84 205
7eaa854b 206 AddRunType("COSMIC");
207 AddRunType("LASER");
44e45fac 208 AddRunType("PHYSICS");
c2ad5069 209 AddRunType("CALIBRATION_BC");
210 AddRunType("CALIBRATION_CENTRAL");
211 AddRunType("CALIBRATION_EMD");
212 AddRunType("CALIBRATION_MB");
213 AddRunType("CALIBRATION_SEMICENTRAL");
69bf9b19 214 AddRunType("CALIBRATION");
215 AddRunType("PEDESTAL");
7be24dea 216 AddRunType("STANDALONE");
217 AddRunType("GAIN");
3242245e 218 AddRunType("NOISE");
219 AddRunType("PULSER");
b7a928fe 220 AddRunType("STANDALONE_PULSER");
52439816 221 AddRunType("STANDALONE_BC");
fe726709 222
223 fmaxFloat = FLT_MAX;
224 fminFloat = -FLT_MAX;
225 fmaxDouble = DBL_MAX;
226 fminDouble = -DBL_MAX;
227 fmaxInt = kMaxInt;
228 fminInt = kMinInt;
229 fmaxUInt = kMaxUInt;
230 fminUInt = 0;
231
232 AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
233 AliInfo(Form("Min allowed float = %6.5e",fminFloat));
234 AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
235 AliInfo(Form("Min allowed double = %6.5e",fminDouble));
236 AliInfo(Form("Max allowed integer = %d",fmaxInt));
237 AliInfo(Form("Min allowed integer = %d",fminInt));
238 AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
239 AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));
240
c5340e82 241 ffailedDPs->SetOwner(kTRUE);
3dedb44a 242}
243
244//_______________________________________________________________
44e45fac 245
e7a6790f 246AliGRPPreprocessor::~AliGRPPreprocessor()
247{
44e45fac 248 //destructor
249
250 delete fPressure;
c5340e82 251 delete ffailedDPs;
252
3dedb44a 253}
254
255//_______________________________________________________________
44e45fac 256
e7a6790f 257void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
258{
ce996d13 259 // Initialize preprocessor
17984b61 260
ce996d13 261 AliPreprocessor::Initialize(run, startTime, endTime);
262
263 AliInfo("Initialization of the GRP preprocessor.");
264 AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
265 AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
266 TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors);
267 for(Int_t j = 0; j < kNumSensors; j++) {
268 AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
269 sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
270 }
271 AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
272
273 fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);
c5340e82 274
275 for (Int_t iDP=0; iDP < fgknDCSDP; iDP++){
276 TObjString* dp = new TObjString(fgkDCSDataPoints[iDP]);
277 ffailedDPs->AddAt(dp,iDP);
278 }
279
3dedb44a 280}
281
282//_______________________________________________________________
44e45fac 283
e7a6790f 284UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
285{
44e45fac 286 // process data retrieved by the Shuttle
287
e75e6e01 288 // retrieving "partition" and "detector" fields from DAQ logbook to
289 // determine the partition in which the run was taken
290 // the partition is used to decide how to react in case of errors for CTP
291
292 TString partition = (TString)GetRunParameter("partition");
293 TString detector = (TString)GetRunParameter("detector");
294
44e45fac 295 AliGRPObject *grpobj = new AliGRPObject(); // object to store data
5cf76849 296 grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format
0254e751 297
44e45fac 298 //=================//
299 // DAQ logbook //
300 //=================//
e3a2ac48 301
302 Log("*************** Processing DAQ logbook");
303
44e45fac 304 UInt_t error = 0;
305
e75e6e01 306 Int_t iDaqLB = ProcessDaqLB(grpobj);
307 TString runType = (TString)GetRunType();
308 TString beamType = (TString)GetRunParameter("beamType");
e3a2ac48 309 if(iDaqLB == fgknDAQLbPar) {
310 Log(Form("DAQ Logbook, successful! Retrieved %d/%d entries",iDaqLB,fgknDAQLbPar));
e75e6e01 311 } else {
e3a2ac48 312 Log(Form("DAQ Logbook, could not get all expected entries!!! Retrieved only %d/%d entries",iDaqLB,fgknDAQLbPar));
e75e6e01 313 error |= 1;
314 }
44e45fac 315
316 //=================//
317 // DAQ FXS //
318 //=================//
e3a2ac48 319
320 Log("*************** Processing DAQ FXS");
321
44e45fac 322 UInt_t iDaqFxs = ProcessDaqFxs();
323 if( iDaqFxs == 0 ) {
324 Log(Form("DAQ FXS, successful!"));
325 } else {
326 Log(Form("DAQ FXS, could not store run raw tag file!!!"));
327 error |= 2;
328 }
329
330 //=================//
331 // DCS FXS //
332 //=================//
e3a2ac48 333
334 Log("*************** Processing DCS FXS");
335
e75e6e01 336 UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
44e45fac 337 if( iDcsFxs == 0 ) {
338 Log(Form("DCS FXS, successful!"));
e75e6e01 339 } else if (iDcsFxs ==1) {
76820ec2 340 Log(Form("DCS FXS, Could not store CTP scalers!!!"));
44e45fac 341 error |= 4;
e75e6e01 342 } else{
343 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
344 error |= 32;
44e45fac 345 }
346
347 //=================//
348 // DCS data points //
349 //=================//
e3a2ac48 350
351 Log("*************** Processing DCS DPs");
352
7e6f5523 353 Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
44e45fac 354 Int_t entries = ProcessDcsDPs( valueMap, grpobj );
9fae6417 355 Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-fgkDCSDPNonWorking));
5fbf7677 356 if (fdaqStartEndTimeOk){
9fae6417 357 if( entries < fgknDCSDP - fgkDCSDPNonWorking ) { // L3_BSF4_H3, L3_BSF17_H1, L3_BSF17_H2, L3_BSF17_H3, L3_BSF17_Temperature are not working yet...
358 Log(Form("Possible problem with the DCS data points!!! Only %d/%d entries found - Please read further for more details",entries,fgknDCSDP-fgkDCSDPNonWorking));
c5340e82 359 Log(Form("The DPs giving problems were:"));
360 for (Int_t iDP = 0; iDP < fgknDCSDP; iDP++){
361 TObjString *dpString = (TObjString*)ffailedDPs->At(iDP);
362 if (dpString){
363 TString name = dpString->String();
9fae6417 364 if (name != "L3_BSF4_H3" && name != "L3_BSF17_H1" && name != "L3_BSF17_H2" && name != "L3_BSF17_H3" && name != "L3_BSF17_Temperature" ){
c5340e82 365 Log(Form("******** %s ******** not present, but foreseen --> causing an ERROR",name.Data()));
366 }
367 else {
368 Log(Form(" %s is not present, but was not generating any error since it is not ready in DCS - check the other DPs in this list!",name.Data()));
369 }
370 }
371 }
5fbf7677 372 error |= 8;
373 }
374 else Log(Form("DCS data points, successful!"));
375 }
376 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 377
378 //=======================//
379 // Trigger Configuration //
380 //=======================//
e75e6e01 381
e3a2ac48 382 Log("*************** Processing Trigger Configuration");
383
44e45fac 384 const char * triggerConf = GetTriggerConfiguration();
e75e6e01 385
386 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
387 Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
388 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
389 if (!cdbEntry) {
390 Log(Form("No dummy CTP configuration entry found, going into error..."));
44e45fac 391 error |= 16;
392 }
e75e6e01 393 else{
394 AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
395 if (!runcfg){
396 Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
44e45fac 397 error |= 16;
398 }
e75e6e01 399 else {
400 TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
401 runcfg->SetTitle(titleCTPcfg);
402 AliCDBMetaData metaData;
403 metaData.SetResponsible("Roman Lietava");
404 metaData.SetComment("CTP run configuration from dummy entry in OCDB");
405 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
406 Log("Unable to store the dummy CTP run configuration object to OCDB!");
407 error |= 16;
408 }
409 }
44e45fac 410 }
411 }
a453acbf 412
e75e6e01 413 else if (!partition.IsNull() && detector.IsNull()){ // global partition
414 Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
415 if (triggerConf!= NULL) {
416 Log("Found trigger configuration in DAQ logbook");
417 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);
44e45fac 418 if (!runcfg) {
e75e6e01 419 Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
420 error |= 16;
44e45fac 421 }
422 else {
e75e6e01 423 TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
44e45fac 424 runcfg->SetTitle(titleCTPcfg);
425 AliCDBMetaData metaData;
426 metaData.SetBeamPeriod(0);
427 metaData.SetResponsible("Roman Lietava");
e75e6e01 428 metaData.SetComment("CTP run configuration from DAQ logbook");
44e45fac 429 if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
430 Log("Unable to store the CTP run configuration object to OCDB!");
431 error |= 16;
432 }
433 }
434 }
e75e6e01 435
436 else {
437 Log("Trigger configuration NULL in DAQ logbook");
438 error |= 16;
439 }
440 }
441
442 else {
443 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
444 error |= 32;
44e45fac 445 }
e75e6e01 446
6614fa48 447 //===========================//
448 // Trigger Timing Parameters //
449 //===========================//
450
e3a2ac48 451 Log("*************** Processing Trigger Time Params");
6614fa48 452
453 const char * triggerCTPtiming = GetCTPTimeParams();
454
455 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
456 Log("STANDALONE partition for current run, using CTP timing params dummy value");
457 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyCTPtime");
458 if (!cdbEntry) {
459 Log(Form("No dummy CTP timing parameters entry found, going into error..."));
460 error |= 64;
461 }
462 else{
463 AliCTPTimeParams *runCTPtiming = (AliCTPTimeParams*)cdbEntry->GetObject();
464 if (!runCTPtiming){
465 Log(Form("dummy CTP timing parameters not found in OCDB entry, going into error..."));
466 error |= 64;
467 }
468 else {
469 TString titleCTPtiming = Form("CTP timing params for run %i from Dummy entry in OCDB",fRun);
470 runCTPtiming->SetTitle(titleCTPtiming);
471 AliCDBMetaData metadata;
472 metadata.SetResponsible("Roman Lietava");
473 metadata.SetComment("CTP run timing parameters from dummy entry in OCDB");
474 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
475 Log("Unable to store the dummy CTP timing params object to OCDB!");
476 error |= 64;
477 }
478 }
479 }
480 }
481
482 else if (!partition.IsNull() && detector.IsNull()){ // global partition
483 Log("GLOBAL partition for current run, using Trigger Timing Parameters from DAQ Logbook");
484 if (triggerCTPtiming!= NULL) {
485 Log("Found trigger timing params in DAQ logbook");
486 AliDebug(2,Form("%s",triggerCTPtiming));
dd5ac86b 487 AliCTPTimeParams *runCTPtiming = AliCTPTimeParams::LoadCTPTimeParamsFromString(triggerCTPtiming);
6614fa48 488 if (!runCTPtiming) {
489 Log("Bad CTP trigger timing params file from DAQ logbook! The corresponding CDB entry will not be filled!");
490 error |= 64;
491 }
492 else {
493 TString titleCTPtiming = Form("CTP timing params for run %i from DAQ",fRun);
494 runCTPtiming->SetTitle(titleCTPtiming);
495 AliCDBMetaData metadata;
496 metadata.SetBeamPeriod(0);
497 metadata.SetResponsible("Roman Lietava");
498 metadata.SetComment("CTP timing params from DAQ logbook");
499 if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
500 Log("Unable to store the CTP timing params object to OCDB!");
501 error |= 64;
502 }
503 }
504 }
505
506 else {
507 Log("Trigger timing params NULL in DAQ logbook");
508 error |= 64;
509 }
510 }
511
512 else {
513 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
514 error |= 32;
515 }
e75e6e01 516
0254e751 517
518 //=================//
519 // LHC Data //
520 //=================//
521
e07d2728 522 if (runType == "PHYSICS"){ // processing the LHC file only in PHYSICS runs
523 Log("*************** Processing LHC Data");
524
525 UInt_t iLHCData = ProcessLHCData(grpobj);
526
527 if( iLHCData == 0 ) {
528 Log(Form("LHC Data from DCS FXS, successful!"));
529 } else if (iLHCData == 1) {
530 Log(Form("LHC Data, problems with DCS FXS!"));
531 error |= 256;
532 } else if (iLHCData ==3){
533 Log(Form("Problems in storing LHC Data - but not going into Error"));
534 } else if (iLHCData ==4){
535 Log(Form("Problems with LHC Data to be put in /GRP/GRP/LHCData - but not going into Error"));
536 } else{
537 Log(Form("LHC Data problems"));
538 error |= 512;
539 }
44e45fac 540
e07d2728 541 }
542
6a150f83 543 //==================//
544 // SPD Mean Vertex //
545 //==================//
e3a2ac48 546
547 Log("*************** Processing SPD Mean Vertex");
548
62d2c16a 549 if (runType == "PHYSICS"){
550 UInt_t iSPDMeanVertex = ProcessSPDMeanVertex();
551 if( iSPDMeanVertex == 1 ) {
552 Log(Form("SPD Mean Vertex, successful!"));
553 } else {
554 Log(Form("SPD Mean Vertex failed!!!"));
555 error |= 128;
556 }
6a150f83 557 }
62d2c16a 558 else {
559 Log("SPD Mean Vertex not processed since runType != PHYSICS");
560 }
561
0254e751 562 // storing AliGRPObject in OCDB
563
564 AliCDBMetaData md;
565 md.SetResponsible("Chiara Zampolli");
566 md.SetComment("Output parameters from the GRP preprocessor.");
567
568 Bool_t result = kTRUE;
569 result = Store("GRP", "Data", grpobj, &md);
570 delete grpobj;
571
44e45fac 572 if (result && !error ) {
573 Log("GRP Preprocessor Success");
574 return 0;
575 } else {
0254e751 576 Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s%s%s%s%s",
44e45fac 577 kppError[(error&1)?1:0],
578 kppError[(error&2)?2:0],
579 kppError[(error&4)?3:0],
580 kppError[(error&8)?4:0],
e75e6e01 581 kppError[(error&16)?5:0],
6614fa48 582 kppError[(error&32)?6:0],
6a150f83 583 kppError[(error&64)?7:0],
0254e751 584 kppError[(error&128)?8:0],
585 kppError[(error&256)?9:0],
586 kppError[(error&512)?10:0]
44e45fac 587 ));
588 return error;
589 }
0254e751 590
591
592}
593
594//_______________________________________________________________
595
596UInt_t AliGRPPreprocessor::ProcessLHCData(AliGRPObject *grpobj)
597{
598 //
599 //Getting the LHC Data from DCS FXS
600 //
601
602 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
603 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
e541e2aa 604 if (timeStartString.IsNull() || timeEndString.IsNull()){
0254e751 605 if (timeStartString.IsNull()){
606 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
607 }
e541e2aa 608 else if (timeEndString.IsNull()){
0254e751 609 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
610 }
611 return 2;
612 }
613
614 Double_t timeStart = timeStartString.Atof();
615 Double_t timeEnd = timeEndString.Atof();
616
0254e751 617 TString fileName = GetFile(kDCS, "LHCData","");
618 if (fileName.Length()>0){
619 AliInfo("Got The LHC Data file");
e541e2aa 620 AliLHCReader lhcReader;
49822138 621
622 // Processing data to be put in AliGRPObject
623
624 // Energy
79350b54 625 Log("*************Energy ");
49822138 626 TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
627 if (energyArray){
4cbf81c1 628 Float_t energy = ProcessEnergy(energyArray,timeStart);
ac152fdd 629 if (energy != -1.) {
49822138 630 grpobj->SetBeamEnergy(energy);
631 grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
0254e751 632 }
49822138 633 delete energyArray;
634 }
635 else {
636 AliError("Energy not found in LHC Data file!!!");
637 }
638
4cbf81c1 639 Double_t timeBeamModeEnd = timeEnd; // max validity for Beam Mode
640 Double_t timeMachineModeEnd = timeEnd; // max validity for Machine Mode
641 Double_t timeBeamEnd = timeEnd; // max validity for Beam Type
642 Double_t timeBeamModeStart = -1; // min validity for Beam Mode
643 Double_t timeMachineModeStart = -1; // min validity for Machine Mode
644 Double_t timeBeamStart = -1; // min validity for Beam Type
645 Int_t indexBeamMode = -1; // index of measurement used to set Beam Mode
646 Int_t indexMachineMode = -1; // index of measurement used to set Beam Mode
647 Int_t indexBeam = -1; // index of measurement used to set Beam Mode
648 Bool_t foundBeamModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
649 Bool_t foundMachineModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
650 Bool_t foundBeamStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
651 Bool_t flagBeamMode = kFALSE; //flag set true if a changed occurred in BeamMode
652 Bool_t flagMachineMode = kFALSE; //flag set true if a changed occurred in MachineMode
653 Bool_t flagBeam = kFALSE; //flag set true if a changed occurred in BeamType
49822138 654
655 // BeamMode
79350b54 656 Log("*************BeamMode (LHCState) ");
49822138 657 TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
658 Int_t nBeamMode = -1;
659 if (beamModeArray){
660 nBeamMode = beamModeArray->GetEntries();
661 if (nBeamMode==0){
79350b54 662 AliInfo("Found zero entries for the Beam Mode, leaving it empty");
49822138 663 }
664 else{
4cbf81c1 665 for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
666 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
667 if (beamMode){
668 if (beamMode->GetTimeStamp()<=timeStart && beamMode->GetTimeStamp()>=timeBeamModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
669 timeBeamModeStart = beamMode->GetTimeStamp();
670 indexBeamMode = iBeamMode;
671 foundBeamModeStart = kTRUE;
79350b54 672 }
4cbf81c1 673 else {
674 break;
675
79350b54 676 }
49822138 677 }
4cbf81c1 678 }
679 if (!foundBeamModeStart){
680 AliInfo("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
40e422c8 681 }
49822138 682 else {
4cbf81c1 683 AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
684 TObjString* beamModeString = beamMode->GetStringArray(0);
685 AliInfo(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
686 grpobj->SetLHCState(beamModeString->String());
687 if (indexBeamMode < nBeamMode-1){
688 AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
689 if (beamMode1){
690 if (beamMode1->GetTimeStamp()<=timeStart){
691 AliError("you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
692 }
693 else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
694 timeBeamModeEnd = beamMode1->GetTimeStamp();
695 TObjString* beamModeString1 = beamMode1->GetStringArray(0);
696 TString bmString0 = beamModeString->String();
697 TString bmString1 = beamModeString1->String();
698 if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
699 AliWarning(Form("The beam mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",bmString0.Data(), bmString1.Data(), bmString0.Data(), timeBeamModeEnd));
700 flagBeamMode = kTRUE;
79350b54 701 }
49822138 702 }
79350b54 703 }
704 else {
4cbf81c1 705 AliInfo("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
5fb8d1a1 706 }
707 }
40e422c8 708 }
0d361338 709 }
49822138 710 delete beamModeArray;
711 }
712 else{
713 AliError("Beam mode array not found in LHC Data file!!!");
714 }
715
716 // MachineMode
79350b54 717 Log("*************MachineMode ");
49822138 718 TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
719 Int_t nMachineMode = -1;
720 if (machineModeArray){
721 nMachineMode = machineModeArray->GetEntries();
722 if (nMachineMode==0){
723 AliInfo("No Machine Mode found, leaving it empty");
0254e751 724 }
49822138 725 else{
4cbf81c1 726 for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
727 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
79350b54 728 if (machineMode){
4cbf81c1 729 if (machineMode->GetTimeStamp()<=timeStart && machineMode->GetTimeStamp()>=timeMachineModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
730 timeMachineModeStart = machineMode->GetTimeStamp();
731 indexMachineMode = iMachineMode;
732 foundMachineModeStart = kTRUE;
79350b54 733 }
734 else{
4cbf81c1 735 break;
79350b54 736 }
49822138 737 }
4cbf81c1 738 }
739 if (!foundMachineModeStart){
740 AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
40e422c8 741 }
49822138 742 else {
4cbf81c1 743 AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
744 TObjString* machineModeString = machineMode->GetStringArray(0);
745 AliInfo(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
746 grpobj->SetMachineMode(machineModeString->String());
747 if (indexMachineMode < nMachineMode-1){
748 AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
749 if (machineMode1){
750 if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
751 timeMachineModeEnd = machineMode1->GetTimeStamp();
752 TObjString* machineModeString1 = machineMode1->GetStringArray(0);
753 TString mmString0 = machineModeString->String();
754 TString mmString1 = machineModeString1->String();
755 if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
756 AliWarning(Form("The machine mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",mmString0.Data(),mmString1.Data(),mmString0.Data(),timeMachineModeEnd));
757 flagMachineMode = kTRUE;
79350b54 758 }
49822138 759 }
79350b54 760 }
4cbf81c1 761 else {
762 AliInfo("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
49822138 763 }
764 }
49822138 765 }
766 }
767 delete machineModeArray;
768 }
4cbf81c1 769 else{
49822138 770 AliError("Machine mode array not found in LHC Data file!!!");
4cbf81c1 771 }
49822138 772
773 // BeamType1 and BeamType2 - both put in the same string
79350b54 774 Log("*************BeamType ");
49822138 775 TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
776 if (beamArray){
777 Int_t nBeam = beamArray->GetEntries();
778 if (nBeam==0){
779 AliInfo("No Beam Type found, leaving it empty");
780 }
781 else{
4cbf81c1 782 for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
783 AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
79350b54 784 if (beam){
4cbf81c1 785 if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
786 timeBeamStart = beam->GetTimeStamp();
787 indexBeam = iBeam;
788 foundBeamStart = kTRUE;
79350b54 789 }
4cbf81c1 790 else{
791 break;
79350b54 792 }
793 }
4cbf81c1 794 }
795 if (!foundBeamStart){
796 AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
797 }
798 else {
799 AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
800 TObjString* beamString = beam->GetStringArray(0);
801 TString beamType = beamString->String();
802 AliInfo(Form("Beam Type = %s",beamType.Data()));
803 if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
804 AliInfo("Setting beam type to p-p");
805 grpobj->SetBeamType("p-p");
806 }
807 else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
808 AliInfo("Setting beam type to Pb-Pb");
809 grpobj->SetBeamType("Pb-Pb");
810 }
79350b54 811 else{
4cbf81c1 812 AliError("Beam Type not known, leaving it empty");
79350b54 813 }
4cbf81c1 814 if (indexBeam < nBeam-1){
815 AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
816 if (beam1){
817 if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
818 timeBeamEnd = beam1->GetTimeStamp();
819 TObjString* beamString1 = beam1->GetStringArray(0);
820 TString beamType1 = beamString1->String();
821 if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
822 AliWarning(Form("The Beam Type changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",beamType.Data(),(beamString1->String()).Data(),beamType.Data(),timeBeamEnd));
823 flagBeam = kTRUE;
79350b54 824 }
79350b54 825 }
826 }
4cbf81c1 827 else {
828 AliInfo("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
e07d2728 829 }
830 }
e07d2728 831 }
832 }
49822138 833 delete beamArray;
834 }
835 else{
4cbf81c1 836 AliError("Beam Type array not found in LHC Data file!!!");
837 }
49822138 838
839 // Setting minTimeLHCValidity
4cbf81c1 840 if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
49822138 841 Double_t minTimeLHCValidity;
4cbf81c1 842 if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true
843 minTimeLHCValidity = timeBeamEnd;
49822138 844 }
4cbf81c1 845 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
846 minTimeLHCValidity = timeMachineModeEnd;
49822138 847 }
4cbf81c1 848 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
849 minTimeLHCValidity = timeBeamModeEnd;
49822138 850 }
4cbf81c1 851 else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
852 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
49822138 853 }
4cbf81c1 854 else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
855 minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
49822138 856 }
4cbf81c1 857 else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
858 minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
0254e751 859 }
49822138 860 else {
4cbf81c1 861 Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam
49822138 862 minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
863 }
864 AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
865 grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
866 }
867
868 // Processing data to go to AliLHCData object
63bd40f4 869 AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
870 // storing AliLHCData in OCDB
871 if (dt){
872 AliInfo(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
873 AliCDBMetaData md;
874 md.SetResponsible("Ruben Shahoyan");
875 md.SetComment("LHC data from the GRP preprocessor.");
876 Bool_t result = kTRUE;
877 result = Store("GRP", "LHCData", dt, &md);
878 delete dt;
879 if (result) return 0;
880 else return 3;
0254e751 881 }
882 }
49822138 883
0254e751 884 else {
885 AliError("No LHCData file found in DCS FXS");
886 return 1;
887 }
79350b54 888
889 return 0;
17984b61 890}
891
6a150f83 892//_______________________________________________________________
893
894UInt_t AliGRPPreprocessor::ProcessSPDMeanVertex()
895{
0254e751 896 //
6a150f83 897 //Getting the SPD Mean Vertex
0254e751 898 //
899
6a150f83 900 TList* list = GetForeignFileSources("SPD", kDAQ, "VertexDiamond");
901 Bool_t storeResult = kTRUE;
902 if (list !=0x0 && list->GetEntries()!=0)
903 {
904 AliInfo("The following sources produced files with the id VertexDiamond from SPD");
905 list->Print();
906 for (Int_t jj=0;jj<list->GetEntries();jj++){
907 TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
908 AliInfo(Form("found source %s", str->String().Data()));
909 TString fileNameRun = GetForeignFile("SPD", kDAQ, "VertexDiamond", str->GetName());
910 if (fileNameRun.Length()>0){
911 AliInfo(Form("Got the file %s", fileNameRun.Data()));
912 TFile daqFile(fileNameRun.Data(),"READ");
913 if (daqFile.IsOpen()) {
914 AliESDVertex* meanVtx = dynamic_cast<AliESDVertex*>(daqFile.Get("MeanVertexPos"));
915 if (meanVtx){
916 meanVtx->Print();
917 // storing in the OCDB
918 AliCDBMetaData md;
919 md.SetResponsible("Cvetan Cheshkov");
920 md.SetComment("SPD Mean Vertex");
295c54b0 921 storeResult = Store("Calib", "MeanVertexSPD", meanVtx, &md, 0, kTRUE);
6a150f83 922 }
923 else{
924 AliWarning("No SPD Mean Vertex object found in file");
925 }
926 }
927 else {
928 AliError("Can't open file");
929 storeResult = kFALSE;
930 }
931 }
932 else{
933 AliWarning("No file found for current source for SPD Mean Vertex");
934 }
935 }
936 }
937 else {
938 AliWarning("No list found for SPD Mean Vertex");
939 }
940
941 if (list) delete list;
942
943 return storeResult;
944}
945
946
17984b61 947//_______________________________________________________________
17984b61 948
e75e6e01 949Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
44e45fac 950{
951 //Getting the DAQ lb information
952
e75e6e01 953 time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
954 time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
955 Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
44e45fac 956 TString beamType = (TString)GetRunParameter("beamType");
957 Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
e75e6e01 958 UInt_t detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
44e45fac 959 TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
960 TString runType = (TString)GetRunType();
961
e75e6e01 962 UInt_t nparameter = 0;
44e45fac 963 if (timeStart != 0){
964 grpObj->SetTimeStart(timeStart);
965 Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
e75e6e01 966 nparameter++;
44e45fac 967 }
968 else {
e3a2ac48 969 Log(Form("Start time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 970 }
971
972 if (timeEnd != 0){
973 grpObj->SetTimeEnd(timeEnd);
974 Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
e75e6e01 975 nparameter++;
44e45fac 976 }
977 else {
e3a2ac48 978 Log(Form("End time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 979 }
980
981 if (beamEnergy != 0){
e3a2ac48 982 Log(Form("Beam Energy for run %d: %f (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamEnergy));
44e45fac 983 }
984 else {
e3a2ac48 985 Log(Form("Beam Energy not put in logbook, but not using it anyway for the GRP object (taking it from the LHC file)"));
44e45fac 986 }
987
44e45fac 988
989 if (beamType.Length() != 0){
e3a2ac48 990 Log(Form("Beam Type for run %d: %s (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamType.Data()));
44e45fac 991 }
992 else {
e3a2ac48 993 Log(Form("Beam Type not put in logbook, but not using it anyway for the GRP entry (taking it from the LHC file)"));
44e45fac 994 }
995
996 if (numberOfDetectors != 0){
997 grpObj->SetNumberOfDetectors(numberOfDetectors);
998 Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
e75e6e01 999 nparameter++;
44e45fac 1000 }
1001 else {
e3a2ac48 1002 Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 1003 }
1004
1005 if (detectorMask != 0){
1006 grpObj->SetDetectorMask(detectorMask);
1007 Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
e75e6e01 1008 nparameter++;
44e45fac 1009 }
1010 else {
e3a2ac48 1011 Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 1012 }
1013
1014 if (lhcPeriod.Length() != 0) {
1015 grpObj->SetLHCPeriod(lhcPeriod);
1016 Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
e75e6e01 1017 nparameter++;
1018 }
1019 else {
e3a2ac48 1020 Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 1021 }
1022 if (runType.Length() != 0) {
1023 grpObj->SetRunType(runType);
1024 Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
e75e6e01 1025 nparameter++;
1026 }
1027 else {
e3a2ac48 1028 Log(Form("Run Type not put in logbook, setting to invalid in GRP entry, and causing an error!"));
44e45fac 1029 }
1030
e75e6e01 1031 return nparameter;
44e45fac 1032}
17984b61 1033
44e45fac 1034//_______________________________________________________________
17984b61 1035
44e45fac 1036UInt_t AliGRPPreprocessor::ProcessDaqFxs()
1037{
1038 //======DAQ FXS======//
1039
ea4a87ee 1040 AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix
44e45fac 1041 TList* list = GetFileSources(kDAQ);
1042 if (!list) {
1043 Log("No raw data tag list: connection problems with DAQ FXS logbook!");
1044 return 1;
1045 }
1046
1047 if (list->GetEntries() == 0) {
1048 Log("no raw data tags in this run: nothing to merge!");
1049 delete list; list=0;
1050 return 0;
1051 }
1052
1053 TChain *fRawTagChain = new TChain("T");
1054 Int_t nFiles=0;
1055 TIterator* iter = list->MakeIterator();
1056 TObject* obj = 0;
1057 while ((obj = iter->Next())) {
1058 TObjString* objStr = dynamic_cast<TObjString*> (obj);
1059 if (objStr) {
1060 Log(Form("Found source %s", objStr->String().Data()));
1061 TList* list2 = GetFileIDs(kDAQ, objStr->String());
1062 if (!list2) {
1063 Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
1064 delete fRawTagChain; fRawTagChain=0;
1065 return 1;
1066 }
1067 Log(Form("Number of ids: %d",list2->GetEntries()));
1068 for(Int_t i = 0; i < list2->GetEntries(); i++) {
1069 TObjString *idStr = (TObjString *)list2->At(i);
1070 TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
1071 if (fileName.Length() > 0) {
1072 Log(Form("Adding file in the chain: %s",fileName.Data()));
1073 fRawTagChain->Add(fileName.Data());
1074 nFiles++;
1075 } else {
1076 Log(Form("Could not retrieve file with id %s from source %s: "
1077 "connection problems with DAQ FXS!",
1078 idStr->String().Data(), objStr->String().Data()));
1079 delete list; list=0;
1080 delete list2; list2=0;
1081 delete fRawTagChain; fRawTagChain=0;
1082 return 2;
1083 }
1084 }
1085 delete list2;
1086 }
1087 }
1088
1089 TString fRawDataFileName = "GRP_Merged.tag.root";
1090 Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
7e6f5523 1091
44e45fac 1092 if( fRawTagChain->Merge(fRawDataFileName) < 1 ) {
1093 Log("Error merging raw data files!!!");
1094 return 3;
1095 }
7e6f5523 1096
44e45fac 1097 TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
1098 Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
1099
1100 if (!result) {
1101 Log("Problem storing raw data tags in local file!!!");
1102 } else {
1103 Log("Raw data tags merged successfully!!");
1104 }
1105
1106 delete iter;
1107 delete list;
1108 delete fRawTagChain; fRawTagChain=0;
1109
1110 if (result == kFALSE) {
1111 return 4;
1112 }
1113
1114 return 0;
1115
1116}
17984b61 1117
44e45fac 1118//_______________________________________________________________
e75e6e01 1119UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
44e45fac 1120{
39e3007b 1121
1122 // processing the info
1123 // stored in the DCS FXS
1124 // coming from the trigger
1125
e75e6e01 1126 // Get the CTP counters information
1127
1128 if (partition.IsNull() && !detector.IsNull()){ // standalone partition
161a4dc3 1129 Log("STANDALONE partition for current run, using Trigger Scalers dummy value");
e75e6e01 1130 AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyScalers");
1131 if (!cdbEntry) {
1132 Log(Form("No dummy CTP scalers entry found, going into error..."));
44e45fac 1133 return 1;
1134 }
e75e6e01 1135 else{
1136 AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntry->GetObject();
1137 if (!scalers){
1138 Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
1139 return 1;
1140 }
1141 else {
1142 AliCDBMetaData metaData;
1143 metaData.SetResponsible("Roman Lietava");
1144 metaData.SetComment("CTP scalers from dummy entry in OCDB");
1145 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1146 Log("Unable to store the dummy CTP scalers object to OCDB!");
1147 return 1;
1148 }
1149 }
1150 }
1151 }
1152
1153 else if (!partition.IsNull() && detector.IsNull()){ // global partition
1154 Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
1155 TString countersfile = GetFile(kDCS, "CTP_xcounters","");
1156 if (countersfile.IsNull()) {
1157 Log("No CTP counters files has been found: empty source!");
44e45fac 1158 return 1;
1159 }
1160 else {
e75e6e01 1161 Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
1162 AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
1163 if (!scalers) {
1164 Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
1165 return 1;
1166 }
1167 else {
1168 AliCDBMetaData metaData;
1169 metaData.SetBeamPeriod(0);
1170 metaData.SetResponsible("Roman Lietava");
1171 metaData.SetComment("CTP scalers");
1172 if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
1173 Log("Unable to store the CTP scalers object to OCDB!");
e541e2aa 1174 delete scalers;
e75e6e01 1175 return 1;
44e45fac 1176 }
1177 }
e541e2aa 1178 delete scalers;
44e45fac 1179 }
44e45fac 1180 }
1181
e75e6e01 1182
1183 else{
1184 Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
1185 return 2;
1186 }
1187
44e45fac 1188 return 0;
e75e6e01 1189
44e45fac 1190}
1191//_______________________________________________________________
17984b61 1192
44e45fac 1193Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
1194{
17984b61 1195
44e45fac 1196 //
1197 // processing DCS DPs
1198 //
1199
26c1dff2 1200 Int_t entries = 0; // counting the entries that are in the DCS DB, not taking care whether they have values or not
44e45fac 1201 Int_t nL3Entries = 0;
1202 Int_t nDipoleEntries = 0;
1203 Int_t nEnvEntries = 0;
1204 Int_t nHallProbesEntries = 0;
44e45fac 1205 nL3Entries = ProcessL3DPs(valueMap, grpObj);
1206 nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
1207 nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
1208 nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
fab61587 1209 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
0254e751 1210 Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
1211 entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
44e45fac 1212 return entries;
17984b61 1213
17984b61 1214}
1215
1216//_______________________________________________________________
29cc8704 1217
39e3007b 1218Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 1219{
39e3007b 1220
1221 // processing DPs
1222 // related to
1223 // L3 info
1224
44e45fac 1225 Int_t nL3Entries = 0;
c5340e82 1226
44e45fac 1227 TObjArray *array = 0x0;
1228 Int_t indexDP = -1;
fe726709 1229 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
44e45fac 1230
fe726709 1231 AliInfo(Form("==========L3Current==========="));
1232 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1233 indexDP = kL3Current;
44e45fac 1234 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1235 if(!array) {
1236 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1237 }
1238 else {
26c1dff2 1239 if (array->GetEntries() == 0){
fe726709 1240 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
26c1dff2 1241 }
1242 else {
fe726709 1243 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1244 if (floatDCS != NULL){
1245 grpObj->SetL3Current(floatDCS);
1246 }
1247 else{
1248 outOfRange = kTRUE;
1249 }
03672227 1250 if (floatDCS){
1251 delete[] floatDCS;
1252 floatDCS = 0x0;
1253 }
26c1dff2 1254 }
c5340e82 1255 if (!outOfRange) {
1256 nL3Entries++;
1257 ffailedDPs->RemoveAt(indexDP);
1258 }
44e45fac 1259 }
1260
1261 if (array) array = 0x0;
1262
fe726709 1263 AliInfo(Form("==========L3Polarity==========="));
1264 indexDP = kL3Polarity;
44e45fac 1265 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1266 if(!array) {
1267 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1268 }
1269 else {
26c1dff2 1270 if (array->GetEntries() == 0){
fe726709 1271 AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
26c1dff2 1272 }
1273 else {
fe726709 1274 Bool_t change = kFALSE;
1275 Char_t charDCS = ProcessBool(array,change);
01920f0c 1276 if (change == kFALSE){
fe726709 1277 grpObj->SetL3Polarity(charDCS);
1278 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
c5340e82 1279 ffailedDPs->RemoveAt(indexDP);
fe726709 1280 nL3Entries++;
1281 }
1282 else if (isZero){
ac833e7a 1283 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
c5340e82 1284 ffailedDPs->RemoveAt(indexDP);
fe726709 1285 nL3Entries++;
1286 }
1287 else {
ac833e7a 1288 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 1289 }
26c1dff2 1290 }
44e45fac 1291 }
1292
1293 return nL3Entries;
e7a6790f 1294
44e45fac 1295}
1296//_______________________________________________________________
ff97356e 1297
39e3007b 1298Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 1299{
39e3007b 1300 // processing DPs
1301 // related to
1302 // the Dipole info
1303
44e45fac 1304 Int_t nDipoleEntries = 0;
1305 TObjArray *array = 0x0;
1306 Int_t indexDP = -1;
fe726709 1307 Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change
44e45fac 1308
fe726709 1309 AliInfo(Form("==========DipoleCurrent==========="));
1310 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
1311 indexDP = kDipoleCurrent;
44e45fac 1312 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
44e45fac 1313 if(!array) {
1314 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1315 }
1316 else {
26c1dff2 1317 if (array->GetEntries() == 0){
1318 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1319 }
1320 else {
fe726709 1321 Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
1322 if (floatDCS != NULL){
1323 grpObj->SetDipoleCurrent(floatDCS);
1324 }
1325 else{
1326 outOfRange=kTRUE;
1327 }
03672227 1328 if (floatDCS){
1329 delete[] floatDCS;
1330 floatDCS = 0x0;
1331 }
26c1dff2 1332 }
c5340e82 1333 if (!outOfRange) {
1334 nDipoleEntries++;
1335 ffailedDPs->RemoveAt(indexDP);
1336 }
44e45fac 1337 }
1338
1339 if (array) array = 0x0;
1340
fe726709 1341 AliInfo(Form("==========DipolePolarity==========="));
1342 indexDP = kDipolePolarity;
44e45fac 1343 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1344 if(!array) {
1345 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1346 }
1347 else {
26c1dff2 1348 if (array->GetEntries() == 0){
1349 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1350 }
1351 else {
fe726709 1352 Bool_t change = kFALSE;
1353 Char_t charDCS = ProcessBool(array,change);
1354 if (!change){
1355 grpObj->SetDipolePolarity(charDCS);
1356 AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
c5340e82 1357 ffailedDPs->RemoveAt(indexDP);
fe726709 1358 nDipoleEntries++;
1359 }
1360 else if (isZero){
ac833e7a 1361 AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
c5340e82 1362 ffailedDPs->RemoveAt(indexDP);
fe726709 1363 nDipoleEntries++;
1364 }
1365 else{
ac833e7a 1366 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 1367 }
26c1dff2 1368 }
44e45fac 1369 }
1370
1371 return nDipoleEntries;
e7a6790f 1372
44e45fac 1373}
1374//_______________________________________________________________
e7a6790f 1375
44e45fac 1376Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
1377{
39e3007b 1378 // processing DPs
1379 // related to
1380 // evironment conditions (temperature, pressure) info
1381
44e45fac 1382 Int_t nEnvEntries = 0;
1383 TObjArray *array = 0x0;
1384 Int_t indexDP = -1;
1385
1386 AliInfo(Form("==========CavernTemperature==========="));
fe726709 1387 Bool_t outOfRange = kFALSE; // flag to monitor if any value collected by DCS is out of range
44e45fac 1388 indexDP = kCavernTemperature;
1389 array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
1390 if(!array) {
1391 Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
1392 }
1393 else {
26c1dff2 1394 if (array->GetEntries() == 0){
1395 AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
1396 }
1397 else {
1398 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 1399 if (floatDCS != NULL){
1400 grpObj->SetCavernTemperature(floatDCS);
1401 }
1402 else{
1403 outOfRange = kTRUE;
1404 }
03672227 1405 if (floatDCS){
1406 delete[] floatDCS;
1407 floatDCS = 0x0;
1408 }
26c1dff2 1409 }
c5340e82 1410 if (!outOfRange) {
1411 ffailedDPs->RemoveAt(indexDP);
1412 nEnvEntries++;
1413 }
44e45fac 1414 }
1415
1416 if (array) array = 0x0;
1417
ce996d13 1418 AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
44e45fac 1419 AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
ce996d13 1420 //dcsSensorArray->Print();
1421 if( fPressure->NumFits()<kNumSensors ) {
d7edf69d 1422 Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
44e45fac 1423 }
d7edf69d 1424 Log(Form("Number of fits performed = %d",fPressure->NumFits()));
1425
1426 AliInfo(Form("==========CavernAtmosPressure==========="));
1427 indexDP = kCavernAtmosPressure;
1428 AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1429 TGraph* graph = sensorCavernP2->GetGraph();
3343d11b 1430 AliDebug(3,Form("index = %d",indexDP));
1431 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
d7edf69d 1432 AliDebug(2,Form("graph = %p",graph));
1433 AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
2a0b175e 1434 if(sensorCavernP2->GetFit() || graph) {
d7edf69d 1435 if (sensorCavernP2->GetFit()){
2a0b175e 1436 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
d7edf69d 1437 }
44e45fac 1438 else {
2a0b175e 1439 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
d7edf69d 1440 }
1441 grpObj->SetCavernAtmosPressure(sensorCavernP2);
c5340e82 1442 ffailedDPs->RemoveAt(indexDP);
d7edf69d 1443 nEnvEntries++;
1444 }
1445 //if (sensorP2) delete sensorP2;
1446 else {
2a0b175e 1447 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 1448 }
2a0b175e 1449
d7edf69d 1450 AliInfo(Form("==========SurfaceAtmosPressure==========="));
1451 indexDP = kSurfaceAtmosPressure;
1452 AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
1453 graph = sensorP2->GetGraph();
3343d11b 1454 AliDebug(3,Form("index = %d",indexDP));
1455 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
d7edf69d 1456 AliDebug(2,Form("graph = %p",graph));
1457 AliDebug(3,Form("sensorP2 = %p", sensorP2));
2a0b175e 1458 if(sensorP2->GetFit() || graph) {
d7edf69d 1459 if (sensorP2->GetFit()){
2a0b175e 1460 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
d7edf69d 1461 }
44e45fac 1462 else {
2a0b175e 1463 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
d7edf69d 1464 }
1465 grpObj->SetSurfaceAtmosPressure(sensorP2);
c5340e82 1466 ffailedDPs->RemoveAt(indexDP);
d7edf69d 1467 nEnvEntries++;
1468 }
1469 //if (sensorP2) delete sensorP2;
1470 else {
2a0b175e 1471 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 1472 }
1473
d7edf69d 1474 AliInfo(Form("==========CavernAtmosPressure2==========="));
1475 indexDP = kCavernAtmosPressure2;
1476 AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
8976336c 1477 graph = sensorCavernP22->GetGraph();
3343d11b 1478 AliDebug(3,Form("index = %d",indexDP));
1479 AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
d7edf69d 1480 AliDebug(2,Form("graph = %p",graph));
1481 AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
2a0b175e 1482 if(sensorCavernP22->GetFit() || graph) {
d7edf69d 1483 if (sensorCavernP22->GetFit()){
2a0b175e 1484 Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
d7edf69d 1485 }
1486 else {
2a0b175e 1487 Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
d7edf69d 1488 }
1489 grpObj->SetCavernAtmosPressure2(sensorCavernP22);
c5340e82 1490 ffailedDPs->RemoveAt(indexDP);
d7edf69d 1491 nEnvEntries++;
1492 }
1493 //if (sensorP2) delete sensorP2;
1494 else {
2a0b175e 1495 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 1496 }
1497
1498
44e45fac 1499 return nEnvEntries;
1500}
1501//_______________________________________________________________
e7a6790f 1502
39e3007b 1503Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
44e45fac 1504{
39e3007b 1505 // processing DPs
1506 // related to
1507 // Hall Probes info
1508
44e45fac 1509 Int_t nHPEntries = 0;
1510 TObjArray *array = 0x0;
1511 Int_t indexDP = -1;
fe726709 1512 Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range
44e45fac 1513
39e3007b 1514 if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
1515 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 1516 }
1517 for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
fe726709 1518 outOfRange = kFALSE; // resetting outOfRange flag at each HP
44e45fac 1519 AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
1520 array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
1521 if(!array) {
1522 Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
1523 }
1524 else {
26c1dff2 1525 if (array->GetEntries() == 0){
1526 AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
1527 }
1528 else {
1529 Float_t *floatDCS = ProcessFloatAll(array);
fe726709 1530 if (floatDCS != NULL){
1531 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]));
1532 grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
1533 for (Int_t kk = 0 ; kk< 5; kk++){
1534 AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
1535 }
1536 }
1537 else{
1538 outOfRange = kTRUE;
26c1dff2 1539 }
03672227 1540 if (floatDCS){
1541 delete[] floatDCS;
1542 floatDCS = 0x0;
1543 }
44e45fac 1544 }
c5340e82 1545 if (!outOfRange) {
4bb7c769 1546 ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift); // 7 = shift in the complete list of DPs to get to the Hall Probes
c5340e82 1547 nHPEntries++;
1548 }
44e45fac 1549 }
1550 }
1551
7e6f5523 1552 Log(Form("Hall Probes = %d ", nHPEntries));
1553 return nHPEntries;
17984b61 1554}
1555
44e45fac 1556//_________________________________________________________________________
1557
39e3007b 1558AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){
1559
1560
1561 //
1562 // returning Spline Fit
1563 //
44e45fac 1564
1565 Int_t entriesarray = array->GetEntries();
1566 Float_t* value = new Float_t[entriesarray];
1567 Float_t* time = new Float_t[entriesarray];
1568 AliDCSValue* v = 0x0;
1569 for (Int_t iarray = 0; iarray < entriesarray; iarray++){
1570 v = (AliDCSValue*)array->At(iarray);
1571 value[iarray] = v->GetFloat();
1572 time[iarray] = v->GetTimeStamp();
e75e6e01 1573 AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
44e45fac 1574 }
1575 TGraph* gr = new TGraph(entriesarray,value,time);
1576 if (!gr ) {
1577 AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
1578 return NULL;
1579 }
1580 AliSplineFit *fit = new AliSplineFit();
1581 fit->SetMinPoints(10);
1582 fit->InitKnots(gr,10,10,0.0);
1583 fit->SplineFit(2);
1584 fit->Cleanup();
1585 if (!fit) {
1586 AliWarning(Form("%s: no fit performed",stringID.Data()));
1587 return NULL;
1588 }
1589 return fit;
48b1b444 1590}
1591
44e45fac 1592//_________________________________________________________________________
1593
39e3007b 1594TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
e7a6790f 1595{
17984b61 1596
44e45fac 1597 //
1598 // processing char
1599 //
1600
1601 TString aDCSString="";
1602
1603 AliDCSValue *v = 0x0;
1604 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1605 v = (AliDCSValue *)array->At(iCount);
26c1dff2 1606 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1607 AliError(Form("DCS values for the parameter outside the queried interval"));
1608 continue;
1609 }
1610 if (iCount > 0) {
7e6f5523 1611 if (aDCSString != v->GetChar())
44e45fac 1612 AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
1613 }
1614 aDCSString = (TString)v->GetChar(); // keeping always last value in the array
1615 }
1616 return aDCSString;
1617}
e7a6790f 1618
44e45fac 1619//__________________________________________________________________________________________________________________
e7a6790f 1620
39e3007b 1621Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
44e45fac 1622{
1623 //
1624 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1625 //
1626 // parameters[0] = mean
1627 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1628 // parameters[2] = median
1629 // parameters[3] = standard deviation wrt mean
1630 // parameters[4] = standard deviation wrt median
1631 //
1632
28131b57 1633 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
1634 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
1635 if (timeStartString.IsNull() || timeStartString.IsNull()){
1636 if (timeStartString.IsNull()){
1637 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
1638 }
1639 else if (timeStartString.IsNull()){
1640 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
1641 }
5fbf7677 1642 fdaqStartEndTimeOk = kFALSE;
28131b57 1643 return 0;
1644 }
1645
1646 Int_t timeStart = (Int_t)(timeStartString.Atoi());
1647 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
5138cd05 1648 Float_t* parameters = new Float_t[5];
44e45fac 1649 Int_t iCounts = 0;
28131b57 1650 Int_t iCountsRun = 0;
44e45fac 1651 Int_t nCounts = array->GetEntries();
28131b57 1652 Float_t valueBeforeSOR = 0;
1653 Float_t valueAfterEOR = 0;
1654 Int_t timestampBeforeSOR = -1;
1655 Int_t timestampAfterEOR = -1;
1656 Int_t ientrySOR = -1;
1657 Int_t ientryEOR = -1;
1658 Float_t* arrayValues = 0x0;
1659 Double_t* arrayWeights = 0x0;
1660 Bool_t truncMeanFlag = kTRUE; // flag to indicate whether Truncated Mean should be calculated or not
5fbf7677 1661 Bool_t sdFlag = kTRUE; // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
1662
44e45fac 1663 for(Int_t i = 0; i < nCounts; i++) {
1664 AliDCSValue *v = (AliDCSValue *)array->At(i);
fe726709 1665 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1666 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
1667 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1668 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
1669 return NULL;
1670 }
1671 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
28131b57 1672 AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
fe726709 1673 iCounts += 1;
28131b57 1674 // look for the last value before SOR and the first value before EOR
1675 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
1676 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
1677 AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
1678 valueBeforeSOR = v->GetFloat();
1679 }
1680 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
1681 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
1682 valueAfterEOR = v->GetFloat();
1683 AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
1684 }
1685 // check if there are DPs between DAQ_time_start and DAQ_time_end
1686 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
1687 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
1688 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
1689 AliDebug(2,Form("entry between SOR and EOR"));
1690 iCountsRun += 1;
1691 }
fe726709 1692 }
1693 else {
28131b57 1694 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
fe726709 1695 }
1696 }
1697
28131b57 1698 if (timestampBeforeSOR == -1){
df1faeb3 1699 AliWarning("No value found before SOR");
28131b57 1700 }
1701 if (timestampAfterEOR == -1){
df1faeb3 1702 AliWarning("No value found after EOR");
28131b57 1703 }
1704
1705 AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
1706 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
1707 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
1708 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
1709 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
1710 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
1711
1712 Int_t nentriesUsed = 0;
1713 if (iCountsRun > 1){
1714 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
1715 AliDebug(2,"Calculating (weighted) Mean and Median");
1716 arrayValues = new Float_t[iCountsRun];
1717 arrayWeights = new Double_t[iCountsRun];
1718 nentriesUsed = iCountsRun;
1719 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
fe726709 1720 AliDCSValue *v = (AliDCSValue *)array->At(i);
28131b57 1721 Int_t timestamp2 = 0;
1722 if (i < ientryEOR){
1723 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
1724 timestamp2 = (Int_t)v1->GetTimeStamp();
fe726709 1725 }
28131b57 1726 else {
1727 timestamp2 = timeEnd+1;
1728 }
1729 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
1730 arrayValues[i-ientrySOR] = v->GetFloat();
fe726709 1731 }
28131b57 1732 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
1733 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
1734 }
1735 else if (iCountsRun == 1){
1736 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
1737 nentriesUsed = 2;
1738 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
1739 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.");
1740 arrayValues = new Float_t[2];
1741 arrayWeights = new Double_t[2];
1742 arrayValues[0] = valueBeforeSOR;
1743 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
1744 arrayValues[1] = v->GetFloat();
1745 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
1746 AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
1747 AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
1748 parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
1749 parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
1750 truncMeanFlag = kFALSE;
fe726709 1751 }
1752 else{
28131b57 1753 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");
1754 parameters[0] = AliGRPObject::GetInvalidFloat();
1755 parameters[1] = AliGRPObject::GetInvalidFloat();
1756 parameters[2] = AliGRPObject::GetInvalidFloat();
1757 parameters[3] = AliGRPObject::GetInvalidFloat();
1758 parameters[4] = AliGRPObject::GetInvalidFloat();
1759 return parameters;
fe726709 1760 }
1761 }
5fbf7677 1762 else { // iCountsRun == 0, using only the point immediately before SOR
1763 if (timestampBeforeSOR == -1){
1764 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 1765 parameters[0] = AliGRPObject::GetInvalidFloat();
1766 parameters[1] = AliGRPObject::GetInvalidFloat();
1767 parameters[2] = AliGRPObject::GetInvalidFloat();
1768 parameters[3] = AliGRPObject::GetInvalidFloat();
1769 parameters[4] = AliGRPObject::GetInvalidFloat();
1770 return parameters;
1771 }
1772 else {
5fbf7677 1773 AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
1774 AliDebug(2,Form("value = %f",valueBeforeSOR));
1775 parameters[0] = valueBeforeSOR;
1776 parameters[2] = valueBeforeSOR;
28131b57 1777 truncMeanFlag = kFALSE;
5fbf7677 1778 sdFlag = kFALSE;
28131b57 1779 }
1780 }
1781
1782 Float_t temp = 0;
1783 Float_t temp1 = 0;
1784 Float_t sumweights = 0;
1785 Int_t entriesTruncMean = 0;
1786 Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed];
1787 Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
1788
1789 // calculating SD wrt Mean and Median
1790 AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
5fbf7677 1791 if (sdFlag){
1792 for (Int_t i =0; i< nentriesUsed; i++){
df1faeb3 1793 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
5fbf7677 1794 temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
1795 temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
1796 sumweights += arrayWeights[i];
1797 }
1798 // setting SD wrt Mean
1799 if (sumweights != 0 ){
1800 parameters[3] = TMath::Sqrt(temp1/sumweights);
1801 }
1802 else {
1803 AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
1804 parameters[3] = AliGRPObject::GetInvalidFloat();
1805 }
1806 // setting SD wrt Median
1807 if (nentriesUsed != 0){
1808 parameters[4] = TMath::Sqrt(temp/nentriesUsed);
1809 }
1810 else{
1811 AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
1812 parameters[4] = AliGRPObject::GetInvalidFloat();
1813 }
28131b57 1814 }
fe726709 1815 else {
28131b57 1816 parameters[3] = AliGRPObject::GetInvalidFloat();
28131b57 1817 parameters[4] = AliGRPObject::GetInvalidFloat();
5fbf7677 1818 }
fe726709 1819
28131b57 1820 // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
1821 if (truncMeanFlag){
1822 AliDebug(2,"Calculating Truncated Mean");
1823 for (Int_t i =0; i< nentriesUsed; i++){
df1faeb3 1824 AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
28131b57 1825 if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
df1faeb3 1826 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
1827 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
1828 AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
28131b57 1829 entriesTruncMean++;
df1faeb3 1830 }
1831 else{
1832 AliDebug(2,"Discarding entry");
28131b57 1833 }
1834 }
1835 // setting truncated mean
1836 if (entriesTruncMean >1){
1837 AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
1838 parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
1839 }
1840 else{
1841 AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
1842 parameters[1] = AliGRPObject::GetInvalidFloat();
1843 }
1844 }
1845 else{
1846 parameters[1] = AliGRPObject::GetInvalidFloat();
1847 }
fe726709 1848
28131b57 1849 AliInfo(Form("(weighted) mean = %f ",parameters[0]));
1850 AliInfo(Form("(weighted) truncated mean = %f ",parameters[1]));
1a3ac627 1851 AliInfo(Form("median = %f ",parameters[2]));
28131b57 1852 AliInfo(Form("(weighted) standard deviation with (weighted) mean = %f ",parameters[3]));
1853 AliInfo(Form("standard deviation with median = %f ",parameters[4]));
1854
fe726709 1855 return parameters;
1856}
1857
fe726709 1858//__________________________________________________________________________________________________________________
1859
1860Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
1861{
1862 //
1863 // processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median
1864 // used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
ac833e7a 1865 // the flag is set according to the L3/Dipole current value
1866 // current threshold for L3 = 350 A (value provided by DCS)
1867 // current threshold for Dipole = 450 A (value provided by DCS)
fe726709 1868 //
1869 // parameters[0] = mean
1870 // parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
1871 // parameters[2] = median
1872 // parameters[3] = standard deviation wrt mean
1873 // parameters[4] = standard deviation wrt median
1874 //
1875
1876 AliInfo(Form("indexDP = %d",indexDP));
28131b57 1877
fe726709 1878 Int_t nCounts = array->GetEntries();
fe726709 1879 for(Int_t i = 0; i < nCounts; i++) {
1880 AliDCSValue *v = (AliDCSValue *)array->At(i);
1881 if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
1882 AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
535c05eb 1883 if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
1884 if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
fe726709 1885 return NULL;
1886 }
26c1dff2 1887 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
28131b57 1888 AliDebug(2,Form("%d-th entry = %f",i,v->GetFloat()));
ac833e7a 1889 if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE;
1890 if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE;
fe726709 1891 }
1892 else {
1893 AliError(Form("DCS values for the parameter outside the queried interval"));
44e45fac 1894 }
1895 }
1896
28131b57 1897 return ProcessFloatAll(array);
44e45fac 1898}
125567f8 1899
e97cc90e 1900
44e45fac 1901//_______________________________________________________________
e97cc90e 1902
fe726709 1903Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
44e45fac 1904{
1905 //
1906 // processing Boolean values
1907 //
1908
1909 Bool_t aDCSBool = kTRUE;
1910
1911 AliDCSValue *v = 0x0;
26c1dff2 1912
44e45fac 1913 for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
1914 v = (AliDCSValue *)array->At(iCount);
26c1dff2 1915 if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
44e45fac 1916 AliError(Form("DCS values for the parameter outside the queried interval"));
1917 continue;
1918 }
1919 if (iCount > 0) {
01920f0c 1920 if (aDCSBool != v->GetBool()) {
1921 AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
1922 change = kTRUE;
1923 }
44e45fac 1924 }
1925 aDCSBool = v->GetBool(); // always keeping last value
26c1dff2 1926 AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
44e45fac 1927 }
1928
26c1dff2 1929 Char_t caDCSBool = (Char_t) aDCSBool;
44e45fac 1930 return caDCSBool;
1931
1932}
e97cc90e 1933
44e45fac 1934//_______________________________________________________________
e97cc90e 1935
39e3007b 1936Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
44e45fac 1937{
1938 //
1939 // processing Int values, returning mean
fe726709 1940 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
1941 // are outside the queried time interval or their value is out of range
44e45fac 1942 //
1943
28131b57 1944 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
1945 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
1946 if (timeStartString.IsNull() || timeStartString.IsNull()){
1947 if (timeStartString.IsNull()){
1948 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
1949 }
1950 else if (timeStartString.IsNull()){
1951 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
1952 }
1953 return 0;
1954 }
1955
1956 Int_t timeStart = (Int_t)(timeStartString.Atoi());
1957 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
44e45fac 1958 Float_t aDCSArrayMean = 0.0;
1959 Int_t iCounts = 0;
28131b57 1960 Float_t valueBeforeSOR = 0;
1961 Float_t valueAfterEOR = 0;
1962 Int_t timestampBeforeSOR = -1;
1963 Int_t timestampAfterEOR = -1;
1964 Int_t ientrySOR = -1;
1965 Int_t ientryEOR = -1;
1966 Float_t* arrayValues = 0x0;
1967 Double_t* arrayWeights = 0x0;
1968 Int_t iCountsRun = 0;
1969 Int_t nCounts = array->GetEntries();
44e45fac 1970
28131b57 1971 for(Int_t i = 0; i < nCounts; i++) {
dd5ac86b 1972 AliDCSValue* v = (AliDCSValue *)array->At(i);
fe726709 1973 if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
28131b57 1974 AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",i, v->GetInt()));
fe726709 1975 return AliGRPObject::GetInvalidFloat();
1976 }
26c1dff2 1977 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
28131b57 1978 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetInt(),v->GetTimeStamp()));
44e45fac 1979 iCounts += 1;
28131b57 1980 // look for the last value before SOR and the first value before EOR
1981 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
1982 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
1983 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
1984 valueBeforeSOR = (Float_t) v->GetInt();
1985 }
1986 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
1987 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
1988 valueAfterEOR = (Float_t) v->GetInt();
1989 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
1990 }
1991 // check if there are DPs between DAQ_time_start and DAQ_time_end
1992 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
1993 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
1994 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
1995 AliDebug(2,Form("entry between SOR and EOR"));
1996 iCountsRun += 1;
1997 }
1998 }
1999 else {
2000 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
44e45fac 2001 }
2002 }
2003
28131b57 2004 if (timestampBeforeSOR == -1){
2005 AliWarning("No value found before SOR!");
2006 }
2007 if (timestampAfterEOR == -1){
2008 AliWarning("No value found after EOR!");
2009 }
2010
2011 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2012 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2013 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2014 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2015 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2016 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2017
2018 Int_t nentriesUsed = 0;
2019 if (iCountsRun > 1){
2020 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2021 AliDebug(2,"Calculating (weighted) Mean");
2022 arrayValues = new Float_t[iCountsRun];
2023 arrayWeights = new Double_t[iCountsRun];
2024 nentriesUsed = iCountsRun;
2025 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2026 AliDCSValue *v = (AliDCSValue *)array->At(i);
2027 Int_t timestamp2 = 0;
2028 if (i < ientryEOR){
2029 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2030 timestamp2 = (Int_t)v1->GetTimeStamp();
2031 }
2032 else {
2033 timestamp2 = timeEnd+1;
2034 }
2035 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2036 arrayValues[i-ientrySOR] = (Float_t)v->GetInt();
2037 }
2038 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2039 }
2040 else if (iCountsRun == 1){
2041 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2042 nentriesUsed = 2;
2043 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2044 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2045 arrayValues = new Float_t[2];
2046 arrayWeights = new Double_t[2];
2047 arrayValues[0] = valueBeforeSOR;
2048 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2049 arrayValues[1] = (Float_t)v->GetInt();
2050 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2051 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2052 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2053 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2054 }
2055 else{
2056 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2057 return AliGRPObject::GetInvalidFloat();
2058 }
2059 }
2060 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2061 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2062 if (timestampBeforeSOR == -1){
2063 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2064 }
2065 if (timestampAfterEOR == -1){
2066 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2067 }
2068 return AliGRPObject::GetInvalidFloat();
2069 }
2070 else {
2071 AliWarning("Using last entry before SOR and first entry after EOR.");
2072 nentriesUsed = 2;
2073 arrayValues = new Float_t[2];
2074 arrayWeights = new Double_t[2];
2075 arrayValues[0] = valueBeforeSOR;
2076 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2077 arrayValues[1] = valueAfterEOR;
2078 arrayWeights[1] = 1.;
2079 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2080 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2081 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2082 }
2083 }
2084
2085 AliInfo(Form("mean = %f ", aDCSArrayMean));
44e45fac 2086 return aDCSArrayMean;
e97cc90e 2087
44e45fac 2088}
2089//_______________________________________________________________
e7a6790f 2090
39e3007b 2091Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
44e45fac 2092{
2093 //
fe726709 2094 // processing Int values, returning mean
2095 // AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
2096 // are outside the queried time interval or their value is out of range
44e45fac 2097 //
2098
28131b57 2099 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2100 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2101 if (timeStartString.IsNull() || timeStartString.IsNull()){
2102 if (timeStartString.IsNull()){
2103 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2104 }
2105 else if (timeStartString.IsNull()){
2106 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2107 }
2108 return 0;
2109 }
2110
2111 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2112 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
44e45fac 2113 Float_t aDCSArrayMean = 0.0;
2114 Int_t iCounts = 0;
28131b57 2115 Float_t valueBeforeSOR = 0;
2116 Float_t valueAfterEOR = 0;
2117 Int_t timestampBeforeSOR = -1;
2118 Int_t timestampAfterEOR = -1;
2119 Int_t ientrySOR = -1;
2120 Int_t ientryEOR = -1;
2121 Float_t* arrayValues = 0x0;
2122 Double_t* arrayWeights = 0x0;
2123 Int_t iCountsRun = 0;
2124 Int_t nCounts = array->GetEntries();
44e45fac 2125
28131b57 2126 for(Int_t i = 0; i < nCounts; i++) {
dd5ac86b 2127 AliDCSValue* v = (AliDCSValue *)array->At(i);
fe726709 2128 if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
28131b57 2129 AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",i,v->GetUInt()));
fe726709 2130 return AliGRPObject::GetInvalidFloat();
2131 }
26c1dff2 2132 if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
28131b57 2133 AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetUInt(),v->GetTimeStamp()));
44e45fac 2134 iCounts += 1;
28131b57 2135 // look for the last value before SOR and the first value before EOR
2136 if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
2137 timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
2138 AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
2139 valueBeforeSOR = (Float_t)v->GetUInt();
2140 }
2141 else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
2142 timestampAfterEOR = (Int_t)(v->GetTimeStamp());
2143 valueAfterEOR = (Float_t)v->GetUInt();
2144 AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
2145 }
2146 // check if there are DPs between DAQ_time_start and DAQ_time_end
2147 if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
2148 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2149 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2150 AliDebug(2,Form("entry between SOR and EOR"));
2151 iCountsRun += 1;
2152 }
2153 }
2154 else {
2155 AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
44e45fac 2156 }
2157 }
2158
28131b57 2159 if (timestampBeforeSOR == -1){
2160 AliWarning("No value found before SOR!");
2161 }
2162 if (timestampAfterEOR == -1){
2163 AliWarning("No value found after EOR!");
2164 }
2165
2166 AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
2167 AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
2168 AliDebug(2,Form("First value after DAQ_time_end (EOR) = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
2169 AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
2170 AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
2171 AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));
2172
2173 Int_t nentriesUsed = 0;
2174 if (iCountsRun > 1){
2175 AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
2176 AliDebug(2,"Calculating (weighted) Mean");
2177 arrayValues = new Float_t[iCountsRun];
2178 arrayWeights = new Double_t[iCountsRun];
2179 nentriesUsed = iCountsRun;
2180 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2181 AliDCSValue *v = (AliDCSValue *)array->At(i);
2182 Int_t timestamp2 = 0;
2183 if (i < ientryEOR){
2184 AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
2185 timestamp2 = (Int_t)v1->GetTimeStamp();
2186 }
2187 else {
2188 timestamp2 = timeEnd+1;
2189 }
2190 arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
2191 arrayValues[i-ientrySOR] = (Float_t)v->GetUInt();
2192 }
2193 aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2194 }
2195 else if (iCountsRun == 1){
2196 AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
2197 nentriesUsed = 2;
2198 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
2199 AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
2200 arrayValues = new Float_t[2];
2201 arrayWeights = new Double_t[2];
2202 arrayValues[0] = valueBeforeSOR;
2203 arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
2204 arrayValues[1] = (Float_t)v->GetUInt();
2205 arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
2206 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2207 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2208 aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
2209 }
2210 else{
2211 AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
2212 return AliGRPObject::GetInvalidFloat();
2213 }
2214 }
2215 else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
2216 if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
2217 if (timestampBeforeSOR == -1){
2218 AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
2219 }
2220 if (timestampAfterEOR == -1){
2221 AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
2222 }
2223 return AliGRPObject::GetInvalidFloat();
2224 }
2225 else {
2226 AliWarning("Using last entry before SOR and first entry after EOR.");
2227 nentriesUsed = 2;
2228 arrayValues = new Float_t[2];
2229 arrayWeights = new Double_t[2];
2230 arrayValues[0] = valueBeforeSOR;
2231 arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
2232 arrayValues[1] = valueAfterEOR;
2233 arrayWeights[1] = 1.;
2234 AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0]));
2235 AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1]));
2236 aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
2237 }
2238 }
2239
2240 AliInfo(Form("mean = %f ",aDCSArrayMean));
44e45fac 2241 return aDCSArrayMean;
e7a6790f 2242
17984b61 2243}
125567f8 2244
44e45fac 2245
17984b61 2246//_______________________________________________________________
44e45fac 2247
3ba92a38 2248AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
e7a6790f 2249{
44e45fac 2250 // extract DCS pressure maps. Perform fits to save space
2251
44e45fac 2252 TMap *map = fPressure->ExtractDCS(dcsAliasMap);
2253 if (map) {
d7edf69d 2254 AliDebug(2,Form("Map has %d entries",map->GetEntries()));
44e45fac 2255 fPressure->MakeSplineFit(map);
2256 Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors();
2257 if (fitFraction > kFitFraction ) {
ce996d13 2258 AliInfo(Form("Pressure values extracted, %d fits performed for %d sensors.", fPressure->NumFits(),fPressure->NumSensors()));
44e45fac 2259 } else {
2260 AliInfo("Too few pressure maps fitted!!!");
2261 }
2262 } else {
2263 AliInfo("no atmospheric pressure map extracted!!!");
2264 }
2265 delete map;
2266
2267 return fPressure;
17984b61 2268}
e97cc90e 2269
1e27bb6b 2270
2271
2272//_______________________________________________________________
03e5ee4f 2273Int_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 2274{
44e45fac 2275 //
2276 // Retrieves logbook and trigger information from the online logbook
2277 // This information is needed for prompt reconstruction
2278 //
2279 // Parameters are:
2280 // Run number
2281 // DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
2282 // cdbRoot
2283 //
2284 // returns:
2285 // positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
2286 // 0 on success and no run was found
2287 // negative on error
2288 //
2289 // This function is NOT called during the preprocessor run in the Shuttle!
2290 //
2291
2292 // defaults
2293 if (dbPort == 0)
2294 dbPort = 3306;
2295
2296 // CDB connection
2297 AliCDBManager* cdb = AliCDBManager::Instance();
2298 cdb->SetDefaultStorage(cdbRoot);
2299
2300 // SQL connection
2301 TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
2302
2303 if (!server)
2304 {
2305 Printf("ERROR: Could not connect to DAQ LB");
2306 return -1;
2307 }
2308
2309 // main logbook
2310 TString sqlQuery;
26c1dff2 2311 sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent FROM logbook WHERE run = %d", run);
44e45fac 2312 TSQLResult* result = server->Query(sqlQuery);
2313 if (!result)
2314 {
2315 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2316 return -2;
2317 }
2318
2319 if (result->GetRowCount() == 0)
2320 {
2321 Printf("ERROR: Run %d not found", run);
2322 delete result;
2323 return -3;
2324 }
2325
2326 TSQLRow* row = result->Next();
2327 if (!row)
2328 {
2329 Printf("ERROR: Could not receive data from run %d", run);
2330 delete result;
2331 return -4;
2332 }
2333
26c1dff2 2334 TString timeStartString(row->GetField(0));
44e45fac 2335 TString runType(row->GetField(1));
26c1dff2 2336 TString detectorMaskString(row->GetField(2));
2337 TString l3CurrentString(row->GetField(3));
2338 TString dipoleCurrentString(row->GetField(4));
2339 time_t timeStart = (time_t)(timeStartString.Atoi());
2340 UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
2341 Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
2342 Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
03e5ee4f 2343 Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
2344 Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
44e45fac 2345
26c1dff2 2346 AliGRPObject * grpObj = new AliGRPObject();
2347 grpObj->SetTimeStart(timeStart);
2348 grpObj->SetRunType((TString)(row->GetField(1)));
2349 grpObj->SetDetectorMask(detectorMask);
2350 grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
2351 grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
03e5ee4f 2352 grpObj->SetL3Polarity(l3Polarity);
2353 grpObj->SetDipolePolarity(dipolePolarity);
48fcacdc 2354 grpObj->SetPolarityConventionLHC(); // after the dipole cables swap we comply with LHC convention
26c1dff2 2355
44e45fac 2356 delete row;
2357 row = 0;
2358
2359 delete result;
2360 result = 0;
2361
2362 Printf("Storing GRP/GRP/Data object with the following content");
26c1dff2 2363 grpObj->Dump();
44e45fac 2364
2365 AliCDBMetaData metadata;
26c1dff2 2366 metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
44e45fac 2367 metadata.SetComment("GRP Output parameters received during online running");
2368
2369 AliCDBId id("GRP/GRP/Data", run, run);
26c1dff2 2370 Bool_t success = cdb->Put(grpObj, id, &metadata);
44e45fac 2371
26c1dff2 2372 delete grpObj;
44e45fac 2373
2374 if (!success)
2375 {
2376 Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
2377 return -5;
2378 }
2379
2380 // Receive trigger information
2381 sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
2382 result = server->Query(sqlQuery);
2383 if (!result)
2384 {
2385 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2386 return -11;
2387 }
2388
2389 if (result->GetRowCount() == 0)
2390 {
2391 Printf("ERROR: Run %d not found in logbook_trigger_config", run);
2392 delete result;
2393 return -12;
2394 }
2395
2396 row = result->Next();
2397 if (!row)
2398 {
2399 Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
2400 delete result;
2401 return -13;
2402 }
2403
2404 TString triggerConfig(row->GetField(0));
2405
2406 delete row;
2407 row = 0;
2408
2409 delete result;
2410 result = 0;
2411
2412 Printf("Found trigger configuration: %s", triggerConfig.Data());
2413
2414 AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
2415 if (!runcfg)
2416 {
2417 Printf("ERROR: Could not create CTP configuration object");
2418 return -14;
2419 }
2420
2421 metadata.SetComment("CTP run configuration received during online running");
2422
2423 AliCDBId id2("GRP/CTP/Config", run, run);
2424 success = cdb->Put(runcfg, id2, &metadata);
2425
2426 delete runcfg;
2427 runcfg = 0;
2428
2429 if (!success)
2430 {
2431 Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
2432 return -15;
2433 }
2434
03e5ee4f 2435
2436 // Receive list of GDCs for this run
2437 sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
2438 result = server->Query(sqlQuery);
2439 if (!result)
2440 {
2441 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2442 return -24;
2443 }
2444
2445 if (result->GetRowCount() == 0)
2446 {
2447 Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
2448 delete result;
2449 return -25;
2450 }
2b81b7d0 2451
2452 gdc = "";
2453 for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
2454 row = result->Next();
2455 if (!row)
2456 {
2457 Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
2458 delete result;
2459 return -26;
2460 }
2461 gdc += row->GetField(0);
2462 gdc += " ";
2463 }
2464
03e5ee4f 2465 delete row;
2466 row = 0;
2467
2468 delete result;
2469 result = 0;
2470
2471 Printf("Found GDC: %s", gdc.Data());
2472
44e45fac 2473 // get last run with same run type that was already processed by the SHUTTLE
2474
2475 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());
2476 result = server->Query(sqlQuery);
2477 if (!result)
2478 {
2479 Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
2480 return -21;
2481 }
2482
2483 if (result->GetRowCount() == 0)
2484 {
2485 Printf("ERROR: No result with query <%s>", sqlQuery.Data());
2486 delete result;
2487 return -22;
2488 }
2489
2490 row = result->Next();
2491 if (!row)
2492 {
2493 Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
2494 delete result;
2495 return -23;
2496 }
2497
2498 TString lastRunStr(row->GetField(0));
2499 Int_t lastRun = lastRunStr.Atoi();
2500
2501 Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
2502
2503 delete row;
2504 row = 0;
2505
2506 delete result;
2507 result = 0;
2508
2509 server->Close();
2510 delete server;
2511 server = 0;
2512
2513 return lastRun;
1e27bb6b 2514}
0254e751 2515//-----------------------------------------------------------------
ac152fdd 2516Double_t AliGRPPreprocessor::CalculateMean(TObjArray* const array){
0254e751 2517
2518 //
2519 // Calculating mean over TObjArray from LHC Data
2520 //
2521
2522 TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
2523 TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
2524 if (timeStartString.IsNull() || timeStartString.IsNull()){
2525 if (timeStartString.IsNull()){
2526 AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
2527 }
2528 else if (timeStartString.IsNull()){
2529 AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
2530 }
2531 return 0;
2532 }
2533
2534 Int_t timeStart = (Int_t)(timeStartString.Atoi());
2535 Int_t timeEnd = (Int_t)(timeEndString.Atoi());
2536 timeStart = 1260646960;
2537 timeEnd = 1260652740;
2538 Double_t* parameters = new Double_t[5];
2539 parameters[0] = -1.;
2540 parameters[1] = -1.;
2541 parameters[2] = -1.;
2542 parameters[3] = -1.;
2543 parameters[4] = -1.;
2544 Int_t iCounts = 0;
2545 Int_t iCountsRun = 0;
2546 Int_t nCounts = array->GetEntries();
2547 printf("ncounts = %d\n",nCounts);
2548 Double_t valueBeforeSOR = 0;
2549 Double_t valueAfterEOR = 0;
2550 Double_t timestampBeforeSOR = -1.;
2551 Double_t timestampAfterEOR = -1.;
2552 Int_t ientrySOR = -1;
2553 Int_t ientryEOR = -1;
2554 Double_t* arrayValues = 0x0;
2555 Double_t* arrayWeights = 0x0;
2556 Bool_t truncMeanFlag = kTRUE; // flag to indicate whether Truncated Mean should be calculated or not
2557 Bool_t sdFlag = kTRUE; // flag to indicate whether SD (wrt Mean/Median) should be calculated or not
2558
2559 for(Int_t i = 0; i < nCounts; i++) {
2560 AliDCSArray *dcs = (AliDCSArray*)array->At(i);
2561 if((dcs->GetTimeStamp() >= timeStart) &&(dcs->GetTimeStamp() <= timeEnd)) {
2562 AliDebug(2,Form("%d-th entry = %f at timestamp %f\n",i,(Double_t)(dcs->GetInt(0)),dcs->GetTimeStamp()));
2563 iCounts += 1;
2564 // look for the last value before SOR and the first value before EOR
2565 if ((dcs->GetTimeStamp() >= timeStart) && (dcs->GetTimeStamp() < timeStart)) {
2566 timestampBeforeSOR = dcs->GetTimeStamp();
2567 AliDebug(2,Form("timestamp of last value before SOR = %f, with DAQ_time_start = %d\n",timestampBeforeSOR,timeStart));
2568 valueBeforeSOR = (Double_t)(dcs->GetInt(0));
2569 }
2570 else if ((dcs->GetTimeStamp() <= timeEnd) && (dcs->GetTimeStamp() > timeEnd) && timestampAfterEOR == -1){
2571 timestampAfterEOR = dcs->GetTimeStamp();
2572 valueAfterEOR = (Double_t)(dcs->GetInt(0));
2573 AliDebug(2,Form("timestamp of first value after EOR = %f, with DAQ_time_end = %d\n",timestampAfterEOR,timeEnd));
2574 }
2575 // check if there are DPs between DAQ_time_start and DAQ_time_end
2576 if((dcs->GetTimeStamp() >= timeStart) &&(dcs->GetTimeStamp() <= timeEnd)) {
2577 if (ientrySOR == -1) ientrySOR = i; // first entry after SOR
2578 if (ientryEOR < i) ientryEOR = i; // last entry before EOR
2579 AliDebug(2,Form("entry between SOR and EOR\n"));
2580 iCountsRun += 1;
2581 }
2582 }
2583 else {
2584 printf("DCS values for the parameter outside the queried interval: timestamp = %f\n",dcs->GetTimeStamp());
2585 }
2586 }
2587
2588 if (timestampBeforeSOR == -1.){
2589 printf("No value found before SOR\n");
2590 }
2591 if (timestampAfterEOR == -1.){
2592 printf("No value found after EOR\n");
2593 }
2594
2595 printf("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries\n",iCounts,nCounts);
2596 printf("Last value before DAQ_time_start (SOR) = %f at timestamp = %f\n",valueBeforeSOR,timestampBeforeSOR);
2597 printf("First value after DAQ_time_end (EOR) = %f at timestamp = %f\n",valueAfterEOR,timestampAfterEOR);
2598 printf("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)\n",iCountsRun);
2599 printf("Index of first entry after DAQ_time_start (SOR) = %d\n ",ientrySOR);
2600 printf("Index of first entry before DAQ_time_end (EOR) = %d\n ",ientryEOR);
2601
2602 Int_t nentriesUsed = 0;
2603 if (iCountsRun > 1){
2604 printf("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)\n");
2605 printf("Calculating (weighted) Mean and Median\n" );
2606 arrayValues = new Double_t[iCountsRun];
2607 arrayWeights = new Double_t[iCountsRun];
2608 nentriesUsed = iCountsRun;
2609 for (Int_t i = ientrySOR; i <= ientryEOR; i++){
2610 AliDCSArray *dcs = (AliDCSArray *)array->At(i);
2611 Double_t timestamp2 = 0;
2612 if (i < ientryEOR){
2613 AliDCSArray *dcs1 = (AliDCSArray *)array->At(i+1);
2614 timestamp2 = dcs1->GetTimeStamp();
2615 }
2616 else {
2617 timestamp2 = (Double_t)timeEnd+1;
2618 }
2619 arrayWeights[i-ientrySOR] = (Double_t)((Double_t)timestamp2 - dcs->GetTimeStamp());
2620 arrayValues[i-ientrySOR] = (Double_t)(dcs->GetInt(0));
2621 printf("Entry %d: value = %f, weight = %f\n",i-ientrySOR,arrayValues[i-ientrySOR],arrayWeights[i-ientrySOR]);
2622 }
2623 parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
2624 parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
2625 }
2626 else if (iCountsRun == 1){
2627 AliDCSArray* dcs = (AliDCSArray *)array->At(ientrySOR);
2628 nentriesUsed = 2;
2629 if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)dcs->GetTimeStamp()){
2630 printf("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR. Truncated mean won't be calculated.\n");
2631 arrayValues = new Double_t[2];
2632 arrayWeights = new Double_t[2];
2633 arrayValues[0] = valueBeforeSOR;
2634 arrayWeights[0] = (Double_t)(dcs->GetTimeStamp()-(Double_t)timestampBeforeSOR);
2635 arrayValues[1] = (Double_t)(dcs->GetInt(0));
2636 arrayWeights[1] = (Double_t)((Double_t)timeEnd+1-dcs->GetTimeStamp());
2637 printf("value0 = %f, with weight = %f\n",arrayValues[0],arrayWeights[0]);
2638 printf("value1 = %f, with weight = %f\n",arrayValues[1],arrayWeights[1]);
2639 parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
2640 parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
2641 truncMeanFlag = kFALSE;
2642 }
2643 else{
2644 printf("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\n");
2645 parameters[0] = -1;
2646 parameters[1] = -1;
2647 parameters[2] = -1;
2648 parameters[3] = -1;
2649 parameters[4] = -1;
2650 return parameters[0];
2651 }
2652 }
2653 else { // iCountsRun == 0, using only the point immediately before SOR
2654 if (timestampBeforeSOR == -1.){
2655 printf("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\n");
2656 parameters[0] = -1;
2657 parameters[1] = -1;
2658 parameters[2] = -1;
2659 parameters[3] = -1;
2660 parameters[4] = -1;
2661 return parameters[0];
2662 }
2663 else {
2664 printf("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.\n");
2665 printf("value = %f\n",valueBeforeSOR);
2666 parameters[0] = valueBeforeSOR;
2667 parameters[2] = valueBeforeSOR;
2668 truncMeanFlag = kFALSE;
2669 sdFlag = kFALSE;
2670 }
2671 }
2672
2673 Double_t temp = 0;
2674 Double_t temp1 = 0;
2675 Double_t sumweights = 0;
2676 Int_t entriesTruncMean = 0;
2677 Double_t* arrayValuesTruncMean = new Double_t[nentriesUsed];
2678 Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed];
2679
2680 // calculating SD wrt Mean and Median
2681 printf("Calculating SD wrt Mean and SD wrt Median\n");
2682 if (sdFlag){
2683 for (Int_t i =0; i< nentriesUsed; i++){
2684 //printf("Entry %d: value = %f, weight = %f\n",i,arrayValues[i],arrayWeights[i]);
2685 temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
2686 temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
2687 sumweights += arrayWeights[i];
2688 }
2689 // setting SD wrt Mean
2690 if (sumweights != 0 ){
2691 parameters[3] = TMath::Sqrt(temp1/sumweights);
2692 }
2693 else {
2694 printf("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid\n");
2695 parameters[3] = -1;
2696 }
2697 // setting SD wrt Median
2698 if (nentriesUsed != 0){
2699 parameters[4] = TMath::Sqrt(temp/nentriesUsed);
2700 }
2701 else{
2702 printf("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid\n");
2703 parameters[4] = -1;
2704 }
2705 }
2706 else {
2707 parameters[3] = -1;
2708 parameters[4] = -1;
2709 }
2710
2711 // calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
2712 if (truncMeanFlag){
2713 printf("Calculating Truncated Mean\n");
2714 for (Int_t i =0; i< nentriesUsed; i++){
2715 //printf("Entry %d: value = %f, weight = %f\n",i,arrayValues[i],arrayWeights[i]);
2716 if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
2717 arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
2718 arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
2719 printf("For Truncated Mean: Entry %d: value = %f, weight = %f\n",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]);
2720 entriesTruncMean++;
2721 }
2722 else{
2723 printf("Discarding entry\n");
2724 }
2725 }
2726 // setting truncated mean
2727 if (entriesTruncMean >1){
2728 printf("%d entries used for truncated mean\n",entriesTruncMean);
2729 parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
2730 }
2731 else{
2732 printf("Too few entries (%d) to calculate truncated mean\n",entriesTruncMean);
2733 parameters[1] = -1;
2734 }
2735 }
2736 else{
2737 parameters[1] = -1;
2738 }
2739
2740 printf("(weighted) mean = %f \n",parameters[0]);
2741 printf("(weighted) truncated mean = %f \n",parameters[1]);
2742 printf("median = %f \n",parameters[2]);
2743 printf("(weighted) standard deviation with (weighted) mean = %f \n",parameters[3]);
2744 printf("standard deviation with median = %f \n",parameters[4]);
2745
2746 return (parameters[0]);
2747}
2748//------------------------------------------------------------------------------------------------------
4cbf81c1 2749Float_t AliGRPPreprocessor::ProcessEnergy(TObjArray* const array, Double_t timeStart){
0254e751 2750
2751 //
2752 // Method to processo LHC Energy information
2753 // Only the first value is returned, provided that it is withing DAQ_time_start and DAQ_time_end
2754 //
2755
2756 Int_t nCounts = array->GetEntries();
2757 Float_t energy = -1;
4cbf81c1 2758 Double_t timeEnergy = -1;
2759 Int_t indexEnergy = -1;
2760 Bool_t foundEnergy = kFALSE;
2761
0254e751 2762 AliDebug(2,Form("Energy measurements = %d\n",nCounts));
0d361338 2763 if (nCounts ==0){
2764 AliWarning("No Energy values found! Beam Energy remaining invalid!");
2765 }
2766 else{
4cbf81c1 2767 for (Int_t i = 0; i < nCounts; i++){
0d361338 2768 AliDCSArray *dcs = (AliDCSArray*)array->At(i);
4cbf81c1 2769 if (dcs){
2770 if (dcs->GetTimeStamp()<=timeStart && dcs->GetTimeStamp()>=timeEnergy){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
2771 timeEnergy = dcs->GetTimeStamp();
2772 indexEnergy = i;
2773 foundEnergy = kTRUE;
2774 }
2775 else{
2776 break;
2777 }
0d361338 2778 }
0254e751 2779 }
4cbf81c1 2780 if (!foundEnergy){
2781 AliInfo("No value for the Energy found before start of run, the Energy will remain invalid");
2782 }
2783 else {
2784 AliDCSArray* dcs = (AliDCSArray*)array->At(indexEnergy);
2785 energy = (Float_t)(TMath::Nint(((Double_t)(dcs->GetInt(0)))*120/1000)); // sqrt(s)/2 energy in GeV
2786 AliInfo(Form("Energy value found = %d (at %f), converting --> sqrt(s)/2 = %f (GeV)", dcs->GetInt(0),dcs->GetTimeStamp(),energy));
e541e2aa 2787 }
0254e751 2788 }
2789
2790 return energy;
2791}