TQPad.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file    TQPad.cxx
/// \brief   Drawing pad for time or charge histograms
/// \author  messier@indiana.edu
/// \version $Id: TQPad.cxx,v 1.19 2012-03-03 05:42:28 messier Exp $
/////////////////////////////////////////////////////////////////////////
#include "EventDisplay/TQPad.h"

#include <cassert>
#include <algorithm>

#include "TBox.h"
#include "TH1F.h"
#include "TPad.h"

#include "nuevdb/EventDisplayBase/Colors.h"
#include "nuevdb/EventDisplayBase/ColorScale.h"
#include "EventDisplay/RawDataDrawer.h"
#include "EventDisplayServices/RawDrawingOptions.h"
#include "EventDisplay/RecoBaseDrawer.h"
#include "EventDisplay/SimulationDrawer.h"
#include "nuevdb/EventDisplayBase/View2D.h"
#include "nuevdb/EventDisplayBase/EventHolder.h"
#include "RecoBase/CellHit.h"

namespace evd
{
  //................................................................

  static const int kTPAD = 0;
  static const int kQPAD = 1;
  // static const int kRAW   = 0;
  // static const int kCALIB = 1;
  // static const int kPE =  2;
  // static const int kTNS = 3;

  //......................................................................

  TQPad::TQPad(const char* nm, const char* ti,
               double x1, double y1,
               double x2, double y2,
               const char* opt) :
    DrawingPad(nm, ti, x1, y1, x2, y2),
    fHisto(0)
  {
    this->Pad()->cd();
    this->Pad()->SetLogy();

    std::string opts(opt);
    if (opts=="T") fTorQ = kTPAD;
    if (opts=="Q") fTorQ = kQPAD;

    fView = new evdb::View2D();

    this->Pad()->Connect("RangeChanged()", 
                         "evd::TQPad", this, "RangeChanged()");
    
    this->BookHistogram();
  }

  //......................................................................

  TQPad::~TQPad() 
  {
    if (fView)  { delete fView;  fView  = 0; }
    if (fHisto) { delete fHisto; fHisto = 0; }
  }

  //......................................................................
  void TQPad::RangeChanged() 
  {
    art::ServiceHandle<evd::RawDrawingOptions> drawopt;

    static int iloqlast = -1;
    static int ihiqlast = -1;
    static int ilotlast = -1;
    static int ihitlast = -1;
  
    int   ilo = fHisto->GetXaxis()->GetFirst();
    int   ihi = fHisto->GetXaxis()->GetLast();
    double lo = fHisto->GetXaxis()->GetBinLowEdge(ilo);
    double hi = fHisto->GetXaxis()->GetBinUpEdge(ihi);
    
    if (fTorQ==kTPAD) {
      if ((ilo==ilotlast) && (ihi==ihitlast)) return;
      ilotlast = ilo;
      ihitlast = ihi;
      art::ServiceHandle<evdb::Colors> colors;
      switch (drawopt->fWhichHits) {
      case evd::RawDrawingOptions::kRAW_HITS:
        colors->Scale("RawT").SetBounds(lo, hi);
        break;
      case evd::RawDrawingOptions::kCAL_HITS:
        colors->Scale("CawT").SetBounds(lo, hi);
        break;
      default: break;
      }
      
      ilotlast = ilo;
      ihitlast = ihi;
    }

    if (fTorQ == kQPAD) {
      if ((ilo==iloqlast) && (ihi==ihiqlast)) return;
      /** \todo what to do with colors when axis zooms?
      switch (drawopt->fWhichHits) {
      case evd::RawDrawingOptions::kRAW_HITS:
        ColorScaleTable::MakeRawQ(lo, hi);
        break;
      case evd::RawDrawingOptions::kCAL_HITS:
        ColorScaleTable::MakeCalQ(lo, hi);
        break;
      default: break;
      }
      */
      iloqlast = ilo;
      ihiqlast = ihi;
    }
  }

  //......................................................................

  void TQPad::Draw() 
  {
    static const double kHistoFloor      = 0.3;
    static const double kColorScaleLevel = 0.6;

    if (fHisto==0) return;

    art::ServiceHandle<evd::RawDrawingOptions> drawopt;

    if ( !drawopt->fTHistogram && fTorQ == kTPAD ) {
      this->Pad()->Clear();
      return;
    }

    //grab the singleton with the event
    const art::Event* evt = evdb::EventHolder::Instance()->GetEvent();
    if (!evt) return;

    fView-> Clear();
    this->BookHistogram();

    if (drawopt->fWhichHits==evd::RawDrawingOptions::kRAW_HITS) {
      if (fTorQ == kTPAD) {
        this->RawDataDraw()->FillTQHisto(*evt, fHisto, 0);
      }
      if (fTorQ == kQPAD) {
        this->RawDataDraw()->FillTQHisto(*evt, 0, fHisto);
      }
    }

    if (drawopt->fWhichHits==evd::RawDrawingOptions::kCAL_HITS) {
      if (fTorQ == kTPAD) {
        this->RecoBaseDraw()->FillTQHisto(*evt, fHisto, 0);
      }
      if (fTorQ == kQPAD) {
        this->RecoBaseDraw()->FillTQHisto(*evt, 0, fHisto);
      }
    }

    if (drawopt->fTimeAutoZoomTruth && fTorQ == kTPAD){
      double tmin, tmax;
      this->SimulationDraw()->GetTimeLimits(evt, tmin, tmax);
      fHisto->GetXaxis()->SetRangeUser(tmin*1e-3-1, tmax*1e-3+2);
      this->RangeChanged();
    }

    this->Pad()->Clear();
    this->Pad()->cd();
  
    //
    // Play some defense against empty histograms
    //
    double hmax = 0.0;
    for (int i=1; i<=fHisto->GetNbinsX(); ++i) {
      double hc = fHisto->GetBinContent(i);
      if (hc>hmax) hmax = hc;
    }
    if (hmax>kHistoFloor){
      this->Pad()->SetLogy(kTRUE);
      fHisto->SetMinimum(kHistoFloor);
      fHisto->SetMaximum(2.0*hmax);
    }
    else {
      fHisto->SetMinimum(0.0);
      fHisto->SetMaximum(1.0);
      this->Pad()->SetLogy(kFALSE);
    }
    if (fTorQ == kQPAD){
      this->Pad()->SetLogx(kTRUE);
    }
    fHisto->Draw();

    //
    // Use this to fill the histogram with colors from the color scale
    //
    art::ServiceHandle<evdb::Colors> colors;
    for (int i=1; i<=fHisto->GetNbinsX(); ++i) {
      if (i<fHisto->GetXaxis()->GetFirst()) continue;
      if (i>fHisto->GetXaxis()->GetLast())  continue;

      double x1, x2, y1, y2;
      x1 = fHisto->GetBinLowEdge(i);
      x2 = x1 + fHisto->GetBinWidth(i);
      y1 = 0.0;
      y2 = fHisto->GetBinContent(i);
      if (y2==0.0) y2 += kColorScaleLevel;
      if (y2>y1) {
        int c=1;
        if (fTorQ==kTPAD&&drawopt->fColor==evd::RawDrawingOptions::kCOLOR_BY_TIME) {
          if (drawopt->fWhichHits==evd::RawDrawingOptions::kRAW_HITS) {
            c = colors->Scale("RawT").GetColor(0.5*(x1+x2));
          }
          if (drawopt->fWhichHits==evd::RawDrawingOptions::kCAL_HITS) {
            c = colors->Scale("CalT").GetColor(0.5*(x1+x2));
          }
          TBox& b = fView->AddBox(x1,y1,x2,y2);
          b.SetFillStyle(1001);
          b.SetFillColor(c);      
          b.Draw();
        }
        if (fTorQ==kQPAD&&drawopt->fColor==evd::RawDrawingOptions::kCOLOR_BY_CHARGE) {
          if (drawopt->fWhichHits==evd::RawDrawingOptions::kRAW_HITS) {
            c = colors->Scale("RawQ").GetColor(0.5*(x1+x2));
          }
          if (drawopt->fWhichHits==evd::RawDrawingOptions::kCAL_HITS) {
            c = colors->Scale("CalQ").GetColor(0.5*(x1+x2));
          }
          TBox& b = fView->AddBox(x1,y1,x2,y2);
          b.SetFillStyle(1001);
          b.SetFillColor(c);      
          b.Draw();
        }
      }
    }
    fHisto->Draw("same");
  }

  //......................................................................
  
  void TQPad::BookHistogram() 
  {
    if (fHisto) {
      delete fHisto; 
      fHisto = 0;
    }
  
    art::ServiceHandle<evd::RawDrawingOptions> drawopt;
    art::ServiceHandle<evdb::Colors>           colors;
    if (fTorQ==kTPAD&&drawopt->fWhichHits==evd::RawDrawingOptions::kRAW_HITS) {
      float lo = drawopt->fTimeRange[0];
      float hi = drawopt->fTimeRange[1];
      int   n  = std::max(1, int(rint((hi-lo)/drawopt->fTimeBinSize)));
      fHisto = new TH1F("fRAWTHisto",";t (#musec);hits",n,lo,hi);
      colors->Scale("RawT").SetBounds(lo, hi);
    }
    if (fTorQ==kTPAD&&drawopt->fWhichHits==evd::RawDrawingOptions::kCAL_HITS) {
      float lo = drawopt->fTimeRange[0];
      float hi = drawopt->fTimeRange[1];
      int   n  = std::max(1, int(rint((hi-lo)/drawopt->fTimeBinSize)));
      fHisto = new TH1F("fCALTHisto",";t (#musec);hits",n,lo,hi);
      colors->Scale("CalT").SetBounds(lo, hi);
    }
    if (fTorQ==kQPAD&&drawopt->fWhichHits==evd::RawDrawingOptions::kRAW_HITS) {
      float lo = drawopt->fADCRange[0];
      float hi = drawopt->fADCRange[1];
      int   n  = std::max(1, int(rint((hi-lo)/drawopt->fADCBinSize)));
      fHisto = new TH1F("fRAWQHisto",";q (ADC);hits",n,lo,hi);
    }
    if (fTorQ==kQPAD&&drawopt->fWhichHits==evd::RawDrawingOptions::kCAL_HITS) {
      // Even though this histo is filled with PE values, we can still use
      // the values below so that the user can maintain control over how the
      // histo is binned.
      float lo = drawopt->fADCRange[0];
      float hi = drawopt->fADCRange[1];
      int   n  = std::max(1, int(rint((hi-lo)/drawopt->fADCBinSize)));
      fHisto = new TH1F("fCALQHisto",";q (pe);hits",n,lo,hi);
    }
  
    // By this time I must have a histogram booked
    assert(fHisto);
  
    fHisto->SetLabelSize  (0.180,"X");
    fHisto->SetLabelOffset(0.002,"X");
    fHisto->SetTitleSize  (0.200,"X");
    fHisto->SetTitleOffset(0.850,"X");

    fHisto->SetLabelSize  (0.180,"Y");
    fHisto->SetLabelOffset(0.002,"Y");
    fHisto->SetTitleSize  (0.200,"Y");
    fHisto->SetTitleOffset(0.230,"Y");
  }

} // end namespace evd
//////////////////////////////////////////////////////////////////////////