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