11from sympy
import Derivative, Subs, Symbol, diff, powsimp, solve, symbols
27 variables: list[object]
28 includes: list[str] |
None =
None
29 template_parameters: list[str] |
None =
None
30 parameter_types: dict[str, str] |
None =
None
31 parameter_value_expressions: dict[str, str] |
None =
None
32 symbolic_functions: dict[str, SymbolicFunctionDefinition] |
None =
None
33 namespace_preamble: str =
""
34 namespace_epilogue: str =
""
35 is_linear: bool =
False
64 for source, target
in sorted(
65 replacements.items(), key=
lambda replacement: len(replacement[0]), reverse=
True
67 expression = expression.replace(source, target)
73 replacements: dict[str, str],
74 symbolic_functions: dict[str, SymbolicFunctionDefinition] |
None =
None,
75 expression_replacements: dict[object, str] |
None =
None,
77 symbolic_functions = symbolic_functions
or {}
78 expression_replacements = expression_replacements
or {}
79 placeholder_replacements: dict[str, str] = {}
81 def render_subexpression(subexpression) -> str:
82 for source_expression, target_expression
in expression_replacements.items():
83 if subexpression == source_expression:
84 return target_expression
89 expression_replacements,
92 def placeholder(rendered_expression: str) -> Symbol:
93 symbol = Symbol(f
"__similie_symbolic_function_{len(placeholder_replacements)}")
94 placeholder_replacements[str(symbol)] = rendered_expression
97 for function_name, function_definition
in symbolic_functions.items():
98 expression = expression.replace(
99 lambda node, name=function_name: (
100 isinstance(node, Subs)
101 and isinstance(node.expr, Derivative)
102 and node.expr.expr.func.__name__ == name
104 lambda node, definition=function_definition: placeholder(
105 definition.derivative_expressions[node.expr.derivative_count].format(
106 argument=render_subexpression(node.point[0])
110 expression = expression.replace(
111 lambda node, name=function_name: node.func.__name__ == name,
112 lambda node, definition=function_definition: placeholder(
113 definition.value_expression.format(
114 argument=render_subexpression(node.args[0])
119 for source_expression, target_expression
in expression_replacements.items():
120 expression = expression.replace(
121 lambda node, source=source_expression: node == source,
122 lambda node, target=target_expression: placeholder(target),
127 placeholder_replacements,
191 parameters: list[tuple[str, str, bool, str]],
193 variable_entries: list[dict[str, object]],
194 includes: list[str] |
None =
None,
195 inverse_symbols: list[str] |
None =
None,
196 inverse_expressions: list |
None =
None,
197 template_parameters: list[str] |
None =
None,
198 parameter_value_expressions: dict[str, str] |
None =
None,
199 definition: HamiltonianDefinition |
None =
None,
201 output_path.parent.mkdir(parents=
True, exist_ok=
True)
202 parameter_value_expressions = parameter_value_expressions
or {}
203 symbolic_functions = (
204 {}
if definition
is None else (definition.symbolic_functions
or {})
208 f
"({parameter_value_expressions[constructor_name]})"
209 if constructor_name
in parameter_value_expressions
212 for member_name, constructor_name, _, _
in parameters
215 for i, entry
in enumerate(variable_entries):
216 field_name =
"potential" if i == 0
else "moments" if i == 1
else entry[
"name"]
217 state_members.append(
218 f
" sil::exterior::Form<std::array<double, {len(entry['symbols'])}>> {field_name} {{}};"
222 str(symbol): f
"state.{field_name}[{component}]"
223 for component, symbol
in enumerate(entry[
"symbols"])
226 potential_symbols = variable_entries[0][
"symbols"]
227 moment_symbols = variable_entries[1][
"symbols"]
229 "dhamiltonian_dpotential",
230 [powsimp(diff(hamiltonian, symbol))
for symbol
in potential_symbols],
235 "dhamiltonian_dmoments",
236 [powsimp(diff(hamiltonian, symbol))
for symbol
in moment_symbols],
241 if inverse_expressions
is not None:
242 inverse_replacements = {
245 symbol: f
"state.moments[{i}]"
246 for i, symbol
in enumerate(inverse_symbols)
252 inverse_replacements,
256 for row, row_symbol
in enumerate(moment_symbols):
257 for column, column_symbol
in enumerate(moment_symbols):
258 expression = diff(diff(hamiltonian, row_symbol), column_symbol)
259 jacobian_cases.append(
260 f
""" {"if" if not jacobian_cases else "else if"} constexpr (RowIndex::value == {row} && ColumnIndex::value == {column}) {{
261 return {_render_cxx_expression(expression, replacements, symbolic_functions)};
266 if not template_parameters
267 else "template <" +
", ".join(template_parameters) +
">\n"
269 rendered_includes =
"".join(f
"#include {header}\n" for header
in includes
or [])
273 constructor += f
"\n : {initializers} {{}}"
276 concept_type = struct_name
277 concept_arguments = []
280 if definition
is None
281 else set((definition.parameter_types
or {}).values())
283 for i, parameter
in enumerate(template_parameters
or []):
284 if parameter.split()[-1]
in parameter_types:
285 concept_arguments.append(
"similie::physics::detail::ParameterConcept")
286 elif "..." in parameter:
287 concept_arguments.append(f
"std::integral_constant<std::size_t, {i + 1}>")
289 concept_arguments.append(f
"std::integral_constant<std::size_t, {i}>")
290 if template_parameters:
291 concept_type +=
"<" +
", ".join(concept_arguments) +
">"
292 checks = f
"static_assert(similie::physics::HamiltonianPhysicsConcept<{concept_type}, similie::physics::detail::ElementConcept>);\n"
293 output_path.write_text(
295// SPDX-FileCopyrightText: 2026 Baptiste Legouix
296// SPDX-License-Identifier: AGPL-3.0-or-later
305#include <type_traits>
306#include <Kokkos_Core.hpp>
307#include <similie/exterior/form.hpp>
308#include <similie/physics/concepts.hpp>
311namespace {namespace} {{
313{"" if definition is None else definition.namespace_preamble}
315{template_prefix}class {struct_name}
317{_render_members(parameters)}
320 static constexpr std::size_t N = {len(moment_symbols)};
321 static constexpr bool IS_LINEAR = {"true" if definition is not None and definition.is_linear else "false"};
325{chr(10).join(state_members)}
330 template <class Elem>
331 [[nodiscard]] KOKKOS_FUNCTION constexpr sil::exterior::Form<double> hamiltonian(State const& state, Elem const& elem) const
333 static_cast<void>(elem);
334 return sil::exterior::Form<double>({_render_cxx_expression(hamiltonian, replacements, symbolic_functions)});
336{potential_method}{moment_method}{inverse_method}
337 template <class RowIndex, class ColumnIndex, class Elem>
338 [[nodiscard]] KOKKOS_FUNCTION constexpr double jacobian(State const& state, Elem const& elem) const
340 static_cast<void>(state);
341 static_cast<void>(elem);
342{chr(10).join(jacobian_cases)}
344 static_assert(RowIndex::value < N && ColumnIndex::value < N, "unsupported moment indices");
351{"" if definition is None else definition.namespace_epilogue}
352}} // namespace {namespace}
358 definition = functor_class.__call__(*args, **kwargs)
359 parameter_types = definition.parameter_types
or {}
361 (f
"m_{name}", name,
True, parameter_types.get(name,
"double"))
362 for name
in definition.parameters
365 inverse_symbols =
None
366 inverse_expressions =
None
369 for entry
in definition.variables
373 if variable_entries[0][
"name"] ==
"phi":
374 dphi_dx_symbols = symbols(f
"dphi_dx0:{len(variable_entries[1]['symbols'])}")
375 inverse_solution = solve(
378 - diff(definition.hamiltonian, variable_entries[1][
"symbols"][i])
379 for i
in range(len(variable_entries[1][
"symbols"]))
381 variable_entries[1][
"symbols"],
385 inverse_symbols = [str(symbol)
for symbol
in dphi_dx_symbols]
386 inverse_expressions = [
387 inverse_solution[0][variable_entries[1][
"symbols"][i]]
388 for i
in range(len(variable_entries[1][
"symbols"]))
392 output_path=output_path,
393 namespace=definition.namespace,
394 struct_name=definition.struct_name,
395 parameters=parameter_tuples,
396 hamiltonian=definition.hamiltonian,
397 variable_entries=variable_entries,
398 includes=definition.includes,
399 inverse_symbols=inverse_symbols,
400 inverse_expressions=inverse_expressions,
401 template_parameters=definition.template_parameters,
402 parameter_value_expressions=definition.parameter_value_expressions,
403 definition=definition,
str _render_cxx_expression(expression, dict[str, str] replacements, dict[str, SymbolicFunctionDefinition]|None symbolic_functions=None, dict[object, str]|None expression_replacements=None)
None write_cpp_hamiltonian_header(Path output_path, str namespace, str struct_name, list[tuple[str, str, bool, str]] parameters, hamiltonian, list[dict[str, object]] variable_entries, list[str]|None includes=None, list[str]|None inverse_symbols=None, list|None inverse_expressions=None, list[str]|None template_parameters=None, dict[str, str]|None parameter_value_expressions=None, HamiltonianDefinition|None definition=None)