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,2285 @@
|
|
|
1
|
+
// Behaviours of the integration points on the GPU (morphogen.homogenization.gpu): ports,
|
|
2
|
+
// line by line, of the Numba kernels of morphogen.homogenization.tensors (small dense
|
|
3
|
+
// algebra), .behaviours (von Mises elasto-(visco)plasticity, Hill's criterion), .crystal
|
|
4
|
+
// (Méric-Cailletaud crystal plasticity), .porous (porous plasticity: GTN, Rousselier, the
|
|
5
|
+
// elliptic criterion) and .finite (the space of the logarithmic strain);
|
|
6
|
+
// one thread per point. The Numba kernels are the reference: a change of a behaviour is made
|
|
7
|
+
// in both, and tests/test_gpu.py compares them point by point.
|
|
8
|
+
//
|
|
9
|
+
// Prepended by morphogen.homogenization.gpu: NS (slip systems of the arrays of the
|
|
10
|
+
// crystals), WIDTH (internal variables of a point) and the constants of the Python modules
|
|
11
|
+
// (CP_ALPHA, STATE_P, STATE_X, KIN, N_PARAMS, PARAMS_WIDTH, ROW_WIDTH, N_CP, MAX_ISOTROPIC,
|
|
12
|
+
// ELASTIC, PLASTIC, CRYSTAL, MFRONT, HILL, POROUS, HILL_IT, SLIP_FLOOR, LOCAL_TOL,
|
|
13
|
+
// MAX_LOCAL, MAX_ROUNDS, SHRINK, SUBSTEP_LEVELS, and those of the porous rows: P_..., the
|
|
14
|
+
// criteria GURSON, ROUSSELIER, ELLIPTIC, POROUS_ISOTROPIC, POROUS_KINEMATIC, STATE_FG,
|
|
15
|
+
// STATE_FN, STATE_SSTAR, STATE_BACK). The rows of parameters are ROW_WIDTH wide: those of
|
|
16
|
+
// von Mises (N_PARAMS), then the coefficients of Hill (PARAMS_WIDTH), or those of a porous
|
|
17
|
+
// point.
|
|
18
|
+
// The points of MFront behaviours (MFRONT) are skipped: MGIS integrates them on the CPU.
|
|
19
|
+
//
|
|
20
|
+
// Arrays of the points are stored point by point, as on the CPU: strains (n x 6,
|
|
21
|
+
// engineering) or displacement gradients (n x 9, row by row), stresses, tangents (n x 6 x 6
|
|
22
|
+
// or n x 9 x 9), internal variables (n x WIDTH).
|
|
23
|
+
|
|
24
|
+
#define MG_INF __longlong_as_double(0x7ff0000000000000LL)
|
|
25
|
+
|
|
26
|
+
// max and min with the semantics of Python's (and Numba's): the first argument unless the
|
|
27
|
+
// second is strictly greater (smaller)
|
|
28
|
+
__device__ __forceinline__ double pmax(double a, double b) { return b > a ? b : a; }
|
|
29
|
+
__device__ __forceinline__ double pmin(double a, double b) { return b < a ? b : a; }
|
|
30
|
+
|
|
31
|
+
// ---- algebra: morphogen.homogenization.tensors -------------------------------------------
|
|
32
|
+
|
|
33
|
+
__device__ __forceinline__ void matmul3(double a[3][3], double b[3][3], double out[3][3]) {
|
|
34
|
+
for (int i = 0; i < 3; ++i)
|
|
35
|
+
for (int j = 0; j < 3; ++j)
|
|
36
|
+
out[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
__device__ __forceinline__ void tmatmul3(double a[3][3], double b[3][3], double out[3][3]) {
|
|
40
|
+
for (int i = 0; i < 3; ++i)
|
|
41
|
+
for (int j = 0; j < 3; ++j)
|
|
42
|
+
out[i][j] = a[0][i] * b[0][j] + a[1][i] * b[1][j] + a[2][i] * b[2][j];
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
__device__ __forceinline__ void matmult3(double a[3][3], double b[3][3], double out[3][3]) {
|
|
46
|
+
for (int i = 0; i < 3; ++i)
|
|
47
|
+
for (int j = 0; j < 3; ++j)
|
|
48
|
+
out[i][j] = a[i][0] * b[j][0] + a[i][1] * b[j][1] + a[i][2] * b[j][2];
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
__device__ __forceinline__ void strain_voigt(double t[3][3], double* out) {
|
|
52
|
+
out[0] = t[0][0];
|
|
53
|
+
out[1] = t[1][1];
|
|
54
|
+
out[2] = t[2][2];
|
|
55
|
+
out[3] = t[1][2] + t[2][1];
|
|
56
|
+
out[4] = t[2][0] + t[0][2];
|
|
57
|
+
out[5] = t[0][1] + t[1][0];
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
__device__ __forceinline__ void stress_tensor(const double* v, double out[3][3]) {
|
|
61
|
+
out[0][0] = v[0];
|
|
62
|
+
out[1][1] = v[1];
|
|
63
|
+
out[2][2] = v[2];
|
|
64
|
+
out[1][2] = v[3];
|
|
65
|
+
out[2][1] = v[3];
|
|
66
|
+
out[2][0] = v[4];
|
|
67
|
+
out[0][2] = v[4];
|
|
68
|
+
out[0][1] = v[5];
|
|
69
|
+
out[1][0] = v[5];
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
__device__ __forceinline__ void elastic_stress(const double* d, double strain[3][3],
|
|
73
|
+
double out[3][3], double* e6, double* s6) {
|
|
74
|
+
strain_voigt(strain, e6);
|
|
75
|
+
for (int r = 0; r < 6; ++r) {
|
|
76
|
+
double acc = 0.0;
|
|
77
|
+
for (int c = 0; c < 6; ++c) acc += d[6 * r + c] * e6[c];
|
|
78
|
+
s6[r] = acc;
|
|
79
|
+
}
|
|
80
|
+
stress_tensor(s6, out);
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
__device__ __forceinline__ double project(const double* lv, const double* nv,
|
|
84
|
+
double t[3][3]) {
|
|
85
|
+
double acc = 0.0;
|
|
86
|
+
for (int i = 0; i < 3; ++i)
|
|
87
|
+
acc += lv[i] * (t[i][0] * nv[0] + t[i][1] * nv[1] + t[i][2] * nv[2]);
|
|
88
|
+
return acc;
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
// a (n x n, row by row) replaced by its symmetric part (symmetrize)
|
|
92
|
+
__device__ __forceinline__ void symmetrize(double* a, int n) {
|
|
93
|
+
for (int r = 0; r < n; ++r)
|
|
94
|
+
for (int c = r + 1; c < n; ++c) {
|
|
95
|
+
double m = 0.5 * (a[n * r + c] + a[n * c + r]);
|
|
96
|
+
a[n * r + c] = m;
|
|
97
|
+
a[n * c + r] = m;
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
__device__ double inverse3(double a[3][3], double out[3][3]) {
|
|
102
|
+
double c00 = a[1][1] * a[2][2] - a[1][2] * a[2][1];
|
|
103
|
+
double c01 = a[1][2] * a[2][0] - a[1][0] * a[2][2];
|
|
104
|
+
double c02 = a[1][0] * a[2][1] - a[1][1] * a[2][0];
|
|
105
|
+
double det = a[0][0] * c00 + a[0][1] * c01 + a[0][2] * c02;
|
|
106
|
+
double inv = 1.0 / det;
|
|
107
|
+
out[0][0] = c00 * inv;
|
|
108
|
+
out[1][0] = c01 * inv;
|
|
109
|
+
out[2][0] = c02 * inv;
|
|
110
|
+
out[0][1] = (a[0][2] * a[2][1] - a[0][1] * a[2][2]) * inv;
|
|
111
|
+
out[1][1] = (a[0][0] * a[2][2] - a[0][2] * a[2][0]) * inv;
|
|
112
|
+
out[2][1] = (a[0][1] * a[2][0] - a[0][0] * a[2][1]) * inv;
|
|
113
|
+
out[0][2] = (a[0][1] * a[1][2] - a[0][2] * a[1][1]) * inv;
|
|
114
|
+
out[1][2] = (a[0][2] * a[1][0] - a[0][0] * a[1][2]) * inv;
|
|
115
|
+
out[2][2] = (a[0][0] * a[1][1] - a[0][1] * a[1][0]) * inv;
|
|
116
|
+
return det;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// a (n x n, rows of lda) x = b (n x m, rows of ldb) by Gaussian elimination with partial
|
|
120
|
+
// pivoting, in place; returns 1 if a is singular
|
|
121
|
+
__device__ __noinline__ int gauss_solve(double* a, int lda, double* b, int ldb, int n, int m) {
|
|
122
|
+
for (int k = 0; k < n; ++k) {
|
|
123
|
+
int piv = k;
|
|
124
|
+
double big = fabs(a[k * lda + k]);
|
|
125
|
+
for (int i = k + 1; i < n; ++i) {
|
|
126
|
+
if (fabs(a[i * lda + k]) > big) {
|
|
127
|
+
big = fabs(a[i * lda + k]);
|
|
128
|
+
piv = i;
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
if (!(big > 1e-300) || !isfinite(big)) return 1;
|
|
132
|
+
if (piv != k) {
|
|
133
|
+
for (int j = 0; j < n; ++j) {
|
|
134
|
+
double tmp = a[k * lda + j];
|
|
135
|
+
a[k * lda + j] = a[piv * lda + j];
|
|
136
|
+
a[piv * lda + j] = tmp;
|
|
137
|
+
}
|
|
138
|
+
for (int j = 0; j < m; ++j) {
|
|
139
|
+
double tmp = b[k * ldb + j];
|
|
140
|
+
b[k * ldb + j] = b[piv * ldb + j];
|
|
141
|
+
b[piv * ldb + j] = tmp;
|
|
142
|
+
}
|
|
143
|
+
}
|
|
144
|
+
double inv = 1.0 / a[k * lda + k];
|
|
145
|
+
for (int i = k + 1; i < n; ++i) {
|
|
146
|
+
double f = a[i * lda + k] * inv;
|
|
147
|
+
if (f != 0.0) {
|
|
148
|
+
for (int j = k + 1; j < n; ++j) a[i * lda + j] -= f * a[k * lda + j];
|
|
149
|
+
for (int j = 0; j < m; ++j) b[i * ldb + j] -= f * b[k * ldb + j];
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
for (int k = n - 1; k >= 0; --k) {
|
|
154
|
+
double inv = 1.0 / a[k * lda + k];
|
|
155
|
+
for (int j = 0; j < m; ++j) {
|
|
156
|
+
double acc = b[k * ldb + j];
|
|
157
|
+
for (int i = k + 1; i < n; ++i) acc -= a[k * lda + i] * b[i * ldb + j];
|
|
158
|
+
b[k * ldb + j] = acc * inv;
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
return 0;
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
// eigenvalues w and eigenvectors (columns of v) of a symmetric matrix by Jacobi's method;
|
|
165
|
+
// a is overwritten
|
|
166
|
+
__device__ __noinline__ void eigh3(double a[3][3], double* w, double v[3][3]) {
|
|
167
|
+
for (int i = 0; i < 3; ++i)
|
|
168
|
+
for (int j = 0; j < 3; ++j) v[i][j] = i == j ? 1.0 : 0.0;
|
|
169
|
+
for (int it = 0; it < 60; ++it) {
|
|
170
|
+
double off = a[0][1] * a[0][1] + a[0][2] * a[0][2] + a[1][2] * a[1][2];
|
|
171
|
+
double scale = a[0][0] * a[0][0] + a[1][1] * a[1][1] + a[2][2] * a[2][2];
|
|
172
|
+
if (off <= 1e-36 * scale || off == 0.0) break;
|
|
173
|
+
for (int p = 0; p < 2; ++p) {
|
|
174
|
+
for (int q = p + 1; q < 3; ++q) {
|
|
175
|
+
double apq = a[p][q];
|
|
176
|
+
if (apq == 0.0) continue;
|
|
177
|
+
double theta = (a[q][q] - a[p][p]) / (2.0 * apq);
|
|
178
|
+
double t;
|
|
179
|
+
if (fabs(theta) > 1e150) {
|
|
180
|
+
t = 0.5 / theta;
|
|
181
|
+
} else {
|
|
182
|
+
t = 1.0 / (fabs(theta) + sqrt(theta * theta + 1.0));
|
|
183
|
+
if (theta < 0.0) t = -t;
|
|
184
|
+
}
|
|
185
|
+
double c = 1.0 / sqrt(t * t + 1.0);
|
|
186
|
+
double s = t * c;
|
|
187
|
+
for (int k = 0; k < 3; ++k) {
|
|
188
|
+
double akp = a[k][p];
|
|
189
|
+
double akq = a[k][q];
|
|
190
|
+
a[k][p] = c * akp - s * akq;
|
|
191
|
+
a[k][q] = s * akp + c * akq;
|
|
192
|
+
}
|
|
193
|
+
for (int k = 0; k < 3; ++k) {
|
|
194
|
+
double apk = a[p][k];
|
|
195
|
+
double aqk = a[q][k];
|
|
196
|
+
a[p][k] = c * apk - s * aqk;
|
|
197
|
+
a[q][k] = s * apk + c * aqk;
|
|
198
|
+
}
|
|
199
|
+
for (int k = 0; k < 3; ++k) {
|
|
200
|
+
double vkp = v[k][p];
|
|
201
|
+
double vkq = v[k][q];
|
|
202
|
+
v[k][p] = c * vkp - s * vkq;
|
|
203
|
+
v[k][q] = s * vkp + c * vkq;
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
for (int i = 0; i < 3; ++i) w[i] = a[i][i];
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
__device__ __forceinline__ double half_log(double mu) { return 0.5 * log1p(mu); }
|
|
212
|
+
|
|
213
|
+
__device__ double log_divided(double x, double y) {
|
|
214
|
+
double z = (x - y) / (1.0 + y);
|
|
215
|
+
if (fabs(z) < 1e-4)
|
|
216
|
+
return 0.5 / (1.0 + y) * (1.0 - z * (0.5 - z * (1.0 / 3.0 - 0.25 * z)));
|
|
217
|
+
return 0.5 * log1p(z) / (x - y);
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
__device__ double log_divided2(double x, double y, double z) {
|
|
221
|
+
double lo = pmin(x, pmin(y, z));
|
|
222
|
+
double hi = pmax(x, pmax(y, z));
|
|
223
|
+
double mid = x + y + z - lo - hi;
|
|
224
|
+
double m = 1.0 + (x + y + z) / 3.0;
|
|
225
|
+
if (hi - lo <= 1e-4 * m) {
|
|
226
|
+
double d0 = 1.0 + x - m;
|
|
227
|
+
double d1 = 1.0 + y - m;
|
|
228
|
+
double d2 = 1.0 + z - m;
|
|
229
|
+
double h2 = 0.5 * (d0 * d0 + d1 * d1 + d2 * d2);
|
|
230
|
+
double h3 = d0 * d1 * d2;
|
|
231
|
+
double m2 = m * m;
|
|
232
|
+
return -0.25 / m2 - h2 / (8.0 * m2 * m2) + h3 / (10.0 * m2 * m2 * m);
|
|
233
|
+
}
|
|
234
|
+
return (log_divided(hi, mid) - log_divided(mid, lo)) / (hi - lo);
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
// ---- von Mises: morphogen.homogenization.behaviours ----------------------------------------
|
|
238
|
+
|
|
239
|
+
__device__ __forceinline__ double ddot6(const double* a, const double* b) {
|
|
240
|
+
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
|
|
241
|
+
+ 2.0 * (a[3] * b[3] + a[4] * b[4] + a[5] * b[5]);
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
__device__ __forceinline__ void j2_hardening(const double* par, double p, double* r,
|
|
245
|
+
double* dr) {
|
|
246
|
+
double rr = par[3] * p;
|
|
247
|
+
double d = par[3];
|
|
248
|
+
for (int i = 0; i < MAX_ISOTROPIC; ++i) {
|
|
249
|
+
double q = par[6 + 2 * i];
|
|
250
|
+
if (q != 0.0) {
|
|
251
|
+
double b = par[7 + 2 * i];
|
|
252
|
+
double e = exp(-b * p);
|
|
253
|
+
rr += q * (1.0 - e);
|
|
254
|
+
d += q * b * e;
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
*r = rr;
|
|
258
|
+
*dr = d;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
__device__ double j2_phi(const double* par, int nk, const double* s_tr, const double* old,
|
|
262
|
+
double dp, double* xi, double* nrm, double* w, double* dphi,
|
|
263
|
+
double* jm_out) {
|
|
264
|
+
double mu = par[1];
|
|
265
|
+
double csum = 0.0;
|
|
266
|
+
double c2sum = 0.0;
|
|
267
|
+
for (int r = 0; r < 6; ++r) {
|
|
268
|
+
xi[r] = s_tr[r];
|
|
269
|
+
w[r] = 0.0;
|
|
270
|
+
}
|
|
271
|
+
for (int k = 0; k < nk; ++k) {
|
|
272
|
+
double c = par[KIN + 2 * k];
|
|
273
|
+
double d = par[KIN + 2 * k + 1];
|
|
274
|
+
double th = 1.0 / (1.0 + d * dp);
|
|
275
|
+
csum += th * c;
|
|
276
|
+
c2sum += th * th * c;
|
|
277
|
+
int base = STATE_X + 6 * k;
|
|
278
|
+
for (int r = 0; r < 6; ++r) {
|
|
279
|
+
double xk = old[base + r];
|
|
280
|
+
xi[r] -= th * xk;
|
|
281
|
+
w[r] += d * th * th * xk;
|
|
282
|
+
}
|
|
283
|
+
}
|
|
284
|
+
double jm = sqrt(pmax(1.5 * ddot6(xi, xi), 0.0));
|
|
285
|
+
double inv = jm > 0.0 ? 1.5 / jm : 0.0;
|
|
286
|
+
for (int r = 0; r < 6; ++r) nrm[r] = inv * xi[r];
|
|
287
|
+
double rr, dr;
|
|
288
|
+
j2_hardening(par, old[STATE_P] + dp, &rr, &dr);
|
|
289
|
+
double phi = jm - (3.0 * mu + csum) * dp - rr - par[2];
|
|
290
|
+
*dphi = ddot6(nrm, w) - 3.0 * mu - c2sum - dr;
|
|
291
|
+
*jm_out = jm;
|
|
292
|
+
return phi;
|
|
293
|
+
}
|
|
294
|
+
|
|
295
|
+
__device__ void elastic_tangent(double lam, double mu, double* tan) {
|
|
296
|
+
for (int r = 0; r < 6; ++r)
|
|
297
|
+
for (int c = 0; c < 6; ++c) tan[6 * r + c] = 0.0;
|
|
298
|
+
for (int r = 0; r < 3; ++r) {
|
|
299
|
+
for (int c = 0; c < 3; ++c) tan[6 * r + c] = lam;
|
|
300
|
+
tan[6 * r + r] += 2.0 * mu;
|
|
301
|
+
tan[6 * (3 + r) + 3 + r] = mu;
|
|
302
|
+
}
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
// implicit update of a von Mises point (_j2_update), its tangent symmetrized with sym;
|
|
306
|
+
// returns 1 on failure
|
|
307
|
+
__device__ __noinline__ int j2_update(const double* par, int nk, const double* eps,
|
|
308
|
+
const double* eth, double dt, const double* old,
|
|
309
|
+
double* nw, double* sig, double* tan, int sym) {
|
|
310
|
+
double lam = par[0];
|
|
311
|
+
double mu = par[1];
|
|
312
|
+
double kv = par[4];
|
|
313
|
+
double nv = par[5];
|
|
314
|
+
double ee[6], s_tr[6], xi[6], nrm[6], w[6], d[6], dxi[6];
|
|
315
|
+
for (int r = 0; r < 6; ++r) {
|
|
316
|
+
double e = r < 3 ? eps[r] : 0.5 * eps[r];
|
|
317
|
+
ee[r] = e - eth[r] - old[r];
|
|
318
|
+
}
|
|
319
|
+
double tr = ee[0] + ee[1] + ee[2];
|
|
320
|
+
for (int r = 0; r < 6; ++r) sig[r] = 2.0 * mu * ee[r];
|
|
321
|
+
for (int r = 0; r < 3; ++r) sig[r] += lam * tr;
|
|
322
|
+
double mean = (sig[0] + sig[1] + sig[2]) / 3.0;
|
|
323
|
+
for (int r = 0; r < 6; ++r) s_tr[r] = r < 3 ? sig[r] - mean : sig[r];
|
|
324
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = old[r];
|
|
325
|
+
double dphi, jm;
|
|
326
|
+
double f_tr = j2_phi(par, nk, s_tr, old, 0.0, xi, nrm, w, &dphi, &jm);
|
|
327
|
+
double rr0, dr0;
|
|
328
|
+
j2_hardening(par, old[STATE_P], &rr0, &dr0);
|
|
329
|
+
double scale = jm + par[2] + fabs(rr0) + 1e-300;
|
|
330
|
+
if (f_tr <= 1e-13 * scale) {
|
|
331
|
+
elastic_tangent(lam, mu, tan);
|
|
332
|
+
return 0;
|
|
333
|
+
}
|
|
334
|
+
double tol = 1e-12 * scale;
|
|
335
|
+
double dp = 0.0;
|
|
336
|
+
double y = 0.0;
|
|
337
|
+
bool converged = false;
|
|
338
|
+
if (kv > 0.0) {
|
|
339
|
+
// viscoplastic: unknown y = (dp / dt)^(1/N), the viscous stress over K
|
|
340
|
+
double lo = 0.0, hi = f_tr / kv;
|
|
341
|
+
y = 0.5 * hi;
|
|
342
|
+
for (int it = 0; it < 200; ++it) {
|
|
343
|
+
dp = dt * pow(y, nv);
|
|
344
|
+
double phi = j2_phi(par, nk, s_tr, old, dp, xi, nrm, w, &dphi, &jm);
|
|
345
|
+
double res = phi - kv * y;
|
|
346
|
+
if (fabs(res) <= tol) {
|
|
347
|
+
converged = true;
|
|
348
|
+
break;
|
|
349
|
+
}
|
|
350
|
+
if (res > 0.0)
|
|
351
|
+
lo = y;
|
|
352
|
+
else
|
|
353
|
+
hi = y;
|
|
354
|
+
double der = dphi * nv * dt * pow(y, nv - 1.0) - kv;
|
|
355
|
+
double step = der < 0.0 ? y - res / der : 0.5 * (lo + hi);
|
|
356
|
+
if (!(lo < step && step < hi)) step = 0.5 * (lo + hi);
|
|
357
|
+
if (fabs(step - y) <= 1e-15 * hi) {
|
|
358
|
+
y = step;
|
|
359
|
+
converged = true;
|
|
360
|
+
break;
|
|
361
|
+
}
|
|
362
|
+
y = step;
|
|
363
|
+
}
|
|
364
|
+
dp = dt * pow(y, nv);
|
|
365
|
+
} else {
|
|
366
|
+
// rate-independent: unknown dp, bracketed by doubling
|
|
367
|
+
double lo = 0.0, hi = f_tr / (3.0 * mu);
|
|
368
|
+
for (int it = 0; it < 200; ++it) {
|
|
369
|
+
double phi = j2_phi(par, nk, s_tr, old, hi, xi, nrm, w, &dphi, &jm);
|
|
370
|
+
if (phi < 0.0) break;
|
|
371
|
+
lo = hi;
|
|
372
|
+
hi *= 2.0;
|
|
373
|
+
}
|
|
374
|
+
dp = lo + 0.5 * (hi - lo);
|
|
375
|
+
for (int it = 0; it < 200; ++it) {
|
|
376
|
+
double phi = j2_phi(par, nk, s_tr, old, dp, xi, nrm, w, &dphi, &jm);
|
|
377
|
+
if (fabs(phi) <= tol) {
|
|
378
|
+
converged = true;
|
|
379
|
+
break;
|
|
380
|
+
}
|
|
381
|
+
if (phi > 0.0)
|
|
382
|
+
lo = dp;
|
|
383
|
+
else
|
|
384
|
+
hi = dp;
|
|
385
|
+
double step = dphi < 0.0 ? dp - phi / dphi : 0.5 * (lo + hi);
|
|
386
|
+
if (!(lo < step && step < hi)) step = 0.5 * (lo + hi);
|
|
387
|
+
if (fabs(step - dp) <= 1e-15 * hi) {
|
|
388
|
+
dp = step;
|
|
389
|
+
converged = true;
|
|
390
|
+
break;
|
|
391
|
+
}
|
|
392
|
+
dp = step;
|
|
393
|
+
}
|
|
394
|
+
}
|
|
395
|
+
if (!converged || !isfinite(dp)) return 1;
|
|
396
|
+
j2_phi(par, nk, s_tr, old, dp, xi, nrm, w, &dphi, &jm);
|
|
397
|
+
if (jm <= 0.0) return 1;
|
|
398
|
+
// new state and stress
|
|
399
|
+
for (int r = 0; r < 6; ++r) {
|
|
400
|
+
nw[r] = old[r] + dp * nrm[r];
|
|
401
|
+
sig[r] -= 2.0 * mu * dp * nrm[r];
|
|
402
|
+
}
|
|
403
|
+
nw[STATE_P] = old[STATE_P] + dp;
|
|
404
|
+
for (int k = 0; k < nk; ++k) {
|
|
405
|
+
double c = par[KIN + 2 * k];
|
|
406
|
+
double th = 1.0 / (1.0 + par[KIN + 2 * k + 1] * dp);
|
|
407
|
+
int base = STATE_X + 6 * k;
|
|
408
|
+
for (int r = 0; r < 6; ++r)
|
|
409
|
+
nw[base + r] = th * (old[base + r] + 2.0 / 3.0 * c * dp * nrm[r]);
|
|
410
|
+
}
|
|
411
|
+
// consistent tangent: d dp = 2 mu / h n : d eps
|
|
412
|
+
double h = -dphi;
|
|
413
|
+
if (kv > 0.0 && y > 0.0) {
|
|
414
|
+
double lg = (1.0 - nv) * log(y);
|
|
415
|
+
h = h + (lg < 700.0 ? kv / (nv * dt) * exp(lg) : MG_INF);
|
|
416
|
+
}
|
|
417
|
+
double inv_h = (h > 0.0 && isfinite(h)) ? 1.0 / h : 0.0;
|
|
418
|
+
for (int j = 0; j < 6; ++j) {
|
|
419
|
+
for (int r = 0; r < 6; ++r) d[r] = 0.0;
|
|
420
|
+
d[j] = j < 3 ? 1.0 : 0.5;
|
|
421
|
+
double trd = j < 3 ? 1.0 : 0.0;
|
|
422
|
+
double ddp = 2.0 * mu * ddot6(nrm, d) * inv_h;
|
|
423
|
+
for (int r = 0; r < 6; ++r) {
|
|
424
|
+
double dev = r < 3 ? d[r] - trd / 3.0 : d[r];
|
|
425
|
+
dxi[r] = 2.0 * mu * dev + w[r] * ddp;
|
|
426
|
+
}
|
|
427
|
+
double ndxi = ddot6(nrm, dxi);
|
|
428
|
+
for (int r = 0; r < 6; ++r) {
|
|
429
|
+
double dn = 1.5 / jm * (dxi[r] - 2.0 / 3.0 * nrm[r] * ndxi);
|
|
430
|
+
double ds = 2.0 * mu * d[r] - 2.0 * mu * (ddp * nrm[r] + dp * dn);
|
|
431
|
+
if (r < 3) ds += lam * trd;
|
|
432
|
+
tan[6 * r + j] = ds;
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
if (sym) symmetrize(tan, 6);
|
|
436
|
+
return 0;
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
// ---- Hill's criterion: morphogen.homogenization.behaviours (_hill_update) ----------------
|
|
440
|
+
|
|
441
|
+
// a = 3/2 P M P in Mandel's notation (_hill_matrix)
|
|
442
|
+
__device__ void hill_matrix(const double* h, double* a) {
|
|
443
|
+
for (int r = 0; r < 36; ++r) a[r] = 0.0;
|
|
444
|
+
for (int r = 0; r < 3; ++r)
|
|
445
|
+
for (int c = 0; c < 3; ++c) {
|
|
446
|
+
double acc = 0.0;
|
|
447
|
+
for (int k = 0; k < 3; ++k) {
|
|
448
|
+
double pr = (r == k ? 1.0 : 0.0) - 1.0 / 3.0;
|
|
449
|
+
double pc = (c == k ? 1.0 : 0.0) - 1.0 / 3.0;
|
|
450
|
+
acc += pr * h[k] * pc;
|
|
451
|
+
}
|
|
452
|
+
a[6 * r + c] = 1.5 * acc;
|
|
453
|
+
}
|
|
454
|
+
for (int r = 3; r < 6; ++r) a[6 * r + r] = 1.5 * h[r];
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
// residuals of a Hill update and their Jacobian (_hill_system); returns J_H (0 where the
|
|
458
|
+
// normal is not defined), with dp and d dp / d q
|
|
459
|
+
__device__ double hill_system(const double* par, int nk, const double* a, const double* s_tr,
|
|
460
|
+
const double* xn, double p0, const double* de, double q,
|
|
461
|
+
double dt, double* res, double* jac, double* sr, double* nrm,
|
|
462
|
+
double* w, double* nn, double* dp_out, double* ddp_out) {
|
|
463
|
+
double lam = par[0];
|
|
464
|
+
double mu = par[1];
|
|
465
|
+
double kv = par[4];
|
|
466
|
+
double nv = par[5];
|
|
467
|
+
double dp, ddp;
|
|
468
|
+
if (kv > 0.0) {
|
|
469
|
+
dp = dt * pow(q, nv);
|
|
470
|
+
ddp = q > 0.0 ? nv * dt * pow(q, nv - 1.0) : (nv == 1.0 ? dt : 0.0);
|
|
471
|
+
} else {
|
|
472
|
+
dp = q;
|
|
473
|
+
ddp = 1.0;
|
|
474
|
+
}
|
|
475
|
+
*dp_out = dp;
|
|
476
|
+
*ddp_out = ddp;
|
|
477
|
+
double cb = 0.0;
|
|
478
|
+
double cdb = 0.0;
|
|
479
|
+
for (int r = 0; r < 6; ++r) {
|
|
480
|
+
sr[r] = s_tr[r];
|
|
481
|
+
w[r] = 0.0;
|
|
482
|
+
}
|
|
483
|
+
for (int k = 0; k < nk; ++k) {
|
|
484
|
+
double c = par[KIN + 2 * k];
|
|
485
|
+
double d = par[KIN + 2 * k + 1];
|
|
486
|
+
double th = 1.0 / (1.0 + d * dp);
|
|
487
|
+
cb += 2.0 / 3.0 * th * c;
|
|
488
|
+
cdb += 2.0 / 3.0 * c * d * th * th;
|
|
489
|
+
for (int r = 0; r < 6; ++r) {
|
|
490
|
+
sr[r] -= th * xn[6 * k + r];
|
|
491
|
+
w[r] += d * th * th * xn[6 * k + r];
|
|
492
|
+
}
|
|
493
|
+
}
|
|
494
|
+
double tr = de[0] + de[1] + de[2];
|
|
495
|
+
for (int r = 0; r < 6; ++r) {
|
|
496
|
+
double b = (2.0 * mu + cb) * de[r] + (r < 3 ? lam * tr : 0.0);
|
|
497
|
+
sr[r] -= b;
|
|
498
|
+
w[r] += cdb * de[r];
|
|
499
|
+
}
|
|
500
|
+
double jj = 0.0;
|
|
501
|
+
for (int r = 0; r < 6; ++r) {
|
|
502
|
+
double acc = 0.0;
|
|
503
|
+
for (int c = 0; c < 6; ++c) acc += a[6 * r + c] * sr[c];
|
|
504
|
+
nrm[r] = acc;
|
|
505
|
+
jj += acc * sr[r];
|
|
506
|
+
}
|
|
507
|
+
if (!(jj > 0.0)) return 0.0;
|
|
508
|
+
double jh = sqrt(jj);
|
|
509
|
+
for (int r = 0; r < 6; ++r) nrm[r] /= jh;
|
|
510
|
+
for (int r = 0; r < 6; ++r)
|
|
511
|
+
for (int c = 0; c < 6; ++c) nn[6 * r + c] = (a[6 * r + c] - nrm[r] * nrm[c]) / jh;
|
|
512
|
+
double rr, dr;
|
|
513
|
+
j2_hardening(par, p0 + dp, &rr, &dr);
|
|
514
|
+
for (int r = 0; r < 6; ++r) res[r] = de[r] - dp * nrm[r];
|
|
515
|
+
res[6] = jh - rr - par[2] - (kv > 0.0 ? kv * q : 0.0);
|
|
516
|
+
for (int r = 0; r < 6; ++r) {
|
|
517
|
+
double rows = 0.0;
|
|
518
|
+
for (int c = 0; c < 3; ++c) rows += nn[6 * r + c];
|
|
519
|
+
for (int c = 0; c < 6; ++c)
|
|
520
|
+
jac[7 * r + c] = dp * ((2.0 * mu + cb) * nn[6 * r + c] + (c < 3 ? lam * rows : 0.0));
|
|
521
|
+
jac[7 * r + r] += 1.0;
|
|
522
|
+
double acc = 0.0;
|
|
523
|
+
for (int c = 0; c < 6; ++c) acc += nn[6 * r + c] * w[c];
|
|
524
|
+
jac[7 * r + 6] = (-nrm[r] - dp * acc) * ddp;
|
|
525
|
+
}
|
|
526
|
+
double ntr = nrm[0] + nrm[1] + nrm[2];
|
|
527
|
+
double nw = 0.0;
|
|
528
|
+
for (int c = 0; c < 6; ++c) {
|
|
529
|
+
jac[7 * 6 + c] = -((2.0 * mu + cb) * nrm[c] + (c < 3 ? lam * ntr : 0.0));
|
|
530
|
+
nw += nrm[c] * w[c];
|
|
531
|
+
}
|
|
532
|
+
jac[7 * 6 + 6] = (nw - dr) * ddp - (kv > 0.0 ? kv : 0.0);
|
|
533
|
+
return jh;
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
// a x = b for the m columns of b (n x m, row by row), Gauss's elimination with partial
|
|
537
|
+
// pivoting (_solve_in_place); 0 if a is singular
|
|
538
|
+
__device__ int hill_solve(double* a, double* b, int n, int m) {
|
|
539
|
+
for (int k = 0; k < n; ++k) {
|
|
540
|
+
int piv = k;
|
|
541
|
+
for (int r = k + 1; r < n; ++r)
|
|
542
|
+
if (fabs(a[n * r + k]) > fabs(a[n * piv + k])) piv = r;
|
|
543
|
+
if (!(fabs(a[n * piv + k]) > 0.0)) return 0;
|
|
544
|
+
if (piv != k) {
|
|
545
|
+
for (int c = 0; c < n; ++c) {
|
|
546
|
+
double t = a[n * k + c];
|
|
547
|
+
a[n * k + c] = a[n * piv + c];
|
|
548
|
+
a[n * piv + c] = t;
|
|
549
|
+
}
|
|
550
|
+
for (int c = 0; c < m; ++c) {
|
|
551
|
+
double t = b[m * k + c];
|
|
552
|
+
b[m * k + c] = b[m * piv + c];
|
|
553
|
+
b[m * piv + c] = t;
|
|
554
|
+
}
|
|
555
|
+
}
|
|
556
|
+
for (int r = k + 1; r < n; ++r) {
|
|
557
|
+
double f = a[n * r + k] / a[n * k + k];
|
|
558
|
+
if (f != 0.0) {
|
|
559
|
+
for (int c = k; c < n; ++c) a[n * r + c] -= f * a[n * k + c];
|
|
560
|
+
for (int c = 0; c < m; ++c) b[m * r + c] -= f * b[m * k + c];
|
|
561
|
+
}
|
|
562
|
+
}
|
|
563
|
+
}
|
|
564
|
+
for (int k = n - 1; k >= 0; --k)
|
|
565
|
+
for (int c = 0; c < m; ++c) {
|
|
566
|
+
double acc = b[m * k + c];
|
|
567
|
+
for (int j = k + 1; j < n; ++j) acc -= a[n * k + j] * b[m * j + c];
|
|
568
|
+
b[m * k + c] = acc / a[n * k + k];
|
|
569
|
+
}
|
|
570
|
+
return 1;
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
// implicit update of a point of Hill's criterion (_hill_update), its tangent symmetrized
|
|
574
|
+
// with sym; returns 1 on failure
|
|
575
|
+
__device__ __noinline__ int hill_update(const double* par, int nk, const double* eps,
|
|
576
|
+
const double* eth, double dt, const double* old,
|
|
577
|
+
double* nw, double* sig, double* tan, int sym) {
|
|
578
|
+
double lam = par[0];
|
|
579
|
+
double mu = par[1];
|
|
580
|
+
double kv = par[4];
|
|
581
|
+
double nv = par[5];
|
|
582
|
+
const double sq2 = sqrt(2.0);
|
|
583
|
+
double f[6], h[6], a[36], s_tr[6], ee[6], xn[6 * 4];
|
|
584
|
+
for (int r = 0; r < 6; ++r) {
|
|
585
|
+
f[r] = r < 3 ? 1.0 : sq2;
|
|
586
|
+
h[r] = par[N_PARAMS + r];
|
|
587
|
+
}
|
|
588
|
+
hill_matrix(h, a);
|
|
589
|
+
for (int r = 0; r < 6; ++r) {
|
|
590
|
+
double e = r < 3 ? eps[r] : 0.5 * eps[r];
|
|
591
|
+
ee[r] = e - eth[r] - old[r];
|
|
592
|
+
}
|
|
593
|
+
double tr = ee[0] + ee[1] + ee[2];
|
|
594
|
+
for (int r = 0; r < 6; ++r) s_tr[r] = f[r] * (2.0 * mu * ee[r] + (r < 3 ? lam * tr : 0.0));
|
|
595
|
+
for (int k = 0; k < nk; ++k)
|
|
596
|
+
for (int r = 0; r < 6; ++r) xn[6 * k + r] = f[r] * old[STATE_X + 6 * k + r];
|
|
597
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = old[r];
|
|
598
|
+
double p0 = old[STATE_P];
|
|
599
|
+
double res[7], jac[49], work[49], sr[6], nrm[6], w[6], nn[36], de[6], trial[6], step[7];
|
|
600
|
+
for (int r = 0; r < 6; ++r) de[r] = 0.0;
|
|
601
|
+
double dp, ddp;
|
|
602
|
+
double jh = hill_system(par, nk, a, s_tr, xn, p0, de, 0.0, dt, res, jac, sr, nrm, w, nn,
|
|
603
|
+
&dp, &ddp);
|
|
604
|
+
double f_tr = jh > 0.0 ? res[6] : -1.0;
|
|
605
|
+
double rr0, dr0;
|
|
606
|
+
j2_hardening(par, p0, &rr0, &dr0);
|
|
607
|
+
double scale = jh + par[2] + fabs(rr0) + 1e-300;
|
|
608
|
+
if (f_tr <= 1e-13 * scale) {
|
|
609
|
+
elastic_tangent(lam, mu, tan);
|
|
610
|
+
for (int r = 0; r < 6; ++r) sig[r] = s_tr[r] / f[r];
|
|
611
|
+
return 0;
|
|
612
|
+
}
|
|
613
|
+
// first guess: the plastic increment of the elastic predictor along its normal
|
|
614
|
+
double stiff = 0.0;
|
|
615
|
+
double ntr = nrm[0] + nrm[1] + nrm[2];
|
|
616
|
+
for (int r = 0; r < 6; ++r) stiff += nrm[r] * (2.0 * mu * nrm[r] + (r < 3 ? lam * ntr : 0.0));
|
|
617
|
+
double nn2 = 0.0;
|
|
618
|
+
for (int r = 0; r < 6; ++r) nn2 += nrm[r] * nrm[r];
|
|
619
|
+
for (int k = 0; k < nk; ++k) stiff += 2.0 / 3.0 * par[KIN + 2 * k] * nn2;
|
|
620
|
+
dp = f_tr / (stiff + pmax(dr0, 0.0));
|
|
621
|
+
double q = kv > 0.0 ? pmin(pow(dp / dt, 1.0 / nv), f_tr / kv) : dp;
|
|
622
|
+
if (kv > 0.0) dp = dt * pow(q, nv);
|
|
623
|
+
for (int r = 0; r < 6; ++r) de[r] = dp * nrm[r];
|
|
624
|
+
double e_scale = f_tr / (3.0 * mu) + 1e-300;
|
|
625
|
+
jh = hill_system(par, nk, a, s_tr, xn, p0, de, q, dt, res, jac, sr, nrm, w, nn, &dp, &ddp);
|
|
626
|
+
if (jh <= 0.0) return 1;
|
|
627
|
+
int converged = 0;
|
|
628
|
+
for (int it = 0; it < HILL_IT; ++it) {
|
|
629
|
+
double merit = 0.0;
|
|
630
|
+
for (int r = 0; r < 6; ++r) merit += (res[r] / e_scale) * (res[r] / e_scale);
|
|
631
|
+
merit += (res[6] / scale) * (res[6] / scale);
|
|
632
|
+
double big = 0.0;
|
|
633
|
+
for (int r = 0; r < 6; ++r) big = pmax(big, fabs(res[r]));
|
|
634
|
+
if (big <= 1e-12 * e_scale && fabs(res[6]) <= 1e-12 * scale) {
|
|
635
|
+
converged = 1;
|
|
636
|
+
break;
|
|
637
|
+
}
|
|
638
|
+
for (int r = 0; r < 7; ++r) {
|
|
639
|
+
step[r] = -res[r];
|
|
640
|
+
for (int c = 0; c < 7; ++c) work[7 * r + c] = jac[7 * r + c];
|
|
641
|
+
}
|
|
642
|
+
if (!hill_solve(work, step, 7, 1)) return 1;
|
|
643
|
+
// backtracking on the scaled residuals: the system of the accepted point is that of
|
|
644
|
+
// the next iteration
|
|
645
|
+
double alpha = 1.0;
|
|
646
|
+
int accepted = 0;
|
|
647
|
+
double qt = q;
|
|
648
|
+
double dpt = dp;
|
|
649
|
+
for (int ls = 0; ls < 16; ++ls) {
|
|
650
|
+
qt = q + alpha * step[6];
|
|
651
|
+
if (qt < 0.0) {
|
|
652
|
+
alpha *= 0.5;
|
|
653
|
+
continue;
|
|
654
|
+
}
|
|
655
|
+
for (int r = 0; r < 6; ++r) trial[r] = de[r] + alpha * step[r];
|
|
656
|
+
double ddpt;
|
|
657
|
+
double jt = hill_system(par, nk, a, s_tr, xn, p0, trial, qt, dt, res, jac, sr, nrm, w,
|
|
658
|
+
nn, &dpt, &ddpt);
|
|
659
|
+
if (jt > 0.0) {
|
|
660
|
+
double m = 0.0;
|
|
661
|
+
for (int r = 0; r < 6; ++r) m += (res[r] / e_scale) * (res[r] / e_scale);
|
|
662
|
+
m += (res[6] / scale) * (res[6] / scale);
|
|
663
|
+
if (m <= (1.0 - 1e-4 * alpha) * merit) {
|
|
664
|
+
accepted = 1;
|
|
665
|
+
break;
|
|
666
|
+
}
|
|
667
|
+
}
|
|
668
|
+
alpha *= 0.5;
|
|
669
|
+
}
|
|
670
|
+
if (!accepted) return 1;
|
|
671
|
+
q = qt;
|
|
672
|
+
dp = dpt;
|
|
673
|
+
for (int r = 0; r < 6; ++r) de[r] = trial[r];
|
|
674
|
+
}
|
|
675
|
+
if (!converged || !isfinite(dp)) return 1;
|
|
676
|
+
// new state and stress (tensor components)
|
|
677
|
+
tr = de[0] + de[1] + de[2];
|
|
678
|
+
for (int r = 0; r < 6; ++r) {
|
|
679
|
+
nw[r] = old[r] + de[r] / f[r];
|
|
680
|
+
sig[r] = (s_tr[r] - (2.0 * mu * de[r] + (r < 3 ? lam * tr : 0.0))) / f[r];
|
|
681
|
+
}
|
|
682
|
+
nw[STATE_P] = p0 + dp;
|
|
683
|
+
for (int k = 0; k < nk; ++k) {
|
|
684
|
+
double th = 1.0 / (1.0 + par[KIN + 2 * k + 1] * dp);
|
|
685
|
+
double c = par[KIN + 2 * k];
|
|
686
|
+
for (int r = 0; r < 6; ++r)
|
|
687
|
+
nw[STATE_X + 6 * k + r] = th * (xn[6 * k + r] + 2.0 / 3.0 * c * de[r]) / f[r];
|
|
688
|
+
}
|
|
689
|
+
// consistent tangent: jac d(de, q) = -d res / d eps_m, d sigma = C (d eps_m - d de)
|
|
690
|
+
double cm[36], rhs[42];
|
|
691
|
+
for (int r = 0; r < 36; ++r) cm[r] = 0.0;
|
|
692
|
+
for (int r = 0; r < 6; ++r) cm[6 * r + r] = 2.0 * mu;
|
|
693
|
+
for (int r = 0; r < 3; ++r)
|
|
694
|
+
for (int c = 0; c < 3; ++c) cm[6 * r + c] += lam;
|
|
695
|
+
for (int c = 0; c < 6; ++c) {
|
|
696
|
+
for (int r = 0; r < 6; ++r) {
|
|
697
|
+
double acc = 0.0;
|
|
698
|
+
for (int j = 0; j < 6; ++j) acc += nn[6 * r + j] * cm[6 * j + c];
|
|
699
|
+
rhs[6 * r + c] = dp * acc;
|
|
700
|
+
}
|
|
701
|
+
double acc = 0.0;
|
|
702
|
+
for (int j = 0; j < 6; ++j) acc += nrm[j] * cm[6 * j + c];
|
|
703
|
+
rhs[6 * 6 + c] = -acc;
|
|
704
|
+
}
|
|
705
|
+
for (int r = 0; r < 49; ++r) work[r] = jac[r];
|
|
706
|
+
if (!hill_solve(work, rhs, 7, 6)) return 1;
|
|
707
|
+
for (int r = 0; r < 6; ++r)
|
|
708
|
+
for (int c = 0; c < 6; ++c) {
|
|
709
|
+
double acc = cm[6 * r + c];
|
|
710
|
+
for (int j = 0; j < 6; ++j) acc -= cm[6 * r + j] * rhs[6 * j + c];
|
|
711
|
+
tan[6 * r + c] = acc / (f[r] * f[c]);
|
|
712
|
+
}
|
|
713
|
+
if (sym) symmetrize(tan, 6);
|
|
714
|
+
return 0;
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
// ---- crystal plasticity: morphogen.homogenization.crystal ---------------------------------
|
|
718
|
+
|
|
719
|
+
// The work arrays of crystal.work_arrays: wv (res, tau, fv, sgn, tau_tr, trial, res_t,
|
|
720
|
+
// dg, act, fv_t, the exponentials of the hardening), wm (jac, lu, dtau, amat), wr, w3, wg,
|
|
721
|
+
// w6 (m, C : m), s6, idx and the internal variables of two substeps.
|
|
722
|
+
struct Work {
|
|
723
|
+
double wv[11][NS];
|
|
724
|
+
double wm[4][NS][NS];
|
|
725
|
+
double wr[NS][9];
|
|
726
|
+
double w3[24][3][3];
|
|
727
|
+
double wg[3][NS][3][3];
|
|
728
|
+
double w6[2][NS][6];
|
|
729
|
+
double s6[6][9];
|
|
730
|
+
int idx[NS];
|
|
731
|
+
double bufs[2][WIDTH];
|
|
732
|
+
};
|
|
733
|
+
|
|
734
|
+
// Parameters of a slip system s: par[N_CP * s + (tau0, Q, b, C, D, K, n)]; interaction
|
|
735
|
+
// matrix h[NS * s + r]; slip systems sys[6 * s + (l, n)]
|
|
736
|
+
|
|
737
|
+
__device__ void tau_small(int ns, const double* dg, const double* tau_tr, double amat[NS][NS],
|
|
738
|
+
double* tau, double dtau[NS][NS], bool with_jac) {
|
|
739
|
+
for (int s = 0; s < ns; ++s) {
|
|
740
|
+
double t = tau_tr[s];
|
|
741
|
+
for (int r = 0; r < ns; ++r) t -= amat[s][r] * dg[r];
|
|
742
|
+
tau[s] = t;
|
|
743
|
+
}
|
|
744
|
+
if (with_jac)
|
|
745
|
+
for (int s = 0; s < ns; ++s)
|
|
746
|
+
for (int r = 0; r < ns; ++r) dtau[s][r] = -amat[s][r];
|
|
747
|
+
}
|
|
748
|
+
|
|
749
|
+
__device__ __noinline__ void tau_finite(int ns, const double* dg, const double* sys,
|
|
750
|
+
double fe_tr[3][3], const double* dm,
|
|
751
|
+
double eth[3][3], double* tau, double dtau[NS][NS],
|
|
752
|
+
bool with_jac, double w3[24][3][3],
|
|
753
|
+
double wg[3][NS][3][3], double s6[6][9]) {
|
|
754
|
+
double(*gam)[3] = w3[0];
|
|
755
|
+
double(*g)[3] = w3[1];
|
|
756
|
+
double(*fe)[3] = w3[2];
|
|
757
|
+
double(*ce)[3] = w3[3];
|
|
758
|
+
double(*se)[3] = w3[4];
|
|
759
|
+
double(*mm)[3] = w3[5];
|
|
760
|
+
double(*t1)[3] = w3[6];
|
|
761
|
+
double(*t2)[3] = w3[7];
|
|
762
|
+
double(*ee)[3] = w3[8];
|
|
763
|
+
for (int i = 0; i < 3; ++i)
|
|
764
|
+
for (int j = 0; j < 3; ++j) gam[i][j] = 0.0;
|
|
765
|
+
for (int r = 0; r < ns; ++r) {
|
|
766
|
+
double d = dg[r];
|
|
767
|
+
if (d != 0.0)
|
|
768
|
+
for (int i = 0; i < 3; ++i)
|
|
769
|
+
for (int j = 0; j < 3; ++j) gam[i][j] += d * sys[6 * r + i] * sys[6 * r + 3 + j];
|
|
770
|
+
}
|
|
771
|
+
matmul3(gam, gam, t1);
|
|
772
|
+
for (int i = 0; i < 3; ++i)
|
|
773
|
+
for (int j = 0; j < 3; ++j) g[i][j] = (i == j ? 1.0 : 0.0) - gam[i][j] + 0.5 * t1[i][j];
|
|
774
|
+
matmul3(fe_tr, g, fe);
|
|
775
|
+
tmatmul3(fe, fe, ce);
|
|
776
|
+
for (int i = 0; i < 3; ++i)
|
|
777
|
+
for (int j = 0; j < 3; ++j)
|
|
778
|
+
ee[i][j] = 0.5 * (ce[i][j] - (i == j ? 1.0 : 0.0)) - eth[i][j];
|
|
779
|
+
elastic_stress(dm, ee, se, s6[0], s6[1]);
|
|
780
|
+
matmul3(ce, se, mm);
|
|
781
|
+
for (int s = 0; s < ns; ++s) tau[s] = project(sys + 6 * s, sys + 6 * s + 3, mm);
|
|
782
|
+
if (!with_jac) return;
|
|
783
|
+
double* av = s6[2];
|
|
784
|
+
for (int r = 0; r < ns; ++r) {
|
|
785
|
+
double(*dgr)[3] = wg[0][r];
|
|
786
|
+
double(*dce)[3] = wg[1][r];
|
|
787
|
+
double(*dsr)[3] = wg[2][r];
|
|
788
|
+
const double* lr = sys + 6 * r;
|
|
789
|
+
const double* nr = sys + 6 * r + 3;
|
|
790
|
+
for (int i = 0; i < 3; ++i) {
|
|
791
|
+
av[i] = gam[0][i] * nr[0] + gam[1][i] * nr[1] + gam[2][i] * nr[2];
|
|
792
|
+
av[3 + i] = gam[i][0] * lr[0] + gam[i][1] * lr[1] + gam[i][2] * lr[2];
|
|
793
|
+
}
|
|
794
|
+
for (int i = 0; i < 3; ++i)
|
|
795
|
+
for (int j = 0; j < 3; ++j)
|
|
796
|
+
dgr[i][j] = -lr[i] * nr[j] + 0.5 * (lr[i] * av[j] + av[3 + i] * nr[j]);
|
|
797
|
+
matmul3(fe_tr, dgr, t1);
|
|
798
|
+
tmatmul3(t1, fe, t2);
|
|
799
|
+
for (int i = 0; i < 3; ++i)
|
|
800
|
+
for (int j = 0; j < 3; ++j) {
|
|
801
|
+
dce[i][j] = t2[i][j] + t2[j][i];
|
|
802
|
+
ee[i][j] = 0.5 * dce[i][j];
|
|
803
|
+
}
|
|
804
|
+
elastic_stress(dm, ee, dsr, s6[0], s6[1]);
|
|
805
|
+
matmul3(dce, se, t1);
|
|
806
|
+
matmul3(ce, dsr, t2);
|
|
807
|
+
for (int i = 0; i < 3; ++i)
|
|
808
|
+
for (int j = 0; j < 3; ++j) t1[i][j] += t2[i][j];
|
|
809
|
+
for (int s = 0; s < ns; ++s) dtau[s][r] = project(sys + 6 * s, sys + 6 * s + 3, t1);
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
// resolved shear stresses, overstresses fv, residuals of the active systems and their
|
|
814
|
+
// Jacobian (_cp_eval); returns the largest |R_s|
|
|
815
|
+
__device__ __noinline__ double cp_eval(bool finite, const double* par, const double* h,
|
|
816
|
+
int ns, double dt, const double* alpha0,
|
|
817
|
+
const double* v0, const double* dg, const double* act,
|
|
818
|
+
const double* sgn, const double* sys, const double* dm,
|
|
819
|
+
double fe_tr[3][3], double eth[3][3], Work* wk,
|
|
820
|
+
double* res, double* fv, bool with_jac) {
|
|
821
|
+
double* tau = wk->wv[1];
|
|
822
|
+
double(*dtau)[NS] = wk->wm[2];
|
|
823
|
+
double* ex = wk->wv[10]; // exp(-b v_r) of the systems r for the b of the last family
|
|
824
|
+
double b_ex = 0.0;
|
|
825
|
+
int have = 0;
|
|
826
|
+
if (finite)
|
|
827
|
+
tau_finite(ns, dg, sys, fe_tr, dm, eth, tau, dtau, with_jac, wk->w3, wk->wg, wk->s6);
|
|
828
|
+
else
|
|
829
|
+
tau_small(ns, dg, wk->wv[4], wk->wm[3], tau, dtau, with_jac);
|
|
830
|
+
double worst = 0.0;
|
|
831
|
+
for (int s = 0; s < ns; ++s) {
|
|
832
|
+
const double* ps = par + N_CP * s;
|
|
833
|
+
double tau0 = ps[0], q = ps[1], b = ps[2], c = ps[3], d = ps[4], k = ps[5], n = ps[6];
|
|
834
|
+
double mag = fabs(dg[s]);
|
|
835
|
+
double over = tau[s] - c * (alpha0[s] + dg[s]) / (1.0 + d * mag);
|
|
836
|
+
double iso = tau0;
|
|
837
|
+
if (q != 0.0) {
|
|
838
|
+
if (!have || b != b_ex) { // the systems of a family share their b
|
|
839
|
+
for (int r = 0; r < ns; ++r) ex[r] = exp(-b * (v0[r] + fabs(dg[r])));
|
|
840
|
+
b_ex = b;
|
|
841
|
+
have = 1;
|
|
842
|
+
}
|
|
843
|
+
double acc = 0.0;
|
|
844
|
+
for (int r = 0; r < ns; ++r) acc += h[NS * s + r] * (1.0 - ex[r]);
|
|
845
|
+
iso += q * acc;
|
|
846
|
+
}
|
|
847
|
+
fv[s] = fabs(over) - iso;
|
|
848
|
+
if (act[s] > 0.5) {
|
|
849
|
+
res[s] = sgn[s] * over - iso - k * pow(mag / dt, 1.0 / n);
|
|
850
|
+
worst = pmax(worst, fabs(res[s]));
|
|
851
|
+
} else {
|
|
852
|
+
res[s] = 0.0;
|
|
853
|
+
}
|
|
854
|
+
}
|
|
855
|
+
if (!isfinite(worst)) return MG_INF;
|
|
856
|
+
if (with_jac) {
|
|
857
|
+
double(*jac)[NS] = wk->wm[0];
|
|
858
|
+
for (int s = 0; s < ns; ++s) {
|
|
859
|
+
if (act[s] < 0.5) continue;
|
|
860
|
+
const double* ps = par + N_CP * s;
|
|
861
|
+
double q = ps[1], b = ps[2], c = ps[3], d = ps[4], k = ps[5], n = ps[6];
|
|
862
|
+
double mag = fabs(dg[s]);
|
|
863
|
+
if (q != 0.0 && (!have || b != b_ex)) {
|
|
864
|
+
for (int r = 0; r < ns; ++r) ex[r] = exp(-b * (v0[r] + fabs(dg[r])));
|
|
865
|
+
b_ex = b;
|
|
866
|
+
have = 1;
|
|
867
|
+
}
|
|
868
|
+
for (int r = 0; r < ns; ++r) {
|
|
869
|
+
if (act[r] < 0.5) continue;
|
|
870
|
+
double v = sgn[s] * sgn[r] * dtau[s][r];
|
|
871
|
+
if (q != 0.0) v -= q * h[NS * s + r] * b * ex[r];
|
|
872
|
+
if (r == s) {
|
|
873
|
+
double den = 1.0 + d * mag;
|
|
874
|
+
v -= c * (1.0 - d * sgn[s] * alpha0[s]) / (den * den);
|
|
875
|
+
v -= k / (n * dt) * pow(mag / dt, 1.0 / n - 1.0);
|
|
876
|
+
}
|
|
877
|
+
jac[s][r] = v;
|
|
878
|
+
}
|
|
879
|
+
}
|
|
880
|
+
}
|
|
881
|
+
return worst;
|
|
882
|
+
}
|
|
883
|
+
|
|
884
|
+
__device__ int active_indices(const double* act, int ns, int* idx) {
|
|
885
|
+
int na = 0;
|
|
886
|
+
for (int s = 0; s < ns; ++s)
|
|
887
|
+
if (act[s] > 0.5) idx[na++] = s;
|
|
888
|
+
return na;
|
|
889
|
+
}
|
|
890
|
+
|
|
891
|
+
// Newton's method on the magnitudes of the slips of the active systems (_active_newton)
|
|
892
|
+
__device__ __noinline__ int active_newton(bool finite, const double* par, const double* h,
|
|
893
|
+
int ns, double dt, const double* alpha0,
|
|
894
|
+
const double* v0, const double* sys,
|
|
895
|
+
const double* dm, double fe_tr[3][3],
|
|
896
|
+
double eth[3][3], Work* wk, double tol) {
|
|
897
|
+
double* res = wk->wv[0];
|
|
898
|
+
double* fv = wk->wv[2];
|
|
899
|
+
double* sgn = wk->wv[3];
|
|
900
|
+
double* trial = wk->wv[5];
|
|
901
|
+
double* res_t = wk->wv[6];
|
|
902
|
+
double* dg = wk->wv[7];
|
|
903
|
+
double* act = wk->wv[8];
|
|
904
|
+
double* fv_t = wk->wv[9];
|
|
905
|
+
double(*jac)[NS] = wk->wm[0];
|
|
906
|
+
double(*lu)[NS] = wk->wm[1];
|
|
907
|
+
double(*wr)[9] = wk->wr;
|
|
908
|
+
int* idx = wk->idx;
|
|
909
|
+
for (int it = 0; it < MAX_LOCAL; ++it) {
|
|
910
|
+
double worst = cp_eval(finite, par, h, ns, dt, alpha0, v0, dg, act, sgn, sys, dm, fe_tr,
|
|
911
|
+
eth, wk, res, fv, true);
|
|
912
|
+
if (!isfinite(worst)) return 1;
|
|
913
|
+
if (worst <= tol) return 0;
|
|
914
|
+
bool dropped = false;
|
|
915
|
+
for (int s = 0; s < ns; ++s) {
|
|
916
|
+
if (act[s] > 0.5 && fabs(dg[s]) <= SLIP_FLOOR && res[s] < 0.0) {
|
|
917
|
+
act[s] = 0.0;
|
|
918
|
+
dg[s] = 0.0;
|
|
919
|
+
dropped = true;
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
if (dropped) continue;
|
|
923
|
+
int na = active_indices(act, ns, idx);
|
|
924
|
+
for (int a = 0; a < na; ++a) {
|
|
925
|
+
for (int c = 0; c < na; ++c) lu[a][c] = jac[idx[a]][idx[c]];
|
|
926
|
+
wr[a][0] = -res[idx[a]];
|
|
927
|
+
}
|
|
928
|
+
if (gauss_solve(&lu[0][0], NS, &wr[0][0], 9, na, 1) != 0) return 1;
|
|
929
|
+
double norm0 = 0.0;
|
|
930
|
+
for (int a = 0; a < na; ++a) norm0 += res[idx[a]] * res[idx[a]];
|
|
931
|
+
double t = 1.0;
|
|
932
|
+
bool accepted = false;
|
|
933
|
+
for (int ls = 0; ls < 30; ++ls) {
|
|
934
|
+
for (int s = 0; s < ns; ++s) trial[s] = dg[s];
|
|
935
|
+
for (int a = 0; a < na; ++a) {
|
|
936
|
+
int s = idx[a];
|
|
937
|
+
double mag = fabs(dg[s]) + t * wr[a][0];
|
|
938
|
+
trial[s] = sgn[s] * pmax(pmax(mag, SHRINK * fabs(dg[s])), SLIP_FLOOR);
|
|
939
|
+
}
|
|
940
|
+
double w = cp_eval(finite, par, h, ns, dt, alpha0, v0, trial, act, sgn, sys, dm,
|
|
941
|
+
fe_tr, eth, wk, res_t, fv_t, false);
|
|
942
|
+
double norm1 = 0.0;
|
|
943
|
+
for (int a = 0; a < na; ++a) norm1 += res_t[idx[a]] * res_t[idx[a]];
|
|
944
|
+
if (isfinite(w) && norm1 <= (1.0 - 1e-4 * t) * norm0) {
|
|
945
|
+
accepted = true;
|
|
946
|
+
break;
|
|
947
|
+
}
|
|
948
|
+
t *= 0.5;
|
|
949
|
+
}
|
|
950
|
+
if (!accepted) {
|
|
951
|
+
// stagnation at the level of rounding errors
|
|
952
|
+
cp_eval(finite, par, h, ns, dt, alpha0, v0, dg, act, sgn, sys, dm, fe_tr, eth, wk,
|
|
953
|
+
res, fv, true);
|
|
954
|
+
return worst <= 1e3 * tol ? 0 : 1;
|
|
955
|
+
}
|
|
956
|
+
for (int s = 0; s < ns; ++s) dg[s] = trial[s];
|
|
957
|
+
}
|
|
958
|
+
return 1;
|
|
959
|
+
}
|
|
960
|
+
|
|
961
|
+
// slips of the step by the active set strategy (_cp_solve)
|
|
962
|
+
__device__ __noinline__ int cp_solve(bool finite, const double* par, const double* h, int ns,
|
|
963
|
+
double dt, const double* alpha0, const double* v0,
|
|
964
|
+
const double* sys, const double* dm, double fe_tr[3][3],
|
|
965
|
+
double eth[3][3], Work* wk) {
|
|
966
|
+
double* res = wk->wv[0];
|
|
967
|
+
double* tau = wk->wv[1];
|
|
968
|
+
double* fv = wk->wv[2];
|
|
969
|
+
double* sgn = wk->wv[3];
|
|
970
|
+
double* dg = wk->wv[7];
|
|
971
|
+
double* act = wk->wv[8];
|
|
972
|
+
for (int s = 0; s < ns; ++s) {
|
|
973
|
+
if (fabs(dg[s]) > SLIP_FLOOR) {
|
|
974
|
+
act[s] = 1.0;
|
|
975
|
+
sgn[s] = dg[s] > 0.0 ? 1.0 : -1.0;
|
|
976
|
+
} else {
|
|
977
|
+
act[s] = 0.0;
|
|
978
|
+
dg[s] = 0.0;
|
|
979
|
+
}
|
|
980
|
+
}
|
|
981
|
+
double worst = cp_eval(finite, par, h, ns, dt, alpha0, v0, dg, act, sgn, sys, dm, fe_tr,
|
|
982
|
+
eth, wk, res, fv, true);
|
|
983
|
+
if (!isfinite(worst)) return 1;
|
|
984
|
+
double scale = 0.0;
|
|
985
|
+
for (int s = 0; s < ns; ++s)
|
|
986
|
+
scale = pmax(scale, fabs(tau[s]) + par[N_CP * s] + par[N_CP * s + 5]);
|
|
987
|
+
double tol = LOCAL_TOL * scale;
|
|
988
|
+
for (int round = 0; round < MAX_ROUNDS; ++round) {
|
|
989
|
+
if (active_newton(finite, par, h, ns, dt, alpha0, v0, sys, dm, fe_tr, eth, wk, tol))
|
|
990
|
+
return 1;
|
|
991
|
+
bool changed = false;
|
|
992
|
+
for (int s = 0; s < ns; ++s) {
|
|
993
|
+
if (act[s] > 0.5) continue;
|
|
994
|
+
double c = par[N_CP * s + 3];
|
|
995
|
+
double k = par[N_CP * s + 5];
|
|
996
|
+
double n = par[N_CP * s + 6];
|
|
997
|
+
if (fv[s] <= k * pow(SLIP_FLOOR / dt, 1.0 / n) + tol) continue;
|
|
998
|
+
// a new active system, from below: a slip that relaxes a tenth of its
|
|
999
|
+
// overstress at most, with a viscous stress half of it at most
|
|
1000
|
+
act[s] = 1.0;
|
|
1001
|
+
sgn[s] = tau[s] - c * alpha0[s] >= 0.0 ? 1.0 : -1.0;
|
|
1002
|
+
double relax = fabs(wk->wm[2][s][s]) + c;
|
|
1003
|
+
double d0 = pmin(dt * pow(0.5 * fv[s] / k, n), 0.1 * fv[s] / pmax(relax, 1e-300));
|
|
1004
|
+
dg[s] = sgn[s] * pmax(d0, SLIP_FLOOR);
|
|
1005
|
+
changed = true;
|
|
1006
|
+
}
|
|
1007
|
+
if (!changed) return 0;
|
|
1008
|
+
}
|
|
1009
|
+
return 1;
|
|
1010
|
+
}
|
|
1011
|
+
|
|
1012
|
+
__device__ void initial_slips(const double* old, const double* nw, const double* par, int ns,
|
|
1013
|
+
double* dg, int guess, double ratio) {
|
|
1014
|
+
for (int s = 0; s < ns; ++s) dg[s] = 0.0;
|
|
1015
|
+
if (guess == 0) return;
|
|
1016
|
+
const int a = CP_ALPHA;
|
|
1017
|
+
for (int s = 0; s < ns; ++s) {
|
|
1018
|
+
double d = par[N_CP * s + 4];
|
|
1019
|
+
double val;
|
|
1020
|
+
if (guess == 1) {
|
|
1021
|
+
double mag = nw[a + ns + s] - old[a + ns + s];
|
|
1022
|
+
val = nw[a + s] * (1.0 + d * mag) - old[a + s];
|
|
1023
|
+
} else {
|
|
1024
|
+
double mag = old[a + ns + s] - nw[a + ns + s];
|
|
1025
|
+
val = ratio * (old[a + s] * (1.0 + d * mag) - nw[a + s]);
|
|
1026
|
+
}
|
|
1027
|
+
if (isfinite(val)) dg[s] = val;
|
|
1028
|
+
}
|
|
1029
|
+
}
|
|
1030
|
+
|
|
1031
|
+
__device__ int solve_slips(bool finite, const double* par, const double* h, int ns, double dt,
|
|
1032
|
+
const double* old, const double* nw, const double* sys,
|
|
1033
|
+
const double* dm, double fe_tr[3][3], double eth[3][3], int guess,
|
|
1034
|
+
double ratio, Work* wk) {
|
|
1035
|
+
double* dg = wk->wv[7];
|
|
1036
|
+
const double* alpha0 = old + CP_ALPHA;
|
|
1037
|
+
const double* v0 = old + CP_ALPHA + ns;
|
|
1038
|
+
initial_slips(old, nw, par, ns, dg, guess, ratio);
|
|
1039
|
+
if (cp_solve(finite, par, h, ns, dt, alpha0, v0, sys, dm, fe_tr, eth, wk) == 0) return 0;
|
|
1040
|
+
if (guess == 0) return 1;
|
|
1041
|
+
initial_slips(old, nw, par, ns, dg, 0, 1.0);
|
|
1042
|
+
return cp_solve(finite, par, h, ns, dt, alpha0, v0, sys, dm, fe_tr, eth, wk);
|
|
1043
|
+
}
|
|
1044
|
+
|
|
1045
|
+
__device__ void update_hardening(const double* par, int ns, const double* dg,
|
|
1046
|
+
const double* old, double* nw) {
|
|
1047
|
+
for (int s = 0; s < ns; ++s) {
|
|
1048
|
+
double d = par[N_CP * s + 4];
|
|
1049
|
+
nw[CP_ALPHA + s] = (old[CP_ALPHA + s] + dg[s]) / (1.0 + d * fabs(dg[s]));
|
|
1050
|
+
nw[CP_ALPHA + ns + s] = old[CP_ALPHA + ns + s] + fabs(dg[s]);
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
|
|
1054
|
+
__device__ void schmid_small(const double* sys, int ns, const double* dm, double m[NS][6],
|
|
1055
|
+
double cm[NS][6], double* me) {
|
|
1056
|
+
for (int s = 0; s < ns; ++s) {
|
|
1057
|
+
double l0 = sys[6 * s], l1 = sys[6 * s + 1], l2 = sys[6 * s + 2];
|
|
1058
|
+
double n0 = sys[6 * s + 3], n1 = sys[6 * s + 4], n2 = sys[6 * s + 5];
|
|
1059
|
+
m[s][0] = l0 * n0;
|
|
1060
|
+
m[s][1] = l1 * n1;
|
|
1061
|
+
m[s][2] = l2 * n2;
|
|
1062
|
+
m[s][3] = 0.5 * (l1 * n2 + l2 * n1);
|
|
1063
|
+
m[s][4] = 0.5 * (l2 * n0 + l0 * n2);
|
|
1064
|
+
m[s][5] = 0.5 * (l0 * n1 + l1 * n0);
|
|
1065
|
+
for (int r = 0; r < 6; ++r) me[r] = r < 3 ? m[s][r] : 2.0 * m[s][r];
|
|
1066
|
+
for (int r = 0; r < 6; ++r) {
|
|
1067
|
+
double acc = 0.0;
|
|
1068
|
+
for (int c = 0; c < 6; ++c) acc += dm[6 * r + c] * me[c];
|
|
1069
|
+
cm[s][r] = acc;
|
|
1070
|
+
}
|
|
1071
|
+
}
|
|
1072
|
+
}
|
|
1073
|
+
|
|
1074
|
+
// backward Euler step of a small-strain point (_small_step)
|
|
1075
|
+
__device__ __noinline__ int small_step(const double* sys, const double* par, const double* h,
|
|
1076
|
+
int ns, const double* dm, const double* emech, double dt,
|
|
1077
|
+
const double* old, double* nw, double* sig, int guess,
|
|
1078
|
+
double ratio, Work* wk) {
|
|
1079
|
+
double(*m)[6] = wk->w6[0];
|
|
1080
|
+
double(*cm)[6] = wk->w6[1];
|
|
1081
|
+
double* tau_tr = wk->wv[4];
|
|
1082
|
+
double(*amat)[NS] = wk->wm[3];
|
|
1083
|
+
double* ee = wk->s6[0];
|
|
1084
|
+
for (int r = 0; r < 6; ++r) ee[r] = emech[r] - old[r] * (r < 3 ? 1.0 : 2.0);
|
|
1085
|
+
for (int r = 0; r < 6; ++r) {
|
|
1086
|
+
double acc = 0.0;
|
|
1087
|
+
for (int c = 0; c < 6; ++c) acc += dm[6 * r + c] * ee[c];
|
|
1088
|
+
sig[r] = acc;
|
|
1089
|
+
}
|
|
1090
|
+
for (int s = 0; s < ns; ++s) {
|
|
1091
|
+
tau_tr[s] = ddot6(m[s], sig);
|
|
1092
|
+
for (int r = 0; r < ns; ++r) amat[s][r] = ddot6(m[s], cm[r]);
|
|
1093
|
+
}
|
|
1094
|
+
if (solve_slips(false, par, h, ns, dt, old, nw, sys, dm, wk->w3[0], wk->w3[0], guess, ratio,
|
|
1095
|
+
wk))
|
|
1096
|
+
return 1;
|
|
1097
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = old[r];
|
|
1098
|
+
double* dg = wk->wv[7];
|
|
1099
|
+
double* dep = wk->s6[1];
|
|
1100
|
+
for (int r = 0; r < 6; ++r) dep[r] = 0.0;
|
|
1101
|
+
for (int s = 0; s < ns; ++s)
|
|
1102
|
+
for (int r = 0; r < 6; ++r) {
|
|
1103
|
+
dep[r] += dg[s] * m[s][r];
|
|
1104
|
+
sig[r] -= dg[s] * cm[s][r];
|
|
1105
|
+
}
|
|
1106
|
+
for (int r = 0; r < 6; ++r) nw[r] = old[r] + dep[r];
|
|
1107
|
+
nw[6] = old[6] + sqrt(pmax(2.0 / 3.0 * ddot6(dep, dep), 0.0));
|
|
1108
|
+
update_hardening(par, ns, dg, old, nw);
|
|
1109
|
+
return 0;
|
|
1110
|
+
}
|
|
1111
|
+
|
|
1112
|
+
// implicit update of a crystal point in small strains (cp_small), its tangent symmetrized
|
|
1113
|
+
// with sym
|
|
1114
|
+
__device__ __noinline__ int cp_small(const double* sys, const double* par, const double* h,
|
|
1115
|
+
int ns, const double* dm, const double* eps,
|
|
1116
|
+
const double* eth, double dt, const double* old,
|
|
1117
|
+
double* nw, double* sig, double* tan, int guess,
|
|
1118
|
+
double ratio, Work* wk, int sym) {
|
|
1119
|
+
double* sgn = wk->wv[3];
|
|
1120
|
+
double(*jac)[NS] = wk->wm[0];
|
|
1121
|
+
double(*lu)[NS] = wk->wm[1];
|
|
1122
|
+
double(*wr)[9] = wk->wr;
|
|
1123
|
+
double(*m)[6] = wk->w6[0];
|
|
1124
|
+
double(*cm)[6] = wk->w6[1];
|
|
1125
|
+
schmid_small(sys, ns, dm, m, cm, wk->s6[3]);
|
|
1126
|
+
double* emech = wk->s6[4];
|
|
1127
|
+
for (int r = 0; r < 6; ++r) emech[r] = eps[r] - eth[r] * (r < 3 ? 1.0 : 2.0);
|
|
1128
|
+
const int slot = CP_ALPHA + 2 * ns;
|
|
1129
|
+
if (small_step(sys, par, h, ns, dm, emech, dt, old, nw, sig, guess, ratio, wk) != 0) {
|
|
1130
|
+
double* ek = wk->s6[5];
|
|
1131
|
+
bool done = false;
|
|
1132
|
+
for (int level = 0; level < SUBSTEP_LEVELS; ++level) {
|
|
1133
|
+
int count = 1 << (2 * (level + 1));
|
|
1134
|
+
double* cur = wk->bufs[0];
|
|
1135
|
+
double* nxt = wk->bufs[1];
|
|
1136
|
+
for (int r = 0; r < WIDTH; ++r) cur[r] = old[r];
|
|
1137
|
+
bool ok = true;
|
|
1138
|
+
for (int k = 1; k <= count; ++k) {
|
|
1139
|
+
for (int r = 0; r < 6; ++r)
|
|
1140
|
+
ek[r] = old[slot + r] + (double)k / count * (emech[r] - old[slot + r]);
|
|
1141
|
+
if (small_step(sys, par, h, ns, dm, ek, dt / count, cur, nxt, sig,
|
|
1142
|
+
k > 1 ? 2 : 0, 1.0, wk)) {
|
|
1143
|
+
ok = false;
|
|
1144
|
+
break;
|
|
1145
|
+
}
|
|
1146
|
+
double* tmp = cur;
|
|
1147
|
+
cur = nxt;
|
|
1148
|
+
nxt = tmp;
|
|
1149
|
+
}
|
|
1150
|
+
if (ok) {
|
|
1151
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = cur[r];
|
|
1152
|
+
done = true;
|
|
1153
|
+
break;
|
|
1154
|
+
}
|
|
1155
|
+
}
|
|
1156
|
+
if (!done) return 1;
|
|
1157
|
+
}
|
|
1158
|
+
for (int r = 0; r < 6; ++r) nw[slot + r] = emech[r];
|
|
1159
|
+
// consistent tangent (of the last substep)
|
|
1160
|
+
int* idx = wk->idx;
|
|
1161
|
+
for (int r = 0; r < 6; ++r)
|
|
1162
|
+
for (int c = 0; c < 6; ++c) tan[6 * r + c] = dm[6 * r + c];
|
|
1163
|
+
int na = active_indices(wk->wv[8], ns, idx);
|
|
1164
|
+
if (na == 0) return 0;
|
|
1165
|
+
for (int a = 0; a < na; ++a) {
|
|
1166
|
+
int s = idx[a];
|
|
1167
|
+
for (int b = 0; b < na; ++b) lu[a][b] = jac[s][idx[b]];
|
|
1168
|
+
for (int j = 0; j < 6; ++j) wr[a][j] = -sgn[s] * cm[s][j];
|
|
1169
|
+
}
|
|
1170
|
+
if (gauss_solve(&lu[0][0], NS, &wr[0][0], 9, na, 6) != 0) return 1;
|
|
1171
|
+
for (int j = 0; j < 6; ++j)
|
|
1172
|
+
for (int r = 0; r < 6; ++r) {
|
|
1173
|
+
double acc = 0.0;
|
|
1174
|
+
for (int a = 0; a < na; ++a) {
|
|
1175
|
+
int s = idx[a];
|
|
1176
|
+
acc += sgn[s] * cm[s][r] * wr[a][j];
|
|
1177
|
+
}
|
|
1178
|
+
tan[6 * r + j] -= acc;
|
|
1179
|
+
}
|
|
1180
|
+
if (sym) symmetrize(tan, 6);
|
|
1181
|
+
return 0;
|
|
1182
|
+
}
|
|
1183
|
+
|
|
1184
|
+
// backward Euler step of a finite-strain point (_finite_step)
|
|
1185
|
+
__device__ __noinline__ int finite_step(const double* sys, const double* par, const double* h,
|
|
1186
|
+
int ns, const double* dm, const double* hg,
|
|
1187
|
+
double eth[3][3], double dt, const double* old,
|
|
1188
|
+
double* nw, int guess, double ratio, Work* wk) {
|
|
1189
|
+
double(*f)[3] = wk->w3[9];
|
|
1190
|
+
double(*fpn)[3] = wk->w3[10];
|
|
1191
|
+
double(*fe_tr)[3] = wk->w3[11];
|
|
1192
|
+
double(*fpi)[3] = wk->w3[13];
|
|
1193
|
+
double(*t1)[3] = wk->w3[15];
|
|
1194
|
+
double(*t2)[3] = wk->w3[16];
|
|
1195
|
+
const int off = CP_ALPHA + 2 * ns;
|
|
1196
|
+
for (int i = 0; i < 3; ++i)
|
|
1197
|
+
for (int j = 0; j < 3; ++j) {
|
|
1198
|
+
f[i][j] = (i == j ? 1.0 : 0.0) + hg[3 * i + j];
|
|
1199
|
+
fpn[i][j] = (i == j ? 1.0 : 0.0) + old[off + 3 * i + j];
|
|
1200
|
+
}
|
|
1201
|
+
matmul3(f, fpn, fe_tr);
|
|
1202
|
+
if (solve_slips(true, par, h, ns, dt, old, nw, sys, dm, fe_tr, eth, guess, ratio, wk))
|
|
1203
|
+
return 1;
|
|
1204
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = old[r];
|
|
1205
|
+
double(*gam)[3] = wk->w3[0];
|
|
1206
|
+
matmul3(fpn, wk->w3[1], fpi);
|
|
1207
|
+
for (int i = 0; i < 3; ++i)
|
|
1208
|
+
for (int j = 0; j < 3; ++j) nw[off + 3 * i + j] = fpi[i][j] - (i == j ? 1.0 : 0.0);
|
|
1209
|
+
inverse3(fpi, t1);
|
|
1210
|
+
tmatmul3(t1, t1, t2);
|
|
1211
|
+
nw[0] = 0.5 * (t2[0][0] - 1.0);
|
|
1212
|
+
nw[1] = 0.5 * (t2[1][1] - 1.0);
|
|
1213
|
+
nw[2] = 0.5 * (t2[2][2] - 1.0);
|
|
1214
|
+
nw[3] = 0.5 * t2[1][2];
|
|
1215
|
+
nw[4] = 0.5 * t2[2][0];
|
|
1216
|
+
nw[5] = 0.5 * t2[0][1];
|
|
1217
|
+
double acc = 0.0;
|
|
1218
|
+
for (int i = 0; i < 3; ++i)
|
|
1219
|
+
for (int j = 0; j < 3; ++j) {
|
|
1220
|
+
double sym = 0.5 * (gam[i][j] + gam[j][i]);
|
|
1221
|
+
acc += sym * sym;
|
|
1222
|
+
}
|
|
1223
|
+
nw[6] = old[6] + sqrt(2.0 / 3.0 * acc);
|
|
1224
|
+
update_hardening(par, ns, wk->wv[7], old, nw);
|
|
1225
|
+
return 0;
|
|
1226
|
+
}
|
|
1227
|
+
|
|
1228
|
+
// implicit update of a crystal point in finite strains (cp_finite): first Piola-Kirchhoff
|
|
1229
|
+
// stress and tangent dP/dF
|
|
1230
|
+
__device__ __noinline__ int cp_finite(const double* sys, const double* par, const double* h,
|
|
1231
|
+
int ns, const double* dm, const double* hg,
|
|
1232
|
+
const double* eth6, double dt, const double* old,
|
|
1233
|
+
double* nw, double* pk1, double* tan, int guess,
|
|
1234
|
+
double ratio, Work* wk) {
|
|
1235
|
+
double* sgn = wk->wv[3];
|
|
1236
|
+
double(*wr)[9] = wk->wr;
|
|
1237
|
+
double(*eth)[3] = wk->w3[12];
|
|
1238
|
+
stress_tensor(eth6, eth);
|
|
1239
|
+
const int hslot = CP_ALPHA + 2 * ns + 9;
|
|
1240
|
+
if (finite_step(sys, par, h, ns, dm, hg, eth, dt, old, nw, guess, ratio, wk) != 0) {
|
|
1241
|
+
double* hk = wk->s6[5];
|
|
1242
|
+
bool done = false;
|
|
1243
|
+
for (int level = 0; level < SUBSTEP_LEVELS; ++level) {
|
|
1244
|
+
int count = 1 << (2 * (level + 1));
|
|
1245
|
+
double* cur = wk->bufs[0];
|
|
1246
|
+
double* nxt = wk->bufs[1];
|
|
1247
|
+
for (int r = 0; r < WIDTH; ++r) cur[r] = old[r];
|
|
1248
|
+
bool ok = true;
|
|
1249
|
+
for (int k = 1; k <= count; ++k) {
|
|
1250
|
+
for (int r = 0; r < 9; ++r)
|
|
1251
|
+
hk[r] = old[hslot + r] + (double)k / count * (hg[r] - old[hslot + r]);
|
|
1252
|
+
if (finite_step(sys, par, h, ns, dm, hk, eth, dt / count, cur, nxt,
|
|
1253
|
+
k > 1 ? 2 : 0, 1.0, wk)) {
|
|
1254
|
+
ok = false;
|
|
1255
|
+
break;
|
|
1256
|
+
}
|
|
1257
|
+
double* tmp = cur;
|
|
1258
|
+
cur = nxt;
|
|
1259
|
+
nxt = tmp;
|
|
1260
|
+
}
|
|
1261
|
+
if (ok) {
|
|
1262
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = cur[r];
|
|
1263
|
+
done = true;
|
|
1264
|
+
break;
|
|
1265
|
+
}
|
|
1266
|
+
}
|
|
1267
|
+
if (!done) return 1;
|
|
1268
|
+
}
|
|
1269
|
+
for (int r = 0; r < 9; ++r) nw[hslot + r] = hg[r];
|
|
1270
|
+
// stress and tangent of the (last sub)step
|
|
1271
|
+
double(*f)[3] = wk->w3[9];
|
|
1272
|
+
double(*fpn)[3] = wk->w3[10];
|
|
1273
|
+
double(*fpi)[3] = wk->w3[13];
|
|
1274
|
+
double(*s2)[3] = wk->w3[14];
|
|
1275
|
+
double(*t1)[3] = wk->w3[15];
|
|
1276
|
+
double(*t2)[3] = wk->w3[16];
|
|
1277
|
+
double(*t3)[3] = wk->w3[17];
|
|
1278
|
+
double(*t4)[3] = wk->w3[18];
|
|
1279
|
+
double(*dpr)[3] = wk->w3[19];
|
|
1280
|
+
double(*fe)[3] = wk->w3[2];
|
|
1281
|
+
double(*ce)[3] = wk->w3[3];
|
|
1282
|
+
double(*se)[3] = wk->w3[4];
|
|
1283
|
+
double(*ee)[3] = wk->w3[8];
|
|
1284
|
+
int* idx = wk->idx;
|
|
1285
|
+
int na = active_indices(wk->wv[8], ns, idx);
|
|
1286
|
+
matmul3(fpi, se, t1);
|
|
1287
|
+
matmult3(t1, fpi, s2);
|
|
1288
|
+
matmul3(f, s2, t1);
|
|
1289
|
+
for (int i = 0; i < 3; ++i)
|
|
1290
|
+
for (int j = 0; j < 3; ++j) pk1[3 * i + j] = t1[i][j];
|
|
1291
|
+
// tangent at fixed slips, and d tau / d F
|
|
1292
|
+
for (int kl = 0; kl < 9; ++kl) {
|
|
1293
|
+
int k = kl / 3;
|
|
1294
|
+
int ll = kl % 3;
|
|
1295
|
+
for (int i = 0; i < 3; ++i)
|
|
1296
|
+
for (int j = 0; j < 3; ++j) t1[i][j] = fpi[ll][i] * fe[k][j];
|
|
1297
|
+
for (int i = 0; i < 3; ++i)
|
|
1298
|
+
for (int j = 0; j < 3; ++j) {
|
|
1299
|
+
t2[i][j] = t1[i][j] + t1[j][i];
|
|
1300
|
+
ee[i][j] = 0.5 * t2[i][j];
|
|
1301
|
+
}
|
|
1302
|
+
elastic_stress(dm, ee, t3, wk->s6[0], wk->s6[1]);
|
|
1303
|
+
matmul3(t2, se, t1);
|
|
1304
|
+
matmul3(ce, t3, t4);
|
|
1305
|
+
for (int i = 0; i < 3; ++i)
|
|
1306
|
+
for (int j = 0; j < 3; ++j) t1[i][j] += t4[i][j];
|
|
1307
|
+
for (int a = 0; a < na; ++a) {
|
|
1308
|
+
int s = idx[a];
|
|
1309
|
+
wr[a][kl] = -sgn[s] * project(sys + 6 * s, sys + 6 * s + 3, t1);
|
|
1310
|
+
}
|
|
1311
|
+
matmul3(fe, t3, t1);
|
|
1312
|
+
matmult3(t1, fpi, t2);
|
|
1313
|
+
for (int i = 0; i < 3; ++i)
|
|
1314
|
+
for (int j = 0; j < 3; ++j) {
|
|
1315
|
+
double v = t2[i][j];
|
|
1316
|
+
if (i == k) v += s2[ll][j];
|
|
1317
|
+
tan[9 * (3 * i + j) + kl] = v;
|
|
1318
|
+
}
|
|
1319
|
+
}
|
|
1320
|
+
if (na > 0) {
|
|
1321
|
+
double(*jac)[NS] = wk->wm[0];
|
|
1322
|
+
double(*lu)[NS] = wk->wm[1];
|
|
1323
|
+
for (int a = 0; a < na; ++a)
|
|
1324
|
+
for (int b = 0; b < na; ++b) lu[a][b] = jac[idx[a]][idx[b]];
|
|
1325
|
+
if (gauss_solve(&lu[0][0], NS, &wr[0][0], 9, na, 9) != 0) return 1;
|
|
1326
|
+
matmul3(fe, se, t4);
|
|
1327
|
+
for (int a = 0; a < na; ++a) {
|
|
1328
|
+
int r = idx[a];
|
|
1329
|
+
// d P / d dgamma_r, with d F_p^-1 = F_p^-1(n) dG_r
|
|
1330
|
+
matmul3(fpn, wk->wg[0][r], t1);
|
|
1331
|
+
matmul3(f, t1, t2);
|
|
1332
|
+
matmul3(t2, se, t3);
|
|
1333
|
+
matmult3(t3, fpi, dpr);
|
|
1334
|
+
matmul3(fe, wk->wg[2][r], t2);
|
|
1335
|
+
matmult3(t2, fpi, t3);
|
|
1336
|
+
for (int i = 0; i < 3; ++i)
|
|
1337
|
+
for (int j = 0; j < 3; ++j) dpr[i][j] += t3[i][j];
|
|
1338
|
+
matmult3(t4, t1, t3);
|
|
1339
|
+
for (int i = 0; i < 3; ++i)
|
|
1340
|
+
for (int j = 0; j < 3; ++j) dpr[i][j] += t3[i][j];
|
|
1341
|
+
for (int kl = 0; kl < 9; ++kl) {
|
|
1342
|
+
double x = sgn[r] * wr[a][kl];
|
|
1343
|
+
if (x != 0.0)
|
|
1344
|
+
for (int i = 0; i < 3; ++i)
|
|
1345
|
+
for (int j = 0; j < 3; ++j) tan[9 * (3 * i + j) + kl] += dpr[i][j] * x;
|
|
1346
|
+
}
|
|
1347
|
+
}
|
|
1348
|
+
}
|
|
1349
|
+
return 0;
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1352
|
+
// ---- porous plasticity: morphogen.homogenization.porous -----------------------------------
|
|
1353
|
+
|
|
1354
|
+
// R(p) = R0 + H p + sum Q (1 - exp(-b p)) (_hardening)
|
|
1355
|
+
__device__ __forceinline__ double porous_hardening(const double* par, double p) {
|
|
1356
|
+
double r = par[2] + par[3] * p;
|
|
1357
|
+
for (int i = 0; i < POROUS_ISOTROPIC; ++i) {
|
|
1358
|
+
double q = par[6 + 2 * i];
|
|
1359
|
+
if (q != 0.0) r += q * (1.0 - exp(-par[7 + 2 * i] * p));
|
|
1360
|
+
}
|
|
1361
|
+
return r;
|
|
1362
|
+
}
|
|
1363
|
+
|
|
1364
|
+
// R'(p) (_hardening_slope)
|
|
1365
|
+
__device__ __forceinline__ double porous_hardening_slope(const double* par, double p) {
|
|
1366
|
+
double r = par[3];
|
|
1367
|
+
for (int i = 0; i < POROUS_ISOTROPIC; ++i) {
|
|
1368
|
+
double q = par[6 + 2 * i];
|
|
1369
|
+
if (q != 0.0) {
|
|
1370
|
+
double b = par[7 + 2 * i];
|
|
1371
|
+
r += q * b * exp(-b * p);
|
|
1372
|
+
}
|
|
1373
|
+
}
|
|
1374
|
+
return r;
|
|
1375
|
+
}
|
|
1376
|
+
|
|
1377
|
+
// the piecewise linear function of the table at par[at], dflt without points (_table_value)
|
|
1378
|
+
__device__ double table_value(const double* par, int at, double x, double dflt) {
|
|
1379
|
+
int n = (int)par[at];
|
|
1380
|
+
if (n == 0) return dflt;
|
|
1381
|
+
if (n == 1) return par[at + 2];
|
|
1382
|
+
int k = 0;
|
|
1383
|
+
while (k < n - 2 && x > par[at + 1 + 2 * (k + 1)]) ++k;
|
|
1384
|
+
double x0 = par[at + 1 + 2 * k];
|
|
1385
|
+
double y0 = par[at + 2 + 2 * k];
|
|
1386
|
+
double x1 = par[at + 3 + 2 * k];
|
|
1387
|
+
double y1 = par[at + 4 + 2 * k];
|
|
1388
|
+
return y0 + (y1 - y0) * (x - x0) / (x1 - x0);
|
|
1389
|
+
}
|
|
1390
|
+
|
|
1391
|
+
// its slope, dflt without points (_table_slope)
|
|
1392
|
+
__device__ double table_slope(const double* par, int at, double x, double dflt) {
|
|
1393
|
+
int n = (int)par[at];
|
|
1394
|
+
if (n == 0) return dflt;
|
|
1395
|
+
if (n == 1) return 0.0;
|
|
1396
|
+
int k = 0;
|
|
1397
|
+
while (k < n - 2 && x > par[at + 1 + 2 * (k + 1)]) ++k;
|
|
1398
|
+
double dy = par[at + 4 + 2 * k] - par[at + 2 + 2 * k];
|
|
1399
|
+
return dy / (par[at + 3 + 2 * k] - par[at + 1 + 2 * k]);
|
|
1400
|
+
}
|
|
1401
|
+
|
|
1402
|
+
// the matrix stress of the GTN potential and its derivatives by seq and sm, the root
|
|
1403
|
+
// bracketed from guess if it is positive, else from an estimate (_gurson_stress)
|
|
1404
|
+
__device__ double gurson_stress(double q1, double q2, double q3, double fs, double seq,
|
|
1405
|
+
double sm, double guess, double* s_q, double* s_m) {
|
|
1406
|
+
if (fs <= 0.0) { // von Mises
|
|
1407
|
+
*s_q = 1.0;
|
|
1408
|
+
*s_m = 0.0;
|
|
1409
|
+
return seq;
|
|
1410
|
+
}
|
|
1411
|
+
if (seq == 0.0 && sm == 0.0) {
|
|
1412
|
+
*s_q = 1.0;
|
|
1413
|
+
*s_m = 0.0;
|
|
1414
|
+
return 0.0;
|
|
1415
|
+
}
|
|
1416
|
+
double c = 1.0 + q3 * fs * fs;
|
|
1417
|
+
if (c - 2.0 * q1 * fs <= 0.0) { // the surface has vanished
|
|
1418
|
+
*s_q = 0.0;
|
|
1419
|
+
*s_m = 0.0;
|
|
1420
|
+
return MG_INF;
|
|
1421
|
+
}
|
|
1422
|
+
double s, grow;
|
|
1423
|
+
if (guess > 0.0 && isfinite(guess)) {
|
|
1424
|
+
s = guess;
|
|
1425
|
+
grow = 1.0 + 1e-6;
|
|
1426
|
+
} else {
|
|
1427
|
+
double k = 1.5 * q2 * sm;
|
|
1428
|
+
s = sqrt(seq * seq + k * k) / pmax(1.0 - q1 * fs, 0.05);
|
|
1429
|
+
grow = 2.0;
|
|
1430
|
+
}
|
|
1431
|
+
double lo = 0.0, hi = 0.0;
|
|
1432
|
+
for (int it = 0; it < 200; ++it) {
|
|
1433
|
+
double t = 1.5 * q2 * sm / s;
|
|
1434
|
+
double a = seq / s;
|
|
1435
|
+
double phi = a * a + 2.0 * q1 * fs * cosh(t) - c;
|
|
1436
|
+
if (phi > 0.0) {
|
|
1437
|
+
lo = s;
|
|
1438
|
+
if (hi == 0.0) {
|
|
1439
|
+
s *= grow;
|
|
1440
|
+
grow = 1.0 + pmin(8.0 * (grow - 1.0), 1.0);
|
|
1441
|
+
continue;
|
|
1442
|
+
}
|
|
1443
|
+
} else {
|
|
1444
|
+
hi = s;
|
|
1445
|
+
if (lo == 0.0) {
|
|
1446
|
+
s /= grow;
|
|
1447
|
+
grow = 1.0 + pmin(8.0 * (grow - 1.0), 1.0);
|
|
1448
|
+
continue;
|
|
1449
|
+
}
|
|
1450
|
+
}
|
|
1451
|
+
break;
|
|
1452
|
+
}
|
|
1453
|
+
for (int it = 0; it < 100; ++it) {
|
|
1454
|
+
double t = 1.5 * q2 * sm / s;
|
|
1455
|
+
double a = seq / s;
|
|
1456
|
+
double phi = a * a + 2.0 * q1 * fs * cosh(t) - c;
|
|
1457
|
+
if (phi > 0.0)
|
|
1458
|
+
lo = s;
|
|
1459
|
+
else
|
|
1460
|
+
hi = s;
|
|
1461
|
+
double dphi = -2.0 / s * (a * a + q1 * fs * t * sinh(t)); // dPhi/ds < 0
|
|
1462
|
+
double step = s - phi / dphi;
|
|
1463
|
+
if (!(lo < step && step < hi)) step = 0.5 * (lo + hi);
|
|
1464
|
+
if (fabs(step - s) <= 1e-15 * s) {
|
|
1465
|
+
s = step;
|
|
1466
|
+
break;
|
|
1467
|
+
}
|
|
1468
|
+
s = step;
|
|
1469
|
+
}
|
|
1470
|
+
double t = 1.5 * q2 * sm / s;
|
|
1471
|
+
double a = seq / s;
|
|
1472
|
+
double den = a * a + q1 * fs * t * sinh(t);
|
|
1473
|
+
*s_q = a / den;
|
|
1474
|
+
*s_m = 1.5 * q1 * q2 * fs * sinh(t) / den;
|
|
1475
|
+
return s;
|
|
1476
|
+
}
|
|
1477
|
+
|
|
1478
|
+
// the matrix stress of the potential of a point and its derivatives by seq and sm at the
|
|
1479
|
+
// porosity f, GTN's iteration started from guess if it is positive (_matrix_stress)
|
|
1480
|
+
__device__ double matrix_stress(const double* par, double seq, double sm, double f,
|
|
1481
|
+
double guess, double* s_q, double* s_m) {
|
|
1482
|
+
int kind = (int)par[P_CRITERION];
|
|
1483
|
+
if (kind == GURSON) {
|
|
1484
|
+
double fs = table_value(par, P_FSTAR, f, f);
|
|
1485
|
+
fs = pmin(pmax(fs, 0.0), par[P_CAP]);
|
|
1486
|
+
return gurson_stress(par[P_Q1], par[P_Q2], par[P_Q3], fs, seq, sm, guess, s_q, s_m);
|
|
1487
|
+
}
|
|
1488
|
+
if (kind == ROUSSELIER) {
|
|
1489
|
+
double fe = pmin(pmax(f, 0.0), par[P_CAP]);
|
|
1490
|
+
double s1 = par[P_SIGMA1];
|
|
1491
|
+
double e = par[P_D] * s1 * fe * exp(pmin(par[P_QR] * sm / ((1.0 - fe) * s1), 700.0));
|
|
1492
|
+
*s_q = 1.0 / (1.0 - fe);
|
|
1493
|
+
*s_m = e * par[P_QR] / ((1.0 - fe) * s1);
|
|
1494
|
+
return seq / (1.0 - fe) + e;
|
|
1495
|
+
}
|
|
1496
|
+
double fe = pmax(f, 0.0);
|
|
1497
|
+
double cc = pmax(table_value(par, P_C, fe, 1.0), 0.0);
|
|
1498
|
+
double ff = pmax(table_value(par, P_F, fe, 0.0), 0.0);
|
|
1499
|
+
double s2 = cc * seq * seq + 9.0 * ff * sm * sm;
|
|
1500
|
+
if (s2 <= 0.0) {
|
|
1501
|
+
*s_q = 1.0;
|
|
1502
|
+
*s_m = 0.0;
|
|
1503
|
+
return 0.0;
|
|
1504
|
+
}
|
|
1505
|
+
double s = sqrt(s2);
|
|
1506
|
+
*s_q = cc * seq / s;
|
|
1507
|
+
*s_m = 9.0 * ff * sm / s;
|
|
1508
|
+
return s;
|
|
1509
|
+
}
|
|
1510
|
+
|
|
1511
|
+
// the rate A(p) of the nucleation of porosity per unit of dp (_nucleation)
|
|
1512
|
+
__device__ double nucleation(const double* par, double p) {
|
|
1513
|
+
int kind = (int)par[P_NUCLEATION];
|
|
1514
|
+
if (kind == 0 || p < par[P_NUCLEATION + 4]) return 0.0;
|
|
1515
|
+
double a = par[P_NUCLEATION + 1], b = par[P_NUCLEATION + 2], c = par[P_NUCLEATION + 3];
|
|
1516
|
+
if (kind == 1) return a;
|
|
1517
|
+
if (kind == 2) {
|
|
1518
|
+
double z = (p - b) / c;
|
|
1519
|
+
return a / (c * sqrt(2.0 * 3.141592653589793)) * exp(-0.5 * z * z);
|
|
1520
|
+
}
|
|
1521
|
+
return a * exp(-p / b);
|
|
1522
|
+
}
|
|
1523
|
+
|
|
1524
|
+
// A'(p), zero below the threshold (_nucleation_slope)
|
|
1525
|
+
__device__ double nucleation_slope(const double* par, double p) {
|
|
1526
|
+
int kind = (int)par[P_NUCLEATION];
|
|
1527
|
+
if (kind <= 1 || p < par[P_NUCLEATION + 4]) return 0.0;
|
|
1528
|
+
double a = par[P_NUCLEATION + 1], b = par[P_NUCLEATION + 2], c = par[P_NUCLEATION + 3];
|
|
1529
|
+
if (kind == 2) {
|
|
1530
|
+
double z = (p - b) / c;
|
|
1531
|
+
return -a / (c * sqrt(2.0 * 3.141592653589793)) * exp(-0.5 * z * z) * z / c;
|
|
1532
|
+
}
|
|
1533
|
+
return -a / b * exp(-p / b);
|
|
1534
|
+
}
|
|
1535
|
+
|
|
1536
|
+
// the derivatives of the matrix stress s of (seq, sm, f) in d: by seq, sm and f, then the
|
|
1537
|
+
// second ones by (seq, seq), (seq, sm), (sm, sm), (seq, f) and (sm, f); those of GTN by the
|
|
1538
|
+
// implicit function theorem on its potential (_matrix_derivatives)
|
|
1539
|
+
__device__ void matrix_derivatives(const double* par, double seq, double sm, double f,
|
|
1540
|
+
double s, double* d) {
|
|
1541
|
+
for (int i = 0; i < 8; ++i) d[i] = 0.0;
|
|
1542
|
+
int kind = (int)par[P_CRITERION];
|
|
1543
|
+
if (kind == GURSON) {
|
|
1544
|
+
double raw = table_value(par, P_FSTAR, f, f);
|
|
1545
|
+
double cap = par[P_CAP];
|
|
1546
|
+
double fs = pmin(pmax(raw, 0.0), cap);
|
|
1547
|
+
double dfs = (0.0 <= raw && raw < cap) ? table_slope(par, P_FSTAR, f, 1.0) : 0.0;
|
|
1548
|
+
if (!(s > 0.0)) {
|
|
1549
|
+
d[0] = 1.0;
|
|
1550
|
+
return;
|
|
1551
|
+
}
|
|
1552
|
+
double q1 = par[P_Q1];
|
|
1553
|
+
double q3 = par[P_Q3];
|
|
1554
|
+
double k = 1.5 * par[P_Q2];
|
|
1555
|
+
double u = k * sm / s;
|
|
1556
|
+
double ch = cosh(u);
|
|
1557
|
+
double sh = sinh(u);
|
|
1558
|
+
double a = seq / s;
|
|
1559
|
+
double p_s = -2.0 * (a * a + q1 * fs * u * sh) / s;
|
|
1560
|
+
double p_q = 2.0 * a / s;
|
|
1561
|
+
double p_m = 2.0 * q1 * fs * k * sh / s;
|
|
1562
|
+
double p_f = 2.0 * (q1 * ch - q3 * fs);
|
|
1563
|
+
double s2 = s * s;
|
|
1564
|
+
double p_qq = 2.0 / s2;
|
|
1565
|
+
double p_qs = -4.0 * a / s2;
|
|
1566
|
+
double p_mm = 2.0 * q1 * fs * k * k * ch / s2;
|
|
1567
|
+
double p_ms = -2.0 * q1 * fs * k * (u * ch + sh) / s2;
|
|
1568
|
+
double p_mf = 2.0 * q1 * k * sh / s;
|
|
1569
|
+
double p_fs = -2.0 * q1 * u * sh / s;
|
|
1570
|
+
double p_ss = (6.0 * a * a + 2.0 * q1 * fs * (2.0 * u * sh + u * u * ch)) / s2;
|
|
1571
|
+
double s_q = -p_q / p_s;
|
|
1572
|
+
double s_m = -p_m / p_s;
|
|
1573
|
+
double s_f = -p_f / p_s;
|
|
1574
|
+
d[0] = s_q;
|
|
1575
|
+
d[1] = s_m;
|
|
1576
|
+
d[2] = s_f * dfs;
|
|
1577
|
+
d[3] = -(p_qq + 2.0 * p_qs * s_q + p_ss * s_q * s_q) / p_s;
|
|
1578
|
+
d[4] = -(p_qs * s_m + p_ms * s_q + p_ss * s_q * s_m) / p_s;
|
|
1579
|
+
d[5] = -(p_mm + 2.0 * p_ms * s_m + p_ss * s_m * s_m) / p_s;
|
|
1580
|
+
d[6] = -(p_qs * s_f + p_fs * s_q + p_ss * s_q * s_f) / p_s * dfs;
|
|
1581
|
+
d[7] = -(p_mf + p_ms * s_f + p_fs * s_m + p_ss * s_m * s_f) / p_s * dfs;
|
|
1582
|
+
return;
|
|
1583
|
+
}
|
|
1584
|
+
if (kind == ROUSSELIER) {
|
|
1585
|
+
double cap = par[P_CAP];
|
|
1586
|
+
double fe = pmin(pmax(f, 0.0), cap);
|
|
1587
|
+
double dfe = (0.0 <= f && f < cap) ? 1.0 : 0.0;
|
|
1588
|
+
double s1 = par[P_SIGMA1];
|
|
1589
|
+
double qr = par[P_QR];
|
|
1590
|
+
double a = 1.0 / (1.0 - fe);
|
|
1591
|
+
double arg = qr * sm * a / s1;
|
|
1592
|
+
int unclamped = arg < 700.0;
|
|
1593
|
+
double ex = exp(unclamped ? arg : 700.0);
|
|
1594
|
+
double g = par[P_D] * s1 * fe * ex;
|
|
1595
|
+
double dg = par[P_D] * s1 * ex + (unclamped ? g * qr * sm * a * a / s1 : 0.0);
|
|
1596
|
+
d[0] = a;
|
|
1597
|
+
d[1] = g * qr * a / s1;
|
|
1598
|
+
d[2] = (seq * a * a + dg) * dfe;
|
|
1599
|
+
d[5] = unclamped ? d[1] * qr * a / s1 : 0.0;
|
|
1600
|
+
d[6] = a * a * dfe;
|
|
1601
|
+
d[7] = qr / s1 * (dg * a + g * a * a) * dfe;
|
|
1602
|
+
return;
|
|
1603
|
+
}
|
|
1604
|
+
double fe = pmax(f, 0.0);
|
|
1605
|
+
double dfe = f >= 0.0 ? 1.0 : 0.0;
|
|
1606
|
+
double c_raw = table_value(par, P_C, fe, 1.0);
|
|
1607
|
+
double f_raw = table_value(par, P_F, fe, 0.0);
|
|
1608
|
+
double cc = pmax(c_raw, 0.0);
|
|
1609
|
+
double ff = pmax(f_raw, 0.0);
|
|
1610
|
+
double dc = c_raw > 0.0 ? table_slope(par, P_C, fe, 0.0) * dfe : 0.0;
|
|
1611
|
+
double dff = f_raw > 0.0 ? table_slope(par, P_F, fe, 0.0) * dfe : 0.0;
|
|
1612
|
+
if (!(s > 0.0)) {
|
|
1613
|
+
d[0] = 1.0;
|
|
1614
|
+
return;
|
|
1615
|
+
}
|
|
1616
|
+
double s3 = s * s * s;
|
|
1617
|
+
d[0] = cc * seq / s;
|
|
1618
|
+
d[1] = 9.0 * ff * sm / s;
|
|
1619
|
+
d[2] = (seq * seq * dc + 9.0 * sm * sm * dff) / (2.0 * s);
|
|
1620
|
+
d[3] = 9.0 * cc * ff * sm * sm / s3;
|
|
1621
|
+
d[4] = -9.0 * cc * ff * seq * sm / s3;
|
|
1622
|
+
d[5] = 9.0 * ff * cc * seq * seq / s3;
|
|
1623
|
+
d[6] = dc * seq / s - cc * seq * d[2] / (s * s);
|
|
1624
|
+
d[7] = 9.0 * dff * sm / s - 9.0 * ff * sm * d[2] / (s * s);
|
|
1625
|
+
}
|
|
1626
|
+
|
|
1627
|
+
// the four equations of the update at x = (dv, dq, z, f), the matrix stress sought from
|
|
1628
|
+
// guess: the matrix stress, or -1 when x is out of bounds (_residual)
|
|
1629
|
+
// the invariants of the relative trial stress after a plastic increment dp: J*, m*, c and
|
|
1630
|
+
// their derivatives by dp in rel[0..5]; kin: the trial deviator (row 0) and the deviators
|
|
1631
|
+
// and mean stresses of the backstresses (rows 1..., 7 wide) (_relative)
|
|
1632
|
+
__device__ void porous_relative(const double* par, const double* kin, double sm_tr,
|
|
1633
|
+
double seq_tr, double dp, double* rel) {
|
|
1634
|
+
int nk = (int)par[P_NKIN];
|
|
1635
|
+
if (nk == 0) {
|
|
1636
|
+
rel[0] = seq_tr;
|
|
1637
|
+
rel[1] = sm_tr;
|
|
1638
|
+
for (int i = 2; i < 6; ++i) rel[i] = 0.0;
|
|
1639
|
+
return;
|
|
1640
|
+
}
|
|
1641
|
+
double m = sm_tr, dm = 0.0, c = 0.0, dc = 0.0;
|
|
1642
|
+
for (int k = 0; k < nk; ++k) {
|
|
1643
|
+
double d = par[P_KIN + 2 * k + 1];
|
|
1644
|
+
double th = 1.0 / (1.0 + d * dp);
|
|
1645
|
+
c += th * par[P_KIN + 2 * k];
|
|
1646
|
+
dc -= d * th * th * par[P_KIN + 2 * k];
|
|
1647
|
+
m -= th * kin[7 * (1 + k) + 6];
|
|
1648
|
+
dm += d * th * th * kin[7 * (1 + k) + 6];
|
|
1649
|
+
}
|
|
1650
|
+
double xx = 0.0, xw = 0.0;
|
|
1651
|
+
for (int r = 0; r < 6; ++r) {
|
|
1652
|
+
double xi = kin[r], w = 0.0;
|
|
1653
|
+
for (int k = 0; k < nk; ++k) {
|
|
1654
|
+
double d = par[P_KIN + 2 * k + 1];
|
|
1655
|
+
double th = 1.0 / (1.0 + d * dp);
|
|
1656
|
+
xi -= th * kin[7 * (1 + k) + r];
|
|
1657
|
+
w += d * th * th * kin[7 * (1 + k) + r];
|
|
1658
|
+
}
|
|
1659
|
+
double g = r < 3 ? 1.0 : 2.0;
|
|
1660
|
+
xx += g * xi * xi;
|
|
1661
|
+
xw += g * xi * w;
|
|
1662
|
+
}
|
|
1663
|
+
double j = sqrt(pmax(1.5 * xx, 0.0));
|
|
1664
|
+
rel[0] = j;
|
|
1665
|
+
rel[1] = m;
|
|
1666
|
+
rel[2] = c;
|
|
1667
|
+
rel[3] = j > 0.0 ? 1.5 * xw / j : 0.0;
|
|
1668
|
+
rel[4] = dm;
|
|
1669
|
+
rel[5] = dc;
|
|
1670
|
+
}
|
|
1671
|
+
|
|
1672
|
+
// the deviator xi of the relative trial stress after dp and its derivative w by dp
|
|
1673
|
+
// (_relative_deviator)
|
|
1674
|
+
__device__ void porous_relative_deviator(const double* par, const double* kin, double dp,
|
|
1675
|
+
double* xi, double* w) {
|
|
1676
|
+
for (int r = 0; r < 6; ++r) {
|
|
1677
|
+
xi[r] = kin[r];
|
|
1678
|
+
w[r] = 0.0;
|
|
1679
|
+
}
|
|
1680
|
+
for (int k = 0; k < (int)par[P_NKIN]; ++k) {
|
|
1681
|
+
double d = par[P_KIN + 2 * k + 1];
|
|
1682
|
+
double th = 1.0 / (1.0 + d * dp);
|
|
1683
|
+
for (int r = 0; r < 6; ++r) {
|
|
1684
|
+
xi[r] -= th * kin[7 * (1 + k) + r];
|
|
1685
|
+
w[r] += d * th * th * kin[7 * (1 + k) + r];
|
|
1686
|
+
}
|
|
1687
|
+
}
|
|
1688
|
+
}
|
|
1689
|
+
|
|
1690
|
+
__device__ double porous_residual(const double* par, const double* x, double sm_tr,
|
|
1691
|
+
double seq_tr, double kb, double mu, double f_old,
|
|
1692
|
+
double p_old, double dt, int vertex, double* out,
|
|
1693
|
+
double guess, const double* kin) {
|
|
1694
|
+
double dv = x[0], dq = x[1], z = x[2], f = x[3];
|
|
1695
|
+
if (z < 0.0 || !(0.0 <= f && f < 0.9999)) return -1.0;
|
|
1696
|
+
int viscous = par[4] > 0.0;
|
|
1697
|
+
double dp = viscous ? dt * pow(z, par[5]) : z;
|
|
1698
|
+
double rel[6];
|
|
1699
|
+
porous_relative(par, kin, sm_tr, seq_tr, dp, rel);
|
|
1700
|
+
double c = rel[2];
|
|
1701
|
+
double sm = rel[1] - (kb + 2.0 * c / 9.0) * dv;
|
|
1702
|
+
double seq = rel[0] - (3.0 * mu + c) * dq;
|
|
1703
|
+
double s_q, s_m;
|
|
1704
|
+
double s = matrix_stress(par, seq, sm, f, guess, &s_q, &s_m);
|
|
1705
|
+
if (!isfinite(s)) return -1.0;
|
|
1706
|
+
double p = p_old + dp;
|
|
1707
|
+
out[0] = vertex ? dq - rel[0] / (3.0 * mu + c) : dv * s_q - dq * s_m;
|
|
1708
|
+
out[1] = s - porous_hardening(par, p) - (viscous ? par[4] * z : 0.0);
|
|
1709
|
+
out[2] = (1.0 - f) * s * dp - sm * dv - seq * dq;
|
|
1710
|
+
out[3] = f - f_old - (1.0 - f) * dv - nucleation(par, p) * dp;
|
|
1711
|
+
return s;
|
|
1712
|
+
}
|
|
1713
|
+
|
|
1714
|
+
// a x = b (4 x 4, n_rhs columns of b, 4 x 2 row-major) by Gaussian elimination with
|
|
1715
|
+
// partial pivoting, in place in b (m: a work matrix); 0 if singular (_solve4)
|
|
1716
|
+
__device__ int solve4(const double* a, double* b, int n_rhs, double* m) {
|
|
1717
|
+
for (int r = 0; r < 16; ++r) m[r] = a[r];
|
|
1718
|
+
for (int col = 0; col < 4; ++col) {
|
|
1719
|
+
int piv = col;
|
|
1720
|
+
for (int r = col + 1; r < 4; ++r)
|
|
1721
|
+
if (fabs(m[4 * r + col]) > fabs(m[4 * piv + col])) piv = r;
|
|
1722
|
+
if (fabs(m[4 * piv + col]) < 1e-300) return 0;
|
|
1723
|
+
if (piv != col) {
|
|
1724
|
+
for (int c = 0; c < 4; ++c) {
|
|
1725
|
+
double t = m[4 * col + c];
|
|
1726
|
+
m[4 * col + c] = m[4 * piv + c];
|
|
1727
|
+
m[4 * piv + c] = t;
|
|
1728
|
+
}
|
|
1729
|
+
for (int c = 0; c < n_rhs; ++c) {
|
|
1730
|
+
double t = b[2 * col + c];
|
|
1731
|
+
b[2 * col + c] = b[2 * piv + c];
|
|
1732
|
+
b[2 * piv + c] = t;
|
|
1733
|
+
}
|
|
1734
|
+
}
|
|
1735
|
+
for (int r = col + 1; r < 4; ++r) {
|
|
1736
|
+
double g = m[4 * r + col] / m[4 * col + col];
|
|
1737
|
+
if (g != 0.0) {
|
|
1738
|
+
for (int c = col; c < 4; ++c) m[4 * r + c] -= g * m[4 * col + c];
|
|
1739
|
+
for (int c = 0; c < n_rhs; ++c) b[2 * r + c] -= g * b[2 * col + c];
|
|
1740
|
+
}
|
|
1741
|
+
}
|
|
1742
|
+
}
|
|
1743
|
+
for (int col = 3; col >= 0; --col)
|
|
1744
|
+
for (int c = 0; c < n_rhs; ++c) {
|
|
1745
|
+
double acc = b[2 * col + c];
|
|
1746
|
+
for (int k = col + 1; k < 4; ++k) acc -= m[4 * col + k] * b[2 * k + c];
|
|
1747
|
+
b[2 * col + c] = acc / m[4 * col + col];
|
|
1748
|
+
}
|
|
1749
|
+
return 1;
|
|
1750
|
+
}
|
|
1751
|
+
|
|
1752
|
+
__device__ __forceinline__ double scaled_norm(const double* r, double e_scale,
|
|
1753
|
+
double s_scale) {
|
|
1754
|
+
return pmax(pmax(pmax(fabs(r[0]) / e_scale, fabs(r[1]) / s_scale),
|
|
1755
|
+
fabs(r[2]) / (s_scale * e_scale)),
|
|
1756
|
+
fabs(r[3]));
|
|
1757
|
+
}
|
|
1758
|
+
|
|
1759
|
+
// the Jacobian jac (4 x 4) of the residual at x, whose matrix stress is s, and in dr
|
|
1760
|
+
// (4 x 2) its derivatives by the trial invariants sm_tr and seq_tr; d: a work vector of 8
|
|
1761
|
+
// (_jacobian)
|
|
1762
|
+
__device__ void porous_jacobian(const double* par, const double* x, double sm_tr,
|
|
1763
|
+
double seq_tr, double kb, double mu, double f_old,
|
|
1764
|
+
double p_old, double dt, int vertex, double s, double* d,
|
|
1765
|
+
double* jac, double* dr, const double* kin) {
|
|
1766
|
+
double dv = x[0], dq = x[1], z = x[2], f = x[3];
|
|
1767
|
+
double kv = par[4];
|
|
1768
|
+
int viscous = kv > 0.0;
|
|
1769
|
+
double nv = par[5];
|
|
1770
|
+
double dp, dpz;
|
|
1771
|
+
if (viscous) {
|
|
1772
|
+
dp = dt * pow(z, nv);
|
|
1773
|
+
dpz = z > 0.0 ? nv * dt * pow(z, nv - 1.0) : (nv == 1.0 ? dt : 0.0);
|
|
1774
|
+
} else {
|
|
1775
|
+
dp = z;
|
|
1776
|
+
dpz = 1.0;
|
|
1777
|
+
}
|
|
1778
|
+
double rel[6];
|
|
1779
|
+
porous_relative(par, kin, sm_tr, seq_tr, dp, rel);
|
|
1780
|
+
double jstar = rel[0], c = rel[2], dj = rel[3], dm = rel[4], dc = rel[5];
|
|
1781
|
+
double kbe = kb + 2.0 * c / 9.0;
|
|
1782
|
+
double mue = 3.0 * mu + c;
|
|
1783
|
+
double sm = rel[1] - kbe * dv;
|
|
1784
|
+
double seq = jstar - mue * dq;
|
|
1785
|
+
// the derivatives of the relative invariants by dp (the recovery of the backstresses)
|
|
1786
|
+
double seq_p = dj - dc * dq;
|
|
1787
|
+
double sm_p = dm - 2.0 * dc / 9.0 * dv;
|
|
1788
|
+
matrix_derivatives(par, seq, sm, f, s, d);
|
|
1789
|
+
double s_q = d[0], s_m = d[1], s_f = d[2];
|
|
1790
|
+
double s_qq = d[3], s_qm = d[4], s_mm = d[5], s_qf = d[6], s_mf = d[7];
|
|
1791
|
+
double s_p = s_q * seq_p + s_m * sm_p;
|
|
1792
|
+
double p = p_old + dp;
|
|
1793
|
+
if (vertex) { // dq - J* / (3 mu + c)
|
|
1794
|
+
jac[0] = 0.0;
|
|
1795
|
+
jac[1] = 1.0;
|
|
1796
|
+
jac[2] = -dpz * (dj - jstar * dc / mue) / mue;
|
|
1797
|
+
jac[3] = 0.0;
|
|
1798
|
+
dr[0] = 0.0;
|
|
1799
|
+
dr[1] = -1.0 / mue;
|
|
1800
|
+
} else { // dv S_q - dq S_m
|
|
1801
|
+
double nq = dv * s_qq - dq * s_qm;
|
|
1802
|
+
double nm = dv * s_qm - dq * s_mm;
|
|
1803
|
+
jac[0] = s_q - kbe * nm;
|
|
1804
|
+
jac[1] = -s_m - mue * nq;
|
|
1805
|
+
jac[2] = dpz * (nq * seq_p + nm * sm_p);
|
|
1806
|
+
jac[3] = dv * s_qf - dq * s_mf;
|
|
1807
|
+
dr[0] = nm;
|
|
1808
|
+
dr[1] = nq;
|
|
1809
|
+
}
|
|
1810
|
+
// s - R(p) - K z
|
|
1811
|
+
jac[4] = -kbe * s_m;
|
|
1812
|
+
jac[5] = -mue * s_q;
|
|
1813
|
+
jac[6] = (s_p - porous_hardening_slope(par, p)) * dpz - (viscous ? kv : 0.0);
|
|
1814
|
+
jac[7] = s_f;
|
|
1815
|
+
dr[2] = s_m;
|
|
1816
|
+
dr[3] = s_q;
|
|
1817
|
+
// (1 - f) s dp - sm dv - seq dq
|
|
1818
|
+
double g = 1.0 - f;
|
|
1819
|
+
jac[8] = -g * dp * kbe * s_m + kbe * dv - sm;
|
|
1820
|
+
jac[9] = -mue * g * dp * s_q + mue * dq - seq;
|
|
1821
|
+
jac[10] = (g * s + g * dp * s_p - dv * sm_p - dq * seq_p) * dpz;
|
|
1822
|
+
jac[11] = (g * s_f - s) * dp;
|
|
1823
|
+
dr[4] = g * dp * s_m - dv;
|
|
1824
|
+
dr[5] = g * dp * s_q - dq;
|
|
1825
|
+
// f - f_old - (1 - f) dv - A(p) dp
|
|
1826
|
+
jac[12] = -g;
|
|
1827
|
+
jac[13] = 0.0;
|
|
1828
|
+
jac[14] = -dpz * (nucleation(par, p) + nucleation_slope(par, p) * dp);
|
|
1829
|
+
jac[15] = 1.0 + dv;
|
|
1830
|
+
dr[6] = 0.0;
|
|
1831
|
+
dr[7] = 0.0;
|
|
1832
|
+
}
|
|
1833
|
+
|
|
1834
|
+
// implicit update of a porous point (_porous_update), its tangent symmetrized with sym;
|
|
1835
|
+
// returns 1 on failure
|
|
1836
|
+
__device__ __noinline__ int porous_update(const double* par, const double* eps,
|
|
1837
|
+
const double* eth, double dt, const double* old,
|
|
1838
|
+
double* nw, double* sig, double* tan, int sym) {
|
|
1839
|
+
double lam = par[0];
|
|
1840
|
+
double mu = par[1];
|
|
1841
|
+
double kb = lam + 2.0 * mu / 3.0;
|
|
1842
|
+
int viscous = par[4] > 0.0;
|
|
1843
|
+
double ee[6], s_tr[6], nrm[6], d[6], xi[6], w[6], x[4], res[4], trial[4], rt[4];
|
|
1844
|
+
double jac[16], m4[16], rhs[8], dr[8], ds[8], rel[6];
|
|
1845
|
+
double kin[7 * (1 + POROUS_KINEMATIC)];
|
|
1846
|
+
for (int r = 0; r < 6; ++r) {
|
|
1847
|
+
double e = r < 3 ? eps[r] : 0.5 * eps[r];
|
|
1848
|
+
ee[r] = e - eth[r] - old[r];
|
|
1849
|
+
}
|
|
1850
|
+
double tr = ee[0] + ee[1] + ee[2];
|
|
1851
|
+
double sm_tr = kb * tr;
|
|
1852
|
+
for (int r = 0; r < 6; ++r) s_tr[r] = 2.0 * mu * (r < 3 ? ee[r] - tr / 3.0 : ee[r]);
|
|
1853
|
+
double seq_tr = sqrt(pmax(1.5 * ddot6(s_tr, s_tr), 0.0));
|
|
1854
|
+
for (int r = 0; r < WIDTH; ++r) nw[r] = old[r];
|
|
1855
|
+
// the trial deviator and the deviators and mean stresses of the backstresses
|
|
1856
|
+
int nk = (int)par[P_NKIN];
|
|
1857
|
+
for (int r = 0; r < 6; ++r) kin[r] = s_tr[r];
|
|
1858
|
+
for (int k = 0; k < nk; ++k) {
|
|
1859
|
+
int base = STATE_BACK + 6 * k;
|
|
1860
|
+
double xm = (old[base] + old[base + 1] + old[base + 2]) / 3.0;
|
|
1861
|
+
for (int r = 0; r < 6; ++r) kin[7 * (1 + k) + r] = old[base + r] - (r < 3 ? xm : 0.0);
|
|
1862
|
+
kin[7 * (1 + k) + 6] = xm;
|
|
1863
|
+
}
|
|
1864
|
+
double f_old = pmax(par[P_F0] + old[STATE_FG] + old[STATE_FN], 0.0);
|
|
1865
|
+
double p_old = old[STATE_P];
|
|
1866
|
+
// the relative trial stress (the trial one without backstresses)
|
|
1867
|
+
porous_relative(par, kin, sm_tr, seq_tr, 0.0, rel);
|
|
1868
|
+
double jstar0 = rel[0], mstar0 = rel[1], c0 = rel[2];
|
|
1869
|
+
double sq0, smd0;
|
|
1870
|
+
double s0 = matrix_stress(par, jstar0, mstar0, f_old, 0.0, &sq0, &smd0);
|
|
1871
|
+
double r_old = porous_hardening(par, p_old);
|
|
1872
|
+
// the stresses of the trial state (not s*, whose exponential term of Rousselier may be
|
|
1873
|
+
// out of all proportion with them)
|
|
1874
|
+
double s_scale =
|
|
1875
|
+
pmax(pmax(pmax(pmax(pmax(seq_tr, fabs(sm_tr)), jstar0), fabs(mstar0)), r_old), 1e-300);
|
|
1876
|
+
double tiny = 1e-14 * s_scale;
|
|
1877
|
+
double inv = seq_tr > tiny ? 1.5 / seq_tr : 0.0;
|
|
1878
|
+
for (int r = 0; r < 6; ++r) nrm[r] = inv * s_tr[r];
|
|
1879
|
+
if (!isfinite(s0)) return 1;
|
|
1880
|
+
if (s0 - r_old <= 1e-13 * s_scale) {
|
|
1881
|
+
for (int r = 0; r < 6; ++r) sig[r] = s_tr[r] + (r < 3 ? sm_tr : 0.0);
|
|
1882
|
+
elastic_tangent(lam, mu, tan);
|
|
1883
|
+
nw[STATE_SSTAR] = s0;
|
|
1884
|
+
return 0;
|
|
1885
|
+
}
|
|
1886
|
+
// plastic flow: initial guess, the cutting-plane step along the normal at the trial
|
|
1887
|
+
// stress
|
|
1888
|
+
double e_scale = s_scale / (3.0 * mu);
|
|
1889
|
+
double work = jstar0 * sq0 + mstar0 * smd0;
|
|
1890
|
+
double dp_dl = work > 0.0 ? work / ((1.0 - f_old) * s0) : 1.0 / (1.0 - f_old);
|
|
1891
|
+
double below = pmax(p_old - 1e-6, 0.0);
|
|
1892
|
+
double slope = (porous_hardening(par, p_old + 1e-6) - porous_hardening(par, below)) /
|
|
1893
|
+
(p_old + 1e-6 - below);
|
|
1894
|
+
double kbe = kb + 2.0 * c0 / 9.0;
|
|
1895
|
+
double mue = 3.0 * mu + c0;
|
|
1896
|
+
double lam0 = (s0 - r_old) / (kbe * smd0 * smd0 + mue * sq0 * sq0 + slope * dp_dl);
|
|
1897
|
+
double dp0 = lam0 * dp_dl;
|
|
1898
|
+
x[0] = lam0 * smd0;
|
|
1899
|
+
x[1] = pmin(lam0 * sq0, 0.5 * jstar0 / mue);
|
|
1900
|
+
x[3] = f_old;
|
|
1901
|
+
if (viscous) { // the viscous stress of the rate-independent increment, at most the
|
|
1902
|
+
// overstress
|
|
1903
|
+
double bound = (s0 - r_old) / par[4];
|
|
1904
|
+
x[2] = dt > 0.0 ? pmin(pow(dp0 / dt, 1.0 / par[5]), bound) : bound;
|
|
1905
|
+
} else {
|
|
1906
|
+
x[2] = dp0;
|
|
1907
|
+
}
|
|
1908
|
+
int vertex = jstar0 <= tiny && (int)par[P_CRITERION] == ROUSSELIER;
|
|
1909
|
+
int converged = 0;
|
|
1910
|
+
double sx = 0.0;
|
|
1911
|
+
for (int attempt = 0; attempt < 2; ++attempt) {
|
|
1912
|
+
// sx: the matrix stress of x, the guess of the points of the line search
|
|
1913
|
+
sx = porous_residual(par, x, sm_tr, seq_tr, kb, mu, f_old, p_old, dt, vertex, res, 0.0,
|
|
1914
|
+
kin);
|
|
1915
|
+
if (sx < 0.0) {
|
|
1916
|
+
x[0] = 0.0;
|
|
1917
|
+
x[1] = 0.0;
|
|
1918
|
+
x[2] = 0.0;
|
|
1919
|
+
x[3] = f_old;
|
|
1920
|
+
sx = porous_residual(par, x, sm_tr, seq_tr, kb, mu, f_old, p_old, dt, vertex, res,
|
|
1921
|
+
0.0, kin);
|
|
1922
|
+
if (sx < 0.0) return 1;
|
|
1923
|
+
}
|
|
1924
|
+
double norm = scaled_norm(res, e_scale, s_scale);
|
|
1925
|
+
for (int it = 0; it < 80; ++it) {
|
|
1926
|
+
if (norm <= 1e-12) {
|
|
1927
|
+
converged = 1;
|
|
1928
|
+
break;
|
|
1929
|
+
}
|
|
1930
|
+
porous_jacobian(par, x, sm_tr, seq_tr, kb, mu, f_old, p_old, dt, vertex, sx, ds,
|
|
1931
|
+
jac, dr, kin);
|
|
1932
|
+
for (int i = 0; i < 4; ++i) rhs[2 * i] = -res[i];
|
|
1933
|
+
if (!solve4(jac, rhs, 1, m4)) return 1;
|
|
1934
|
+
// the porosity falls at most by 90 % per iteration
|
|
1935
|
+
double alpha = 1.0;
|
|
1936
|
+
if (rhs[6] < 0.0 && x[3] > 0.0) alpha = pmin(1.0, 0.9 * x[3] / -rhs[6]);
|
|
1937
|
+
int accepted = 0;
|
|
1938
|
+
double n_t = norm;
|
|
1939
|
+
double inside = -1.0;
|
|
1940
|
+
for (int ls = 0; ls < 30; ++ls) {
|
|
1941
|
+
for (int i = 0; i < 4; ++i) trial[i] = x[i] + alpha * rhs[2 * i];
|
|
1942
|
+
trial[3] = pmax(trial[3], 0.0); // a dense point stays dense
|
|
1943
|
+
inside = porous_residual(par, trial, sm_tr, seq_tr, kb, mu, f_old, p_old, dt,
|
|
1944
|
+
vertex, rt, sx, kin);
|
|
1945
|
+
if (inside >= 0.0) {
|
|
1946
|
+
n_t = scaled_norm(rt, e_scale, s_scale);
|
|
1947
|
+
if (n_t < (1.0 - 1e-4 * alpha) * norm || alpha < 1e-6) {
|
|
1948
|
+
accepted = 1;
|
|
1949
|
+
break;
|
|
1950
|
+
}
|
|
1951
|
+
}
|
|
1952
|
+
alpha *= 0.5;
|
|
1953
|
+
}
|
|
1954
|
+
if (!accepted) return 1;
|
|
1955
|
+
for (int i = 0; i < 4; ++i) {
|
|
1956
|
+
x[i] = trial[i];
|
|
1957
|
+
res[i] = rt[i];
|
|
1958
|
+
}
|
|
1959
|
+
sx = inside;
|
|
1960
|
+
norm = n_t;
|
|
1961
|
+
}
|
|
1962
|
+
if (!converged) return 1;
|
|
1963
|
+
double dp1 = viscous ? dt * pow(x[2], par[5]) : x[2];
|
|
1964
|
+
porous_relative(par, kin, sm_tr, seq_tr, dp1, rel);
|
|
1965
|
+
double seq = rel[0] - (3.0 * mu + rel[2]) * x[1];
|
|
1966
|
+
if (seq >= -1e-10 * s_scale || vertex) break;
|
|
1967
|
+
// Rousselier's vertex: the hydrostatic return
|
|
1968
|
+
vertex = 1;
|
|
1969
|
+
converged = 0;
|
|
1970
|
+
x[1] = rel[0] / (3.0 * mu + rel[2]);
|
|
1971
|
+
}
|
|
1972
|
+
if (!converged) return 1;
|
|
1973
|
+
double dv = x[0], dq = x[1], z = x[2], f = x[3];
|
|
1974
|
+
double dp, dpz;
|
|
1975
|
+
if (viscous) {
|
|
1976
|
+
dp = dt * pow(z, par[5]);
|
|
1977
|
+
dpz = z > 0.0 ? par[5] * dt * pow(z, par[5] - 1.0) : (par[5] == 1.0 ? dt : 0.0);
|
|
1978
|
+
} else {
|
|
1979
|
+
dp = z;
|
|
1980
|
+
dpz = 1.0;
|
|
1981
|
+
}
|
|
1982
|
+
porous_relative(par, kin, sm_tr, seq_tr, dp, rel);
|
|
1983
|
+
double jstar = rel[0], c = rel[2];
|
|
1984
|
+
double sm = rel[1] - (kb + 2.0 * c / 9.0) * dv;
|
|
1985
|
+
double seq = pmax(jstar - (3.0 * mu + c) * dq, 0.0);
|
|
1986
|
+
double sq_, smd_;
|
|
1987
|
+
double s = matrix_stress(par, seq, sm, f, 0.0, &sq_, &smd_);
|
|
1988
|
+
// the deviator of the relative trial stress, whose direction the plastic strain takes
|
|
1989
|
+
porous_relative_deviator(par, kin, dp, xi, w);
|
|
1990
|
+
if (nk > 0) {
|
|
1991
|
+
double inv1 = jstar > tiny ? 1.5 / jstar : 0.0;
|
|
1992
|
+
for (int r = 0; r < 6; ++r) nrm[r] = inv1 * xi[r];
|
|
1993
|
+
}
|
|
1994
|
+
for (int r = 0; r < 6; ++r) nw[r] = old[r] + (r < 3 ? dv / 3.0 : 0.0) + dq * nrm[r];
|
|
1995
|
+
nw[STATE_P] = p_old + dp;
|
|
1996
|
+
nw[STATE_FN] = old[STATE_FN] + nucleation(par, p_old + dp) * dp;
|
|
1997
|
+
// no porosity below zero (a dense point whose volume change is a roundoff)
|
|
1998
|
+
nw[STATE_FG] = pmax(old[STATE_FG] + (1.0 - f) * dv, -par[P_F0] - nw[STATE_FN]);
|
|
1999
|
+
nw[STATE_SSTAR] = s;
|
|
2000
|
+
for (int k = 0; k < nk; ++k) { // X = th (X_n + 2/3 C deps_p), its hydrostatic part included
|
|
2001
|
+
double th = 1.0 / (1.0 + par[P_KIN + 2 * k + 1] * dp);
|
|
2002
|
+
double cc = 2.0 / 3.0 * par[P_KIN + 2 * k];
|
|
2003
|
+
int base = STATE_BACK + 6 * k;
|
|
2004
|
+
for (int r = 0; r < 6; ++r) {
|
|
2005
|
+
double dep = (r < 3 ? dv / 3.0 : 0.0) + dq * nrm[r];
|
|
2006
|
+
nw[base + r] = th * (old[base + r] + cc * dep);
|
|
2007
|
+
}
|
|
2008
|
+
}
|
|
2009
|
+
// sig = sig_tr - K dv I - 2 mu dq n: the deviator (s_tr - xi) + (1 - 3 mu dq / J*) xi
|
|
2010
|
+
double ratio_s = jstar > tiny ? pmax(jstar - 3.0 * mu * dq, 0.0) / jstar : 1.0;
|
|
2011
|
+
double sm_abs = sm_tr - kb * dv;
|
|
2012
|
+
for (int r = 0; r < 6; ++r)
|
|
2013
|
+
sig[r] = (s_tr[r] - xi[r]) + ratio_s * xi[r] + (r < 3 ? sm_abs : 0.0);
|
|
2014
|
+
// consistent tangent: the sensitivity of the solution to the trial invariants (with
|
|
2015
|
+
// backstresses: m* and J*, dJ* = n : ds_tr)
|
|
2016
|
+
porous_jacobian(par, x, sm_tr, seq_tr, kb, mu, f_old, p_old, dt, vertex, sx, ds, jac, dr,
|
|
2017
|
+
kin);
|
|
2018
|
+
for (int i = 0; i < 4; ++i) {
|
|
2019
|
+
rhs[2 * i] = -dr[2 * i];
|
|
2020
|
+
rhs[2 * i + 1] = -dr[2 * i + 1];
|
|
2021
|
+
}
|
|
2022
|
+
if (!solve4(jac, rhs, 2, m4)) return 1;
|
|
2023
|
+
double gq = rhs[3];
|
|
2024
|
+
double ratio = jstar > tiny ? ratio_s : 1.0 - 3.0 * mu * gq;
|
|
2025
|
+
// the turn of the direction with dp: dn = 3 / (2 J*) (w - 2/3 (n : w) n) ddp
|
|
2026
|
+
double turn = nk > 0 && jstar > tiny ? 3.0 * mu * dq / jstar : 0.0;
|
|
2027
|
+
double nwd = ddot6(nrm, w);
|
|
2028
|
+
for (int j = 0; j < 6; ++j) {
|
|
2029
|
+
for (int r = 0; r < 6; ++r) d[r] = 0.0;
|
|
2030
|
+
d[j] = j < 3 ? 1.0 : 0.5;
|
|
2031
|
+
double trd = j < 3 ? 1.0 : 0.0;
|
|
2032
|
+
double nd = ddot6(nrm, d);
|
|
2033
|
+
double dsm_tr = kb * trd;
|
|
2034
|
+
double dseq_tr = 2.0 * mu * nd;
|
|
2035
|
+
double ddv = rhs[0] * dsm_tr + rhs[1] * dseq_tr;
|
|
2036
|
+
double ddq = rhs[2] * dsm_tr + rhs[3] * dseq_tr;
|
|
2037
|
+
double ddp = turn * dpz * (rhs[4] * dsm_tr + rhs[5] * dseq_tr);
|
|
2038
|
+
double dsm = dsm_tr - kb * ddv;
|
|
2039
|
+
double dseq = dseq_tr - 3.0 * mu * ddq;
|
|
2040
|
+
for (int r = 0; r < 6; ++r) {
|
|
2041
|
+
double dev = r < 3 ? d[r] - trd / 3.0 : d[r];
|
|
2042
|
+
double value =
|
|
2043
|
+
2.0 / 3.0 * dseq * nrm[r] + 2.0 * mu * ratio * (dev - 2.0 / 3.0 * nd * nrm[r]);
|
|
2044
|
+
if (turn != 0.0) value -= ddp * (w[r] - 2.0 / 3.0 * nwd * nrm[r]);
|
|
2045
|
+
if (r < 3) value += dsm;
|
|
2046
|
+
tan[6 * r + j] = value;
|
|
2047
|
+
}
|
|
2048
|
+
}
|
|
2049
|
+
if (sym) symmetrize(tan, 6);
|
|
2050
|
+
return 0;
|
|
2051
|
+
}
|
|
2052
|
+
|
|
2053
|
+
// ---- finite strains: morphogen.homogenization.finite --------------------------------------
|
|
2054
|
+
|
|
2055
|
+
// elastic, von Mises, Hill or porous point in the space of the logarithmic strain
|
|
2056
|
+
// (_log_point), the tangent of the logarithmic strain symmetrized with sym
|
|
2057
|
+
__device__ __noinline__ int log_point(int kind, const double* dm, const double* par, int nk,
|
|
2058
|
+
const double* hg, const double* eth, double dt,
|
|
2059
|
+
const double* old, double* nw, double* pk1,
|
|
2060
|
+
double* tan, int sym) {
|
|
2061
|
+
double f[3][3], e2[3][3], q[3][3], tq[3][3], s[3][3], t1[3][3], t2[3][3], dcq[3][3];
|
|
2062
|
+
double dtq[3][3], f1[3][3], f2[3][3][3];
|
|
2063
|
+
double mu[3], eps6[6], sig6[6], d6[6], ds6[6], tan6[36];
|
|
2064
|
+
for (int i = 0; i < 3; ++i)
|
|
2065
|
+
for (int j = 0; j < 3; ++j) f[i][j] = (i == j ? 1.0 : 0.0) + hg[3 * i + j];
|
|
2066
|
+
// C - I = H + H^T + H^T H, without cancellation for small strains
|
|
2067
|
+
for (int i = 0; i < 3; ++i)
|
|
2068
|
+
for (int j = 0; j < 3; ++j) {
|
|
2069
|
+
double acc = hg[3 * i + j] + hg[3 * j + i];
|
|
2070
|
+
for (int k = 0; k < 3; ++k) acc += hg[3 * k + i] * hg[3 * k + j];
|
|
2071
|
+
e2[i][j] = acc;
|
|
2072
|
+
}
|
|
2073
|
+
for (int i = 0; i < 3; ++i)
|
|
2074
|
+
for (int j = 0; j < 3; ++j) t1[i][j] = e2[i][j];
|
|
2075
|
+
eigh3(t1, mu, q);
|
|
2076
|
+
for (int a = 0; a < 3; ++a)
|
|
2077
|
+
if (!(mu[a] > -1.0 && isfinite(mu[a]))) return 1;
|
|
2078
|
+
for (int i = 0; i < 3; ++i)
|
|
2079
|
+
for (int j = 0; j < 3; ++j) {
|
|
2080
|
+
double acc = 0.0;
|
|
2081
|
+
for (int a = 0; a < 3; ++a) acc += q[i][a] * q[j][a] * half_log(mu[a]);
|
|
2082
|
+
t1[i][j] = acc;
|
|
2083
|
+
}
|
|
2084
|
+
strain_voigt(t1, eps6);
|
|
2085
|
+
if (kind == PLASTIC) {
|
|
2086
|
+
if (j2_update(par, nk, eps6, eth, dt, old, nw, sig6, tan6, sym) != 0) return 1;
|
|
2087
|
+
} else if (kind == HILL) {
|
|
2088
|
+
if (hill_update(par, nk, eps6, eth, dt, old, nw, sig6, tan6, sym) != 0) return 1;
|
|
2089
|
+
} else if (kind == POROUS) {
|
|
2090
|
+
if (porous_update(par, eps6, eth, dt, old, nw, sig6, tan6, sym) != 0) return 1;
|
|
2091
|
+
} else {
|
|
2092
|
+
for (int r = 0; r < 6; ++r) d6[r] = eps6[r] - eth[r] * (r < 3 ? 1.0 : 2.0);
|
|
2093
|
+
for (int r = 0; r < 6; ++r) {
|
|
2094
|
+
double acc = 0.0;
|
|
2095
|
+
for (int c = 0; c < 6; ++c) {
|
|
2096
|
+
acc += dm[6 * r + c] * d6[c];
|
|
2097
|
+
tan6[6 * r + c] = dm[6 * r + c];
|
|
2098
|
+
}
|
|
2099
|
+
sig6[r] = acc;
|
|
2100
|
+
}
|
|
2101
|
+
}
|
|
2102
|
+
stress_tensor(sig6, t1);
|
|
2103
|
+
tmatmul3(q, t1, t2);
|
|
2104
|
+
matmul3(t2, q, tq);
|
|
2105
|
+
// the divided differences are symmetric in their arguments: their 6 and 10 values
|
|
2106
|
+
for (int a = 0; a < 3; ++a)
|
|
2107
|
+
for (int b = a; b < 3; ++b) {
|
|
2108
|
+
double v = log_divided(mu[a], mu[b]);
|
|
2109
|
+
f1[a][b] = v;
|
|
2110
|
+
f1[b][a] = v;
|
|
2111
|
+
for (int c = b; c < 3; ++c) {
|
|
2112
|
+
v = log_divided2(mu[a], mu[b], mu[c]);
|
|
2113
|
+
f2[a][b][c] = v;
|
|
2114
|
+
f2[a][c][b] = v;
|
|
2115
|
+
f2[b][a][c] = v;
|
|
2116
|
+
f2[b][c][a] = v;
|
|
2117
|
+
f2[c][a][b] = v;
|
|
2118
|
+
f2[c][b][a] = v;
|
|
2119
|
+
}
|
|
2120
|
+
}
|
|
2121
|
+
for (int a = 0; a < 3; ++a)
|
|
2122
|
+
for (int b = 0; b < 3; ++b) t1[a][b] = 2.0 * f1[a][b] * tq[a][b];
|
|
2123
|
+
matmul3(q, t1, t2);
|
|
2124
|
+
matmult3(t2, q, s);
|
|
2125
|
+
matmul3(f, s, t1);
|
|
2126
|
+
for (int i = 0; i < 3; ++i)
|
|
2127
|
+
for (int j = 0; j < 3; ++j) pk1[3 * i + j] = t1[i][j];
|
|
2128
|
+
// dS is linear in dC: F dS for the six directions of dC, B = e_m (x) e_n + e_n (x) e_m
|
|
2129
|
+
// (e_m (x) e_m when m = n), then for each dF = e_k (x) e_l the sum of the dC_mn F dS(B)
|
|
2130
|
+
const int pm[6] = {0, 1, 2, 1, 0, 0};
|
|
2131
|
+
const int pn[6] = {0, 1, 2, 2, 2, 1};
|
|
2132
|
+
double gb[6][3][3];
|
|
2133
|
+
for (int bb = 0; bb < 6; ++bb) {
|
|
2134
|
+
int m = pm[bb], n = pn[bb];
|
|
2135
|
+
for (int a = 0; a < 3; ++a) // Q^T B Q
|
|
2136
|
+
for (int b = 0; b < 3; ++b) {
|
|
2137
|
+
double v = q[m][a] * q[n][b];
|
|
2138
|
+
if (m != n) v += q[n][a] * q[m][b];
|
|
2139
|
+
dcq[a][b] = v;
|
|
2140
|
+
}
|
|
2141
|
+
for (int a = 0; a < 3; ++a)
|
|
2142
|
+
for (int b = 0; b < 3; ++b) t1[a][b] = f1[a][b] * dcq[a][b];
|
|
2143
|
+
matmul3(q, t1, t2);
|
|
2144
|
+
matmult3(t2, q, t1);
|
|
2145
|
+
strain_voigt(t1, d6);
|
|
2146
|
+
for (int r = 0; r < 6; ++r) {
|
|
2147
|
+
double acc = 0.0;
|
|
2148
|
+
for (int c = 0; c < 6; ++c) acc += tan6[6 * r + c] * d6[c];
|
|
2149
|
+
ds6[r] = acc;
|
|
2150
|
+
}
|
|
2151
|
+
stress_tensor(ds6, t1);
|
|
2152
|
+
tmatmul3(q, t1, t2);
|
|
2153
|
+
matmul3(t2, q, dtq);
|
|
2154
|
+
for (int a = 0; a < 3; ++a)
|
|
2155
|
+
for (int b = 0; b < 3; ++b) {
|
|
2156
|
+
double acc = 2.0 * f1[a][b] * dtq[a][b];
|
|
2157
|
+
for (int c = 0; c < 3; ++c)
|
|
2158
|
+
acc += 2.0 * f2[a][b][c] * (dcq[a][c] * tq[c][b] + tq[a][c] * dcq[c][b]);
|
|
2159
|
+
t1[a][b] = acc;
|
|
2160
|
+
}
|
|
2161
|
+
matmul3(q, t1, t2);
|
|
2162
|
+
matmult3(t2, q, t1);
|
|
2163
|
+
matmul3(f, t1, gb[bb]);
|
|
2164
|
+
}
|
|
2165
|
+
for (int kl = 0; kl < 9; ++kl) {
|
|
2166
|
+
int k = kl / 3;
|
|
2167
|
+
int ll = kl % 3;
|
|
2168
|
+
// dC = dF^T F + F^T dF for dF = e_k (x) e_l: dC_mn = d_ml F_kn + d_nl F_km
|
|
2169
|
+
for (int i = 0; i < 3; ++i)
|
|
2170
|
+
for (int j = 0; j < 3; ++j) t2[i][j] = 0.0;
|
|
2171
|
+
for (int bb = 0; bb < 6; ++bb) {
|
|
2172
|
+
int m = pm[bb], n = pn[bb];
|
|
2173
|
+
double c = (m == ll ? f[k][n] : 0.0) + (n == ll ? f[k][m] : 0.0);
|
|
2174
|
+
if (c != 0.0)
|
|
2175
|
+
for (int i = 0; i < 3; ++i)
|
|
2176
|
+
for (int j = 0; j < 3; ++j) t2[i][j] += c * gb[bb][i][j];
|
|
2177
|
+
}
|
|
2178
|
+
for (int i = 0; i < 3; ++i)
|
|
2179
|
+
for (int j = 0; j < 3; ++j) {
|
|
2180
|
+
double v = t2[i][j];
|
|
2181
|
+
if (i == k) v += s[ll][j];
|
|
2182
|
+
tan[9 * (3 * i + j) + kl] = v;
|
|
2183
|
+
}
|
|
2184
|
+
}
|
|
2185
|
+
return 0;
|
|
2186
|
+
}
|
|
2187
|
+
|
|
2188
|
+
// ---- the integration of the points: update_points and update_points_finite --------------
|
|
2189
|
+
|
|
2190
|
+
// Stress, internal variables and tangent (symmetrized with sym) of the points first, ...,
|
|
2191
|
+
// n - 1 for the strains eps (engineering, n x 6) at the end of a step dt
|
|
2192
|
+
// (behaviours.update_points); failed counts the points whose integration failed.
|
|
2193
|
+
extern "C" __global__ void integrate_small(
|
|
2194
|
+
const long long first, const long long n, const long long* kind, const long long* mat,
|
|
2195
|
+
const long long* pmat, const double* matrices, const double* eigen, const double* params,
|
|
2196
|
+
const int nk, const double* systems, const double* cp_par, const double* cp_h,
|
|
2197
|
+
const long long* cp_n, const double* eps, const double dtemp, const double dt,
|
|
2198
|
+
const double* old, double* nw, double* sigma, double* tangent, const int guess,
|
|
2199
|
+
const double ratio, const int sym, unsigned int* failed) {
|
|
2200
|
+
long long i = first + (long long)blockIdx.x * blockDim.x + threadIdx.x;
|
|
2201
|
+
if (i >= n) return;
|
|
2202
|
+
const int m = (int)mat[i];
|
|
2203
|
+
const int k = (int)kind[i];
|
|
2204
|
+
if (k == MFRONT) return;
|
|
2205
|
+
const double* dm = matrices + 36LL * m;
|
|
2206
|
+
const double* e = eps + 6 * i;
|
|
2207
|
+
double* sg = sigma + 6 * i;
|
|
2208
|
+
double* tg = tangent + 36 * i;
|
|
2209
|
+
if (k == ELASTIC) {
|
|
2210
|
+
double mech[6];
|
|
2211
|
+
for (int r = 0; r < 6; ++r) mech[r] = e[r] - dtemp * eigen[6 * m + r];
|
|
2212
|
+
for (int r = 0; r < 6; ++r) {
|
|
2213
|
+
double s = 0.0;
|
|
2214
|
+
for (int c = 0; c < 6; ++c) {
|
|
2215
|
+
s += dm[6 * r + c] * mech[c];
|
|
2216
|
+
tg[6 * r + c] = dm[6 * r + c];
|
|
2217
|
+
}
|
|
2218
|
+
sg[r] = s;
|
|
2219
|
+
}
|
|
2220
|
+
return;
|
|
2221
|
+
}
|
|
2222
|
+
double eth[6];
|
|
2223
|
+
for (int r = 0; r < 6; ++r) eth[r] = dtemp * eigen[6 * m + r] * (r < 3 ? 1.0 : 0.5);
|
|
2224
|
+
const double* o = old + (long long)WIDTH * i;
|
|
2225
|
+
double* w = nw + (long long)WIDTH * i;
|
|
2226
|
+
int fail;
|
|
2227
|
+
if (k == PLASTIC) {
|
|
2228
|
+
fail = j2_update(params + (long long)ROW_WIDTH * pmat[i], nk, e, eth, dt, o, w, sg,
|
|
2229
|
+
tg, sym);
|
|
2230
|
+
} else if (k == HILL) {
|
|
2231
|
+
fail = hill_update(params + (long long)ROW_WIDTH * pmat[i], nk, e, eth, dt, o, w, sg,
|
|
2232
|
+
tg, sym);
|
|
2233
|
+
} else if (k == POROUS) {
|
|
2234
|
+
fail = porous_update(params + (long long)ROW_WIDTH * pmat[i], e, eth, dt, o, w, sg, tg,
|
|
2235
|
+
sym);
|
|
2236
|
+
} else {
|
|
2237
|
+
const long long c = pmat[i];
|
|
2238
|
+
Work wk;
|
|
2239
|
+
fail = cp_small(systems + (long long)m * NS * 6, cp_par + c * NS * N_CP,
|
|
2240
|
+
cp_h + c * NS * NS, (int)cp_n[c], dm, e, eth, dt, o, w, sg, tg, guess,
|
|
2241
|
+
ratio, &wk, sym);
|
|
2242
|
+
}
|
|
2243
|
+
if (fail) atomicAdd(failed, 1u);
|
|
2244
|
+
}
|
|
2245
|
+
|
|
2246
|
+
// First Piola-Kirchhoff stress, internal variables and tangent dP/dF (symmetrized with
|
|
2247
|
+
// sym) of the points first, ..., n - 1 for the displacement gradients hg (n x 9) at the end
|
|
2248
|
+
// of a step (finite.update_points_finite).
|
|
2249
|
+
extern "C" __global__ void integrate_finite(
|
|
2250
|
+
const long long first, const long long n, const long long* kind, const long long* mat,
|
|
2251
|
+
const long long* pmat, const double* matrices, const double* eigen, const double* params,
|
|
2252
|
+
const int nk, const double* systems, const double* cp_par, const double* cp_h,
|
|
2253
|
+
const long long* cp_n, const double* hg, const double dtemp, const double dt,
|
|
2254
|
+
const double* old, double* nw, double* pk1, double* tangent, const int guess,
|
|
2255
|
+
const double ratio, const int sym, unsigned int* failed) {
|
|
2256
|
+
long long i = first + (long long)blockIdx.x * blockDim.x + threadIdx.x;
|
|
2257
|
+
if (i >= n) return;
|
|
2258
|
+
const int m = (int)mat[i];
|
|
2259
|
+
const int k = (int)kind[i];
|
|
2260
|
+
if (k == MFRONT) return;
|
|
2261
|
+
double eth[6];
|
|
2262
|
+
for (int r = 0; r < 6; ++r) eth[r] = dtemp * eigen[6 * m + r] * (r < 3 ? 1.0 : 0.5);
|
|
2263
|
+
const double* dm = matrices + 36LL * m;
|
|
2264
|
+
const double* o = old + (long long)WIDTH * i;
|
|
2265
|
+
double* w = nw + (long long)WIDTH * i;
|
|
2266
|
+
double* p = pk1 + 9 * i;
|
|
2267
|
+
double* a = tangent + 81 * i;
|
|
2268
|
+
int fail;
|
|
2269
|
+
if (k == CRYSTAL) {
|
|
2270
|
+
const long long c = pmat[i];
|
|
2271
|
+
Work wk;
|
|
2272
|
+
fail = cp_finite(systems + (long long)m * NS * 6, cp_par + c * NS * N_CP,
|
|
2273
|
+
cp_h + c * NS * NS, (int)cp_n[c], dm, hg + 9 * i, eth, dt, o, w, p, a,
|
|
2274
|
+
guess, ratio, &wk);
|
|
2275
|
+
} else {
|
|
2276
|
+
const long long row = pmat[i] > 0 ? pmat[i] : 0;
|
|
2277
|
+
fail = log_point(k, dm, params + (long long)ROW_WIDTH * row, nk, hg + 9 * i,
|
|
2278
|
+
eth, dt, o, w, p, a, sym);
|
|
2279
|
+
}
|
|
2280
|
+
if (fail == 0) {
|
|
2281
|
+
if (sym) symmetrize(a, 9);
|
|
2282
|
+
} else {
|
|
2283
|
+
atomicAdd(failed, 1u);
|
|
2284
|
+
}
|
|
2285
|
+
}
|