WriteCheckpoint.py

Go to the documentation of this file.

# This file is part of the ExaHyPE2 project. For conditions of distribution and
# use, please see the copyright notice at www.peano-framework.org
import os
 
import peano4.api
import toolbox.blockstructured.api
 
from ..Solver import Solver
from .PlotAsVTKFile import _PlotPatchesIfPlotterIsActive
from .actionsets import ApplyDirichletBoundaryConditions
 
 
class WriteCheckpoint(Solver.Plotter):
    """!
 
    Write checkpoints of the fourth-order Finite Differences
 
    The checkpoint is configured like PlotAsVTKFile, i.e. it is written in
    regular time intervals. Different to a plot, it writes the whole state
    of the solver such that a simulation can continue from it. It hence has
    neither plot filters nor a selection of quantities: It writes all
    entries of Q, i.e. the unknowns and the auxiliary variables, of all
    cells which the solver updates.
 
    - It writes each patch together with its halo. Before it writes the
      data, it reconstructs the halo exactly as the first Runge-Kutta stage
      of the time step does: It sets the ghost grid cells along the domain
      boundary (Dirichlet boundary conditions), interpolates the hanging
      faces on adaptive meshes and gathers patch and face data into
      solver._patch_with_halo
      (toolbox.blockstructured.api.ReconstructPatchWithHalo). A patch
      with N grid cells per axis and a halo of M grid cells is written as a
      patch with N+2M grid cells per axis. Its box covers the cell plus the
      halo, so every grid cell sits at its true position, and neighbouring
      patches overlap.
    - It writes all values without loss: values, patch offsets and sizes
      carry 17 significant digits by default, and the writer does not set
      small values to zero
      (@ref tarch::plotter::griddata::blockstructured::PeanoTextPatchFileWriter).
    - The meta-data block in the header of each file holds the solver's
      state (@ref exahype2::Solver::toCheckpointMetaData()): its time
      stamps, time step sizes, admissible time step size and mesh sizes,
      plus the attributes the Python API adds to the solver's class, e.g.
      the time stamps of the next outputs of all of its plotters.
 
    The files are called checkpoint-SolverName by default. A solver can
    have a checkpoint next to its other plotters
    (@ref exahype2.api.Solver.Solver.add_plotter()).
    A simulation continues from a checkpoint with
    @ref exahype2.api.blockstructured.LoadCheckpoint.LoadCheckpoint instead of
    its usual grid construction.
 
    The reconstruction only reads the patch and face data, i.e. a
    checkpoint does not change the solution. The Dirichlet boundary
    conditions overwrite the ghost grid cells with the values they have at
    the current time stamp anyway, and the next time step sets them again.
 
    The class is the counterpart of exahype2.api.fv.WriteCheckpoint, as rkfd4
    does not depend on the Finite Volume package.
 
    """
 
    def __init__(
        self,
        solver: Solver,
        first_plot_time_stamp=0.0,
        time_in_between_plots=0.1,
        plotter_precision=17,
        output_path=".",
        filename="checkpoint",
        name: str = None,
        binary=True,
    ):
        """!
 
        @param solver: exahype2.api.Solver
          The solver whose state is written.
 
        @param first_plot_time_stamp: float
          Time stamp of the first checkpoint.
 
        @param time_in_between_plots: float
          Time in between two checkpoints. Has to be positive.
 
        @param plotter_precision: int
          Number of significant digits written per value. The default of 17
          ensures that the values are read back without loss.
 
        @param output_path: str
          Directory the checkpoint files are written into.
 
        @param filename: str
          The checkpoint files are called filename-SolverName.
 
        @param name: str or None
          Name of the plotter (@ref exahype2.api.Solver.Solver.Plotter).
 
        @param binary: bool
          Write the values as raw doubles instead of text
          (@ref tarch::plotter::griddata::blockstructured::PeanoBinaryPatchFileWriter).
          The checkpoint reader (@ref exahype2::CheckpointReader) reads both
          formats. Pass False to get human-readable checkpoints.
 
        """
        super().__init__(solver, name)
 
        if time_in_between_plots <= 0:
            raise Exception("Time in between checkpoints has to be bigger than 0")
        if plotter_precision <= 0:
            raise Exception("Precision has to be bigger than 0")
        self._first_plot_time_stamp = first_plot_time_stamp
        self._time_in_between_plots = time_in_between_plots
        self._plotter_precision = plotter_precision
        self._output_path = output_path
        self._filename = filename
        self._binary = binary
 
    def output_file_prefix(self):
        return os.path.join(self._output_path, self._filename + "-" + self._solver_solver.name)
 
    def construct_output(self, exahype2_project, peano_project, plot):
        """!
 
        Add the reconstruction of the halo and the writing of the checkpoint
        to the plot graph
 
        All action sets are guarded by the checkpoint's is<Name>Active(),
        i.e. the tasks do no work in plot phases without checkpoint. The
        writing task is the last one, so it moves the checkpoint on to its
        next time stamp.
 
        """
        peano4.api.Logger().log(
            "Create checkpoint task graph for fourth-order Finite Differences with Runge-Kutta over block-structured meshes"
        )
 
        for attribute in [
            "_patch",
            "_patch_with_halo",
            "_patch_overlap_current_time_step",
        ]:
            assert hasattr(self._solver_solver, attribute), (
                f"Solver {self._solver.name} has no attribute {attribute}. "
                "WriteCheckpoint assumes the numerical scheme has added this field "
                "to the solver immediately upon construction."
            )
 
        self._add_time_interval_bookkeeping_to_solver(
            self._first_plot_time_stamp, self._time_in_between_plots
        )
        self._solver_solver._add_checkpoint_meta_data_to_solver()
 
        Access = peano4.api.taskgraph.Task.DataAccess
        is_active = self.create_is_active_predicate()
        cell_guard = (
            "("
            + is_active
            + ") and ("
            + self._solver_solver.grid_selector.createCellGuard()
            + ")"
        )
        includes = (
            self._solver_solver._get_default_includes() + self._solver_solver.user_solver_includes
        )
 
        reconstruction_task = peano4.api.taskgraph.Task(
            name=f"{self._solver.name}_{self.name}_Reconstruct",
            entity=peano4.api.taskgraph.Task.GridEntity.CELL,
            may_spawn_background_tasks=False,
        )
        write_checkpoint_task = peano4.api.taskgraph.Task(
            name=f"{self._solver.name}_{self.name}_Write checkpoint",
            entity=peano4.api.taskgraph.Task.GridEntity.CELL,
            may_spawn_background_tasks=False,
        )
        plot.add_task(reconstruction_task)
        plot.add_task(write_checkpoint_task)
 
        
        reconstruction_task.use_cell(self._solver_solver._patch, Access.READ_AND_WRITE)
        reconstruction_task.use_cell(self._solver_solver._patch_with_halo, Access.WRITE)
        reconstruction_task.use_face(
            self._solver_solver._patch_overlap_current_time_step, Access.READ_AND_WRITE
        )
        reconstruction_task.add_action_set(
            toolbox.blockstructured.api.ReconstructPatchWithHalo(
                patch=self._solver_solver._patch,
                patch_overlap=self._solver_solver._patch_overlap_current_time_step,
                reconstructed_patch=self._solver_solver._patch_with_halo,
                guard=cell_guard,
                add_assertions_to_halo_exchange=False,
                additional_includes=includes,
            )
        )
        
        reconstruction_task.add_action_set(
            toolbox.blockstructured.api.InterpolateHangingFaces(
                self._solver_solver._patch_overlap_current_time_step,
                scheme=self._solver_solver.numerical_scheme.interpolation,
                guard=is_active,
                additional_includes=includes,
            )
        )
        
        ApplyDirichletBoundaryConditions.add_task_to_time_step(
            self._solver_solver,
            exahype2_project,
            plot,
            reconstruction_task,
            name_suffix=f" for {self.name}",
            relative_time_step_size=0.0,
            additional_guard=is_active,
        )
 
        
        write_checkpoint_task.add_dependency(reconstruction_task)
        write_checkpoint_task.use_cell(
            self._solver_solver._patch_with_halo, Access.READ_AND_DISCARD
        )
        write_checkpoint_task.add_action_set(
            _PlotPatchesIfPlotterIsActive(
                is_active_predicate=is_active,
                finish_call=self.create_finish_call(),
                filename=self.output_file_prefixoutput_file_prefix(),
                patch=self._solver_solver._patch_with_halo,
                dataset_name=self._solver_solver._patch_with_halo.name,
                description=", ".join(self._solver_solver.variable_names_per_entry())
                or self._solver_solver._unknown_identifier(),
                guard=self._solver_solver.grid_selector.createCellGuard(),
                additional_includes="""
#include "../repositories/SolverRepository.h"
""",
                precision=self._plotter_precision,
                binary=self._binary,
                time_stamp_evaluation="0.5*(repositories::getMinTimeStamp()+repositories::getMaxTimeStamp())",
                patch_scaling=self._solver_solver._patch_with_halo.dim[0]
                / self._solver_solver._patch.dim[0],
                metadata_evaluation="repositories::"
                + self._solver_solver.get_name_of_global_instance()
                + ".toCheckpointMetaData()",
            )
        )
 
        if peano4.api.Logger().is_visualisation:
            plot.visualise(title="Plot task graph for {}".format(self._solver_solver.name))
        if peano4.api.Logger().is_text:
            plot.log_as_text(title="Plot task graph for {}".format(self._solver_solver.name))