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,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
|
+
)
|