Units.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/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"
#include "common/format/Format.hpp"
 
namespace geos
{
 
namespace units
{
 
static constexpr double DarcyToSqM = 9.869233e-13;
 
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,
 
  Mass,
 
  Mole,
 
  MassRate,
 
  MoleRate,
 
  Transmissibility,
 
  MolarVolume,
 
  MolarDensity,
 
  Permeability,
};
 
 
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]";
    case Mass:              return "mass [kg]";
    case Mole:              return "mole [mol]";
    case MassRate:          return "mass rate [kg/s]";
    case MoleRate:          return "mole rate [mol/s]";
    case Transmissibility:  return "transmissibility [(Pa*s*rm3/s)/Pa]";
    case MolarVolume:       return "molar volume [m3/mol]";
    case MolarDensity:      return "molar density [mol/m3]";
    case Permeability:      return "permeability [m2]";
  }
}
 
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";
    case Viscosity:         return "Pa*s";
    case Enthalpy:          return "J/kg";
    case Density:           return "kg/m3";
    case Solubility:        return "g/L";
    case Mass:              return "kg";
    case Mole:              return "mol";
    case MassRate:          return "kg/s";
    case MoleRate:          return "mol/s";
    case Transmissibility:  return "(Pa*s*rm3/s)/Pa";
    case MolarVolume:       return "m3/mol";
    case MolarDensity:      return "mol/m3";
    case Permeability:      return "m2";
  }
}
 
constexpr inline std::string_view getVariableSymbol( Unit unit )
{
  switch( unit )
  {
    default:
    case Dimensionless:     return "?";
    case Pressure:          return "P";
    case Temperature:       return "T";
    case TemperatureInC:    return "T";
    case Distance:          return "L";
    case Time:              return "t";
    case Viscosity:         return "mu";
    case Enthalpy:          return "H";
    case Density:           return "rho";
    case Solubility:        return "S";
    case Mass:              return "m";
    case Mole:              return "n";
    case MassRate:          return "Q_m";
    case MoleRate:          return "Q_n";
    case Transmissibility:  return "T_r";
    case MolarVolume:       return "V_m";
    case MolarDensity:      return "rho_n";
    case Permeability:      return "K";
  }
}
 
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 );
    case Viscosity:         return GEOS_FMT( "viscosity of {} [Pa*s]", value );
    case Enthalpy:          return GEOS_FMT( "enthalpy of {} [J/kg]", value );
    case Density:           return GEOS_FMT( "density of {} [kg/m3]", value );
    case Solubility:        return GEOS_FMT( "solubility of {} [g/L]", value );
    case Mass:              return GEOS_FMT( "mass of {} [kg]", value );
    case Mole:              return GEOS_FMT( "mole of {} [mol]", value );
    case MassRate:          return GEOS_FMT( "mass rate of {} [kg/s]", value );
    case MoleRate:          return GEOS_FMT( "mole rate of {} [mol/s]", value );
    case Transmissibility:  return GEOS_FMT( "transmissibility of {} [(Pa*s*rm3/s)/Pa]", value );
    case MolarVolume:       return GEOS_FMT( "molar volume of {} [m3/mol]", value );
    case MolarDensity:      return GEOS_FMT( "molar density of {} [mol/m3]", value );
    case Permeability:      return GEOS_FMT( "permeability of {} [m2]", value );
  }
}
 
 
using SystemClock = std::chrono::high_resolution_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 const m_totalSeconds = 0.0;
  int const m_years = 0;
  int const m_days = 0;
  int const m_hours = 0;
  int const m_minutes = 0;
  int const 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;
 
  string toUnfoldedString() const;
 
  string toSecondsString() const;
};
 
template< typename DURATION >
TimeFormatInfo TimeFormatInfo::fromDuration( DURATION const value )
{
  using namespace std::chrono;
 
  auto const totalYears = duration_cast< units::Years >( value );
  auto const daysOut = duration_cast< units::Days >( value - totalYears );
  auto const hoursOut = duration_cast< hours >( value - totalYears - daysOut );
  auto const minutesOut = duration_cast< minutes >( value - totalYears - daysOut - hoursOut );
  auto const secondsOut = duration_cast< seconds >( value - totalYears - daysOut - hoursOut - minutesOut );
 
  return TimeFormatInfo( duration< double >( value ).count(), int( totalYears.count() ),
                         int( daysOut.count() ), int( hoursOut.count() ),
                         int( minutesOut.count() ), int( secondsOut.count() ) );
}
 
} // 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 ) const
  {
    return GEOS_FMT_NS::formatter< std::string >::format( durationData.toString(), ctx );
  }
};
 
#endif //GEOS_MATH_PHYSICSCONSTANTS_HPP_