dualplot.cpp

//**************************************************************************************************
//*  FRIDA: fast reliable interactive data analysis                         
//*  (C) Joachim Wuttke 1990-, v2(C++) 2001-                                
//*  http://apps.jcns.fz-juelich.de/frida                                   
//**************************************************************************************************

//! \file  dualplot.cpp
//! \brief Collection NPlot of plot frames CPlot.

#include <cstdio>
#include <cmath>
#include <cstring>
#include <fcntl.h>
#include <errno.h>
#include <iostream>
#include <sys/stat.h>
#include <boost/format.hpp>

#include <../trivia/file_ops.hpp>

#include "defs.hpp"
#include "dualplot.hpp"

using boost::format;

static const int mLin = 80; // max num of chars in PostScript line


//! Constructor for plot window: setup for gnuplot and postscript.

CPlot::CPlot( int _iPlot, bool _logx, bool _logy ) :
    iPlot( _iPlot ), X( "x", _logx ), Y( "y", _logy ),
    maxpoints(20000), with_errors(true), equipoints(49), refine(true)
{
    // == Initialization for Gnuplot ==

    // Create a named pipe (FIFO) that will transmit our commands to Gnuplot.
    string fn_fifo = string("/tmp/gnuplot-") + getenv( "LOGNAME" );
    triv::system( "rm -f "+fn_fifo );
    if (mkfifo( fn_fifo.c_str(), 0666 ))
        throw "SYSTEM ERROR cannot make fifo "+fn_fifo+": will not be able to print";

    // Start a Gnuplot that will read from our pipe.
    triv::system( "gnuplot -title "+S(iPlot)+" -noraise < "+fn_fifo+"&" );

    // Open our pipe so that we can write commands to it
    //   (we use 'open' instead of 'fopen' or 'ofstream', because we need non-blocking mode).
    if ( ( gp_fifo = open( fn_fifo.c_str(), O_WRONLY ) )==-1 )
        throw "SYSTEM ERROR: cannot open fifo "+fn_fifo+" ("+strerror(errno)+")";
    fcntl( gp_fifo, F_SETFL, O_NONBLOCK );

    // Now the initialization _within_ Gnuplot.
    gp_write( string("set terminal x11") );

    // == Initialization for PostScript ==
    ps_fnum=0;
}


//! Clear plot frame and buffer.

void CPlot::clearFrame()
{
    // clear gnuplot tmp files
    gp_fno = 0;
    gp_fnames = "";

    // reset buffers for postscript output
    string cmd;
    ps_accu.clear();
    ps_accu.push_back( "\n%% output created by frida2\n");
    ps_snum = 0;
    ps_pnum = 0;
    ps_cnum = 0;
    ps_Doc.clear();
}


//! Change one setup parameter per command.

void CPlot::setAux( const string& cmd )
{
    if ( cmd=="gxl" ) {
        X.setLog( !X.logflag );
        printf( "set x %s\n", X.logflag ? "log" : "lin" ); }
    else if ( cmd=="gxl+" )
        X.setLog( true );
    else if ( cmd=="gxl-" )
        X.setLog( false );
    else if ( cmd=="gyl" ) {
        Y.setLog( !Y.logflag );
        printf( "set y %s\n", Y.logflag ? "log" : "lin" ); }
    else if ( cmd=="gyl+" )
        Y.setLog( true );
    else if ( cmd=="gyl-" )
        Y.setLog( false );
    else if ( cmd=="gxf" ) {
        X.force = !X.force;
        printf( "force x %s\n", X.force ? "on" : "off" ); }
    else if ( cmd=="gxf+" )
        X.force = true;
    else if ( cmd=="gxf-" )
        X.force = false;
    else if ( cmd=="gyf" ) {
        Y.force = !Y.force;
        printf( "force y %s\n", Y.force ? "on" : "off" ); }
    else if ( cmd=="gyf+" )
        Y.force = true;
    else if ( cmd=="gyf-" )
        Y.force = false;
    else if ( cmd=="ge" )
        with_errors = !with_errors;
    else if ( cmd=="ge+" )
        with_errors = true;
    else if ( cmd=="ge-" )
        with_errors = false;
    else
        throw "unknown command " + cmd;
}


//! Plot coordinate frame (axes, ticks, labels).

void CPlot::plotFrame( const string& xlabel, const string& ylabel )
{
    gp_write( "set nologscale" );
    string whichlog="";
    if (X.logflag) whichlog += "x";
    if (Y.logflag) whichlog += "y";
    if (whichlog!="")
        gp_write( "set logscale " + whichlog );

    // wups:
    char outlin[ mLin ];
    snprintf( outlin, mLin, "\n%d %g %g xSetCoord\n", 
              X.logflag, X.inf, X.sup );
    ps_accu.push_back( outlin );
    snprintf( outlin, mLin, "%d %g %g ySetCoord\n", 
              Y.logflag, Y.inf, Y.sup );
    ps_accu.push_back( outlin );
    snprintf( outlin, mLin, "%% %d %g %g %d zSetCoord\n\n",
              0, 0., 0., 0 );
    ps_accu.push_back( outlin );

    int ntpt;
    double ticklim[2];
    vector<double> Tacks;
    ps_accu.push_back( "\n/xPlotFrame {\n" );
    if ( X.logflag && X.inf<= 0 )
        throw "BUG: x log incompatible with limits " + X.str();
    X.calc_ticks( Tacks, &ntpt, ticklim );
    ps_ticktack( Tacks, ntpt, ticklim, &X);
    snprintf( outlin, mLin-4, "  {(%s", xlabel.c_str() );
    strncat( outlin, ")}\n", mLin );
    ps_accu.push_back( outlin );
    ps_accu.push_back( "   0 10   0  0     0  90 "
                       "OneAxx Axx Tic Tac xNumL %% low x axis\n" );
    ps_accu.push_back( "   0 10   0 10     0 270 "
                       "OneAxx Axx Tic Tac       %% top x axis\n" );
    ps_accu.push_back( "  xCL\n" );
    ps_accu.push_back( "} def\n" );
    
    ps_accu.push_back( "\n/yPlotFrame {\n" );
    if ( Y.logflag && Y.inf<= 0 )
        throw "BUG: y log incompatible with limits " + Y.str();
    Y.calc_ticks( Tacks, &ntpt, ticklim );
    ps_ticktack( Tacks, ntpt, ticklim, &Y);
    snprintf( outlin, mLin-4, "   {(%s", ylabel.c_str() );
    strncat( outlin, ")}\n", mLin );
    ps_accu.push_back( outlin );
    ps_accu.push_back( "   0 10   0  0    90   0 "
                       "OneAxx Axx Tic Tac yNumL %% left y axis\n" );
    ps_accu.push_back( "   0 10  10  0    90 180 "
                       "OneAxx Axx Tic Tac       %% right y axis\n" );
    ps_accu.push_back( "  yCL\n" );
    ps_accu.push_back( "} def\n" );
    ps_accu.push_back( "\n%% modeDD\nplotbefore\n" );
}


//! Plot one spectrum.

void CPlot::addSpec( bool as_line, bool new_style, int style_no,
                     const vector<double>& xp,
                     const vector<double>& yp, const vector<double>& dyp,
                     const vector<double>& z,
                     const string& xco,
                     const string& yco,
                     const string& info
    )
{
    static const int mColor = 6;
    static int color[mColor] = { 0x880000, 0x008800, 0x000088,
                                 0x006666, 0x660066, 0x666600 };
    // Checks:
    int np=xp.size();
    if ( !np )
        throw "invalid call to CPLot::addSpec: no data points";
    if ( np!=yp.size() )
        throw "invalid call to CPLot::addSpec: x.size<>y.size";

    // Prepare for live display, to be shown by showSpecs():
    string gp_fnam = str( format( "/tmp/%s-%d-%03d.gnu" )
                          % getenv("LOGNAME") % iPlot % gp_fno++ );
    if (gp_fnames!="") gp_fnames += ", ";
    gp_fnames += string("\"") + gp_fnam + "\" notitle";
    if ( as_line )
        gp_fnames += str( format( " with lines lt 1 lc rgb \"#%6x\"" )
                          % color[ style_no % mColor ] );
    else if( with_errors && dyp.size() )
        gp_fnames += " with errorbars";
    FILE *gp_fd;
    if (!(gp_fd = fopen(gp_fnam.c_str(), "w")))
        throw "cannot save gnuplot data to " + gp_fnam;
    int nout = 0;
    try {
        for (int i=0; i<np; i++){
            if( std::isinf(xp[i]) || std::isinf(yp[i]) )
                throw "Data point number " + S(i) + " is invalid: x=" +
                    S(xp[i]) + ", y=" + S(yp[i]);
            if( xp[i]<X.inf || xp[i]>X.sup )
                throw "CPlot::addSpec: x["+S(i)+"]="+S(xp[i])+" out of range";
            if( yp[i]<Y.inf || yp[i]>Y.sup )
                throw "CPlot::addSpec: y["+S(i)+"]="+S(yp[i])+" out of range";
            if( with_errors && dyp.size() )
                fprintf(gp_fd, "%16.8g %16.8g %16.8g\n", xp[i], yp[i], dyp[i] );
            else
                fprintf(gp_fd, "%16.8g %16.8g\n", xp[i], yp[i]);
            nout++;
        }
    } catch ( string &s ) {
        fclose(gp_fd);
        throw s;
    } catch ( ... ) {
        fclose(gp_fd);
        throw "BUG: unexpected exception type";
    }
    fclose(gp_fd);
    if( !nout )
        throw "no points in frame: " + info;

    // Postscript copy:
    char outlin[ mLin ];
    if ( new_style ) {
        snprintf( outlin, mLin, "\n%3u [", ++ps_snum );
        ps_accu.push_back( outlin );
        for (int i=0; i<z.size(); i++){
            snprintf( outlin, mLin, " %12g", z[i]);
            ps_accu.push_back( outlin );
        }
        snprintf( outlin, mLin, " ] zValues\n" );
        ps_accu.push_back( outlin );
        if ( as_line )
            snprintf( outlin, mLin, "%2d cstyle", style_no );
        else
            snprintf( outlin, mLin, "%2d pstyle", style_no );
        ps_accu.push_back( outlin );
        snprintf( outlin, mLin-2, " %% (%s -> %s)", xco.c_str(), yco.c_str() );
        strncat( outlin, "\n", mLin );
        ps_accu.push_back( outlin );
    } else {
        ps_accu.push_back( "\n" );
    }
    for (int i=0; i<np; i++) {
        snprintf( outlin, mLin,
                  "%6.3f %6.3f %6.3f t%c %% %13.7g wx %13.7g wy\n",
                  X.pc(xp[i]), Y.pc(yp[i]), 
                  dyp.size() ? Y.pcerr(yp[i],dyp[i]) : 0,
                  i==0 ? 'i' : i==np-1 ? 'f' : ' ',
                  xp[i], yp[i] );
        ps_accu.push_back( outlin );
    }
}


//! Live display as prepared by addSpec.

void CPlot::showSpecs()
{
    if ( gp_fnames!="" )
        gp_write( "plot " + 
                  str( format( "[%12.8g:%12.8g] [%12.8g:%12.8g] " )
                       % X.inf % X.sup % Y.inf % Y.sup ) +
                  gp_fnames );
}


//! Add documentation line to postscript output.

void CPlot::docTxLine( const string& line )
{
    ps_Doc.push_back( "  {("+line+")} TxLine" );
}


//! Add documentation line explaining a plot symbol to postscript output.

void CPlot::docPtTxLine( const string& line, int num )
{
    ps_Doc.push_back( "  " + S(num) + " {("+line+")} PtTxLine" );
}


//! Add documentation line explaining a curve style to postscript output.

void CPlot::docCvTxLine( const string& line, int num )
{
    ps_Doc.push_back( "  " + S(num) + " {("+line+")} CvTxLine" );
}


//! Write buffered plot to postscript file.

void CPlot::writePostscript( const string& ps_outdir,
                             const string& ps_head,
                             const string& ps_dict )
{
    // construct output file name:
    FILE *pssav;
    string cmd, outf;
    while(1) {
        if (ps_fnum>=999)
            throw "graph file number overflow";
        outf = triv::wordexp_unique( 
            ps_outdir + str( format( "l%d" ) % ++ps_fnum ) + "." + ( ps_dict=="" ? "psa" : "ps" ) );
        if( !triv::file_exists( outf.c_str() ) )
            break; // legal exit
    }
    cout << "save plot in " << outf << "\n";

    // copy headers to output file:
    cmd = string("cat ") +
        ps_dict + " " + // ps_dict may be ""
        ps_head + " > " +
        outf + "\n";
    triv::system( cmd );
    
    // append specific output to output file:
    if ( !(pssav = fopen( outf.c_str(), "a+" )) )
        throw "cannot append contents to file " + outf;
    for( string lin: ps_accu ){
        // fprintf does not work here because output line may contain "%"
        fwrite( lin.c_str(), 1, lin.size(), pssav );
    }

    // additional output (do not append this to ps_accu to allow
    // further incrementation of ps_accu):
    fprintf( pssav, "\n{ black 0 -4 13 1.65 NewList\n" );
    for ( string lin: ps_Doc ) 
        fprintf( pssav, "%s\n", lin.c_str() );
    fprintf( pssav, "} oooinfo 1 eq { exec } { pop } ifelse\n" );

    fprintf( pssav, 
             "\n{(%s)}  /filename exch def 10 -2.8 18 showfilename\n\n"
            " EndFrame\n", outf.c_str() );

    // output completed:
    fclose(pssav);
}


//! Info line to characterize this plot window.

string CPlot::info() const
{
    string ret;
    ret  =   "x: " + X.info();
    ret += "  y: " + Y.info();
    return ret;
}


//! Send one line to gnuplot fifo.

void CPlot::gp_write( const string& in )
{
    string out = in + "\n";
    // cout << "monitor gnuplot driver: '" << out << "'\n";
    if( write( gp_fifo, out.c_str(), out.size() ) <= 0 )
        throw "could not write to gp_fifo";
}


//! Format ticks and tacks for postscript file.

void CPlot::ps_ticktack( const vector<double>& Tacks, int ntpt,
                         const double *ticklim, const CAxis *A )
{
    char outlin[ mLin ];
    int i, ntack;
    ntack = Tacks.size();
    if (ntack > 0 ) {
        ps_accu.push_back( "  [\n" );
        if (A->logflag && ( Tacks[0]<1e-3 || Tacks[ntack-1]>1e3 )) {
            for (i=0; i<ntack; i++) {
                snprintf( outlin, mLin,
                          "   %9.6f {(10)(%d)sp()} %%{(%g)}\n", 
                          A->pc(Tacks[i]), (int)(log10(Tacks[i])), (float) Tacks[i]);
                ps_accu.push_back( outlin );
            }
        } else {
            for (i=0; i<ntack; i++) {
                snprintf( outlin, mLin, "   %9.6f {(%g)}\n", 
                          A->pc(Tacks[i]), (float) Tacks[i]);
                ps_accu.push_back( outlin );
            }
        }
        ps_accu.push_back( "  ] SetTacVec\n" );
    }
    snprintf( outlin, mLin, "  %g %g %d %d SetTicVec%s\n", 
              A->pc(ticklim[0]), A->pc(ticklim[1]), ntack+2, ntpt,
              (A->logflag? "Log" : "Lin"));
    ps_accu.push_back( outlin );
}


namespace NPloWin {
    vector<CPlot*> Plots;
    int nPlot;
    int iPlot;

    void initialize();
}


//! Initialize default choice of plot windows.

void NPloWin::initialize()
{
    nPlot = 0; // shorthand for Plots.size()
    Plots.push_back( new class CPlot( nPlot++, false, false ) );
    Plots.push_back( new class CPlot( nPlot++, true,  false ) );
    Plots.push_back( new class CPlot( nPlot++, false, true ) );
    Plots.push_back( new class CPlot( nPlot++, true,  true ) );
    iPlot = 0; // current plot window
}