SolverToCPPFiles.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 peano4.api
import peano4.api.output.Jinja2TemplatedHeaderImplementationFilePair
 
import dastgen2
 
import os
import sys
 
from .Solver import Solver
 
 
class SolverToCPPFiles(Solver.SolverGenerator):
    TEMPLATE_ABSTRACT_HEADER_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
#pragma once
 
#include "exahype2/RefinementControl.h"
#include "exahype2/Solver.h"
#include "tarch/la/Vector.h"
#include "tarch/accelerator/accelerator.h"
#include "tarch/NonCriticalAssertions.h"
 
#include "peano4/utils/Globals.h"
 
#include "Constants.h"
    
 
{% for item in NAMESPACE -%}
  namespace {{ item }} {
  {# Empty line here #}
{%- endfor %}
  class {{CLASSNAME}};
 
{% for item in NAMESPACE -%}
  }
{%- endfor %}
 
 
class {{NAMESPACE | join("::")}}::{{CLASSNAME}}: public ::exahype2::Solver {
  public:
    {{CLASSNAME}}();
 
    static constexpr int    NumberOfUnknowns           = {{NUMBER_OF_UNKNOWNS}};
    static constexpr int    NumberOfAuxiliaryVariables = {{NUMBER_OF_AUXILIARY_VARIABLES}};
    static constexpr int    PatchSize                  = {{PATCH_SIZE}};
    static constexpr int    HaloSize                   = {{HALO_SIZE}};
 
    {{VARIABLES}}
 
    {{PDE_TERM_DECLARATIONS}}
 
    {{ADDITIONAL_METHOD_DECLARATIONS}}
 
  protected:
    static tarch::logging::Log  _log;
 
    {{ADDITIONAL_ATTRIBUTES}}
};
 
{# Empty line here #}
"""
 
    TEMPLATE_ABSTRACT_CPP_FILE = """
#include "{{CLASSNAME}}.h"
#include "exahype2/RefinementControl.h"
{{USER_SOLVER_INCLUDES}}
 
tarch::logging::Log {{NAMESPACE | join("::")}}::{{CLASSNAME}}::_log( "{{NAMESPACE | join("::")}}::{{CLASSNAME}}" );
 
 
{{NAMESPACE | join("::")}}::{{CLASSNAME}}::{{CLASSNAME}}() {
}
 
 
{{PDE_TERM_DEFINITIONS}}
 
{{ADDITIONAL_METHOD_DEFINITIONS}}
"""
 
    TEMPLATE_SOLVER_HEADER_FILE = """
// This file has been generated by the ExaHyPE2 api which is part
// of the ExaHyPE2 project. For conditions of distribution and
// use of ExaHyPE2, please see the copyright notice at 
// www.peano-framework.org. However, this file is only a suggestion
// and can be freely changed by the ExaHyPE 2 user who might decide
// to apply their own copyright.
#pragma once
 
#include "Abstract{{CLASSNAME}}.h"
 
 
{% for item in NAMESPACE -%}
  namespace {{ item }} {
  {# Empty line here #}
{%- endfor %}
  class {{CLASSNAME}};
 
{% for item in NAMESPACE -%}
  }
{%- endfor %}
 
 
class {{NAMESPACE | join("::")}}::{{CLASSNAME}}: public {{NAMESPACE | join("::")}}::Abstract{{CLASSNAME}} {
  public:
    {{CLASSNAME}}() = default;
 
    {{PDE_TERM_STUB_DECLARATIONS}}
};
 
{# Empty line here #}
"""
 
    TEMPLATE_SOLVER_CPP_FILE = """
#include "{{CLASSNAME}}.h"
 
 
{{PDE_TERM_STUB_DEFINITIONS}}
"""
 
    """!
 
    Default implementation that takes a solver and maps it onto two C++ classes:
    An abstract base class and a class for the user to implement it.
 
    The user class is only generated if at least one PDE term lacks an
    implementation (@see Solver.requires_user_class). It is never
    overwritten once it exists, and it is added to the Makefile as a
    non-generated file. Without it, the solver repository instantiates
    the abstract base class directly.
 
    """
 
    def __init__(self, solver: Solver):
        super().__init__(solver)
 
    def _variables_declaration(self) -> str:
        """!
 
        Nested struct Variables with the position of each named variable
        within Q, or the empty string if the solver's variables carry no
        names. User code (and code injected from Python) then can write
        Q[Variables::rho] instead of Q[0].
 
        """
        if not self._solver._variable_positions:
            return ""
        constants = "\n".join(
            f"      static constexpr int {variable_name} = {position};"
            for variable_name, position in self._solver._variable_positions.items()
        )
        return (
            "/**\n"
            "     * Positions of the named unknowns and auxiliary variables within Q\n"
            "     */\n"
            "    struct Variables {\n" + constants + "\n    };"
        )
 
    def construct_output(
        self,
        exahype2_project,
        peano_project,
    ):
        """!
 
        Dump the solver into actual C++ classes.
 
        """
        class_name = "Abstract" + self._solver.name
        templatefile_prefix = (
            os.path.realpath(__file__).replace(".pyc", "").replace(".py", "")
        )
 
        peano4.api.Logger().log(
            "Map class {} onto C++ class {} using {}".format(
                self._solver.name, class_name, templatefile_prefix
            )
        )
 
        qualified_class_name = "::".join(peano_project.namespace) + "::" + class_name
 
        local_d = {
            "NUMBER_OF_UNKNOWNS": self._solver._unknowns,
            "NUMBER_OF_AUXILIARY_VARIABLES": self._solver._auxiliary_variables,
            "PATCH_SIZE": self._solver.numerical_scheme.patch_size,
            "HALO_SIZE": self._solver.numerical_scheme.halo_size,
            "USER_SOLVER_INCLUDES": self._solver.user_solver_includes,
            "VARIABLES": self._variables_declaration(),
            "PDE_TERM_DECLARATIONS": "\n".join(
                term.generator.generate_declaration() for term in self._solver.pde_terms
            ),
            "PDE_TERM_DEFINITIONS": "\n".join(
                term.generator.generate_out_of_class_definitions(qualified_class_name)
                for term in self._solver.pde_terms
            ),
            "ADDITIONAL_ATTRIBUTES": "\n".join(
                self._solver._abstract_solver_attributes
            ),
            "ADDITIONAL_METHOD_DECLARATIONS": "\n".join(
                declaration
                for declaration, definition_generator in self._solver._abstract_solver_methods
            ),
            "ADDITIONAL_METHOD_DEFINITIONS": "\n".join(
                definition_generator(qualified_class_name)
                for declaration, definition_generator in self._solver._abstract_solver_methods
            ),
        }
 
        generated_files = (
            peano4.api.output.Jinja2TemplateStringHeaderImplementationFilePair(
                headerfile_template=self.TEMPLATE_ABSTRACT_HEADER_FILE,
                cppfile_template=self.TEMPLATE_ABSTRACT_CPP_FILE,
                classname=class_name,
                namespace=peano_project.namespace,
                subdirectory=peano_project.subdirectory,
                dictionary=local_d,
                default_overwrite=True,
                apply_iteratively=False,
            )
        )
        peano_project.output.add(generated_files)
        peano_project.output.makefile.add_cpp_file(
            peano_project.subdirectory + class_name + ".cpp", generated=True
        )
 
        if not self._solver.requires_user_class:
            return
 
        solver_class_name = self._solver.name
        qualified_solver_class_name = (
            "::".join(peano_project.namespace) + "::" + solver_class_name
        )
 
        solver_local_d = {
            "PDE_TERM_STUB_DECLARATIONS": "\n".join(
                term.generator.generate_stub_declaration()
                for term in self._solver.pde_terms
            ),
            "PDE_TERM_STUB_DEFINITIONS": "\n".join(
                term.generator.generate_stub_definition(qualified_solver_class_name)
                for term in self._solver.pde_terms
            ),
        }
 
        solver_generated_files = (
            peano4.api.output.Jinja2TemplateStringHeaderImplementationFilePair(
                headerfile_template=self.TEMPLATE_SOLVER_HEADER_FILE,
                cppfile_template=self.TEMPLATE_SOLVER_CPP_FILE,
                classname=solver_class_name,
                namespace=peano_project.namespace,
                subdirectory=peano_project.subdirectory,
                dictionary=solver_local_d,
                default_overwrite=False,
                apply_iteratively=False,
            )
        )
        peano_project.output.add(solver_generated_files)
        # Not flagged as generated: the user owns these files, so the
        # Makefile's clean targets must not delete them.
        peano_project.output.makefile.add_h_file(
            peano_project.subdirectory + solver_class_name + ".h", generated=False
        )
        peano_project.output.makefile.add_cpp_file(
            peano_project.subdirectory + solver_class_name + ".cpp", generated=False
        )