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,592 @@
|
|
|
1
|
+
"""Microstructures generated by cellular automata and reaction-diffusion.
|
|
2
|
+
|
|
3
|
+
Each realization is a :class:`~morphogen.models.lattice_field.LatticeField` on a
|
|
4
|
+
lattice of cells of edge ``cell_size`` covering the domain:
|
|
5
|
+
|
|
6
|
+
* periodic domains use periodic lattices (the realization tiles space);
|
|
7
|
+
* non-periodic domains are windows of an automaton running on a larger periodic
|
|
8
|
+
lattice, enlarged by the distance information travels in the run (the light cone:
|
|
9
|
+
neighbourhood radius times the number of steps, at most 32 cells): the windows are
|
|
10
|
+
then unbiased, without boundary effects.
|
|
11
|
+
|
|
12
|
+
``dimension: 2`` runs planar automata (one cell through the thickness of the domain).
|
|
13
|
+
Other ``lattice`` values than ``square`` run the automata (and reaction-diffusion, with
|
|
14
|
+
the finite-volume Laplacian of the tiling) on the cells of a tiling
|
|
15
|
+
(:mod:`morphogen.automata.tilings`: triangles, hexagons, Penrose and Ammann-Beenker
|
|
16
|
+
tiles, prisms, the Voronoi cells of the BCC and FCC lattices, golden rhombohedra) and
|
|
17
|
+
give a :class:`~morphogen.models.tiling_field.TilingField`, rasterized cell by cell; the
|
|
18
|
+
non-periodic windows are then cut from a larger periodic tiling (a larger quasi-periodic
|
|
19
|
+
patch, with free boundaries) in the same way. Quasi-periodic tilings fill periodic
|
|
20
|
+
domains through their periodic approximants (``approximant``: an order), the same tiles
|
|
21
|
+
in a rectangle or a cube of which the box holds a whole number.
|
|
22
|
+
"""
|
|
23
|
+
|
|
24
|
+
from __future__ import annotations
|
|
25
|
+
|
|
26
|
+
import math
|
|
27
|
+
from dataclasses import dataclass
|
|
28
|
+
from typing import ClassVar
|
|
29
|
+
|
|
30
|
+
import numpy as np
|
|
31
|
+
|
|
32
|
+
from morphogen._utils import check_fraction, check_positive
|
|
33
|
+
from morphogen.automata.engine import UPDATES, CellularAutomaton, random_state
|
|
34
|
+
from morphogen.automata.lattice import NEIGHBOURHOODS
|
|
35
|
+
from morphogen.automata.reaction import (
|
|
36
|
+
GRAY_SCOTT_PRESETS,
|
|
37
|
+
gray_scott,
|
|
38
|
+
gray_scott_tiling,
|
|
39
|
+
stable_substeps,
|
|
40
|
+
)
|
|
41
|
+
from morphogen.automata.rules import ActivatorInhibitorRule, make_rule
|
|
42
|
+
from morphogen.automata.tilings import LATTICES, PLANAR, QUASIPERIODIC, REACH, make_tiling
|
|
43
|
+
from morphogen.domain import Domain
|
|
44
|
+
from morphogen.models.base import Model, param, register
|
|
45
|
+
from morphogen.models.lattice_field import LatticeField, lattice_shape
|
|
46
|
+
from morphogen.models.tiling_field import TilingField, default_grid
|
|
47
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
48
|
+
|
|
49
|
+
#: Largest margin (in cells) added around non-periodic windows.
|
|
50
|
+
MAX_MARGIN = 32
|
|
51
|
+
|
|
52
|
+
_LATTICE_DOC = (
|
|
53
|
+
"Cells: square (cubes in 3D), triangular, hexagonal, penrose or ammann_beenker "
|
|
54
|
+
"(quasi-periodic: non-periodic domains, or periodic ones with an approximant), "
|
|
55
|
+
"stacked as prisms in 3D; bcc, fcc or "
|
|
56
|
+
"icosahedral (3D: truncated octahedra, rhombic dodecahedra, golden rhombohedra, the "
|
|
57
|
+
"last quasi-periodic). Cells of area cell_size^2 or volume cell_size^3 (on average "
|
|
58
|
+
"for quasi-periodic tilings)"
|
|
59
|
+
)
|
|
60
|
+
_APPROXIMANT_DOC = (
|
|
61
|
+
"Order (1, 2, ...) of the periodic approximant of a quasi-periodic lattice (penrose, "
|
|
62
|
+
"ammann_beenker, icosahedral) for periodic domains: the same tiles, periodic in a "
|
|
63
|
+
"rectangle or a cube that the box holds a whole number of times (fitted to it; "
|
|
64
|
+
"morphogen.automata.tilings.approximant_period). Non-periodic domains: windows of it"
|
|
65
|
+
)
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
def _recorder(steps: int, frames: int, crop, pick=None):
|
|
69
|
+
"""Frames (window sections of the states) at about ``frames`` evenly spaced steps,
|
|
70
|
+
and the callback that records them (None without frames)."""
|
|
71
|
+
record: list[np.ndarray] = []
|
|
72
|
+
if frames <= 0:
|
|
73
|
+
return record, None
|
|
74
|
+
every = max(1, round(steps / frames))
|
|
75
|
+
|
|
76
|
+
def callback(k, *state):
|
|
77
|
+
if k % every == 0 or k == steps:
|
|
78
|
+
current = pick(*state) if pick is not None else state[0]
|
|
79
|
+
record.append(np.array(current[crop]))
|
|
80
|
+
|
|
81
|
+
return record, callback
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
@dataclass(frozen=True)
|
|
85
|
+
class _LatticeModel(Model):
|
|
86
|
+
"""Common parameters of the models generated cell by cell."""
|
|
87
|
+
|
|
88
|
+
phases: ClassVar[dict[int, str]] = {0: "phase 0", 1: "phase 1"}
|
|
89
|
+
|
|
90
|
+
cell_size: float = param(
|
|
91
|
+
1.0,
|
|
92
|
+
doc="Edge of the cells of the lattice (other lattices than square: the edge of the "
|
|
93
|
+
"square or cube of the same area or volume)",
|
|
94
|
+
unit="length",
|
|
95
|
+
)
|
|
96
|
+
dimension: int = param(
|
|
97
|
+
3, doc="3, or 2 for planar structures (one cell through the thickness)", kind="int"
|
|
98
|
+
)
|
|
99
|
+
smoothing: float = param(
|
|
100
|
+
0.0,
|
|
101
|
+
doc="Gaussian smoothing (in cells) of the interface for other resolutions and "
|
|
102
|
+
"conforming meshes (0: trilinear interpolation of the cells)",
|
|
103
|
+
unit="cells",
|
|
104
|
+
)
|
|
105
|
+
|
|
106
|
+
def _validate_lattice(self) -> None:
|
|
107
|
+
check_positive(self.cell_size, "cell_size")
|
|
108
|
+
if self.dimension not in (2, 3):
|
|
109
|
+
raise ValueError("dimension: 2 or 3")
|
|
110
|
+
check_positive(self.smoothing, "smoothing", allow_zero=True)
|
|
111
|
+
|
|
112
|
+
def evolution(self, domain: Domain, seed: SeedLike = None, frames: int = 20):
|
|
113
|
+
"""States of the lattice of the domain along the formation of the realization of
|
|
114
|
+
``generate(domain, seed)`` (about ``frames`` of them, the realization last)."""
|
|
115
|
+
rng, _ = make_rng(seed)
|
|
116
|
+
return self._simulate(domain, rng, max(1, int(frames)))[-1]
|
|
117
|
+
|
|
118
|
+
def _validate_tiling(self) -> None:
|
|
119
|
+
if self.lattice not in LATTICES:
|
|
120
|
+
raise ValueError(f"lattice: one of {LATTICES}")
|
|
121
|
+
if self.lattice not in PLANAR and self.dimension != 3:
|
|
122
|
+
raise ValueError(f"lattice {self.lattice}: three-dimensional (dimension: 3)")
|
|
123
|
+
if self.lattice != "square" and self.smoothing > 0:
|
|
124
|
+
raise ValueError(
|
|
125
|
+
"smoothing: square lattices only (tilings are rasterized cell by cell)"
|
|
126
|
+
)
|
|
127
|
+
if self.approximant is not None:
|
|
128
|
+
if self.lattice not in QUASIPERIODIC:
|
|
129
|
+
raise ValueError(
|
|
130
|
+
f"approximant: quasi-periodic lattices only ({', '.join(QUASIPERIODIC)})"
|
|
131
|
+
)
|
|
132
|
+
if self.approximant < 1:
|
|
133
|
+
raise ValueError("approximant: an order of at least 1")
|
|
134
|
+
|
|
135
|
+
def _tiling(self, domain: Domain, reach_cells: float, rng):
|
|
136
|
+
"""Tiling of the simulation and the indices of its cells meeting the domain (None:
|
|
137
|
+
all): the periodic tiling of a periodic domain (the approximant of a quasi-periodic
|
|
138
|
+
one), otherwise a tiling of the domain enlarged by the light cone (periodic, or a
|
|
139
|
+
free patch for quasi-periodic tilings without approximant)."""
|
|
140
|
+
h, dims = self.cell_size, self.dimension
|
|
141
|
+
approximant = self.approximant
|
|
142
|
+
if domain.periodic:
|
|
143
|
+
tiling = make_tiling(
|
|
144
|
+
self.lattice, domain.lengths, h, dims=dims, periodic=True, origin=domain.lower,
|
|
145
|
+
rng=rng, approximant=approximant,
|
|
146
|
+
) # fmt: skip
|
|
147
|
+
return tiling, None
|
|
148
|
+
margin = min(MAX_MARGIN, math.ceil(reach_cells)) * h
|
|
149
|
+
pad = np.array([margin, margin, margin if dims == 3 else 0.0])
|
|
150
|
+
tiling = make_tiling(
|
|
151
|
+
self.lattice,
|
|
152
|
+
domain.lengths + 2 * pad,
|
|
153
|
+
h,
|
|
154
|
+
dims=dims,
|
|
155
|
+
periodic=self.lattice not in QUASIPERIODIC or approximant is not None,
|
|
156
|
+
origin=domain.lower - pad,
|
|
157
|
+
rng=rng,
|
|
158
|
+
approximant=approximant,
|
|
159
|
+
)
|
|
160
|
+
r = tiling.circumradius
|
|
161
|
+
lo, hi = domain.lower - r, domain.upper + r
|
|
162
|
+
inside = np.all((tiling.centres >= lo) & (tiling.centres <= hi), axis=1)
|
|
163
|
+
return tiling, np.flatnonzero(inside)
|
|
164
|
+
|
|
165
|
+
def _frames_of(self, domain: Domain, tiling, frames: int):
|
|
166
|
+
"""Image of the cells of the window (default grid of the realizations), indexing
|
|
167
|
+
the states of the frames, or None without frames."""
|
|
168
|
+
return tiling.cell_index(default_grid(domain, tiling)) if frames > 0 else None
|
|
169
|
+
|
|
170
|
+
def _window(self, domain: Domain, reach_cells: float):
|
|
171
|
+
"""Lattice of the domain, simulation lattice and the slices of the window."""
|
|
172
|
+
shape = lattice_shape(domain, self.cell_size, self.dimension)
|
|
173
|
+
if domain.periodic:
|
|
174
|
+
return shape, shape, (slice(None),) * 3
|
|
175
|
+
margin = int(min(MAX_MARGIN, math.ceil(reach_cells)))
|
|
176
|
+
sim = tuple(
|
|
177
|
+
n + 2 * margin if (a < 2 or self.dimension == 3) else n for a, n in enumerate(shape)
|
|
178
|
+
)
|
|
179
|
+
crop = tuple(
|
|
180
|
+
slice(margin, margin + n) if (a < 2 or self.dimension == 3) else slice(None)
|
|
181
|
+
for a, n in enumerate(shape)
|
|
182
|
+
)
|
|
183
|
+
return shape, sim, crop
|
|
184
|
+
|
|
185
|
+
|
|
186
|
+
@register
|
|
187
|
+
@dataclass(frozen=True)
|
|
188
|
+
class CellularAutomatonModel(_LatticeModel):
|
|
189
|
+
"""Two-phase structure grown by a cellular automaton from random noise."""
|
|
190
|
+
|
|
191
|
+
name = "cellular_automaton"
|
|
192
|
+
|
|
193
|
+
rule: str = param(
|
|
194
|
+
"anneal",
|
|
195
|
+
doc="majority, anneal (twisted majority: bicontinuous coarsening), conserved "
|
|
196
|
+
"(majority at constant volume fraction), clouds, life, or B<counts>/S<counts>",
|
|
197
|
+
kind="str",
|
|
198
|
+
)
|
|
199
|
+
steps: int = param(30, doc="Number of updates", kind="int")
|
|
200
|
+
neighbourhood: str = param("moore", doc="von_neumann, moore, edges or euclidean", kind="str")
|
|
201
|
+
radius: float = param(1.0, doc="Radius of the neighbourhood, in cells")
|
|
202
|
+
initial_fraction: float = param(
|
|
203
|
+
0.5, doc="Probability of phase 1 in the initial noise", kind="fraction"
|
|
204
|
+
)
|
|
205
|
+
volume_fraction: float | None = param(
|
|
206
|
+
None, doc="Volume fraction kept by the 'conserved' rule", kind="fraction"
|
|
207
|
+
)
|
|
208
|
+
update: str = param("synchronous", doc="synchronous, asynchronous or sequential", kind="str")
|
|
209
|
+
async_fraction: float = param(
|
|
210
|
+
0.5,
|
|
211
|
+
doc="Probability that a cell is updated at each asynchronous step",
|
|
212
|
+
kind="fraction",
|
|
213
|
+
)
|
|
214
|
+
lattice: str = param(
|
|
215
|
+
"square",
|
|
216
|
+
doc=_LATTICE_DOC,
|
|
217
|
+
kind="str",
|
|
218
|
+
)
|
|
219
|
+
approximant: int | None = param(None, doc=_APPROXIMANT_DOC, kind="int")
|
|
220
|
+
|
|
221
|
+
def _validate(self) -> None:
|
|
222
|
+
self._validate_lattice()
|
|
223
|
+
self._validate_tiling()
|
|
224
|
+
conserved = str(self.rule).strip().lower() == "conserved"
|
|
225
|
+
if conserved and self.volume_fraction is None:
|
|
226
|
+
raise ValueError("the 'conserved' rule needs 'volume_fraction'")
|
|
227
|
+
if not conserved and self.volume_fraction is not None:
|
|
228
|
+
raise ValueError(
|
|
229
|
+
"volume_fraction is kept only by the 'conserved' rule; other rules start "
|
|
230
|
+
"from 'initial_fraction'"
|
|
231
|
+
)
|
|
232
|
+
make_rule(self.rule, fraction=self.volume_fraction) # raises on bad rules
|
|
233
|
+
if self.neighbourhood not in NEIGHBOURHOODS:
|
|
234
|
+
raise ValueError(f"neighbourhood: one of {NEIGHBOURHOODS}")
|
|
235
|
+
if not self.radius >= 1:
|
|
236
|
+
raise ValueError("radius: at least 1 cell")
|
|
237
|
+
if self.steps < 0:
|
|
238
|
+
raise ValueError("steps: must be non-negative")
|
|
239
|
+
if self.update not in UPDATES:
|
|
240
|
+
raise ValueError(f"update: one of {UPDATES}")
|
|
241
|
+
check_fraction(self.initial_fraction, "initial_fraction")
|
|
242
|
+
if self.volume_fraction is not None:
|
|
243
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
244
|
+
|
|
245
|
+
@property
|
|
246
|
+
def conserved(self) -> bool:
|
|
247
|
+
return self.volume_fraction is not None
|
|
248
|
+
|
|
249
|
+
def automaton(self, periodic: bool = True, tiling=None) -> CellularAutomaton:
|
|
250
|
+
return CellularAutomaton(
|
|
251
|
+
self.rule,
|
|
252
|
+
neighbourhood=self.neighbourhood,
|
|
253
|
+
radius=self.radius,
|
|
254
|
+
dims=self.dimension,
|
|
255
|
+
periodic=periodic,
|
|
256
|
+
fraction=self.volume_fraction,
|
|
257
|
+
tiling=tiling,
|
|
258
|
+
)
|
|
259
|
+
|
|
260
|
+
def _simulate_tiling(self, domain: Domain, rng, frames: int = 0):
|
|
261
|
+
reach = self.radius * self.steps
|
|
262
|
+
if self.neighbourhood != "euclidean":
|
|
263
|
+
reach *= REACH[self.lattice]
|
|
264
|
+
tiling, cells = self._tiling(domain, reach, rng)
|
|
265
|
+
p0 = self.volume_fraction if self.conserved else self.initial_fraction
|
|
266
|
+
state = random_state((tiling.n_cells,), p0, rng, exact=self.conserved)
|
|
267
|
+
crop = self._frames_of(domain, tiling, frames)
|
|
268
|
+
record, callback = _recorder(self.steps, frames, crop)
|
|
269
|
+
if callback is not None:
|
|
270
|
+
callback(0, state)
|
|
271
|
+
evo = self.automaton(tiling=tiling).run(
|
|
272
|
+
state,
|
|
273
|
+
self.steps,
|
|
274
|
+
rng,
|
|
275
|
+
update=self.update,
|
|
276
|
+
async_fraction=self.async_fraction,
|
|
277
|
+
callback=callback,
|
|
278
|
+
)
|
|
279
|
+
if callback is not None and not np.array_equal(record[-1], evo.state[crop]):
|
|
280
|
+
record.append(evo.state[crop].copy())
|
|
281
|
+
return evo, (tiling, cells), record
|
|
282
|
+
|
|
283
|
+
def _simulate(self, domain: Domain, rng, frames: int = 0):
|
|
284
|
+
if self.lattice != "square":
|
|
285
|
+
return self._simulate_tiling(domain, rng, frames)
|
|
286
|
+
_, sim, crop = self._window(domain, self.radius * self.steps)
|
|
287
|
+
p0 = self.volume_fraction if self.conserved else self.initial_fraction
|
|
288
|
+
state = random_state(sim, p0, rng, exact=self.conserved)
|
|
289
|
+
record, callback = _recorder(self.steps, frames, crop)
|
|
290
|
+
if callback is not None:
|
|
291
|
+
callback(0, state)
|
|
292
|
+
evo = self.automaton().run(
|
|
293
|
+
state,
|
|
294
|
+
self.steps,
|
|
295
|
+
rng,
|
|
296
|
+
update=self.update,
|
|
297
|
+
async_fraction=self.async_fraction,
|
|
298
|
+
callback=callback,
|
|
299
|
+
)
|
|
300
|
+
if callback is not None and not np.array_equal(record[-1], evo.state[crop]):
|
|
301
|
+
record.append(evo.state[crop].copy()) # stopped early: stable state
|
|
302
|
+
return evo, crop, record
|
|
303
|
+
|
|
304
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> LatticeField:
|
|
305
|
+
rng, seed_info = make_rng(seed)
|
|
306
|
+
evo, crop, _ = self._simulate(domain, rng)
|
|
307
|
+
attributes = {"steps": evo.steps, "history": evo.history}
|
|
308
|
+
if self.lattice != "square":
|
|
309
|
+
tiling, cells = crop
|
|
310
|
+
phases = evo.state if cells is None else evo.state[cells]
|
|
311
|
+
return TilingField(
|
|
312
|
+
domain, tiling, phases, cells=cells, model=self, seed=seed_info,
|
|
313
|
+
attributes=attributes,
|
|
314
|
+
) # fmt: skip
|
|
315
|
+
return LatticeField(
|
|
316
|
+
domain,
|
|
317
|
+
evo.state[crop],
|
|
318
|
+
smoothing=self.smoothing,
|
|
319
|
+
model=self,
|
|
320
|
+
seed=seed_info,
|
|
321
|
+
attributes=attributes,
|
|
322
|
+
)
|
|
323
|
+
|
|
324
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
325
|
+
return {"volume_fraction": self.volume_fraction} if self.conserved else {}
|
|
326
|
+
|
|
327
|
+
|
|
328
|
+
@register
|
|
329
|
+
@dataclass(frozen=True)
|
|
330
|
+
class ActivatorInhibitorModel(_LatticeModel):
|
|
331
|
+
"""Turing patterns of Young's (1984) activator-inhibitor cellular automaton.
|
|
332
|
+
|
|
333
|
+
Spots, stripes or labyrinths with a wavelength set by the inhibition radius.
|
|
334
|
+
"""
|
|
335
|
+
|
|
336
|
+
name = "activator_inhibitor"
|
|
337
|
+
|
|
338
|
+
activation_radius: float = param(
|
|
339
|
+
2.0, doc="Radius of the activating neighbourhood", unit="length"
|
|
340
|
+
)
|
|
341
|
+
inhibition_radius: float = param(5.0, doc="Outer radius of the inhibiting shell", unit="length")
|
|
342
|
+
inhibition_weight: float | None = param(
|
|
343
|
+
None,
|
|
344
|
+
doc="Weight of the inhibiting cells (default: balanced, a uniform state scores 0)",
|
|
345
|
+
)
|
|
346
|
+
volume_fraction: float | None = param(
|
|
347
|
+
None,
|
|
348
|
+
doc="Keep this fraction of active cells (the highest scores); otherwise the sign "
|
|
349
|
+
"of the score decides",
|
|
350
|
+
kind="fraction",
|
|
351
|
+
)
|
|
352
|
+
initial_fraction: float = param(
|
|
353
|
+
0.5, doc="Probability of phase 1 in the initial noise", kind="fraction"
|
|
354
|
+
)
|
|
355
|
+
steps: int = param(15, doc="Number of updates", kind="int")
|
|
356
|
+
lattice: str = param(
|
|
357
|
+
"square",
|
|
358
|
+
doc=_LATTICE_DOC,
|
|
359
|
+
kind="str",
|
|
360
|
+
)
|
|
361
|
+
approximant: int | None = param(None, doc=_APPROXIMANT_DOC, kind="int")
|
|
362
|
+
|
|
363
|
+
def _validate(self) -> None:
|
|
364
|
+
self._validate_lattice()
|
|
365
|
+
self._validate_tiling()
|
|
366
|
+
r1 = check_positive(self.activation_radius, "activation_radius")
|
|
367
|
+
r2 = check_positive(self.inhibition_radius, "inhibition_radius")
|
|
368
|
+
if r1 < self.cell_size:
|
|
369
|
+
raise ValueError("activation_radius: at least one cell")
|
|
370
|
+
if r2 <= r1:
|
|
371
|
+
raise ValueError("inhibition_radius must exceed activation_radius")
|
|
372
|
+
if self.inhibition_weight is not None:
|
|
373
|
+
check_positive(self.inhibition_weight, "inhibition_weight")
|
|
374
|
+
if self.volume_fraction is not None:
|
|
375
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
376
|
+
check_fraction(self.initial_fraction, "initial_fraction")
|
|
377
|
+
if self.steps < 0:
|
|
378
|
+
raise ValueError("steps: must be non-negative")
|
|
379
|
+
|
|
380
|
+
def _simulate(self, domain: Domain, rng, frames: int = 0):
|
|
381
|
+
r1 = self.activation_radius / self.cell_size
|
|
382
|
+
r2 = self.inhibition_radius / self.cell_size
|
|
383
|
+
rule = ActivatorInhibitorRule(
|
|
384
|
+
r1, r2, self.inhibition_weight, self.volume_fraction, dims=self.dimension
|
|
385
|
+
)
|
|
386
|
+
if self.lattice != "square":
|
|
387
|
+
tiling, cells = self._tiling(domain, r2 * self.steps, rng)
|
|
388
|
+
p0 = self.volume_fraction if self.volume_fraction is not None else self.initial_fraction
|
|
389
|
+
state = random_state((tiling.n_cells,), p0, rng, exact=self.volume_fraction is not None)
|
|
390
|
+
crop = self._frames_of(domain, tiling, frames)
|
|
391
|
+
record, callback = _recorder(self.steps, frames, crop)
|
|
392
|
+
if callback is not None:
|
|
393
|
+
callback(0, state)
|
|
394
|
+
ca = CellularAutomaton(rule, tiling=tiling)
|
|
395
|
+
evo = ca.run(state, self.steps, rng, callback=callback)
|
|
396
|
+
if callback is not None and not np.array_equal(record[-1], evo.state[crop]):
|
|
397
|
+
record.append(evo.state[crop].copy())
|
|
398
|
+
return evo, (tiling, cells, ca.lattice), rule, record
|
|
399
|
+
_, sim, crop = self._window(domain, r2 * self.steps)
|
|
400
|
+
p0 = self.volume_fraction if self.volume_fraction is not None else self.initial_fraction
|
|
401
|
+
state = random_state(sim, p0, rng, exact=self.volume_fraction is not None)
|
|
402
|
+
record, callback = _recorder(self.steps, frames, crop)
|
|
403
|
+
if callback is not None:
|
|
404
|
+
callback(0, state)
|
|
405
|
+
ca = CellularAutomaton(rule, dims=self.dimension, periodic=True)
|
|
406
|
+
evo = ca.run(state, self.steps, rng, callback=callback)
|
|
407
|
+
if callback is not None and not np.array_equal(record[-1], evo.state[crop]):
|
|
408
|
+
record.append(evo.state[crop].copy())
|
|
409
|
+
return evo, crop, rule, record
|
|
410
|
+
|
|
411
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> LatticeField:
|
|
412
|
+
rng, seed_info = make_rng(seed)
|
|
413
|
+
evo, crop, rule, _ = self._simulate(domain, rng)
|
|
414
|
+
if self.lattice != "square":
|
|
415
|
+
tiling, cells, context = crop
|
|
416
|
+
weight = np.mean(rule.tiling_kernels(context)[2])
|
|
417
|
+
return TilingField(
|
|
418
|
+
domain,
|
|
419
|
+
tiling,
|
|
420
|
+
evo.state if cells is None else evo.state[cells],
|
|
421
|
+
cells=cells,
|
|
422
|
+
model=self,
|
|
423
|
+
seed=seed_info,
|
|
424
|
+
attributes={
|
|
425
|
+
"steps": evo.steps,
|
|
426
|
+
"inhibition_weight": float(weight),
|
|
427
|
+
"history": evo.history,
|
|
428
|
+
},
|
|
429
|
+
)
|
|
430
|
+
return LatticeField(
|
|
431
|
+
domain,
|
|
432
|
+
evo.state[crop],
|
|
433
|
+
smoothing=self.smoothing,
|
|
434
|
+
model=self,
|
|
435
|
+
seed=seed_info,
|
|
436
|
+
attributes={
|
|
437
|
+
"steps": evo.steps,
|
|
438
|
+
"inhibition_weight": rule.weight,
|
|
439
|
+
"history": evo.history,
|
|
440
|
+
},
|
|
441
|
+
)
|
|
442
|
+
|
|
443
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
444
|
+
if self.volume_fraction is None:
|
|
445
|
+
return {}
|
|
446
|
+
return {"volume_fraction": self.volume_fraction}
|
|
447
|
+
|
|
448
|
+
|
|
449
|
+
#: Initial conditions drawn (from the same random stream) before giving up on a pattern.
|
|
450
|
+
MAX_ATTEMPTS = 5
|
|
451
|
+
|
|
452
|
+
|
|
453
|
+
@register
|
|
454
|
+
@dataclass(frozen=True)
|
|
455
|
+
class ReactionDiffusionModel(_LatticeModel):
|
|
456
|
+
"""Turing patterns of the Gray-Scott reaction-diffusion system.
|
|
457
|
+
|
|
458
|
+
Spots, worms, labyrinths or holes, thresholded on the activator concentration.
|
|
459
|
+
With the default diffusion coefficients, the patterns have a period of about 12
|
|
460
|
+
cells: ``cell_size`` sets their scale. Lattices narrower than about two periods
|
|
461
|
+
(24 cells) may not sustain them; the activator then dies out and new initial
|
|
462
|
+
conditions are drawn (up to 5 times). Other lattices than ``square`` run the
|
|
463
|
+
system on the cells of a tiling with its finite-volume Laplacian (a
|
|
464
|
+
:class:`~morphogen.models.tiling_field.TilingField`).
|
|
465
|
+
"""
|
|
466
|
+
|
|
467
|
+
name = "reaction_diffusion"
|
|
468
|
+
|
|
469
|
+
pattern: str | None = param(
|
|
470
|
+
"labyrinth",
|
|
471
|
+
doc="Preset of feed and kill rates: spots, worms, labyrinth or holes "
|
|
472
|
+
"(ignored when feed and kill are given)",
|
|
473
|
+
kind="str",
|
|
474
|
+
)
|
|
475
|
+
feed: float | None = param(None, doc="Feed rate F (with kill: overrides the preset)")
|
|
476
|
+
kill: float | None = param(None, doc="Kill rate k (with feed: overrides the preset)")
|
|
477
|
+
diffusion_u: float = param(0.16, doc="Diffusion coefficient of u, in cells^2 per step")
|
|
478
|
+
diffusion_v: float = param(0.08, doc="Diffusion coefficient of v, in cells^2 per step")
|
|
479
|
+
steps: int = param(4000, doc="Number of explicit time steps", kind="int")
|
|
480
|
+
volume_fraction: float | None = param(
|
|
481
|
+
None,
|
|
482
|
+
doc="Fraction of phase 1 (the cells of highest activator concentration); "
|
|
483
|
+
"otherwise phase 1 is v > threshold",
|
|
484
|
+
kind="fraction",
|
|
485
|
+
)
|
|
486
|
+
threshold: float = param(0.2, doc="Activator level of phase 1 without volume_fraction")
|
|
487
|
+
seed_fraction: float = param(
|
|
488
|
+
0.1, doc="Fraction of the cells in the initial activator blobs", kind="fraction"
|
|
489
|
+
)
|
|
490
|
+
lattice: str = param("square", doc=_LATTICE_DOC, kind="str")
|
|
491
|
+
approximant: int | None = param(None, doc=_APPROXIMANT_DOC, kind="int")
|
|
492
|
+
|
|
493
|
+
def _validate(self) -> None:
|
|
494
|
+
self._validate_lattice()
|
|
495
|
+
self._validate_tiling()
|
|
496
|
+
if (self.feed is None) != (self.kill is None):
|
|
497
|
+
raise ValueError("give both 'feed' and 'kill', or a 'pattern' preset")
|
|
498
|
+
if self.feed is None and self.pattern not in GRAY_SCOTT_PRESETS:
|
|
499
|
+
raise ValueError(f"pattern: one of {list(GRAY_SCOTT_PRESETS)}")
|
|
500
|
+
if self.feed is not None:
|
|
501
|
+
check_positive(self.feed, "feed")
|
|
502
|
+
check_positive(self.kill, "kill")
|
|
503
|
+
limit = 1.0 / (2 * self.dimension)
|
|
504
|
+
for name in ("diffusion_u", "diffusion_v"):
|
|
505
|
+
d = check_positive(getattr(self, name), name)
|
|
506
|
+
if d > limit:
|
|
507
|
+
raise ValueError(f"{name}: at most {limit:g} for a stable explicit scheme")
|
|
508
|
+
if self.steps < 1:
|
|
509
|
+
raise ValueError("steps: at least 1")
|
|
510
|
+
if self.volume_fraction is not None:
|
|
511
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
512
|
+
check_fraction(self.seed_fraction, "seed_fraction")
|
|
513
|
+
|
|
514
|
+
def rates(self) -> tuple[float, float]:
|
|
515
|
+
if self.feed is not None:
|
|
516
|
+
return float(self.feed), float(self.kill)
|
|
517
|
+
return GRAY_SCOTT_PRESETS[self.pattern]
|
|
518
|
+
|
|
519
|
+
def _simulate(self, domain: Domain, rng, frames: int = 0):
|
|
520
|
+
feed, kill = self.rates()
|
|
521
|
+
# the pattern has a finite correlation length: a margin of 16 cells is enough
|
|
522
|
+
if self.lattice != "square":
|
|
523
|
+
tiling, cells = self._tiling(domain, 16, rng)
|
|
524
|
+
crop = self._frames_of(domain, tiling, frames)
|
|
525
|
+
else:
|
|
526
|
+
_, sim, crop = self._window(domain, 16)
|
|
527
|
+
attempts = 0
|
|
528
|
+
while True:
|
|
529
|
+
attempts += 1
|
|
530
|
+
record, callback = _recorder(self.steps, frames, crop, pick=lambda u, v: v)
|
|
531
|
+
options = {
|
|
532
|
+
"feed": feed,
|
|
533
|
+
"kill": kill,
|
|
534
|
+
"du": self.diffusion_u,
|
|
535
|
+
"dv": self.diffusion_v,
|
|
536
|
+
"steps": self.steps,
|
|
537
|
+
"seed_fraction": self.seed_fraction,
|
|
538
|
+
"callback": callback,
|
|
539
|
+
}
|
|
540
|
+
if self.lattice != "square":
|
|
541
|
+
_, v = gray_scott_tiling(tiling, rng, **options)
|
|
542
|
+
else:
|
|
543
|
+
_, v = gray_scott(sim, rng, periodic=True, **options)
|
|
544
|
+
if v.max() > 1e-3:
|
|
545
|
+
break
|
|
546
|
+
if attempts == MAX_ATTEMPTS:
|
|
547
|
+
raise ValueError(
|
|
548
|
+
f"reaction_diffusion: the activator died out {MAX_ATTEMPTS} times (F = "
|
|
549
|
+
f"{feed:g}, k = {kill:g}); use a lattice of at least 24 cells across "
|
|
550
|
+
"(smaller cell_size), or feed and kill rates that form patterns"
|
|
551
|
+
)
|
|
552
|
+
if self.lattice != "square":
|
|
553
|
+
crop = (tiling, cells)
|
|
554
|
+
return v, crop, feed, kill, attempts, record
|
|
555
|
+
|
|
556
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> LatticeField:
|
|
557
|
+
rng, seed_info = make_rng(seed)
|
|
558
|
+
v, crop, feed, kill, attempts, _ = self._simulate(domain, rng)
|
|
559
|
+
attributes = {"steps": self.steps, "feed": feed, "kill": kill, "attempts": attempts}
|
|
560
|
+
if self.lattice != "square":
|
|
561
|
+
tiling, cells = crop
|
|
562
|
+
kept = slice(None) if cells is None else cells
|
|
563
|
+
v, volumes = v[kept], tiling.volumes[kept]
|
|
564
|
+
if self.volume_fraction is not None: # the cells of highest v, by volume
|
|
565
|
+
order = np.argsort(-v, kind="stable")
|
|
566
|
+
filled = np.cumsum(volumes[order]) / volumes.sum()
|
|
567
|
+
k = min(len(v) - 1, int(np.searchsorted(filled, self.volume_fraction)))
|
|
568
|
+
threshold = float(v[order[k]])
|
|
569
|
+
else:
|
|
570
|
+
threshold = float(self.threshold)
|
|
571
|
+
attributes["threshold"] = threshold
|
|
572
|
+
attributes["substeps"] = stable_substeps(tiling, self.diffusion_u, self.diffusion_v)
|
|
573
|
+
return TilingField(
|
|
574
|
+
domain, tiling, (v > threshold).astype(np.uint8), cells=cells, model=self,
|
|
575
|
+
seed=seed_info, attributes=attributes,
|
|
576
|
+
) # fmt: skip
|
|
577
|
+
v = v[crop].astype(np.float32) # the stored field: phases are thresholded on it
|
|
578
|
+
if self.volume_fraction is not None:
|
|
579
|
+
threshold = float(np.quantile(v, 1.0 - self.volume_fraction))
|
|
580
|
+
else:
|
|
581
|
+
threshold = float(self.threshold)
|
|
582
|
+
phases = (v > threshold).astype(np.uint8)
|
|
583
|
+
return LatticeField(
|
|
584
|
+
domain,
|
|
585
|
+
phases,
|
|
586
|
+
field=v,
|
|
587
|
+
threshold=threshold,
|
|
588
|
+
smoothing=self.smoothing,
|
|
589
|
+
model=self,
|
|
590
|
+
seed=seed_info,
|
|
591
|
+
attributes=attributes,
|
|
592
|
+
)
|