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,577 @@
1
+ """The nonuniform transformation field analysis (NTFA; Michel & Suquet 2003, 2004): a
2
+ reduced model of the nonlinear response of a periodic voxel microstructure.
3
+
4
+ The plastic strain of each plastic phase ``r`` is sought as a combination of a few
5
+ modes, ``eps_p(x) = sum_k xi_k mu_k(x)`` (``k`` among the modes of ``r``, zero outside
6
+ it). Offline (:func:`train_ntfa`), full-field simulations along training paths (the
7
+ voxel solver of :class:`~morphogen.homogenization.fft_nonlinear.NonlinearFFTProblem`,
8
+ full integration) give snapshots of the plastic strain fields, and the modes are their
9
+ proper orthogonal decomposition phase by phase, orthogonal and normalized so that
10
+ ``<mu_k : mu_k>_r = 3/2``. Linear elastic solves on the same voxels give the strain
11
+ fields ``A_j`` of the unit macroscopic strains and ``D_k`` of the modes taken as
12
+ eigenstrains, so that ``eps(x) = A(x) E + sum_k D_k(x) xi_k`` and, with
13
+ ``sigma = C (eps - eps_p)``, the macroscopic stress and the reduced (generalized)
14
+ stresses ``tau_k = <sigma : mu_k>_r`` are affine in ``E`` and ``xi``:
15
+
16
+ Sigma = L E + sum_k rho_k xi_k, tau = a E + d xi.
17
+
18
+ Online (:meth:`NTFAModel.run`), the reduced variables follow the law of their phase
19
+ written for them (the von Mises model of Lemaitre & Chaboche with isotropic hardening):
20
+ ``f_r = ||tau_r|| - R0 - R(p_r)``, ``dxi_r = dp_r tau_r / ||tau_r||``, ``p_r`` the
21
+ cumulated reduced plastic strain, with the consistency condition ``f_r = 0``
22
+ (rate-independent plasticity) or Norton's flow ``dp_r/dt = <f_r / K>^N``; for one
23
+ uniform mode this is exactly the law of the phase. Each step is integrated implicitly
24
+ (backward Euler) by Newton iterations on a few unknowns, with strain, stress or mixed
25
+ control, without any field computation.
26
+ """
27
+
28
+ from __future__ import annotations
29
+
30
+ import dataclasses
31
+ import time
32
+
33
+ import numpy as np
34
+
35
+ from morphogen.homogenization import kernels
36
+ from morphogen.homogenization.behaviours import Plasticity
37
+ from morphogen.homogenization.fft import FFTElasticProblem
38
+ from morphogen.homogenization.materials import Material
39
+ from morphogen.homogenization.paths import LoadingPath, PathResult
40
+ from morphogen.image import VoxelImage
41
+
42
+ #: Tensor to engineering strain components (Voigt 11 22 33 23 31 12).
43
+ SHEAR = np.array([1.0, 1.0, 1.0, 2.0, 2.0, 2.0])
44
+ #: Weights of the double contraction of two engineering strains.
45
+ WEIGHTS = np.array([1.0, 1.0, 1.0, 0.5, 0.5, 0.5])
46
+
47
+
48
+ def _contract(a: np.ndarray, b: np.ndarray) -> np.ndarray:
49
+ """``a : b`` of engineering strain fields (last axis: Voigt)."""
50
+ return np.sum(a * b * WEIGHTS, axis=-1)
51
+
52
+
53
+ @dataclasses.dataclass
54
+ class NTFAModel:
55
+ """Reduced model of a microstructure: the modes of its plastic phases and the
56
+ affine relations ``Sigma = L E + rho^T xi`` and ``tau = a E + d xi`` (Voigt,
57
+ engineering strains)."""
58
+
59
+ stiffness: np.ndarray # L, 6 x 6
60
+ rho: np.ndarray # modes x 6
61
+ a: np.ndarray # modes x 6
62
+ d: np.ndarray # modes x modes
63
+ mode_phase: np.ndarray # the phase of each mode
64
+ plasticity: dict # phase -> Plasticity
65
+ fractions: dict # phase -> volume fraction
66
+ energy: dict = dataclasses.field(default_factory=dict) # phase -> captured POD energy
67
+ modes: np.ndarray | None = dataclasses.field(default=None, repr=False) # modes x voxels x 6
68
+ shape: tuple = ()
69
+ #: for the local fields: the strain fields of the unit strains (6 x voxels x 6) and of
70
+ #: the modes (modes x voxels x 6), the stiffness of each voxel
71
+ #: the mean stress and strain of each phase: ``phase -> (stress of E (6 x 6), of xi
72
+ #: (modes x 6), strain of E, of xi)``
73
+ phase_means: dict = dataclasses.field(default_factory=dict, repr=False)
74
+ unit_fields: np.ndarray | None = dataclasses.field(default=None, repr=False)
75
+ mode_fields: np.ndarray | None = dataclasses.field(default=None, repr=False)
76
+ voxel_stiffness: np.ndarray | None = dataclasses.field(default=None, repr=False)
77
+
78
+ @property
79
+ def n_modes(self) -> int:
80
+ return len(self.mode_phase)
81
+
82
+ def plastic_strain(self, xi) -> np.ndarray:
83
+ """The plastic strain field (voxels x 6, engineering) of the reduced variables."""
84
+ if self.modes is None:
85
+ raise ValueError("the modes were not kept (train_ntfa(..., keep_modes=True))")
86
+ return np.tensordot(np.asarray(xi, dtype=float), self.modes, axes=1)
87
+
88
+ # -- online integration ---------------------------------------------------------------
89
+ def _phase_slices(self):
90
+ return {r: np.flatnonzero(self.mode_phase == r) for r in self.plasticity}
91
+
92
+ def run(self, path, *, name: str = "ntfa") -> PathResult:
93
+ """Macroscopic response along a loading path (:class:`LoadingPath`, or a mapping
94
+ for :meth:`LoadingPath.from_spec`); strain, stress or mixed control, no change
95
+ of temperature."""
96
+ path = LoadingPath.from_spec(path)
97
+ if np.any(np.asarray(path.temperature) != 0):
98
+ raise ValueError("NTFA: no change of temperature")
99
+ t0 = time.perf_counter()
100
+ controls = path.strain_controlled
101
+ free = np.flatnonzero(~controls)
102
+ groups = self._phase_slices()
103
+ xi = np.zeros(self.n_modes)
104
+ p = dict.fromkeys(self.plasticity, 0.0)
105
+ x = {
106
+ r: [np.zeros(groups[r].size) for _ in law.kinematic]
107
+ for r, law in self.plasticity.items()
108
+ }
109
+ e = np.zeros(6)
110
+ times, strains, stresses, plastics, iterations = (
111
+ [path.times[0]],
112
+ [e.copy()],
113
+ [np.zeros(6)],
114
+ [0.0],
115
+ [],
116
+ )
117
+ phase_p = {r: [0.0] for r in self.plasticity}
118
+ phase_states = [(e.copy(), xi.copy())]
119
+ t_old = path.times[0]
120
+ for t in path.schedule():
121
+ values, _ = path.at(t)
122
+ e, xi, p, x, its = self._step(values, controls, free, e, xi, p, x, t - t_old, groups)
123
+ t_old = t
124
+ times.append(t)
125
+ strains.append(e.copy())
126
+ stresses.append(self.stiffness @ e + self.rho.T @ xi)
127
+ plastics.append(sum(self.fractions[r] * p[r] for r in self.plasticity))
128
+ for r in self.plasticity:
129
+ phase_p[r].append(p[r])
130
+ phase_states.append((e.copy(), xi.copy()))
131
+ iterations.append(its)
132
+ phases = {}
133
+ for r, (ls, rs, le, rd) in self.phase_means.items():
134
+ phases[r] = {
135
+ "stress": np.array([ls @ ee + rs.T @ xx for ee, xx in phase_states]),
136
+ "strain": np.array([le @ ee + rd.T @ xx for ee, xx in phase_states]),
137
+ "plastic": np.asarray(phase_p.get(r, [0.0] * len(phase_states))),
138
+ }
139
+ return PathResult(
140
+ name=name,
141
+ bc="ntfa",
142
+ path=path,
143
+ times=np.asarray(times),
144
+ strain=np.asarray(strains),
145
+ stress=np.asarray(stresses),
146
+ temperature=np.zeros(len(times)),
147
+ plastic=np.asarray(plastics),
148
+ phases=phases,
149
+ iterations=np.asarray(iterations, dtype=int),
150
+ info={"solver": "ntfa", "modes": self.n_modes, "time_s": time.perf_counter() - t0},
151
+ )
152
+
153
+ def _step(self, values, controls, free, e_old, xi_old, p_old, x_old, dt, groups):
154
+ """One backward Euler step: the reduced variables, the cumulated reduced plastic
155
+ strains, the reduced backstresses and the free macroscopic strains, by Newton's
156
+ method (analytic Jacobian, backtracking) over the active plastic phases, the set
157
+ of which is corrected until consistent. ``x_old``: phase -> list of the reduced
158
+ backstresses of its kinematic terms (vectors over its modes)."""
159
+ m, nf = self.n_modes, free.size
160
+ known = np.where(controls, values, 0.0)
161
+ y_ref = max(law.yield_stress for law in self.plasticity.values()) or 1.0
162
+ e_ref = y_ref / float(np.abs(self.stiffness).max())
163
+
164
+ def split(y, active):
165
+ na = len(active)
166
+ return y[:m], y[m : m + na], y[m + na :]
167
+
168
+ def increment(law, q):
169
+ """``dp`` and ``d dp / dq`` of the unknown ``q`` of a phase: ``dp`` itself, or
170
+ the viscous overstress ``K (dp/dt)^(1/N)``."""
171
+ if not law.viscous:
172
+ return q, 1.0
173
+ qq = max(q, 0.0)
174
+ ratio = qq / law.viscosity
175
+ return dt * ratio**law.exponent, dt * law.exponent * ratio ** (
176
+ law.exponent - 1.0
177
+ ) / law.viscosity
178
+
179
+ def backstress(r, dxi_r, dp):
180
+ """Armstrong-Frederick backstresses at the end of the step, their sum, and the
181
+ derivatives of the sum by the increments of the reduced variables (a scalar
182
+ times the identity) and by ``dp``."""
183
+ terms, total = [], np.zeros(dxi_r.size)
184
+ slope, by_dp = 0.0, np.zeros(dxi_r.size)
185
+ for (c, d_k), x0 in zip(self.plasticity[r].kinematic, x_old[r], strict=True):
186
+ factor = 1.0 / (1.0 + d_k * dp)
187
+ x = (x0 + c * dxi_r) * factor
188
+ terms.append(x)
189
+ total = total + x
190
+ slope += c * factor
191
+ by_dp = by_dp - d_k * factor * x
192
+ return terms, total, slope, by_dp
193
+
194
+ def system(y, active):
195
+ dxi, q, ef = split(y, active)
196
+ e = known.copy()
197
+ e[free] = ef
198
+ xi = xi_old + dxi
199
+ tau = self.a @ e + self.d @ xi
200
+ n_a = len(active)
201
+ res = np.zeros(m + n_a + nf)
202
+ jac = np.zeros((m + n_a + nf, m + n_a + nf))
203
+ res[:m] = dxi
204
+ jac[:m, :m] = np.eye(m)
205
+ for i, r in enumerate(active):
206
+ idx = groups[r]
207
+ law = self.plasticity[r]
208
+ dp, ddp = increment(law, q[i])
209
+ _, x, slope, x_dp = backstress(r, dxi[idx], dp)
210
+ z = tau[idx] - x
211
+ norm = float(np.linalg.norm(z))
212
+ n = z / norm
213
+ dn = (np.eye(idx.size) - np.outer(n, n)) / norm
214
+ dz = self.d[idx].copy() # d z / d dxi
215
+ dz[:, idx] -= slope * np.eye(idx.size)
216
+ dz_dq = -x_dp * ddp # d z / d q
217
+ res[idx] = dxi[idx] - dp * n
218
+ jac[np.ix_(idx, np.arange(m))] -= dp * dn @ dz
219
+ jac[idx, m + i] = -ddp * n - dp * dn @ dz_dq
220
+ if nf:
221
+ jac[np.ix_(idx, m + n_a + np.arange(nf))] = -dp * dn @ self.a[np.ix_(idx, free)]
222
+ p = p_old[r] + dp
223
+ row = m + i
224
+ visc = q[i] if law.viscous else 0.0
225
+ res[row] = (norm - law.yield_stress - _hardening(law, p) - visc) / y_ref
226
+ jac[row, :m] = n @ dz / y_ref
227
+ jac[row, m + i] = (
228
+ n @ dz_dq - _slope(law, p) * ddp - (1.0 if law.viscous else 0.0)
229
+ ) / y_ref
230
+ if nf:
231
+ jac[row, m + n_a :] = n @ self.a[np.ix_(idx, free)] / y_ref
232
+ if nf:
233
+ sigma = self.stiffness @ e + self.rho.T @ xi
234
+ rows = m + n_a + np.arange(nf)
235
+ res[rows] = (sigma[free] - values[free]) / y_ref
236
+ jac[np.ix_(rows, np.arange(m))] = self.rho[:, free].T / y_ref
237
+ jac[np.ix_(rows, rows)] = self.stiffness[np.ix_(free, free)] / y_ref
238
+ res[:m] /= e_ref
239
+ jac[:m] /= e_ref
240
+ return res, jac
241
+
242
+ def newton(y, active):
243
+ res, jac = system(y, active)
244
+ norm = float(np.linalg.norm(res))
245
+ for it in range(100):
246
+ if norm <= 1e-11:
247
+ return y, it
248
+ step = np.linalg.solve(jac, -res)
249
+ t = 1.0
250
+ while True:
251
+ trial = y + t * step
252
+ r_t, j_t = system(trial, active)
253
+ n_t = float(np.linalg.norm(r_t))
254
+ if n_t < (1.0 - 1e-4 * t) * norm or t < 1e-6:
255
+ break
256
+ t *= 0.5
257
+ y, res, jac, norm = trial, r_t, j_t, n_t
258
+ raise RuntimeError(f"NTFA: Newton's method did not converge (residual {norm:.2e})")
259
+
260
+ # elastic trial: frozen plastic strains, the free macroscopic strains solved
261
+ ef = e_old[free].copy()
262
+ if nf:
263
+ rhs = values[free] - (self.stiffness @ known + self.rho.T @ xi_old)[free]
264
+ ef = np.linalg.solve(self.stiffness[np.ix_(free, free)], rhs)
265
+
266
+ def overstress(e, xi, r):
267
+ law = self.plasticity[r]
268
+ tau = self.a @ e + self.d @ xi
269
+ x = sum(x_old[r]) if x_old[r] else 0.0
270
+ return (
271
+ float(np.linalg.norm(tau[groups[r]] - x))
272
+ - law.yield_stress
273
+ - _hardening(law, p_old[r])
274
+ )
275
+
276
+ e = known.copy()
277
+ e[free] = ef
278
+ active = [r for r in groups if overstress(e, xi_old, r) > 1e-10 * y_ref]
279
+ iterations = 0
280
+ for _ in range(2 * len(groups) + 2):
281
+ y = np.concatenate([np.zeros(m), np.zeros(len(active)), ef])
282
+ if active:
283
+ y, its = newton(y, active)
284
+ iterations += its
285
+ dxi, q, ef_new = split(y, active)
286
+ e = known.copy()
287
+ e[free] = ef_new
288
+ xi = xi_old + dxi
289
+ changed = False
290
+ for i, r in enumerate(list(active)):
291
+ if q[i] < 0.0: # unloading: elastic
292
+ active.remove(r)
293
+ changed = True
294
+ for r in groups:
295
+ if r not in active and overstress(e, xi, r) > 1e-8 * y_ref:
296
+ active.append(r)
297
+ changed = True
298
+ if not changed:
299
+ p_new, x_new = dict(p_old), dict(x_old)
300
+ for i, r in enumerate(active):
301
+ dp = increment(self.plasticity[r], q[i])[0]
302
+ p_new[r] = p_old[r] + dp
303
+ x_new[r] = backstress(r, dxi[groups[r]], dp)[0]
304
+ return e, xi, p_new, x_new, iterations
305
+ ef = ef_new
306
+ raise RuntimeError("NTFA: no consistent set of plastic phases in the step")
307
+
308
+ def local_fields(self, strain, xi) -> dict[str, np.ndarray]:
309
+ """Strain and stress fields (voxels x 6; engineering strains, Voigt stresses) of
310
+ the macroscopic strain ``strain`` and the reduced variables ``xi`` (trained with
311
+ ``keep_fields=True``)."""
312
+ if self.unit_fields is None:
313
+ raise ValueError(
314
+ "the influence fields were not kept (train_ntfa(..., keep_fields=True))"
315
+ )
316
+ eps = np.tensordot(np.asarray(strain, float), self.unit_fields, axes=1)
317
+ eps = eps + np.tensordot(np.asarray(xi, float), self.mode_fields, axes=1)
318
+ plastic = self.plastic_strain(xi)
319
+ return {
320
+ "strain": eps,
321
+ "plastic_strain": plastic,
322
+ "stress": np.einsum("nij,nj->ni", self.voxel_stiffness, eps - plastic),
323
+ }
324
+
325
+ # -- storage ----------------------------------------------------------------------------
326
+ def save(self, path) -> None:
327
+ """The reduced model (without the modes) in a ``.npz`` file."""
328
+ laws = {
329
+ str(r): [
330
+ law.yield_stress,
331
+ law.hardening,
332
+ np.nan if law.viscosity is None else law.viscosity,
333
+ np.nan if law.exponent is None else law.exponent,
334
+ ]
335
+ for r, law in self.plasticity.items()
336
+ }
337
+ iso = {
338
+ str(r): np.asarray(law.isotropic, dtype=float).reshape(-1, 2)
339
+ for r, law in self.plasticity.items()
340
+ }
341
+ kin = {
342
+ str(r): np.asarray(law.kinematic, dtype=float).reshape(-1, 2)
343
+ for r, law in self.plasticity.items()
344
+ }
345
+ np.savez(
346
+ path,
347
+ stiffness=self.stiffness,
348
+ rho=self.rho,
349
+ a=self.a,
350
+ d=self.d,
351
+ mode_phase=self.mode_phase,
352
+ phases=np.array(sorted(self.plasticity), dtype=int),
353
+ laws=np.array([laws[str(r)] for r in sorted(self.plasticity)]),
354
+ fractions=np.array([self.fractions[r] for r in sorted(self.plasticity)]),
355
+ **{f"iso_{k}": v for k, v in iso.items()},
356
+ **{f"kin_{k}": v for k, v in kin.items()},
357
+ )
358
+
359
+ @classmethod
360
+ def load(cls, path) -> NTFAModel:
361
+ data = np.load(path)
362
+ plasticity, fractions = {}, {}
363
+ for r, law, frac in zip(data["phases"], data["laws"], data["fractions"], strict=True):
364
+ r = int(r)
365
+ visc = None if np.isnan(law[2]) else float(law[2])
366
+ expo = None if np.isnan(law[3]) else float(law[3])
367
+ iso = tuple(map(tuple, data[f"iso_{r}"])) if f"iso_{r}" in data else ()
368
+ kin = tuple(map(tuple, data[f"kin_{r}"])) if f"kin_{r}" in data else ()
369
+ plasticity[r] = Plasticity(float(law[0]), float(law[1]), iso, kin, visc, expo)
370
+ fractions[r] = float(frac)
371
+ return cls(
372
+ data["stiffness"],
373
+ data["rho"],
374
+ data["a"],
375
+ data["d"],
376
+ data["mode_phase"],
377
+ plasticity,
378
+ fractions,
379
+ )
380
+
381
+
382
+ def _hardening(law: Plasticity, p: float) -> float:
383
+ r = law.hardening * p
384
+ for q, b in law.isotropic:
385
+ r += q * (1.0 - np.exp(-b * p))
386
+ return float(r)
387
+
388
+
389
+ def _slope(law: Plasticity, p: float) -> float:
390
+ h = law.hardening
391
+ for q, b in law.isotropic:
392
+ h += q * b * np.exp(-b * p)
393
+ return float(h)
394
+
395
+
396
+ def _influence(
397
+ problem: FFTElasticProblem, eigen: np.ndarray | None, macro: np.ndarray
398
+ ) -> np.ndarray:
399
+ """Mean strain of each voxel (engineering) of the periodic elastic solution for the
400
+ macroscopic strain ``macro`` and the eigenstrain field ``eigen`` (voxels x 6)."""
401
+ nx, ny, nz = problem.shape
402
+ el = problem.element
403
+ if eigen is None:
404
+ w, _ = problem._field(macro, 0.0)
405
+ else:
406
+ n = nx * ny * nz
407
+ mat = problem.mat
408
+ c = problem.table.matrices[np.maximum(mat, 0)]
409
+ sig = np.einsum("nij,nj->ni", c, eigen)
410
+ sig[mat < 0] = 0.0
411
+ loads = -el.weight * np.einsum("grc,nr->nc", el.b_gauss, sig)
412
+ index = np.where(mat >= 0, np.arange(n), -1)
413
+ dof = np.arange(3 * n, dtype=np.int64)
414
+ rhs = kernels.element_load(
415
+ nx, ny, nz, True, index, dof, 3, np.ascontiguousarray(loads), dof.size
416
+ )
417
+ rhs = rhs + _macro_load(problem, macro)
418
+ scale = float(np.sqrt(np.sum(loads * loads))) or 1.0
419
+ w, _ = problem._solve(rhs, scale)
420
+ strain, _, _ = kernels.elastic_fields(
421
+ nx,
422
+ ny,
423
+ nz,
424
+ True,
425
+ problem.mat,
426
+ problem.table.matrices,
427
+ problem.table.eigen,
428
+ 0.0,
429
+ w,
430
+ el.affine_displacement(macro),
431
+ el.b_mean,
432
+ el.b_gauss,
433
+ )
434
+ return np.nan_to_num(strain) * SHEAR
435
+
436
+
437
+ def _macro_load(problem: FFTElasticProblem, macro: np.ndarray) -> np.ndarray:
438
+ if not np.any(macro):
439
+ return 0.0
440
+ nx, ny, nz = problem.shape
441
+ loads = np.ascontiguousarray(
442
+ problem.element_matrices @ problem.element.affine_displacement(macro)
443
+ )
444
+ dof = np.arange(3 * nx * ny * nz, dtype=np.int64)
445
+ return kernels.element_load(nx, ny, nz, True, problem.mat, dof, 3, loads, dof.size)
446
+
447
+
448
+ def train_ntfa(
449
+ image: VoxelImage,
450
+ materials: dict[int, Material],
451
+ paths,
452
+ *,
453
+ modes=4,
454
+ tol: float = 1e-8,
455
+ newton_tol: float = 1e-6,
456
+ keep_modes: bool = True,
457
+ keep_fields: bool = False,
458
+ snapshots: list | None = None,
459
+ normalization: str = "mean",
460
+ ) -> NTFAModel:
461
+ """Reduced model of a periodic voxel image: snapshots of the plastic strain fields
462
+ along the training ``paths`` (full-field simulations, :class:`NonlinearFFTProblem`
463
+ with full integration, at the end of every step), their POD in each plastic phase
464
+ (``modes``: the number of modes, or a mapping phase -> number), and the elastic
465
+ influence fields of the unit strains and of the modes (FFT solves). ``snapshots``:
466
+ plastic strain fields already computed (voxels x 6, tensor components), used
467
+ instead of the paths."""
468
+ from morphogen.homogenization.fft_nonlinear import NonlinearFFTProblem
469
+
470
+ if not image.periodic:
471
+ raise ValueError("NTFA: a periodic voxel image")
472
+ labels = np.asarray(image.data).ravel()
473
+ plastic = {
474
+ int(r): m.plasticity
475
+ for r, m in materials.items()
476
+ if m.plasticity is not None and np.any(labels == r)
477
+ }
478
+ for r, m in materials.items(): # not elastic phases in disguise
479
+ if m.porous and np.any(labels == r):
480
+ raise ValueError(
481
+ f"NTFA: phase {r}: porous plasticity (its porosity and backstresses) is not "
482
+ "reduced: isotropic von Mises phases only"
483
+ )
484
+ if not plastic:
485
+ raise ValueError("NTFA: no plastic phase in the image")
486
+ for r in plastic:
487
+ if materials[r].stiffness is not None or materials[r].crystal_plasticity is not None:
488
+ raise ValueError(f"NTFA: phase {r}: isotropic von Mises phases only")
489
+ if materials[r].damage is not None:
490
+ raise ValueError(f"NTFA: phase {r}: the damage of a plastic phase is not reduced")
491
+ if materials[r].plasticity.hill is not None:
492
+ raise ValueError(f"NTFA: phase {r}: von Mises phases only (not Hill's criterion)")
493
+ if snapshots is None:
494
+ snapshots = []
495
+ for path in paths:
496
+ problem = NonlinearFFTProblem(
497
+ image, materials, "periodic", tol=tol, newton_tol=newton_tol, integration="full"
498
+ )
499
+ path = LoadingPath.from_spec(path)
500
+ result = problem.run(path, fields=[float(t) for t in path.schedule()])
501
+ for t in sorted(result.fields):
502
+ snapshots.append(np.asarray(result.fields[t]["plastic_strain"]).reshape(-1, 6))
503
+ snaps = np.stack([np.nan_to_num(s) * SHEAR for s in snapshots], axis=-1) # voxels x 6 x S
504
+ counts = {r: int(np.sum(labels == r)) for r in plastic}
505
+ n_modes = modes if isinstance(modes, dict) else dict.fromkeys(plastic, int(modes))
506
+ field_modes, mode_phase, energy = [], [], {}
507
+ root_w = np.sqrt(WEIGHTS)[None, :, None]
508
+ for r in sorted(plastic):
509
+ sel = labels == r
510
+ x = (snaps[sel] * root_w).reshape(-1, snaps.shape[-1])
511
+ u, s, _ = np.linalg.svd(x, full_matrices=False)
512
+ keep = int(min(n_modes.get(r, 0), np.sum(s > 1e-10 * s[0]) if s.size and s[0] > 0 else 0))
513
+ energy[r] = float(np.sum(s[:keep] ** 2) / np.sum(s**2)) if keep else 0.0
514
+ for k in range(keep):
515
+ mode = np.zeros((labels.size, 6))
516
+ values = u[:, k].reshape(-1, 6) / np.sqrt(WEIGHTS)
517
+ if normalization == "mean": # Michel & Suquet: <mu_eq>_r = 1
518
+ equivalent = np.sqrt(2.0 / 3.0 * _contract(values, values))
519
+ values = values / equivalent.mean()
520
+ else: # <mu : mu>_r = 3/2
521
+ values = values * np.sqrt(1.5 * counts[r])
522
+ mode[sel] = values
523
+ field_modes.append(mode)
524
+ mode_phase.append(r)
525
+ if not field_modes:
526
+ raise ValueError("NTFA: the training paths stay elastic (no plastic strain to reduce)")
527
+ mode_phase = np.asarray(mode_phase)
528
+ linear = FFTElasticProblem(image, materials, "periodic", tol=min(tol, 1e-10))
529
+ mat = linear.mat
530
+ c = linear.table.matrices[np.maximum(mat, 0)]
531
+ c[mat < 0] = 0.0
532
+ unit_strains = [_influence(linear, None, np.eye(6)[j]) for j in range(6)]
533
+ stress_e = [np.einsum("nij,nj->ni", c, a) for a in unit_strains]
534
+ stiffness = np.stack([s.mean(axis=0) for s in stress_e], axis=1)
535
+ m = len(field_modes)
536
+ rho = np.zeros((m, 6))
537
+ a_red = np.zeros((m, 6))
538
+ d_red = np.zeros((m, m))
539
+ stress_m = []
540
+ mode_strains = []
541
+ for mode in field_modes:
542
+ strain = _influence(linear, mode, np.zeros(6))
543
+ mode_strains.append(strain)
544
+ stress_m.append(np.einsum("nij,nj->ni", c, strain - mode))
545
+ for k, mode in enumerate(field_modes):
546
+ n_r = counts[int(mode_phase[k])]
547
+ rho[k] = stress_m[k].mean(axis=0)
548
+ for j in range(6):
549
+ a_red[k, j] = np.sum(stress_e[j] * mode) / n_r # stress . engineering strain
550
+ for ell in range(m):
551
+ d_red[k, ell] = np.sum(stress_m[ell] * mode) / n_r
552
+ fractions = {r: counts[r] / labels.size for r in plastic}
553
+ phase_means = {}
554
+ for r in np.unique(labels[mat >= 0]):
555
+ sel = labels == r
556
+ phase_means[int(r)] = (
557
+ np.stack([s[sel].mean(axis=0) for s in stress_e], axis=1),
558
+ np.array([s[sel].mean(axis=0) for s in stress_m]),
559
+ np.stack([a[sel].mean(axis=0) for a in unit_strains], axis=1),
560
+ np.array([d[sel].mean(axis=0) for d in mode_strains]),
561
+ )
562
+ return NTFAModel(
563
+ stiffness=stiffness,
564
+ rho=rho,
565
+ a=a_red,
566
+ d=d_red,
567
+ mode_phase=mode_phase,
568
+ plasticity=plastic,
569
+ fractions=fractions,
570
+ energy=energy,
571
+ phase_means=phase_means,
572
+ modes=np.stack(field_modes) if keep_modes or keep_fields else None,
573
+ shape=tuple(image.shape),
574
+ unit_fields=np.stack(unit_strains) if keep_fields else None,
575
+ mode_fields=np.stack(mode_strains) if keep_fields else None,
576
+ voxel_stiffness=c if keep_fields else None,
577
+ )