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.
Files changed (381) hide show
  1. morphogen/__init__.py +60 -0
  2. morphogen/__main__.py +7 -0
  3. morphogen/_platform.py +55 -0
  4. morphogen/_public.py +153 -0
  5. morphogen/_utils.py +80 -0
  6. morphogen/_version.py +1 -0
  7. morphogen/analysis/__init__.py +174 -0
  8. morphogen/analysis/anisotropy.py +135 -0
  9. morphogen/analysis/basic.py +38 -0
  10. morphogen/analysis/cells.py +54 -0
  11. morphogen/analysis/connectivity.py +156 -0
  12. morphogen/analysis/correlation.py +195 -0
  13. morphogen/analysis/covariance.py +80 -0
  14. morphogen/analysis/fractal.py +54 -0
  15. morphogen/analysis/measures.py +188 -0
  16. morphogen/analysis/morphology.py +265 -0
  17. morphogen/analysis/particles.py +160 -0
  18. morphogen/analysis/percolation.py +2034 -0
  19. morphogen/analysis/power_laws.py +143 -0
  20. morphogen/analysis/random_sets.py +351 -0
  21. morphogen/analysis/stereology.py +289 -0
  22. morphogen/analysis/surface.py +107 -0
  23. morphogen/analysis/topology.py +92 -0
  24. morphogen/automata/__init__.py +74 -0
  25. morphogen/automata/engine.py +211 -0
  26. morphogen/automata/growth.py +686 -0
  27. morphogen/automata/lattice.py +143 -0
  28. morphogen/automata/reaction.py +255 -0
  29. morphogen/automata/rules.py +353 -0
  30. morphogen/automata/tilings.py +1715 -0
  31. morphogen/cli.py +3526 -0
  32. morphogen/config.py +2167 -0
  33. morphogen/contact/__init__.py +113 -0
  34. morphogen/contact/experiments.py +368 -0
  35. morphogen/contact/hertz.py +104 -0
  36. morphogen/contact/kernels.py +827 -0
  37. morphogen/contact/periodic.py +278 -0
  38. morphogen/contact/problem.py +578 -0
  39. morphogen/contact/surfaces.py +310 -0
  40. morphogen/coupling/__init__.py +43 -0
  41. morphogen/coupling/ageing.py +143 -0
  42. morphogen/coupling/diffusion.py +226 -0
  43. morphogen/coupling/fenicsx.py +484 -0
  44. morphogen/coupling/oxidation.py +447 -0
  45. morphogen/coupling/plates.py +247 -0
  46. morphogen/design/__init__.py +51 -0
  47. morphogen/design/csp.py +616 -0
  48. morphogen/design/frames.py +277 -0
  49. morphogen/design/search.py +287 -0
  50. morphogen/design/tiles.py +336 -0
  51. morphogen/distributions.py +312 -0
  52. morphogen/domain.py +203 -0
  53. morphogen/dynamics/__init__.py +179 -0
  54. morphogen/dynamics/model.py +638 -0
  55. morphogen/dynamics/openradioss.py +643 -0
  56. morphogen/dynamics/results.py +515 -0
  57. morphogen/fracture/__init__.py +170 -0
  58. morphogen/fracture/bulk.py +349 -0
  59. morphogen/fracture/cohesive.py +1614 -0
  60. morphogen/fracture/ductile.py +557 -0
  61. morphogen/fracture/lefm.py +1168 -0
  62. morphogen/fracture/mixed.py +1178 -0
  63. morphogen/fracture/periodic.py +733 -0
  64. morphogen/fracture/phasefield.py +714 -0
  65. morphogen/fracture/phasefield_finite.py +368 -0
  66. morphogen/fracture/surface.py +572 -0
  67. morphogen/fracture/toughness.py +566 -0
  68. morphogen/gpu.py +108 -0
  69. morphogen/gui/__init__.py +8 -0
  70. morphogen/gui/api.py +1927 -0
  71. morphogen/gui/desktop.py +387 -0
  72. morphogen/gui/icon.png +0 -0
  73. morphogen/gui/index.html +1909 -0
  74. morphogen/gui/server.py +229 -0
  75. morphogen/gui/tools/__init__.py +629 -0
  76. morphogen/gui/tools/compare.py +149 -0
  77. morphogen/gui/tools/contact.py +391 -0
  78. morphogen/gui/tools/couplings.py +1085 -0
  79. morphogen/gui/tools/crackfront.py +245 -0
  80. morphogen/gui/tools/design.py +224 -0
  81. morphogen/gui/tools/dynamics.py +824 -0
  82. morphogen/gui/tools/fracture.py +2586 -0
  83. morphogen/gui/tools/interop.py +1654 -0
  84. morphogen/gui/tools/learning.py +595 -0
  85. morphogen/gui/tools/mechanics.py +3881 -0
  86. morphogen/gui/tools/nonlocal_damage.py +1321 -0
  87. morphogen/gui/tools/phasefield.py +215 -0
  88. morphogen/gui/tools/physics.py +597 -0
  89. morphogen/gui/tools/stability.py +1756 -0
  90. morphogen/gui/tools/statistics.py +1408 -0
  91. morphogen/gui/viewer.js +1100 -0
  92. morphogen/homogenization/__init__.py +210 -0
  93. morphogen/homogenization/acoustics.py +566 -0
  94. morphogen/homogenization/amg.py +1005 -0
  95. morphogen/homogenization/apparent.py +1046 -0
  96. morphogen/homogenization/behaviours.cu +2285 -0
  97. morphogen/homogenization/behaviours.py +944 -0
  98. morphogen/homogenization/beremin.py +263 -0
  99. morphogen/homogenization/bifurcation.py +1085 -0
  100. morphogen/homogenization/bloch.py +507 -0
  101. morphogen/homogenization/bounds.py +226 -0
  102. morphogen/homogenization/core.py +458 -0
  103. morphogen/homogenization/coupled.py +1135 -0
  104. morphogen/homogenization/crystal.py +2967 -0
  105. morphogen/homogenization/dilatation.py +454 -0
  106. morphogen/homogenization/elements.py +157 -0
  107. morphogen/homogenization/fatigue.py +768 -0
  108. morphogen/homogenization/fe.py +1739 -0
  109. morphogen/homogenization/fenicsx.py +307 -0
  110. morphogen/homogenization/fft.py +499 -0
  111. morphogen/homogenization/fft_nonlinear.py +391 -0
  112. morphogen/homogenization/finite.py +613 -0
  113. morphogen/homogenization/flow.py +361 -0
  114. morphogen/homogenization/frames.py +1125 -0
  115. morphogen/homogenization/gpu.py +1241 -0
  116. morphogen/homogenization/harmonic.py +427 -0
  117. morphogen/homogenization/identification.py +579 -0
  118. morphogen/homogenization/kernels.py +760 -0
  119. morphogen/homogenization/laws.py +2061 -0
  120. morphogen/homogenization/materials.py +1080 -0
  121. morphogen/homogenization/mfront.py +589 -0
  122. morphogen/homogenization/networks.py +880 -0
  123. morphogen/homogenization/nonlinear.py +2612 -0
  124. morphogen/homogenization/ntfa.py +577 -0
  125. morphogen/homogenization/paths.py +476 -0
  126. morphogen/homogenization/photonic.py +467 -0
  127. morphogen/homogenization/poroelastic.py +212 -0
  128. morphogen/homogenization/porous.py +1120 -0
  129. morphogen/homogenization/postprocess.py +290 -0
  130. morphogen/homogenization/solvers.py +1140 -0
  131. morphogen/homogenization/tensors.py +240 -0
  132. morphogen/homogenization/voxel_fe.py +457 -0
  133. morphogen/homogenization/xfem.py +1016 -0
  134. morphogen/homogenization/zmat.py +1258 -0
  135. morphogen/iga/__init__.py +48 -0
  136. morphogen/iga/analysis.py +508 -0
  137. morphogen/iga/basis.py +214 -0
  138. morphogen/iga/geometry.py +501 -0
  139. morphogen/iga/homogenization.py +219 -0
  140. morphogen/iga/optimization.py +700 -0
  141. morphogen/iga/shapes.py +331 -0
  142. morphogen/image.py +128 -0
  143. morphogen/io/__init__.py +246 -0
  144. morphogen/io/amitex.py +741 -0
  145. morphogen/io/ebsd.py +881 -0
  146. morphogen/io/export.py +196 -0
  147. morphogen/io/geometry.py +158 -0
  148. morphogen/io/medit.py +147 -0
  149. morphogen/io/meshes.py +844 -0
  150. morphogen/io/metaimage.py +97 -0
  151. morphogen/io/mfront.py +1104 -0
  152. morphogen/io/native.py +57 -0
  153. morphogen/io/radioss.py +764 -0
  154. morphogen/io/solvers.py +371 -0
  155. morphogen/io/tables.py +278 -0
  156. morphogen/io/tiff.py +66 -0
  157. morphogen/io/vtk.py +701 -0
  158. morphogen/io/xdmf.py +200 -0
  159. morphogen/kernels/__init__.py +5 -0
  160. morphogen/kernels/annealing.py +192 -0
  161. morphogen/kernels/cells.py +69 -0
  162. morphogen/kernels/collective.py +87 -0
  163. morphogen/kernels/force_biased.py +595 -0
  164. morphogen/kernels/implicit.py +145 -0
  165. morphogen/kernels/leaves.py +132 -0
  166. morphogen/kernels/packing.py +304 -0
  167. morphogen/kernels/raster.py +279 -0
  168. morphogen/kernels/rsa.py +371 -0
  169. morphogen/kernels/union.py +135 -0
  170. morphogen/kernels/watershed.py +190 -0
  171. morphogen/laser/__init__.py +234 -0
  172. morphogen/laser/architectures.py +375 -0
  173. morphogen/laser/bending.py +216 -0
  174. morphogen/laser/cells.py +1694 -0
  175. morphogen/laser/design.py +940 -0
  176. morphogen/laser/figures.py +227 -0
  177. morphogen/laser/heat.py +804 -0
  178. morphogen/laser/materials.py +691 -0
  179. morphogen/laser/mechanics.py +1670 -0
  180. morphogen/laser/metallurgy.py +615 -0
  181. morphogen/laser/patterns.py +828 -0
  182. morphogen/laser/periodic.py +392 -0
  183. morphogen/laser/process.py +362 -0
  184. morphogen/laser/run.py +534 -0
  185. morphogen/laser/solid.py +216 -0
  186. morphogen/laser/specimen.py +200 -0
  187. morphogen/laser/structures.py +708 -0
  188. morphogen/learning/__init__.py +81 -0
  189. morphogen/learning/behaviour.py +398 -0
  190. morphogen/learning/data.py +328 -0
  191. morphogen/learning/learned.cpp +668 -0
  192. morphogen/learning/logarithmic.py +202 -0
  193. morphogen/learning/mfront.py +409 -0
  194. morphogen/learning/networks.py +767 -0
  195. morphogen/learning/run.py +212 -0
  196. morphogen/learning/standard.py +814 -0
  197. morphogen/learning/training.py +235 -0
  198. morphogen/mesh/__init__.py +29 -0
  199. morphogen/mesh/conforming.py +1423 -0
  200. morphogen/mesh/curved.py +600 -0
  201. morphogen/mesh/exact.py +1717 -0
  202. morphogen/mesh/octree.py +350 -0
  203. morphogen/mesh/polycrystal.py +1041 -0
  204. morphogen/mesh/polyhedra.py +677 -0
  205. morphogen/mesh/regularize.py +570 -0
  206. morphogen/mesh/surface.py +97 -0
  207. morphogen/mesh/tetra.py +512 -0
  208. morphogen/mesh/voxel.py +124 -0
  209. morphogen/micromorphic/__init__.py +31 -0
  210. morphogen/micromorphic/damage.py +359 -0
  211. morphogen/micromorphic/ductile.py +534 -0
  212. morphogen/micromorphic/finite.py +220 -0
  213. morphogen/micromorphic/microfoam.py +787 -0
  214. morphogen/micromorphic/space.py +341 -0
  215. morphogen/models/__init__.py +195 -0
  216. morphogen/models/affine.py +384 -0
  217. morphogen/models/automata.py +592 -0
  218. morphogen/models/base.py +500 -0
  219. morphogen/models/boolean.py +310 -0
  220. morphogen/models/bouligand.py +331 -0
  221. morphogen/models/branching.py +241 -0
  222. morphogen/models/combination.py +430 -0
  223. morphogen/models/deadleaves.py +766 -0
  224. morphogen/models/design.py +289 -0
  225. morphogen/models/ebsd.py +206 -0
  226. morphogen/models/fibers.py +1476 -0
  227. morphogen/models/foam.py +594 -0
  228. morphogen/models/gaussian.py +314 -0
  229. morphogen/models/growth.py +459 -0
  230. morphogen/models/hardcore.py +317 -0
  231. morphogen/models/hierarchical.py +269 -0
  232. morphogen/models/honeycomb.py +749 -0
  233. morphogen/models/implicit.py +177 -0
  234. morphogen/models/laminate.py +470 -0
  235. morphogen/models/lattice.py +351 -0
  236. morphogen/models/lattice_field.py +345 -0
  237. morphogen/models/levelset_foam.py +563 -0
  238. morphogen/models/nacre.py +411 -0
  239. morphogen/models/nested.py +924 -0
  240. morphogen/models/osteons.py +374 -0
  241. morphogen/models/pieces.py +167 -0
  242. morphogen/models/planar.py +126 -0
  243. morphogen/models/reconstruction.py +203 -0
  244. morphogen/models/scale_rich.py +1409 -0
  245. morphogen/models/scale_rich_3d.py +1616 -0
  246. morphogen/models/tessellation.py +735 -0
  247. morphogen/models/tiling_field.py +302 -0
  248. morphogen/models/tpms.py +197 -0
  249. morphogen/models/transparent.py +406 -0
  250. morphogen/models/union.py +141 -0
  251. morphogen/optimization/__init__.py +43 -0
  252. morphogen/optimization/cell.py +295 -0
  253. morphogen/optimization/filters.py +115 -0
  254. morphogen/optimization/mma.py +226 -0
  255. morphogen/optimization/run.py +219 -0
  256. morphogen/optimization/topology.py +632 -0
  257. morphogen/orientations.py +568 -0
  258. morphogen/parallel.py +599 -0
  259. morphogen/pipeline.py +978 -0
  260. morphogen/primitives.py +188 -0
  261. morphogen/results.py +564 -0
  262. morphogen/rve/__init__.py +73 -0
  263. morphogen/rve/report.py +627 -0
  264. morphogen/rve/scaling.py +363 -0
  265. morphogen/rve/study.py +1054 -0
  266. morphogen/rve/windows.py +345 -0
  267. morphogen/seeding.py +51 -0
  268. morphogen/settings.py +118 -0
  269. morphogen/stopping.py +48 -0
  270. morphogen/symmetry.py +384 -0
  271. morphogen/templates/activator_inhibitor.yaml +22 -0
  272. morphogen/templates/aggregation.yaml +23 -0
  273. morphogen/templates/boolean_cylinders.yaml +20 -0
  274. morphogen/templates/boolean_spheres.yaml +22 -0
  275. morphogen/templates/bouligand.yaml +28 -0
  276. morphogen/templates/cellular_automaton.yaml +25 -0
  277. morphogen/templates/coated_spheres.yaml +26 -0
  278. morphogen/templates/contact_fibers.yaml +27 -0
  279. morphogen/templates/cox_nanocomposite.yaml +22 -0
  280. morphogen/templates/cross_linked_fibers.yaml +26 -0
  281. morphogen/templates/curved_arcs.yaml +28 -0
  282. morphogen/templates/curved_fibers.yaml +24 -0
  283. morphogen/templates/dead_leaves.yaml +22 -0
  284. morphogen/templates/delaunay_network.yaml +22 -0
  285. morphogen/templates/dense_packing.yaml +22 -0
  286. morphogen/templates/diffusion.yaml +33 -0
  287. morphogen/templates/ebsd.yaml +34 -0
  288. morphogen/templates/ebsd_map.ctf +3087 -0
  289. morphogen/templates/fracture_composite.yaml +42 -0
  290. morphogen/templates/fracture_rubber.yaml +47 -0
  291. morphogen/templates/gaussian_excursion.yaml +17 -0
  292. morphogen/templates/graded_lattice.yaml +24 -0
  293. morphogen/templates/hardcore_fibers.yaml +22 -0
  294. morphogen/templates/hardcore_spheres.yaml +22 -0
  295. morphogen/templates/hierarchical_lattice.yaml +22 -0
  296. morphogen/templates/homogenization_acoustic_foam.yaml +36 -0
  297. morphogen/templates/homogenization_beremin.yaml +50 -0
  298. morphogen/templates/homogenization_cleavage.yaml +51 -0
  299. morphogen/templates/homogenization_cleavage_band.yaml +55 -0
  300. morphogen/templates/homogenization_contact.yaml +43 -0
  301. morphogen/templates/homogenization_crack_closure.yaml +49 -0
  302. morphogen/templates/homogenization_crystal_plasticity.yaml +50 -0
  303. morphogen/templates/homogenization_crystal_plasticity_fft.yaml +52 -0
  304. morphogen/templates/homogenization_crystallization.yaml +30 -0
  305. morphogen/templates/homogenization_debonding.yaml +43 -0
  306. morphogen/templates/homogenization_detwinning.yaml +58 -0
  307. morphogen/templates/homogenization_ductile_damage.yaml +47 -0
  308. morphogen/templates/homogenization_fatigue.yaml +40 -0
  309. morphogen/templates/homogenization_grain_fracture.yaml +56 -0
  310. morphogen/templates/homogenization_gyroid.yaml +30 -0
  311. morphogen/templates/homogenization_intergranular.yaml +43 -0
  312. morphogen/templates/homogenization_interphase.yaml +42 -0
  313. morphogen/templates/homogenization_mixed_loading.yaml +33 -0
  314. morphogen/templates/homogenization_ntfa.yaml +56 -0
  315. morphogen/templates/homogenization_piezoelectric.yaml +27 -0
  316. morphogen/templates/homogenization_polycrystal.yaml +30 -0
  317. morphogen/templates/homogenization_polycrystal_inclusions.yaml +30 -0
  318. morphogen/templates/homogenization_poroelastic.yaml +26 -0
  319. morphogen/templates/homogenization_rubber.yaml +40 -0
  320. morphogen/templates/homogenization_slip_cleavage.yaml +50 -0
  321. morphogen/templates/homogenization_spheres.yaml +31 -0
  322. morphogen/templates/homogenization_transport.yaml +29 -0
  323. morphogen/templates/homogenization_twinning.yaml +54 -0
  324. morphogen/templates/homogenization_viscoelastic.yaml +34 -0
  325. morphogen/templates/homogenization_viscoplastic.yaml +42 -0
  326. morphogen/templates/homogenization_voronoi.yaml +26 -0
  327. morphogen/templates/homogenization_xfem.yaml +23 -0
  328. morphogen/templates/hyperuniform_cells.yaml +24 -0
  329. morphogen/templates/laguerre.yaml +18 -0
  330. morphogen/templates/laser_bending.yaml +35 -0
  331. morphogen/templates/laser_cells.yaml +38 -0
  332. morphogen/templates/laser_corrugated.yaml +36 -0
  333. morphogen/templates/level_set_foam.yaml +29 -0
  334. morphogen/templates/menger_sponge.yaml +17 -0
  335. morphogen/templates/nacre.yaml +25 -0
  336. morphogen/templates/nucleation_growth.yaml +25 -0
  337. morphogen/templates/optimize_auxetic.yaml +29 -0
  338. morphogen/templates/optimize_auxetic_3d.yaml +27 -0
  339. morphogen/templates/optimize_bulk.yaml +23 -0
  340. morphogen/templates/optimize_conductivity.yaml +20 -0
  341. morphogen/templates/osteons.yaml +28 -0
  342. morphogen/templates/penetrable_spheres.yaml +21 -0
  343. morphogen/templates/poisson_fibers.yaml +21 -0
  344. morphogen/templates/random_laminate.yaml +26 -0
  345. morphogen/templates/random_lattice.yaml +27 -0
  346. morphogen/templates/random_walk_fibers.yaml +26 -0
  347. morphogen/templates/reaction_diffusion.yaml +22 -0
  348. morphogen/templates/reconstruction.yaml +22 -0
  349. morphogen/templates/rve_cellular_automaton.yaml +23 -0
  350. morphogen/templates/rve_crystal_plasticity_fft.yaml +51 -0
  351. morphogen/templates/rve_multiphysics.yaml +43 -0
  352. morphogen/templates/rve_poisson_fibers.yaml +22 -0
  353. morphogen/templates/rve_poisson_fibers_fe.yaml +33 -0
  354. morphogen/templates/rve_voronoi_windows.yaml +20 -0
  355. morphogen/templates/scale_rich_network.yaml +29 -0
  356. morphogen/templates/scale_rich_plates.yaml +30 -0
  357. morphogen/templates/sequential_dead_leaves.yaml +25 -0
  358. morphogen/templates/strut_lattice.yaml +21 -0
  359. morphogen/templates/tile_assembly.yaml +28 -0
  360. morphogen/templates/tpms.yaml +19 -0
  361. morphogen/templates/trabecular_bone.yaml +29 -0
  362. morphogen/templates/transparent_dead_leaves.yaml +23 -0
  363. morphogen/templates/vascular_tree.yaml +23 -0
  364. morphogen/templates/voronoi.yaml +20 -0
  365. morphogen/templates/wood.yaml +34 -0
  366. morphogen/templates/workflow.yaml +56 -0
  367. morphogen/texture.py +665 -0
  368. morphogen/theory.py +162 -0
  369. morphogen/viz/__init__.py +12 -0
  370. morphogen/viz/export.py +244 -0
  371. morphogen/viz/figures.py +707 -0
  372. morphogen/viz/png.py +148 -0
  373. morphogen/viz/sections.py +696 -0
  374. morphogen/viz/surfaces.py +1352 -0
  375. morphogen/viz/video.py +904 -0
  376. morphogen/viz/workflow.py +488 -0
  377. morphogen-1.0.0.dist-info/METADATA +2316 -0
  378. morphogen-1.0.0.dist-info/RECORD +381 -0
  379. morphogen-1.0.0.dist-info/WHEEL +4 -0
  380. morphogen-1.0.0.dist-info/entry_points.txt +5 -0
  381. 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)
@@ -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