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