Source code for src.mesh

# -*- coding: utf-8 -*-
# noinspection PyUnresolvedReferences
.. _docs-mesh:


We define an abstract mesh based on an abstract manifold by calling ``ph.mesh`` method,

    .. autofunction:: src.mesh.mesh

As an example,

>>> mesh = ph.mesh(manifold)

The output, ``mesh``, is an instance of :class:`Mesh`. And similarly, it is abstract at this stage.

    .. autoclass:: src.mesh.Mesh
        :members: m, n, manifold

You can print a list of defined meshes by

>>> ph.list_meshes()  # doctest: +ELLIPSIS
Existing meshes:...

from tools.frozen import Frozen
from src.config import _mesh_default_sym_repr
from src.config import _check_sym_repr
from src.config import _parse_lin_repr
from src.config import _mesh_default_lin_repr
from src.spaces.main import set_mesh

from src.config import _mesh_partition_sym_repr, _mesh_partition_lin_repr

_global_meshes = dict()    # all meshes are cached, and all sym_repr and lin_repr are different.

[docs] def mesh(manifold, sym_repr=None, lin_repr=None): """Generate an abstract mesh over an abstract manifold. It is actually a wrapper of the ``__init__`` method of :class:`Mesh`. Parameters ---------- manifold : :class:`Manifold` The abstract manifold this mesh is built on. sym_repr : {None, str}, optional The symbolic representation of the mesh. If it is ``None``, we will use a pre-set symbolic representation. The default is ``None``. lin_repr : {None, str}, optional The linguistic representation of the mesh. If it is ``None``, we will use a pre-set linguistic representation. The default is ``None``. Returns ------- mesh : :class:`Mesh` The abstract mesh instance. """ return Mesh( manifold, sym_repr=sym_repr, lin_repr=lin_repr, )
def _list_meshes(): """""" from src.config import RANK, MASTER_RANK if RANK != MASTER_RANK: return else: pass print('Existing meshes:') print('{:>25} - {}'.format('---------------- symbolic', '<manifold> -------------------------')) for rp in _global_meshes: print('{:>25} | {}'.format(rp, _global_meshes[rp].manifold))
[docs] class Mesh(Frozen): # Mesh - def __init__(self, manifold, sym_repr=None, lin_repr=None): self._objective = None # when initializing, it has no objective instance. And when we generate an objective of this # abstract mesh, we store the last objective one with this attribute. assert manifold.__class__.__name__ == 'Manifold', f"I need a manifold." self._manifold = manifold assert manifold._covered_by_mesh is None, f"we already made an abstract mesh for this manifold." manifold._covered_by_mesh = self if sym_repr is None: number_existing_meshes = len(_global_meshes) base_repr = _mesh_default_sym_repr if number_existing_meshes == 0: sym_repr = base_repr else: sym_repr = base_repr + r'_{' + str(number_existing_meshes) + '}' else: pass sym_repr = _check_sym_repr(sym_repr) if lin_repr is None: base_repr = _mesh_default_lin_repr number_existing_meshes = len(_global_meshes) if number_existing_meshes == 0: lin_repr = base_repr else: lin_repr = base_repr + str(number_existing_meshes) assert sym_repr not in _global_meshes, \ f"Manifold symbolic representation is illegal, pls specify a symbolic representation other than " \ f"{set(_global_meshes.keys())}" for _ in _global_meshes: _m = _global_meshes[_] assert lin_repr != _m._lin_repr lin_repr, pure_lin_repr = _parse_lin_repr('mesh', lin_repr) self._sym_repr = sym_repr self._lin_repr = lin_repr self._pure_lin_repr = pure_lin_repr _global_meshes[sym_repr] = self if len(_global_meshes) == 1: # we just initialize the first mesh set_mesh(self) # we set it as the default mesh self._boundary = None self._interface = None self._inclusion = None self._freeze() @property def ndim(self): """""" return self._manifold.ndim @property def n(self): """The dimensions of the manifold.""" return self.ndim @property def m(self): """The dimensions of the embedding space.""" return self._manifold.m def __repr__(self): """""" super_repr = super().__repr__().split('object')[-1] return '<Mesh ' + self._sym_repr + super_repr # this will be unique. @property def manifold(self): """The manifold this mesh is built on.""" return self._manifold # it is regarded as an operator, so do not use @property def boundary(self): """Give a mesh of dimensions (n-1) on the boundary manifold.""" if self._boundary is None: manifold_boundary = self.manifold.boundary() if manifold_boundary.__class__.__name__ == 'Manifold': self._boundary = Mesh( manifold_boundary, sym_repr=r'\eth' + self._sym_repr, lin_repr=r'boundary-of-' + self._pure_lin_repr ) self._boundary._inclusion = self elif manifold_boundary.__class__.__name__ == 'NullManifold': self._boundary = NullMesh(manifold_boundary) else: raise NotImplementedError() return self._boundary def inclusion(self): """Give the mesh of dimensions (n+1) on the inclusion manifold.""" return self._inclusion def boundary_partition(self, *sym_reprs, config_name=None): """Define boundary sections by partition the mesh boundary into sections defined by `*sym_reprs`.""" if self._boundary is None: _ = self.boundary() else: pass _boundary = self.manifold.boundary() sub_manifolds = _boundary.partition(*sym_reprs, config_name=config_name) for sub_manifold in sub_manifolds: sr0, sr1 = _mesh_partition_sym_repr if sub_manifold._covered_by_mesh is None: self.__class__( sub_manifold, sym_repr=sr0 + sub_manifold._sym_repr + sr1, lin_repr=_mesh_partition_lin_repr + sub_manifold._pure_lin_repr, ) # it will be automatically saved to _global_meshes. else: pass
class NullMesh(Frozen): """A mesh that is constructed upon a null manifold.""" def __init__(self, null_manifold): self._null_manifold = null_manifold self._freeze() @property def ndim(self): return self._null_manifold.ndim