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(startTime);
 112   fEndTime   = TTimeStamp(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(startTime);
 137   fEndTime   = TTimeStamp(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 ) {
 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=fStartTime.GetSec();
 300   Int_t out=0;
 301   Int_t skipped=0;
 302   AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
 303   AliDCSValue::Type type = val->GetType();
 304   if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
 305   Float_t value;
 306   for (Int_t i=0; i<nentries; i++){
 307     val = (AliDCSValue *)valueSet->At(i);
 308     if (!val) continue;
 309     if (time0==0){
 310       time0=val->GetTimeStamp();
 311     }
 312     switch ( type )
 313     {
 314       case AliDCSValue::kFloat:
 315         value = val->GetFloat();
 316         break;
 317       case AliDCSValue::kChar:
 318         value = static_cast<Float_t>(val->GetChar());
 319         break;
 320       case AliDCSValue::kInt:
 321         value = static_cast<Float_t>(val->GetInt());
 322         break;
 323       case AliDCSValue::kUInt:
 324         value = static_cast<Float_t>(val->GetUInt());
 325         break;
 326       default:
 327         continue;
 328     }
 329     if (fValCut>0 && TMath::Abs(value)>fValCut) continue;   // refuse values greater than cut
 330     if (fDiffCut>0 ) {
 331       if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
 332         skipped++;                               // refuse values changing
 333         continue;                                // by > cut  in one time step
 334       }
 335       skipped=0;
 336     }
 337     if (val->GetTimeStamp()-time0>1000000) continue;
 338     x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours
 339     y[out] = val->GetFloat();
 340     out++;
 341
 342   }
 343   TGraph * graph = new TGraph(out,x,y);
 344   delete [] x;
 345   delete [] y;
 346   return graph;
 347 }
 348
 349 //_____________________________________________________________________________
 350 AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS)
 351 {
 352  //
 353  //  Return sensor information for sensor specified by IdDCS
 354  //
 355  Int_t nsensors = fSensors->GetEntries();
 356  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 357    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 358    if (entry->GetIdDCS() == IdDCS) return entry;
 359  }
 360  return 0;
 361 }
 362 //_____________________________________________________________________________
 363 AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
 364 {
 365  //
 366  //  Return sensor information for sensor specified by IdDCS
 367  //
 368  Int_t nsensors = fSensors->GetEntries();
 369  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 370    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 371    if (entry->GetStringID() == stringID) return entry;
 372  }
 373  return 0;
 374 }
 375 //_____________________________________________________________________________
 376 AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
 377 {
 378  //
 379  //  Return sensor closest to given position
 380  //
 381  Int_t nsensors = fSensors->GetEntries();
 382  Double_t dist2min=1e99;
 383  Double_t xs,ys,zs,dist2;
 384  Int_t ind=-1;
 385  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 386    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 387    xs = entry->GetX();
 388    ys = entry->GetY();
 389    zs = entry->GetZ();
 390    dist2 = (x-xs)*(x-xs) + (y-ys)*(y-ys) + (z-zs)*(z-zs);
 391    if (dist2 < dist2min) {
 392       ind=isensor;
 393       dist2min = dist2;
 394    }
 395  }
 396  if ( ind >= 0 ) {
 397     return (AliDCSSensor*)fSensors->At(ind);
 398  } else {
 399     return 0;
 400  }
 401 }
 402
 403 AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
 404 {
 405  //
 406  //  Return sensor given by array index
 407  //
 408  return (AliDCSSensor*)fSensors->At(ind);
 409 }
 410
 411 void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
 412 {
 413  //
 414  //  Return sensor given by array index
 415  //
 416
 417   delete fSensors->RemoveAt(ind);
 418   fSensors->Compress();
 419 }
 420 void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
 421 {
 422  //
 423  //  Deletes Sensor by given IdDCS
 424  //
 425
 426   Int_t nsensors = fSensors->GetEntries();
 427   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
 428     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 429     if (entry->GetIdDCS()==IdDCS) {
 430       delete fSensors->RemoveAt(isensor);
 431       break;
 432     }
 433   }
 434   fSensors->Compress();
 435 }
 436
 437 Int_t AliDCSSensorArray::GetFirstIdDCS() const
 438 {
 439  //
 440  //  Return DCS Id of first sensor
 441  //
 442  if ( fSensors != 0 ) {
 443     return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
 444  } else {
 445     return 0;
 446  }
 447 }
 448
 449 Int_t AliDCSSensorArray::GetLastIdDCS() const
 450 {
 451  //
 452  //  Return DCS Id of last sensor
 453  //
 454  if ( fSensors != 0 ) {
 455     Int_t last = fSensors->GetEntries();
 456     return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
 457  } else {
 458     return 0;
 459  }
 460 }
 461 void AliDCSSensorArray::ClearGraph()
 462 {
 463   //
 464   // Delete DCS graphs from all sensors in array
 465   //
 466
 467    Int_t nsensors = fSensors->GetEntries();
 468    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 469      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 470      TGraph *gr = sensor->GetGraph();
 471      if ( gr != 0 ) {
 472        delete gr;
 473        gr = 0;
 474      }
 475      sensor->SetGraph(0);
 476    }
 477 }
 478 void AliDCSSensorArray::ClearFit()
 479 {
 480   //
 481   // Delete spline fits from all sensors in array
 482   //
 483
 484    Int_t nsensors = fSensors->GetEntries();
 485    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 486      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 487      AliSplineFit *fit = sensor->GetFit();
 488      if ( fit != 0 ) {
 489        delete fit;
 490        fit = 0;
 491      }
 492      sensor->SetFit(0);
 493    }
 494 }