GlobalAdaptiveTimeStep.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
from .kernels import *
 
from toolbox.blockstructured.api import ReconstructedArrayMemoryLocation
 
from exahype2.solvers import PDETerms
from exahype2.solvers.fv.SingleSweep import SingleSweep
 
from exahype2.solvers.fv.AdaptiveTimeSteppingCodeSnippets import (
    AdaptiveTimeSteppingCodeSnippets,
)
 
 
class GlobalAdaptiveTimeStep(SingleSweep):
    def __init__(
        self,
        name,
        patch_size,
        unknowns,
        auxiliary_variables,
        min_volume_h,
        max_volume_h,
        time_step_relaxation,
        initial_conditions=PDETerms.User_Defined_Implementation,
        boundary_conditions=PDETerms.User_Defined_Implementation,
        refinement_criterion=PDETerms.Empty_Implementation,
        flux=PDETerms.None_Implementation,
        ncp=PDETerms.None_Implementation,
        eigenvalues=PDETerms.None_Implementation,
        riemann_solver=PDETerms.User_Defined_Implementation,
        source_term=PDETerms.None_Implementation,
        plot_grid_properties=False,
        pde_terms_without_state=False,
        overlap=1,
    ):
        super(GlobalAdaptiveTimeStep, self).__init__(
            name,
            patch_size,
            overlap,
            unknowns,
            auxiliary_variables,
            min_volume_h,
            max_volume_h,
            plot_grid_properties,
            pde_terms_without_state,
            kernel_namespace="riemann",
        )
        self._time_step_relaxation = time_step_relaxation
 
        self._flux_implementation = PDETerms.None_Implementation
        self._ncp_implementation = PDETerms.None_Implementation
        self._eigenvalues_implementation = PDETerms.None_Implementation
        self._riemann_solver_implementation = PDETerms.None_Implementation
        self._source_term_implementation = PDETerms.None_Implementation
 
        self._compute_eigenvalue = True
 
        self.set_implementation(
            initial_conditions=initial_conditions,
            boundary_conditions=boundary_conditions,
            refinement_criterion=refinement_criterion,
            flux=flux,
            ncp=ncp,
            eigenvalues=eigenvalues,
            riemann_solver=riemann_solver,
            source_term=source_term,
        )
 
    def set_implementation(
        self,
        initial_conditions=None,
        boundary_conditions=None,
        refinement_criterion=None,
        flux=None,
        ncp=None,
        eigenvalues=None,
        riemann_solver=None,
        source_term=None,
        memory_location=None,
        use_split_loop=False,
        additional_action_set_includes="",
        additional_user_includes="",
    ):
        """
        If you pass in User_Defined, then the generator will create C++ stubs
        that you have to befill manually. If you pass in None_Implementation, it
        will create nop, i.e., no implementation or defaults. Any other string
        is copied 1:1 into the implementation. If you pass in None, then the
        set value so far won't be overwritten.
 
        Please note that not all options are supported by all solvers.
 
        This routine should be the very last invoked by the constructor.
        """
        if initial_conditions is not None:
            self._initial_conditions_implementation = initial_conditions
        if boundary_conditions is not None:
            self._boundary_conditions_implementation = boundary_conditions
        if refinement_criterion is not None:
            self._refinement_criterion_implementation = refinement_criterion
        if flux is not None:
            self._flux_implementation = flux
        if ncp is not None:
            self._ncp_implementation = ncp
        if eigenvalues is not None:
            self._eigenvalues_implementation = eigenvalues
        if riemann_solver is not None:
            self._riemann_solver_implementation = riemann_solver
        if source_term is not None:
            self._source_term_implementation = source_term
        if memory_location is not None:
            self._reconstructed_array_memory_location = memory_location
        if use_split_loop:
            self._use_split_loop = use_split_loop
 
        self._compute_kernel_call = create_compute_Riemann_kernel(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            compute_max_eigenvalue_of_next_time_step=self._compute_eigenvalue,
            solver_variant=SolverVariant.WithVirtualFunctions,
            kernel_variant=KernelVariant.PatchWiseAoS,
        )
 
        self._compute_kernel_call_stateless = create_compute_Riemann_kernel(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            compute_max_eigenvalue_of_next_time_step=self._compute_eigenvalue,
            solver_variant=SolverVariant.Stateless,
            kernel_variant=KernelVariant.PatchWiseAoS,
        )
 
        if (
            self._reconstructed_array_memory_location
            == ReconstructedArrayMemoryLocation.HeapThroughTarchWithoutDelete
            or self._reconstructed_array_memory_location
            == ReconstructedArrayMemoryLocation.HeapWithoutDelete
            or self._reconstructed_array_memory_location
            == ReconstructedArrayMemoryLocation.ManagedSharedAcceleratorDeviceMemoryThroughTarchWithoutDelete
        ):
            raise Exception(
                "Memory mode without appropriate delete chosen, i.e. this will lead to a memory leak"
            )
 
        solver_code_snippets = AdaptiveTimeSteppingCodeSnippets(
            self._time_step_relaxation
        )
 
        self._abstract_solver_user_declarations = create_abstract_solver_declarations(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            pde_terms_without_state=self._pde_terms_without_state,
        )
        self._abstract_solver_user_declarations += (
            solver_code_snippets.create_abstract_solver_user_declarations()
        )
        self._abstract_solver_user_definitions = create_abstract_solver_definitions(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            pde_terms_without_state=self._pde_terms_without_state,
        )
        self._abstract_solver_user_definitions += (
            solver_code_snippets.create_abstract_solver_user_definitions()
        )
 
        self._solver_user_declarations = create_solver_declarations(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            pde_terms_without_state=self._pde_terms_without_state,
        )
        self._solver_user_definitions = create_solver_definitions(
            flux_implementation=self._flux_implementation,
            ncp_implementation=self._ncp_implementation,
            eigenvalues_implementation=self._eigenvalues_implementation,
            riemann_solver_implementation=self._riemann_solver_implementation,
            source_term_implementation=self._source_term_implementation,
            pde_terms_without_state=self._pde_terms_without_state,
        )
 
        self._compute_time_step_size = (
            solver_code_snippets.create_compute_time_step_size()
        )
        self._compute_new_time_step_size = (
            solver_code_snippets.create_compute_new_time_step_size()
        )
 
        self._start_time_step_implementation = (
            solver_code_snippets.create_start_time_step_implementation()
        )
        self._finish_time_step_implementation = (
            solver_code_snippets.create_finish_time_step_implementation()
        )
        self._constructor_implementation = (
            solver_code_snippets.create_abstract_solver_constructor_statements()
        )
 
        super(GlobalAdaptiveTimeStep, self).set_implementation(
            initial_conditions=initial_conditions,
            boundary_conditions=boundary_conditions,
            refinement_criterion=refinement_criterion,
            memory_location=memory_location,
            use_split_loop=use_split_loop,
            additional_action_set_includes=additional_action_set_includes,
            additional_user_includes=additional_user_includes,
        )
 
    @property
    def user_action_set_includes(self):
        return (
            super(GlobalAdaptiveTimeStep, self).user_action_set_includes
            + """
#include "exahype2/fv/riemann/Riemann.h"
"""
        )
 
    def __str__(self):
        result = super(GlobalAdaptiveTimeStep, self).__str__().rstrip("\n")
        result += (
            """
Riemann solver:         """
            + str(self._riemann_solver_implementation)
            + """
"""
        )
        return result
 
    __repr__ = __str__