719 lines
25 KiB
C++
719 lines
25 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2011 Jürgen Riegel <juergen.riegel@web.de> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
#ifndef _PreComp_
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <utility>
|
|
#endif
|
|
|
|
#include "Unit.h"
|
|
#include "Exception.h"
|
|
#include "Quantity.h"
|
|
|
|
|
|
using namespace Base;
|
|
|
|
// clang-format off
|
|
constexpr int UnitSignatureLengthBits = 4;
|
|
constexpr int UnitSignatureMassBits = 4;
|
|
constexpr int UnitSignatureTimeBits = 4;
|
|
constexpr int UnitSignatureElectricCurrentBits = 4;
|
|
constexpr int UnitSignatureThermodynamicTemperatureBits = 4;
|
|
constexpr int UnitSignatureAmountOfSubstanceBits = 4;
|
|
constexpr int UnitSignatureLuminousIntensityBits = 4;
|
|
constexpr int UnitSignatureAngleBits = 4;
|
|
|
|
struct UnitSignature {
|
|
int32_t Length: UnitSignatureLengthBits;
|
|
int32_t Mass: UnitSignatureMassBits;
|
|
int32_t Time: UnitSignatureTimeBits;
|
|
int32_t ElectricCurrent: UnitSignatureElectricCurrentBits;
|
|
int32_t ThermodynamicTemperature: UnitSignatureThermodynamicTemperatureBits;
|
|
int32_t AmountOfSubstance: UnitSignatureAmountOfSubstanceBits;
|
|
int32_t LuminousIntensity: UnitSignatureLuminousIntensityBits;
|
|
int32_t Angle: UnitSignatureAngleBits;
|
|
};
|
|
|
|
static inline uint32_t sigVal(const std::string &op,
|
|
int length, int mass, int time, int electricCurrent,
|
|
int thermodynamicTemperature, int amountOfSubstance, int luminousIntensity, int angle)
|
|
{
|
|
if ( ( length >= (1 << (UnitSignatureLengthBits - 1)) ) ||
|
|
( mass >= (1 << (UnitSignatureMassBits - 1)) ) ||
|
|
( time >= (1 << (UnitSignatureTimeBits - 1)) ) ||
|
|
( electricCurrent >= (1 << (UnitSignatureElectricCurrentBits - 1)) ) ||
|
|
( thermodynamicTemperature >= (1 << (UnitSignatureThermodynamicTemperatureBits - 1)) ) ||
|
|
( amountOfSubstance >= (1 << (UnitSignatureAmountOfSubstanceBits - 1)) ) ||
|
|
( luminousIntensity >= (1 << (UnitSignatureLuminousIntensityBits - 1)) ) ||
|
|
( angle >= (1 << (UnitSignatureAngleBits - 1)) ) ) {
|
|
throw Base::OverflowError(("Unit overflow in " + op).c_str());
|
|
}
|
|
if ( ( length < -(1 << (UnitSignatureLengthBits - 1)) ) ||
|
|
( mass < -(1 << (UnitSignatureMassBits - 1)) ) ||
|
|
( time < -(1 << (UnitSignatureTimeBits - 1)) ) ||
|
|
( electricCurrent < -(1 << (UnitSignatureElectricCurrentBits - 1)) ) ||
|
|
( thermodynamicTemperature < -(1 << (UnitSignatureThermodynamicTemperatureBits - 1)) ) ||
|
|
( amountOfSubstance < -(1 << (UnitSignatureAmountOfSubstanceBits - 1)) ) ||
|
|
( luminousIntensity < -(1 << (UnitSignatureLuminousIntensityBits - 1)) ) ||
|
|
( angle < -(1 << (UnitSignatureAngleBits - 1)) ) ) {
|
|
throw Base::UnderflowError(("Unit underflow in " + op).c_str());
|
|
}
|
|
|
|
UnitSignature Sig;
|
|
Sig.Length = length;
|
|
Sig.Mass = mass;
|
|
Sig.Time = time;
|
|
Sig.ElectricCurrent = electricCurrent;
|
|
Sig.ThermodynamicTemperature = thermodynamicTemperature;
|
|
Sig.AmountOfSubstance = amountOfSubstance;
|
|
Sig.LuminousIntensity = luminousIntensity;
|
|
Sig.Angle = angle;
|
|
|
|
uint32_t ret;
|
|
memcpy(&ret, &Sig, sizeof(ret));
|
|
return ret;
|
|
}
|
|
|
|
|
|
Unit::Unit(int8_t Length, //NOLINT
|
|
int8_t Mass,
|
|
int8_t Time,
|
|
int8_t ElectricCurrent,
|
|
int8_t ThermodynamicTemperature,
|
|
int8_t AmountOfSubstance,
|
|
int8_t LuminousIntensity,
|
|
int8_t Angle)
|
|
{
|
|
Val = sigVal("unit",
|
|
Length,
|
|
Mass,
|
|
Time,
|
|
ElectricCurrent,
|
|
ThermodynamicTemperature,
|
|
AmountOfSubstance,
|
|
LuminousIntensity,
|
|
Angle);
|
|
}
|
|
|
|
|
|
Unit::Unit() //NOLINT
|
|
{
|
|
Val = 0;
|
|
}
|
|
|
|
Unit::Unit(const std::string& expr) // NOLINT
|
|
{
|
|
try {
|
|
*this = Quantity::parse(QString::fromStdString(expr)).getUnit();
|
|
}
|
|
catch (const Base::ParserError&) {
|
|
Val = 0;
|
|
}
|
|
}
|
|
|
|
Unit Unit::pow(double exp) const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
auto isInt = [](double value) {
|
|
return std::fabs(std::round(value) - value) < std::numeric_limits<double>::epsilon();
|
|
};
|
|
if (!isInt(sig.Length * exp) ||
|
|
!isInt(sig.Mass * exp) ||
|
|
!isInt(sig.Time * exp) ||
|
|
!isInt(sig.ElectricCurrent * exp) ||
|
|
!isInt(sig.ThermodynamicTemperature * exp) ||
|
|
!isInt(sig.AmountOfSubstance * exp) ||
|
|
!isInt(sig.LuminousIntensity * exp) ||
|
|
!isInt(sig.Angle * exp))
|
|
throw Base::UnitsMismatchError("pow() of unit not possible");
|
|
|
|
Unit result;
|
|
result.Val = sigVal("pow()",
|
|
sig.Length * exp,
|
|
sig.Mass * exp,
|
|
sig.Time * exp,
|
|
sig.ElectricCurrent * exp,
|
|
sig.ThermodynamicTemperature * exp,
|
|
sig.AmountOfSubstance * exp,
|
|
sig.LuminousIntensity * exp,
|
|
sig.Angle * exp);
|
|
|
|
return result;
|
|
}
|
|
|
|
Unit Unit::sqrt() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
// All components of unit must be either zero or dividable by 2
|
|
if (!((sig.Length % 2) == 0) &&
|
|
((sig.Mass % 2) == 0) &&
|
|
((sig.Time % 2) == 0) &&
|
|
((sig.ElectricCurrent % 2) == 0) &&
|
|
((sig.ThermodynamicTemperature % 2) == 0) &&
|
|
((sig.AmountOfSubstance % 2) == 0) &&
|
|
((sig.LuminousIntensity % 2) == 0) &&
|
|
((sig.Angle % 2) == 0))
|
|
throw Base::UnitsMismatchError("sqrt() needs even dimensions");
|
|
|
|
Unit result;
|
|
result.Val = sigVal("sqrt()",
|
|
sig.Length >> 1,
|
|
sig.Mass >> 1,
|
|
sig.Time >> 1,
|
|
sig.ElectricCurrent >> 1,
|
|
sig.ThermodynamicTemperature >> 1,
|
|
sig.AmountOfSubstance >> 1,
|
|
sig.LuminousIntensity >> 1,
|
|
sig.Angle >> 1);
|
|
|
|
return result;
|
|
}
|
|
|
|
Unit Unit::cbrt() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
// All components of unit must be either zero or dividable by 3
|
|
if (!((sig.Length % 3) == 0) &&
|
|
((sig.Mass % 3) == 0) &&
|
|
((sig.Time % 3) == 0) &&
|
|
((sig.ElectricCurrent % 3) == 0) &&
|
|
((sig.ThermodynamicTemperature % 3) == 0) &&
|
|
((sig.AmountOfSubstance % 3) == 0) &&
|
|
((sig.LuminousIntensity % 3) == 0) &&
|
|
((sig.Angle % 3) == 0))
|
|
throw Base::UnitsMismatchError("cbrt() needs dimensions to be multiples of 3");
|
|
|
|
Unit result;
|
|
result.Val = sigVal("cbrt()",
|
|
sig.Length / 3,
|
|
sig.Mass / 3,
|
|
sig.Time / 3,
|
|
sig.ElectricCurrent / 3,
|
|
sig.ThermodynamicTemperature / 3,
|
|
sig.AmountOfSubstance / 3,
|
|
sig.LuminousIntensity / 3,
|
|
sig.Angle / 3);
|
|
|
|
return result;
|
|
}
|
|
|
|
int Unit::length() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.Length;
|
|
}
|
|
|
|
int Unit::mass() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.Mass;
|
|
}
|
|
|
|
|
|
int Unit::time() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.Time;
|
|
}
|
|
|
|
int Unit::electricCurrent() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.ElectricCurrent;
|
|
}
|
|
|
|
int Unit::thermodynamicTemperature() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.ThermodynamicTemperature;
|
|
}
|
|
|
|
int Unit::amountOfSubstance() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.AmountOfSubstance;
|
|
}
|
|
|
|
int Unit::luminousIntensity() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.LuminousIntensity;
|
|
}
|
|
|
|
int Unit::angle() const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
return sig.Angle;
|
|
}
|
|
|
|
bool Unit::isEmpty() const
|
|
{
|
|
return Val == 0;
|
|
}
|
|
|
|
int Unit::operator [](int index) const
|
|
{
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
|
|
switch (index) {
|
|
case 0:
|
|
return sig.Length;
|
|
case 1:
|
|
return sig.Mass;
|
|
case 2:
|
|
return sig.Time;
|
|
case 3:
|
|
return sig.ElectricCurrent;
|
|
case 4:
|
|
return sig.ThermodynamicTemperature;
|
|
case 5:
|
|
return sig.AmountOfSubstance;
|
|
case 6:
|
|
return sig.LuminousIntensity;
|
|
case 7:
|
|
return sig.Angle;
|
|
default:
|
|
throw Base::IndexError("Unknown Unit element");
|
|
}
|
|
}
|
|
|
|
bool Unit::operator ==(const Unit& that) const
|
|
{
|
|
return Val == that.Val;
|
|
}
|
|
|
|
Unit Unit::operator *(const Unit &right) const
|
|
{
|
|
Unit result;
|
|
UnitSignature sig, rsig;
|
|
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
memcpy(&rsig, &right.Val, sizeof(right.Val));
|
|
result.Val = sigVal("* operator",
|
|
sig.Length + rsig.Length,
|
|
sig.Mass + rsig.Mass,
|
|
sig.Time + rsig.Time,
|
|
sig.ElectricCurrent + rsig.ElectricCurrent,
|
|
sig.ThermodynamicTemperature + rsig.ThermodynamicTemperature,
|
|
sig.AmountOfSubstance + rsig.AmountOfSubstance,
|
|
sig.LuminousIntensity + rsig.LuminousIntensity,
|
|
sig.Angle + rsig.Angle);
|
|
|
|
return result;
|
|
}
|
|
|
|
Unit Unit::operator /(const Unit &right) const
|
|
{
|
|
Unit result;
|
|
UnitSignature sig, rsig;
|
|
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
memcpy(&rsig, &right.Val, sizeof(right.Val));
|
|
result.Val = sigVal("/ operator",
|
|
sig.Length - rsig.Length,
|
|
sig.Mass - rsig.Mass,
|
|
sig.Time - rsig.Time,
|
|
sig.ElectricCurrent - rsig.ElectricCurrent,
|
|
sig.ThermodynamicTemperature - rsig.ThermodynamicTemperature,
|
|
sig.AmountOfSubstance - rsig.AmountOfSubstance,
|
|
sig.LuminousIntensity - rsig.LuminousIntensity,
|
|
sig.Angle - rsig.Angle);
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string Unit::getString() const
|
|
{
|
|
if (isEmpty()) {
|
|
return {};
|
|
}
|
|
|
|
std::stringstream ret;
|
|
UnitSignature sig;
|
|
memcpy(&sig, &Val, sizeof(Val));
|
|
|
|
if (sig.Length > 0 ||
|
|
sig.Mass > 0 ||
|
|
sig.Time > 0 ||
|
|
sig.ElectricCurrent > 0 ||
|
|
sig.ThermodynamicTemperature > 0 ||
|
|
sig.AmountOfSubstance > 0 ||
|
|
sig.LuminousIntensity > 0 ||
|
|
sig.Angle > 0 ) {
|
|
|
|
bool mult = false;
|
|
if (sig.Length > 0) {
|
|
mult = true;
|
|
ret << "mm";
|
|
if (sig.Length > 1) {
|
|
ret << "^" << sig.Length;
|
|
}
|
|
}
|
|
|
|
if (sig.Mass > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "kg";
|
|
if (sig.Mass > 1) {
|
|
ret << "^" << sig.Mass;
|
|
}
|
|
}
|
|
|
|
if (sig.Time > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "s";
|
|
if (sig.Time > 1) {
|
|
ret << "^" << sig.Time;
|
|
}
|
|
}
|
|
|
|
if (sig.ElectricCurrent > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "A";
|
|
if (sig.ElectricCurrent > 1) {
|
|
ret << "^" << sig.ElectricCurrent;
|
|
}
|
|
}
|
|
|
|
if (sig.ThermodynamicTemperature > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "K";
|
|
if (sig.ThermodynamicTemperature > 1) {
|
|
ret << "^" << sig.ThermodynamicTemperature;
|
|
}
|
|
}
|
|
|
|
if (sig.AmountOfSubstance > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "mol";
|
|
if (sig.AmountOfSubstance > 1) {
|
|
ret << "^" << sig.AmountOfSubstance;
|
|
}
|
|
}
|
|
|
|
if (sig.LuminousIntensity > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "cd";
|
|
if (sig.LuminousIntensity > 1) {
|
|
ret << "^" << sig.LuminousIntensity;
|
|
}
|
|
}
|
|
|
|
if (sig.Angle > 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "deg";
|
|
if (sig.Angle > 1) {
|
|
ret << "^" << sig.Angle;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ret << "1";
|
|
}
|
|
|
|
if (sig.Length < 0 ||
|
|
sig.Mass < 0 ||
|
|
sig.Time < 0 ||
|
|
sig.ElectricCurrent < 0 ||
|
|
sig.ThermodynamicTemperature < 0 ||
|
|
sig.AmountOfSubstance < 0 ||
|
|
sig.LuminousIntensity < 0 ||
|
|
sig.Angle < 0 ) {
|
|
ret << "/";
|
|
|
|
int nnom = 0;
|
|
nnom += sig.Length < 0 ? 1 : 0;
|
|
nnom += sig.Mass < 0 ? 1 : 0;
|
|
nnom += sig.Time < 0 ? 1 : 0;
|
|
nnom += sig.ElectricCurrent < 0 ? 1 : 0;
|
|
nnom += sig.ThermodynamicTemperature < 0 ? 1 : 0;
|
|
nnom += sig.AmountOfSubstance < 0 ? 1 : 0;
|
|
nnom += sig.LuminousIntensity < 0 ? 1 : 0;
|
|
nnom += sig.Angle < 0 ? 1 : 0;
|
|
|
|
if (nnom > 1) {
|
|
ret << '(';
|
|
}
|
|
|
|
bool mult = false;
|
|
if (sig.Length < 0) {
|
|
ret << "mm";
|
|
mult = true;
|
|
if (sig.Length < -1) {
|
|
ret << "^" << abs(sig.Length);
|
|
}
|
|
}
|
|
|
|
if (sig.Mass < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "kg";
|
|
if (sig.Mass < -1) {
|
|
ret << "^" << abs(sig.Mass);
|
|
}
|
|
}
|
|
|
|
if (sig.Time < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "s";
|
|
if (sig.Time < -1) {
|
|
ret << "^" << abs(sig.Time);
|
|
}
|
|
}
|
|
|
|
if (sig.ElectricCurrent < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "A";
|
|
if (sig.ElectricCurrent < -1) {
|
|
ret << "^" << abs(sig.ElectricCurrent);
|
|
}
|
|
}
|
|
|
|
if (sig.ThermodynamicTemperature < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "K";
|
|
if (sig.ThermodynamicTemperature < -1) {
|
|
ret << "^" << abs(sig.ThermodynamicTemperature);
|
|
}
|
|
}
|
|
|
|
if (sig.AmountOfSubstance < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "mol";
|
|
if (sig.AmountOfSubstance < -1) {
|
|
ret << "^" << abs(sig.AmountOfSubstance);
|
|
}
|
|
}
|
|
|
|
if (sig.LuminousIntensity < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "cd";
|
|
if (sig.LuminousIntensity < -1) {
|
|
ret << "^" << abs(sig.LuminousIntensity);
|
|
}
|
|
}
|
|
|
|
if (sig.Angle < 0) {
|
|
if (mult) {
|
|
ret << '*';
|
|
}
|
|
mult = true;
|
|
ret << "deg";
|
|
if (sig.Angle < -1) {
|
|
ret << "^" << abs(sig.Angle);
|
|
}
|
|
}
|
|
|
|
if (nnom > 1) {
|
|
ret << ')';
|
|
}
|
|
}
|
|
|
|
return ret.str();
|
|
}
|
|
|
|
std::string Unit::getTypeString() const
|
|
{
|
|
static std::array<std::pair<Unit, std::string>, 55> unitSpecs {{
|
|
{ Unit::Acceleration, "Acceleration" },
|
|
{ Unit::AmountOfSubstance, "AmountOfSubstance" },
|
|
{ Unit::Angle, "Angle" },
|
|
{ Unit::AngleOfFriction, "AngleOfFriction" },
|
|
{ Unit::Area, "Area" },
|
|
{ Unit::CurrentDensity, "CurrentDensity" },
|
|
{ Unit::Density, "Density" },
|
|
{ Unit::DissipationRate, "DissipationRate" },
|
|
{ Unit::DynamicViscosity, "DynamicViscosity" },
|
|
{ Unit::ElectricalCapacitance, "ElectricalCapacitance" },
|
|
{ Unit::ElectricalConductance, "ElectricalConductance" },
|
|
{ Unit::ElectricalConductivity, "ElectricalConductivity" },
|
|
{ Unit::ElectricalInductance, "ElectricalInductance" },
|
|
{ Unit::ElectricalResistance, "ElectricalResistance" },
|
|
{ Unit::ElectricCharge, "ElectricCharge" },
|
|
{ Unit::ElectricCurrent, "ElectricCurrent" },
|
|
{ Unit::ElectricPotential, "ElectricPotential" },
|
|
{ Unit::ElectromagneticPotential, "ElectromagneticPotential" },
|
|
{ Unit::Frequency, "Frequency" },
|
|
{ Unit::Force, "Force" },
|
|
{ Unit::HeatFlux, "HeatFlux" },
|
|
{ Unit::InverseArea, "InverseArea" },
|
|
{ Unit::InverseLength, "InverseLength" },
|
|
{ Unit::InverseVolume, "InverseVolume" },
|
|
{ Unit::KinematicViscosity, "KinematicViscosity" },
|
|
{ Unit::Length, "Length" },
|
|
{ Unit::LuminousIntensity, "LuminousIntensity" },
|
|
{ Unit::MagneticFieldStrength, "MagneticFieldStrength" },
|
|
{ Unit::MagneticFlux, "MagneticFlux" },
|
|
{ Unit::MagneticFluxDensity, "MagneticFluxDensity" },
|
|
{ Unit::Magnetization, "Magnetization" },
|
|
{ Unit::Mass, "Mass" },
|
|
{ Unit::Pressure, "Pressure" },
|
|
{ Unit::Power, "Power" },
|
|
{ Unit::ShearModulus, "ShearModulus" },
|
|
{ Unit::SpecificEnergy, "SpecificEnergy" },
|
|
{ Unit::SpecificHeat, "SpecificHeat" },
|
|
{ Unit::Stiffness, "Stiffness" },
|
|
{ Unit::StiffnessDensity, "StiffnessDensity" },
|
|
{ Unit::Stress, "Stress" },
|
|
{ Unit::Temperature, "Temperature" },
|
|
{ Unit::ThermalConductivity, "ThermalConductivity" },
|
|
{ Unit::ThermalExpansionCoefficient, "ThermalExpansionCoefficient" },
|
|
{ Unit::ThermalTransferCoefficient, "ThermalTransferCoefficient" },
|
|
{ Unit::TimeSpan, "TimeSpan" },
|
|
{ Unit::UltimateTensileStrength, "UltimateTensileStrength" },
|
|
{ Unit::VacuumPermittivity, "VacuumPermittivity" },
|
|
{ Unit::Velocity, "Velocity" },
|
|
{ Unit::Volume, "Volume" },
|
|
{ Unit::VolumeFlowRate, "VolumeFlowRate" },
|
|
{ Unit::VolumetricThermalExpansionCoefficient, "VolumetricThermalExpansionCoefficient" },
|
|
{ Unit::Work, "Work" },
|
|
{ Unit::YieldStrength, "YieldStrength" },
|
|
{ Unit::YoungsModulus, "YoungsModulus" },
|
|
{ Unit::Moment, "Moment" },
|
|
}};
|
|
|
|
const auto spec =
|
|
std::find_if(unitSpecs.begin(), unitSpecs.end(), [&](const auto& pair) {
|
|
return pair.first == *this;
|
|
});
|
|
|
|
if (spec == std::end(unitSpecs))
|
|
return "";
|
|
|
|
return spec->second;
|
|
}
|
|
|
|
// SI base units
|
|
const Unit Unit::AmountOfSubstance (0, 0, 0, 0, 0, 1);
|
|
const Unit Unit::ElectricCurrent (0, 0, 0, 1);
|
|
const Unit Unit::Length (1);
|
|
const Unit Unit::LuminousIntensity (0, 0, 0, 0, 0, 0, 1);
|
|
const Unit Unit::Mass (0, 1);
|
|
const Unit Unit::Temperature (0, 0, 0, 0, 1);
|
|
const Unit Unit::TimeSpan (0, 0, 1);
|
|
|
|
// all other units
|
|
const Unit Unit::Acceleration (1, 0, -2);
|
|
const Unit Unit::Angle (0, 0, 0, 0, 0, 0, 0, 1);
|
|
const Unit Unit::AngleOfFriction (0, 0, 0, 0, 0, 0, 0, 1);
|
|
const Unit Unit::Area (2);
|
|
const Unit Unit::CompressiveStrength (-1, 1, -2);
|
|
const Unit Unit::CurrentDensity (-2, 0, 0, 1);
|
|
const Unit Unit::Density (-3, 1);
|
|
const Unit Unit::DissipationRate (2, 0, -3); // https://cfd-online.com/Wiki/Turbulence_dissipation_rate
|
|
const Unit Unit::DynamicViscosity (-1, 1, -1);
|
|
const Unit Unit::ElectricalCapacitance (-2, -1, 4, 2);
|
|
const Unit Unit::ElectricalConductance (-2, -1, 3, 2);
|
|
const Unit Unit::ElectricalConductivity (-3, -1, 3, 2);
|
|
const Unit Unit::ElectricalInductance (2, 1, -2, -2);
|
|
const Unit Unit::ElectricalResistance (2, 1, -3, -2);
|
|
const Unit Unit::ElectricCharge (0, 0, 1, 1);
|
|
const Unit Unit::ElectricPotential (2, 1, -3, -1);
|
|
const Unit Unit::ElectromagneticPotential (1, 1, -2, -1);
|
|
const Unit Unit::Force (1, 1, -2);
|
|
const Unit Unit::Frequency (0, 0, -1);
|
|
const Unit Unit::HeatFlux (0, 1, -3, 0, 0);
|
|
const Unit Unit::InverseArea (-2, 0, 0);
|
|
const Unit Unit::InverseLength (-1, 0, 0);
|
|
const Unit Unit::InverseVolume (-3, 0, 0);
|
|
const Unit Unit::KinematicViscosity (2, 0, -1);
|
|
const Unit Unit::MagneticFieldStrength (-1,0,0,1);
|
|
const Unit Unit::MagneticFlux (2,1,-2,-1);
|
|
const Unit Unit::MagneticFluxDensity (0,1,-2,-1);
|
|
const Unit Unit::Magnetization (-1,0,0,1);
|
|
const Unit Unit::Moment (2, 1, -2);
|
|
const Unit Unit::Pressure (-1,1,-2);
|
|
const Unit Unit::Power (2, 1, -3);
|
|
const Unit Unit::ShearModulus (-1,1,-2);
|
|
const Unit Unit::SpecificEnergy (2, 0, -2);
|
|
const Unit Unit::SpecificHeat (2, 0, -2, 0, -1);
|
|
const Unit Unit::Stiffness (0, 1, -2);
|
|
const Unit Unit::StiffnessDensity (-2, 1, -2);
|
|
const Unit Unit::Stress (-1,1,-2);
|
|
const Unit Unit::ThermalConductivity (1, 1, -3, 0, -1);
|
|
const Unit Unit::ThermalExpansionCoefficient(0, 0, 0, 0, -1);
|
|
const Unit Unit::ThermalTransferCoefficient (0, 1, -3, 0, -1);
|
|
const Unit Unit::UltimateTensileStrength (-1,1,-2);
|
|
const Unit Unit::VacuumPermittivity (-3, -1, 4, 2);
|
|
const Unit Unit::Velocity (1, 0, -1);
|
|
const Unit Unit::Volume (3);
|
|
const Unit Unit::VolumeFlowRate (3, 0, -1);
|
|
const Unit Unit::VolumetricThermalExpansionCoefficient(0, 0, 0, 0, -1);
|
|
const Unit Unit::Work (2, 1, -2);
|
|
const Unit Unit::YieldStrength (-1,1,-2);
|
|
const Unit Unit::YoungsModulus (-1,1,-2);
|
|
// clang-format on
|