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,279 @@
|
|
|
1
|
+
"""Rasterization of unions of spheres and segments (Numba kernels).
|
|
2
|
+
|
|
3
|
+
Primitives are registered in a uniform grid of cells (compressed sparse rows: the
|
|
4
|
+
primitives of cell ``c`` are ``items[offsets[c]:offsets[c + 1]]``). A primitive is
|
|
5
|
+
registered in every cell that may contain a point closer to it than its radius plus
|
|
6
|
+
an extra reach (the level-set band), so that each query point only tests the
|
|
7
|
+
candidates of its own cell. Loops over voxels are parallel over x-slices; each voxel
|
|
8
|
+
is written by a single thread.
|
|
9
|
+
"""
|
|
10
|
+
|
|
11
|
+
from __future__ import annotations
|
|
12
|
+
|
|
13
|
+
import math
|
|
14
|
+
|
|
15
|
+
import numpy as np
|
|
16
|
+
from numba import njit, prange
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
@njit(cache=True, inline="always")
|
|
20
|
+
def _axis_cell(v, lo, h, n):
|
|
21
|
+
c = math.floor((v - lo) / h)
|
|
22
|
+
if c < 0:
|
|
23
|
+
return 0
|
|
24
|
+
if c >= n:
|
|
25
|
+
return n - 1
|
|
26
|
+
return c
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
@njit(cache=True, inline="always")
|
|
30
|
+
def _cell_of(x, y, z, cell_lo, cell_h, cell_n):
|
|
31
|
+
ci = _axis_cell(x, cell_lo[0], cell_h[0], cell_n[0])
|
|
32
|
+
cj = _axis_cell(y, cell_lo[1], cell_h[1], cell_n[1])
|
|
33
|
+
ck = _axis_cell(z, cell_lo[2], cell_h[2], cell_n[2])
|
|
34
|
+
return (ci * cell_n[1] + cj) * cell_n[2] + ck
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
@njit(cache=True, inline="always")
|
|
38
|
+
def _segment_param(px, py, pz, ax, ay, az, bx, by, bz):
|
|
39
|
+
"""Parameter t of the projection of p on the line (a, b), unclamped."""
|
|
40
|
+
ux, uy, uz = bx - ax, by - ay, bz - az
|
|
41
|
+
uu = ux * ux + uy * uy + uz * uz
|
|
42
|
+
if uu == 0.0:
|
|
43
|
+
return 0.0
|
|
44
|
+
return ((px - ax) * ux + (py - ay) * uy + (pz - az) * uz) / uu
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
@njit(cache=True, inline="always")
|
|
48
|
+
def _dist2_to_point_on_axis(px, py, pz, ax, ay, az, bx, by, bz, t):
|
|
49
|
+
qx = ax + t * (bx - ax) - px
|
|
50
|
+
qy = ay + t * (by - ay) - py
|
|
51
|
+
qz = az + t * (bz - az) - pz
|
|
52
|
+
return qx * qx + qy * qy + qz * qz
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
@njit(cache=True)
|
|
56
|
+
def _register_spheres(centers, radii, extra, cell_lo, cell_h, cell_n, counts, offsets, items, fill):
|
|
57
|
+
n = centers.shape[0]
|
|
58
|
+
for s in range(n):
|
|
59
|
+
reach = radii[s] + extra
|
|
60
|
+
r2 = reach * reach
|
|
61
|
+
cx, cy, cz = centers[s, 0], centers[s, 1], centers[s, 2]
|
|
62
|
+
i0 = _axis_cell(cx - reach, cell_lo[0], cell_h[0], cell_n[0])
|
|
63
|
+
i1 = _axis_cell(cx + reach, cell_lo[0], cell_h[0], cell_n[0])
|
|
64
|
+
j0 = _axis_cell(cy - reach, cell_lo[1], cell_h[1], cell_n[1])
|
|
65
|
+
j1 = _axis_cell(cy + reach, cell_lo[1], cell_h[1], cell_n[1])
|
|
66
|
+
k0 = _axis_cell(cz - reach, cell_lo[2], cell_h[2], cell_n[2])
|
|
67
|
+
k1 = _axis_cell(cz + reach, cell_lo[2], cell_h[2], cell_n[2])
|
|
68
|
+
for i in range(i0, i1 + 1):
|
|
69
|
+
bx0 = cell_lo[0] + i * cell_h[0]
|
|
70
|
+
dx = max(bx0 - cx, 0.0, cx - (bx0 + cell_h[0]))
|
|
71
|
+
for j in range(j0, j1 + 1):
|
|
72
|
+
by0 = cell_lo[1] + j * cell_h[1]
|
|
73
|
+
dy = max(by0 - cy, 0.0, cy - (by0 + cell_h[1]))
|
|
74
|
+
for k in range(k0, k1 + 1):
|
|
75
|
+
bz0 = cell_lo[2] + k * cell_h[2]
|
|
76
|
+
dz = max(bz0 - cz, 0.0, cz - (bz0 + cell_h[2]))
|
|
77
|
+
if dx * dx + dy * dy + dz * dz <= r2:
|
|
78
|
+
cell = (i * cell_n[1] + j) * cell_n[2] + k
|
|
79
|
+
if fill:
|
|
80
|
+
items[offsets[cell] + counts[cell]] = s
|
|
81
|
+
counts[cell] += 1
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
@njit(cache=True)
|
|
85
|
+
def _register_segments(a, b, radii, extra, cell_lo, cell_h, cell_n, counts, offsets, items, fill):
|
|
86
|
+
n = a.shape[0]
|
|
87
|
+
half_diag = 0.5 * math.sqrt(cell_h[0] ** 2 + cell_h[1] ** 2 + cell_h[2] ** 2)
|
|
88
|
+
for s in range(n):
|
|
89
|
+
reach = radii[s] + extra
|
|
90
|
+
lim = reach + half_diag
|
|
91
|
+
lim2 = lim * lim
|
|
92
|
+
ax, ay, az = a[s, 0], a[s, 1], a[s, 2]
|
|
93
|
+
bx, by, bz = b[s, 0], b[s, 1], b[s, 2]
|
|
94
|
+
i0 = _axis_cell(min(ax, bx) - reach, cell_lo[0], cell_h[0], cell_n[0])
|
|
95
|
+
i1 = _axis_cell(max(ax, bx) + reach, cell_lo[0], cell_h[0], cell_n[0])
|
|
96
|
+
j0 = _axis_cell(min(ay, by) - reach, cell_lo[1], cell_h[1], cell_n[1])
|
|
97
|
+
j1 = _axis_cell(max(ay, by) + reach, cell_lo[1], cell_h[1], cell_n[1])
|
|
98
|
+
k0 = _axis_cell(min(az, bz) - reach, cell_lo[2], cell_h[2], cell_n[2])
|
|
99
|
+
k1 = _axis_cell(max(az, bz) + reach, cell_lo[2], cell_h[2], cell_n[2])
|
|
100
|
+
for i in range(i0, i1 + 1):
|
|
101
|
+
px = cell_lo[0] + (i + 0.5) * cell_h[0]
|
|
102
|
+
for j in range(j0, j1 + 1):
|
|
103
|
+
py = cell_lo[1] + (j + 0.5) * cell_h[1]
|
|
104
|
+
for k in range(k0, k1 + 1):
|
|
105
|
+
pz = cell_lo[2] + (k + 0.5) * cell_h[2]
|
|
106
|
+
t = _segment_param(px, py, pz, ax, ay, az, bx, by, bz)
|
|
107
|
+
t = min(max(t, 0.0), 1.0)
|
|
108
|
+
if _dist2_to_point_on_axis(px, py, pz, ax, ay, az, bx, by, bz, t) <= lim2:
|
|
109
|
+
cell = (i * cell_n[1] + j) * cell_n[2] + k
|
|
110
|
+
if fill:
|
|
111
|
+
items[offsets[cell] + counts[cell]] = s
|
|
112
|
+
counts[cell] += 1
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
def build_cells(kind, arrays, extra, cell_lo, cell_h, cell_n):
|
|
116
|
+
"""CSR cell lists for ``kind`` in {"spheres", "segments"}."""
|
|
117
|
+
ncell = int(np.prod(cell_n))
|
|
118
|
+
counts = np.zeros(ncell, dtype=np.int64)
|
|
119
|
+
offsets = np.zeros(ncell + 1, dtype=np.int64)
|
|
120
|
+
dummy = np.zeros(0, dtype=np.int64)
|
|
121
|
+
register = _register_spheres if kind == "spheres" else _register_segments
|
|
122
|
+
register(*arrays, float(extra), cell_lo, cell_h, cell_n, counts, offsets, dummy, False)
|
|
123
|
+
np.cumsum(counts, out=offsets[1:])
|
|
124
|
+
items = np.empty(offsets[-1], dtype=np.int64)
|
|
125
|
+
counts[:] = 0
|
|
126
|
+
register(*arrays, float(extra), cell_lo, cell_h, cell_n, counts, offsets, items, True)
|
|
127
|
+
return offsets, items
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
@njit(cache=True, inline="always")
|
|
131
|
+
def _inside(x, y, z, cell, sc, sr, so, si, ga, gb, gr, round_caps, go, gi):
|
|
132
|
+
for t in range(so[cell], so[cell + 1]):
|
|
133
|
+
s = si[t]
|
|
134
|
+
dx = x - sc[s, 0]
|
|
135
|
+
dy = y - sc[s, 1]
|
|
136
|
+
dz = z - sc[s, 2]
|
|
137
|
+
if dx * dx + dy * dy + dz * dz <= sr[s] * sr[s]:
|
|
138
|
+
return True
|
|
139
|
+
for t in range(go[cell], go[cell + 1]):
|
|
140
|
+
s = gi[t]
|
|
141
|
+
ax, ay, az = ga[s, 0], ga[s, 1], ga[s, 2]
|
|
142
|
+
bx, by, bz = gb[s, 0], gb[s, 1], gb[s, 2]
|
|
143
|
+
u = _segment_param(x, y, z, ax, ay, az, bx, by, bz)
|
|
144
|
+
if round_caps:
|
|
145
|
+
u = min(max(u, 0.0), 1.0)
|
|
146
|
+
elif u < 0.0 or u > 1.0:
|
|
147
|
+
continue
|
|
148
|
+
if _dist2_to_point_on_axis(x, y, z, ax, ay, az, bx, by, bz, u) <= gr[s] * gr[s]:
|
|
149
|
+
return True
|
|
150
|
+
return False
|
|
151
|
+
|
|
152
|
+
|
|
153
|
+
@njit(cache=True, inline="always")
|
|
154
|
+
def _distance(x, y, z, cell, band, sc, sr, so, si, ga, gb, gr, round_caps, go, gi):
|
|
155
|
+
"""Signed distance to the union, clipped to [-band, band] (exact outside)."""
|
|
156
|
+
d = band
|
|
157
|
+
for t in range(so[cell], so[cell + 1]):
|
|
158
|
+
s = si[t]
|
|
159
|
+
dx = x - sc[s, 0]
|
|
160
|
+
dy = y - sc[s, 1]
|
|
161
|
+
dz = z - sc[s, 2]
|
|
162
|
+
v = math.sqrt(dx * dx + dy * dy + dz * dz) - sr[s]
|
|
163
|
+
if v < d:
|
|
164
|
+
d = v
|
|
165
|
+
for t in range(go[cell], go[cell + 1]):
|
|
166
|
+
s = gi[t]
|
|
167
|
+
ax, ay, az = ga[s, 0], ga[s, 1], ga[s, 2]
|
|
168
|
+
bx, by, bz = gb[s, 0], gb[s, 1], gb[s, 2]
|
|
169
|
+
u = _segment_param(x, y, z, ax, ay, az, bx, by, bz)
|
|
170
|
+
if round_caps:
|
|
171
|
+
uc = min(max(u, 0.0), 1.0)
|
|
172
|
+
v = math.sqrt(_dist2_to_point_on_axis(x, y, z, ax, ay, az, bx, by, bz, uc)) - gr[s]
|
|
173
|
+
else:
|
|
174
|
+
length = math.sqrt((bx - ax) ** 2 + (by - ay) ** 2 + (bz - az) ** 2)
|
|
175
|
+
radial = math.sqrt(_dist2_to_point_on_axis(x, y, z, ax, ay, az, bx, by, bz, u)) - gr[s]
|
|
176
|
+
axial = (abs(u - 0.5) - 0.5) * length
|
|
177
|
+
ox = max(radial, 0.0)
|
|
178
|
+
oy = max(axial, 0.0)
|
|
179
|
+
v = math.sqrt(ox * ox + oy * oy) + min(max(radial, axial), 0.0)
|
|
180
|
+
if v < d:
|
|
181
|
+
d = v
|
|
182
|
+
if d < -band:
|
|
183
|
+
d = -band
|
|
184
|
+
return d
|
|
185
|
+
|
|
186
|
+
|
|
187
|
+
@njit(parallel=True, cache=True)
|
|
188
|
+
def rasterize_count(
|
|
189
|
+
sc,
|
|
190
|
+
sr,
|
|
191
|
+
so,
|
|
192
|
+
si,
|
|
193
|
+
ga,
|
|
194
|
+
gb,
|
|
195
|
+
gr,
|
|
196
|
+
round_caps,
|
|
197
|
+
go,
|
|
198
|
+
gi,
|
|
199
|
+
cell_lo,
|
|
200
|
+
cell_h,
|
|
201
|
+
cell_n,
|
|
202
|
+
grid_lo,
|
|
203
|
+
spacing,
|
|
204
|
+
shape,
|
|
205
|
+
ss,
|
|
206
|
+
out,
|
|
207
|
+
):
|
|
208
|
+
"""Number of the ``ss**3`` sub-samples of each voxel lying in the union."""
|
|
209
|
+
inv = 1.0 / ss
|
|
210
|
+
for i in prange(shape[0]):
|
|
211
|
+
for j in range(shape[1]):
|
|
212
|
+
for k in range(shape[2]):
|
|
213
|
+
cnt = 0
|
|
214
|
+
for a in range(ss):
|
|
215
|
+
x = grid_lo[0] + (i + (a + 0.5) * inv) * spacing[0]
|
|
216
|
+
for b in range(ss):
|
|
217
|
+
y = grid_lo[1] + (j + (b + 0.5) * inv) * spacing[1]
|
|
218
|
+
for c in range(ss):
|
|
219
|
+
z = grid_lo[2] + (k + (c + 0.5) * inv) * spacing[2]
|
|
220
|
+
cell = _cell_of(x, y, z, cell_lo, cell_h, cell_n)
|
|
221
|
+
if _inside(
|
|
222
|
+
x, y, z, cell, sc, sr, so, si, ga, gb, gr, round_caps, go, gi
|
|
223
|
+
):
|
|
224
|
+
cnt += 1
|
|
225
|
+
out[i, j, k] = cnt
|
|
226
|
+
|
|
227
|
+
|
|
228
|
+
@njit(parallel=True, cache=True)
|
|
229
|
+
def rasterize_distance(
|
|
230
|
+
sc,
|
|
231
|
+
sr,
|
|
232
|
+
so,
|
|
233
|
+
si,
|
|
234
|
+
ga,
|
|
235
|
+
gb,
|
|
236
|
+
gr,
|
|
237
|
+
round_caps,
|
|
238
|
+
go,
|
|
239
|
+
gi,
|
|
240
|
+
cell_lo,
|
|
241
|
+
cell_h,
|
|
242
|
+
cell_n,
|
|
243
|
+
grid_lo,
|
|
244
|
+
spacing,
|
|
245
|
+
shape,
|
|
246
|
+
band,
|
|
247
|
+
out,
|
|
248
|
+
):
|
|
249
|
+
"""Signed distance at voxel centres, clipped to [-band, band]."""
|
|
250
|
+
for i in prange(shape[0]):
|
|
251
|
+
x = grid_lo[0] + (i + 0.5) * spacing[0]
|
|
252
|
+
for j in range(shape[1]):
|
|
253
|
+
y = grid_lo[1] + (j + 0.5) * spacing[1]
|
|
254
|
+
for k in range(shape[2]):
|
|
255
|
+
z = grid_lo[2] + (k + 0.5) * spacing[2]
|
|
256
|
+
cell = _cell_of(x, y, z, cell_lo, cell_h, cell_n)
|
|
257
|
+
out[i, j, k] = _distance(
|
|
258
|
+
x, y, z, cell, band, sc, sr, so, si, ga, gb, gr, round_caps, go, gi
|
|
259
|
+
)
|
|
260
|
+
|
|
261
|
+
|
|
262
|
+
@njit(parallel=True, cache=True)
|
|
263
|
+
def points_inside(
|
|
264
|
+
sc, sr, so, si, ga, gb, gr, round_caps, go, gi, cell_lo, cell_h, cell_n, pts, out
|
|
265
|
+
):
|
|
266
|
+
for p in prange(pts.shape[0]):
|
|
267
|
+
x, y, z = pts[p, 0], pts[p, 1], pts[p, 2]
|
|
268
|
+
cell = _cell_of(x, y, z, cell_lo, cell_h, cell_n)
|
|
269
|
+
out[p] = _inside(x, y, z, cell, sc, sr, so, si, ga, gb, gr, round_caps, go, gi)
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
@njit(parallel=True, cache=True)
|
|
273
|
+
def points_distance(
|
|
274
|
+
sc, sr, so, si, ga, gb, gr, round_caps, go, gi, cell_lo, cell_h, cell_n, pts, band, out
|
|
275
|
+
):
|
|
276
|
+
for p in prange(pts.shape[0]):
|
|
277
|
+
x, y, z = pts[p, 0], pts[p, 1], pts[p, 2]
|
|
278
|
+
cell = _cell_of(x, y, z, cell_lo, cell_h, cell_n)
|
|
279
|
+
out[p] = _distance(x, y, z, cell, band, sc, sr, so, si, ga, gb, gr, round_caps, go, gi)
|
morphogen/kernels/rsa.py
ADDED
|
@@ -0,0 +1,371 @@
|
|
|
1
|
+
"""Random sequential addition (RSA) of non-overlapping spheres in a periodic box."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import math
|
|
6
|
+
|
|
7
|
+
import numpy as np
|
|
8
|
+
from numba import njit
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
@njit(cache=True)
|
|
12
|
+
def rsa_insert(radii, gap, box, cell_h, cell_n, head, nxt, pos, placed, candidates):
|
|
13
|
+
"""Try ``candidates`` in turn for the sphere ``placed``, then the next ones.
|
|
14
|
+
|
|
15
|
+
Cells form a periodic grid with linked lists (``head[cell]`` is the last sphere
|
|
16
|
+
inserted in the cell, ``nxt[s]`` the previous one). Cells are at least as large as
|
|
17
|
+
the largest interaction distance, so only the 27 neighbouring cells are searched.
|
|
18
|
+
Returns the new number of placed spheres and the number of candidates used.
|
|
19
|
+
"""
|
|
20
|
+
n_total = radii.shape[0]
|
|
21
|
+
rmax = 0.0
|
|
22
|
+
for s in range(n_total):
|
|
23
|
+
rmax = max(rmax, radii[s])
|
|
24
|
+
used = 0
|
|
25
|
+
for c in range(candidates.shape[0]):
|
|
26
|
+
if placed >= n_total:
|
|
27
|
+
break
|
|
28
|
+
used += 1
|
|
29
|
+
x, y, z = candidates[c, 0], candidates[c, 1], candidates[c, 2]
|
|
30
|
+
r = radii[placed]
|
|
31
|
+
ci = min(int(x / cell_h[0]), cell_n[0] - 1)
|
|
32
|
+
cj = min(int(y / cell_h[1]), cell_n[1] - 1)
|
|
33
|
+
ck = min(int(z / cell_h[2]), cell_n[2] - 1)
|
|
34
|
+
ok = True
|
|
35
|
+
# with fewer than 3 cells along an axis, visit each cell once
|
|
36
|
+
ni = min(3, cell_n[0])
|
|
37
|
+
nj = min(3, cell_n[1])
|
|
38
|
+
nk = min(3, cell_n[2])
|
|
39
|
+
for di in range(ni):
|
|
40
|
+
ii = (ci + di - 1) % cell_n[0] if ni == 3 else di
|
|
41
|
+
for dj in range(nj):
|
|
42
|
+
jj = (cj + dj - 1) % cell_n[1] if nj == 3 else dj
|
|
43
|
+
for dk in range(nk):
|
|
44
|
+
kk = (ck + dk - 1) % cell_n[2] if nk == 3 else dk
|
|
45
|
+
s = head[(ii * cell_n[1] + jj) * cell_n[2] + kk]
|
|
46
|
+
while s >= 0:
|
|
47
|
+
dx = x - pos[s, 0]
|
|
48
|
+
dy = y - pos[s, 1]
|
|
49
|
+
dz = z - pos[s, 2]
|
|
50
|
+
dx -= box[0] * math.floor(dx / box[0] + 0.5)
|
|
51
|
+
dy -= box[1] * math.floor(dy / box[1] + 0.5)
|
|
52
|
+
dz -= box[2] * math.floor(dz / box[2] + 0.5)
|
|
53
|
+
lim = r + radii[s] + gap
|
|
54
|
+
if dx * dx + dy * dy + dz * dz < lim * lim:
|
|
55
|
+
ok = False
|
|
56
|
+
break
|
|
57
|
+
s = nxt[s]
|
|
58
|
+
if not ok:
|
|
59
|
+
break
|
|
60
|
+
if not ok:
|
|
61
|
+
break
|
|
62
|
+
if not ok:
|
|
63
|
+
break
|
|
64
|
+
if ok:
|
|
65
|
+
pos[placed, 0] = x
|
|
66
|
+
pos[placed, 1] = y
|
|
67
|
+
pos[placed, 2] = z
|
|
68
|
+
cell = (ci * cell_n[1] + cj) * cell_n[2] + ck
|
|
69
|
+
nxt[placed] = head[cell]
|
|
70
|
+
head[cell] = placed
|
|
71
|
+
placed += 1
|
|
72
|
+
return placed, used
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def random_sequential_addition(radii, box, gap, rng, max_attempts, batch=4096):
|
|
76
|
+
"""Positions (in ``[0, box)``) of non-overlapping spheres, inserted in the given order.
|
|
77
|
+
|
|
78
|
+
Raises ``RuntimeError`` when the spheres cannot all be placed within
|
|
79
|
+
``max_attempts`` trials (jamming).
|
|
80
|
+
"""
|
|
81
|
+
radii = np.ascontiguousarray(radii, dtype=float)
|
|
82
|
+
box = np.asarray(box, dtype=float)
|
|
83
|
+
n = len(radii)
|
|
84
|
+
pos = np.zeros((n, 3))
|
|
85
|
+
if n == 0:
|
|
86
|
+
return pos
|
|
87
|
+
reach = 2.0 * radii.max() + gap
|
|
88
|
+
cell_n = np.maximum(1, np.floor(box / reach)).astype(np.int64)
|
|
89
|
+
cell_h = box / cell_n
|
|
90
|
+
head = np.full(int(np.prod(cell_n)), -1, dtype=np.int64)
|
|
91
|
+
nxt = np.full(n, -1, dtype=np.int64)
|
|
92
|
+
placed, attempts = 0, 0
|
|
93
|
+
while placed < n and attempts < max_attempts:
|
|
94
|
+
m = int(min(batch, max_attempts - attempts))
|
|
95
|
+
cand = rng.random((m, 3)) * box
|
|
96
|
+
placed, used = rsa_insert(
|
|
97
|
+
radii, float(gap), box, cell_h, cell_n, head, nxt, pos, placed, cand
|
|
98
|
+
)
|
|
99
|
+
attempts += used
|
|
100
|
+
if placed < n:
|
|
101
|
+
raise RuntimeError(
|
|
102
|
+
f"random sequential addition jammed: {placed} of {n} spheres placed after "
|
|
103
|
+
f"{attempts} attempts; lower the volume fraction (the RSA jamming limit is "
|
|
104
|
+
f"about 0.38 for equal spheres) or raise max_attempts"
|
|
105
|
+
)
|
|
106
|
+
return pos
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
# -- fibres: spherocylinders -------------------------------------------------------------
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
@njit(cache=True, inline="always")
|
|
113
|
+
def _clamp(x):
|
|
114
|
+
return 0.0 if x < 0.0 else (1.0 if x > 1.0 else x)
|
|
115
|
+
|
|
116
|
+
|
|
117
|
+
@njit(cache=True)
|
|
118
|
+
def segment_distance2(p1, d1, p2, d2) -> float:
|
|
119
|
+
"""Squared distance between the segments ``p1 + s d1`` and ``p2 + t d2`` (s, t in
|
|
120
|
+
[0, 1]): the closest points of Ericson (2005, sec. 5.1.9), robust for parallel or
|
|
121
|
+
degenerate segments."""
|
|
122
|
+
rx, ry, rz = p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]
|
|
123
|
+
a = d1[0] * d1[0] + d1[1] * d1[1] + d1[2] * d1[2]
|
|
124
|
+
e = d2[0] * d2[0] + d2[1] * d2[1] + d2[2] * d2[2]
|
|
125
|
+
f = d2[0] * rx + d2[1] * ry + d2[2] * rz
|
|
126
|
+
eps = 1e-300
|
|
127
|
+
if a <= eps and e <= eps:
|
|
128
|
+
s, t = 0.0, 0.0
|
|
129
|
+
elif a <= eps:
|
|
130
|
+
s, t = 0.0, _clamp(f / e)
|
|
131
|
+
else:
|
|
132
|
+
c = d1[0] * rx + d1[1] * ry + d1[2] * rz
|
|
133
|
+
if e <= eps:
|
|
134
|
+
s, t = _clamp(-c / a), 0.0
|
|
135
|
+
else:
|
|
136
|
+
b = d1[0] * d2[0] + d1[1] * d2[1] + d1[2] * d2[2]
|
|
137
|
+
denom = a * e - b * b
|
|
138
|
+
s = _clamp((b * f - c * e) / denom) if denom > 1e-14 * a * e else 0.0
|
|
139
|
+
t = (b * s + f) / e
|
|
140
|
+
if t < 0.0:
|
|
141
|
+
t, s = 0.0, _clamp(-c / a)
|
|
142
|
+
elif t > 1.0:
|
|
143
|
+
t, s = 1.0, _clamp((b - c) / a)
|
|
144
|
+
dx = rx + d1[0] * s - d2[0] * t
|
|
145
|
+
dy = ry + d1[1] * s - d2[1] * t
|
|
146
|
+
dz = rz + d1[2] * s - d2[2] * t
|
|
147
|
+
return dx * dx + dy * dy + dz * dz
|
|
148
|
+
|
|
149
|
+
|
|
150
|
+
@njit(cache=True)
|
|
151
|
+
def rsa_insert_fibres(radii, halves, gap, box, cell_h, cell_n, head, nxt, pos, axes, placed,
|
|
152
|
+
candidates, directions): # fmt: skip
|
|
153
|
+
"""Try ``candidates`` (centres) with ``directions`` (unit axes) in turn for the fibre
|
|
154
|
+
``placed`` (a spherocylinder of radius ``radii[i]`` and half-length ``halves[i]``),
|
|
155
|
+
then the next ones, in a periodic box with linked cell lists (see :func:`rsa_insert`;
|
|
156
|
+
cells at least as large as the reach of two fibres). Fibres closer than ``gap`` are
|
|
157
|
+
rejected; the nearest periodic image is tested. Returns the new number of placed fibres
|
|
158
|
+
and the number of candidates used."""
|
|
159
|
+
n_total = radii.shape[0]
|
|
160
|
+
used = 0
|
|
161
|
+
q = np.empty(3)
|
|
162
|
+
p1 = np.empty(3)
|
|
163
|
+
d1 = np.empty(3)
|
|
164
|
+
p2 = np.empty(3)
|
|
165
|
+
d2 = np.empty(3)
|
|
166
|
+
for c in range(candidates.shape[0]):
|
|
167
|
+
if placed >= n_total:
|
|
168
|
+
break
|
|
169
|
+
used += 1
|
|
170
|
+
x, y, z = candidates[c, 0], candidates[c, 1], candidates[c, 2]
|
|
171
|
+
q[0], q[1], q[2] = x, y, z
|
|
172
|
+
r, h = radii[placed], halves[placed]
|
|
173
|
+
for k in range(3):
|
|
174
|
+
d1[k] = 2.0 * h * directions[c, k]
|
|
175
|
+
p1[k] = q[k] - 0.5 * d1[k]
|
|
176
|
+
ci = min(int(x / cell_h[0]), cell_n[0] - 1)
|
|
177
|
+
cj = min(int(y / cell_h[1]), cell_n[1] - 1)
|
|
178
|
+
ck = min(int(z / cell_h[2]), cell_n[2] - 1)
|
|
179
|
+
ok = True
|
|
180
|
+
ni = min(3, cell_n[0])
|
|
181
|
+
nj = min(3, cell_n[1])
|
|
182
|
+
nk = min(3, cell_n[2])
|
|
183
|
+
for di in range(ni):
|
|
184
|
+
ii = (ci + di - 1) % cell_n[0] if ni == 3 else di
|
|
185
|
+
for dj in range(nj):
|
|
186
|
+
jj = (cj + dj - 1) % cell_n[1] if nj == 3 else dj
|
|
187
|
+
for dk in range(nk):
|
|
188
|
+
kk = (ck + dk - 1) % cell_n[2] if nk == 3 else dk
|
|
189
|
+
s = head[(ii * cell_n[1] + jj) * cell_n[2] + kk]
|
|
190
|
+
while s >= 0:
|
|
191
|
+
# the image of fibre s nearest to the candidate
|
|
192
|
+
for k in range(3):
|
|
193
|
+
dc = pos[s, k] - q[k]
|
|
194
|
+
dc -= box[k] * math.floor(dc / box[k] + 0.5)
|
|
195
|
+
d2[k] = 2.0 * halves[s] * axes[s, k]
|
|
196
|
+
p2[k] = q[k] + dc - 0.5 * d2[k]
|
|
197
|
+
lim = r + radii[s] + gap
|
|
198
|
+
if segment_distance2(p1, d1, p2, d2) < lim * lim:
|
|
199
|
+
ok = False
|
|
200
|
+
break
|
|
201
|
+
s = nxt[s]
|
|
202
|
+
if not ok:
|
|
203
|
+
break
|
|
204
|
+
if not ok:
|
|
205
|
+
break
|
|
206
|
+
if not ok:
|
|
207
|
+
break
|
|
208
|
+
if ok:
|
|
209
|
+
pos[placed, 0] = x
|
|
210
|
+
pos[placed, 1] = y
|
|
211
|
+
pos[placed, 2] = z
|
|
212
|
+
for k in range(3):
|
|
213
|
+
axes[placed, k] = directions[c, k]
|
|
214
|
+
cell = (ci * cell_n[1] + cj) * cell_n[2] + ck
|
|
215
|
+
nxt[placed] = head[cell]
|
|
216
|
+
head[cell] = placed
|
|
217
|
+
placed += 1
|
|
218
|
+
return placed, used
|
|
219
|
+
|
|
220
|
+
|
|
221
|
+
def random_sequential_addition_fibres(radii, lengths, box, gap, rng, orientation, max_attempts,
|
|
222
|
+
batch=4096): # fmt: skip
|
|
223
|
+
"""Centres (in ``[0, box)``) and unit axes of non-overlapping spherocylinders of
|
|
224
|
+
radii ``radii`` and lengths ``lengths`` (of their cylindrical parts), inserted in the
|
|
225
|
+
given order; candidate axes come from ``orientation`` (an orientation distribution).
|
|
226
|
+
Raises ``RuntimeError`` when the fibres cannot all be placed within ``max_attempts``
|
|
227
|
+
trials (jamming)."""
|
|
228
|
+
radii = np.ascontiguousarray(radii, dtype=float)
|
|
229
|
+
halves = np.ascontiguousarray(0.5 * np.asarray(lengths, dtype=float))
|
|
230
|
+
box = np.asarray(box, dtype=float)
|
|
231
|
+
n = len(radii)
|
|
232
|
+
pos = np.zeros((n, 3))
|
|
233
|
+
axes = np.zeros((n, 3))
|
|
234
|
+
if n == 0:
|
|
235
|
+
return pos, axes
|
|
236
|
+
reach = 2.0 * (halves.max() + radii.max()) + gap
|
|
237
|
+
cell_n = np.maximum(1, np.floor(box / reach)).astype(np.int64)
|
|
238
|
+
cell_h = box / cell_n
|
|
239
|
+
head = np.full(int(np.prod(cell_n)), -1, dtype=np.int64)
|
|
240
|
+
nxt = np.full(n, -1, dtype=np.int64)
|
|
241
|
+
placed, attempts = 0, 0
|
|
242
|
+
while placed < n and attempts < max_attempts:
|
|
243
|
+
m = int(min(batch, max_attempts - attempts))
|
|
244
|
+
cand = rng.random((m, 3)) * box
|
|
245
|
+
dirs = np.ascontiguousarray(orientation.sample(rng, m), dtype=float)
|
|
246
|
+
placed, used = rsa_insert_fibres(radii, halves, float(gap), box, cell_h, cell_n, head,
|
|
247
|
+
nxt, pos, axes, placed, cand, dirs) # fmt: skip
|
|
248
|
+
attempts += used
|
|
249
|
+
if placed < n:
|
|
250
|
+
raise RuntimeError(
|
|
251
|
+
f"random sequential addition jammed: {placed} of {n} fibres placed after "
|
|
252
|
+
f"{attempts} attempts; lower the volume fraction (the jamming limit of RSA "
|
|
253
|
+
"falls as the fibres lengthen) or raise max_attempts"
|
|
254
|
+
)
|
|
255
|
+
return pos, axes
|
|
256
|
+
|
|
257
|
+
|
|
258
|
+
@njit(cache=True)
|
|
259
|
+
def rsa_insert_polylines(offsets, extents, radius, gap, box, cell_h, cell_n, head, nxt, pos,
|
|
260
|
+
placed, candidates): # fmt: skip
|
|
261
|
+
"""Try ``candidates`` (centres) in turn for the fibre ``placed``, a chain of
|
|
262
|
+
spherocylinders of radius ``radius`` whose axis passes through the points
|
|
263
|
+
``offsets[placed]`` (relative to its centre; ``extents``: their largest distance to
|
|
264
|
+
it), then the next fibres, in a periodic box with linked cell lists (cells at least
|
|
265
|
+
as large as the reach of two fibres). A candidate is rejected when one of its
|
|
266
|
+
segments comes closer than ``2 radius + gap`` to a segment of the nearest periodic
|
|
267
|
+
image of a fibre already placed. Returns the new number of placed fibres and the
|
|
268
|
+
number of candidates used."""
|
|
269
|
+
n_total, m1 = offsets.shape[0], offsets.shape[1]
|
|
270
|
+
used = 0
|
|
271
|
+
q = np.empty(3)
|
|
272
|
+
dc = np.empty(3)
|
|
273
|
+
a0 = np.empty(3)
|
|
274
|
+
da = np.empty(3)
|
|
275
|
+
b0 = np.empty(3)
|
|
276
|
+
db = np.empty(3)
|
|
277
|
+
lim = 2.0 * radius + gap
|
|
278
|
+
for c in range(candidates.shape[0]):
|
|
279
|
+
if placed >= n_total:
|
|
280
|
+
break
|
|
281
|
+
used += 1
|
|
282
|
+
for k in range(3):
|
|
283
|
+
q[k] = candidates[c, k]
|
|
284
|
+
ci = min(int(q[0] / cell_h[0]), cell_n[0] - 1)
|
|
285
|
+
cj = min(int(q[1] / cell_h[1]), cell_n[1] - 1)
|
|
286
|
+
ck = min(int(q[2] / cell_h[2]), cell_n[2] - 1)
|
|
287
|
+
ok = True
|
|
288
|
+
ni = min(3, cell_n[0])
|
|
289
|
+
nj = min(3, cell_n[1])
|
|
290
|
+
nk = min(3, cell_n[2])
|
|
291
|
+
for di in range(ni):
|
|
292
|
+
ii = (ci + di - 1) % cell_n[0] if ni == 3 else di
|
|
293
|
+
for dj in range(nj):
|
|
294
|
+
jj = (cj + dj - 1) % cell_n[1] if nj == 3 else dj
|
|
295
|
+
for dk in range(nk):
|
|
296
|
+
kk = (ck + dk - 1) % cell_n[2] if nk == 3 else dk
|
|
297
|
+
s = head[(ii * cell_n[1] + jj) * cell_n[2] + kk]
|
|
298
|
+
while s >= 0:
|
|
299
|
+
d2 = 0.0
|
|
300
|
+
for k in range(3):
|
|
301
|
+
d = pos[s, k] - q[k]
|
|
302
|
+
d -= box[k] * math.floor(d / box[k] + 0.5)
|
|
303
|
+
dc[k] = d
|
|
304
|
+
d2 += d * d
|
|
305
|
+
reach = extents[placed] + extents[s] + lim
|
|
306
|
+
if d2 < reach * reach:
|
|
307
|
+
for i in range(m1 - 1):
|
|
308
|
+
for k in range(3):
|
|
309
|
+
a0[k] = q[k] + offsets[placed, i, k]
|
|
310
|
+
da[k] = offsets[placed, i + 1, k] - offsets[placed, i, k]
|
|
311
|
+
for j in range(m1 - 1):
|
|
312
|
+
for k in range(3):
|
|
313
|
+
b0[k] = q[k] + dc[k] + offsets[s, j, k]
|
|
314
|
+
db[k] = offsets[s, j + 1, k] - offsets[s, j, k]
|
|
315
|
+
if segment_distance2(a0, da, b0, db) < lim * lim:
|
|
316
|
+
ok = False
|
|
317
|
+
break
|
|
318
|
+
if not ok:
|
|
319
|
+
break
|
|
320
|
+
if not ok:
|
|
321
|
+
break
|
|
322
|
+
s = nxt[s]
|
|
323
|
+
if not ok:
|
|
324
|
+
break
|
|
325
|
+
if not ok:
|
|
326
|
+
break
|
|
327
|
+
if not ok:
|
|
328
|
+
break
|
|
329
|
+
if ok:
|
|
330
|
+
for k in range(3):
|
|
331
|
+
pos[placed, k] = q[k]
|
|
332
|
+
cell = (ci * cell_n[1] + cj) * cell_n[2] + ck
|
|
333
|
+
nxt[placed] = head[cell]
|
|
334
|
+
head[cell] = placed
|
|
335
|
+
placed += 1
|
|
336
|
+
return placed, used
|
|
337
|
+
|
|
338
|
+
|
|
339
|
+
def random_sequential_addition_polylines(offsets, radius, box, gap, rng, max_attempts,
|
|
340
|
+
batch=4096): # fmt: skip
|
|
341
|
+
"""Centres (in ``[0, box)``) of non-overlapping curved fibres: chains of
|
|
342
|
+
spherocylinders of radius ``radius`` along the polylines ``offsets`` (n x points x
|
|
343
|
+
3, relative to the centres), inserted in the given order with uniformly random
|
|
344
|
+
centres. Raises ``RuntimeError`` when they cannot all be placed within
|
|
345
|
+
``max_attempts`` trials (jamming)."""
|
|
346
|
+
offsets = np.ascontiguousarray(offsets, dtype=float)
|
|
347
|
+
box = np.asarray(box, dtype=float)
|
|
348
|
+
n = len(offsets)
|
|
349
|
+
pos = np.zeros((n, 3))
|
|
350
|
+
if n == 0:
|
|
351
|
+
return pos
|
|
352
|
+
extents = np.ascontiguousarray(np.sqrt((offsets**2).sum(axis=-1)).max(axis=1))
|
|
353
|
+
reach = 2.0 * extents.max() + 2.0 * radius + gap
|
|
354
|
+
cell_n = np.maximum(1, np.floor(box / reach)).astype(np.int64)
|
|
355
|
+
cell_h = box / cell_n
|
|
356
|
+
head = np.full(int(np.prod(cell_n)), -1, dtype=np.int64)
|
|
357
|
+
nxt = np.full(n, -1, dtype=np.int64)
|
|
358
|
+
placed, attempts = 0, 0
|
|
359
|
+
while placed < n and attempts < max_attempts:
|
|
360
|
+
m = int(min(batch, max_attempts - attempts))
|
|
361
|
+
cand = rng.random((m, 3)) * box
|
|
362
|
+
placed, used = rsa_insert_polylines(offsets, extents, float(radius), float(gap),
|
|
363
|
+
box, cell_h, cell_n, head, nxt, pos, placed,
|
|
364
|
+
cand) # fmt: skip
|
|
365
|
+
attempts += used
|
|
366
|
+
if placed < n:
|
|
367
|
+
raise RuntimeError(
|
|
368
|
+
f"random sequential addition jammed: {placed} of {n} curved fibres placed after "
|
|
369
|
+
f"{attempts} attempts; lower the volume fraction or raise max_attempts"
|
|
370
|
+
)
|
|
371
|
+
return pos
|