BaselineView.cc

Go to the documentation of this file.

#include <sevt/PMT.h>
#include "AddText.h"
#include "BaselineView.h"

#include <TCanvas.h>
#include <TH1D.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TArrow.h>
#include <TBox.h>

#include <boost/format.hpp>

#include <algorithm>
#include <sstream>

using namespace utl;
using namespace sevt;
using namespace std;
using namespace boost;
using namespace SdCalibPlotterOG;


void
BaselineView::DividePage(TCanvas& c)
{
  const double xmargin = 0.003;
  const double ymargin = 0.003;
  const double vertDivision = 0.2;

  TPad* const savePad = (TPad*)gPad;
  c.cd();
  const string name = c.GetName();
  ostringstream os;
  int n = 1;
  os.str(""); os << name << "_1";
  const double x1 = xmargin;
  const double x2 = vertDivision - 0.5*xmargin;
  const double x3 = vertDivision + 0.5*xmargin;
  const double x4 = 1 - xmargin;
  const double y11 = ymargin;
  const double y12 = 1 - ymargin;
  TPad* const pad1 = new TPad(os.str().c_str(), os.str().c_str(), x1, y11, x2, y12, 0);
  pad1->SetNumber(n++);
  pad1->Draw();
  const int nRows = 6;
  for (int row = 0; row < nRows; ++row) {
    const double y1 = 1 - (row+1)*(1 - ymargin)/nRows;
    const double y2 = 1 - ymargin - row*(1 - ymargin)/nRows;
    os.str(""); os << name << '_' << n;
    TPad* const pad = new TPad(os.str().c_str(), os.str().c_str(), x3, y1, x4, y2, 0);
    pad->SetNumber(n++);
    pad->SetLeftMargin(0.5*pad->GetLeftMargin());
    pad->SetRightMargin(0);
    pad->Draw();
  }
  savePad->cd();
}


void
BaselineView::Draw(const PMT& pmt)
{
  if (!pmt.HasFADCTrace()) {
    Missing("No FADC Trace");
    return;
  }
  // raw trace
  const TraceI& trace = pmt.GetFADCTrace(fGain);
  const int traceLength = trace.GetSize();
  ostringstream os;
  os << "PMT" << pmt.GetId() << '_'
     << (fGain == sdet::PMTConstants::eLowGain ? "LowGain" : "HighGain")
     << "_Baseline";
  TH1D& th =
    Add(new TH1D(os.str().c_str(), os.str().c_str(), traceLength, 0, traceLength));
  for (int i = 0; i < traceLength; ++i)
    th.SetBinContent(i+1, trace[i]);
  th.SetStats(false);
  th.SetMinimum(0);
  th.SetLineColor(kRed);
  th.GetYaxis()->SetTitle("[FADC]");
  th.GetYaxis()->SetTitleOffset(0.23);
  th.GetYaxis()->SetTickLength(0.01);

  if (!pmt.HasRecData()) {
    Missing("No Rec Data");
    return;
  }

  const PMTRecData& pmtRec = pmt.GetRecData();

  // no baseline
  if (!pmtRec.HasFADCBaseline(fGain)) {
    // draw online baseline arrow
    if (pmt.HasCalibData()) {
      const double baseline = pmt.GetCalibData().GetBaseline(fGain);
      TArrow& ba = Add(new TArrow(0.2*traceLength, baseline, 0, baseline, 0.01));
      ba.SetAngle(20);
      ba.SetLineColor(8);
      ba.Draw();
    }
    Missing("No Baseline");
    return;
  }

  // baseline
  const TraceD& baseline = pmtRec.GetFADCBaseline(fGain);
  TH1D& bh =
    Add(new TH1D((os.str() + "2").c_str(), "", traceLength, 0, traceLength));
  for (int i = 0; i < traceLength; ++i)
    bh.SetBinContent(i+1, baseline[i]);
  bh.SetStats(false);
  bh.SetLineColor(kBlue);

  // fix view range
  // at least +- baseline sigma
  const double baseError = pmtRec.GetFADCBaselineError(fGain);
  const double baseWidth = max(baseError, 3.);
  double baseMin = bh.GetMinimum();
  double baseMax = bh.GetMaximum();
  double baseMean = 0.5*(baseMin + baseMax);
  double baseDiff  = baseMax - baseMin;
  baseMin -= 0.3*baseDiff;
  baseMax += 0.3*baseDiff;
  baseDiff = baseMax - baseMin;
  if (baseDiff < 3*baseWidth) {
    baseMin = baseMean - 1.5*baseWidth;
    baseMax = baseMean + 1.5*baseWidth;
  }

  // online baseline has to be in the middle
  if (pmt.HasCalibData()) {
    const double onlineBase = pmt.GetCalibData().GetBaseline(fGain);
    if (onlineBase < baseMean)
      baseMin = 2*onlineBase - baseMax;
    else
      baseMax = 2*onlineBase - baseMin;
  }

  // adjust to see sigma boxes for flat pieces
  const PMTRecData::FlatPieceCollection& flat =
    pmtRec.GetBaselineFlatPieces(fGain);
  const int nFlat = flat.size();
  const int sigma = pmtRec.GetFADCBaselineWindow(fGain);
  for (int i = 0; i < nFlat; ++i) {
    const int start = flat[i].first;
    const int y = trace[start];
    const int min = y - sigma - 1;
    if (baseMin > min)
      baseMin = min;
    const int max = y + sigma + 1;
    if (baseMax < max)
      baseMax = max;
  }

  baseMin = floor(baseMin);
  baseMax = ceil(baseMax);

  // final sanity check
  if (baseMin < 0)
    baseMin = 0;
  if (baseMax > (1<<10))
    baseMax = (1<<10);

  th.SetMinimum(baseMin);
  th.SetMaximum(baseMax);
  th.Draw();
  bh.SetTitle("");
  bh.Draw("same");

  // online baseline
  {
    const double x = 40;
    const double y =
      (pmt.HasCalibData() ? pmt.GetCalibData().GetBaseline(fGain) : baseline[int(x)]);
    TGraphErrors& bg = Add(new TGraphErrors(1, &x, &y, 0, &baseError));
    bg.SetMarkerStyle(kCircle);
    bg.SetMarkerSize(2);
    bg.SetLineWidth(2);
    bg.SetLineColor(kGreen);
    bg.Draw("same");
  }

  // flat pieces
  for (int i = 0; i < nFlat; ++i) {
    const int start = flat[i].first;
    const int stop = flat[i].second;
    const int y = trace[start];
    TBox& bb = Add(new TBox(start, y-sigma, stop, y+sigma));
    bb.SetFillStyle(0);
    bb.SetLineColor(8); // dark green
    bb.Draw();
  }

  // gain used
  if (pmtRec.GetGainUsed() == fGain) {
    TPaveText& pt = Add(new TPaveText(0.95,0.77,0.99,0.87, "ndc"));
    pt.SetBorderSize(2);
    pt.SetTextAlign(12);
    pt.SetFillColor(kWhite);
    pt.AddText("Used");
    pt.Draw();
  }

  // sturated bins
  if (pmtRec.GetFADCSaturatedBins(fGain)) {
    TPaveText& pt = Add(new TPaveText(0.94,0.62,0.99,0.74, "ndc"));
    pt.SetBorderSize(2);
    pt.SetTextAlign(12);
    pt.SetFillColor(kCyan);
    pt.AddText((format("N_{sat} = %d ") % pmtRec.GetFADCSaturatedBins(fGain)).str().c_str());
    pt.Draw();
  }

  if (pmt.HasCalibData()) {

    const PMTCalibData& pmtCalib = pmt.GetCalibData();

    // tube not OK
    if (!pmtCalib.IsTubeOk()) {
      TPaveText& pt = Add(new TPaveText(0.69,0.73,0.8,0.87, "ndc"));
      pt.SetBorderSize(2);
      pt.SetTextAlign(12);
      pt.SetFillColor(kRed);
      pt.AddText("Tube not OK");
      pt.Draw();
    }

    // D/A ratio
    if (fGain == sdet::PMTConstants::eLowGain) {
      TPaveText& pt = Add(new TPaveText(0.92,0.90,0.99,1, "ndc"));
      pt.SetBorderSize(2);
      pt.SetTextAlign(12);
      pt.SetFillColor(kWhite);
      pt.AddText((format("D/A = %.2f (%.2f)") % pmtRec.GetGainRatio() % pmtCalib.GetGainRatio()).str().c_str());
      pt.Draw();
    }

  }
}


void
BaselineView::Missing(const string& what)
{
  TPaveText& pt = Add(new TPaveText(0.3,0.4,0.7,0.6, "ndc"));
  pt.SetBorderSize(2);
  pt.SetFillColor(kRed);
  pt.SetTextAlign(12);
  pt.AddText(what.c_str());
  pt.Draw();
}