morphogen.homogenization.crystal

Crystal plasticity of Méric & Cailletaud (1991).

Plastic flow is the sum of the slips gamma^s on the slip systems s of the lattice (plane normal n^s, slip direction l^s), driven by the resolved shear stress tau^s = sigma : m^s, m^s = sym(l^s (x) n^s):

  • viscoplastic slip dgamma^s/dt = <(|tau^s - x^s| - r^s) / K>^n sign(tau^s - x^s);

  • kinematic hardening of each system x^s = C alpha^s, dalpha^s = dgamma^s - D alpha^s |dgamma^s|;

  • isotropic hardening r^s = tau_0 + Q sum_r h_sr (1 - exp(-b v^r)) with the cumulated slips v^r (dv^r = |dgamma^r|) and the interaction matrix h;

  • deps_p = sum_s dgamma^s m^s in small strains; dF_p F_p^-1 = sum_s dgamma^s l^s (x) n^s in finite strains (multiplicative decomposition F = F_e F_p, the slip systems fixed in the intermediate configuration, the lattice rotating with F_e).

The parameters tau_0, Q, b, C, D, K, n belong to the families of slip systems. Slip systems are given in the axes of the crystal; each grain turns them by its orientation, as its elasticity (morphogen.homogenization.materials).

Families: octahedral {111}<110> and cube {100}<110> (face-centred cubic crystals, and the cube slip of nickel-base superalloys), bcc110 {110}<111> and bcc112 {112}<111> (body-centred cubic crystals); for hexagonal crystals of ratio c_over_a (axis c along the third axis of the crystal, a_1 along the first), basal (0001)<11-20>, prismatic {10-10}<11-20>, pyramidal_a {10-11}<11-20>, pyramidal_ca {10-11}<11-23> and pyramidal2_ca {11-22}<11-23>.

Twinning (twins) is a slip in one sense (the pseudo-slip of Kalidindi 1998): a twin system of plane K_1 and direction eta_1 shears by gamma when the fraction f = gamma / gamma_tw of the crystal has twinned, gamma_tw the shear of the twin (the one that leaves the second plane K_2 undistorted). Its flow rule is that of a slip system for a positive resolved shear stress, with a resistance that grows without bound as the twinned fraction F = sum_t gamma^t / gamma_tw^t comes to its saturation F_sat (a barrier: 1 % of tau_0 at 90 % of the saturation, tau_0 at 99.9 %):

dgamma^t/dt = <(tau^t - x^t - r^t - 10^-3 tau_0 F / (F_sat - F)) / K>^n,

so that the twins stop there, whatever the stress. Under a stress that is reversed the twins shear back, down to none (detwinning, at the resistance of the twinning without its barrier, or at a share of it: twin_detwinning, a number; false: they stay). Families: twin111 {111}<11-2> (face-centred cubic, shear 1 / sqrt 2), twin112 {112}<11-1> (body-centred cubic, 1 / sqrt 2), and for hexagonal crystals twin1012 {10-12}<10-1-1> (which extends the axis c below c / a = sqrt 3: magnesium, titanium, and shortens it above: zinc), twin1011 {10-11}<10-1-2>, twin1122 {11-22}<11-2-3> and twin1121 {11-21}<-1-126>.

The lattice of a twin (twin_reorientation, a twinned fraction): when the twinned fraction of a point comes to it at the end of a step, the lattice of the point becomes that of its predominant twin (Van Houtte 1978; Tomé, Lebensohn & Kocks 1991, at each integration point): turned by half a turn about the normal of the twin plane, Q = 2 n (x) n - I, with its systems, its elasticity and its thermal strain. Its twins start again from nothing; in the new lattice the system of that twin shears the other way and brings the first lattice back, the other twins of its family being held. With {threshold, growth} the lattices are turned grain by grain after each step (turn_twins()): the most twinned points first, while the turned volume of the grain is below its twinned volume. Without it the lattice of the twinned fraction is not turned: the slip of the twins is not followed.

Cleavage (cleavage) opens crystallographic planes (the damage systems of Marchal, Forest, Rémy & Duvinage 2006, see Aslan & Forest 2009): a plane of normal n has an opening system, whose strain is delta n (x) n and which flows under a positive normal stress n . sigma . n, and accommodation systems sym(n (x) l) along directions l of the plane, which release its shear stresses once it has opened. Their flow rule is that of the slip systems, with a strength that softens with the opening and the slips of the plane:

Y = Y_0 exp(-w d),    d = delta + sum_i |delta_i|,

(shear times Y_0 for the accommodation systems): the energy dissipated by a plane that breaks is Y_0 / w per unit volume, a fracture energy G_c per unit area for elements of size h when w = Y_0 h / G_c (the crack band of Bažant & Oh 1983), which requires w Y_0 below the stiffness of the opening (h < E G_c / Y_0^2). Planes: cube {100}, dodecahedral {110} and octahedral {111} of cubic crystals, basal (0001) and prismatic {10-10} of hexagonal ones. Under pressure a plane closes: its opening follows the sign of the normal stress, back to nothing (Aslan & Forest 2009), and the closed plane carries the pressure as the sound crystal (the unilateral condition; closure: false: the opening stays, and the lattice alone is pressed; a number: the share of its strength at which the plane closes). With a coupling the slip of the crystal nucleates its cleavage (Aslan, Cordero, Gaubert & Forest 2011): the strength of the planes falls with the cumulated slip of the slip systems, Y = Y_0 exp(-w d) exp(-Theta gamma_cum), and their damage takes Theta exp(-Theta gamma_cum) sum_p (Y_0 / w) (1 - exp(-w d_p)) off the resistance of the slip systems (the two derive from one energy). With a regularization the planes are those of the microdamage theory of Aslan & Forest (2009): the planes of a point have one threshold, which softens linearly with the damage d of them all and hardens with this damage less the microdamage of the point, Y = Y_0 (1 - w d) + chi_H (d - chi_d), the microdamage chi_d following the damage over a length, chi_d - ell^2 lap chi_d = d (the solvers of the loading paths solve it, and break through the planes whose strength has come to nothing): a crack is then a band of a width that the elements do not set (microdamage_band()). The lips of a plane under pressure rub: the strength of its accommodation systems has Coulomb’s friction times the pressure (0 by default).

The interaction matrix is uniform (Taylor hardening) by default; [h_self, h_latent]; the six coefficients of Franciosi for the octahedral systems, in the order self, coplanar, Hirth lock, collinear, glissile junction, Lomer lock; or a full matrix.

Integration is implicit (backward Euler, the Armstrong-Frederick variables in closed form): Newton’s method on the magnitudes of the slips of an active set of systems, with the flow rule written as stresses (see the kernels below), and substeps when it fails; its linearization gives the consistent tangent, symmetric in small strains without isotropic hardening (Q b = 0) and not otherwise (the latent hardening of a system by the slips of the others; the multiplicative decomposition of finite strains), symmetrized for the conjugate gradient solvers or kept whole for GMRES (sym).

morphogen.homogenization.crystal.PARAMS = ('tau0', 'Q', 'b', 'C', 'D', 'K', 'n')

Parameters of a family of slip systems, in the order of the kernels

morphogen.homogenization.crystal.INTERACTIONS = ('self', 'coplanar', 'hirth', 'collinear', 'glissile', 'lomer')

Order of the six interaction coefficients of the octahedral systems

morphogen.homogenization.crystal.FAMILIES = {'bcc110': ((1, 1, 0), (1, 1, 1)), 'bcc112': ((1, 1, 2), (1, 1, 1)), 'cube': ((1, 0, 0), (1, 1, 0)), 'octahedral': ((1, 1, 1), (1, 1, 0))}

(normal type, direction type) of the cubic lattice

Type:

Slip families

morphogen.homogenization.crystal.HEXAGONAL = {'basal': ((0, 0, 0, 1), (1, 1, -2, 0)), 'prismatic': ((1, 0, -1, 0), (1, -2, 1, 0)), 'pyramidal2_ca': ((1, 1, -2, 2), (-1, -1, 2, 3)), 'pyramidal_a': ((1, 0, -1, 1), (1, -2, 1, 0)), 'pyramidal_ca': ((1, 0, -1, 1), (-1, -1, 2, 3))}

the plane (hkil) and the direction [uvtw] of one of their systems

Type:

Slip families of the hexagonal lattice

morphogen.homogenization.crystal.TWINS = {'twin1011': ('hexagonal', (1, 0, -1, 1), (1, 0, -1, -2), (3, 0, -3, 2)), 'twin1012': ('hexagonal', (1, 0, -1, 2), (-1, 0, 1, 1), (1, 0, -1, 1)), 'twin111': ('cubic', (1, 1, 1), (1, 1, -2), (1, 1, 2)), 'twin112': ('cubic', (1, 1, 2), (-1, -1, 1), (1, 1, 1)), 'twin1121': ('hexagonal', (1, 1, -2, 1), (-1, -1, 2, 6), (1, 1, -2, 0)), 'twin1122': ('hexagonal', (1, 1, -2, 2), (1, 1, -2, -3), (2, 2, -4, 3))}

the lattice, the plane K_1 and the direction eta_1 of one of their systems, and the direction eta_2 of its second undistorted plane (which sets the shear)

Type:

Twinning modes

morphogen.homogenization.crystal.CLEAVAGE = {'basal': ('hexagonal', (0, 0, 0, 1), ((1, 1, -2, 0), (1, -2, 1, 0), (-2, 1, 1, 0))), 'cube': ('cubic', (1, 0, 0), ((0, 1, 0), (0, 0, 1))), 'dodecahedral': ('cubic', (1, 1, 0), ((0, 0, 1), (1, -1, 0))), 'octahedral': ('cubic', (1, 1, 1), ((1, -1, 0), (1, 0, -1), (0, 1, -1))), 'prismatic': ('hexagonal', (1, 0, -1, 0), ((1, -2, 1, 0), (0, 0, 0, 1)))}

the lattice, one plane and the directions of its accommodation systems

Type:

Cleavage planes

morphogen.homogenization.crystal.SLIP = 0

slip, twin (in one sense), opening of a cleavage plane (in one sense), accommodation of a cleavage plane

Type:

Kinds of the systems of a crystal

morphogen.homogenization.crystal.TWIN = 1

slip, twin (in one sense), opening of a cleavage plane (in one sense), accommodation of a cleavage plane

Type:

Kinds of the systems of a crystal

morphogen.homogenization.crystal.OPENING = 2

slip, twin (in one sense), opening of a cleavage plane (in one sense), accommodation of a cleavage plane

Type:

Kinds of the systems of a crystal

morphogen.homogenization.crystal.ACCOMMODATION = 3

slip, twin (in one sense), opening of a cleavage plane (in one sense), accommodation of a cleavage plane

Type:

Kinds of the systems of a crystal

morphogen.homogenization.crystal.FIELDS = ('twin_fraction', 'twin_reoriented', 'twin_misorientation', 'cleavage_opening', 'cleavage_damage', 'cleavage_microdamage')

The fields of the crystals that twin or cleave, and the curves of their means along a loading path (CrystalPlasticity.point_fields())

morphogen.homogenization.crystal.lattice_of(family: str) → str[source]

The lattice ("cubic" or "hexagonal") of a family of slip systems, of twins or of cleavage planes.

morphogen.homogenization.crystal.disorientation(rotations, lattice: str) → ndarray[source]

The disorientation (degrees) of lattices turned by rotations (…, 3, 3; in the axes of the crystal) from the one that they were: the smallest angle of the rotations that bring the one onto the other, over the symmetries of the lattice (60 degrees for the twins of cubic crystals, 86.3 for the {10-12} twin of magnesium).

morphogen.homogenization.crystal.slip_systems(family: str, c_over_a: float | None = None) → tuple[ndarray, ndarray][source]

Unit plane normals and slip directions (N x 3 each, axes of the crystal) of a family of slip systems; c_over_a: the ratio of the hexagonal lattice.

morphogen.homogenization.crystal.twin_systems(family: str, c_over_a: float | None = None)[source]

Unit normals of the twin planes K_1 and directions of their shear (N x 3 each, axes of the crystal) of a family of twins, and the shear of the twin: the one that leaves the direction eta_2 of the second undistorted plane with its length, gamma_tw = 2 |eta_2 . l| / (eta_2 . n); the directions are those of the shear (the twin does not form in the other sense).

morphogen.homogenization.crystal.cleavage_systems(planes: str, c_over_a: float | None = None)[source]

The systems of a family of cleavage planes: unit normals and directions (N x 3 each, axes of the crystal), their kinds (OPENING, whose direction is the normal, then the ACCOMMODATION systems of the plane) and the plane of each (its index in the family).

morphogen.homogenization.crystal.interaction_types(normals, directions) → ndarray[source]

Type of the interaction of each pair of octahedral systems (index in INTERACTIONS): self, coplanar, Hirth lock (orthogonal Burgers vectors), collinear, and for the other pairs a glissile junction when the junction b_s +- b_r lies in one of the two planes, a Lomer lock otherwise.

morphogen.homogenization.crystal.CLEAVAGE_PARAMS = ('strength', 'softening', 'shear', 'K', 'n')

the normal stress that opens them, the rate of their softening (per unit of opening strain), the ratio of the strength of their accommodation systems to it, and the viscosity (K, n) of their flow

Type:

Parameters of a family of cleavage planes

morphogen.homogenization.crystal.microdamage_band(strength: float, softening: float, modulus: float, length: float)[source]

The damage band of cleavage planes regularized by their microdamage (Aslan & Forest 2009), when a plane breaks across a bar normal to it: its width and the fracture energy of the planes (per unit area).

strength: Y_0; softening: w, their linear softening Y_0 (1 - w d), of modulus H = -w Y_0; modulus: the micromorphic modulus chi_H, above w Y_0; length: ell = sqrt(A / chi_H), that of the equation of the microdamage, chi_d - ell^2 lap chi_d = d. With r = w Y_0 / chi_H and theta = pi - atan sqrt(r / (1 - r)), the damage is (Y_0 - sigma) / |H| + beta cos(omega x) over the width b = 2 theta / omega, omega = sqrt(r / (1 - r)) / ell; the bar softens linearly from Y_0 to nothing as the band opens by Y_0 (b + 2 ell) / |H|, and the work that breaks it is G_c = Y_0^2 (b + 2 ell) / (2 |H|).

morphogen.homogenization.crystal.microdamage_parameters(strength: float, energy: float, width: float, ratio: float = 0.3333333333333333)[source]

The parameters of cleavage planes regularized by their microdamage from the fracture energy of the planes (per unit area) and the width of their damage band (microdamage_band(), inverted): their softening w (linear: Y_0 (1 - w d)), their micromorphic modulus chi_H = w Y_0 / ratio and the length of the equation of the microdamage (a mapping of the three). ratio: that of the softening modulus to the micromorphic one, in ]0, 1[ (a third by default, as in the reference): the band is 2 theta sqrt((1 - r) / r) lengths wide.

class morphogen.homogenization.crystal.CrystalPlasticity(families: tuple[tuple[str, tuple[float, ...]], ...], interaction: tuple = (), twins: tuple[tuple[str, tuple[float, ...]], ...] = (), cleavage: tuple[tuple[str, tuple[float, ...]], ...] = (), c_over_a: float | None = None, twin_saturation: float = 1.0, twin_reorientation: float | None = None, twin_detwinning: bool | float = True, cleavage_closure: bool | float = True, cleavage_friction: float = 0.0, twin_reorientation_growth: float | None = None, cleavage_coupling: float = 0.0, cleavage_regularization: tuple[float, float] | None = None)[source]

Bases: object

Méric-Cailletaud crystal plasticity: families of slip systems with their parameters (tau0, Q, b, C, D, K, n, see PARAMS) and the interaction matrix ((): uniform; (h_self, h_latent); the six coefficients of INTERACTIONS for the octahedral family; or a full matrix). twins: families of twins (TWINS) with the same parameters, which shear in one sense until the fraction twin_saturation of the crystal has twinned; cleavage: families of cleavage planes (CLEAVAGE) with their parameters (CLEAVAGE_PARAMS), which open under a normal stress; c_over_a: the ratio of a hexagonal lattice (its families are those of HEXAGONAL). The systems of a crystal are its slip systems, then its twins, then those of its cleavage planes.

twin_detwinning and cleavage_closure: whether the twins shear back and the planes close when the stress is reversed, or the share of their resistance at which they do (true: 1). twin_reorientation: the twinned fraction at which the lattice of a point becomes that of its predominant twin; with twin_reorientation_growth, the lattices are turned grain by grain (turn_twins()), the threshold of a grain growing by it times the share of its twinned volume that is turned. cleavage_coupling: the rate at which the cumulated slip of the crystal lowers the strength of its cleavage planes (Aslan et al. 2011), the damage of the planes easing its slip in return. cleavage_regularization: the micromorphic modulus and the length of the microdamage that regularizes the planes (Aslan & Forest 2009: microdamage_band()), whose softening is then linear.

property n_slip: int

The slip systems.

property n_twins: int

The twin systems.

property n_cleavage: int

The systems of the cleavage planes (openings and accommodations).

property n_systems: int
property extended: bool

Whether the crystal twins or cleaves (systems that are not slip systems).

property reorients: bool

Whether the twins of the crystal turn its lattice (twin_reorientation): its points then keep their rotation (CP_TURNED internal variables more).

property regularized: bool

Whether the cleavage planes are regularized by their microdamage (cleavage_regularization): their points then keep it (micro_width internal variables more), and the solvers of the loading paths solve its equation.

property n_planes: int

The cleavage planes of the crystal.

property micro_width: int

The internal variables of the microdamage of a point (state_width()): the microdamage, and the mark of each plane (0, or 1 + the damage that it had when it was broken through); none for planes that are not regularized.

property by_grain: bool

Whether the lattices are turned grain by grain, after each step (turn_twins(): twin_reorientation_growth), not point by point.

systems() → tuple[ndarray, ndarray][source]

Unit normals and slip directions of all the systems (axes of the crystal): the direction of the opening of a cleavage plane is its normal.

params_array() → ndarray[source]

Parameters of each system (N x 7, see PARAMS): of a cleavage system, its strength (tau0) and its viscosity (K, n).

kinds_array() → ndarray[source]

What each system is, beside its parameters (N x 9): its kind (SLIP, TWIN, OPENING, ACCOMMODATION), the rate of its softening (cleavage), its share of the saturation per unit of shear, 1 / (gamma_tw F_sat) (twins), its cleavage plane (-1 for the others), the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share per unit of shear of the fraction at which the lattice is turned, 1 / (gamma_tw F_turn) (twins that turn it; -1 where the lattices are turned grain by grain), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), its twinned fraction per unit of shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength and the micromorphic modulus of its regularization (the systems of the cleavage planes: cleavage_coupling, cleavage_regularization).

interaction_matrix() → ndarray[source]

The interaction of the slip systems and of the twins (none with the systems of the cleavage planes).

property lattice: str

The lattice of the families of the crystal, "cubic" or "hexagonal".

property field_names: tuple[str, ...]

The fields of the crystal beside those of every behaviour (among FIELDS): those of its twins (the lattices that they turn with twin_reorientation, and their disorientation) and of its cleavage planes.

check_softening(stiffness, force: bool = False) → None[source]

Refuse cleavage planes that soften faster than the crystal unloads (stiffness: its 6 x 6 matrix in its axes): the opening delta of a point whose strain is held releases the stress (n (x) n) : C : (n (x) n) delta, and its strength must fall more slowly, w Y_0 < (n (x) n) : C : (n (x) n) (likewise for the accommodation systems), for the state of the point to follow its strain. With the fracture energy G_c of the planes dissipated in elements of size h (w = Y_0 h / G_c): h < C_nn G_c / Y_0^2. Not for planes regularized by their microdamage, which harden at a fixed microdamage (force: for them too, as a point alone softens with its damage).

point_fields(slips, *, openings=None, turned=None, orientations=None, micro=None) → dict[source]

The fields of points from the cumulated slips of their systems (points x N): the twin_fraction (with twins), the cleavage_opening (the opening strain of the planes) and the cleavage_damage of the most damaged plane, the share of its strength that its damage has taken (with cleavage planes: 1 - exp(-w d); for planes regularized by their microdamage, what the damage of the planes of the point and its microdamage have taken, w d - chi_H (d - chi_d) / Y_0 between 0 and 1, and 1 for a plane broken through); for these, the cleavage_microdamage of the points (micro, points x micro_width: the microdamage — of a point alone, a negative value: the damage of its planes — and the marks of the planes broken through).

openings: the slips of the systems now (points x N, the variables alpha): the opening is then that of the planes now, less than what they have opened once they close. turned: the variables of the lattices that their twins turn (points x CP_TURNED): the twinned fraction of a turned lattice is the one that it had when it was turned, less the fraction of the twin that brings the first lattice back (detwinning) — the fraction of the shears of the twins, which a turn does not change; twin_reoriented is 1 where the lattice is that of a twin (its mean: the turned volume) and twin_misorientation its disorientation() from the lattice of the grain (degrees; with the orientations of the grains of the points, points x 3 x 3, their axes in those of the sample: the rotations are kept in the latter).

state_fields(state, finite: bool = False, orientations=None) → dict[source]

The fields of points (point_fields()) from their internal variables (points x width, those of the kernels in small or finite strains).

to_config() → dict[source]
classmethod from_config(spec) → CrystalPlasticity[source]

{families: [octahedral, ...] or {octahedral: {tau0: ..}, ...}, tau0, Q, b, C, D, K, n, interaction}: the parameters given at the top apply to every family, and those of a family override them. twins: families of twins, given as the slip families (twin_saturation: the fraction at which they stop; twin_reorientation: the fraction at which the lattice of a point becomes that of its predominant twin, none by default, or {threshold, growth}: the lattices are turned grain by grain, the most twinned points first while the turned volume of the grain is below its twinned volume, past a threshold that grows by growth times their ratio; twin_detwinning: false: the twins do not shear back, or the share of their resistance at which they do); cleavage: {planes: basal, or a list, or {basal: {strength: ..}}, strength, softening (or energy and length), shear, K, n, closure, friction, coupling} (closure: false: the planes do not close, or the share of their strength at which they do; friction: Coulomb’s, of the planes under pressure; coupling: the rate at which the cumulated slip lowers their strength; regularization: the microdamage of the planes, {modulus, length} with their linear softening, or {width, ratio} of their damage band with their fracture energy: microdamage_parameters()); c_over_a: the ratio of a hexagonal lattice. The slip families default to the octahedral one, to none with twins or cleavage planes.

morphogen.homogenization.crystal.CP_ALPHA = 7

Index of alpha among the internal variables

morphogen.homogenization.crystal.CP_KIND = 7

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_SOFT = 8

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_SAT = 9

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_GROUP = 10

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_CLOSE = 11

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_TURN = 12

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_OPEN = 13

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_FAMILY = 14

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_SHEAR = 15

Columns of the parameters of a system after those of PARAMS, which the kernels read when the array has them (CrystalPlasticity.kinds_array()): its kind, the rate of its softening, its share of the saturation of the twins, its cleavage plane, the share of its resistance at which it goes back to nothing (a twin that untwins, the opening of a plane that closes; 0: it does not) or the friction of its plane under pressure (an accommodation system), its share of the twinned fraction at which the lattice is turned into that of the twin (negative: the lattices are turned grain by grain, turn_twins()), the opening system of its plane (an accommodation system; -1 for the others), its family (a twin; -1 for the others), the twinned fraction per unit of its shear, 1 / gamma_tw (a twin), the rate at which the slip of the crystal lowers its strength, and the micromorphic modulus of the planes that their microdamage regularizes (the systems of the cleavage planes; 0: a local softening)

morphogen.homogenization.crystal.CP_WIDTH = 18

Width of the parameters of a system for the kernels

morphogen.homogenization.crystal.CP_TURNED = 11

its rotation from that of the grain, less the identity (9), the twin that would bring it back (its index + 1; 0 without one, -1 for a lattice turned more than once) and the twinned fraction of the point when it was turned

Type:

The internal variables of a lattice that its twins turn, after the others

morphogen.homogenization.crystal.state_width(n_systems: int, finite: bool = False, turns: bool = False, micro: int = 0) → int[source]

Internal variables of a crystal point with n_systems slip systems; turns: its twins turn its lattice (CP_TURNED more); micro: those of the microdamage that regularizes its cleavage planes, the last ones (the microdamage, then the mark of each plane, 1 + its damage when it was broken through: CrystalPlasticity.micro_width).

morphogen.homogenization.crystal.work_blocks(count, n_max)[source]

count sets of work arrays of the kernels for at most n_max slip systems: those of work_arrays() with one more axis, the first one (work_block() takes a set).

morphogen.homogenization.crystal.work_block(blocks, k)[source]

The set k of the work arrays of work_blocks() (views).

The kernels take rows of their work arrays at each call. Rows of arrays that the compiled code manages count their references, atomically: a third to a half of the time of a point where the arrays are allocated in the loop over the points. The loops over the points (morphogen.homogenization.behaviours.update_points(), morphogen.homogenization.finite.update_points_finite()) allocate instead the sets of all their chunks of points before their parallel loop, which then holds them as plain memory, and take the set of each chunk.

morphogen.homogenization.crystal.work_arrays(n_max)[source]

Work arrays of the kernels for at most n_max slip systems.

morphogen.homogenization.crystal.rotate_stiffness(dm, rot, out, bond, tmp)[source]

The stiffness dm (6 x 6, stresses for engineering strains) of a lattice turned by the rotation rot (its vectors v become rot v): out = K dm K^T, with K (left in bond) the matrix of the tensor components of a turned symmetric tensor, (rot a rot^T) = K a.

morphogen.homogenization.crystal.turn_lattice(par, ns, normal, new, rot, best)[source]

Turn the lattice of a point (its internal variables new, the rotation at new[rot:]) into that of its twin best, of plane normal (axes of the sample, in the lattice as it is): by half a turn about the normal, Q = 2 n (x) n - I, a rotation that composes with those of the earlier twins. Its twins start again from nothing: in the new lattice, the system of that twin shears the other way and brings the first lattice back (detwinning), the other systems of its family being held (the conjugate twin of a twin of small shear deforms the lattice as the detwinning does, under the same resolved stress, and would otherwise share it). The point keeps the twinned fraction that it had (by the shears of its twins); when the lattice of the grain comes back, what is left of it is the shear of that twin, which goes on shearing back.

morphogen.homogenization.crystal.turn_twins(crystal, state, before, grains, systems, *, points=None, finite: bool = False, weights=None) → int[source]

The lattices that the twins of grains turn at the end of a step, grain by grain: the predominant twin reorientation of Tomé, Lebensohn & Kocks (1991), with the points of a grain in place of the grains of an aggregate. In each grain, of twinned volume V_acc (the mean of the twinned fractions of its points, by the shears of their twins) and turned volume V_eff (that of its points whose lattice is that of a twin), the points whose twinned fraction has grown over the step past the threshold

F_T = min(1, A_1 + A_2 V_eff / V_acc)

take the lattice of their predominant twin (turn_lattice(); the first of the twins within _TIE of the largest fraction), the most twinned first, while the turned volume is below the twinned one. When the twins shear back, the lattices come back — the points whose twin has been undone the most first, by A_1 at least, while the turned volume is above the twinned one — and those whose twin is undone altogether in any case.

crystal: a CrystalPlasticity with twin_reorientation (A_1) and twin_reorientation_growth (A_2); state and before: the internal variables of points at the end and at the start of the step (rows x width; state is changed in place); points: the rows of the points of the crystal (all by default), grains the grain of each of them, systems the systems of the lattices of the grains (grains x N x 6: direction and normal, axes of the sample) and weights their volumes (equal by default). Returns the number of lattices turned.

morphogen.homogenization.crystal.cp_small(sys, par, h, ns, dm, eps, eth, dt, old, new, sig, tan, guess, ratio, work, sym=True, key=-1)[source]

Implicit update of a Méric-Cailletaud point in small strains over a step dt: strain eps (engineering), thermal strain eth (tensor components), slip systems sys (slip direction, plane normal) and elasticity dm in the axes of the sample. Fills the stress, the internal variables and the consistent tangent (symmetrized with sym); returns 1 if the local iteration fails, even in substeps. key: a number of the material of the point (its systems and its elasticity), 0 or more: the Schmid tensors of the last point integrated with these work arrays are kept for a point of the same key (-1: computed for each point).

morphogen.homogenization.crystal.cp_finite(sys, par, h, ns, dm, hg, eth6, dt, old, new, pk1, tan, guess, ratio, work)[source]

Implicit update of a Méric-Cailletaud point in finite strains: displacement gradient hg (F - I, 9 components row by row), thermal strain eth6 (tensor components, Green-Lagrange, of the lattice), slip systems sys and elasticity dm of the lattice in the intermediate configuration, axes of the sample. Fills the first Piola-Kirchhoff stress pk1, the internal variables and the tangent tan = d P / d F (9 x 9); returns 1 if the local iteration fails, even in substeps.