fe_output.hh

Go to the documentation of this file.

#pragma once
 
// DiFfRG
#include <DiFfRG/common/utils.hh>
#include <DiFfRG/discretization/data/hdf5_output.hh>
 
// external libraries
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/lac/vector_memory.h>
#include <deal.II/numerics/data_out.h>
 
#include <hdf5lib/hdf5.hh>
 
// standard library
#include <exception>
#include <list>
#include <mutex>
#include <thread>
 
namespace DiFfRG
{
  using namespace dealii;
 
  template <uint dim, typename VectorType> class FEOutput
  {
  public:
    FEOutput(std::string top_folder, std::string output_name, std::string output_folder, const JSONValue &json);
 
    FEOutput();
    ~FEOutput();
 
    void set_hdf5_output(HDF5Output *output);
 
    void attach(const DoFHandler<dim> &dof_handler, const VectorType &solution, const std::string &name);
 
    void attach(const DoFHandler<dim> &dof_handler, const VectorType &solution, const std::vector<std::string> &names);
 
    void flush(double time);
 
  private:
    const std::string top_folder;
    const std::string output_name;
    const std::string output_folder;
    const std::string filename_pvd;
    const uint buffer_size;
 
    uint series_number, subdivisions;
    std::vector<std::pair<double, std::string>> time_series;
 
    constexpr static uint safe_dim = dim == 0 ? 1 : dim;
    std::vector<DataOut<safe_dim>> data_outs;
    std::list<std::thread> output_threads;
    // series number each worker thread is responsible for, kept in lockstep with output_threads so
    // the main thread can clear() the corresponding DataOut once the worker has been joined. Clearing
    // a DataOut frees its Kokkos-backed vectors, which (with deal.II's Kokkos host backend) must not
    // happen on a worker thread concurrently with the main thread's own Kokkos work.
    std::list<uint> output_thread_series;
    std::list<std::list<typename VectorMemory<VectorType>::Pointer>> attached_solutions;
 
    // serializes worker-thread access to time_series and the shared .pvd file
    std::mutex output_mutex;
    // captures any exception thrown inside a worker thread so it can be re-raised on the
    // main thread at the next flush() (or at destruction, if no other throw is unwinding)
    std::mutex exception_mutex;
    std::exception_ptr stored_exception;
 
    GrowingVectorMemory<VectorType> mem;
 
    void update_buffers();
 
    HDF5Output *hdf5_output = nullptr;
 
    bool save_vtk;
  };
 
  template <typename VectorType> class FEOutput<0, VectorType>
  {
  public:
    FEOutput(std::string top_folder, std::string output_name, std::string output_folder, const JSONValue &json);
  };
 
} // namespace DiFfRG