gnuplotWriter.hh

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2016 Fabian Klemens
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef GNUPLOT_WRITER_HH
#define GNUPLOT_WRITER_HH
 
#include <fstream>
#include <iostream>
#include <unistd.h>
#include "core/singleton.h"
#include "io/fileName.h"
#include "gnuplotWriter.h"
#include "utilities/vectorHelpers.h"
 
namespace olb {
template< typename T >
Gnuplot<T>::Gnuplot(std::string name, bool liveplot, std::string preCommand, AxisType axisType, Regression regressionType)
  : _name(name),
    _liveplot(liveplot),
    _dataFile(singleton::directories().getGnuplotOutDir()+"data/"+_name+".dat"),
    _dir(singleton::directories().getGnuplotOutDir()),
    _preCommand(preCommand),
    _axisType(axisType),
    _regressionType(regressionType),
    csvWriter(name)
{
#ifndef WIN32
  _gnuplotInstalled = (! system("which gnuplot >/dev/null 2>/dev/null"));
#endif
  if ((! _gnuplotInstalled) && (singleton::mpi().getRank() == _rank )) {
    std::cout << "We could not find a gnuplot distribution at your system." << std::endl;
    std::cout << "We still write the data files s.t. you can plot the data yourself." << std::endl;
  }
}
 
template <typename T>
Gnuplot<T>::Gnuplot(std::string name) : Gnuplot(name, false, "", LINEAR, OFF) {}
 
template< typename T >
Gnuplot<T>::Gnuplot(std::string name, bool liveplot) : Gnuplot(name, liveplot,"", LINEAR, OFF) {}
 
template <typename T>
Gnuplot<T>::Gnuplot(std::string name, AxisType axisType) : Gnuplot(name, false, "", axisType, OFF) {}
 
template< typename T >
Gnuplot<T>::Gnuplot(std::string name, AxisType axisType, Regression regressionType) : Gnuplot(name, false,"", axisType, regressionType) {}
 
 
template< typename T >
void Gnuplot<T>::setData(T xValue, T yValue, std::string name, std::string key, char plotType)
{
  setData(xValue, std::vector<T>{yValue}, std::vector<std::string>{name}, key, std::vector<char>{plotType});
}
 
template< typename T >
void Gnuplot<T>::setData(bool noXvalue, T yValue, std::string name, std::string key, char plotType)
{
  T xValue = _time;
  setData(xValue, yValue, name, key, std::vector<char>{plotType});
  _time++;
}
 
template< typename T >
void Gnuplot<T>::setData(T xValue, std::vector<T> yValues, std::vector<std::string> names, std::string key, std::vector<char> plotType)
{
  if (_init) {
    _dataSize = yValues.size();
    _key = key;
    _names = names;
    _plotTypes = plotType;
    if (_names.size() < _dataSize) {
      for (unsigned int i = _names.size(); i < _dataSize; i++) {
        _names.push_back("");
      }
    }
    if (_plotTypes.size() < _dataSize) {
      for (unsigned int i = _plotTypes.size(); i < _dataSize; i++) {
        _plotTypes.push_back('l');
      }
    }
    if (_gnuplotInstalled && _liveplot) {
      writePlotFile("plot");
    }
  }
  csvWriter.writeDataFile(xValue,yValues);
 
  if (_gnuplotInstalled && _liveplot && _init) {
    startGnuplot("plot");
  }
 
  _init = false;
  return;
}
 
template<typename T>
void Gnuplot<T>::linRegression(std::ofstream& fout, std::string xAxisType, std::string yAxisType)
{
  fout << "set fit quiet\n";
 
  for (unsigned int i = 0; i < _dataSize; ++i) {
    fout << "f" << i+1 << "(x) = m" << i+1 << " * x + b"<< i+1 << "\n"; //Match f2 to the dataset 1:3 with f2(x) = m2 * x + b2 and so on
    fout << "fit f" << i+1 << "(x) path using ("<< xAxisType << "$1)):(" << yAxisType << "$" << i+2 << ")) via m" << i+1 << ", b" << i+1 <<"\n";
  }
  fout << "\n";
 
  fout << "plot ";
  for (unsigned int i = 0; i < _dataSize; ++i) {
    fout << "f"<< i+1 <<"(x) title sprintf('regr " << _names[i] << ", gradient = %.3f', m" << i+1 << ") lc " << i+1 << " axis x1y1,";
  }
 
  return;
}
 
template<typename T>
void Gnuplot<T>::scaleAxes(std::ofstream& fout)
{
  switch (_axisType)
  {
    case (LOGLOG): 
    case(LOGLOGINVERTED):
    {
      fout << "set xtics nomirror" << "\n";
      fout << "set ytics nomirror" << "\n";
 
      fout << "set format y '10^{%.2f}'" << "\n"; 
      fout << "set format x '10^{%.2f}'" << "\n"; 
    } break;
 
    case LINEAR:
    default:
    {} break;
  }
 
  fout << "\n";
  return;
}
 
 
template< typename T >
void Gnuplot<T>::setData(bool noXvalue, std::vector<T> yValues, std::vector<std::string> names, std::string key, std::vector<char> plotType)
{
  T xValue = _time;
  setData(xValue, yValues, names, key, plotType);
  _time++;
}
 
 
template< typename T >
void Gnuplot<T>::writePDF(std::string plotName)
{
  if (_gnuplotInstalled && (!_init)) {
    writePlotFile("pdf", plotName);
    startGnuplot("plotPDF", plotName);
  }
  return;
}
 
 
template< typename T >
void Gnuplot<T>::writePNG(int iT, double xRange, std::string plotName)
{
  if (_gnuplotInstalled && (!_init)) {
    _iT = iT;
    _xRange = xRange;
 
    writePlotFile("png", plotName);
    startGnuplot("plotPNG", plotName);
  }
  return;
}
 
template< typename T >
void Gnuplot<T>::writePlotFile(std::string type, std::string plotName)
{
  if (singleton::mpi().getRank() == _rank ) {
    std::ofstream fout;
 
    std::string plotFile;
    if (_liveplot && type == "plot") {
      plotFile = singleton::directories().getGnuplotOutDir()+"data/plot.p";
    }
    else if (type == "pdf") {
      plotFile = singleton::directories().getGnuplotOutDir()+"data/plotPDF"+plotName+".p";
    }
    else if (type == "png") {
      plotFile = singleton::directories().getGnuplotOutDir()+"data/plotPNG"+plotName+".p";
    }
    else {
      std::cout << "WARNING: invalid Gnuplot type={'', 'plot'; 'pdf', 'png'}" << std::endl;
      exit(-1);
    }
 
    fout.open(plotFile.c_str(), std::ios::trunc);
    fout << "set key " << _key << "\n";
 
    if (type=="pdf") {
      fout << "set terminal pdf enhanced" << "\n"
           << "set output '"<<_dir<<_name<<".pdf'" << "\n";
    }
    if (type=="png") {
      if ( !util::nearZero(_xRange+1) ) {
        fout << "set xr[0:"<< _xRange <<"]" << "\n";
      }
      fout << "set terminal png" << "\n"
           << "set output '"<<_dir<<_name;
      if (_iT != -1) {
        fout <<"_"<<_iT;
      }
      fout <<".png'" << "\n";
    }
 
    fout << _preCommand << "\n";
 
 
    scaleAxes(fout);
 
 
    fout << "set xlabel '" << _xLabel << "'" << "\n";
    fout << "set ylabel '" << _yLabel << "'" << "\n";
 
 
 
    std::string xAxisType; 
    std::string yAxisType; 
 
    switch (_axisType)
    {
      case LOGLOG:
      {
        xAxisType = "log10(";
        yAxisType = "log10(";
      } break;
 
      case LOGLOGINVERTED:
      {
        xAxisType = "log10(1/";
        yAxisType = "log10(";
      } break;
 
      case LINEAR:
      default:
      {
        xAxisType = "(";
        yAxisType = "(";
      }
    }
 
    fout << "path = '" << _dir << "data/"<<_name << ".dat'" << "\n"; 
 
 
 
 
    switch (_regressionType)
    {
      case LINREG:
      {  
        linRegression(fout, xAxisType, yAxisType);  
      } break;
 
      case OFF: 
      default:
      {
        fout << "plot ";
      } break;
 
    }
 
 
    unsigned int i = 0;
    for ( ; i < _dataSize - 1; ++i) {
      fout << "path u (" << xAxisType << "$1)):(" << yAxisType << "$" << i+2 << ")) w " << _plotTypes[i] << " t '" << _names[i] << "' lc " << i+1 << " axis x1y1,";
    }
    fout << "path u (" << xAxisType << "$1)):(" << yAxisType << "$" << i+2 << ")) w " << _plotTypes[i] << " t '" << _names[i] << "' lc " << i+1 << " axis x1y1";
 
    fout << "\n";
    if (_liveplot && type=="plot") {
      fout << "pause -1" << "\n"
          << "reread" << "\n";
    }
    fout.close();
 
 
  }
  return;
}
 
 
template< typename T >
void Gnuplot<T>::setLabel(std::string xLabel, std::string yLabel)
{
  _xLabel = xLabel;
  _yLabel = yLabel;
}
 
 
template< typename T >
void Gnuplot<T>::startGnuplot(std::string plotFile, std::string plotName)
{
#ifndef WIN32
  if (singleton::mpi().getRank() == _rank) {
    if (!system(nullptr)) {
      exit (EXIT_FAILURE);
    }
    const std::string command = "gnuplot -persistent "+_dir+"data/"+plotFile+plotName+".p > /dev/null &";
    if ( system(command.c_str()) ) {
      std::cout << "Error at GnuplotWriter" << std::endl;
    }
  }
  return;
#endif
}
}  // namespace olb
 
#endif