]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/STEER/AliGRPObject.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
adding return for non-void function
[u/mrichter/AliRoot.git] / STEER / 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),
92664bc8 112 fQATrigClasses(0x0),
113 fQACloningRequest(0x0),
26fd9395 114 fMaxTimeLHCValidity(0),
115 fNFalseDataQualityFlag(0),
81a1addb 116 fFalseDataQualityFlag(0x0),
117 fBeamTypeFromLHC(fgkInvalidString)
29d11b68 118{
119
120 //
121 // AliGRPObject default ctor
122 //
123
124 fDimension = fgknDCSDPHallProbes*fPoints;
125 fHallProbes = new Float_t[fDimension];
126
127 for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP
128 if ((nhp >= 0 && nhp <= 1*fPoints-1) || // L3_BSF17_H1
129 (nhp >= 1*fPoints && nhp <= 2*fPoints-1) || // L3_BSF17_H2
130 (nhp >= 2*fPoints && nhp <= 3*fPoints-1) || // L3_BSF17_H3
131 (nhp >= 3*fPoints && nhp <= 4*fPoints-1) || // L3_BSF17_Temperature
132 (nhp >= 6*fPoints && nhp <= 7*fPoints-1) ) { // L3_BSF4_H3
133 fHallProbes[nhp] = 0; // setting to zero values for non working HP
134 AliDebug(2,Form("setting hp[%d] to zero = %f",
135nhp, fHallProbes[nhp]));
136 }
137 else {
138 fHallProbes[nhp] = fgkInvalidFloat;
139 }
140 }
141
142
143 for (Int_t i = 0; i < fPoints; i++){
144
145 fL3Current[i] = fgkInvalidFloat;
146 fDipoleCurrent[i] = fgkInvalidFloat;
147 fCavernTemperature[i] = fgkInvalidFloat;
148 }
53b0ec45 149
150 for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
151 fSeparateBeamType[ibeamType] = fgkInvalidString;
152 }
29d11b68 153}
154
155//-----------------------------------------------------------------------------
156
157AliGRPObject::AliGRPObject(const AliGRPObject &obj):
158 TObject(obj),
159 fPoints(obj.fPoints),
160 fDimension(obj.fDimension),
161 fTimeStart(obj.fTimeStart),
162 fTimeEnd(obj.fTimeEnd),
163 fBeamEnergy(obj.fBeamEnergy),
164 fBeamType(obj.fBeamType),
165 fNumberOfDetectors(obj.fNumberOfDetectors),
166 fDetectorMask(obj.fDetectorMask),
167 fLHCPeriod(obj.fLHCPeriod),
168 fRunType(obj.fRunType),
169 fLHCState(obj.fLHCState),
170 fL3Polarity(obj.fL3Polarity),
171 fDipolePolarity(obj.fDipolePolarity),
172 fL3Current(new Float_t[fPoints]),
173 fDipoleCurrent(new Float_t[fPoints]),
174 fCavernTemperature(new Float_t[fPoints]),
175 fCavernAtmosPressure(obj.fCavernAtmosPressure),
176 fCavernAtmosPressure2(obj.fCavernAtmosPressure2),
177 fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),
178 fHallProbes(0x0),
179 fMachineMode(obj.fMachineMode),
180 fLHCStateArray(obj.fLHCStateArray),
181 fMachineModeArray(obj.fMachineModeArray),
92664bc8 182 fQATrigClasses(obj.fQATrigClasses),
183 fQACloningRequest(obj.fQACloningRequest),
26fd9395 184 fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity),
185 fNFalseDataQualityFlag(obj.fNFalseDataQualityFlag),
81a1addb 186 fFalseDataQualityFlag(obj.fFalseDataQualityFlag),
187 fBeamTypeFromLHC(obj.fBeamTypeFromLHC)
26fd9395 188
29d11b68 189
190{
191
192 //
193 // AliGRPObject copy ctor
194 //
195
196 fHallProbes = new Float_t[fDimension];
197
198 for (Int_t nhp=0; nhp< fDimension; nhp++){
199 fHallProbes[nhp] = obj.fHallProbes[nhp];
200 }
201
202 for (Int_t i = 0; i < fPoints; i++){
203
204 fL3Current[i] = obj.fL3Current[i];
205 fDipoleCurrent[i] = obj.fDipoleCurrent[i];
206 fCavernTemperature[i] = obj.fCavernTemperature[i];
207 }
53b0ec45 208
209 for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
210 fSeparateBeamType[ibeamType] = obj.fSeparateBeamType[ibeamType];
211 }
29d11b68 212}
213
214//-----------------------------------------------------------------------------
215
216AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj)
217{
218
219 //
220 // AliGRPObject assignment operator
221 //
222
223 if (&obj == this) return *this;
224
225 TObject::operator=(obj);
226 this->fTimeStart = obj.GetTimeStart();
227 this->fTimeEnd = obj.GetTimeEnd();
228 this->fBeamEnergy = obj.GetBeamEnergy();
229 this->fBeamType = obj.GetBeamType();
230 this->fNumberOfDetectors = obj.GetNumberOfDetectors();
231 this->fDetectorMask = obj.GetDetectorMask();
232 this->fLHCPeriod = obj.GetLHCPeriod();
233 this->fRunType = obj.GetRunType();
234 this->fLHCState = obj.GetLHCState();
235 this->fL3Polarity = obj.GetL3Polarity();
236 this->fDipolePolarity = obj.GetDipolePolarity();
237 this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();
238 this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();
239 this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();
240 this->fPoints = obj.GetPoints();
241 this->fDimension = obj.GetDimension();
242
243 this->fL3Current = new Float_t[fPoints];
244 this->fDipoleCurrent = new Float_t[fPoints];
245 this->fCavernTemperature = new Float_t[fPoints];
246
247 if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension];
248 for (Int_t nhp=0; nhp< fDimension; nhp++){
249 this->fHallProbes[nhp] = obj.GetHallProbes(nhp);
250
251 }
252 for (Int_t i = 0; i < fPoints; i++){
253
254 this->fL3Current[i] = obj.GetL3Current((Stats)i);
255 this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);
256 this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);
257 }
258
259 this->fMachineMode = obj.fMachineMode;
260 this->fLHCStateArray = obj.fLHCStateArray;
261 this->fMachineModeArray = obj.fMachineModeArray;
262 this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
53b0ec45 263
92664bc8 264 this->fQATrigClasses = obj.fQATrigClasses;
265 this->fQACloningRequest = obj.fQACloningRequest;
266
53b0ec45 267 for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
268 this->fSeparateBeamType[ibeamType] = obj.fSeparateBeamType[ibeamType];
269 }
270
26fd9395 271 this->fNFalseDataQualityFlag = obj.fNFalseDataQualityFlag;
272 this->fFalseDataQualityFlag = obj.fFalseDataQualityFlag;
81a1addb 273 this->fBeamTypeFromLHC = obj.fBeamTypeFromLHC;
26fd9395 274
29d11b68 275 return *this;
276}
277
278//-----------------------------------------------------------------------------
279
280AliGRPObject::~AliGRPObject() {
281
282 //
283 // dtor
284 //
285
286
287 delete [] fHallProbes;
288 delete [] fL3Current;
289 delete [] fDipoleCurrent;
290 delete [] fCavernTemperature;
291
292 if (fCavernAtmosPressure){
293 delete fCavernAtmosPressure;
294 fCavernAtmosPressure = 0x0;
295 }
296 if (fCavernAtmosPressure2){
297 delete fCavernAtmosPressure2;
298 fCavernAtmosPressure2 = 0x0;
299 }
300 if (fSurfaceAtmosPressure){
301 delete fSurfaceAtmosPressure;
302 fSurfaceAtmosPressure = 0x0;
303 }
304 if (fLHCStateArray){
305 delete fLHCStateArray;
306 fLHCStateArray = 0x0;
307 }
308 if (fMachineModeArray){
309 delete fMachineModeArray;
310 fMachineModeArray = 0x0;
311 }
92664bc8 312 if (fQATrigClasses) {
313 delete fQATrigClasses;
314 fQATrigClasses = 0x0;
315 }
316 if (fQACloningRequest) {
317 delete fQACloningRequest;
318 fQACloningRequest = 0x0;
319 }
26fd9395 320 if (fFalseDataQualityFlag){
321 delete fFalseDataQualityFlag;
322 fFalseDataQualityFlag = 0x0;
323 }
29d11b68 324}
325
326//-----------------------------------------------------------------------------
327Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {
328
329 //
330 // method to return array of statistical
331 // variables for Hall Probe hp
332 //
333
334 Float_t* array = new Float_t[fPoints];
335 Int_t shift = fPoints*(Int_t)hp;
336 for (Int_t i=0;i<fPoints; i++){
337
338 array[i] = fHallProbes[shift+i];
339
340 }
341
342 return array;
343}
344//-------------------------------------------------------------------------------
345
346void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){
347
348 //
349 // method to set hall probe hp
350 // from a given array
351 //
352
353 Int_t shift = fPoints*hp;
354 for (Int_t i = 0; i< fPoints; i++){
355
356 fHallProbes[i+shift] = hall_probe[i];
357 }
358 return;
359}
360
361//-------------------------------------------------------------------------------
362
363void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){
364
365 //
366 // method to set the values of the GRP parameters
367 // reading them from the old format of the GRP
368 // object, i.e. a TMap
369 //
370
371 if (mapGRP->GetValue("fAliceStartTime")){
372 SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());
373 }
374 else {
375 AliError(Form("No fAliceStartTime value found in GRP map!"));
376 }
377 if (mapGRP->GetValue("fAliceStopTime")){
378 SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());
379 }
380
381 else {
382 AliError(Form("No fAliceStopTime value found in GRP map!"));
383 }
384
385 if(mapGRP->GetValue("fAliceBeamEnergy")){
386 double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();
387 if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2; // old format was storig sqrt(s)
388 SetBeamEnergy(be);
389 }
390 else {
391 AliError(Form("No fAliceBeamEnergy value found in GRP map!"));
392 }
393 if(mapGRP->GetValue("fAliceBeamType")){
394 SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());
395 }
396 else {
397 AliError(Form("No fAliceBeamType value found in GRP map!"));
398 }
399 if(mapGRP->GetValue("fNumberOfDetectors")){
400 SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi());
820b4d9e 401 AliDebug(1, Form("fNumberOfDetectors = %d", fNumberOfDetectors));
29d11b68 402 }
403 else {
404 AliError(Form("No fNumberOfDetectors value found in GRP map!"));
405 }
406 if(mapGRP->GetValue("fDetectorMask")){
407 SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());
820b4d9e 408 AliDebug(1, Form("fDetectorMask = %d",fDetectorMask));
29d11b68 409 }
410 else {
411 AliError(Form("No fDetectorMask value found in GRP map!"));
412 }
413 if(mapGRP->GetValue("fLHCPeriod")){
414 SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());
415 }
416 else {
417 AliError(Form("No fLHCPeriod value found in GRP map!"));
418 }
419 if(mapGRP->GetValue("fRunType")){
420 SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());
421 }
422 else {
423 AliError(Form("No fRunType value found in GRP map!"));
424 }
425 if(mapGRP->GetValue("fLHCState")){
426 SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());
427 }
428 else {
429 AliError(Form("No fLHCState value found in GRP map!"));
430 }
431 if(mapGRP->GetValue("fLHCluminosity")){
432 AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));
433 }
434 else {
435 AliError(Form("No fLHCLuminosity value found in GRP map!"));
436 }
437 if(mapGRP->GetValue("fBeamIntensity")){
438 AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));
439 }
440 else {
441 AliError(Form("No fBeamIntensity value found in GRP map!"));
442 }
443 if(mapGRP->GetValue("fL3Polarity")){
444 SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());
445 }
446 else {
447 AliError(Form("No fL3Polarity value found in GRP map!"));
448 }
449 if(mapGRP->GetValue("fDipolePolarity")){
450 SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());
451 }
452 else {
453 AliError(Form("No fDipolePolarity value found in GRP map!"));
454 }
455 if(mapGRP->GetValue("fL3Current")){
456 AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));
457 SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);
458 }
459 else {
460 AliError(Form("No fL3Current value found in GRP map!"));
461 }
462 if(mapGRP->GetValue("fDipoleCurrent")){
463 AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));
464 SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);
465 }
466 else {
467 AliError(Form("No fDipoleCurrent value found in GRP map!"));
468 }
469 if(mapGRP->GetValue("fCavernTemperature")){
470 AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));
471 SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);
472 }
473 else {
474 AliError(Form("No fCavernTemperature value found in GRP map!"));
475 }
476 if(mapGRP->GetValue("fCavernAtmosPressure")){
477 AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));
478 }
479 else {
480 AliError(Form("No fCavernAtmosPressure value found in GRP map!"));
481 }
482 if(mapGRP->GetValue("fP2Pressure")){
483 SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));
484 }
485 else {
486 AliError(Form("No fP2Pressure value found in GRP map!"));
487 }
488
489 return;
490
491}
549ab3c2 492//-------------------------------------------------------------------------------
493
494Float_t AliGRPObject::GetBeamEnergy() const {
495
496 //
497 // Getting the energy
498 // in case of BeamType = A-A, multiplying by 82/208 (for PbPb)
499 //
500
501 Float_t energy = fBeamEnergy;
502 if (fBeamType=="A-A"){
503 energy = energy*82./208;
504 }
505 return IsBeamEnergyIsSqrtSHalfGeV() ? energy : energy/2;
506}
de67dd6b 507
508//-------------------------------------------------------------------------------
509
510Double_t AliGRPObject::EvalCavernPressure(const TTimeStamp& time, Bool_t& inside) const {
511//
512// Return current pressure value from 'best' cavern sensor
513// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
514// use sensor most compatible with surface sensor
515
516 return EvalCavernPressure(fCavernAtmosPressure,fCavernAtmosPressure2,
517 fSurfaceAtmosPressure,time,inside);
518
519}
520
521//-------------------------------------------------------------------------------
522
523Double_t AliGRPObject::EvalCavernPressure(AliDCSSensor* cavern1,
524 AliDCSSensor* cavern2, AliDCSSensor* surface,
525 const TTimeStamp& time, Bool_t& inside) {
526//
527// Return current pressure value from 'best' cavern sensor
528// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
529// use sensor most compatible with surface sensor
530
531
532 Double_t valueSensor2 = cavern2->Eval(time,inside);
533 Double_t valueSensor1 = cavern1->Eval(time,inside);
534 if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
535 return valueSensor2;
536 } else {
537 Double_t valueSurface = surface->Eval(time,inside);
538 Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
539 Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
540 if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
541 return valueSensor1;
542 } else {
543 return valueSensor2;
544 }
545 }
546}
547
548//-------------------------------------------------------------------------------
549
550AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(AliDCSSensor* cavern1,
551 AliDCSSensor* cavern2, AliDCSSensor* surface, const TTimeStamp& time) {
552
553//
554// Return pointer to 'best' cavern sensor
555// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
556// use sensor most compatible with surface sensor
557// Pressure measuread at time specified by TTimestamp
558
559
560 Bool_t inside;
561 Double_t valueSensor2 = cavern2->Eval(time,inside);
562 Double_t valueSensor1 = cavern1->Eval(time,inside);
563 if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
564 return cavern2;
565 } else {
566 Double_t valueSurface = surface->Eval(time,inside);
567 Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
568 Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
569 if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
570 return cavern1;
571 } else {
572 return cavern2;
573 }
574 }
575}
576
577//-------------------------------------------------------------------------------
578
579AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(const TTimeStamp& time) const {
580//
581// Return pointer to 'best' cavern sensor
582// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
583// use sensor most compatible with surface sensor
584// Pressure measuread at time specified by TTimestamp
585
586
587 return GetBestCavernAtmosPressure(fCavernAtmosPressure,
588 fCavernAtmosPressure2, fSurfaceAtmosPressure, time);
589
590}
591
592//-------------------------------------------------------------------------------
593
594AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure() const {
595//
596// Return pointer to 'best' cavern sensor
597// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
598// use sensor most compatible with surface sensor
599// Pressure measuread at start-of-run
600
601 return GetBestCavernAtmosPressure(TTimeStamp(fTimeStart));
602}
603
26fd9395 604//-------------------------------------------------------------------------------
605void AliGRPObject::SetFalseDataQualityFlagPeriods(Double_t* falses){
606
607 //
608 // setting the starts (even positions in the array) and ends (odd positions in the array)
609 // of the periods when the Data Quality Flag was set to FALSE
610 //
611
612 fFalseDataQualityFlag = new TArrayD(fNFalseDataQualityFlag*2,falses);
613}
614
615//-------------------------------------------------------------------------------
616Double_t AliGRPObject::GetStartFalseDataQualityFlag(Int_t iperiod) const {
617
618 //
619 // returning the start timestamp of the FALSE period "iperiod"
620 //
621
622 if (iperiod < fNFalseDataQualityFlag){
623 return fFalseDataQualityFlag->At(iperiod*2);
624 }
625 else{
626 AliError(Form("You are looking for FALSE period %d, but the number of FALSE periods was %d - returning -1!", iperiod, fNFalseDataQualityFlag));
627 }
628 return -1.;
629}
630
631//-------------------------------------------------------------------------------
632Double_t AliGRPObject::GetEndFalseDataQualityFlag(Int_t iperiod) const {
633
634 //
635 // returning the end timestamp of the FALSE period "iperiod"
636 //
637
638 if (iperiod < fNFalseDataQualityFlag){
639 return fFalseDataQualityFlag->At(iperiod*2+1);
640 }
641 else{
642 AliError(Form("You are looking for FALSE period %d, but the number of FALSE periods was %d - returning -1!", iperiod, fNFalseDataQualityFlag));
643 }
644 return -1.;
645}