STEER/AliDCSSensor.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2006-07, 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 // Class describing time dependent values read from DCS sensors               //
  20 // (including pointers to graphs/fits)                                        //
  21 // Authors: Marian Ivanov, Haavard Helstrup and Martin Siska                  //
  22 //                                                                            //
  23 ////////////////////////////////////////////////////////////////////////////////
  24
  25
  26 #include "AliDCSSensor.h"
  27 #include "TDatime.h"
  28 ClassImp(AliDCSSensor)
  29
  30 const Double_t kSecInHour = 3600.; // seconds in one hour
  31
  32
  33
  34 AliDCSSensor::AliDCSSensor():
  35   fId(),
  36   fIdDCS(0),
  37   fStringID(),
  38   fStartTime(0),
  39   fEndTime(0),
  40   fGraph(0),
  41   fFit(0),
  42   fX(0),
  43   fY(0),
  44   fZ(0)
  45 {
  46   //
  47   //  Standard constructor
  48   //
  49 }
  50
  51 AliDCSSensor::AliDCSSensor(const AliDCSSensor& source) :
  52    TNamed(source),
  53    fId(source.fId),
  54    fIdDCS(source.fIdDCS),
  55    fStringID(source.fStringID),
  56    fStartTime(source.fStartTime),
  57    fEndTime(source.fEndTime),
  58    fGraph(0),
  59    fFit(0),
  60    fX(source.fX),
  61    fY(source.fY),
  62    fZ(source.fZ)
  63 //
  64 //  Copy constructor
  65 //
  66 {
  67    if (source.fGraph) fGraph = (TGraph*)source.fGraph->Clone();
  68    if (source.fFit) fFit = (AliSplineFit*)source.fFit->Clone();
  69 }
  70
  71 AliDCSSensor& AliDCSSensor::operator=(const AliDCSSensor& source){
  72 //
  73 // assignment operator
  74 //
  75   if (&source == this) return *this;
  76   new (this) AliDCSSensor(source);
  77
  78   return *this;
  79 }
  80
  81 //_____________________________________________________________________________
  82 Double_t AliDCSSensor::GetValue(UInt_t timeSec)
  83 {
  84  //
  85  // Get DCS value for actual sensor
  86  //  timeSec given as offset from start-of-map measured in seconds
  87  //  *NOTE* In the current TPC setup, start-of-map is defined as the
  88  //         first measured point for each sensor. This will be different
  89  //         for each sensor in the array. If you want to get a value at the
  90  //         same absolute time, use AliDCSSensor::GetValue(TTimeStamp time)
  91  //         or AliDCSSensorArray::GetValue (UInt_t timeSec, Int_t sensor)
  92  //         which measure offsets with respect to the (global) start-of-run
  93  //
  94  Bool_t inside=kTRUE;
  95  return Eval(TTimeStamp((time_t)(fStartTime+timeSec),0),inside);
  96 }
  97 //_____________________________________________________________________________
  98 Double_t AliDCSSensor::GetValue(TTimeStamp time)
  99 {
 100  // Get DCS value for actual sensor
 101  //  time given as absolute TTimeStamp
 102  //
 103  Bool_t inside=kTRUE;
 104  return Eval(time, inside);
 105 }
 106
 107 //_____________________________________________________________________________
 108
 109 Double_t AliDCSSensor::Eval(const TTimeStamp& time, Bool_t& inside) const
 110 {
 111   //
 112   // Return DCS value at given time
 113   //  The value is calculated from the AliSplineFit, if a fit is not available
 114   //    the most recent reading from the Graph of DCS points is returned (if
 115   //    the graph is present)
 116   //  If time < start of map  return value at start of map, inside = false
 117   //  If time > end of map    return value at end of map, inside = false
 118
 119   UInt_t timeSec = time.GetSec();
 120   UInt_t diff = timeSec-fStartTime;
 121   inside = true;
 122
 123   if ( timeSec < fStartTime ) {
 124      inside=false;
 125      diff=0;
 126   }
 127   if ( timeSec > fEndTime ) {
 128      inside=false;
 129      diff = fEndTime-fStartTime;
 130   }
 131
 132   Double_t timeHour = diff/kSecInHour;
 133   if ( fFit ) {
 134      return fFit->Eval(timeHour);
 135   } else {
 136      if ( fGraph ) {
 137        return EvalGraph(timeHour);
 138      } else {
 139        return -99;
 140      }
 141   }
 142 }
 143 //_____________________________________________________________________________
 144
 145 Double_t AliDCSSensor::EvalGraph(const TTimeStamp& time, Bool_t& inside) const
 146 {
 147   //
 148   // Return DCS value from graph of DCS points (i.e return last reading before
 149   //  the time specified by TTimeStamp
 150   //  If time < start of map  return value at start of map, inside = false
 151   //  If time > end of map    return value at end of map, inside = false
 152
 153   UInt_t timeSec = time.GetSec();
 154   UInt_t diff = timeSec-fStartTime;
 155   inside = true;
 156
 157   if ( timeSec < fStartTime ) {
 158      inside=false;
 159      diff=0;
 160   }
 161   if ( timeSec > fEndTime ) {
 162      inside=false;
 163      diff = fEndTime-fStartTime;
 164   }
 165
 166   Double_t timeHour = diff/kSecInHour;
 167   if ( fGraph ) {
 168      return EvalGraph(timeHour);
 169   } else {
 170      return -99;
 171   }
 172 }
 173 //_____________________________________________________________________________
 174 Double_t AliDCSSensor::EvalGraph(const Double_t& timeHour) const
 175 {
 176   //
 177   // Extract last value in graph observed before time given by timeHour
 178   //
 179
 180   // return -99 if point specified is before beginning of graph
 181   Double_t x=0; Double_t y=0;
 182   fGraph->GetPoint(0,x,y);
 183   if ( timeHour < x ) return -99;
 184
 185   // return previous point when first time > timeHour is observed
 186
 187   Int_t npoints = fGraph->GetN();
 188   for (Int_t i=1; i<npoints; i++) {
 189      fGraph->GetPoint(i,x,y);
 190      if ( timeHour < x ) {
 191        fGraph->GetPoint(i-1,x,y);
 192        return y;
 193      }
 194   }
 195
 196   // return last point if all times are < timeHour
 197   return y;
 198 }
 199
 200
 201 //_____________________________________________________________________________
 202 TGraph* AliDCSSensor::MakeGraph(Int_t nPoints, Bool_t debug) const
 203 {
 204   //
 205   // Make graph from start time to end time of DCS values
 206   //
 207
 208
 209
 210   UInt_t stepTime = (fEndTime-fStartTime)/nPoints;
 211
 212   if (debug==kTRUE) {
 213      printf ("Start time %d, End time %d, step time %d\n",
 214      fStartTime,fEndTime,stepTime);
 215      TTimeStamp t((time_t)fStartTime,0); t.Print();
 216      TTimeStamp t2((time_t)fEndTime,0); t2.Print();
 217   }
 218
 219   if ( !fFit ) return 0;
 220
 221   Double_t *x = new Double_t[nPoints+1];
 222   Double_t *y = new Double_t[nPoints+1];
 223   for (Int_t ip=0; ip<nPoints; ip++) {
 224     x[ip] = (time_t)(fStartTime+ip*stepTime);
 225     y[ip] = fFit->Eval(ip*stepTime/kSecInHour);
 226     if (debug==kTRUE) {
 227      TTimeStamp t3((time_t)x[ip],0);
 228      printf ("x=%f, y=%f  ",x[ip],y[ip]);
 229      t3.Print();
 230     }
 231   }
 232
 233   TGraph *graph = new TGraph(nPoints,x,y);
 234   delete [] x;
 235   delete [] y;
 236
 237   graph->GetXaxis()->SetTimeDisplay(1);
 238   graph->GetXaxis()->SetLabelOffset(0.02);
 239   graph->GetXaxis()->SetTimeFormat("#splitline{%d/%m}{%H:%M}");
 240
 241   return graph;
 242 }
 243
 244 //_____________________________________________________________________________
 245
 246 TClonesArray * AliDCSSensor::ReadTree(TTree* tree) {
 247   //
 248   // read values from ascii file
 249   //
 250
 251   Int_t nentries = tree->GetEntries();
 252
 253   char stringId[100];
 254   Int_t num=0;
 255   Int_t idDCS=0;
 256   Double_t x=0;
 257   Double_t y=0;
 258   Double_t z=0;
 259
 260   tree->SetBranchAddress("StringID",&stringId);
 261   tree->SetBranchAddress("IdDCS",&idDCS);
 262   tree->SetBranchAddress("Num",&num);
 263   tree->SetBranchAddress("X",&x);
 264   tree->SetBranchAddress("Y",&y);
 265   tree->SetBranchAddress("Z",&z);
 266
 267   // firstSensor = (Int_t)tree->GetMinimum("ECha");
 268   // lastSensor = (Int_t)tree->GetMaximum("ECha");
 269
 270   TClonesArray * array = new TClonesArray("AliDCSSensor",nentries);
 271    printf ("nentries = %d\n",nentries);
 272
 273   for (Int_t isensor=0; isensor<nentries; isensor++){
 274     AliDCSSensor * sens = new ((*array)[isensor])AliDCSSensor;
 275     tree->GetEntry(isensor);
 276     sens->SetId(isensor);
 277     sens->SetIdDCS(idDCS);
 278     sens->SetStringID(TString(stringId));
 279     sens->SetX(x);
 280     sens->SetY(y);
 281     sens->SetZ(z);
 282
 283   }
 284   return array;
 285 }
 286