unitforge 0.5.7__tar.gz → 0.5.10__tar.gz

{unitforge-0.5.7 → unitforge-0.5.10}/Cargo.lock

@@ -351,7 +351,7 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unitforge"
-version = "0.5.7"
+version = "0.5.10"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -367,7 +367,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.5.7"
+version = "0.5.10"
 dependencies = [
  "regex",
 ]

{unitforge-0.5.7 → unitforge-0.5.10}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge"
-version = "0.5.7"
+version = "0.5.10"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "A library for unit and quantity consistent computations in Rust"
@@ -20,7 +20,7 @@ pyo3 = { version = "0.28.3", features = ["extension-module", "auto-initialize",
 numpy = { version = "0.28.0", optional = true }
 strum = { version = "0.28.0", optional = true }
 strum_macros = { version = "0.28.0", optional = true }
-unitforge_macros = { version = "0.5.7", path = "unitforge_macros" }
+unitforge_macros = { version = "0.5.10", path = "unitforge_macros" }
 
 [features]
 default = []

{unitforge-0.5.7 → unitforge-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.5.7
+Version: 0.5.10
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -9,7 +9,9 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Dist: numpy>=2.2.0
 Summary: A library for unit and quantity consistent computations in Rust
 Keywords: units,quantities,simulation,physics
+Author: Dr.Q team <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
 Author-email: "Dr.Q team" <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
+License: MIT
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Repository, https://gitlab.com/henrikjstromberg/unitforge

{unitforge-0.5.7 → unitforge-0.5.10}/src/lib.rs

@@ -93,6 +93,8 @@ pub mod quantities {
     pub use force_volume::*;
     pub mod frequency;
     pub use frequency::*;
+    pub mod heat_flux;
+    pub use heat_flux::*;
     pub mod inverse_distance;
     pub use inverse_distance::*;
     pub mod inverse_area;
@@ -107,12 +109,18 @@ pub mod quantities {
     pub use mass_per_distance::*;
     pub mod pressure_rate;
     pub use pressure_rate::*;
+    pub mod power;
+    pub use power::*;
     pub mod force_distance;
     pub use force_distance::*;
     pub mod force_stress;
     pub use force_stress::*;
     pub mod specific_gas_constant;
     pub use specific_gas_constant::*;
+    pub mod specific_energy;
+    pub use specific_energy::*;
+    pub mod specific_heat_capacity;
+    pub use specific_heat_capacity::*;
     pub mod stiffness;
     pub use stiffness::*;
     pub mod rotational_stiffness;
@@ -135,8 +143,14 @@ pub mod quantities {
     pub use stress_squared::*;
     pub mod temperature;
     pub use temperature::*;
+    pub mod temperature_gradient;
+    pub use temperature_gradient::*;
+    pub mod thermal_conductance;
+    pub use thermal_conductance::*;
     pub mod inverse_temperature;
     pub use inverse_temperature::*;
+    pub mod thermal_conductivity;
+    pub use thermal_conductivity::*;
     pub mod time;
     pub use time::*;
     pub mod universal_gas_constant;
@@ -151,6 +165,10 @@ pub mod quantities {
     pub use voltage::*;
     pub mod inverse_angle;
     pub use inverse_angle::*;
+    pub mod volumetric_heat_capacity;
+    pub use volumetric_heat_capacity::*;
+    pub mod volumetric_energy_density;
+    pub use volumetric_energy_density::*;
 }
 pub use quantities::*;
 

unitforge-0.5.10/src/quantities/heat_flux.rs

@@ -0,0 +1,38 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum HeatFluxUnit {
+    W_msq,
+    mW_msq,
+    kW_msq,
+}
+
+impl HeatFluxUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            HeatFluxUnit::W_msq => (1., 0),
+            HeatFluxUnit::mW_msq => (1., -3),
+            HeatFluxUnit::kW_msq => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for HeatFluxUnit {
+    fn name(&self) -> &str {
+        match &self {
+            HeatFluxUnit::W_msq => "W/m²",
+            HeatFluxUnit::mW_msq => "mW/m²",
+            HeatFluxUnit::kW_msq => "kW/m²",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(HeatFlux, HeatFluxUnit, [HeatFluxUnit::W_msq]);
+impl_div_with_self_to_f64!(HeatFlux);

unitforge-0.5.10/src/quantities/power.rs

@@ -0,0 +1,52 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum PowerUnit {
+    GW,
+    MW,
+    kW,
+    W,
+    mW,
+    muW,
+    nW,
+}
+
+make_alias!(Power, PowerUnit, HeatRate, HeatRateUnit);
+
+impl PowerUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            PowerUnit::GW => (1., 9),
+            PowerUnit::MW => (1., 6),
+            PowerUnit::kW => (1., 3),
+            PowerUnit::W => (1., 0),
+            PowerUnit::mW => (1., -3),
+            PowerUnit::muW => (1., -6),
+            PowerUnit::nW => (1., -9),
+        }
+    }
+}
+
+impl PhysicsUnit for PowerUnit {
+    fn name(&self) -> &str {
+        match &self {
+            PowerUnit::GW => "GW",
+            PowerUnit::MW => "MW",
+            PowerUnit::kW => "kW",
+            PowerUnit::W => "W",
+            PowerUnit::mW => "mW",
+            PowerUnit::muW => "μW",
+            PowerUnit::nW => "nW",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(Power, PowerUnit, [PowerUnit::W]);
+impl_div_with_self_to_f64!(Power);

unitforge-0.5.10/src/quantities/specific_energy.rs

@@ -0,0 +1,39 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum SpecificEnergyUnit {
+    J_kg,
+    kJ_kg,
+}
+
+impl SpecificEnergyUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            SpecificEnergyUnit::J_kg => (1., 0),
+            SpecificEnergyUnit::kJ_kg => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for SpecificEnergyUnit {
+    fn name(&self) -> &str {
+        match &self {
+            SpecificEnergyUnit::J_kg => "J/kg",
+            SpecificEnergyUnit::kJ_kg => "kJ/kg",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    SpecificEnergy,
+    SpecificEnergyUnit,
+    [SpecificEnergyUnit::J_kg]
+);
+impl_div_with_self_to_f64!(SpecificEnergy);

unitforge-0.5.10/src/quantities/specific_heat_capacity.rs

@@ -0,0 +1,39 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum SpecificHeatCapacityUnit {
+    J_kgK,
+    kJ_kgK,
+}
+
+impl SpecificHeatCapacityUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            SpecificHeatCapacityUnit::J_kgK => (1., 0),
+            SpecificHeatCapacityUnit::kJ_kgK => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for SpecificHeatCapacityUnit {
+    fn name(&self) -> &str {
+        match &self {
+            SpecificHeatCapacityUnit::J_kgK => "J/(kg*K)",
+            SpecificHeatCapacityUnit::kJ_kgK => "kJ/(kg*K)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    SpecificHeatCapacity,
+    SpecificHeatCapacityUnit,
+    [SpecificHeatCapacityUnit::J_kgK]
+);
+impl_div_with_self_to_f64!(SpecificHeatCapacity);

unitforge-0.5.10/src/quantities/temperature_gradient.rs

@@ -0,0 +1,42 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum TemperatureGradientUnit {
+    K_m,
+    K_mm,
+    K_km,
+}
+
+impl TemperatureGradientUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            TemperatureGradientUnit::K_m => (1., 0),
+            TemperatureGradientUnit::K_mm => (1., 3),
+            TemperatureGradientUnit::K_km => (1., -3),
+        }
+    }
+}
+
+impl PhysicsUnit for TemperatureGradientUnit {
+    fn name(&self) -> &str {
+        match &self {
+            TemperatureGradientUnit::K_m => "K/m",
+            TemperatureGradientUnit::K_mm => "K/mm",
+            TemperatureGradientUnit::K_km => "K/km",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    TemperatureGradient,
+    TemperatureGradientUnit,
+    [TemperatureGradientUnit::K_m]
+);
+impl_div_with_self_to_f64!(TemperatureGradient);

unitforge-0.5.10/src/quantities/thermal_conductance.rs

@@ -0,0 +1,42 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum ThermalConductanceUnit {
+    mW_K,
+    W_K,
+    kW_K,
+}
+
+impl ThermalConductanceUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            ThermalConductanceUnit::mW_K => (1., -3),
+            ThermalConductanceUnit::W_K => (1., 0),
+            ThermalConductanceUnit::kW_K => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for ThermalConductanceUnit {
+    fn name(&self) -> &str {
+        match self {
+            ThermalConductanceUnit::mW_K => "mW/K",
+            ThermalConductanceUnit::W_K => "W/K",
+            ThermalConductanceUnit::kW_K => "kW/K",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    ThermalConductance,
+    ThermalConductanceUnit,
+    [ThermalConductanceUnit::W_K]
+);
+impl_div_with_self_to_f64!(ThermalConductance);

unitforge-0.5.10/src/quantities/thermal_conductivity.rs

@@ -0,0 +1,42 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum ThermalConductivityUnit {
+    W_mK,
+    mW_mK,
+    kW_mK,
+}
+
+impl ThermalConductivityUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            ThermalConductivityUnit::W_mK => (1., 0),
+            ThermalConductivityUnit::mW_mK => (1., -3),
+            ThermalConductivityUnit::kW_mK => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for ThermalConductivityUnit {
+    fn name(&self) -> &str {
+        match &self {
+            ThermalConductivityUnit::W_mK => "W/(m*K)",
+            ThermalConductivityUnit::mW_mK => "mW/(m*K)",
+            ThermalConductivityUnit::kW_mK => "kW/(m*K)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    ThermalConductivity,
+    ThermalConductivityUnit,
+    [ThermalConductivityUnit::W_mK]
+);
+impl_div_with_self_to_f64!(ThermalConductivity);

unitforge-0.5.10/src/quantities/volumetric_energy_density.rs

@@ -0,0 +1,39 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum VolumetricEnergyDensityUnit {
+    J_mcb,
+    kJ_mcb,
+}
+
+impl VolumetricEnergyDensityUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            VolumetricEnergyDensityUnit::J_mcb => (1., 0),
+            VolumetricEnergyDensityUnit::kJ_mcb => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for VolumetricEnergyDensityUnit {
+    fn name(&self) -> &str {
+        match &self {
+            VolumetricEnergyDensityUnit::J_mcb => "J/m³",
+            VolumetricEnergyDensityUnit::kJ_mcb => "kJ/m³",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    VolumetricEnergyDensity,
+    VolumetricEnergyDensityUnit,
+    [VolumetricEnergyDensityUnit::J_mcb]
+);
+impl_div_with_self_to_f64!(VolumetricEnergyDensity);

unitforge-0.5.10/src/quantities/volumetric_heat_capacity.rs

@@ -0,0 +1,39 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum VolumetricHeatCapacityUnit {
+    J_mcbK,
+    kJ_mcbK,
+}
+
+impl VolumetricHeatCapacityUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            VolumetricHeatCapacityUnit::J_mcbK => (1., 0),
+            VolumetricHeatCapacityUnit::kJ_mcbK => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for VolumetricHeatCapacityUnit {
+    fn name(&self) -> &str {
+        match &self {
+            VolumetricHeatCapacityUnit::J_mcbK => "J/(m³*K)",
+            VolumetricHeatCapacityUnit::kJ_mcbK => "kJ/(m³*K)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    VolumetricHeatCapacity,
+    VolumetricHeatCapacityUnit,
+    [VolumetricHeatCapacityUnit::J_mcbK]
+);
+impl_div_with_self_to_f64!(VolumetricHeatCapacity);

{unitforge-0.5.7 → unitforge-0.5.10}/src/relations.rs

@@ -28,6 +28,13 @@ impl_mul_relation_with_other!(Distance, InverseArea, InverseDistance);
 impl_mul_relation_with_other!(InverseDistance, Area, Distance);
 impl_mul_relation_with_other!(Velocity, Time, Distance);
 impl_mul_relation_with_other!(Force, Distance, ForceDistance);
+impl_mul_relation_with_other!(Power, Time, ForceDistance);
+impl_mul_relation_with_other!(Force, Velocity, Power);
+impl_mul_relation_with_other!(HeatFlux, Area, Power);
+impl_mul_relation_with_other!(ThermalConductivity, TemperatureGradient, HeatFlux);
+impl_mul_relation_with_other!(TemperatureGradient, Distance, Temperature);
+impl_mul_relation_with_other!(ThermalConductivity, Distance, ThermalConductance);
+impl_mul_relation_with_other!(ThermalConductance, Temperature, Power);
 impl_mul_relation_with_other!(Force, Area, ForceArea);
 impl_mul_relation_with_other!(ForceArea, Distance, ForceVolume);
 impl_mul_relation_with_other!(AreaOfMoment, Stress, ForceArea);
@@ -73,18 +80,28 @@ impl_mul_relation_with_other!(SpecificGasConstant, DensityTemperatureRate, Stres
 impl_mul_relation_with_other!(DensityRate, SpecificGasConstant, StressRatePerTemperature);
 impl_mul_relation_with_other!(StressRatePerTemperature, Temperature, StressRate);
 impl_mul_relation_with_other!(InverseTemperature, Temperature, Strain);
-impl_mul!(InverseDistance, Distance, f64);
-impl_mul!(InverseAngle, Angle, f64);
-impl_mul!(InverseStress, Stress, f64);
-impl_mul!(Frequency, Time, f64);
-impl_div!(Stress, Strain, Stress);
-impl_mul!(Stress, Strain, Stress);
-
 impl_mul_relation_with_self!(Distance, Area);
 impl_mul_relation_with_self!(Area, AreaOfMoment);
 impl_mul_relation_with_self!(InverseDistance, InverseArea);
 impl_mul_relation_with_self!(Strain, StrainSquared);
 impl_mul_relation_with_self!(Stress, StressSquared);
 impl_mul_relation_with_other!(Stress, StressSquared, StressCubed);
-impl_div!(StressSquared, StressCubed, InverseStress);
 impl_mul_relation_with_self!(AngularVelocity, AngularAcceleration);
+impl_mul_relation_with_other!(ForceDistance, Frequency, Power);
+impl_mul_relation_with_other!(Density, SpecificHeatCapacity, VolumetricHeatCapacity);
+impl_mul_relation_with_other!(VolumetricHeatCapacity, Temperature, VolumetricEnergyDensity);
+impl_mul_relation_with_other!(SpecificHeatCapacity, Temperature, SpecificEnergy);
+impl_mul_relation_with_other!(SpecificEnergy, Density, VolumetricEnergyDensity);
+impl_mul_relation_with_other!(
+    DensityTemperature,
+    SpecificHeatCapacity,
+    VolumetricEnergyDensity
+);
+
+impl_mul!(InverseDistance, Distance, f64);
+impl_mul!(InverseAngle, Angle, f64);
+impl_mul!(InverseStress, Stress, f64);
+impl_mul!(Frequency, Time, f64);
+impl_div!(Stress, Strain, Stress);
+impl_mul!(Stress, Strain, Stress);
+impl_div!(StressSquared, StressCubed, InverseStress);