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,302 @@
|
|
|
1
|
+
"""Microstructures defined cell by cell on a tiling other than the square grid.
|
|
2
|
+
|
|
3
|
+
Cellular automata (and reaction-diffusion, thresholded cell by cell) on triangles,
|
|
4
|
+
hexagons, Penrose rhombi, Ammann-Beenker squares and rhombi, prisms, truncated octahedra,
|
|
5
|
+
rhombic dodecahedra or golden rhombohedra (:mod:`morphogen.automata.tilings`) give a
|
|
6
|
+
phase per cell. Images are rasterized at any resolution, each voxel taking the phase of
|
|
7
|
+
the cell containing its centre (partial volumes by supersampling), so that every analysis
|
|
8
|
+
and solver applies. The realization keeps the specification of its tiling (lattice, box,
|
|
9
|
+
cell size and, for quasi-periodic tilings, the offsets of their grids and the order of a
|
|
10
|
+
periodic approximant), from which the tiling is rebuilt, and the phases of the cells
|
|
11
|
+
meeting the domain.
|
|
12
|
+
"""
|
|
13
|
+
|
|
14
|
+
from __future__ import annotations
|
|
15
|
+
|
|
16
|
+
import numpy as np
|
|
17
|
+
|
|
18
|
+
from morphogen.automata.tilings import Tiling, make_tiling
|
|
19
|
+
from morphogen.domain import Domain, Grid
|
|
20
|
+
from morphogen.image import VoxelImage
|
|
21
|
+
from morphogen.models.base import Microstructure, register_kind
|
|
22
|
+
from morphogen.models.lattice_field import _decode, _encode
|
|
23
|
+
|
|
24
|
+
#: Voxels per cell size of the default images (2D, 3D).
|
|
25
|
+
VOXELS_PER_CELL = {2: 4, 3: 2}
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def default_grid(domain: Domain, tiling: Tiling) -> Grid:
|
|
29
|
+
"""Grid of the default images of a tiling: 4 voxels per cell size in 2D (one through
|
|
30
|
+
the thickness), 2 in 3D."""
|
|
31
|
+
n = np.rint(domain.lengths * VOXELS_PER_CELL[tiling.dims] / tiling.cell_size)
|
|
32
|
+
n = np.maximum(1, n).astype(int)
|
|
33
|
+
if tiling.dims == 2:
|
|
34
|
+
n[2] = 1
|
|
35
|
+
return Grid(domain, tuple(int(v) for v in n))
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
@register_kind
|
|
39
|
+
class TilingField(Microstructure):
|
|
40
|
+
"""A phase per cell of a tiling covering the domain.
|
|
41
|
+
|
|
42
|
+
Parameters
|
|
43
|
+
----------
|
|
44
|
+
tiling
|
|
45
|
+
The :class:`~morphogen.automata.tilings.Tiling`, or its ``spec``.
|
|
46
|
+
phases
|
|
47
|
+
``uint8`` phase of each cell (of each of ``cells`` when given).
|
|
48
|
+
cells
|
|
49
|
+
Indices of the cells kept (those meeting a window cut from a larger tiling);
|
|
50
|
+
all cells when None.
|
|
51
|
+
attributes
|
|
52
|
+
JSON-able data (number of steps, history of the run...).
|
|
53
|
+
"""
|
|
54
|
+
|
|
55
|
+
kind = "tiling_field"
|
|
56
|
+
|
|
57
|
+
def __init__(
|
|
58
|
+
self,
|
|
59
|
+
domain: Domain,
|
|
60
|
+
tiling: Tiling | dict,
|
|
61
|
+
phases,
|
|
62
|
+
*,
|
|
63
|
+
cells=None,
|
|
64
|
+
attributes: dict | None = None,
|
|
65
|
+
**kwargs,
|
|
66
|
+
) -> None:
|
|
67
|
+
super().__init__(domain, **kwargs)
|
|
68
|
+
self.tiling = tiling if isinstance(tiling, Tiling) else make_tiling(**tiling)
|
|
69
|
+
self.phases = np.ascontiguousarray(phases, dtype=np.uint8).ravel()
|
|
70
|
+
self.cells = None if cells is None else np.ascontiguousarray(cells, dtype=np.int64)
|
|
71
|
+
n = self.tiling.n_cells if self.cells is None else len(self.cells)
|
|
72
|
+
if len(self.phases) != n:
|
|
73
|
+
raise ValueError(f"phases: one per cell ({n}), got {len(self.phases)}")
|
|
74
|
+
self.attributes = dict(attributes or {})
|
|
75
|
+
self._position = None
|
|
76
|
+
|
|
77
|
+
@property
|
|
78
|
+
def default_grid(self) -> Grid:
|
|
79
|
+
return default_grid(self.domain, self.tiling)
|
|
80
|
+
|
|
81
|
+
@property
|
|
82
|
+
def binary(self) -> bool:
|
|
83
|
+
return bool(self.phases.max(initial=0) <= 1)
|
|
84
|
+
|
|
85
|
+
def phase_of(self, cells) -> np.ndarray:
|
|
86
|
+
"""Phases of cells of the tiling (0 for cells not kept: outside the window)."""
|
|
87
|
+
cells = np.asarray(cells)
|
|
88
|
+
if self.cells is None:
|
|
89
|
+
return self.phases[cells]
|
|
90
|
+
if self._position is None:
|
|
91
|
+
pos = np.full(self.tiling.n_cells, len(self.phases), dtype=np.int64)
|
|
92
|
+
pos[self.cells] = np.arange(len(self.cells))
|
|
93
|
+
self._position = pos
|
|
94
|
+
return np.append(self.phases, np.uint8(0))[self._position[cells]]
|
|
95
|
+
|
|
96
|
+
def cell_image(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
97
|
+
"""Image of the index (in the tiling) of the cell containing each voxel centre."""
|
|
98
|
+
grid = self._resolve(shape, voxel_size, grid)
|
|
99
|
+
data = self.tiling.cell_index(grid)
|
|
100
|
+
return VoxelImage.from_grid(data, grid, name="cell", metadata=self.image_metadata())
|
|
101
|
+
|
|
102
|
+
def _resolve(self, shape, voxel_size, grid) -> Grid:
|
|
103
|
+
if shape is None and voxel_size is None and grid is None:
|
|
104
|
+
grid = self.default_grid
|
|
105
|
+
return self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
106
|
+
|
|
107
|
+
# -- discretization ----------------------------------------------------------------
|
|
108
|
+
|
|
109
|
+
def voxelize(self, shape=None, *, voxel_size=None, grid: Grid | None = None, supersampling=1):
|
|
110
|
+
grid = self._resolve(shape, voxel_size, grid)
|
|
111
|
+
ss = int(supersampling)
|
|
112
|
+
if not 1 <= ss <= 6:
|
|
113
|
+
raise ValueError("supersampling must be an integer between 1 and 6")
|
|
114
|
+
meta = self.image_metadata()
|
|
115
|
+
if ss == 1:
|
|
116
|
+
data = self.phase_of(self.tiling.cell_index(grid))
|
|
117
|
+
return VoxelImage.from_grid(data, grid, name="phase", metadata=meta)
|
|
118
|
+
if not self.binary:
|
|
119
|
+
raise ValueError("partial volumes are defined for two-phase structures")
|
|
120
|
+
sub = (ss, ss, 1 if self.tiling.dims == 2 else ss)
|
|
121
|
+
fine = Grid(grid.domain, tuple(n * s for n, s in zip(grid.shape, sub, strict=True)))
|
|
122
|
+
inside = (self.phase_of(self.tiling.cell_index(fine)) == 1).astype(np.float32)
|
|
123
|
+
nx, ny, nz = grid.shape
|
|
124
|
+
data = inside.reshape(nx, sub[0], ny, sub[1], nz, sub[2]).mean(
|
|
125
|
+
axis=(1, 3, 5), dtype=np.float32
|
|
126
|
+
)
|
|
127
|
+
return VoxelImage.from_grid(data, grid, name="fraction", metadata=meta)
|
|
128
|
+
|
|
129
|
+
def contains(self, points) -> np.ndarray:
|
|
130
|
+
return self.phase_of(self.tiling.locate(points)) == 1
|
|
131
|
+
|
|
132
|
+
# -- implicit functions ----------------------------------------------------------------
|
|
133
|
+
|
|
134
|
+
def implicit_phases(self) -> list[int]:
|
|
135
|
+
phases = {int(k) for k in np.unique(self.phases)} | {0, 1}
|
|
136
|
+
if self.model is not None:
|
|
137
|
+
phases |= {int(k) for k in self.model.active_phases()}
|
|
138
|
+
return sorted(phases)
|
|
139
|
+
|
|
140
|
+
def _cell_planes(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
|
141
|
+
"""The planes ``(n, h)`` of the faces of the cells from their centres (``n . x <=
|
|
142
|
+
h`` inside), by kind of cell (the cells of a kind are translated copies): the kind
|
|
143
|
+
of each cell, the planes of each kind (padded) and their numbers."""
|
|
144
|
+
if getattr(self, "_planes", None) is not None:
|
|
145
|
+
return self._planes
|
|
146
|
+
t = self.tiling
|
|
147
|
+
if t._plane is not None: # polygons (prisms through the layers in 3D)
|
|
148
|
+
p = t._plane
|
|
149
|
+
m = len(p["centres"])
|
|
150
|
+
kind = np.arange(t.n_cells) % m
|
|
151
|
+
ptr = p["poly_ptr"]
|
|
152
|
+
poly = p["poly"] * p["scale"][:2]
|
|
153
|
+
extra = 2 if t.dims == 3 else 0
|
|
154
|
+
width = int(np.diff(ptr).max()) + extra
|
|
155
|
+
planes = np.zeros((m, width, 4))
|
|
156
|
+
counts = np.zeros(m, dtype=np.int64)
|
|
157
|
+
hz = 0.5 * p["layer_height"] * p["scale"][2]
|
|
158
|
+
for c in range(m):
|
|
159
|
+
v = poly[ptr[c] : ptr[c + 1]]
|
|
160
|
+
edge = np.roll(v, -1, axis=0) - v # counterclockwise: the outside on the right
|
|
161
|
+
normal = np.c_[edge[:, 1], -edge[:, 0]]
|
|
162
|
+
normal /= np.linalg.norm(normal, axis=1, keepdims=True)
|
|
163
|
+
k = len(v)
|
|
164
|
+
planes[c, :k, :2] = normal
|
|
165
|
+
planes[c, :k, 3] = np.einsum("ij,ij->i", normal, v)
|
|
166
|
+
if extra:
|
|
167
|
+
planes[c, k, 2], planes[c, k + 1, 2] = 1.0, -1.0
|
|
168
|
+
planes[c, k : k + 2, 3] = hz
|
|
169
|
+
counts[c] = k + extra
|
|
170
|
+
else:
|
|
171
|
+
from scipy.spatial import ConvexHull
|
|
172
|
+
|
|
173
|
+
s = t._solid
|
|
174
|
+
if "frames" in s: # rhombohedra: a kind for each triple of edges
|
|
175
|
+
kind = s["triple"].astype(np.int64)
|
|
176
|
+
corners = [
|
|
177
|
+
np.array(list(np.ndindex(2, 2, 2)), dtype=float) @ f - 0.5 * f.sum(axis=0)
|
|
178
|
+
for f in s["frames"]
|
|
179
|
+
]
|
|
180
|
+
else: # the Voronoi cells of a lattice: all alike
|
|
181
|
+
kind = np.zeros(t.n_cells, dtype=np.int64)
|
|
182
|
+
corners = [s["prototype"] * s["scale"]]
|
|
183
|
+
hulls = [ConvexHull(v).equations for v in corners]
|
|
184
|
+
width = max(len(h) for h in hulls)
|
|
185
|
+
planes = np.zeros((len(hulls), width, 4))
|
|
186
|
+
counts = np.array([len(h) for h in hulls], dtype=np.int64)
|
|
187
|
+
for c, h in enumerate(hulls):
|
|
188
|
+
planes[c, : len(h), :3] = h[:, :3]
|
|
189
|
+
planes[c, : len(h), 3] = -h[:, 3]
|
|
190
|
+
self._planes = (kind, planes, counts)
|
|
191
|
+
return self._planes
|
|
192
|
+
|
|
193
|
+
def phase_level_set(
|
|
194
|
+
self, phase: int, shape=None, *, voxel_size=None, grid: Grid | None = None
|
|
195
|
+
) -> VoxelImage:
|
|
196
|
+
"""The implicit function of a phase (see :meth:`Microstructure.phase_level_set`):
|
|
197
|
+
the cells of the phase are convex, each the points on the inner side of the planes
|
|
198
|
+
of its faces; the function is half the smallest gauge of the cells of the phase
|
|
199
|
+
(the largest distance of the point to the planes of a cell, negative in it) minus
|
|
200
|
+
half the smallest gauge of the other cells, among the cell of the point and those
|
|
201
|
+
that share a vertex with it: zero on the faces between a cell of the phase and
|
|
202
|
+
another, the distance to the face near it, clipped to a band of four voxels."""
|
|
203
|
+
from morphogen.kernels.cells import cells_implicit
|
|
204
|
+
from morphogen.models.implicit import band_of
|
|
205
|
+
|
|
206
|
+
phase = int(phase)
|
|
207
|
+
if phase not in self.implicit_phases():
|
|
208
|
+
raise ValueError(f"phase {phase}: the phases are {self.implicit_phases()}")
|
|
209
|
+
grid = self._resolve(shape, voxel_size, grid)
|
|
210
|
+
t = self.tiling
|
|
211
|
+
kind, planes, counts = self._cell_planes()
|
|
212
|
+
indptr, indices = t.adjacency("vertices")
|
|
213
|
+
inside = self.phase_of(np.arange(t.n_cells)) == phase
|
|
214
|
+
lengths = np.where(t.periodic, t.size, 0.0).astype(float)
|
|
215
|
+
if t.dims == 2:
|
|
216
|
+
lengths[2] = 0.0
|
|
217
|
+
band = band_of(grid)
|
|
218
|
+
nx, ny, nz = grid.shape
|
|
219
|
+
out = np.empty(grid.shape, dtype=np.float32)
|
|
220
|
+
step = max(1, (1 << 20) // max(1, nx * ny))
|
|
221
|
+
for k0 in range(0, nz, step):
|
|
222
|
+
k1 = min(nz, k0 + step)
|
|
223
|
+
pts = grid.center_points(k0, k1)
|
|
224
|
+
values = np.empty(len(pts))
|
|
225
|
+
cells_implicit(
|
|
226
|
+
pts,
|
|
227
|
+
t.locate(pts).astype(np.int64),
|
|
228
|
+
indptr.astype(np.int64),
|
|
229
|
+
indices.astype(np.int64),
|
|
230
|
+
t.centres,
|
|
231
|
+
kind,
|
|
232
|
+
planes,
|
|
233
|
+
counts,
|
|
234
|
+
inside,
|
|
235
|
+
lengths,
|
|
236
|
+
t.dims,
|
|
237
|
+
band,
|
|
238
|
+
values,
|
|
239
|
+
)
|
|
240
|
+
out[:, :, k0:k1] = values.reshape(nx, ny, k1 - k0)
|
|
241
|
+
return VoxelImage.from_grid(out, grid, name="level_set", metadata=self.image_metadata())
|
|
242
|
+
|
|
243
|
+
def level_set(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
244
|
+
"""The implicit function of phase 1 (:meth:`phase_level_set`)."""
|
|
245
|
+
return self.phase_level_set(1, shape, voxel_size=voxel_size, grid=grid)
|
|
246
|
+
|
|
247
|
+
def phase_level_sets_at(self, points, reach: float = np.inf) -> dict[int, np.ndarray]:
|
|
248
|
+
"""The functions of :meth:`phase_level_set` at the points: half the smallest gauge
|
|
249
|
+
of the cells of each phase minus half the smallest gauge of the other cells, among
|
|
250
|
+
the cell of the point and those that share a vertex with it, within ``[-reach,
|
|
251
|
+
reach]`` (default: the diagonal of the box)."""
|
|
252
|
+
from morphogen.kernels.cells import cells_implicit
|
|
253
|
+
|
|
254
|
+
pts = np.ascontiguousarray(np.asarray(points, dtype=float).reshape(-1, 3))
|
|
255
|
+
band = float(self.domain.diagonal) if not np.isfinite(reach) else float(reach)
|
|
256
|
+
t = self.tiling
|
|
257
|
+
kind, planes, counts = self._cell_planes()
|
|
258
|
+
indptr, indices = t.adjacency("vertices")
|
|
259
|
+
lengths = np.where(t.periodic, t.size, 0.0).astype(float)
|
|
260
|
+
if t.dims == 2:
|
|
261
|
+
lengths[2] = 0.0
|
|
262
|
+
cell = t.locate(pts).astype(np.int64)
|
|
263
|
+
phase_of = self.phase_of(np.arange(t.n_cells))
|
|
264
|
+
out = {}
|
|
265
|
+
for k in self.implicit_phases():
|
|
266
|
+
values = np.empty(len(pts))
|
|
267
|
+
cells_implicit(pts, cell, indptr.astype(np.int64), indices.astype(np.int64),
|
|
268
|
+
t.centres, kind, planes, counts, phase_of == k, lengths, t.dims,
|
|
269
|
+
band, values) # fmt: skip
|
|
270
|
+
out[k] = values
|
|
271
|
+
return out
|
|
272
|
+
|
|
273
|
+
def level_set_at(self, points, reach: float = np.inf) -> np.ndarray:
|
|
274
|
+
"""The function of phase 1 at the points (:meth:`phase_level_sets_at`)."""
|
|
275
|
+
return self.phase_level_sets_at(points, reach)[1]
|
|
276
|
+
|
|
277
|
+
# -- description ---------------------------------------------------------------------
|
|
278
|
+
|
|
279
|
+
def summary(self) -> dict:
|
|
280
|
+
out = {"lattice": self.tiling.name, "n_cells": len(self.phases)}
|
|
281
|
+
if "steps" in self.attributes:
|
|
282
|
+
out["steps"] = self.attributes["steps"]
|
|
283
|
+
return out
|
|
284
|
+
|
|
285
|
+
def _geometry(self) -> dict:
|
|
286
|
+
geo = {"tiling": self.tiling.spec, "phases": _encode(self.phases)}
|
|
287
|
+
if self.cells is not None:
|
|
288
|
+
geo["cells"] = _encode(self.cells)
|
|
289
|
+
if self.attributes:
|
|
290
|
+
geo["attributes"] = self.attributes
|
|
291
|
+
return geo
|
|
292
|
+
|
|
293
|
+
@classmethod
|
|
294
|
+
def _from_geometry(cls, domain, geometry, **kwargs):
|
|
295
|
+
return cls(
|
|
296
|
+
domain,
|
|
297
|
+
geometry["tiling"],
|
|
298
|
+
_decode(geometry["phases"]),
|
|
299
|
+
cells=_decode(geometry["cells"]) if "cells" in geometry else None,
|
|
300
|
+
attributes=geometry.get("attributes"),
|
|
301
|
+
**kwargs,
|
|
302
|
+
)
|
morphogen/models/tpms.py
ADDED
|
@@ -0,0 +1,197 @@
|
|
|
1
|
+
"""Triply periodic minimal surface (TPMS) architectures."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from dataclasses import dataclass
|
|
6
|
+
from typing import ClassVar
|
|
7
|
+
|
|
8
|
+
import numpy as np
|
|
9
|
+
|
|
10
|
+
from morphogen._utils import as_triplet, check_fraction
|
|
11
|
+
from morphogen.domain import Domain, Grid
|
|
12
|
+
from morphogen.image import VoxelImage
|
|
13
|
+
from morphogen.kernels import implicit
|
|
14
|
+
from morphogen.models.affine import ANISOTROPY, Anisotropy, anisotropic
|
|
15
|
+
from morphogen.models.base import Microstructure, Model, param, register, register_kind
|
|
16
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
17
|
+
|
|
18
|
+
#: Samples per unit-cell edge used to relate the level to the volume fraction.
|
|
19
|
+
_CALIBRATION_SAMPLES = 96
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def _unit_cell_values(code: int, n: int = _CALIBRATION_SAMPLES) -> np.ndarray:
|
|
23
|
+
"""phi at the centres of an n^3 grid of one unit cell."""
|
|
24
|
+
t = 2.0 * np.pi * (np.arange(n) + 0.5) / n
|
|
25
|
+
X, Y, Z = np.meshgrid(t, t, t, indexing="ij")
|
|
26
|
+
sx, sy, sz, cx, cy, cz = np.sin(X), np.sin(Y), np.sin(Z), np.cos(X), np.cos(Y), np.cos(Z)
|
|
27
|
+
if code == implicit.GYROID:
|
|
28
|
+
return (sx * cy + sy * cz + sz * cx).ravel()
|
|
29
|
+
if code == implicit.SCHWARZ_P:
|
|
30
|
+
return (cx + cy + cz).ravel()
|
|
31
|
+
if code == implicit.SCHWARZ_D:
|
|
32
|
+
return (sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz).ravel()
|
|
33
|
+
return (3.0 * (cx + cy + cz) + 4.0 * cx * cy * cz).ravel()
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
@register_kind
|
|
37
|
+
class TPMSStructure(Microstructure):
|
|
38
|
+
"""Solid ``{phi <= level}`` (network) or ``{|phi| <= level}`` (sheet)."""
|
|
39
|
+
|
|
40
|
+
kind = "tpms"
|
|
41
|
+
|
|
42
|
+
def __init__(self, domain, surface, variant, level, cell_size, **kwargs):
|
|
43
|
+
super().__init__(domain, **kwargs)
|
|
44
|
+
self.surface = surface
|
|
45
|
+
self.variant = variant
|
|
46
|
+
self.level = float(level)
|
|
47
|
+
self.cell_size = np.asarray(as_triplet(cell_size, "cell_size", positive=True))
|
|
48
|
+
self._code = implicit.SURFACES[surface]
|
|
49
|
+
self._k = 2.0 * np.pi / self.cell_size
|
|
50
|
+
|
|
51
|
+
def _args(self):
|
|
52
|
+
return self._code, self.variant == "sheet", self.level, self._k, self.domain.lower
|
|
53
|
+
|
|
54
|
+
def voxelize(self, shape=None, *, voxel_size=None, grid: Grid | None = None, supersampling=1):
|
|
55
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
56
|
+
ss = int(supersampling)
|
|
57
|
+
if not 1 <= ss <= 6:
|
|
58
|
+
raise ValueError("supersampling must be an integer between 1 and 6")
|
|
59
|
+
out = np.zeros(grid.shape, dtype=np.uint8)
|
|
60
|
+
implicit.tpms_count(
|
|
61
|
+
*self._args(), grid.origin, grid.spacing, np.array(grid.shape, dtype=np.int64), ss, out
|
|
62
|
+
)
|
|
63
|
+
if ss == 1:
|
|
64
|
+
return VoxelImage.from_grid(out, grid, name="phase", metadata=self.image_metadata())
|
|
65
|
+
data = out.astype(np.float32) / np.float32(ss**3)
|
|
66
|
+
return VoxelImage.from_grid(data, grid, name="fraction", metadata=self.image_metadata())
|
|
67
|
+
|
|
68
|
+
def level_set(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
69
|
+
"""First-order signed distance ``(phi - t) / |grad phi|`` (negative in the solid)."""
|
|
70
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
71
|
+
out = np.empty(grid.shape, dtype=np.float32)
|
|
72
|
+
implicit.tpms_level_set(
|
|
73
|
+
*self._args(), grid.origin, grid.spacing, np.array(grid.shape, dtype=np.int64), out
|
|
74
|
+
)
|
|
75
|
+
return VoxelImage.from_grid(out, grid, name="level_set", metadata=self.image_metadata())
|
|
76
|
+
|
|
77
|
+
def contains(self, points) -> np.ndarray:
|
|
78
|
+
pts = np.ascontiguousarray(points, dtype=float).reshape(-1, 3)
|
|
79
|
+
out = np.zeros(len(pts), dtype=np.bool_)
|
|
80
|
+
implicit.tpms_points(*self._args(), pts, out)
|
|
81
|
+
return out
|
|
82
|
+
|
|
83
|
+
#: The first-order distance is a distance near the surface; margin for its curvature
|
|
84
|
+
lipschitz = 1.5
|
|
85
|
+
|
|
86
|
+
def level_set_at(self, points, reach: float = np.inf) -> np.ndarray:
|
|
87
|
+
"""``(phi - t) / |grad phi|`` at the points, as :meth:`level_set`."""
|
|
88
|
+
pts = np.ascontiguousarray(points, dtype=float).reshape(-1, 3)
|
|
89
|
+
out = np.empty(len(pts))
|
|
90
|
+
implicit.tpms_level_points(*self._args(), pts, out)
|
|
91
|
+
return out
|
|
92
|
+
|
|
93
|
+
def summary(self) -> dict:
|
|
94
|
+
cells = self.domain.lengths / self.cell_size
|
|
95
|
+
return {"surface": self.surface, "cells": "x".join(f"{c:g}" for c in cells)}
|
|
96
|
+
|
|
97
|
+
def _geometry(self) -> dict:
|
|
98
|
+
return {
|
|
99
|
+
"surface": self.surface,
|
|
100
|
+
"variant": self.variant,
|
|
101
|
+
"level": self.level,
|
|
102
|
+
"cell_size": self.cell_size.tolist(),
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
@classmethod
|
|
106
|
+
def _from_geometry(cls, domain, geometry, **kwargs):
|
|
107
|
+
return cls(
|
|
108
|
+
domain,
|
|
109
|
+
geometry["surface"],
|
|
110
|
+
geometry["variant"],
|
|
111
|
+
geometry["level"],
|
|
112
|
+
geometry["cell_size"],
|
|
113
|
+
**kwargs,
|
|
114
|
+
)
|
|
115
|
+
|
|
116
|
+
|
|
117
|
+
@register
|
|
118
|
+
@anisotropic
|
|
119
|
+
@dataclass(frozen=True)
|
|
120
|
+
class TPMS(Model):
|
|
121
|
+
"""TPMS lattice: gyroid, Schwarz P (primitive), Schwarz D (diamond) or Neovius.
|
|
122
|
+
|
|
123
|
+
``network``: solid ``{phi <= level}``; ``sheet``: solid ``{|phi| <= level}`` (walls around
|
|
124
|
+
the minimal surface). Give the level or the target volume fraction (solid fraction),
|
|
125
|
+
from which the level is computed on a fine sampling of the unit cell.
|
|
126
|
+
"""
|
|
127
|
+
|
|
128
|
+
name = "tpms"
|
|
129
|
+
phases: ClassVar[dict[int, str]] = {0: "void", 1: "solid"}
|
|
130
|
+
count_label = "unit cells"
|
|
131
|
+
|
|
132
|
+
surface: str = param("gyroid", doc="gyroid, schwarz_p, schwarz_d or neovius", kind="str")
|
|
133
|
+
cell_size: float | tuple = param(
|
|
134
|
+
1.0, doc="Edge of the unit cell (one value or three)", kind="vector", unit="length"
|
|
135
|
+
)
|
|
136
|
+
variant: str = param("network", doc="'network' (solid skeleton) or 'sheet' (walls)", kind="str")
|
|
137
|
+
level: float | None = param(None, doc="Level t of the iso-surface")
|
|
138
|
+
volume_fraction: float | None = param(None, doc="Target solid volume fraction", kind="fraction")
|
|
139
|
+
anisotropy: Anisotropy | None = param(None, doc=ANISOTROPY, kind="anisotropy", kw_only=True)
|
|
140
|
+
|
|
141
|
+
def _validate(self) -> None:
|
|
142
|
+
if self.surface not in implicit.SURFACES:
|
|
143
|
+
raise ValueError(
|
|
144
|
+
f"surface: expected one of {sorted(implicit.SURFACES)}, got {self.surface!r}"
|
|
145
|
+
)
|
|
146
|
+
if self.variant not in ("network", "sheet"):
|
|
147
|
+
raise ValueError(f"variant: expected 'network' or 'sheet', got {self.variant!r}")
|
|
148
|
+
as_triplet(self.cell_size, "cell_size", positive=True)
|
|
149
|
+
if (self.level is None) == (self.volume_fraction is None):
|
|
150
|
+
raise ValueError("give exactly one of 'level' and 'volume_fraction'")
|
|
151
|
+
if self.volume_fraction is not None:
|
|
152
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
153
|
+
if self.variant == "sheet" and self.level is not None and self.level < 0:
|
|
154
|
+
raise ValueError("level: must be non-negative for sheet TPMS")
|
|
155
|
+
|
|
156
|
+
@property
|
|
157
|
+
def iso_level(self) -> float:
|
|
158
|
+
if self.level is not None:
|
|
159
|
+
return float(self.level)
|
|
160
|
+
values = _unit_cell_values(implicit.SURFACES[self.surface])
|
|
161
|
+
if self.variant == "sheet":
|
|
162
|
+
values = np.abs(values)
|
|
163
|
+
return float(np.quantile(values, self.volume_fraction))
|
|
164
|
+
|
|
165
|
+
def solid_fraction(self) -> float:
|
|
166
|
+
"""Volume fraction of the solid for the current level (numerical)."""
|
|
167
|
+
values = _unit_cell_values(implicit.SURFACES[self.surface], 128)
|
|
168
|
+
if self.variant == "sheet":
|
|
169
|
+
values = np.abs(values)
|
|
170
|
+
return float(np.mean(values <= self.iso_level))
|
|
171
|
+
|
|
172
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> TPMSStructure:
|
|
173
|
+
_, seed_info = make_rng(seed)
|
|
174
|
+
cell = np.array(as_triplet(self.cell_size, "cell_size", positive=True))
|
|
175
|
+
if domain.periodic:
|
|
176
|
+
ratio = domain.lengths / cell
|
|
177
|
+
if np.any(np.abs(ratio - np.rint(ratio)) > 1e-6 * np.maximum(ratio, 1.0)):
|
|
178
|
+
raise ValueError(
|
|
179
|
+
"tpms: a periodic domain must contain a whole number of unit cells "
|
|
180
|
+
f"(domain {domain.size}, cell {tuple(cell)})"
|
|
181
|
+
)
|
|
182
|
+
return TPMSStructure(
|
|
183
|
+
domain,
|
|
184
|
+
self.surface,
|
|
185
|
+
self.variant,
|
|
186
|
+
self.iso_level,
|
|
187
|
+
tuple(cell),
|
|
188
|
+
model=self,
|
|
189
|
+
seed=seed_info,
|
|
190
|
+
)
|
|
191
|
+
|
|
192
|
+
def expected_count(self, domain: Domain) -> float:
|
|
193
|
+
"""Number of unit cells in the domain."""
|
|
194
|
+
return domain.volume / float(np.prod(np.broadcast_to(self.cell_size, 3)))
|
|
195
|
+
|
|
196
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
197
|
+
return {"level": self.iso_level, "volume_fraction": self.solid_fraction()}
|