improved handling for grouping and addrun

2010-02-22 06:55:49 +00:00
parent c3316e9676
commit d5d36d21fd
8 changed files with 1197 additions and 327 deletions
--- a/src/classes/PMusrT0.cpp
+++ b/src/classes/PMusrT0.cpp
@@ -42,8 +42,167 @@ using namespace std;

 #define DETECTOR_TAG_FORWARD  0
 #define DETECTOR_TAG_BACKWARD 1
-#define DETECTOR_TAG_RIGHT    2
-#define DETECTOR_TAG_LEFT     3
+
+//--------------------------------------------------------------------------
+// Constructor
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+PMusrT0Data::PMusrT0Data()
+{
+  InitData();
+}
+
+//--------------------------------------------------------------------------
+// Destructor
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+PMusrT0Data::~PMusrT0Data()
+{
+  fRawRunData.clear();
+  fHistoNo.clear();
+  fT0.clear();
+  for (UInt_t i=0; i<fAddT0.size(); i++)
+    fAddT0[i].clear();
+  fAddT0.clear();
+}
+
+//--------------------------------------------------------------------------
+// InitData
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+void PMusrT0Data::InitData()
+{
+  fSingleHisto = true;
+  fRunNo       = -1;
+  fAddRunIdx   = -1;
+  fHistoNoIdx  = -1;
+  fDetectorTag = -1;
+  fCmdTag      = -1;
+  fRawRunData.clear();
+  fHistoNo.clear();
+  fT0.clear();
+  for (UInt_t i=0; i<fAddT0.size(); i++)
+    fAddT0[i].clear();
+  fAddT0.clear();
+}
+
+//--------------------------------------------------------------------------
+// GetRawRunData
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+PRawRunData* PMusrT0Data::GetRawRunData(Int_t idx)
+{
+  if ((idx < 0) || (idx >= static_cast<Int_t>(fRawRunData.size())))
+    return 0;
+
+  return fRawRunData[idx];
+}
+
+//--------------------------------------------------------------------------
+// GetHistoNo
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+Int_t PMusrT0Data::GetHistoNo(UInt_t idx)
+{
+  if (idx >= fHistoNo.size())
+    return -1;
+
+  return fHistoNo[idx];
+}
+
+//--------------------------------------------------------------------------
+// GetT0
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+Int_t PMusrT0Data::GetT0(UInt_t idx)
+{
+  if (idx >= fT0.size())
+    return -1;
+
+  return fT0[idx];
+}
+
+//--------------------------------------------------------------------------
+// GetAddT0Size
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+UInt_t PMusrT0Data::GetAddT0Size(UInt_t idx)
+{
+  if (idx >= fAddT0.size())
+    return 0;
+
+  return fAddT0[idx].size();
+}
+
+//--------------------------------------------------------------------------
+// GetAddT0
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+Int_t PMusrT0Data::GetAddT0(UInt_t addRunIdx, UInt_t idx)
+{
+  if (addRunIdx >= fAddT0.size())
+    return -1;
+
+  if (idx >= fAddT0[addRunIdx].size())
+    return -1;
+
+  return fAddT0[addRunIdx][idx];
+}
+
+//--------------------------------------------------------------------------
+// SetT0
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+void PMusrT0Data::SetT0(UInt_t val, UInt_t idx)
+{
+//cout << endl << "debug+> SetT0: size=" << fT0.size();
+//cout << endl << "debug+> SetT0: val=" << val << ", idx=" << idx << endl;
+
+  if (idx >= fT0.size())
+    fT0.resize(idx+1);
+
+  fT0[idx] = val;
+}
+
+//--------------------------------------------------------------------------
+// SetAddT0
+//--------------------------------------------------------------------------
+/**
+ *
+ */
+void PMusrT0Data::SetAddT0(UInt_t val, UInt_t addRunIdx, UInt_t idx)
+{
+//cout << endl << "debug+> SetAddT0: size=" << fAddT0.size();
+//cout << endl << "debug+> SetAddT0: val=" << val << ", addRunIdx=" << addRunIdx << ", idx=" << idx << endl;
+
+  if (addRunIdx >= fAddT0.size())
+    fAddT0.resize(addRunIdx+1);
+
+  if (idx >= fAddT0[addRunIdx].size())
+    fAddT0[addRunIdx].resize(idx+1);
+
+  fAddT0[addRunIdx][idx] = val;
+}
+
+//--------------------------------------------------------------------------

 ClassImpQ(PMusrT0)

@@ -55,8 +214,9 @@ ClassImpQ(PMusrT0)
 */
 PMusrT0::PMusrT0()
 {
-  fRunNo       = -1;
-  fDetectorTag = -1;
+  fValid = false;
+
+  fStatus = 0; // default is quit locally

  fMainCanvas = 0;

@@ -64,6 +224,11 @@ PMusrT0::PMusrT0()
  fData  = 0;
  fBkg   = 0;

+  fToDoInfo = 0;
+
+  fDataAndBkgEnabled = false;
+  fT0Enabled         = false;
+
  fDataRange[0] = 0;
  fDataRange[1] = 0;
  fBkgRange[0]  = 0;
@@ -80,40 +245,241 @@ PMusrT0::PMusrT0()
 // Constructor
 //--------------------------------------------------------------------------
 /**
+ * <p>
 *
- * \param rawRunData
- * \param histoNo
+ * \param data
 */
-PMusrT0::PMusrT0(PRawRunData *rawRunData, Int_t runNo, Int_t histoNo, Int_t detectorTag, Int_t addRunNo) :
-    fRunNo(runNo), fDetectorTag(detectorTag), fAddRunNo(addRunNo)
+PMusrT0::PMusrT0(PMusrT0Data &data) : fMusrT0Data(data)
 {
-cout << endl << "run Name = " << rawRunData->GetRunName()->Data() << ", runNo = " << fRunNo << ", histoNo = " << histoNo << endl;
+  fValid = true;

  fStatus = 0; // default is quit locally

-  fAddRunOffset = 0;
+  fMainCanvas = 0;

-  TString str = *rawRunData->GetRunName() + TString(" : ");
-  str += histoNo;
+  fHisto = 0;
+  fData  = 0;
+  fBkg   = 0;
+
+  fToDoInfo = 0;
+
+  fDataAndBkgEnabled = false;
+  fT0Enabled         = false;
+
+  fDataRange[0] = 0;
+  fDataRange[1] = 0;
+  fBkgRange[0]  = 0;
+  fBkgRange[1]  = 0;
+
+  fT0Line        = 0;
+  fFirstBkgLine  = 0;
+  fLastBkgLine   = 0;
+  fFirstDataLine = 0;
+  fLastDataLine  = 0;

  // feed necessary objects
+  TString str;

-  // feed raw data histo
-  Int_t noOfBins = rawRunData->GetDataBin(histoNo-1)->size();
-  Double_t start = -0.5;
-  Double_t end   = noOfBins - 0.5; // -0.5 is correct since the data start at 0.0
-  fHisto = new TH1F("fHisto", str.Data(), noOfBins, start, end);
-  fHisto->SetMarkerStyle(21);
-  fHisto->SetMarkerSize(0.5);
-  fHisto->SetMarkerColor(TColor::GetColor(0,0,0)); // black
+  if ((fMusrT0Data.GetCmdTag() == PMUSRT0_GET_T0) || (fMusrT0Data.GetCmdTag() == PMUSRT0_GET_T0_DATA_AND_BKG_RANGE)) {
+    str = *fMusrT0Data.GetRawRunData(fMusrT0Data.GetAddRunIdx())->GetRunName() + TString(" : ");
+    str += fMusrT0Data.GetHistoNo(fMusrT0Data.GetHistoNoIdx());
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+      str += " (f)";
+    else
+      str += " (b)";
+    str += ", msr runNo = ";
+    str += fMusrT0Data.GetRunNo()+1;
+
+
+    // feed raw data histo
+    PRawRunData *rawRunData = fMusrT0Data.GetRawRunData(fMusrT0Data.GetAddRunIdx());
+    if (rawRunData == 0) {
+      fValid = false;
+      return;
+    }
+    Int_t histoNo = fMusrT0Data.GetHistoNo(fMusrT0Data.GetHistoNoIdx())-1;
+    Int_t noOfBins = rawRunData->GetDataBin(histoNo)->size();
+    Double_t start = -0.5;
+    Double_t end   = noOfBins - 0.5; // -0.5 is correct since the data start at 0.0
+    fHisto = new TH1F("fHisto", str.Data(), noOfBins, start, end);
+    fHisto->SetMarkerStyle(21);
+    fHisto->SetMarkerSize(0.5);
+    fHisto->SetMarkerColor(TColor::GetColor(0,0,0)); // black
+
+    Double_t maxVal = 0.0;
+    fT0Estimated = 0;
+    for (UInt_t i=0; i<rawRunData->GetDataBin(histoNo)->size(); i++) {
+      fHisto->SetBinContent(i+1, rawRunData->GetDataBin(histoNo)->at(i));
+      if (rawRunData->GetDataBin(histoNo)->at(i) > maxVal) {
+        maxVal = rawRunData->GetDataBin(histoNo)->at(i);
+        fT0Estimated = i;
+      }
+    }
+  } else {
+/*
+cout << endl << "debug> all t0's:" << endl;
+for (UInt_t i=0; i<fMusrT0Data.GetT0Size(); i++) {
+cout << fMusrT0Data.GetT0(i) << ",";
+}
+cout << endl << "debug> all addt0's:" << endl;
+for (UInt_t j=0; j<fMusrT0Data.GetAddT0Entries(); j++) {
+  cout << "debug> j=" << j << endl;
+  for (UInt_t i=0; i<fMusrT0Data.GetAddT0Size(j); i++)
+    cout << fMusrT0Data.GetAddT0(j,i) << ",";
+}
+cout << endl;
+*/
+    str = *fMusrT0Data.GetRawRunData(0)->GetRunName() + TString(" : ");
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+      str += " forward grouped and runs added";
+    else
+      str += " backward grouped and runs added";
+    str += ", msr runNo = ";
+    str += fMusrT0Data.GetRunNo()+1;
+
+    // feed raw data histo
+    PRawRunData *rawRunData = fMusrT0Data.GetRawRunData(0);
+    if (rawRunData == 0) {
+      fValid = false;
+      return;
+    }
+
+    // get run and first histo of grouping and feed it into fHisto
+    Int_t histoNo = fMusrT0Data.GetHistoNo(0)-1;
+    Int_t noOfBins = rawRunData->GetDataBin(histoNo)->size();
+    Double_t start = -0.5;
+    Double_t end   = noOfBins - 0.5; // -0.5 is correct since the data start at 0.0
+    fHisto = new TH1F("fHisto", str.Data(), noOfBins, start, end);
+    fHisto->SetMarkerStyle(21);
+    fHisto->SetMarkerSize(0.5);
+    fHisto->SetMarkerColor(TColor::GetColor(0,0,0)); // black
+
+    // sum up all necessary histograms by taking care of the proper t0's
+    Int_t t00;
+    Int_t t0;
+    Double_t dval;
+
+    // check if asymmetry fit
+    UInt_t factor=1;
+    if (!fMusrT0Data.IsSingleHisto())
+      factor=2;
+
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+      t00 = fMusrT0Data.GetT0(0);
+    else
+      t00 = fMusrT0Data.GetT0(1);
+
+    // check if there are addruns and grouping
+    if ((fMusrT0Data.GetRawRunDataSize() > 1) && (fMusrT0Data.GetHistoNoSize() > 1)) { // addruns and grouping present
+
+      for (Int_t i=0; i<noOfBins; i++) { // loop over all entries in fHisto
+
+        dval = 0;
+
+        for (UInt_t k=0; k<fMusrT0Data.GetHistoNoSize(); k++) { // loop over all histograms (grouping)
+
+          histoNo = fMusrT0Data.GetHistoNo(k)-1;
+
+          // get t0
+          if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+            t0 = fMusrT0Data.GetT0(factor*k);
+          else
+            t0 = fMusrT0Data.GetT0(factor*k+1);
+
+          // get proper rawRunData
+          rawRunData = fMusrT0Data.GetRawRunData(0);
+
+          // get bin value from run/grouping
+          if ((i+t0-t00 > 0) && (i+t0-t00 < static_cast<Int_t>(rawRunData->GetDataBin(histoNo)->size())))
+            dval += rawRunData->GetDataBin(histoNo)->at(i+t0-t00);
+
+          for (UInt_t j=1; j<fMusrT0Data.GetRawRunDataSize(); j++) { // loop over all potential addruns
+
+            rawRunData = fMusrT0Data.GetRawRunData(j);
+
+            // get t0
+            if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+              t0 = fMusrT0Data.GetAddT0(j-1, factor*k);
+            else
+              t0 = fMusrT0Data.GetAddT0(j-1, factor*k+1);
+
+            // get bin value from addrun/grouping
+            if ((i+t0-t00 > 0) && (i+t0-t00 < static_cast<Int_t>(rawRunData->GetDataBin(histoNo)->size())))
+              dval += rawRunData->GetDataBin(histoNo)->at(i+t0-t00);
+          }
+        }
+        // set bin value of fHisto
+        fHisto->SetBinContent(i+1, dval);
+      }
+
+    } else if (fMusrT0Data.GetRawRunDataSize() > 1) { // only addruns present
+
+      for (Int_t i=0; i<noOfBins; i++) { // loop over all entries in fHisto
+
+        dval = 0;
+
+        histoNo = fMusrT0Data.GetHistoNo(0)-1;
+
+        // get t0
+        if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+          t0 = fMusrT0Data.GetT0(0);
+        else
+          t0 = fMusrT0Data.GetT0(1);
+
+        // get proper rawRunData
+        rawRunData = fMusrT0Data.GetRawRunData(0);
+
+        // get bin value from run/grouping
+        if ((i+t0-t00 > 0) && (i+t0-t00 < static_cast<Int_t>(rawRunData->GetDataBin(histoNo)->size())))
+          dval += rawRunData->GetDataBin(histoNo)->at(i+t0-t00);
+
+        for (UInt_t j=1; j<fMusrT0Data.GetRawRunDataSize(); j++) { // loop over all potential addruns
+
+          // get proper rawRunData
+          rawRunData = fMusrT0Data.GetRawRunData(j);
+
+          // get t0
+          if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+            t0 = fMusrT0Data.GetAddT0(j-1, 0);
+          else
+            t0 = fMusrT0Data.GetAddT0(j-1, 1);
+
+          // get bin value from addrun/grouping
+          if ((i+t0-t00 > 0) && (i+t0-t00 < static_cast<Int_t>(rawRunData->GetDataBin(histoNo)->size())))
+            dval += rawRunData->GetDataBin(histoNo)->at(i+t0-t00);
+        }
+        // set bin value of fHisto
+        fHisto->SetBinContent(i+1, dval);
+      }
+
+    } else if (fMusrT0Data.GetHistoNoSize() > 1) { // only grouping persent
+
+      for (Int_t i=0; i<noOfBins; i++) { // loop over all entries in fHisto
+
+        dval = 0;
+
+        // get proper rawRunData
+        rawRunData = fMusrT0Data.GetRawRunData(0);
+
+        for (UInt_t k=0; k<fMusrT0Data.GetHistoNoSize(); k++) { // loop over all histograms (grouping)
+
+          histoNo = fMusrT0Data.GetHistoNo(k)-1;
+
+          // get t0
+          if (fMusrT0Data.GetDetectorTag() == PMUSRT0_FORWARD)
+            t0 = fMusrT0Data.GetT0(factor*k);
+          else
+            t0 = fMusrT0Data.GetT0(factor*k+1);
+
+          // get bin value from run/grouping
+          if ((i+t0-t00 > 0) && (i+t0-t00 < static_cast<Int_t>(rawRunData->GetDataBin(histoNo)->size())))
+            dval += rawRunData->GetDataBin(histoNo)->at(i+t0-t00);
+
+        }
+        // set bin value of fHisto
+        fHisto->SetBinContent(i+1, dval);
+      }

-  Double_t maxVal = 0.0;
-  fT0Estimated = 0;
-  for (UInt_t i=0; i<rawRunData->GetDataBin(histoNo-1)->size(); i++) {
-    fHisto->SetBinContent(i+1, rawRunData->GetDataBin(histoNo-1)->at(i));
-    if (rawRunData->GetDataBin(histoNo-1)->at(i) > maxVal) {
-      maxVal = rawRunData->GetDataBin(histoNo-1)->at(i);
-      fT0Estimated = i;
    }
  }

@@ -121,13 +487,46 @@ cout << endl << "run Name = " << rawRunData->GetRunName()->Data() << ", runNo =
  fMainCanvas = new TCanvas("fMainCanvas", str);
  fMainCanvas->SetFillColor(TColor::GetColor(255,255,255));

+
  fMainCanvas->Show();

  fMainCanvas->Connect("ProcessedEvent(Int_t,Int_t,Int_t,TObject*)", "PMusrT0",
                       this, "HandleCmdKey(Int_t,Int_t,Int_t,TObject*)");

+  if (fMusrT0Data.GetCmdTag() != PMUSRT0_GET_T0)
+    fDataAndBkgEnabled = true;
+  else
+    fDataAndBkgEnabled = false;
+
+  if (fMusrT0Data.GetCmdTag() != PMUSRT0_GET_DATA_AND_BKG_RANGE)
+    fT0Enabled = true;
+  else
+    fT0Enabled = false;
+
+  // do not show root statistics block
+  fHisto->SetStats(kFALSE);
+
  // draw histos etc
  fHisto->Draw("p0 9 hist");
+
+  if (fMusrT0Data.GetCmdTag() == PMUSRT0_GET_T0) {
+    str = "please set t0 bin only.";
+    fToDoInfo = new TLatex();
+    fToDoInfo->SetTextFont(51);
+    fToDoInfo->SetTextSize(0.030);
+    fToDoInfo->SetLineWidth(2);
+    fToDoInfo->SetNDC(kTRUE);
+    fToDoInfo->DrawLatex(0.1, 0.91, str.Data());
+  }
+  if (fMusrT0Data.GetCmdTag() == PMUSRT0_GET_DATA_AND_BKG_RANGE) {
+    str = "please set data and bkg range.";
+    fToDoInfo = new TLatex();
+    fToDoInfo->SetTextFont(51);
+    fToDoInfo->SetTextSize(0.030);
+    fToDoInfo->SetLineWidth(2);
+    fToDoInfo->SetNDC(kTRUE);
+    fToDoInfo->DrawLatex(0.1, 0.91, str.Data());
+  }
 }

 //--------------------------------------------------------------------------
@@ -150,6 +549,10 @@ PMusrT0::~PMusrT0()
    delete fBkg;
    fBkg = 0;
  }
+  if (fToDoInfo) {
+    delete fToDoInfo;
+    fToDoInfo = 0;
+  }
  if (fT0Line) {
    delete fT0Line;
    fT0Line = 0;
@@ -212,6 +615,8 @@ void PMusrT0::HandleCmdKey(Int_t event, Int_t x, Int_t y, TObject *selected)
    Done(0);
  } else if (x == 'u') { // unzoom to the original range
    UnZoom();
+  } else if (x == 'z') { // zoom to the region around t0, and the estimated t0
+    ZoomT0();
  } else if (x == 'T') { // set estimated t0 channel
    SetEstimatedT0Channel();
  } else if (x == 't') { // set t0 channel
@@ -237,8 +642,50 @@ void PMusrT0::HandleCmdKey(Int_t event, Int_t x, Int_t y, TObject *selected)
 void PMusrT0::SetMsrHandler(PMsrHandler *msrHandler)
 {
  fMsrHandler = msrHandler;
+}

-  InitDataAndBkg();
+//--------------------------------------------------------------------------
+// InitT0
+//--------------------------------------------------------------------------
+/**
+ * <p>
+ *
+ */
+void PMusrT0::InitT0()
+{
+  // t0 line
+  Int_t t0Bin = 0;
+  Int_t histoIdx  = fMusrT0Data.GetHistoNoIdx();
+  Int_t addRunIdx = fMusrT0Data.GetAddRunIdx();
+  UInt_t factor=1;
+  if (!fMusrT0Data.IsSingleHisto())
+    factor=2;
+  switch (fMusrT0Data.GetDetectorTag() ) {
+    case PMUSRT0_FORWARD:
+      if (addRunIdx == 0)
+        t0Bin = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetT0(factor*histoIdx);
+      else if (addRunIdx > 0)
+        t0Bin = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetAddT0(addRunIdx-1, factor*histoIdx);
+      break;
+    case PMUSRT0_BACKWARD:
+      if (addRunIdx == 0)
+        t0Bin = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetT0(factor*histoIdx+1);
+      else if (addRunIdx > 0)
+        t0Bin = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetAddT0(addRunIdx-1, factor*histoIdx+1);
+      break;
+    default:
+      // not clear yet what to be done
+      break;
+  }
+  Double_t max = fHisto->GetMaximum();
+
+//cout << "debug-> histoIdx=" << histoIdx << ", addRunIdx=" << addRunIdx << ", t0Bin=" << t0Bin << endl;
+
+  fT0Line = new TLine((Double_t)t0Bin, 0.0, (Double_t)t0Bin, max);
+  fT0Line->SetLineStyle(1); // solid
+  fT0Line->SetLineColor(TColor::GetColor(0,255,0)); // green
+  fT0Line->SetLineWidth(2);
+  fT0Line->Draw();
 }

 //--------------------------------------------------------------------------
@@ -250,31 +697,15 @@ void PMusrT0::SetMsrHandler(PMsrHandler *msrHandler)
 */
 void PMusrT0::InitDataAndBkg()
 {
-  // get addRun offset which depends on the fit type
-  Int_t fitType = fMsrHandler->GetMsrRunList()->at(fRunNo).GetFitType();
-  if (fitType == MSR_FITTYPE_SINGLE_HISTO) {
-    fAddRunOffset = 2;
-  } else if (fitType == MSR_FITTYPE_ASYM) {
-    fAddRunOffset = 4;
-  } else if (fitType == MSR_FITTYPE_MU_MINUS) {
-    fAddRunOffset = 2;
-  }
-
  // feed data range histo
-  switch (fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      fDataRange[0] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetDataRange(0 + fAddRunNo * fAddRunOffset);
-      fDataRange[1] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetDataRange(1 + fAddRunNo * fAddRunOffset);
+  switch (fMusrT0Data.GetDetectorTag()) {
+    case PMUSRT0_FORWARD:
+      fDataRange[0] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetDataRange(0);
+      fDataRange[1] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetDataRange(1);
      break;
-    case DETECTOR_TAG_BACKWARD:
-      fDataRange[0] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetDataRange(2 + fAddRunNo * fAddRunOffset);
-      fDataRange[1] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetDataRange(3 + fAddRunNo * fAddRunOffset);
-      break;
-    case DETECTOR_TAG_RIGHT:
-      // not clear yet what to be done
-      break;
-    case DETECTOR_TAG_LEFT:
-      // not clear yet what to be done
+    case PMUSRT0_BACKWARD:
+      fDataRange[0] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetDataRange(2);
+      fDataRange[1] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetDataRange(3);
      break;
    default:
      // not clear yet what to be done
@@ -295,20 +726,14 @@ void PMusrT0::InitDataAndBkg()
  fData->Draw("p0 9 hist same");

  // feed background histo
-  switch (fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      fBkgRange[0] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetBkgRange(0 + fAddRunNo * fAddRunOffset);
-      fBkgRange[1] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetBkgRange(1 + fAddRunNo * fAddRunOffset);
+  switch (fMusrT0Data.GetDetectorTag()) {
+    case PMUSRT0_FORWARD:
+      fBkgRange[0] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetBkgRange(0);
+      fBkgRange[1] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetBkgRange(1);
      break;
-    case DETECTOR_TAG_BACKWARD:
-      fBkgRange[0] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetBkgRange(2 + fAddRunNo * fAddRunOffset);
-      fBkgRange[1] = fMsrHandler->GetMsrRunList()->at(fRunNo).GetBkgRange(3 + fAddRunNo * fAddRunOffset);
-      break;
-    case DETECTOR_TAG_RIGHT:
-      // not clear yet what to be done
-      break;
-    case DETECTOR_TAG_LEFT:
-      // not clear yet what to be done
+    case PMUSRT0_BACKWARD:
+      fBkgRange[0] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetBkgRange(2);
+      fBkgRange[1] = fMsrHandler->GetMsrRunList()->at(fMusrT0Data.GetRunNo()).GetBkgRange(3);
      break;
    default:
      // not clear yet what to be done
@@ -329,31 +754,7 @@ void PMusrT0::InitDataAndBkg()
  fBkg->Draw("p0 9 hist same");

  // add lines
-  // t0 line
-  Int_t t0Bin = 0;
-  switch (fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      t0Bin = fMsrHandler->GetMsrRunList()->at(fRunNo).GetT0(0 + fAddRunNo * fAddRunOffset/2);
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      t0Bin = fMsrHandler->GetMsrRunList()->at(fRunNo).GetT0(1 + fAddRunNo * fAddRunOffset/2);
-      break;
-    case DETECTOR_TAG_RIGHT:
-      // not clear yet what to be done
-      break;
-    case DETECTOR_TAG_LEFT:
-      // not clear yet what to be done
-      break;
-    default:
-      // not clear yet what to be done
-      break;
-  }
  Double_t max = fHisto->GetMaximum();
-  fT0Line = new TLine((Double_t)t0Bin, 0.0, (Double_t)t0Bin, max);
-  fT0Line->SetLineStyle(1); // solid
-  fT0Line->SetLineColor(TColor::GetColor(0,255,0)); // green
-  fT0Line->SetLineWidth(2);
-  fT0Line->Draw();

  // data lines
  fFirstDataLine = new TLine((Double_t)fDataRange[0], 0.0, (Double_t)fDataRange[0], max);
@@ -393,33 +794,35 @@ void PMusrT0::InitDataAndBkg()
 */
 void PMusrT0::SetT0Channel()
 {
+  if (!fT0Enabled)
+    return;
+
  Double_t x=0, y=0;
  fMainCanvas->AbsPixeltoXY(fPx,fPy,x,y);

  // get binx to set t0 corresponding to fPx
  Int_t binx = fHisto->GetXaxis()->FindFixBin(x) - 1;

-cout << endl << ">> PMusrT0::SetT0Channel(): binx = " << binx << endl;
+  cout << endl << ">> PMusrT0::SetT0Channel(): t0 = " << binx << endl;

  // set t0 bin in msr-Handler
-  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 1 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 2 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 3 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    default:
-      break;
+  UInt_t idx;
+  if (fMusrT0Data.IsSingleHisto()) {
+    idx = fMusrT0Data.GetHistoNoIdx();
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+      idx += 1;
+  } else {
+    idx = 2*fMusrT0Data.GetHistoNoIdx();
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+      idx += 1;
  }
-  fMsrHandler->SetMsrT0Entry(fRunNo, idx, binx);
+
+//cout << endl << "debug> SetT0Channel: t0-idx=" << idx << ", t0-value=" << binx;
+
+  if (fMusrT0Data.GetAddRunIdx() == 0)
+    fMsrHandler->SetMsrT0Entry(fMusrT0Data.GetRunNo(), idx, binx);
+  else if (fMusrT0Data.GetAddRunIdx() > 0)
+    fMsrHandler->SetMsrAddT0Entry(fMusrT0Data.GetRunNo(), fMusrT0Data.GetAddRunIdx()-1, idx, binx);

  // shift line to the proper position
  fT0Line->SetX1(x);
@@ -438,27 +841,29 @@ cout << endl << ">> PMusrT0::SetT0Channel(): binx = " << binx << endl;
 */
 void PMusrT0::SetEstimatedT0Channel()
 {
-  // set t0 bin in msr-Handler
-  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 1 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 2 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 3 + fAddRunNo * fAddRunOffset / 2;
-      break;
-    default:
-      break;
-  }
-  fMsrHandler->SetMsrT0Entry(fRunNo, idx, fT0Estimated);
+  if (!fT0Enabled)
+    return;

-  Double_t x = fHisto->GetXaxis()->GetBinCenter(fT0Estimated);
+  // set t0 bin in msr-Handler
+  UInt_t idx;
+  if (fMusrT0Data.IsSingleHisto()) {
+    idx = fMusrT0Data.GetHistoNoIdx();
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+      idx += 1;
+  } else {
+    idx = 2*fMusrT0Data.GetHistoNoIdx();
+    if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+      idx += 1;
+  }
+
+  if (fMusrT0Data.GetAddRunIdx() == 0)
+    fMsrHandler->SetMsrT0Entry(fMusrT0Data.GetRunNo(), idx, fT0Estimated);
+  else if (fMusrT0Data.GetAddRunIdx() > 0)
+    fMsrHandler->SetMsrAddT0Entry(fMusrT0Data.GetRunNo(), fMusrT0Data.GetAddRunIdx()-1, idx, fT0Estimated);
+
+  Double_t x = fHisto->GetXaxis()->GetBinCenter(fT0Estimated)+1.0; // +1.0 needed since the first bin == 1 not 0.
+
+  cout << endl << ">> PMusrT0::SetEstimatedT0Channel(): estimated t0 = " << fT0Estimated << endl;

  // shift line to the proper position
  fT0Line->SetX1(x);
@@ -477,6 +882,9 @@ void PMusrT0::SetEstimatedT0Channel()
 */
 void PMusrT0::SetDataFirstChannel()
 {
+  if (!fDataAndBkgEnabled)
+    return;
+
  Double_t x=0, y=0;
  fMainCanvas->AbsPixeltoXY(fPx,fPy,x,y);

@@ -487,23 +895,9 @@ cout << endl << ">> PMusrT0::SetDataFirstChannel(): fDataRange[0] = " << fDataRa

  // set the data first bin in msr-Handler
  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 2 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 4 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 6 + fAddRunNo * fAddRunOffset;
-      break;
-    default:
-      break;
-  }
-  fMsrHandler->SetMsrDataRangeEntry(fRunNo, idx, fDataRange[0]);
+  if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+    idx = 2;
+  fMsrHandler->SetMsrDataRangeEntry(fMusrT0Data.GetRunNo(), idx, fDataRange[0]);

  // shift line to the proper position
  fFirstDataLine->SetX1(x);
@@ -539,6 +933,9 @@ cout << endl << ">> PMusrT0::SetDataFirstChannel(): fDataRange[0] = " << fDataRa
 */
 void PMusrT0::SetDataLastChannel()
 {
+  if (!fDataAndBkgEnabled)
+    return;
+
  Double_t x=0, y=0;
  fMainCanvas->AbsPixeltoXY(fPx,fPy,x,y);

@@ -548,24 +945,10 @@ void PMusrT0::SetDataLastChannel()
 cout << endl << ">> PMusrT0::SetDataLastChannel(): fDataRange[1] = " << fDataRange[1] << endl;

  // set the data first bin in msr-Handler
-  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = 1 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 3 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 5 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 7 + fAddRunNo * fAddRunOffset;
-      break;
-    default:
-      break;
-  }
-  fMsrHandler->SetMsrDataRangeEntry(fRunNo, idx, fDataRange[1]);
+  UInt_t idx = 1;
+  if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+    idx = 3;
+  fMsrHandler->SetMsrDataRangeEntry(fMusrT0Data.GetRunNo(), idx, fDataRange[1]);

  // shift line to the proper position
  fLastDataLine->SetX1(x);
@@ -601,6 +984,9 @@ cout << endl << ">> PMusrT0::SetDataLastChannel(): fDataRange[1] = " << fDataRan
 */
 void PMusrT0::SetBkgFirstChannel()
 {
+  if (!fDataAndBkgEnabled)
+    return;
+
  Double_t x=0, y=0;
  fMainCanvas->AbsPixeltoXY(fPx,fPy,x,y);

@@ -611,23 +997,9 @@ cout << endl << ">> PMusrT0::SetBkgFirstChannel(): fBkgRange[0] = " << fBkgRange

  // set the background first bin in msr-Handler
  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 2 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 4 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 6 + fAddRunNo * fAddRunOffset;
-      break;
-    default:
-      break;
-  }
-  fMsrHandler->SetMsrBkgRangeEntry(fRunNo, idx, fBkgRange[0]);
+  if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+    idx = 2;
+  fMsrHandler->SetMsrBkgRangeEntry(fMusrT0Data.GetRunNo(), idx, fBkgRange[0]);

  // shift line to the proper position
  fFirstBkgLine->SetX1(x);
@@ -663,6 +1035,9 @@ cout << endl << ">> PMusrT0::SetBkgFirstChannel(): fBkgRange[0] = " << fBkgRange
 */
 void PMusrT0::SetBkgLastChannel()
 {
+  if (!fDataAndBkgEnabled)
+    return;
+
  Double_t x=0, y=0;
  fMainCanvas->AbsPixeltoXY(fPx,fPy,x,y);

@@ -672,24 +1047,10 @@ void PMusrT0::SetBkgLastChannel()
 cout << endl << ">> PMusrT0::SetBkgLastChannel(): fBkgRange[1] = " << fBkgRange[1] << endl;

  // set the background first bin in msr-Handler
-  UInt_t idx = 0;
-  switch(fDetectorTag) {
-    case DETECTOR_TAG_FORWARD:
-      idx = 1 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_BACKWARD:
-      idx = 3 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_LEFT:
-      idx = 5 + fAddRunNo * fAddRunOffset;
-      break;
-    case DETECTOR_TAG_RIGHT:
-      idx = 7 + fAddRunNo * fAddRunOffset;
-      break;
-    default:
-      break;
-  }
-  fMsrHandler->SetMsrBkgRangeEntry(fRunNo, idx, fBkgRange[1]);
+  UInt_t idx = 1;
+  if (fMusrT0Data.GetDetectorTag() == PMUSRT0_BACKWARD)
+    idx = 3;
+  fMsrHandler->SetMsrBkgRangeEntry(fMusrT0Data.GetRunNo(), idx, fBkgRange[1]);

  // shift line to the proper position
  fLastBkgLine->SetX1(x);
@@ -731,6 +1092,48 @@ void PMusrT0::UnZoom()
  fMainCanvas->Update();
 }

+//--------------------------------------------------------------------------
+// ZoomT0
+//--------------------------------------------------------------------------
+/**
+ * <p>
+ *
+ */
+void PMusrT0::ZoomT0()
+{
+  if (!fT0Enabled)
+    return;
+
+  const Int_t range = 75;
+
+  // get current t0 position
+  Double_t t0x = fT0Line->GetX1();
+  Int_t t0 = fHisto->GetXaxis()->FindBin(t0x)-1;
+
+  Int_t min = t0 - range;
+  Int_t max = t0 + range;
+
+  // check if t0 is defined at all
+  if (t0 <= 0) {
+    min = fT0Estimated - range;
+    max = fT0Estimated + range;
+  }
+
+  if (fT0Estimated < min) {
+    min = fT0Estimated - range;
+  }
+  if (fT0Estimated > max) {
+    max = fT0Estimated + range;
+  }
+
+//  cout << endl << "debug> ZoomT0: min=" << min << ", max=" << max << endl;
+
+  fHisto->GetXaxis()->SetRangeUser(min, max);
+
+  fMainCanvas->Modified(); // needed that Update is actually working
+  fMainCanvas->Update();
+}
+
 //--------------------------------------------------------------------------
 // END
 //--------------------------------------------------------------------------