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