Corrected protection.
[u/mrichter/AliRoot.git] / STEER / AliGRPObject.cxx
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
32 ClassImp(AliGRPObject)
33         
34 const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float
35 const TString AliGRPObject::fgkInvalidString = "";  // value to identify invalid data - string
36 const Char_t AliGRPObject::fgkInvalidChar = -1;         // value to identify invalid data - uchar
37 const Int_t AliGRPObject::fgkInvalidInt = -1;  // value to identify invalid data - uint
38 const Int_t AliGRPObject::fgkInvalidUInt = 0;  // value to identify invalid data - uint
39 const Int_t AliGRPObject::fgknDCSDPHallProbes = 40;   // number of dcs dps
40 const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {
41                    "L3_BSF17_H1",
42                    "L3_BSF17_H2",
43                    "L3_BSF17_H3",
44                    "L3_BSF17_Temperature",
45                    "L3_BSF4_H1",
46                    "L3_BSF4_H2",
47                    "L3_BSF4_H3",
48                    "L3_BSF4_Temperature",
49                    "L3_BKF17_H1",
50                    "L3_BKF17_H2",
51                    "L3_BKF17_H3",
52                    "L3_BKF17_Temperature",
53                    "L3_BKF4_H1",
54                    "L3_BKF4_H2",
55                    "L3_BKF4_H3",
56                    "L3_BKF4_Temperature",
57                    "L3_BSF13_H1",
58                    "L3_BSF13_H2",
59                    "L3_BSF13_H3",
60                    "L3_BSF13_Temperature",
61                    "L3_BSF8_H1",
62                    "L3_BSF8_H2",
63                    "L3_BSF8_H3",
64                    "L3_BSF8_Temperature",
65                    "L3_BKF13_H1",
66                    "L3_BKF13_H2",
67                    "L3_BKF13_H3",
68                    "L3_BKF13_Temperature",
69                    "L3_BKF8_H1",
70                    "L3_BKF8_H2",
71                    "L3_BKF8_H3",
72                    "L3_BKF8_Temperature",
73                    "Dipole_Inside_H1",
74                    "Dipole_Inside_H2",
75                    "Dipole_Inside_H3",
76                    "Dipole_Inside_Temperature",
77                    "Dipole_Outside_H1",
78                    "Dipole_Outside_H2",
79                    "Dipole_Outside_H3",
80                    "Dipole_Outside_Temperature",
81                  };
82
83 //-----------------------------------------------------------------------------
84 AliGRPObject::AliGRPObject():
85         TObject(),
86         fPoints(5),
87         fDimension(0),
88         fTimeStart((time_t)fgkInvalidFloat),
89         fTimeEnd((time_t)fgkInvalidFloat),
90         fBeamEnergy(fgkInvalidFloat),
91         fBeamType(fgkInvalidString),
92         fNumberOfDetectors(fgkInvalidChar),
93         fDetectorMask(fgkInvalidUInt),
94         fLHCPeriod(fgkInvalidString),
95         fRunType(fgkInvalidString),
96         fLHCState(fgkInvalidString),
97         fL3Polarity(fgkInvalidChar),
98         fDipolePolarity(fgkInvalidChar),
99         fL3Current(new Float_t[fPoints]),
100         fDipoleCurrent(new Float_t[fPoints]),
101         fCavernTemperature(new Float_t[fPoints]),
102         fCavernAtmosPressure(0x0),
103         fCavernAtmosPressure2(0x0),
104         fSurfaceAtmosPressure(0x0),
105         fHallProbes(0x0),
106         fMachineMode(fgkInvalidString),
107         fLHCStateArray(0x0),
108         fMachineModeArray(0x0),
109         fMaxTimeLHCValidity(0)
110 {
111
112         //
113         // AliGRPObject default ctor
114         //
115
116         fDimension = fgknDCSDPHallProbes*fPoints;
117         fHallProbes = new Float_t[fDimension];
118
119         for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP 
120                 if ((nhp >= 0 && nhp <= 1*fPoints-1) || // L3_BSF17_H1
121                     (nhp >= 1*fPoints && nhp <= 2*fPoints-1) || // L3_BSF17_H2
122                     (nhp >= 2*fPoints && nhp <= 3*fPoints-1) || // L3_BSF17_H3
123                     (nhp >= 3*fPoints && nhp <= 4*fPoints-1) || // L3_BSF17_Temperature
124                     (nhp >= 6*fPoints && nhp <= 7*fPoints-1) ) { // L3_BSF4_H3
125                         fHallProbes[nhp] = 0; // setting to zero values for non working HP 
126                         AliDebug(2,Form("setting hp[%d] to zero = %f", 
127 nhp, fHallProbes[nhp]));
128                 }
129                 else {
130                         fHallProbes[nhp] = fgkInvalidFloat;
131                 }
132         }
133
134
135         for (Int_t i = 0; i < fPoints; i++){
136
137                 fL3Current[i] = fgkInvalidFloat;
138                 fDipoleCurrent[i] = fgkInvalidFloat;
139                 fCavernTemperature[i] = fgkInvalidFloat;
140         }
141 }
142
143 //-----------------------------------------------------------------------------
144
145 AliGRPObject::AliGRPObject(const AliGRPObject &obj):
146         TObject(obj),
147         fPoints(obj.fPoints),
148         fDimension(obj.fDimension),
149         fTimeStart(obj.fTimeStart),
150         fTimeEnd(obj.fTimeEnd),
151         fBeamEnergy(obj.fBeamEnergy),
152         fBeamType(obj.fBeamType),
153         fNumberOfDetectors(obj.fNumberOfDetectors),
154         fDetectorMask(obj.fDetectorMask),
155         fLHCPeriod(obj.fLHCPeriod),
156         fRunType(obj.fRunType),
157         fLHCState(obj.fLHCState),
158         fL3Polarity(obj.fL3Polarity),
159         fDipolePolarity(obj.fDipolePolarity),
160         fL3Current(new Float_t[fPoints]),
161         fDipoleCurrent(new Float_t[fPoints]),
162         fCavernTemperature(new Float_t[fPoints]),
163         fCavernAtmosPressure(obj.fCavernAtmosPressure),
164         fCavernAtmosPressure2(obj.fCavernAtmosPressure2),
165         fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),
166         fHallProbes(0x0),
167         fMachineMode(obj.fMachineMode),
168         fLHCStateArray(obj.fLHCStateArray),
169         fMachineModeArray(obj.fMachineModeArray),
170         fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)
171
172 {
173
174         //
175         // AliGRPObject copy ctor
176         //
177
178         fHallProbes = new Float_t[fDimension]; 
179
180         for (Int_t nhp=0; nhp< fDimension; nhp++){
181                 fHallProbes[nhp] = obj.fHallProbes[nhp];
182         }
183
184         for (Int_t i = 0; i < fPoints; i++){
185
186                 fL3Current[i] = obj.fL3Current[i];
187                 fDipoleCurrent[i] = obj.fDipoleCurrent[i];
188                 fCavernTemperature[i] = obj.fCavernTemperature[i];
189         }
190 }
191
192 //-----------------------------------------------------------------------------
193
194 AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) 
195 {
196
197         //
198         // AliGRPObject assignment operator
199         //
200
201         if (&obj == this) return *this; 
202
203         TObject::operator=(obj);
204         this->fTimeStart = obj.GetTimeStart();
205         this->fTimeEnd = obj.GetTimeEnd();
206         this->fBeamEnergy = obj.GetBeamEnergy();
207         this->fBeamType = obj.GetBeamType();
208         this->fNumberOfDetectors = obj.GetNumberOfDetectors();
209         this->fDetectorMask = obj.GetDetectorMask();
210         this->fLHCPeriod = obj.GetLHCPeriod();
211         this->fRunType = obj.GetRunType();
212         this->fLHCState = obj.GetLHCState();
213         this->fL3Polarity = obj.GetL3Polarity();
214         this->fDipolePolarity = obj.GetDipolePolarity();
215         this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();
216         this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();
217         this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();
218         this->fPoints = obj.GetPoints();
219         this->fDimension = obj.GetDimension();
220
221         this->fL3Current = new Float_t[fPoints];
222         this->fDipoleCurrent = new Float_t[fPoints];
223         this->fCavernTemperature = new Float_t[fPoints];
224         
225         if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension]; 
226         for (Int_t nhp=0; nhp< fDimension; nhp++){
227                 this->fHallProbes[nhp] = obj.GetHallProbes(nhp);
228
229         }
230         for (Int_t i = 0; i < fPoints; i++){
231
232                 this->fL3Current[i] = obj.GetL3Current((Stats)i);
233                 this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);
234                 this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);
235         }
236
237         this->fMachineMode = obj.fMachineMode;
238         this->fLHCStateArray = obj.fLHCStateArray;
239         this->fMachineModeArray = obj.fMachineModeArray;
240         this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
241         return *this;
242 }
243
244 //-----------------------------------------------------------------------------
245
246 AliGRPObject::~AliGRPObject() {
247
248         //
249         // dtor
250         //
251
252         
253         delete [] fHallProbes;
254         delete [] fL3Current;
255         delete [] fDipoleCurrent;
256         delete [] fCavernTemperature;
257
258         if (fCavernAtmosPressure){
259                 delete fCavernAtmosPressure;
260                 fCavernAtmosPressure = 0x0;
261         }
262         if (fCavernAtmosPressure2){
263                 delete fCavernAtmosPressure2;
264                 fCavernAtmosPressure2 = 0x0;
265         }
266         if (fSurfaceAtmosPressure){
267                 delete fSurfaceAtmosPressure;
268                 fSurfaceAtmosPressure = 0x0;
269         }
270         if (fLHCStateArray){
271                 delete fLHCStateArray;
272                 fLHCStateArray = 0x0;
273         }
274         if (fMachineModeArray){
275                 delete fMachineModeArray;
276                 fMachineModeArray = 0x0;
277         }
278 }
279
280 //-----------------------------------------------------------------------------
281 Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {
282
283         //
284         // method to return array of statistical
285         // variables for Hall Probe hp
286         //
287
288         Float_t* array = new Float_t[fPoints];
289         Int_t shift = fPoints*(Int_t)hp; 
290         for (Int_t i=0;i<fPoints; i++){
291
292                 array[i] = fHallProbes[shift+i];
293
294         }
295
296         return array;
297 }
298 //-------------------------------------------------------------------------------
299
300 void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){
301
302         //
303         // method to set hall probe hp 
304         // from a given array
305         //
306
307         Int_t shift = fPoints*hp;
308         for (Int_t i = 0; i< fPoints; i++){
309
310                 fHallProbes[i+shift] =  hall_probe[i];
311         }
312         return;
313 }
314
315 //-------------------------------------------------------------------------------
316
317 void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){
318
319         //
320         // method to set the values of the GRP parameters 
321         // reading them from the old format of the GRP 
322         // object, i.e. a TMap
323         //
324
325         if (mapGRP->GetValue("fAliceStartTime")){
326                 SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());
327         }
328         else {
329                 AliError(Form("No fAliceStartTime value found in GRP map!"));
330         }
331         if (mapGRP->GetValue("fAliceStopTime")){
332                 SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());
333         }
334         
335         else { 
336                 AliError(Form("No fAliceStopTime value found in GRP map!"));
337         }
338
339         if(mapGRP->GetValue("fAliceBeamEnergy")){
340           double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();
341           if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2;   // old format was storig sqrt(s)
342           SetBeamEnergy(be);
343         }
344         else { 
345                 AliError(Form("No fAliceBeamEnergy value found in GRP map!"));
346         }
347         if(mapGRP->GetValue("fAliceBeamType")){
348                 SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());
349         }
350         else { 
351                 AliError(Form("No fAliceBeamType value found in GRP map!"));
352         }
353         if(mapGRP->GetValue("fNumberOfDetectors")){
354                 SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); 
355         }
356         else { 
357                 AliError(Form("No fNumberOfDetectors value found in GRP map!"));
358         }
359         if(mapGRP->GetValue("fDetectorMask")){
360                 SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());  
361         }
362         else { 
363                 AliError(Form("No fDetectorMask value found in GRP map!"));
364         }
365         if(mapGRP->GetValue("fLHCPeriod")){
366                 SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());
367         }
368         else { 
369                 AliError(Form("No fLHCPeriod value found in GRP map!"));
370         }
371         if(mapGRP->GetValue("fRunType")){
372                 SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());
373         }
374         else { 
375                 AliError(Form("No fRunType value found in GRP map!"));
376         }
377         if(mapGRP->GetValue("fLHCState")){
378                 SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());
379         }
380         else { 
381                 AliError(Form("No fLHCState value found in GRP map!"));
382         }
383         if(mapGRP->GetValue("fLHCluminosity")){
384                 AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));
385         }       
386         else { 
387                 AliError(Form("No fLHCLuminosity value found in GRP map!"));
388         }
389         if(mapGRP->GetValue("fBeamIntensity")){
390                 AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));
391         }       
392         else { 
393                 AliError(Form("No fBeamIntensity value found in GRP map!"));
394         }
395         if(mapGRP->GetValue("fL3Polarity")){
396                 SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());
397         }       
398         else { 
399                 AliError(Form("No fL3Polarity value found in GRP map!"));
400         }
401         if(mapGRP->GetValue("fDipolePolarity")){
402                 SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());  
403         }       
404         else { 
405                 AliError(Form("No fDipolePolarity value found in GRP map!"));
406         }
407         if(mapGRP->GetValue("fL3Current")){
408                 AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));
409                 SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);
410         }       
411         else { 
412                 AliError(Form("No fL3Current value found in GRP map!"));
413         }
414         if(mapGRP->GetValue("fDipoleCurrent")){
415                 AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));
416                 SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);
417         }       
418         else { 
419                 AliError(Form("No fDipoleCurrent value found in GRP map!"));
420         }
421         if(mapGRP->GetValue("fCavernTemperature")){
422                 AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));
423                 SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);
424         }       
425         else { 
426                 AliError(Form("No fCavernTemperature value found in GRP map!"));
427         }
428         if(mapGRP->GetValue("fCavernAtmosPressure")){
429                 AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));
430         }       
431         else { 
432                 AliError(Form("No fCavernAtmosPressure value found in GRP map!"));
433         }
434         if(mapGRP->GetValue("fP2Pressure")){
435                 SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));
436         }
437         else { 
438                 AliError(Form("No fP2Pressure value found in GRP map!"));
439         }
440         
441         return;
442
443 }