Coverity 16571
[u/mrichter/AliRoot.git] / STEER / AliGRPObject.cxx
CommitLineData
29d11b68 1/**************************************************************************
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
16/* $Id$ */
17
18// **********************
19// Class containing the GRP data that have to be stored in the OCDB.
20// Data come either from DAQ logbook or from DCS DB.
21// Processing of the data can also be performed here.
22// **********************
23
24#include <TMap.h>
25#include <TObject.h>
26#include <TObjString.h>
27
28#include "AliGRPObject.h"
29#include "AliDCSSensor.h"
30#include "AliLog.h"
31
32ClassImp(AliGRPObject)
de67dd6b 33
34const Double_t kCavernCut = 1.0; // tolerable difference between cavern pressure sensors
35const Double_t kSurfaceDifference = 4.5; // offset between surface and cavern pressure sensors
29d11b68 36
37const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float
38const TString AliGRPObject::fgkInvalidString = ""; // value to identify invalid data - string
39const Char_t AliGRPObject::fgkInvalidChar = -1; // value to identify invalid data - uchar
40const Int_t AliGRPObject::fgkInvalidInt = -1; // value to identify invalid data - uint
41const Int_t AliGRPObject::fgkInvalidUInt = 0; // value to identify invalid data - uint
42const Int_t AliGRPObject::fgknDCSDPHallProbes = 40; // number of dcs dps
43const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {
44 "L3_BSF17_H1",
45 "L3_BSF17_H2",
46 "L3_BSF17_H3",
47 "L3_BSF17_Temperature",
48 "L3_BSF4_H1",
49 "L3_BSF4_H2",
50 "L3_BSF4_H3",
51 "L3_BSF4_Temperature",
52 "L3_BKF17_H1",
53 "L3_BKF17_H2",
54 "L3_BKF17_H3",
55 "L3_BKF17_Temperature",
56 "L3_BKF4_H1",
57 "L3_BKF4_H2",
58 "L3_BKF4_H3",
59 "L3_BKF4_Temperature",
60 "L3_BSF13_H1",
61 "L3_BSF13_H2",
62 "L3_BSF13_H3",
63 "L3_BSF13_Temperature",
64 "L3_BSF8_H1",
65 "L3_BSF8_H2",
66 "L3_BSF8_H3",
67 "L3_BSF8_Temperature",
68 "L3_BKF13_H1",
69 "L3_BKF13_H2",
70 "L3_BKF13_H3",
71 "L3_BKF13_Temperature",
72 "L3_BKF8_H1",
73 "L3_BKF8_H2",
74 "L3_BKF8_H3",
75 "L3_BKF8_Temperature",
76 "Dipole_Inside_H1",
77 "Dipole_Inside_H2",
78 "Dipole_Inside_H3",
79 "Dipole_Inside_Temperature",
80 "Dipole_Outside_H1",
81 "Dipole_Outside_H2",
82 "Dipole_Outside_H3",
83 "Dipole_Outside_Temperature",
84 };
85
86//-----------------------------------------------------------------------------
87AliGRPObject::AliGRPObject():
88 TObject(),
89 fPoints(5),
90 fDimension(0),
91 fTimeStart((time_t)fgkInvalidFloat),
92 fTimeEnd((time_t)fgkInvalidFloat),
93 fBeamEnergy(fgkInvalidFloat),
94 fBeamType(fgkInvalidString),
95 fNumberOfDetectors(fgkInvalidChar),
96 fDetectorMask(fgkInvalidUInt),
97 fLHCPeriod(fgkInvalidString),
98 fRunType(fgkInvalidString),
99 fLHCState(fgkInvalidString),
100 fL3Polarity(fgkInvalidChar),
101 fDipolePolarity(fgkInvalidChar),
102 fL3Current(new Float_t[fPoints]),
103 fDipoleCurrent(new Float_t[fPoints]),
104 fCavernTemperature(new Float_t[fPoints]),
105 fCavernAtmosPressure(0x0),
106 fCavernAtmosPressure2(0x0),
107 fSurfaceAtmosPressure(0x0),
108 fHallProbes(0x0),
109 fMachineMode(fgkInvalidString),
110 fLHCStateArray(0x0),
111 fMachineModeArray(0x0),
112 fMaxTimeLHCValidity(0)
113{
114
115 //
116 // AliGRPObject default ctor
117 //
118
119 fDimension = fgknDCSDPHallProbes*fPoints;
120 fHallProbes = new Float_t[fDimension];
121
122 for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP
123 if ((nhp >= 0 && nhp <= 1*fPoints-1) || // L3_BSF17_H1
124 (nhp >= 1*fPoints && nhp <= 2*fPoints-1) || // L3_BSF17_H2
125 (nhp >= 2*fPoints && nhp <= 3*fPoints-1) || // L3_BSF17_H3
126 (nhp >= 3*fPoints && nhp <= 4*fPoints-1) || // L3_BSF17_Temperature
127 (nhp >= 6*fPoints && nhp <= 7*fPoints-1) ) { // L3_BSF4_H3
128 fHallProbes[nhp] = 0; // setting to zero values for non working HP
129 AliDebug(2,Form("setting hp[%d] to zero = %f",
130nhp, fHallProbes[nhp]));
131 }
132 else {
133 fHallProbes[nhp] = fgkInvalidFloat;
134 }
135 }
136
137
138 for (Int_t i = 0; i < fPoints; i++){
139
140 fL3Current[i] = fgkInvalidFloat;
141 fDipoleCurrent[i] = fgkInvalidFloat;
142 fCavernTemperature[i] = fgkInvalidFloat;
143 }
144}
145
146//-----------------------------------------------------------------------------
147
148AliGRPObject::AliGRPObject(const AliGRPObject &obj):
149 TObject(obj),
150 fPoints(obj.fPoints),
151 fDimension(obj.fDimension),
152 fTimeStart(obj.fTimeStart),
153 fTimeEnd(obj.fTimeEnd),
154 fBeamEnergy(obj.fBeamEnergy),
155 fBeamType(obj.fBeamType),
156 fNumberOfDetectors(obj.fNumberOfDetectors),
157 fDetectorMask(obj.fDetectorMask),
158 fLHCPeriod(obj.fLHCPeriod),
159 fRunType(obj.fRunType),
160 fLHCState(obj.fLHCState),
161 fL3Polarity(obj.fL3Polarity),
162 fDipolePolarity(obj.fDipolePolarity),
163 fL3Current(new Float_t[fPoints]),
164 fDipoleCurrent(new Float_t[fPoints]),
165 fCavernTemperature(new Float_t[fPoints]),
166 fCavernAtmosPressure(obj.fCavernAtmosPressure),
167 fCavernAtmosPressure2(obj.fCavernAtmosPressure2),
168 fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),
169 fHallProbes(0x0),
170 fMachineMode(obj.fMachineMode),
171 fLHCStateArray(obj.fLHCStateArray),
172 fMachineModeArray(obj.fMachineModeArray),
173 fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)
174
175{
176
177 //
178 // AliGRPObject copy ctor
179 //
180
181 fHallProbes = new Float_t[fDimension];
182
183 for (Int_t nhp=0; nhp< fDimension; nhp++){
184 fHallProbes[nhp] = obj.fHallProbes[nhp];
185 }
186
187 for (Int_t i = 0; i < fPoints; i++){
188
189 fL3Current[i] = obj.fL3Current[i];
190 fDipoleCurrent[i] = obj.fDipoleCurrent[i];
191 fCavernTemperature[i] = obj.fCavernTemperature[i];
192 }
193}
194
195//-----------------------------------------------------------------------------
196
197AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj)
198{
199
200 //
201 // AliGRPObject assignment operator
202 //
203
204 if (&obj == this) return *this;
205
206 TObject::operator=(obj);
207 this->fTimeStart = obj.GetTimeStart();
208 this->fTimeEnd = obj.GetTimeEnd();
209 this->fBeamEnergy = obj.GetBeamEnergy();
210 this->fBeamType = obj.GetBeamType();
211 this->fNumberOfDetectors = obj.GetNumberOfDetectors();
212 this->fDetectorMask = obj.GetDetectorMask();
213 this->fLHCPeriod = obj.GetLHCPeriod();
214 this->fRunType = obj.GetRunType();
215 this->fLHCState = obj.GetLHCState();
216 this->fL3Polarity = obj.GetL3Polarity();
217 this->fDipolePolarity = obj.GetDipolePolarity();
218 this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();
219 this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();
220 this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();
221 this->fPoints = obj.GetPoints();
222 this->fDimension = obj.GetDimension();
223
224 this->fL3Current = new Float_t[fPoints];
225 this->fDipoleCurrent = new Float_t[fPoints];
226 this->fCavernTemperature = new Float_t[fPoints];
227
228 if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension];
229 for (Int_t nhp=0; nhp< fDimension; nhp++){
230 this->fHallProbes[nhp] = obj.GetHallProbes(nhp);
231
232 }
233 for (Int_t i = 0; i < fPoints; i++){
234
235 this->fL3Current[i] = obj.GetL3Current((Stats)i);
236 this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);
237 this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);
238 }
239
240 this->fMachineMode = obj.fMachineMode;
241 this->fLHCStateArray = obj.fLHCStateArray;
242 this->fMachineModeArray = obj.fMachineModeArray;
243 this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
244 return *this;
245}
246
247//-----------------------------------------------------------------------------
248
249AliGRPObject::~AliGRPObject() {
250
251 //
252 // dtor
253 //
254
255
256 delete [] fHallProbes;
257 delete [] fL3Current;
258 delete [] fDipoleCurrent;
259 delete [] fCavernTemperature;
260
261 if (fCavernAtmosPressure){
262 delete fCavernAtmosPressure;
263 fCavernAtmosPressure = 0x0;
264 }
265 if (fCavernAtmosPressure2){
266 delete fCavernAtmosPressure2;
267 fCavernAtmosPressure2 = 0x0;
268 }
269 if (fSurfaceAtmosPressure){
270 delete fSurfaceAtmosPressure;
271 fSurfaceAtmosPressure = 0x0;
272 }
273 if (fLHCStateArray){
274 delete fLHCStateArray;
275 fLHCStateArray = 0x0;
276 }
277 if (fMachineModeArray){
278 delete fMachineModeArray;
279 fMachineModeArray = 0x0;
280 }
281}
282
283//-----------------------------------------------------------------------------
284Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {
285
286 //
287 // method to return array of statistical
288 // variables for Hall Probe hp
289 //
290
291 Float_t* array = new Float_t[fPoints];
292 Int_t shift = fPoints*(Int_t)hp;
293 for (Int_t i=0;i<fPoints; i++){
294
295 array[i] = fHallProbes[shift+i];
296
297 }
298
299 return array;
300}
301//-------------------------------------------------------------------------------
302
303void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){
304
305 //
306 // method to set hall probe hp
307 // from a given array
308 //
309
310 Int_t shift = fPoints*hp;
311 for (Int_t i = 0; i< fPoints; i++){
312
313 fHallProbes[i+shift] = hall_probe[i];
314 }
315 return;
316}
317
318//-------------------------------------------------------------------------------
319
320void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){
321
322 //
323 // method to set the values of the GRP parameters
324 // reading them from the old format of the GRP
325 // object, i.e. a TMap
326 //
327
328 if (mapGRP->GetValue("fAliceStartTime")){
329 SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());
330 }
331 else {
332 AliError(Form("No fAliceStartTime value found in GRP map!"));
333 }
334 if (mapGRP->GetValue("fAliceStopTime")){
335 SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());
336 }
337
338 else {
339 AliError(Form("No fAliceStopTime value found in GRP map!"));
340 }
341
342 if(mapGRP->GetValue("fAliceBeamEnergy")){
343 double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();
344 if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2; // old format was storig sqrt(s)
345 SetBeamEnergy(be);
346 }
347 else {
348 AliError(Form("No fAliceBeamEnergy value found in GRP map!"));
349 }
350 if(mapGRP->GetValue("fAliceBeamType")){
351 SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());
352 }
353 else {
354 AliError(Form("No fAliceBeamType value found in GRP map!"));
355 }
356 if(mapGRP->GetValue("fNumberOfDetectors")){
357 SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi());
358 }
359 else {
360 AliError(Form("No fNumberOfDetectors value found in GRP map!"));
361 }
362 if(mapGRP->GetValue("fDetectorMask")){
363 SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());
364 }
365 else {
366 AliError(Form("No fDetectorMask value found in GRP map!"));
367 }
368 if(mapGRP->GetValue("fLHCPeriod")){
369 SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());
370 }
371 else {
372 AliError(Form("No fLHCPeriod value found in GRP map!"));
373 }
374 if(mapGRP->GetValue("fRunType")){
375 SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());
376 }
377 else {
378 AliError(Form("No fRunType value found in GRP map!"));
379 }
380 if(mapGRP->GetValue("fLHCState")){
381 SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());
382 }
383 else {
384 AliError(Form("No fLHCState value found in GRP map!"));
385 }
386 if(mapGRP->GetValue("fLHCluminosity")){
387 AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));
388 }
389 else {
390 AliError(Form("No fLHCLuminosity value found in GRP map!"));
391 }
392 if(mapGRP->GetValue("fBeamIntensity")){
393 AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));
394 }
395 else {
396 AliError(Form("No fBeamIntensity value found in GRP map!"));
397 }
398 if(mapGRP->GetValue("fL3Polarity")){
399 SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());
400 }
401 else {
402 AliError(Form("No fL3Polarity value found in GRP map!"));
403 }
404 if(mapGRP->GetValue("fDipolePolarity")){
405 SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());
406 }
407 else {
408 AliError(Form("No fDipolePolarity value found in GRP map!"));
409 }
410 if(mapGRP->GetValue("fL3Current")){
411 AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));
412 SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);
413 }
414 else {
415 AliError(Form("No fL3Current value found in GRP map!"));
416 }
417 if(mapGRP->GetValue("fDipoleCurrent")){
418 AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));
419 SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);
420 }
421 else {
422 AliError(Form("No fDipoleCurrent value found in GRP map!"));
423 }
424 if(mapGRP->GetValue("fCavernTemperature")){
425 AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));
426 SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);
427 }
428 else {
429 AliError(Form("No fCavernTemperature value found in GRP map!"));
430 }
431 if(mapGRP->GetValue("fCavernAtmosPressure")){
432 AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));
433 }
434 else {
435 AliError(Form("No fCavernAtmosPressure value found in GRP map!"));
436 }
437 if(mapGRP->GetValue("fP2Pressure")){
438 SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));
439 }
440 else {
441 AliError(Form("No fP2Pressure value found in GRP map!"));
442 }
443
444 return;
445
446}
549ab3c2 447//-------------------------------------------------------------------------------
448
449Float_t AliGRPObject::GetBeamEnergy() const {
450
451 //
452 // Getting the energy
453 // in case of BeamType = A-A, multiplying by 82/208 (for PbPb)
454 //
455
456 Float_t energy = fBeamEnergy;
457 if (fBeamType=="A-A"){
458 energy = energy*82./208;
459 }
460 return IsBeamEnergyIsSqrtSHalfGeV() ? energy : energy/2;
461}
de67dd6b 462
463//-------------------------------------------------------------------------------
464
465Double_t AliGRPObject::EvalCavernPressure(const TTimeStamp& time, Bool_t& inside) const {
466//
467// Return current pressure value from 'best' cavern sensor
468// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
469// use sensor most compatible with surface sensor
470
471 return EvalCavernPressure(fCavernAtmosPressure,fCavernAtmosPressure2,
472 fSurfaceAtmosPressure,time,inside);
473
474}
475
476//-------------------------------------------------------------------------------
477
478Double_t AliGRPObject::EvalCavernPressure(AliDCSSensor* cavern1,
479 AliDCSSensor* cavern2, AliDCSSensor* surface,
480 const TTimeStamp& time, Bool_t& inside) {
481//
482// Return current pressure value from 'best' cavern sensor
483// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
484// use sensor most compatible with surface sensor
485
486
487 Double_t valueSensor2 = cavern2->Eval(time,inside);
488 Double_t valueSensor1 = cavern1->Eval(time,inside);
489 if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
490 return valueSensor2;
491 } else {
492 Double_t valueSurface = surface->Eval(time,inside);
493 Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
494 Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
495 if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
496 return valueSensor1;
497 } else {
498 return valueSensor2;
499 }
500 }
501}
502
503//-------------------------------------------------------------------------------
504
505AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(AliDCSSensor* cavern1,
506 AliDCSSensor* cavern2, AliDCSSensor* surface, const TTimeStamp& time) {
507
508//
509// Return pointer to 'best' cavern sensor
510// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
511// use sensor most compatible with surface sensor
512// Pressure measuread at time specified by TTimestamp
513
514
515 Bool_t inside;
516 Double_t valueSensor2 = cavern2->Eval(time,inside);
517 Double_t valueSensor1 = cavern1->Eval(time,inside);
518 if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
519 return cavern2;
520 } else {
521 Double_t valueSurface = surface->Eval(time,inside);
522 Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
523 Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
524 if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
525 return cavern1;
526 } else {
527 return cavern2;
528 }
529 }
530}
531
532//-------------------------------------------------------------------------------
533
534AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(const TTimeStamp& time) const {
535//
536// Return pointer to 'best' cavern sensor
537// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
538// use sensor most compatible with surface sensor
539// Pressure measuread at time specified by TTimestamp
540
541
542 return GetBestCavernAtmosPressure(fCavernAtmosPressure,
543 fCavernAtmosPressure2, fSurfaceAtmosPressure, time);
544
545}
546
547//-------------------------------------------------------------------------------
548
549AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure() const {
550//
551// Return pointer to 'best' cavern sensor
552// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
553// use sensor most compatible with surface sensor
554// Pressure measuread at start-of-run
555
556 return GetBestCavernAtmosPressure(TTimeStamp(fTimeStart));
557}
558