API — LayeredSphere

MeanFieldHomogenization.LayeredSpheres Module

MeanFieldHomogenization.LayeredSpheres

Isotropic n-layer spherical composite inclusion (core + concentric shells) embedded in an infinite matrix, with perfect or imperfect interfaces (spring / surface-elastic / Kapitza / surface-conductive). Public entry points: LayeredSphere, the bulk / shear concentration and layer-average utilities.

MeanFieldHomogenization.LayeredSpheres.LayeredSphere Type

LayeredSphere{T, N, Cs, Is} <: AbstractLayeredInclusion{3, T}

Isotropic N-layer spherical composite inclusion (core + concentric shells) embedded in an infinite matrix. Type parameters:

• T — element type of the radii (Float64, BigFloat, ForwardDiff.Dual, SymPyPythonCall.Sym, Symbolics.Num, …).

• N — number of layers ( ).

• Cs — concrete type of the moduli NTuple.

• Is — concrete type of the interfaces NTuple.

Use the keyword-argument constructor LayeredSphere(radii, moduli; interfaces) for most cases.

Convention

• Radii are ascending,   implicit.

• Moduli per layer, layer between and .

• Interfaces at each radius ; interface is the outer boundary with the matrix.

MeanFieldHomogenization.LayeredSpheres.AbstractInterface Type

AbstractInterface{T}

Root supertype for interface conditions in a LayeredSphere. Concrete subtypes determine the jump matrix applied to the state vector (bulk), (shear), or (conductivity).

MeanFieldHomogenization.LayeredSpheres.PerfectInterface Type

PerfectInterface{T}()

Perfect (continuous) interface: all state-vector components are continuous.

MeanFieldHomogenization.LayeredSpheres.SpringInterface Type

SpringInterface(kn, kt)
SpringInterface(kn)
SpringInterface(; kn, kt)      # stiffnesses
SpringInterface(; sn, st)      # compliances

Imperfect interface of linear-spring type: the traction stays continuous while the displacement jumps in proportion to it,

kn, kt are the normal and tangential stiffnesses , — traction per unit opening, the usual meaning of those symbols — and sn, st the matching compliances  ,  . Both spellings read and write the same interface:

itf = SpringInterface(50.0, 20.0)        # stiffnesses
itf.kn, itf.kt                           # (50.0, 20.0)
itf.sn, itf.st                           # (0.02, 0.05)
SpringInterface(; sn = 0.02, st = 0.05)  # == itf

Limits:   (equivalently   ) recovers PerfectInterface;    is a free surface, the layer boundary fully decoupled. The one-argument form SpringInterface(kn) is a normal spring with the tangential direction bonded ( ).

Compliances are what is stored

The perfect interface is   , an exact zero, whereas in stiffnesses it is an infinity. Storing the compliances therefore keeps the near-perfect regime representable in ForwardDiff.Dual and in the symbolic types, where an Inf would poison the derivative. The stiffness spelling is a conversion on read and on write; the transfer matrices consume spring_compliances.

Echoes' PRIMALDISC takes the same stiffness convention, so the two accept the same numbers.

For a full compliance tensor with normal/tangential coupling, see AnisotropicSpringInterface.

MeanFieldHomogenization.LayeredSpheres.MembraneInterface Type

MembraneInterface{T}(κs::T, μs::T)

Imperfect interface of surface-elastic (Gurtin–Murdoch "membrane") type — the dual analog of SpringInterface and the elastic counterpart of Echoes' DUALDISC. The interface behaves as a 2D elastic shell with surface moduli    (surface dilatation, matching Echoes' ks) and surface shear . Displacement is continuous across the interface and the surface strain generates a traction jump (    ). On a spherical interface of radius , the bulk () mode jump is

and the shear (-harmonic) mode jump, with   ,   , is

The    limit recovers PerfectInterface. These jumps reproduce Echoes' DUALDISC concentration tensors and effective moduli to machine precision.

MeanFieldHomogenization.LayeredSpheres.KapitzaInterface Type

KapitzaInterface{T}(resistance::T)

Thermal imperfect interface with scalar thermal resistance (resistance): the flux is continuous and the temperature drops across the interface in the direction of the flux,

with     the flux and   , the normal pointing from the inner side to the outer side . Primal analog of SpringInterface: in the dictionary    it reads   , as   .

MeanFieldHomogenization.LayeredSpheres.SurfaceConductiveInterface Type

SurfaceConductiveInterface{T}(conductance::T)

Highly-conductive 2D surface layer (dual analog of MembraneInterface). Introduces a flux jump driven by the surface Laplacian of the temperature; for the spherical harmonic on a spherical interface of radius and surface conductance (conductance),

  recovers PerfectInterface.

MeanFieldHomogenization.LayeredSpheres.layer_count Function

layer_count(lam) -> Int

Number of layers in one period.

layer_count(spheroid) -> Int

Number of layers (excluding the matrix).

layer_count(incl::FEAxiLayeredSpheroid) -> Int

How many layers the inclusion has, the matrix excluded.

layer_count(sphere) -> Int

Number of layers (excluding the matrix).

MeanFieldHomogenization.LayeredSpheres.layer_radius Function

layer_radius(sphere, k) -> T

Outer radius of layer k. Layer 1 extends from 0 to layer_radius(1), layer k from layer_radius(k-1) to layer_radius(k).

MeanFieldHomogenization.LayeredSpheres.layer_modulus Function

layer_modulus(spheroid, k)

Isotropic conductivity of layer k.

layer_modulus(sphere, k)

Stiffness (or conductivity) tensor of layer k.

MeanFieldHomogenization.LayeredSpheres.layer_property_average Function

layer_property_average(spheroid, Val(2)) -> TensISO{2,3}

Voigt (volume) average of the layer conductivities,   (scalar, direction-independent — the Voigt/Reuss bounds only ever need the phase's volume-averaged property, not its shape). A layered spheroid carries conductivities only.

layer_property_average(sphere, P₀) -> TensISO
layer_property_average(sphere, Val(order)) -> TensISO

Voigt (volume) average of the layer properties: the stiffnesses,  , when P₀ is a fourth-order tensor (order = 4), the conductivities,  , when it is a second-order one (order = 2); P₀ only sets the order. This is what the Voigt bound needs for a composite sphere: the declared phase property does not represent it. Explicit names: layer_stiffness_average and layer_conductivity_average.

MeanFieldHomogenization.LayeredSpheres.layer_inverse_property_average Function

layer_inverse_property_average(spheroid, Val(2)) -> TensISO{2,3}

Reuss (volume) average of the layer resistivities, .

layer_inverse_property_average(sphere, P₀) -> TensISO
layer_inverse_property_average(sphere, Val(order)) -> TensISO

Reuss (volume) average of the inverse layer properties: the compliances,  , at order 4, the resistivities, , at order 2. Explicit names: layer_compliance_average and layer_resistivity_average.

MeanFieldHomogenization.LayeredSpheres.layer_interface Function

layer_interface(lam, k::Integer) -> AbstractInterface

The interface on top of layer k (the k-th in stacking order); k = N closes the cell onto layer 1 by periodicity.

layer_interface(spheroid, k) -> AbstractInterface

Interface condition at layer_q(spheroid, k) (between layer k and layer k+1 if k < N, or with the matrix if k = N).

layer_interface(sphere, k) -> AbstractInterface

Interface condition at layer_radius(k) (between layer k and layer k+1 if k < N, or with the matrix if k = N).

MeanFieldHomogenization.LayeredSpheres.layer_volume_fraction Function

layer_volume_fraction(lam, name::Symbol) -> Number

Volume fraction   of layer name.

layer_volume_fraction(spheroid, k) -> T

Volume fraction of layer k inside the outer spheroid , based on the confocal volume shape function    (   , eq:xLeg).

layer_volume_fraction(sphere, k) -> T

Volume fraction of layer k inside the outer sphere of radius layer_radius(N).

MeanFieldHomogenization.LayeredSpheres.outer_radius Function

outer_radius(sphere) -> T

Outermost radius of the composite sphere.

MeanFieldHomogenization.LayeredSpheres.layer_gradient_average Function

layer_gradient_average(sphere, C₀, ε∞, layer) -> Tens{2,3}

Volume-averaged strain tensor inside the layer-th layer of a LayeredSphere embedded in an isotropic matrix C₀, under a remote strain ε∞. Returns a symmetric 2-tensor in the canonical frame. Combines the bulk concentration (hydrostatic part) and the shear concentration (deviatoric part).

This is the strain of the layer's material: the opening of a SpringInterface on either side of it is not included. gradient_gradient_concentration(sphere, C₀; layer, external, internal) adds it.

layer_gradient_average(sphere, K₀, ∇T∞, layer) -> Vec{3}

Volume-averaged temperature gradient    inside the layer-th layer of a LayeredSphere in an isotropic matrix K₀.

The conduction method. The average is a scalar multiple of the remote gradient, and that scalar is constant inside a layer: with         and   , the directional averages    give

the terms of and canceling exactly. The decaying mode is not absent — it is generally large — it simply contributes nothing to the mean gradient.

MeanFieldHomogenization.LayeredSpheres.layer_flux_average Function

layer_flux_average(sphere, C₀, ε∞, layer) -> Tens{2,3}

Volume-averaged stress    inside the layer-th layer, under a remote strain ε∞.

Note this is the average of the stress inside the layer's material. A MembraneInterface additionally carries a surface stress on the layer boundary, which belongs to the interface rather than to either adjacent bulk, and is therefore not included here — property_contribution and flux_gradient_concentration account for it separately. The gap is not small: on a two-layer sphere with MembraneInterface(1.3, 0.7), sphere_flux_average and flux_gradient_concentration ⊡ ε∞ differ by order one, while with perfect interfaces they agree to machine precision.

layer_flux_average(sphere, K₀, ∇T∞, layer) -> Vec{3}

Volume-averaged flux     inside the layer-th layer, with the Fourier / Fick sign convention.

MeanFieldHomogenization.LayeredSpheres.sphere_gradient_average Function

sphere_gradient_average(sphere, C₀, ε∞) -> Tens{2,3}

Volume-averaged strain over the whole composite sphere (all layers combined):    where is the volume fraction of layer inside the composite sphere.

This is the strain of the material, which leaves out the opening of the spring interfaces. The strain of the sphere seen from the matrix, which the schemes use, includes it: gradient_gradient_concentration(sphere, C₀, C₀) ⊡ ε∞. The two agree when every interface is perfect or a membrane.

sphere_gradient_average(sphere, K₀, ∇T∞) -> Vec{3}

Volume-averaged temperature gradient over the whole composite sphere,    .

As in elasticity, an average over the material: the temperature jump across a KapitzaInterface is left out, and gradient_gradient_concentration(sphere, K₀, K₀) includes it.

MeanFieldHomogenization.LayeredSpheres.sphere_flux_average Function

sphere_flux_average(sphere, C₀, ε∞) -> Tens{2,3}

Volume-averaged stress over the whole composite sphere,    .

sphere_flux_average(sphere, K₀, ∇T∞) -> Vec{3}

Volume-averaged flux over the composite sphere,   , with the Fourier / Fick sign convention: the conduction method of the function whose elasticity method averages the stress.

MeanFieldHomogenization.LayeredSpheres.cumulative_strain_average Function

cumulative_strain_average(sphere, C₀, ε∞, r) -> Tens{2,3}

Volume-averaged strain over the ball of radius   centered on the composite sphere center. The ball may cross several layers; the outermost one it reaches is generally cut part way through, and the average accounts for that exactly.

Why a truncated layer is not a scaled one

Weighting the full-layer average by the truncated volume — the obvious shortcut — is correct only where the field is uniform inside a layer, and it is not: the mode-2 term of the deviatoric solution varies as . The truncated average is obtained instead by evaluating _layer_avg_dev_shear_factor at the cut radius. The two agree at  , which is why interface radii alone cannot expose the difference.

MeanFieldHomogenization.LayeredSpheres.spring_compliances Function

spring_compliances(intf::SpringInterface) -> (sn, st)

Normal and tangential compliances — the quantities the transfer matrices multiply the traction by. This is the stored pair; a perfect interface gives exact zeros.

MeanFieldHomogenization.LayeredSpheres.spring_stiffnesses Function

spring_stiffnesses(intf::SpringInterface) -> (kn, kt)

Normal and tangential stiffnesses, . A bonded direction has a zero compliance and therefore an infinite stiffness.

MeanFieldHomogenization.LayeredSpheres.LayeredSphereFields Type

LayeredSphereFields(sphere, C₀)

Precomputed pointwise elastic solution of a LayeredSphere embedded in the isotropic matrix C₀: the per-region amplitudes of the spherical mode pair and of the four deviatoric Love modes , for   the layers and    the matrix, under a unit remote strain.

Build it once and pass it wherever (sphere, C₀) is accepted. Every local_* entry point also takes (sphere, C₀) directly, but that form re-runs the whole recurrence on every call — fine for a handful of points, wasteful for the thousands a field map needs.

sol = LayeredSphereFields(sphere, C₀)
A   = local_gradient_gradient_concentration(sol, x)

See also LayeredSphereTransportFields.

MeanFieldHomogenization.LayeredSpheres.LayeredSphereTransportFields Type

LayeredSphereTransportFields(sphere, K₀)

Precomputed pointwise transport (thermal / electric / Darcy) solution of a LayeredSphere in the isotropic matrix K₀: the per-region amplitudes of     , for   the layers and    the matrix, under a unit remote gradient.

Transport twin of LayeredSphereFields.

MeanFieldHomogenization.LayeredSpheres.get_layer Function

get_layer(s::LayeredSpheroid, q; side = :outer) -> Int

Index of the region containing the confocal coordinate q: for the layers,   for the surrounding matrix ( ).

Exactly on an interface   the field has two limits and side picks one — :outer (default) the limit from outside, region  ; :inner the limit from inside, region . Same convention and same keyword as get_layer(::LayeredSphere, r); it matters for a KapitzaInterface, across which the temperature itself jumps.

get_layer(sphere::LayeredSphere, r; side = :outer) -> Int

Index of the region containing the radius r: for the layers,   for the surrounding matrix.

Layer occupies   , so a radius strictly between two interfaces is unambiguous. On an interface   the field has two different limits and side picks one:

• side = :outer (default) — the limit from above, : region  , consistent with the half-open convention used by layer_volume_fraction and by LayeredSpheroids.get_layer;

• side = :inner — the limit from below, : region .

The distinction is not cosmetic. Across a SpringInterface the displacement jumps and across a MembraneInterface the traction jumps, so local_flux(…, r_k; side = :inner) and side = :outer return genuinely different tensors — that difference is the interface law, and the test suite checks it against the prescribed jump.

Radii beyond always give  , whatever side.

A symbolic radius is refused rather than located. SymPyPythonCall.Sym answers a comparison it cannot decide with a plain false — r ≥ 1.0 on a positive symbol returns Bool(false), not an error — so the loop below would silently return layer 1 for any symbol. Name the region explicitly instead: every pointwise entry point takes a layer keyword.

MeanFieldHomogenization.LayeredSpheres.region_stiffness Function

region_stiffness(f::LayeredSphereFields, k) -> TensISO{4,3}

Stiffness tensor of region k, the matrix C₀ for k = N+1.

MeanFieldHomogenization.LayeredSpheres.shell_concentration Function

shell_concentration(f::LayeredSphereFields, k) -> (α_k, β_k)

Volume-averaged bulk and shear concentration of layer k, recovered from the cached pointwise amplitudes:   (the spherical concentration is uniform inside a layer) and    , with = _layer_avg_dev_shear_factor(r_{k-1}, r_k, κ_k, μ_k).

Identical by construction to _bulk_concentration and _shear_concentration, which is the point: the pointwise reconstruction and the averaged path share their amplitudes and cannot drift apart.

MeanFieldHomogenization.LayeredSpheres.local_gradient_gradient_concentration Function

local_gradient_gradient_concentration(f_or_sphere, [C₀,] x; side = :outer) -> TensTI{4,3}
local_gradient_gradient_concentration(f_or_sphere, [K₀,] x; side = :outer) -> TensTI{2,3}

In elasticity, with a fourth-order matrix stiffness C₀: Pointwise strain-strain concentration tensor , so that the local strain under a remote uniform strain is   . Valid at every point: inside any layer and in the surrounding matrix, with perfect or imperfect interfaces.

The point x is either a Cartesian vector (Vec{3}, NTuple{3}, AbstractVector, 1st-order AbstractTens) or spherical coordinates given as three arguments (r, θ, φ), θ the colatitude from .

The result is transversely isotropic about   — the configuration is rotation-invariant about the center — and has no major symmetry, so it comes back as a general TensTI{4,T,6}, six Walpole scalars plus the axis, in the canonical basis.

At   every Walpole coefficient degenerates to the isotropic pair , so the returned tensor is the same for any axis; (0,0,1) is used. Note that is the pointwise core value and differs in general from the layer average , which folds in the mode-2 term.

side disambiguates a point lying exactly on an interface — see get_layer.

See also local_flux_gradient_concentration, local_gradient_flux_concentration, local_flux_flux_concentration, local_gradient, LayeredSphereFields.

In conduction, with a second-order matrix conductivity K₀: Pointwise gradient-gradient concentration , so that the local temperature gradient under a remote uniform gradient is   . Valid in any layer and in the matrix, with perfect, Kapitza or surface-conductive interfaces.

       is transversely isotropic about   and comes back as a TensTI{2,T,2}. Same argument forms and same side convention as in elasticity.

MeanFieldHomogenization.LayeredSpheres.local_flux_gradient_concentration Function

local_flux_gradient_concentration(f_or_sphere, [C₀,] x; side = :outer) -> TensTI{4,3}
local_flux_gradient_concentration(f_or_sphere, [K₀,] x; side = :outer) -> TensTI{2,3}

In elasticity, with a fourth-order matrix stiffness C₀: Pointwise stress-strain concentration  : the local stress under a remote uniform strain is σ(x) = local_flux_gradient_concentration(…) ⊡ ε∞. is the stiffness of the region containing x (the matrix outside).

Twin of local_gradient_gradient_concentration; same arguments and conventions.

In conduction, with a second-order matrix conductivity K₀: Pointwise flux-gradient concentration  : the local flux under a remote uniform gradient is q(x) = local_flux_gradient_concentration(…) · ∇T∞, with the Fourier / Fick sign convention    .

MeanFieldHomogenization.LayeredSpheres.local_gradient_flux_concentration Function

local_gradient_flux_concentration(f_or_sphere, [C₀,] x; side = :outer) -> TensTI{4,3}
local_gradient_flux_concentration(f_or_sphere, [K₀,] x; side = :outer) -> TensTI{2,3}

In elasticity, with a fourth-order matrix stiffness C₀: Pointwise strain-stress concentration  ,  : the local strain under a remote uniform stress is ε(x) = local_gradient_flux_concentration(…) ⊡ σ∞.

Exact because the remote medium is uniform:   . Twin of local_gradient_gradient_concentration; same arguments and conventions.

In conduction, with a second-order matrix conductivity K₀: Pointwise gradient-flux concentration  : the local gradient under a remote uniform flux is ∇T(x) = local_gradient_flux_concentration(…) · q∞.

MeanFieldHomogenization.LayeredSpheres.local_flux_flux_concentration Function

local_flux_flux_concentration(f_or_sphere, [C₀,] x; side = :outer) -> TensTI{4,3}
local_flux_flux_concentration(f_or_sphere, [K₀,] x; side = :outer) -> TensTI{2,3}

In elasticity, with a fourth-order matrix stiffness C₀: Pointwise stress-stress concentration   : the local stress under a remote uniform stress is σ(x) = local_flux_flux_concentration(…) ⊡ σ∞.

Twin of local_gradient_gradient_concentration; same arguments and conventions.

In conduction, with a second-order matrix conductivity K₀: Pointwise flux-flux concentration   : the local flux under a remote uniform flux is q(x) = local_flux_flux_concentration(…) · q∞.

MeanFieldHomogenization.LayeredSpheres.local_gradient Function

local_gradient(f_or_sphere, [C₀,] x, ε∞; side = :outer) -> Tens{2,3}
local_gradient(f_or_sphere, [K₀,] x, ∇T∞; side = :outer) -> Vec{3}

In elasticity, with a fourth-order matrix stiffness C₀: Local strain tensor at x under the remote uniform strain ε∞, i.e. local_gradient_gradient_concentration(…) ⊡ ε∞. x is Cartesian, or replace it by three arguments (r, θ, φ).

In conduction, with a second-order matrix conductivity K₀: Local temperature gradient at x under the remote uniform gradient ∇T∞, i.e. local_gradient_gradient_concentration(…) · ∇T∞.

MeanFieldHomogenization.LayeredSpheres.local_flux Function

local_flux(f_or_sphere, [C₀,] x, ε∞; side = :outer) -> Tens{2,3}
local_flux(f_or_sphere, [K₀,] x, ∇T∞; side = :outer) -> Vec{3}

In elasticity, with a fourth-order matrix stiffness C₀: Local stress tensor at x under the remote uniform strain ε∞, i.e.  , being local_gradient(…) and the stiffness of the region containing the point (the matrix C₀ outside the composite sphere).

In conduction, with a second-order matrix conductivity K₀: Local flux at x under the remote uniform gradient ∇T∞, with the Fourier / Fick convention    , the conductivity of the region containing the point (the matrix outside).

MeanFieldHomogenization.LayeredSpheres.local_displacement Function

local_displacement(f_or_sphere, [C₀,] x, ε∞; side = :outer) -> Vec{3}

Local displacement at x under the remote uniform strain ε∞:

with   , the deviatoric part of and , the deviatoric radial functions of the four Love modes. The rigid-body translation is fixed by    at infinity, and  .

Across a SpringInterface the displacement is discontinuous; use side to select the limit (see get_layer).

MeanFieldHomogenization.LayeredSpheres.local_temperature Function

local_temperature(f_or_sphere, [K₀,] x, ∇T∞; side = :outer) -> Number

Local temperature (or pressure / potential) at x under the remote uniform gradient ∇T∞:    , normalized so that    at infinity and  .

Discontinuous across a KapitzaInterface; use side to pick the limit (see get_layer).

The names of elasticity and of conduction

The functions above serve both physics, the order of the matrix property selecting the method. Each also answers to the name it has in elasticity (or, for the layer averages of a property, in conduction); such a name forwards to the generic function, accepts one order only, and refuses the other with an error that names the generic function.

Generic function	Elasticity	Conduction
layer_property_average	layer_stiffness_average	layer_conductivity_average
layer_inverse_property_average	layer_compliance_average	layer_resistivity_average
layer_gradient_average	layer_strain_average
layer_flux_average	layer_stress_average
sphere_gradient_average	sphere_strain_average
sphere_flux_average	sphere_stress_average
local_gradient_gradient_concentration	local_strain_strain_concentration
local_flux_gradient_concentration	local_stress_strain_concentration
local_gradient_flux_concentration	local_strain_stress_concentration
local_flux_flux_concentration	local_stress_stress_concentration
local_gradient	local_strain
local_flux	local_stress

MeanFieldHomogenization.LayeredSpheres.layer_stiffness_average Function

layer_stiffness_average(sphere) -> TensISO{4,3}

Name in elasticity of layer_property_average: the Voigt average of the layer stiffnesses.

MeanFieldHomogenization.LayeredSpheres.layer_compliance_average Function

layer_compliance_average(sphere) -> TensISO{4,3}

Name in elasticity of layer_inverse_property_average: the Reuss average of the layer compliances.

MeanFieldHomogenization.LayeredSpheres.layer_conductivity_average Function

layer_conductivity_average(sphere) -> TensISO{2,3}

Name in conduction of layer_property_average: the Voigt average of the layer conductivities.

MeanFieldHomogenization.LayeredSpheres.layer_resistivity_average Function

layer_resistivity_average(sphere) -> TensISO{2,3}

Name in conduction of layer_inverse_property_average: the Reuss average of the layer resistivities.

MeanFieldHomogenization.LayeredSpheres.layer_strain_average Function

layer_strain_average(args...; kw...)

Name in elasticity of layer_gradient_average, which it takes the arguments of: the mean strain of a layer, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.layer_stress_average Function

layer_stress_average(args...; kw...)

Name in elasticity of layer_flux_average, which it takes the arguments of: the mean stress of a layer, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.sphere_strain_average Function

sphere_strain_average(args...; kw...)

Name in elasticity of sphere_gradient_average, which it takes the arguments of: the mean strain of the composite sphere, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.sphere_stress_average Function

sphere_stress_average(args...; kw...)

Name in elasticity of sphere_flux_average, which it takes the arguments of: the mean stress of the composite sphere, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_strain_strain_concentration Function

local_strain_strain_concentration(args...; kw...)

Name in elasticity of local_gradient_gradient_concentration, which it takes the arguments of: the pointwise strain concentration tensor, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_stress_strain_concentration Function

local_stress_strain_concentration(args...; kw...)

Name in elasticity of local_flux_gradient_concentration, which it takes the arguments of: the pointwise stress per unit remote strain, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_strain_stress_concentration Function

local_strain_stress_concentration(args...; kw...)

Name in elasticity of local_gradient_flux_concentration, which it takes the arguments of: the pointwise strain per unit remote stress, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_stress_stress_concentration Function

local_stress_stress_concentration(args...; kw...)

Name in elasticity of local_flux_flux_concentration, which it takes the arguments of: the pointwise stress per unit remote stress, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_strain Function

local_strain(args...; kw...)

Name in elasticity of local_gradient, which it takes the arguments of: the local strain, for a fourth-order matrix stiffness only.

MeanFieldHomogenization.LayeredSpheres.local_stress Function

local_stress(args...; kw...)

Name in elasticity of local_flux, which it takes the arguments of: the local stress, for a fourth-order matrix stiffness only.