Make fit parameters configurable (Haavard).

diff --git a/STEER/AliDCSSensor.cxx b/STEER/AliDCSSensor.cxx
index f4d05acc8bcf36f27dcc78e1fc4f0a70531c0d9e..fe3c456550db87f00ec3755e0e81466a21ada597 100644 (file)
--- a/STEER/AliDCSSensor.cxx
+++ b/STEER/AliDCSSensor.cxx
@@ -93,12 +93,7 @@ Double_t AliDCSSensor::GetValue(UInt_t timeSec)
  // Get temperature value for actual sensor
  //  timeSec given as offset from start-of-run measured in seconds
  //
- Double_t timeHrs = timeSec/kSecInHour;
- if (fFit) {
-  return  fFit->Eval(timeHrs,0);
- } else { 
-  return kSmall;
- }
+ return Eval(TTimeStamp(timeSec));
 }
 //_____________________________________________________________________________
 Double_t AliDCSSensor::GetValue(TTimeStamp time) 
@@ -106,12 +101,7 @@ Double_t AliDCSSensor::GetValue(TTimeStamp time)
  // Get temperature value for actual sensor
  //  time given as absolute TTimeStamp
  //
- Double_t timeHrs = (time.GetSec() - fStartTime)/kSecInHour;
- if (fFit) {
-  return  fFit->Eval(timeHrs,0);
- } else { 
-  return kSmall;
- }
+ return Eval(time);
 }
 
 //_____________________________________________________________________________

diff --git a/STEER/AliDCSSensorArray.cxx b/STEER/AliDCSSensorArray.cxx
index 591aca09362af3b95cb2af0f8535956b112e8e2d..6336b95c7147a1868b05ee9ed50f3e9757075d6b 100644 (file)
--- a/STEER/AliDCSSensorArray.cxx
+++ b/STEER/AliDCSSensorArray.cxx
@@ -25,15 +25,17 @@
 
 ClassImp(AliDCSSensorArray)
 
-const Int_t  kMinGraph = 10;       // minimum #points of graph to be fitted
-const Int_t  kMinPoints = 10;      // minimum number of points per knot in fit
-const Int_t  kIter = 10;           // number of iterations for spline fit
-const Double_t  kMaxDelta = 0.00;  // precision parameter for spline fit
-const Int_t  kFitReq = 2;          // fit requirement, 2 = continuous 2nd derivative
 const Double_t kSecInHour = 3600.; // seconds in one hour
 
 //_____________________________________________________________________________
 AliDCSSensorArray::AliDCSSensorArray():TNamed(), 
+  fMinGraph(10),
+  fMinPoints(10),
+  fIter(10),
+  fMaxDelta(0.0),
+  fFitReq(2),
+  fValCut(9999999),
+  fDiffCut(9999999),
   fStartTime (2000,1,1,0,0,0),
   fEndTime   (2000,1,1,0,0,0),
   fSensors(0)
@@ -46,6 +48,13 @@ AliDCSSensorArray::AliDCSSensorArray():TNamed(),
 //_____________________________________________________________________________
 AliDCSSensorArray::AliDCSSensorArray(Int_t prevRun, const char* dbEntry) : 
   TNamed(),
+  fMinGraph(10),
+  fMinPoints(10),
+  fIter(10),
+  fMaxDelta(0.0),
+  fFitReq(2),
+  fValCut(9999999),
+  fDiffCut(9999999),
   fStartTime (2000,1,1,0,0,0),
   fEndTime   (2000,1,1,0,0,0),
   fSensors(0)
@@ -90,6 +99,13 @@ AliDCSSensorArray::AliDCSSensorArray(Int_t prevRun, const char* dbEntry) :
 
 //_____________________________________________________________________________
 AliDCSSensorArray::AliDCSSensorArray(const AliDCSSensorArray &c):TNamed(c),
+  fMinGraph(c.fMinGraph),
+  fMinPoints(c.fMinPoints),
+  fIter(c.fIter),
+  fMaxDelta(c.fMaxDelta),
+  fFitReq(c.fFitReq),
+  fValCut(c.fValCut),
+  fDiffCut(c.fDiffCut),
   fStartTime (c.fStartTime),
   fEndTime   (c.fEndTime),
   fSensors(0)
@@ -165,10 +181,10 @@ void AliDCSSensorArray::MakeSplineFit(TMap *map, const char *amandaString,
     Int_t dcsSensor=entry->GetIdDCS();
     sprintf(dname,amandaString,dcsSensor);
     TGraph *gr = (TGraph*)map->GetValue(dname);
-    if (gr->GetN() < kMinGraph ) continue;    
+    if (gr->GetN() < fMinGraph ) continue;    
     AliSplineFit *fit = new AliSplineFit();
-    fit->InitKnots(gr,kMinPoints,kIter,kMaxDelta);
-    fit->SplineFit(kFitReq);
+    fit->InitKnots(gr,fMinPoints,fIter,fMaxDelta);
+    fit->SplineFit(fFitReq);
     entry->SetStartTime(fStartTime);
     entry->SetEndTime(fEndTime);
     fit->Cleanup();
@@ -222,18 +238,37 @@ TGraph* AliDCSSensorArray::MakeGraph(TObjArray* valueSet){
   Int_t time0=0;
   Int_t out=0;
   Int_t skipped=0;
-  Float_t value;  
+  AliDCSValue *val = (AliDCSValue *)valueSet->At(0);
+  AliDCSValue::Type type = val->GetType();
+  if ( type == AliDCSValue::kInvalid || type == AliDCSValue::kBool ) return 0;
+  Float_t value;
   for (Int_t i=0; i<nentries; i++){
-    AliDCSValue * val = (AliDCSValue *)valueSet->At(i);
+    val = (AliDCSValue *)valueSet->At(i);
     if (!val) continue;
     if (time0==0){
       time0=val->GetTimeStamp();
     }
-    value = val->GetFloat();
-    if (TMath::Abs(value)>100) continue;   // refuse values exceeding 100
-    if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>5) {
-      skipped++;                               // refuse temperatures changing 
-      continue;                                // by > 5 degrees in one time step
+    switch ( type )
+    { 
+      case AliDCSValue::kFloat:
+        value = val->GetFloat();
+        break;
+      case AliDCSValue::kChar:
+        value = val->GetChar();
+       break;
+      case AliDCSValue::kInt:
+        value = val->GetInt();
+       break;
+      case AliDCSValue::kUInt:
+        value = val->GetUInt();
+       break;
+      default:
+        continue;
+    }
+    if (TMath::Abs(value)>fValCut) continue;   // refuse values greater than cut
+    if ( out>0 && skipped<10 && TMath::Abs(value-y[out-1])>fDiffCut) {
+      skipped++;                               // refuse values changing 
+      continue;                                // by > cut  in one time step
     }                                          
     skipped=0;                                       
     if (val->GetTimeStamp()-time0>1000000) continue;

diff --git a/STEER/AliDCSSensorArray.h b/STEER/AliDCSSensorArray.h
index 75302fe02f90ec35d4554bf7659c8f55865827cf..780b9be92062092ea2264b42b7bf46d5fe945364 100644 (file)
--- a/STEER/AliDCSSensorArray.h
+++ b/STEER/AliDCSSensorArray.h
@@ -34,6 +34,21 @@ class AliDCSSensorArray : public TNamed {
   void SetEndTime   (const TTimeStamp& end) { fEndTime = end; }
   TTimeStamp GetStartTime () const { return fStartTime; } 
   TTimeStamp GetEndTime () const { return fEndTime; } 
+  void  SetMinGraph(const Int_t minGraph) { fMinGraph=minGraph;}
+  Int_t GetMinGraph()  const { return fMinGraph; }
+  void  SetMinPoints(const Int_t minPoints) { fMinPoints=minPoints;}
+  Int_t GetMinPoints() const { return fMinPoints; }
+  void  SetIter(const Int_t iter ) { fIter=iter; } 
+  Int_t GetIter() const { return fIter; }             
+  void  SetMaxDelta(const Double_t maxDelta) { fMaxDelta= maxDelta;}
+  Double_t GetMaxDelta() const { return fMaxDelta; }   
+  void  SetFitReq(const Int_t fitReq) { fFitReq=fitReq; }
+  Int_t GetFitReq() const {return fFitReq;}
+  void  SetValCut(const Int_t valCut) { fValCut=valCut;}
+  Int_t GetValCut() const {return fValCut;} 
+  void  SetDiffCut(const Int_t diffCut) { fDiffCut=diffCut; }
+  Int_t GetDiffCut() const {return fDiffCut;}
+
   void SetGraph     (TMap *map, const char* amandaString);
   void MakeSplineFit(TMap *map, const char* amandaString, Bool_t keepMap=kFALSE);
   TMap* ExtractDCS  (TMap *dcsMap, const char* amandaString);
@@ -48,11 +63,18 @@ class AliDCSSensorArray : public TNamed {
   Int_t GetLastIdDCS()  const; 
 
  protected:
-  TTimeStamp  fStartTime;         // start time for measurements in this entry
-  TTimeStamp  fEndTime;           // end time for measurements in this entry
-  TClonesArray *fSensors;         // Array of sensors
+  Int_t  fMinGraph;              // minimum #points of graph to be fitted
+  Int_t  fMinPoints;             // minimum number of points per knot in fit
+  Int_t  fIter;                  // number of iterations for spline fit
+  Double_t  fMaxDelta;           // precision parameter for spline fit
+  Int_t  fFitReq;                // fit requirement, 2 = continuous 2nd derivative
+  Int_t  fValCut;                // cut on absolute value read from DCS map
+  Int_t  fDiffCut;               // cut on difference in value read from DCS map
+  TTimeStamp  fStartTime;        // start time for measurements in this entry
+  TTimeStamp  fEndTime;          // end time for measurements in this entry
+  TClonesArray *fSensors;        // Array of sensors
 
-  ClassDef(AliDCSSensorArray,2)       //  TPC calibration class for parameters which are saved per pad
+  ClassDef(AliDCSSensorArray,3)       //  TPC calibration class for parameters which are saved per pad
 
 };