Corrected protection.
[u/mrichter/AliRoot.git] / STEER / AliDCSSensor.cxx
index 47c3e07..aed5f6d 100644 (file)
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                                                            //
-// Class describing TPC temperature sensors (including pointers to graphs/fits//
+// Class describing time dependent values read from DCS sensors               //  
+// (including pointers to graphs/fits)                                        //
 // Authors: Marian Ivanov, Haavard Helstrup and Martin Siska                  //
 //                                                                            //
 ////////////////////////////////////////////////////////////////////////////////
 
 
 #include "AliDCSSensor.h"
+#include "TDatime.h"
 ClassImp(AliDCSSensor)
 
 const Double_t kSecInHour = 3600.; // seconds in one hour
@@ -53,15 +55,18 @@ AliDCSSensor::AliDCSSensor(const AliDCSSensor& source) :
    fStringID(source.fStringID),
    fStartTime(source.fStartTime),
    fEndTime(source.fEndTime),
-   fGraph(source.fGraph),
-   fFit(source.fFit),
+   fGraph(0),
+   fFit(0),
    fX(source.fX),
    fY(source.fY),
    fZ(source.fZ)
 //
 //  Copy constructor
 //
-{ }
+{ 
+   if (source.fGraph) fGraph = (TGraph*)source.fGraph->Clone();
+   if (source.fFit) fFit = (AliSplineFit*)source.fFit->Clone();
+}
 
 AliDCSSensor& AliDCSSensor::operator=(const AliDCSSensor& source){
 //
@@ -77,28 +82,37 @@ AliDCSSensor& AliDCSSensor::operator=(const AliDCSSensor& source){
 Double_t AliDCSSensor::GetValue(UInt_t timeSec)
 {
  //
- // Get temperature value for actual sensor
- //  timeSec given as offset from start-of-run measured in seconds
+ // Get DCS value for actual sensor
+ //  timeSec given as offset from start-of-map measured in seconds
+ //  *NOTE* In the current TPC setup, start-of-map is defined as the 
+ //         first measured point for each sensor. This will be different
+ //         for each sensor in the array. If you want to get a value at the 
+ //         same absolute time, use AliDCSSensor::GetValue(TTimeStamp time)
+ //         or AliDCSSensorArray::GetValue (UInt_t timeSec, Int_t sensor)
+ //         which measure offsets with respect to the (global) start-of-run
  //
- Bool_t inside;
- return Eval(TTimeStamp((time_t)(fStartTime+timeSec)),inside);
+ Bool_t inside=kTRUE;
+ return Eval(TTimeStamp((time_t)(fStartTime+timeSec),0),inside);
 }
 //_____________________________________________________________________________
 Double_t AliDCSSensor::GetValue(TTimeStamp time) 
 {
- // Get temperature value for actual sensor
+ // Get DCS value for actual sensor
  //  time given as absolute TTimeStamp
  //
- Bool_t inside;
+ Bool_t inside=kTRUE;
  return Eval(time, inside);
 }
 
 //_____________________________________________________________________________
 
-Double_t AliDCSSensor::Eval(const TTimeStamp& time, Bool_t inside) const
+Double_t AliDCSSensor::Eval(const TTimeStamp& time, Bool_t& inside) const
 {
   // 
-  // Return temperature at given time
+  // Return DCS value at given time
+  //  The value is calculated from the AliSplineFit, if a fit is not available 
+  //    the most recent reading from the Graph of DCS points is returned (if 
+  //    the graph is present)
   //  If time < start of map  return value at start of map, inside = false
   //  If time > end of map    return value at end of map, inside = false
   
@@ -119,25 +133,101 @@ Double_t AliDCSSensor::Eval(const TTimeStamp& time, Bool_t inside) const
   if ( fFit ) {
      return fFit->Eval(timeHour); 
   } else {
-     return -99;
+     if ( fGraph ) {
+       return EvalGraph(timeHour);
+     } else {  
+       return -99;
+     }
+  }
+}
+//_____________________________________________________________________________
+
+Double_t AliDCSSensor::EvalGraph(const TTimeStamp& time, Bool_t& inside) const
+{
+  // 
+  // Return DCS value from graph of DCS points (i.e return last reading before
+  //  the time specified by TTimeStamp
+  //  If time < start of map  return value at start of map, inside = false
+  //  If time > end of map    return value at end of map, inside = false
+  
+  UInt_t timeSec = time.GetSec();
+  UInt_t diff = timeSec-fStartTime;
+  inside = true;
+  
+  if ( timeSec < fStartTime ) { 
+     inside=false;
+     diff=0;
+  }
+  if ( timeSec > fEndTime ) {
+     inside=false;
+     diff = fEndTime-fStartTime;
   }
+  Double_t timeHour = diff/kSecInHour;
+  if ( fGraph ) {
+     return EvalGraph(timeHour);
+  } else {  
+     return -99;
+  }  
 }
+//_____________________________________________________________________________
+Double_t AliDCSSensor::EvalGraph(const Double_t& timeHour) const 
+{
+  //
+  // Extract last value in graph observed before time given by timeHour
+  //
 
-TGraph* AliDCSSensor::MakeGraph(Int_t nPoints) const
+  // return -99 if point specified is before beginning of graph
+  Double_t x=0; Double_t y=0;
+  fGraph->GetPoint(0,x,y);
+  if ( timeHour < x ) return -99;
+  
+  // return previous point when first time > timeHour is observed
+  
+  Int_t npoints = fGraph->GetN();
+  for (Int_t i=1; i<npoints; i++) {
+     fGraph->GetPoint(i,x,y);
+     if ( timeHour < x ) {
+       fGraph->GetPoint(i-1,x,y);
+       return y;
+     }
+  }
+  
+  // return last point if all times are < timeHour
+  return y;
+} 
+       
+
+//_____________________________________________________________________________
+TGraph* AliDCSSensor::MakeGraph(Int_t nPoints, Bool_t debug) const
 {
   //
   // Make graph from start time to end time of DCS values 
   //
 
+
   UInt_t stepTime = (fEndTime-fStartTime)/nPoints;
   
+  if (debug==kTRUE) {
+     printf ("Start time %d, End time %d, step time %d\n",
+     fStartTime,fEndTime,stepTime);
+     TTimeStamp t((time_t)fStartTime,0); t.Print();
+     TTimeStamp t2((time_t)fEndTime,0); t2.Print();
+  }     
+  
   if ( !fFit ) return 0;
 
   Double_t *x = new Double_t[nPoints+1];
   Double_t *y = new Double_t[nPoints+1];
   for (Int_t ip=0; ip<nPoints; ip++) {
-    x[ip] = fStartTime+ip*stepTime;
+    x[ip] = (time_t)(fStartTime+ip*stepTime);
     y[ip] = fFit->Eval(ip*stepTime/kSecInHour);
+    if (debug==kTRUE) {
+     TTimeStamp t3((time_t)x[ip],0); 
+     printf ("x=%f, y=%f  ",x[ip],y[ip]);
+     t3.Print();
+    }
   }
   
   TGraph *graph = new TGraph(nPoints,x,y);