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.
- morphogen/__init__.py +60 -0
- morphogen/__main__.py +7 -0
- morphogen/_platform.py +55 -0
- morphogen/_public.py +153 -0
- morphogen/_utils.py +80 -0
- morphogen/_version.py +1 -0
- morphogen/analysis/__init__.py +174 -0
- morphogen/analysis/anisotropy.py +135 -0
- morphogen/analysis/basic.py +38 -0
- morphogen/analysis/cells.py +54 -0
- morphogen/analysis/connectivity.py +156 -0
- morphogen/analysis/correlation.py +195 -0
- morphogen/analysis/covariance.py +80 -0
- morphogen/analysis/fractal.py +54 -0
- morphogen/analysis/measures.py +188 -0
- morphogen/analysis/morphology.py +265 -0
- morphogen/analysis/particles.py +160 -0
- morphogen/analysis/percolation.py +2034 -0
- morphogen/analysis/power_laws.py +143 -0
- morphogen/analysis/random_sets.py +351 -0
- morphogen/analysis/stereology.py +289 -0
- morphogen/analysis/surface.py +107 -0
- morphogen/analysis/topology.py +92 -0
- morphogen/automata/__init__.py +74 -0
- morphogen/automata/engine.py +211 -0
- morphogen/automata/growth.py +686 -0
- morphogen/automata/lattice.py +143 -0
- morphogen/automata/reaction.py +255 -0
- morphogen/automata/rules.py +353 -0
- morphogen/automata/tilings.py +1715 -0
- morphogen/cli.py +3526 -0
- morphogen/config.py +2167 -0
- morphogen/contact/__init__.py +113 -0
- morphogen/contact/experiments.py +368 -0
- morphogen/contact/hertz.py +104 -0
- morphogen/contact/kernels.py +827 -0
- morphogen/contact/periodic.py +278 -0
- morphogen/contact/problem.py +578 -0
- morphogen/contact/surfaces.py +310 -0
- morphogen/coupling/__init__.py +43 -0
- morphogen/coupling/ageing.py +143 -0
- morphogen/coupling/diffusion.py +226 -0
- morphogen/coupling/fenicsx.py +484 -0
- morphogen/coupling/oxidation.py +447 -0
- morphogen/coupling/plates.py +247 -0
- morphogen/design/__init__.py +51 -0
- morphogen/design/csp.py +616 -0
- morphogen/design/frames.py +277 -0
- morphogen/design/search.py +287 -0
- morphogen/design/tiles.py +336 -0
- morphogen/distributions.py +312 -0
- morphogen/domain.py +203 -0
- morphogen/dynamics/__init__.py +179 -0
- morphogen/dynamics/model.py +638 -0
- morphogen/dynamics/openradioss.py +643 -0
- morphogen/dynamics/results.py +515 -0
- morphogen/fracture/__init__.py +170 -0
- morphogen/fracture/bulk.py +349 -0
- morphogen/fracture/cohesive.py +1614 -0
- morphogen/fracture/ductile.py +557 -0
- morphogen/fracture/lefm.py +1168 -0
- morphogen/fracture/mixed.py +1178 -0
- morphogen/fracture/periodic.py +733 -0
- morphogen/fracture/phasefield.py +714 -0
- morphogen/fracture/phasefield_finite.py +368 -0
- morphogen/fracture/surface.py +572 -0
- morphogen/fracture/toughness.py +566 -0
- morphogen/gpu.py +108 -0
- morphogen/gui/__init__.py +8 -0
- morphogen/gui/api.py +1927 -0
- morphogen/gui/desktop.py +387 -0
- morphogen/gui/icon.png +0 -0
- morphogen/gui/index.html +1909 -0
- morphogen/gui/server.py +229 -0
- morphogen/gui/tools/__init__.py +629 -0
- morphogen/gui/tools/compare.py +149 -0
- morphogen/gui/tools/contact.py +391 -0
- morphogen/gui/tools/couplings.py +1085 -0
- morphogen/gui/tools/crackfront.py +245 -0
- morphogen/gui/tools/design.py +224 -0
- morphogen/gui/tools/dynamics.py +824 -0
- morphogen/gui/tools/fracture.py +2586 -0
- morphogen/gui/tools/interop.py +1654 -0
- morphogen/gui/tools/learning.py +595 -0
- morphogen/gui/tools/mechanics.py +3881 -0
- morphogen/gui/tools/nonlocal_damage.py +1321 -0
- morphogen/gui/tools/phasefield.py +215 -0
- morphogen/gui/tools/physics.py +597 -0
- morphogen/gui/tools/stability.py +1756 -0
- morphogen/gui/tools/statistics.py +1408 -0
- morphogen/gui/viewer.js +1100 -0
- morphogen/homogenization/__init__.py +210 -0
- morphogen/homogenization/acoustics.py +566 -0
- morphogen/homogenization/amg.py +1005 -0
- morphogen/homogenization/apparent.py +1046 -0
- morphogen/homogenization/behaviours.cu +2285 -0
- morphogen/homogenization/behaviours.py +944 -0
- morphogen/homogenization/beremin.py +263 -0
- morphogen/homogenization/bifurcation.py +1085 -0
- morphogen/homogenization/bloch.py +507 -0
- morphogen/homogenization/bounds.py +226 -0
- morphogen/homogenization/core.py +458 -0
- morphogen/homogenization/coupled.py +1135 -0
- morphogen/homogenization/crystal.py +2967 -0
- morphogen/homogenization/dilatation.py +454 -0
- morphogen/homogenization/elements.py +157 -0
- morphogen/homogenization/fatigue.py +768 -0
- morphogen/homogenization/fe.py +1739 -0
- morphogen/homogenization/fenicsx.py +307 -0
- morphogen/homogenization/fft.py +499 -0
- morphogen/homogenization/fft_nonlinear.py +391 -0
- morphogen/homogenization/finite.py +613 -0
- morphogen/homogenization/flow.py +361 -0
- morphogen/homogenization/frames.py +1125 -0
- morphogen/homogenization/gpu.py +1241 -0
- morphogen/homogenization/harmonic.py +427 -0
- morphogen/homogenization/identification.py +579 -0
- morphogen/homogenization/kernels.py +760 -0
- morphogen/homogenization/laws.py +2061 -0
- morphogen/homogenization/materials.py +1080 -0
- morphogen/homogenization/mfront.py +589 -0
- morphogen/homogenization/networks.py +880 -0
- morphogen/homogenization/nonlinear.py +2612 -0
- morphogen/homogenization/ntfa.py +577 -0
- morphogen/homogenization/paths.py +476 -0
- morphogen/homogenization/photonic.py +467 -0
- morphogen/homogenization/poroelastic.py +212 -0
- morphogen/homogenization/porous.py +1120 -0
- morphogen/homogenization/postprocess.py +290 -0
- morphogen/homogenization/solvers.py +1140 -0
- morphogen/homogenization/tensors.py +240 -0
- morphogen/homogenization/voxel_fe.py +457 -0
- morphogen/homogenization/xfem.py +1016 -0
- morphogen/homogenization/zmat.py +1258 -0
- morphogen/iga/__init__.py +48 -0
- morphogen/iga/analysis.py +508 -0
- morphogen/iga/basis.py +214 -0
- morphogen/iga/geometry.py +501 -0
- morphogen/iga/homogenization.py +219 -0
- morphogen/iga/optimization.py +700 -0
- morphogen/iga/shapes.py +331 -0
- morphogen/image.py +128 -0
- morphogen/io/__init__.py +246 -0
- morphogen/io/amitex.py +741 -0
- morphogen/io/ebsd.py +881 -0
- morphogen/io/export.py +196 -0
- morphogen/io/geometry.py +158 -0
- morphogen/io/medit.py +147 -0
- morphogen/io/meshes.py +844 -0
- morphogen/io/metaimage.py +97 -0
- morphogen/io/mfront.py +1104 -0
- morphogen/io/native.py +57 -0
- morphogen/io/radioss.py +764 -0
- morphogen/io/solvers.py +371 -0
- morphogen/io/tables.py +278 -0
- morphogen/io/tiff.py +66 -0
- morphogen/io/vtk.py +701 -0
- morphogen/io/xdmf.py +200 -0
- morphogen/kernels/__init__.py +5 -0
- morphogen/kernels/annealing.py +192 -0
- morphogen/kernels/cells.py +69 -0
- morphogen/kernels/collective.py +87 -0
- morphogen/kernels/force_biased.py +595 -0
- morphogen/kernels/implicit.py +145 -0
- morphogen/kernels/leaves.py +132 -0
- morphogen/kernels/packing.py +304 -0
- morphogen/kernels/raster.py +279 -0
- morphogen/kernels/rsa.py +371 -0
- morphogen/kernels/union.py +135 -0
- morphogen/kernels/watershed.py +190 -0
- morphogen/laser/__init__.py +234 -0
- morphogen/laser/architectures.py +375 -0
- morphogen/laser/bending.py +216 -0
- morphogen/laser/cells.py +1694 -0
- morphogen/laser/design.py +940 -0
- morphogen/laser/figures.py +227 -0
- morphogen/laser/heat.py +804 -0
- morphogen/laser/materials.py +691 -0
- morphogen/laser/mechanics.py +1670 -0
- morphogen/laser/metallurgy.py +615 -0
- morphogen/laser/patterns.py +828 -0
- morphogen/laser/periodic.py +392 -0
- morphogen/laser/process.py +362 -0
- morphogen/laser/run.py +534 -0
- morphogen/laser/solid.py +216 -0
- morphogen/laser/specimen.py +200 -0
- morphogen/laser/structures.py +708 -0
- morphogen/learning/__init__.py +81 -0
- morphogen/learning/behaviour.py +398 -0
- morphogen/learning/data.py +328 -0
- morphogen/learning/learned.cpp +668 -0
- morphogen/learning/logarithmic.py +202 -0
- morphogen/learning/mfront.py +409 -0
- morphogen/learning/networks.py +767 -0
- morphogen/learning/run.py +212 -0
- morphogen/learning/standard.py +814 -0
- morphogen/learning/training.py +235 -0
- morphogen/mesh/__init__.py +29 -0
- morphogen/mesh/conforming.py +1423 -0
- morphogen/mesh/curved.py +600 -0
- morphogen/mesh/exact.py +1717 -0
- morphogen/mesh/octree.py +350 -0
- morphogen/mesh/polycrystal.py +1041 -0
- morphogen/mesh/polyhedra.py +677 -0
- morphogen/mesh/regularize.py +570 -0
- morphogen/mesh/surface.py +97 -0
- morphogen/mesh/tetra.py +512 -0
- morphogen/mesh/voxel.py +124 -0
- morphogen/micromorphic/__init__.py +31 -0
- morphogen/micromorphic/damage.py +359 -0
- morphogen/micromorphic/ductile.py +534 -0
- morphogen/micromorphic/finite.py +220 -0
- morphogen/micromorphic/microfoam.py +787 -0
- morphogen/micromorphic/space.py +341 -0
- morphogen/models/__init__.py +195 -0
- morphogen/models/affine.py +384 -0
- morphogen/models/automata.py +592 -0
- morphogen/models/base.py +500 -0
- morphogen/models/boolean.py +310 -0
- morphogen/models/bouligand.py +331 -0
- morphogen/models/branching.py +241 -0
- morphogen/models/combination.py +430 -0
- morphogen/models/deadleaves.py +766 -0
- morphogen/models/design.py +289 -0
- morphogen/models/ebsd.py +206 -0
- morphogen/models/fibers.py +1476 -0
- morphogen/models/foam.py +594 -0
- morphogen/models/gaussian.py +314 -0
- morphogen/models/growth.py +459 -0
- morphogen/models/hardcore.py +317 -0
- morphogen/models/hierarchical.py +269 -0
- morphogen/models/honeycomb.py +749 -0
- morphogen/models/implicit.py +177 -0
- morphogen/models/laminate.py +470 -0
- morphogen/models/lattice.py +351 -0
- morphogen/models/lattice_field.py +345 -0
- morphogen/models/levelset_foam.py +563 -0
- morphogen/models/nacre.py +411 -0
- morphogen/models/nested.py +924 -0
- morphogen/models/osteons.py +374 -0
- morphogen/models/pieces.py +167 -0
- morphogen/models/planar.py +126 -0
- morphogen/models/reconstruction.py +203 -0
- morphogen/models/scale_rich.py +1409 -0
- morphogen/models/scale_rich_3d.py +1616 -0
- morphogen/models/tessellation.py +735 -0
- morphogen/models/tiling_field.py +302 -0
- morphogen/models/tpms.py +197 -0
- morphogen/models/transparent.py +406 -0
- morphogen/models/union.py +141 -0
- morphogen/optimization/__init__.py +43 -0
- morphogen/optimization/cell.py +295 -0
- morphogen/optimization/filters.py +115 -0
- morphogen/optimization/mma.py +226 -0
- morphogen/optimization/run.py +219 -0
- morphogen/optimization/topology.py +632 -0
- morphogen/orientations.py +568 -0
- morphogen/parallel.py +599 -0
- morphogen/pipeline.py +978 -0
- morphogen/primitives.py +188 -0
- morphogen/results.py +564 -0
- morphogen/rve/__init__.py +73 -0
- morphogen/rve/report.py +627 -0
- morphogen/rve/scaling.py +363 -0
- morphogen/rve/study.py +1054 -0
- morphogen/rve/windows.py +345 -0
- morphogen/seeding.py +51 -0
- morphogen/settings.py +118 -0
- morphogen/stopping.py +48 -0
- morphogen/symmetry.py +384 -0
- morphogen/templates/activator_inhibitor.yaml +22 -0
- morphogen/templates/aggregation.yaml +23 -0
- morphogen/templates/boolean_cylinders.yaml +20 -0
- morphogen/templates/boolean_spheres.yaml +22 -0
- morphogen/templates/bouligand.yaml +28 -0
- morphogen/templates/cellular_automaton.yaml +25 -0
- morphogen/templates/coated_spheres.yaml +26 -0
- morphogen/templates/contact_fibers.yaml +27 -0
- morphogen/templates/cox_nanocomposite.yaml +22 -0
- morphogen/templates/cross_linked_fibers.yaml +26 -0
- morphogen/templates/curved_arcs.yaml +28 -0
- morphogen/templates/curved_fibers.yaml +24 -0
- morphogen/templates/dead_leaves.yaml +22 -0
- morphogen/templates/delaunay_network.yaml +22 -0
- morphogen/templates/dense_packing.yaml +22 -0
- morphogen/templates/diffusion.yaml +33 -0
- morphogen/templates/ebsd.yaml +34 -0
- morphogen/templates/ebsd_map.ctf +3087 -0
- morphogen/templates/fracture_composite.yaml +42 -0
- morphogen/templates/fracture_rubber.yaml +47 -0
- morphogen/templates/gaussian_excursion.yaml +17 -0
- morphogen/templates/graded_lattice.yaml +24 -0
- morphogen/templates/hardcore_fibers.yaml +22 -0
- morphogen/templates/hardcore_spheres.yaml +22 -0
- morphogen/templates/hierarchical_lattice.yaml +22 -0
- morphogen/templates/homogenization_acoustic_foam.yaml +36 -0
- morphogen/templates/homogenization_beremin.yaml +50 -0
- morphogen/templates/homogenization_cleavage.yaml +51 -0
- morphogen/templates/homogenization_cleavage_band.yaml +55 -0
- morphogen/templates/homogenization_contact.yaml +43 -0
- morphogen/templates/homogenization_crack_closure.yaml +49 -0
- morphogen/templates/homogenization_crystal_plasticity.yaml +50 -0
- morphogen/templates/homogenization_crystal_plasticity_fft.yaml +52 -0
- morphogen/templates/homogenization_crystallization.yaml +30 -0
- morphogen/templates/homogenization_debonding.yaml +43 -0
- morphogen/templates/homogenization_detwinning.yaml +58 -0
- morphogen/templates/homogenization_ductile_damage.yaml +47 -0
- morphogen/templates/homogenization_fatigue.yaml +40 -0
- morphogen/templates/homogenization_grain_fracture.yaml +56 -0
- morphogen/templates/homogenization_gyroid.yaml +30 -0
- morphogen/templates/homogenization_intergranular.yaml +43 -0
- morphogen/templates/homogenization_interphase.yaml +42 -0
- morphogen/templates/homogenization_mixed_loading.yaml +33 -0
- morphogen/templates/homogenization_ntfa.yaml +56 -0
- morphogen/templates/homogenization_piezoelectric.yaml +27 -0
- morphogen/templates/homogenization_polycrystal.yaml +30 -0
- morphogen/templates/homogenization_polycrystal_inclusions.yaml +30 -0
- morphogen/templates/homogenization_poroelastic.yaml +26 -0
- morphogen/templates/homogenization_rubber.yaml +40 -0
- morphogen/templates/homogenization_slip_cleavage.yaml +50 -0
- morphogen/templates/homogenization_spheres.yaml +31 -0
- morphogen/templates/homogenization_transport.yaml +29 -0
- morphogen/templates/homogenization_twinning.yaml +54 -0
- morphogen/templates/homogenization_viscoelastic.yaml +34 -0
- morphogen/templates/homogenization_viscoplastic.yaml +42 -0
- morphogen/templates/homogenization_voronoi.yaml +26 -0
- morphogen/templates/homogenization_xfem.yaml +23 -0
- morphogen/templates/hyperuniform_cells.yaml +24 -0
- morphogen/templates/laguerre.yaml +18 -0
- morphogen/templates/laser_bending.yaml +35 -0
- morphogen/templates/laser_cells.yaml +38 -0
- morphogen/templates/laser_corrugated.yaml +36 -0
- morphogen/templates/level_set_foam.yaml +29 -0
- morphogen/templates/menger_sponge.yaml +17 -0
- morphogen/templates/nacre.yaml +25 -0
- morphogen/templates/nucleation_growth.yaml +25 -0
- morphogen/templates/optimize_auxetic.yaml +29 -0
- morphogen/templates/optimize_auxetic_3d.yaml +27 -0
- morphogen/templates/optimize_bulk.yaml +23 -0
- morphogen/templates/optimize_conductivity.yaml +20 -0
- morphogen/templates/osteons.yaml +28 -0
- morphogen/templates/penetrable_spheres.yaml +21 -0
- morphogen/templates/poisson_fibers.yaml +21 -0
- morphogen/templates/random_laminate.yaml +26 -0
- morphogen/templates/random_lattice.yaml +27 -0
- morphogen/templates/random_walk_fibers.yaml +26 -0
- morphogen/templates/reaction_diffusion.yaml +22 -0
- morphogen/templates/reconstruction.yaml +22 -0
- morphogen/templates/rve_cellular_automaton.yaml +23 -0
- morphogen/templates/rve_crystal_plasticity_fft.yaml +51 -0
- morphogen/templates/rve_multiphysics.yaml +43 -0
- morphogen/templates/rve_poisson_fibers.yaml +22 -0
- morphogen/templates/rve_poisson_fibers_fe.yaml +33 -0
- morphogen/templates/rve_voronoi_windows.yaml +20 -0
- morphogen/templates/scale_rich_network.yaml +29 -0
- morphogen/templates/scale_rich_plates.yaml +30 -0
- morphogen/templates/sequential_dead_leaves.yaml +25 -0
- morphogen/templates/strut_lattice.yaml +21 -0
- morphogen/templates/tile_assembly.yaml +28 -0
- morphogen/templates/tpms.yaml +19 -0
- morphogen/templates/trabecular_bone.yaml +29 -0
- morphogen/templates/transparent_dead_leaves.yaml +23 -0
- morphogen/templates/vascular_tree.yaml +23 -0
- morphogen/templates/voronoi.yaml +20 -0
- morphogen/templates/wood.yaml +34 -0
- morphogen/templates/workflow.yaml +56 -0
- morphogen/texture.py +665 -0
- morphogen/theory.py +162 -0
- morphogen/viz/__init__.py +12 -0
- morphogen/viz/export.py +244 -0
- morphogen/viz/figures.py +707 -0
- morphogen/viz/png.py +148 -0
- morphogen/viz/sections.py +696 -0
- morphogen/viz/surfaces.py +1352 -0
- morphogen/viz/video.py +904 -0
- morphogen/viz/workflow.py +488 -0
- morphogen-1.0.0.dist-info/METADATA +2316 -0
- morphogen-1.0.0.dist-info/RECORD +381 -0
- morphogen-1.0.0.dist-info/WHEEL +4 -0
- morphogen-1.0.0.dist-info/entry_points.txt +5 -0
- 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
|
+
}
|