| standard library package ISQMechanics { | |
| doc | |
| /* | |
| * International System of Quantities and Units | |
| * Generated on 2022-08-07T14:44:27Z from standard ISO-80000-4:2019 "Mechanics" | |
| * see also https://www.iso.org/obp/ui/#iso:std:iso:80000:-4:ed-2:v1:en | |
| * | |
| * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts, | |
| * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks. | |
| * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is | |
| * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) | |
| * or TensorMeasurementReference. | |
| */ | |
| private import ScalarValues::Real; | |
| private import Quantities::*; | |
| private import MeasurementReferences::*; | |
| private import ISQBase::*; | |
| /* Quantity definitions referenced from other ISQ packages */ | |
| private import ISQThermodynamics::EnergyValue; | |
| /* ISO-80000-4 item 4-1 mass */ | |
| /* See package ISQBase for the declarations of MassValue and MassUnit */ | |
| /* ISO-80000-4 item 4-2 mass density, density */ | |
| attribute def MassDensityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-2 mass density, density | |
| * symbol(s): `ρ`, `ρ_m` | |
| * application domain: generic | |
| * name: MassDensity | |
| * quantity dimension: L^-3*M^1 | |
| * measurement unit(s): kg*m^-3 | |
| * tensor order: 0 | |
| * definition: quantity representing the spatial distribution of mass of a continuous material: `ρ(vec(r)) = (dm)/(dV)` where `m` is mass of the material contained in an infinitesimal domain at point `vec(r)` and `V` is volume of this domain | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MassDensityUnit[1]; | |
| } | |
| attribute massDensity: MassDensityValue[*] nonunique :> scalarQuantities; | |
| attribute def MassDensityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); } | |
| } | |
| alias DensityUnit for MassDensityUnit; | |
| alias DensityValue for MassDensityValue; | |
| alias density for massDensity; | |
| /* ISO-80000-4 item 4-3 specific volume */ | |
| attribute def SpecificVolumeValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-3 specific volume | |
| * symbol(s): `v` | |
| * application domain: generic | |
| * name: SpecificVolume | |
| * quantity dimension: L^3*M^-1 | |
| * measurement unit(s): kg^-1*m^3 | |
| * tensor order: 0 | |
| * definition: reciprocal of mass density `ρ` (item 4-2): `v = 1/ρ` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SpecificVolumeUnit[1]; | |
| } | |
| attribute specificVolume: SpecificVolumeValue[*] nonunique :> scalarQuantities; | |
| attribute def SpecificVolumeUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); } | |
| } | |
| /* ISO-80000-4 item 4-4 relative mass density, relative density */ | |
| attribute def RelativeMassDensityValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-4 relative mass density, relative density | |
| * symbol(s): `d` | |
| * application domain: generic | |
| * name: RelativeMassDensity (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of mass density of a substance `ρ` and mass density of a reference substance `ρ_0` : `d = ρ/ρ_0` | |
| * remarks: Conditions and material should be specified for the reference substance. | |
| */ | |
| } | |
| attribute relativeMassDensity: RelativeMassDensityValue :> scalarQuantities; | |
| alias relativeDensity for relativeMassDensity; | |
| /* ISO-80000-4 item 4-5 surface mass density, surface density */ | |
| attribute def SurfaceMassDensityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-5 surface mass density, surface density | |
| * symbol(s): `ρ_A` | |
| * application domain: generic | |
| * name: SurfaceMassDensity | |
| * quantity dimension: L^-2*M^1 | |
| * measurement unit(s): kg*m^-2 | |
| * tensor order: 0 | |
| * definition: quantity representing the areal distribution of mass of a continuous material: `ρ_A(vec(r)) = (dm)/(dA)` where `m` is the mass of the material at position `vec(r)` and `A` is area | |
| * remarks: The name "grammage" should not be used for this quantity. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SurfaceMassDensityUnit[1]; | |
| } | |
| attribute surfaceMassDensity: SurfaceMassDensityValue[*] nonunique :> scalarQuantities; | |
| attribute def SurfaceMassDensityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); } | |
| } | |
| alias SurfaceDensityUnit for SurfaceMassDensityUnit; | |
| alias SurfaceDensityValue for SurfaceMassDensityValue; | |
| alias surfaceDensity for surfaceMassDensity; | |
| /* ISO-80000-4 item 4-6 linear mass density, linear density */ | |
| attribute def LinearMassDensityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-6 linear mass density, linear density | |
| * symbol(s): `ρ_I` | |
| * application domain: generic | |
| * name: LinearMassDensity | |
| * quantity dimension: L^-1*M^1 | |
| * measurement unit(s): kg*m^-1 | |
| * tensor order: 0 | |
| * definition: quantity representing the linear distribution of mass of a continuous material: `ρ_I(vec(r)) = (dm)/(dI)` where `m` is the mass of the material at position `vec(r)` and `l` is length | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: LinearMassDensityUnit[1]; | |
| } | |
| attribute linearMassDensity: LinearMassDensityValue[*] nonunique :> scalarQuantities; | |
| attribute def LinearMassDensityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); } | |
| } | |
| alias LinearDensityUnit for LinearMassDensityUnit; | |
| alias LinearDensityValue for LinearMassDensityValue; | |
| alias linearDensity for linearMassDensity; | |
| /* ISO-80000-4 item 4-7 moment of inertia */ | |
| attribute def MomentOfInertiaValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-7 moment of inertia (magnitude) | |
| * symbol(s): `J` | |
| * application domain: generic | |
| * name: MomentOfInertia | |
| * quantity dimension: L^2*M^1 | |
| * measurement unit(s): kg*m^2 | |
| * tensor order: 0 | |
| * definition: tensor (ISO 80000-2) quantity representing rotational inertia of a rigid body relative to a fixed centre of rotation expressed by the tensor product: `vec(L) = vec(vec(J)) vec(ω)` where `vec(L)` is angular momentum (item 4-11) of the body relative to the reference point and `vec(ω)` is its angular velocity (ISO 80000-3) | |
| * remarks: The calculation of the value requires an integration. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MomentOfInertiaUnit[1]; | |
| } | |
| attribute momentOfInertia: MomentOfInertiaValue[*] nonunique :> scalarQuantities; | |
| attribute def MomentOfInertiaUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); } | |
| } | |
| attribute def Cartesian3dMomentOfInertiaTensor :> TensorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-7 moment of inertia (tensor) | |
| * symbol(s): `vec(vec(J))` | |
| * application domain: generic | |
| * name: MomentOfInertia | |
| * quantity dimension: L^2*M^1 | |
| * measurement unit(s): kg*m^2 | |
| * tensor order: 2 | |
| * definition: tensor (ISO 80000-2) quantity representing rotational inertia of a rigid body relative to a fixed centre of rotation expressed by the tensor product: `vec(L) = vec(vec(J)) vec(ω)` where `vec(L)` is angular momentum (item 4-11) of the body relative to the reference point and `vec(ω)` is its angular velocity (ISO 80000-3) | |
| * remarks: The calculation of the value requires an integration. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[9]; | |
| attribute :>> mRef: Cartesian3dMomentOfInertiaMeasurementReference[1]; | |
| } | |
| attribute momentOfInertiaTensor: Cartesian3dMomentOfInertiaTensor :> tensorQuantities; | |
| attribute def Cartesian3dMomentOfInertiaMeasurementReference :> TensorMeasurementReference { | |
| attribute :>> dimensions = (3, 3); | |
| attribute :>> isBound = false; | |
| attribute :>> mRefs: MomentOfInertiaUnit[9]; | |
| } | |
| /* ISO-80000-4 item 4-8 momentum */ | |
| attribute def MomentumValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-8 momentum (magnitude) | |
| * symbol(s): `p` | |
| * application domain: generic | |
| * name: Momentum | |
| * quantity dimension: L^1*M^1*T^-1 | |
| * measurement unit(s): kg*m*s^-1 | |
| * tensor order: 0 | |
| * definition: product of mass `m` (item 4-1) of a body and velocity `vec(v)` (ISO 80000-3) of its centre of mass: `vec(p) = m vec(v)` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MomentumUnit[1]; | |
| } | |
| attribute momentum: MomentumValue[*] nonunique :> scalarQuantities; | |
| attribute def MomentumUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dMomentumVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-8 momentum (vector) | |
| * symbol(s): `vec(p)` | |
| * application domain: generic | |
| * name: Momentum | |
| * quantity dimension: L^1*M^1*T^-1 | |
| * measurement unit(s): kg*m*s^-1 | |
| * tensor order: 1 | |
| * definition: product of mass `m` (item 4-1) of a body and velocity `vec(v)` (ISO 80000-3) of its centre of mass: `vec(p) = m vec(v)` | |
| * remarks: None. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dMomentumCoordinateFrame[1]; | |
| } | |
| attribute momentumVector: Cartesian3dMomentumVector :> vectorQuantities; | |
| attribute def Cartesian3dMomentumCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: MomentumUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-9.1 force */ | |
| attribute def ForceValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.1 force (magnitude) | |
| * symbol(s): `F` | |
| * application domain: generic | |
| * name: Force | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity describing interaction between bodies or particles | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ForceUnit[1]; | |
| } | |
| attribute force: ForceValue[*] nonunique :> scalarQuantities; | |
| attribute def ForceUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dForceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.1 force (vector) | |
| * symbol(s): `vec(F)` | |
| * application domain: generic | |
| * name: Force | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity describing interaction between bodies or particles | |
| * remarks: None. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute forceVector: Cartesian3dForceVector :> vectorQuantities; | |
| attribute def Cartesian3dForceCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: ForceUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-9.2 weight */ | |
| attribute def Cartesian3dWeightVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.2 weight | |
| * symbol(s): `vec(F_g)` | |
| * application domain: generic | |
| * name: Weight (specializes Force) | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: force (item 4-9.1) acting on a body in the gravitational field of Earth: `vec(F_g) = m vec(g)` where `m` (item 4-1) is the mass of the body and `vec(g)` is the local acceleration of free fall (ISO 80000-3) | |
| * remarks: In colloquial language, the name "weight" continues to be used where "mass" is meant. This practice should be avoided. Weight is an example of a gravitational force. Weight comprises not only the local gravitational force but also the local centrifugal force due to the rotation of the Earth. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute weightVector: Cartesian3dWeightVector :> vectorQuantities; | |
| /* ISO-80000-4 item 4-9.3 static friction force, static friction */ | |
| attribute def Cartesian3dStaticFrictionForceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.3 static friction force, static friction | |
| * symbol(s): `vec(F_s)` | |
| * application domain: generic | |
| * name: StaticFrictionForce (specializes Force) | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: force (item 4-9.1) resisting the motion before a body starts to slide on a surface | |
| * remarks: For the static friction coefficient, see item 4-23.1. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute staticFrictionForceVector: Cartesian3dStaticFrictionForceVector :> vectorQuantities; | |
| alias staticFrictionVector for staticFrictionForceVector; | |
| /* ISO-80000-4 item 4-9.4 kinetic friction force, dynamic friction force */ | |
| attribute def Cartesian3dKineticFrictionForceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.4 kinetic friction force, dynamic friction force | |
| * symbol(s): `vec(F_μ)` | |
| * application domain: generic | |
| * name: KineticFrictionForce (specializes Force) | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: force (item 4-9.1) resisting the motion when a body slides on a surface | |
| * remarks: For the kinetic friction factor, see item 4-23.2. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute kineticFrictionForceVector: Cartesian3dKineticFrictionForceVector :> vectorQuantities; | |
| alias dynamicFrictionForceVector for kineticFrictionForceVector; | |
| /* ISO-80000-4 item 4-9.5 rolling resistance, rolling drag, rolling friction force */ | |
| attribute def Cartesian3dRollingResistanceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.5 rolling resistance, rolling drag, rolling friction force | |
| * symbol(s): `vec(F_"rr")` | |
| * application domain: generic | |
| * name: RollingResistance (specializes Force) | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: force (item 4-9.1) resisting the motion when a body rolls on a surface | |
| * remarks: For the rolling resistance factor, see item 4-23.3. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute rollingResistanceVector: Cartesian3dRollingResistanceVector :> vectorQuantities; | |
| alias rollingDragVector for rollingResistanceVector; | |
| alias rollingFrictionForceVector for rollingResistanceVector; | |
| /* ISO-80000-4 item 4-9.6 drag force */ | |
| attribute def Cartesian3dDragForceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-9.6 drag force | |
| * symbol(s): `vec(F_D)` | |
| * application domain: generic | |
| * name: DragForce (specializes Force) | |
| * quantity dimension: L^1*M^1*T^-2 | |
| * measurement unit(s): N, kg*m*s^-2 | |
| * tensor order: 1 | |
| * definition: force (item 4-9.1) resisting the motion of a body in a fluid | |
| * remarks: For the drag coefficient, see item 4-23.4. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dForceCoordinateFrame[1]; | |
| } | |
| attribute dragForceVector: Cartesian3dDragForceVector :> vectorQuantities; | |
| /* ISO-80000-4 item 4-10 impulse */ | |
| attribute def ImpulseValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-10 impulse (magnitude) | |
| * symbol(s): `I` | |
| * application domain: generic | |
| * name: Impulse | |
| * quantity dimension: L^1*M^1*T^-1 | |
| * measurement unit(s): N*s, kg*m*s^-1 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity describing the effect of force acting during a time interval: `vec(I) = int_(t_1)^(t_2) vec(F)*dt` where `vec(F)` is force (item 4-9.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval | |
| * remarks: For a time interval `[t_1, t_2]`, `vec(I)(t_1, t_2) = vec(p)(t_1) - vec(p)(t_2) = vec(Δp)` where `vec(p)` is momentum (item 4-8). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ImpulseUnit[1]; | |
| } | |
| attribute impulse: ImpulseValue[*] nonunique :> scalarQuantities; | |
| attribute def ImpulseUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dImpulseVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-10 impulse (vector) | |
| * symbol(s): `vec(I)` | |
| * application domain: generic | |
| * name: Impulse | |
| * quantity dimension: L^1*M^1*T^-1 | |
| * measurement unit(s): N*s, kg*m*s^-1 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity describing the effect of force acting during a time interval: `vec(I) = int_(t_1)^(t_2) vec(F)*dt` where `vec(F)` is force (item 4-9.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval | |
| * remarks: For a time interval `[t_1, t_2]`, `vec(I)(t_1, t_2) = vec(p)(t_1) - vec(p)(t_2) = vec(Δp)` where `vec(p)` is momentum (item 4-8). | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dImpulseCoordinateFrame[1]; | |
| } | |
| attribute impulseVector: Cartesian3dImpulseVector :> vectorQuantities; | |
| attribute def Cartesian3dImpulseCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: ImpulseUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-11 angular momentum */ | |
| attribute def AngularMomentumValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-11 angular momentum (magnitude) | |
| * symbol(s): `L` | |
| * application domain: generic | |
| * name: AngularMomentum | |
| * quantity dimension: L^2*M^1*T^-1 | |
| * measurement unit(s): kg*m^2*s^-1 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(L) = vec(r) xx vec(p)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(p)` is momentum (item 4-8) | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: AngularMomentumUnit[1]; | |
| } | |
| attribute angularMomentum: AngularMomentumValue[*] nonunique :> scalarQuantities; | |
| attribute def AngularMomentumUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dAngularMomentumVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-11 angular momentum (vector) | |
| * symbol(s): `vec(L)` | |
| * application domain: generic | |
| * name: AngularMomentum | |
| * quantity dimension: L^2*M^1*T^-1 | |
| * measurement unit(s): kg*m^2*s^-1 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(L) = vec(r) xx vec(p)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(p)` is momentum (item 4-8) | |
| * remarks: None. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dAngularMomentumCoordinateFrame[1]; | |
| } | |
| attribute angularMomentumVector: Cartesian3dAngularMomentumVector :> vectorQuantities; | |
| attribute def Cartesian3dAngularMomentumCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: AngularMomentumUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-12.1 moment of force */ | |
| attribute def MomentOfForceValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-12.1 moment of force (magnitude) | |
| * symbol(s): `M` | |
| * application domain: generic | |
| * name: MomentOfForce | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): N*m, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(M) = vec(r) xx vec(F)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(F)` is force (item 4-9.1) | |
| * remarks: The bending moment of force is denoted by `vec(M)_b`. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MomentOfForceUnit[1]; | |
| } | |
| attribute momentOfForce: MomentOfForceValue[*] nonunique :> scalarQuantities; | |
| attribute def MomentOfForceUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dMomentOfForceVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-12.1 moment of force (vector) | |
| * symbol(s): `vec(M)` | |
| * application domain: generic | |
| * name: MomentOfForce | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): N*m, kg*m^2*s^-2 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(M) = vec(r) xx vec(F)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(F)` is force (item 4-9.1) | |
| * remarks: The bending moment of force is denoted by `vec(M)_b`. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dMomentOfForceCoordinateFrame[1]; | |
| } | |
| attribute momentOfForceVector: Cartesian3dMomentOfForceVector :> vectorQuantities; | |
| attribute def Cartesian3dMomentOfForceCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: MomentOfForceUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-12.2 torque */ | |
| attribute def TorqueValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-12.2 torque | |
| * symbol(s): `T`, `M_Q` | |
| * application domain: generic | |
| * name: Torque | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): N*m, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: quantity described by the scalar product: `T = vec(M)*vec(e_Q)` where `vec(M)` is moment of force (item 4-12.1) and `vec(e_Q)` is unit vector of direction with respect to which the torque is considered | |
| * remarks: For example, torque is the twisting moment of force with respect to the longitudinal axis of a beam or shaft. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: TorqueUnit[1]; | |
| } | |
| attribute torque: TorqueValue[*] nonunique :> scalarQuantities; | |
| attribute def TorqueUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-13 angular impulse */ | |
| attribute def AngularImpulseValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-13 angular impulse (magnitude) | |
| * symbol(s): `H` | |
| * application domain: generic | |
| * name: AngularImpulse | |
| * quantity dimension: L^2*M^1*T^-1 | |
| * measurement unit(s): N*m*s, kg*m^2*s^-1 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity describing the effect of moment of force during a time interval: `vec(H)(t_1; t_2) = int_(t_1)^(t_2) vec(M) dt` where `vec(M)` is moment of force (item 4-12.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval | |
| * remarks: For a time interval `[t_1, t_2]`, `vec(H)(t_1, t_2) = vec(L)(t_1) - vec(L)(t_2) = vec(ΔL)` where `vec(L)` is angular momentum. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: AngularImpulseUnit[1]; | |
| } | |
| attribute angularImpulse: AngularImpulseValue[*] nonunique :> scalarQuantities; | |
| attribute def AngularImpulseUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dAngularImpulseVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-13 angular impulse (vector) | |
| * symbol(s): `vec(H)` | |
| * application domain: generic | |
| * name: AngularImpulse | |
| * quantity dimension: L^2*M^1*T^-1 | |
| * measurement unit(s): N*m*s, kg*m^2*s^-1 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity describing the effect of moment of force during a time interval: `vec(H)(t_1; t_2) = int_(t_1)^(t_2) vec(M) dt` where `vec(M)` is moment of force (item 4-12.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval | |
| * remarks: For a time interval `[t_1, t_2]`, `vec(H)(t_1, t_2) = vec(L)(t_1) - vec(L)(t_2) = vec(ΔL)` where `vec(L)` is angular momentum. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dAngularImpulseCoordinateFrame[1]; | |
| } | |
| attribute angularImpulseVector: Cartesian3dAngularImpulseVector :> vectorQuantities; | |
| attribute def Cartesian3dAngularImpulseCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: AngularImpulseUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-14.1 pressure */ | |
| attribute def PressureValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-14.1 pressure | |
| * symbol(s): `p` | |
| * application domain: generic | |
| * name: Pressure | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: quotient of the component of a force normal to a surface and its area: `p = (vec(e_n) * vec(F)) / A` where `vec(e_n)` is unit vector of the surface normal, `vec(F)` is force (item 4-9.1) and `A` is area (ISO 80000-3) | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: PressureUnit[1]; | |
| } | |
| attribute pressure: PressureValue[*] nonunique :> scalarQuantities; | |
| attribute def PressureUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-14.2 gauge pressure */ | |
| attribute gaugePressure: PressureValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-14.2 gauge pressure | |
| * symbol(s): `p_e` | |
| * application domain: generic | |
| * name: GaugePressure (specializes Pressure) | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: pressure `p` (item 4-14.1) decremented by ambient pressure `p_amb` : `p_e = p - p_amb` | |
| * remarks: Often, `p_amb` is chosen as a standard pressure. Gauge pressure is positive or negative. | |
| */ | |
| } | |
| /* ISO-80000-4 item 4-15 stress */ | |
| attribute def StressValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-15 stress (magnitude) | |
| * symbol(s): `σ` | |
| * application domain: generic | |
| * name: Stress | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: tensor (ISO 80000-2) quantity representing state of tension of matter | |
| * remarks: Stress tensor is symmetric and has three normal-stress and three shear-stress (Cartesian) components. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: StressUnit[1]; | |
| } | |
| attribute stress: StressValue[*] nonunique :> scalarQuantities; | |
| attribute def StressUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dStressTensor :> TensorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-15 stress (tensor) | |
| * symbol(s): `vec(vec(σ))` | |
| * application domain: generic | |
| * name: Stress | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 2 | |
| * definition: tensor (ISO 80000-2) quantity representing state of tension of matter | |
| * remarks: Stress tensor is symmetric and has three normal-stress and three shear-stress (Cartesian) components. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[9]; | |
| attribute :>> mRef: Cartesian3dStressMeasurementReference[1]; | |
| } | |
| attribute stressTensor: Cartesian3dStressTensor :> tensorQuantities; | |
| attribute def Cartesian3dStressMeasurementReference :> TensorMeasurementReference { | |
| attribute :>> dimensions = (3, 3); | |
| attribute :>> isBound = false; | |
| attribute :>> mRefs: StressUnit[9]; | |
| } | |
| /* ISO-80000-4 item 4-16.1 normal stress */ | |
| attribute def NormalStressValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-16.1 normal stress | |
| * symbol(s): `σ_n`, `σ` | |
| * application domain: generic | |
| * name: NormalStress | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: scalar (ISO 80000-2) quantity describing surface action of a force into a body equal to: `σ_n = (d F_n)/(dA)` where `F_n` is the normal component of force (item 4-9.1) and `A` is the area (ISO 80000-3) of the surface element | |
| * remarks: A couple of mutually opposite forces of magnitude `F` acting on the opposite surfaces of a slice (layer) of homogenous solid matter normal to it, and evenly distributed, cause a constant normal stress `σ_n = F A` in the slice (layer). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: NormalStressUnit[1]; | |
| } | |
| attribute normalStress: NormalStressValue[*] nonunique :> scalarQuantities; | |
| attribute def NormalStressUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-16.2 shear stress */ | |
| attribute def ShearStressValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-16.2 shear stress | |
| * symbol(s): `τ_s`, `τ` | |
| * application domain: generic | |
| * name: ShearStress | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: scalar (ISO 80000-2) quantity describing surface action of a force into a body equal to: `τ_s = (d F_t)/(dA)` where `F_t` is the tangential component of force (item 4-9.1) and `A` is the area (ISO 80000-3) of the surface element | |
| * remarks: A couple of mutually opposite forces of magnitude `F` acting on the opposite surfaces of a slice (layer) of homogenous solid matter parallel to it, and evenly distributed, cause a constant shear stress `τ = F/A` in the slice (layer). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ShearStressUnit[1]; | |
| } | |
| attribute shearStress: ShearStressValue[*] nonunique :> scalarQuantities; | |
| attribute def ShearStressUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-17.1 strain */ | |
| attribute def StrainValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-17.1 strain (magnitude) | |
| * symbol(s): `ε` | |
| * application domain: generic | |
| * name: Strain | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: tensor (ISO 80000-2) quantity representing the deformation of matter caused by stress | |
| * remarks: Strain tensor is symmetric and has three linear-strain and three shear strain (Cartesian) components. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: StrainUnit[1]; | |
| } | |
| attribute strain: StrainValue[*] nonunique :> scalarQuantities; | |
| attribute def StrainUnit :> DimensionOneUnit { | |
| } | |
| attribute def Cartesian3dStrainTensor :> TensorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-17.1 strain (tensor) | |
| * symbol(s): `vec(vec(ε))` | |
| * application domain: generic | |
| * name: Strain | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 2 | |
| * definition: tensor (ISO 80000-2) quantity representing the deformation of matter caused by stress | |
| * remarks: Strain tensor is symmetric and has three linear-strain and three shear strain (Cartesian) components. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[9]; | |
| attribute :>> mRef: Cartesian3dStrainMeasurementReference[1]; | |
| } | |
| attribute strainTensor: Cartesian3dStrainTensor :> tensorQuantities; | |
| attribute def Cartesian3dStrainMeasurementReference :> TensorMeasurementReference { | |
| attribute :>> dimensions = (3, 3); | |
| attribute :>> isBound = false; | |
| attribute :>> mRefs: StrainUnit[9]; | |
| } | |
| /* ISO-80000-4 item 4-17.2 relative linear strain */ | |
| attribute def RelativeLinearStrainValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-17.2 relative linear strain | |
| * symbol(s): `ε`, `(e)` | |
| * application domain: generic | |
| * name: RelativeLinearStrain (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of change in length `Δl` (ISO 80000-3) of an object and its length `l` (ISO 80000-3): `ε = (Δl)/l` | |
| * remarks: None. | |
| */ | |
| } | |
| attribute relativeLinearStrain: RelativeLinearStrainValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-17.3 shear strain */ | |
| attribute def ShearStrainValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-17.3 shear strain | |
| * symbol(s): `γ` | |
| * application domain: generic | |
| * name: ShearStrain (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of parallel displacement `Δx` (ISO 80000-3) of two surfaces of a layer and the thickness `d` (ISO 80000-3) of the layer: `γ = (Δx)/d` | |
| * remarks: None. | |
| */ | |
| } | |
| attribute shearStrain: ShearStrainValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-17.4 relative volume strain */ | |
| attribute def RelativeVolumeStrainValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-17.4 relative volume strain | |
| * symbol(s): `θ` | |
| * application domain: generic | |
| * name: RelativeVolumeStrain (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of change in volume `ΔV` (ISO 80000-3) of an object and its volume `V_0` (ISO 80000-3): `θ = (ΔV)/V_0` | |
| * remarks: None. | |
| */ | |
| } | |
| attribute relativeVolumeStrain: RelativeVolumeStrainValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-18 Poisson number */ | |
| attribute def PoissonNumberValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-18 Poisson number | |
| * symbol(s): `μ`, `(v)` | |
| * application domain: generic | |
| * name: PoissonNumber (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of change in width `Δb` (width is defined in ISO 80000-3) and change in length `Δl` (length is defined in ISO 80000-3) of an object: `μ = (Δb)/(Δl)` | |
| * remarks: None. | |
| */ | |
| } | |
| attribute poissonNumber: PoissonNumberValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-19.1 modulus of elasticity, Young modulus */ | |
| attribute def ModulusOfElasticityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-19.1 modulus of elasticity, Young modulus | |
| * symbol(s): `E`, `E_m`, `Y` | |
| * application domain: generic | |
| * name: ModulusOfElasticity | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: quotient of normal stress `σ` (item 4-16.1) and relative linear strain `ε` (item 4-17.2): `E = σ/ε` | |
| * remarks: Conditions should be specified (e.g. adiabatic or isothermal process). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ModulusOfElasticityUnit[1]; | |
| } | |
| attribute modulusOfElasticity: ModulusOfElasticityValue[*] nonunique :> scalarQuantities; | |
| attribute def ModulusOfElasticityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| alias YoungModulusUnit for ModulusOfElasticityUnit; | |
| alias YoungModulusValue for ModulusOfElasticityValue; | |
| alias youngModulus for modulusOfElasticity; | |
| /* ISO-80000-4 item 4-19.2 modulus of rigidity, shear modulus */ | |
| attribute def ModulusOfRigidityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-19.2 modulus of rigidity, shear modulus | |
| * symbol(s): `G` | |
| * application domain: generic | |
| * name: ModulusOfRigidity | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: quotient of shear stress `τ` (item 4-16.2) and shear strain `γ` (item 4-17.3): `G = τ/γ` | |
| * remarks: Conditions should be specified (e.g. isentropic or isothermal process). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ModulusOfRigidityUnit[1]; | |
| } | |
| attribute modulusOfRigidity: ModulusOfRigidityValue[*] nonunique :> scalarQuantities; | |
| attribute def ModulusOfRigidityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| alias ShearModulusUnit for ModulusOfRigidityUnit; | |
| alias ShearModulusValue for ModulusOfRigidityValue; | |
| alias shearModulus for modulusOfRigidity; | |
| /* ISO-80000-4 item 4-19.3 modulus of compression, bulk modulus */ | |
| attribute def ModulusOfCompressionValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-19.3 modulus of compression, bulk modulus | |
| * symbol(s): `K`, `K_m`, `B` | |
| * application domain: generic | |
| * name: ModulusOfCompression | |
| * quantity dimension: L^-1*M^1*T^-2 | |
| * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2 | |
| * tensor order: 0 | |
| * definition: negative of the quotient of pressure `p` (item 4-14.1) and relative volume strain `θ` (item 4-17.4): `K = -(p/θ)` | |
| * remarks: Conditions should be specified (e.g. isentropic or isothermal process). | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ModulusOfCompressionUnit[1]; | |
| } | |
| attribute modulusOfCompression: ModulusOfCompressionValue[*] nonunique :> scalarQuantities; | |
| attribute def ModulusOfCompressionUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| alias BulkModulusUnit for ModulusOfCompressionUnit; | |
| alias BulkModulusValue for ModulusOfCompressionValue; | |
| alias bulkModulus for modulusOfCompression; | |
| /* ISO-80000-4 item 4-20 compressibility */ | |
| attribute def CompressibilityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-20 compressibility | |
| * symbol(s): `ϰ` | |
| * application domain: generic | |
| * name: Compressibility | |
| * quantity dimension: L^1*M^-1*T^2 | |
| * measurement unit(s): Pa^-1, kg^-1*m*s^2 | |
| * tensor order: 0 | |
| * definition: negative relative change of volume `V` (ISO 80000-3) of an object under pressure `p` (item 4-14.1) expressed by: `ϰ = -(1/V)(dV)/(dp)` | |
| * remarks: Conditions should be specified (e.g. isentropic or isothermal process). See also ISO 80000-5. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: CompressibilityUnit[1]; | |
| } | |
| attribute compressibility: CompressibilityValue[*] nonunique :> scalarQuantities; | |
| attribute def CompressibilityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-21.1 second axial moment of area */ | |
| attribute def SecondAxialMomentOfAreaValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-21.1 second axial moment of area | |
| * symbol(s): `I_a` | |
| * application domain: generic | |
| * name: SecondAxialMomentOfArea | |
| * quantity dimension: L^4 | |
| * measurement unit(s): m^4 | |
| * tensor order: 0 | |
| * definition: geometrical characteristic of a shape of a body equal to: `I_a = int int_M r_Q^2 dA` where `M` is the two-dimensional domain of the cross-section of a plane and considered body, `r_Q` is radial distance (ISO 80000-3) from a Q-axis in the plane of the surface considered and `A` is area (ISO 80000-3) | |
| * remarks: This quantity is often referred to wrongly as "moment of inertia" (item 4-7). The subscript, `a`, may be omitted when there is no risk of confusion. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SecondAxialMomentOfAreaUnit[1]; | |
| } | |
| attribute secondAxialMomentOfArea: SecondAxialMomentOfAreaValue[*] nonunique :> scalarQuantities; | |
| attribute def SecondAxialMomentOfAreaUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; } | |
| } | |
| /* ISO-80000-4 item 4-21.2 second polar moment of area */ | |
| attribute def SecondPolarMomentOfAreaValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-21.2 second polar moment of area | |
| * symbol(s): `I_p` | |
| * application domain: generic | |
| * name: SecondPolarMomentOfArea | |
| * quantity dimension: L^4 | |
| * measurement unit(s): m^4 | |
| * tensor order: 0 | |
| * definition: geometrical characteristic of a shape of a body equal to: `I_p = int int_M r_Q^2 * dA` where `M` is the two-dimensional domain of the cross-section of a plane and considered body, `r_Q` is radial distance (ISO 80000-3) from a Q-axis perpendicular to the plane of the surface considered and `A` is area (ISO 80000-3) | |
| * remarks: This quantity is often referred to wrongly as "moment of inertia" (item 4-7). The subscript, `p`, may be omitted when there is no risk of confusion. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SecondPolarMomentOfAreaUnit[1]; | |
| } | |
| attribute secondPolarMomentOfArea: SecondPolarMomentOfAreaValue[*] nonunique :> scalarQuantities; | |
| attribute def SecondPolarMomentOfAreaUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; } | |
| } | |
| /* ISO-80000-4 item 4-22 section modulus */ | |
| attribute def SectionModulusValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-22 section modulus | |
| * symbol(s): `Z`, `(W)` | |
| * application domain: generic | |
| * name: SectionModulus | |
| * quantity dimension: L^3 | |
| * measurement unit(s): m^3 | |
| * tensor order: 0 | |
| * definition: geometrical characteristic of a shape of a body equal to: `Z = I_a/r_(Q_max)` where `I_a` is the second axial moment of area (item 4-21.1) and `r_(Q,max)` is the maximum radial distance (ISO 80000-3) of any point in the surface considered from the Q-axis with respect to which `I_a` is defined | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SectionModulusUnit[1]; | |
| } | |
| attribute sectionModulus: SectionModulusValue[*] nonunique :> scalarQuantities; | |
| attribute def SectionModulusUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; } | |
| } | |
| /* ISO-80000-4 item 4-23.1 static friction coefficient, static friction factor, coefficient of static friction */ | |
| attribute def StaticFrictionCoefficientValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-23.1 static friction coefficient, static friction factor, coefficient of static friction | |
| * symbol(s): `μ_s`, `(f_s)` | |
| * application domain: generic | |
| * name: StaticFrictionCoefficient (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: proportionality factor between the maximum magnitude of the tangential component `F_max` of the static friction force (item 4-9.3) and the magnitude of the normal component `N` of the contact force (item 4-9.1) between two bodies at relative rest with respect to each other: `F_max = μ_s * N` | |
| * remarks: When it is not necessary to distinguish between dynamic friction factor and static friction factor, the name friction factor may be used for both. | |
| */ | |
| } | |
| attribute staticFrictionCoefficient: StaticFrictionCoefficientValue :> scalarQuantities; | |
| alias staticFrictionFactor for staticFrictionCoefficient; | |
| alias coefficientOfStaticFriction for staticFrictionCoefficient; | |
| /* ISO-80000-4 item 4-23.2 kinetic friction factor, dynamic friction factor */ | |
| attribute def KineticFrictionFactorValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-23.2 kinetic friction factor, dynamic friction factor | |
| * symbol(s): `μ`, `(f)` | |
| * application domain: generic | |
| * name: KineticFrictionFactor (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: proportionality factor between the magnitudes of the kinetic friction force, `F_μ` (item 4-9.4) and the normal component `N` of the contact force (item 4-9.1): `F_μ = μ * N` | |
| * remarks: When it is not necessary to distinguish between dynamic friction factor and static friction factor, the name friction factor may be used for both. The dynamic friction factor `µ` is independent in first approximation of the contact surface. | |
| */ | |
| } | |
| attribute kineticFrictionFactor: KineticFrictionFactorValue :> scalarQuantities; | |
| alias dynamicFrictionFactor for kineticFrictionFactor; | |
| /* ISO-80000-4 item 4-23.3 rolling resistance factor */ | |
| attribute def RollingResistanceFactorValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-23.3 rolling resistance factor | |
| * symbol(s): `C_"rr"` | |
| * application domain: generic | |
| * name: RollingResistanceFactor (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: proportionality factor between the magnitude of the tangential component `F` and the magnitude of the normal component `N` of the force applied to a body rolling on a surface at constant speed: `F = C_(rr)*N` | |
| * remarks: Also known as rolling resistance coefficient, RRC. | |
| */ | |
| } | |
| attribute rollingResistanceFactor: RollingResistanceFactorValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-23.4 drag coefficient, drag factor */ | |
| attribute def DragCoefficientValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-23.4 drag coefficient, drag factor | |
| * symbol(s): `C_D` | |
| * application domain: generic | |
| * name: DragCoefficient (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: factor proportional to magnitude `F_D` of the drag force (item 4-9.6) of a body moving in a fluid, dependent on the shape and speed `v` (ISO 80000-3) of a body: `F_D = 1/2 * C_D * ρ * v^2 * A` where `ρ` is mass density (item 4-2) of the fluid and `A` is cross-section area (ISO 80000-3) of the body | |
| * remarks: None. | |
| */ | |
| } | |
| attribute dragCoefficient: DragCoefficientValue :> scalarQuantities; | |
| alias dragFactor for dragCoefficient; | |
| /* ISO-80000-4 item 4-24 dynamic viscosity, viscosity */ | |
| attribute def DynamicViscosityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-24 dynamic viscosity, viscosity | |
| * symbol(s): `η` | |
| * application domain: generic | |
| * name: DynamicViscosity | |
| * quantity dimension: L^-1*M^1*T^-1 | |
| * measurement unit(s): Pa*s, kg*m^-1*s^-1 | |
| * tensor order: 0 | |
| * definition: for laminar flows, proportionality constant between shear stress `τ_(xz)` (item 4-16.2) in a fluid moving with a velocity `v_x` (ISO 80000-3) and gradient `(d v_x)/dz` perpendicular to the plane of shear: `τ_(xz) = η (d v_x)/(dz)` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: DynamicViscosityUnit[1]; | |
| } | |
| attribute dynamicViscosity: DynamicViscosityValue[*] nonunique :> scalarQuantities; | |
| attribute def DynamicViscosityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| alias ViscosityUnit for DynamicViscosityUnit; | |
| alias ViscosityValue for DynamicViscosityValue; | |
| alias viscosity for dynamicViscosity; | |
| /* ISO-80000-4 item 4-25 kinematic viscosity */ | |
| attribute def KinematicViscosityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-25 kinematic viscosity | |
| * symbol(s): `v` | |
| * application domain: generic | |
| * name: KinematicViscosity | |
| * quantity dimension: L^2*T^-1 | |
| * measurement unit(s): m^2*s^-1 | |
| * tensor order: 0 | |
| * definition: quotient of dynamic viscosity `η` (item 4-24) and mass density `ρ` (item 4-2) of a fluid: `v = η/ρ` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: KinematicViscosityUnit[1]; | |
| } | |
| attribute kinematicViscosity: KinematicViscosityValue[*] nonunique :> scalarQuantities; | |
| attribute def KinematicViscosityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-26 surface tension */ | |
| attribute def SurfaceTensionValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-26 surface tension | |
| * symbol(s): `γ`, `σ` | |
| * application domain: generic | |
| * name: SurfaceTension | |
| * quantity dimension: M^1*T^-2 | |
| * measurement unit(s): N*m^-1, kg*s^-2 | |
| * tensor order: 0 | |
| * definition: magnitude of a force acting against the enlargement of area portion of a surface separating a liquid from its surrounding | |
| * remarks: The concept of surface energy is closely related to surface tension and has the same dimension. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: SurfaceTensionUnit[1]; | |
| } | |
| attribute surfaceTension: SurfaceTensionValue[*] nonunique :> scalarQuantities; | |
| attribute def SurfaceTensionUnit :> DerivedUnit { | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-27.1 power */ | |
| attribute def PowerValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-27.1 power | |
| * symbol(s): `P` | |
| * application domain: generic | |
| * name: Power | |
| * quantity dimension: L^2*M^1*T^-3 | |
| * measurement unit(s): W, J*s^-1, kg*m^2*s^-3 | |
| * tensor order: 0 | |
| * definition: quotient of energy (ISO 80000-5) and duration (ISO 80000-3) | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: PowerUnit[1]; | |
| } | |
| attribute power: PowerValue[*] nonunique :> scalarQuantities; | |
| attribute def PowerUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-27 mechanical power */ | |
| attribute mechanicalPower: PowerValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-27 mechanical power | |
| * symbol(s): `P` | |
| * application domain: mechanics | |
| * name: MechanicalPower (specializes Power) | |
| * quantity dimension: L^2*M^1*T^-3 | |
| * measurement unit(s): W, N*m*s^-1, kg*m^2*s^-3 | |
| * tensor order: 0 | |
| * definition: scalar product of force `vec(F)` (item 4-9.1) acting to a body and its velocity `vec(v)` (ISO 80000-3): `P = vec(F) * vec(v)` | |
| * remarks: None. | |
| */ | |
| } | |
| /* ISO-80000-4 item 4-28.1 potential energy */ | |
| attribute potentialEnergy: EnergyValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-28.1 potential energy | |
| * symbol(s): `V`, `E_p` | |
| * application domain: generic | |
| * name: PotentialEnergy (specializes Energy) | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): J, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: for conservative force `vec(F)`, scalar additive quantity obeying condition `vec(F) = -nabla F`, if it exists | |
| * remarks: For the definition of energy, see ISO 80000-5. A force is conservative when the force field is irrotational, i.e. `rot(F) = 0` , or `vec(F)` is perpendicular to the speed of the body to ensure `vec(F) * d vec(r) = 0` . | |
| */ | |
| } | |
| /* ISO-80000-4 item 4-28.2 kinetic energy */ | |
| attribute kineticEnergy: EnergyValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-28.2 kinetic energy | |
| * symbol(s): `T`, `E_k` | |
| * application domain: generic | |
| * name: KineticEnergy (specializes Energy) | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): J, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: scalar (ISO 80000-2) quantity characterizing a moving body expressed by: `T = 1/2 m v^2` where `m` is mass (item 4-1) of the body and `v` is its speed (ISO 80000-3) | |
| * remarks: For the definition of energy, see ISO 80000-5. | |
| */ | |
| } | |
| /* ISO-80000-4 item 4-28.3 mechanical energy */ | |
| attribute mechanicalEnergy: EnergyValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-28.3 mechanical energy | |
| * symbol(s): `E`, `W` | |
| * application domain: generic | |
| * name: MechanicalEnergy (specializes Energy) | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): J, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: sum of kinetic energy `T` (item 4-28.2) and potential energy `V` (item 4-28.1): `E = T+V` | |
| * remarks: The symbols `E` and `W` are also used for other kinds of energy. This definition is understood in a classical way and it does not include thermal motion. | |
| */ | |
| } | |
| /* ISO-80000-4 item 4-28.4 mechanical work, work */ | |
| attribute mechanicalWork: EnergyValue :> scalarQuantities { | |
| doc | |
| /* | |
| * source: item 4-28.4 mechanical work, work | |
| * symbol(s): `A`, `W` | |
| * application domain: generic | |
| * name: MechanicalWork (specializes Energy) | |
| * quantity dimension: L^2*M^1*T^-2 | |
| * measurement unit(s): J, kg*m^2*s^-2 | |
| * tensor order: 0 | |
| * definition: process quantity describing the total action of a force `vec(F)` (item 4-9.1) along a continuous curve `Γ` in three-dimensional space with infinitesimal displacement (ISO 80000-3) `dvec(r)`, as a line integral of their scalar product: `A = int_Γ vec(F) * d vec(r)` | |
| * remarks: The definition covers the case `A = -int_Γ p*dV` where `Γ` is a curve in the phase space and implies that work generally depends upon `Γ`, and that type of process must be defined (e.g. isentropic or isothermic). | |
| */ | |
| } | |
| alias work for mechanicalWork; | |
| /* ISO-80000-4 item 4-29 mechanical efficiency */ | |
| attribute def MechanicalEfficiencyValue :> DimensionOneValue { | |
| doc | |
| /* | |
| * source: item 4-29 mechanical efficiency | |
| * symbol(s): `η` | |
| * application domain: mechanics | |
| * name: MechanicalEfficiency (specializes DimensionOneQuantity) | |
| * quantity dimension: 1 | |
| * measurement unit(s): 1 | |
| * tensor order: 0 | |
| * definition: quotient of output power `P_"out"` (item 4-27) from a system and input power `P_"in"` (item 4-27) to this system: `η = P_"out"/P_"in"` | |
| * remarks: The system must be specified. This quantity is often expressed by the unit percent, symbol %. | |
| */ | |
| } | |
| attribute mechanicalEfficiency: MechanicalEfficiencyValue :> scalarQuantities; | |
| /* ISO-80000-4 item 4-30.1 mass flow */ | |
| attribute def MassFlowValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-30.1 mass flow (magnitude) | |
| * symbol(s): `j_m` | |
| * application domain: generic | |
| * name: MassFlow | |
| * quantity dimension: L^-2*M^1*T^-1 | |
| * measurement unit(s): kg*m^-2*s^-1 | |
| * tensor order: 0 | |
| * definition: vector (ISO 80000-2) quantity characterizing a flowing fluid by the product of its local mass density `ρ` (item 4-2) and local velocity `vec(v)` (ISO 80000-3): `vec(j_m) = ρ vec(v)` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MassFlowUnit[1]; | |
| } | |
| attribute massFlow: MassFlowValue[*] nonunique :> scalarQuantities; | |
| attribute def MassFlowUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| attribute def Cartesian3dMassFlowVector :> VectorQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-30.1 mass flow (vector) | |
| * symbol(s): `vec(j_m)` | |
| * application domain: generic | |
| * name: MassFlow | |
| * quantity dimension: L^-2*M^1*T^-1 | |
| * measurement unit(s): kg*m^-2*s^-1 | |
| * tensor order: 1 | |
| * definition: vector (ISO 80000-2) quantity characterizing a flowing fluid by the product of its local mass density `ρ` (item 4-2) and local velocity `vec(v)` (ISO 80000-3): `vec(j_m) = ρ vec(v)` | |
| * remarks: None. | |
| */ | |
| attribute :>> isBound = false; | |
| attribute :>> num: Real[3]; | |
| attribute :>> mRef: Cartesian3dMassFlowCoordinateFrame[1]; | |
| } | |
| attribute massFlowVector: Cartesian3dMassFlowVector :> vectorQuantities; | |
| attribute def Cartesian3dMassFlowCoordinateFrame :> VectorMeasurementReference { | |
| attribute :>> dimensions = 3; | |
| attribute :>> isBound = false; | |
| attribute :>> isOrthogonal = true; | |
| attribute :>> mRefs: MassFlowUnit[3]; | |
| } | |
| /* ISO-80000-4 item 4-30.2 mass flow rate */ | |
| attribute def MassFlowRateValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-30.2 mass flow rate | |
| * symbol(s): `q_m` | |
| * application domain: generic | |
| * name: MassFlowRate | |
| * quantity dimension: M^1*T^-1 | |
| * measurement unit(s): kg*s^-1 | |
| * tensor order: 0 | |
| * definition: scalar (ISO 80000-2) quantity characterizing the total flow through the two-dimensional domain `A` with normal vector `vec(e)_n` of a flowing fluid with mass flow `vec(j)_m` (item 4-30.1) as an integral: `q_m = int int_A vec(j)_m * vec(e)_n dA` where `dA` is the area (ISO 80000-3) of an element of the two-dimensional domain `A` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MassFlowRateUnit[1]; | |
| } | |
| attribute massFlowRate: MassFlowRateValue[*] nonunique :> scalarQuantities; | |
| attribute def MassFlowRateUnit :> DerivedUnit { | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-30.3 mass change rate */ | |
| attribute def MassChangeRateValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-30.3 mass change rate | |
| * symbol(s): `q_m` | |
| * application domain: generic | |
| * name: MassChangeRate | |
| * quantity dimension: M^1*T^-1 | |
| * measurement unit(s): kg*s^-1 | |
| * tensor order: 0 | |
| * definition: rate of increment of mass `m` (item 4-1): `q_m = (dm)/(dt)` where `dm` is the infinitesimal mass (item 4-1) increment and `dt` is the infinitesimal duration (ISO 80000-3) | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: MassChangeRateUnit[1]; | |
| } | |
| attribute massChangeRate: MassChangeRateValue[*] nonunique :> scalarQuantities; | |
| attribute def MassChangeRateUnit :> DerivedUnit { | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-31 volume flow rate */ | |
| attribute def VolumeFlowRateValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-31 volume flow rate | |
| * symbol(s): `q_v` | |
| * application domain: generic | |
| * name: VolumeFlowRate | |
| * quantity dimension: L^3*T^-1 | |
| * measurement unit(s): m^3*s^-1 | |
| * tensor order: 0 | |
| * definition: scalar (ISO 80000-2) quantity characterizing the total flow through the two-dimensional domain `A` with the normal vector `vec(e)_n` of a flowing fluid with velocity `vec(v)` (ISO 80000-3) as an integral: `q_v = int int_A vec(v) * vec(e)_n dA` where `dA` is the area (ISO 80000-3) of an element of the two-dimensional domain `A` | |
| * remarks: None. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: VolumeFlowRateUnit[1]; | |
| } | |
| attribute volumeFlowRate: VolumeFlowRateValue[*] nonunique :> scalarQuantities; | |
| attribute def VolumeFlowRateUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); } | |
| } | |
| /* ISO-80000-4 item 4-32 action quantity */ | |
| attribute def ActionQuantityValue :> ScalarQuantityValue { | |
| doc | |
| /* | |
| * source: item 4-32 action quantity | |
| * symbol(s): `S` | |
| * application domain: generic | |
| * name: ActionQuantity | |
| * quantity dimension: L^2*M^1*T^-1 | |
| * measurement unit(s): J*s, kg*m^2*s^-1 | |
| * tensor order: 0 | |
| * definition: time integral of energy `E` over a time interval `(t_1, t_2)`: `S = int_(t_1)^(t_2) E dt` | |
| * remarks: The energy may be expressed by a Lagrangian or Hamiltonian function. | |
| */ | |
| attribute :>> num: Real; | |
| attribute :>> mRef: ActionQuantityUnit[1]; | |
| } | |
| attribute actionQuantity: ActionQuantityValue[*] nonunique :> scalarQuantities; | |
| attribute def ActionQuantityUnit :> DerivedUnit { | |
| private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; } | |
| private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; } | |
| private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; } | |
| attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); } | |
| } | |
| } | |