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,48 @@
1
+ """Isogeometric analysis: NURBS geometries, their analysis and their shape optimization.
2
+
3
+ * :mod:`morphogen.iga.basis`: B-spline functions, knot vectors, refinement operators;
4
+ * :mod:`morphogen.iga.geometry`: NURBS patches and their assemblies (:class:`Patch`,
5
+ :class:`Multipatch`), their refinements;
6
+ * :mod:`morphogen.iga.shapes`: rectangles, rings, plates and periodic cells with holes
7
+ (boxes, parallelograms, the sheet with alternating holes);
8
+ * :mod:`morphogen.iga.analysis`: linear elasticity and conduction (:class:`Analysis`);
9
+ * :mod:`morphogen.iga.homogenization`: the effective tensors of periodic cells, boxes
10
+ or cells of any lattice (:func:`homogenize`, :class:`Cell`);
11
+ * :mod:`morphogen.iga.optimization`: shape optimization with the control points as
12
+ variables, linked by the symmetries of a pattern, and analytical sensitivities
13
+ (:class:`ShapeDesign`, :func:`optimize_cell`, :func:`optimize_structure`).
14
+
15
+ The tutorial ``docs/tutorial_iga.md`` follows the package from a patch to the shape of
16
+ an auxetic sheet.
17
+ """
18
+
19
+ from morphogen.iga import basis, homogenization, optimization, shapes
20
+ from morphogen.iga.analysis import Analysis, conduction_matrix, elastic_matrix
21
+ from morphogen.iga.geometry import Multipatch, Patch
22
+ from morphogen.iga.homogenization import Cell, CellSolution, homogenize, plane_constants
23
+ from morphogen.iga.optimization import (
24
+ ShapeDesign,
25
+ ShapeResult,
26
+ optimize_cell,
27
+ optimize_structure,
28
+ )
29
+
30
+ __all__ = [
31
+ "Analysis",
32
+ "Cell",
33
+ "CellSolution",
34
+ "Multipatch",
35
+ "Patch",
36
+ "ShapeDesign",
37
+ "ShapeResult",
38
+ "basis",
39
+ "conduction_matrix",
40
+ "elastic_matrix",
41
+ "homogenization",
42
+ "homogenize",
43
+ "optimization",
44
+ "optimize_cell",
45
+ "optimize_structure",
46
+ "plane_constants",
47
+ "shapes",
48
+ ]
@@ -0,0 +1,508 @@
1
+ """Isogeometric analysis of linear elasticity and conduction on NURBS assemblies.
2
+
3
+ The isoparametric concept of Hughes, Cottrell & Bazilevs (2005): the rational functions
4
+ ``R_a`` that describe the geometry (:mod:`morphogen.iga.geometry`) interpolate the
5
+ unknowns too, ``u = sum_a R_a u_a``, the unknowns attached to the control points. The
6
+ geometry of the analysis is that of the design — a circle stays a circle at any
7
+ refinement —, and the functions are smooth across the elements of a patch (``C^(p-1)``
8
+ after a *k*-refinement), which gives more accuracy per unknown than finite elements of
9
+ the same degree.
10
+
11
+ Discretization. The elements are the knot spans of each patch; the integrals are those
12
+ of Gauss-Legendre with ``p + 1`` points per direction. At a point, the derivatives of the
13
+ functions with respect to the parameters give the Jacobian ``J = sum_a P_a (x) dR_a/dxi``
14
+ and the gradients ``dR_a/dx = dR_a/dxi J^-1``; the stiffness is ``K = sum int B^T D B det
15
+ J dxi``, as for finite elements, with ``B`` the strain operator of these gradients.
16
+ Strains and stresses are written in Voigt's notation with engineering shears: ``(11, 22,
17
+ 12)`` in the plane, ``(11, 22, 33, 23, 31, 12)`` in space (the order of the rest of
18
+ morphoGen). In the plane, ``plane="strain"`` takes the stiffness of the plane components
19
+ of the three-dimensional law, ``plane="stress"`` its condensation at zero out-of-plane
20
+ stresses.
21
+
22
+ Conditions. The functions of an open knot vector interpolate at the ends of a patch:
23
+ the control points of a side carry the values of the unknown along it, so that a
24
+ uniform value (a clamped or symmetric side) is prescribed on them exactly; tractions
25
+ are integrated on the sides.
26
+ """
27
+
28
+ from __future__ import annotations
29
+
30
+ from collections.abc import Callable, Iterator
31
+ from dataclasses import dataclass
32
+
33
+ import numpy as np
34
+ import scipy.sparse as sp
35
+ import scipy.sparse.linalg as spla
36
+
37
+ from morphogen.iga import basis as bs
38
+ from morphogen.iga.geometry import Multipatch, Patch
39
+
40
+ PLANES = ("strain", "stress")
41
+ PHYSICS = ("elastic", "conduction")
42
+ #: Elements of a patch integrated at once (memory of the arrays of their points)
43
+ _CHUNK = 4096
44
+
45
+
46
+ def elastic_matrix(material, ndim: int, plane: str = "strain") -> np.ndarray:
47
+ """The stiffness of a material in Voigt's notation for an analysis of ``ndim``
48
+ dimensions: the 6 x 6 matrix of a solid; in the plane, its plane components (plane
49
+ strain) or its condensation at zero out-of-plane stresses (plane stress). ``material``:
50
+ a :class:`~morphogen.homogenization.materials.Material`, or a 6 x 6 (or, in the plane,
51
+ 3 x 3) array."""
52
+ if hasattr(material, "matrix"):
53
+ full = np.asarray(material.matrix("elastic"), dtype=float)
54
+ else:
55
+ full = np.asarray(material, dtype=float)
56
+ if ndim == 3:
57
+ if full.shape != (6, 6):
58
+ raise ValueError("elastic_matrix: a 6 x 6 stiffness for a solid")
59
+ return full
60
+ if full.shape == (3, 3):
61
+ return full
62
+ if full.shape != (6, 6):
63
+ raise ValueError("elastic_matrix: a 6 x 6 stiffness, or 3 x 3 in the plane")
64
+ if plane not in PLANES:
65
+ raise ValueError(f"plane: one of {PLANES}")
66
+ kept, out = [0, 1, 5], [2, 3, 4]
67
+ if plane == "strain":
68
+ return full[np.ix_(kept, kept)]
69
+ coupling = full[np.ix_(kept, out)]
70
+ return full[np.ix_(kept, kept)] - coupling @ np.linalg.solve(
71
+ full[np.ix_(out, out)], full[np.ix_(out, kept)]
72
+ )
73
+
74
+
75
+ def conduction_matrix(material, ndim: int) -> np.ndarray:
76
+ """The conductivity tensor of a material for an analysis of ``ndim`` dimensions: a
77
+ :class:`~morphogen.homogenization.materials.Material`, a number or a tensor."""
78
+ if hasattr(material, "matrix"):
79
+ full = np.asarray(material.matrix("thermal"), dtype=float)
80
+ else:
81
+ full = np.asarray(material, dtype=float)
82
+ if full.ndim == 0:
83
+ return float(full) * np.eye(ndim)
84
+ return full[:ndim, :ndim]
85
+
86
+
87
+ @dataclass
88
+ class Points:
89
+ """The integration points of a group of elements of a patch: the control points of
90
+ each element (``nodes``: elements x functions), the weights of the points times the
91
+ Jacobian (``weights``: elements x points), their positions, the functions there and
92
+ their gradients (elements x points x functions (x dim)), and the Jacobian
93
+ determinants."""
94
+
95
+ patch: int
96
+ nodes: np.ndarray
97
+ weights: np.ndarray
98
+ x: np.ndarray
99
+ values: np.ndarray
100
+ gradients: np.ndarray
101
+ jacobian: np.ndarray
102
+
103
+
104
+ def _directions(patch: Patch, extra: int):
105
+ """For each direction of a patch: the functions and their derivatives at the Gauss
106
+ points of its elements (elements x points x degree + 1), the weights of the points
107
+ and the indices of these functions (elements x degree + 1)."""
108
+ out = []
109
+ for knots, degree in zip(patch.knots, patch.degrees, strict=True):
110
+ ends = bs.breakpoints(knots)
111
+ points, weights = bs.gauss(degree + 1 + extra)
112
+ u = ends[:-1, None] + np.diff(ends)[:, None] * points[None, :]
113
+ span, values = bs.basis(knots, degree, u.ravel(), 1)
114
+ shape = (len(ends) - 1, len(points), degree + 1)
115
+ index = span.reshape(u.shape)[:, :1] - degree + np.arange(degree + 1)[None, :]
116
+ out.append((values[0].reshape(shape), values[1].reshape(shape),
117
+ np.diff(ends)[:, None] * weights[None, :], index)) # fmt: skip
118
+ return out
119
+
120
+
121
+ def _tensor(directions, which: int | None, rows: np.ndarray) -> np.ndarray:
122
+ """The products of the functions of the directions for the elements ``rows`` of the
123
+ first one (all those of the others), the direction ``which`` differentiated:
124
+ elements x points x functions."""
125
+ factors = [d[1] if k == which else d[0] for k, d in enumerate(directions)]
126
+ factors[0] = factors[0][rows]
127
+ if len(factors) == 2:
128
+ out = np.einsum("iga,jhb->ijghab", *factors)
129
+ else:
130
+ out = np.einsum("iga,jhb,kfc->ijkghfabc", *factors)
131
+ n = len(factors)
132
+ elements = int(np.prod(out.shape[:n]))
133
+ points = int(np.prod(out.shape[n : 2 * n]))
134
+ return out.reshape(elements, points, -1)
135
+
136
+
137
+ def patch_points(model: Multipatch, k: int, extra: int = 0) -> Iterator[Points]:
138
+ """The integration points of patch ``k`` of an assembly, by groups of elements
139
+ (``extra`` Gauss points per direction beyond ``degree + 1``)."""
140
+ patch, ids = model.patches[k], model.ids[k]
141
+ ndim = patch.ndim
142
+ if patch.dim != ndim or ndim not in (2, 3):
143
+ raise ValueError("analysis: surfaces of the plane or solids")
144
+ directions = _directions(patch, extra)
145
+ others = int(np.prod([len(d[2]) for d in directions[1:]]))
146
+ step = max(1, _CHUNK // others)
147
+ for start in range(0, len(directions[0][2]), step):
148
+ rows = np.arange(start, min(start + step, len(directions[0][2])))
149
+ index = [d[3] for d in directions]
150
+ index[0] = index[0][rows]
151
+ if ndim == 2:
152
+ nodes = ids[index[0][:, None, :, None], index[1][None, :, None, :]]
153
+ w = np.einsum("ig,jh->ijgh", directions[0][2][rows], directions[1][2])
154
+ else:
155
+ nodes = ids[index[0][:, None, None, :, None, None],
156
+ index[1][None, :, None, None, :, None],
157
+ index[2][None, None, :, None, None, :]] # fmt: skip
158
+ w = np.einsum("ig,jh,kf->ijkghf", directions[0][2][rows], directions[1][2],
159
+ directions[2][2]) # fmt: skip
160
+ n_el = int(np.prod(nodes.shape[:ndim]))
161
+ nodes = nodes.reshape(n_el, -1)
162
+ w = w.reshape(n_el, -1)
163
+ weight = model.weights[nodes] # elements x functions
164
+ values = _tensor(directions, None, rows) * weight[:, None, :]
165
+ total = values.sum(axis=2)
166
+ values /= total[:, :, None]
167
+ derived = np.empty((*values.shape, ndim))
168
+ for d in range(ndim):
169
+ dn = _tensor(directions, d, rows) * weight[:, None, :]
170
+ derived[..., d] = (dn - values * dn.sum(axis=2)[:, :, None]) / total[:, :, None]
171
+ control = model.nodes[nodes] # elements x functions x dim
172
+ x = np.einsum("eqa,eak->eqk", values, control)
173
+ jac = np.einsum("eqad,eak->eqkd", derived, control)
174
+ det = np.linalg.det(jac)
175
+ gradients = np.einsum("eqad,eqdk->eqak", derived, np.linalg.inv(jac))
176
+ yield Points(k, nodes, w * det, x, values, gradients, det)
177
+
178
+
179
+ def strain_operator(gradients: np.ndarray) -> np.ndarray:
180
+ """The strain operator ``B`` of the gradients of the functions (... x functions x
181
+ dim): ... x strains x (functions dim), in Voigt's notation with engineering shears."""
182
+ *lead, n, dim = gradients.shape
183
+ rows = 3 if dim == 2 else 6
184
+ b = np.zeros((*lead, rows, n, dim))
185
+ if dim == 2:
186
+ b[..., 0, :, 0] = gradients[..., 0]
187
+ b[..., 1, :, 1] = gradients[..., 1]
188
+ b[..., 2, :, 0] = gradients[..., 1]
189
+ b[..., 2, :, 1] = gradients[..., 0]
190
+ else:
191
+ gx, gy, gz = gradients[..., 0], gradients[..., 1], gradients[..., 2]
192
+ b[..., 0, :, 0] = gx
193
+ b[..., 1, :, 1] = gy
194
+ b[..., 2, :, 2] = gz
195
+ b[..., 3, :, 1] = gz
196
+ b[..., 3, :, 2] = gy
197
+ b[..., 4, :, 0] = gz
198
+ b[..., 4, :, 2] = gx
199
+ b[..., 5, :, 0] = gy
200
+ b[..., 5, :, 1] = gx
201
+ return b.reshape(*lead, rows, n * dim)
202
+
203
+
204
+ class Analysis:
205
+ """The discretization of an assembly for a physics (see the module): ``"elastic"``
206
+ (``plane``: ``"strain"`` or ``"stress"`` for surfaces) or ``"conduction"``, with the
207
+ ``materials`` of the phases of its patches (:class:`~morphogen.homogenization.
208
+ materials.Material`, or their matrices); ``extra`` Gauss points per direction beyond
209
+ ``degree + 1``."""
210
+
211
+ def __init__(self, model: Multipatch, materials, *, physics: str = "elastic",
212
+ plane: str = "strain", extra: int = 0): # fmt: skip
213
+ if physics not in PHYSICS:
214
+ raise ValueError(f"physics: one of {PHYSICS}")
215
+ if isinstance(model, Patch):
216
+ model = Multipatch(model)
217
+ self.model = model
218
+ self.physics = physics
219
+ self.plane = plane
220
+ self.extra = int(extra)
221
+ self.dim = model.dim
222
+ #: Unknowns per control point, and components of the gradient-like measure
223
+ self.nd = self.dim if physics == "elastic" else 1
224
+ missing = [p for p in model.phases if p not in materials]
225
+ if missing:
226
+ raise ValueError(f"no material for phase(s) {missing}")
227
+ if physics == "elastic":
228
+ self.matrices = {p: elastic_matrix(materials[p], self.dim, plane) for p in model.phases}
229
+ else:
230
+ self.matrices = {p: conduction_matrix(materials[p], self.dim) for p in model.phases}
231
+ self.n_dofs = self.nd * model.n_nodes
232
+
233
+ # -- the points and their operators ---------------------------------------------------
234
+
235
+ def points(self) -> Iterator[tuple[Points, np.ndarray, np.ndarray, np.ndarray]]:
236
+ """The groups of integration points with their operator ``B`` (strains, or
237
+ gradients: elements x points x components x unknowns of the element), the
238
+ matrix of their material and the unknowns of their elements."""
239
+ for k, patch in enumerate(self.model.patches):
240
+ for pts in patch_points(self.model, k, self.extra):
241
+ if np.any(pts.jacobian <= 0.0):
242
+ raise ValueError(
243
+ f"patch {k}: the Jacobian of its geometry is not positive everywhere "
244
+ "(a patch turned over, or folded)"
245
+ )
246
+ if self.physics == "elastic":
247
+ b = strain_operator(pts.gradients)
248
+ else:
249
+ b = np.swapaxes(pts.gradients, 2, 3)
250
+ dofs = (self.nd * pts.nodes[:, :, None] + np.arange(self.nd)).reshape(
251
+ len(pts.nodes), -1
252
+ )
253
+ yield pts, b, self.matrices[patch.phase], dofs
254
+
255
+ def matrix(self) -> sp.csr_matrix:
256
+ """The stiffness (conductivity) matrix of all the unknowns."""
257
+ rows, cols, values = [], [], []
258
+ for pts, b, d, dofs in self.points():
259
+ ke = np.einsum("eq,eqsi,st,eqtj->eij", pts.weights, b, d, b, optimize=True)
260
+ n = dofs.shape[1]
261
+ rows.append(np.repeat(dofs, n, axis=1).ravel())
262
+ cols.append(np.tile(dofs, (1, n)).ravel())
263
+ values.append(ke.ravel())
264
+ matrix = sp.coo_matrix(
265
+ (np.concatenate(values), (np.concatenate(rows), np.concatenate(cols))),
266
+ shape=(self.n_dofs, self.n_dofs),
267
+ )
268
+ return matrix.tocsr()
269
+
270
+ def measure(self) -> float:
271
+ """The area (volume) of the assembly."""
272
+ return float(sum(pts.weights.sum() for pts, _, _, _ in self.points()))
273
+
274
+ def uniform_loads(self) -> tuple[np.ndarray, np.ndarray]:
275
+ """The nodal forces ``int B^T D E`` of the unit uniform strains (gradients) ``E``
276
+ (unknowns x components), and ``int D`` (components x components)."""
277
+ n = next(iter(self.matrices.values())).shape[0]
278
+ loads = np.zeros((self.n_dofs, n))
279
+ total = np.zeros((n, n))
280
+ for pts, b, d, dofs in self.points():
281
+ fe = np.einsum("eq,eqsi,st->eit", pts.weights, b, d)
282
+ for j in range(n):
283
+ np.add.at(loads[:, j], dofs, fe[:, :, j])
284
+ total += pts.weights.sum() * d
285
+ return loads, total
286
+
287
+ # -- loads ------------------------------------------------------------------------------
288
+
289
+ def side_load(self, patch: int, axis: int, end: int, traction) -> np.ndarray:
290
+ """The nodal forces of a traction (a flux, for conduction) on a side of a
291
+ patch: a vector, or a function ``traction(x, n)`` of the points (points x dim)
292
+ and of the outward unit normals there."""
293
+ p = self.model.patches[patch]
294
+ local = self.model.side_nodes(patch, axis, end)
295
+ f = np.zeros((self.model.n_nodes, self.nd))
296
+ values, x, tangents, w, nodes, params = _side_points(p.side(axis, end), self.extra)
297
+ if self.dim == 2:
298
+ normal = np.stack([tangents[..., 1, 0], -tangents[..., 0, 0]], axis=-1)
299
+ else:
300
+ normal = np.cross(tangents[..., 0], tangents[..., 1])
301
+ size = np.linalg.norm(normal, axis=-1)
302
+ normal = normal / size[..., None]
303
+ # outwards: along the direction of the patch that leaves it through this side
304
+ full = np.insert(params.reshape(-1, p.ndim - 1), axis, p.knots[axis][-end], axis=1)
305
+ leaving = p.jacobian(full)[1][:, :, axis].reshape(x.shape) * (1.0 if end else -1.0)
306
+ normal = normal * np.sign(np.einsum("eqk,eqk->eq", normal, leaving))[..., None]
307
+ if callable(traction):
308
+ t = np.asarray(traction(x.reshape(-1, self.dim), normal.reshape(-1, self.dim)))
309
+ t = t.reshape(*x.shape[:2], self.nd)
310
+ else:
311
+ t = np.broadcast_to(np.asarray(traction, dtype=float), (*x.shape[:2], self.nd))
312
+ fe = np.einsum("eq,eqa,eqc->eac", w * size, values, t)
313
+ np.add.at(f, local[nodes], fe)
314
+ return f.ravel()
315
+
316
+ # -- solution ---------------------------------------------------------------------------
317
+
318
+ def dofs(self, nodes, components=None) -> np.ndarray:
319
+ """The unknowns of control points: all their components, or those given."""
320
+ nodes = np.atleast_1d(np.asarray(nodes, dtype=np.int64))
321
+ components = range(self.nd) if components is None else np.atleast_1d(components)
322
+ return np.concatenate([self.nd * nodes + int(c) for c in components])
323
+
324
+ def solve(self, forces, fixed, values=0.0, matrix=None) -> np.ndarray:
325
+ """The unknowns under nodal ``forces`` with the unknowns ``fixed`` prescribed to
326
+ ``values`` (0 by default)."""
327
+ k = self.matrix() if matrix is None else matrix
328
+ fixed = np.unique(np.asarray(fixed, dtype=np.int64))
329
+ u = np.zeros(self.n_dofs)
330
+ u[fixed] = values
331
+ free = np.setdiff1d(np.arange(self.n_dofs), fixed)
332
+ rhs = np.asarray(forces, dtype=float)[free] - (k[free][:, fixed] @ u[fixed])
333
+ u[free] = spla.spsolve(k[free][:, free].tocsc(), rhs)
334
+ return u
335
+
336
+ # -- fields -----------------------------------------------------------------------------
337
+
338
+ def fields(self, u, counts: int = 4) -> list[dict]:
339
+ """For each patch, on a grid of parameters (``counts`` per element and direction):
340
+ the positions, the unknown and, for the elastic problems, the strains and the
341
+ stresses there (Voigt's notation); for conduction, the gradient and the flux."""
342
+ u = np.asarray(u, dtype=float).reshape(-1, self.nd)
343
+ out = []
344
+ for k, patch in enumerate(self.model.patches):
345
+ params = _grid(patch, counts)
346
+ values, gradients, x = _functions_at(self.model, k, params)
347
+ nodes = self.model.ids[k].ravel()
348
+ d = self.matrices[patch.phase]
349
+ if self.physics == "elastic":
350
+ b = strain_operator(gradients)
351
+ measure = b @ u[nodes].ravel()
352
+ flux = measure @ d.T
353
+ names = ("strain", "stress")
354
+ else:
355
+ measure = np.einsum("mak,a->mk", gradients, u[nodes, 0])
356
+ flux = -measure @ d.T
357
+ names = ("gradient", "flux")
358
+ out.append(
359
+ {
360
+ "x": x,
361
+ "u": values @ u[nodes],
362
+ names[0]: measure,
363
+ names[1]: flux,
364
+ "shape": params.shape[:-1],
365
+ "parameters": params.reshape(-1, patch.ndim),
366
+ }
367
+ )
368
+ return out
369
+
370
+ def at(self, u, patch: int, params) -> dict:
371
+ """The position, the unknown and its measures at parameters of a patch (points x
372
+ ndim), as :meth:`fields`."""
373
+ params = np.atleast_2d(np.asarray(params, dtype=float))
374
+ u = np.asarray(u, dtype=float).reshape(-1, self.nd)
375
+ values, gradients, x = _functions_at(self.model, patch, params)
376
+ nodes = self.model.ids[patch].ravel()
377
+ d = self.matrices[self.model.patches[patch].phase]
378
+ if self.physics == "elastic":
379
+ measure = strain_operator(gradients) @ u[nodes].ravel()
380
+ return {"x": x, "u": values @ u[nodes], "strain": measure, "stress": measure @ d.T}
381
+ measure = np.einsum("mak,a->mk", gradients, u[nodes, 0])
382
+ return {"x": x, "u": values @ u[nodes], "gradient": measure, "flux": -measure @ d.T}
383
+
384
+ def error(self, u, exact: Callable | None = None, exact_stress: Callable | None = None):
385
+ """The errors of a solution against an exact one: ``l2``, the relative error of
386
+ the unknown in the mean square (``exact(x)``: points x unknowns), and ``energy``,
387
+ that of the stresses in the energy norm (``exact_stress(x)``: points x
388
+ components, Voigt's notation); each for the function given."""
389
+ u = np.asarray(u, dtype=float)
390
+ num = den = num_e = den_e = 0.0
391
+ for pts, b, d, dofs in self.points():
392
+ flat = pts.x.reshape(-1, self.dim)
393
+ if exact is not None:
394
+ ref = np.asarray(exact(flat)).reshape(*pts.x.shape[:2], self.nd)
395
+ ue = u[dofs].reshape(len(dofs), -1, self.nd)
396
+ uh = np.einsum("eqa,eac->eqc", pts.values, ue)
397
+ num += float(np.einsum("eq,eqc,eqc->", pts.weights, uh - ref, uh - ref))
398
+ den += float(np.einsum("eq,eqc,eqc->", pts.weights, ref, ref))
399
+ if exact_stress is not None:
400
+ sigma = np.einsum("st,eqti,ei->eqs", d, b, u[dofs])
401
+ ref_s = np.asarray(exact_stress(flat)).reshape(sigma.shape)
402
+ compliance = np.linalg.inv(d)
403
+ diff = sigma - ref_s
404
+ num_e += float(np.einsum("eq,eqs,st,eqt->", pts.weights, diff, compliance, diff))
405
+ den_e += float(np.einsum("eq,eqs,st,eqt->", pts.weights, ref_s, compliance, ref_s))
406
+ out = {}
407
+ if exact is not None:
408
+ out["l2"] = float(np.sqrt(num / den))
409
+ if exact_stress is not None:
410
+ out["energy"] = float(np.sqrt(num_e / den_e))
411
+ return out
412
+
413
+
414
+ def _grid(patch: Patch, counts) -> np.ndarray:
415
+ """A grid of parameters of a patch: ``counts`` per element and direction, the ends
416
+ of the elements included (... x ndim)."""
417
+ axes = []
418
+ for knots in patch.knots:
419
+ ends = bs.breakpoints(knots)
420
+ inside = ends[:-1, None] + np.diff(ends)[:, None] * np.arange(counts)[None, :] / counts
421
+ axes.append(np.append(inside.ravel(), ends[-1]))
422
+ return np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1)
423
+
424
+
425
+ def _functions_at(model: Multipatch, k: int, params):
426
+ """The rational functions of all the control points of patch ``k`` and their
427
+ gradients at parameters (points x functions (x dim)), and the positions."""
428
+ patch = model.patches[k]
429
+ params = np.asarray(params, dtype=float).reshape(-1, patch.ndim)
430
+ letters = "abc"[: patch.ndim]
431
+ spec = ",".join(f"m{c}" for c in letters) + f"->m{letters}"
432
+ weight = patch.weights.ravel()
433
+
434
+ def product(which):
435
+ matrices = [
436
+ bs.collocation(patch.knots[d], patch.degrees[d], params[:, d], int(d == which))
437
+ for d in range(patch.ndim)
438
+ ]
439
+ return np.einsum(spec, *matrices).reshape(len(params), -1) * weight[None, :]
440
+
441
+ values = product(None)
442
+ total = values.sum(axis=1)
443
+ values /= total[:, None]
444
+ derived = np.empty((*values.shape, patch.ndim))
445
+ for d in range(patch.ndim):
446
+ dn = product(d)
447
+ derived[..., d] = (dn - values * dn.sum(axis=1)[:, None]) / total[:, None]
448
+ control = model.nodes[model.ids[k].ravel()]
449
+ x = values @ control
450
+ jac = np.einsum("mad,ak->mkd", derived, control)
451
+ gradients = np.einsum("mad,mdk->mak", derived, np.linalg.inv(jac))
452
+ return values, gradients, x
453
+
454
+
455
+ def _side_points(side: Patch, extra: int):
456
+ """The integration points of a side (a curve or a surface in a space of one more
457
+ dimension): the functions (elements x points x functions), the positions, the
458
+ tangents (elements x points x dim x ndim), the weights of the points, the control
459
+ points of the elements (indices in the raveled side) and the parameters of the
460
+ points (elements x points x ndim)."""
461
+ directions = _directions(side, extra)
462
+ ids = np.arange(side.weights.size).reshape(side.shape)
463
+ parameters = []
464
+ for knots, degree in zip(side.knots, side.degrees, strict=True):
465
+ ends = bs.breakpoints(knots)
466
+ points, _ = bs.gauss(degree + 1 + extra)
467
+ parameters.append(ends[:-1, None] + np.diff(ends)[:, None] * points[None, :])
468
+ if side.ndim == 1:
469
+ n, dn, w, index = directions[0]
470
+ nodes = ids[index]
471
+ values, derived = n.copy(), dn[..., None].copy()
472
+ params = parameters[0][..., None]
473
+ else:
474
+ rows = np.arange(len(directions[0][2]))
475
+ index = [d[3] for d in directions]
476
+ nodes = ids[index[0][:, None, :, None], index[1][None, :, None, :]]
477
+ nodes = nodes.reshape(-1, nodes.shape[2] * nodes.shape[3])
478
+ w = np.einsum("ig,jh->ijgh", directions[0][2], directions[1][2]).reshape(len(nodes), -1)
479
+ values = _tensor(directions, None, rows)
480
+ derived = np.stack([_tensor(directions, d, rows) for d in range(2)], axis=-1)
481
+ first = np.broadcast_to(parameters[0][:, None, :, None],
482
+ (len(parameters[0]), len(parameters[1]),
483
+ parameters[0].shape[1], parameters[1].shape[1])) # fmt: skip
484
+ second = np.broadcast_to(parameters[1][None, :, None, :], first.shape)
485
+ params = np.stack([first, second], axis=-1).reshape(len(nodes), -1, 2)
486
+ weight = side.weights.ravel()[nodes]
487
+ values = values * weight[:, None, :]
488
+ total = values.sum(axis=2)
489
+ values /= total[:, :, None]
490
+ for d in range(side.ndim):
491
+ dn = derived[..., d] * weight[:, None, :]
492
+ derived[..., d] = (dn - values * dn.sum(axis=2)[:, :, None]) / total[:, :, None]
493
+ control = side.points.reshape(-1, side.dim)[nodes]
494
+ x = np.einsum("eqa,eak->eqk", values, control)
495
+ tangents = np.einsum("eqad,eak->eqkd", derived, control)
496
+ return values, x, tangents, w, nodes, params
497
+
498
+
499
+ __all__ = [
500
+ "PHYSICS",
501
+ "PLANES",
502
+ "Analysis",
503
+ "Points",
504
+ "conduction_matrix",
505
+ "elastic_matrix",
506
+ "patch_points",
507
+ "strain_operator",
508
+ ]