rock-physics-open 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

rock_physics_open/equinor_utilities/various_utilities/pressure.py

@@ -1,7 +1,15 @@
 import numpy as np
+import numpy.typing as npt
 
 
-def pressure(rho, tvd_msl, water_depth, p_form, tvd_p_form, n):
+def pressure(
+    rho: npt.NDArray[np.float64],
+    tvd_msl: npt.NDArray[np.float64],
+    water_depth: float,
+    p_form: float,
+    tvd_p_form: float,
+    n: float,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """
     Function to estimate overburden pressure and vertical effective stress (lithostatic pressure)
     based on density.

rock_physics_open/equinor_utilities/various_utilities/reflectivity.py

@@ -1,9 +1,19 @@
+from typing import Literal, cast
+
 import numpy as np
+import numpy.typing as npt
 
 from rock_physics_open.equinor_utilities import gen_utilities, std_functions
 
 
-def reflectivity(vp_inp, vs_inp, rho_inp, theta=0.0, k=2.0, model="AkiRichards"):
+def reflectivity(
+    vp_inp: npt.NDArray[np.float64],
+    vs_inp: npt.NDArray[np.float64],
+    rho_inp: npt.NDArray[np.float64],
+    theta: float = 0.0,
+    k: float = 2.0,
+    model: Literal["AkiRichards", "SmithGidlow"] = "AkiRichards",
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.bool_]]:
     """
     Reflectivity model according to Aki and Richards or Smith and Gidlow for weak contrasts
     and angles less than critical angle.
@@ -35,12 +45,17 @@ def reflectivity(vp_inp, vs_inp, rho_inp, theta=0.0, k=2.0, model="AkiRichards")
         idx_inp: index to accepted part of the input arrays [bool].
     """
 
-    vp, vs, rho, theta, k = gen_utilities.dim_check_vector(
-        (vp_inp, vs_inp, rho_inp, theta, k)
+    vp, vs, rho, theta_, k_ = cast(
+        list[npt.NDArray[np.float64]],
+        gen_utilities.dim_check_vector((vp_inp, vs_inp, rho_inp, theta, k)),
     )
 
-    idx_inp, (vp, vs, rho, theta, k) = gen_utilities.filter_input_log(
-        [vp, vs, rho, theta, k], positive=True
+    idx_inp, (vp, vs, rho, theta_, k_) = cast(
+        tuple[npt.NDArray[np.bool_], list[npt.NDArray[np.float64]]],
+        gen_utilities.filter_input_log(
+            [vp, vs, rho, theta_, k_],
+            positive=True,
+        ),
     )
 
     if np.any(~idx_inp):
@@ -69,16 +84,17 @@ def reflectivity(vp_inp, vs_inp, rho_inp, theta=0.0, k=2.0, model="AkiRichards")
                 > 1
             ) * "s"
             raise ValueError(
-                "{0:} reflectivity: Missing or illegal values in input log{1:}: {2:}interpolation of input log{1:} "
-                "is needed\n".format(model, log_str, pl_str)
+                "{0:} reflectivity: Missing or illegal values in input log{1:}: {2:}interpolation of input log{1:} is needed\n".format(
+                    model, log_str, pl_str
+                )
             )
 
     if model == "AkiRichards":
-        refl_coef = std_functions.aki_richards(vp, vs, rho, theta, k)
+        refl_coef = std_functions.aki_richards(vp, vs, rho, theta_, k_)
     elif model == "SmithGidlow":
-        refl_coef = std_functions.smith_gidlow(vp, vs, rho, theta, k)
+        refl_coef = std_functions.smith_gidlow(vp, vs, rho, theta_, k_)
     else:
-        raise ValueError(
+        raise ValueError(  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
             f'{__file__}: unknown model: {model}, should be one of "AkiRichards", "SmithGidlow"'
         )
 

rock_physics_open/equinor_utilities/various_utilities/timeshift.py

@@ -1,7 +1,13 @@
 import numpy as np
+import numpy.typing as npt
 
 
-def time_shift_pp(tvd, vp_base, vp_mon, multiplier):
+def time_shift_pp(
+    tvd: npt.NDArray[np.float64],
+    vp_base: npt.NDArray[np.float64],
+    vp_mon: npt.NDArray[np.float64],
+    multiplier: int,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """
     Cumulative time shift calculation for 4D case. According to Equinor standard
     the time shift is negative for an increase in velocity from base to monitor
@@ -43,7 +49,14 @@ def time_shift_pp(tvd, vp_base, vp_mon, multiplier):
     return owt_pp_shift, twt_pp_shift
 
 
-def time_shift_ps(tvd, vp_base, vp_mon, vs_base, vs_mon, multiplier):
+def time_shift_ps(
+    tvd: npt.NDArray[np.float64],
+    vp_base: npt.NDArray[np.float64],
+    vp_mon: npt.NDArray[np.float64],
+    vs_base: npt.NDArray[np.float64],
+    vs_mon: npt.NDArray[np.float64],
+    multiplier: int,
+) -> npt.NDArray[np.float64]:
     """
     Cumulative time shift calculation for 4D case. According to Equinor standard
     the time shift is negative for an increase in velocity from base to monitor

rock_physics_open/equinor_utilities/various_utilities/vp_vs_rho_set_statistics.py

@@ -1,6 +1,8 @@
 import os
+from typing import Literal, cast
 
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 from sklearn.metrics import r2_score
 
@@ -8,18 +10,18 @@ from .display_result_statistics import disp_result_stats
 
 
 def vp_vs_rho_stats(
-    vp_observed,
-    vs_observed,
-    rho_observed,
-    vp_estimated,
-    vs_estimated,
-    rho_estimated,
-    fname,
-    estimated_set_names,
-    well_names,
-    file_mode="a",
-    disp_results=True,
-):
+    vp_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vs_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    rho_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vp_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vs_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    rho_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    fname: str,
+    estimated_set_names: str | list[str],
+    well_names: str | list[str],
+    file_mode: Literal["a", "w"] = "a",
+    disp_results: bool = True,
+) -> None:
     """
     Utility to estimate statistics between vp-vs-rho sets - observed and estimated values. The results are displayed
     on screen (optional) and saved to a .csv file. If the file exists, the results will be appended.
@@ -83,33 +85,42 @@ def vp_vs_rho_stats(
     ]
     est_frame = pd.DataFrame(columns=est_frame_columns, index=estimated_set_names)
     est_frame.index.name = "Estimated set name"
-    est_frame.iloc[:, 0] = well_names
+    est_frame.iloc[:, 0] = well_names  # pyright: ignore[reportArgumentType]
 
     # If inputs are found to satisfy expectations in _verify, and they are numpy arrays, cast to lists, and run through
     if isinstance(vp_observed, np.ndarray):
         vp_observed = [vp_observed]
+    if isinstance(vs_observed, np.ndarray):
         vs_observed = [vs_observed]
+    if isinstance(rho_observed, np.ndarray):
         rho_observed = [rho_observed]
+    if isinstance(vp_estimated, np.ndarray):
         vp_estimated = [vp_estimated]
+    if isinstance(vs_estimated, np.ndarray):
         vs_estimated = [vs_estimated]
+    if isinstance(rho_estimated, np.ndarray):
         rho_estimated = [rho_estimated]
 
     for i in range(len(vp_observed)):
-        res = []
+        res: list[float] = []
         for obs, est in zip(
             [vp_observed[i], vs_observed[i], rho_observed[i]],
             [vp_estimated[i], vs_estimated[i], rho_estimated[i]],
         ):
-            res.append(np.mean(np.abs((est.flatten() - obs.flatten()) / obs.flatten())))
-            res.append(
-                np.sqrt(
-                    np.mean(np.square((est.flatten() - obs.flatten()) / obs.flatten()))
-                )
+            rmae = float(
+                np.mean(np.abs((est.flatten() - obs.flatten()) / obs.flatten()))
+            )
+            rrmse: float = np.sqrt(
+                np.mean(np.square((est.flatten() - obs.flatten()) / obs.flatten()))
             )
-            res.append(r2_score(obs.flatten(), est.flatten()))
+            r2 = cast(float, r2_score(obs.flatten(), est.flatten()))
+
+            res.append(rmae)
+            res.append(rrmse)
+            res.append(r2)
 
         res_dict = dict(zip(est_frame_columns[1:], res))
-        est_frame.iloc[i, 1:] = res_dict
+        est_frame.iloc[i, 1:] = res_dict  # pyright: ignore[reportArgumentType]
         if disp_results:
             disp_result_stats(
                 estimated_set_names[i], res, est_frame_columns[1:], values_only=True
@@ -122,7 +133,12 @@ def vp_vs_rho_stats(
         est_frame.to_csv(fname, mode=file_mode)
 
 
-def _verify(*args, set_names=None, well_names=None, file_mode=None):
+def _verify(
+    *args: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    set_names: list[str],
+    well_names: list[str],
+    file_mode: Literal["a", "w"],
+):
     """Verify that arguments are either numpy arrays or lists of numpy arrays.
     Raises
     ------
@@ -142,7 +158,7 @@ def _verify(*args, set_names=None, well_names=None, file_mode=None):
         if isinstance(arg, np.ndarray):
             arg = [arg]
         for this_arg in arg:
-            if not isinstance(this_arg, np.ndarray):
+            if not isinstance(this_arg, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance] | For backward compatibility
                 raise ValueError(f"{__file__}: input not numpy array: {type(arg)}")
             if np.any(np.isnan(this_arg)):
                 raise ValueError(f"{__file__}: input contains NaNs")
@@ -151,4 +167,4 @@ def _verify(*args, set_names=None, well_names=None, file_mode=None):
         if not len(arg) == len(set_names) == len(well_names):
             raise ValueError(f"{__file__}: mismatch in argument lengths")
     if not (file_mode == "a" or file_mode == "w"):
-        raise ValueError(f'{__file__}: file_mode must be one of ["a", "w"]')
+        raise ValueError(f'{__file__}: file_mode must be one of ["a", "w"]')  # pyright: ignore[reportUnreachable] | For backward compatibility

rock_physics_open/equinor_utilities/various_utilities/vrh_3_min.py

@@ -1,9 +1,31 @@
+import numpy as np
+import numpy.typing as npt
+
 from rock_physics_open.equinor_utilities import std_functions
 
 
 def min_3_voigt_reuss_hill(
-    vp1, vs1, rhob1, f1, vp2, vs2, rhob2, f2, vp3, vs3, rhob3, f3
-):
+    vp1: npt.NDArray[np.float64],
+    vs1: npt.NDArray[np.float64],
+    rhob1: npt.NDArray[np.float64],
+    f1: npt.NDArray[np.float64],
+    vp2: npt.NDArray[np.float64],
+    vs2: npt.NDArray[np.float64],
+    rhob2: npt.NDArray[np.float64],
+    f2: npt.NDArray[np.float64],
+    vp3: npt.NDArray[np.float64],
+    vs3: npt.NDArray[np.float64],
+    rhob3: npt.NDArray[np.float64],
+    f3: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
     """
     Mix of three phases by Voigt-Reuss-Hill model. The fractions should add up to 1 with input of vp, vs and rho.
 

rock_physics_open/fluid_models/brine_model/brine_properties.py

@@ -14,16 +14,16 @@ def brine_properties(
     p_cacl: np.ndarray | float | None = None,
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
-    :param salinity: Salinity of solution as ppm of NaCl.
-    :param pressure: Pressure (Pa) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :param salinity: Salinity of solution as [ppm] of NaCl.
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
     :param p_nacl: NaCl percentage, for future use
     :param p_kcl: KCl percentage, for future use
     :param p_cacl: CaCl percentage, for future use
-    :return: vel_b [m/s], den_b [kg/m^3], k_b [Pa]
+    :return: Brine velocity vel_b [m/s], brine density den_b [kg/m^3], brine bulk modulus k_b [Pa]
     """
-    vel_b = brine_primary_velocity(temperature, pressure * 1e-6, salinity * 1e-6)
-    den_b = brine_density(temperature, pressure * 1e-6, salinity * 1e-6) * 1000
+    vel_b = brine_primary_velocity(temperature, pressure, salinity)
+    den_b = brine_density(temperature, pressure, salinity)
     k_b = vel_b**2 * den_b
     return vel_b, den_b, k_b
 
@@ -35,19 +35,27 @@ def brine_density(
 ) -> np.ndarray | float:
     """
     density of sodium chloride solutions, equation 27 in Batzle & Wang [1].
-    :param salinity: Salinity of solution as weight fraction (ppm/1000000) of
-        sodium chloride.
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: density of solution in g/cc.
+    :param salinity: Salinity of solution in ppm
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: density of solution in [kg/m^3].
     """
+    # Change unit of pressure to MPa
+    pressure_mpa = pressure / 1.0e6
+    # Change unit of salinity to fraction
+    salinity_frac = salinity / 1.0e6
+
     coefficients = [
         [[0.668, 3e-4], [8e-5, -13e-6], [3e-6, 0.0]],
         [[0.44, -24e-4], [-33e-4, 47e-6], [0.0, 0.0]],
     ]
-    return water_density(temperature, pressure) + salinity * polyval3d(
-        salinity, temperature, pressure, coefficients
+    water_den = water_density(temperature, pressure)
+    brine_correction = (
+        salinity_frac
+        * polyval3d(salinity_frac, temperature, pressure_mpa, coefficients)
+        * 1000.0
     )
+    return water_den + brine_correction
 
 
 def brine_primary_velocity(
@@ -58,12 +66,16 @@ def brine_primary_velocity(
     """
     Primary wave velocity of sodium chloride solutions, equation 29 in Batzle & Wang [1]
 
-    :param salinity: Salinity of solution as weight fraction (ppm/1000000) of
-        sodium chloride.
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :param salinity: Salinity of solution as [ppm] of sodium chloride
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
     :return: velocity of solution in m/s.
     """
+    # Change unit for salinity from ppm to fraction
+    salinity_frac = salinity / 1.0e6
+    # Change the unit for pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
     coefficients = np.zeros((3, 4, 3))
     coefficients[0, 0, 0] = 1170
     coefficients[0, 1, 0] = -9.6
@@ -77,8 +89,8 @@ def brine_primary_velocity(
     coefficients[1, 0, 2] = 0.16
     coefficients[2, 0, 0] = -820
 
-    return water_primary_velocity(temperature, pressure) + salinity * polyval3d(
-        sqrt(salinity), temperature, pressure, coefficients
+    return water_primary_velocity(temperature, pressure) + salinity_frac * polyval3d(
+        sqrt(salinity_frac), temperature, pressure_mpa, coefficients
     )
 
 
@@ -88,17 +100,20 @@ def water_density(
 ) -> np.ndarray | float:
     """
     Density of water,, equation 27a in Batzle & Wang [1].
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: Density of water in g/cc.
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: Density of water in [kg/m^3].
     """
+    # Change unit of pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
     coefficients = [
         [1.0, 489e-6, -333e-9],
         [-8e-5, -2e-6, -2e-09],
         [-33e-7, 16e-9, 0.0],
         [1.75e-9, -13e-12, 0.0],
     ]
-    return polyval2d(temperature, pressure, coefficients)
+    return polyval2d(temperature, pressure_mpa, coefficients) * 1000.0
 
 
 def water_primary_velocity(
@@ -107,11 +122,14 @@ def water_primary_velocity(
 ) -> np.ndarray | float:
     """
     Primary wave velocity of water, table 1 and equation 28 in Batzle & Wang [1].
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
     :return: primary wave velocity of water in m/s.
     """
-    if np.any(pressure > 100):
+    # Change unit of pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
+    if np.any(pressure_mpa > 100):
         warnings.warn(
             "Calculations for water velocity is not precise for\n"
             + "pressure outside [0,100]MPa"
@@ -125,19 +143,36 @@ def water_primary_velocity(
         [1.487e-4, -6.503e-7, -1.455e-8, 1.327e-10],
         [-2.197e-7, 7.987e-10, 5.23e-11, -4.614e-13],
     ]
-    return polyval2d(temperature, pressure, coefficients)
+    return polyval2d(temperature, pressure_mpa, coefficients)
 
 
 def water(
     temperature: np.ndarray | float, pressure: np.ndarray | float
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
-    :param pressure: Pressure (Pa) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: water_density [kg/m^3], water_velocity [m/s], water_bulk_modulus [Pa]
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: water_velocity [m/s], water_density [kg/m^3], water_bulk_modulus [Pa]
     """
-    pressure_mpa = pressure * 1.0e-6
-    water_den = water_density(temperature, pressure_mpa)
-    water_vel = water_primary_velocity(temperature, pressure_mpa)
-    water_k = water_vel**2 * water_den * 1000.0
-    return water_den, water_vel, water_k
+    water_den = water_density(temperature, pressure)
+    water_vel = water_primary_velocity(temperature, pressure)
+    water_k = water_vel**2 * water_den
+    return water_vel, water_den, water_k
+
+
+def brine_viscosity(
+    temperature: np.ndarray | float,
+    salinity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Brine viscosity according to Batzle & Wang [1].
+
+    Based on equation 32.
+    """
+    salinity_frac = salinity / 1.0e6
+    return (
+        0.1
+        + 0.333 * salinity_frac
+        + (1.65 + 91.9 * salinity_frac**3)
+        * np.exp(-(0.42 * (salinity_frac**0.8 - 0.17) ** 2 + 0.045) * temperature**0.8)
+    )

rock_physics_open/fluid_models/gas_model/gas_properties.py

@@ -4,7 +4,7 @@ from scipy.constants import gas_constant
 
 from rock_physics_open.equinor_utilities.conversions import celsius_to_kelvin
 
-AIR_WEIGHT = 28.8  # g/mol
+AIR_WEIGHT = 28.8 * 1.0e-3  # kg/mol
 
 
 def gas_properties(
@@ -20,10 +20,11 @@ def gas_properties(
     :param model: for future use
     :return: vel_gas [m/s], den_gas [kg/m^3], k_gas [Pa], eta_gas [cP]
     """
-    den_gas = gas_density(celsius_to_kelvin(temperature), pressure * 1e-6, gas_gravity)
-    k_gas = gas_bulk_modulus(
-        celsius_to_kelvin(temperature), pressure * 1e-6, gas_gravity
-    )
+
+    den_gas = gas_density(celsius_to_kelvin(temperature), pressure, gas_gravity)
+
+    k_gas = gas_bulk_modulus(celsius_to_kelvin(temperature), pressure, gas_gravity)
+
     vel_gas = (k_gas / den_gas) ** 0.5
 
     eta_gas = lee_gas_viscosity(celsius_to_kelvin(temperature), pressure, gas_gravity)
@@ -33,9 +34,9 @@ def gas_properties(
 
 def molecular_weight(gas_gravity: np.ndarray | float) -> np.ndarray | float:
     """
-    calculates molecluar weight of a gas from gas gravity.
+    calculates molecular weight of a gas from gas gravity.
     :param gas_gravity: molar mass of gas relative to air molar mas.
-    :return: The volume of the gas in g/mol.
+    :return: The volume of the gas in kg/mol.
     """
     return gas_gravity * AIR_WEIGHT
 
@@ -47,9 +48,10 @@ def molar_volume(
     """
     calculates molar volume using the ideal gas law.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
-    :param pressure: Confining pressure in MPa.
-    :return: The volume of the gas in cc/mol.
+    :param pressure: Confining pressure in Pa.
+    :return: The volume of the gas in m^3/mol.
     """
+
     return gas_constant * absolute_temperature / pressure
 
 
@@ -62,8 +64,8 @@ def ideal_gas_density(
     calculates molar volume using the ideal gas law.
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
-    :param pressure: Confining pressure in MPa.
-    :return: The density of the gas in g/cc
+    :param pressure: Confining pressure in Pa.
+    :return: The density of the gas in kg/m^3
     """
     return molecular_weight(gas_gravity) / molar_volume(absolute_temperature, pressure)
 
@@ -89,13 +91,11 @@ def ideal_gas(
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
     :param pressure: Confining pressure in Pa.
-    :return: ideal_gas_density, ideal_gas_velocity
+    :return: ideal_gas_velocity [m/s], ideal_gas_density [kg/m^3],
     """
-    ideal_gas_den = 1000 * ideal_gas_density(
-        absolute_temperature, pressure * 1e6, gas_gravity
-    )
+    ideal_gas_den = ideal_gas_density(absolute_temperature, pressure, gas_gravity)
     ideal_gas_vel = ideal_gas_primary_velocity(absolute_temperature, gas_gravity)
-    return ideal_gas_den, ideal_gas_vel
+    return ideal_gas_vel, ideal_gas_den
 
 
 def pseudoreduced_temperature(
@@ -132,13 +132,13 @@ def pseudoreduced_pressure(
     Tech., 22, 889-892.
 
     :param gas_gravity: molar mass of gas relative to air molar mas.
-    :param pressure: Confining pressure in MPa.
-    :return: Pseudoreduced pressure in MPa.
+    :param pressure: Confining pressure in Pa.
+    :return: Pseudoreduced pressure in Pa.
     """
     return pressure / (4.892 - 0.4048 * gas_gravity)
 
 
-def compressability_factor(
+def compressibility_factor(
     absolute_temperature: np.ndarray | float,
     pressure: np.ndarray | float,
     gas_gravity: np.ndarray | float,
@@ -149,11 +149,13 @@ def compressability_factor(
 
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
-    :param pressure: Confining pressure in MPa.
-    :return: The density of the gas in g/cc
+    :param pressure: Confining pressure in Pa.
+    :return: Gas compressibility - unitless
     """
     tpr = pseudoreduced_temperature(absolute_temperature, gas_gravity)
-    ppr = pseudoreduced_pressure(pressure, gas_gravity)
+
+    # Pseudoreduced pressure has unit MPa in equation
+    ppr = pseudoreduced_pressure(pressure, gas_gravity) * 1.0e-6
 
     return (
         (0.03 + 0.00527 * (3.5 - tpr) ** 3) * ppr
@@ -162,7 +164,7 @@ def compressability_factor(
         - 0.52
         + 0.109
         * (3.85 - tpr) ** 2
-        / exp((0.45 + 8 * (0.56 - 1 / tpr) ** 2) * ppr**1.2 / tpr)
+        / exp((0.45 + 8.0 * (0.56 - 1 / tpr) ** 2) * ppr**1.2 / tpr)
     )
 
 
@@ -176,18 +178,17 @@ def gas_density(
 
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
-    :param pressure: Confining pressure in MPa.
-    :return: The density of the gas in g/cc
+    :param pressure: Confining pressure in Pa.
+    :return: The density of the gas in kg/m^3
     """
-    ideal_gas_den, ideal_gas_vel = ideal_gas(
-        absolute_temperature, pressure * 1e-6, gas_gravity
-    )
-    return ideal_gas_den / compressability_factor(
+
+    _, ideal_gas_den = ideal_gas(absolute_temperature, pressure, gas_gravity)
+    return ideal_gas_den / compressibility_factor(
         absolute_temperature, pressure, gas_gravity
     )
 
 
-def compressability_rate_per_pseudoreduced_pressure(
+def compressibility_rate_per_pseudoreduced_pressure(
     absolute_temperature: np.ndarray | float,
     pressure: np.ndarray | float,
     gas_gravity: np.ndarray | float,
@@ -198,10 +199,12 @@ def compressability_rate_per_pseudoreduced_pressure(
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
     :param pressure: Confining pressure in MPa.
-    :return: The density of the gas in g/cc
+    :return: Derivative of the compressibility factor (unitless) with respect to pseudoreduced pressure
     """
     tpr = pseudoreduced_temperature(absolute_temperature, gas_gravity)
-    ppr = pseudoreduced_pressure(pressure, gas_gravity)
+
+    # Pseudoreduced pressure is expected to be in MPa in the expression
+    ppr = pseudoreduced_pressure(pressure, gas_gravity) * 1.0e-6
 
     return (
         0.03
@@ -226,15 +229,16 @@ def gas_bulk_modulus(
 
     :param gas_gravity: molar mass of gas relative to air molar mas.
     :param absolute_temperature: The absolute temperature of the gas in kelvin.
-    :param pressure: Confining pressure in MPa.
-    :return: The bulk modulus of the gas in MPa.
+    :param pressure: Confining pressure in Pa.
+    :return: The bulk modulus of the gas in Pa.
     """
-    z = compressability_factor(absolute_temperature, pressure, gas_gravity)
-    dz_dppr = compressability_rate_per_pseudoreduced_pressure(
+    z = compressibility_factor(absolute_temperature, pressure, gas_gravity)
+    dz_dppr = compressibility_rate_per_pseudoreduced_pressure(
         absolute_temperature, pressure, gas_gravity
     )
 
-    ppr = pseudoreduced_pressure(pressure, gas_gravity)
+    # Set ppr in unit MPa in order to use it in calculation of gamma_0
+    ppr = pseudoreduced_pressure(pressure, gas_gravity) * 1.0e-6
 
     # Equation 11b
     gamma_0 = (
@@ -247,6 +251,44 @@ def gas_bulk_modulus(
     return gamma_0 * pressure / (1 - dz_dppr * ppr / z)
 
 
+def gas_viscosity(
+    absolute_temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    gas_gravity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    The gas viscosity of hydrocarbon gas, using equations 12 and 13 of Batzle & Wang [1].
+
+    :param absolute_temperature: The absolute temperature of the gas in kelvin.
+    :param pressure: Confining pressure in Pa.
+    :param gas_gravity: molar mass of gas relative to air mas.
+    :return: The gas viscosity of the gas in cP.
+    """
+    temp_pr = pseudoreduced_temperature(absolute_temperature, gas_gravity)
+
+    # Pseudoreduced pressure should be in unit MPa
+    pres_pr = pseudoreduced_pressure(pressure, gas_gravity) * 1.0e-6
+
+    eta_1 = 0.0001 * (
+        temp_pr * (28.0 + 48.0 * gas_gravity - 5.0 * gas_gravity**2)
+        - 6.47 * gas_gravity**-2
+        + 35.0 * gas_gravity**-1
+        + 1.14 * gas_gravity
+        - 15.55
+    )
+    return eta_1 * (
+        0.001
+        * pres_pr
+        * (
+            (1057.0 - 8.08 * temp_pr) / pres_pr
+            + (796.0 * pres_pr**0.5 - 704.0)
+            / (((temp_pr - 1.0) ** 0.7) * (pres_pr + 1.0))
+            - 3.24 * temp_pr
+            - 38.0
+        )
+    )
+
+
 def lee_gas_viscosity(
     absolute_temperature: np.ndarray | float,
     pressure: np.ndarray | float,