696 lines
25 KiB
C++
696 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 <cmath>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#endif
|
|
|
|
#include "Unit.h"
|
|
#include "Exception.h"
|
|
#include "Quantity.h"
|
|
|
|
|
|
using namespace Base;
|
|
|
|
// clang-format off
|
|
static inline void checkPow(UnitSignature sig, double exp)
|
|
{
|
|
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");
|
|
}
|
|
}
|
|
|
|
static inline void checkRange(const char * 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((std::string("Unit overflow in ") + std::string(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((std::string("Unit underflow in ") + std::string(op)).c_str());
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
checkRange("unit",
|
|
Length,
|
|
Mass,
|
|
Time,
|
|
ElectricCurrent,
|
|
ThermodynamicTemperature,
|
|
AmountOfSubstance,
|
|
LuminousIntensity,
|
|
Angle);
|
|
|
|
Sig.Length = Length;
|
|
Sig.Mass = Mass;
|
|
Sig.Time = Time;
|
|
Sig.ElectricCurrent = ElectricCurrent;
|
|
Sig.ThermodynamicTemperature = ThermodynamicTemperature;
|
|
Sig.AmountOfSubstance = AmountOfSubstance;
|
|
Sig.LuminousIntensity = LuminousIntensity;
|
|
Sig.Angle = Angle;
|
|
}
|
|
|
|
|
|
Unit::Unit() //NOLINT
|
|
{
|
|
Sig.Length = 0;
|
|
Sig.Mass = 0;
|
|
Sig.Time = 0;
|
|
Sig.ElectricCurrent = 0;
|
|
Sig.ThermodynamicTemperature = 0;
|
|
Sig.AmountOfSubstance = 0;
|
|
Sig.LuminousIntensity = 0;
|
|
Sig.Angle = 0;
|
|
}
|
|
|
|
Unit::Unit(const QString& expr) // NOLINT
|
|
{
|
|
try {
|
|
*this = Quantity::parse(expr).getUnit();
|
|
}
|
|
catch (const Base::ParserError&) {
|
|
Sig.Length = 0;
|
|
Sig.Mass = 0;
|
|
Sig.Time = 0;
|
|
Sig.ElectricCurrent = 0;
|
|
Sig.ThermodynamicTemperature = 0;
|
|
Sig.AmountOfSubstance = 0;
|
|
Sig.LuminousIntensity = 0;
|
|
Sig.Angle = 0;
|
|
}
|
|
}
|
|
|
|
Unit Unit::pow(double exp) const
|
|
{
|
|
checkPow(Sig, exp);
|
|
checkRange("pow()",
|
|
static_cast<int>(Sig.Length * exp),
|
|
static_cast<int>(Sig.Mass * exp),
|
|
static_cast<int>(Sig.Time * exp),
|
|
static_cast<int>(Sig.ElectricCurrent * exp),
|
|
static_cast<int>(Sig.ThermodynamicTemperature * exp),
|
|
static_cast<int>(Sig.AmountOfSubstance * exp),
|
|
static_cast<int>(Sig.LuminousIntensity * exp),
|
|
static_cast<int>(Sig.Angle * exp));
|
|
|
|
Unit result;
|
|
result.Sig.Length = static_cast<int8_t>(Sig.Length * exp);
|
|
result.Sig.Mass = static_cast<int8_t>(Sig.Mass * exp);
|
|
result.Sig.Time = static_cast<int8_t>(Sig.Time * exp);
|
|
result.Sig.ElectricCurrent = static_cast<int8_t>(Sig.ElectricCurrent * exp);
|
|
result.Sig.ThermodynamicTemperature = static_cast<int8_t>(Sig.ThermodynamicTemperature * exp);
|
|
result.Sig.AmountOfSubstance = static_cast<int8_t>(Sig.AmountOfSubstance * exp);
|
|
result.Sig.LuminousIntensity = static_cast<int8_t>(Sig.LuminousIntensity * exp);
|
|
result.Sig.Angle = static_cast<int8_t>(Sig.Angle * exp);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool Unit::isEmpty()const
|
|
{
|
|
return (this->Sig.Length == 0)
|
|
&& (this->Sig.Mass == 0)
|
|
&& (this->Sig.Time == 0)
|
|
&& (this->Sig.ElectricCurrent == 0)
|
|
&& (this->Sig.ThermodynamicTemperature == 0)
|
|
&& (this->Sig.AmountOfSubstance == 0)
|
|
&& (this->Sig.LuminousIntensity == 0)
|
|
&& (this->Sig.Angle == 0);
|
|
}
|
|
|
|
bool Unit::operator ==(const Unit& that) const
|
|
{
|
|
return (this->Sig.Length == that.Sig.Length)
|
|
&& (this->Sig.Mass == that.Sig.Mass)
|
|
&& (this->Sig.Time == that.Sig.Time)
|
|
&& (this->Sig.ElectricCurrent == that.Sig.ElectricCurrent)
|
|
&& (this->Sig.ThermodynamicTemperature == that.Sig.ThermodynamicTemperature)
|
|
&& (this->Sig.AmountOfSubstance == that.Sig.AmountOfSubstance)
|
|
&& (this->Sig.LuminousIntensity == that.Sig.LuminousIntensity)
|
|
&& (this->Sig.Angle == that.Sig.Angle);
|
|
}
|
|
|
|
|
|
Unit Unit::operator *(const Unit &right) const
|
|
{
|
|
checkRange("* operator",
|
|
Sig.Length +right.Sig.Length,
|
|
Sig.Mass + right.Sig.Mass,
|
|
Sig.Time + right.Sig.Time,
|
|
Sig.ElectricCurrent + right.Sig.ElectricCurrent,
|
|
Sig.ThermodynamicTemperature + right.Sig.ThermodynamicTemperature,
|
|
Sig.AmountOfSubstance + right.Sig.AmountOfSubstance,
|
|
Sig.LuminousIntensity + right.Sig.LuminousIntensity,
|
|
Sig.Angle + right.Sig.Angle);
|
|
|
|
Unit result;
|
|
result.Sig.Length = Sig.Length + right.Sig.Length;
|
|
result.Sig.Mass = Sig.Mass + right.Sig.Mass;
|
|
result.Sig.Time = Sig.Time + right.Sig.Time;
|
|
result.Sig.ElectricCurrent = Sig.ElectricCurrent + right.Sig.ElectricCurrent;
|
|
result.Sig.ThermodynamicTemperature = Sig.ThermodynamicTemperature + right.Sig.ThermodynamicTemperature;
|
|
result.Sig.AmountOfSubstance = Sig.AmountOfSubstance + right.Sig.AmountOfSubstance;
|
|
result.Sig.LuminousIntensity = Sig.LuminousIntensity + right.Sig.LuminousIntensity;
|
|
result.Sig.Angle = Sig.Angle + right.Sig.Angle;
|
|
|
|
return result;
|
|
}
|
|
|
|
Unit Unit::operator /(const Unit &right) const
|
|
{
|
|
checkRange("/ operator",
|
|
Sig.Length - right.Sig.Length,
|
|
Sig.Mass - right.Sig.Mass,
|
|
Sig.Time - right.Sig.Time,
|
|
Sig.ElectricCurrent - right.Sig.ElectricCurrent,
|
|
Sig.ThermodynamicTemperature - right.Sig.ThermodynamicTemperature,
|
|
Sig.AmountOfSubstance - right.Sig.AmountOfSubstance,
|
|
Sig.LuminousIntensity - right.Sig.LuminousIntensity,
|
|
Sig.Angle - right.Sig.Angle);
|
|
|
|
Unit result;
|
|
result.Sig.Length = Sig.Length - right.Sig.Length;
|
|
result.Sig.Mass = Sig.Mass - right.Sig.Mass;
|
|
result.Sig.Time = Sig.Time - right.Sig.Time;
|
|
result.Sig.ElectricCurrent = Sig.ElectricCurrent - right.Sig.ElectricCurrent;
|
|
result.Sig.ThermodynamicTemperature = Sig.ThermodynamicTemperature - right.Sig.ThermodynamicTemperature;
|
|
result.Sig.AmountOfSubstance = Sig.AmountOfSubstance - right.Sig.AmountOfSubstance;
|
|
result.Sig.LuminousIntensity = Sig.LuminousIntensity - right.Sig.LuminousIntensity;
|
|
result.Sig.Angle = Sig.Angle - right.Sig.Angle;
|
|
|
|
return result;
|
|
}
|
|
|
|
QString Unit::getString() const
|
|
{
|
|
std::stringstream ret;
|
|
|
|
if (isEmpty()) {
|
|
return {};
|
|
}
|
|
|
|
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; //NOLINT
|
|
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; //NOLINT
|
|
ret << "deg";
|
|
if (Sig.Angle < -1) {
|
|
ret << "^" << abs(Sig.Angle);
|
|
}
|
|
}
|
|
|
|
if (nnom > 1) {
|
|
ret << ')';
|
|
}
|
|
}
|
|
|
|
return QString::fromUtf8(ret.str().c_str());
|
|
}
|
|
|
|
QString Unit::getTypeString() const
|
|
{
|
|
if (*this == Unit::Acceleration) {
|
|
return QString::fromLatin1("Acceleration");
|
|
}
|
|
if (*this == Unit::AmountOfSubstance) {
|
|
return QString::fromLatin1("AmountOfSubstance");
|
|
}
|
|
if (*this == Unit::Angle) {
|
|
return QString::fromLatin1("Angle");
|
|
}
|
|
if (*this == Unit::AngleOfFriction) {
|
|
return QString::fromLatin1("AngleOfFriction");
|
|
}
|
|
if (*this == Unit::Area) {
|
|
return QString::fromLatin1("Area");
|
|
}
|
|
if (*this == Unit::CurrentDensity) {
|
|
return QString::fromLatin1("CurrentDensity");
|
|
}
|
|
if (*this == Unit::Density) {
|
|
return QString::fromLatin1("Density");
|
|
}
|
|
if (*this == Unit::DissipationRate) {
|
|
return QString::fromLatin1("DissipationRate");
|
|
}
|
|
if (*this == Unit::DynamicViscosity) {
|
|
return QString::fromLatin1("DynamicViscosity");
|
|
}
|
|
if (*this == Unit::ElectricalCapacitance) {
|
|
return QString::fromLatin1("ElectricalCapacitance");
|
|
}
|
|
if (*this == Unit::ElectricalConductance) {
|
|
return QString::fromLatin1("ElectricalConductance");
|
|
}
|
|
if (*this == Unit::ElectricalConductivity) {
|
|
return QString::fromLatin1("ElectricalConductivity");
|
|
}
|
|
if (*this == Unit::ElectricalInductance) {
|
|
return QString::fromLatin1("ElectricalInductance");
|
|
}
|
|
if (*this == Unit::ElectricalResistance) {
|
|
return QString::fromLatin1("ElectricalResistance");
|
|
}
|
|
if (*this == Unit::ElectricCharge) {
|
|
return QString::fromLatin1("ElectricCharge");
|
|
}
|
|
if (*this == Unit::ElectricCurrent) {
|
|
return QString::fromLatin1("ElectricCurrent");
|
|
}
|
|
if (*this == Unit::ElectricPotential) {
|
|
return QString::fromLatin1("ElectricPotential");
|
|
}
|
|
if (*this == Unit::ElectromagneticPotential) {
|
|
return QString::fromLatin1("ElectromagneticPotential");
|
|
}
|
|
if (*this == Unit::Frequency) {
|
|
return QString::fromLatin1("Frequency");
|
|
}
|
|
if (*this == Unit::Force) {
|
|
return QString::fromLatin1("Force");
|
|
}
|
|
if (*this == Unit::HeatFlux) {
|
|
return QString::fromLatin1("HeatFlux");
|
|
}
|
|
if (*this == Unit::InverseArea) {
|
|
return QString::fromLatin1("InverseArea");
|
|
}
|
|
if (*this == Unit::InverseLength) {
|
|
return QString::fromLatin1("InverseLength");
|
|
}
|
|
if (*this == Unit::InverseVolume) {
|
|
return QString::fromLatin1("InverseVolume");
|
|
}
|
|
if (*this == Unit::KinematicViscosity) {
|
|
return QString::fromLatin1("KinematicViscosity");
|
|
}
|
|
if (*this == Unit::Length) {
|
|
return QString::fromLatin1("Length");
|
|
}
|
|
if (*this == Unit::LuminousIntensity) {
|
|
return QString::fromLatin1("LuminousIntensity");
|
|
}
|
|
if (*this == Unit::MagneticFieldStrength) {
|
|
return QString::fromLatin1("MagneticFieldStrength");
|
|
}
|
|
if (*this == Unit::MagneticFlux) {
|
|
return QString::fromLatin1("MagneticFlux");
|
|
}
|
|
if (*this == Unit::MagneticFluxDensity) {
|
|
return QString::fromLatin1("MagneticFluxDensity");
|
|
}
|
|
if (*this == Unit::Magnetization) {
|
|
return QString::fromLatin1("Magnetization");
|
|
}
|
|
if (*this == Unit::Mass) {
|
|
return QString::fromLatin1("Mass");
|
|
}
|
|
if (*this == Unit::Pressure) {
|
|
return QString::fromLatin1("Pressure");
|
|
}
|
|
if (*this == Unit::Power) {
|
|
return QString::fromLatin1("Power");
|
|
}
|
|
if (*this == Unit::ShearModulus) {
|
|
return QString::fromLatin1("ShearModulus");
|
|
}
|
|
if (*this == Unit::SpecificEnergy) {
|
|
return QString::fromLatin1("SpecificEnergy");
|
|
}
|
|
if (*this == Unit::SpecificHeat) {
|
|
return QString::fromLatin1("SpecificHeat");
|
|
}
|
|
if (*this == Unit::Stiffness) {
|
|
return QString::fromLatin1("Stiffness");
|
|
}
|
|
if (*this == Unit::StiffnessDensity) {
|
|
return QString::fromLatin1("StiffnessDensity");
|
|
}
|
|
if (*this == Unit::Stress) {
|
|
return QString::fromLatin1("Stress");
|
|
}
|
|
if (*this == Unit::Temperature) {
|
|
return QString::fromLatin1("Temperature");
|
|
}
|
|
if (*this == Unit::ThermalConductivity) {
|
|
return QString::fromLatin1("ThermalConductivity");
|
|
}
|
|
if (*this == Unit::ThermalExpansionCoefficient) {
|
|
return QString::fromLatin1("ThermalExpansionCoefficient");
|
|
}
|
|
if (*this == Unit::ThermalTransferCoefficient) {
|
|
return QString::fromLatin1("ThermalTransferCoefficient");
|
|
}
|
|
if (*this == Unit::TimeSpan) {
|
|
return QString::fromLatin1("TimeSpan");
|
|
}
|
|
if (*this == Unit::UltimateTensileStrength) {
|
|
return QString::fromLatin1("UltimateTensileStrength");
|
|
}
|
|
if (*this == Unit::VacuumPermittivity) {
|
|
return QString::fromLatin1("VacuumPermittivity");
|
|
}
|
|
if (*this == Unit::Velocity) {
|
|
return QString::fromLatin1("Velocity");
|
|
}
|
|
if (*this == Unit::Volume) {
|
|
return QString::fromLatin1("Volume");
|
|
}
|
|
if (*this == Unit::VolumeFlowRate) {
|
|
return QString::fromLatin1("VolumeFlowRate");
|
|
}
|
|
if (*this == Unit::VolumetricThermalExpansionCoefficient) {
|
|
return QString::fromLatin1("VolumetricThermalExpansionCoefficient");
|
|
}
|
|
if (*this == Unit::Work) {
|
|
return QString::fromLatin1("Work");
|
|
}
|
|
if (*this == Unit::YieldStrength) {
|
|
return QString::fromLatin1("YieldStrength");
|
|
}
|
|
if (*this == Unit::YoungsModulus) {
|
|
return QString::fromLatin1("YoungsModulus");
|
|
}
|
|
if (*this == Unit::Moment) {
|
|
return QString::fromLatin1("Moment");
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
// 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
|