Use the solver

The Simcoon solver allows you to simulate the mechanical or thermomechanical response of materials under various loading conditions. This page documents the loading path, kept in a path.json file, and how to drive the solver with it. Since simcoon 2.0 the C++ engine reads no file at all: sim.solver.load_path_json reads the path in Python into loading objects, and sim.solver.solve runs them and returns the whole history as numpy arrays. See In-memory Python solver to build the same loading objects directly, without any file, and to convert the pre-2.0 path.txt / material.dat inputs.

Elastic tensile test

Probably the first thing you would like to do with Simcoon is to simulate the mechanical response corresponding to a simple tension test, considering an elastic isotropic material.

We first import simcoon (the Python simulation module of simcoon) and numpy:

import os

import numpy as np
import simcoon as sim

Next we shall define the material constitutive law to be utilized and the associated material properties. We will pass them as a numpy array:

umat_name = 'ELISO'  # This is the 5 character code for the elastic-isotropic subroutine
nstatev = 1  # The number of scalar state variables required

E = 700000.  # The Young modulus
nu = 0.2  # The Poisson coefficient
alpha = 1.E-5  # The coefficient of thermal expansion

# Three Euler angles to represent the material orientation with respect to the reference basis
psi_rve = 0.
theta_rve = 0.
phi_rve = 0.

# Solver parameters
solver_type = 0  # Solver strategy (0 for Newton-Raphson)
corate_type = 3  # Corotational spin rate type (0: Jaumann, 1: Green-Naghdi, 2: logarithmic/XBM, 3: logarithmic_R — recommended default)

props = np.array([E, nu, alpha])

We shall then define the location of the loading path file:

path_data = 'data'
pathfile = 'path.json'

The last part is to define the loading path. Create a folder data and a file named path.json with the following content:

{
  "initial_temperature": 293.5,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "small_strain",
      "ncycle": 1,
      "steps": [
        {
          "thermomechanical": false,
          "mode": "linear",
          "time": 30.0,
          "ninc": 100,
          "Dn_init": 1.0,
          "Dn_mini": 0.1,
          "control": ["strain", "stress", "stress", "stress", "stress", "stress"],
          "value": [0.01, 0.0, 0.0, 0.0, 0.0, 0.0],
          "T_final": 293.5
        }
      ]
    }
  ]
}

This corresponds to a pure strain-controlled tension test in direction 1 up to 1% strain, at 293.5K, in 100 increments. The file is what sim.solver.save_path_json writes for a Block of one StepMeca; the pre-2.0 text format is converted to it once with scripts/legacy_to_json.py (see In-memory Python solver).

Finally, read the path file and run the solver:

blocks, T_init, _ = sim.solver.load_path_json(os.path.join(path_data, pathfile))

res = sim.solver.solve(
    blocks,
    umat_name,
    props,
    nstatev,
    T_init=T_init,
    solver_type=solver_type,
    corate=corate_type,
    orientation=(psi_rve, theta_rve, phi_rve),
)

No result file is written: res holds the whole history in memory, as numpy arrays of shape (6, N) for the tensor quantities:

e11, e22, e33, e12, e13, e23 = res["Strain"]   # total strain
s11, s22, s33, s12, s13, s23 = res["Stress"]   # Cauchy stress
time, T = res["Time"], res["Temp"]
Wm, Wm_r, Wm_ir, Wm_d = res["Wm"]

See In-memory Python solver for the full list of available keys.

Solver parameters

sim.solver.solve takes the following parameters:

Parameter

Type

Description

blocks

Block, StepMeca, or a sequence of them

The loading path, as returned by sim.solver.load_path_json or built directly (see In-memory Python solver)

umat_name

string or callable

name of the constitutive law (e.g., ‘ELISO’, ‘EPICP’, ‘EPKCP’; a legacy name runs the modular engine, EPICP_closed and the other _closed names the dedicated kernels), or a constitutive law written in Python

props

numpy array

Material properties array

nstatev

int

Number of internal state variables

T_init

float

Initial temperature in Kelvin (default 293.15); load_path_json returns the value read from the path file

kinematic_form

string or int

"total", an objective rate, or "rate" (default, the rate "logarithmic_R"): see below

corate

string or int

Former name of kinematic_form: the same value under either name

tangent_mode

string or int

Tangent operator (default "algorithmic"): see below

integrator

string

Local integrator, "cutting_plane" (default) or "closest_point": see below

ncp

string

Complementarity function of the cutting plane, "fischer_burmeister" (default) or "min" (see the UMAT catalog)

solver_type

int

Solver strategy (0: Newton-Raphson)

orientation

simcoon.Rotation or 3 floats

Orientation of the material frame: a Rotation or its Euler angles (psi, theta, phi) in degrees (see In-memory Python solver, mean-field composites, for the convention)

phases

sequence, optional

Sub-phases of a mean-field model (MIHEN, MIMTN, MISCN, MIPLN), passed in memory: Ellipsoid / Layer objects (numbered by position) or the dicts to_phase_dicts() makes of them. Their geometry must be the one the model builds, the concentrations must sum to 1, and a sub-phase that is itself a mean-field model carries its own sub-phases in its phases attribute

record_tangent

bool

Whether to record the tangent operator in the results (default True)

Tangent-operator modes

The tangent_mode keyword selects the tangent operator returned by the constitutive models (also exposed as named constants: sim.tangent_none, sim.tangent_continuum, sim.tangent_algorithmic). It is the consistent operator of the local integrator that ran, chosen apart by integrator (below):

Value

Name

Description

0

none

No tangent assembly — Lt stays the elastic operator (explicit integration schemes)

1

continuum

Continuum elasto-(visco)plastic operator (this was mode 0 before the 2.0 renumbering)

2

algorithmic

Simo–Hughes consistent (algorithmic) operator — default; the exact Jacobian of the discrete update, hence Q-quadratic global convergence, for von Mises plasticity with isotropic hardening and for the linear viscoelastic and damage models and their MODUL compositions (see the note below); approximate otherwise (this was mode 1 before the 2.0 renumbering)

integrator="closest_point" replaces the cutting-plane local loop (the default "cutting_plane") by the closest-point projection: the plastic strain uses the flow of the converged state, so the algorithmic operator becomes the exact Jacobian of the discrete update for every criterion and hardening law the integrator supports; a law or a row without it keeps the cutting plane. It takes tangent_mode="algorithmic". It used to be tangent_mode=3, which is no longer accepted (ValueError). See the UMAT catalog, integrator and tangent operator.

Note

Scope of the algorithmic tangent (2.1). The plastic return mapping is a cutting-plane scheme: the plastic strain accumulates along the flow direction of each Newton iterate. The direction stays fixed during the step only for von Mises with isotropic hardening (radial return); with kinematic hardening (Prager, Armstrong–Frederick, Chaboche) or a Hill, DFA, Drucker or Tresca criterion it rotates between iterates, the update depends on the iteration path, and no tangent can be its exact derivative: the algorithmic operator is then a close approximation (about \(10^{-4}\) to \(10^{-2}\) relative, more for Tresca), which slows the global Newton iteration but leaves the converged response unchanged. integrator="closest_point" (formerly mode 3) replaces the cutting-plane scheme by a closest-point projection, which makes the operator exact for the laws that carry it (see the UMAT catalog, integrator and tangent operator).

Note

2.0 renumbering. Pre-2.0, tangent_mode 0 meant continuum and 1 meant algorithmic; there was no “none” mode. Modes 0, 1 and 2 share the same integrator, so their converged response is identical (the tangent steers the global Newton iteration, not the residual) — only iteration counts and run time change; mode 3 integrates differently and its converged response differs from theirs by the increment’s second order wherever the flow direction rotates within the step. Scripts passing explicit values should shift them by +1; scripts relying on the default silently upgrade from continuum to the (faster) algorithmic operator.

Finite-strain formulation

The kinematic_form parameter selects how a law is updated at finite strain. It fixes the pair of measures the law works on. It is one value: "total", or an objective rate of the table below (by name or by code), which means the rate formulation with that rate, or "rate", the rate formulation with its default rate "logarithmic_R" (also the default when nothing is given). corate is the former name of the same parameter and takes the same values; given together, the two must agree.

kinematic_form

Strain of the law

Stress of the law

Update

"rate" or an objective rate

\(\ln\mathbf{V}\) (spatial) under the logarithmic rates, the default included

Kirchhoff \(\boldsymbol{\tau}\)

Integrated with the objective rate (table below); the stored state is transported with the frame increment of that rate

"total"

\(\ln\mathbf{U}\) (material)

\(\mathbf{T}\), dual to \(\ln\mathbf{U}\)

No rate: the strain is a state function of \(\mathbf{F}\) in reference components, exact at any step size, and nothing is transported

"total" is the strain-space framework of Miehe, Apel and Lambrecht (2002). It involves no objective rate, serves the laws listed in the total formulation, and refuses "logarithmic" and "small_strain" control. Its Strain output is \(\ln\mathbf{U}\). Under the default rate "logarithmic_R" the two formulations run a log-strain box law on the same strain and read its output differently; on a path of prescribed \(\mathbf{F}\) they coincide whenever the stress is coaxial with the stretch, up to the first-order quadrature of the log_R strain. A hyperelastic law built on \(\mathbf{F}\) gives the same stress in both. The outputs LogStrainU, LogStrainV and LogStressU express either run in the measures of the other (see Read the results).

Corotational spin rate types

As an objective rate, kinematic_form (or corate) controls the corotational formulation used in finite deformation problems:

Value

Type

Description

0

Jaumann

Uses the spin tensor \(\mathbf{W}\) from the velocity gradient

1

Green-Naghdi

Uses the spin from the polar decomposition \(\dot{\mathbf{R}}\mathbf{R}^T\)

2

Logarithmic

Uses the logarithmic (Xiao–Bruhns–Meyers) spin rate

3

Logarithmic_R (log_R)

Logarithmic strain transported by the exact polar rotation increment \(\Delta\mathbf{R} = \mathbf{R}_1\mathbf{R}_0^T\) (recommended default: exact tangent transport, including with rotated internal-variable history)

4

Truesdell

Convected (Truesdell / Oldroyd) rate, \(\Delta\mathbf{F} = \mathbf{F}_1\mathbf{F}_0^{-1}\): Kirchhoff stress transported upper-convected, strain lower-convected, so the accumulated strain is the Almansi strain \(\frac12(\mathbf{I} - \mathbf{b}^{-1})\) and the box tangent is the Lie tangent. Under this rate the default Strain output is the Almansi strain, not the logarithmic one: read LogStrain for \(\ln\mathbf{V}\) (see Read the results). "logarithmic" control still prescribes \(\ln\mathbf{V}\), rebuilt from the stored strain as \(-\frac12\ln(\mathbf{I} - 2\mathbf{e}_A)\). Internal variables are transported with their variance for the kernels that declare them (see Constitutive model (UMAT) catalog)

5

Logarithmic_F (log_F)

Convected logarithmic rate (pure \(\mathbf{F}\) transport)

Use "logarithmic_R" (3) for production work. The Jaumann (0), Green-Naghdi (1) and "logarithmic_F" (5) rates are provided for research and for comparing objective rates: under combined stretching and rotation they are different constitutive assumptions and give different responses. Under Jaumann and Green-Naghdi, Strain is the integral of \(\mathbf{D}\) along the rate’s spin, path dependent and equal to \(\ln\mathbf{V}\) only when the principal axes do not rotate; LogStrain and GreenLagrange are computed from \(\mathbf{F}\) and exact for every rate. At small strain ("small_strain" blocks) the rate plays no role.

The loading path file

path.json is what sim.solver.save_path_json writes for a list of Block objects, and what sim.solver.load_path_json reads back. Every name below is a keyword of Block, StepMeca or StepThermomeca, so a path built in Python and a path read from the file are the same objects (see In-memory Python solver). Enumerated entries (control_type, mode, control, thermal_control, corate) accept the names given here or the integer codes of the C++ solver; save_path_json always writes the names.

General structure

{
  "initial_temperature": 293.15,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "small_strain",
      "ncycle": 1,
      "steps": [
        { "...": "step definitions" }
      ]
    }
  ]
}

Path and block parameters

initial_temperature: initial temperature of the simulation (Kelvin); load_path_json returns it as T_init for solve.

kinematic_form: "total", or the objective rate of the finite-strain control types ("jaumann", "green_naghdi", "logarithmic", "logarithmic_R", "truesdell", "logarithmic_F", see the table above), or "rate" for the default rate "logarithmic_R" (also when absent). load_path_json returns it as its third element, for solve(kinematic_form=...).

corate: former name of kinematic_form, still read.

blocks: the loading blocks, run in order. A block is mechanical or thermomechanical (coupled heat equation) according to its steps: all the steps of a block are StepMeca ("thermomechanical": false) or all are StepThermomeca ("thermomechanical": true).

control_type: kinematic framework and control variables of the block, for mechanical and thermomechanical blocks alike. NLGEOM (non-linear geometry) is activated from "green_lagrange" on; a thermomechanical NLGEOM block needs kinematic_form "logarithmic_R" ("rate") or "total" (see Thermomechanical blocks under finite strain below):

Name (code)

NLGEOM

Description

"small_strain" (1)

No

Infinitesimal strains/stress (small deformations)

"green_lagrange" (2)

Yes

Finite deformation with Lagrangian control (Green-Lagrange strain \(\mathbf{E}\) / 2nd Piola-Kirchhoff stress \(\mathbf{S}\))

"logarithmic" (3)

Yes

Finite deformation with logarithmic (true) strain \(\boldsymbol{\varepsilon}\) / Kirchhoff stress \(\boldsymbol{\tau}\)

"biot" (4)

Yes

Finite deformation with the right stretch \(\mathbf{U}\) / Biot stress \(\mathbf{T}_B = \frac{1}{2}(\mathbf{R}^T\mathbf{P} + \mathbf{P}^T\mathbf{R})\). The kinematic targets are the components of \(\mathbf{U}\) itself, not of the Biot strain \(\mathbf{U} - \mathbf{I}\): the undeformed state is 1 on the diagonal, and a 8 % stretch is 1.08

"F" (5)

Yes

Finite deformation with deformation gradient \(\mathbf{F}\) control (Eulerian velocity L)

"gradU" (6)

Yes

Finite deformation with displacement gradient \(\nabla\mathbf{u}\) control

Important

A run is either entirely small strain or entirely finite strain: do not mix "small_strain" blocks with NLGEOM blocks. A small-strain block never updates \(\mathbf{F}\) (it stays \(\mathbf{I}\)), so a finite-strain block that follows it restarts its kinematics from \(\mathbf{F} = \mathbf{I}\) and the strain accumulated before is not carried into \(\mathbf{F}\) (under "truesdell", rebuilt from \(\mathbf{F}\), it is lost outright). The NLGEOM control types can be mixed freely.

Note

"logarithmic" control rebuilds the deformation gradient from the controlled strain as \(\mathbf{F} = \exp(\boldsymbol{\varepsilon})\,\mathbf{R}\), i.e. it takes the accumulated strain to be the Hencky strain \(\ln \mathbf{V}\), carried between increments by the polar rotation. The stored strain follows the chosen corate, so the two coincide exactly for the polar corates, "green_naghdi" and "logarithmic_R", and on any path without simultaneous stretching and rotation (a superposed rigid spin included). With "jaumann", "logarithmic" (XBM) or "logarithmic_F" under combined stretching and rotation, strain-controlled components are approximate and a difference is expected; this is one more reason to run with "logarithmic_R" (see the corate table above). Under kinematic_form="total" the stored strain is \(\ln\mathbf{U}\) and the law’s tangent is \(\partial\mathbf{T}/\partial\mathbf{H}\), so "logarithmic" control is refused, and "small_strain" blocks as well (their strain is not carried by \(\mathbf{F}\)): use "green_lagrange", "biot", "F" or "gradU".

ncycle: number of times the step sequence of the block is repeated (cyclic loading). A block holding a tabular step cannot be cycled.

steps: the steps of the block, in order.

Step definitions

mode: evolution of the prescribed components over the step:

  • "linear" (1): linear ramp to the target values

  • "sinusoidal" (2): sinusoidal evolution to the target values

  • "tabular" (3): table of increments read from a CSV file

Linear and sinusoidal steps

{
  "thermomechanical": false,
  "mode": "linear",
  "time": 30.0,
  "ninc": 100,
  "Dn_init": 1.0,
  "Dn_mini": 0.1,
  "control": ["strain", "stress", "stress", "stress", "stress", "stress"],
  "value": [0.01, 0.0, 0.0, 0.0, 0.0, 0.0],
  "T_final": 293.5
}

Parameters:

  • time: duration of the step \(\Delta t\)

  • ninc: number of increments; the time increment is \(\delta t = \Delta t / n_{inc}\)

  • Dn_init: initial size of the first sub-increment, as a fraction of one increment (usually 1.0)

  • Dn_mini: minimal sub-increment fraction the adaptive stepping may cut down to before giving up

  • control, value: the prescribed mechanical state (below)

  • T_final: temperature at the end of the step, null to hold the current one (mechanical steps: imposed temperature, thermal expansion without the heat equation)

Every block, mechanical or thermomechanical, starts with a zero-increment call to the law that primes its tangent. There is nothing to subdivide on that call: a law that requests a step cut there (a state it cannot evaluate, such as an SMA started inside its transformation zone) stops the run with an error naming the block. Start such a block from a state the law accepts.

Mechanical state specification

control names the prescribed quantity of each component and value its target at the end of the step, in Voigt order:

11  22  33  12  13  23

"strain" (or "E") prescribes the kinematic quantity of the control type (strain component), "stress" (or "S") the static one (stress component); a single string applies to all six components. For example "control": ["strain", "stress", "stress", "stress", "stress", "stress"] with "value": [0.01, 0, 0, 0, 0, 0] is a uniaxial tension test to 1 % strain in direction 1, the other components being stress-free. Targets are absolute values, reached at the end of the step whatever the state at its start.

For "F" and "gradU" control types the state is the full tensor, 9 components row-major:

11  12  13  21  22  23  31  32  33

control is then "strain" for all of them and value holds the target \(\mathbf{F}\) (or \(\nabla\mathbf{u} = \mathbf{F} - \mathbf{I}\)). The increments follow the geodesic \(\mathbf{F}_i = \exp(\Delta\mathbf{L}_i)\,\mathbf{F}_{i-1}\), each with its constant generator \(\Delta\mathbf{L}_i\) (a tabular step reads it between two rows, \(\ln(\mathbf{F}_i\mathbf{F}_{i-1}^{-1})\); a "zero" component of the table holds its value). A sub-increment of fraction \(s\) of the increment, from a step cut or Dn_init < 1, prescribes \(\exp(s\,\Delta\mathbf{L}_i)\,\mathbf{F}\) over \(s\,\delta t\), as the other control types prescribe \(s\) times their increment; the sub-increment that closes the increment lands on \(\mathbf{F}_i\) exactly.

For the mixed finite-strain control types ("green_lagrange", "logarithmic", "biot") a rotation rate can be superimposed with BC_w, a 3x3 spin matrix applied during the step:

"BC_w": [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]

Thermal state specification

Mechanical steps only carry T_final (above). Thermomechanical steps ("thermomechanical": true) solve the heat equation and take thermal_control:

  • "temperature" (T): imposed temperature, ramped to T_final

  • "heat_flux" (Q): imposed heat flux Q on the RVE (0.0 for adiabatic conditions)

  • "convection" (C): 0D convection \(Q = -q_{conv}\,(T - T_{init})\) with coefficient q_conv

Note

Thermomechanical blocks under finite strain. Every thermomechanical law is secant in the strain it is fed, so under NLGEOM it reads as a law in the logarithmic strain: ln V accumulated by "logarithmic_R" (the rate form, the default) or ln U and its dual stress under "total", in the frame that follows the material (anisotropy axes rotate with the body). Its parameters read accordingly: the density is the reference one \(\rho_0\), the expansion coefficient a logarithmic one. The entropy, the heat of the increment \(r\), the works and the imposed Q and q_conv are all per unit reference volume, and the stress in the entropy is the Kirchhoff stress \(\boldsymbol{\tau}\). The total form is exact: \(\mathbf{T}:\dot{\mathbf{H}} = \boldsymbol{\tau}:\mathbf{D}\). Under the rate form the kernel’s power differs from \(\boldsymbol{\tau}:\mathbf{D}\) when the stress is not coaxial with the stretch; the difference is booked to Wm and Wm_r, never to the heat. The two forms are therefore one law on a path whose principal stretch directions are fixed in the material (they agree to the time-discretization order of the rate form), and two different, equally legitimate laws when those directions turn: in simple shear to \(\gamma = 1\) with plasticity the adiabatic temperature and the dissipation of the two forms agree to \(10^{-3}\) while their recoverable works differ (the defect is second order in the difference of the principal log strains, \(1 - x/\sinh x\)). Prefer "total" when such paths dominate and the recoverable work matters. The other rates are refused. Under "F" / "gradU" control with a heat flux or a convection, the Newton runs on the temperature alone.

{
  "thermomechanical": true,
  "mode": "linear",
  "time": 1.0,
  "ninc": 100,
  "Dn_init": 1.0,
  "Dn_mini": 1.0,
  "control": ["strain", "stress", "stress", "stress", "stress", "stress"],
  "value": [0.02, 0.0, 0.0, 0.0, 0.0, 0.0],
  "thermal_control": "heat_flux",
  "Q": 0.0
}

Tabular steps

A tabular step follows a table of increments instead of a linear ramp. The table is the one input that is not JSON: it lives in its own CSV file next to path.json (<stem>_tab<k>.csv, k numbering the tabular steps of the path from 1), and the step references it by name:

{
  "thermomechanical": false,
  "mode": "tabular",
  "tabular": "path_tab1.csv",
  "Dn_init": 1.0,
  "Dn_mini": 0.01,
  "control": ["strain", "zero", "zero", "zero", "zero", "zero"],
  "tabular_T": false
}

The control list says which components the table drives:

  • "strain": strain-controlled component (a column of the table)

  • "stress": stress-controlled component (a column of the table)

  • "zero": component held at zero (no column)

tabular_T: false if the temperature is constant, true if the table carries a temperature column.

The table, one row per increment, comma- or whitespace-separated, # lines ignored:

# time, E11
0.01, 0.0005
0.02, 0.0010
0.03, 0.0015
...

Columns: time (absolute simulation time, continuing from the previous step), T if tabular_T is set (Q for a heat-flux thermomechanical step), then the controlled components in Voigt order 11, 22, 33, 12, 13, 23. sim.solver.save_path_json writes this file (with the header) from the tabular array of a StepMeca; the pre-2.0 #File increment tables (leading increment number, time restarting at 0) are converted to it by scripts/legacy_to_json.py. A tabular step cannot be cycled.

Examples

Cyclic loading (plasticity)

Stress-controlled tension/compression cycle, 1000 increments per step:

{
  "initial_temperature": 293.15,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "small_strain",
      "ncycle": 1,
      "steps": [
        {
          "thermomechanical": false,
          "mode": "linear",
          "time": 300.0,
          "ninc": 1000,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["stress", "stress", "stress", "stress", "stress", "stress"],
          "value": [1000.0, 0.0, 0.0, 0.0, 0.0, 0.0],
          "T_final": 293.15
        },
        {
          "thermomechanical": false,
          "mode": "linear",
          "time": 300.0,
          "ninc": 1000,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["stress", "stress", "stress", "stress", "stress", "stress"],
          "value": [-1100.0, 0.0, 0.0, 0.0, 0.0, 0.0],
          "T_final": 293.15
        }
      ]
    }
  ]
}

(additional steps, or "ncycle": 10 on the block, for cyclic loading; the files are written exactly like this by sim.solver.save_path_json)

Hyperelasticity with deformation gradient control

{
  "initial_temperature": 293.5,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "F",
      "ncycle": 1,
      "steps": [
        {
          "thermomechanical": false,
          "mode": "linear",
          "time": 5.0,
          "ninc": 10,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["strain", "strain", "strain",
                      "strain", "strain", "strain",
                      "strain", "strain", "strain"],
          "value": [5.0, 0.0, 0.0,
                    0.0, 0.4472135955, 0.0,
                    0.0, 0.0, 0.4472135955],
          "T_final": 290.0
        }
      ]
    }
  ]
}

This applies a uniaxial stretch with \(\lambda_1 = 5\) and \(\lambda_2 = \lambda_3 = 1/\sqrt{5}\) (incompressible).

Finite deformation with spin (logarithmic strain)

{
  "initial_temperature": 290.0,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "logarithmic",
      "ncycle": 1,
      "steps": [
        {
          "thermomechanical": false,
          "mode": "linear",
          "time": 30.0,
          "ninc": 100,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["stress", "stress", "stress", "stress", "stress", "stress"],
          "value": [3.0, 0.0, 0.0, 0.0, 0.0, 0.0],
          "BC_w": [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
          "T_final": 293.5
        }
      ]
    }
  ]
}

Thermomechanical loading

Adiabatic strain-controlled loading/unloading (heat equation on, no heat flux):

{
  "initial_temperature": 290.0,
  "kinematic_form": "logarithmic_R",
  "blocks": [
    {
      "control_type": "small_strain",
      "ncycle": 1,
      "steps": [
        {
          "thermomechanical": true,
          "mode": "linear",
          "time": 1.0,
          "ninc": 100,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["strain", "stress", "stress", "stress", "stress", "stress"],
          "value": [0.02, 0.0, 0.0, 0.0, 0.0, 0.0],
          "thermal_control": "heat_flux",
          "Q": 0.0
        },
        {
          "thermomechanical": true,
          "mode": "linear",
          "time": 1.0,
          "ninc": 100,
          "Dn_init": 1.0,
          "Dn_mini": 1.0,
          "control": ["strain", "stress", "stress", "stress", "stress", "stress"],
          "value": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
          "thermal_control": "heat_flux",
          "Q": 0.0
        }
      ]
    }
  ]
}

Pre-2.0 text inputs

Before 2.0 the loading path was a text file (path.txt, with #Mode / #prescribed_mechanical_state blocks and #File increment tables). Nothing in simcoon reads that format any more: scripts/legacy_to_json.py converts a data directory once into the files described here (see In-memory Python solver).