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,563 @@
|
|
|
1
|
+
"""Foams as level sets of distance fields (Sonon, François & Massart 2012, 2015; Kilingar,
|
|
2
|
+
Sonon & Massart 2019; Degdeg & Dirrenberger 2026).
|
|
3
|
+
|
|
4
|
+
Seeds: non-overlapping ellipsoids aligned with the axes, of short semi-axis ``a`` (a
|
|
5
|
+
distribution) and shape factors ``b/a`` and ``c/a`` (``aspect``): a dense packing of
|
|
6
|
+
polydisperse spheres (Lubachevsky–Stillinger) or their random sequential addition,
|
|
7
|
+
mapped by the stretch of the y and z axes, so that the packing of the ellipsoids is the
|
|
8
|
+
affine image of that of spheres (as the packing of Degdeg & Dirrenberger, whose aligned
|
|
9
|
+
ellipsoids fall into a container). Each seed defines the normalized algebraic distance
|
|
10
|
+
|
|
11
|
+
D_i(x) = sum_m (x_m - x_im)^2 / r_im^2 - 1
|
|
12
|
+
|
|
13
|
+
(-1 at its centre, 0 on its surface), and ``D_N1 <= D_N2 <= D_N3 <= D_N4`` are the four
|
|
14
|
+
smallest at ``x``. The open foam is the region ``Phi <= 0`` of
|
|
15
|
+
|
|
16
|
+
Phi = O_p - t O_s - K_c O_k
|
|
17
|
+
O_p = (D_N3 + D_N2)/2 - D_N1 zero on the edges of the tessellation
|
|
18
|
+
O_s = sqrt(c1 xi^4 + c2 xi^2 + 1) thickening towards the nodes
|
|
19
|
+
O_k = min(0, (delta^2 - w^2) / (2 w)) delta = (D_N3 - D_N2)/2, w = t O_s
|
|
20
|
+
|
|
21
|
+
``t`` the thickness (dimensionless; or solved for a ``volume_fraction``), ``K_c`` the
|
|
22
|
+
curvature of the cross-sections of the struts (``0 < K_c < 1``: the concave Plateau
|
|
23
|
+
borders of drained foams; ``K_c < 0``: convex), ``xi`` the position along the strut (0
|
|
24
|
+
at mid-span, 1/2 at the nodes): ``D_N4 - D_N3`` vanishes at the nodes and is largest at
|
|
25
|
+
mid-span, and ``xi = (1 - (D_N4 - D_N3)/m)/2`` with ``m`` its largest value near the
|
|
26
|
+
axis of the strut (the strut of the three nearest seeds), found on a fine grid at
|
|
27
|
+
generation. Closed cells add walls where ``D_N2 = D_N1``:
|
|
28
|
+
``Phi = min(Phi, (D_N2 - D_N1)/2 - t_w)``.
|
|
29
|
+
|
|
30
|
+
:func:`calibrate_seeds` scales the seeds (and, if asked, changes their shape factors)
|
|
31
|
+
until the mean radii of the sections of the pores by the planes of the grid match
|
|
32
|
+
measured ones, the cells of a packing being larger than its seeds.
|
|
33
|
+
"""
|
|
34
|
+
|
|
35
|
+
from __future__ import annotations
|
|
36
|
+
|
|
37
|
+
import dataclasses
|
|
38
|
+
import math
|
|
39
|
+
from dataclasses import dataclass
|
|
40
|
+
from typing import ClassVar
|
|
41
|
+
|
|
42
|
+
import numpy as np
|
|
43
|
+
from scipy.spatial import cKDTree
|
|
44
|
+
|
|
45
|
+
from morphogen._utils import check_fraction, check_positive
|
|
46
|
+
from morphogen.distributions import Constant, Distribution, distribution_from_config
|
|
47
|
+
from morphogen.domain import Domain, Grid
|
|
48
|
+
from morphogen.image import VoxelImage
|
|
49
|
+
from morphogen.kernels.rsa import random_sequential_addition
|
|
50
|
+
from morphogen.models.base import Microstructure, Model, param, register, register_kind
|
|
51
|
+
from morphogen.models.hardcore import grown_packing
|
|
52
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
53
|
+
|
|
54
|
+
_CHUNK = 1 << 18
|
|
55
|
+
_NEAR = 1.0 # points of a strut: O_p below this (normalized units)
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def nearest_distances(points, centres, radii, box, periodic: bool, k: int = 16):
|
|
59
|
+
"""The four smallest ``|y - y_i|^2 / a_i^2 - 1`` at ``points`` (y-space: the seeds are
|
|
60
|
+
spheres of radii ``radii``) and the indices of their seeds, from the ``k`` nearest
|
|
61
|
+
centres (more where the four could hide beyond them)."""
|
|
62
|
+
n = len(centres)
|
|
63
|
+
tree = cKDTree(centres, boxsize=box if periodic else None)
|
|
64
|
+
pts = np.mod(points, box) if periodic else points
|
|
65
|
+
a2 = radii**2
|
|
66
|
+
amax2 = float(a2.max())
|
|
67
|
+
dn = np.empty((len(pts), 4))
|
|
68
|
+
nn = np.empty((len(pts), 4), dtype=np.int64)
|
|
69
|
+
todo = np.arange(len(pts))
|
|
70
|
+
kk = min(k, n)
|
|
71
|
+
while todo.size:
|
|
72
|
+
d, idx = tree.query(pts[todo], k=kk, workers=-1)
|
|
73
|
+
ds = d * d / a2[idx] - 1.0
|
|
74
|
+
order = np.argsort(ds, axis=1)[:, :4]
|
|
75
|
+
rows = np.arange(len(todo))[:, None]
|
|
76
|
+
dn[todo] = ds[rows, order]
|
|
77
|
+
nn[todo] = idx[rows, order]
|
|
78
|
+
if kk >= n:
|
|
79
|
+
break
|
|
80
|
+
bound = d[:, -1] ** 2 / amax2 - 1.0 # no seed beyond the k nearest is closer
|
|
81
|
+
todo = todo[dn[todo, 3] > bound]
|
|
82
|
+
kk = min(2 * kk, n)
|
|
83
|
+
return dn, nn
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
def strut_keys(nn: np.ndarray, n: int) -> np.ndarray:
|
|
87
|
+
"""Key of the strut of the three nearest seeds (their sorted indices)."""
|
|
88
|
+
s = np.sort(nn[:, :3], axis=1)
|
|
89
|
+
return (s[:, 0] * n + s[:, 1]) * n + s[:, 2]
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
@register_kind
|
|
93
|
+
class DistanceFieldFoam(Microstructure):
|
|
94
|
+
"""A foam, the region ``Phi <= 0`` of the level-set function of its seeds (see the
|
|
95
|
+
module); the same realization can be evaluated at any resolution and point."""
|
|
96
|
+
|
|
97
|
+
kind = "distance_field_foam"
|
|
98
|
+
|
|
99
|
+
def __init__(
|
|
100
|
+
self,
|
|
101
|
+
domain,
|
|
102
|
+
centres,
|
|
103
|
+
axes,
|
|
104
|
+
box_lower,
|
|
105
|
+
box_lengths,
|
|
106
|
+
thickness,
|
|
107
|
+
*,
|
|
108
|
+
curvature: float = 0.0,
|
|
109
|
+
c1: float = 0.0,
|
|
110
|
+
c2: float = 0.0,
|
|
111
|
+
cells: str = "open",
|
|
112
|
+
wall_thickness: float = 0.0,
|
|
113
|
+
periodic_box: bool = True,
|
|
114
|
+
struts=None,
|
|
115
|
+
**kwargs,
|
|
116
|
+
):
|
|
117
|
+
super().__init__(domain, **kwargs)
|
|
118
|
+
self.centres = np.asarray(centres, dtype=float).reshape(-1, 3)
|
|
119
|
+
self.axes = np.asarray(axes, dtype=float).reshape(-1, 3)
|
|
120
|
+
if len(self.centres) < 5:
|
|
121
|
+
raise ValueError("distance_field_foam: five seeds at least")
|
|
122
|
+
self.box_lower = np.asarray(box_lower, dtype=float)
|
|
123
|
+
self.box_lengths = np.asarray(box_lengths, dtype=float)
|
|
124
|
+
self.thickness = float(thickness)
|
|
125
|
+
self.curvature = float(curvature)
|
|
126
|
+
self.c1, self.c2 = float(c1), float(c2)
|
|
127
|
+
self.cells = cells
|
|
128
|
+
self.wall_thickness = float(wall_thickness)
|
|
129
|
+
self.periodic_box = bool(periodic_box)
|
|
130
|
+
# aligned ellipsoids of equal shapes: spheres in the y-space x / (1, b/a, c/a)
|
|
131
|
+
self.scale = self.axes[0] / self.axes[0, 0]
|
|
132
|
+
if not np.allclose(self.axes / self.axes[:, :1], self.scale, rtol=1e-9):
|
|
133
|
+
raise ValueError("distance_field_foam: seeds of the same shape (aspect) only")
|
|
134
|
+
self.struts = None
|
|
135
|
+
if struts is not None:
|
|
136
|
+
keys, top = struts
|
|
137
|
+
self.struts = (np.asarray(keys, dtype=np.int64), np.asarray(top, dtype=float))
|
|
138
|
+
|
|
139
|
+
# -- distance fields ----------------------------------------------------------------
|
|
140
|
+
def distances(self, points) -> tuple[np.ndarray, np.ndarray]:
|
|
141
|
+
"""``D_N1..D_N4`` and the indices of their seeds at ``points`` (n x 3)."""
|
|
142
|
+
y = (np.asarray(points, dtype=float) - self.box_lower) / self.scale
|
|
143
|
+
cy = (self.centres - self.box_lower) / self.scale
|
|
144
|
+
box = self.box_lengths / self.scale
|
|
145
|
+
dn = np.empty((len(y), 4))
|
|
146
|
+
nn = np.empty((len(y), 4), dtype=np.int64)
|
|
147
|
+
for s in range(0, len(y), _CHUNK):
|
|
148
|
+
dn[s : s + _CHUNK], nn[s : s + _CHUNK] = nearest_distances(
|
|
149
|
+
y[s : s + _CHUNK], np.mod(cy, box), self.axes[:, 0], box, self.periodic_box
|
|
150
|
+
)
|
|
151
|
+
return dn, nn
|
|
152
|
+
|
|
153
|
+
def learn_struts(self, dn: np.ndarray, nn: np.ndarray) -> None:
|
|
154
|
+
"""Largest ``D_N4 - D_N3`` of each strut, over the points near its axis."""
|
|
155
|
+
op = 0.5 * (dn[:, 2] + dn[:, 1]) - dn[:, 0]
|
|
156
|
+
near = op <= _NEAR
|
|
157
|
+
keys = strut_keys(nn[near], len(self.centres))
|
|
158
|
+
gap = dn[near, 3] - dn[near, 2]
|
|
159
|
+
uniq, inverse = np.unique(keys, return_inverse=True)
|
|
160
|
+
top = np.zeros(len(uniq))
|
|
161
|
+
np.maximum.at(top, inverse, gap)
|
|
162
|
+
self.struts = (uniq, top)
|
|
163
|
+
|
|
164
|
+
def _position(self, dn, nn) -> np.ndarray:
|
|
165
|
+
"""``xi`` along the struts: 0 at mid-span, 1/2 at the nodes."""
|
|
166
|
+
if self.struts is None or len(self.struts[0]) == 0 or (self.c1 == 0 and self.c2 == 0):
|
|
167
|
+
return np.zeros(len(dn))
|
|
168
|
+
keys, top = self.struts
|
|
169
|
+
k = strut_keys(nn, len(self.centres))
|
|
170
|
+
i = np.clip(np.searchsorted(keys, k), 0, len(keys) - 1)
|
|
171
|
+
m = np.where(keys[i] == k, top[i], float(np.median(top)))
|
|
172
|
+
ratio = np.divide(dn[:, 3] - dn[:, 2], m, out=np.ones(len(dn)), where=m > 0)
|
|
173
|
+
return 0.5 * (1.0 - np.clip(ratio, 0.0, 1.0))
|
|
174
|
+
|
|
175
|
+
def phi(self, dn, nn, thickness: float | None = None) -> np.ndarray:
|
|
176
|
+
"""The level-set function (solid where it is not positive)."""
|
|
177
|
+
t = self.thickness if thickness is None else float(thickness)
|
|
178
|
+
xi = self._position(dn, nn)
|
|
179
|
+
o_s = np.sqrt(self.c1 * xi**4 + self.c2 * xi**2 + 1.0)
|
|
180
|
+
o_p = 0.5 * (dn[:, 2] + dn[:, 1]) - dn[:, 0]
|
|
181
|
+
out = o_p - t * o_s
|
|
182
|
+
if t > 0.0 and self.curvature != 0.0:
|
|
183
|
+
w = t * o_s
|
|
184
|
+
delta = 0.5 * (dn[:, 2] - dn[:, 1])
|
|
185
|
+
out -= self.curvature * np.minimum(0.0, (delta**2 - w**2) / (2.0 * w))
|
|
186
|
+
if self.cells == "closed":
|
|
187
|
+
out = np.minimum(out, 0.5 * (dn[:, 1] - dn[:, 0]) - self.wall_thickness)
|
|
188
|
+
return out
|
|
189
|
+
|
|
190
|
+
def values(self, points) -> np.ndarray:
|
|
191
|
+
dn, nn = self.distances(points)
|
|
192
|
+
return self.phi(dn, nn)
|
|
193
|
+
|
|
194
|
+
# -- microstructure -------------------------------------------------------------------
|
|
195
|
+
def _grid_values(self, grid: Grid) -> np.ndarray:
|
|
196
|
+
pts = np.stack(
|
|
197
|
+
np.meshgrid(*[grid.centers(a) for a in range(3)], indexing="ij"), axis=-1
|
|
198
|
+
).reshape(-1, 3)
|
|
199
|
+
return self.values(pts).reshape(grid.shape)
|
|
200
|
+
|
|
201
|
+
def field(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
202
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
203
|
+
data = self._grid_values(grid).astype(np.float32)
|
|
204
|
+
return VoxelImage.from_grid(data, grid, name="phi", metadata=self.image_metadata())
|
|
205
|
+
|
|
206
|
+
def voxelize(self, shape=None, *, voxel_size=None, grid: Grid | None = None, supersampling=1):
|
|
207
|
+
grid = self.grid(shape, voxel_size=voxel_size, grid=grid)
|
|
208
|
+
ss = int(supersampling)
|
|
209
|
+
if not 1 <= ss <= 6:
|
|
210
|
+
raise ValueError("supersampling must be an integer between 1 and 6")
|
|
211
|
+
if ss == 1:
|
|
212
|
+
data = (self._grid_values(grid) <= 0.0).astype(np.uint8)
|
|
213
|
+
return VoxelImage.from_grid(data, grid, name="phase", metadata=self.image_metadata())
|
|
214
|
+
fine = Grid(grid.domain, tuple(n * ss for n in grid.shape))
|
|
215
|
+
inside = (self._grid_values(fine) <= 0.0).astype(np.float32)
|
|
216
|
+
nx, ny, nz = grid.shape
|
|
217
|
+
data = inside.reshape(nx, ss, ny, ss, nz, ss).mean(axis=(1, 3, 5), dtype=np.float32)
|
|
218
|
+
return VoxelImage.from_grid(data, grid, name="fraction", metadata=self.image_metadata())
|
|
219
|
+
|
|
220
|
+
def level_set(self, shape=None, *, voxel_size=None, grid: Grid | None = None) -> VoxelImage:
|
|
221
|
+
"""``Phi`` times half the mean short semi-axis: negative in the solid, roughly a
|
|
222
|
+
distance near its surface (``|grad D_i|`` is about ``2 / a`` there)."""
|
|
223
|
+
f = self.field(shape, voxel_size=voxel_size, grid=grid)
|
|
224
|
+
data = f.data * np.float32(0.5 * float(self.axes[:, 0].mean()))
|
|
225
|
+
return f.with_data(data.astype(np.float32), name="level_set")
|
|
226
|
+
|
|
227
|
+
def contains(self, points) -> np.ndarray:
|
|
228
|
+
return self.values(np.asarray(points, dtype=float).reshape(-1, 3)) <= 0.0
|
|
229
|
+
|
|
230
|
+
#: ``Phi`` grows at most twice as fast as the distance to the nearest seed
|
|
231
|
+
lipschitz = 1.5
|
|
232
|
+
|
|
233
|
+
def level_set_at(self, points, reach: float = np.inf) -> np.ndarray:
|
|
234
|
+
"""``Phi`` times half the mean short semi-axis at the points, as :meth:`level_set`."""
|
|
235
|
+
values = self.values(np.asarray(points, dtype=float).reshape(-1, 3))
|
|
236
|
+
return values * 0.5 * float(self.axes[:, 0].mean())
|
|
237
|
+
|
|
238
|
+
def summary(self) -> dict:
|
|
239
|
+
return {
|
|
240
|
+
"seeds": len(self.centres),
|
|
241
|
+
"thickness": self.thickness,
|
|
242
|
+
"struts": 0 if self.struts is None else len(self.struts[0]),
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
def _geometry(self) -> dict:
|
|
246
|
+
return {
|
|
247
|
+
"centres": self.centres.tolist(),
|
|
248
|
+
"axes": self.axes.tolist(),
|
|
249
|
+
"box_lower": self.box_lower.tolist(),
|
|
250
|
+
"box_lengths": self.box_lengths.tolist(),
|
|
251
|
+
"thickness": self.thickness,
|
|
252
|
+
"curvature": self.curvature,
|
|
253
|
+
"c1": self.c1,
|
|
254
|
+
"c2": self.c2,
|
|
255
|
+
"cells": self.cells,
|
|
256
|
+
"wall_thickness": self.wall_thickness,
|
|
257
|
+
"periodic_box": self.periodic_box,
|
|
258
|
+
"struts": None
|
|
259
|
+
if self.struts is None
|
|
260
|
+
else [self.struts[0].tolist(), self.struts[1].tolist()],
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
@classmethod
|
|
264
|
+
def _from_geometry(cls, domain, geometry, **kwargs):
|
|
265
|
+
g = dict(geometry)
|
|
266
|
+
return cls(
|
|
267
|
+
domain,
|
|
268
|
+
g.pop("centres"),
|
|
269
|
+
g.pop("axes"),
|
|
270
|
+
g.pop("box_lower"),
|
|
271
|
+
g.pop("box_lengths"),
|
|
272
|
+
g.pop("thickness"),
|
|
273
|
+
**g,
|
|
274
|
+
**kwargs,
|
|
275
|
+
)
|
|
276
|
+
|
|
277
|
+
|
|
278
|
+
@register
|
|
279
|
+
@dataclass(frozen=True)
|
|
280
|
+
class LevelSetFoam(Model):
|
|
281
|
+
"""Open- or closed-cell foams as level sets of the distance fields of a packing of
|
|
282
|
+
aligned ellipsoids (Sonon et al. 2012; Kilingar et al. 2019; Degdeg & Dirrenberger
|
|
283
|
+
2026): struts with Plateau-border cross-sections of controlled curvature, thickening
|
|
284
|
+
towards the nodes, cells elongated by the shape of the seeds (see the module)."""
|
|
285
|
+
|
|
286
|
+
name = "level_set_foam"
|
|
287
|
+
phases: ClassVar[dict[int, str]] = {0: "pores", 1: "solid"}
|
|
288
|
+
count_label = "seeds"
|
|
289
|
+
|
|
290
|
+
seed_radius: Distribution = param(
|
|
291
|
+
Constant(0.1),
|
|
292
|
+
doc="Short semi-axis a of the seed ellipsoids",
|
|
293
|
+
kind="distribution",
|
|
294
|
+
unit="length",
|
|
295
|
+
)
|
|
296
|
+
aspect: tuple[float, ...] = param(
|
|
297
|
+
(1.0, 1.0),
|
|
298
|
+
doc="Shape factors b/a and c/a of the seeds (semi-axes along y and z)",
|
|
299
|
+
kind="floats",
|
|
300
|
+
)
|
|
301
|
+
packing: str = param(
|
|
302
|
+
"dense",
|
|
303
|
+
doc="Packing of the seeds: dense (Lubachevsky-Stillinger) or rsa (random sequential "
|
|
304
|
+
"addition)",
|
|
305
|
+
kind="str",
|
|
306
|
+
)
|
|
307
|
+
packing_fraction: float = param(
|
|
308
|
+
0.6, doc="Volume fraction of the seed ellipsoids", kind="fraction"
|
|
309
|
+
)
|
|
310
|
+
thickness: float | None = param(
|
|
311
|
+
None, doc="Thickness t of the struts (dimensionless; or give volume_fraction)"
|
|
312
|
+
)
|
|
313
|
+
volume_fraction: float | None = param(
|
|
314
|
+
None, doc="Solid volume fraction, reached by solving for t", kind="fraction"
|
|
315
|
+
)
|
|
316
|
+
curvature: float = param(
|
|
317
|
+
0.0, doc="Curvature K_c of the cross-sections: 0 < K_c < 1 concave, K_c < 0 convex"
|
|
318
|
+
)
|
|
319
|
+
c1: float = param(0.0, doc="Node thickening: A(xi) = c1 xi^4 + c2 xi^2 + 1")
|
|
320
|
+
c2: float = param(0.0, doc="Node thickening: A(xi) = c1 xi^4 + c2 xi^2 + 1")
|
|
321
|
+
cells: str = param("open", doc="open (struts) or closed (struts and walls)", kind="str")
|
|
322
|
+
wall_thickness: float = param(
|
|
323
|
+
0.05, doc="Thickness of the walls of closed cells (dimensionless)"
|
|
324
|
+
)
|
|
325
|
+
growth_rate: float = param(0.01, doc="Growth rate of the dense packing", unit="")
|
|
326
|
+
|
|
327
|
+
def _validate(self) -> None:
|
|
328
|
+
if len(self.aspect) != 2 or min(self.aspect) <= 0:
|
|
329
|
+
raise ValueError("aspect: two positive shape factors, b/a and c/a")
|
|
330
|
+
if self.packing not in ("dense", "rsa"):
|
|
331
|
+
raise ValueError("packing: dense or rsa")
|
|
332
|
+
check_fraction(self.packing_fraction, "packing_fraction")
|
|
333
|
+
if (self.thickness is None) == (self.volume_fraction is None):
|
|
334
|
+
raise ValueError("give exactly one of thickness and volume_fraction")
|
|
335
|
+
if self.thickness is not None:
|
|
336
|
+
check_positive(self.thickness, "thickness")
|
|
337
|
+
else:
|
|
338
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
339
|
+
if not self.curvature < 1.0:
|
|
340
|
+
raise ValueError("curvature: K_c < 1")
|
|
341
|
+
if self.cells not in ("open", "closed"):
|
|
342
|
+
raise ValueError("cells: open or closed")
|
|
343
|
+
check_positive(self.wall_thickness, "wall_thickness", allow_zero=True)
|
|
344
|
+
check_positive(self.growth_rate, "growth_rate")
|
|
345
|
+
|
|
346
|
+
@property
|
|
347
|
+
def scale(self) -> np.ndarray:
|
|
348
|
+
return np.array([1.0, *self.aspect])
|
|
349
|
+
|
|
350
|
+
def _radii(self, rng, volume: float) -> np.ndarray:
|
|
351
|
+
"""Short semi-axes of the seeds filling ``packing_fraction`` of ``volume``."""
|
|
352
|
+
shape = float(np.prod(self.scale))
|
|
353
|
+
target = self.packing_fraction * volume
|
|
354
|
+
radii = np.empty(0)
|
|
355
|
+
while True:
|
|
356
|
+
m = int(1.2 * target / (4.0 / 3.0 * math.pi * shape * self.seed_radius.moment(3))) + 8
|
|
357
|
+
radii = np.concatenate([radii, self.seed_radius.sample(rng, m)])
|
|
358
|
+
cum = np.cumsum(4.0 / 3.0 * math.pi * shape * radii**3)
|
|
359
|
+
if cum[-1] >= target:
|
|
360
|
+
return radii[: int(np.searchsorted(cum, target)) + 1]
|
|
361
|
+
|
|
362
|
+
def seeds(self, domain: Domain, rng) -> tuple[np.ndarray, np.ndarray, Domain]:
|
|
363
|
+
"""Centres and semi-axes of the seed ellipsoids, and their periodic box (the
|
|
364
|
+
domain if periodic, enlarged by two long semi-axes otherwise)."""
|
|
365
|
+
reach = 2.0 * float(self.seed_radius.upper()) * float(self.scale.max())
|
|
366
|
+
box = domain if domain.periodic else domain.dilated(reach)
|
|
367
|
+
radii = self._radii(rng, box.volume)
|
|
368
|
+
lengths = box.lengths / self.scale # the box of the spheres
|
|
369
|
+
if self.packing == "dense":
|
|
370
|
+
if np.any(lengths < 6.0 * radii.max()):
|
|
371
|
+
raise ValueError(
|
|
372
|
+
"level_set_foam: the dense packing needs a box of three seed diameters along "
|
|
373
|
+
"each axis (the long ones included): enlarge it or use packing: rsa"
|
|
374
|
+
)
|
|
375
|
+
pos = grown_packing(radii, lengths, rng, growth_rate=self.growth_rate)
|
|
376
|
+
else:
|
|
377
|
+
order = np.argsort(-radii, kind="stable")
|
|
378
|
+
pos = np.empty((len(radii), 3))
|
|
379
|
+
pos[order] = random_sequential_addition(
|
|
380
|
+
radii[order], lengths, 0.0, rng, 10_000 * len(radii)
|
|
381
|
+
)
|
|
382
|
+
centres = box.lower + pos * self.scale
|
|
383
|
+
return centres, radii[:, None] * self.scale, box
|
|
384
|
+
|
|
385
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> DistanceFieldFoam:
|
|
386
|
+
rng, seed_info = make_rng(seed)
|
|
387
|
+
centres, axes, box = self.seeds(domain, rng)
|
|
388
|
+
foam = DistanceFieldFoam(
|
|
389
|
+
domain,
|
|
390
|
+
centres,
|
|
391
|
+
axes,
|
|
392
|
+
box.lower,
|
|
393
|
+
box.lengths,
|
|
394
|
+
self.thickness if self.thickness is not None else 0.0,
|
|
395
|
+
curvature=self.curvature,
|
|
396
|
+
c1=self.c1,
|
|
397
|
+
c2=self.c2,
|
|
398
|
+
cells=self.cells,
|
|
399
|
+
wall_thickness=self.wall_thickness,
|
|
400
|
+
periodic_box=True,
|
|
401
|
+
model=self,
|
|
402
|
+
seed=seed_info,
|
|
403
|
+
)
|
|
404
|
+
# the struts (and the thickness) on a grid of about eight voxels per short semi-axis
|
|
405
|
+
h = float(self.seed_radius.moment(1)) / 8.0
|
|
406
|
+
n = np.maximum(8, np.ceil(domain.lengths / h)).astype(int)
|
|
407
|
+
while np.prod(n) > 2_000_000:
|
|
408
|
+
n = np.maximum(8, n // 2 + 1)
|
|
409
|
+
grid = Grid(domain, tuple(int(v) for v in n))
|
|
410
|
+
pts = np.stack(np.meshgrid(*[grid.centers(a) for a in range(3)], indexing="ij"), axis=-1)
|
|
411
|
+
dn, nn = foam.distances(pts.reshape(-1, 3))
|
|
412
|
+
foam.learn_struts(dn, nn)
|
|
413
|
+
if self.volume_fraction is not None:
|
|
414
|
+
foam.thickness = self._solve_thickness(foam, dn, nn)
|
|
415
|
+
return foam
|
|
416
|
+
|
|
417
|
+
def _solve_thickness(self, foam, dn, nn) -> float:
|
|
418
|
+
"""Bisection of the solid fraction of the generation grid (increasing with t)."""
|
|
419
|
+
target = self.volume_fraction
|
|
420
|
+
lo, hi = 0.0, 0.5
|
|
421
|
+
while np.mean(foam.phi(dn, nn, hi) <= 0.0) < target:
|
|
422
|
+
lo, hi = hi, 2.0 * hi
|
|
423
|
+
if hi > 64.0:
|
|
424
|
+
raise ValueError("level_set_foam: the volume fraction cannot be reached")
|
|
425
|
+
for _ in range(50):
|
|
426
|
+
mid = 0.5 * (lo + hi)
|
|
427
|
+
if np.mean(foam.phi(dn, nn, mid) <= 0.0) < target:
|
|
428
|
+
lo = mid
|
|
429
|
+
else:
|
|
430
|
+
hi = mid
|
|
431
|
+
return 0.5 * (lo + hi)
|
|
432
|
+
|
|
433
|
+
def expected_count(self, domain: Domain) -> float:
|
|
434
|
+
shape = float(np.prod(self.scale))
|
|
435
|
+
return (
|
|
436
|
+
self.packing_fraction
|
|
437
|
+
* domain.volume
|
|
438
|
+
/ (4.0 / 3.0 * math.pi * shape * self.seed_radius.moment(3))
|
|
439
|
+
)
|
|
440
|
+
|
|
441
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
442
|
+
shape = float(np.prod(self.scale))
|
|
443
|
+
return {
|
|
444
|
+
"seed_packing_fraction": self.packing_fraction,
|
|
445
|
+
"seed_intensity": self.packing_fraction
|
|
446
|
+
/ (4.0 / 3.0 * math.pi * shape * self.seed_radius.moment(3)),
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
|
|
450
|
+
#: Keys of the configurations of distributions that are lengths.
|
|
451
|
+
_LENGTHS = ("value", "low", "high", "mean", "std")
|
|
452
|
+
#: d log kappa_D / d (log s, log b/a, log c/a) of the sections normal to x, y and z of
|
|
453
|
+
#: ellipsoids of semi-axes a, b, c along x, y, z (kappa_x = sqrt(bc)/a, kappa_y = sqrt(c/a),
|
|
454
|
+
#: kappa_z = sqrt(b/a), in units of a).
|
|
455
|
+
_SECTION_JACOBIAN = np.array([[1.0, 0.5, 0.5], [1.0, 0.0, 0.5], [1.0, 0.5, 0.0]])
|
|
456
|
+
|
|
457
|
+
|
|
458
|
+
def _scaled(distribution: Distribution, factor: float) -> Distribution:
|
|
459
|
+
"""``distribution`` of lengths multiplied by ``factor``."""
|
|
460
|
+
cfg = distribution.to_config()
|
|
461
|
+
if not isinstance(cfg, dict):
|
|
462
|
+
return Constant(float(cfg) * factor)
|
|
463
|
+
out = {}
|
|
464
|
+
for key, value in cfg.items():
|
|
465
|
+
if key == "values":
|
|
466
|
+
out[key] = [factor * float(v) for v in value]
|
|
467
|
+
elif key in _LENGTHS:
|
|
468
|
+
out[key] = factor * float(value)
|
|
469
|
+
else:
|
|
470
|
+
out[key] = value
|
|
471
|
+
return distribution_from_config(out)
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
@dataclass
|
|
475
|
+
class SeedCalibration:
|
|
476
|
+
"""The result of :func:`calibrate_seeds`: the calibrated ``model``, the ``scale`` of its
|
|
477
|
+
seeds relative to the initial model and their ``aspect``, the ``target`` and
|
|
478
|
+
``achieved`` mean section radii (axis -> radius), the ``history`` of (scale, aspect,
|
|
479
|
+
achieved) over the iterations and the ``sections`` of the last foam."""
|
|
480
|
+
|
|
481
|
+
model: Model
|
|
482
|
+
scale: float
|
|
483
|
+
aspect: tuple[float, float]
|
|
484
|
+
target: dict[int, float]
|
|
485
|
+
achieved: dict[int, float]
|
|
486
|
+
history: list
|
|
487
|
+
sections: list
|
|
488
|
+
|
|
489
|
+
@property
|
|
490
|
+
def residual(self) -> float:
|
|
491
|
+
"""The largest relative deviation of the achieved mean section radii."""
|
|
492
|
+
return max(abs(self.achieved[a] / self.target[a] - 1.0) for a in self.target)
|
|
493
|
+
|
|
494
|
+
|
|
495
|
+
def calibrate_seeds(
|
|
496
|
+
model: LevelSetFoam,
|
|
497
|
+
domain: Domain,
|
|
498
|
+
target,
|
|
499
|
+
*,
|
|
500
|
+
shape=None,
|
|
501
|
+
voxel_size=None,
|
|
502
|
+
phase: int = 0,
|
|
503
|
+
fit_shape: bool = False,
|
|
504
|
+
separate: bool = True,
|
|
505
|
+
prominence: float | None = None,
|
|
506
|
+
min_radius: float = 0.0,
|
|
507
|
+
iterations: int = 8,
|
|
508
|
+
tol: float = 0.01,
|
|
509
|
+
seed: SeedLike = None,
|
|
510
|
+
) -> SeedCalibration:
|
|
511
|
+
"""Scale the seeds of a foam, and with ``fit_shape`` change their shape factors, until
|
|
512
|
+
the mean radii of the sections of its ``phase`` (the pores) by the planes normal to the
|
|
513
|
+
axes of ``target`` (a mapping axis -> mean radius, or the measured
|
|
514
|
+
:class:`~morphogen.analysis.stereology.Sections`) match them within ``tol``.
|
|
515
|
+
Gauss–Newton steps in the logarithms of the scale and of the shape factors with the
|
|
516
|
+
Jacobian of ellipsoids, ``log r_D = log s + log kappa_D(b/a, c/a)`` (``fit_shape``
|
|
517
|
+
needs the three axes; otherwise the step is the mean logarithmic deviation, and the
|
|
518
|
+
iterations stop when it falls below ``tol / 2``, a shape that does not fit the
|
|
519
|
+
sections leaving its misfit in :attr:`SeedCalibration.residual`); each foam
|
|
520
|
+
is generated with the same ``seed`` (drawn once if None) on the grid ``shape`` or
|
|
521
|
+
``voxel_size`` and measured as the target should have been (``separate``,
|
|
522
|
+
``prominence``, ``min_radius``: see
|
|
523
|
+
:func:`~morphogen.analysis.stereology.section_sizes`)."""
|
|
524
|
+
from morphogen.analysis.stereology import section_sizes
|
|
525
|
+
|
|
526
|
+
if isinstance(target, dict):
|
|
527
|
+
means = {int(a): float(r) for a, r in target.items()}
|
|
528
|
+
else:
|
|
529
|
+
means = {s.axis: s.mean_radius() for s in target}
|
|
530
|
+
axes = sorted(means)
|
|
531
|
+
if fit_shape and axes != [0, 1, 2]:
|
|
532
|
+
raise ValueError("calibrate_seeds: fit_shape needs the sections normal to x, y and z")
|
|
533
|
+
if seed is None:
|
|
534
|
+
seed = int(np.random.default_rng().integers(2**31))
|
|
535
|
+
base = model.seed_radius
|
|
536
|
+
log_p = np.log([1.0, *model.aspect])
|
|
537
|
+
goal = np.log([means[a] for a in axes])
|
|
538
|
+
jacobian = _SECTION_JACOBIAN[axes] if fit_shape else np.ones((len(axes), 1))
|
|
539
|
+
history = []
|
|
540
|
+
for it in range(int(iterations) + 1):
|
|
541
|
+
scale, aspect = float(np.exp(log_p[0])), tuple(float(v) for v in np.exp(log_p[1:]))
|
|
542
|
+
current = dataclasses.replace(model, seed_radius=_scaled(base, scale), aspect=aspect)
|
|
543
|
+
image = current.generate(domain, seed=seed).voxelize(shape, voxel_size=voxel_size)
|
|
544
|
+
sections = [
|
|
545
|
+
section_sizes(
|
|
546
|
+
image, phase, a, separate=separate, prominence=prominence, min_radius=min_radius
|
|
547
|
+
)
|
|
548
|
+
for a in axes
|
|
549
|
+
]
|
|
550
|
+
got = np.log([s.mean_radius() for s in sections])
|
|
551
|
+
achieved = {a: float(np.exp(g)) for a, g in zip(axes, got, strict=True)}
|
|
552
|
+
history.append((scale, aspect, achieved))
|
|
553
|
+
residual = goal - got
|
|
554
|
+
if np.abs(np.expm1(residual)).max() < tol or it == int(iterations):
|
|
555
|
+
break
|
|
556
|
+
step, *_ = np.linalg.lstsq(jacobian, residual, rcond=None)
|
|
557
|
+
if np.abs(step).max() < 0.5 * tol:
|
|
558
|
+
break # settled: what remains is the misfit of the shape
|
|
559
|
+
if fit_shape:
|
|
560
|
+
log_p += step
|
|
561
|
+
else:
|
|
562
|
+
log_p[0] += step[0]
|
|
563
|
+
return SeedCalibration(current, scale, aspect, means, achieved, history, sections)
|