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