JGraph.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <limits>
 
#include "TROOT.h"
#include "TFile.h"
#include "TGraph.h"
#include "TGraphErrors.h"
 
#include "JGizmo/JGizmoToolkit.hh"
 
#include "Jeep/JeepToolkit.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
 
/**
 * \file
 * Auxiliary program to create TGraph from input file with ASCII data.
 *
 * Supported input file formats:
 * <pre>
 *     x y
 *     x y ey
 *     x y ex ey
 * </pre>
 * or (option -M)
 * <pre>
 *     x y [y [y]]
 * </pre>
 *
 * Lines starting with a '#' are skipped.
 * Optionally, a single header line is interpreted as column names (option -HM).
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
 
  vector<string> inputFile;
  string         outputFile;
  bool           multicolumn;
  bool           header;
  string         title;
  int            debug;
 
  try {
 
    JParser<> zap("Auxiliary program to create TGraph from input file with ASCII data.");
    
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile);
    zap['M'] = make_field(multicolumn);
    zap['H'] = make_field(header);
    zap['T'] = make_field(title)        = "";
    zap['d'] = make_field(debug)        = 1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  using namespace JPP;
 
  TFile out(outputFile.c_str(), "recreate");
 
  
  for (vector<string>::const_iterator file_name = inputFile.begin(); file_name != inputFile.end(); ++file_name) {
 
    const string gname = (title != "" ? title : getFilename(*file_name));
    
    ifstream in(file_name->c_str());
 
    while (in.peek() == '#') {
      in.ignore(numeric_limits<streamsize>::max(), '\n');
    }
    
    vector<string> column;
 
    if (header) {
 
      if (multicolumn) {
 
        string buffer;
 
        if (getline(in,buffer)) {
          
          istringstream is(buffer);
          
          for (string key; is >> key; ) {
            column.push_back(key);
          }
        }
 
      } else {
 
        in.ignore(numeric_limits<streamsize>::max(), '\n');
      }
    }
 
    
    Double_t x, y, ex, ey;
 
    if (!multicolumn) {      
 
      vector<Double_t> X;
      vector<Double_t> Y;
      vector<Double_t> EX;
      vector<Double_t> EY;
      
      for (string buffer; getline(in,buffer); ) {
 
        istringstream is(buffer);
 
        if (is >> x)  X .push_back(x);
        if (is >> y)  Y .push_back(y);
        if (is >> ex) EX.push_back(ex);
        if (is >> ey) EY.push_back(ey);
      }
 
      if (X.size() != Y.size()) {
        FATAL("Number of points " << X.size() <<  ' ' << Y.size() << endl);
      }
 
 
      TGraph* graph = NULL;
 
      if (EX.empty()) {
 
        graph = new TGraph(X.size(), X.data(), Y.data());
 
      } else {
 
        if (X.size() != EX.size()) {
          FATAL("Number of x points " << X.size() <<  ' ' << EX.size() << endl);
        }
 
        if (EY.empty()) {
          EY.swap(EX);
          EX.resize(X.size(), 0.0);
        }
 
        if (Y.size() != EY.size()) {
          FATAL("Number of y points " << Y.size() <<  ' ' << EY.size() << endl);
        }
      
        graph = new TGraphErrors(X.size(), X.data(), Y.data(), EX.data(), EY.data());
      }
 
      if (graph != NULL) {
 
        graph->SetName(gname.c_str());
        
        setLimits(*graph);
 
        DEBUG("TGraph " << graph->GetName() << endl);
        
        graph->Write();
      }
 
    } else {   // multicolumn option
 
      vector< Double_t >         X;
      vector< vector<Double_t> > Y;
 
      for (string buffer; getline(in,buffer); ) {
 
        istringstream is(buffer);
 
        if (is >> x) {
 
          X.push_back(x);
          
          size_t i = 0;
          
          for ( ; is >> y; ++i) { 
            
            if (i == Y.size()) {
              Y.resize(i+1);
            }
            
            Y[i].push_back(y);
          }
        
          if (i+1 != column.size()) {
            FATAL("Number of colums " << i+1 <<  ' ' << column.size() << endl);
          }
        }
      }
 
      for (size_t i = 0; i != Y.size(); ++i) {  
 
        TGraph* graph = new TGraph(X.size(), X.data(), Y[i].data());
 
        ostringstream os;
 
        os << gname << "[" << column[i+1] << "]";
        
        graph->SetName(os.str().c_str());
 
        setLimits(*graph);
        
        DEBUG("TGraph " << graph->GetName() << endl);
        
        graph->Write();
      }
    }
 
    in.close();
  }
 
  out.Write();
  out.Close();
}