checkPoint.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2014-2017 Zuse Institute Berlin                             */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef CHECK_POINT_HH
#define CHECK_POINT_HH
 
#include <string>
#include <sstream>
#include <memory>
#include <iomanip>
#include <ctime>
#include <chrono>
#include <vector>
#include <utility>
 
#include <boost/filesystem.hpp>
 
#include <dune/grid/common/backuprestore.hh>
#include <dune/istl/bvector.hh>
 
#include <fem/gridmanager.hh>
#include <fem/variables.hh>
 
namespace Kaskade {
  struct CheckPoint
  {
    CheckPoint();
 
    CheckPoint(std::string const& pathName);
 
    bool readMode() const {
      return timeStamp_.empty();
    }
 
    std::string timeStamp() const {
      return timeStamp_;
    }
 
    template <class Grid>
    void writeGrid(GridManager<Grid> const& gridManager, std::string const& gridName) const {
      writeGrid(gridManager.grid(), gridName);
    }
 
    template <class Grid>
    void writeGrid(Grid const& grid, std::string const& gridName) const {
      boost::filesystem::path path = directory/(gridName+".grid");
      boost::filesystem::path tmpPath = path;
      tmpPath += std::string("~");
      // unfortunately backup with AluGrid does not tell us if action was succesfull or not (e.g. due to wrong path)
      Dune::BackupRestoreFacility<Grid>::backup(grid, tmpPath.string());
      boost::filesystem::rename(tmpPath, path);
    }
 
    template <class Grid>
    std::unique_ptr<Grid> readGrid(std::string const& gridName) const {
      // Todo: throw if restore returns nullptr?
      return std::unique_ptr<Grid>(Dune::BackupRestoreFacility<Grid>::restore((directory/(gridName+".grid")).string()));
    }
 
    template <class Index>
    void writeRefinementHistory(std::vector<std::vector<std::pair<int, Index>>> const& refHist, std::string const& gridName) const {
      boost::filesystem::path path = directory/(gridName+".refHist");
      boost::filesystem::path tmpPath = path;
      tmpPath += "~";
      std::ofstream out(tmpPath.string(), std::ios::binary);
      for(auto const& refStep : refHist) {
        out << refStep.size() << " ";
        out.write(reinterpret_cast<char const*>(refStep.data()), sizeof(std::pair<int, Index>) * refStep.size());
      }
      boost::filesystem::rename(tmpPath, path);
    }
 
    template <class Index>
    void appendRefinementHistory(std::vector<std::pair<int, Index>> const& refStep, std::string const& gridName) const {
      boost::filesystem::path path = directory/(gridName+".refHist");
      boost::filesystem::path tmpPath = path;
      tmpPath += "~";
      if(boost::filesystem::exists(path)) boost::filesystem::copy_file(path, tmpPath);
      std::ofstream out(tmpPath.string(), std::ios::binary | std::ios::app);
      out << refStep.size() << " ";
      out.write(reinterpret_cast<char const*>(refStep.data()), sizeof(std::pair<int, Index>) * refStep.size());
      boost::filesystem::rename(tmpPath, path);
    }
 
    template <class Index>
    std::vector<std::vector<std::pair<int, Index>>> readRefinementHistory(std::string const& gridName) const {
      using RefHist = std::vector<std::vector<std::pair<int, Index>>>;
      using RefStep = typename RefHist::value_type;
      RefHist refHist;
      std::ifstream in((directory/(gridName+".refHist")).string(), std::ios::binary);
      typename RefStep::size_type nRefCells;
      while(in >> nRefCells) {
        refHist.push_back(RefStep(nRefCells));
        in.get(); // skip one white space
        in.read(reinterpret_cast<char *>(refHist.back().data()), sizeof(typename RefStep::value_type) * nRefCells);
      }
      return refHist;
    }
 
    template <template<class, int> class Array, class Scalar, int dim>
    void writeData(Dune::BlockVector<Array<Scalar, dim>> const& data, std::string const& dataName) const {
      boost::filesystem::path path = directory/(dataName+".data");
      boost::filesystem::path tmpPath = path;
      tmpPath += std::string("~");
      writeData(data, std::ofstream(tmpPath.string(), std::ios::binary));
      boost::filesystem::rename(tmpPath, path);
    }
 
    template <class DataBlocks>
    void writeData(DataBlocks const& data, std::string const& dataName) const {
      boost::filesystem::path path = directory/(dataName+".data");
      boost::filesystem::path tmpPath = path;
      tmpPath += std::string("~");
      std::ofstream out(tmpPath.string(), std::ios::binary);
      boost::fusion::for_each(data.data, [this, &out](auto const& dataBlock) {
        out = this->writeData(dataBlock, std::move(out));
      });
      boost::filesystem::rename(tmpPath, path);
    }
 
    template <class FeSpace, int m>
    void writeData(FunctionSpaceElement<FeSpace, m> const& data, std::string const& dataName) const {
      writeData(data.coefficients(), dataName);
    }
 
    template <template<class, int> class Array, class Scalar, int dim>
    void readData(Dune::BlockVector<Array<Scalar, dim>> & data, std::string const& dataName) const {
      readData(data, std::ifstream((directory/(dataName+".data")).string(), std::ios::binary));
    }
 
    template <class DataBlocks>
    void readData(DataBlocks & data, std::string const& dataName) const {
      std::ifstream in((directory/(dataName+".data")).string(), std::ios::binary);
      boost::fusion::for_each(data.data, [this, &in](auto & dataBlock) {
        in = this->readData(dataBlock, std::move(in));
      });
    }
 
    template <class FeSpace, int m>
    void readData(FunctionSpaceElement<FeSpace, m> & data, std::string const& dataName) const {
      readData(data.coefficients(), dataName);
    }
 
  protected:
    void setTimeStamp();
 
    template <template<class, int> class Array, class Scalar, int dim>
    std::ofstream writeData(Dune::BlockVector<Array<Scalar, dim>> const& data, std::ofstream out) const {
      out.write(reinterpret_cast<char const*>(&data[0]), sizeof(Scalar) * data.size() * dim);
      return out;
    }
 
    template <class FeSpace, int m>
    std::ofstream writeData(FunctionSpaceElement<FeSpace, m> const& data, std::ofstream out) const {
      return writeData(data.coefficients(), std::move(out));
    }
 
    template <template<class, int> class Array, class Scalar, int dim>
    std::ifstream readData(Dune::BlockVector<Array<Scalar, dim>> & data, std::ifstream in) const {
      in.read(reinterpret_cast<char *>(&data[0]), sizeof(Scalar) * data.size() * dim);
      return in;
    }
 
    template <class FeSpace, int m>
    std::ifstream readData(FunctionSpaceElement<FeSpace, m> & data, std::ifstream in) const {
      return readData(data.coefficients(), std::move(in));
    }
 
    std::string timeStamp_;
    boost::filesystem::path directory;
  };
}
#endif // CHECK_POINT_HH