capytaine 3.0.0a1__cp314-cp314t-macosx_15_0_x86_64.whl

capytaine/tools/symbolic_multiplication.py

@@ -0,0 +1,161 @@
+"""This module is used for the handling of zero and infinite frequencies.
+In this cases, the magnitudes that the solver has to manipulate are in the form of ω times a non-zero term.
+Instead of evaluating this multiplication as zero of infinity, we keep it symbolic using the class defined here.
+
+The frequency can be provided to the solver as something like
+`SymbolicMultiplication("0", 1.0)` (that is zero) and the solver will return an
+output of the form `SymbolicMultiplication("0", np.array(...))`
+(that is also actually zero, except we may be intested in the non-zero array).
+"""
+
+import numpy as np
+from functools import wraps, total_ordering
+
+class SymbolicMultiplication:
+    def __init__(self, symbol, value=1.0):
+        self.symbol = symbol
+        self.value = value
+        if hasattr(value, "shape"):
+            self.shape = value.shape  # When wrapping Numpy arrays
+
+    def __format__(self, format_spec):
+        return f"{self.symbol}×{self.value.__format__(format_spec)}"
+
+    __array_priority__ = 1.0
+
+    def __array_function__(self, func, types, *args, **kwargs):
+        actual_args = args[0]  # args = (actual_args, kwargs) for some reason
+        if func in {np.real, np.imag, np.sum} and len(actual_args) == 1 and len(kwargs) == 0:
+            return SymbolicMultiplication(self.symbol, func(self.value))
+        elif (
+                func in {np.einsum} and
+                len([a for a in actual_args if isinstance(a, SymbolicMultiplication)]) == 1 and
+                "out" not in kwargs
+                ):
+            # Einsum with one of the array being wrapped in SymbolicMultiplication
+            unwrapped = [a.value if isinstance(a, SymbolicMultiplication) else a for a in actual_args]
+            return SymbolicMultiplication(self.symbol, func(*unwrapped, **kwargs))
+        else:
+            return NotImplemented
+
+    def astype(self, proper_type):
+        return SymbolicMultiplication(self.symbol, proper_type(self.value))
+
+    def __str__(self):
+        return f"{self.symbol}×{self.value}"
+
+    def __repr__(self):
+        return f"SymbolicMultiplication(\"{self.symbol}\", {repr(self.value)})"
+
+    def __add__(self, x):
+        return self._concretize() + x
+
+    def __radd__(self, x):
+        return x + self._concretize()
+
+    def __neg__(self):
+        return SymbolicMultiplication(self.symbol, -self.value)
+
+    def __mul__(self, x):
+        return SymbolicMultiplication(self.symbol, self.value * x)
+
+    def __rmul__(self, x):
+        return SymbolicMultiplication(self.symbol, x * self.value)
+
+    def __pow__(self, n):
+        if n == 2:
+            return self * self
+        else:
+            raise NotImplementedError
+
+    def __truediv__(self, x):
+        if hasattr(x, 'symbol') and self.symbol == x.symbol:
+            return self.value / x.value
+        else:
+            return SymbolicMultiplication(self.symbol, self.value / x)
+
+    def __rtruediv__(self, x):
+        if hasattr(x, 'symbol') and self.symbol == x.symbol:
+            return x.value / self.value
+        elif self.symbol == "0":
+            return SymbolicMultiplication("∞", x/self.value)
+        elif self.symbol == "∞":
+            return SymbolicMultiplication("0", x/self.value)
+        else:
+            raise NotImplementedError
+
+    def __matmul__(self, x):
+        return SymbolicMultiplication(self.symbol, self.value @ x)
+
+    def __rmatmul__(self, x):
+        return SymbolicMultiplication(self.symbol, x @ self.value)
+
+    def __getitem__(self, item):
+        return SymbolicMultiplication(self.symbol, self.value[item])
+
+    def __setitem__(self, item, val):
+        if isinstance(val, SymbolicMultiplication) and self.symbol == val.symbol:
+            self.value.__setitem__(item, val.value)
+        else:
+            raise NotImplementedError
+
+    def __lt__(self, x):
+        return self._concretize() < x
+
+    def __le__(self, x):
+        return self._concretize() <= x
+
+    def __eq__(self, x):
+        return self._concretize() == x
+
+    def __ge__(self, x):
+        return self._concretize() >= x
+
+    def __gt__(self, x):
+        return self._concretize() > x
+
+    def __hash__(self):
+        return hash((self.symbol, self.value))
+
+    def _concretize(self):
+        if isinstance(self.value, np.ndarray):
+            if self.symbol == "0":
+                return np.zeros_like(self.value)
+            elif self.symbol == "∞":
+                return np.full_like(self.value, np.inf)
+        else:
+            return float(self)
+
+    def __float__(self):
+        if self.symbol == "0":
+            return 0.0 * float(self.value)
+        elif self.symbol == "∞":
+            return np.inf * float(self.value)
+        else:
+            raise NotImplementedError
+
+    def reshape(self, *args):
+        return SymbolicMultiplication(self.symbol, self.value.reshape(*args))
+
+    def sum(self, *args, **kwargs):
+        return SymbolicMultiplication(self.symbol, self.value.sum(*args, **kwargs))
+
+    @property
+    def T(self):
+        return SymbolicMultiplication(self.symbol, self.value.T)
+
+
+def supporting_symbolic_multiplication(f):
+    """
+    When this decorator is applied to a function, this function can now take
+    as input a `SymbolicMultiplication` object. The function is applied on the
+    `value` part of the `SymbolicMultiplication` without modifying the
+    `symbol`.
+    """
+    @wraps(f)
+    def wrapped_f(a, x):
+        if hasattr(x, 'symbol'):
+            return SymbolicMultiplication(x.symbol, f(a, x.value))
+        else:
+            return f(a, x)
+    return wrapped_f

capytaine/tools/timer.py

@@ -0,0 +1,90 @@
+"""A simple timer class used to measure the time spent in various parts of the BEM solver."""
+
+from functools import wraps
+import time
+import contextlib
+
+import pandas as pd
+
+class Timer:
+    """A timer class that can be used as context manager or as decorator using `wraps_function` method.
+    Several timing measurement can be nested.
+
+    Attributes
+    ----------
+    timings: List[Dict]]
+        List of records of each timing measurement.
+        The record is a dict with a 'timing' key and any number of other metadata keys.
+    default_tags: Optional[Dict]
+        Tags added to all the timing measurements.
+    _start_times: List[float]
+        Start times of the ongoing timing measurements.
+
+    Example
+    -------
+    ::
+        from time import sleep  # For testing
+
+        timer = Timer()
+
+        with timer(tag="run 1"):
+            sleep(1.0)
+
+        print(timer.total)  # 1.0...
+
+        @timer.wraps_function(tag="run function")
+        def my_function():
+            sleep(0.5)
+
+        my_function()
+        print(timer.total)  # 1.5...
+        my_function()
+        print(timer.total)  # 2.0...
+
+        with timer(tag="outer"):
+            sleep(0.3)
+            with timer(tag="inner"):
+                sleep(0.3)
+            sleep(0.3)
+    """
+    def __init__(self, *, default_tags=None):
+        self.timings = []
+        if default_tags is None:
+            default_tags = {}
+        self.default_tags = default_tags
+        self._start_times = []  # Starting time of ongoing sub-timers
+
+    def __repr__(self):
+        return f"Timer({self.timings})"
+
+    def add_data_from_other_timer(self, other, **supplementary_tags):
+        self.timings.extend([{**t, **supplementary_tags} for t in other.timings])
+
+    @contextlib.contextmanager
+    def __call__(self, **tags):
+        self._start_times.append(time.perf_counter())
+        try:
+            yield
+        finally:
+            timing = time.perf_counter() - self._start_times.pop()
+            self.timings.append({'timing': timing, **tags, **self.default_tags})
+
+    def wraps_function(self, **tags):
+        def wrapper(f):
+            @wraps(f)
+            def wrapped_f(*args, **kwargs):
+                with self(**tags):
+                    out = f(*args, **kwargs)
+                return out
+            return wrapped_f
+        return wrapper
+
+    def as_dataframe(self):
+        if len(self.timings) == 0:
+            return pd.DataFrame([{'timing': 0.0}])
+        else:
+            return pd.DataFrame(self.timings)
+
+    @property
+    def total(self):
+        return self.as_dataframe()['timing'].sum()

capytaine/ui/cli.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# coding: utf-8
+"""Experimental command-line interface for Capytaine."""
+# Copyright (C) 2017-2023 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import argparse
+
+import capytaine as cpt
+from capytaine.io.legacy import run_cal_file
+
+cpt.set_logging()
+
+parser = argparse.ArgumentParser(description="Command-line interface for Capytaine taking Nemoh.cal files as input and returning Tecplots files.")
+parser.add_argument('paramfiles',
+                    default=['./Nemoh.cal'],
+                    nargs='*',
+                    help='path of parameters files (default: ./Nemoh.cal)')
+
+
+def main():
+    args = parser.parse_args()
+    for paramfile in args.paramfiles:
+        run_cal_file(paramfile)
+
+
+if __name__ == '__main__':
+    main()

capytaine/ui/rich.py

@@ -0,0 +1,5 @@
+import logging
+from rich.logging import RichHandler
+
+def set_logging(level="INFO"):
+    logging.basicConfig(level=level, format="%(message)s", handlers=[RichHandler(level=level, log_time_format="[%X]", show_path=False)], force=True)