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,668 @@
1
+ // The learned laws of morphoGen (morphogen.learning) in the MFront sources of
2
+ // morphogen.learning.mfront: ports, line by line, of the forward passes of the models and of
3
+ // their consistent tangents (networks.py: FeedForward, Potential, Recurrent; standard.py:
4
+ // Standard, its Newton solve of the incremental potential), in the normalized variables of
5
+ // the models. NumPy and Numba are the reference: a change of a model is made in both, and
6
+ // tests/test_learning_mfront.py compares them through MFront and MGIS.
7
+ //
8
+ // The source prepends the sizes and the trained parameters of its model (constexpr in the
9
+ // namespace of the behaviour: SCALE_STRAIN, SCALE_STRESS, SCALE_INCREMENT, SCALE_TIME, then
10
+ // those of its kind) and takes the common part of this file and the section of its kind
11
+ // (from "// ---- <kind>" to the next).
12
+ //
13
+ // Components: morphoGen's Voigt order 11, 22, 33, 23, 31, 12, engineering shears of the
14
+ // strains, in every array of this file (the trained parameters are those of the models);
15
+ // the source turns TFEL's components (11, 22, 33, then sqrt(2) times 12, 13, 23) to them
16
+ // and back.
17
+ //
18
+ // Every law is
19
+ // int law(const double* e1, const double* e0, const double* s0, double dt,
20
+ // double* sig, double* tan, double* s1)
21
+ // e1 and e0: the strains that the model sees at the end and at the start of the step (6:
22
+ // the small strain, the logarithmic strain 1/2 ln C or the Green-Lagrange strain, without
23
+ // the thermal strain, in the axes of the material); s0: the state of the model at the start
24
+ // of the step (its internal variables); dt: the time step. On return: sig, the stress (6:
25
+ // that conjugate to the strain the model sees), tan, its derivative with respect to e1 (6 x
26
+ // 6, row by row; engineering shears), s1, the state at the end; 0, or 1 where the stress or
27
+ // its tangent is not finite (a failed point, as in morphoGen).
28
+
29
+ // ---- common
30
+
31
+ inline double sigmoid(double x) { return 0.5 * (1.0 + std::tanh(0.5 * x)); }
32
+
33
+ inline int finite_values(const double* sig, const double* tan) {
34
+ for (int i = 0; i != 6; ++i) {
35
+ if (!std::isfinite(sig[i])) {
36
+ return 1;
37
+ }
38
+ }
39
+ for (int i = 0; i != 36; ++i) {
40
+ if (!std::isfinite(tan[i])) {
41
+ return 1;
42
+ }
43
+ }
44
+ return 0;
45
+ }
46
+
47
+ // ---- feedforward
48
+ // y = L x + Wout z_K + bout, z_{k+1} = tanh(W_k z_k + b_k), z_0 = x (FeedForward._output),
49
+ // and its Jacobian forward through the layers (FeedForward._jacobian). Constants: N_LAYERS,
50
+ // SIZES, WIDEST, W (the hidden weights W_k, out x in, layer after layer), B (their biases),
51
+ // WOUT (6 x SIZES[N_LAYERS - 1]), BOUT (6), LIN (6 x 6).
52
+
53
+ inline int law(const double* e1, const double*, const double*, double, double* sig,
54
+ double* tan, double*) {
55
+ double x[6], z[WIDEST], zn[WIDEST], t[6 * WIDEST], tn[6 * WIDEST];
56
+ for (int i = 0; i != 6; ++i) {
57
+ x[i] = e1[i] / SCALE_STRAIN;
58
+ z[i] = x[i];
59
+ for (int d = 0; d != 6; ++d) {
60
+ t[6 * i + d] = i == d ? 1.0 : 0.0;
61
+ }
62
+ }
63
+ int n = 6, w = 0, b = 0;
64
+ for (int k = 0; k != N_LAYERS; ++k) {
65
+ const int m = SIZES[k];
66
+ for (int i = 0; i != m; ++i) {
67
+ double a = 0.0;
68
+ for (int j = 0; j != n; ++j) {
69
+ a += z[j] * W[w + n * i + j];
70
+ }
71
+ zn[i] = std::tanh(a + B[b + i]);
72
+ const double g = 1.0 - zn[i] * zn[i];
73
+ for (int d = 0; d != 6; ++d) {
74
+ double s = 0.0;
75
+ for (int j = 0; j != n; ++j) {
76
+ s += W[w + n * i + j] * t[6 * j + d];
77
+ }
78
+ tn[6 * i + d] = g * s;
79
+ }
80
+ }
81
+ for (int i = 0; i != m; ++i) {
82
+ z[i] = zn[i];
83
+ for (int d = 0; d != 6; ++d) {
84
+ t[6 * i + d] = tn[6 * i + d];
85
+ }
86
+ }
87
+ w += m * n;
88
+ b += m;
89
+ n = m;
90
+ }
91
+ for (int r = 0; r != 6; ++r) {
92
+ double y = 0.0;
93
+ for (int j = 0; j != n; ++j) {
94
+ y += z[j] * WOUT[n * r + j];
95
+ }
96
+ y += BOUT[r];
97
+ double lin = 0.0;
98
+ for (int c = 0; c != 6; ++c) {
99
+ lin += x[c] * LIN[6 * r + c];
100
+ }
101
+ sig[r] = SCALE_STRESS * (y + lin);
102
+ for (int d = 0; d != 6; ++d) {
103
+ double s = 0.0;
104
+ for (int j = 0; j != n; ++j) {
105
+ s += WOUT[n * r + j] * t[6 * j + d];
106
+ }
107
+ tan[6 * r + d] = SCALE_STRESS / SCALE_STRAIN * (s + LIN[6 * r + d]);
108
+ }
109
+ }
110
+ return finite_values(sig, tan);
111
+ }
112
+
113
+ // ---- potential
114
+ // y = dW/dx (x) - dW/dx (0), W(x) = x . A x / 2 + w . z_K, z_k = g(U_k x + b_k + W_k z_{k-1})
115
+ // an input-convex network (Potential._gradient: the gradient backward through the layers,
116
+ // the Hessian forward derivatives of it, symmetrized). Constants: N_LAYERS, SIZES, OFFSETS
117
+ // (of the units of each layer), TOTAL, WIDEST, U (TOTAL x 6), BIAS (TOTAL), WPOS (the
118
+ // nonnegative W_k = softplus(V_k) of the layers k > 0, SIZES[k] x SIZES[k - 1], layer after
119
+ // layer; WOFFSETS their offsets), WOUT (w = softplus(v), SIZES[N_LAYERS - 1]), AMAT (A = L
120
+ // L^T, 6 x 6), G0 (dW/dx (0)).
121
+
122
+ inline double softplus(double a) { // NumPy's logaddexp(0, a)
123
+ return (a > 0.0 ? a : 0.0) + std::log1p(std::exp(-std::fabs(a)));
124
+ }
125
+
126
+ inline int law(const double* e1, const double*, const double*, double, double* sig,
127
+ double* tan, double*) {
128
+ double x[6], z[TOTAL], s[TOTAL], ds[TOTAL], delta[TOTAL], tang[6 * TOTAL];
129
+ for (int d = 0; d != 6; ++d) {
130
+ x[d] = e1[d] / SCALE_STRAIN;
131
+ }
132
+ for (int k = 0; k != N_LAYERS; ++k) { // the layers and their derivatives da_k / dx
133
+ const int o = OFFSETS[k];
134
+ for (int i = 0; i != SIZES[k]; ++i) {
135
+ double a = 0.0;
136
+ for (int d = 0; d != 6; ++d) {
137
+ a += x[d] * U[6 * (o + i) + d];
138
+ }
139
+ a += BIAS[o + i];
140
+ if (k > 0) {
141
+ const int p = OFFSETS[k - 1], hp = SIZES[k - 1];
142
+ double v = 0.0;
143
+ for (int j = 0; j != hp; ++j) {
144
+ v += z[p + j] * WPOS[WOFFSETS[k] + hp * i + j];
145
+ }
146
+ a += v;
147
+ }
148
+ z[o + i] = softplus(a);
149
+ s[o + i] = sigmoid(a);
150
+ ds[o + i] = s[o + i] * (1.0 - s[o + i]);
151
+ for (int d = 0; d != 6; ++d) {
152
+ double t = U[6 * (o + i) + d];
153
+ if (k > 0) {
154
+ const int p = OFFSETS[k - 1], hp = SIZES[k - 1];
155
+ double v = 0.0;
156
+ for (int j = 0; j != hp; ++j) {
157
+ v += WPOS[WOFFSETS[k] + hp * i + j] * (s[p + j] * tang[6 * (p + j) + d]);
158
+ }
159
+ t += v;
160
+ }
161
+ tang[6 * (o + i) + d] = t;
162
+ }
163
+ }
164
+ }
165
+ const int last = N_LAYERS - 1, ol = OFFSETS[last];
166
+ for (int i = 0; i != SIZES[last]; ++i) { // dW / da_k, backward
167
+ delta[ol + i] = WOUT[i] * s[ol + i];
168
+ }
169
+ for (int k = last; k > 0; --k) {
170
+ const int o = OFFSETS[k], h = SIZES[k], p = OFFSETS[k - 1], hp = SIZES[k - 1];
171
+ for (int j = 0; j != hp; ++j) {
172
+ double v = 0.0;
173
+ for (int i = 0; i != h; ++i) {
174
+ v += delta[o + i] * WPOS[WOFFSETS[k] + hp * i + j];
175
+ }
176
+ delta[p + j] = v * s[p + j];
177
+ }
178
+ }
179
+ for (int r = 0; r != 6; ++r) {
180
+ double g = 0.0;
181
+ for (int k = 0; k != N_LAYERS; ++k) {
182
+ double v = 0.0;
183
+ for (int i = 0; i != SIZES[k]; ++i) {
184
+ v += delta[OFFSETS[k] + i] * U[6 * (OFFSETS[k] + i) + r];
185
+ }
186
+ g += v;
187
+ }
188
+ double q = 0.0;
189
+ for (int c = 0; c != 6; ++c) {
190
+ q += x[c] * AMAT[6 * c + r];
191
+ }
192
+ sig[r] = SCALE_STRESS * ((g + q) - G0[r]);
193
+ }
194
+ // the Hessian: dd = d(dW/da_k)/dx, from the last layer down
195
+ double hess[36], dd[6 * WIDEST], nd[6 * WIDEST];
196
+ for (int i = 0; i != SIZES[last]; ++i) {
197
+ for (int d = 0; d != 6; ++d) {
198
+ dd[6 * i + d] = (WOUT[i] * ds[ol + i]) * tang[6 * (ol + i) + d];
199
+ }
200
+ }
201
+ for (int j = 0; j != 6; ++j) {
202
+ for (int d = 0; d != 6; ++d) {
203
+ double v = 0.0;
204
+ for (int i = 0; i != SIZES[last]; ++i) {
205
+ v += dd[6 * i + d] * U[6 * (ol + i) + j];
206
+ }
207
+ hess[6 * j + d] = v;
208
+ }
209
+ }
210
+ for (int k = last; k > 0; --k) {
211
+ const int o = OFFSETS[k], h = SIZES[k], p = OFFSETS[k - 1], hp = SIZES[k - 1];
212
+ for (int j = 0; j != hp; ++j) {
213
+ double q = 0.0;
214
+ for (int i = 0; i != h; ++i) {
215
+ q += delta[o + i] * WPOS[WOFFSETS[k] + hp * i + j];
216
+ }
217
+ q *= ds[p + j];
218
+ for (int d = 0; d != 6; ++d) {
219
+ double back = 0.0;
220
+ for (int i = 0; i != h; ++i) {
221
+ back += dd[6 * i + d] * WPOS[WOFFSETS[k] + hp * i + j];
222
+ }
223
+ nd[6 * j + d] = back * s[p + j] + q * tang[6 * (p + j) + d];
224
+ }
225
+ }
226
+ for (int j = 0; j != hp; ++j) {
227
+ for (int d = 0; d != 6; ++d) {
228
+ dd[6 * j + d] = nd[6 * j + d];
229
+ }
230
+ }
231
+ for (int jj = 0; jj != 6; ++jj) {
232
+ for (int d = 0; d != 6; ++d) {
233
+ double v = 0.0;
234
+ for (int j = 0; j != hp; ++j) {
235
+ v += dd[6 * j + d] * U[6 * (p + j) + jj];
236
+ }
237
+ hess[6 * jj + d] += v;
238
+ }
239
+ }
240
+ }
241
+ for (int i = 0; i != 36; ++i) {
242
+ hess[i] += AMAT[i];
243
+ }
244
+ for (int r = 0; r != 6; ++r) {
245
+ for (int c = 0; c != 6; ++c) {
246
+ tan[6 * r + c] = SCALE_STRESS / SCALE_STRAIN * (0.5 * (hess[6 * r + c] + hess[6 * c + r]));
247
+ }
248
+ }
249
+ return finite_values(sig, tan);
250
+ }
251
+
252
+ // ---- recurrent
253
+ // A gated recurrent unit over the steps (Recurrent.step): its input the strain at the end
254
+ // of the step and the increment of the step (and the time step, with RATE), its state the
255
+ // internal variables of the law, y = V h + Q x + c; the tangent the derivative with respect
256
+ // to the strain at the end of the step, the state at its start held. Constants: HIDDEN,
257
+ // N_INPUTS, RATE, LOGARITHMIC (the increment of the normalized logarithmic strain, as
258
+ // Recurrent.step writes it), WI (N_INPUTS x 3 HIDDEN), WH (HIDDEN x 3 HIDDEN), BG (3 HIDDEN),
259
+ // BN (HIDDEN), V (HIDDEN x 6), Q (6 x 6), C (6).
260
+
261
+ inline int law(const double* e1, const double* e0, const double* s0, double dt, double* sig,
262
+ double* tan, double* s1) {
263
+ constexpr int H = HIDDEN;
264
+ double u[N_INPUTS], seen[6], gi[3 * H], gh[3 * H], r[H], zg[H], hn[H], cand[H];
265
+ double dstate[6 * H];
266
+ for (int i = 0; i != 6; ++i) {
267
+ seen[i] = e1[i] / SCALE_STRAIN;
268
+ u[i] = seen[i];
269
+ if (LOGARITHMIC) {
270
+ u[6 + i] = (seen[i] - e0[i] / SCALE_STRAIN) * (SCALE_STRAIN / SCALE_INCREMENT);
271
+ } else {
272
+ u[6 + i] = (e1[i] - e0[i]) / SCALE_INCREMENT;
273
+ }
274
+ }
275
+ if (RATE) { // the last input, the thirteenth
276
+ u[N_INPUTS - 1] = dt / SCALE_TIME;
277
+ }
278
+ for (int j = 0; j != 3 * H; ++j) {
279
+ double a = 0.0;
280
+ for (int c = 0; c != N_INPUTS; ++c) {
281
+ a += u[c] * WI[3 * H * c + j];
282
+ }
283
+ gi[j] = a + BG[j];
284
+ double v = 0.0;
285
+ for (int c = 0; c != H; ++c) {
286
+ v += s0[c] * WH[3 * H * c + j];
287
+ }
288
+ gh[j] = v;
289
+ }
290
+ for (int j = 0; j != H; ++j) {
291
+ r[j] = sigmoid(gi[j] + gh[j]);
292
+ zg[j] = sigmoid(gi[H + j] + gh[H + j]);
293
+ hn[j] = gh[2 * H + j] + BN[j];
294
+ cand[j] = std::tanh(gi[2 * H + j] + r[j] * hn[j]);
295
+ s1[j] = cand[j] + zg[j] * (s0[j] - cand[j]);
296
+ for (int d = 0; d != 6; ++d) { // the inputs of the strain at the end, of the increment
297
+ const double dr = WI[3 * H * d + j] / SCALE_STRAIN
298
+ + WI[3 * H * (6 + d) + j] / SCALE_INCREMENT;
299
+ const double dz = WI[3 * H * d + H + j] / SCALE_STRAIN
300
+ + WI[3 * H * (6 + d) + H + j] / SCALE_INCREMENT;
301
+ const double dn = WI[3 * H * d + 2 * H + j] / SCALE_STRAIN
302
+ + WI[3 * H * (6 + d) + 2 * H + j] / SCALE_INCREMENT;
303
+ const double ddr = r[j] * (1.0 - r[j]) * dr;
304
+ const double ddz = zg[j] * (1.0 - zg[j]) * dz;
305
+ const double dcand = (1.0 - cand[j] * cand[j]) * (dn + ddr * hn[j]);
306
+ dstate[6 * j + d] = (1.0 - zg[j]) * dcand + ddz * (s0[j] - cand[j]);
307
+ }
308
+ }
309
+ for (int k = 0; k != 6; ++k) {
310
+ double y = 0.0;
311
+ for (int j = 0; j != H; ++j) {
312
+ y += s1[j] * V[6 * j + k];
313
+ }
314
+ double q = 0.0;
315
+ for (int c = 0; c != 6; ++c) {
316
+ q += seen[c] * Q[6 * k + c];
317
+ }
318
+ sig[k] = SCALE_STRESS * ((y + q) + C[k]);
319
+ for (int d = 0; d != 6; ++d) {
320
+ double v = 0.0;
321
+ for (int j = 0; j != H; ++j) {
322
+ v += dstate[6 * j + d] * V[6 * j + k];
323
+ }
324
+ tan[6 * k + d] = SCALE_STRESS * (v + Q[6 * k + d] / SCALE_STRAIN);
325
+ }
326
+ }
327
+ return finite_values(sig, tan);
328
+ }
329
+
330
+ // ---- standard
331
+ // A learned generalized standard material (standard.py): the state of a step the minimizer
332
+ // of the incremental potential W(z) + Phi(alpha - alpha_n), z = (x, alpha), by Newton's
333
+ // method with Armijo's backtracking (_update), the stress dW/dx and the tangent the Schur
334
+ // complement of its Hessian (_schur). Constants: M (internal variables), D = 6 + M, NH (the
335
+ // ridges of the free energy), U (NH x D), BIAS (NH), WR (w = softplus, NH), A (L L^T, D x
336
+ // D), G0 (dW/dz (0)), N_NORMS, N_RIDGES, BM (B, N_NORMS x M x M), GM (B_j^T B_j), P
337
+ // (softplus, N_RIDGES x N_NORMS), CM (N_RIDGES x M), VM (M M^T, M x M), DELTA, PLASTIC,
338
+ // VISCOUS, NEWTON_TOL, NEWTON_MAX, ARMIJO.
339
+
340
+ inline double soft(double t) { // the softplus of a scalar, without overflow (_soft)
341
+ if (t > 30.0) {
342
+ return t;
343
+ }
344
+ if (t < -30.0) {
345
+ return std::exp(t);
346
+ }
347
+ return std::log1p(std::exp(t));
348
+ }
349
+
350
+ // W(z) - z . g0 and, with order 1 or 2, its gradient and Hessian (_energy)
351
+ inline double energy(const double* z, double* grad, double* hess, int order) {
352
+ double value = 0.0;
353
+ for (int i = 0; i != D; ++i) {
354
+ double s = 0.0;
355
+ for (int j = 0; j != D; ++j) {
356
+ s += A[D * i + j] * z[j];
357
+ }
358
+ value += (0.5 * s - G0[i]) * z[i];
359
+ if (order > 0) {
360
+ grad[i] = s - G0[i];
361
+ }
362
+ }
363
+ if (order > 1) {
364
+ for (int i = 0; i != D * D; ++i) {
365
+ hess[i] = A[i];
366
+ }
367
+ }
368
+ for (int k = 0; k != NH; ++k) {
369
+ double a = BIAS[k];
370
+ for (int j = 0; j != D; ++j) {
371
+ a += U[D * k + j] * z[j];
372
+ }
373
+ value += WR[k] * soft(a);
374
+ if (order > 0) {
375
+ const double sg = sigmoid(a);
376
+ const double c = WR[k] * sg;
377
+ for (int j = 0; j != D; ++j) {
378
+ grad[j] += c * U[D * k + j];
379
+ }
380
+ if (order > 1) {
381
+ const double c2 = c * (1.0 - sg);
382
+ for (int i = 0; i != D; ++i) {
383
+ const double ci = c2 * U[D * k + i];
384
+ for (int j = 0; j != D; ++j) {
385
+ hess[D * i + j] += ci * U[D * k + j];
386
+ }
387
+ }
388
+ }
389
+ }
390
+ }
391
+ return value;
392
+ }
393
+
394
+ // the dissipation of a step Phi(v) of the increment v and, with order 1 or 2, its gradient
395
+ // and Hessian (_dissipation)
396
+ inline double dissipation(const double* v, double tau, double* grad, double* hess, int order) {
397
+ double value = 0.0;
398
+ if (order > 0) {
399
+ for (int i = 0; i != M; ++i) {
400
+ grad[i] = 0.0;
401
+ }
402
+ }
403
+ if (order > 1) {
404
+ for (int i = 0; i != M * M; ++i) {
405
+ hess[i] = 0.0;
406
+ }
407
+ }
408
+ if (VISCOUS) {
409
+ for (int i = 0; i != M; ++i) {
410
+ double s = 0.0;
411
+ for (int j = 0; j != M; ++j) {
412
+ s += VM[M * i + j] * v[j];
413
+ }
414
+ value += 0.5 * s * v[i] / tau;
415
+ if (order > 0) {
416
+ grad[i] += s / tau;
417
+ }
418
+ if (order > 1) {
419
+ for (int j = 0; j != M; ++j) {
420
+ hess[M * i + j] += VM[M * i + j] / tau;
421
+ }
422
+ }
423
+ }
424
+ }
425
+ if (!PLASTIC) {
426
+ return value;
427
+ }
428
+ double norm[N_NORMS], radius[N_NORMS], dn[N_NORMS * M], f[N_NORMS], dt[M];
429
+ for (int j = 0; j != N_NORMS; ++j) {
430
+ double ss = 0.0;
431
+ for (int i = 0; i != M; ++i) {
432
+ double s = 0.0;
433
+ for (int l = 0; l != M; ++l) {
434
+ s += BM[M * M * j + M * i + l] * v[l];
435
+ }
436
+ ss += s * s;
437
+ }
438
+ radius[j] = std::sqrt(ss + DELTA * DELTA);
439
+ norm[j] = ss / (radius[j] + DELTA); // sqrt(ss + delta^2) - delta, without cancellation
440
+ if (order > 0) {
441
+ for (int l = 0; l != M; ++l) {
442
+ double s = 0.0;
443
+ for (int i = 0; i != M; ++i) {
444
+ s += GM[M * M * j + M * l + i] * v[i];
445
+ }
446
+ dn[M * j + l] = s / radius[j];
447
+ }
448
+ }
449
+ f[j] = 0.0;
450
+ }
451
+ for (int k = 0; k != N_RIDGES; ++k) {
452
+ double t = 0.0;
453
+ for (int j = 0; j != N_NORMS; ++j) {
454
+ t += P[N_NORMS * k + j] * norm[j];
455
+ }
456
+ double lin = 0.0;
457
+ for (int l = 0; l != M; ++l) {
458
+ t += CM[M * k + l] * v[l];
459
+ lin += CM[M * k + l] * v[l];
460
+ }
461
+ const double q = std::sqrt(t * t + DELTA * DELTA);
462
+ value += 0.5 * (t + q) - 0.5 * DELTA - 0.5 * lin;
463
+ if (order == 0) {
464
+ continue;
465
+ }
466
+ const double s1 = 0.5 * (1.0 + t / q);
467
+ for (int l = 0; l != M; ++l) {
468
+ double s = CM[M * k + l];
469
+ for (int j = 0; j != N_NORMS; ++j) {
470
+ s += P[N_NORMS * k + j] * dn[M * j + l];
471
+ }
472
+ dt[l] = s;
473
+ grad[l] += s1 * s - 0.5 * CM[M * k + l];
474
+ }
475
+ if (order > 1) {
476
+ const double s2 = 0.5 * DELTA * DELTA / (q * q * q);
477
+ for (int l = 0; l != M; ++l) {
478
+ for (int i = 0; i != M; ++i) {
479
+ hess[M * l + i] += s2 * dt[l] * dt[i];
480
+ }
481
+ }
482
+ for (int j = 0; j != N_NORMS; ++j) {
483
+ f[j] += s1 * P[N_NORMS * k + j];
484
+ }
485
+ }
486
+ }
487
+ if (order > 1) { // sum_j f_j d2 n_j, d2 n_j = (B_j^T B_j - dn_j dn_j^T) / r_j
488
+ for (int j = 0; j != N_NORMS; ++j) {
489
+ for (int l = 0; l != M; ++l) {
490
+ for (int i = 0; i != M; ++i) {
491
+ hess[M * l + i] += f[j] * (GM[M * M * j + M * l + i] - dn[M * j + l] * dn[M * j + i])
492
+ / radius[j];
493
+ }
494
+ }
495
+ }
496
+ }
497
+ return value;
498
+ }
499
+
500
+ // K^-1 rhs of a symmetric positive definite matrix by Cholesky's factorization, a small
501
+ // shift of the diagonal if round-off spoils it (_solve)
502
+ inline void solve(const double* K, const double* rhs, double* out) {
503
+ double low[M * M];
504
+ for (int i = 0; i != M * M; ++i) {
505
+ low[i] = 0.0;
506
+ }
507
+ double shift = 0.0;
508
+ for (int attempt = 0; attempt != 8; ++attempt) {
509
+ bool ok = true;
510
+ for (int j = 0; j != M && ok; ++j) {
511
+ double s = K[M * j + j] + shift;
512
+ for (int k = 0; k != j; ++k) {
513
+ s -= low[M * j + k] * low[M * j + k];
514
+ }
515
+ if (!(s > 0.0)) {
516
+ ok = false;
517
+ break;
518
+ }
519
+ low[M * j + j] = std::sqrt(s);
520
+ for (int i = j + 1; i != M; ++i) {
521
+ double v = K[M * i + j];
522
+ for (int k = 0; k != j; ++k) {
523
+ v -= low[M * i + k] * low[M * j + k];
524
+ }
525
+ low[M * i + j] = v / low[M * j + j];
526
+ }
527
+ }
528
+ if (ok) {
529
+ break;
530
+ }
531
+ double trace = 0.0;
532
+ for (int j = 0; j != M; ++j) {
533
+ trace += std::fabs(K[M * j + j]);
534
+ }
535
+ const double floor = 1e-14 * trace / M + 1e-300;
536
+ shift = 10.0 * shift > floor ? 10.0 * shift : floor;
537
+ }
538
+ for (int i = 0; i != M; ++i) {
539
+ double s = rhs[i];
540
+ for (int k = 0; k != i; ++k) {
541
+ s -= low[M * i + k] * out[k];
542
+ }
543
+ out[i] = s / low[M * i + i];
544
+ }
545
+ for (int i = M - 1; i >= 0; --i) {
546
+ double s = out[i];
547
+ for (int k = i + 1; k != M; ++k) {
548
+ s -= low[M * k + i] * out[k];
549
+ }
550
+ out[i] = s / low[M * i + i];
551
+ }
552
+ }
553
+
554
+ // the state of a step: the minimizer alpha of the incremental potential at the strain x
555
+ // from the state a0 (Newton's method from a0, a backtracking line search); on return z =
556
+ // (x, alpha), the gradient gz and Hessian hz of the free energy at z and kmat, the Hessian
557
+ // of the potential in alpha; returns the iterations, or minus them without convergence
558
+ // (_update)
559
+ inline int update(const double* x, const double* a0, double tau, double* z, double* gz,
560
+ double* hz, double* kmat) {
561
+ double inc[M], res[M], step[M], trial[D], gp[M], hp[M * M];
562
+ for (int i = 0; i != 6; ++i) {
563
+ z[i] = x[i];
564
+ }
565
+ for (int i = 0; i != M; ++i) {
566
+ z[6 + i] = a0[i];
567
+ inc[i] = 0.0;
568
+ }
569
+ for (int it = 0; it != NEWTON_MAX + 1; ++it) {
570
+ double value = energy(z, gz, hz, 2);
571
+ for (int i = 0; i != M; ++i) {
572
+ inc[i] = z[6 + i] - a0[i];
573
+ }
574
+ value += dissipation(inc, tau, gp, hp, 2);
575
+ double size = 0.0;
576
+ for (int i = 0; i != M; ++i) {
577
+ res[i] = gz[6 + i] + gp[i];
578
+ size = std::fabs(res[i]) > size ? std::fabs(res[i]) : size;
579
+ for (int j = 0; j != M; ++j) {
580
+ kmat[M * i + j] = hz[D * (6 + i) + 6 + j] + hp[M * i + j];
581
+ }
582
+ }
583
+ if (size <= NEWTON_TOL) {
584
+ return it;
585
+ }
586
+ if (it == NEWTON_MAX) {
587
+ break;
588
+ }
589
+ solve(kmat, res, step);
590
+ double slope = 0.0;
591
+ for (int i = 0; i != M; ++i) {
592
+ step[i] = -step[i];
593
+ slope += res[i] * step[i];
594
+ }
595
+ double t = 1.0;
596
+ // far from the solution: Armijo's backtracking on the potential, while the decrease it
597
+ // predicts is above the round-off of the potential
598
+ if (size > 1e-6 && -slope > 1e-12 * (1.0 + std::fabs(value))) {
599
+ for (int i = 0; i != 6; ++i) {
600
+ trial[i] = x[i];
601
+ }
602
+ for (int ls = 0; ls != 40; ++ls) {
603
+ for (int i = 0; i != M; ++i) {
604
+ trial[6 + i] = z[6 + i] + t * step[i];
605
+ inc[i] = trial[6 + i] - a0[i];
606
+ }
607
+ double got = energy(trial, gz, hz, 0);
608
+ got += dissipation(inc, tau, gp, hp, 0);
609
+ if (got <= value + ARMIJO * t * slope) {
610
+ break;
611
+ }
612
+ t *= 0.5;
613
+ }
614
+ }
615
+ for (int i = 0; i != M; ++i) {
616
+ z[6 + i] += t * step[i];
617
+ }
618
+ }
619
+ return -NEWTON_MAX;
620
+ }
621
+
622
+ // the consistent tangent d2W/dx2 - d2W/dx dalpha K^-1 d2W/dalpha dx (6 x 6, symmetrized:
623
+ // _schur)
624
+ inline void schur(const double* hz, const double* kmat, double* out) {
625
+ double col[M], sol[M];
626
+ for (int c = 0; c != 6; ++c) {
627
+ for (int i = 0; i != M; ++i) {
628
+ col[i] = hz[D * (6 + i) + c];
629
+ }
630
+ solve(kmat, col, sol);
631
+ for (int r = 0; r != 6; ++r) {
632
+ double s = hz[D * r + c];
633
+ for (int i = 0; i != M; ++i) {
634
+ s -= hz[D * r + 6 + i] * sol[i];
635
+ }
636
+ out[6 * r + c] = s;
637
+ }
638
+ }
639
+ for (int r = 0; r != 6; ++r) {
640
+ for (int c = 0; c != r; ++c) {
641
+ const double s = 0.5 * (out[6 * r + c] + out[6 * c + r]);
642
+ out[6 * r + c] = s;
643
+ out[6 * c + r] = s;
644
+ }
645
+ }
646
+ }
647
+
648
+ inline int law(const double* e1, const double*, const double* s0, double dt, double* sig,
649
+ double* tan, double* s1) {
650
+ double x[6], z[D], gz[D], hz[D * D], kmat[M * M], k6[36];
651
+ for (int i = 0; i != 6; ++i) {
652
+ x[i] = e1[i] / SCALE_STRAIN;
653
+ }
654
+ // a step of no time: the viscous variables frozen (an infinite viscous resistance)
655
+ const double tau = VISCOUS ? (dt / SCALE_TIME > 1e-12 ? dt / SCALE_TIME : 1e-12) : 1.0;
656
+ update(x, s0, tau, z, gz, hz, kmat);
657
+ schur(hz, kmat, k6);
658
+ for (int i = 0; i != 6; ++i) {
659
+ sig[i] = SCALE_STRESS * gz[i];
660
+ }
661
+ for (int i = 0; i != 36; ++i) {
662
+ tan[i] = SCALE_STRESS / SCALE_STRAIN * k6[i];
663
+ }
664
+ for (int i = 0; i != M; ++i) {
665
+ s1[i] = z[6 + i];
666
+ }
667
+ return finite_values(sig, tan);
668
+ }