diff --git a/Project.toml b/Project.toml index d4b6700..67e9067 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "UnitSystems" uuid = "3a241a3c-2137-41aa-af5e-1388e404ca09" authors = ["Michael Reed"] -version = "0.1.1" +version = "0.2.0" [compat] julia = "1" diff --git a/README.md b/README.md index f8165f2..f97b6aa 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # UnitSystems.jl -*Physical unit system constants (Metric, English, Natural, etc...)* +*Physical unit systems (Metric, English, Natural, etc...)* [![DOI](https://zenodo.org/badge/317419353.svg)](https://zenodo.org/badge/latestdoi/317419353) [![Build Status](https://travis-ci.org/chakravala/UnitSystems.jl.svg?branch=master)](https://travis-ci.org/chakravala/UnitSystems.jl) @@ -8,21 +8,50 @@ [![Coverage Status](https://coveralls.io/repos/chakravala/UnitSystems.jl/badge.svg?branch=master&service=github)](https://coveralls.io/github/chakravala/UnitSystems.jl?branch=master) [![codecov.io](https://codecov.io/github/chakravala/UnitSystems.jl/coverage.svg?branch=master)](https://codecov.io/github/chakravala/UnitSystems.jl?branch=master) +Specifications for dimensional units are in the [UnitSystems.jl](https://github.com/chakravala/UnitSystems.jl) and [UnitfulSystems.jl](httsp://github.com/chakravala/UnitfulSystems.jl) repositories. +The two packages are designed so that they can be interchanged if compatibility with [Unitful.jl](https://github.com/PainterQubits/Unitful.jl) is desired or not. +However, the `UnitfulSystems` package has fewer `UnitSystem` specifications available than the `UnitSystems` package due to limitations in combination with the `Unitful` package. +Specifically, `Metric`, `SI2019`, `CODATA`, `Conventional`, `MTS`, `EMU2019`, `English`, and `EnglishUS` can have `Unitful` values; while `Gauss`, `LorentzHeaviside`, `Thomson`, `EMU`, `ESU`, `ESU2019`, `IAU`, `FFF`, `Planck`, `PlanckGauss`, `Stoney`, `Hartree`, `Rydberg`, `Schrodinger`, `Electronic`, `Natural`, `NaturalGauss`, `QCD`, `QCDGauss`, and `QCDoriginal` are plain valued. + +```Julia +pkg> add UnitSystems # or UnitfulSystems + +julia> using UnitSystems +``` + A `UnitSystem` is a consistent set of dimensional values selected to accomodate a particular use case or standardization. -In total, five fundamental constants `kB,ħ,𝘤,μ₀,mₑ` are used to specify a specific unit system. These are the constants of `boltzmann`, `planckreduced`, `lightspeed`, `permeability`, and `electronmass`. -Different choices of natural units or physical measurements result in a variety of unit systems optimized for many purposes. +It is possible to convert derived physical quantities from any `UnitSystem` specification into any other using accurate values. +In total, five fundamental constants `kB,ħ,𝘤,μ₀,mₑ` are used to specify a specific unit system. +These are the constants of `boltzmann`, `planckreduced`, `lightspeed`, `permeability`, and `electronmass`. +Different choices of natural units or physical measurements result in a variety of unit systems for many purposes. + +Main documentation is at https://geophysics.crucialflow.com/dev/units + +Another important additional definition is the `molarmass` constant `Mᵤ`, which is automatically selected based on the choice of `boltzmann` constant (but can also be customized if necessary). +Historically, older electromagnetic unit systems also relied on a `rationalization` constant `λ` and a `lorentz` force proportionality constant `αL`. +In most unit systems these extra constants have a value of `1` unless otherwise specified. ```Julia - UnitSystem{kB,ħ,𝘤,μ₀,mₑ} + UnitSystem{kB,ħ,𝘤,μ₀,mₑ,λ,αL} ``` -Standardized for engineering based on fundamental constants: `kB` Boltzmann's constant, `ħ` reduced Planck's constant, `𝘤` speed of light, `μ₀` vacuum permeability, and `mₑ` electron rest mass. +Fundamental constants of physics are: `kB` Boltzmann's constant, `ħ` reduced Planck's constant, `𝘤` speed of light, `μ₀` vacuum permeability, `mₑ` electron rest mass, `λ` Gauss rationalization, and `αL` Lorentz's constant. Primarily the `Metric` SI unit system is used in addition to the historic `English` engineering unit system. These constants induce derived values for `avogadro`, `boltzmann`, `universal`, `planck`, `planckreduced`, `lightspeed`, `planckmass`, `atomicmass`, `protonmass`, `electronmass`, `newton`, `einstein`, `permeability`, `permittivity`, `coulomb`, and -additional constants `stefan`, `radiationintensity`, `impedance`, `charge`, `magneton`, `conductance`, `faraday`, `magneticflux`, `josephson`, `klitzing`, `hartree`, `rydberg`, `bohr`, `bohrreduced`, and `molarmass`. +additional constants `molarmass`, `hyperfine`, `luminousefficacy`, `stefan`, `radiationintensity`, `ampere`, `lorentz`, `biotsavart`, `rationalization`, `impedance`, `charge`, `magneton`, `conductance`, `faraday`, `magneticflux`, `josephson`, `klitzing`, `hartree`, `rydberg`, `bohr`, and `bohrreduced`. -Main documentation is at https://geophysics.crucialflow.com/dev/units +Physics constant documentation is at https://geophysics.crucialflow.com/dev/constants + +Additional reference `UnitSystem` variants: `EMU`, `ESU`, `Gauss`, `LorentzHeaviside`, `MTS`, `SI2019`, `CODATA`, `Conventional`, `IAU`, `EnglishUS`; and natural atomic units based on gravitational coupling `αG` and the fine structure `1/αinv` constant (`Planck`, `PlanckGauss`, `Stoney`, `Hartree`, `Rydberg`, `Schrodinger`, `Electronic`, `Natural`, `NaturalGauss`, `QCD`, `QCDGauss`, and `QCDoriginal`). + +Unt conversion documentation is at https://geophysics.crucialflow.com/dev/convert -Additional reference `UnitSystem` variants `CGS`, `CGS2019`, `SI2019`, `CODATA`, `Conventional`, `IAU`; along with several natural atomic units based on the fine structure constant `1/αinv` and the gravitational coupling constant `αG` (`Planck`, `PlanckGauss`, `Stoney`, `Hartree`, `Rydberg`, `Schrodinger`, `Electronic`, `Natural`, `NaturalGauss`, `QCD`, `QCDGauss`, and `QCDoriginal`). +**Unit conversions:** +Kinematic: `time`, `length`, `area`, `volume`, `wavenumber`, `fuelefficiency`, `frequency`, `frequencydrift`, `speed`, `acceleration`, `jerk`, `snap`, and `volumeflow`; +Mechanical: `mass`, `energy`, `power`, `force`, `pressure`, `momentum`, `angularmomentum`, `yank`, `areadensity`, `density`, `specificvolume`, `action`, `specificenergy`, `stiffness`, `irradiance`, `diffusivity`, `viscosity`, `lineardensity`, `massflow`, `radiantflux`, `powerdensity`, `compressibility`, `fluence`, and `rotationalinertia`; +Electromagnetic: `charge`, `current`, `voltage`, `capacitance`, `impedance`, `conductance`, `magneticflux`, `magneticinduction`, `inductance`, `electricinduction`, `chargedensity`, `currentdensity`, `conductivity`, `permittivity`, `permeability`, `electricfield`, `magneticfield`, `exposure`, `resistivity`, `linearchargedensity`, `magneticdipolemoment`, `mobility`, `reluctance`, `vectorpotential`, `magneticmoment`, `rigidity`, `susceptibility`, `electricflux`, and `electricdipolemoment`; +Thermodynamic: `temperature`, `entropy`, `specificentropy`, `thermalconductivity`, `thermalconductance`, `thermalresistance`, `thermalexpansion`, and `lapserate`; +Molar: `molarmass`, `molality`, `mole`, `molarity`, `molarvolume`, `molarentropy`, `molarenergy`, `molarconductivity`, `catalysis`, and `specificity`; +Photometric: `luminousflux`, `luminance`, `luminousenergy`, `luminousexposure`, and `luminousefficacy`. -Other similar packages include [PhysicalConstants.jl](https://github.com/JuliaPhysics/PhysicalConstants.jl), [MathPhysicalConstants.jl](https://github.com/LaGuer/MathPhysicalConstants.jl), [Unitful.jl](https://github.com/PainterQubits/Unitful.jl.git), [UnitfulUS](https://github.com/PainterQubits/UnitfulUS.jl), [UnitfulAstro](https://github.com/JuliaAstro/UnitfulAstro.jl), [UnitfulAtomic](https://github.com/sostock/UnitfulAtomic.jl), [NaturallyUnitful](https://github.com/MasonProtter/NaturallyUnitful.jl), and [UnitfulMoles](https://github.com/rafaqz/UnitfulMoles.jl). +Other similar packages include [PhysicalConstants.jl](https://github.com/JuliaPhysics/PhysicalConstants.jl), [MathPhysicalConstants.jl](https://github.com/LaGuer/MathPhysicalConstants.jl), [Unitful.jl](https://github.com/PainterQubits/Unitful.jl.git), [UnitfulSystems.jl](https://github.com/chakravala/UnitfulSystems.jl), [UnitfulUS.jl](https://github.com/PainterQubits/UnitfulUS.jl), [UnitfulAstro.jl](https://github.com/JuliaAstro/UnitfulAstro.jl), [UnitfulAtomic.jl](https://github.com/sostock/UnitfulAtomic.jl), [NaturallyUnitful.jl](https://github.com/MasonProtter/NaturallyUnitful.jl), and [UnitfulMoles.jl](https://github.com/rafaqz/UnitfulMoles.jl). diff --git a/src/UnitSystems.jl b/src/UnitSystems.jl index 49ae0b8..806fa08 100644 --- a/src/UnitSystems.jl +++ b/src/UnitSystems.jl @@ -3,79 +3,138 @@ module UnitSystems # This file is part of UnitSystems.jl. It is licensed under the MIT license # UnitSystems Copyright (C) 2020 Michael Reed -import Base: @pure - -export slug, ft, KJ1990, KJ2014, RK1990, RK2014, mₑ2014 -export mass, slugs, kilograms, poundal, meters, feet, rankine, kelvin, moles, molecules -export UnitSystem, CGS, CGS2019, Metric, SI2019, CODATA, Conventional, English, IAU -export Planck, PlanckGauss, Stoney, Hartree, Rydberg, Schrodinger, Electronic, Natural, NaturalGauss, QCD, QCDGauss, QCDoriginal +import Base: @pure, length, time + +export slug, ft, KJ1990, KJ2014, RK1990, RK2014, mₑ1990, mₑ2014, temp, units, US +export slugs, kilograms, lbm, meters, feet, rankine, kelvin, moles, molecules +export UnitSystem, CGS, CGS2019, Metric, SI2019, CODATA, Conventional, English, IAU, SI +export EMU, ESU, CGSm, CGSe, MTS, EMU2019, ESU2019, LorentzHeaviside, HLU, EnglishUS, FFF +export Planck, PlanckGauss, Stoney, Hartree, Rydberg, Schrodinger, Electronic, Natural, NaturalGauss, QCD, QCDGauss, QCDoriginal, SI1976, Thomson, Gauss, Mixed, Kennelly + +const Constants = (:boltzmann,:planck,:planckreduced,:lightspeed,:permeability,:luminousefficacy,:hyperfine,:lorentz,:rationalization,:molarmass,:electronmass) +const Physics = (:protonmass,:atomicmass,:planckmass,:stefan,:radiationdensity,:einstein,:impedance,:charge,:faraday,:josephson,:klitzing,:hartree,:rydberg,:bohr,:bohrreduced,:electronradius,:conductance,:magneticflux,:magneton,:hyperfine,:ampere,:biotsavart,:coulomb,:permittivity,:universal,:newton,:avogadro) +const Kinematic = (:time,:length,:area,:volume,:wavenumber,:fuelefficiency,:frequency,:frequencydrift,:speed,:acceleration,:jerk,:snap,:volumeflow) +const Mechanical = (:mass,:energy,:power,:force,:pressure,:momentum,:angularmomentum,:yank,:areadensity,:density,:specificvolume,:action,:specificenergy,:stiffness,:irradiance,:diffusivity,:viscosity,:lineardensity,:massflow,:radiantflux,:powerdensity,:compressibility,:fluence,:rotationalinertia) +const Molar = (:molarmass,:molality,:mole,:molarity,:molarvolume,:molarentropy,:molarenergy,:molarconductivity,:catalysis,:specificity) +const Electromagnetic = (:charge,:current,:voltage,:capacitance,:impedance,:conductance,:magneticflux,:magneticinduction,:inductance,:electricinduction,:chargedensity,:currentdensity,:conductivity,:permittivity,:permeability,:electricfield,:magneticfield,:exposure,:resistivity,:linearchargedensity,:magneticdipolemoment,:mobility,:reluctance,:vectorpotential,:magneticmoment,:rigidity,:susceptibility,:electricflux,:electricdipolemoment) +const Photometric = (:luminousflux,:luminance,:luminousenergy,:luminousexposure,:luminousefficacy) +const Thermodynamic = (:temperature,:entropy,:specificentropy,:thermalconductivity,:thermalconductance,:thermalresistance,:thermalexpansion,:lapserate) +const Convert = [Kinematic...,Mechanical...,Molar...,Electromagnetic...,Photometric...,Thermodynamic...] + +listext(x) = join(x,"`, `","`, and `") # unit systems """ - UnitSystem{kB,ħ,𝘤,μ₀,mₑ} + UnitSystem{kB,ħ,𝘤,μ₀,mₑ,λ,αL} -Standardized for engineering based on fundamental constants: `kB` Boltzmann's constant, `ħ` reduced Planck's constant, `𝘤` speed of light, `μ₀` vacuum permeability, and `mₑ` electron rest mass. +Fundamental constants of physics are: `kB` Boltzmann's constant, `ħ` reduced Planck's constant, `𝘤` speed of light, `μ₀` vacuum permeability, `mₑ` electron rest mass, `λ` Gauss rationalization, and `αL` Lorentz's constant. Primarily the `Metric` SI unit system is used in addition to the historic `English` engineering unit system. These constants induce derived values for `avogadro`, `boltzmann`, `universal`, `planck`, `planckreduced`, `lightspeed`, `planckmass`, `atomicmass`, `protonmass`, `electronmass`, `newton`, `einstein`, `permeability`, `permittivity`, `coulomb`, and -additional constants `stefan`, `radiationintensity`, `impedance`, `charge`, `magneton`, `conductance`, `faraday`, `magneticflux`, `josephson`, `klitzing`, `hartree`, `rydberg`, `bohr`, `bohrreduced`, and `molarmass`. +additional constants `molarmass`, `hyperfine`, `luminousefficacy`, `stefan`, `radiationintensity`, `ampere`, `lorentz`, `biotsavart`, `rationalization`, `impedance`, `charge`, `magneton`, `conductance`, `faraday`, `magneticflux`, `josephson`, `klitzing`, `hartree`, `rydberg`, `bohr`, and `bohrreduced`. + +Additional reference `UnitSystem` variants: `EMU`, `ESU`, `Gauss`, `LorentzHeaviside`, `MTS`, `SI2019`, `CODATA`, `Conventional`, `IAU`, `EnglishUS`; and natural atomic units based on gravitational coupling `αG` and the fine structure `1/αinv` constant (`Planck`, `PlanckGauss`, `Stoney`, `Hartree`, `Rydberg`, `Schrodinger`, `Electronic`, `Natural`, `NaturalGauss`, `QCD`, `QCDGauss`, and `QCDoriginal`). -Additional reference `UnitSystem` variants `CGS`, `CGS2019`, `SI2019`, `CODATA`, `Conventional`, `IAU`; along with several natural atomic units based on the fine structure constant `1/αinv` and the gravitational coupling constant `αG` (`Planck`, `PlanckGauss`, `Stoney`, `Hartree`, `Rydberg`, `Schrodinger`, `Electronic`, `Natural`, `NaturalGauss`, `QCD`, `QCDGauss`, and `QCDoriginal`). +**Unit conversions:** +Kinematic: `$(listext(Kinematic))`; +Mechanical: `$(listext(Mechanical))`; +Electromagnetic: `$(listext(Electromagnetic))`; +Thermodynamic: `$(listext(Thermodynamic))`; +Molar: `$(listext(Molar))`; +Photometric: `$(listext(Photometric))`. """ #`Rᵤ,mᵤ,σ,ħ,μ₀,ε₀,kₑ,𝘦,𝔉,RK,Z₀,G₀` -struct UnitSystem{kB,ħ,𝘤,μ,mₑ} end +struct UnitSystem{kB,ħ,𝘤,μ₀,mₑ,λ,αL} end +@pure UnitSystem{k,ħ,𝘤,μ,m,λ}() where {k,ħ,𝘤,μ,m,λ} = UnitSystem{k,ħ,𝘤,μ,m,λ,1}() +@pure UnitSystem{k,ħ,𝘤,μ,m}() where {k,ħ,𝘤,μ,m} = UnitSystem{k,ħ,𝘤,μ,m,1}() @pure boltzmann(::UnitSystem{k}) where k = k -@pure planckreduced(::UnitSystem{k,h}) where {k,h} = h -@pure lightspeed(::UnitSystem{k,h,c}) where {k,h,c} = c -@pure permeability(::UnitSystem{k,h,c,μ}) where {k,h,c,μ} = μ -@pure electronmass(::UnitSystem{k,h,c,μ,m}) where {k,h,c,μ,m} = m +@pure planckreduced(::UnitSystem{k,ħ}) where {k,ħ} = ħ +@pure lightspeed(::UnitSystem{k,ħ,𝘤}) where {k,ħ,𝘤} = 𝘤 +@pure permeability(::UnitSystem{k,ħ,𝘤,μ}) where {k,ħ,𝘤,μ} = μ +@pure electronmass(::UnitSystem{k,ħ,𝘤,μ,m}) where {k,ħ,𝘤,μ,m} = m +@pure rationalization(::UnitSystem{k,ħ,𝘤,μ,m,λ}) where {k,ħ,𝘤,μ,m,λ} = λ +@pure lorentz(::UnitSystem{k,ħ,𝘤,μ,m,λ,α}) where {k,ħ,𝘤,μ,m,λ,α} = α # ΔνCs:s⁻¹, c:m⋅s⁻¹, h:kg⋅m²⋅s⁻¹, kB:kg⋅m²⋅s⁻²⋅K⁻¹, NA:mol⁻¹, Kcd: cd⋅sr⋅s³⋅kg⁻¹⋅m⁻² -@pure electronmass(R∞::Float64=R∞,𝘩::Float64=𝘩) = αinv^2*R∞*2𝘩/𝘤 -@pure mass(U::UnitSystem,S::UnitSystem) = electronmass(S)/electronmass(U) -@pure newton(U::UnitSystem) = lightspeed(U)*planckreduced(U)/planckmass(U)^2 +isrationalized(U::UnitSystem) = rationalization(U) ≠ 4π + +Base.display(U::UnitSystem) = println("UnitSystem{kB=$(boltzmann(U)),ħ=$(planckreduced(U)),𝘤=$(lightspeed(U)),μ₀=$(permeability(U)),mᵤ=$(electronmass(U)),λ=$(isrationalized(U) ? rationalization(U) : "4π"),αL=$(lorentz(U))}") + +@pure unit(x,y=1) = isapprox(y,x,rtol=eps()^0.9) ? y : x +@pure mass(U::UnitSystem,S::UnitSystem) = electronmass(U,S) +@pure electronmass(𝘩::Float64,R∞::Float64=R∞) = αinv^2*R∞*2𝘩/𝘤 @pure planckmass(U::UnitSystem) = mass(mP,U) @pure planck(U::UnitSystem) = 2π*planckreduced(U) -@pure impedance(U::UnitSystem) = permeability(U)*lightspeed(U) +@pure newton(U::UnitSystem) = lightspeed(U)*planckreduced(U)/planckmass(U)^2 @pure charge(U::UnitSystem) = sqrt(2planck(U)/impedance(U)/αinv) # fine structure -@pure charge(U::UnitSystem,S::UnitSystem) = charge(S)/charge(U) +@pure impedance(U::UnitSystem) = permeability(U)*lightspeed(U)*rationalization(U)*lorentz(U)^2 -for unit ∈ (:mass,:length,:time,:temperature,:charge) - @eval @pure $unit(v::Real,U::UnitSystem,S::UnitSystem=Metric) = v/$unit(U,S) - unit ≠ :charge && @eval @pure $unit(U::UnitSystem) = $unit(U,Metric) +for unit ∈ Constants + @eval @pure $unit(U::UnitSystem,S::UnitSystem) = unit($unit(S)/$unit(U)) +end +for unit ∈ Convert + @eval begin + @pure @inline $unit(v::Real,U::UnitSystem) = $unit(v,U,Metric) + @pure @inline $unit(v::Real,U::UnitSystem,S::UnitSystem) = (u=$unit(U,S);isone(u) ? v : v/u) + @pure @inline $unit(v::Real,U::UnitSystem{kB,ħ,𝘤,μ₀,mₑ},S::UnitSystem{kB,ħ,𝘤,μ₀,mₑ}) where {kB,ħ,𝘤,μ₀,mₑ} = v + @pure @inline $unit(U::UnitSystem{kB,ħ,𝘤,μ₀,mₑ},S::UnitSystem{kB,ħ,𝘤,μ₀,mₑ}) where {kB,ħ,𝘤,μ₀,mₑ} = 1 + end + if unit ∉ (Constants...,:permittivity,:charge,:magneticflux,:impedance,:conductance) + @eval @pure @inline $unit(U::UnitSystem) = $unit(U,Metric) + end +end +for unit ∈ (Constants...,Physics...,Convert...) + @eval export $unit end -Base.display(U::UnitSystem) = println("UnitSystem{kB=$(boltzmann(U)),ħ=$(planckreduced(U)),𝘤=$(lightspeed(U)),μ₀=$(permeability(U)),mᵤ=$(electronmass(U))}") +function (U::UnitSystem)(JK=1,Js=1,ms=1,Hm=1,kg=1) + kB = boltzmann(U)*JK + ħ = planckreduced(U)*Js + 𝘤 = lightspeed(U)*ms + μ₀ = permeability(U)*Hm + mₑ = electronmass(U)*kg + λ = rationalization(U) + αL = lorentz(U) + UnitSystem{kB,ħ,𝘤,μ₀,mₑ,λ,isone(αL) ? αL : αL/ms}() +end # common conversion factors const atm,g₀,lbm = 101325.0,9.80665,32.17404856 # lb-f to pdl -const slug,ft,ftUS,rankine,kelvin = 0.45359237lbm,0.3048,1200/3937,9/5,5/9 +const slug,ft,ftUS,rankine,kelvin = 0.45359237lbm,0.3048,1200/3937,5/9,9/5 const kcalₜₕ,kcal₄,kcal₁₀,kcal₂₀,kcalₘ,kcalᵢₜ = 4184,4204,4185.5,4182,4190,4186.8 const calₜₕ,cal₄,cal₁₀,cal₂₀,calₘ,calᵢₜ = (kcalₜₕ,kcal₄,kcal₁₀,kcal₂₀,kcalₘ,kcalᵢₜ)./1e3 const kcal = kcalₜₕ; const cal = kcal/1000 # calₜₕ thermal calorie # fundamental constants, αinv = (34259-1/4366.8123)/250 # 137.036 exactly? -const ΔνCs,Kcd,mP = 9192631770.0,683.0,2.176434e-8 # planck mass (kg) +const ΔνCs,Kcd,mP = 9192631770.0,683.002,2.176434e-8 # planck mass (kg) const NA,kB,𝘩,𝘤,𝘦 = 6.02214076e23,1.380649e-23,6.62607015e-34,299792458.,1.602176634e-19 const μₑᵤ,μₚᵤ,αinv,R∞ = 1/1822.888486209,1.007276466621,137.035999084,10973731.5681601 const μ₀ = 2𝘩/𝘤/αinv/𝘦^2 # ≈ 4π*(1e-7+5.5e-17), exact charge -const ħ,δμ₀,μₚₑ,Rᵤ,mₑ = 𝘩/2π,μ₀-4π*1e-7,μₚᵤ/μₑᵤ,NA*kB,electronmass(R∞,𝘩) +const ħ,δμ₀,μₚₑ,Rᵤ,mₑ = 𝘩/2π,μ₀-4π*1e-7,μₚᵤ/μₑᵤ,NA*kB,electronmass(𝘩) const RK1990,RK2014,KJ1990,KJ2014 = 25812.807,25812.8074555,4.835979e14,4.835978525e14 -const ħ2014 = 2/RK2014/KJ2014^2/π; const mₑ2014 = electronmass(10973731.568508,ħ2014) - -# engineering units - -const CGS = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,4π,1000mₑ}() -const CGS2019 = UnitSystem{1e7*kB,1e7*ħ,100𝘤,1e7*μ₀,1000mₑ}() +const ħ1990,ħ2014 = 2/RK1990/KJ1990^2/π,2/RK2014/KJ2014^2/π +const mₑ1990,mₑ2014 = electronmass(2π*ħ1990),electronmass(2π*ħ2014) + +# engineering units # Thomson: αL = 1/2 + +const Gauss = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,4π,0.01/𝘤}() +const LorentzHeaviside = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,1,0.01/𝘤}() +const Thomson = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,4π,1/2}() +const Kennelly = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,1e-7,mₑ,4π}() # ? +const ESU = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,(100𝘤)^-2,1000mₑ,4π}() +const ESU2019 = UnitSystem{1e7*kB,1e7*ħ,100𝘤,1e3*μ₀/𝘤^2,1000mₑ}() +const EMU = UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,4π}() +const EMU2019 = UnitSystem{1e7*kB,1e7*ħ,100𝘤,1e7*μ₀,1000mₑ}() +const MTS = UnitSystem{1e6*Rᵤ*mₑ/μₑᵤ,1000ħ,𝘤,4π/1e4,mₑ/1000}() +const Mixed = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,μ₀,mₑ}() const Metric = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,4π*1e-7,mₑ}() const SI1976 = UnitSystem{8.31432mₑ/μₑᵤ/0.001,ħ,𝘤,4π*1e-7,mₑ}() const SI2019 = UnitSystem{kB,ħ,𝘤,μ₀,mₑ}() const CODATA = UnitSystem{Rᵤ*mₑ2014/μₑᵤ/0.001,ħ2014,𝘤,2RK2014/𝘤/αinv,mₑ2014}() -const Conventional = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,2/RK1990/KJ1990^2/π,𝘤,2RK1990/𝘤/αinv,mₑ}() -const English = UnitSystem{5.657302466e-24,ħ/slug/ft^2,𝘤/ft,4π,mₑ/slug}() -const EnglishNew = UnitSystem{1000rankine/slug/ft*Rᵤ*mₑ/μₑᵤ,ħ/slug/ft^2,𝘤/ft,4π,mₑ/slug}() -const Sudgy = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,μ₀,mₑ}() +const Conventional = UnitSystem{Rᵤ*mₑ1990/μₑᵤ/0.001,ħ1990,𝘤,2RK1990/𝘤/αinv,mₑ1990}() +const English = UnitSystem{kB*rankine/slug/ft^2,ħ/slug/ft^2,𝘤/ft,4π,mₑ/slug}() +const EnglishUS = UnitSystem{1000Rᵤ*mₑ/μₑᵤ*rankine/slug/ftUS^2,ħ/slug/ftUS^2,𝘤/ftUS,4π,mₑ/slug}() # astronomical units @@ -83,7 +142,14 @@ const GMsun,GMearth,GMjupiter = 1.32712442099e20,398600441.8e6,1.26686534e17 const au,LD,day = 149597870.7e3,384402e3,60^2*24 const pc,ly,GG = au*648000/π,365.25𝘤*day,newton(SI2019) const mₛ = GMsun/GG; const Jₛ = mₛ*au^2/day^2; export mₛ,Jₛ,au,day -const IAU = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001/Jₛ,ħ*day/Jₛ,day*𝘤/au,4π*1e-7*day^2/Jₛ,mₑ/mₛ}() +const IAU = UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001/Jₛ,ħ/day/Jₛ,day*𝘤/au,4π*1e-7*day^2/Jₛ,mₑ/mₛ}() + +# aliased & humorous units + +const mf = mass(90/lbm,Metric,English); const Jf = mf*(201.168/14day)^2 +const FFF = UnitSystem{1000Rᵤ*mₑ/μₑᵤ*rankine/Jf,ħ/14day/Jf,14day*𝘤/201.168,0,mₑ/mf}() +const units, US, SI, temp = UnitSystem, UnitSystem, SI2019, temperature +const CGS, CGS2019, CGSm, CGSe, HLU = Gauss, EMU2019, EMU, ESU, LorentzHeaviside # natural units @@ -104,15 +170,24 @@ const QCDoriginal = UnitSystem{1,1,1,4π/αinv,1/μₚₑ}() # physical constants @pure molarmass(U::UnitSystem{1}) = 1 -@pure molarmass(U::UnitSystem{boltzmann(CGS)}) = molarmass(Natural) -@pure molarmass(U::UnitSystem{kB}) where kB = molarmass(CGS)/1000 -@pure molarmass(U::UnitSystem{1e7*kB}) = 1000molarmass(SI2019) @pure molarmass(U::UnitSystem{kB}) = electronmass(U)*NA/μₑᵤ +@pure molarmass(U::UnitSystem{1e7*kB}) = 1000molarmass(SI2019) +@pure molarmass(U::UnitSystem{1e3*kB}) = molarmass(SI2019)/1000 +@pure molarmass(U::UnitSystem{kB}) where kB = molarmass(CGS)/1000 +@pure molarmass(U::UnitSystem{boltzmann(MTS)}) = molarmass(CGS)/1e6 +@pure molarmass(U::UnitSystem{boltzmann(CGS)}) = molarmass(Natural) +@pure molarmass(U::UnitSystem{boltzmann(FFF)}) = molarmass(Natural) +@pure molarmass(U::UnitSystem{boltzmann(English)}) = 1000molarmass(SI2019) +@pure molarmass(U::UnitSystem{boltzmann(EnglishUS)}) = molarmass(Natural) @pure molarmass(U::UnitSystem{boltzmann(IAU)}) = 1/1000mₛ -@pure molarmass(U::UnitSystem{boltzmann(English)}) = Rᵤ*mₑ/μₑᵤ/slug/ft*rankine/boltzmann(English) +@pure luminousefficacy(U::UnitSystem{1}) = 1 +@pure luminousefficacy(U::UnitSystem) = power(Kcd,SI2019,U) + +include("kinematic.jl") +include("electromagnetic.jl") +include("thermodynamic.jl") include("physics.jl") -include("convert.jl") # == Metric is different const κ = einstein(SI2019) @@ -130,116 +205,217 @@ const G₀ = conductance(SI2019) # const Eₕ = hartree(SI2019) const a₀ = bohr(SI2019) const rₑ = electronradius(SI2019) -const ℓP = plancklength(SI2019) const RK = klitzing(SI2019) # const KJ = josephson(SI2019) # const RH,Ry = R∞*mₚ/(mₑ+mₚ),𝘩*𝘤*R∞ -const Mu,Ru,SB,hh,cc,m0,e0,ke,me,mp,mu,ee,FF,Z0,G0,Eh,a0,re,g0 = Mᵤ,Rᵤ,σ,𝘩,𝘤,μ₀,ε₀,kₑ,mₑ,mₚ,mᵤ,𝘦,𝔉,Z₀,G₀,Eₕ,a₀,rₑ,g₀ -export κ, GG, NA, kB, Rᵤ, σ, 𝘩, ħ, 𝘤, μ₀, ε₀, kₑ, mₑ, mₚ, mᵤ, 𝘦, 𝔉, Φ₀, Z₀, G₀, Eₕ, R∞, a₀, rₑ, KJ, RK, Ru, SB, hh, cc, m0, e0, ke, me, mp, mu, ee, FF, Z0, G0, Eh, a0, re -export αG, αinv, μₚₑ, μₑᵤ, μₚᵤ, mpe, meu, mpu, mP, δμ₀, Mᵤ, Mu, RH, Ry, ΔνCs, Kcd, lbm -export cal, kcal, calₜₕ, kcalₜₕ, calᵢₜ, kcalᵢₜ, SI, SI1976, ℓP, plancklength, g₀, g0, atm -const mpe, mea, mpu, SI = μₚₑ, μₑᵤ, μₚᵤ, SI2019 -const Constants = (:newton,:avogadro,:boltzmann,:planck,:planckreduced,:lightspeed,:universal,:permeability,:permittivity,:coulomb) -const Physics = (:electronmass,:protonmass,:atomicmass,:planckmass,:stefan,:radiationdensity,:einstein,:impedance,:charge,:faraday,:josephson,:klitzing,:hartree,:rydberg,:bohr,:bohrreduced,:electronradius,:conductance,:magneticflux,:magneton,:molarmass) +const ℓP = length(PlanckGauss) +const tP = time(PlanckGauss) +const TP = temperature(PlanckGauss) -for op ∈ (Constants...,Physics...) - @eval export $op -end +const lS = length(Stoney) +const tS = time(Stoney) +const mS = mass(Stoney) +const qS = charge(Stoney) + +const lA = length(Hartree) +const tA = time(Hartree) +const mA = mass(Hartree) +const qA = charge(Hartree) + +const lQCD = length(QCD) +const tQCD = time(QCD) +const mQCD = mass(QCD) + +# non standard units + +const BTUftlb = 3600/0.5778thermalconductivity(English) # BTU⋅ft⁻¹⋅lb⁻¹ +const BTUJ = energy(English)*BTUftlb # BTU⋅J⁻¹ + +# constant aliases + +const mpe, meu, mpu, ainv, aG = μₚₑ, μₑᵤ, μₚᵤ, αinv, αG +const Mu,Ru,SB,hh,cc,m0,e0,ke,me,mp,mu,ee,FF,Z0,G0,Eh,a0,re,g0,lP,ϵ₀ = Mᵤ,Rᵤ,σ,𝘩,𝘤,μ₀,ε₀,kₑ,mₑ,mₚ,mᵤ,𝘦,𝔉,Z₀,G₀,Eₕ,a₀,rₑ,g₀,ℓP,ε₀ +export κ, GG, NA, kB, Rᵤ, σ, 𝘩, ħ, 𝘤, μ₀, ε₀, kₑ, mₑ, mₚ, mᵤ, 𝘦, 𝔉, Φ₀, Z₀, G₀, Eₕ, R∞, a₀, rₑ, KJ, RK, Ru, SB, hh, cc, m0, e0, ke, me, mp, mu, ee, FF, Z0, G0, Eh, a0, re, μB +export αG, αinv, μₚₑ, μₑᵤ, μₚᵤ, mpe, meu, mpu, mP, δμ₀, Mᵤ, Mu, RH, Ry, ΔνCs, Kcd, ainv +export cal, kcal, calₜₕ, kcalₜₕ, calᵢₜ, kcalᵢₜ, ℓP, g₀, g0, atm, lbm, BTUJ, BTUftlb, aG +export lP, tP, TP, lS, tS, mS, qS, lA, tA, mA, qA, lQCD, tQCD, mQCD, ϵ₀ # engineering unit systems docs +cgstext(US,AMP,cgs=eval(US)) = """ +```Julia +julia> boltzmann($US) # erg⋅K⁻¹ +$(boltzmann(cgs)) + +julia> planckreduced($US) # erg⋅s⋅rad⁻¹ +$(planckreduced(cgs)) + +julia> lightspeed($US) # cm⋅s⁻¹ +$(lightspeed(cgs)) + +julia> permeability($US) # statH⋅cm⁻¹ +$(permeability(cgs)) + +julia> electronmass($US) # g +$(electronmass(cgs)) + +julia> rationalization($US) +$(rationalization(cgs)) +``` +""" + +for U ∈ (:CGSm,:CGSe,:EMU,:ESU) + (EU,AMP) = QuoteNode.(U ∉ (:CGSe,:ESU) ? (:EMU,:Bi) : (:ESU,:statA)) +@eval @doc """ + $($(QuoteNode(U)))::UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,$($EU≠:EMU ? "(100𝘤)^-2" : 1),1000mₑ,4π} + +Centimetre-gram-second `UnitSystem` variant based on `$($EU)` (non-rationalized). + +$(cgstext($(QuoteNode(U)),$AMP)) +""" $U + +U ∉ (:CGSm,:CGSe) && @eval @doc """ + $(Symbol($(QuoteNode(U)),:2019))::UnitSystem{1e7*kB,1e7*ħ,100𝘤,$($EU≠:EMU ? "1e3*μ₀/𝘤^2" : "1e7*μ₀"),1000mₑ} + +Centimetre-gram-second `UnitSystem` variant of tuned `SI2019` based on `$($EU)` (rationalized). + +$(cgstext(Symbol($(QuoteNode(U)),:2019),$AMP)) +""" $(Symbol(U,:2019)) +end + @doc """ - Metric::UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,4π*1e-7,mₑ} + Thomson::UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,4π,1/2} -Systeme International d'Unites (the SI units) adopted as the preferred `UnitSystem`. +Centimetre-gram-second `UnitSystem` variant `Thomson` (EMU-Lorentz, non-rationalized). ```Julia -julia> boltzmann(Metric) # J⋅K⁻¹ -$(boltzmann(Metric)) +julia> boltzmann(Thomson) # erg⋅K⁻¹ +$(boltzmann(Thomson)) -julia> planckreduced(Metric) # J⋅s⋅rad⁻¹ -$(planckreduced(Metric)) +julia> planckreduced(Thomson) # erg⋅s⋅rad⁻¹ +$(planckreduced(Thomson)) -julia> lightspeed(Metric) # m⋅s⁻¹ -$(lightspeed(Metric)) +julia> lightspeed(Thomson) # cm⋅s⁻¹ +$(lightspeed(Thomson)) -julia> permeability(Metric) # H⋅m⁻¹ -$(permeability(Metric)) +julia> permeability(Thomson) # abH⋅cm⁻¹ +$(permeability(Thomson)) -julia> electronmass(Metric) # kg -$(electronmass(Metric)) +julia> electronmass(Thomson) # g +$(electronmass(Thomson)) + +julia> rationalization(Thomson) +$(rationalization(Thomson)) + +julia> lorentz(Thomson) +$(lorentz(Thomson)) ``` -""" Metric +""" Thomson @doc """ - English::UnitSystem{5.657302466e-24,ħ/slug/ft^2,𝘤/ft,4π,mₑ/slug} + Gauss::UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,4π,0.01/𝘤} -Engineering `UnitSystem` historically used by Britain and United States. +Centimetre-gram-second `UnitSystem` variant `CGS` (Gauss-Lorentz, non-rationalized). ```Julia -julia> boltzmann(English) # ft⋅lb⋅°R⁻¹ -$(boltzmann(English)) +julia> boltzmann(Gauss) # erg⋅K⁻¹ +$(boltzmann(Gauss)) -julia> planckreduced(English) # ft⋅lb⋅s⋅rad⁻¹ -$(planckreduced(English)) +julia> planckreduced(Gauss) # erg⋅s⋅rad⁻¹ +$(planckreduced(Gauss)) -julia> lightspeed(English) # ft⋅s⁻¹ -$(lightspeed(English)) +julia> lightspeed(Gauss) # cm⋅s⁻¹ +$(lightspeed(Gauss)) -julia> permeability(English) # slug⋅ft²⋅?⁻² -$(permeability(English)) +julia> permeability(Gauss) # statH⋅cm⁻¹ +$(permeability(Gauss)) -julia> electronmass(English) # slugs -$(electronmass(English)) +julia> electronmass(Gauss) # g +$(electronmass(Gauss)) + +julia> rationalization(Gauss) +$(rationalization(Gauss)) + +julia> lorentz(Gauss) +$(lorentz(Gauss)) ``` -""" English +""" Gauss, CGS @doc """ - CGS::UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,4π,1000mₑ} + LorentzHeaviside::UnitSystem{1e10*Rᵤ*mₑ/μₑᵤ,1e7*ħ,100𝘤,1,1000mₑ,1,0.01/𝘤} -Centimetre-gram-second `UnitSystem` variant of `Metric` system based on factors of `1e2,1e3`. +Centimetre-gram-second `UnitSystem` variant `HLU` (Heaviside-Lorentz, rationalized). ```Julia -julia> boltzmann(CGS) # erg⋅K⁻¹ -$(boltzmann(CGS)) +julia> boltzmann(LorentzHeaviside) # erg⋅K⁻¹ +$(boltzmann(LorentzHeaviside)) -julia> planckreduced(CGS) # erg⋅s⋅rad⁻¹ -$(planckreduced(CGS)) +julia> planckreduced(LorentzHeaviside) # erg⋅s⋅rad⁻¹ +$(planckreduced(LorentzHeaviside)) -julia> lightspeed(CGS) # cm⋅s⁻¹ -$(lightspeed(CGS)) +julia> lightspeed(LorentzHeaviside) # cm⋅s⁻¹ +$(lightspeed(LorentzHeaviside)) -julia> permeability(CGS) # erg⋅A⁻²⋅cm⁻¹ -$(permeability(CGS)) +julia> permeability(HLU) # hlH⋅cm⁻¹ +$(permeability(LorentzHeaviside)) -julia> electronmass(CGS) # g -$(electronmass(CGS)) +julia> electronmass(LorentzHeaviside) # g +$(electronmass(LorentzHeaviside)) + +julia> rationalization(LorentzHeaviside) +$(rationalization(LorentzHeaviside)) + +julia> lorentz(LorentzHeaviside) +$(lorentz(LorentzHeaviside)) +``` +""" LorentzHeaviside, HLU + +@doc """ + MTS::UnitSystem{1e6*Rᵤ*mₑ/μₑᵤ,1000ħ,𝘤,4π/1e4,mₑ/1000} + +Metre-tonne-second `UnitSystem` variant of `Metric` system. + +```Julia +julia> boltzmann(MTS) # kJ⋅K⁻¹ +$(boltzmann(MTS)) + +julia> planckreduced(MTS) # kJ⋅s⋅rad⁻¹ +$(planckreduced(MTS)) + +julia> lightspeed(MTS) # m⋅s⁻¹ +$(lightspeed(MTS)) + +julia> permeability(MTS) # kH⋅m⁻¹ +$(permeability(MTS)) + +julia> electronmass(MTS) # t +$(electronmass(MTS)) ``` -""" CGS +""" MTS @doc """ - CGS2019::UnitSystem{1e7*kB,1e7*ħ,100𝘤,1e7*μ₀,1000mₑ} + Metric::UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,4π*1e-7,mₑ} -Centimetre-gram-second `UnitSystem` variant of the tuned `SI2019` unit specification. +Systeme International d'Unites (the SI units) adopted as the preferred `UnitSystem`. ```Julia -julia> boltzmann(CGS2019) # erg⋅K⁻¹ -$(boltzmann(CGS2019)) +julia> boltzmann(Metric) # J⋅K⁻¹ +$(boltzmann(Metric)) -julia> planckreduced(CGS2019) # erg⋅s⋅rad⁻¹ -$(planckreduced(CGS2019)) +julia> planckreduced(Metric) # J⋅s⋅rad⁻¹ +$(planckreduced(Metric)) -julia> lightspeed(CGS2019) # cm⋅s⁻¹ -$(lightspeed(CGS2019)) +julia> lightspeed(Metric) # m⋅s⁻¹ +$(lightspeed(Metric)) -julia> permeability(CGS2019) # erg⋅A⁻²⋅cm⁻¹ -$(permeability(CGS2019)) +julia> permeability(Metric) # H⋅m⁻¹ +$(permeability(Metric)) -julia> electronmass(CGS2019 # g -$(electronmass(CGS2019)) +julia> electronmass(Metric) # kg +$(electronmass(Metric)) ``` -""" CGS2019 +""" Metric @doc """ SI2019::UnitSystem{kB,ħ,𝘤,μ₀,mₑ} @@ -288,7 +464,7 @@ $(electronmass(CODATA)) """ CODATA @doc """ - Conventional::UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,2/RK1990/KJ1990^2/π,𝘤,2RK1990/𝘤/αinv,mₑ} + Conventional::UnitSystem{Rᵤ*mₑ1990/μₑᵤ/0.001,2/RK1990/KJ1990^2/π,𝘤,2RK1990/𝘤/αinv,mₑ1990} Conventional electronic `UnitSystem` with 1990 tuned `josephson` and `klitzing` constants. @@ -333,7 +509,102 @@ $(electronmass(IAU)) ``` """ IAU -# other unit system docs +@doc """ + English::UnitSystem{kB*rankine/slug/ft^2,ħ/slug/ft^2,𝘤/ft,4π,mₑ/slug} + +Engineering `UnitSystem` historically used by Britain and United States. + +```Julia +julia> boltzmann(English) # ft⋅lb⋅°R⁻¹ +$(boltzmann(English)) + +julia> planckreduced(English) # ft⋅lb⋅s⋅rad⁻¹ +$(planckreduced(English)) + +julia> lightspeed(English) # ft⋅s⁻¹ +$(lightspeed(English)) + +julia> permeability(English) # slug⋅ft²⋅?⁻² +$(permeability(English)) + +julia> electronmass(English) # slugs +$(electronmass(English)) +``` +""" English + +@doc """ + EnglishUS::UnitSystem{1000Rᵤ*mₑ/μₑᵤ*rankine/slug/ftUS^2,ħ/slug/ftUS^2,𝘤/ftUS,4π,mₑ/slug} + +Engineering `UnitSystem` based on the geophysical US survey foot (1200/3937). + +```Julia +julia> boltzmann(EnglishUS) # ftUS⋅lb⋅°R⁻¹ +$(boltzmann(EnglishUS)) + +julia> planckreduced(EnglishUS) # ftUS⋅lb⋅s⋅rad⁻¹ +$(planckreduced(EnglishUS)) + +julia> lightspeed(EnglishUS) # ftUS⋅s⁻¹ +$(lightspeed(EnglishUS)) + +julia> permeability(EnglishUS) # slug⋅ftUS²⋅?⁻² +$(permeability(EnglishUS)) + +julia> electronmass(EnglishUS) # slugs +$(electronmass(EnglishUS)) +``` +""" EnglishUS + +@doc """ + FFF::UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001*rankine/Jf,ħ/14day/Jf,14day*𝘤/201.168,0,mₑ/mf} + +Furlong–firkin–fortnight `FFF` is a humorous `UnitSystem` based on unusal impractical units. + +```Julia +julia> boltzmann(FFF) # fir⋅fur²⋅ftn⁻²⋅F⁻¹ +$(boltzmann(FFF)) + +julia> planckreduced(FFF) # fir⋅fur²⋅ftn⁻¹⋅rad⁻¹ +$(planckreduced(FFF)) + +julia> lightspeed(FFF) # fur⋅ftn⁻¹ +$(lightspeed(FFF)) + +julia> permeability(FFF) # fir⋅fur²⋅Inf⁻² +$(permeability(FFF)) + +julia> electronmass(FFF) # fir +$(electronmass(FFF)) +``` +""" FFF + +@doc """ + Kennelly::UnitSystem{Rᵤ*mₑ/μₑᵤ/0.001,ħ,𝘤,1e-7,mₑ,4π} + +Kennelly ? variant `UnitSystem` of the standard `Metric` units ??? + +```Julia +julia> boltzmann(Kennelly) # J⋅K⁻¹ +$(boltzmann(Kennelly)) + +julia> planckreduced(Kennelly) # J⋅s⋅rad⁻¹ +$(planckreduced(Kennelly)) + +julia> lightspeed(Kennelly) # m⋅s⁻¹ +$(lightspeed(Kennelly)) + +julia> permeability(Kennelly) # H⋅m⁻¹ +$(permeability(Kennelly)) + +julia> electronmass(Kennelly) # kg +$(electronmass(Kennelly)) + +julia> rationalization(Kennelly) +$(rationalization(Kennelly)) +``` +""" Kennelly + +# natural unit system docs textunits(U,S) = """ ```Julia @@ -368,6 +639,21 @@ $(textunits(Planck,:Planck)) Planck (Gauss) `UnitSystem` with `permeability` of `4π` and `electronmass` coupling `√αG`. $(textunits(PlanckGauss,:PlanckGauss)) + +The well known `PlanckGauss` values for `length`, `time`, `mass`, and `temperature` are: +```Julia +julia> length(PlanckGauss,Metric) # ℓP +$(length(PlanckGauss,Metric)) + +julia> time(PlanckGauss,Metric) # tP +$(time(PlanckGauss,Metric)) + +julia> mass(PlanckGauss,Metric) # mP +$(mass(PlanckGauss,Metric)) + +julia> temperature(PlanckGauss,Metric) # TP +$(temperature(PlanckGauss,Metric)) +``` """ PlanckGauss @doc """ @@ -376,6 +662,21 @@ $(textunits(PlanckGauss,:PlanckGauss)) Stoney `UnitSystem` with `permeability` of `4π` and `electronmass` coupling `√(αG*αinv)`. $(textunits(Stoney,:Stoney)) + +The well known `Stoney` values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(Stoney,Metric) # lS +$(length(Stoney,Metric)) + +julia> time(Stoney,Metric) # tS +$(time(Stoney,Metric)) + +julia> mass(Stoney,Metric) # mS +$(mass(Stoney,Metric)) + +julia> charge(Stoney,Metric) # qS +$(charge(Stoney,Metric)) +``` """ Stoney @doc """ @@ -384,6 +685,21 @@ $(textunits(Stoney,:Stoney)) Hartree atomic `UnitSystem` with `lightspeed` of `αinv` and `permeability` of `4π/αinv^2`. $(textunits(Hartree,:Hartree)) + +The well known `Hartree` atomic unit values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(Hartree,Metric) # lA +$(length(Hartree,Metric)) + +julia> time(Hartree,Metric) # tA +$(time(Hartree,Metric)) + +julia> mass(Hartree,Metric) # mA +$(mass(Hartree,Metric)) + +julia> charge(Hartree,Metric) # qA +$(charge(Hartree,Metric)) +``` """ Hartree @doc """ @@ -417,6 +733,21 @@ $(textunits(Electronic,:Electronic)) Natural `UnitSystem` with all primary constants having unit value. $(textunits(Natural,:Natural)) + +The well known `Natural` values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(Natural,Metric) +$(length(Natural,Metric)) + +julia> time(Natural,Metric) +$(time(Natural,Metric)) + +julia> mass(Natural,Metric) +$(mass(Natural,Metric)) + +julia> charge(Natural,Metric) +$(charge(Natural,Metric)) +``` """ Natural @doc """ @@ -433,6 +764,21 @@ $(textunits(NaturalGauss,:NaturalGauss)) Qunatum chromodynamics `UnitSystem` with `electronmass` of `1/μₚₑ` or `1/$μₚₑ`. $(textunits(QCD,:QCD)) + +The well known `QCD` values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(QCD,Metric) # lQCD +$(length(QCD,Metric)) + +julia> time(QCD,Metric) # tQCD +$(time(QCD,Metric)) + +julia> mass(QCD,Metric) # mQCD +$(mass(QCD,Metric)) + +julia> charge(QCD,Metric) +$(charge(QCD,Metric)) +``` """ QCD @doc """ @@ -441,6 +787,21 @@ $(textunits(QCD,:QCD)) Qunatum chromodynamics (Gauss) `UnitSystem` with `electronmass` of `1/μₚₑ`. $(textunits(QCDGauss,:QCDGauss)) + +The well known `QCDGauss` values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(QCDGauss,Metric) # lQCD +$(length(QCDGauss,Metric)) + +julia> time(QCDGauss,Metric) # tQCD +$(time(QCDGauss,Metric)) + +julia> mass(QCDGauss,Metric) # mQCD +$(mass(QCDGauss,Metric)) + +julia> charge(QCDGauss,Metric) +$(charge(QCDGauss,Metric)) +``` """ QCDGauss @doc """ @@ -449,6 +810,21 @@ $(textunits(QCDGauss,:QCDGauss)) Qunatum chromodynamics (original) `UnitSystem` with `permeability` of `4π/αinv`. $(textunits(QCDoriginal,:QCDoriginal)) + +The well known `QCDoriginal` values for `length`, `time`, `mass`, and `charge` are: +```Julia +julia> length(QCDoriginal,Metric) # lQCD +$(length(QCDoriginal,Metric)) + +julia> time(QCDoriginal,Metric) # tQCD +$(time(QCDoriginal,Metric)) + +julia> mass(QCDoriginal,Metric) # mQCD +$(mass(QCDoriginal,Metric)) + +julia> charge(QCDoriginal,Metric) +$(charge(QCDoriginal,Metric)) +``` """ QCDoriginal end # module diff --git a/src/convert.jl b/src/convert.jl deleted file mode 100644 index 3a71cab..0000000 --- a/src/convert.jl +++ /dev/null @@ -1,128 +0,0 @@ - -# This file is part of UnitSystems.jl. It is licensed under the MIT license -# UnitSystems Copyright (C) 2020 Michael Reed - -@doc """ - kilograms(m::Real) = $(slug)m - -Converts mass `m` from slugs to kilogram (kg). -""" kilograms, slug -@pure kilograms(m::Real,U::UnitSystem=English) = mass(m,Metric,U) - -""" - slugs(m::Real) = $(1/slug)m - -Converts mass `m` from kilograms to slugs (slug). -""" -@pure slugs(m::Real,U::UnitSystem=Metric) = mass(m,English,U) - -""" - feet(d) = $(1/ft)d - -Converts distance `d` from meters to feet (ft). -""" -@pure feet(d,U::UnitSystem=Metric) = length(d,English,U) - -@doc """ - meters(d) = $(ft)d - -Converts distance `d` from feet to meters (m). -""" meters, ft -@pure meters(d,U::UnitSystem=English) = length(d,Metric,U) - -@doc """ - rankine*T == (9/5)*T - -Converts temperature `T` from Kelvin to degrees Rankine (°R). -""" rankine - -@doc """ - kelvin*T == (5/9)*T - -Converts temperature `T` from degrees Rankine to Kelvin (K). -""" kelvin - -""" - moles(N::Real,U::UnitSystem=Metric) = N/avogadro(U) - -Converts the number of molecules `N` to number of moles (mol). -""" -@pure moles(N::Real,U::UnitSystem=Metric) = N/avogadro(U) - -""" - molecules(n::Real,U::UnitSystem=Metric) = n*avogadro(U) - -Converts the number of moles `n` to number of molecules (dimensionless). -""" -@pure molecules(n::Real,U::UnitSystem=Metric) = n*avogadro(U) - -# CGS to SI -@pure length(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = 100 -@pure time(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = 1 - -# SI to CGS -@pure length(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 0.01 -@pure time(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 1 - -# IAU to SI -@pure length(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = 1/au -@pure time(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = day -@pure temperature(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = 1 - -# SI to IAU -@pure length(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = au -@pure time(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 1/day -@pure temperature(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 1 - -# SI to English -@pure length(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = ft -@pure time(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = rankine - -# English to SI -@pure length(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = 1/ft -@pure time(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = kelvin - -# CGS to English -@pure length(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = 100ft -@pure time(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = rankine - -# English to CGS -@pure length(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = 0.01ft -@pure time(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = 1 -@pure temperature(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = kelvin - -# IAU to English -@pure length(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = ft/au -@pure time(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = day -@pure temperature(::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = rankine - -# English to IAU -@pure length(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = au*ft -@pure time(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = 1/day -@pure temperature(::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = kelvin - -# to PlanckGauss -@pure length(::typeof(PlanckGauss),U::UnitSystem) = sqrt(planckreduced(U)*newton(U)/lightspeed(U)^3) -@pure time(::typeof(PlanckGauss),U::UnitSystem) = sqrt(planckreduced(U)*newton(U)/lightspeed(U)^5) -@pure temperature(::typeof(PlanckGauss),U::UnitSystem) = sqrt(planckreduced(U)*lightspeed(U)^5/newton(U)/boltzmann(U)^2) - -# to Stoney -@pure length(::typeof(Stoney),U::UnitSystem) = sqrt(newton(U)*coulomb(U)*charge(U)^2/lightspeed(U)^4) -@pure time(::typeof(Stoney),U::UnitSystem) = sqrt(planckreduced(U)*newton(U)^2/lightspeed(U)^6) - -# to Hartree -@pure length(::typeof(Hartree),U::UnitSystem) = 4π*permeability(U)*planckreduced(U)^2/electronmass(U)/charge(U)^2 -@pure time(::typeof(Hartree),U::UnitSystem) = (4π*permeability(U)/charge(U)^2)^2*planckreduced(U)/electronmass(U) - -# to NaturalGauss -@pure length(::typeof(NaturalGauss),U::UnitSystem) = planckreduced(U)/electronmass(U)/lightspeed(U) -@pure time(::typeof(NaturalGauss),U::UnitSystem) = planckreduced(U)/electronmass(U)/lightspeed(U)^2 - -# to QCDx -@pure length(::UnitSystem{1,1,1,μ₀,1/μₚₑ} where μ₀,U::UnitSystem) = planckreduced(U)/protonmass(U)/lightspeed(U) -@pure time(::UnitSystem{1,1,1,μ₀,1/μₚₑ} where μ₀,U::UnitSystem) = planckreduced(U)/protonmass(U)/lightspeed(U)^2 diff --git a/src/electromagnetic.jl b/src/electromagnetic.jl new file mode 100644 index 0000000..7eb8f73 --- /dev/null +++ b/src/electromagnetic.jl @@ -0,0 +1,542 @@ + +# This file is part of UnitSystems.jl. It is licensed under the MIT license +# UnitSystems Copyright (C) 2020 Michael Reed + +""" +$(convertext(:charge,"sqrt(planck(U,S)*current(U,S)/voltage(U,S))")) + +Electric `charge` quantization (C, A⋅s), unit conversion factor. + +```Julia +julia> charge(EMU,Metric) # C⋅abC⁻¹ +$(charge(EMU,Metric)) + +julia> charge(EMU,ESU) # statC⋅abC⁻¹ +$(charge(EMU,ESU)) + +julia> charge(ESU,Metric) # C⋅statC⁻¹ +$(charge(ESU,Metric)) + +julia> charge(Metric,SI2019) # C⋅C⁻¹ +$(charge(Metric,SI2019)) + +julia> charge(Hartree,SI2019) # C⋅𝘦⁻¹ +$(charge(Hartree,SI2019)) +``` +""" +@pure charge(U::UnitSystem,S::UnitSystem) = unit(sqrt((planckreduced(S)*permeability(U)*lightspeed(U)*rationalization(U)*lorentz(U)^2)/(planckreduced(U)*permeability(S)*lightspeed(S)*rationalization(S)*lorentz(S)^2))) + +""" +$(convertext(:current,"charge(U,S)/time(U,S)")) + +Flow of electric `charge` per `time` or `current` (A, C⋅s⁻¹), unit conversion factor. + +```Julia +julia> current(EMU,Metric) # A⋅Bi⁻¹ +$(current(EMU,Metric)) + +julia> current(EMU,ESU) # statA⋅Bi⁻¹ +$(current(EMU,ESU)) + +julia> current(ESU,Metric) # A⋅statA⁻¹ +$(current(ESU,Metric)) + +julia> current(Metric,SI2019) # A⋅A⁻¹ +$(current(Metric,SI2019)) +``` +""" +@pure current(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/time(U,S)) + +""" +$(convertext(:voltage,"energy(U,S)/charge(U,S)")) + +Electric potential difference or `energy` per `charge` (V, J⋅C⁻¹), unit conversion factor. + +```Julia +julia> voltage(EMU,Metric) # V⋅abV⁻¹ +$(voltage(EMU,Metric)) + +julia> voltage(EMU,ESU) # statV⋅abV⁻¹ +$(voltage(EMU,ESU)) + +julia> voltage(ESU,Metric) # V⋅statV⁻¹ +$(voltage(ESU,Metric)) + +julia> voltage(Metric,SI2019) # V⋅V⁻¹ +$(voltage(Metric,SI2019)) +``` +""" +@pure voltage(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/charge(U,S)) + +""" +$(convertext(:capacitance,"charge(U,S)/voltage(U,S)")) + +Electrical `capactiance` or `charge` per `voltage` (F, C⋅V⁻¹), unit conversion factor. + +```Julia +julia> capacitance(EMU,Metric) # F⋅abF⁻¹ +$(capacitance(EMU,Metric)) + +julia> capacitance(ESU,Metric) # F⋅statF⁻¹ +$(capacitance(ESU,Metric)) + +julia> capactiance(Metric,SI2019) # F⋅F⁻¹ +$(capacitance(Metric,SI2019)) +``` +""" +@pure capacitance(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/voltage(U,S)) + +""" +$(convertext(:impedance,"voltage(U,S)/current(U,S)")) + +Electrical `impedance` or `voltage` per `current` (Ω, S⁻¹, V⋅A⁻¹), unit conversion factor. + +```Julia +julia> impedance(EMU,Metric) # Ω⋅abΩ⁻¹ +$(impedance(EMU,Metric)) + +julia> impedance(ESU,Metric) # Ω⋅statΩ⁻¹ +$(impedance(ESU,Metric)) + +julia> impedance(Metric,SI2019) # Ω⋅Ω⁻¹ +$(impedance(Metric,SI2019)) +``` +""" +@pure impedance(U::UnitSystem,S::UnitSystem) = unit(voltage(U,S)/current(U,S)) + +""" +$(convertext(:conductance,"voltage(U,S)/current(U,S)")) + +Electrical `conductance` or `current` per `voltage` (S, Ω⁻¹, A⋅V⁻¹), unit conversion factor. + +```Julia +julia> conductance(EMU,Metric) # S⋅abS⁻¹ +$(conductance(EMU,Metric)) + +julia> conductance(ESU,Metric) # S⋅statS⁻¹ +$(conductance(ESU,Metric)) + +julia> conductance(Metric,SI2019) # S⋅S⁻¹ +$(conductance(Metric,SI2019)) +``` +""" +@pure conductance(U::UnitSystem,S::UnitSystem) = unit(current(U,S)/voltage(U,S)) + +""" +$(convertext(:magneticflux,"energy(U,S)/lorentz(U,S)/current(U,S)")) + +Surface `magneticflux` or `energy` per `current` (Wb, J⋅A⁻¹, V⋅s), unit conversion factor. + +```Julia +julia> magneticflux(EMU,Metric) # Wb⋅Mx⁻¹ +$(magneticflux(EMU,Metric)) + +julia> magneticflux(ESU,Metric) # Wb⋅statWb⁻¹ +$(magneticflux(ESU,Metric)) + +julia> magneticflux(Metric,SI2019) # Wb⋅Wb⁻¹ +$(magneticflux(Metric,SI2019)) +``` +""" +@pure magneticflux(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/lorentz(U,S)/current(U,S)) + +""" +$(convertext(:magneticinduction,"mass(U,S)/lorentz(U,S)/current(U,S)/time(U,S)^2")) + +Magnetic `magneticinduction` or `magneticflux` per `area` (T, Wb⋅m⁻²), unit conversion factor. + +```Julia +julia> magneticinduction(EMU,Metric) # T⋅G⁻¹ +$(magneticinduction(EMU,Metric)) + +julia> magneticinduction(EMU,ESU) # statT⋅G⁻¹ +$(magneticinduction(EMU,ESU)) + +julia> magneticinduction(Metric,SI2019) # T⋅T⁻¹ +$(magneticinduction(Metric,SI2019)) +``` +""" +@pure magneticinduction(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/lorentz(U,S)/current(U,S)/time(U,S)^2) + +""" +$(convertext(:inductance,"mass(U,S)*area(U,S)/charge(U,S)")) + +Electro-`magneticflux` per `current` or `inductance` (H, Ω⋅s, Wb⋅A⁻¹), unit conversion factor. + +```Julia +julia> inductance(EMU,Metric) # H⋅abH⁻¹ +$(inductance(EMU,Metric)) + +julia> inductance(ESU,Metric) # H⋅statH⁻¹ +$(inductance(ESU,Metric)) + +julia> inductance(Metric,SI2019) # H⋅H⁻¹ +$(inductance(Metric,SI2019)) +``` +""" +@pure inductance(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*area(U,S)/charge(U,S)^2) + +# electromagnetics + +""" +$(convertext(:electricinduction,"charge(U,S)/area(U,S)")) + +Electric field displacement or `electricinduction` (C⋅m⁻²), unit conversion factor. + +```Julia +julia> electricinduction(EMU,Metric) # C⋅cm²⋅abC⁻¹⋅m⁻² +$(electricinduction(EMU,Metric)) + +julia> electricinduction(ESU,Metric) # C⋅cm²⋅statC⁻¹⋅m⁼² +$(electricinduction(ESU,Metric)) + +julia> electricinduction(Metric,SI2019) # C⋅C⁻¹ +$(electricinduction(Metric,SI2019)) +``` +""" +@pure electricinduction(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/area(U,S)) + +""" +$(convertext(:chargedensity,"charge(U,S)/volume(U,S)")) + +Volume `chargedensity` or `charge` per `volume` (C⋅m⁻³), unit conversion factor. + +```Julia +julia> chargedensity(EMU,Metric) # C⋅cm³⋅abC⁻¹⋅m⁻³ +$(chargedensity(EMU,Metric)) + +julia> chargedensity(ESU,Metric) # C⋅cm³⋅statC⁻¹⋅m⁼³ +$(chargedensity(ESU,Metric)) + +julia> chargedensity(Metric,SI2019) # C⋅C⁻¹ +$(chargedensity(Metric,SI2019)) +``` +""" +@pure chargedensity(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/volume(U,S)) + +""" +$(convertext(:currentdensity,"current(U,S)/area(U,S)")) + +Cross-section `currentdensity` or `current` per `area` (A⋅m⁻²), unit conversion factor. + +```Julia +julia> currentdensity(EMU,Metric) # A⋅cm²⋅Bi⁻¹⋅m⁻² +$(currentdensity(EMU,Metric)) + +julia> currentdensity(ESU,Metric) # A⋅cm²⋅statA⁻¹⋅m⁼² +$(currentdensity(ESU,Metric)) + +julia> currentdensity(Metric,SI2019) # A⋅A⁻¹ +$(currentdensity(Metric,SI2019)) +``` +""" +@pure currentdensity(U::UnitSystem,S::UnitSystem) = unit(current(U,S)/area(U,S)) + +""" +$(convertext(:conductivity,"conductance(U,S)/length(U,S)")) + +Reciprocal `resistivity` or electrical `conductivity` (S⋅m⁻¹), unit conversion factor. + +```Julia +julia> conductivity(EMU,Metric) # S⋅cm⋅abS⁻¹⋅m⁻¹ +$(conductivity(EMU,Metric)) + +julia> conductivity(ESU,Metric) # S⋅cm⋅statS⁻¹⋅m⁼¹ +$(conductivity(ESU,Metric)) + +julia> conductivity(Metric,SI2019) # S⋅S⁻¹ +$(conductivity(Metric,SI2019)) +``` +""" +@pure conductivity(U::UnitSystem,S::UnitSystem) = unit(conductance(U,S)/length(U,S)) + +""" +$(convertext(:permittivity,"capacitance(U,S)*rationalization(U,S)/length(U,S)")) + +Absolute `permittivity` or `capacitance` per `length` (F⋅m⁻¹), unit conversion factor. + +```Julia +julia> permittivity(EMU,Metric) # F⋅cm⋅abF⁻¹⋅m⁻¹ +$(permittivity(EMU,Metric)) + +julia> permittivity(ESU,Metric) # F⋅cm⋅statF⁻¹⋅m⁼¹ +$(permittivity(ESU,Metric)) + +julia> permittivity(Metric,SI2019) # F⋅F⁻¹ +$(permittivity(Metric,SI2019)) +``` +""" +@pure permittivity(U::UnitSystem,S::UnitSystem) = unit(capacitance(U,S)*rationalization(U,S)/length(U,S)) + +@doc """ +$(convertext(:permeability,"permeability(S)/permeability(U)")) + +Magnetic `permeability` or `inductance` per `length` (H⋅m⁻¹), unit conversion factor. + +```Julia +julia> permeability(EMU,Metric) # H⋅cm⋅abH⁻¹⋅m⁻¹ +$(permeability(EMU,Metric)) + +julia> permeability(ESU,Metric) # H⋅cm⋅statH⁻¹⋅m⁼¹ +$(permeability(ESU,Metric)) + +julia> permeability(Metric,SI2019) # H⋅H⁻¹ +$(permeability(Metric,SI2019)) +``` +""" permeability(::UnitSystem,::UnitSystem) + +""" + electricfield # V⋅m⁻¹ +""" +@pure electricfield(U::UnitSystem,S::UnitSystem) = unit(voltage(U,S)/length(U,S)) + +""" +$(convertext(:magneticfield,"current(U,S)*rationalization(U,S)*lorentz(U,S)/length(U,S)")) + +Magnetization or `magneticfield` or `current` per `length` (A⋅m⁻¹), unit conversion factor. + +```Julia +julia> magneticfield(EMU,Metric) # A⋅m⁻¹⋅Oe⁻¹ +$(magneticfield(EMU,Metric)) + +julia> magneticfield(ESU,Metric) # A⋅cm⋅m⁻¹⋅statA⁻¹ +$(magneticfield(ESU,Metric)) + +julia> magneticfield(Metric,SI2019) # A⋅A⁻¹ +$(magneticfield(Metric,SI2019)) +``` +""" +@pure magneticfield(U::UnitSystem,S::UnitSystem) = unit(current(U,S)*rationalization(U,S)*lorentz(U,S)/length(U,S)) + +""" +$(convertext(:exposure,"charge(U,S)/mass(U,S)")) + +Ionizing radiation `exposure` or `charge` per `mass` (C⋅kg⁻¹), unit conversion factor. + +```Julia +julia> exposure(EMU,Metric) # C⋅g⋅abC⁻¹⋅kg +$(exposure(EMU,Metric)) + +julia> exposure(EMU,ESU) # statC⋅abC⁻¹ +$(exposure(EMU,ESU)) + +julia> expsure(ESU,Metric) # C⋅g⋅statC⁻¹⋅kg +$(exposure(ESU,Metric)) + +julia> exposure(Metric,SI2019) # C⋅C⁻¹ +$(exposure(Metric,SI2019)) +``` +""" +@pure exposure(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/mass(U,S)) + +""" +$(convertext(:resistivity,"impedance(U,S)*length(U,S)")) + +Electrical `resistivity` or `impedance` by `length` (Ω⋅m), unit conversion factor. + +```Julia +julia> impedance(EMU,Metric) # Ω⋅m⋅abΩ⁻¹⋅cm⁻¹ +$(impedance(EMU,Metric)) + +julia> impedance(ESU,Metric) # Ω⋅m⋅statΩ⁻¹⋅cm⁻¹ +$(impedance(ESU,Metric)) + +julia> impedance(Metric,SI2019) # Ω⋅Ω⁻¹ +$(impedance(Metric,SI2019)) +``` +""" +@pure resistivity(U::UnitSystem,S::UnitSystem) = unit(impedance(U,S)*length(U,S)) + +""" + linearchargedensity # C⋅m⁻¹ +$(convertext(:linearchargedensity,"charge(U,S)/length(U,S)")) + +Amount of `linearchargedensity` or `charge` per `length` (C⋅m⁻¹), unit conversion factor. + +```Julia +julia> linearchargedensity(EMU,Metric) # C⋅cm⋅abC⁻¹⋅m⁻¹ +$(linearchargedensity(EMU,Metric)) + +julia> linearchargedensity(ESU,Metric) # C⋅cm⋅statC⁻¹⋅m⁼¹ +$(linearchargedensity(ESU,Metric)) + +julia> linearchargedensity(Metric,SI2019) # C⋅C⁻¹ +$(linearchargedensity(Metric,SI2019)) +``` +""" +@pure linearchargedensity(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)/length(U,S)) + +""" +$(convertext(:magneticdipolemoment,"current(U,S)*lorentz(U,S)/area(U,S)")) + +Magnetic dipole moment or `magneticdipolemoment` (J⋅T⁻¹, A⋅m²), unit conversion factor. + +```Julia +julia> magneticdipolemoment(EMU,Metric) # J⋅G⋅T⁻¹⋅erg⁻¹ +$(magneticdipolemoment(EMU,Metric)) + +julia> magneticdipolemoment(ESU,Metric) # J⋅statT⋅T⁻¹⋅erg⁼¹ +$(magneticdipolemoment(ESU,Metric)) + +julia> magneticdipolemoment(Metric,SI2019) # A⋅A⁻¹⋅ +$(magneticdipolemoment(Metric,SI2019)) +``` +""" +@pure magneticdipolemoment(U::UnitSystem,S::UnitSystem) = unit(current(U,S)*lorentz(U,S)*area(U,S)) + +""" +$(convertext(:mobility,"charge(U,S)*time(U,S)/mass(U,S)")) + +Electron `mobility` in solid state physics (m²⋅V⁻¹⋅s⁻¹, A⋅s²⋅kg⁻¹), unit conversion factor. + +```Julia +julia> mobility(EMU,Metric) # C⋅g⋅abC⁻¹⋅kg +$(mobility(EMU,Metric)) + +julia> mobility(EMU,ESU) # statC⋅abC⁻¹ +$(mobility(EMU,ESU)) + +julia> mobility(ESU,Metric) # C⋅g⋅statC⁻¹⋅kg +$(mobility(ESU,Metric)) + +julia> mobility(Metric,SI2019) # C⋅C⁻¹ +$(mobility(Metric,SI2019)) +``` +""" +@pure mobility(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)*time(U,S)/mass(U,S)) + +""" +$(convertext(:reluctance,"1/inductance(U,S)")) + +Magnetic `reluctance` or magnetic resistance (H⁻¹), unit conversion factor. + +```Julia +julia> reluctance(EMU,Metric) # abH⋅H⁻¹ +$(reluctance(EMU,Metric)) + +julia> reluctance(ESU,Metric) # statH⋅H⁻¹ +$(reluctance(ESU,Metric)) + +julia> reluctance(Metric,SI2019) # H⋅H⁻¹ +$(reluctance(Metric,SI2019)) +``` +""" +@pure reluctance(U::UnitSystem,S::UnitSystem) = inductance(S,U) + +""" +$(convertext(:vectorpotential,"magneticflux(U,S)/length(U,S)")) + +Magnetic `vectorpotential` (Wb⋅m⁻¹), unit conversion factor. + +```julia +julia> vectorpotential(EMU,Metric) # Wb⋅cm⋅Mx⁻¹⋅m⁻¹ +$(vectorpotential(EMU,Metric)) + +julia> vectorpotential(ESU,Metric) # Wb⋅cm⋅statWb⁻¹⋅m⁻¹ +$(vectorpotential(ESU,Metric)) + +julia> vectorpotential(Metric,SI2019) # Wb⋅Wb⁻¹ +$(vectorpotential(Metric,SI2019)) +``` +""" +@pure vectorpotential(U::UnitSystem,S::UnitSystem) = unit(magneticflux(U,S)/length(U,S)) + +""" +$(convertext(:magneticmoment,"magneticflux(U,S)*length(U,S)")) + +Amount of `magneticmoment` or `magneticflux` by `length` (Wb⋅m), unit conversion factor. + +```Julia +julia> magneticmoment(EMU,Metric) # Wb⋅m⋅Mx⁻¹⋅cm⁻¹ +$(magneticmoment(EMU,Metric)) + +julia> magneticmoment(ESU,Metric) # Wb⋅m⋅statWb⁻¹⋅cm⁻¹ +$(magneticmoment(ESU,Metric)) + +julia> magneticmoment(Metric,SI2019) # Wb⋅Wb⁻¹ +$(magneticmoment(Metric,SI2019)) +``` +""" +@pure magneticmoment(U::UnitSystem,S::UnitSystem) = unit(magneticflux(U,S)*length(U,S)) + +""" +$(convertext(:rigidity,"magneticinduction(U,S)*length(U,S)")) + +Electromagnetic `rigidity` (T⋅m), unit conversion factor. + +```Julia +julia> rigidity(EMU,Metric) # T⋅m⋅G⁻¹⋅cm⁻¹ +$(rigidity(EMU,Metric)) + +julia> rigidity(EMU,ESU) # statT⋅G⁻¹ +$(rigidity(EMU,ESU)) + +julia> rigidity(Metric,SI2019) # T⋅T⁻¹ +$(rigidity(Metric,SI2019)) +``` +""" +@pure rigidity(U::UnitSystem,S::UnitSystem) = unit(magneticinduction(U,S)*length(U,S)) + +""" +$(convertext(:susceptibility,"1/permeability(U,S)")) + +Magnetic `susceptibility` or `length` per `inductance` (m⋅H⁻¹), unit conversion factor. + +```Julia +julia> susceptibility(EMU,Metric) # H⋅cm⋅abH⁻¹⋅m⁻¹ +$(susceptibility(EMU,Metric)) + +julia> susceptibility(ESU,Metric) # H⋅cm⋅statH⁻¹⋅m⁼¹ +$(susceptibility(ESU,Metric)) + +julia> susceptibility(Metric,SI2019) # H⋅H⁻¹ +$(susceptibility(Metric,SI2019)) +``` +""" +@pure susceptibility(U::UnitSystem,S::UnitSystem) = permeability(S,U) + +# WARNING unchecked: rigidity, magneticmoment, vectorpotential, reluctance, mobility, electricflux, linearchargedensity, exposure, currentdensity, chargedensity, conductivity + +# CGS extra + +""" +$(convertext(:electricflux,"voltage(U,S)*length(U,S)")) + +Amount of `electricflux` or `voltage` by `length` (V⋅m) # wikipedia CGS page has error ? + +```Julia +julia> electricflux(EMU,Metric) # V⋅m⋅abV⁻¹⋅cm⁻¹ +$(electricflux(EMU,Metric)) + +julia> electricflux(EMU,ESU) # statV⋅abV⁻¹ +$(electricflux(EMU,ESU)) + +julia> electricflux(ESU,Metric) # V⋅m⋅statV⁻¹⋅cm⁻¹ +$(electricflux(ESU,Metric)) + +julia> electricflux(Metric,SI2019) # V⋅V⁻¹ +$(electricflux(Metric,SI2019)) +``` +""" +@pure electricflux(U::UnitSystem,S::UnitSystem) = unit(voltage(U,S)*length(U,S)) + +""" +$(convertext(:electricdipolemoment,"charge(U,S)*length(U,S)")) + +Electric dipole moment or `electricdipolemoment` (C⋅m), unit conversion factor. + +```Julia +julia> electricdipolemoment(EMU,Metric) # C⋅m⋅abC⁻¹⋅cm⁻¹ +$(electricdipolemoment(EMU,Metric)) + +julia> electricdipolemoment(ESU,Metric) # C⋅m⋅statC⁻¹⋅cm⁼¹ +$(electricdipolemoment(ESU,Metric)) + +julia> electricdipolemoment(Metric,Gauss)/1e-18 # D⋅C⁻¹⋅m⁻¹ +$(electricdipolemoment(Metric,Gauss)/1e-18) + +julia> electricdipolemoment(Metric,SI2019) # C⋅C⁻¹⋅ +$(electricdipolemoment(Metric,SI2019)) +``` +""" +@pure electricdipolemoment(U::UnitSystem,S::UnitSystem) = unit(charge(U,S)*length(U,S)) diff --git a/src/kinematic.jl b/src/kinematic.jl new file mode 100644 index 0000000..24d3a9e --- /dev/null +++ b/src/kinematic.jl @@ -0,0 +1,771 @@ + +# This file is part of UnitSystems.jl. It is licensed under the MIT license +# UnitSystems Copyright (C) 2020 Michael Reed + +""" + kilograms(m::Real) = $(slug)m + +Converts mass `m` from slugs to kilogram (kg). +""" +@pure kilograms(m::Real,U::UnitSystem=English) = mass(m,Metric,U) + +""" + slugs(m::Real) = $(1/slug)m + +Converts mass `m` from kilograms to slugs (slug). +""" +@pure slugs(m::Real,U::UnitSystem=Metric) = mass(m,English,U) + +""" + feet(d) = $(1/ft)d + +Converts distance `d` from meters to feet (ft). +""" +@pure feet(d,U::UnitSystem=Metric) = length(d,English,U) + +""" + meters(d) = $(ft)d + +Converts distance `d` from feet to meters (m). +""" +@pure meters(d,U::UnitSystem=English) = length(d,Metric,U) + +# special exact cases + +# IAU to SI +@pure length(U::UnitSystem{kB,ħ,𝘤} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = length(U,S,1/au) +@pure time(U::UnitSystem{kB,ħ,𝘤} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = time(U,S,1/day) + +# SI to IAU +@pure length(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = length(U,S,au) +@pure time(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,𝘤} where {kB,ħ}) = time(U,S,day) + +# IAU to CGS +@pure length(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = length(U,S,1/au) +@pure time(::UnitSystem{kB,ħ,100𝘤} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = time(U,S,1/day) + +# CGS to IAU +@pure length(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = length(U,S,au) +@pure time(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,100𝘤} where {kB,ħ}) = time(U,S,day) + +# IAU to English +@pure length(U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = length(U,S,ft/au) +@pure time(U::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ},S::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ}) = time(U,S,1/day) + +# English to IAU +@pure length(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = length(U,S,au/ft) +@pure time(U::UnitSystem{kB,ħ,day*𝘤/au} where {kB,ħ},S::UnitSystem{kB,ħ,𝘤/ft} where {kB,ħ}) = time(U,S,day) + +# base unit conversions + +convertext(unit,fun) = """ +```Julia +$unit(U::UnitSystem,S::UnitSystem) = $fun +$unit(v::Real,U::UnitSystem,S::UnitSystem) = v/$unit(U,S) +``` +""" + +# derived unit conversions + +#@pure heatcapacity(U::UnitSystem,S::UnitSystem) = (boltzmann(S)/boltzmann(U))/volume(U,S) +#@pure acoustic(U::UnitSystem,S::UnitSystem) = (planckreduced(S)^3*electronmass(U)^2*lightspeed(U)^4)/(planckreduced(U)^3*electronmass(S)^2*lightspeed(S)^4) + +# spacetime + +@pure length(U::UnitSystem,S::UnitSystem,l=1) = unit((planckreduced(S)*electronmass(U)*lightspeed(U))/(planckreduced(U)*electronmass(S)*lightspeed(S)),l) +@doc """ +$(convertext(:length,"planck(U,S)/mass(U,S)/speed(U,S)")) + +Extent of one-dimensional shape or `length` (m), unit conversion factor. + +```Julia +julia> length(CGS,Metric) # m⋅cm⁻¹ +$(length(CGS,Metric)) + +julia> length(IAU,Metric) # m⋅au⁻¹ +$(length(IAU,Metric)) + +julia> length(English,Metric) # m⋅ft⁻¹ +$(length(English,Metric)) + +julia> length(EnglishUS,English) # ft⋅ftUS⁻¹ +$(length(EnglishUS,English)) + +julia> length(PlanckGauss,Metric) # m⋅ℓP⁻¹ +$(length(PlanckGauss,Metric)) +``` +""" length, ft, ftUS, au + +""" +$(convertext(:area,"length(U,S)^2")) + +Extent of two-dimensional shape or `area` (m²), unit conversion factor. + +```Julia +julia> area(CGS,Metric) # m²⋅cm⁻² +$(area(CGS,Metric)) + +julia> area(English,Metric) # m²⋅ft⁻² +$(area(English,Metric)) + +julia> area(EnglishUS,English) # ft²⋅ftUS⁻² +$(area(EnglishUS,English)) +``` +""" +@pure area(U::UnitSystem,S::UnitSystem) = unit(length(U,S)^2) + +""" +$(convertext(:volume,"length(U,S)^3")) + +Extent of three-dimensional shape or `volume` (m³), unit conversion factor. + +```Julia +julia> volume(CGS,Metric) # m³⋅cm⁻³ +$(volume(CGS,Metric)) + +julia> volume(English,Metric) # m³⋅ft⁻³ +$(volume(English,Metric)) + +julia> volume(EnglishUS,English) # ft³⋅ftUS⁻³ +$(volume(EnglishUS,English)) +``` +""" +@pure volume(U::UnitSystem,S::UnitSystem) = unit(length(U,S)^3) + +""" +$(convertext(:wavenumber,"1/length(U,S)")) + +Number of occurences per unit of space (m⁻¹), unit conversion factor. + +```Julia +julia> wavenumber(CGS,Metric) # cm⋅m⁻¹ +$(wavenumber(CGS,Metric)) + +julia> wavenumber(English,Metric) # ft⋅m⁻¹ +$(wavenumber(English,Metric)) +``` +""" +@pure wavenumber(U::UnitSystem,S::UnitSystem) = unit(length(S,U)) + +""" +$(convertext(:fuelefficiency,"1/area(U,S)")) + +Distance per volume or `fuelefficiency` (m⋅m⁻³, m⁻²), unit conversion factor. + +```Julia +julia> fuelefficiency(CGS,Metric) # cm²⋅m⁻² +$(fuelefficiency(CGS,Metric)) + +julia> fuelefficiency(English,Metric) # ft²⋅m⁻² +$(fuelefficiency(English,Metric)) +``` +""" +@pure fuelefficiency(U::UnitSystem,S::UnitSystem) = area(S,U) + +@pure time(U::UnitSystem,S::UnitSystem,t=1) = unit(length(U,S)/lightspeed(U,S),1) +@doc """ +$(convertext(:time,"length(U,S)/speed(U,S)")) + +Dimension along which events are ordered or `time` (s), unit conversion factor. + +```Julia +julia> time(IAU,Metric) # s⋅day⁻¹ +$(time(IAU,Metric)) + +julia> time(PlanckGauss,Metric) # s⋅tP⁻¹ +$(time(PlanckGauss,Metric)) +``` +""" time, day + +""" +$(convertext(:frequency,"1/time(U,S)")) + +Number of occurences per unit of time (Hz or s⁻¹), unit conversion factor. + +```Julia +julia> frequency(IAU,Metric) day⋅s⁻¹ +$(frequency(IAU,Metric)) +``` +""" +@pure frequency(U::UnitSystem,S::UnitSystem) = time(S,U) + +""" +$(convertext(:frequencydrift,"1/time(U,S)^2")) + +Drift of `frequency` per `time` or `frequencydrift` (Hz⋅s⁻¹, s⁻²), unit conversion factor. +```Julia +julia> frequencydrift(IAU,Metric) day²⋅Hz⋅s⁻¹ +$(frequencydrift(IAU,Metric)) +``` +""" +@pure frequencydrift(U::UnitSystem,S::UnitSystem) = unit(time(S,U)^2) + +""" +$(convertext(:speed,"lightspeed(S)/lightspeed(U)")) + +Velocity or `length` per `time` or `speed` (m⋅s⁻¹), unit conversion factor. + +```Julia +julia> speed(CGS,Metric) # m⋅cm⁻¹ +$(speed(CGS,Metric)) + +julia> speed(IAU,Metric) # m⋅day⋅s⁻¹⋅au⁻¹ +$(speed(IAU,Metric)) + +julia> speed(English,Metric) # m⋅ft⁻¹ +$(speed(English,Metric)) + +julia> speed(EnglishUS,English) # ft⋅ftUS⁻¹ +$(speed(EnglishUS,English)) +``` +""" +@pure speed(U::UnitSystem,S::UnitSystem) = lightspeed(U,S) + +@doc """ +$(convertext(:acceleration,"speed(U,S)/time(U,S)")) + +Specific force or `speed` per `time` or `acceleration` (m⋅s⁻²), unit conversion factor. + +```Julia +julia> acceleration(CGS,Metric) # m⋅s⁻¹⋅gal⁻¹ +$(acceleration(CGS,Metric)) + +julia> acceleration(IAU,Metric) # m⋅day²⋅s⁻²⋅au⁻¹ +$(acceleration(IAU,Metric)) + +julia> acceleration(English,Metric) # m⋅ft⁻¹ +$(acceleration(English,Metric)) + +julia> acceleration(EnglishUS,English) # ft⋅ftUS⁻¹ +$(acceleration(EnglishUS,English)) +``` +""" +@pure acceleration(U::UnitSystem,S::UnitSystem) = unit(speed(U,S)/time(U,S)) + +""" +$(convertext(:jerk,"speed(U,S)/time(U,S)^2")) + +Jolt or `acceleration` per `time` or `jerk` (m⋅s⁻³), unit conversion factor. + +```Julia +julia> jerk(CGS,Metric) # m⋅cm⁻¹ +$(jerk(CGS,Metric)) + +julia> jerk(IAU,Metric) # m⋅day³⋅s⁻³⋅au⁻¹ +$(jerk(IAU,Metric)) + +julia> jerk(English,Metric) # m⋅ft⁻¹ +$(jerk(English,Metric)) + +julia> jerk(EnglishUS,English) # ft⋅ftUS⁻¹ +$(jerk(EnglishUS,English)) +``` +""" +@pure jerk(U::UnitSystem,S::UnitSystem) = unit(speed(U,S)/time(U,S)^2) + +""" +$(convertext(:snap,"speed(U,S)/time(U,S)^3")) + +Jounce or `jerk` per `time` or `snap` (m⋅s⁻⁴), unit conversion factor. + +```Julia +julia> snap(CGS,Metric) # m⋅cm⁻¹ +$(snap(CGS,Metric)) + +julia> snap(IAU,Metric) # m⋅day⁴⋅s⁻⁴⋅au⁻¹ +$(snap(IAU,Metric)) + +julia> snap(English,Metric) # m⋅ft⁻¹ +$(snap(English,Metric)) + +julia> snap(EnglishUS,English) # ft⋅ftUS⁻¹ +$(snap(EnglishUS,English)) +``` +""" +@pure snap(U::UnitSystem,S::UnitSystem) = unit(speed(U,S)/time(U,S)^3) + +""" +$(convertext(:volumeflow,"area(U,S)*speed(U,S)")) + +Volumetric flow rate or `volumeflow` (m³⋅s⁻¹), unit conversion factor. + +```Julia +julia> volumeflow(CGS,Metric) # m³⋅cm⁻³ +$(volume(CGS,Metric)) + +julia> volumeflow(English,Metric) # m³⋅ft⁻³ +$(volume(English,Metric)) + +julia> volumeflow(EnglishUS,English) # ft³⋅ftUS⁻³ +$(volume(EnglishUS,English)) +``` +""" +@pure volumeflow(U::UnitSystem,S::UnitSystem) = unit(area(U,S)*speed(U,S)) + +""" +$(convertext(:specificenergy,"speed(U,S)^2")) + +Massic energy or `energy` per `mass` or `specificenergy` (J⋅kg⁻¹), unit conversion factor. + +```Julia +julia> specificenergy(CGS,Metric) # m²⋅cm⁻² +$(specificenergy(CGS,Metric)) + +julia> specificenergy(IAU,Metric) # m²⋅day²⋅s⁻²⋅au⁻² +$(specificenergy(IAU,Metric)) + +julia> specificenergy(English,Metric) # m²⋅ft⁻² +$(specificenergy(English,Metric)) + +julia> specificenergy(EnglishUS,English) # ft²⋅ftUS⁻² +$(specificenergy(EnglishUS,English)) +``` +""" +@pure specificenergy(U::UnitSystem,S::UnitSystem) = unit(speed(U,S)^2) + +# kinematic + +@doc """ +$(convertext(:mass,"electronmass(S)/electronmass(U)")) + +Inertal `mass` or resitance to aceleration or quantity of matter (kg), unit conversion factor. + +```Julia +julia> mass(CGS,Metric) # kg⋅g⁻¹ +$(mass(CGS,Metric)) + +julia> mass(CODATA,Metric) # kg⋅kg⁻¹ +$(mass(CODATA,Metric)) + +julia> mass(Conventional,Metric) # kg⋅kg⁻¹ +$(mass(Conventional,Metric)) + +julia> mass(English,Metric) # kg⋅slug⁻¹ +$(mass(English,Metric)) + +julia> mass(IAU,Metric) # kg⋅m⊙⁻¹ +$(mass(IAU,Metric)) + +julia> mass(PlanckGauss,Metric) # kg⋅mP⁻¹ +$(mass(PlanckGauss,Metric)) +``` +""" mass, slug, mₛ + +@pure energy(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*specificenergy(U,S)) +""" +$(convertext(:energy,"mass(U,S)*specificenergy(U,S)")) + +Work or heat or `energy` (J, N⋅m, kg⋅m²⋅s⁻²), unit conversion factor. + +```Julia +julia> energy(CGS,Metric) # J⋅erg⁻¹ +$(energy(CGS,Metric)) + +julia> energy(CGS,English) # ft⋅lb⋅erg⁻¹ +$(energy(CGS,English)) + +julia> energy(English,Metric) # J⋅ft⁻¹⋅lb⁻¹ +$(energy(English,Metric)) + +julia> 0.001/3600 # J⋅kW⁻¹⋅h⁻¹ +$(0.001/3600) + +julia> 1/kcal # J⋅kcalₜₕ⁻¹ +$(1/kcal) + +julia> 1/BTUJ # J⋅BTU⁻¹ +$(1/1055.036345118633) + +julia> 1/charge(SI2019) # J⋅eV⁻¹ +$(1/charge(SI2019)) +``` +""" energy, cal, kcal, BTUJ, BTUftlb + +""" +$(convertext(:power,"energy(U,S)/time(U,S))")) + +Radiant flux or `power` or `energy` per `time` (W, J⋅s⁻¹, kg⋅m²⋅s⁻³), unit conversion factor. + +```Julia +julia> power(CGS,Metric) # W⋅s⋅erg⁻¹ +$(power(CGS,Metric)) + +julia> power(English,Metric) # W⋅s⋅ft⁻¹⋅lb⁻¹ +$(power(English,Metric)) +``` +""" +@pure power(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/time(U,S)) + +@pure force(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*acceleration(U,S)) +""" +$(convertext(:force,"mass(U,S)*acceleration(U,S)")) + +Weight or force or `mass` times `acceleration` (N, kg⋅m⋅s⁻²), unit conversion factor. + +```Julia +julia> force(CGS,Metric) # N⋅dyn⁻¹ +$(force(CGS,Metric)) + +julia> force(CGS,English) # lb⋅dyn⁻¹ +$(force(CGS,English)) + +julia> force(English,Metric) # N⋅lb⁻¹ +$(force(English,Metric)) + +julia> force(1/lbm,Metric,English) # pdl⋅N⁻¹ +$(force(1/lbm,Metric,English)) + +julia> g₀ # kp⋅N⁻¹ +$g₀ +``` +""" force, g₀, g0, lbm + +@pure pressure(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/length(U,S)/time(U,S)^2) +@doc """ +$(convertext(:pressure,"energy(U,S)/volume(U,S)")) + +Pressure or stress or `force` per `area` (Pa, N⋅m⁻², kg⋅m⁻¹⋅s⁻²), unit conversion factor. + +```Julia +julia> pressure(CGS,Metric) # Pa⋅Ba⁻¹ +$(pressure(CGS,Metric)) + +julia> 1/atm # Pa⋅atm⁻¹ +$(1/atm) + +julia> pressure(English,Metric) # Pa⋅ft²⋅lb⁻¹ +$(pressure(English,Metric)) + +julia> pressure(Metric,English)/12^2 # psi⋅Pa⁻¹ +$(pressure(Metric,English)/12^2) +``` +""" pressure, atm + +# mechanical + +""" +$(convertext(:momentum,"mass(U,S)*speed(U,S)")) + +Linear `momentum` or `mass` times `speed` (N⋅s, kg⋅m⋅s⁻¹), unit conversion factor. + +```Julia +julia> momentum(CGS,Metric) # N⋅dyn⁻¹ +$(momentum(CGS,Metric)) + +julia> momentum(CGS,English) # lb⋅dyn⁻¹ +$(momentum(CGS,English)) + +julia> momentum(English,Metric) # N⋅lb⁻¹ +$(momentum(English,Metric)) +``` +""" +@pure momentum(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*speed(U,S)) + +""" +$(convertext(:angularmomentum,"momentum(U,S)*length(U,S)")) + +Rotational momentum or `angularmomentum` (N⋅m⋅s, kg⋅m²⋅s⁻¹), unit conversion factor. + +```Julia +julia> momentum(CGS,Metric) # N⋅m⋅dyn⁻¹⋅cm⁻¹ +$(momentum(CGS,Metric)) + +julia> momentum(CGS,English) # lb⋅ft⋅dyn⁻¹⋅cm⁻¹ +$(momentum(CGS,English)) + +julia> momentum(English,Metric) # N⋅m⋅lb⁻¹⋅ft⁻¹ +$(momentum(English,Metric)) +``` +""" +@pure angularmomentum(U::UnitSystem,S::UnitSystem) = unit(momentum(U,S)*length(U,S)) + +""" +$(convertext(:yank,"mass(U,S)*jerk(U,S)")) + +Rate of change of `force` or `yank` (N⋅s⁻¹, kg⋅m⋅s⁻³), unit conversion factor. + +```Julia +julia> yank(CGS,Metric) # N⋅dyn⁻¹ +$(yank(CGS,Metric)) + +julia> yank(CGS,English) # lb⋅dyn⁻¹ +$(yank(CGS,English)) + +julia> yank(English,Metric) # N⋅lb⁻¹⋅ +$(yank(English,Metric)) +``` +""" +@pure yank(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*jerk(U,S)) + +""" +$(convertext(:areadensity,"mass(U,S)/area(U,S)")) + +Surface or `areadensity` or `mass` per `area` (kg⋅m⁻²), unit conversion factor. + +```Julia +julia> areadensity(CGS,Metric) # kg⋅cm²⋅g⁻¹⋅m⁻² +$(areadensity(CGS,Metric)) + +julia> areadensity(CGS,English) # slug⋅cm²⋅g⁻¹⋅ft⁻² +$(areadensity(CGS,English)) + +julia> areadensity(English,Metric) # kg⋅ft²⋅slug⁻¹⋅m⁻² +$(areadensity(English,Metric)) +``` +""" +@pure areadensity(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/area(U,S)) + +""" +$(convertext(:density,"mass(U,S)/volume(U,S)")) + +Specific mass or `mass` per `volume` or `density` (kg⋅m⁻³), unit conversion factor. + +```Julia +julia> density(CGS,Metric) # kg⋅cm³⋅g⁻¹⋅m⁻³ +$(density(CGS,Metric)) + +julia> density(CGS,English) # slug⋅cm³⋅g⁻¹⋅ft⁻³ +$(density(CGS,English)) + +julia> density(English,Metric) # kg⋅ft³⋅slug⁻¹⋅m⁻³ +$(density(English,Metric)) +``` +""" +@pure density(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/volume(U,S)) + +""" +$(convertext(:specificvolume,"volume(U,S)/mass(U,S)")) + +Reciprocal `density` or `volume` per `mass` or `specificvolume` (m³⋅kg), unit conversion factor. + +```Julia +julia> specificvolume(CGS,Metric) # g⋅m³⋅kg⁻¹⋅cm⁻³ +$(specificvolume(CGS,Metric)) + +julia> specificvolume(CGS,English) # kg⋅ft³⋅slug⁻¹⋅cm⁻³ +$(specificvolume(CGS,English)) + +julia> specificvolume(English,Metric) # slug⋅m³⋅kg⁻¹⋅ft⁻³ +$(specificvolume(English,Metric)) +``` +""" +@pure specificvolume(U::UnitSystem,S::UnitSystem) = unit(volume(U,S)/mass(U,S)) + +""" +$(convertext(:action,"energy(U,S)*time(U,S)")) + +Integrated `momentum` over `length` or `action` (J⋅s, N⋅m⋅s), unit conversion factor. + +```Julia +julia> action(CGS,Metric) # J⋅erg⁻¹ +$(action(CGS,Metric)) + +julia> action(CGS,English) # ft⋅lb⋅erg⁻¹ +$(action(CGS,English)) + +julia> action(English,Metric) # J⋅ft⁻¹⋅lb⁻¹ +$(action(English,Metric)) +``` +""" +@pure action(U::UnitSystem,S::UnitSystem) = unit(momentum(U,S)*length(U,S)) + +""" +$(convertext(:stiffness,"energy(U,S)/area(U,S)")) + +Amount of `force` per `length` or `stiffness` (N⋅m⁻¹, J⋅m⁻², kg⋅s⁻²), unit conversion factor. + +```Julia +julia> stiffness(CGS,Metric) # kg⋅g⁻¹ +$(stiffness(CGS,Metric)) + +julia> stiffness(CGS,English) # slug⋅g⁻¹ +$(stiffness(CGS,English)) + +julia> stiffness(English,Metric) # kg⋅slug⁻¹ +$(stiffness(English,Metric)) +``` +""" +@pure stiffness(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/area(U,S)) + +""" +$(convertext(:irradiance,"power(U,S)/area(U,S)")) + +Heat flux density or `power` per `area` or `irradiance` (W⋅m⁻², kg⋅s⁻³), unit conversion factor. + +```Julia +julia> irradiance(CGS,Metric) # kg⋅g⁻¹ +$(irradiance(CGS,Metric)) + +julia> irradiance(CGS,English) # slug⋅g⁻¹ +$(irradiance(CGS,English)) + +julia> irradiance(English,Metric) # kg⋅slug⁻¹ +$(irradiance(English,Metric)) +``` +""" +@pure irradiance(U::UnitSystem,S::UnitSystem) = unit(power(U,S)/area(U,S)) + +""" +$(convertext(:diffusivity,"planck(U,S)/mass(U,S)")) + +Thermal `diffusivity` or kinematic viscostiy (m²⋅s⁻¹), unit conversion factor. + +```Julia +julia> diffusivity(CGS,Metric) # m²⋅cm⁻² +$(diffusivity(CGS,Metric)) + +julia> diffusivity(English,Metric) # m²⋅ft⁻² +$(diffusivity(English,Metric)) + +julia> diffusivity(EnglishUS,English) # ft²⋅ftUS⁻² +$(diffusivity(EnglishUS,English)) +``` +""" +@pure diffusivity(U::UnitSystem,S::UnitSystem) = unit((planckreduced(S)*electronmass(U))/(planckreduced(U)*electronmass(S))) + +""" +$(convertext(:viscosity,"mass(U,S)/length(U,S)/time(U,S)^2")) + +Resistance to deformation or `viscosity` (Pa⋅s, kg⋅m⁻¹⋅s⁻¹), unit conversion factor. + +```Julia +julia> viscosity(CGS,Metric) # Pa⋅Ba⁻¹ +$(viscosity(CGS,Metric)) + +julia> viscosity(English,Metric) # Pa⋅ft²⋅lb⁻¹ +$(viscosity(English,Metric)) +``` +""" +@pure viscosity(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/length(U,S)/time(U,S)) + +""" +$(convertext(:lineardensity,"mass(U,S)/length(U,S)")) + +Amount of `lineardensity` or `mass` per `length` (kg⋅m⁻¹), unit conversion factor. + +```Julia +julia> lineardensity(CGS,Metric) # kg⋅cm¹⋅g⁻¹⋅m⁻¹ +$(lineardensity(CGS,Metric)) + +julia> lineardensity(CGS,English) # slug⋅cm¹⋅g⁻¹⋅ft⁻¹ +$(lineardensity(CGS,English)) + +julia> lineardensity(English,Metric) # kg⋅ft¹⋅slug⁻¹⋅m⁻¹ +$(lineardensity(English,Metric)) +``` +""" +@pure lineardensity(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/length(U,S)) + +""" +$(convertext(:massflow,"mass(U,S)/time(U,S)")) + +Rate of `massflow` or `mass` per `time` (kg⋅s⁼¹), unit conversion factor. + +```Julia +julia> massflow(CGS,Metric) # kg⋅g⁻¹ +$(massflow(CGS,Metric)) + +julia> massflow(CODATA,Metric) # kg⋅kg⁻¹ +$(massflow(CODATA,Metric)) + +julia> massflow(Conventional,Metric) # kg⋅kg⁻¹ +$(massflow(Conventional,Metric)) + +julia> massflow(English,Metric) # kg⋅slug⁻¹ +$(massflow(English,Metric)) +``` +""" +@pure massflow(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)/time(U,S)) + +""" +$(convertext(:radiantflux,"power(U,S)/length(U,S)")) + +Spectral power or `radiantflux` (W⋅m⁻¹), unit conversion factor. + +```Julia +julia> radiantflux(CGS,Metric) # kg⋅m⋅g⁻¹⋅cm⁻¹ +$(radiantflux(CGS,Metric)) + +julia> radiantflux(CGS,English) # slug⋅ft⋅g⁻¹⋅cm⁻¹ +$(radiantflux(CGS,English)) + +julia> radiantflux(English,Metric) # kg⋅m⋅slug⁻¹⋅ft⁻¹ +$(radiantflux(English,Metric)) +``` +""" +@pure radiantflux(U::UnitSystem,S::UnitSystem) = unit(power(U,S)/length(U,S)) + +""" +$(convertext(:powerdensity,"power(U,S)/volume(U,S)")) + +Spectral irradiance (volume) or `powerdensity` (W⋅m⁻³), unit conversion factor. + +```Julia +julia> powerdensity(CGS,Metric) # kg⋅cm⋅g⁻¹⋅m⁻¹ +$(powerdensity(CGS,Metric)) + +julia> powerdensity(CGS,English) # slug⋅cm⋅g⁻¹⋅ft⁻¹ +$(powerdensity(CGS,English)) + +julia> powerdensity(English,Metric) # kg⋅ft⋅slug⁻¹⋅m⁻¹ +$(powerdensity(English,Metric)) +``` +""" +@pure powerdensity(U::UnitSystem,S::UnitSystem) = unit(power(U,S)/volume(U,S)) + +""" +$(convertext(:compressibility,"1/pressure(U,S)")) + +Relative volume change or `compressibility` (Pa⁻¹), unit conversion factor. + +```Julia +julia> compressibility(CGS,Metric) # Ba⋅Pa⁻¹ +$(compressibility(CGS,Metric)) + +julia> compressibility(English,Metric) # lb⋅ft⁻²⋅Pa⁻¹ +$(compressibility(English,Metric)) + +julia> compressibility(Metric,English)/12^2 # Pa⋅psi⁻¹ +$(compressibility(Metric,English)/12^2) +``` +""" +@pure compressibility(U::UnitSystem,S::UnitSystem) = pressure(S,U) + +""" +$(convertext(:fluence,"energy(U,S)/area(U,S")) + +Radiant exposure or `energy` per `area` or `fluence` (J⋅m⁻²), unit conversion factor. + +```Julia +julia> fluence(CGS,Metric) # kg⋅g⁻¹ +$(mass(CGS,Metric)) + +julia> fluence(CODATA,Metric) # kg⋅kg⁻¹ +$(mass(CODATA,Metric)) + +julia> fluence(Conventional,Metric) # kg⋅kg⁻¹ +$(fluence(Conventional,Metric)) + +julia> fluence(English,Metric) # kg⋅slug⁻¹ +$(fluence(English,Metric)) +``` +""" +@pure fluence(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/area(U,S)) + +""" +$(convertext(:rotationalinertia,"mass(U,S)*area(U,S)")) + +Moment of inertia or `rotationalinertia` (kg⋅m²), unit conversion factor. + +```Julia +julia> rotationalinertia(CGS,Metric) # kg⋅m²⋅g⁻¹⋅cm⁻² +$(rotationalinertia(CGS,Metric)) + +julia> rotationalinertia(CGS,English) # slug⋅ft²⋅g⁻¹⋅cm⁻² +$(rotationalinertia(CGS,English)) + +julia> rotationalinertia(English,Metric) # kg⋅m²⋅slug⁻¹⋅ft⁻² +$(rotationalinertia(English,Metric)) +``` +""" +@pure rotationalinertia(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*area(U,S)) diff --git a/src/physics.jl b/src/physics.jl index 35992c7..69cedac 100644 --- a/src/physics.jl +++ b/src/physics.jl @@ -2,6 +2,65 @@ # This file is part of UnitSystems.jl. It is licensed under the MIT license # UnitSystems Copyright (C) 2020 Michael Reed +@doc """ + μₑᵤ, μₚᵤ, μₚₑ, αinv, αG + +Physical measured dimensionless values with uncertainty are the electron to proton mass ratio `μₑᵤ`, proton to atomic mass ratio `μₚᵤ`, proton to electron mass ratio `μₚₑ`, inverted fine structure constant `αinv`, and the gravitaional coupling constant `αG`. + +```Julia +julia> μₑᵤ +$μₑᵤ + +julia> μₚᵤ +$μₚᵤ + +julia> μₚₑ +$μₚₑ + +julia> αinv +$αinv + +julia> αG +$αG +``` +""" μₑᵤ, μₚᵤ, μₚₑ, αinv, αG, meu, mpu, mpe, ainv, aG + +@pure hyperfine(U::UnitSystem) = frequency(ΔνCs,U) +@doc """ + hyperfine(U::UnitSystem) = frequency($ΔνCs,U) + +Unperturbed groundstate hyperfine transition frequency `ΔνCs` of caesium-133 atom (Hz). +```Julia +julia> hyperfine(Metric) # Hz +$(hyperfine(Metric)) +``` +""" hyperfine, ΔνCs + +@doc """ +```Julia +luminousefficacy(U::UnitSystem{1}) = 1 +luminousefficacy(U::UnitSystem) = $(Kcd)power(U) +``` + +Luminous efficacy of monochromatic radiation `Kcd` of frequency 540 THz (lm⋅W⁻¹). +```Julia +julia> luminousefficacy(Metric) # lm⋅W⁻¹ +$(luminousefficacy(Metric)) + +julia> luminousefficacy(CODATA) # lm⋅W⁻¹ +$(luminousefficacy(CODATA)) + +julia> luminousefficacy(Conventional) # lm⋅W⁻¹ +$(luminousefficacy(Conventional)) + +julia> luminousefficacy(CGS) # lm⋅s⋅erg⁻¹ +$(luminousefficacy(CGS)) + +julia> luminousefficacy(English) # lm⋅s³⋅slug⋅ft⁻² +$(luminousefficacy(English)) +``` +""" luminousefficacy, Kcd + @doc """ molarmass(U::UnitSystem) = avogadro(U)*electronmass(U)/μₑᵤ # 1/μₑᵤ = $(1/μₑᵤ-2e-13) @@ -18,11 +77,8 @@ $(molarmass(Metric)) julia> molarmass(SI2019) # kg⋅mol⁻¹ $(molarmass(SI2019)) - -julia> molarmass(English) # slug⋅slug-mol⁻¹ -$(molarmass(English)) ``` -""" molarmass, Mᵤ +""" molarmass, Mᵤ, Mu @pure avogadro(U::UnitSystem) = μₑᵤ*molarmass(U)/electronmass(U) @doc """ @@ -127,8 +183,8 @@ $(boltzmann(CGS)) julia> boltzmann(SI2019)/calᵢₜ # calᵢₜ⋅K⁻¹ $(boltzmann(SI2019)/calᵢₜ) -julia> boltzmann(SI2019)/rankine/calᵢₜ # calᵢₜ⋅°R⁻¹ -$(boltzmann(SI2019)/rankine/calᵢₜ) +julia> boltzmann(SI2019)*rankine/calᵢₜ # calᵢₜ⋅°R⁻¹ +$(boltzmann(SI2019)*rankine/calᵢₜ) julia> boltzmann(English) # ft⋅lb⋅°R⁻¹ $(boltzmann(English)) @@ -145,7 +201,7 @@ $(10log10(boltzmann(SI2019))) """ boltzmann, kB @doc """ - lightspeed(U::UnitSystem) = 1/sqrt(permeability(U)*permittivity(U)) + lightspeed(U::UnitSystem) = 1/sqrt(permeability(U)*permittivity(U)*lorentz(U)^2) Speed of light in a vacuum `𝘤` for massless particles (m⋅s⁻¹ or ft⋅s⁻¹). @@ -159,14 +215,11 @@ $(lightspeed(English)) """ lightspeed, 𝘤, cc @doc """ - permeability(U::UnitSystem) = 1/permittivity(U)/lightspeed(U) + permeability(U::UnitSystem) = 1/permittivity(U)/(lightspeed(U)*lorentz(U))^2 Magnetic permeability in a classical vacuum defined as `μ₀` in SI units (H⋅m⁻¹, kg⋅m²⋅C⁻²). ```Julia -julia> permeability(CGS) # abhenry⋅cm⁻¹ -$(permeability(CGS)) - julia> permeability(Metric) # H⋅m⁻¹ $(permeability(Metric)) @@ -178,9 +231,46 @@ $(permeability(CODATA)) julia> permeability(SI2019) # H⋅m⁻¹ $(permeability(SI2019)) + +julia> permeability(EMU) # abH⋅cm⁻¹ +$(permeability(EMU)) + +julia> permeability(ESU) # statH⋅cm⁻¹ +$(permeability(ESU)) ``` """ permeability, μ₀, m0 +@doc """ + lorentz(U::UnitSystem) = 4π*biotsavart(U)/permeability(U)/rationalization(U) + +Electromagnetic proportionality constant `αL` for the Lorentz's law force (?). + +```Julia +julia> lorentz(Metric) +$(lorentz(Metric)) + +julia> lorentz(Thomson) +$(lorentz(Thomson)) + +julia> lorentz(Gauss) +$(lorentz(Gauss)) +``` +""" lorentz, αL, aL + +@doc """ + rationalization(U::UnitSystem) = 4π*biotsavart(U)/permeability(U)/lorentz(U) + +Constant of magnetization and polarization density or `4π*coulomb(U)*permittivity(U)` (?). + +```Julia +julia> rationalization(Metric) +$(rationalization(Metric)) + +julia> rationalization(Gauss) +$(rationalization(Gauss)) +``` +""" rationalization + @doc """ electronmass(U::UnitSystem) = protonmass(U)/$μₚₑ # αinv^2*R∞*2𝘩/𝘤 @@ -285,7 +375,7 @@ $(newton(English)) @doc """ einstein(U::UnitSystem) = 8π*newton(U)/lightspeed(U)^4 -Einstein's gravitational constant from the Einstein field equations (? or ?). +Einstein's gravitational constant from the Einstein field equations (s⋅²⋅m⁻¹⋅kg⁻¹). ```Julia julia> einstein(Metric) # s⋅²⋅m⁻¹⋅kg⁻¹ $(einstein(Metric)) @@ -363,9 +453,9 @@ $(radiationdensity(English)) """ @pure radiationdensity(U::UnitSystem) = 4stefan(U)/lightspeed(U) -@pure permittivity(U::UnitSystem) = inv(permeability(U)*lightspeed(U)^2) +@pure permittivity(U::UnitSystem) = inv(permeability(U)*(lightspeed(U)*lorentz(U))^2) @doc """ - permittivity(U::UnitSystem) = 1/permeability(U)/lightspeed(U)^2 + permittivity(U::UnitSystem) = 1/permeability(U)/(lightspeed(U)*lorentz(U))^2 Dielectric permittivity constant `ε₀` of a classical vacuum (C²⋅N⁻¹⋅m⁻²). @@ -382,14 +472,20 @@ $(permittivity(CODATA)) julia> permittivity(SI2019) # F⋅m⁻¹ $(permittivity(SI2019)) +julia> permittivity(EMU) # abF⋅cm⁻¹ +$(permittivity(EMU)) + +julia> permittivity(ESU) # statF⋅cm⁻¹ +$(permittivity(ESU)) + julia> permittivity(SI2019)/charge(SI2019) # 𝘦²⋅eV⁻¹⋅m⁻¹ $(permittivity(SI2019)/charge(SI2019)) ``` -""" permittivity, ε₀, e0 +""" permittivity, ε₀, ϵ₀, e0 -@pure coulomb(U::UnitSystem) = inv(4π*permittivity(U)) +@pure coulomb(U::UnitSystem) = rationalization(U)/4π/permittivity(U) @doc """ - coulomb(U::UnitSystem) = 1/4π/permittivity(U) + coulomb(U::UnitSystem) = rationalization(U)/4π/permittivity(U) Electrostatic proportionality constant `kₑ` for the Coulomb's law force (N⋅m²⋅C⁻²). @@ -397,22 +493,91 @@ Electrostatic proportionality constant `kₑ` for the Coulomb's law force (N⋅m julia> coulomb(Metric) # N⋅m²⋅C⁻² $(coulomb(Metric)) -julia> coulomb(Metric)/lightspeed(Metric)^2 # (N·s²⋅C⁻²)⋅𝘤² -$(coulomb(Metric)/lightspeed(Metric)^2) +julia> coulomb(CODATA) # N·m²⋅C⁻² +$(coulomb(CODATA)) -julia> coulomb(Conventional)/lightspeed(Conventional)^2 # (N·s²⋅C⁻²)⋅𝘤² -$(coulomb(Conventional)/lightspeed(Conventional)^2) +julia> coulomb(SI2019) # N·m²⋅C⁻² +$(coulomb(SI2019)) -julia> coulomb(CODATA)/lightspeed(CODATA)^2 # (N·s²⋅C⁻²)⋅𝘤² -$(coulomb(CODATA)/lightspeed(CODATA)^2) +julia> coulomb(Conventional) # N·m²⋅C⁻² +$(coulomb(Conventional)) -julia> coulomb(SI2019)/lightspeed(SI2019)^2 # (N·s²⋅C⁻²)⋅𝘤² -$(coulomb(SI2019)/lightspeed(SI2019)^2) +julia> coulomb(EMU) # dyn⋅cm²⋅abC⁻² +$(coulomb(EMU)) + +julia> coulomb(ESU) # dyn⋅cm²⋅statC⁻² +$(coulomb(ESU)) + +julia> coulomb(HLU) # dyn⋅cm²⋅hlC⁻² +$(coulomb(HLU)) ``` """ coulomb, kₑ, ke +@pure biotsavart(U::UnitSystem) = permeability(U)*lorentz(U)*(rationalization(U)/4π) +@doc """ + biotsavart(U::UnitSystem) = permeability(U)*lorentz(U)*rationalization(U)/4π + +Matnetostatic proportionality constant `αB` for the Biot-Savart's law (?). + +```Julia +julia> biotsavart(Metric) +$(biotsavart(Metric)) + +julia> biotsavart(CODATA) +$(biotsavart(CODATA)) + +julia> biotsavart(SI2019) +$(biotsavart(SI2019)) + +julia> biotsavart(Conventional) +$(biotsavart(Conventional)) + +julia> biotsavart(EMU) +$(biotsavart(EMU)) + +julia> biotsavart(ESU) +$(biotsavart(ESU)) + +julia> biotsavart(Gauss) +$(biotsavart(Gauss)) + +julia> biotsavart(HLU) +$(biotsavart(HLU)) +``` +""" biotsavart, αB, aB + +@pure ampere(U::UnitSystem) = lorentz(U)*biotsavart(U) +@doc """ + ampere(U::UnitSystem) = lorentz(U)*biotsavart(U) # coulomb(U)/lightspeed(U)^2 + +Magnetic proportionality constant `kₘ` for the Ampere's law force (N·s²⋅C⁻²). + +```Julia +julia> ampere(Metric) # N·s²⋅C⁻² +$(ampere(Metric)) + +julia> ampere(CODATA) # N·s²⋅C⁻² +$(ampere(CODATA)) + +julia> ampere(SI2019) # N·s²⋅C⁻² +$(ampere(SI2019)) + +julia> ampere(Conventional) # N·s²⋅C⁻² +$(ampere(Conventional)) + +julia> ampere(EMU) # dyn·s²⋅abC⁻² +$(ampere(EMU)) + +julia> ampere(ESU) # dyn·s²⋅statC⁻² +$(ampere(ESU)) + +julia> ampere(HLU) # dyn·s²⋅hlC⁻² +$(ampere(HLU)) +``` +""" ampere, kₘ, km + @doc """ - impedance(U::UnitSystem) = permeability(U)*lightspeed(U) + impedance(U::UnitSystem) = permeability(U)*lightspeed(U)*rationalization(U)*lorentz(U)^2 Vacuum impedance of free space `Z₀` is magnitude ratio of electric to magnetic field (Ω). ```Julia @@ -430,6 +595,15 @@ $(impedance(SI2019)) julia> 120π # 3e8*μ₀ # Ω $(120π) + +julia> impedance(EMU) # abΩ +$(impedance(EMU)) + +julia> impedance(ESU) # statΩ +$(impedance(ESU)) + +julia> impedance(HLU) # hlΩ +$(impedance(HLU)) ``` """ impedance, Z₀, Z0 @@ -450,8 +624,11 @@ $(charge(CODATA)) julia> charge(Conventional) # C $(charge(Conventional)) -julia> 10lightspeed(Metric)*charge(metric) # statC -$(10lightspeed(Metric)*charge(Metric)) +julia> charge(EMU) # abC +$(charge(EMU)) + +julia> charge(ESU) # statC +$(charge(ESU)) julia> charge(Planck) # sqrt(4π/αinv) $(charge(Planck)) @@ -476,6 +653,12 @@ $(faraday(CODATA)) julia> faraday(Conventional) # C⋅mol⁻¹ $(faraday(Conventional)) +julia> faraday(EMU) # abC⋅mol⁻¹ +$(faraday(EMU)) + +julia> faraday(ESU) # statC⋅mol⁻¹ +$(faraday(ESU)) + julia> faraday(Metric)/kcal # kcal⋅(V-g-e)⁻¹ $(faraday(Metric)/kcal) @@ -484,9 +667,9 @@ $(faraday(Metric)/3600) ``` """ faraday, 𝔉, FF -@pure josephson(U::UnitSystem) = 2charge(U)/planck(U) +@pure josephson(U::UnitSystem) = 2charge(U)*lorentz(U)/planck(U) @doc """ - josephson(U::UnitSystem) = 2charge(U)/planck(U) # 1/magneticflux(U) + josephson(U::UnitSystem) = 2charge(U)*lorentz(U)/planck(U) # 1/magneticflux(U) Josephson constant `KJ` relating potential difference to irradiation frequency (Hz⋅V⁻¹). ```Julia @@ -501,12 +684,18 @@ $(josephson(Conventional)) julia> josephson(CODATA) # Hz⋅V⁻¹ $(josephson(CODATA)) + +julia> josephson(EMU) # Hz⋅abV⁻¹ +$(josephson(EMU)) + +julia> josephson(ESU) # Hz⋅statV⁻¹ +$(josephson(ESU)) ``` """ josephson, KJ @pure magneticflux(U::UnitSystem) = inv(josephson(U)) @doc """ - magneticflux(U::UnitSystem) = planck(U)/2charge(U) + magneticflux(U::UnitSystem) = planck(U)/2charge(U)/lorentz(U) Magnetic flux quantum `Φ₀` is `1/josephson(U)` (Wb). ```Julia @@ -519,8 +708,11 @@ $(magneticflux(Metric)) julia> magneticflux(Conventional) # Wb $(magneticflux(Conventional)) -julia> magneticflux(CODATA) # Wb -$(magneticflux(CODATA)) +julia> magneticflux(EMU) # Mx +$(magneticflux(EMU)) + +julia> magneticflux(ESU) # statWb +$(magneticflux(ESU)) ``` """ magneticflux, Φ₀ @@ -541,12 +733,18 @@ $(klitzing(Conventional)) julia> klitzing(CODATA) # Ω $(klitzing(CODATA)) + +julia> klitzing(EMU) # abΩ +$(klitzing(EMU)) + +julia> klitzing(ESU) # statΩ +$(klitzing(ESU)) ``` """ klitzing, RK @pure conductance(U::UnitSystem) = 2charge(U)^2/planck(U) @doc """ - conductance(U::UnitSystem) = 2charge(U)^2/𝘩 # 2/klitzing(U) + conductance(U::UnitSystem) = 2charge(U)^2/planck(U) # 2/klitzing(U) Conductance quantum `G₀` is a quantized unit of electrical conductance (S). ```Julia @@ -561,6 +759,12 @@ $(conductance(Conventional)) julia> conductance(CODATA) # S $(conductance(CODATA)) + +julia> conductance(EMU) # abS +$(conductance(EMU)) + +julia> conductance(ESU) # statS +$(conductance(ESU)) ``` """ conductance, G₀, G0 @@ -635,7 +839,6 @@ $(1/rydberg(Metric)/2π) Precision measurements of the Rydberg constants are within a relative standard uncertainty of under 2 parts in 10¹², and is chosen to constrain values of other physical constants. """ rydberg, R∞, RH, Ry -@pure plancklength(U::UnitSystem) = sqrt(planckreduced(U)*newton(U)/lightspeed(U)^3) @pure bohr(U::UnitSystem) = αinv*planckreduced(U)/electronmass(U)/lightspeed(U) @doc """ bohr(U) = $αinv*planckreduced(U)/electronmass(U)/lightspeed(U) @@ -648,13 +851,13 @@ $(bohr(Metric)) julia> 12bohr(English) # in $(12bohr(English)) -julia> bohr(Metric)/plancklength(Metric) # ℓP -$(bohr(Metric)/plancklength(Metric)) +julia> bohr(Metric)/length(PlanckGauss) # ℓP +$(bohr(Metric)/length(PlanckGauss)) ``` """ bohr, a₀, a0 """ - bohrreduced(U::UnitSystem) = electronmass(U)/bohr(U)/$μₚₑ + bohrreduced(U::UnitSystem) = bohr(U)*(1+1/$μₚₑ) Reduced Bohr radius including the effect of reduced mass in hydrogen atom (m). ```Julia @@ -684,9 +887,9 @@ $(electronradius(Conventional)) ``` """ electronradius, rₑ, re -@pure magneton(U::UnitSystem) = charge(U)*planckreduced(U)/2electronmass(U) +@pure magneton(U::UnitSystem) = charge(U)*planckreduced(U)*lorentz(U)/2electronmass(U) """ - magneton(U::UnitSystem) = charge(U)*planckreduced(U)/2electronmass(U) + magneton(U::UnitSystem) = charge(U)*planckreduced(U)*lorentz(U)/2electronmass(U) Bohr magneton `μB` natural unit for expressing magnetic moment of electron (J⋅T⁻¹). ```Julia @@ -702,8 +905,11 @@ $(magneton(CODATA)) julia> magneton(Conventional) # J⋅T⁻¹ $(magneton(Conventional)) -julia> magneton(CGS2019) # erg⋅T⁻¹ -$(magneton(CGS2019)) +julia> magneton(EMU2019) # erg⋅G⁻¹ +$(magneton(EMU2019)) + +julia> magneton(ESU2019) # statA⋅cm² +$(magneton(ESU2019)) julia> magneton(SI2019)/charge(SI2019) # eV⋅T⁻¹ $(magneton(SI2019)/charge(SI2019)) diff --git a/src/thermodynamic.jl b/src/thermodynamic.jl new file mode 100644 index 0000000..6fb4bfc --- /dev/null +++ b/src/thermodynamic.jl @@ -0,0 +1,412 @@ + +# This file is part of UnitSystems.jl. It is licensed under the MIT license +# UnitSystems Copyright (C) 2020 Michael Reed + +@doc """ + T/kelvin == (9/5)*T + +Converts temperature `T` from Kelvin to degrees Rankine (°R). +""" kelvin + +@doc """ + T/rankine == (5/9)*T + +Converts temperature `T` from degrees Rankine to Kelvin (K). +""" rankine + +""" + moles(N::Real,U::UnitSystem=Metric) = N/avogadro(U) + +Converts the number of molecules `N` to number of moles (mol). +""" +@pure moles(N::Real,U::UnitSystem=Metric) = N/avogadro(U) + +""" + molecules(n::Real,U::UnitSystem=Metric) = n*avogadro(U) + +Converts the number of moles `n` to number of molecules (dimensionless). +""" +@pure molecules(n::Real,U::UnitSystem=Metric) = n*avogadro(U) + +# thermodynamics + +""" +$(convertext(:temperature,"mass(U,S)*speed(U,S)^2/boltzmann(U,S)")) + +Measurement scale for thermodynamic energy or `temperature` (K), unit conversion factor. + +```Julia +julia> temperature(Metric,SI2019) # K⋅K⁻¹ +$(temperature(Metric,SI2019)) + +julia> temperature(English,SI2019) # K⋅°R⁻¹ +$(temperature(English,SI2019)) + +julia> temperature(English,Metric) # K⋅°R⁻¹ +$(temperature(English,Metric)) + +julia> temperature(PlanckGauss,Metric) # K⋅TP⁻¹ +$(temperature(PlanckGauss,Metric)) +``` +""" +@pure temperature(U::UnitSystem,S::UnitSystem) = unit((boltzmann(U)*electronmass(S)*lightspeed(S)^2)/(boltzmann(S)*electronmass(U)*lightspeed(U)^2)) + +""" +$(convertext(:entropy,"energy(U,S)/temperature(U,S)")) + +Heat capacity or `energy` per `temperature` or `entropy` (J⋅K⁻¹), unit conversion factor. + +```Julia +julia> entropy(Metric,SI2019) # K⋅K⁻¹ +$(entropy(Metric,SI2019)) + +julia> entropy(CGS,Metric) # J⋅erg⁻¹ +$(entropy(CGS,Metric)) + +julia> entropy(English,SI2019) # J⋅°R⋅K⁻¹⋅ft⁻¹⋅lb⁻¹ +$(entropy(English,SI2019)) + +julia> entropy(EnglishUS,English) # ftUS²⋅°R⋅°ft⁻²⋅°R⁻¹ +$(entropy(EnglishUS,English)) +``` +""" +@pure entropy(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/temperature(U,S)) + +""" +$(convertext(:specificentropy,"specificenergy(U,S)/temperature(U,S)")) + +Specific heat capacity or `specificentropy` (J⋅K⁻¹⋅kg⁻¹), unit conversion factor. + +```Julia +julia> specificentropy(Metric,SI2019) # m²⋅K⋅K⁻¹⋅cm⁻² +$(specificentropy(Metric,SI2019)) + +julia> specificentropy(CGS,Metric) # m²⋅cm⁻² +$(specificentropy(CGS,Metric)) + +julia> specificentropy(English,Metric) # m²⋅°R⋅K⁻¹⋅ft⁻² +$(specificentropy(English,Metric)) + +julia> specificentropy(EnglishUS,English) # ft²⋅°R⋅ftUS⁻²⋅°R⁻¹ +$(specificentropy(EnglishUS,English)) +``` +""" +@pure specificentropy(U::UnitSystem,S::UnitSystem) = unit(specificenergy(U,S)/temperature(U,S)) + +""" +$(convertext(:thermalconductivity,"force(U,S)/time(U,S)/temperature(U,S)")) + +Heat conductivity or `thermalconductivity` (W⋅m⁻¹⋅K⁻¹), unit conversion factor. + +```Julia +julia> thermalconductivity(Metric,SI2019) # K⋅K⁻¹ +$(thermalconductivity(Metric,SI2019)) + +julia> thermalconductivity(CGS,Metric) # N⋅dyn⁻¹ +$(thermalconductivity(CGS,Metric)) + +julia> thermalconductivity(English,Metric) # N⋅°R⋅K⁻¹⋅ft⁻¹⋅lb⁻¹ +$(thermalconductivity(English,Metric)) +``` +""" +@pure thermalconductivity(U::UnitSystem,S::UnitSystem) = unit(force(U,S)/time(U,S)/temperature(U,S)) + +""" +$(convertext(:thermalconductance,"thermalconductivity(U,S)*length(U,S)")) + +Reciprocal of `thermalresistance` (W⋅K⁻¹), unit conversion factor. + +```Julia +julia> thermalconductance(Metric,SI2019) # K⋅K⁻¹ +$(thermalconductance(Metric,SI2019)) + +julia> thermalconductance(CGS,Metric) # W⋅s⋅erg⁻¹ +$(thermalconductance(CGS,Metric)) + +julia> thermalconductance(English,Metric) # J⋅°R⋅K⁻¹⋅ft⁻¹⋅lb⁻¹ +$(thermalconductance(English,Metric)) +``` +""" +@pure thermalconductance(U::UnitSystem,S::UnitSystem) = unit(thermalconductivity(U,S)*length(U,S)) + +""" +$(convertext(:thermalresistance,"1/thermalconductivity(U,S)/length(U,S)")) + +Resistance to heat flow or `thermalresistance` (K⋅W⁻¹), unit conversion factor. + +```Julia +julia> thermalresistance(Metric,SI2019) # K⋅K⁻¹ +$(thermalresistance(Metric,SI2019)) + +julia> thermalresistance(CGS,Metric) # erg⋅s⁻¹⋅W⁻¹ +$(thermalresistance(CGS,Metric)) + +julia> thermalresistance(English,Metric) # ft⋅lb⋅K⋅°R⁻¹⋅J⁻¹ +$(thermalresistance(English,Metric)) +``` +""" +@pure thermalresistance(U::UnitSystem,S::UnitSystem) = thermalconductance(S,U) + +""" +$(convertext(:thermalexpansion,"1/temperature(U,S)")) + +Measurement scale for coefficient of `thermalexpansion` (K⁻¹), unit conversion factor. + +```Julia +julia> thermalexpansion(Metric,SI2019) # K⋅K⁻¹ +$(thermalexpansion(Metric,SI2019)) + +julia> thermalexpansion(English,SI2019) # °R⋅K⁻¹ +$(thermalexpansion(English,SI2019)) + +julia> thermalexpansion(English,Metric) # °R⋅K⁻¹ +$(thermalexpansion(English,Metric)) +``` +""" +@pure thermalexpansion(U::UnitSystem,S::UnitSystem) = temperature(S,U) + +""" +$(convertext(:lapserate,"temperature(U,S)/length(U,S)")) + +Temperature gradient over `length` or `lapserate` (K⋅m⁻¹), unit conversion factor. + +```Julia +julia> lapserate(Metric,SI2019) # K⋅K⁻¹ +$(lapserate(Metric,SI2019)) + +julia> lapserate(English,SI2019) # K⋅ft⋅°R⁻¹⋅m⁻¹ +$(lapserate(English,SI2019)) + +julia> lapserate(English,Metric) # K⋅ft⋅°R⁻¹⋅m⁻¹ +$(lapserate(English,Metric)) + +julia> lapserate(EnglishUS,English) # °R⋅ftUS⋅°R⁻¹⋅ft⁻¹ +$(lapserate(EnglishUS,English)) +``` +""" +@pure lapserate(U::UnitSystem,S::UnitSystem) = unit(temperature(U,S)/length(U,S)) + +# molar + +@doc """ +$(convertext(:molarmass,"molarmass(S)/molarmass(U)")) + +Molar mass or `mass` per `mole` (kg⋅mol⁻¹), unit conversion factor. + +```Julia +julia> molarmass(CGS,Metric) # mol⋅mol⁻¹ +$(molarmass(CGS,Metric)) + +julia> molarmass(Metric,SI2019) # mol⋅mol⁻¹ +$(molarmass(Metric,SI2019)) +``` +""" molarmass(::UnitSystem,::UnitSystem) + +""" +$(convertext(:molality,"molarmass(U)/molarmass(S)")) + +Molality or `mole` per `mass` (mol⋅kg⁻¹), unit conversion factor. + +```Julia +julia> molality(CGS,Metric) # mol⋅mol⁻¹ +$(molality(CGS,Metric)) + +julia> molality(Metric,SI2019) # mol⋅mol⁻¹ +$(molality(Metric,SI2019)) +``` +""" +@pure molality(U::UnitSystem,S::UnitSystem) = molarmass(S,U) + +""" +$(convertext(:mole,"mass(U,S)*molality(U,S)")) + +Amount of molecular substance or `mole` (mol), unit conversion factor. + +```Julia +julia> mole(SI2019,Metric) # mol⋅mol⁻¹ +$(mole(SI2019,Metric)) + +julia> mole(English,SI2019) # mol⋅slug-mol⁻¹ +$(mole(English,SI2019)) + +julia> mole(English,SI2019)/lbm # mol⋅lb-mol⁻¹ +$(mole(English,SI2019)/lbm) +``` +""" +@pure mole(U::UnitSystem,S::UnitSystem) = unit(mass(U,S)*molality(U,S)) + +""" +$(convertext(:molarity,"mole(U,S)/volume(U,S)")) + +Molar concentration or `mole` per `volume` or `molarity` (mol⋅m⁻³), unit conversion factor. + +```Julia +julia> molarity(CGS,Metric) # cm³⋅m⁻³ +$(molarity(CGS,Metric)) + +julia> molarity(English,SI2019) # ft³⋅m⁻³ +$(molarity(English,SI2019)) +``` +""" +@pure molarity(U::UnitSystem,S::UnitSystem) = unit(mole(U,S)/volume(U,S)) + +""" +$(convertext(:molarvolume,"volume(U,S)/mole(U,S)")) + +Occupied `volume` per `mole` or `molarvolume` (m³⋅mol⁻¹), unit conversion factor. + +```Julia +julia> molarvolume(CGS,Metric) # m³⋅cm⁻³ +$(molarvolume(CGS,Metric)) + +julia> molarvolume(English,SI2019) # m³⋅ft⁻³ +$(molarvolume(English,SI2019)) +``` +""" +@pure molarvolume(U::UnitSystem,S::UnitSystem) = unit(volume(U,S)/mole(U,S)) + +""" +$(convertext(:molarentropy,"entropy(U,S)/mole(U,S)")) + +Molar heat capacity or `entropy` per `mole` (J⋅K⁻¹⋅mol⁻¹), unit conversion factor. + +```Julia +julia> molarentropy(CGS,Metric) # J⋅erg⁻¹ +$(molarentropy(CGS,Metric)) + +julia> molarentropy(English,SI2019) # J⋅°R⋅slug-mol⋅ft⁻¹⋅lb⁻¹⋅K⁻¹⋅mol⁻¹ +$(molarentropy(English,SI2019)) +``` +""" +@pure molarentropy(U::UnitSystem,S::UnitSystem) = unit(entropy(U,S)/mole(U,S)) + +""" +$(convertext(:molarenergy,"energy(U,S)/mole(U,S)")) + +Gibbs free `energy` per `mole` or `molarenergy` (J⋅mol⁻¹), unit conversion factor. + +```Julia +julia> molarenergy(CGS,Metric) # J⋅erg⁻¹ +$(molarenergy(CGS,Metric)) + +julia> molarenergy(English,SI2019) # J⋅slug-mol⋅ft⁻¹⋅lb⁻¹⋅mol⁻¹ +$(molarenergy(English,SI2019)) +``` +""" +@pure molarenergy(U::UnitSystem,S::UnitSystem) = unit(energy(U,S)/mole(U,S)) + +""" +$(convertext(:molarconductivity,"conductivity(U,S)*area(U,S)/mole(U,S)")) + +Conductivity per `molarvolume` or `molarconductivity` (S⋅m²⋅mol⁻¹), unit conversion factor. + +```Julia +julia> molarconductivity(EMU,Metric) # S⋅m²⋅abΩ⋅cm⁻² +$(molarconductivity(EMU,Metric)) + +julia> molarconductivity(ESU,Metric) # S⋅m²⋅statΩ⋅cm⁻² +$(molarconductivity(ESU,Metric)) +``` +""" +@pure molarconductivity(U::UnitSystem,S::UnitSystem) = unit(conductivity(U,S)*area(U,S)/mole(U,S)) + +""" +$(convertext(:catalysis,"mole(U,S)/time(U,S)")) + +Catalytic activity or `mole` per `time` or `catalysis` (kat, mol⁻¹), unit conversion factor. + +```Julia +julia> catalysis(English,Metric) # kat⋅slug-mol +$(catalysis(English,Metric)) +``` +""" +@pure catalysis(U::UnitSystem,S::UnitSystem) = unit(mole(U,S)/time(U,S)) + +""" +$(convertext(:specificity,"volume(U,S)/mole(U,S)/time(U,S)")) + +Catalytic efficiency or `volume` per `mole` per `time` (m³⋅mol⁻¹⋅s⁻¹), unit conversion factor. + +```Julia +julia> specificity(CGS,Metric) # m³⋅cm⁻³ +$(specificity(CGS,Metric)) + +julia> specificity(English,Metric) # m³⋅slug-mol⋅mol⁻¹⋅ft⁻³ +$(specificity(English,Metric)) +``` +""" +@pure specificity(U::UnitSystem,S::UnitSystem) = unit(volume(U,S)/mole(U,S)/time(U,S)) + +# photometrics + +""" +$(convertext(:luminousflux,"luminousefficacy(U,S)*planck(U,S)/time(U,S)^2")) + +Perceived power of light or `luminousflux` (lm, cd⋅sr), unit conversion factor. +""" +@pure luminousflux(U::UnitSystem,S::UnitSystem) = unit(frequency(U,S)^2*(luminousefficacy(S)*planckreduced(S))/(luminousefficacy(U)*planckreduced(U))) + +""" +$(convertext(:luminance,"luminousflux(U,S)/area(U,S)")) + +Luminous intensity per `area` or `luminance` (lx, lm⋅m⁻², cd⋅m⁻²⋅sr), unit conversion factor. + +```Julia +julia> luminance(CGS,Metric) # lx⋅ph⁻¹ +$(luminance(CGS,Metric)) + +julia> luminance(IAU,Metric) # lx⋅au²⋅lm⁻¹ +$(luminance(IAU,Metric)) + +julia> luminance(English,Metric) # ft²⋅m⁻² +$(luminance(English,Metric)) + +julia> 1/10.76 # lx⋅fc⁻¹ +$(1/10.76) +``` +""" +@pure luminance(U::UnitSystem,S::UnitSystem) = unit(luminousflux(U,S)/area(U,S)) + +""" +$(convertext(:luminousenergy,"luminousflux(U,S)*time(U,S)")) + +Perceived quantity of light or `luminousenergy` (lm⋅s, cd⋅s⋅sr), unit conversion factor. + +```Julia +julia> luminousenergy(IAU,Metric) # s⋅day⁻¹ +$(luminousenergy(IAU,Metric)) +``` +""" +@pure luminousenergy(U::UnitSystem,S::UnitSystem) = unit(frequency(U,S)*(luminousefficacy(S)*planckreduced(S))/(luminousefficacy(U)*planckreduced(U))) + +""" +$(convertext(:luminousexposure,"luminance(U,S)*time(U,S)")) + +Integrated `luminance` along `time` (lx⋅s, lm⋅s⋅m⁻², cd⋅s⋅m⁻²⋅sr), unit conversion factor. + +```Julia +julia> luminousexposure(CGS,Metric) # lx⋅ph⁻¹ +$(luminousexposure(CGS,Metric)) + +julia> luminousexposure(IAU,Metric) # s⋅au²⋅day⁻¹⋅m⁻² +$(luminousexposure(IAU,Metric)) + +julia> luminousexposure(English,Metric) # ft²⋅m⁻² +$(luminousexposure(English,Metric)) +``` +""" +@pure luminousexposure(U::UnitSystem,S::UnitSystem) = unit(luminance(U,S)*time(U,S)) + +@doc """ +$(convertext(:luminousefficacy,"luminousefficacy(S)/luminousefficacy(U)")) + +Ratio of `luminousflux` to `power` or `luminousefficacy` (lm⋅W⁻¹), unit conversion factor. + +```Julia +julia> luminousefficacy(CGS,Metric) # erg⋅s⁻¹⋅W⁻¹ +$(luminousefficacy(CGS,Metric)) + +julia> luminousefficacy(English,Metric) # ft⋅lb⋅s⁻¹⋅W⁻¹ +$(luminousefficacy(English,Metric)) +``` +""" luminousefficacy(::UnitSystem,::UnitSystem)