Material Models

Material model definitions

Material Model

class onscale.material_models.MaterialModel(alias: str | None = None)
Parameters:

alias – Optional alias for this node

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

Thermal

ConductivityIsotropic

class onscale.material_models.ConductivityIsotropic(conductivity: float | str | Var | Function, alias: str | None = None)

Definition of thermal conductivity behavior using a isotropic model.

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ConductivityIsotropic(conductivity = 100)
...     mat.set('thermal_conductivity_model', material_model)
Parameters:

conductivity – Isotropic thermal conductivity.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

ConductivityOrthotropic

class onscale.material_models.ConductivityOrthotropic(conductivity_11: float | str | Var | Function, conductivity_22: float | str | Var | Function, conductivity_33: float | str | Var | Function, alias: str | None = None)

Definition of thermal conductivity behavior using a orthotropic model.

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ConductivityOrthotropic(conductivity_11 = 100,
...                                                                    conductivity_22 = 200,
...                                                                    conductivity_33 = 100)
...     mat.set('thermal_conductivity_model', material_model)
Parameters:
  • conductivity_11 – Thermal conductivity in direction 11.

  • conductivity_22 – Thermal conductivity in direction 22.

  • conductivity_33 – Thermal conductivity in direction 33.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

Mechanical

ElasticIsotropicLinear

class onscale.material_models.ElasticIsotropicLinear(youngs_modulus: float | str | Var | Function | None = None, poissons_ratio: float | str | Var | Function | None = None, alias: str | None = None)
Definition of elastic behavior using isotropic linear elastic properties.

This material model is appropriate for small strains

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ElasticIsotropicLinear(
...            youngs_modulus = 1e9, poissons_ratio = 0.31)
...     mat.set('elastic_model', material_model)
Parameters:
  • youngs_modulus – Young’s modulus of elasticity.

  • poissons_ratio – Poisson’s ratio.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

ElasticNeohookean

class onscale.material_models.ElasticNeohookean(youngs_modulus: float | str | Var | Function, poissons_ratio: float | str | Var | Function, alias: str | None = None)
Definition of elastic behavior using a NeoHookean hyperelastic model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ElasticNeohookean(
...            youngs_modulus = 1e9, poissons_ratio = 0.31)
...     mat.set('elastic_model', material_model)
Parameters:
  • youngs_modulus – Young’s modulus of elasticity.

  • poissons_ratio – Poisson’s ratio.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

ElasticTransverseIsotropicLinear

class onscale.material_models.ElasticTransverseIsotropicLinear(transverse_youngs_modulus: float | str | Var | Function, transverse_poissons_ratio: float | str | Var | Function, longitudinal_youngs_modulus: float | str | Var | Function, longitudinal_shear_modulus: float | str | Var | Function, longitudinal_poissons_ratio: float | str | Var | Function, alias: str | None = None)
Definition of elastic behavior using transverse isotropic linear elastic properties.

This material model is appropriate for small strains

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ElasticTransverseIsotropicLinear(
...            transverse_youngs_modulus = 1e9,
...            transverse_poissons_ratio = 0.31,
...            longitudinal_youngs_modulus = 1e8,
...            longitudinal_shear_modulus = 1e6,
...            longitudinal_poissons_ratio = 0.2)
...     mat.set('elastic_model', material_model)
Parameters:
  • transverse_youngs_modulus – Young’s modulus of elasticity in directions 11 and 22.

  • transverse_poissons_ratio – Poisson’s ratio in plane 12.

  • longitudinal_youngs_modulus – Young’s modulus of elasticity in direction 33.

  • longitudinal_shear_modulus – Shear modulus of elasticity in planes 13 and 23.

  • longitudinal_poissons_ratio – Poisson’s ratio in planes 13 and 23.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

ElasticOrthotropicLinear

class onscale.material_models.ElasticOrthotropicLinear(youngs_modulus_11: float | str | Var | Function, youngs_modulus_22: float | str | Var | Function, youngs_modulus_33: float | str | Var | Function, shear_modulus_12: float | str | Var | Function, shear_modulus_23: float | str | Var | Function, shear_modulus_13: float | str | Var | Function, poissons_ratio_12: float | str | Var | Function, poissons_ratio_23: float | str | Var | Function, poissons_ratio_13: float | str | Var | Function, alias: str | None = None)
Definition of elastic behavior using orthotropic linear elastic properties.

This material model is appropriate for small strains

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ElasticOrthotropicLinear(
...            youngs_modulus_11 = 1e9,
...            youngs_modulus_22 = 1e9,
...            youngs_modulus_33 = 1e9,
...            shear_modulus_12 = 1e6,
...            shear_modulus_23 = 1e6,
...            shear_modulus_13 = 1e6,
...            poissons_ratio_12 = 0.31,
...            poissons_ratio_23 = 0.15,
...            poissons_ratio_13 = 0.2)
...     mat.set('elastic_model', material_model)
Parameters:
  • youngs_modulus_11 – Young’s modulus of elasticity in direction 1.

  • youngs_modulus_22 – Young’s modulus of elasticity in direction 2.

  • youngs_modulus_33 – Young’s modulus of elasticity in direction 3.

  • shear_modulus_12 – Shear modulus of elasticity in plane 12.

  • shear_modulus_23 – Shear modulus of elasticity in plane 23.

  • shear_modulus_13 – Shear modulus of elasticity in plane 13.

  • poissons_ratio_12 – Poisson’s ratio in plane 12.

  • poissons_ratio_23 – Poisson’s ratio in plane 23.

  • poissons_ratio_13 – Poisson’s ratio in plane 13.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

ElasticSaintVenantKirchhoff

class onscale.material_models.ElasticSaintVenantKirchhoff(youngs_modulus: float | str | Var | Function, poissons_ratio: float | str | Var | Function, alias: str | None = None)
Definition of elastic behavior using a Saint Venant-Kirchhoff hyperelastic model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.ElasticSaintVenantKirchhoff(
...            youngs_modulus = 1e9, poissons_ratio = 0.31)
...     mat.set('elastic_model', material_model)
Parameters:
  • youngs_modulus – Young’s modulus of elasticity.

  • poissons_ratio – Poisson’s ratio.

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

PlasticVonMisesLinearHardening

class onscale.material_models.PlasticVonMisesLinearHardening(yield_strength: float | str | Var | Function, isotropic_hardening_modulus: float | str | Var | Function, alias: str | None = None)
Definition of plastic behavior using a vonMises linear hardening model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.PlasticVonMisesLinearHardening(
...            yield_strength = 1e9, isotropic_hardening_modulus = 0.31)
...     mat.set('plastic_model', material_model)
Parameters:
  • yield_strength – Initial yield surface position (stress).

  • isotropic_hardening_modulus – Isotropic hardening parameter (plastic tangent modulus).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

PlasticIsotropicGeneralizedQuadric

class onscale.material_models.PlasticIsotropicGeneralizedQuadric(positive_yield_stress: float | str | Var | Function, negative_yield_stress: float | str | Var | Function, form_factor: float | str | Var | Function, isotropic_hardening_modulus: float | str | Var | Function, alias: str | None = None)
Definition of plastic behavior using a isotropic generalized quadric model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.PlasticIsotropicGeneralizedQuadric(
...            positive_yield_stress = 1e9,
...            negative_yield_stress = 1e9,
...            form_factor = 0.2,
...            isotropic_hardening_modulus = 0.31)
...     mat.set('plastic_model', material_model)
Parameters:
  • positive_yield_stress – Initial yield stress in tension.

  • negative_yield_stress – Initial yield stress in compression.

  • form_factor – Form factor parameter, which changes the shape of the yield function, from -1 (yielding two parallel planes) to 0.5 (which yields a cone, one should never use exactly 0.5 as this model does not check for singularities).

  • isotropic_hardening_modulus – Isotropic hardening parameter (plastic tangent modulus, unlike that of VonMises, this is unitless).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

CreepNorton

class onscale.material_models.CreepNorton(parameter_A: float | str | Var | Function, parameter_n: float | str | Var | Function, parameter_Q: float | str | Var | Function, parameter_R: float | str | Var | Function, plasticity_coupling: bool | None = None, creep_stress: float | str | Var | Function | None = None, creep_tangent_modulus: float | str | Var | Function | None = None, temperature: float | str | Var | Function | None = None, alias: str | None = None)
Definition of creep behavior using a Norton creep model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.CreepNorton(parameter_A = 1,
...                                                        parameter_n = 2,
...                                                        parameter_Q = 3,
...                                                        parameter_R = 4)
...     mat.set('creep_model', material_model)
Parameters:
  • parameter_A – Linear constant.

  • parameter_n – Exponent of the stress.

  • parameter_Q – Apparent activation energy.

  • parameter_R – Ratio of the gas constant.

  • plasticity_coupling – Coupling with plasticity.

  • creep_stress – Initial stress at which creep starts to develop.

  • creep_tangent_modulus – Hardening modulus which increases creep stress with respect to creep strain (linear parameter).

  • temperature – Temperature (if a coupled simulation is not considered, in Kelvin).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

CreepGarofalo

class onscale.material_models.CreepGarofalo(parameter_C1: float | str | Var | Function, parameter_C2: float | str | Var | Function, parameter_C3: float | str | Var | Function, parameter_C4: float | str | Var | Function, plasticity_coupling: bool | None = None, creep_stress: float | str | Var | Function | None = None, creep_tangent_modulus: float | str | Var | Function | None = None, temperature: float | str | Var | Function | None = None, alias: str | None = None)
Definition of creep behavior using a Garofalo creep model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.CreepGarofalo(parameter_C1 = 1,
...                                                          parameter_C2 = 2,
...                                                          parameter_C3 = 3,
...                                                          parameter_C4 = 4)
...     mat.set('creep_model', material_model)
Parameters:
  • parameter_C1 – Linear constant.

  • parameter_C2 – Linear constant of the stress.

  • parameter_C3 – Exponent of the hyperbolic sine term.

  • parameter_C4 – Linear constant applied to the inverse of temperature.

  • plasticity_coupling – Coupling with plasticity.

  • creep_stress – Initial stress at which creep starts to develop.

  • creep_tangent_modulus – Hardening modulus which increases creep stress with respect to creep strain (linear parameter).

  • temperature – Temperature (if a coupled simulation is not considered, in Kelvin).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

CreepDoublePowerLaw

class onscale.material_models.CreepDoublePowerLaw(parameter_A1: float | str | Var | Function, parameter_n1: float | str | Var | Function, parameter_Q1: float | str | Var | Function, parameter_A2: float | str | Var | Function, parameter_n2: float | str | Var | Function, parameter_Q2: float | str | Var | Function, parameter_R: float | str | Var | Function, plasticity_coupling: bool | None = None, creep_stress: float | str | Var | Function | None = None, creep_tangent_modulus: float | str | Var | Function | None = None, temperature: float | str | Var | Function | None = None, alias: str | None = None)
Definition of creep behavior using a double power creep model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.CreepDoublePowerLaw(parameter_A1 = 1,
...                                                                parameter_n1 = 2,
...                                                                parameter_Q1 = 3,
...                                                                parameter_A2 = 4,
...                                                                parameter_n2 = 2,
...                                                                parameter_Q2 = 3,
...                                                                parameter_R = 4)
...     mat.set('creep_model', material_model)
Parameters:
  • parameter_A1 – First linear constant.

  • parameter_n1 – First exponent of the stress.

  • parameter_Q1 – First apparent activation energy.

  • parameter_A2 – Second linear constant.

  • parameter_n2 – Second exponent of the stress.

  • parameter_Q2 – Second apparent activation energy.

  • parameter_R – Ratio of the gas constant.

  • plasticity_coupling – Coupling with plasticity.

  • creep_stress – Initial stress at which creep starts to develop.

  • creep_tangent_modulus – Hardening modulus which increases creep stress with respect to creep strain (linear parameter).

  • temperature – Temperature (if a coupled simulation is not considered, in Kelvin).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.

CreepExponential

class onscale.material_models.CreepExponential(parameter_A: float | str | Var | Function, parameter_b: float | str | Var | Function, parameter_Q: float | str | Var | Function, parameter_R: float | str | Var | Function, plasticity_coupling: bool | None = None, creep_stress: float | str | Var | Function | None = None, creep_tangent_modulus: float | str | Var | Function | None = None, temperature: float | str | Var | Function | None = None, alias: str | None = None)
Definition of creep behavior using a exponential creep model.

Selecting this model will trigger a nonlinear solve

Examples

>>> import onscale as on
>>> with on.Simulation("Static Solve") as sim:
...     mat = on.CustomMaterial('my_material')
...     material_model = on.material_models.CreepExponential(parameter_A = 1,
...                                                             parameter_b = 2,
...                                                             parameter_Q = 3,
...                                                             parameter_R = 4)
...     mat.set('creep_model', material_model)
Parameters:
  • parameter_A – Linear constant.

  • parameter_b – Linear constant which divides the stress.

  • parameter_Q – Apparent activation energy.

  • parameter_R – Ratio of the gas constant.

  • plasticity_coupling – Coupling with plasticity.

  • creep_stress – Initial stress at which creep starts to develop.

  • creep_tangent_modulus – Hardening modulus which increases creep stress with respect to creep strain (linear parameter).

  • temperature – Temperature (if a coupled simulation is not considered, in Kelvin).

property bounds_types: Dict[str, BoundsType]

For specifying which fields need to be verified :return: a k,v map of fields names to coefficient types

static from_dict(data: Dict[str, Any], sim: Simulation | None = None) Node

Construct this node from serialized dictionary data

to_json() str

Convert this node into JSON representation

property uuid: str

Get the UUID associated with this node.