custemx 0.9.5.1__py3-none-any.whl

custemx/Types table.md

@@ -0,0 +1,45 @@
+# Types table
+
+# Numpy
+np.ndarray:
+    Numpy Array
+
+# Petsc
+petsc4py.PETSc.Mat
+    System matrix
+
+petsc4py.PETSc.Vec
+    Right hand side
+
+# dolfinx
+dfx.mesh.Mesh
+    Dolfinx Mesh
+
+dfx.mesh.MeshTags
+    Marker for a mesh
+
+dfx.fem.Constant
+    Constant function on a mesh
+
+dfx.fem.FunctionSpace
+    Function space for dof definition
+
+dfx.fem.function.Function
+    Empty dolfinx function for coeffiecients
+
+# UFL
+ufl.argument.Argument
+    e.g. u = ufl.TrialFunction(V)
+    e.g. v = ufl.TestFunction(V)
+
+# pyGIMLi
+pg.Mesh
+    pyGIMLi mesh
+
+# MPI
+mpi4py.MPI.Intracomm
+    Communicator for the different MPI processes
+
+# custEMx
+cx.mod.ModelParameter
+    Model parameter class instance

custemx/__init__.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+@author: Rochlitz & Skibbe
+
+Main initialization file for the custEMx module.
+Imports submodules and configuration file as well as the logger instance.
+"""
+import logging
+import dolfinx as dx
+from pathlib import Path
+import tempfile
+import json
+import mpi4py.MPI as MPI
+from logging.handlers import MemoryHandler
+
+# CONFIG
+class _cfg():
+    """ Class for handling the configuration of the custemx module."""
+    def __init__(self, config='custemx_config.json') -> dict:
+        # dolfinx mesh partitioner
+        self._partitioner = None
+        with open(Path(__file__).with_name(config), 'r') as infile:
+            self._cfg = json.load(infile)
+
+        for key in self._cfg.keys():
+            setattr(self, key, self._cfg[key])
+
+        if not hasattr(self, 'global_timeout') or self.global_timeout == 0:
+            self.global_timeout = None
+
+        self.basepath = Path(__file__).parent
+        self.testpath = self.basepath.parent.joinpath('pytest')
+
+    @property
+    def partitioner(self):
+        """Get the mesh partitioner for dolfinx meshes."""
+        if self._partitioner is None:
+            # FIXME allow ordering in module config
+            try:
+                from dolfinx.graph import partitioner_scotch
+                log.info('Use partitioner "Scotch"')
+                use_partitioner = partitioner_scotch()
+            except ImportError:
+                try:
+                    from dolfinx.graph import partitioner_kahip
+                    log.info('Use partitioner "Kahip"')
+                    use_partitioner = partitioner_kahip()
+                except ImportError:
+                    try:
+                        from dolfinx.graph import partitioner_parmetis
+                        log.info('Use partitioner "Parmetis"')
+                        use_partitioner = partitioner_parmetis()
+                    except ImportError:
+                        pass
+            finally:
+                if use_partitioner is not None:
+                    self._partitioner =\
+                        dx.mesh.create_cell_partitioner(use_partitioner)
+        return self._partitioner
+
+cfg = _cfg()
+
+# LOGGER
+log = logging.getLogger('cx')
+_MEMORY_EXPORT_FMT = '%(asctime)s %(message)s'
+_MEMORY_EXPORT_DATEFMT = '%Y-%m-%d %H:%M:%S'
+
+# Custom logging level between INFO (20) and WARNING (30)
+NOTICE = 25
+logging.addLevelName(NOTICE, "NOTICE")
+
+
+def _notice(self, message, *args, **kwargs):
+    if self.isEnabledFor(NOTICE):
+        self._log(NOTICE, message, args, **kwargs)
+
+
+def _log_line(self, char="-", length=80):
+    if MPI.COMM_WORLD.rank == 0:
+        """Print a separator line without logging prefix."""
+        if log.level < 24:
+            print(char * length, flush=True)
+
+
+def _log_header(self, text, char="-", length=80):
+    if MPI.COMM_WORLD.rank == 0:
+        """Print header lines without logging prefix."""
+        if log.level < 24:
+            print(char * length, flush=True)
+            print(text, flush=True)
+            print(char * length, flush=True)
+
+
+def _ensure_root_console_handler(root_logger):
+    """Set the formatter of all root console handlers."""
+
+    if not root_logger.handlers:
+        root_logger.addHandler(logging.StreamHandler())
+
+    elif len(root_logger.handlers) > 1:
+        root_logger.handlers = [root_logger.handlers[0]]
+
+    for handler in root_logger.handlers:
+        if isinstance(handler, logging.StreamHandler):
+            handler.setFormatter(
+                logging.Formatter(
+                    fmt='CX - %(levelname)s - %(asctime)s - %(message)s',
+                    datefmt='%H:%M:%S'))
+
+def _ensure_memory_handler(logger):
+    """Keep one MemoryHandler on cx logger for logfile message export."""
+    memory_handlers = [h for h in logger.handlers if
+                       isinstance(h, MemoryHandler)]
+    if memory_handlers:
+        memory_handler = memory_handlers[0]
+    else:
+        memory_handler = MemoryHandler(
+            capacity=99999,
+            flushLevel=logging.CRITICAL,
+        )
+
+    memory_handler.setLevel(logging.NOTSET)
+    memory_handler.setFormatter(
+        logging.Formatter(
+            fmt=_MEMORY_EXPORT_FMT,
+            datefmt=_MEMORY_EXPORT_DATEFMT,
+        )
+    )
+
+    # Keep cx handler setup minimal and deterministic: memory capture locally,
+    # console output through root logger propagation.
+    logger.handlers = [memory_handler]
+    logger.propagate = True
+
+
+def _get_memory_messages(logger):
+    """Return buffered messages from cx MemoryHandler."""
+    memory_handler = next(
+        (h for h in logger.handlers if isinstance(h, MemoryHandler)),
+        None,
+    )
+    messages = []
+    if memory_handler is not None:
+        for record in memory_handler.buffer:
+            try:
+                messages.append(memory_handler.formatter.format(record))
+            except Exception:
+                messages.append(record.getMessage())
+    return messages
+
+logging.Logger.notice = _notice
+log.get_messages = lambda: _get_memory_messages(log)
+log.line = _log_line.__get__(log, logging.Logger)
+log.header = _log_header.__get__(log, logging.Logger)
+log.setLevel(cfg.log_level)
+
+if MPI.COMM_WORLD.rank != 0:
+    log.setLevel(40)
+
+# VERSION
+try:
+    from importlib.metadata import version, PackageNotFoundError
+    __version__ = version("custemx")
+except PackageNotFoundError:
+    __version__ = None
+
+# SUBMODULES
+from . import mod
+from . import misc
+from . import plot
+from . import fe
+from . import meshtools
+from . import io
+from . import solver
+from . import inv
+
+
+_ensure_root_console_handler(log.root)
+_ensure_memory_handler(log)
+
+# init default model parameters
+mod.update_default_model_parameter(version=__version__)

custemx/custemx_config.json

@@ -0,0 +1,21 @@
+{
+    "log_level": 20,
+    "max_cpu": 64,
+    "cpu_per_task": 16,
+    "global_timeout": 86400,
+    "inner_maxiter_warning": 50,
+    "petsc_options": {
+        "mumps": {
+            "ksp_type": "preonly",
+            "mat_mumps_cntl_1": 1e-8,
+            "mat_mumps_cntl_2": 1e-8,
+            "mat_mumps_icntl_8": 0,
+            "mat_mumps_icntl_14": 80,
+            "mat_mumps_icntl_48": 0,
+            "pc_factor_reuse_ordering": true,
+            "pc_factor_reuse_fill": true,
+            "pc_type": "cholesky",
+            "pc_factor_mat_solver_type": "mumps"
+        }
+    }
+}

custemx/fe/__init__.py

@@ -0,0 +1,38 @@
+"""
+This file is part of custemx.
+Licensed under the GNU LGPLv3, see LICENSE for details.
+
+Authors: Nico Skibbe, Raphael Rochlitz
+
+Public finite-element formulations and helper exports.
+"""
+
+from .fe_class import BaseFormulation
+from .fe_forms import FormEFD
+from .fe_lib import (
+    LocalAssembler,
+    adjust_parameter,
+    check_attributes,
+    check_cell_markers,
+    create_delta_sigma,
+    eval_current_dir,
+    find_source_dofs_geometrical,
+    get_boundary_dofs,
+    parameter_to_array,
+)
+from .primary_fields import PF
+
+__all__ = [
+    "BaseFormulation",
+    "FormEFD",
+    "LocalAssembler",
+    "adjust_parameter",
+    "check_attributes",
+    "check_cell_markers",
+    "create_delta_sigma",
+    "eval_current_dir",
+    "find_source_dofs_geometrical",
+    "get_boundary_dofs",
+    "parameter_to_array",
+    "PF",
+]