Units.hpp

Go to the documentation of this file.

/*
 * -------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MATH_UNITS_HPP_
#define GEOS_MATH_UNITS_HPP_
 
#include "common/DataTypes.hpp"
#include "common/PhysicsConstants.hpp"
 
namespace geos
{
 
namespace units
{
 
 
GEOS_HOST_DEVICE
inline constexpr double convertKToC( double kelvin )
{ return kelvin - constants::zeroDegreesCelsiusInKelvin; }
GEOS_HOST_DEVICE
inline constexpr double convertCToK( double celsius )
{ return celsius + constants::zeroDegreesCelsiusInKelvin; }
 
 
enum Unit : integer
{
  Unknown,
 
  Dimensionless,
 
  Pressure,
 
  Temperature,
 
  TemperatureInC,
 
  Distance,
 
  Time,
 
  Viscosity,
 
  Density,
 
  Enthalpy,
 
  Solubility,
};
 
 
constexpr inline std::string_view getDescription( Unit unit )
{
  switch( unit )
  {
    default:              return "unknown [?]";
    case Dimensionless:   return "dimensionless [1]";
    case Pressure:        return "pressure [Pa]";
    case Temperature:     return "temperature [K]";
    case TemperatureInC:  return "temperature [C]";
    case Distance:        return "distance [m]";
    case Time:            return "time [s]";
    case Viscosity:       return "viscosity [Pa*s]";
    case Enthalpy:        return "enthalpy [J/kg]";
    case Density:         return "density [kg/m3]";
    case Solubility:      return "solubility [g/L]";
  }
}
 
constexpr inline std::string_view getSymbol( Unit unit )
{
  switch( unit )
  {
    default:              return "?";
    case Dimensionless:   return "1";
    case Pressure:        return "Pa";
    case Temperature:     return "K";
    case TemperatureInC:  return "C";
    case Distance:        return "m";
    case Time:            return "s";
  }
}
 
inline string formatValue( real64 value, Unit unit )
{
  switch( unit )
  {
    default:              return GEOS_FMT( "value of {} [?]", value );
    case Dimensionless:   return GEOS_FMT( "value of {} [1]", value );
    case Pressure:        return GEOS_FMT( "pressure of {} [Pa]", value );
    case Temperature:     return GEOS_FMT( "temperature of {} [K]", value );
    case TemperatureInC:  return GEOS_FMT( "temperature of {} [K]", convertCToK( value ) );
    case Distance:        return GEOS_FMT( "distance of {} [s]", value );
    case Time:            return GEOS_FMT( "time of {} [s]", value );
  }
}
 
 
using SystemClock = std::chrono::system_clock;
 
using YearDaysRatio = std::ratio< 146097, 400 >;
using Days = std::chrono::duration< int64_t, std::ratio_multiply< std::ratio< 24 >, std::chrono::hours::period > >;
using Years = std::chrono::duration< int64_t, std::ratio_multiply< YearDaysRatio, Days::period > >;
 
static constexpr double YearDays = ( double )YearDaysRatio::num / YearDaysRatio::den;
static constexpr double MinuteSeconds = 60.0;
static constexpr double HourSeconds = 60.0 * MinuteSeconds;
static constexpr double DaySeconds = 24.0 * HourSeconds;
static constexpr double YearSeconds = YearDays * DaySeconds;
 
 
struct TimeFormatInfo
{
  double m_totalSeconds = 0.0;
  int m_years = 0;
  int m_days = 0;
  int m_hours = 0;
  int m_minutes = 0;
  int m_seconds = 0;
 
 
  TimeFormatInfo( double totalSeconds, int years, int days, int hours, int minutes, int seconds );
  static TimeFormatInfo fromSeconds( double const seconds );
  template< typename DURATION > static TimeFormatInfo fromDuration( DURATION duration );
 
  friend std::ostream & operator<<( std::ostream & os, TimeFormatInfo const & ctx );
 
  string toString() const;
};
 
 
} // end namespace units
 
} // end namespace geos
 
 
template<>
struct GEOS_FMT_NS::formatter< geos::units::TimeFormatInfo > : GEOS_FMT_NS::formatter< std::string >
{
  auto format( geos::units::TimeFormatInfo const & durationData, format_context & ctx )
  {
    return GEOS_FMT_NS::formatter< std::string >::format( durationData.toString(), ctx );
  }
};
 
#endif //GEOS_MATH_PHYSICSCONSTANTS_HPP_