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,501 @@
1
+ """NURBS patches and their assemblies: the geometry of an isogeometric analysis.
2
+
3
+ A patch is a tensor product of B-spline bases (:mod:`morphogen.iga.basis`) with control
4
+ points ``P_a`` and positive weights ``w_a``: a point of parameters ``xi`` is::
5
+
6
+ x(xi) = sum_a R_a(xi) P_a, R_a = N_a w_a / sum_b N_b w_b,
7
+
8
+ ``N_a`` the product of the functions of each direction. Rational functions give conics —
9
+ circles, ellipses — exactly; with unit weights the patch is a polynomial spline. A patch
10
+ of two parameters in the plane is a surface (plane stress or plane strain), of three
11
+ parameters a solid; their sides are patches of one parameter less.
12
+
13
+ A :class:`Multipatch` assembles patches that share whole sides: their control points
14
+ there coincide (with their weights and their knots, so that the patches fit along the
15
+ whole side), and are one control point of the assembly. The unknowns of an analysis are
16
+ attached to these control points (the isoparametric concept: the functions of the
17
+ geometry are those of the fields).
18
+
19
+ Refinement keeps the geometry (:meth:`Patch.refined`): every element cut in parts
20
+ (*h*), the degree raised (*p*), or the degree raised then the elements cut (*k*, which
21
+ keeps the continuity of the higher degree across the new knots). The control points of
22
+ the refined patch are linear in those of the coarse one for given weights:
23
+ :meth:`Multipatch.refinement` returns the matrix of that map, by which a design made of
24
+ few control points drives the many of its analysis (:mod:`morphogen.iga.optimization`).
25
+ """
26
+
27
+ from __future__ import annotations
28
+
29
+ from dataclasses import dataclass, field
30
+
31
+ import numpy as np
32
+ import scipy.sparse as sp
33
+ from scipy.sparse.csgraph import connected_components
34
+ from scipy.spatial import cKDTree
35
+
36
+ from morphogen.iga import basis as bs
37
+
38
+
39
+ def _per_direction(value, ndim: int, name: str) -> tuple[int, ...]:
40
+ values = (int(value),) * ndim if np.isscalar(value) else tuple(int(v) for v in value)
41
+ if len(values) != ndim:
42
+ raise ValueError(f"{name}: one value, or one per direction ({ndim})")
43
+ return values
44
+
45
+
46
+ def _inside(points: np.ndarray, polygon: np.ndarray) -> np.ndarray:
47
+ """Whether points of the plane are inside a closed polygon (the parity of the
48
+ crossings of a half-line)."""
49
+ x, y = points[:, 0], points[:, 1]
50
+ inside = np.zeros(len(points), dtype=bool)
51
+ with np.errstate(divide="ignore", invalid="ignore"):
52
+ for (a, b), (c, d) in zip(polygon, np.roll(polygon, -1, axis=0), strict=True):
53
+ inside ^= ((b > y) != (d > y)) & (x < (c - a) * (y - b) / (d - b) + a)
54
+ return inside
55
+
56
+
57
+ def _lattice(lattice, dim: int) -> np.ndarray | None:
58
+ """The periods of a cell as an array (one vector per row), checked."""
59
+ if lattice is None:
60
+ return None
61
+ lattice = np.array(lattice, dtype=float)
62
+ if lattice.shape != (dim, dim):
63
+ raise ValueError(f"lattice: {dim} vectors of {dim} coordinates")
64
+ if abs(np.linalg.det(lattice)) < 1e-9 * np.abs(lattice).max() ** dim:
65
+ raise ValueError("lattice: independent vectors")
66
+ return lattice
67
+
68
+
69
+ @dataclass
70
+ class Patch:
71
+ """A NURBS patch: the ``degrees`` and the ``knots`` of its directions, its control
72
+ ``points`` (``n_1 x ... x n_d x dim``) and their ``weights`` (``n_1 x ... x n_d``; unit
73
+ weights by default), and the ``phase`` of its material."""
74
+
75
+ degrees: tuple
76
+ knots: tuple
77
+ points: np.ndarray
78
+ weights: np.ndarray | None = None
79
+ phase: int = 0
80
+ metadata: dict = field(default_factory=dict)
81
+
82
+ def __post_init__(self) -> None:
83
+ self.degrees = tuple(int(p) for p in self.degrees)
84
+ self.knots = tuple(
85
+ bs.check_knots(k, p) for k, p in zip(self.knots, self.degrees, strict=True)
86
+ )
87
+ self.points = np.array(self.points, dtype=float)
88
+ shape = tuple(bs.n_functions(k, p) for k, p in zip(self.knots, self.degrees, strict=True))
89
+ if self.points.shape[:-1] != shape:
90
+ raise ValueError(
91
+ f"points: {shape} control points for these knots and degrees, got "
92
+ f"{self.points.shape[:-1]}"
93
+ )
94
+ if self.weights is None:
95
+ self.weights = np.ones(shape)
96
+ self.weights = np.array(self.weights, dtype=float)
97
+ if self.weights.shape != shape or np.any(self.weights <= 0):
98
+ raise ValueError("weights: one positive weight per control point")
99
+ self.phase = int(self.phase)
100
+
101
+ # -- sizes -------------------------------------------------------------------------
102
+
103
+ @property
104
+ def ndim(self) -> int:
105
+ """The number of parameters: 1 (curve), 2 (surface) or 3 (solid)."""
106
+ return len(self.degrees)
107
+
108
+ @property
109
+ def dim(self) -> int:
110
+ """The dimension of the space of the control points."""
111
+ return self.points.shape[-1]
112
+
113
+ @property
114
+ def shape(self) -> tuple[int, ...]:
115
+ """The numbers of control points along the directions."""
116
+ return self.weights.shape
117
+
118
+ @property
119
+ def n_elements(self) -> int:
120
+ return int(np.prod([len(bs.breakpoints(k)) - 1 for k in self.knots]))
121
+
122
+ @property
123
+ def rational(self) -> bool:
124
+ return bool(np.ptp(self.weights) > 0.0)
125
+
126
+ # -- evaluation --------------------------------------------------------------------
127
+
128
+ def _collocations(self, params, derivative=None) -> list[np.ndarray]:
129
+ """The matrices of the functions of each direction at the parameters (points x
130
+ ndim), with those of ``derivative`` differentiated once."""
131
+ params = np.atleast_2d(np.asarray(params, dtype=float))
132
+ if params.shape[1] != self.ndim:
133
+ raise ValueError(f"parameters: {self.ndim} per point")
134
+ return [
135
+ bs.collocation(self.knots[d], self.degrees[d], params[:, d], int(d == derivative))
136
+ for d in range(self.ndim)
137
+ ]
138
+
139
+ def _contract(self, matrices, coefficients) -> np.ndarray:
140
+ """``sum_a prod_d C_d[m, a_d] c_a``: the spline of coefficients ``c`` at the
141
+ points (rows of the matrices)."""
142
+ letters = "abc"[: self.ndim]
143
+ operands = ",".join(f"m{letter}" for letter in letters)
144
+ trailing = "k" if coefficients.ndim > self.ndim else ""
145
+ return np.einsum(f"{operands},{letters}{trailing}->m{trailing}", *matrices, coefficients)
146
+
147
+ def at(self, params) -> np.ndarray:
148
+ """The points of the patch at parameters (points x ndim): points x dim."""
149
+ matrices = self._collocations(params)
150
+ weighted = self.weights[..., None] * self.points
151
+ return self._contract(matrices, weighted) / self._contract(matrices, self.weights)[:, None]
152
+
153
+ def jacobian(self, params) -> tuple[np.ndarray, np.ndarray]:
154
+ """The points at parameters and the derivatives of the position with respect to
155
+ the parameters there (points x dim x ndim)."""
156
+ weighted = self.weights[..., None] * self.points
157
+ matrices = self._collocations(params)
158
+ den = self._contract(matrices, self.weights)
159
+ x = self._contract(matrices, weighted) / den[:, None]
160
+ jac = np.empty((len(x), self.dim, self.ndim))
161
+ for d in range(self.ndim):
162
+ derived = self._collocations(params, d)
163
+ da = self._contract(derived, weighted)
164
+ dw = self._contract(derived, self.weights)
165
+ jac[:, :, d] = (da - x * dw[:, None]) / den[:, None]
166
+ return x, jac
167
+
168
+ def sample(self, counts=8) -> np.ndarray:
169
+ """The points of a grid of parameters, ``counts`` per element and direction
170
+ (and the end of the last element): ``m_1 x ... x m_d x dim``."""
171
+ counts = _per_direction(counts, self.ndim, "counts")
172
+ axes = []
173
+ for knots, count in zip(self.knots, counts, strict=True):
174
+ ends = bs.breakpoints(knots)
175
+ inside = ends[:-1, None] + np.diff(ends)[:, None] * np.arange(count)[None, :] / count
176
+ axes.append(np.append(inside.ravel(), ends[-1]))
177
+ grid = np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1)
178
+ return self.at(grid.reshape(-1, self.ndim)).reshape(*grid.shape[:-1], self.dim)
179
+
180
+ # -- sides ---------------------------------------------------------------------------
181
+
182
+ def side_indices(self, axis: int, end: int) -> np.ndarray:
183
+ """The control points of a side (``end`` 0: the start of direction ``axis``, 1:
184
+ its end): their indices in the raveled arrays of the patch."""
185
+ index = np.arange(self.weights.size).reshape(self.shape)
186
+ return np.take(index, 0 if end == 0 else -1, axis=axis).ravel()
187
+
188
+ def side(self, axis: int, end: int) -> Patch:
189
+ """A side of the patch: a patch of one parameter less."""
190
+ if self.ndim < 2:
191
+ raise ValueError("side: of a surface or a solid")
192
+ take = 0 if end == 0 else -1
193
+ others = [d for d in range(self.ndim) if d != axis]
194
+ return Patch(
195
+ tuple(self.degrees[d] for d in others),
196
+ tuple(self.knots[d] for d in others),
197
+ np.take(self.points, take, axis=axis),
198
+ np.take(self.weights, take, axis=axis),
199
+ self.phase,
200
+ )
201
+
202
+ # -- refinement ----------------------------------------------------------------------
203
+
204
+ def refinement_operators(self, subdivisions=1, elevate=0) -> tuple[list, list, list]:
205
+ """The matrices of the refinement of each direction (new functions x old ones;
206
+ :func:`morphogen.iga.basis.embedding`), with the new degrees and knots."""
207
+ subdivisions = _per_direction(subdivisions, self.ndim, "subdivisions")
208
+ elevate = _per_direction(elevate, self.ndim, "elevate")
209
+ operators, degrees, knots = [], [], []
210
+ for d in range(self.ndim):
211
+ new_knots = bs.refined_knots(
212
+ self.knots[d], self.degrees[d], subdivisions[d], elevate[d]
213
+ )
214
+ new_degree = self.degrees[d] + elevate[d]
215
+ if subdivisions[d] == 1 and elevate[d] == 0:
216
+ operators.append(np.eye(self.shape[d]))
217
+ else:
218
+ operators.append(
219
+ bs.embedding(self.knots[d], self.degrees[d], new_knots, new_degree)
220
+ )
221
+ degrees.append(new_degree)
222
+ knots.append(new_knots)
223
+ return operators, degrees, knots
224
+
225
+ def refined(self, subdivisions=1, elevate=0) -> Patch:
226
+ """The same patch with every element cut into ``subdivisions`` parts along each
227
+ direction and its degrees raised by ``elevate`` (one value, or one per
228
+ direction): the degree is raised first (*k*-refinement)."""
229
+ operators, degrees, knots = self.refinement_operators(subdivisions, elevate)
230
+ homogeneous = np.concatenate(
231
+ [self.weights[..., None] * self.points, self.weights[..., None]], axis=-1
232
+ )
233
+ for d, matrix in enumerate(operators):
234
+ homogeneous = np.moveaxis(np.tensordot(matrix, homogeneous, axes=(1, d)), 0, d)
235
+ weights = homogeneous[..., -1]
236
+ points = homogeneous[..., :-1] / weights[..., None]
237
+ return Patch(tuple(degrees), tuple(knots), points, weights, self.phase, dict(self.metadata))
238
+
239
+ def with_points(self, points) -> Patch:
240
+ """The patch with other control points (the same weights and knots)."""
241
+ return Patch(self.degrees, self.knots, points, self.weights, self.phase,
242
+ dict(self.metadata)) # fmt: skip
243
+
244
+
245
+ class Multipatch:
246
+ """Patches that share whole sides (see the module): ``patches``, the control points
247
+ of the assembly (``nodes``, ``weights``) and, for each patch, the indices of its
248
+ control points among them (``ids``, of the shape of the patch). Control points
249
+ closer than ``tolerance`` times the size of the assembly are one.
250
+
251
+ ``lattice`` (optional; one vector per row) gives the periods of an assembly that is
252
+ the cell of a periodic medium without being a box — a parallelogram, or any set of
253
+ patches that tiles the plane (the space) by these translations: the sides of its
254
+ boundary then match by a period (:mod:`morphogen.iga.homogenization`)."""
255
+
256
+ def __init__(self, patches, tolerance: float = 1e-8, lattice=None):
257
+ patches = [patches] if isinstance(patches, Patch) else list(patches)
258
+ if not patches:
259
+ raise ValueError("Multipatch: at least one patch")
260
+ if len({(p.ndim, p.dim) for p in patches}) != 1:
261
+ raise ValueError("Multipatch: patches of the same dimensions")
262
+ self.patches = patches
263
+ self.tolerance = float(tolerance)
264
+ self.lattice = _lattice(lattice, patches[0].dim)
265
+ points = np.concatenate([p.points.reshape(-1, p.dim) for p in patches])
266
+ weights = np.concatenate([p.weights.ravel() for p in patches])
267
+ size = float(np.ptp(points, axis=0).max()) or 1.0
268
+ pairs = cKDTree(points).query_pairs(self.tolerance * size, output_type="ndarray")
269
+ graph = sp.coo_matrix(
270
+ (np.ones(len(pairs)), (pairs[:, 0], pairs[:, 1])), shape=(len(points),) * 2
271
+ )
272
+ count, labels = connected_components(graph, directed=False)
273
+ # the control points of the assembly in the order of their first patch
274
+ _, first = np.unique(labels, return_index=True)
275
+ order = np.argsort(first)
276
+ rank = np.empty(count, dtype=np.int64)
277
+ rank[order] = np.arange(count)
278
+ labels = rank[labels]
279
+ self.nodes = np.zeros((count, points.shape[1]))
280
+ self.nodes[labels] = points
281
+ self.weights = np.zeros(count)
282
+ self.weights[labels] = weights
283
+ if np.abs(self.weights[labels] - weights).max() > 1e-9:
284
+ raise ValueError(
285
+ "Multipatch: control points shared by two patches have different weights"
286
+ )
287
+ self.ids, start = [], 0
288
+ for p in patches:
289
+ self.ids.append(labels[start : start + p.weights.size].reshape(p.shape))
290
+ start += p.weights.size
291
+
292
+ # -- sizes -------------------------------------------------------------------------
293
+
294
+ @property
295
+ def ndim(self) -> int:
296
+ return self.patches[0].ndim
297
+
298
+ @property
299
+ def dim(self) -> int:
300
+ return self.patches[0].dim
301
+
302
+ @property
303
+ def n_nodes(self) -> int:
304
+ return len(self.nodes)
305
+
306
+ @property
307
+ def n_elements(self) -> int:
308
+ return sum(p.n_elements for p in self.patches)
309
+
310
+ @property
311
+ def lower(self) -> np.ndarray:
312
+ """The lower corner of the box of the control points."""
313
+ return self.nodes.min(axis=0)
314
+
315
+ @property
316
+ def upper(self) -> np.ndarray:
317
+ return self.nodes.max(axis=0)
318
+
319
+ @property
320
+ def phases(self) -> list[int]:
321
+ return sorted({p.phase for p in self.patches})
322
+
323
+ def side_nodes(self, patch: int, axis: int, end: int) -> np.ndarray:
324
+ """The control points of a side of a patch (indices in the assembly)."""
325
+ return self.ids[patch].ravel()[self.patches[patch].side_indices(axis, end)]
326
+
327
+ def boundary_nodes(self) -> np.ndarray:
328
+ """The control points of the sides that belong to one patch only: the boundary
329
+ of the assembly (the outer one and those of its holes)."""
330
+ sides: dict[tuple, int] = {}
331
+ for k, p in enumerate(self.patches):
332
+ for axis in range(p.ndim):
333
+ for end in (0, 1):
334
+ key = tuple(sorted(self.side_nodes(k, axis, end).tolist()))
335
+ sides[key] = sides.get(key, 0) + 1
336
+ nodes = [n for key, count in sides.items() if count == 1 for n in key]
337
+ return np.unique(np.array(nodes, dtype=np.int64))
338
+
339
+ def free_sides(self) -> list[tuple[int, int, int]]:
340
+ """The sides (patch, axis, end) that belong to one patch only."""
341
+ sides: dict[tuple, list] = {}
342
+ for k, p in enumerate(self.patches):
343
+ for axis in range(p.ndim):
344
+ for end in (0, 1):
345
+ key = tuple(sorted(self.side_nodes(k, axis, end).tolist()))
346
+ sides.setdefault(key, []).append((k, axis, end))
347
+ return [found[0] for found in sides.values() if len(found) == 1]
348
+
349
+ # -- other geometries of the same assembly -----------------------------------------------
350
+
351
+ def with_nodes(self, nodes) -> Multipatch:
352
+ """The assembly with its control points moved to ``nodes`` (the same weights,
353
+ knots and connections)."""
354
+ nodes = np.asarray(nodes, dtype=float)
355
+ if nodes.shape != self.nodes.shape:
356
+ raise ValueError(
357
+ f"nodes: {self.nodes.shape[0]} control points of {self.dim} coordinates"
358
+ )
359
+ out = Multipatch.__new__(Multipatch)
360
+ out.patches = [
361
+ p.with_points(nodes[ids]) for p, ids in zip(self.patches, self.ids, strict=True)
362
+ ]
363
+ out.tolerance = self.tolerance
364
+ out.lattice = self.lattice
365
+ out.nodes = nodes.copy()
366
+ out.weights = self.weights.copy()
367
+ out.ids = [ids.copy() for ids in self.ids]
368
+ return out
369
+
370
+ def refined(self, subdivisions=1, elevate=0) -> Multipatch:
371
+ """The assembly of the refined patches (:meth:`Patch.refined`)."""
372
+ return Multipatch(
373
+ [p.refined(subdivisions, elevate) for p in self.patches], self.tolerance, self.lattice
374
+ )
375
+
376
+ def refinement(self, subdivisions=1, elevate=0) -> tuple[Multipatch, sp.csr_matrix]:
377
+ """The refined assembly and the matrix ``T`` of its control points in terms of
378
+ those of this one, for given weights: ``refined.nodes = T @ nodes`` (and for any
379
+ other positions of the control points of this assembly:
380
+ ``refined.with_nodes(T @ other)``)."""
381
+ fine = self.refined(subdivisions, elevate)
382
+ rows, cols, values = [], [], []
383
+ seen = np.zeros(fine.n_nodes, dtype=bool)
384
+ for p, ids, fine_ids in zip(self.patches, self.ids, fine.ids, strict=True):
385
+ operators, _, _ = p.refinement_operators(subdivisions, elevate)
386
+ matrix = operators[0]
387
+ for other in operators[1:]:
388
+ matrix = np.kron(matrix, other)
389
+ scaled = matrix * p.weights.ravel()[None, :]
390
+ scaled /= scaled.sum(axis=1, keepdims=True) # the weights of the refined points
391
+ targets = fine_ids.ravel()
392
+ new = ~seen[targets]
393
+ seen[targets] = True
394
+ r, c = np.nonzero(scaled[new])
395
+ rows.append(targets[new][r])
396
+ cols.append(ids.ravel()[c])
397
+ values.append(scaled[new][r, c])
398
+ matrix = sp.coo_matrix(
399
+ (np.concatenate(values), (np.concatenate(rows), np.concatenate(cols))),
400
+ shape=(fine.n_nodes, self.n_nodes),
401
+ ).tocsr()
402
+ return fine, matrix
403
+
404
+ def jacobians(self, counts: int = 6) -> tuple[float, float]:
405
+ """The smallest and the largest determinants of the Jacobian of the patches, on
406
+ grids of parameters that hold the ends of the elements (``counts`` per element
407
+ and direction): a negative one where a patch folds or turns over — at its
408
+ boundary first, where the points of integration of an analysis do not look."""
409
+ if self.ndim != self.dim:
410
+ raise ValueError("jacobians: of surfaces of the plane or of solids")
411
+ low, high = np.inf, -np.inf
412
+ for p in self.patches:
413
+ axes = []
414
+ for knots in p.knots:
415
+ ends = bs.breakpoints(knots)
416
+ inside = ends[:-1, None] + np.diff(ends)[:, None] * np.arange(counts) / counts
417
+ axes.append(np.append(inside.ravel(), ends[-1]))
418
+ grid = np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1).reshape(-1, p.ndim)
419
+ det = np.linalg.det(p.jacobian(grid)[1])
420
+ low, high = min(low, float(det.min())), max(high, float(det.max()))
421
+ return low, high
422
+
423
+ def polygons(self, counts: int = 12) -> list[np.ndarray]:
424
+ """The boundary of each patch as a closed polygon (for figures: the patches
425
+ filled): surfaces only."""
426
+ if self.ndim != 2:
427
+ raise ValueError("polygons: of an assembly of surfaces")
428
+ out = []
429
+ for p in self.patches:
430
+ sides = [
431
+ p.side(1, 0).sample(counts),
432
+ p.side(0, 1).sample(counts),
433
+ p.side(1, 1).sample(counts)[::-1],
434
+ p.side(0, 0).sample(counts)[::-1],
435
+ ]
436
+ out.append(np.concatenate([side[:-1] for side in sides]))
437
+ return out
438
+
439
+ def voxelize(self, shape, lower=None, upper=None, hole: int | None = None,
440
+ depth: int = 1, counts: int = 16): # fmt: skip
441
+ """The image of an assembly of surfaces on a grid of ``shape`` pixels over the
442
+ box from ``lower`` to ``upper`` (that of its control points by default): each
443
+ pixel takes the phase of the patch that holds its centre, ``hole`` where there
444
+ is none (by default the largest phase plus one). With a ``lattice``, the copies
445
+ of the patches by its periods are drawn as well, so that a box that is a period
446
+ of the medium gives a periodic image — the square of two spacings for
447
+ :func:`~morphogen.iga.shapes.alternating_holes`. Curved sides are drawn as
448
+ polygons of ``counts`` points per element.
449
+
450
+ Returns a periodic :class:`~morphogen.image.VoxelImage` of ``depth`` voxels along
451
+ the third axis: the shape for the voxel solvers (plane strain), the nonlinear
452
+ behaviours and the exports."""
453
+ from morphogen.image import VoxelImage
454
+
455
+ if self.ndim != 2 or self.dim != 2:
456
+ raise ValueError("voxelize: an assembly of surfaces of the plane")
457
+ shape = (int(shape),) * 2 if np.isscalar(shape) else tuple(int(n) for n in shape)
458
+ lower = self.lower if lower is None else np.asarray(lower, dtype=float)
459
+ upper = self.upper if upper is None else np.asarray(upper, dtype=float)
460
+ if len(shape) != 2 or min(shape) < 1 or np.any(upper <= lower):
461
+ raise ValueError("voxelize: a shape of two counts and a box lower < upper")
462
+ step = (upper - lower) / shape
463
+ hole = max(self.phases) + 1 if hole is None else int(hole)
464
+ image = np.full(shape, hole, dtype=np.uint8)
465
+ shifts = np.zeros((1, 2))
466
+ if self.lattice is not None:
467
+ reach = int(np.ceil(np.abs((upper - lower) @ np.linalg.inv(self.lattice)).max())) + 2
468
+ combos = np.array(np.meshgrid(*[np.arange(-reach, reach + 1)] * 2)).reshape(2, -1).T
469
+ shifts = combos @ self.lattice
470
+ for patch, polygon in zip(self.patches, self.polygons(counts), strict=True):
471
+ for shift in shifts:
472
+ moved = polygon + shift
473
+ first = np.maximum(np.floor((moved.min(axis=0) - lower) / step).astype(int), 0)
474
+ last = np.minimum(np.ceil((moved.max(axis=0) - lower) / step).astype(int), shape)
475
+ if np.any(last <= first):
476
+ continue
477
+ axes = [lower[d] + (np.arange(first[d], last[d]) + 0.5) * step[d] for d in (0, 1)]
478
+ centres = np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1).reshape(-1, 2)
479
+ found = _inside(centres, moved).reshape(len(axes[0]), len(axes[1]))
480
+ image[first[0] : last[0], first[1] : last[1]][found] = patch.phase
481
+ return VoxelImage(
482
+ np.repeat(image[:, :, None], int(depth), axis=2),
483
+ spacing=(step[0], step[1], step[0]),
484
+ origin=(lower[0], lower[1], 0.0),
485
+ periodic=True,
486
+ metadata={"source": "morphogen.iga", "hole": hole},
487
+ )
488
+
489
+ def outline(self, counts: int = 12) -> list[np.ndarray]:
490
+ """The sides of the patches as polylines (for figures): surfaces only."""
491
+ if self.ndim != 2:
492
+ raise ValueError("outline: of an assembly of surfaces")
493
+ lines = []
494
+ for p in self.patches:
495
+ for axis in range(2):
496
+ for end in (0, 1):
497
+ lines.append(p.side(axis, end).sample(counts))
498
+ return lines
499
+
500
+
501
+ __all__ = ["Multipatch", "Patch"]