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(gr);
 232     }
 233     if (keepMap) entry->SetGraph(gr);
 234   }
 235 }
 236
 237 //_____________________________________________________________________________
 238 Int_t AliDCSSensorArray::NumFits() const
 239 {
 240  //
 241  // Return number of sensors where a succesful fit has been made
 242  //
 243   Int_t nfit=0;
 244   Int_t nsensors = fSensors->GetEntries();
 245   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 246     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 247     if (entry->GetFit()) nfit++;
 248   }
 249   return nfit;
 250 }
 251 //_____________________________________________________________________________
 252 Double_t AliDCSSensorArray::GetValue(UInt_t timeSec, Int_t sensor)
 253 {
 254   //
 255   // Return sensor value at time timeSec (obtained from fitted function)
 256   //  timeSec = time in seconds from start of run
 257   //
 258   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(sensor);
 259   return entry->GetValue(timeSec);
 260 }
 261
 262
 263 //_____________________________________________________________________________
 264 TMap* AliDCSSensorArray::ExtractDCS(TMap *dcsMap)
 265 {
 266  //
 267  // Extract temperature graphs from DCS maps
 268  //
 269  TMap *values = new TMap;
 270  TObjArray * valueSet;
 271  //
 272  // Keep global start/end times
 273  //    to avoid extrapolations, the fits will only be valid from first
 274  //    measured point to last measured point. This is consistent with hardware,
 275  //    as there would be a new measured point if the value changed.
 276
 277  TTimeStamp startTime=fStartTime;
 278  TTimeStamp endTime=fEndTime;
 279
 280  Int_t nsensors = fSensors->GetEntries();
 281  for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 282    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 283    TString stringID = entry->GetStringID();
 284    TPair *pair = (TPair*)dcsMap->FindObject(stringID.Data());
 285    if ( pair ) {                            // only try to read values
 286                                             // if DCS object available
 287      valueSet = (TObjArray*)pair->Value();
 288      TGraph *graph = MakeGraph(valueSet);   // MakeGraph sets start/end time
 289                                             // per sensor
 290      values->Add(new TObjString(stringID.Data()),graph);
 291      entry->SetStartTime(fStartTime);
 292      entry->SetEndTime(fEndTime);
 293    }
 294  }
 295  // Reset global start/end time
 296  //    ..... yes, I know this won't get a prize for structured programming..:-)
 297
 298  fStartTime=startTime;
 299  fEndTime=endTime;
 300  return values;
 301 }
 302
 303 //_____________________________________________________________________________
 304 TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet){
 305   //
 306   // Make graph of temperature values read from DCS map
 307   //   (spline fit parameters will subsequently be obtained from this graph)
 308   //
 309   Int_t nentries = valueSet->GetEntriesFast();
 310   if ( nentries == 0 ) return 0;
 311
 312   Float_t *x = new Float_t[nentries];
 313   Float_t *y = new Float_t[nentries];
 314   Int_t time0=0;
 315   TTimeStamp firstTime(0);
 316   TTimeStamp lastTime(0);
 317   Int_t out=0;
 318   Int_t skipped=0;
 319   AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
 320   AliDCSValue::Type type = val->GetType();
 321   if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
 322   Float_t value;
 323   for (Int_t i=0; i<nentries; i++){
 324     val = (AliDCSValue *)valueSet->At(i);
 325     if (!val) continue;
 326     if (time0==0){
 327       time0=val->GetTimeStamp();
 328       firstTime= val->GetTimeStamp();
 329       lastTime=val->GetTimeStamp();
 330     }
 331     switch ( type )
 332     {
 333       case AliDCSValue::kFloat:
 334         value = val->GetFloat();
 335         break;
 336       case AliDCSValue::kChar:
 337         value = static_cast<Float_t>(val->GetChar());
 338         break;
 339       case AliDCSValue::kInt:
 340         value = static_cast<Float_t>(val->GetInt());
 341         break;
 342       case AliDCSValue::kUInt:
 343         value = static_cast<Float_t>(val->GetUInt());
 344         break;
 345       default:
 346         continue;
 347     }
 348     if (fValCut>0 && TMath::Abs(value)>fValCut) continue;   // refuse values greater than cut
 349     if (fDiffCut>0 ) {
 350       if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
 351         skipped++;                               // refuse values changing
 352         continue;                                // by > cut  in one time step
 353       }
 354       skipped=0;
 355     }
 356     if (val->GetTimeStamp()-time0>1000000) continue;
 357     lastTime=val->GetTimeStamp();
 358     x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours
 359     y[out] = val->GetFloat();
 360     out++;
 361   }
 362   fStartTime=firstTime;
 363   fEndTime=lastTime;
 364   TGraph * graph = new TGraph(out,x,y);
 365   delete [] x;
 366   delete [] y;
 367   return graph;
 368 }
 369
 370 //_____________________________________________________________________________
 371 AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS)
 372 {
 373  //
 374  //  Return sensor information for sensor specified by IdDCS
 375  //
 376  Int_t nsensors = fSensors->GetEntries();
 377  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 378    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 379    if (entry->GetIdDCS() == IdDCS) return entry;
 380  }
 381  return 0;
 382 }
 383 //_____________________________________________________________________________
 384 AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
 385 {
 386  //
 387  //  Return sensor information for sensor specified by IdDCS
 388  //
 389  Int_t nsensors = fSensors->GetEntries();
 390  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 391    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 392    if (entry->GetStringID() == stringID) return entry;
 393  }
 394  return 0;
 395 }
 396 //_____________________________________________________________________________
 397 AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
 398 {
 399  //
 400  //  Return sensor closest to given position
 401  //
 402  Int_t nsensors = fSensors->GetEntries();
 403  Double_t dist2min=1e99;
 404  Double_t xs,ys,zs,dist2;
 405  Int_t ind=-1;
 406  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 407    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 408    xs = entry->GetX();
 409    ys = entry->GetY();
 410    zs = entry->GetZ();
 411    dist2 = (x-xs)*(x-xs) + (y-ys)*(y-ys) + (z-zs)*(z-zs);
 412    if (dist2 < dist2min) {
 413       ind=isensor;
 414       dist2min = dist2;
 415    }
 416  }
 417  if ( ind >= 0 ) {
 418     return (AliDCSSensor*)fSensors->At(ind);
 419  } else {
 420     return 0;
 421  }
 422 }
 423 //_____________________________________________________________________________
 424 AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
 425 {
 426  //
 427  //  Return sensor given by array index
 428  //
 429  return (AliDCSSensor*)fSensors->At(ind);
 430 }
 431
 432 //_____________________________________________________________________________
 433 void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
 434 {
 435  //
 436  //  Return sensor given by array index
 437  //
 438
 439   delete fSensors->RemoveAt(ind);
 440   fSensors->Compress();
 441 }
 442 //_____________________________________________________________________________
 443 void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
 444 {
 445  //
 446  //  Deletes Sensor by given IdDCS
 447  //
 448
 449   Int_t nsensors = fSensors->GetEntries();
 450   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
 451     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 452     if (entry->GetIdDCS()==IdDCS) {
 453       delete fSensors->RemoveAt(isensor);
 454       break;
 455     }
 456   }
 457   fSensors->Compress();
 458 }
 459 //_____________________________________________________________________________
 460 TArrayI AliDCSSensorArray::OutsideThreshold(Double_t threshold, UInt_t timeSec, Bool_t below) const
 461 {
 462  //
 463  // Return sensors with values outside threshold at time defined by second
 464  // parameter
 465  // By default sensors with values below threshold are listed, if third
 466  // parameter is set to kFALSE sensors with values above threshold are listed
 467  //
 468   Int_t nsensors = fSensors->GetEntries();
 469   TArrayI array(nsensors);
 470   Int_t outside=0;
 471   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
 472     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 473     Double_t val=entry->GetValue(timeSec);
 474     if (below) {
 475       if (val<threshold) array[outside++] = entry->GetIdDCS();
 476     } else {
 477       if (val>threshold) array[outside++] = entry->GetIdDCS();
 478     }
 479   }
 480   array.Set(outside);
 481   return array;
 482 }
 483
 484 //_____________________________________________________________________________
 485 Int_t AliDCSSensorArray::GetFirstIdDCS() const
 486 {
 487  //
 488  //  Return DCS Id of first sensor
 489  //
 490  if ( fSensors != 0 ) {
 491     return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
 492  } else {
 493     return 0;
 494  }
 495 }
 496
 497 //_____________________________________________________________________________
 498 Int_t AliDCSSensorArray::GetLastIdDCS() const
 499 {
 500  //
 501  //  Return DCS Id of last sensor
 502  //
 503  if ( fSensors != 0 ) {
 504     Int_t last = fSensors->GetEntries();
 505     return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
 506  } else {
 507     return 0;
 508  }
 509 }
 510 //_____________________________________________________________________________
 511 void AliDCSSensorArray::ClearGraph()
 512 {
 513   //
 514   // Delete DCS graphs from all sensors in array
 515   //
 516
 517    Int_t nsensors = fSensors->GetEntries();
 518    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 519      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 520      TGraph *gr = sensor->GetGraph();
 521      if ( gr != 0 ) {
 522        delete gr;
 523        gr = 0;
 524      }
 525      sensor->SetGraph(0);
 526    }
 527 }
 528 //_____________________________________________________________________________
 529 void AliDCSSensorArray::ClearFit()
 530 {
 531   //
 532   // Delete spline fits from all sensors in array
 533   //
 534
 535    Int_t nsensors = fSensors->GetEntries();
 536    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 537      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 538      AliSplineFit *fit = sensor->GetFit();
 539      if ( fit != 0 ) {
 540        delete fit;
 541        fit = 0;
 542      }
 543      sensor->SetFit(0);
 544    }
 545 }