iointerface.hh

#ifndef DUNE_FEM_IOINTERFACE_HH
#define DUNE_FEM_IOINTERFACE_HH
 
//- system includes
#include <dirent.h>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <utility>
#include <sys/stat.h>
#include <sys/types.h>
 
 
//- Dune includes
#include <dune/common/exceptions.hh>
#include <dune/grid/yaspgrid.hh>
#include <dune/grid/io/file/dgfparser/dgfparser.hh>
 
 
// defines Parameter
#include <dune/fem/io/parameter.hh>
 
// binary data io
#include <dune/fem/io/io.hh>
 
#include <dune/fem/misc/capabilities.hh>
 
// if grape was configured then include headers
#if HAVE_GRAPE
#include <dune/grid/io/visual/grapedatadisplay.hh>
#endif
 
namespace Dune
{
 
  namespace Fem
  {
 
    // generateFilename
    // ----------------
 
    inline std::string generateFilename ( const std::string &fn,
                                          int ntime,
                                          int precision = 6 )
    {
      std::ostringstream name;
      name << fn << std::setw( precision ) << std::setfill( '0' ) << ntime;
      return name.str();
    }
 
 
 
    class TimeProviderBase;
 
    class IOInterface {
 
    protected:
      IOInterface() {}
 
    public:
      virtual ~IOInterface () {}
 
      virtual void writeData ( double sequenceStamp ) const = 0;
 
      virtual void write( const TimeProviderBase& tp ) const = 0;
 
      virtual void write() const = 0;
 
      static std::string defaultGridKey ( int dimension, bool check = true )
      {
        return defaultGridKey( dimension, Parameter::container(), check );
      }
 
      static std::string defaultGridKey ( int dimension, const ParameterReader &parameter, bool check = true )
      {
        return defaultGridKey( "fem.io.macroGridFile", dimension, parameter, check );
      }
 
      static std::string defaultGridKey ( std::string base, int dimension, bool check = true )
      {
        return defaultGridKey( std::move( base ), dimension, Parameter::container(), check );
      }
 
      static std::string defaultGridKey ( std::string base, int dimension, const ParameterReader &parameter, bool check = true )
      {
        const std::string oldGridKey( base );
 
        std::ostringstream gridKeyStream;
        gridKeyStream << oldGridKey << "_" << dimension << "d";
        const std::string newGridKey( gridKeyStream.str() );
 
        // check for old parameter
        if( parameter.exists( oldGridKey ) )
        {
          if( parameter.exists( newGridKey ) )
          {
            std::cerr << "WARNING: ignoring `" << oldGridKey << "' because `"
                      << newGridKey << "' was also found in parameter file." << std::endl;
            return newGridKey;
          }
          else
          {
            std::cerr << "WARNING: change `" << oldGridKey << "' to `"  << newGridKey
                      << "' in parameter file." << std::endl;
            return oldGridKey;
          }
        }
 
        // check for parameter with dimension
        if( check && !parameter.exists( newGridKey ) )
        {
          std::cerr << "ERROR: Parameter `" << newGridKey << "' not found." << std::endl;
          DUNE_THROW( ParameterNotFound, "Parameter `" << newGridKey << "' not found." );
        }
        return newGridKey;
      }
 
      static void createPath ( const std::string &path )
      {
        if( !createDirectory( path ) )
          std::cerr << "Failed to create path `" << path << "'." << std::endl;
      }
 
      static std::string createPathName(const std::string& pathPref, int rank )
      {
        std::string path(pathPref);
 
        // add proc number to path
        {
          path += "_";
          std::stringstream rankDummy;
          rankDummy << rank;
          path += rankDummy.str();
        }
        return path;
      }
 
      static std::string readPath()
      {
        return Parameter::commonOutputPath();
      }
 
      template <class CommunicatorType>
      static void createGlobalPath(const CommunicatorType& comm,
              const std::string& path)
      {
        // only rank 0 creates global dir
        if( comm.rank() <= 0 )
        {
          // create directory
          if( !createDirectory( path ) )
            std::cerr << "Failed to create path `" << path << "'." << std::endl;
        }
 
        // wait for all procs to arrive here
        comm.barrier ();
      }
 
      // copy path to filename and add a slash if necessary
      static std::string copyPathToFilename( const std::string& path )
      {
        // first proc creates directory
        std::string filename( path );
 
        const char lastToken = filename.c_str()[ filename.size() - 1 ];
        const char* slash = "/";
        // add / if necessary
        if( lastToken != slash[0] )
          filename += "/";
 
        return filename;
      }
 
      // creates path and processor sub pathes
      template <class CommunicatorType>
      static std::string createPath(const CommunicatorType& comm,
              const std::string& pathPrefix,
              const std::string& dataPrefix,
              const int step,
              const bool alsoCreateRankPath = true )
      {
        // first proc creates directory
        std::string filename( copyPathToFilename( pathPrefix ));
 
        filename += dataPrefix;
        std::string path = generateFilename( filename, step );
 
        // create global path
        createGlobalPath( comm, path );
 
        // also create path for each rank
        if( alsoCreateRankPath )
        {
          // append path with p for proc
          path += "/p";
 
          // create path if not exists
          path = createPathName( path, comm.rank() );
 
          // create path if not exits
          if( !createDirectory( path ) )
            std::cerr << "Failed to create path `" << path << "'." << std::endl;
        }
        return path;
      }
 
      // creates path and processor sub pathes
      static std::string createRecoverPath(
              const std::string& pathPrefix,
              const int rank,
              const std::string& dataPrefix,
              const int step,
              const bool alsoUseRankPath = true )
      {
        // first proc creates directory
        std::string filename( copyPathToFilename( pathPrefix ));
 
        filename += dataPrefix;
        std::string path = generateFilename( filename, step );
 
        if( alsoUseRankPath )
        {
          // append path with p for proc
          path += "/p";
 
          // create proc dir
          return createPathName( path , rank );
        }
        else
          return path;
      }
    }; // end class IOInterface
 
  } // end namespace Fem
 
} // end namespace Dune
#endif // #ifndef DUNE_FEM_IOINTERFACE_HH