PlotView.cxx

Go to the documentation of this file.

/// \file    PlotView.cxx
/// \brief   Display a collection of plots for this event
/// \author  messier@indiana.edu
/// \version $Id: PlotView.cxx,v 1.5 2012-02-22 01:41:58 bckhouse Exp $
///
#include "EventDisplay/PlotView.h"
#include <iostream>
#include <string>
#include <vector>
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "nuevdb/EventDisplayBase/EventHolder.h"
#include "EventDisplayServices/PlotDrawingOptions.h"

//
// Split up a string based on tokens.
//
static void tokenize(const std::string&        str,
                     std::vector<std::string>& tokens,
                     const std::string&        delimiters) 
{
  std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
  std::string::size_type pos     = str.find_first_of(delimiters, lastPos);

  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(str.substr(lastPos, pos-lastPos));
    lastPos = str.find_first_not_of(delimiters, pos);
    pos = str.find_first_of(delimiters, lastPos);
  }
}

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

static TObject* find_by_name(const std::string&                        n,
                             art::Handle< std::vector<TH1F> >&         th1f,
                             art::Handle< std::vector<TH2F> >&         th2f,
                             art::Handle< std::vector<TH1D> >&         th1d,
                             art::Handle< std::vector<TH2D> >&         th2d,
                             art::Handle< std::vector<TProfile> >&     tprofile,
                             art::Handle< std::vector<TGraph> >&       tgraph,
                             art::Handle< std::vector<TGraphErrors> >& tgrapherrors) 
{
  unsigned int i;
#define CHECK(V) \
  { if (V.failedToGet()==false) {\
      for (i=0; i<V->size(); ++i) {\
        if (n==(*V)[i].GetName()) return (TObject*)&(*V)[i];\
      }\
    }\
  }
  CHECK(th1f);
  CHECK(th2f);
  CHECK(th1d);
  CHECK(th2d);
  CHECK(tprofile);
  CHECK(tgraph);
  CHECK(tgrapherrors);
#undef CHECK
  return 0;
}

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

namespace evd
{
  //...................................................................
  
  PlotView::PlotView(TGMainFrame* mf) : evdb::Canvas(mf) { }

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

  PlotView::~PlotView() { }
  
  //......................................................................
  
  ///
  /// Parse out the configuration strings into a collection of
  /// modules, plots, and drawing options
  ///
  void PlotView::Parse(std::vector<PlotPad>& pads)
  {
    art::ServiceHandle<evd::PlotDrawingOptions> plot;

    unsigned int i, j;
    
    std::string str;
    for (i=0; i<plot->fPadDescription.size(); ++i) {
      PlotPad pad;
      
      // Remove white space
      str = plot->fPadDescription[i];
      if (str.find(" ")!=std::string::npos) {
        str.erase(remove_if(str.begin(), str.end(), isspace));
      }

      // Split into plots separated by "+"'s
      std::vector<std::string> plots;
      tokenize(str, plots, "+");
      for (j=0; j<plots.size(); ++j) {
        Plot plot;

        // module, object and plot options are separted by "/"
        std::vector<std::string> fields;
        tokenize(plots[j], fields, "/");
        
        // Get the module, object and plot options

        if (fields.size()>0) plot.fModule = fields[0];
        if (fields.size()>1) plot.fObject = fields[1];
        if (fields.size()>2) {
          tokenize(fields[2], plot.fOptions, ",");
        }
        pad.fPlot.push_back(plot);
      }
      pads.push_back(pad);
    }
  }
  
  //......................................................................

  void PlotView::Draw(const char* opt) 
  {
    evdb::Canvas::fCanvas->Clear();
    const art::Event* evt = evdb::EventHolder::Instance()->GetEvent();
    if (evt==0) return;

    evdb::Canvas::fCanvas->cd();

    // Get the pad descriptions
    std::vector<PlotPad> pads;
    this->Parse(pads);
    
    // Lay out the main canvas to hold the pads
    unsigned int nx=1, ny=1;
    while (nx*ny < pads.size()) {
      if (nx-ny<2) ++nx;
      else        { --nx; ++ny;}
    }
    evdb::Canvas::fCanvas->Divide(nx,ny);
    
    //
    // Loop over the pads and draw the plots
    //
    unsigned int i, j, k;
    for (i=0; i<pads.size(); ++i) {
      evdb::Canvas::fCanvas->cd(i+1);
      // nuevdb/EventDisplayBase/RootEnv.cxx sets some huge margins on gStyle. Just
      // reset our pad to some more sensible margins here.
      gPad->SetBottomMargin(.1);
      gPad->SetLeftMargin(.1);
      gPad->SetTopMargin(.05);
      gPad->SetRightMargin(.05);

      const PlotPad& pad = pads[i];
      for (j=0; j<pad.fPlot.size(); ++j) {
        const Plot& plot = pad.fPlot[j];

        // Find the plot object we've been requested to plot...
        TObject* obj=0;
        art::Handle< std::vector<TH1F> >         th1f;
        art::Handle< std::vector<TH2F> >         th2f;
        art::Handle< std::vector<TH1D> >         th1d;
        art::Handle< std::vector<TH2D> >         th2d;
        art::Handle< std::vector<TProfile> >     tprofile;
        art::Handle< std::vector<TGraph> >       tgraph;
        art::Handle< std::vector<TGraphErrors> > tgrapherrors;
        
        evt->getByLabel(plot.fModule, th1f);
        evt->getByLabel(plot.fModule, th2f);
        evt->getByLabel(plot.fModule, th1d);
        evt->getByLabel(plot.fModule, th2d);
        evt->getByLabel(plot.fModule, tprofile);
        evt->getByLabel(plot.fModule, tgraph);
        evt->getByLabel(plot.fModule, tgrapherrors);

        obj = find_by_name(plot.fObject,
                           th1f,
                           th2f,
                           th1d,
                           th2d,
                           tprofile,
                           tgraph,
                           tgrapherrors);
        if (obj==0) {
          std::cerr << "find_by_name failed to find " 
                    << plot.fModule << "/" << plot.fObject 
                    << " in event." << std::endl;
          continue;
        }
        
        TAttLine*   l = dynamic_cast<TAttLine*>(obj);
        TAttMarker* m = dynamic_cast<TAttMarker*>(obj);

        // Tease out the plotting options
        std::string options;
        if (j>0) options += "same";
        for (k=0; k<plot.fOptions.size(); ++k) {
          const std::string& opt = plot.fOptions[k];
          
          bool r = false;
          if (opt=="logx")  { gPad->SetLogx();  r=true; }
          if (opt=="logy")  { gPad->SetLogy();  r=true; }
          if (opt=="logz")  { gPad->SetLogz();  r=true; }
          if (opt=="gridx") { gPad->SetGridx(); r=true; }
          if (opt=="gridy") { gPad->SetGridy(); r=true; }
          if (r==false && opt.find("=")!=std::string::npos) {
            std::vector<std::string> kv;
            tokenize(opt, kv, "=");
            if (kv.size()!=2) abort();
            if (kv[0]=="lstyle") { if (l) l->SetLineStyle(atoi(kv[1].c_str()));   r=true; }
            if (kv[0]=="lwidth") { if (l) l->SetLineWidth(atoi(kv[1].c_str()));   r=true; }
            if (kv[0]=="lcolor") { if (l) l->SetLineColor(atoi(kv[1].c_str()));   r=true; }
            if (kv[0]=="mstyle") { if (m) m->SetMarkerStyle(atoi(kv[1].c_str())); r=true; }
            if (kv[0]=="msize")  { if (m) m->SetMarkerSize(atof(kv[1].c_str()));  r=true; }
            if (kv[0]=="mcolor") { if (m) m->SetMarkerColor(atoi(kv[1].c_str())); r=true; }
          }
          if (r==false) { options += ","; options += opt; }
        } // Loop on options k
        obj->Draw(options.c_str());
      } // Loop on plots j
    } // Loop on pads i
    evdb::Canvas::fCanvas->Update();
  }

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