The constructor will set the LHC Bfield convention bit
[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(0x0),\r
107         fCavernAtmosPressure2(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         }\r
131         SetBit(kPolConvLHC);\r
132 }\r
133 \r
134 //-----------------------------------------------------------------------------\r
135 \r
136 AliGRPObject::AliGRPObject(const AliGRPObject &obj):\r
137         TObject(obj),\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         fCavernAtmosPressure2(obj.fCavernAtmosPressure2),\r
160         fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),\r
161         fHallProbes(0x0)\r
162 \r
163 {\r
164 \r
165         //\r
166         // AliGRPObject copy ctor\r
167         //\r
168 \r
169         fHallProbes = new Float_t[fDimension]; \r
170 \r
171         for (Int_t nhp=0; nhp< fDimension; nhp++){\r
172                 fHallProbes[nhp] = obj.fHallProbes[nhp];\r
173         }\r
174 \r
175         for (Int_t i = 0; i < fPoints; i++){\r
176 \r
177                 fLHCLuminosity[i] = obj.fLHCLuminosity[i];\r
178                 fBeamIntensity[i] = obj.fBeamIntensity[i];\r
179                 fL3Current[i] = obj.fL3Current[i];\r
180                 fDipoleCurrent[i] = obj.fDipoleCurrent[i];\r
181                 fCavernTemperature[i] = obj.fCavernTemperature[i];\r
182         }\r
183 }\r
184 \r
185 //-----------------------------------------------------------------------------\r
186 \r
187 AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) \r
188 {\r
189 \r
190         //\r
191         // AliGRPObject assignment operator\r
192         //\r
193 \r
194         if (&obj == this) return *this; \r
195 \r
196         TObject::operator=(obj);\r
197         this->fTimeStart = obj.GetTimeStart();\r
198         this->fTimeEnd = obj.GetTimeEnd();\r
199         this->fBeamEnergy = obj.GetBeamEnergy();\r
200         this->fBeamType = obj.GetBeamType();\r
201         this->fNumberOfDetectors = obj.GetNumberOfDetectors();\r
202         this->fDetectorMask = obj.GetDetectorMask();\r
203         this->fLHCPeriod = obj.GetLHCPeriod();\r
204         this->fRunType = obj.GetRunType();\r
205         this->fLHCState = obj.GetLHCState();\r
206         this->fLHCLuminositySplineFit = obj.GetLHCLuminositySplineFit();\r
207         this->fBeamIntensitySplineFit = obj.GetBeamIntensitySplineFit();\r
208         this->fL3Polarity = obj.GetL3Polarity();\r
209         this->fDipolePolarity = obj.GetDipolePolarity();\r
210         this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();\r
211         this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();\r
212         this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();\r
213         this->fPoints = obj.GetPoints();\r
214         this->fDimension = obj.GetDimension();\r
215 \r
216         this->fLHCLuminosity = new Float_t[fPoints];\r
217         this->fBeamIntensity = new Float_t[fPoints];\r
218         this->fL3Current = new Float_t[fPoints];\r
219         this->fDipoleCurrent = new Float_t[fPoints];\r
220         this->fCavernTemperature = new Float_t[fPoints];\r
221         \r
222         if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension]; \r
223         for (Int_t nhp=0; nhp< fDimension; nhp++){\r
224                 this->fHallProbes[nhp] = obj.GetHallProbes(nhp);\r
225 \r
226         }\r
227         for (Int_t i = 0; i < fPoints; i++){\r
228 \r
229                 this->fLHCLuminosity[i] = obj.GetLHCLuminosity((Stats)i);\r
230                 this->fBeamIntensity[i] = obj.GetBeamIntensity((Stats)i);\r
231                 this->fL3Current[i] = obj.GetL3Current((Stats)i);\r
232                 this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);\r
233                 this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);\r
234         }\r
235 \r
236         return *this;\r
237 }\r
238 \r
239 //-----------------------------------------------------------------------------\r
240 \r
241 AliGRPObject::~AliGRPObject() {\r
242 \r
243         //\r
244         // dtor\r
245         //\r
246 \r
247         \r
248         delete [] fHallProbes;\r
249         delete [] fLHCLuminosity;\r
250         delete [] fBeamIntensity;\r
251         delete [] fL3Current;\r
252         delete [] fDipoleCurrent;\r
253         delete [] fCavernTemperature;\r
254 \r
255         if (fLHCLuminositySplineFit){\r
256                 delete fLHCLuminositySplineFit;\r
257                 fLHCLuminositySplineFit = 0x0;\r
258         }\r
259         if (fBeamIntensitySplineFit){\r
260                 delete fBeamIntensitySplineFit;\r
261                 fBeamIntensitySplineFit = 0x0;\r
262         }\r
263         if (fCavernAtmosPressure){\r
264                 delete fCavernAtmosPressure;\r
265                 fCavernAtmosPressure = 0x0;\r
266         }\r
267         if (fCavernAtmosPressure2){\r
268                 delete fCavernAtmosPressure2;\r
269                 fCavernAtmosPressure2 = 0x0;\r
270         }\r
271         if (fSurfaceAtmosPressure){\r
272                 delete fSurfaceAtmosPressure;\r
273                 fSurfaceAtmosPressure = 0x0;\r
274         }\r
275 }\r
276 \r
277 //-----------------------------------------------------------------------------\r
278 Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {\r
279 \r
280         //\r
281         // method to return array of statistical\r
282         // variables for Hall Probe hp\r
283         //\r
284 \r
285         Float_t* array = new Float_t[fPoints];\r
286         Int_t shift = fPoints*(Int_t)hp; \r
287         for (Int_t i=0;i<fPoints; i++){\r
288 \r
289                 array[i] = fHallProbes[shift+i];\r
290 \r
291         }\r
292 \r
293         return array;\r
294 }\r
295 //-------------------------------------------------------------------------------\r
296 \r
297 void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){\r
298 \r
299         //\r
300         // method to set hall probe hp \r
301         // from a given array\r
302         //\r
303 \r
304         Int_t shift = fPoints*hp;\r
305         for (Int_t i = 0; i< fPoints; i++){\r
306 \r
307                 fHallProbes[i+shift] =  hall_probe[i];\r
308         }\r
309         return;\r
310 }\r
311 \r
312 //-------------------------------------------------------------------------------\r
313 \r
314 void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){\r
315 \r
316         //\r
317         // method to set the values of the GRP parameters \r
318         // reading them from the old format of the GRP \r
319         // object, i.e. a TMap\r
320         //\r
321 \r
322         if (mapGRP->GetValue("fAliceStartTime")){\r
323                 SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());\r
324         }\r
325         else {\r
326                 AliError(Form("No fAliceStartTime value found in GRP map!"));\r
327         }\r
328         if (mapGRP->GetValue("fAliceStopTime")){\r
329                 SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());\r
330         }\r
331         \r
332         else { \r
333                 AliError(Form("No fAliceStopTime value found in GRP map!"));\r
334         }\r
335 \r
336         if(mapGRP->GetValue("fAliceBeamEnergy")){\r
337                 SetBeamEnergy((((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof());\r
338         }\r
339         else { \r
340                 AliError(Form("No fAliceBeamEnergy value found in GRP map!"));\r
341         }\r
342         if(mapGRP->GetValue("fAliceBeamType")){\r
343                 SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());\r
344         }\r
345         else { \r
346                 AliError(Form("No fAliceBeamType value found in GRP map!"));\r
347         }\r
348         if(mapGRP->GetValue("fNumberOfDetectors")){\r
349                 SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); \r
350         }\r
351         else { \r
352                 AliError(Form("No fNumberOfDetectors value found in GRP map!"));\r
353         }\r
354         if(mapGRP->GetValue("fDetectorMask")){\r
355                 SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());  \r
356         }\r
357         else { \r
358                 AliError(Form("No fDetectorMask value found in GRP map!"));\r
359         }\r
360         if(mapGRP->GetValue("fLHCPeriod")){\r
361                 SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());\r
362         }\r
363         else { \r
364                 AliError(Form("No fLHCPeriod value found in GRP map!"));\r
365         }\r
366         if(mapGRP->GetValue("fRunType")){\r
367                 SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());\r
368         }\r
369         else { \r
370                 AliError(Form("No fRunType value found in GRP map!"));\r
371         }\r
372         if(mapGRP->GetValue("fLHCState")){\r
373                 SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());\r
374         }\r
375         else { \r
376                 AliError(Form("No fLHCState value found in GRP map!"));\r
377         }\r
378         if(mapGRP->GetValue("fLHCluminosity")){\r
379                 AliInfo(Form("fLHCLuminosity found, but porting only average to the new object, since the other values are not available in the old object"));\r
380                 SetLHCLuminosity((Float_t)(((TObjString*)(mapGRP->GetValue("fLHCLuminosity")))->GetString()).Atof(),(Stats)0);\r
381         }       \r
382         else { \r
383                 AliError(Form("No fLHCLuminosity value found in GRP map!"));\r
384         }\r
385         if(mapGRP->GetValue("fBeamIntensity")){\r
386                 AliInfo(Form("fBeamIntensity found, but porting only average to the new object, since the other values are not available in the old object"));\r
387                 SetBeamIntensity((Float_t)(((TObjString*)(mapGRP->GetValue("fBeamIntensity")))->GetString()).Atof(),(Stats)0);\r
388         }       \r
389         else { \r
390                 AliError(Form("No fBeamIntensity value found in GRP map!"));\r
391         }\r
392         if(mapGRP->GetValue("fL3Polarity")){\r
393                 SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());\r
394         }       \r
395         else { \r
396                 AliError(Form("No fL3Polarity value found in GRP map!"));\r
397         }\r
398         if(mapGRP->GetValue("fDipolePolarity")){\r
399                 SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());  \r
400         }       \r
401         else { \r
402                 AliError(Form("No fDipolePolarity value found in GRP map!"));\r
403         }\r
404         if(mapGRP->GetValue("fL3Current")){\r
405                 AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));\r
406                 SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);\r
407         }       \r
408         else { \r
409                 AliError(Form("No fL3Current value found in GRP map!"));\r
410         }\r
411         if(mapGRP->GetValue("fDipoleCurrent")){\r
412                 AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));\r
413                 SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);\r
414         }       \r
415         else { \r
416                 AliError(Form("No fDipoleCurrent value found in GRP map!"));\r
417         }\r
418         if(mapGRP->GetValue("fCavernTemperature")){\r
419                 AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));\r
420                 SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);\r
421         }       \r
422         else { \r
423                 AliError(Form("No fCavernTemperature value found in GRP map!"));\r
424         }\r
425         if(mapGRP->GetValue("fCavernAtmosPressure")){\r
426                 AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));\r
427         }       \r
428         else { \r
429                 AliError(Form("No fCavernAtmosPressure value found in GRP map!"));\r
430         }\r
431         if(mapGRP->GetValue("fP2Pressure")){\r
432                 SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));\r
433         }\r
434         else { \r
435                 AliError(Form("No fP2Pressure value found in GRP map!"));\r
436         }\r
437         \r
438         return;\r
439 \r
440 }\r