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)...);
}