added run-number structure
authorrpreghen <rpreghen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 14 Feb 2011 16:08:08 +0000 (16:08 +0000)
committerrpreghen <rpreghen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 14 Feb 2011 16:08:08 +0000 (16:08 +0000)
TOF/AliTOFRunParams.cxx
TOF/AliTOFRunParams.h

index 1c8c1c5..15a6a70 100644 (file)
@@ -25,6 +25,7 @@
 // *
 
 #include "AliTOFRunParams.h"
+#include "TGraph.h"
 
 ClassImp(AliTOFRunParams)
 
@@ -36,7 +37,11 @@ AliTOFRunParams::AliTOFRunParams() :
   fTimestamp(NULL),
   fT0(NULL),
   fTOFResolution(NULL),
-  fT0Spread(NULL)
+  fT0Spread(NULL),
+  fNRuns(0),
+  fRunNb(NULL),
+  fRunFirstPoint(NULL),
+  fRunLastPoint(NULL)
 {
   /*
    * default constructor
@@ -45,13 +50,17 @@ AliTOFRunParams::AliTOFRunParams() :
 
 //_________________________________________________________
 
-AliTOFRunParams::AliTOFRunParams(Int_t nPoints) :
+AliTOFRunParams::AliTOFRunParams(Int_t nPoints, Int_t nRuns) :
   TObject(),
   fNPoints(nPoints),
   fTimestamp(new UInt_t[nPoints]),
   fT0(new Float_t[nPoints]),
   fTOFResolution(new Float_t[nPoints]),
-  fT0Spread(new Float_t[nPoints])
+  fT0Spread(new Float_t[nPoints]),
+  fNRuns(nRuns),
+  fRunNb(new UInt_t[nRuns]),
+  fRunFirstPoint(new UInt_t[nRuns]),
+  fRunLastPoint(new UInt_t[nRuns])
 {
   /*
    * standard constructor
@@ -70,6 +79,9 @@ AliTOFRunParams::~AliTOFRunParams()
   if (fT0) delete [] fT0;
   if (fTOFResolution) delete [] fTOFResolution;
   if (fT0Spread) delete [] fT0Spread;
+  if (fRunNb) delete [] fRunNb;
+  if (fRunFirstPoint) delete [] fRunFirstPoint;
+  if (fRunLastPoint) delete [] fRunLastPoint;
 }
 
 //_________________________________________________________
@@ -80,7 +92,11 @@ AliTOFRunParams::AliTOFRunParams(const AliTOFRunParams &source) :
   fTimestamp(new UInt_t[source.fNPoints]),
   fT0(new Float_t[source.fNPoints]),
   fTOFResolution(new Float_t[source.fNPoints]),
-  fT0Spread(new Float_t[source.fNPoints])
+  fT0Spread(new Float_t[source.fNPoints]),
+  fNRuns(source.fNRuns),
+  fRunNb(new UInt_t[source.fNRuns]),
+  fRunFirstPoint(new UInt_t[source.fNRuns]),
+  fRunLastPoint(new UInt_t[source.fNRuns])
 {
   /*
    * copy constructor
@@ -92,6 +108,12 @@ AliTOFRunParams::AliTOFRunParams(const AliTOFRunParams &source) :
     fTOFResolution[i] = source.fTOFResolution[i];
     fT0Spread[i] = source.fT0Spread[i];
   }
+
+  for (Int_t i = 0; i < fNRuns; i++) {
+    fRunNb[i] = source.fRunNb[i];
+    fRunFirstPoint[i] = source.fRunFirstPoint[i];
+    fRunLastPoint[i] = source.fRunLastPoint[i];
+  }
   
 }
 
@@ -126,6 +148,22 @@ AliTOFRunParams::operator=(const AliTOFRunParams &source)
     fT0Spread[i] = source.fT0Spread[i];
   }
 
+  if (fNRuns != source.fNRuns) {
+    if (fRunNb) delete [] fRunNb;
+    if (fRunFirstPoint) delete [] fRunFirstPoint;
+    if (fRunLastPoint) delete [] fRunLastPoint;
+    fNRuns = source.fNRuns;
+    fRunNb = new UInt_t[source.fNRuns];
+    fRunFirstPoint = new UInt_t[source.fNRuns];
+    fRunLastPoint = new UInt_t[source.fNRuns];
+  }
+
+  for (Int_t i = 0; i < fNRuns; i++) {
+    fRunNb[i] = source.fRunNb[i];
+    fRunFirstPoint[i] = source.fRunFirstPoint[i];
+    fRunLastPoint[i] = source.fRunLastPoint[i];
+  }
+
   return *this;
 }
 
@@ -222,3 +260,81 @@ AliTOFRunParams::EvalT0Spread(UInt_t timestamp)
   return spread;
 }
 
+//_________________________________________________________
+
+Float_t
+AliTOFRunParams::Average(Float_t *data, Int_t first, Int_t last)
+{
+  /*
+   * average
+   */
+
+  if (first < 0) first = 0;
+  if (last >= fNPoints) last = fNPoints - 1;
+  Float_t value = 0.;
+  Int_t npt = 0;
+  for (Int_t i = first; i <= last; i++) {
+    value += data[i];
+    npt++;
+  }
+  value /= npt;
+  return value;
+
+}
+
+//_________________________________________________________
+
+Float_t
+AliTOFRunParams::Average(Float_t *data, UInt_t runNb)
+{
+  /*
+   * average
+   */
+
+  /* critical cases:
+     1. no measurement -> 0.
+     2. no runNb structure -> average over all points
+     3. runNb not found -> average over all points
+  */
+  if (fNPoints <= 0 || !fT0 || !fTimestamp) return 0.;
+  if (fNRuns <= 0 || !fRunNb || !fRunFirstPoint || !fRunLastPoint) return Average(data, 0, fNPoints - 1);
+
+
+  /* search for runNb */
+  UInt_t runPoint = 0;
+  Bool_t gotRunNb = kFALSE;
+  for (Int_t irun = 0; irun < fNRuns; irun++) {
+    if (fRunNb[irun] == runNb) {
+      runPoint = irun;
+      gotRunNb = kTRUE;
+      break;
+    }
+  }
+  if (!gotRunNb) return Average(data, 0, fNPoints - 1);
+
+  /* average between first and last run points */
+  UInt_t firstPoint = fRunFirstPoint[runPoint];
+  UInt_t lastPoint = fRunLastPoint[runPoint];
+  return Average(data, firstPoint, lastPoint);
+
+}
+
+//_________________________________________________________
+
+TGraph *
+AliTOFRunParams::DrawGraph(Float_t *data, Option_t* option)
+{
+  /*
+   * draw
+   */
+
+  if (fNPoints == 0 || !data || !fTimestamp) return NULL;
+
+  Float_t ts[1000000];
+  for (Int_t i = 0; i < fNPoints; i++)
+    ts[i] = fTimestamp[i];
+
+  TGraph *graph = new TGraph(fNPoints, ts, data);
+  graph->Draw(option);
+  return graph;
+}
index e45ea6c..a3dccf2 100644 (file)
@@ -18,6 +18,8 @@
 
 #include "TObject.h"
 
+class TGraph;
+
 class AliTOFRunParams :
 public TObject
 {
@@ -25,7 +27,7 @@ public TObject
  public:
 
   AliTOFRunParams(); // default constructor
-  AliTOFRunParams(Int_t nPoints); // standard constructor
+  AliTOFRunParams(Int_t nPoints, Int_t nRuns = 1); // standard constructor
   virtual ~AliTOFRunParams(); // default destructor
   AliTOFRunParams(const AliTOFRunParams &source); // copy constructor
   AliTOFRunParams &operator=(const AliTOFRunParams &source); // operator=
@@ -36,16 +38,41 @@ public TObject
   Float_t GetTOFResolution(Int_t i) const {return fTOFResolution && i < fNPoints ? fTOFResolution[i] : 0.;}; // getter
   Float_t GetT0Spread(Int_t i) const {return fT0Spread && i < fNPoints ? fT0Spread[i] : 0.;}; // getter
   
+  UInt_t GetRunNb(Int_t i) const {return fRunNb && i < fNRuns ? fRunNb[i] : 0;}; // getter
+  UInt_t GetRunFirstPoint(Int_t i) const {return fRunFirstPoint && i < fNRuns ? fRunFirstPoint[i] : 0;}; // getter
+  UInt_t GetRunLastPoint(Int_t i) const {return fRunLastPoint && i < fNRuns ? fRunLastPoint[i] : 0;}; // getter
+
   void SetTimestamp(UInt_t *value) {if (fTimestamp) for (Int_t i = 0; i < fNPoints; i++) fTimestamp[i] = value[i];}; // setter
   void SetT0(Float_t *value) {if (fT0) for (Int_t i = 0; i < fNPoints; i++) fT0[i] = value[i];}; // setter
   void SetTOFResolution(Float_t *value) {if (fTOFResolution) for (Int_t i = 0; i < fNPoints; i++) fTOFResolution[i] = value[i];}; // setter
   void SetT0Spread(Float_t *value) {if (fT0Spread) for (Int_t i = 0; i < fNPoints; i++) fT0Spread[i] = value[i];}; // setter
 
+  void SetRunNb(UInt_t *value) {if (fRunNb) for (Int_t i = 0; i < fNRuns; i++) fRunNb[i] = value[i];}; // setter
+  void SetRunFirstPoint(UInt_t *value) {if (fRunFirstPoint) for (Int_t i = 0; i < fNRuns; i++) fRunFirstPoint[i] = value[i];}; // setter
+  void SetRunLastPoint(UInt_t *value) {if (fRunLastPoint) for (Int_t i = 0; i < fNRuns; i++) fRunLastPoint[i] = value[i];}; // setter
+
   Float_t EvalT0(UInt_t timestamp); // eval T0
   Float_t EvalTOFResolution(UInt_t timestamp); // eval TOF resolution
   Float_t EvalT0Spread(UInt_t timestamp); // eval T0 spread
+  
+  Float_t AverageT0(UInt_t runNb) {return Average(fT0, runNb);}; // average T0
+  Float_t AverageTOFResolution(UInt_t runNb) {return Average(fTOFResolution, runNb);}; // average TOF resolution
+  Float_t AverageT0Spread(UInt_t runNb) {return Average(fT0Spread, runNb);}; // average T0 spread
+
+  TGraph *DrawGraphT0(Option_t *option = "") {return DrawGraph(fT0, option);}; // draw graph t0
+  TGraph *DrawGraphTOFResolution(Option_t *option = "") {return DrawGraph(fTOFResolution, option);}; // draw graph t0
+  TGraph *DrawGraphT0Spread(Option_t *option = "") {return DrawGraph(fT0Spread, option);}; // draw graph t0
+
 
  private:
+  
+  /* private methods */
+  
+  Float_t Average(Float_t *data, UInt_t runNb); // average
+  Float_t Average(Float_t *data, Int_t first, Int_t last); // average
+  TGraph *DrawGraph(Float_t *data, Option_t *option = ""); // draw graph
+  
+  /* data members */
 
   Int_t fNPoints;
   UInt_t *fTimestamp; //[fNPoints] time stamp
@@ -53,7 +80,13 @@ public TObject
   Float_t *fTOFResolution; //[fNPoints] average TOF resolution (T0 uncertainty included) (ps)
   Float_t *fT0Spread; //[fNPoints] estimated T0 spread (from vertex spread z) (ps)
 
-  ClassDef(AliTOFRunParams, 1);
+  Int_t fNRuns;
+  UInt_t *fRunNb; //[fNRuns] run number
+  UInt_t *fRunFirstPoint; //[fNRuns] run start point
+  UInt_t *fRunLastPoint; //[fNRuns] run last point
+
+
+  ClassDef(AliTOFRunParams, 2);
 };
 
 #endif /* ALITOFRUNPARAMS_H */