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,317 @@
|
|
|
1
|
+
"""Hard-core (non-overlapping) spheres: random sequential addition, dense packings grown
|
|
2
|
+
by the Lubachevsky–Stillinger algorithm, and penetrable spheres with impenetrable cores
|
|
3
|
+
(the cherry-pit model of Torquato)."""
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
import math
|
|
8
|
+
from dataclasses import dataclass
|
|
9
|
+
from typing import ClassVar
|
|
10
|
+
|
|
11
|
+
import numpy as np
|
|
12
|
+
|
|
13
|
+
from morphogen import theory
|
|
14
|
+
from morphogen._utils import check_fraction, check_positive, exactly_one
|
|
15
|
+
from morphogen.distributions import Constant, Distribution
|
|
16
|
+
from morphogen.domain import Domain
|
|
17
|
+
from morphogen.kernels.packing import grow_packing
|
|
18
|
+
from morphogen.kernels.rsa import random_sequential_addition
|
|
19
|
+
from morphogen.models.affine import ANISOTROPY, Anisotropy, anisotropic
|
|
20
|
+
from morphogen.models.base import Model, param, register
|
|
21
|
+
from morphogen.models.union import PrimitiveUnion
|
|
22
|
+
from morphogen.primitives import Spheres
|
|
23
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
24
|
+
|
|
25
|
+
#: Methods of the hard-core spheres.
|
|
26
|
+
METHODS = ("rsa", "lubachevsky_stillinger")
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def largest_first(radii, box, gap: float, rng, max_attempts: int) -> np.ndarray:
|
|
30
|
+
"""Positions (in ``[0, box)``, in the order of ``radii``) of non-overlapping spheres
|
|
31
|
+
placed by random sequential addition, the largest first: drawn late among
|
|
32
|
+
polydisperse spheres, a large one may find no room left (radii uniform between 0.8
|
|
33
|
+
and 1.2 and 0.05 apart jam from a fraction of 0.31 in the order of their draw; the
|
|
34
|
+
largest first, they still fill 0.41)."""
|
|
35
|
+
radii = np.asarray(radii, dtype=float)
|
|
36
|
+
order = np.argsort(-radii, kind="stable")
|
|
37
|
+
pos = np.empty((len(radii), 3))
|
|
38
|
+
pos[order] = random_sequential_addition(radii[order], box, gap, rng, max_attempts)
|
|
39
|
+
return pos
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def grown_packing(radii, box, rng, *, growth_rate: float = 0.01, max_events=None):
|
|
43
|
+
"""Positions (in ``[0, box)``) of non-overlapping spheres of the given radii in a
|
|
44
|
+
periodic box, grown by the Lubachevsky–Stillinger algorithm
|
|
45
|
+
(:mod:`morphogen.kernels.packing`): from the positions of a random sequential
|
|
46
|
+
addition of the spheres shrunk to a packing fraction of at most 0.25, the largest
|
|
47
|
+
first (drawn late, a large sphere may find no room left), with Gaussian velocities of
|
|
48
|
+
the mean radius per unit time, the radii growing at ``growth_rate`` times themselves
|
|
49
|
+
per unit time. Raises ``RuntimeError`` when the packing jams before the spheres
|
|
50
|
+
reach their radii (after ``max_events``, 20000 per sphere by default)."""
|
|
51
|
+
rho = np.ascontiguousarray(radii, dtype=float)
|
|
52
|
+
box = np.asarray(box, dtype=float)
|
|
53
|
+
n = len(rho)
|
|
54
|
+
if n == 0:
|
|
55
|
+
return np.zeros((0, 3))
|
|
56
|
+
if np.any(box < 6.0 * rho.max() * (1.0 + 1e-9)):
|
|
57
|
+
raise ValueError("lubachevsky_stillinger: the box spans three diameters at least")
|
|
58
|
+
target = 4.0 / 3.0 * math.pi * float(np.sum(rho**3)) / float(np.prod(box))
|
|
59
|
+
start = min(0.25, 0.5 * target)
|
|
60
|
+
s0 = (start / target) ** (1.0 / 3.0)
|
|
61
|
+
pos = largest_first(rho * s0, box, 0.0, rng, 10_000 * n)
|
|
62
|
+
vel = rng.normal(0.0, float(rho.mean()), (n, 3))
|
|
63
|
+
vel -= vel.mean(axis=0)
|
|
64
|
+
growth = float(growth_rate)
|
|
65
|
+
t_end = (1.0 - s0) / growth
|
|
66
|
+
events = 20_000 * n if max_events is None else int(max_events)
|
|
67
|
+
t, _, _ = grow_packing(pos, vel, rho, box, s0, growth, t_end, events)
|
|
68
|
+
if t < t_end:
|
|
69
|
+
reached = target * (s0 + growth * t) ** 3
|
|
70
|
+
raise RuntimeError(
|
|
71
|
+
f"lubachevsky_stillinger: the packing jammed at a fraction of {reached:.4f} "
|
|
72
|
+
f"before {target:.4f} ({events} events); lower the volume fraction (equal "
|
|
73
|
+
"spheres jam near 0.64) or the growth rate, or raise max_attempts"
|
|
74
|
+
)
|
|
75
|
+
return pos
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
@register
|
|
79
|
+
@anisotropic
|
|
80
|
+
@dataclass(frozen=True)
|
|
81
|
+
class HardcoreSpheres(Model):
|
|
82
|
+
"""Non-overlapping spheres, by random sequential addition (RSA) or grown into dense
|
|
83
|
+
packings by the Lubachevsky–Stillinger algorithm.
|
|
84
|
+
|
|
85
|
+
RSA adds the spheres one at a time at uniformly random positions, the largest first,
|
|
86
|
+
a trial being rejected when the sphere would come closer than ``min_gap`` to an
|
|
87
|
+
existing one: the process jams near a volume fraction of 0.38 for equal spheres. The
|
|
88
|
+
Lubachevsky–Stillinger algorithm grows the spheres of a hard-sphere fluid (an
|
|
89
|
+
event-driven molecular dynamics) until they reach their radii (plus half the gap):
|
|
90
|
+
fast growths jam equal spheres near 0.64 (the maximally random jammed state), slow
|
|
91
|
+
ones let them order.
|
|
92
|
+
|
|
93
|
+
Generation always takes place in a periodic box; for non-periodic domains the box
|
|
94
|
+
is enlarged by two grain diameters and cropped, which avoids wall effects.
|
|
95
|
+
"""
|
|
96
|
+
|
|
97
|
+
name = "hardcore_spheres"
|
|
98
|
+
phases: ClassVar[dict[int, str]] = {0: "matrix", 1: "spheres"}
|
|
99
|
+
count_label = "spheres"
|
|
100
|
+
|
|
101
|
+
radius: Distribution = param(
|
|
102
|
+
Constant(1.0),
|
|
103
|
+
doc="Sphere radius (number or distribution)",
|
|
104
|
+
kind="distribution",
|
|
105
|
+
unit="length",
|
|
106
|
+
)
|
|
107
|
+
volume_fraction: float | None = param(None, doc="Target volume fraction", kind="fraction")
|
|
108
|
+
number: int | None = param(None, doc="Number of spheres in the generation box", kind="int")
|
|
109
|
+
min_gap: float = param(0.0, doc="Minimal distance between sphere surfaces", unit="length")
|
|
110
|
+
max_attempts: int | None = param(
|
|
111
|
+
None,
|
|
112
|
+
doc="Maximal number of trials (RSA, default 10000 per sphere) or of events "
|
|
113
|
+
"(Lubachevsky-Stillinger, default 20000 per sphere)",
|
|
114
|
+
kind="int",
|
|
115
|
+
)
|
|
116
|
+
method: str = param(
|
|
117
|
+
"rsa",
|
|
118
|
+
doc="rsa (random sequential addition, up to about 0.38) or lubachevsky_stillinger "
|
|
119
|
+
"(growing spheres: dense packings, up to about 0.64 for equal spheres)",
|
|
120
|
+
kind="str",
|
|
121
|
+
)
|
|
122
|
+
growth_rate: float = param(
|
|
123
|
+
0.01,
|
|
124
|
+
doc="Lubachevsky-Stillinger: growth of the radii per unit time over the thermal "
|
|
125
|
+
"speed (fast: jammed, random packings; slow: ordered ones)",
|
|
126
|
+
)
|
|
127
|
+
anisotropy: Anisotropy | None = param(None, doc=ANISOTROPY, kind="anisotropy", kw_only=True)
|
|
128
|
+
|
|
129
|
+
def _validate(self) -> None:
|
|
130
|
+
exactly_one("volume_fraction", self.volume_fraction, "number", self.number)
|
|
131
|
+
if self.volume_fraction is not None:
|
|
132
|
+
check_fraction(self.volume_fraction, "volume_fraction")
|
|
133
|
+
elif self.number < 0:
|
|
134
|
+
raise ValueError("number: must be non-negative")
|
|
135
|
+
check_positive(self.min_gap, "min_gap", allow_zero=True)
|
|
136
|
+
if self.max_attempts is not None and self.max_attempts < 1:
|
|
137
|
+
raise ValueError("max_attempts: must be positive")
|
|
138
|
+
if self.method not in METHODS:
|
|
139
|
+
raise ValueError(f"method: {' or '.join(METHODS)}, got {self.method!r}")
|
|
140
|
+
check_positive(self.growth_rate, "growth_rate")
|
|
141
|
+
|
|
142
|
+
def _draw_radii(self, rng, box_volume: float) -> np.ndarray:
|
|
143
|
+
if self.number is not None:
|
|
144
|
+
return self.radius.sample(rng, self.number)
|
|
145
|
+
target = self.volume_fraction * box_volume
|
|
146
|
+
mean_v = 4.0 / 3.0 * math.pi * self.radius.moment(3)
|
|
147
|
+
radii = np.empty(0)
|
|
148
|
+
while True:
|
|
149
|
+
more = self.radius.sample(rng, int(1.1 * target / mean_v) + 16)
|
|
150
|
+
radii = np.concatenate([radii, more])
|
|
151
|
+
cum = np.cumsum(4.0 / 3.0 * math.pi * radii**3)
|
|
152
|
+
if cum[-1] >= target:
|
|
153
|
+
break
|
|
154
|
+
# number of spheres whose total volume is closest to the target
|
|
155
|
+
k = int(np.searchsorted(cum, target))
|
|
156
|
+
n = k + 1 if k == 0 or cum[k] - target <= target - cum[k - 1] else k
|
|
157
|
+
return radii[:n]
|
|
158
|
+
|
|
159
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> PrimitiveUnion:
|
|
160
|
+
rng, seed_info = make_rng(seed)
|
|
161
|
+
rmax = self.radius.upper()
|
|
162
|
+
if domain.periodic:
|
|
163
|
+
if 2.0 * rmax + self.min_gap >= min(domain.size) / 2.0:
|
|
164
|
+
raise ValueError("hardcore_spheres: spheres are too large for the periodic box")
|
|
165
|
+
box = domain
|
|
166
|
+
else:
|
|
167
|
+
box = domain.dilated(2.0 * rmax + self.min_gap)
|
|
168
|
+
radii = self._draw_radii(rng, box.volume)
|
|
169
|
+
if self.method == "lubachevsky_stillinger":
|
|
170
|
+
local = grown_packing(
|
|
171
|
+
radii + 0.5 * self.min_gap,
|
|
172
|
+
box.lengths,
|
|
173
|
+
rng,
|
|
174
|
+
growth_rate=self.growth_rate,
|
|
175
|
+
max_events=self.max_attempts,
|
|
176
|
+
)
|
|
177
|
+
else:
|
|
178
|
+
max_attempts = self.max_attempts or 10_000 * max(len(radii), 1)
|
|
179
|
+
local = largest_first(radii, box.lengths, self.min_gap, rng, max_attempts)
|
|
180
|
+
spheres = Spheres(box.lower + local, radii)
|
|
181
|
+
if not domain.periodic:
|
|
182
|
+
spheres = spheres.subset(domain.distance_to_box(spheres.centers) <= spheres.radii)
|
|
183
|
+
return PrimitiveUnion(domain, spheres=spheres, model=self, seed=seed_info)
|
|
184
|
+
|
|
185
|
+
def expected_count(self, domain: Domain) -> float | None:
|
|
186
|
+
"""Number of sphere centres in the domain (given a volume fraction)."""
|
|
187
|
+
if self.volume_fraction is None:
|
|
188
|
+
return None
|
|
189
|
+
return self.volume_fraction * domain.volume / (4.0 / 3.0 * math.pi * self.radius.moment(3))
|
|
190
|
+
|
|
191
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
192
|
+
jammed = theory.RSA_JAMMING_FRACTION if self.method == "rsa" else theory.MRJ_FRACTION
|
|
193
|
+
out = {"jamming_fraction_equal_spheres": jammed}
|
|
194
|
+
if self.volume_fraction is not None:
|
|
195
|
+
out["volume_fraction"] = self.volume_fraction
|
|
196
|
+
out["specific_surface"] = (
|
|
197
|
+
self.volume_fraction * 3.0 * self.radius.moment(2) / self.radius.moment(3)
|
|
198
|
+
)
|
|
199
|
+
return out
|
|
200
|
+
|
|
201
|
+
|
|
202
|
+
@register
|
|
203
|
+
@anisotropic
|
|
204
|
+
@dataclass(frozen=True)
|
|
205
|
+
class PenetrableSpheres(Model):
|
|
206
|
+
"""Penetrable spheres with impenetrable cores: the cherry-pit model of Torquato (1984),
|
|
207
|
+
or penetrable-concentric-shell model.
|
|
208
|
+
|
|
209
|
+
Each sphere of radius ``R`` has a core of radius ``λR`` that no other core overlaps:
|
|
210
|
+
the cores are placed by random sequential addition, the largest first (or grown into
|
|
211
|
+
dense packings by the Lubachevsky–Stillinger algorithm), and the shells
|
|
212
|
+
interpenetrate. ``λ = 0`` gives fully penetrable spheres (independent uniform
|
|
213
|
+
centres), ``λ = 1`` hard spheres; phase 1 is the union of the spheres, whose fraction
|
|
214
|
+
lies between ``1 - e^{-η}`` and ``η`` for the reduced density ``η`` (the number of
|
|
215
|
+
spheres per unit volume times their mean volume).
|
|
216
|
+
"""
|
|
217
|
+
|
|
218
|
+
name = "penetrable_spheres"
|
|
219
|
+
phases: ClassVar[dict[int, str]] = {0: "matrix", 1: "spheres"}
|
|
220
|
+
count_label = "spheres"
|
|
221
|
+
|
|
222
|
+
radius: Distribution = param(
|
|
223
|
+
Constant(1.0),
|
|
224
|
+
doc="Sphere radius (number or distribution)",
|
|
225
|
+
kind="distribution",
|
|
226
|
+
unit="length",
|
|
227
|
+
)
|
|
228
|
+
impenetrability: float = param(
|
|
229
|
+
0.5,
|
|
230
|
+
doc="Radius of the impenetrable core over that of the sphere (lambda: 0 fully "
|
|
231
|
+
"penetrable, 1 hard spheres)",
|
|
232
|
+
kind="fraction",
|
|
233
|
+
)
|
|
234
|
+
reduced_density: float | None = param(
|
|
235
|
+
None, doc="Number of spheres per unit volume times their mean volume (eta)"
|
|
236
|
+
)
|
|
237
|
+
number: int | None = param(None, doc="Number of spheres in the generation box", kind="int")
|
|
238
|
+
method: str = param(
|
|
239
|
+
"rsa", doc="Placement of the cores: rsa or lubachevsky_stillinger", kind="str"
|
|
240
|
+
)
|
|
241
|
+
growth_rate: float = param(0.01, doc="Lubachevsky-Stillinger: growth rate of the cores")
|
|
242
|
+
max_attempts: int | None = param(
|
|
243
|
+
None,
|
|
244
|
+
doc="Maximal number of trials (RSA) or of events (Lubachevsky-Stillinger)",
|
|
245
|
+
kind="int",
|
|
246
|
+
)
|
|
247
|
+
anisotropy: Anisotropy | None = param(None, doc=ANISOTROPY, kind="anisotropy", kw_only=True)
|
|
248
|
+
|
|
249
|
+
def _validate(self) -> None:
|
|
250
|
+
exactly_one("reduced_density", self.reduced_density, "number", self.number)
|
|
251
|
+
if self.reduced_density is not None:
|
|
252
|
+
check_positive(self.reduced_density, "reduced_density")
|
|
253
|
+
elif self.number < 0:
|
|
254
|
+
raise ValueError("number: must be non-negative")
|
|
255
|
+
check_fraction(self.impenetrability, "impenetrability", open_interval=False)
|
|
256
|
+
if self.method not in METHODS:
|
|
257
|
+
raise ValueError(f"method: {' or '.join(METHODS)}, got {self.method!r}")
|
|
258
|
+
check_positive(self.growth_rate, "growth_rate")
|
|
259
|
+
if self.max_attempts is not None and self.max_attempts < 1:
|
|
260
|
+
raise ValueError("max_attempts: must be positive")
|
|
261
|
+
|
|
262
|
+
def _mean_volume(self) -> float:
|
|
263
|
+
return 4.0 / 3.0 * math.pi * self.radius.moment(3)
|
|
264
|
+
|
|
265
|
+
def generate(self, domain: Domain, seed: SeedLike = None) -> PrimitiveUnion:
|
|
266
|
+
rng, seed_info = make_rng(seed)
|
|
267
|
+
rmax = self.radius.upper()
|
|
268
|
+
if domain.periodic:
|
|
269
|
+
if 2.0 * rmax >= min(domain.size) / 2.0:
|
|
270
|
+
raise ValueError("penetrable_spheres: spheres are too large for the periodic box")
|
|
271
|
+
box = domain
|
|
272
|
+
else:
|
|
273
|
+
box = domain.dilated(2.0 * rmax)
|
|
274
|
+
if self.number is not None:
|
|
275
|
+
n = int(self.number)
|
|
276
|
+
else:
|
|
277
|
+
n = round(self.reduced_density * box.volume / self._mean_volume())
|
|
278
|
+
radii = self.radius.sample(rng, n)
|
|
279
|
+
cores = self.impenetrability * radii
|
|
280
|
+
if n == 0 or self.impenetrability == 0.0:
|
|
281
|
+
local = rng.random((n, 3)) * box.lengths
|
|
282
|
+
elif self.method == "lubachevsky_stillinger":
|
|
283
|
+
local = grown_packing(cores, box.lengths, rng, growth_rate=self.growth_rate,
|
|
284
|
+
max_events=self.max_attempts) # fmt: skip
|
|
285
|
+
else:
|
|
286
|
+
local = largest_first(cores, box.lengths, 0.0, rng, self.max_attempts or 10_000 * n)
|
|
287
|
+
spheres = Spheres(box.lower + local, radii)
|
|
288
|
+
if not domain.periodic:
|
|
289
|
+
spheres = spheres.subset(domain.distance_to_box(spheres.centers) <= spheres.radii)
|
|
290
|
+
return PrimitiveUnion(domain, spheres=spheres, model=self, seed=seed_info)
|
|
291
|
+
|
|
292
|
+
def expected_count(self, domain: Domain) -> float | None:
|
|
293
|
+
if self.reduced_density is None:
|
|
294
|
+
return None
|
|
295
|
+
return self.reduced_density * domain.volume / self._mean_volume()
|
|
296
|
+
|
|
297
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
298
|
+
"""The reduced density, the fraction of the cores (``λ^3 η``), and the fraction and
|
|
299
|
+
specific surface of the union in the two limits: ``1 - e^{-η}`` and its surface
|
|
300
|
+
``3 η E[R^2] / E[R^3] e^{-η}`` for fully penetrable spheres (large boxes), ``η`` and
|
|
301
|
+
``3 η E[R^2] / E[R^3]`` for hard spheres."""
|
|
302
|
+
if self.reduced_density is None:
|
|
303
|
+
return {}
|
|
304
|
+
eta, lam = float(self.reduced_density), float(self.impenetrability)
|
|
305
|
+
out = {
|
|
306
|
+
"reduced_density": eta,
|
|
307
|
+
"core_fraction": eta * lam**3,
|
|
308
|
+
"volume_fraction_lower": 1.0 - math.exp(-eta),
|
|
309
|
+
"volume_fraction_upper": eta,
|
|
310
|
+
}
|
|
311
|
+
surface = 3.0 * eta * self.radius.moment(2) / self.radius.moment(3)
|
|
312
|
+
if lam == 0.0:
|
|
313
|
+
bare = math.exp(-eta)
|
|
314
|
+
out.update(volume_fraction=1.0 - bare, specific_surface=surface * bare)
|
|
315
|
+
elif lam == 1.0:
|
|
316
|
+
out.update(volume_fraction=eta, specific_surface=surface)
|
|
317
|
+
return out
|
|
@@ -0,0 +1,269 @@
|
|
|
1
|
+
"""Hierarchical lattices of tubes: frames of generation G (Rayneau-Kirkhope, Mao & Farr,
|
|
2
|
+
"Ultralight fractal structures from hollow tubes", Phys. Rev. Lett. 109, 204301, 2012).
|
|
3
|
+
|
|
4
|
+
A frame of generation 1 between two nodes is a column of ``n`` regular octahedra
|
|
5
|
+
(triangular antiprisms: consecutive triangles turned by 60 degrees) closed by two
|
|
6
|
+
regular tetrahedra whose apexes are the nodes; its length is ``sqrt(2/3) (n + 2) a``
|
|
7
|
+
for an edge ``a``. Under compression along the column, the edges of its triangles carry
|
|
8
|
+
tension and its lateral and end edges compression. A frame of generation G replaces
|
|
9
|
+
each compressed edge by a frame of generation G - 1 of the same length; a frame of
|
|
10
|
+
generation 0 is a tube. The lattice joins the nodes of a face-centred cubic lattice to
|
|
11
|
+
their 12 nearest and 6 next-nearest neighbours with such frames, made of solid or
|
|
12
|
+
hollow tubes. For hollow tubes, the volume of material that carries a load index ``f``
|
|
13
|
+
without buckling scales as ``f^((G+2)/(G+3))``, against ``f^(1/2)`` for solid struts:
|
|
14
|
+
the hierarchy makes very light structures stable.
|
|
15
|
+
"""
|
|
16
|
+
|
|
17
|
+
from __future__ import annotations
|
|
18
|
+
|
|
19
|
+
import itertools
|
|
20
|
+
import json
|
|
21
|
+
import math
|
|
22
|
+
from dataclasses import dataclass
|
|
23
|
+
from functools import lru_cache
|
|
24
|
+
from typing import ClassVar
|
|
25
|
+
|
|
26
|
+
import numpy as np
|
|
27
|
+
|
|
28
|
+
from morphogen._utils import check_positive
|
|
29
|
+
from morphogen.domain import Domain
|
|
30
|
+
from morphogen.models.base import Model, model_from_config, param, register
|
|
31
|
+
from morphogen.models.combination import Combined
|
|
32
|
+
from morphogen.models.union import PrimitiveUnion
|
|
33
|
+
from morphogen.primitives import Segments
|
|
34
|
+
from morphogen.seeding import SeedLike, make_rng
|
|
35
|
+
|
|
36
|
+
_H = math.sqrt(2.0 / 3.0) # height of a regular octahedron or tetrahedron, per edge
|
|
37
|
+
|
|
38
|
+
#: Nodes of the face-centred cubic cell, and half of the bonds of each (the others are
|
|
39
|
+
#: those of the neighbouring nodes): nearest neighbours (12) and next-nearest (6).
|
|
40
|
+
FCC_NODES = np.array([[0, 0, 0], [0.5, 0.5, 0], [0.5, 0, 0.5], [0, 0.5, 0.5]], dtype=float)
|
|
41
|
+
_NN = [
|
|
42
|
+
v
|
|
43
|
+
for v in itertools.product((-0.5, 0.0, 0.5), repeat=3)
|
|
44
|
+
if sum(x != 0 for x in v) == 2 and next(x for x in v if x != 0) > 0
|
|
45
|
+
]
|
|
46
|
+
NEAREST = np.array(_NN, dtype=float)
|
|
47
|
+
NEXT_NEAREST = np.eye(3)
|
|
48
|
+
CONNECTIONS = ("nn+nnn", "nn", "nnn")
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def _basis(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
|
|
52
|
+
"""Two unit vectors orthogonal to ``axis`` (unit) and to each other."""
|
|
53
|
+
ref = np.eye(3)[int(np.argmin(np.abs(axis)))]
|
|
54
|
+
e1 = np.cross(axis, ref)
|
|
55
|
+
e1 /= np.linalg.norm(e1)
|
|
56
|
+
return e1, np.cross(axis, e1)
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
def frame(p, q, generation: int, cells) -> tuple[list, list]:
|
|
60
|
+
"""Tubes of a frame of generation ``generation`` from ``p`` to ``q`` (``cells``:
|
|
61
|
+
octahedra of the frames of each generation, outermost first): their ends, and the
|
|
62
|
+
generation of the frame that holds each (for radii by generation)."""
|
|
63
|
+
p, q = np.asarray(p, dtype=float), np.asarray(q, dtype=float)
|
|
64
|
+
if generation == 0:
|
|
65
|
+
return [(p, q)], [0]
|
|
66
|
+
n = int(cells[0])
|
|
67
|
+
axis = q - p
|
|
68
|
+
length = float(np.linalg.norm(axis))
|
|
69
|
+
e3 = axis / length
|
|
70
|
+
e1, e2 = _basis(e3)
|
|
71
|
+
edge = length / (_H * (n + 2))
|
|
72
|
+
radius = edge / math.sqrt(3.0) # of the circle through the corners of a triangle
|
|
73
|
+
layers = []
|
|
74
|
+
for k in range(n + 1):
|
|
75
|
+
centre = p + _H * edge * (k + 1) * e3
|
|
76
|
+
angles = (k % 2) * math.pi / 3.0 + 2.0 * math.pi * np.arange(3) / 3.0
|
|
77
|
+
ring = np.cos(angles)[:, None] * e1 + np.sin(angles)[:, None] * e2
|
|
78
|
+
layers.append(centre + radius * ring)
|
|
79
|
+
tubes, owners = [], []
|
|
80
|
+
for layer in layers: # the triangles: tension, tubes of this frame
|
|
81
|
+
for j in range(3):
|
|
82
|
+
tubes.append((layer[j], layer[(j + 1) % 3]))
|
|
83
|
+
owners.append(generation)
|
|
84
|
+
compressed = [(p, v) for v in layers[0]] + [(v, q) for v in layers[-1]]
|
|
85
|
+
for below, above in itertools.pairwise(layers):
|
|
86
|
+
for v in below: # to the two nearest corners of the next triangle
|
|
87
|
+
near = np.argsort(np.linalg.norm(above - v, axis=1))[:2]
|
|
88
|
+
compressed += [(v, above[i]) for i in near]
|
|
89
|
+
for a, b in compressed:
|
|
90
|
+
t, o = frame(a, b, generation - 1, cells[1:])
|
|
91
|
+
tubes += t
|
|
92
|
+
owners += o
|
|
93
|
+
return tubes, owners
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
@lru_cache(maxsize=32)
|
|
97
|
+
def _cell_fraction(config: str, n: int) -> float:
|
|
98
|
+
"""Solid fraction of a unit cell of a hierarchical lattice (voxel estimate)."""
|
|
99
|
+
model = model_from_config(json.loads(config))
|
|
100
|
+
unit = Domain.cube(model.cell_size, periodic=True)
|
|
101
|
+
micro = model.generate(unit, 0)
|
|
102
|
+
return float(micro.voxelize((n, n, n)).data.astype(bool).mean())
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
@register
|
|
106
|
+
@dataclass(frozen=True)
|
|
107
|
+
class HierarchicalLattice(Model):
|
|
108
|
+
"""Hierarchical lattice: frames of generation G of (hollow) tubes on an fcc lattice.
|
|
109
|
+
|
|
110
|
+
The nodes of the face-centred cubic lattice of edge ``cell_size`` are joined to their
|
|
111
|
+
nearest (``nn``: the octet truss) and next-nearest (``nnn``: the cube edges)
|
|
112
|
+
neighbours by frames of generation ``generations`` (see the module): columns of
|
|
113
|
+
``cells`` regular octahedra whose compressed edges are frames of the generation
|
|
114
|
+
below, recursively (``cells``: one number, or one per generation from the outermost).
|
|
115
|
+
Generation 0 is a plain strut lattice. Tubes of ``tube_radius`` (one value, or one
|
|
116
|
+
per generation of the frames that hold them, from G down to 0), hollow with
|
|
117
|
+
``wall_thickness``.
|
|
118
|
+
"""
|
|
119
|
+
|
|
120
|
+
name = "hierarchical_lattice"
|
|
121
|
+
phases: ClassVar[dict[int, str]] = {0: "void", 1: "tubes"}
|
|
122
|
+
count_label = "unit cells"
|
|
123
|
+
|
|
124
|
+
cell_size: float = param(1.0, doc="Edge of the cubic cell of the fcc lattice", unit="length")
|
|
125
|
+
generations: int = param(1, doc="Generation G of the frames (0: tubes)", kind="int")
|
|
126
|
+
cells: tuple | int = param(
|
|
127
|
+
4, doc="Octahedra per frame: one number, or one per generation (outermost first)",
|
|
128
|
+
kind="json",
|
|
129
|
+
) # fmt: skip
|
|
130
|
+
tube_radius: tuple | float = param(
|
|
131
|
+
0.01, doc="Radius of the tubes, or one per generation (G down to 0)", kind="json"
|
|
132
|
+
)
|
|
133
|
+
wall_thickness: float | None = param(
|
|
134
|
+
None, doc="Wall thickness of hollow tubes (default: solid)", unit="length"
|
|
135
|
+
)
|
|
136
|
+
connections: str = param(
|
|
137
|
+
"nn+nnn", doc="Bonds: nn+nnn (nearest and next-nearest), nn or nnn", kind="str"
|
|
138
|
+
)
|
|
139
|
+
|
|
140
|
+
def _validate(self) -> None:
|
|
141
|
+
check_positive(self.cell_size, "cell_size")
|
|
142
|
+
if not 0 <= self.generations <= 3:
|
|
143
|
+
raise ValueError("generations: from 0 to 3")
|
|
144
|
+
if self.connections not in CONNECTIONS:
|
|
145
|
+
raise ValueError(f"connections: one of {list(CONNECTIONS)}")
|
|
146
|
+
counts = self.cells_per_generation
|
|
147
|
+
if len(counts) != self.generations or any(n < 1 for n in counts):
|
|
148
|
+
raise ValueError("cells: a positive number, or one per generation")
|
|
149
|
+
radii = self.radii
|
|
150
|
+
if len(radii) != self.generations + 1 or any(not r > 0 for r in radii):
|
|
151
|
+
raise ValueError("tube_radius: a positive radius, or one per generation (G to 0)")
|
|
152
|
+
if self.wall_thickness is not None:
|
|
153
|
+
check_positive(self.wall_thickness, "wall_thickness")
|
|
154
|
+
if self.wall_thickness >= min(radii):
|
|
155
|
+
raise ValueError("wall_thickness: smaller than the tube radius")
|
|
156
|
+
shortest = self.edges[-1]
|
|
157
|
+
if 4.0 * radii[-1] > shortest:
|
|
158
|
+
raise ValueError(
|
|
159
|
+
f"tube_radius: the finest tubes ({shortest:.4g} long) would merge into "
|
|
160
|
+
"blobs: thinner tubes, larger cells, fewer octahedra or generations"
|
|
161
|
+
)
|
|
162
|
+
|
|
163
|
+
@property
|
|
164
|
+
def cells_per_generation(self) -> tuple[int, ...]:
|
|
165
|
+
c = self.cells
|
|
166
|
+
if np.ndim(c) == 0:
|
|
167
|
+
return (int(c),) * self.generations
|
|
168
|
+
return tuple(int(v) for v in c)
|
|
169
|
+
|
|
170
|
+
@property
|
|
171
|
+
def radii(self) -> tuple[float, ...]:
|
|
172
|
+
"""Tube radius of each generation, from G down to 0."""
|
|
173
|
+
r = self.tube_radius
|
|
174
|
+
if np.ndim(r) == 0:
|
|
175
|
+
return (float(r),) * (self.generations + 1)
|
|
176
|
+
return tuple(float(v) for v in r)
|
|
177
|
+
|
|
178
|
+
@property
|
|
179
|
+
def edges(self) -> list[float]:
|
|
180
|
+
"""Length of the edges of the frames of each generation, from the shortest bond
|
|
181
|
+
(G) down to the finest tubes (0)."""
|
|
182
|
+
bond = self.cell_size * (1.0 if self.connections == "nnn" else math.sqrt(0.5))
|
|
183
|
+
out = [bond]
|
|
184
|
+
for n in self.cells_per_generation:
|
|
185
|
+
out.append(out[-1] / (_H * (n + 2)))
|
|
186
|
+
return out
|
|
187
|
+
|
|
188
|
+
def bonds(self) -> tuple[np.ndarray, np.ndarray]:
|
|
189
|
+
"""Ends of the bonds of one cell, in units of the cell size."""
|
|
190
|
+
vectors = []
|
|
191
|
+
if self.connections in ("nn+nnn", "nn"):
|
|
192
|
+
vectors.append(NEAREST)
|
|
193
|
+
if self.connections in ("nn+nnn", "nnn"):
|
|
194
|
+
vectors.append(NEXT_NEAREST)
|
|
195
|
+
v = np.concatenate(vectors)
|
|
196
|
+
start = np.repeat(FCC_NODES, len(v), axis=0)
|
|
197
|
+
return start, start + np.tile(v, (len(FCC_NODES), 1))
|
|
198
|
+
|
|
199
|
+
def unit_tubes(self) -> Segments:
|
|
200
|
+
"""Tubes of one cell (anchored at the origin), with their radii."""
|
|
201
|
+
start, end = self.bonds()
|
|
202
|
+
tubes, owners = [], []
|
|
203
|
+
for p, q in zip(start * self.cell_size, end * self.cell_size, strict=True):
|
|
204
|
+
t, o = frame(p, q, self.generations, self.cells_per_generation)
|
|
205
|
+
tubes += t
|
|
206
|
+
owners += o
|
|
207
|
+
ends = np.array(tubes)
|
|
208
|
+
radii = np.array(self.radii[::-1])[np.array(owners)] # owners: generation, 0 finest
|
|
209
|
+
return Segments(ends[:, 0], ends[:, 1], radii, round_caps=True)
|
|
210
|
+
|
|
211
|
+
def generate(self, domain: Domain, seed: SeedLike = None):
|
|
212
|
+
_, seed_info = make_rng(seed)
|
|
213
|
+
a = self.cell_size
|
|
214
|
+
if domain.periodic:
|
|
215
|
+
ratio = domain.lengths / a
|
|
216
|
+
if np.any(np.abs(ratio - np.rint(ratio)) > 1e-6 * np.maximum(ratio, 1.0)):
|
|
217
|
+
raise ValueError(
|
|
218
|
+
"hierarchical_lattice: a periodic domain must contain a whole number of cells"
|
|
219
|
+
)
|
|
220
|
+
unit = self.unit_tubes()
|
|
221
|
+
lower = domain.lower - (0.0 if domain.periodic else a)
|
|
222
|
+
upper = domain.upper + (0.0 if domain.periodic else a)
|
|
223
|
+
lo = np.floor(lower / a).astype(int)
|
|
224
|
+
hi = np.ceil(upper / a).astype(int) - 1
|
|
225
|
+
shifts = np.array(
|
|
226
|
+
list(itertools.product(*[range(lo[d], max(hi[d], lo[d]) + 1) for d in range(3)])),
|
|
227
|
+
dtype=float,
|
|
228
|
+
)
|
|
229
|
+
shifts *= a
|
|
230
|
+
segments = Segments(
|
|
231
|
+
(shifts[:, None, :] + unit.start[None]).reshape(-1, 3),
|
|
232
|
+
(shifts[:, None, :] + unit.end[None]).reshape(-1, 3),
|
|
233
|
+
np.tile(unit.radii, len(shifts)),
|
|
234
|
+
round_caps=True,
|
|
235
|
+
)
|
|
236
|
+
if not domain.periodic:
|
|
237
|
+
seg_lo, seg_hi = segments.bounds()
|
|
238
|
+
segments = segments.subset(
|
|
239
|
+
np.all((seg_hi >= domain.lower) & (seg_lo <= domain.upper), axis=1)
|
|
240
|
+
)
|
|
241
|
+
outer = PrimitiveUnion(domain, segments=segments, model=self, seed=seed_info)
|
|
242
|
+
if self.wall_thickness is None:
|
|
243
|
+
return outer
|
|
244
|
+
from morphogen.models.nested import bores_of
|
|
245
|
+
|
|
246
|
+
bores = bores_of(outer, self.wall_thickness)
|
|
247
|
+
return Combined(domain, "difference", [outer, bores], model=self, seed=seed_info)
|
|
248
|
+
|
|
249
|
+
def expected_count(self, domain: Domain) -> float:
|
|
250
|
+
return domain.volume / self.cell_size**3
|
|
251
|
+
|
|
252
|
+
def solid_fraction(self, n: int = 96) -> float:
|
|
253
|
+
"""Solid fraction (voxel estimate on ``n^3`` voxels of a cell)."""
|
|
254
|
+
return _cell_fraction(json.dumps(self.to_config(), sort_keys=True), int(n))
|
|
255
|
+
|
|
256
|
+
def theory(self, domain: Domain | None = None) -> dict[str, float]:
|
|
257
|
+
"""Number and length of the tubes; the volume fraction (estimated on voxels)."""
|
|
258
|
+
unit = self.unit_tubes()
|
|
259
|
+
length = float(unit.lengths.sum())
|
|
260
|
+
edges = self.edges
|
|
261
|
+
out = {
|
|
262
|
+
"tubes_per_cell": float(len(unit)),
|
|
263
|
+
"tube_length_per_cell": length,
|
|
264
|
+
"finest_edge": edges[-1],
|
|
265
|
+
}
|
|
266
|
+
h = edges[-1] / 6.0 # a few voxels across the finest tubes
|
|
267
|
+
n = int(min(256, max(48, math.ceil(self.cell_size / max(h, 1e-12)))))
|
|
268
|
+
out["volume_fraction"] = self.solid_fraction(n)
|
|
269
|
+
return out
|