morphogen 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- morphogen/__init__.py +60 -0
- morphogen/__main__.py +7 -0
- morphogen/_platform.py +55 -0
- morphogen/_public.py +153 -0
- morphogen/_utils.py +80 -0
- morphogen/_version.py +1 -0
- morphogen/analysis/__init__.py +174 -0
- morphogen/analysis/anisotropy.py +135 -0
- morphogen/analysis/basic.py +38 -0
- morphogen/analysis/cells.py +54 -0
- morphogen/analysis/connectivity.py +156 -0
- morphogen/analysis/correlation.py +195 -0
- morphogen/analysis/covariance.py +80 -0
- morphogen/analysis/fractal.py +54 -0
- morphogen/analysis/measures.py +188 -0
- morphogen/analysis/morphology.py +265 -0
- morphogen/analysis/particles.py +160 -0
- morphogen/analysis/percolation.py +2034 -0
- morphogen/analysis/power_laws.py +143 -0
- morphogen/analysis/random_sets.py +351 -0
- morphogen/analysis/stereology.py +289 -0
- morphogen/analysis/surface.py +107 -0
- morphogen/analysis/topology.py +92 -0
- morphogen/automata/__init__.py +74 -0
- morphogen/automata/engine.py +211 -0
- morphogen/automata/growth.py +686 -0
- morphogen/automata/lattice.py +143 -0
- morphogen/automata/reaction.py +255 -0
- morphogen/automata/rules.py +353 -0
- morphogen/automata/tilings.py +1715 -0
- morphogen/cli.py +3526 -0
- morphogen/config.py +2167 -0
- morphogen/contact/__init__.py +113 -0
- morphogen/contact/experiments.py +368 -0
- morphogen/contact/hertz.py +104 -0
- morphogen/contact/kernels.py +827 -0
- morphogen/contact/periodic.py +278 -0
- morphogen/contact/problem.py +578 -0
- morphogen/contact/surfaces.py +310 -0
- morphogen/coupling/__init__.py +43 -0
- morphogen/coupling/ageing.py +143 -0
- morphogen/coupling/diffusion.py +226 -0
- morphogen/coupling/fenicsx.py +484 -0
- morphogen/coupling/oxidation.py +447 -0
- morphogen/coupling/plates.py +247 -0
- morphogen/design/__init__.py +51 -0
- morphogen/design/csp.py +616 -0
- morphogen/design/frames.py +277 -0
- morphogen/design/search.py +287 -0
- morphogen/design/tiles.py +336 -0
- morphogen/distributions.py +312 -0
- morphogen/domain.py +203 -0
- morphogen/dynamics/__init__.py +179 -0
- morphogen/dynamics/model.py +638 -0
- morphogen/dynamics/openradioss.py +643 -0
- morphogen/dynamics/results.py +515 -0
- morphogen/fracture/__init__.py +170 -0
- morphogen/fracture/bulk.py +349 -0
- morphogen/fracture/cohesive.py +1614 -0
- morphogen/fracture/ductile.py +557 -0
- morphogen/fracture/lefm.py +1168 -0
- morphogen/fracture/mixed.py +1178 -0
- morphogen/fracture/periodic.py +733 -0
- morphogen/fracture/phasefield.py +714 -0
- morphogen/fracture/phasefield_finite.py +368 -0
- morphogen/fracture/surface.py +572 -0
- morphogen/fracture/toughness.py +566 -0
- morphogen/gpu.py +108 -0
- morphogen/gui/__init__.py +8 -0
- morphogen/gui/api.py +1927 -0
- morphogen/gui/desktop.py +387 -0
- morphogen/gui/icon.png +0 -0
- morphogen/gui/index.html +1909 -0
- morphogen/gui/server.py +229 -0
- morphogen/gui/tools/__init__.py +629 -0
- morphogen/gui/tools/compare.py +149 -0
- morphogen/gui/tools/contact.py +391 -0
- morphogen/gui/tools/couplings.py +1085 -0
- morphogen/gui/tools/crackfront.py +245 -0
- morphogen/gui/tools/design.py +224 -0
- morphogen/gui/tools/dynamics.py +824 -0
- morphogen/gui/tools/fracture.py +2586 -0
- morphogen/gui/tools/interop.py +1654 -0
- morphogen/gui/tools/learning.py +595 -0
- morphogen/gui/tools/mechanics.py +3881 -0
- morphogen/gui/tools/nonlocal_damage.py +1321 -0
- morphogen/gui/tools/phasefield.py +215 -0
- morphogen/gui/tools/physics.py +597 -0
- morphogen/gui/tools/stability.py +1756 -0
- morphogen/gui/tools/statistics.py +1408 -0
- morphogen/gui/viewer.js +1100 -0
- morphogen/homogenization/__init__.py +210 -0
- morphogen/homogenization/acoustics.py +566 -0
- morphogen/homogenization/amg.py +1005 -0
- morphogen/homogenization/apparent.py +1046 -0
- morphogen/homogenization/behaviours.cu +2285 -0
- morphogen/homogenization/behaviours.py +944 -0
- morphogen/homogenization/beremin.py +263 -0
- morphogen/homogenization/bifurcation.py +1085 -0
- morphogen/homogenization/bloch.py +507 -0
- morphogen/homogenization/bounds.py +226 -0
- morphogen/homogenization/core.py +458 -0
- morphogen/homogenization/coupled.py +1135 -0
- morphogen/homogenization/crystal.py +2967 -0
- morphogen/homogenization/dilatation.py +454 -0
- morphogen/homogenization/elements.py +157 -0
- morphogen/homogenization/fatigue.py +768 -0
- morphogen/homogenization/fe.py +1739 -0
- morphogen/homogenization/fenicsx.py +307 -0
- morphogen/homogenization/fft.py +499 -0
- morphogen/homogenization/fft_nonlinear.py +391 -0
- morphogen/homogenization/finite.py +613 -0
- morphogen/homogenization/flow.py +361 -0
- morphogen/homogenization/frames.py +1125 -0
- morphogen/homogenization/gpu.py +1241 -0
- morphogen/homogenization/harmonic.py +427 -0
- morphogen/homogenization/identification.py +579 -0
- morphogen/homogenization/kernels.py +760 -0
- morphogen/homogenization/laws.py +2061 -0
- morphogen/homogenization/materials.py +1080 -0
- morphogen/homogenization/mfront.py +589 -0
- morphogen/homogenization/networks.py +880 -0
- morphogen/homogenization/nonlinear.py +2612 -0
- morphogen/homogenization/ntfa.py +577 -0
- morphogen/homogenization/paths.py +476 -0
- morphogen/homogenization/photonic.py +467 -0
- morphogen/homogenization/poroelastic.py +212 -0
- morphogen/homogenization/porous.py +1120 -0
- morphogen/homogenization/postprocess.py +290 -0
- morphogen/homogenization/solvers.py +1140 -0
- morphogen/homogenization/tensors.py +240 -0
- morphogen/homogenization/voxel_fe.py +457 -0
- morphogen/homogenization/xfem.py +1016 -0
- morphogen/homogenization/zmat.py +1258 -0
- morphogen/iga/__init__.py +48 -0
- morphogen/iga/analysis.py +508 -0
- morphogen/iga/basis.py +214 -0
- morphogen/iga/geometry.py +501 -0
- morphogen/iga/homogenization.py +219 -0
- morphogen/iga/optimization.py +700 -0
- morphogen/iga/shapes.py +331 -0
- morphogen/image.py +128 -0
- morphogen/io/__init__.py +246 -0
- morphogen/io/amitex.py +741 -0
- morphogen/io/ebsd.py +881 -0
- morphogen/io/export.py +196 -0
- morphogen/io/geometry.py +158 -0
- morphogen/io/medit.py +147 -0
- morphogen/io/meshes.py +844 -0
- morphogen/io/metaimage.py +97 -0
- morphogen/io/mfront.py +1104 -0
- morphogen/io/native.py +57 -0
- morphogen/io/radioss.py +764 -0
- morphogen/io/solvers.py +371 -0
- morphogen/io/tables.py +278 -0
- morphogen/io/tiff.py +66 -0
- morphogen/io/vtk.py +701 -0
- morphogen/io/xdmf.py +200 -0
- morphogen/kernels/__init__.py +5 -0
- morphogen/kernels/annealing.py +192 -0
- morphogen/kernels/cells.py +69 -0
- morphogen/kernels/collective.py +87 -0
- morphogen/kernels/force_biased.py +595 -0
- morphogen/kernels/implicit.py +145 -0
- morphogen/kernels/leaves.py +132 -0
- morphogen/kernels/packing.py +304 -0
- morphogen/kernels/raster.py +279 -0
- morphogen/kernels/rsa.py +371 -0
- morphogen/kernels/union.py +135 -0
- morphogen/kernels/watershed.py +190 -0
- morphogen/laser/__init__.py +234 -0
- morphogen/laser/architectures.py +375 -0
- morphogen/laser/bending.py +216 -0
- morphogen/laser/cells.py +1694 -0
- morphogen/laser/design.py +940 -0
- morphogen/laser/figures.py +227 -0
- morphogen/laser/heat.py +804 -0
- morphogen/laser/materials.py +691 -0
- morphogen/laser/mechanics.py +1670 -0
- morphogen/laser/metallurgy.py +615 -0
- morphogen/laser/patterns.py +828 -0
- morphogen/laser/periodic.py +392 -0
- morphogen/laser/process.py +362 -0
- morphogen/laser/run.py +534 -0
- morphogen/laser/solid.py +216 -0
- morphogen/laser/specimen.py +200 -0
- morphogen/laser/structures.py +708 -0
- morphogen/learning/__init__.py +81 -0
- morphogen/learning/behaviour.py +398 -0
- morphogen/learning/data.py +328 -0
- morphogen/learning/learned.cpp +668 -0
- morphogen/learning/logarithmic.py +202 -0
- morphogen/learning/mfront.py +409 -0
- morphogen/learning/networks.py +767 -0
- morphogen/learning/run.py +212 -0
- morphogen/learning/standard.py +814 -0
- morphogen/learning/training.py +235 -0
- morphogen/mesh/__init__.py +29 -0
- morphogen/mesh/conforming.py +1423 -0
- morphogen/mesh/curved.py +600 -0
- morphogen/mesh/exact.py +1717 -0
- morphogen/mesh/octree.py +350 -0
- morphogen/mesh/polycrystal.py +1041 -0
- morphogen/mesh/polyhedra.py +677 -0
- morphogen/mesh/regularize.py +570 -0
- morphogen/mesh/surface.py +97 -0
- morphogen/mesh/tetra.py +512 -0
- morphogen/mesh/voxel.py +124 -0
- morphogen/micromorphic/__init__.py +31 -0
- morphogen/micromorphic/damage.py +359 -0
- morphogen/micromorphic/ductile.py +534 -0
- morphogen/micromorphic/finite.py +220 -0
- morphogen/micromorphic/microfoam.py +787 -0
- morphogen/micromorphic/space.py +341 -0
- morphogen/models/__init__.py +195 -0
- morphogen/models/affine.py +384 -0
- morphogen/models/automata.py +592 -0
- morphogen/models/base.py +500 -0
- morphogen/models/boolean.py +310 -0
- morphogen/models/bouligand.py +331 -0
- morphogen/models/branching.py +241 -0
- morphogen/models/combination.py +430 -0
- morphogen/models/deadleaves.py +766 -0
- morphogen/models/design.py +289 -0
- morphogen/models/ebsd.py +206 -0
- morphogen/models/fibers.py +1476 -0
- morphogen/models/foam.py +594 -0
- morphogen/models/gaussian.py +314 -0
- morphogen/models/growth.py +459 -0
- morphogen/models/hardcore.py +317 -0
- morphogen/models/hierarchical.py +269 -0
- morphogen/models/honeycomb.py +749 -0
- morphogen/models/implicit.py +177 -0
- morphogen/models/laminate.py +470 -0
- morphogen/models/lattice.py +351 -0
- morphogen/models/lattice_field.py +345 -0
- morphogen/models/levelset_foam.py +563 -0
- morphogen/models/nacre.py +411 -0
- morphogen/models/nested.py +924 -0
- morphogen/models/osteons.py +374 -0
- morphogen/models/pieces.py +167 -0
- morphogen/models/planar.py +126 -0
- morphogen/models/reconstruction.py +203 -0
- morphogen/models/scale_rich.py +1409 -0
- morphogen/models/scale_rich_3d.py +1616 -0
- morphogen/models/tessellation.py +735 -0
- morphogen/models/tiling_field.py +302 -0
- morphogen/models/tpms.py +197 -0
- morphogen/models/transparent.py +406 -0
- morphogen/models/union.py +141 -0
- morphogen/optimization/__init__.py +43 -0
- morphogen/optimization/cell.py +295 -0
- morphogen/optimization/filters.py +115 -0
- morphogen/optimization/mma.py +226 -0
- morphogen/optimization/run.py +219 -0
- morphogen/optimization/topology.py +632 -0
- morphogen/orientations.py +568 -0
- morphogen/parallel.py +599 -0
- morphogen/pipeline.py +978 -0
- morphogen/primitives.py +188 -0
- morphogen/results.py +564 -0
- morphogen/rve/__init__.py +73 -0
- morphogen/rve/report.py +627 -0
- morphogen/rve/scaling.py +363 -0
- morphogen/rve/study.py +1054 -0
- morphogen/rve/windows.py +345 -0
- morphogen/seeding.py +51 -0
- morphogen/settings.py +118 -0
- morphogen/stopping.py +48 -0
- morphogen/symmetry.py +384 -0
- morphogen/templates/activator_inhibitor.yaml +22 -0
- morphogen/templates/aggregation.yaml +23 -0
- morphogen/templates/boolean_cylinders.yaml +20 -0
- morphogen/templates/boolean_spheres.yaml +22 -0
- morphogen/templates/bouligand.yaml +28 -0
- morphogen/templates/cellular_automaton.yaml +25 -0
- morphogen/templates/coated_spheres.yaml +26 -0
- morphogen/templates/contact_fibers.yaml +27 -0
- morphogen/templates/cox_nanocomposite.yaml +22 -0
- morphogen/templates/cross_linked_fibers.yaml +26 -0
- morphogen/templates/curved_arcs.yaml +28 -0
- morphogen/templates/curved_fibers.yaml +24 -0
- morphogen/templates/dead_leaves.yaml +22 -0
- morphogen/templates/delaunay_network.yaml +22 -0
- morphogen/templates/dense_packing.yaml +22 -0
- morphogen/templates/diffusion.yaml +33 -0
- morphogen/templates/ebsd.yaml +34 -0
- morphogen/templates/ebsd_map.ctf +3087 -0
- morphogen/templates/fracture_composite.yaml +42 -0
- morphogen/templates/fracture_rubber.yaml +47 -0
- morphogen/templates/gaussian_excursion.yaml +17 -0
- morphogen/templates/graded_lattice.yaml +24 -0
- morphogen/templates/hardcore_fibers.yaml +22 -0
- morphogen/templates/hardcore_spheres.yaml +22 -0
- morphogen/templates/hierarchical_lattice.yaml +22 -0
- morphogen/templates/homogenization_acoustic_foam.yaml +36 -0
- morphogen/templates/homogenization_beremin.yaml +50 -0
- morphogen/templates/homogenization_cleavage.yaml +51 -0
- morphogen/templates/homogenization_cleavage_band.yaml +55 -0
- morphogen/templates/homogenization_contact.yaml +43 -0
- morphogen/templates/homogenization_crack_closure.yaml +49 -0
- morphogen/templates/homogenization_crystal_plasticity.yaml +50 -0
- morphogen/templates/homogenization_crystal_plasticity_fft.yaml +52 -0
- morphogen/templates/homogenization_crystallization.yaml +30 -0
- morphogen/templates/homogenization_debonding.yaml +43 -0
- morphogen/templates/homogenization_detwinning.yaml +58 -0
- morphogen/templates/homogenization_ductile_damage.yaml +47 -0
- morphogen/templates/homogenization_fatigue.yaml +40 -0
- morphogen/templates/homogenization_grain_fracture.yaml +56 -0
- morphogen/templates/homogenization_gyroid.yaml +30 -0
- morphogen/templates/homogenization_intergranular.yaml +43 -0
- morphogen/templates/homogenization_interphase.yaml +42 -0
- morphogen/templates/homogenization_mixed_loading.yaml +33 -0
- morphogen/templates/homogenization_ntfa.yaml +56 -0
- morphogen/templates/homogenization_piezoelectric.yaml +27 -0
- morphogen/templates/homogenization_polycrystal.yaml +30 -0
- morphogen/templates/homogenization_polycrystal_inclusions.yaml +30 -0
- morphogen/templates/homogenization_poroelastic.yaml +26 -0
- morphogen/templates/homogenization_rubber.yaml +40 -0
- morphogen/templates/homogenization_slip_cleavage.yaml +50 -0
- morphogen/templates/homogenization_spheres.yaml +31 -0
- morphogen/templates/homogenization_transport.yaml +29 -0
- morphogen/templates/homogenization_twinning.yaml +54 -0
- morphogen/templates/homogenization_viscoelastic.yaml +34 -0
- morphogen/templates/homogenization_viscoplastic.yaml +42 -0
- morphogen/templates/homogenization_voronoi.yaml +26 -0
- morphogen/templates/homogenization_xfem.yaml +23 -0
- morphogen/templates/hyperuniform_cells.yaml +24 -0
- morphogen/templates/laguerre.yaml +18 -0
- morphogen/templates/laser_bending.yaml +35 -0
- morphogen/templates/laser_cells.yaml +38 -0
- morphogen/templates/laser_corrugated.yaml +36 -0
- morphogen/templates/level_set_foam.yaml +29 -0
- morphogen/templates/menger_sponge.yaml +17 -0
- morphogen/templates/nacre.yaml +25 -0
- morphogen/templates/nucleation_growth.yaml +25 -0
- morphogen/templates/optimize_auxetic.yaml +29 -0
- morphogen/templates/optimize_auxetic_3d.yaml +27 -0
- morphogen/templates/optimize_bulk.yaml +23 -0
- morphogen/templates/optimize_conductivity.yaml +20 -0
- morphogen/templates/osteons.yaml +28 -0
- morphogen/templates/penetrable_spheres.yaml +21 -0
- morphogen/templates/poisson_fibers.yaml +21 -0
- morphogen/templates/random_laminate.yaml +26 -0
- morphogen/templates/random_lattice.yaml +27 -0
- morphogen/templates/random_walk_fibers.yaml +26 -0
- morphogen/templates/reaction_diffusion.yaml +22 -0
- morphogen/templates/reconstruction.yaml +22 -0
- morphogen/templates/rve_cellular_automaton.yaml +23 -0
- morphogen/templates/rve_crystal_plasticity_fft.yaml +51 -0
- morphogen/templates/rve_multiphysics.yaml +43 -0
- morphogen/templates/rve_poisson_fibers.yaml +22 -0
- morphogen/templates/rve_poisson_fibers_fe.yaml +33 -0
- morphogen/templates/rve_voronoi_windows.yaml +20 -0
- morphogen/templates/scale_rich_network.yaml +29 -0
- morphogen/templates/scale_rich_plates.yaml +30 -0
- morphogen/templates/sequential_dead_leaves.yaml +25 -0
- morphogen/templates/strut_lattice.yaml +21 -0
- morphogen/templates/tile_assembly.yaml +28 -0
- morphogen/templates/tpms.yaml +19 -0
- morphogen/templates/trabecular_bone.yaml +29 -0
- morphogen/templates/transparent_dead_leaves.yaml +23 -0
- morphogen/templates/vascular_tree.yaml +23 -0
- morphogen/templates/voronoi.yaml +20 -0
- morphogen/templates/wood.yaml +34 -0
- morphogen/templates/workflow.yaml +56 -0
- morphogen/texture.py +665 -0
- morphogen/theory.py +162 -0
- morphogen/viz/__init__.py +12 -0
- morphogen/viz/export.py +244 -0
- morphogen/viz/figures.py +707 -0
- morphogen/viz/png.py +148 -0
- morphogen/viz/sections.py +696 -0
- morphogen/viz/surfaces.py +1352 -0
- morphogen/viz/video.py +904 -0
- morphogen/viz/workflow.py +488 -0
- morphogen-1.0.0.dist-info/METADATA +2316 -0
- morphogen-1.0.0.dist-info/RECORD +381 -0
- morphogen-1.0.0.dist-info/WHEEL +4 -0
- morphogen-1.0.0.dist-info/entry_points.txt +5 -0
- morphogen-1.0.0.dist-info/licenses/LICENSE +674 -0
|
@@ -0,0 +1,411 @@
|
|
|
1
|
+
"""Nacre: brick-and-mortar stacks of mineral tablets in an organic matrix.
|
|
2
|
+
|
|
3
|
+
Nacre (mother of pearl) is about 95 % of aragonite tablets, some 0.5 um thick and 5 to
|
|
4
|
+
10 um wide, in layers bonded by some 20 to 30 nm of biopolymers (the mortar); the
|
|
5
|
+
tablets of consecutive layers overlap, and the load passes from one to the next by
|
|
6
|
+
shear of the mortar between them (Jackson, Vincent and Turner 1988; Barthelat et al.
|
|
7
|
+
2007). Its toughness, far above that of aragonite, inspires brick-and-mortar composites.
|
|
8
|
+
|
|
9
|
+
The model stacks layers of tablets along an axis, with the period ``t + m`` (``t``: the
|
|
10
|
+
thickness of the tablets, ``m``: that of the mortar between layers). In each layer the
|
|
11
|
+
tablets are the cells of a planar tessellation shrunk by half the gap ``g`` between
|
|
12
|
+
neighbouring tablets:
|
|
13
|
+
|
|
14
|
+
* ``voronoi``: polygonal tablets, the cells of germs at least a fraction ``regularity``
|
|
15
|
+
of the jamming distance of their random sequential addition apart (Poisson germs for
|
|
16
|
+
0), independent from one layer to the next (sheet nacre);
|
|
17
|
+
* ``brick``: rectangles of area ``w^2`` and aspect ratio ``a/b``, each layer shifted by
|
|
18
|
+
``overlap`` tablet from the previous one, along both axes of the plane (each tablet
|
|
19
|
+
over four, ``stagger: uv``) or along the first (over two, ``stagger: u``). A periodic
|
|
20
|
+
box one tablet wide along an axis makes the tablets continuous across it: with
|
|
21
|
+
``stagger: u``, the two-dimensional brick-and-mortar model, extruded.
|
|
22
|
+
|
|
23
|
+
Volume fraction of tablets: ``t / (t + m)`` times the fraction of each layer they cover,
|
|
24
|
+
``(a - g)(b - g) / (a b)`` for bricks, and ``1 - 2 sqrt(lambda) g`` to first order in
|
|
25
|
+
``g`` for the cells of Poisson germs of intensity ``lambda = 1 / w^2`` (their sides are
|
|
26
|
+
``2 sqrt(lambda)`` long per unit area).
|
|
27
|
+
"""
|
|
28
|
+
|
|
29
|
+
from __future__ import annotations
|
|
30
|
+
|
|
31
|
+
import math
|
|
32
|
+
from dataclasses import dataclass
|
|
33
|
+
from typing import ClassVar
|
|
34
|
+
|
|
35
|
+
import numpy as np
|
|
36
|
+
|
|
37
|
+
from morphogen._utils import check_positive
|
|
38
|
+
from morphogen.domain import Domain, Grid
|
|
39
|
+
from morphogen.image import VoxelImage
|
|
40
|
+
from morphogen.models.base import Microstructure, Model, param, register, register_kind
|
|
41
|
+
from morphogen.models.planar import (
|
|
42
|
+
PlanarCells,
|
|
43
|
+
axis_centres,
|
|
44
|
+
hardcore_germs,
|
|
45
|
+
jamming_distance,
|
|
46
|
+
pixel_centres,
|
|
47
|
+
plane_axes,
|
|
48
|
+
)
|
|
49
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
50
|
+
|
|
51
|
+
ARRANGEMENTS = ("voronoi", "brick")
|
|
52
|
+
STAGGERS = ("uv", "u")
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
@register_kind
|
|
56
|
+
class NacreStructure(Microstructure):
|
|
57
|
+
"""Layers of tablets along ``axis``: layer ``k`` spans ``[z0 + k p, z0 + (k + 1) p)``
|
|
58
|
+
(``p``: the period), its tablet the slab of thickness ``t`` in its middle; in the
|
|
59
|
+
plane, the tablets are the cells of the germs of the layer, shrunk by half the
|
|
60
|
+
``gap``. Periodic domains hold a whole number of layers, which wrap around."""
|
|
61
|
+
|
|
62
|
+
kind = "nacre"
|
|
63
|
+
|
|
64
|
+
def __init__(self, domain, axis, period, thickness, offset, gap, layers, **kwargs):
|
|
65
|
+
super().__init__(domain, **kwargs)
|
|
66
|
+
self.axis = int(axis)
|
|
67
|
+
self.period = float(period)
|
|
68
|
+
self.thickness = float(thickness)
|
|
69
|
+
self.offset = float(offset)
|
|
70
|
+
self.gap = float(gap)
|
|
71
|
+
self.layers = [np.asarray(g, dtype=float).reshape(-1, 2) for g in layers]
|
|
72
|
+
self._cells: dict[int, PlanarCells] = {}
|
|
73
|
+
|
|
74
|
+
@property
|
|
75
|
+
def n_layers(self) -> int:
|
|
76
|
+
return len(self.layers)
|
|
77
|
+
|
|
78
|
+
@property
|
|
79
|
+
def axes(self) -> tuple[int, int]:
|
|
80
|
+
return plane_axes(self.axis)
|
|
81
|
+
|
|
82
|
+
def cells(self, layer: int) -> PlanarCells:
|
|
83
|
+
"""Tessellation of the tablets of a layer."""
|
|
84
|
+
if layer not in self._cells:
|
|
85
|
+
b, c = self.axes
|
|
86
|
+
d = self.domain
|
|
87
|
+
self._cells[layer] = PlanarCells(
|
|
88
|
+
self.layers[layer], d.lengths[[b, c]], d.periodic, d.lower[[b, c]]
|
|
89
|
+
)
|
|
90
|
+
return self._cells[layer]
|
|
91
|
+
|
|
92
|
+
def _layer(self, j: np.ndarray) -> np.ndarray:
|
|
93
|
+
"""Stored layer of the layer indices ``j`` (-1: none)."""
|
|
94
|
+
if self.domain.periodic:
|
|
95
|
+
return np.mod(j, self.n_layers)
|
|
96
|
+
return np.where((j >= 0) & (j < self.n_layers), j, -1)
|
|
97
|
+
|
|
98
|
+
def _slab(self, z: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
|
|
99
|
+
"""Index of the layer around each coordinate and the signed distance to the slab
|
|
100
|
+
of its tablet (negative inside)."""
|
|
101
|
+
j = np.floor((z - self.offset) / self.period).astype(np.int64)
|
|
102
|
+
centre = self.offset + (j + 0.5) * self.period
|
|
103
|
+
return j, np.abs(z - centre) - 0.5 * self.thickness
|
|
104
|
+
|
|
105
|
+
# -- point classification ----------------------------------------------------------
|
|
106
|
+
|
|
107
|
+
def contains(self, points) -> np.ndarray:
|
|
108
|
+
pts = np.asarray(points, dtype=float).reshape(-1, 3)
|
|
109
|
+
if self.domain.periodic:
|
|
110
|
+
pts = self.domain.wrap(pts)
|
|
111
|
+
b, c = self.axes
|
|
112
|
+
j, slab = self._slab(pts[:, self.axis])
|
|
113
|
+
layer = self._layer(j)
|
|
114
|
+
out = np.zeros(len(pts), dtype=bool)
|
|
115
|
+
for k in np.unique(layer[(slab <= 0) & (layer >= 0)]):
|
|
116
|
+
sel = (layer == k) & (slab <= 0)
|
|
117
|
+
_, d = self.cells(int(k)).locate(pts[sel][:, [b, c]], reach=0.5 * self.gap)
|
|
118
|
+
out[sel] = d > 0.5 * self.gap
|
|
119
|
+
return out
|
|
120
|
+
|
|
121
|
+
# -- discretization ---------------------------------------------------------------
|
|
122
|
+
|
|
123
|
+
def _phases_on(self, grid: Grid) -> np.ndarray:
|
|
124
|
+
pts, shape = pixel_centres(grid, self.axes)
|
|
125
|
+
j, slab = self._slab(axis_centres(grid, self.axis))
|
|
126
|
+
layer = self._layer(j)
|
|
127
|
+
out = np.zeros((len(j), *shape), dtype=np.uint8)
|
|
128
|
+
tablets: dict[int, np.ndarray] = {}
|
|
129
|
+
for i in np.flatnonzero((slab <= 0) & (layer >= 0)):
|
|
130
|
+
k = int(layer[i])
|
|
131
|
+
if k not in tablets:
|
|
132
|
+
_, d = self.cells(k).locate(pts, reach=0.5 * self.gap)
|
|
133
|
+
tablets[k] = (d > 0.5 * self.gap).reshape(shape).astype(np.uint8)
|
|
134
|
+
out[i] = tablets[k]
|
|
135
|
+
return np.moveaxis(out, 0, self.axis)
|
|
136
|
+
|
|
137
|
+
def voxelize(self, shape=None, *, voxel_size=None, grid: Grid | None = None, supersampling=1):
|
|
138
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
139
|
+
ss = int(supersampling)
|
|
140
|
+
if ss == 1:
|
|
141
|
+
data = self._phases_on(grid)
|
|
142
|
+
return VoxelImage.from_grid(data, grid, name="phase", metadata=self.image_metadata())
|
|
143
|
+
if not 1 <= ss <= 6:
|
|
144
|
+
raise ValueError("supersampling must be an integer between 1 and 6")
|
|
145
|
+
fine = Grid(grid.domain, tuple(n * ss for n in grid.shape))
|
|
146
|
+
ph = self._phases_on(fine).astype(np.float32)
|
|
147
|
+
nx, ny, nz = grid.shape
|
|
148
|
+
data = ph.reshape(nx, ss, ny, ss, nz, ss).mean(axis=(1, 3, 5), dtype=np.float32)
|
|
149
|
+
return VoxelImage.from_grid(data, grid, name="fraction", metadata=self.image_metadata())
|
|
150
|
+
|
|
151
|
+
def level_set(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
152
|
+
"""Minimum over the layers around each point of ``max(slab, g / 2 - d)``: the
|
|
153
|
+
signed distance to the slab of the tablets and the distance ``d`` to the sides
|
|
154
|
+
of the cells (negative in the tablets, a distance near their faces)."""
|
|
155
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
156
|
+
pts, shape2 = pixel_centres(grid, self.axes)
|
|
157
|
+
z = axis_centres(grid, self.axis)
|
|
158
|
+
j0, _ = self._slab(z)
|
|
159
|
+
reach = 0.5 * self.gap + 4.0 * float(np.max(grid.spacing))
|
|
160
|
+
far = np.float32(np.max(grid.domain.lengths))
|
|
161
|
+
out = np.full((len(z), *shape2), far, dtype=np.float32)
|
|
162
|
+
planes: dict[int, np.ndarray] = {}
|
|
163
|
+
for i, zi in enumerate(z):
|
|
164
|
+
for j in (j0[i] - 1, j0[i], j0[i] + 1):
|
|
165
|
+
k = int(self._layer(np.array([j]))[0])
|
|
166
|
+
if k < 0:
|
|
167
|
+
continue
|
|
168
|
+
if k not in planes:
|
|
169
|
+
_, d = self.cells(k).locate(pts, reach=reach)
|
|
170
|
+
planes[k] = (0.5 * self.gap - d).reshape(shape2).astype(np.float32)
|
|
171
|
+
centre = self.offset + (j + 0.5) * self.period
|
|
172
|
+
slab = np.float32(abs(zi - centre) - 0.5 * self.thickness)
|
|
173
|
+
out[i] = np.minimum(out[i], np.maximum(slab, planes[k]))
|
|
174
|
+
data = np.moveaxis(out, 0, self.axis)
|
|
175
|
+
return VoxelImage.from_grid(data, grid, name="level_set", metadata=self.image_metadata())
|
|
176
|
+
|
|
177
|
+
def level_set_at(self, points, reach: float = np.inf) -> np.ndarray:
|
|
178
|
+
"""As :meth:`level_set`, at the points (the distances to the sides of the cells
|
|
179
|
+
exact within ``reach`` of them, by default the half gap and a tenth of the period)."""
|
|
180
|
+
pts = np.asarray(points, dtype=float).reshape(-1, 3)
|
|
181
|
+
if self.domain.periodic:
|
|
182
|
+
pts = self.domain.wrap(pts)
|
|
183
|
+
b, c = self.axes
|
|
184
|
+
z = pts[:, self.axis]
|
|
185
|
+
j0, _ = self._slab(z)
|
|
186
|
+
if not np.isfinite(reach):
|
|
187
|
+
reach = 0.5 * self.gap + 0.1 * self.period
|
|
188
|
+
out = np.full(len(pts), float(np.max(self.domain.lengths)))
|
|
189
|
+
for shift in (-1, 0, 1):
|
|
190
|
+
j = j0 + shift
|
|
191
|
+
layer = self._layer(j)
|
|
192
|
+
centre = self.offset + (j + 0.5) * self.period
|
|
193
|
+
slab = np.abs(z - centre) - 0.5 * self.thickness
|
|
194
|
+
for k in np.unique(layer[layer >= 0]):
|
|
195
|
+
sel = np.flatnonzero(layer == k)
|
|
196
|
+
_, d = self.cells(int(k)).locate(pts[sel][:, [b, c]], reach=float(reach))
|
|
197
|
+
out[sel] = np.minimum(out[sel], np.maximum(slab[sel], 0.5 * self.gap - d))
|
|
198
|
+
return out
|
|
199
|
+
|
|
200
|
+
# -- description -------------------------------------------------------------------
|
|
201
|
+
|
|
202
|
+
def summary(self) -> dict:
|
|
203
|
+
return {
|
|
204
|
+
"n_layers": self.n_layers,
|
|
205
|
+
"tablets_per_layer": float(np.mean([len(g) for g in self.layers])),
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
def _geometry(self) -> dict:
|
|
209
|
+
return {
|
|
210
|
+
"axis": self.axis,
|
|
211
|
+
"period": self.period,
|
|
212
|
+
"thickness": self.thickness,
|
|
213
|
+
"offset": self.offset,
|
|
214
|
+
"gap": self.gap,
|
|
215
|
+
"layers": [g.tolist() for g in self.layers],
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
@classmethod
|
|
219
|
+
def _from_geometry(cls, domain, geometry, **kwargs):
|
|
220
|
+
return cls(
|
|
221
|
+
domain,
|
|
222
|
+
geometry["axis"],
|
|
223
|
+
geometry["period"],
|
|
224
|
+
geometry["thickness"],
|
|
225
|
+
geometry["offset"],
|
|
226
|
+
geometry["gap"],
|
|
227
|
+
geometry["layers"],
|
|
228
|
+
**kwargs,
|
|
229
|
+
)
|
|
230
|
+
|
|
231
|
+
|
|
232
|
+
@register
|
|
233
|
+
@dataclass(frozen=True)
|
|
234
|
+
class Nacre(Model):
|
|
235
|
+
"""Nacre: staggered layers of mineral tablets bonded by an organic mortar.
|
|
236
|
+
|
|
237
|
+
Tablets of ``tablet_thickness`` and in-plane ``tablet_size`` (the side of a square of
|
|
238
|
+
the same area), ``voronoi`` polygons (sheet nacre) or ``brick`` rectangles in a
|
|
239
|
+
staggered stack, separated by ``mortar_thickness`` between the layers and ``gap``
|
|
240
|
+
between the tablets of a layer, stacked along ``axis``.
|
|
241
|
+
"""
|
|
242
|
+
|
|
243
|
+
name = "nacre"
|
|
244
|
+
phases: ClassVar[dict[int, str]] = {0: "mortar", 1: "tablets"}
|
|
245
|
+
count_label = "tablets"
|
|
246
|
+
|
|
247
|
+
tablet_size: float = param(
|
|
248
|
+
1.0, doc="In-plane size of the tablets (square root of their area)", unit="length"
|
|
249
|
+
)
|
|
250
|
+
tablet_thickness: float = param(0.2, doc="Thickness of the tablets", unit="length")
|
|
251
|
+
mortar_thickness: float = param(
|
|
252
|
+
0.02, doc="Thickness of the mortar between the layers", unit="length"
|
|
253
|
+
)
|
|
254
|
+
gap: float | None = param(
|
|
255
|
+
None, doc="Width of the mortar between the tablets of a layer (default: as between "
|
|
256
|
+
"the layers)", unit="length",
|
|
257
|
+
) # fmt: skip
|
|
258
|
+
arrangement: str = param(
|
|
259
|
+
"voronoi", doc="voronoi (polygonal tablets) or brick (staggered rectangles)", kind="str"
|
|
260
|
+
)
|
|
261
|
+
regularity: float = param(
|
|
262
|
+
0.7, doc="voronoi: least distance of the germs, in jamming distances (0: Poisson)",
|
|
263
|
+
kind="fraction",
|
|
264
|
+
) # fmt: skip
|
|
265
|
+
aspect: float = param(1.0, doc="brick: length over width of the tablets")
|
|
266
|
+
overlap: float = param(
|
|
267
|
+
0.5, doc="brick: shift of a layer from the previous one, in tablets", kind="fraction"
|
|
268
|
+
)
|
|
269
|
+
stagger: str = param(
|
|
270
|
+
"uv", doc="brick: shift along both axes of the plane (uv) or the first (u)", kind="str"
|
|
271
|
+
)
|
|
272
|
+
axis: int = param(2, doc="Stacking direction (0: x, 1: y, 2: z)", kind="int")
|
|
273
|
+
|
|
274
|
+
def _validate(self) -> None:
|
|
275
|
+
check_positive(self.tablet_size, "tablet_size")
|
|
276
|
+
check_positive(self.tablet_thickness, "tablet_thickness")
|
|
277
|
+
check_positive(self.mortar_thickness, "mortar_thickness", allow_zero=True)
|
|
278
|
+
check_positive(self.aspect, "aspect")
|
|
279
|
+
if self.arrangement not in ARRANGEMENTS:
|
|
280
|
+
raise ValueError(f"arrangement: one of {list(ARRANGEMENTS)}")
|
|
281
|
+
if self.stagger not in STAGGERS:
|
|
282
|
+
raise ValueError(f"stagger: one of {list(STAGGERS)}")
|
|
283
|
+
if self.axis not in (0, 1, 2):
|
|
284
|
+
raise ValueError("axis: 0, 1 or 2")
|
|
285
|
+
if not 0.0 <= self.regularity <= 0.95:
|
|
286
|
+
raise ValueError("regularity: from 0 (Poisson germs) to 0.95 (near jamming)")
|
|
287
|
+
if not 0.0 <= self.overlap < 1.0:
|
|
288
|
+
raise ValueError("overlap: from 0 to 1 (excluded)")
|
|
289
|
+
g = self.gap_width
|
|
290
|
+
check_positive(g, "gap", allow_zero=True)
|
|
291
|
+
a, b = self.brick_sides
|
|
292
|
+
if g >= (min(a, b) if self.arrangement == "brick" else 0.5 * self.tablet_size):
|
|
293
|
+
raise ValueError("gap: narrower than the tablets")
|
|
294
|
+
|
|
295
|
+
@property
|
|
296
|
+
def gap_width(self) -> float:
|
|
297
|
+
return self.mortar_thickness if self.gap is None else float(self.gap)
|
|
298
|
+
|
|
299
|
+
@property
|
|
300
|
+
def period(self) -> float:
|
|
301
|
+
"""Thickness of a layer: a tablet and the mortar over it."""
|
|
302
|
+
return self.tablet_thickness + self.mortar_thickness
|
|
303
|
+
|
|
304
|
+
@property
|
|
305
|
+
def brick_sides(self) -> tuple[float, float]:
|
|
306
|
+
"""Sides of the bricks along the two axes of the plane."""
|
|
307
|
+
s = math.sqrt(self.aspect)
|
|
308
|
+
return self.tablet_size * s, self.tablet_size / s
|
|
309
|
+
|
|
310
|
+
# -- generation ----------------------------------------------------------------------
|
|
311
|
+
|
|
312
|
+
def _layer_count(self, length: float) -> int:
|
|
313
|
+
"""Layers in a periodic box: the closest to its height in whole periods of the
|
|
314
|
+
staggering (a whole number of tablets of shift)."""
|
|
315
|
+
n0 = max(1, round(length / self.period))
|
|
316
|
+
if self.arrangement != "brick" or self.overlap == 0:
|
|
317
|
+
return n0
|
|
318
|
+
fits = [
|
|
319
|
+
n for n in range(1, 4 * n0 + 8)
|
|
320
|
+
if abs(n * self.overlap - round(n * self.overlap)) < 1e-9
|
|
321
|
+
] # fmt: skip
|
|
322
|
+
if not fits:
|
|
323
|
+
raise ValueError(
|
|
324
|
+
f"nacre: no number of layers repeats a shift of {self.overlap} tablet; "
|
|
325
|
+
"use a rational overlap (0.5, 0.25, 1/3...) or a non-periodic domain"
|
|
326
|
+
)
|
|
327
|
+
return min(fits, key=lambda n: abs(math.log(length / (n * self.period))))
|
|
328
|
+
|
|
329
|
+
def _brick_germs(self, k: int, lower, lengths, counts, sides, periodic: bool):
|
|
330
|
+
"""Centres of the bricks of layer ``k``."""
|
|
331
|
+
a, b = sides
|
|
332
|
+
shift = self.overlap * k * np.array([a, b if self.stagger == "uv" else 0.0])
|
|
333
|
+
if periodic: # from the corner of the box, which holds whole bricks
|
|
334
|
+
i, j = np.meshgrid(np.arange(counts[0]), np.arange(counts[1]), indexing="ij")
|
|
335
|
+
shift = shift + lower
|
|
336
|
+
else: # the bricks over the box, and a row around it
|
|
337
|
+
lo = np.floor((lower - shift) / sides).astype(int) - 1
|
|
338
|
+
hi = np.ceil((lower + lengths - shift) / sides).astype(int) + 1
|
|
339
|
+
i, j = np.meshgrid(np.arange(lo[0], hi[0]), np.arange(lo[1], hi[1]), indexing="ij")
|
|
340
|
+
return np.column_stack([(i.ravel() + 0.5) * a, (j.ravel() + 0.5) * b]) + shift
|
|
341
|
+
|
|
342
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> NacreStructure:
|
|
343
|
+
rng, seed_info = make_rng(seed)
|
|
344
|
+
ax = self.axis
|
|
345
|
+
b, c = plane_axes(ax)
|
|
346
|
+
lower, lengths = domain.lower[[b, c]], domain.lengths[[b, c]]
|
|
347
|
+
height = float(domain.lengths[ax])
|
|
348
|
+
scale = 1.0
|
|
349
|
+
if domain.periodic:
|
|
350
|
+
n_layers = self._layer_count(height)
|
|
351
|
+
scale = height / (n_layers * self.period) # the stack fills the box
|
|
352
|
+
offset = float(domain.lower[ax] + rng.random() * height)
|
|
353
|
+
layer_ids = range(n_layers)
|
|
354
|
+
else:
|
|
355
|
+
offset = float(domain.lower[ax] - rng.random() * self.period)
|
|
356
|
+
n_layers = math.ceil((domain.upper[ax] - offset) / self.period)
|
|
357
|
+
layer_ids = range(n_layers)
|
|
358
|
+
sides = np.array(self.brick_sides)
|
|
359
|
+
counts = np.maximum(1, np.rint(lengths / sides)).astype(int)
|
|
360
|
+
if domain.periodic and self.arrangement == "brick":
|
|
361
|
+
sides = lengths / counts # whole bricks in the box
|
|
362
|
+
layers = []
|
|
363
|
+
margin = 0.0 if domain.periodic else 3.0 * self.tablet_size
|
|
364
|
+
window_lo, window = lower - margin, lengths + 2.0 * margin
|
|
365
|
+
area = float(np.prod(window))
|
|
366
|
+
for k in layer_ids:
|
|
367
|
+
if self.arrangement == "brick":
|
|
368
|
+
layers.append(self._brick_germs(k, lower, lengths, counts, sides, domain.periodic))
|
|
369
|
+
continue
|
|
370
|
+
if domain.periodic:
|
|
371
|
+
n = max(1, round(area / self.tablet_size**2))
|
|
372
|
+
else:
|
|
373
|
+
n = max(1, int(rng.poisson(area / self.tablet_size**2)))
|
|
374
|
+
distance = self.regularity * jamming_distance(n, area)
|
|
375
|
+
layers.append(window_lo + hardcore_germs(n, window, distance, rng))
|
|
376
|
+
metadata = {"scale": {"thickness": scale}} if domain.periodic else {}
|
|
377
|
+
if domain.periodic and self.arrangement == "brick":
|
|
378
|
+
metadata.setdefault("scale", {})["tablet_sides"] = (sides / self.brick_sides).tolist()
|
|
379
|
+
return NacreStructure(
|
|
380
|
+
domain,
|
|
381
|
+
ax,
|
|
382
|
+
self.period * scale,
|
|
383
|
+
self.tablet_thickness * scale,
|
|
384
|
+
offset,
|
|
385
|
+
self.gap_width,
|
|
386
|
+
layers,
|
|
387
|
+
model=self,
|
|
388
|
+
seed=seed_info,
|
|
389
|
+
metadata=metadata,
|
|
390
|
+
)
|
|
391
|
+
|
|
392
|
+
# -- theory ----------------------------------------------------------------------------
|
|
393
|
+
|
|
394
|
+
def expected_count(self, domain: Domain) -> float:
|
|
395
|
+
"""Mean number of tablets in the domain."""
|
|
396
|
+
return float(domain.volume / (self.tablet_size**2 * self.period))
|
|
397
|
+
|
|
398
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
399
|
+
layer = self.tablet_thickness / self.period
|
|
400
|
+
g = self.gap_width
|
|
401
|
+
out = {
|
|
402
|
+
"layer_fraction": layer,
|
|
403
|
+
"tablet_aspect_ratio": self.tablet_size / self.tablet_thickness,
|
|
404
|
+
}
|
|
405
|
+
if self.arrangement == "brick":
|
|
406
|
+
a, b = self.brick_sides
|
|
407
|
+
out["volume_fraction"] = layer * (a - g) * (b - g) / (a * b)
|
|
408
|
+
elif self.regularity == 0: # sides 2 sqrt(lambda) long per unit area
|
|
409
|
+
out["gap_fraction_first_order"] = 2.0 * g / self.tablet_size
|
|
410
|
+
out["volume_fraction_first_order"] = layer * (1.0 - 2.0 * g / self.tablet_size)
|
|
411
|
+
return out
|