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 //_____________________________________________________________________________
 118 AliDCSSensorArray::AliDCSSensorArray(const AliDCSSensorArray &c):TNamed(c),
 119   fMinGraph(c.fMinGraph),
 120   fMinPoints(c.fMinPoints),
 121   fIter(c.fIter),
 122   fMaxDelta(c.fMaxDelta),
 123   fFitReq(c.fFitReq),
 124   fValCut(c.fValCut),
 125   fDiffCut(c.fDiffCut),
 126   fStartTime (c.fStartTime),
 127   fEndTime   (c.fEndTime),
 128   fSensors(0)
 129
 130 {
 131   //
 132   // AliDCSSensorArray copy constructor
 133   //
 134
 135   fSensors = (TClonesArray*)c.fSensors->Clone();
 136 }
 137
 138 ///_____________________________________________________________________________
 139 AliDCSSensorArray::~AliDCSSensorArray()
 140 {
 141   //
 142   // AliDCSSensorArray destructor
 143   //
 144   fSensors->Delete();
 145   delete fSensors;
 146
 147 }
 148
 149 //_____________________________________________________________________________
 150 AliDCSSensorArray &AliDCSSensorArray::operator=(const AliDCSSensorArray &c)
 151 {
 152   //
 153   // Assignment operator
 154   //
 155   if (this != &c) {
 156      fSensors->Delete();
 157      new (this) AliDCSSensorArray(c);
 158      fSensors = (TClonesArray*)c.fSensors->Clone();
 159   }
 160   return *this;
 161 }
 162
 163 //____________________________________________________________________________
 164
 165 void AliDCSSensorArray::SetGraph(TMap *map)
 166 {
 167   //
 168   // Read graphs from DCS maps
 169   //
 170   Int_t nsensors = fSensors->GetEntries();
 171   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 172     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 173     TString stringID = entry->GetStringID();
 174     TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
 175     if ( gr !=0 ) {
 176        entry->SetGraph((TGraph*)gr->Clone());
 177     } else {
 178        entry->SetGraph(0);
 179     }
 180   }
 181 }
 182 //_____________________________________________________________________________
 183 void AliDCSSensorArray::MakeSplineFit(TMap *map, Bool_t keepMap)
 184 {
 185   //
 186   // Make spline fits from DCS maps
 187   //
 188   Int_t nsensors = fSensors->GetEntries();
 189   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 190     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 191     TString stringID = entry->GetStringID();
 192     TGraph *gr = (TGraph*)map->GetValue(stringID.Data());
 193     if (!gr ) {
 194       entry->SetFit(0);
 195       entry->SetGraph(0);
 196       AliWarning(Form("sensor %s: no input graph",stringID.Data()));
 197       continue;
 198     }
 199     AliSplineFit *fit = new AliSplineFit();
 200     fit->SetMinPoints(fMinGraph);
 201     fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
 202     fit->SplineFit(fFitReq);
 203     entry->SetStartTime(fStartTime);
 204     entry->SetEndTime(fEndTime);
 205     fit->Cleanup();
 206     if (fit) {
 207       entry->SetFit(fit);
 208     } else {
 209       AliWarning(Form("sensor %s: no fit performed, DCS graph kept.",stringID.Data()));
 210       entry->SetGraph(gr);
 211     }
 212     if (keepMap) entry->SetGraph(gr);
 213   }
 214 }
 215
 216 //_____________________________________________________________________________
 217 Int_t AliDCSSensorArray::NumFits() const
 218 {
 219  //
 220  // Return number of sensors where a succesful fit has been made
 221  //
 222   Int_t nfit=0;
 223   Int_t nsensors = fSensors->GetEntries();
 224   for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 225     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 226     if (entry->GetFit()) nfit++;
 227   }
 228   return nfit;
 229 }
 230 //_____________________________________________________________________________
 231 Double_t AliDCSSensorArray::GetValue(UInt_t timeSec, Int_t sensor)
 232 {
 233   //
 234   // Return sensor value at time timeSec (obtained from fitted function)
 235   //  timeSec = time in seconds from start of run
 236   //
 237   AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(sensor);
 238   return entry->GetValue(timeSec);
 239 }
 240
 241
 242 //_____________________________________________________________________________
 243 TMap* AliDCSSensorArray::ExtractDCS(TMap *dcsMap)
 244 {
 245  //
 246  // Extract temperature graphs from DCS maps
 247  //
 248  TMap *values = new TMap;
 249  TObjArray * valueSet;
 250  Int_t nsensors = fSensors->GetEntries();
 251  for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 252    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 253    TString stringID = entry->GetStringID();
 254    TPair *pair = (TPair*)dcsMap->FindObject(stringID.Data());
 255    if ( pair ) {                            // only try to read values
 256                                             // if DCS object available
 257      valueSet = (TObjArray*)pair->Value();
 258      TGraph *graph = MakeGraph(valueSet);
 259      values->Add(new TObjString(stringID.Data()),graph);
 260    }
 261  }
 262  return values;
 263 }
 264
 265 //_____________________________________________________________________________
 266 TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet){
 267   //
 268   // Make graph of temperature values read from DCS map
 269   //   (spline fit parameters will subsequently be obtained from this graph)
 270   //
 271   Int_t nentries = valueSet->GetEntriesFast();
 272   if ( nentries == 0 ) return 0;
 273
 274   Float_t *x = new Float_t[nentries];
 275   Float_t *y = new Float_t[nentries];
 276   Int_t time0=fStartTime.GetSec();
 277   Int_t out=0;
 278   Int_t skipped=0;
 279   AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
 280   AliDCSValue::Type type = val->GetType();
 281   if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
 282   Float_t value;
 283   for (Int_t i=0; i<nentries; i++){
 284     val = (AliDCSValue *)valueSet->At(i);
 285     if (!val) continue;
 286     if (time0==0){
 287       time0=val->GetTimeStamp();
 288     }
 289     switch ( type )
 290     {
 291       case AliDCSValue::kFloat:
 292         value = val->GetFloat();
 293         break;
 294       case AliDCSValue::kChar:
 295         value = static_cast<Float_t>(val->GetChar());
 296         break;
 297       case AliDCSValue::kInt:
 298         value = static_cast<Float_t>(val->GetInt());
 299         break;
 300       case AliDCSValue::kUInt:
 301         value = static_cast<Float_t>(val->GetUInt());
 302         break;
 303       default:
 304         continue;
 305     }
 306     if (fValCut>0 && TMath::Abs(value)>fValCut) continue;   // refuse values greater than cut
 307     if (fDiffCut>0 ) {
 308       if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
 309         skipped++;                               // refuse values changing
 310         continue;                                // by > cut  in one time step
 311       }
 312       skipped=0;
 313     }
 314     if (val->GetTimeStamp()-time0>1000000) continue;
 315     x[out] = (val->GetTimeStamp()-time0)/kSecInHour; // give times in fractions of hours
 316     y[out] = val->GetFloat();
 317     out++;
 318
 319   }
 320   TGraph * graph = new TGraph(out,x,y);
 321   delete [] x;
 322   delete [] y;
 323   return graph;
 324 }
 325
 326 //_____________________________________________________________________________
 327 AliDCSSensor* AliDCSSensorArray::GetSensor(Int_t IdDCS)
 328 {
 329  //
 330  //  Return sensor information for sensor specified by IdDCS
 331  //
 332  Int_t nsensors = fSensors->GetEntries();
 333  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 334    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 335    if (entry->GetIdDCS() == IdDCS) return entry;
 336  }
 337  return 0;
 338 }
 339 //_____________________________________________________________________________
 340 AliDCSSensor* AliDCSSensorArray::GetSensor(const TString& stringID)
 341 {
 342  //
 343  //  Return sensor information for sensor specified by IdDCS
 344  //
 345  Int_t nsensors = fSensors->GetEntries();
 346  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 347    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 348    if (entry->GetStringID() == stringID) return entry;
 349  }
 350  return 0;
 351 }
 352 //_____________________________________________________________________________
 353 AliDCSSensor* AliDCSSensorArray::GetSensor(Double_t x, Double_t y, Double_t z)
 354 {
 355  //
 356  //  Return sensor closest to given position
 357  //
 358  Int_t nsensors = fSensors->GetEntries();
 359  Double_t dist2min=1e99;
 360  Double_t xs,ys,zs,dist2;
 361  Int_t ind=-1;
 362  for (Int_t isensor=0; isensor<nsensors; isensor++) {
 363    AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 364    xs = entry->GetX();
 365    ys = entry->GetY();
 366    zs = entry->GetZ();
 367    dist2 = (x-xs)*(x-xs) + (y-ys)*(y-ys) + (z-zs)*(z-zs);
 368    if (dist2 < dist2min) {
 369       ind=isensor;
 370       dist2min = dist2;
 371    }
 372  }
 373  if ( ind >= 0 ) {
 374     return (AliDCSSensor*)fSensors->At(ind);
 375  } else {
 376     return 0;
 377  }
 378 }
 379
 380 AliDCSSensor* AliDCSSensorArray::GetSensorNum(Int_t ind)
 381 {
 382  //
 383  //  Return sensor given by array index
 384  //
 385  return (AliDCSSensor*)fSensors->At(ind);
 386 }
 387
 388 void AliDCSSensorArray::RemoveSensorNum(Int_t ind)
 389 {
 390  //
 391  //  Return sensor given by array index
 392  //
 393
 394   delete fSensors->RemoveAt(ind);
 395   fSensors->Compress();
 396 }
 397 void AliDCSSensorArray::RemoveSensor(Int_t IdDCS)
 398 {
 399  //
 400  //  Deletes Sensor by given IdDCS
 401  //
 402
 403   Int_t nsensors = fSensors->GetEntries();
 404   for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over sensors
 405     AliDCSSensor *entry = (AliDCSSensor*)fSensors->At(isensor);
 406     if (entry->GetIdDCS()==IdDCS) {
 407       delete fSensors->RemoveAt(isensor);
 408       break;
 409     }
 410   }
 411   fSensors->Compress();
 412 }
 413
 414 Int_t AliDCSSensorArray::GetFirstIdDCS() const
 415 {
 416  //
 417  //  Return DCS Id of first sensor
 418  //
 419  if ( fSensors != 0 ) {
 420     return ((AliDCSSensor*)fSensors->At(0))->GetIdDCS();
 421  } else {
 422     return 0;
 423  }
 424 }
 425
 426 Int_t AliDCSSensorArray::GetLastIdDCS() const
 427 {
 428  //
 429  //  Return DCS Id of last sensor
 430  //
 431  if ( fSensors != 0 ) {
 432     Int_t last = fSensors->GetEntries();
 433     return ((AliDCSSensor*)fSensors->At(last-1))->GetIdDCS();
 434  } else {
 435     return 0;
 436  }
 437 }
 438 void AliDCSSensorArray::ClearGraph()
 439 {
 440   //
 441   // Delete DCS graphs from all sensors in array
 442   //
 443
 444    Int_t nsensors = fSensors->GetEntries();
 445    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 446      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 447      TGraph *gr = sensor->GetGraph();
 448      if ( gr != 0 ) {
 449        delete gr;
 450        gr = 0;
 451      }
 452      sensor->SetGraph(0);
 453    }
 454 }
 455 void AliDCSSensorArray::ClearFit()
 456 {
 457   //
 458   // Delete spline fits from all sensors in array
 459   //
 460
 461    Int_t nsensors = fSensors->GetEntries();
 462    for ( Int_t isensor=0; isensor<nsensors; isensor++) {
 463      AliDCSSensor *sensor = (AliDCSSensor*)fSensors->At(isensor);
 464      AliSplineFit *fit = sensor->GetFit();
 465      if ( fit != 0 ) {
 466        delete fit;
 467        fit = 0;
 468      }
 469      sensor->SetFit(0);
 470    }
 471 }