JPlot1D.cc File Reference

General purpose plot program for 1D ROOT objects. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <cmath>
#include "TROOT.h"
#include "TFile.h"
#include "TClass.h"
#include "TApplication.h"
#include "TCanvas.h"
#include "TKey.h"
#include "TStyle.h"
#include "TAttMarker.h"
#include "TAttLine.h"
#include "TH1.h"
#include "TH2.h"
#include "TF1.h"
#include "THStack.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TMultiGraph.h"
#include "TProfile.h"
#include "TLegend.h"
#include "TString.h"
#include "TRegexp.h"
#include "TText.h"
#include "JTools/JRange.hh"
#include "JLang/JSinglePointer.hh"
#include "JGizmo/JStyle.hh"
#include "JGizmo/JCanvas.hh"
#include "JGizmo/JMarkerAttributes.hh"
#include "JGizmo/JLineAttributes.hh"
#include "JGizmo/JLegend.hh"
#include "JGizmo/JRootObjectID.hh"
#include "JGizmo/JRootObject.hh"
#include "JGizmo/JGizmoToolkit.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

General purpose plot program for 1D ROOT objects.

The option -f corresponds to <file name>:<object name>.

Author

mdejong

Definition in file JPlot1D.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 58 of file JPlot1D.cc.

{
  using namespace std;
  using namespace JPP;

  typedef JRange<double>  JRange_t;

  vector<JRootObjectID>   inputFile;
  string                  outputFile;
  JCanvas                 canvas;
  int                     stats;
  string                  legend;
  JRange_t                X;
  JRange_t                Y;
  JRange_t                Z;
  JCounter                logx;
  bool                    logy;
  bool                    logz;
  char                    project;
  string                  xLabel;
  string                  yLabel;
  JCounter                drawLine;
  bool                    fillArea;
  int                     lineWidth;
  double                  markerSize;
  string                  option;
  set<char>               grid;
  bool                    batch;
  string                  title;
  pair<string, int>       Ndivisions;
  int                     group;
  int                     debug;
  string                  xTimeFormat;
 
  try {

    JParser<> zap("General purpose plot program for 1D ROOT objects.");
    
    zap['f'] = make_field(inputFile,  "<input file>:<object name>");
    zap['o'] = make_field(outputFile, "graphics output")                    = "";
    zap['w'] = make_field(canvas,     "size of canvas <nx>x<ny> [pixels]")  = JCanvas(500, 500);
    zap['s'] = make_field(stats)                                            = -1;
    zap['L'] = make_field(legend,     "position legend e.g. TR")            = "";
    zap['x'] = make_field(X,          "abscissa range")                     = JRange_t();
    zap['y'] = make_field(Y,          "ordinate range")                     = JRange_t();
    zap['z'] = make_field(Z,          "ordinate range of projection)")      = JRange_t();
    zap['X'] = make_field(logx,       "logarithmic x-axis (-XX log10 axis)");
    zap['Y'] = make_field(logy,       "logarithmic y-axis");
    zap['Z'] = make_field(logz,       "logarithmic y-axis; after projection");
    zap['P'] = make_field(project,    "projection")                         = '\0', 'x', 'X', 'y', 'Y';
    zap['>'] = make_field(xLabel,     "x-axis label")                       = "";
    zap['^'] = make_field(yLabel,     "y-axis label")                       = "";
    zap['C'] = make_field(drawLine);
    zap['F'] = make_field(fillArea);
    zap['l'] = make_field(lineWidth,  "line width")                         = 2;
    zap['S'] = make_field(markerSize, "marker size")                        = 1.0;
    zap['O'] = make_field(option,     "plotting option")                    = "";
    zap['G'] = make_field(grid,       "grid lines [X][Y]")                  = JPARSER::initialised();
    zap['B'] = make_field(batch,      "batch processing");
    zap['T'] = make_field(title,      "title")                              = "KM3NeT preliminary";
    zap['N'] = make_field(Ndivisions, "axis divisioning (e.g. \"X 505\")")  = JPARSER::initialised();
    zap['g'] = make_field(group,      "group colour codes of objects")      = 1;
    zap['t'] = make_field(xTimeFormat, "set time format for x-axis, e.g. \%d\\/\%m\\/\\%y%F1970-01-01 00:00:00") = "";
    zap['d'] = make_field(debug)      = 0;
     
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  gROOT->SetBatch(batch);

  TApplication* tp = new TApplication("user", NULL, NULL);
  TCanvas*      cv = new TCanvas("c1", "c1", canvas.x, canvas.y);

  JSinglePointer<TStyle> gStyle(new JStyle("gplot", cv->GetWw(), cv->GetWh()));

  gROOT->SetStyle("gplot");
  gROOT->ForceStyle();


  cv->SetFillStyle(4000);
  cv->SetFillColor(kWhite);
  cv->Divide(1,1);
  cv->cd(1);
    

  JMarkerAttributes::getInstance().setMarkerSize(markerSize);
  JLineAttributes  ::getInstance().setLineWidth (lineWidth);


  Double_t xmin = +numeric_limits<double>::max();
  Double_t xmax = -numeric_limits<double>::max();

  Double_t ymin = +numeric_limits<double>::max();
  Double_t ymax = -numeric_limits<double>::max();


  vector<JRootObject> listOfObjects;

  const bool px = (project == 'x' || project == 'X');  // projection on x-axis
  const bool py = (project == 'y' || project == 'Y');  // projection on y-axis

  logy = (logy || logz);

  if (px) {
    swap(Y, Z);   // Y becomes range in TH2::ProjectionX() and Z becomes y-axis range
  }

  if (py) {
    swap(X, Z);   // X becomes range in TH2::ProjectionY()
    swap(Y, X);   // Y becomes x-axis range and Z becomes y-axis range
  }

  TH1* master = NULL;
  
  for (vector<JRootObjectID>::const_iterator input = inputFile.begin(); input != inputFile.end(); ++input) {

    DEBUG("Input: " << *input << endl);

    TDirectory* dir = getDirectory(*input);

    if (dir == NULL) {
      ERROR("File: " << input->getFullFilename() << " not opened." << endl);
      continue;
    }

    const TRegexp regexp(input->getObjectName());

    TIter iter(dir->GetListOfKeys());

    for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {

      const TString tag(key->GetName());

      DEBUG("Key: " << tag << " match = " << tag.Contains(regexp) << endl);
        
      // option match

      if (tag.Contains(regexp)) {

        if        (title == JName_t) {
          title = key->GetName();
        } else if (title == JTitle_t) {
          title = key->GetTitle();
        }

        JRootObject object(key->ReadObj());

        TAttMarker marker = JMarkerAttributes::getInstance().get(0);
        TAttLine   line   = JLineAttributes  ::getInstance().get(0);

        if (group > 1)
          marker.SetMarkerColor(JMarkerAttributes::getInstance().get(listOfObjects.size()/group).GetMarkerColor());
        else
          marker = JMarkerAttributes::getInstance().get(listOfObjects.size());

        if (drawLine == 1)
          line = JLineAttributes::getInstance().get(listOfObjects.size());
        else
          line.SetLineColor(marker.GetMarkerColor());

        try {

          TProfile& h1 = dynamic_cast<TProfile&>(*object);

          object = h1.ProjectionX();
        }
        catch(exception&) {}

        try {
            
          TH2& h2 = dynamic_cast<TH2&>(*object);

          if        (px) {

            if (Z != JRange_t())
              object = h2.ProjectionX(MAKE_CSTRING(h2.GetName() << "_px" << LABEL_TERMINATOR << listOfObjects.size()), 
                                      h2.GetYaxis()->FindBin(Z.getLowerLimit()),
                                      h2.GetYaxis()->FindBin(Z.getUpperLimit()) - 1);
            else
              object = h2.ProjectionX(MAKE_CSTRING(h2.GetName() << "_px" << LABEL_TERMINATOR << listOfObjects.size()), 
                                      1,
                                      h2.GetYaxis()->GetNbins());

          } else if (py) {
            
            if (Z != JRange_t())
              object = h2.ProjectionY(MAKE_CSTRING(h2.GetName() << "_py" << LABEL_TERMINATOR << listOfObjects.size()), 
                                      h2.GetXaxis()->FindBin(Z.getLowerLimit()),
                                      h2.GetXaxis()->FindBin(Z.getUpperLimit()) - 1);
            else
              object = h2.ProjectionY(MAKE_CSTRING(h2.GetName() << "_py" << LABEL_TERMINATOR << listOfObjects.size()), 
                                      1,
                                      h2.GetXaxis()->GetNbins());

          } else {

            ERROR("For 2D histograms, use option option -P for projections or use JPlot2D" << endl);

            continue;
          }
        }           
        catch(exception&) {}

        try { 

          dynamic_cast<TAttMarker&>(*object) = marker; 
        } 
        catch(exception&) {}

        try { 

          dynamic_cast<TAttLine&>  (*object) = line; 
        }
        catch(exception&) {}

        try {

          TH1& h1 = dynamic_cast<TH1&>(*object);

          h1.SetStats(stats != -1);
            
          xmin = min(xmin, h1.GetXaxis()->GetXmin());
          xmax = max(xmax, h1.GetXaxis()->GetXmax());
            
          ymin = min(ymin, logy ? h1.GetMinimum(0.0) : h1.GetMinimum());
          ymax = max(ymax, h1.GetMaximum());

          if (drawLine) {             
            for (int i = 1; i <= h1.GetNbinsX(); ++i) {
              h1.SetBinError(i, 0.0);
            }
          }
        }
        catch(exception&) {}

        if (fillArea) {

          try { 
            
            TAttFill& fill = dynamic_cast<TAttFill&>(*object);
              
            fill.SetFillColor(marker.GetMarkerColor()); 
          } 
          catch(exception&) {}
        }

        try {

          TGraph& g1 = dynamic_cast<TGraph&>(*object);

          for (Int_t i = 0; i != g1.GetN(); ++i) {

            xmin = min(xmin, g1.GetX()[i]);
            xmax = max(xmax, g1.GetX()[i]);
            
            if (!logy || g1.GetY()[i] > 0.0) {
              ymin = min(ymin, g1.GetY()[i]);
              ymax = max(ymax, g1.GetY()[i]);
            }
          }
        }
        catch(exception&) {}

        try {

          TGraphErrors& g1 = dynamic_cast<TGraphErrors&>(*object);

          if (drawLine) {
            for (Int_t i = 0; i != g1.GetN(); ++i) {
              g1.GetEX()[i] = 0.0;
              g1.GetEY()[i] = 0.0;
            }
          }
        }
        catch(exception&) {}

        try {

          TMultiGraph& mg = dynamic_cast<TMultiGraph&>(*object);

          TIter next(mg.GetListOfGraphs());

          while (TGraph* g1 = dynamic_cast<TGraph*>(next())) {
            
            for (Int_t j = 0; j != g1->GetN(); ++j) {
              
              xmin = min(xmin, g1->GetX()[j]);
              xmax = max(xmax, g1->GetX()[j]);
              
              if (!logy || g1->GetY()[j] > 0.0) {
                ymin = min(ymin, g1->GetY()[j]);
                ymax = max(ymax, g1->GetY()[j]);
              }
            }
          }
        }
        catch(exception&) {}

        try {

          TF1& f1 = dynamic_cast<TF1&>(*object);

          if (xmin != +numeric_limits<double>::max()  &&
              xmax != -numeric_limits<double>::max()) {
            ymin = min(ymin, f1.GetMinimum(xmin, xmax));
            ymax = max(ymax, f1.GetMaximum(xmin, xmax));
          }
        }
        catch(exception&) {}


        try {
            
          THStack& hs = dynamic_cast<THStack&>(*object);

          NOTICE("THStack" << endl);

          TIterator* iterator = hs.GetHists()->MakeIterator();

          for (size_t index = 1; TObject* i = iterator->Next(); ++index) {
              
            TH1& h1 = dynamic_cast<TH1&>(*i);

            NOTICE("TH1[" << index << "] " << h1.GetName() << endl);

            xmin = min(xmin, h1.GetXaxis()->GetXmin());
            xmax = max(xmax, h1.GetXaxis()->GetXmax());
            
            ymin = min(ymin, logy ? h1.GetMinimum(0.0) : h1.GetMinimum());
            ymax = max(ymax, h1.GetMaximum());

            h1.SetLineWidth(1);
            h1.SetLineColor(kBlack);

            h1.SetFillColor(JMarkerAttributes::getInstance().get(index).GetMarkerColor());
          }
        }
        catch(exception&) {}

        for (TString buffer[] = { object.getLabel(), input->getFilename().c_str(), "" }, *i = buffer; *i != ""; ++i) {

          *i = (*i)(TRegexp("\\[.*\\]"));
            
          DEBUG("Label: <" << *i << ">" << endl); 

          if (i->Length() > 2) {
            object.setLabel((*i)(1, i->Length() - 2));
          }
        }

        DEBUG("Add object: " << tag << " with label " << object.getLabel() << endl);

        if (master == NULL) {
          master = dynamic_cast<TH1*>(object.get());
        }

        listOfObjects.push_back(object);
      }
    }
  }

  if (listOfObjects.empty()) {
    ERROR("Nothing to draw." << endl);
  }

  for (vector<JRootObject>::iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {

    TH1*         h1 = dynamic_cast<TH1*>        (i->get());
    TGraph*      g1 = dynamic_cast<TGraph*>     (i->get());
    TMultiGraph* mg = dynamic_cast<TMultiGraph*>(i->get());
    TAttLine*    ls = dynamic_cast<TAttLine*>   (i->get());

    TList      list;
    TIterator* iterator = NULL;

    if      (h1 != NULL)
      iterator = h1->GetListOfFunctions()->MakeIterator();
    else if (g1 != NULL)
      iterator = g1->GetListOfFunctions()->MakeIterator();
    else if (mg != NULL) {

      TIter next1(mg->GetListOfGraphs());

      while (TGraph* gi = dynamic_cast<TGraph*>(next1())) {

        TIter next2(gi->GetListOfFunctions());

        while (TF1 *fi = dynamic_cast<TF1*>(next2())) {
          list.Add(fi);
        }
      }

      iterator = list.MakeIterator();
      
    } else  
      continue;

    Double_t x1 = +numeric_limits<Double_t>::max();
    Double_t x2 = -numeric_limits<Double_t>::max();

    for (int ns = 0, nc = 1; TF1* f1 = (TF1*) iterator->Next(); ) {

      Double_t __x1;
      Double_t __x2;

      f1->GetRange(__x1, __x2);
      f1->SetNpx(1000);

      dynamic_cast<TAttLine&>(*f1) = JLineAttributes::getInstance().get(0);

      if (listOfObjects.size() == 1) {

        f1->SetLineStyle(JLineAttributes::getInstance().get(ns).GetLineStyle());

        if (x1 != +numeric_limits<Double_t>::max() &&
            x2 != -numeric_limits<Double_t>::max()) {

          if (x1 == __x1 && 
              x2 == __x2)
            ++nc;    // follow colour style
          else
            ++ns;    // follow line   style
        }

        f1->SetLineColor(JMarkerAttributes::getInstance().get(nc).GetMarkerColor());

      } else {

        // keep colour of base object and accordingly modify line style.

        f1->SetLineColor(ls->GetLineColor());
        f1->SetLineStyle(JLineAttributes::getInstance().get(ns++).GetLineStyle());
      }

      ymin = min(ymin, f1->GetMinimum(xmin, xmax));
      ymax = max(ymax, f1->GetMaximum(xmin, xmax));

      x1 = __x1;
      x2 = __x2;
    }
  }


  // plot frame

  if (X != JRange_t()) { 
    xmin = X.getLowerLimit();
    xmax = X.getUpperLimit();
  }

  if (Y != JRange_t()) {
    ymin = Y.getLowerLimit();
    ymax = Y.getUpperLimit();
  } else {
    setRange(ymin, ymax, logy);
  }

  cv->cd(1);

  if (master == NULL) {

    if        (X != JRange_t()) {
 
      master = new TH1D("__H__", NULL, 100, X.getLowerLimit(), X.getUpperLimit());

      master->SetStats(kFALSE);

    } else if (xmin < xmax) {
 
      master = new TH1D("__H__", NULL, 100, xmin, xmax);

      master->SetStats(kFALSE);

    } else {

      TText* p = new TText(0.5, 0.5, MAKE_CSTRING("No data"));

      p->SetTextAlign(21);
      p->SetTextAngle(45);
      p->Draw();
    }
  }

  if (master != NULL) {

    if (logx) { gPad->SetLogx(); }
    if (logy) { gPad->SetLogy(); }

    master->GetXaxis()->SetRangeUser(xmin, xmax);

    if (logx > 1) {
      setLogarithm(master->GetXaxis());
    }

    master->SetTitle(title.c_str());

    master->SetMinimum(ymin);
    master->SetMaximum(ymax);
    
    if (xLabel != "") { master->GetXaxis()->SetTitle(xLabel.c_str()); master->GetXaxis()->CenterTitle(true); }
    if (yLabel != "") { master->GetYaxis()->SetTitle(yLabel.c_str()); master->GetYaxis()->CenterTitle(true); }
    
    master->GetXaxis()->SetMoreLogLabels((logx == 1 && log10(xmax/xmin) < 2) ||
                                         (logx >  1 &&       xmax-xmin  < 2));
    
    master->GetYaxis()->SetMoreLogLabels( logy      && log10(ymax/ymin) < 2);
    master->GetYaxis()->SetNoExponent   ( logy      && log10(ymax/ymin) < 2);
    
    if (Ndivisions.first != "") {
      master->SetNdivisions(Ndivisions.second, Ndivisions.first.c_str());
    }

    if (xTimeFormat != "") {
      master->GetXaxis()->SetTimeDisplay(1);
      master->GetXaxis()->SetTimeFormat(xTimeFormat.c_str());
    }

    master->Draw(option.c_str());
  }

  if (logx > 1) {

    for (vector<JRootObject>::iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {

      TH1* h1 = dynamic_cast<TH1*>(i->get());

      if (h1 != NULL) {

        if (logx > 0 && h1 != master) {
          setLogarithm(h1->GetXaxis());
        }

        TIter iter(h1->GetListOfFunctions());

        const TRegexp key("x[^a-zA-Z]");     // replace parameter x by log10(x)
        const TString rep("log10(x)");       //

        for (TF1* f1; (f1 = (TF1*) iter.Next()) != NULL; ) {
          
          TString formula(f1->GetExpFormula());
          
          for (Ssiz_t pos = 0; (pos = formula.Index(key, pos)) != -1; pos += rep.Length()) {
            formula.Replace(pos, 1, rep);
          };

          TF1 f2(f1->GetName(), formula);

          f2.SetParameters(f1->GetParameters());
          f2.SetRange(f1->GetXmin(), f1->GetXmax());
          
          static_cast<TAttLine&>(f2) = *f1;

          *f1 = f2;

          if (f1->GetXmin() != 0.0 && f1->GetXmax() != 1.0)
            f1->SetRange(pow(10.0,f1->GetXmin()), pow(10.0,f1->GetXmax()));
          else
            f1->SetRange(pow(10.0,xmin), pow(10.0,xmax));           
        }
      }
    }
  }

  if (grid.count('x') || grid.count('X')) { gPad->SetGridx(); }
  if (grid.count('y') || grid.count('Y')) { gPad->SetGridy(); }

  if (stats != -1)
    gStyle->SetOptStat(stats);
  else  
    gStyle->SetOptFit(kFALSE);


  for (vector<JRootObject>::const_iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {

    DEBUG("Draw " << (*i)->GetName() << ' ' << (*i)->GetTitle() << endl);

    string buffer(option);

    //if (!dynamic_cast<THStack*>(i->get())) {
    //  buffer += "SAMES";
    //}

    buffer += "SAME";

    TGraph*      p1 = dynamic_cast<TGraph*>     (i->get());
    TMultiGraph* q1 = dynamic_cast<TMultiGraph*>(i->get());

    if        (p1 != NULL) {

      if (p1->GetN() > 1 && drawLine)
        buffer += "L";       // drawing cut
      else
        buffer += "P";       // drawing point(s)

      p1->Draw(buffer.c_str());

    } else if (q1 != NULL) {
      
      TIter next(q1->GetListOfGraphs());

      while (TGraph* gi = dynamic_cast<TGraph*>(next())) {

        if (gi->GetN() > 1 && drawLine)
          buffer += "L";       // drawing cut
        else
          buffer += "P";       // drawing point(s)

        gi->Draw(buffer.c_str());
      }
      
    } else {
      
      (*i).Draw(buffer.c_str());
    }
  }

  //gPad->RedrawAxis();

  if (legend != "") {

    Ssiz_t height = listOfObjects.size();
    Ssiz_t width  = 1;
    
    for (vector<JRootObject>::const_iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {
      width = max(width, i->getLabel().Length());
    }

    TLegend* lg = getLegend(width, height, legend);

    for (vector<JRootObject>::const_iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {
      lg->AddEntry(*i, " " + i->getLabel(), isTAttLine(*i) ? "L" : "LPF"); 
    }

    lg->Draw();
  }

  cv->Update();

  if (outputFile != "") {
    cv->SaveAs(outputFile.c_str());
  }

  if (!batch) {
    tp->Run();
  }
}