SimiLie
Loading...
Searching...
No Matches
generate_cpp_hamiltonian.py
1#!/usr/bin/env python3
2# SPDX-FileCopyrightText: 2026 Baptiste Legouix
3# SPDX-License-Identifier: AGPL-3.0-or-later
4# AI-GENERATED
5
6from __future__ import annotations
7
8from dataclasses import dataclass
9from pathlib import Path
10
11from sympy import Derivative, Subs, Symbol, diff, powsimp, solve, symbols
12from sympy.printing.codeprinter import cxxcode
13
14
15@dataclass(frozen=True)
17 value_expression: str
18 derivative_expressions: dict[int, str]
19
20
21@dataclass(frozen=True)
23 namespace: str
24 struct_name: str
25 parameters: list[str]
26 hamiltonian: object
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
36
37
38def _flatten_variable_entries(entries: list[object]) -> list[object]:
39 flattened: list[object] = []
40 for entry in entries:
41 if isinstance(entry, (list, tuple)):
42 flattened.extend(_flatten_variable_entries(list(entry)))
43 else:
44 flattened.append(entry)
45 return flattened
46
47
48def _entry_symbols(entry: object) -> list[object]:
49 if isinstance(entry, (list, tuple)):
50 return _flatten_variable_entries(list(entry))
51 return [entry]
52
53
54def _entry_name(entry: object) -> str:
55 symbols_ = _entry_symbols(entry)
56 if len(symbols_) == 1:
57 return str(symbols_[0])
58 first_name = str(symbols_[0])
59 prefix = first_name.rstrip("0123456789")
60 return prefix if prefix else first_name
61
62
63def _replace_symbols(expression: str, replacements: dict[str, str]) -> str:
64 for source, target in sorted(
65 replacements.items(), key=lambda replacement: len(replacement[0]), reverse=True
66 ):
67 expression = expression.replace(source, target)
68 return expression
69
70
72 expression,
73 replacements: dict[str, str],
74 symbolic_functions: dict[str, SymbolicFunctionDefinition] | None = None,
75 expression_replacements: dict[object, str] | None = None,
76) -> str:
77 symbolic_functions = symbolic_functions or {}
78 expression_replacements = expression_replacements or {}
79 placeholder_replacements: dict[str, str] = {}
80
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
86 subexpression,
87 replacements,
88 symbolic_functions,
89 expression_replacements,
90 )
91
92 def placeholder(rendered_expression: str) -> Symbol:
93 symbol = Symbol(f"__similie_symbolic_function_{len(placeholder_replacements)}")
94 placeholder_replacements[str(symbol)] = rendered_expression
95 return symbol
96
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
103 ),
104 lambda node, definition=function_definition: placeholder(
105 definition.derivative_expressions[node.expr.derivative_count].format(
106 argument=render_subexpression(node.point[0])
107 )
108 ),
109 )
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])
115 )
116 ),
117 )
118
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),
123 )
124
125 return _replace_symbols(
126 _replace_symbols(cxxcode(expression), replacements),
127 placeholder_replacements,
128 )
129
130
131def _render_members(parameters: list[tuple[str, str, bool, str]]) -> str:
132 return "\n".join(
133 f" {'const ' if is_const else ''}{type_name} {name};"
134 for name, _, is_const, type_name in parameters
135 )
136
137
139 struct_name: str, parameters: list[tuple[str, str, bool, str]]
140) -> str:
141 params = ",\n ".join(
142 (
143 f"{type_name} const {constructor_name}_"
144 if type_name in {"double", "float", "int", "bool", "std::size_t"}
145 else f"{type_name} const& {constructor_name}_"
146 )
147 for _, constructor_name, _, type_name in parameters
148 )
149 return f" KOKKOS_FUNCTION constexpr {struct_name}(\n {params})"
150
151
153 parameters: list[tuple[str, str, bool, str]],
154) -> str:
155 return ", ".join(
156 f"{name}({constructor_name}_)" for name, constructor_name, _, _ in parameters
157 )
158
159
161 name: str,
162 expressions: list,
163 replacements: dict[str, str],
164 symbolic_functions: dict[str, SymbolicFunctionDefinition],
165) -> str:
166 cases = "\n".join(
167 f""" {"if" if i == 0 else "else if"} constexpr (Index::value == {i}) {{
168 return {_render_cxx_expression(expression, replacements, symbolic_functions)};
169 }}"""
170 for i, expression in enumerate(expressions)
171 )
172 return f"""
173 template <class Index, class Elem>
174 [[nodiscard]] KOKKOS_FUNCTION constexpr double {name}(State const& state, Elem const& elem) const
175 {{
176 static_cast<void>(state);
177 static_cast<void>(elem);
178{cases}
179 else {{
180 static_assert(Index::value < {len(expressions)}, "unsupported component index");
181 return 0.0;
182 }}
183 }}
184"""
185
186
188 output_path: Path,
189 namespace: str,
190 struct_name: str,
191 parameters: list[tuple[str, str, bool, str]],
192 hamiltonian,
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,
200) -> 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 {})
205 )
206 replacements = {
207 constructor_name: (
208 f"({parameter_value_expressions[constructor_name]})"
209 if constructor_name in parameter_value_expressions
210 else member_name
211 )
212 for member_name, constructor_name, _, _ in parameters
213 }
214 state_members = []
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} {{}};"
219 )
220 replacements.update(
221 {
222 str(symbol): f"state.{field_name}[{component}]"
223 for component, symbol in enumerate(entry["symbols"])
224 }
225 )
226 potential_symbols = variable_entries[0]["symbols"]
227 moment_symbols = variable_entries[1]["symbols"]
228 potential_method = _render_state_component_method(
229 "dhamiltonian_dpotential",
230 [powsimp(diff(hamiltonian, symbol)) for symbol in potential_symbols],
231 replacements,
232 symbolic_functions,
233 )
234 moment_method = _render_state_component_method(
235 "dhamiltonian_dmoments",
236 [powsimp(diff(hamiltonian, symbol)) for symbol in moment_symbols],
237 replacements,
238 symbolic_functions,
239 )
240 inverse_method = ""
241 if inverse_expressions is not None:
242 inverse_replacements = {
243 **replacements,
244 **{
245 symbol: f"state.moments[{i}]"
246 for i, symbol in enumerate(inverse_symbols)
247 },
248 }
249 inverse_method = _render_state_component_method(
250 "moments",
251 inverse_expressions,
252 inverse_replacements,
253 symbolic_functions,
254 )
255 jacobian_cases = []
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)};
262 }}"""
263 )
264 template_prefix = (
265 ""
266 if not template_parameters
267 else "template <" + ", ".join(template_parameters) + ">\n"
268 )
269 rendered_includes = "".join(f"#include {header}\n" for header in includes or [])
270 initializers = _render_constructor_initializers(parameters)
271 constructor = _render_constructor_signature(struct_name, parameters)
272 if initializers:
273 constructor += f"\n : {initializers} {{}}"
274 else:
275 constructor += " {}"
276 concept_type = struct_name
277 concept_arguments = []
278 parameter_types = (
279 set()
280 if definition is None
281 else set((definition.parameter_types or {}).values())
282 )
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}>")
288 else:
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(
294 f"""\
295// SPDX-FileCopyrightText: 2026 Baptiste Legouix
296// SPDX-License-Identifier: AGPL-3.0-or-later
297// AI-GENERATED
298
299#pragma once
300
301#include <array>
302#include <cmath>
303#include <cstddef>
304#include <span>
305#include <type_traits>
306#include <Kokkos_Core.hpp>
307#include <similie/exterior/form.hpp>
308#include <similie/physics/concepts.hpp>
309{rendered_includes}
310
311namespace {namespace} {{
312
313{"" if definition is None else definition.namespace_preamble}
314
315{template_prefix}class {struct_name}
316{{
317{_render_members(parameters)}
318
319public:
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"};
322
323 struct State
324 {{
325{chr(10).join(state_members)}
326 }};
327
328{constructor}
329
330 template <class Elem>
331 [[nodiscard]] KOKKOS_FUNCTION constexpr sil::exterior::Form<double> hamiltonian(State const& state, Elem const& elem) const
332 {{
333 static_cast<void>(elem);
334 return sil::exterior::Form<double>({_render_cxx_expression(hamiltonian, replacements, symbolic_functions)});
335 }}
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
339 {{
340 static_cast<void>(state);
341 static_cast<void>(elem);
342{chr(10).join(jacobian_cases)}
343 else {{
344 static_assert(RowIndex::value < N && ColumnIndex::value < N, "unsupported moment indices");
345 return 0.0;
346 }}
347 }}
348}};
349
350{checks}
351{"" if definition is None else definition.namespace_epilogue}
352}} // namespace {namespace}
353"""
354 )
355
356
357def generate_cpp_hamiltonian(functor_class, output_path: Path, *args, **kwargs) -> None:
358 definition = functor_class.__call__(*args, **kwargs)
359 parameter_types = definition.parameter_types or {}
360 parameter_tuples = [
361 (f"m_{name}", name, True, parameter_types.get(name, "double"))
362 for name in definition.parameters
363 ]
364
365 inverse_symbols = None
366 inverse_expressions = None
367 variable_entries = [
368 {"name": _entry_name(entry), "symbols": _entry_symbols(entry)}
369 for entry in definition.variables
370 ]
371
372 flat_variables = _flatten_variable_entries(list(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(
376 [
377 dphi_dx_symbols[i]
378 - diff(definition.hamiltonian, variable_entries[1]["symbols"][i])
379 for i in range(len(variable_entries[1]["symbols"]))
380 ],
381 variable_entries[1]["symbols"],
382 dict=True,
383 )
384 if inverse_solution:
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"]))
389 ]
390
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,
404 )
list[object] _entry_symbols(object entry)
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)
str _render_constructor_initializers(list[tuple[str, str, bool, str]] parameters)
str _render_constructor_signature(str struct_name, list[tuple[str, str, bool, str]] parameters)
str _replace_symbols(str expression, dict[str, str] replacements)
str _render_members(list[tuple[str, str, bool, str]] parameters)
str _render_state_component_method(str name, list expressions, dict[str, str] replacements, dict[str, SymbolicFunctionDefinition] symbolic_functions)
list[object] _flatten_variable_entries(list[object] entries)