]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliDCSSensorArray.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix for Coverity defect 10859: FORWARD_NULL
[u/mrichter/AliRoot.git] / STEER / AliDCSSensorArray.cxx
CommitLineData
7264822f 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///////////////////////////////////////////////////////////////////////////////
18// //
19// Calibration class for DCS sensors //
20// Authors: Marian Ivanov and Haavard Helstrup //
21// //
22///////////////////////////////////////////////////////////////////////////////
23
24#include "AliDCSSensorArray.h"
82dfb6c8 25#include "AliLog.h"
1b613a12 26#include <TMath.h>
7264822f 27
28ClassImp(AliDCSSensorArray)
29
8cb8848e 30const Double_t kSecInHour = 3600.; // seconds in one hour
082c0071 31const UInt_t kMinMapTime = 60; // don't fit maps shorter than one minute
7264822f 32
33//_____________________________________________________________________________
7c76a767 34AliDCSSensorArray::AliDCSSensorArray():TNamed(),
e5250086 35 fMinGraph(10),
36 fMinPoints(10),
37 fIter(10),
38 fMaxDelta(0.0),
39 fFitReq(2),
24938b4c 40 fValCut(-1),
41 fDiffCut(-1),
7c76a767 42 fStartTime (2000,1,1,0,0,0),
43 fEndTime (2000,1,1,0,0,0),
44 fSensors(0)
7264822f 45{
46 //
47 // AliDCSSensorArray default constructor
48 //
7264822f 49
50}
51//_____________________________________________________________________________
67a165ed 52AliDCSSensorArray::AliDCSSensorArray(TClonesArray *arr):TNamed(),
24938b4c 53 fMinGraph(10),
54 fMinPoints(10),
55 fIter(10),
56 fMaxDelta(0.0),
57 fFitReq(2),
58 fValCut(-1),
59 fDiffCut(-1),
60 fStartTime (2000,1,1,0,0,0),
61 fEndTime (2000,1,1,0,0,0),
62 fSensors(arr)
63{
64 //
65 // AliDCSSensorArray special constructor taking TClonesArray from ReadList
66 //
67
68}
69//_____________________________________________________________________________
67a165ed 70AliDCSSensorArray::AliDCSSensorArray(Int_t run, const char* dbEntry) :
7c76a767 71 TNamed(),
e5250086 72 fMinGraph(10),
73 fMinPoints(10),
74 fIter(10),
75 fMaxDelta(0.0),
76 fFitReq(2),
24938b4c 77 fValCut(-1),
78 fDiffCut(-1),
7c76a767 79 fStartTime (2000,1,1,0,0,0),
80 fEndTime (2000,1,1,0,0,0),
81 fSensors(0)
7264822f 82{
83 //
24938b4c 84 // Read configuration from OCDB
7264822f 85 //
67a165ed 86
87 AliCDBEntry *entry = AliCDBManager::Instance()->Get(dbEntry,run);
24938b4c 88 TTree *tree = (TTree*) entry->GetObject();
89 fSensors = AliDCSSensor::ReadTree(tree);
90}
91//_____________________________________________________________________________
92AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
93 TTree* confTree) :
94 TNamed(),
95 fMinGraph(10),
96 fMinPoints(10),
97 fIter(10),
98 fMaxDelta(0.0),
99 fFitReq(2),
100 fValCut(-1),
101 fDiffCut(-1),
102 fStartTime (2000,1,1,0,0,0),
103 fEndTime (2000,1,1,0,0,0),
104 fSensors(0)
7264822f 105
24938b4c 106{
107 //
67a165ed 108 // AliDCSSensorArray constructor for Shuttle preprocessor
24938b4c 109 // (confTree read from OCDB)
110 //
111 fSensors = AliDCSSensor::ReadTree(confTree);
112 fSensors->BypassStreamer(kFALSE);
008ef66a 113 fStartTime = TTimeStamp((time_t)startTime,0);
114 fEndTime = TTimeStamp((time_t)endTime,0);
7264822f 115}
116
117
17984b61 118//_____________________________________________________________________________
119AliDCSSensorArray::AliDCSSensorArray(UInt_t startTime, UInt_t endTime,
120 TClonesArray *sensors) :
121 TNamed(),
122 fMinGraph(10),
123 fMinPoints(10),
124 fIter(10),
125 fMaxDelta(0.0),
126 fFitReq(2),
127 fValCut(-1),
128 fDiffCut(-1),
129 fStartTime (2000,1,1,0,0,0),
130 fEndTime (2000,1,1,0,0,0),
131 fSensors(sensors)
132
133{
134 //
135 // AliDCSSensorArray constructor for Shuttle preprocessor
136 // (TClonesArray of AliDCSSensor objects)
137 //
008ef66a 138 fStartTime = TTimeStamp((time_t)startTime,0);
139 fEndTime = TTimeStamp((time_t)endTime,0);
17984b61 140}
7264822f 141
142//_____________________________________________________________________________
7c76a767 143AliDCSSensorArray::AliDCSSensorArray(const AliDCSSensorArray &c):TNamed(c),
e5250086 144 fMinGraph(c.fMinGraph),
145 fMinPoints(c.fMinPoints),
146 fIter(c.fIter),
147 fMaxDelta(c.fMaxDelta),
148 fFitReq(c.fFitReq),
149 fValCut(c.fValCut),
150 fDiffCut(c.fDiffCut),
7c76a767 151 fStartTime (c.fStartTime),
152 fEndTime (c.fEndTime),
153 fSensors(0)
154
7264822f 155{
156 //
157 // AliDCSSensorArray copy constructor
158 //
159
67a165ed 160 fSensors = (TClonesArray*)c.fSensors->Clone();
7264822f 161}
162
163///_____________________________________________________________________________
164AliDCSSensorArray::~AliDCSSensorArray()
165{
166 //
167 // AliDCSSensorArray destructor
168 //
169 fSensors->Delete();
170 delete fSensors;
171
172}
173
174//_____________________________________________________________________________
175AliDCSSensorArray &AliDCSSensorArray::operator=(const AliDCSSensorArray &c)
176{
177 //
178 // Assignment operator
179 //
67a165ed 180 if (this != &c) {
181 fSensors->Delete();
182 new (this) AliDCSSensorArray(c);
183 fSensors = (TClonesArray*)c.fSensors->Clone();
184 }
7264822f 185 return *this;
7264822f 186}
187
67a165ed 188//____________________________________________________________________________
7264822f 189
82dfb6c8 190void AliDCSSensorArray::SetGraph(TMap *map)
7264822f 191{
82dfb6c8 192 //
193 // Read graphs from DCS maps
7264822f 194 //
7264822f 195 Int_t nsensors = fSensors->GetEntries();
196 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
197 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
82dfb6c8 198 TString stringID = entry->GetStringID();
24938b4c 199 TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
200 if ( gr !=0 ) {
201 entry->SetGraph((TGraph*)gr->Clone());
82dfb6c8 202 } else {
24938b4c 203 entry->SetGraph(0);
204 }
82dfb6c8 205 }
206}
7264822f 207//_____________________________________________________________________________
82dfb6c8 208void AliDCSSensorArray::MakeSplineFit(TMap *map, Bool_t keepMap)
7264822f 209{
82dfb6c8 210 //
211 // Make spline fits from DCS maps
7264822f 212 //
7264822f 213 Int_t nsensors = fSensors->GetEntries();
214 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
215 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
82dfb6c8 216 TString stringID = entry->GetStringID();
24938b4c 217 TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
008ef66a 218 if (!gr ) {
24938b4c 219 entry->SetFit(0);
82dfb6c8 220 entry->SetGraph(0);
221 AliWarning(Form("sensor %s: no input graph",stringID.Data()));
222 continue;
24938b4c 223 }
082c0071 224 UInt_t timeDiff = entry->GetEndTime() - entry->GetStartTime();
225 if ( timeDiff < kMinMapTime ) {
226 AliWarning(Form("sensor %s: map length < 60 s, DCS graph kept.",stringID.Data()));
6ec4e3e3 227 entry->SetGraph((TGraph*)gr->Clone());
082c0071 228 } else {
229 AliSplineFit *fit = new AliSplineFit();
230 fit->SetMinPoints(fMinGraph);
231 fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
232 fit->SplineFit(fFitReq);
233 fit->Cleanup();
234 if (fit) {
235 entry->SetFit(fit);
236 } else {
237 AliWarning(Form("sensor %s: no fit performed, DCS graph kept.",stringID.Data()));
238 entry->SetGraph((TGraph*)gr->Clone());
239 }
82dfb6c8 240 }
6ec4e3e3 241 if (keepMap) entry->SetGraph((TGraph*)gr->Clone());
82dfb6c8 242 }
243}
e7097603 244//_____________________________________________________________________________
0baf4718 245void AliDCSSensorArray::MakeSplineFitAddPoints(TMap *map)
e7097603 246{
247 //
0baf4718 248 // Make spline fits from DCS maps
e7097603 249 //
250 Int_t nsensors = fSensors->GetEntries();
251 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
252 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
0baf4718 253
254 // fetch old points from existing graph
255
256 TGraph *gr = entry->GetGraph();
257 if (!gr) {
258 gr = new TGraph();
259 entry->SetGraph(gr);
260 }
e7097603 261 TString stringID = entry->GetStringID();
0baf4718 262
263 // fetch new points from DCS map
264
265 TGraph *grAdd = (TGraph*)map->GetValue(stringID.Data());
266 if (!grAdd ) return;
267
268 // add new points to end of graph
269
270 Int_t nPointsOld=gr->GetN();
271 Int_t nPointsAdd=grAdd->GetN();
272 gr->Expand(nPointsOld+nPointsAdd);
273 gr->Set(nPointsOld+nPointsAdd);
274 Double_t *addX=grAdd->GetX();
275 Double_t *addY=grAdd->GetY();
276 for (Int_t i=0;i<nPointsAdd;i++) {
277 gr->SetPoint(nPointsOld+i,addX[i],addY[i]);
278 }
279
280 // make fit to complete graph
281
282 AliSplineFit *fit = new AliSplineFit();
283 fit->SetMinPoints(fMinGraph);
284 fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
285 fit->SplineFit(fFitReq);
286 fit->Cleanup();
287 if (fit) {
288 AliSplineFit *oldFit = entry->GetFit();
289 if (oldFit) delete oldFit;
290 entry->SetFit(fit);
291 } else {
292 AliWarning(Form("sensor %s: no new fit performed. If available, old fit kept.",stringID.Data()));
e7097603 293 }
e7097603 294 }
295}
7264822f 296
67a165ed 297//_____________________________________________________________________________
298Int_t AliDCSSensorArray::NumFits() const
299{
300 //
301 // Return number of sensors where a succesful fit has been made
302 //
303 Int_t nfit=0;
304 Int_t nsensors = fSensors->GetEntries();
305 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
306 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
307 if (entry->GetFit()) nfit++;
308 }
309 return nfit;
310}
7264822f 311//_____________________________________________________________________________
082c0071 312Double_t AliDCSSensorArray::GetValue(UInt_t timeSec, Int_t sensor)
7264822f 313{
82dfb6c8 314 //
7264822f 315 // Return sensor value at time timeSec (obtained from fitted function)
316 // timeSec = time in seconds from start of run
317 //
082c0071 318
7264822f 319 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(sensor);
082c0071 320 return entry->GetValue(TTimeStamp((time_t)fStartTime.GetSec()+timeSec,0));
7264822f 321}
82dfb6c8 322
7264822f 323
324//_____________________________________________________________________________
0baf4718 325TMap* AliDCSSensorArray::ExtractDCS(TMap *dcsMap, Bool_t keepStart)
7264822f 326{
327 //
328 // Extract temperature graphs from DCS maps
329 //
330 TMap *values = new TMap;
331 TObjArray * valueSet;
008ef66a 332 //
333 // Keep global start/end times
334 // to avoid extrapolations, the fits will only be valid from first
335 // measured point to last measured point. This is consistent with hardware,
336 // as there would be a new measured point if the value changed.
337
338 TTimeStamp startTime=fStartTime;
339 TTimeStamp endTime=fEndTime;
340
7c76a767 341 Int_t nsensors = fSensors->GetEntries();
342 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
343 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
82dfb6c8 344 TString stringID = entry->GetStringID();
24938b4c 345 TPair *pair = (TPair*)dcsMap->FindObject(stringID.Data());
82dfb6c8 346 if ( pair ) { // only try to read values
24938b4c 347 // if DCS object available
348 valueSet = (TObjArray*)pair->Value();
0baf4718 349 TGraph *graph = MakeGraph(valueSet,keepStart); // MakeGraph sets start/end time
008ef66a 350 // per sensor
24938b4c 351 values->Add(new TObjString(stringID.Data()),graph);
008ef66a 352 entry->SetStartTime(fStartTime);
353 entry->SetEndTime(fEndTime);
24938b4c 354 }
7264822f 355 }
008ef66a 356 // Reset global start/end time
357 // ..... yes, I know this won't get a prize for structured programming..:-)
358
359 fStartTime=startTime;
360 fEndTime=endTime;
7264822f 361 return values;
362}
363
989362ab 364
7264822f 365//_____________________________________________________________________________
0baf4718 366TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet, Bool_t keepStart){
7264822f 367 //
368 // Make graph of temperature values read from DCS map
369 // (spline fit parameters will subsequently be obtained from this graph)
370 //
371 Int_t nentries = valueSet->GetEntriesFast();
24938b4c 372 if ( nentries == 0 ) return 0;
373
7264822f 374 Float_t *x = new Float_t[nentries];
375 Float_t *y = new Float_t[nentries];
4ba8baed 376 Int_t time0=0, previousTime=0;
bf84b403 377 TTimeStamp firstTime(0);
378 TTimeStamp lastTime(0);
0baf4718 379 if (keepStart) {
380 firstTime = fStartTime;
381 time0 = firstTime.GetSec();
382 }
7264822f 383 Int_t out=0;
384 Int_t skipped=0;
e5250086 385 AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
386 AliDCSValue::Type type = val->GetType();
387 if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
388 Float_t value;
7264822f 389 for (Int_t i=0; i<nentries; i++){
e5250086 390 val = (AliDCSValue *)valueSet->At(i);
7264822f 391 if (!val) continue;
392 if (time0==0){
393 time0=val->GetTimeStamp();
40de6493 394 firstTime= TTimeStamp((time_t)val->GetTimeStamp(),0);
395 lastTime=TTimeStamp((time_t)val->GetTimeStamp(),0);
0baf4718 396 }
e5250086 397 switch ( type )
398 {
399 case AliDCSValue::kFloat:
400 value = val->GetFloat();
401 break;
402 case AliDCSValue::kChar:
24938b4c 403 value = static_cast<Float_t>(val->GetChar());
e5250086 404 break;
405 case AliDCSValue::kInt:
24938b4c 406 value = static_cast<Float_t>(val->GetInt());
e5250086 407 break;
408 case AliDCSValue::kUInt:
24938b4c 409 value = static_cast<Float_t>(val->GetUInt());
e5250086 410 break;
411 default:
412 continue;
413 }
24938b4c 414 if (fValCut>0 && TMath::Abs(value)>fValCut) continue; // refuse values greater than cut
415 if (fDiffCut>0 ) {
416 if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
417 skipped++; // refuse values changing
418 continue; // by > cut in one time step
419 }
420 skipped=0;
421 }
7264822f 422 if (val->GetTimeStamp()-time0>1000000) continue;
4ba8baed 423 if (val->GetTimeStamp()-previousTime < 1 ) continue; // refuse duplicate recordings
424 previousTime=val->GetTimeStamp();
40de6493 425 lastTime=TTimeStamp((time_t)val->GetTimeStamp(),0);
8cb8848e 426 x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours
7264822f 427 y[out] = val->GetFloat();
bf84b403 428 out++;
7264822f 429 }
0baf4718 430 if (!keepStart) fStartTime=firstTime;
008ef66a 431 fEndTime=lastTime;
7264822f 432 TGraph * graph = new TGraph(out,x,y);
433 delete [] x;
434 delete [] y;
435 return graph;
436}
989362ab 437
438//_____________________________________________________________________________
439void AliDCSSensorArray::RemoveGraphDuplicates(Double_t tolerance){
440//
441// Remove points with same y value as the previous measured point
442// (to save space for non-fitted graphs -- i.e. last measured point used)
443//
444 Int_t nsensors = fSensors->GetEntries();
445 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
446 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
447 TGraph *graph = entry->GetGraph();
448 Double_t x=-999.,y=-999., x0=-999.,y0=-999.;
449 if (graph) {
450 Int_t npoints=graph->GetN();
451 if (npoints>1) {
452 for (Int_t i=npoints-1;i>0;i--) {
453 graph->GetPoint(i,x,y);
454 graph->GetPoint(i-1,x0,y0);
1b613a12 455 if ( TMath::Abs(y-y0) < TMath::Abs(tolerance*y0) ) graph->RemovePoint(i);
989362ab 456 }
457 }
458 }
459 }
460}
461
7264822f 462
463//_____________________________________________________________________________
464AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS)
465{
466 //
467 // Return sensor information for sensor specified by IdDCS
468 //
469 Int_t nsensors = fSensors->GetEntries();
470 for (Int_t isensor=0; isensor<nsensors; isensor++) {
471 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
472 if (entry->GetIdDCS() == IdDCS) return entry;
473 }
474 return 0;
475}
476//_____________________________________________________________________________
82dfb6c8 477AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
24938b4c 478{
479 //
9663477d 480 // Return sensor information for sensor specified by stringID
24938b4c 481 //
482 Int_t nsensors = fSensors->GetEntries();
483 for (Int_t isensor=0; isensor<nsensors; isensor++) {
484 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
485 if (entry->GetStringID() == stringID) return entry;
486 }
487 return 0;
488}
489//_____________________________________________________________________________
82dfb6c8 490AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
7264822f 491{
492 //
493 // Return sensor closest to given position
494 //
495 Int_t nsensors = fSensors->GetEntries();
496 Double_t dist2min=1e99;
497 Double_t xs,ys,zs,dist2;
498 Int_t ind=-1;
499 for (Int_t isensor=0; isensor<nsensors; isensor++) {
500 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
501 xs = entry->GetX();
502 ys = entry->GetY();
503 zs = entry->GetZ();
504 dist2 = (x-xs)*(x-xs) + (y-ys)*(y-ys) + (z-zs)*(z-zs);
505 if (dist2 < dist2min) {
506 ind=isensor;
507 dist2min = dist2;
82dfb6c8 508 }
7264822f 509 }
510 if ( ind >= 0 ) {
511 return (AliDCSSensor*)fSensors->At(ind);
512 } else {
513 return 0;
514 }
515}
bf84b403 516//_____________________________________________________________________________
82dfb6c8 517AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
8cb8848e 518{
519 //
520 // Return sensor given by array index
521 //
522 return (AliDCSSensor*)fSensors->At(ind);
523}
524
9663477d 525//_____________________________________________________________________________
526Int_t AliDCSSensorArray::SetSensor(const TString& stringID,
527 const AliDCSSensor& sensor)
528{
529 //
530 // Update sensor information for sensor specified by stringID
531 //
532 Int_t nsensors = fSensors->GetEntries();
533 for (Int_t isensor=0; isensor<nsensors; isensor++) {
534 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
535 if (entry->GetStringID() == stringID)
536 {
537 new ((*fSensors)[isensor])AliDCSSensor(sensor);
538 return isensor;
539 }
540 }
541 return -1;
542}
543//_____________________________________________________________________________
544void AliDCSSensorArray::SetSensorNum(const Int_t ind, const AliDCSSensor& sensor)
545{
546 //
547 // Update sensor information for sensor at index ind
548 //
549 new ((*fSensors)[ind])AliDCSSensor(sensor);
550 return;
551}
bf84b403 552//_____________________________________________________________________________
82dfb6c8 553void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
554{
555 //
556 // Return sensor given by array index
557 //
558
559 delete fSensors->RemoveAt(ind);
560 fSensors->Compress();
561}
bf84b403 562//_____________________________________________________________________________
82dfb6c8 563void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
564{
565 //
566 // Deletes Sensor by given IdDCS
567 //
568
569 Int_t nsensors = fSensors->GetEntries();
570 for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
571 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
572 if (entry->GetIdDCS()==IdDCS) {
573 delete fSensors->RemoveAt(isensor);
574 break;
575 }
576 }
577 fSensors->Compress();
578}
bf84b403 579//_____________________________________________________________________________
580TArrayI AliDCSSensorArray::OutsideThreshold(Double_t threshold, UInt_t timeSec, Bool_t below) const
581{
582 //
583 // Return sensors with values outside threshold at time defined by second
584 // parameter
585 // By default sensors with values below threshold are listed, if third
586 // parameter is set to kFALSE sensors with values above threshold are listed
587 //
588 Int_t nsensors = fSensors->GetEntries();
589 TArrayI array(nsensors);
590 Int_t outside=0;
591 for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
592 AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
0baf4718 593 Double_t val=entry->GetValue(timeSec);
bf84b403 594 if (below) {
595 if (val<threshold) array[outside++] = entry->GetIdDCS();
596 } else {
597 if (val>threshold) array[outside++] = entry->GetIdDCS();
598 }
599 }
600 array.Set(outside);
601 return array;
602}
603
604//_____________________________________________________________________________
8cb8848e 605Int_t AliDCSSensorArray::GetFirstIdDCS() const
606{
607 //
608 // Return DCS Id of first sensor
609 //
610 if ( fSensors != 0 ) {
611 return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
612 } else {
613 return 0;
614 }
615}
616
bf84b403 617//_____________________________________________________________________________
8cb8848e 618Int_t AliDCSSensorArray::GetLastIdDCS() const
619{
620 //
621 // Return DCS Id of last sensor
622 //
623 if ( fSensors != 0 ) {
624 Int_t last = fSensors->GetEntries();
625 return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
626 } else {
627 return 0;
628 }
629}
bf84b403 630//_____________________________________________________________________________
24938b4c 631void AliDCSSensorArray::ClearGraph()
632{
633 //
634 // Delete DCS graphs from all sensors in array
635 //
636
637 Int_t nsensors = fSensors->GetEntries();
638 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
639 AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
640 TGraph *gr = sensor->GetGraph();
641 if ( gr != 0 ) {
642 delete gr;
643 gr = 0;
644 }
645 sensor->SetGraph(0);
82dfb6c8 646 }
647}
bf84b403 648//_____________________________________________________________________________
24938b4c 649void AliDCSSensorArray::ClearFit()
650{
651 //
652 // Delete spline fits from all sensors in array
653 //
82dfb6c8 654
24938b4c 655 Int_t nsensors = fSensors->GetEntries();
656 for ( Int_t isensor=0; isensor<nsensors; isensor++) {
657 AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
658 AliSplineFit *fit = sensor->GetFit();
659 if ( fit != 0 ) {
660 delete fit;
661 fit = 0;
662 }
663 sensor->SetFit(0);
82dfb6c8 664 }
665}
e7097603 666//_____________________________________________________________________________
667void AliDCSSensorArray::AddSensors(AliDCSSensorArray *newSensors)
668{
669 //
670 // add sensors from two sensor arrays
671 //
672
673 Int_t numNew = newSensors->NumSensors();
674 Int_t numOld = fSensors->GetEntries();
675 fSensors->Expand(numOld+numNew);
676 for (Int_t i=0;i<numNew;i++) {
677 AliDCSSensor *sens = newSensors->GetSensorNum(i);
678 new ((*fSensors)[numOld+i]) AliDCSSensor(*sens);
679 }
680}
681