grid/gridOutput.h

Go to the documentation of this file.

/**
 *  @file      gridOutput.h
 *  @brief     Writes checkpoints from the grid to the output data file.
 *  @author    Mikica Kocic
 *  @copyright GNU General Public License (GPLv3).
 */

#include <deque>

/** Writes checkpoints from the grid to the output data file.
 */
class GridOutputWriter
{
    UniformGrid* gridDriver;     //! The grid-driver
    bool  binaryFormat;          //!< Write binary data to output file.
    FILE* outf;                  //!< Output stream for the results.
    std::string fileName;        //!< Output filename
    std::string prefixFileName;  //!< Filename that is copied out (reversed) before start
    std::vector<Int> output;     //!< List of grid functions to write out

    struct skipInfo { Real t; Int mSkip; Real delta_t; };
    std::deque<skipInfo> skipSetter;  //!< Apply new "skips" at the given time point

    Int mSkip;     //!< Output every `mSkip` rows
    Int nOut;      //!< Number of grid points to get in the output
    Int nSkip;     //!< Output every `nSkip` points
    Int chunkSize; //!< Size (in bytes) of the output chunk

    /** Writes the results for a particular grid row to output.
     */
    void write( Int m, Int nFrom, Int nTo, Int nSkip = 1 )
    {
        GridPoint* row = gridDriver->get_grid() [m];
        for( Int n = nFrom; n < nTo; n += nSkip ) {
            IORecord( row[n] ).write( outf, binaryFormat, output );
        }
    }

public:

    Int get_mSkip () const { return mSkip; }
    Int get_nOut  () const { return nOut;  }
    Int get_nSkip () const { return nSkip; }

    /** Retrieve the size (in bytes) of the output record.
     */
    Int recordSizeInBytes () const { return chunkSize; }

    /** Constructs the output writer as specified in the parameter file.
     */
    GridOutputWriter( Parameters& params, UniformGrid& ug )
        : gridDriver( &ug ), binaryFormat(false), outf(NULL)
    {
        output.reserve( 100 );
        output.push_back( fld::t );
        output.push_back( fld::r );

        params.get( "output.file",   fileName, "stdout" );
        params.get( "output.binary", binaryFormat, true );
        params.get( "output.prefix", prefixFileName, "" );

        slog << "Output Writer:" << std::endl << std::endl
             << "    file = " << fileName << ",  binary = " << binaryFormat
             << std::endl << std::endl;

        params.get( "output.nOut",  nOut,  10 );
        params.get( "output.nSkip", nSkip,  1 );
        params.get( "output.mSkip", mSkip,  1 );

        chunkSize = 0; // still not defined

        slog << "Output Filter:" << std::endl << std::endl
             << "    nOut = " << nOut << ",  nSkip = " << nSkip << ",  mSkip = " << mSkip
             << std::endl << std::endl;

        // Get skip setters
        //
        for( int i = 1; i < 10; ++i )
        {
            std::string tag = "at" + std::to_string( i );
            skipInfo info;
            params.get( tag + ".t",       info.t,       NAN );
            params.get( tag + ".mSkip",   info.mSkip,   1   );
            params.get( tag + ".delta_t", info.delta_t, NAN );
            if ( ! std::isnan( info.t ) ) {
                skipSetter.push_back( info );
            }
        }

        if( skipSetter.size() > 0 )
        {
            slog << "Skip Setter:" << std::endl << std::endl;
            for( auto i: skipSetter ) {
                slog << "    t = " << i.t << ", mSkip = " << i.mSkip
                    << ", delta_t = " << i.delta_t << std::endl;
            }
            slog << std::endl;
        }
    }

    ~GridOutputWriter ()
    {
        close ();
    }

    /** The given grid functions will be written to the output.
     */
    void gridFunctions( const std::vector<Int>& gfs )
    {
        output.insert( output.end(), gfs.begin(), gfs.end() );
    }

    /** Opens output data file for storing the results.
     */
    bool open ()
    {
        GridPoint** grid = gridDriver->get_grid ();
        Int nGhost = gridDriver->get_nGhost();

        chunkSize = ( 2 * nGhost + nOut / nSkip ) * output.size() * sizeof(Real);

        if( fileName == "stdout" ) {
            binaryFormat = false;
            outf = stdout;
            return false;
        }

        if ( gridDriver->mpiSize() > 1 ) {
            outf = fopen( ( std::to_string( gridDriver->mpiRank() + 100 )
                           + "-" + fileName ).c_str(), binaryFormat ? "wb+" : "w+" );
        }
        else {
            outf = fopen( fileName.c_str(), binaryFormat ? "wb+" : "w+" );
        }

        if( binaryFormat && prefixFileName != "" )
        {
            std::ifstream pref( prefixFileName, std::ios::in | std::ios::binary );
            if( pref )
            {
                slog << "*** Appending the reversed-t: " << prefixFileName << std::endl;

                pref.seekg( 0, std::ios::end );  // Go to end of file
                auto len = pref.tellg ();   // Get the length of file (in bytes)

                if ( ( len % chunkSize ) != 0 ) {
                    std::cerr << "Error: Invalid grid alignment." << std::endl;
                    return false;
                }

                // While len > 0 means skip the last record (at t_0)
                for( len -= chunkSize; len > 0; len -= chunkSize )
                {
                    pref.seekg( len, std::ios::beg );
                    pref.read( (char*)&grid[0][0], chunkSize );
                    fwrite( &grid[0][0], chunkSize, 1, outf );
                }
                pref.close ();
            }
        }

        return true;
    }

    /** Closes the output file.
     */
    void close ()
    {
        if( outf != NULL ) {
            fclose( outf );
            outf = NULL;
        }
    }

    void write( Int m, Real cur_t, Real& delta_t )
    {
        Int nLen   = gridDriver->get_nLen ();
        Int nGhost = gridDriver->get_nGhost ();
        write( m, 0, nGhost );
        write( m, nGhost, nGhost + (nLen < nOut ? nLen : nOut), nSkip );
        write( m, nGhost + nLen, nGhost + nLen + nGhost );

        if( skipSetter.size() > 0 && cur_t >= skipSetter.front().t )
        {
            mSkip = skipSetter.front().mSkip;
            Real new_dt = skipSetter.front().delta_t;
            if( ! std::isnan( new_dt ) )
            {
                delta_t = new_dt;
                slog << std::endl << std::endl << "*** at t = " << cur_t
                     << " new mSkip = " << mSkip << ", delta_t = " << delta_t
                     << std::endl << std::endl;
            }
            else
            {
                slog << std::endl << std::endl << "*** at t = " << cur_t
                     << " new mSkip = " << mSkip << std::endl << std::endl;
            }
            skipSetter.pop_front ();
        }
    }
};