]>
Commit | Line | Data |
---|---|---|
345932e4 | 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 | /* | |
17 | $Log$ | |
ebab534a | 18 | Revision 1.2 2006/12/18 18:17:38 arcelli |
19 | Updated Aliases for DCS TOF datapoints (C.Zampolli) | |
20 | ||
8259e6f8 | 21 | Revision 1.1 2006/10/26 09:10:52 arcelli |
22 | Class for handling the TOF DCS data in the Shuttle (C.Zampolli) | |
23 | ||
345932e4 | 24 | */ |
25 | ||
26 | #include "AliTOFDataDCS.h" | |
27 | ||
28 | #include "AliDCSValue.h" | |
29 | #include "AliLog.h" | |
30 | ||
31 | #include "TString.h" | |
32 | #include "AliTOFFormatDCS.h" | |
33 | #include "TF1.h" | |
34 | #include "TCanvas.h" | |
35 | #include "TH1F.h" | |
36 | #include "TTimeStamp.h" | |
37 | #include "TMap.h" | |
38 | ||
39 | class TH2; | |
40 | class AliCDBMetaData; | |
41 | class TDatime; | |
42 | ||
43 | // AliTOFDataDCS class | |
44 | // main aim to introduce the aliases for the TOF DCS | |
45 | // data points to be then | |
46 | // stored in the OCDB, and to process them. | |
47 | // Process() method called by TOFPrepr | |
48 | ||
49 | ClassImp(AliTOFDataDCS) | |
50 | ||
51 | //--------------------------------------------------------------- | |
52 | AliTOFDataDCS::AliTOFDataDCS(): | |
53 | TObject(), | |
54 | fRun(0), | |
55 | fStartTime(0), | |
56 | fEndTime(0), | |
57 | fIsProcessed(kFALSE) | |
58 | { | |
59 | ||
60 | // main constructor | |
61 | ||
8259e6f8 | 62 | for(int i=0;i<kNHV;i++) { |
63 | fHVvp[i]=0x0; | |
64 | fHVvn[i]=0x0; | |
65 | fHVip[i]=0x0; | |
66 | fHVin[i]=0x0; | |
67 | } | |
68 | ||
69 | for(int i=0;i<kNLV;i++) { | |
70 | fLVv[i]=0x0; | |
71 | fLVi[i]=0x0; | |
72 | } | |
73 | ||
74 | for(int i=0;i<kNLV33;i++) { | |
75 | fLVv33[i]=0x0; | |
76 | fLVi33[i]=0x0; | |
77 | } | |
78 | ||
79 | for(int i=0;i<kNLV50;i++) { | |
80 | fLVv50[i]=0x0; | |
81 | fLVi50[i]=0x0; | |
82 | } | |
83 | ||
84 | for(int i=0;i<kNLV48;i++) { | |
85 | fLVv48[i]=0x0; | |
86 | fLVi48[i]=0x0; | |
87 | } | |
88 | ||
89 | for(int i=0;i<kNFEEthr;i++) { | |
90 | fFEEthr[i]=0x0; | |
91 | } | |
92 | ||
93 | for(int i=0;i<kNFEEtfeac;i++) { | |
94 | fFEEtfeac[i]=0x0; | |
95 | } | |
96 | ||
97 | for(int i=0;i<kNFEEttrm;i++) { | |
98 | fFEEttrm[i]=0x0; | |
99 | } | |
100 | ||
101 | for(int i=0;i<3;i++) { | |
102 | fT[i]=0; | |
103 | fP[i]=0; | |
104 | } | |
105 | ||
345932e4 | 106 | } |
107 | ||
108 | //--------------------------------------------------------------- | |
109 | AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime): | |
110 | TObject(), | |
111 | fRun(nRun), | |
112 | fStartTime(startTime), | |
113 | fEndTime(endTime), | |
114 | fIsProcessed(kFALSE) | |
115 | { | |
116 | ||
117 | // constructor with arguments | |
118 | ||
119 | AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun, | |
120 | TTimeStamp(startTime).AsString(), | |
121 | TTimeStamp(endTime).AsString())); | |
122 | ||
123 | Init(); | |
124 | ||
125 | } | |
126 | ||
127 | //--------------------------------------------------------------- | |
128 | ||
129 | AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data): | |
130 | TObject(), | |
131 | fRun(0), | |
132 | fStartTime(0), | |
133 | fEndTime(0), | |
134 | fIsProcessed(kFALSE) | |
135 | ||
136 | { | |
137 | ||
138 | // copy constructor | |
139 | ||
140 | fRun=data.fRun; | |
141 | fStartTime=data.fStartTime; | |
142 | fEndTime=data.fEndTime; | |
143 | fIsProcessed=data.fIsProcessed; | |
144 | ||
145 | for(int i=0;i<kNAliases;i++) { | |
146 | fAliasNames[i]=data.fAliasNames[i]; | |
147 | } | |
148 | ||
149 | for(int i=0;i<kNHV;i++) { | |
8259e6f8 | 150 | fHVvp[i]=data.fHVvp[i]; |
151 | fHVvn[i]=data.fHVvn[i]; | |
152 | fHVip[i]=data.fHVip[i]; | |
153 | fHVin[i]=data.fHVin[i]; | |
345932e4 | 154 | } |
155 | ||
156 | for(int i=0;i<kNLV;i++) { | |
157 | fLVv[i]=data.fLVv[i]; | |
8259e6f8 | 158 | fLVi[i]=data.fLVi[i]; |
159 | } | |
160 | ||
161 | for(int i=0;i<kNLV33;i++) { | |
162 | fLVv33[i]=data.fLVv33[i]; | |
163 | fLVi33[i]=data.fLVi33[i]; | |
164 | } | |
165 | ||
166 | for(int i=0;i<kNLV50;i++) { | |
167 | fLVv50[i]=data.fLVv50[i]; | |
168 | fLVi50[i]=data.fLVi50[i]; | |
169 | } | |
170 | ||
171 | for(int i=0;i<kNLV48;i++) { | |
172 | fLVv48[i]=data.fLVv48[i]; | |
173 | fLVi48[i]=data.fLVi48[i]; | |
345932e4 | 174 | } |
175 | ||
176 | for(int i=0;i<kNFEEthr;i++) { | |
177 | fFEEthr[i]=data.fFEEthr[i]; | |
178 | } | |
179 | ||
8259e6f8 | 180 | for(int i=0;i<kNFEEtfeac;i++) { |
181 | fFEEtfeac[i]=data.fFEEtfeac[i]; | |
182 | } | |
183 | ||
184 | for(int i=0;i<kNFEEttrm;i++) { | |
185 | fFEEttrm[i]=data.fFEEttrm[i]; | |
345932e4 | 186 | } |
187 | ||
188 | for(int i=0;i<3;i++) { | |
189 | fT[i]=data.fT[i]; | |
190 | fP[i]=data.fP[i]; | |
191 | } | |
192 | ||
193 | } | |
194 | //--------------------------------------------------------------- | |
195 | ||
196 | AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) { | |
197 | ||
198 | // assignment operator | |
199 | ||
200 | this->fRun=data.GetRun(); | |
201 | this->fStartTime=data.GetStartTime(); | |
202 | this->fEndTime=data.GetEndTime(); | |
203 | ||
204 | for(int i=0;i<kNAliases;i++) { | |
205 | this->fAliasNames[i]=data.GetAliasName(i); | |
206 | } | |
207 | ||
208 | for(int i=0;i<3;i++) { | |
209 | this->fT[i]=data.GetT(i); | |
210 | this->fP[i]=data.GetP(i); | |
211 | } | |
212 | ||
345932e4 | 213 | |
214 | for(int i=0;i<kNHV;i++) { | |
8259e6f8 | 215 | this->fHVvp[i]=data.GetHVvp(i); |
216 | this->fHVvn[i]=data.GetHVvn(i); | |
217 | this->fHVip[i]=data.GetHVip(i); | |
218 | this->fHVin[i]=data.GetHVin(i); | |
345932e4 | 219 | } |
220 | ||
221 | for(int i=0;i<kNLV;i++) { | |
222 | this->fLVv[i]=data.GetLVv(i); | |
8259e6f8 | 223 | this->fLVi[i]=data.GetLVi(i); |
224 | } | |
225 | ||
226 | for(int i=0;i<kNLV33;i++) { | |
227 | this->fLVv33[i]=data.GetLVv33(i); | |
228 | this->fLVi33[i]=data.GetLVi33(i); | |
229 | } | |
230 | ||
231 | for(int i=0;i<kNLV50;i++) { | |
232 | this->fLVv50[i]=data.GetLVv50(i); | |
233 | this->fLVi50[i]=data.GetLVi50(i); | |
234 | } | |
235 | ||
236 | for(int i=0;i<kNLV48;i++) { | |
237 | this->fLVv48[i]=data.GetLVv48(i); | |
238 | this->fLVi48[i]=data.GetLVi48(i); | |
345932e4 | 239 | } |
240 | ||
241 | for(int i=0;i<kNFEEthr;i++) { | |
242 | this->fFEEthr[i]=data.GetFEEthr(i); | |
243 | } | |
244 | ||
8259e6f8 | 245 | for(int i=0;i<kNFEEtfeac;i++) { |
246 | this->fFEEtfeac[i]=data.GetFEEtfeac(i); | |
247 | } | |
248 | ||
249 | for(int i=0;i<kNFEEttrm;i++) { | |
250 | this->fFEEttrm[i]=data.GetFEEttrm(i); | |
345932e4 | 251 | } |
252 | ||
253 | this->fIsProcessed=data.fIsProcessed; | |
254 | ||
255 | return *this; | |
256 | } | |
257 | //--------------------------------------------------------------- | |
258 | AliTOFDataDCS::~AliTOFDataDCS() { | |
259 | ||
260 | // destructor | |
261 | ||
8259e6f8 | 262 | for(int i=0;i<kNHV;i++) { |
263 | delete fHVvp[i]; | |
264 | fHVvp[i]=0; | |
265 | delete fHVvn[i]; | |
266 | fHVvn[i]=0; | |
267 | delete fHVip[i]; | |
268 | fHVip[i]=0; | |
269 | delete fHVin[i]; | |
270 | fHVin[i]=0; | |
271 | } | |
272 | ||
273 | for(int i=0;i<kNLV;i++) { | |
274 | delete fLVv[i]; | |
275 | fLVv[i]=0; | |
276 | delete fLVi[i]; | |
277 | fLVi[i]=0; | |
278 | } | |
279 | ||
280 | for(int i=0;i<kNLV33;i++) { | |
281 | delete fLVv33[i]; | |
282 | fLVv33[i]=0; | |
283 | delete fLVi33[i]; | |
284 | fLVi33[i]=0; | |
285 | } | |
286 | ||
287 | for(int i=0;i<kNLV50;i++) { | |
288 | delete fLVv50[i]; | |
289 | fLVv50[i]=0; | |
290 | delete fLVi50[i]; | |
291 | fLVi50[i]=0; | |
292 | } | |
293 | ||
294 | for(int i=0;i<kNLV48;i++) { | |
295 | delete fLVv48[i]; | |
296 | fLVv48[i]=0; | |
297 | delete fLVi48[i]; | |
298 | fLVi48[i]=0; | |
299 | } | |
300 | ||
301 | for(int i=0;i<kNFEEthr;i++) { | |
302 | delete fFEEthr[i]; | |
303 | fFEEthr[i]=0; | |
304 | } | |
305 | ||
306 | for(int i=0;i<kNFEEtfeac;i++) { | |
307 | delete fFEEtfeac[i]; | |
308 | fFEEtfeac[i]=0; | |
309 | } | |
310 | ||
311 | for(int i=0;i<kNFEEttrm;i++) { | |
312 | delete fFEEttrm[i]; | |
313 | fFEEttrm[i]=0; | |
314 | } | |
345932e4 | 315 | } |
316 | ||
317 | //----------------------------------------------------------------------------- | |
318 | Float_t* AliTOFDataDCS::GetT()const { | |
319 | ||
320 | // method to retrieve environment temperature info | |
321 | ||
322 | Float_t* t=0; | |
323 | for (Int_t i=0;i<3;i++){ | |
324 | t[i]=this->fT[i]; | |
325 | } | |
326 | return t; | |
327 | } | |
328 | //----------------------------------------------------------------------------- | |
329 | Float_t* AliTOFDataDCS::GetP() const{ | |
330 | ||
331 | // method to retrieve environment pressure info | |
332 | ||
333 | Float_t* p=0; | |
334 | for (Int_t i=0;i<3;i++){ | |
335 | p[i]=this->fP[i]; | |
336 | } | |
337 | return p; | |
338 | } | |
339 | ||
340 | //--------------------------------------------------------------- | |
ebab534a | 341 | Bool_t AliTOFDataDCS::ProcessData(TMap& aliasMap){ |
345932e4 | 342 | |
343 | if(!(fAliasNames[0])) Init(); | |
344 | ||
345 | Float_t timeMin = (Float_t)fStartTime; | |
346 | Float_t timeMax = (Float_t)fEndTime; | |
345932e4 | 347 | Float_t val=0; |
348 | Float_t val1=0; | |
349 | Float_t time=0; | |
350 | Float_t delta[2]; | |
351 | Float_t timedelta[2]; | |
352 | ||
353 | TObjArray *aliasArr; | |
354 | AliDCSValue* aValue; | |
355 | AliDCSValue* aValue1; | |
356 | TH1F * histoT=0x0; | |
357 | TH1F * histoP=0x0; | |
358 | ||
359 | // starting loop on aliases | |
360 | for(int j=0; j<kNAliases; j++){ | |
361 | for (Int_t k=0;k<2;k++) { | |
362 | delta[k]=0; | |
363 | timedelta[k]=0; | |
364 | } | |
365 | //AliInfo(Form("j = %i, with alias = %s",j,fAliasNames[j].Data())); | |
366 | aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data()); | |
367 | if(!aliasArr){ | |
368 | AliError(Form("Alias %s not found!", fAliasNames[j].Data())); | |
ebab534a | 369 | return kFALSE; |
345932e4 | 370 | } |
371 | ||
372 | Introduce(j, aliasArr); | |
373 | ||
374 | if(aliasArr->GetEntries()<3){ | |
375 | AliError(Form("Alias %s has just %d entries!", | |
376 | fAliasNames[j].Data(),aliasArr->GetEntries())); | |
377 | continue; | |
378 | } | |
379 | ||
380 | TIter iterarray(aliasArr); | |
381 | ||
382 | Int_t nentries = aliasArr->GetEntries(); | |
345932e4 | 383 | Int_t deltaTimeStamp = (Int_t) nentries/3; |
384 | Int_t deltaTimeStamp1 = (Int_t) nentries/2; | |
385 | AliDCSValue *lastDCSvalue = (AliDCSValue*) aliasArr->At(nentries-1); | |
386 | Float_t maxTimeStamp = (Float_t) (lastDCSvalue->GetTimeStamp()); | |
387 | Float_t minTimeStamp = 0; | |
388 | ||
389 | // filling aliases with 10 floats+1 Usign | |
8259e6f8 | 390 | if (j < kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm){ |
345932e4 | 391 | Int_t index = 0; |
392 | for (Int_t k=0;k<3;k++){ | |
393 | index = deltaTimeStamp*k; | |
394 | if (k==0) { | |
395 | index=0; | |
396 | } | |
397 | else if (k==1) { | |
398 | index=deltaTimeStamp1; | |
399 | } | |
400 | else if (k==2) { | |
401 | index=nentries-1; | |
402 | } | |
403 | aValue = (AliDCSValue*) aliasArr->At(index); | |
404 | val = aValue->GetFloat(); | |
405 | time = (Float_t) (aValue->GetTimeStamp()); | |
406 | if (j<kNHV){ | |
8259e6f8 | 407 | fHVvp[j]->SetFloat(k,val); |
408 | fHVvp[j]->SetTimeStampFloat(k,time); | |
345932e4 | 409 | } |
410 | else if (j<kNHV*2){ | |
8259e6f8 | 411 | fHVvn[j-kNHV]->SetFloat(k,val); |
412 | fHVvn[j-kNHV]->SetTimeStampFloat(k,time); | |
345932e4 | 413 | } |
414 | else if (j<kNHV*3){ | |
8259e6f8 | 415 | fHVip[j-2*kNHV]->SetFloat(k,val); |
416 | fHVip[j-2*kNHV]->SetTimeStampFloat(k,time); | |
345932e4 | 417 | } |
418 | else if (j<kNHV*4){ | |
8259e6f8 | 419 | fHVin[j-3*kNHV]->SetFloat(k,val); |
420 | fHVin[j-3*kNHV]->SetTimeStampFloat(k,time); | |
345932e4 | 421 | } |
422 | else if (j<kNHV*4+kNLV){ | |
423 | fLVv[j-4*kNHV]->SetFloat(k,val); | |
424 | fLVv[j-4*kNHV]->SetTimeStampFloat(k,time); | |
425 | } | |
426 | else if (j<kNHV*4+kNLV*2){ | |
8259e6f8 | 427 | fLVi[j-4*kNHV-kNLV]->SetFloat(k,val); |
428 | fLVi[j-4*kNHV-kNLV]->SetTimeStampFloat(k,time); | |
429 | } | |
430 | else if (j<kNHV*4+kNLV*2+kNLV33){ | |
431 | fLVv33[j-4*kNHV-2*kNLV]->SetFloat(k,val); | |
432 | fLVv33[j-4*kNHV-2*kNLV]->SetTimeStampFloat(k,time); | |
433 | } | |
434 | else if (j<kNHV*4+kNLV*2+kNLV33*2){ | |
435 | fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetFloat(k,val); | |
436 | fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetTimeStampFloat(k,time); | |
437 | } | |
438 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50){ | |
439 | fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetFloat(k,val); | |
440 | fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetTimeStampFloat(k,time); | |
441 | } | |
442 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2){ | |
443 | fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetFloat(k,val); | |
444 | fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetTimeStampFloat(k,time); | |
445 | } | |
446 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48){ | |
447 | fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetFloat(k,val); | |
448 | fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetTimeStampFloat(k,time); | |
345932e4 | 449 | } |
8259e6f8 | 450 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2){ |
451 | fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetFloat(k,val); | |
452 | fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetTimeStampFloat(k,time); | |
453 | } | |
454 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr){ | |
455 | fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetFloat(k,val); | |
456 | fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetTimeStampFloat(k,time); | |
457 | } | |
458 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac){ | |
459 | fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetFloat(k,val); | |
460 | fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampFloat(k,time); | |
345932e4 | 461 | } |
462 | else { | |
8259e6f8 | 463 | fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetFloat(k,val); |
464 | fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampFloat(k,time); | |
345932e4 | 465 | } |
466 | } | |
467 | } | |
468 | ||
469 | //filling Temperature and Pressure aliases | |
470 | ||
471 | else { | |
472 | Int_t entriesT=0; | |
473 | Int_t entriesP=0; | |
8259e6f8 | 474 | if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+1){ |
345932e4 | 475 | histoT=new TH1F("histoT","histoT",nentries,minTimeStamp,maxTimeStamp); |
476 | } | |
8259e6f8 | 477 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+2) { |
345932e4 | 478 | histoP=new TH1F("histoP","histoP",nentries,minTimeStamp,maxTimeStamp); |
479 | } | |
480 | while ((aValue = (AliDCSValue*) iterarray.Next())) { | |
481 | val = aValue->GetFloat(); | |
482 | time = (Float_t) (aValue->GetTimeStamp()); | |
8259e6f8 | 483 | if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+1){ |
345932e4 | 484 | histoT->Fill(time,val); |
485 | entriesT = (Int_t)(histoT->GetEntries()); | |
486 | } | |
8259e6f8 | 487 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+2){ |
345932e4 | 488 | histoP->Fill(time,val); |
489 | entriesP = (Int_t)(histoP->GetEntries()); | |
490 | } | |
491 | } | |
492 | ||
8259e6f8 | 493 | if (j==kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+1){ |
345932e4 | 494 | entriesT = (Int_t)(histoT->GetEntries()); |
495 | histoT->Fit("pol1","Q",""); | |
496 | histoP->Fit("pol1","Q",""); | |
497 | ||
498 | TF1 *tempFunc = histoT->GetFunction("pol1"); | |
499 | TF1 *pressFunc = histoP->GetFunction("pol1"); | |
500 | ||
501 | SetInterceptT((Float_t)tempFunc->GetParameter(0)); | |
502 | SetSlopeT((Float_t)tempFunc->GetParameter(1)); | |
503 | SetMaxT((Float_t)histoT->GetMaximum()); | |
504 | SetInterceptP((Float_t)pressFunc->GetParameter(0)); | |
505 | SetSlopeP((Float_t)pressFunc->GetParameter(1)); | |
506 | SetMaxP((Float_t)histoP->GetMaximum()); | |
507 | ||
508 | TCanvas *chT; | |
509 | TString canvasHistoNameT="HistosT"; | |
510 | chT=new TCanvas(canvasHistoNameT,canvasHistoNameT,20,20,600,600); | |
511 | chT->cd(); | |
512 | histoT->Draw(); | |
513 | TCanvas *chP; | |
514 | TString canvasHistoNameP="HistosP"; | |
515 | chP=new TCanvas(canvasHistoNameP,canvasHistoNameP,20,20,600,600); | |
516 | chP->cd(); | |
517 | histoP->Draw(); | |
518 | } | |
519 | } | |
520 | ||
521 | //computing the most significant variations | |
522 | ||
523 | Int_t deltamin = (Int_t)(60/(timeMax-timeMin)*nentries); | |
524 | Int_t klast = nentries-deltamin; | |
525 | ||
526 | for (Int_t k=0;k<klast;k++){ | |
527 | aValue = (AliDCSValue*) aliasArr->At(k); | |
528 | aValue1 = (AliDCSValue*) aliasArr->At(k+deltamin); | |
529 | val = aValue->GetFloat(); | |
530 | val1 = aValue1->GetFloat(); | |
531 | if (delta[0]<=TMath::Abs(val1-val)) { | |
532 | delta[0]=TMath::Abs(val1-val); | |
533 | timedelta[0] = (Float_t)k; | |
534 | } | |
535 | if (delta[1]<=delta[0]) { | |
536 | Float_t temp = delta[1]; | |
537 | Float_t timetemp = timedelta[1]; | |
538 | delta[1]=delta[0]; | |
539 | delta[0]=temp; | |
540 | timedelta[1]=timedelta[0]; | |
541 | timedelta[0]=timetemp; | |
542 | } | |
543 | } | |
544 | ||
545 | for (Int_t kk=0;kk<2;kk++){ | |
8259e6f8 | 546 | if (j < kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac){ |
345932e4 | 547 | if (j<kNHV){ |
8259e6f8 | 548 | fHVvp[j]->SetDelta(kk,delta[kk]); |
549 | fHVvp[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 550 | } |
551 | else if (j<kNHV*2){ | |
8259e6f8 | 552 | fHVvn[j-kNHV]->SetDelta(kk,delta[kk]); |
553 | fHVvn[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 554 | } |
555 | else if (j<kNHV*3){ | |
8259e6f8 | 556 | fHVip[j-2*kNHV]->SetDelta(kk,delta[kk]); |
557 | fHVip[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 558 | } |
559 | else if (j<kNHV*4){ | |
8259e6f8 | 560 | fHVin[j-3*kNHV]->SetDelta(kk,delta[kk]); |
561 | fHVin[j-3*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 562 | } |
563 | else if (j<kNHV*4+kNLV){ | |
564 | fLVv[j-4*kNHV]->SetDelta(kk,delta[kk]); | |
565 | fLVv[j-4*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
566 | } | |
567 | else if (j<kNHV*4+kNLV*2){ | |
8259e6f8 | 568 | fLVi[j-4*kNHV-kNLV]->SetDelta(kk,delta[kk]); |
569 | fLVi[j-4*kNHV-kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
570 | } | |
571 | else if (j<kNHV*4+kNLV*2+kNLV33){ | |
572 | fLVv33[j-4*kNHV-2*kNLV]->SetDelta(kk,delta[kk]); | |
573 | fLVv33[j-4*kNHV-2*kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
574 | } | |
575 | else if (j<kNHV*4+kNLV*2+kNLV33*2){ | |
576 | fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetDelta(kk,delta[kk]); | |
577 | fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
578 | } | |
579 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50){ | |
580 | fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetDelta(kk,delta[kk]); | |
581 | fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
582 | } | |
583 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2){ | |
584 | fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetDelta(kk,delta[kk]); | |
585 | fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 586 | } |
8259e6f8 | 587 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48){ |
588 | fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetDelta(kk,delta[kk]); | |
589 | fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 590 | } |
8259e6f8 | 591 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2){ |
592 | fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetDelta(kk,delta[kk]); | |
593 | fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
594 | } | |
595 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr){ | |
596 | fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetDelta(kk,delta[kk]); | |
597 | fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
598 | } | |
599 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac){ | |
600 | fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetDelta(kk,delta[kk]); | |
601 | fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
602 | } | |
603 | else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm){ | |
604 | fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetDelta(kk,delta[kk]); | |
605 | fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]); | |
345932e4 | 606 | } |
607 | } | |
608 | ||
609 | ||
610 | //filling for temperature and pressure | |
611 | ||
8259e6f8 | 612 | else if (j==kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm){ |
345932e4 | 613 | fT[2]=delta[1]; |
614 | } | |
8259e6f8 | 615 | else if (j==kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+1){ |
345932e4 | 616 | fP[2]=delta[1]; |
617 | } | |
618 | ||
8259e6f8 | 619 | } |
345932e4 | 620 | } |
621 | ||
622 | fIsProcessed=kTRUE; | |
623 | ||
ebab534a | 624 | return kTRUE; |
345932e4 | 625 | } |
626 | ||
627 | //--------------------------------------------------------------- | |
628 | void AliTOFDataDCS::Init(){ | |
629 | ||
630 | // initialization of aliases and DCS data | |
631 | ||
8259e6f8 | 632 | TString sindex; |
345932e4 | 633 | for(int i=0;i<kNAliases;i++){ |
8259e6f8 | 634 | //HV, v |
345932e4 | 635 | if (i<kNHV){ |
8259e6f8 | 636 | fAliasNames[i] = "tof_hv_vp_"; |
637 | sindex.Form("%02i",i); | |
638 | fAliasNames[i] += sindex; | |
639 | fHVvp[i] = new AliTOFFormatDCS(); | |
345932e4 | 640 | } |
641 | else if (i<kNHV*2){ | |
8259e6f8 | 642 | fAliasNames[i] = "tof_hv_vn_"; |
643 | sindex.Form("%02i",i-kNHV); | |
644 | fAliasNames[i] += sindex; | |
645 | fHVvn[i-kNHV] = new AliTOFFormatDCS(); | |
345932e4 | 646 | } |
8259e6f8 | 647 | //HV, i |
345932e4 | 648 | else if (i<kNHV*3){ |
8259e6f8 | 649 | fAliasNames[i] = "tof_hv_ip_"; |
650 | sindex.Form("%02i",i-2*kNHV); | |
651 | fAliasNames[i] += sindex; | |
652 | fHVip[i-2*kNHV] = new AliTOFFormatDCS(); | |
345932e4 | 653 | } |
654 | else if (i<kNHV*4){ | |
8259e6f8 | 655 | fAliasNames[i] = "tof_hv_in_"; |
656 | sindex.Form("%02i",i-3*kNHV); | |
657 | fAliasNames[i] += sindex; | |
658 | fHVin[i-3*kNHV] = new AliTOFFormatDCS(); | |
345932e4 | 659 | } |
8259e6f8 | 660 | //LV, v |
345932e4 | 661 | else if (i<(kNHV*4+kNLV)){ |
8259e6f8 | 662 | fAliasNames[i] = "tof_lv_vfea_"; |
663 | sindex.Form("%03i",i-4*kNHV); | |
664 | fAliasNames[i] += sindex; | |
345932e4 | 665 | fLVv[i-4*kNHV] = new AliTOFFormatDCS(); |
666 | } | |
8259e6f8 | 667 | //LV, i |
345932e4 | 668 | else if (i<(kNHV*4+kNLV*2)){ |
8259e6f8 | 669 | fAliasNames[i] = "tof_lv_ifea_"; |
670 | sindex.Form("%03i",i-4*kNHV-kNLV); | |
671 | fAliasNames[i] += sindex; | |
672 | fLVi[i-4*kNHV-kNLV] = new AliTOFFormatDCS(); | |
673 | } | |
674 | //LV 3.3, v | |
675 | else if (i<(kNHV*4+kNLV*2+kNLV33)){ | |
676 | fAliasNames[i] = "tof_lv_v33_"; | |
677 | sindex.Form("%02i",i-4*kNHV-2*kNLV); | |
678 | fAliasNames[i] += sindex; | |
679 | fLVv33[i-4*kNHV-2*kNLV] = new AliTOFFormatDCS(); | |
680 | } | |
681 | //LV 3.3, i | |
682 | else if (i<(kNHV*4+kNLV*2+kNLV33*2)){ | |
683 | fAliasNames[i] = "tof_lv_i33_"; | |
684 | sindex.Form("%02i",i-4*kNHV-2*kNLV-kNLV33); | |
685 | fAliasNames[i] += sindex; | |
686 | fLVi33[i-4*kNHV-2*kNLV-kNLV33] = new AliTOFFormatDCS(); | |
345932e4 | 687 | } |
8259e6f8 | 688 | //LV 5.0, v |
689 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50)){ | |
690 | fAliasNames[i] = "tof_lv_v50_"; | |
691 | sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33); | |
692 | fAliasNames[i] += sindex; | |
693 | fLVv50[i-4*kNHV-2*kNLV-2*kNLV33] = new AliTOFFormatDCS(); | |
345932e4 | 694 | } |
8259e6f8 | 695 | //LV 5.0, i |
696 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2)){ | |
697 | fAliasNames[i] = "tof_lv_i50_"; | |
698 | sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-kNLV50); | |
699 | fAliasNames[i] += sindex; | |
700 | fLVi50[i-4*kNHV-2*kNLV-2*kNLV33-kNLV50] = new AliTOFFormatDCS(); | |
345932e4 | 701 | } |
8259e6f8 | 702 | //LV 48, v |
703 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48)){ | |
704 | fAliasNames[i] = "tof_lv_v48_"; | |
705 | sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50); | |
706 | fAliasNames[i] += sindex; | |
707 | fLVv48[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50] = new AliTOFFormatDCS(); | |
708 | } | |
709 | //LV 48, i | |
710 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2)){ | |
711 | fAliasNames[i] = "tof_lv_i48_"; | |
712 | sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48); | |
713 | fAliasNames[i] += sindex; | |
714 | fLVi48[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48] = new AliTOFFormatDCS(); | |
715 | } | |
716 | //FEE thresholds | |
717 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr)){ | |
718 | fAliasNames[i] = "tof_fee_th_"; | |
719 | sindex.Form("%04i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48); | |
720 | fAliasNames[i] += sindex; | |
721 | fFEEthr[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48] = new AliTOFFormatDCS(); | |
722 | } | |
723 | //FEE FEAC temperatures | |
724 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac)){ | |
725 | fAliasNames[i] = "tof_fee_tfeac_"; | |
726 | sindex.Form("%03i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr); | |
727 | fAliasNames[i] += sindex; | |
728 | fFEEtfeac[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr] = new AliTOFFormatDCS(); | |
729 | } | |
730 | //FEE trms temperatures | |
731 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm)){ | |
732 | AliInfo(Form("**before temperature ")); | |
733 | fAliasNames[i] = "tof_fee_ttrm_"; | |
734 | sindex.Form("%04i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac); | |
735 | fAliasNames[i] += sindex; | |
736 | fFEEttrm[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac] = new AliTOFFormatDCS(); | |
737 | } | |
738 | //environment temperature | |
739 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+1)){ | |
740 | AliInfo(Form("**temperature ")); | |
741 | ||
742 | fAliasNames[i] = "temperature"; | |
345932e4 | 743 | } |
8259e6f8 | 744 | //environment pressure |
745 | else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm+2)){ | |
746 | fAliasNames[i] = "pressure"; | |
345932e4 | 747 | } |
748 | } | |
749 | } | |
750 | ||
751 | ||
752 | //--------------------------------------------------------------- | |
753 | void AliTOFDataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const | |
754 | { | |
755 | ||
756 | // method to introduce new aliases | |
757 | ||
758 | int entries=0; | |
759 | entries = aliasArr->GetEntries(); | |
760 | int nal=0; | |
761 | nal=numAlias; | |
8259e6f8 | 762 | AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data())); |
763 | AliInfo(Form(" %d DP values collected",entries)); | |
345932e4 | 764 | |
765 | } | |
766 | ||
767 | //--------------------------------------------------------------- | |
768 | void AliTOFDataDCS::Draw(const Option_t* /*option*/) | |
769 | { | |
770 | // Draw all histos and graphs | |
771 | ||
772 | if(!fIsProcessed) return; | |
773 | ||
774 | TCanvas *ch; | |
775 | TString canvasHistoName="Histos"; | |
776 | ch=new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600); | |
777 | ch->cd(); | |
778 | ||
779 | // to be implemented | |
780 | ||
781 | } | |
782 |