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