Units.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseTypes.h"
#include "MooseError.h"
#include <vector>
#include <iostream>
 
class MooseUnits;
 
// power function injected into std
namespace std
{
MooseUnits pow(const MooseUnits &, int);
}
 
// output stream operator
std::ostream & operator<<(std::ostream & os, const MooseUnits & u);
 
class MooseUnits
{
  enum class BaseUnit
  {
    METER,
    KILOGRAM,
    SECOND,
    AMPERE,
    KELVIN,
    COUNT,
    CANDELA
  };
 
public:
  MooseUnits(const std::string & unit_string);
  MooseUnits(Real f) : _factor(f), _shift(), _base() {}
  MooseUnits(Real f, Real s, std::vector<std::pair<MooseUnits::BaseUnit, int>> b)
    : _factor(f), _shift(s), _base(b)
  {
  }
 
  bool conformsTo(const MooseUnits &) const;
 
  Real convert(Real from_value, const MooseUnits & from_unit) const;
 
  void parse(const std::string & unit_string);
 
  void simplify();
 
  static const std::map<std::string, Real> _si_prefix;
  static const std::vector<std::pair<std::string, MooseUnits>> _unit_table;
 
  bool isLength() const { return isBase(BaseUnit::METER); }
  bool isTime() const { return isBase(BaseUnit::SECOND); }
  bool isMass() const { return isBase(BaseUnit::KILOGRAM); }
  bool isCurrent() const { return isBase(BaseUnit::AMPERE); }
  bool isTemperature() const { return isBase(BaseUnit::KELVIN); }
 
  MooseUnits operator*(const Real f) const;
 
  MooseUnits operator*(const MooseUnits & rhs) const;
  MooseUnits operator/(const MooseUnits & rhs) const;
 
  bool operator==(const MooseUnits & rhs) const;
  bool operator==(const Real rhs) const;
 
  explicit operator Real() const;
 
  friend std::ostream & operator<<(std::ostream & os, const MooseUnits & dt);
  friend MooseUnits std::pow(const MooseUnits &, int);
 
  static std::ostream & latex(std::ostream & os);
  static std::ostream & text(std::ostream & os);
 
protected:
  template <typename... Args>
  void parseError(const std::string & unit_string, std::string::const_iterator it, Args... args);
 
  Real _factor;
 
  Real _shift;
 
  bool isBase(const MooseUnits::BaseUnit) const;
 
  std::vector<std::pair<BaseUnit, int>> _base;
 
  static int geti();
};
 
template <typename... Args>
void
MooseUnits::parseError(const std::string & unit_string,
                       std::string::const_iterator it,
                       Args... args)
{
  auto d = std::distance(unit_string.begin(), it);
  mooseError("At position ", d, " in ", unit_string, ": ", std::forward<Args>(args)...);
}