Changing name of getter method to avoid ambiguity.
[u/mrichter/AliRoot.git] / STEER / AliGRPObject.cxx
1 /**************************************************************************\r
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
3  *                                                                        *\r
4  * Author: The ALICE Off-line Project.                                    *\r
5  * Contributors are mentioned in the code where appropriate.              *\r
6  *                                                                        *\r
7  * Permission to use, copy, modify and distribute this software and its   *\r
8  * documentation strictly for non-commercial purposes is hereby granted   *\r
9  * without fee, provided that the above copyright notice appears in all   *\r
10  * copies and that both the copyright notice and this permission notice   *\r
11  * appear in the supporting documentation. The authors make no claims     *\r
12  * about the suitability of this software for any purpose. It is          *\r
13  * provided "as is" without express or implied warranty.                  *\r
14  **************************************************************************/\r
15 \r
16 /* $Id$ */\r
17 \r
18 // **********************\r
19 // Class containing the GRP data that have to be stored in the OCDB.\r
20 // Data come either from DAQ logbook or from DCS DB.\r
21 // Processing of the data can also be performed here.\r
22 // **********************\r
23 \r
24 #include <TMap.h>\r
25 #include <TObject.h>\r
26 #include <TObjString.h>\r
27 \r
28 #include "AliGRPObject.h"\r
29 #include "AliDCSSensor.h"\r
30 #include "AliLog.h"\r
31 \r
32 ClassImp(AliGRPObject)\r
33         \r
34 const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float\r
35 const TString AliGRPObject::fgkInvalidString = "";  // value to identify invalid data - string\r
36 const Char_t AliGRPObject::fgkInvalidChar = -1;         // value to identify invalid data - uchar\r
37 const Int_t AliGRPObject::fgkInvalidInt = -1;  // value to identify invalid data - uint\r
38 const Int_t AliGRPObject::fgkInvalidUInt = 0;  // value to identify invalid data - uint\r
39 const Int_t AliGRPObject::fgknDCSDPHallProbes = 40;   // number of dcs dps\r
40 const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {\r
41                    "L3_BSF17_H1",\r
42                    "L3_BSF17_H2",\r
43                    "L3_BSF17_H3",\r
44                    "L3_BSF17_Temperature",\r
45                    "L3_BSF4_H1",\r
46                    "L3_BSF4_H2",\r
47                    "L3_BSF4_H3",\r
48                    "L3_BSF4_Temperature",\r
49                    "L3_BKF17_H1",\r
50                    "L3_BKF17_H2",\r
51                    "L3_BKF17_H3",\r
52                    "L3_BKF17_Temperature",\r
53                    "L3_BKF4_H1",\r
54                    "L3_BKF4_H2",\r
55                    "L3_BKF4_H3",\r
56                    "L3_BKF4_Temperature",\r
57                    "L3_BSF13_H1",\r
58                    "L3_BSF13_H2",\r
59                    "L3_BSF13_H3",\r
60                    "L3_BSF13_Temperature",\r
61                    "L3_BSF8_H1",\r
62                    "L3_BSF8_H2",\r
63                    "L3_BSF8_H3",\r
64                    "L3_BSF8_Temperature",\r
65                    "L3_BKF13_H1",\r
66                    "L3_BKF13_H2",\r
67                    "L3_BKF13_H3",\r
68                    "L3_BKF13_Temperature",\r
69                    "L3_BKF8_H1",\r
70                    "L3_BKF8_H2",\r
71                    "L3_BKF8_H3",\r
72                    "L3_BKF8_Temperature",\r
73                    "Dipole_Inside_H1",\r
74                    "Dipole_Inside_H2",\r
75                    "Dipole_Inside_H3",\r
76                    "Dipole_Inside_Temperature",\r
77                    "Dipole_Outside_H1",\r
78                    "Dipole_Outside_H2",\r
79                    "Dipole_Outside_H3",\r
80                    "Dipole_Outside_Temperature",\r
81                  };\r
82 \r
83 //-----------------------------------------------------------------------------\r
84 AliGRPObject::AliGRPObject():\r
85         TObject(),\r
86         fPoints(5),\r
87         fDimension(0),\r
88         fTimeStart((time_t)fgkInvalidFloat),\r
89         fTimeEnd((time_t)fgkInvalidFloat),\r
90         fBeamEnergy(fgkInvalidFloat),\r
91         fBeamType(fgkInvalidString),\r
92         fNumberOfDetectors(fgkInvalidChar),\r
93         fDetectorMask(fgkInvalidUInt),\r
94         fLHCPeriod(fgkInvalidString),\r
95         fRunType(fgkInvalidString),\r
96         fLHCState(fgkInvalidString),\r
97         fLHCLuminosity(new Float_t[fPoints]),\r
98         fLHCLuminositySplineFit(0x0),\r
99         fBeamIntensity(new Float_t[fPoints]),\r
100         fBeamIntensitySplineFit(0x0),\r
101         fL3Polarity(fgkInvalidChar),\r
102         fDipolePolarity(fgkInvalidChar),\r
103         fL3Current(new Float_t[fPoints]),\r
104         fDipoleCurrent(new Float_t[fPoints]),\r
105         fCavernTemperature(new Float_t[fPoints]),\r
106         //fCavernAtmosPressure(new Float_t[fPoints]),\r
107         fCavernAtmosPressure(0x0),\r
108         fSurfaceAtmosPressure(0x0),\r
109         fHallProbes(0x0)\r
110 {\r
111 \r
112         //\r
113         // AliGRPObject default ctor\r
114         //\r
115 \r
116         fDimension = fgknDCSDPHallProbes*fPoints;\r
117         fHallProbes = new Float_t[fDimension];\r
118 \r
119         for (Int_t nhp=0; nhp< fDimension; nhp++){\r
120                 fHallProbes[nhp] = fgkInvalidFloat;\r
121         }\r
122 \r
123         for (Int_t i = 0; i < fPoints; i++){\r
124 \r
125                 fLHCLuminosity[i] = fgkInvalidFloat;\r
126                 fBeamIntensity[i] = fgkInvalidFloat;\r
127                 fL3Current[i] = fgkInvalidFloat;\r
128                 fDipoleCurrent[i] = fgkInvalidFloat;\r
129                 fCavernTemperature[i] = fgkInvalidFloat;\r
130                 //              fCavernAtmosPressure[i] = fgkInvalidFloat;\r
131         }\r
132 }\r
133 \r
134 //-----------------------------------------------------------------------------\r
135 \r
136 AliGRPObject::AliGRPObject(const AliGRPObject &obj):\r
137         TObject(),\r
138         fPoints(obj.fPoints),\r
139         fDimension(obj.fDimension),\r
140         fTimeStart(obj.fTimeStart),\r
141         fTimeEnd(obj.fTimeEnd),\r
142         fBeamEnergy(obj.fBeamEnergy),\r
143         fBeamType(obj.fBeamType),\r
144         fNumberOfDetectors(obj.fNumberOfDetectors),\r
145         fDetectorMask(obj.fDetectorMask),\r
146         fLHCPeriod(obj.fLHCPeriod),\r
147         fRunType(obj.fRunType),\r
148         fLHCState(obj.fLHCState),\r
149         fLHCLuminosity(new Float_t[fPoints]),\r
150         fLHCLuminositySplineFit(obj.fLHCLuminositySplineFit),\r
151         fBeamIntensity(new Float_t[fPoints]),\r
152         fBeamIntensitySplineFit(obj.fBeamIntensitySplineFit),\r
153         fL3Polarity(obj.fL3Polarity),\r
154         fDipolePolarity(obj.fDipolePolarity),\r
155         fL3Current(new Float_t[fPoints]),\r
156         fDipoleCurrent(new Float_t[fPoints]),\r
157         fCavernTemperature(new Float_t[fPoints]),\r
158         fCavernAtmosPressure(obj.fCavernAtmosPressure),\r
159         fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),\r
160         fHallProbes(0x0)\r
161 \r
162 {\r
163 \r
164         //\r
165         // AliGRPObject copy ctor\r
166         //\r
167 \r
168         for (Int_t nhp=0; nhp< fDimension; nhp++){\r
169                 fHallProbes[nhp] = obj.fHallProbes[nhp];\r
170         }\r
171 \r
172         for (Int_t i = 0; i < fPoints; i++){\r
173 \r
174                 fLHCLuminosity[i] = obj.fLHCLuminosity[i];\r
175                 fBeamIntensity[i] = obj.fBeamIntensity[i];\r
176                 fL3Current[i] = obj.fL3Current[i];\r
177                 fDipoleCurrent[i] = obj.fDipoleCurrent[i];\r
178                 fCavernTemperature[i] = obj.fCavernTemperature[i];\r
179         }\r
180 }\r
181 \r
182 //-----------------------------------------------------------------------------\r
183 \r
184 AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) \r
185 {\r
186 \r
187         //\r
188         // AliGRPObject assignment operator\r
189         //\r
190 \r
191         this->fTimeStart = obj.GetTimeStart();\r
192         this->fTimeEnd = obj.GetTimeEnd();\r
193         this->fBeamEnergy = obj.GetBeamEnergy();\r
194         this->fBeamType = obj.GetBeamType();\r
195         this->fNumberOfDetectors = obj.GetNumberOfDetectors();\r
196         this->fDetectorMask = obj.GetDetectorMask();\r
197         this->fLHCPeriod = obj.GetLHCPeriod();\r
198         this->fRunType = obj.GetRunType();\r
199         this->fLHCState = obj.GetLHCState();\r
200         this->fLHCLuminositySplineFit = obj.GetLHCLuminositySplineFit();\r
201         this->fBeamIntensitySplineFit = obj.GetBeamIntensitySplineFit();\r
202         this->fL3Polarity = obj.GetL3Polarity();\r
203         this->fDipolePolarity = obj.GetDipolePolarity();\r
204         this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();\r
205         this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();\r
206         this->fPoints = obj.GetPoints();\r
207         this->fDimension = obj.GetDimension();\r
208 \r
209         this->fLHCLuminosity = new Float_t[fPoints];\r
210         this->fBeamIntensity = new Float_t[fPoints];\r
211         this->fL3Current = new Float_t[fPoints];\r
212         this->fDipoleCurrent = new Float_t[fPoints];\r
213         this->fCavernTemperature = new Float_t[fPoints];\r
214         \r
215         for (Int_t nhp=0; nhp< fDimension; nhp++){\r
216                 this->fHallProbes[nhp] = obj.GetHallProbes(nhp);\r
217 \r
218         }\r
219         for (Int_t i = 0; i < fPoints; i++){\r
220 \r
221                 this->fLHCLuminosity[i] = obj.GetLHCLuminosity((Stats)i);\r
222                 this->fBeamIntensity[i] = obj.GetBeamIntensity((Stats)i);\r
223                 this->fL3Current[i] = obj.GetL3Current((Stats)i);\r
224                 this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);\r
225                 this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);\r
226         }\r
227 \r
228         return *this;\r
229 }\r
230 \r
231 //-----------------------------------------------------------------------------\r
232 \r
233 AliGRPObject::~AliGRPObject() {\r
234 \r
235         //\r
236         // dtor\r
237         //\r
238 \r
239         \r
240         delete [] fHallProbes;\r
241         delete [] fLHCLuminosity;\r
242         delete [] fBeamIntensity;\r
243         delete [] fL3Current;\r
244         delete [] fDipoleCurrent;\r
245         delete [] fCavernTemperature;\r
246 \r
247         if (fLHCLuminositySplineFit){\r
248                 delete fLHCLuminositySplineFit;\r
249                 fLHCLuminositySplineFit = 0x0;\r
250         }\r
251         if (fBeamIntensitySplineFit){\r
252                 delete fBeamIntensitySplineFit;\r
253                 fBeamIntensitySplineFit = 0x0;\r
254         }\r
255         if (fCavernAtmosPressure){\r
256                 delete fCavernAtmosPressure;\r
257                 fCavernAtmosPressure = 0x0;\r
258         }\r
259         if (fSurfaceAtmosPressure){\r
260                 delete fSurfaceAtmosPressure;\r
261                 fSurfaceAtmosPressure = 0x0;\r
262         }\r
263 }\r
264 \r
265 //-----------------------------------------------------------------------------\r
266 Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {\r
267 \r
268         //\r
269         // method to return array of statistical\r
270         // variables for Hall Probe hp\r
271         //\r
272 \r
273         Float_t* array = new Float_t[fPoints];\r
274         Int_t shift = fPoints*(Int_t)hp; \r
275         for (Int_t i=0;i<fPoints; i++){\r
276 \r
277                 array[i] = fHallProbes[shift+i];\r
278 \r
279         }\r
280 \r
281         return array;\r
282 }\r
283 //-------------------------------------------------------------------------------\r
284 \r
285 void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){\r
286 \r
287         //\r
288         // method to set hall probe hp \r
289         // from a given array\r
290         //\r
291 \r
292         Int_t shift = fPoints*hp;\r
293         for (Int_t i = 0; i< fPoints; i++){\r
294 \r
295                 fHallProbes[i+shift] =  hall_probe[i];\r
296         }\r
297         return;\r
298 }\r
299 \r
300 //-------------------------------------------------------------------------------\r
301 \r
302 void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){\r
303 \r
304         //\r
305         // method to set the values of the GRP parameters \r
306         // reading them from the old format of the GRP \r
307         // object, i.e. a TMap\r
308         //\r
309 \r
310         if (mapGRP->GetValue("fAliceStartTime")){\r
311                 SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());\r
312         }\r
313         else {\r
314                 AliError(Form("No fAliceStartTime value found in GRP map!"));\r
315         }\r
316         if (mapGRP->GetValue("fAliceStopTime")){\r
317                 SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());\r
318         }\r
319         \r
320         else { \r
321                 AliError(Form("No fAliceStopTime value found in GRP map!"));\r
322         }\r
323 \r
324         if(mapGRP->GetValue("fAliceBeamEnergy")){\r
325                 SetBeamEnergy((((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof());\r
326         }\r
327         else { \r
328                 AliError(Form("No fAliceBeamEnergy value found in GRP map!"));\r
329         }\r
330         if(mapGRP->GetValue("fAliceBeamType")){\r
331                 SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());\r
332         }\r
333         else { \r
334                 AliError(Form("No fAliceBeamType value found in GRP map!"));\r
335         }\r
336         if(mapGRP->GetValue("fNumberOfDetectors")){\r
337                 SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); \r
338         }\r
339         else { \r
340                 AliError(Form("No fNumberOfDetectors value found in GRP map!"));\r
341         }\r
342         if(mapGRP->GetValue("fDetectorMask")){\r
343                 SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());  \r
344         }\r
345         else { \r
346                 AliError(Form("No fDetectorMask value found in GRP map!"));\r
347         }\r
348         if(mapGRP->GetValue("fLHCPeriod")){\r
349                 SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());\r
350         }\r
351         else { \r
352                 AliError(Form("No fLHCPeriod value found in GRP map!"));\r
353         }\r
354         if(mapGRP->GetValue("fRunType")){\r
355                 SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());\r
356         }\r
357         else { \r
358                 AliError(Form("No fRunType value found in GRP map!"));\r
359         }\r
360         if(mapGRP->GetValue("fLHCState")){\r
361                 SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());\r
362         }\r
363         else { \r
364                 AliError(Form("No fLHCState value found in GRP map!"));\r
365         }\r
366         if(mapGRP->GetValue("fLHCluminosity")){\r
367                 AliInfo(Form("fLHCLuminosity found, but porting only average to the new object, since the other values are not available in the old object"));\r
368                 SetLHCLuminosity((Float_t)(((TObjString*)(mapGRP->GetValue("fLHCLuminosity")))->GetString()).Atof(),(Stats)0);\r
369         }       \r
370         else { \r
371                 AliError(Form("No fLHCLuminosity value found in GRP map!"));\r
372         }\r
373         if(mapGRP->GetValue("fBeamIntensity")){\r
374                 AliInfo(Form("fBeamIntensity found, but porting only average to the new object, since the other values are not available in the old object"));\r
375                 SetBeamIntensity((Float_t)(((TObjString*)(mapGRP->GetValue("fBeamIntensity")))->GetString()).Atof(),(Stats)0);\r
376         }       \r
377         else { \r
378                 AliError(Form("No fBeamIntensity value found in GRP map!"));\r
379         }\r
380         if(mapGRP->GetValue("fL3Polarity")){\r
381                 SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());\r
382         }       \r
383         else { \r
384                 AliError(Form("No fL3Polarity value found in GRP map!"));\r
385         }\r
386         if(mapGRP->GetValue("fDipolePolarity")){\r
387                 SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());  \r
388         }       \r
389         else { \r
390                 AliError(Form("No fDipolePolarity value found in GRP map!"));\r
391         }\r
392         if(mapGRP->GetValue("fL3Current")){\r
393                 AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));\r
394                 SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);\r
395         }       \r
396         else { \r
397                 AliError(Form("No fL3Current value found in GRP map!"));\r
398         }\r
399         if(mapGRP->GetValue("fDipoleCurrent")){\r
400                 AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));\r
401                 SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);\r
402         }       \r
403         else { \r
404                 AliError(Form("No fDipoleCurrent value found in GRP map!"));\r
405         }\r
406         if(mapGRP->GetValue("fCavernTemperature")){\r
407                 AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));\r
408                 SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);\r
409         }       \r
410         else { \r
411                 AliError(Form("No fCavernTemperature value found in GRP map!"));\r
412         }\r
413         if(mapGRP->GetValue("fCavernAtmosPressure")){\r
414                 AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));\r
415         }       \r
416         else { \r
417                 AliError(Form("No fCavernAtmosPressure value found in GRP map!"));\r
418         }\r
419         if(mapGRP->GetValue("fP2Pressure")){\r
420                 SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));\r
421         }\r
422         else { \r
423                 AliError(Form("No fP2Pressure value found in GRP map!"));\r
424         }\r
425         \r
426         return;\r
427 \r
428 }\r