pygmm 0.0.0__py3-none-any.whl

pygmm/__init__.py

@@ -0,0 +1,87 @@
+"""pyGMM: Ground motion models implemented in Python."""
+
+import logging
+from importlib.metadata import version
+
+from .abrahamson_bhasin_2020 import AbrahamsonBhasin2020
+from .abrahamson_gregor_addo_2016 import AbrahamsonGregorAddo2016
+from .abrahamson_silva_1996 import AbrahamsonSilva1996
+from .abrahamson_silva_kamai_2014 import AbrahamsonSilvaKamai2014
+from .afshari_stewart_2016 import AfshariStewart2016
+from .akkar_sandikkaya_bommer_2014 import AkkarSandikkayaBommer2014
+from .atkinson_boore_2006 import AtkinsonBoore2006
+from .bayless_abrahamson_2018 import BaylessAbrahamson2018
+from .bayless_abrahamson_2019 import BaylessAbrahamson2019
+from .boore_stewart_seyhan_atkinson_2014 import BooreStewartSeyhanAtkinson2014
+from .campbell_2003 import Campbell2003
+from .campbell_bozorgnia_2014 import CampbellBozorgnia2014
+from .chiou_youngs_2014 import ChiouYoungs2014
+from .coppersmith_bommer_2014 import CoppersmithBommer2014
+from .derras_bard_cotton_2014 import DerrasBardCotton2014
+from .gulerce_abrahamson_2011 import GulerceAbrahamson2011
+from .idriss_2014 import Idriss2014
+from .kempton_stewart_2006 import KemptonStewart2006
+from .model import Scenario
+from .pezeshk_zandieh_tavakoli_2011 import PezeshkZandiehTavakoli2011
+from .tavakoli_pezeshk_2005 import TavakoliPezeshk05
+
+__all__ = [
+    "Scenario",
+    "AbrahamsonBhasin2020",
+    "AbrahamsonSilvaKamai2014",
+    "AbrahamsonGregorAddo2016",
+    "AfshariStewart2016",
+    "AkkarSandikkayaBommer2014",
+    "AtkinsonBoore2006",
+    "BaylessAbrahamson2018",
+    "BaylessAbrahamson2019",
+    "BooreStewartSeyhanAtkinson2014",
+    "Campbell2003",
+    "CampbellBozorgnia2014",
+    "ChiouYoungs2014",
+    "CoppersmithBommer2014",
+    "DerrasBardCotton2014",
+    "GulerceAbrahamson2011",
+    "KemptonStewart2006",
+    "Idriss2014",
+    "PezeshkZandiehTavakoli2011",
+    "TavakoliPezeshk05",
+]
+
+__author__ = "Albert Kottke"
+__copyright__ = "Copyright 2016 Albert Kottke"
+__license__ = "MIT"
+__title__ = "pyGMM"
+__version__ = version("pyGMM")
+
+# Set default logging handler to avoid "No handler found" warnings.
+try:  # Python 2.7+
+    from logging import NullHandler
+except ImportError:
+
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+models = [
+    AbrahamsonSilva1996,
+    AbrahamsonSilvaKamai2014,
+    AfshariStewart2016,
+    AkkarSandikkayaBommer2014,
+    AtkinsonBoore2006,
+    BaylessAbrahamson2019,
+    BooreStewartSeyhanAtkinson2014,
+    Campbell2003,
+    CampbellBozorgnia2014,
+    ChiouYoungs2014,
+    CoppersmithBommer2014,
+    DerrasBardCotton2014,
+    GulerceAbrahamson2011,
+    KemptonStewart2006,
+    Idriss2014,
+    PezeshkZandiehTavakoli2011,
+    TavakoliPezeshk05,
+]

pygmm/abrahamson_bhasin_2020.py

@@ -0,0 +1,158 @@
+"""Abrahamson and Bhasin (2020, :cite:`abrahamson20`) model."""
+
+from typing import Optional
+
+import numpy as np
+
+from . import model
+
+__author__ = "Albert Kottke"
+
+
+class AbrahamsonBhasin2020(model.Model):
+    """Abrahamson (2020, :cite:`abrahamson20`) model.
+
+    Conditional PGV model
+
+    Parameters
+    ----------
+    scenario : :class:`pygmm.model.Scenario`
+        earthquake scenario
+
+    """
+
+    NAME = "Abrahamson and Bhasin (2020)"
+    ABBREV = "AB20"
+
+    # Reference velocity (m/s)
+    V_REF = 425.0
+
+    # Load the coefficients for the model
+    COEFFS = {
+        # From Table 3.2
+        "psa(T=Tpgv)": model.Coefficients(
+            a_1=5.39,
+            a_2=0.799,
+            a_3=0.654,
+            a_4=0.479,
+            a_5=-0.062,
+            a_6=-0.359,
+            a_7=-0.134,
+            a_8=0.023,
+            phi=0.29,
+            tau=0.16,
+        ),
+        "pga": model.Coefficients(
+            a_1=4.77,
+            a_2=0.738,
+            a_3=0.484,
+            a_4=0.275,
+            a_5=-0.036,
+            a_6=-0.332,
+            a_7=-0.44,
+            a_8=0,
+            phi_1=0.32,
+            phi_2=0.42,
+            tau_1=0.12,
+            tau_2=0.26,
+            M_1=5.0,
+            M_2=7.0,
+        ),
+        "psa(T=1s)": model.Coefficients(
+            a_1=4.80,
+            a_2=0.82,
+            a_3=0.55,
+            a_4=0.27,
+            a_5=0.054,
+            a_6=-0.382,
+            a_7=-0.21,
+            a_8=0.0,
+            phi_1=0.28,
+            phi_2=0.38,
+            tau_1=0.12,
+            tau_2=0.17,
+            M_1=5.0,
+            M_2=7.0,
+        ),
+    }
+
+    PARAMS = [
+        model.NumericParameter("dist_rup", True, 0, 300),
+        model.NumericParameter("mag", True, 3.0, 8.0),
+        model.NumericParameter("v_s30", True, 180, 1500),
+    ]
+
+    def __init__(
+        self,
+        scenario: model.Scenario,
+        psa=Optional[float],
+        pga=Optional[float],
+        psa_1s=Optional[float],
+    ):
+        super().__init__(scenario)
+
+        if psa is not None:
+            method = "psa(T=Tpgv)"
+            # FIXME: How to interpolate?
+            raise NotImplementedError
+        elif pga is not None:
+            method = "pga"
+            ln_gm = np.log(pga)
+        else:
+            method = "psa(T=1s)"
+            ln_gm = np.log(psa_1s)
+
+        C = self.COEFFS[method]
+        s = scenario
+
+        # Mean
+        if s.mag < 5:
+            f_1 = C.a_2
+        elif s.mag > 7.5:
+            f_1 = C.a_3
+        else:
+            f_1 = C.a_2 + (C.a_3 - C.a_2) * (s.mag - 5) / 2.5
+
+        ln_mean = (
+            C.a_1
+            + f_1 * ln_gm
+            + C.a_4 * (s.mag - 6)
+            + C.a_5 * (8.5 - s.mag) ** 2
+            + C.a_6 * np.log(s.dist_rup + 5 * np.exp(0.4 * (s.mag - 6)))
+            + (C.a_7 + C.a_8 * (s.mag - 5)) * np.log(C.v_s30 / self.V_REF)
+        )
+
+        if method == "psa(T=Tpgv)":
+            phi, tau = C.phi, C.tau
+        else:
+
+            def interp(var_1, var_2):
+                if s.mag < C.mag_1:
+                    val = var_1
+                elif s.mag > C.mag_2:
+                    val = var_2
+                else:
+                    val = var_1 + (var_2 - var_1) * (s.mag - C.mag_1) / (C.mag_2 - C.mag_1)
+                return val
+
+            phi = interp(C.phi_1, C.phi_2)
+            tau = interp(C.tau_1, C.tau_2)
+
+        ln_std = np.sqrt(phi**2 + tau**2)
+        return ln_mean, ln_std
+
+    @classmethod
+    def ln_period_pgv(cls, mag: float) -> float:
+        """Natural logarithm of the period for calculating PGV. Equation 3.6.
+
+        Parameters
+        ----------
+        mag : float
+            Magnitude
+
+        Returns
+        -------
+        ln_period_pgv : float
+            Best period for computing PGV.
+        """
+        return -4.09 + 0.66 * mag

pygmm/abrahamson_gregor_addo_2016.py

@@ -0,0 +1,248 @@
+"""Abrahamson, Gregor, and Addo (2016) ground motion moodel."""
+
+import numpy as np
+
+from . import model
+
+__author__ = "Albert Kottke"
+
+
+class AbrahamsonGregorAddo2016(model.GroundMotionModel):
+    """Abrahamson, Gregor, and Addo (2016) ground motion moodel.
+
+    This model was developed for subduction regions and is commonly referred to
+    as the BCHydro model.
+
+    Parameters
+    ----------
+    scenario : :class:`pygmm.model.Scenario`
+        earthquake scenario
+
+    """
+
+    NAME = "Abrahamson, Gregor, & Addo (2016)"
+    ABBREV = "AGA16"
+
+    # Reference shear-wave velocity in m/sec
+    V_REF = 1000.0
+
+    # Load the coefficients for the model
+    COEFF = model.load_data_file("abrahamson_gregor_addo_2016.csv", 1)
+    PERIODS = COEFF["period"]
+
+    INDEX_PGA = 0
+    INDICES_PSA = np.arange(1, 23)
+
+    # FIXME
+    LIMITS = dict(
+        mag=(3.0, 8.5),
+        dist_jb=(0.0, 300.0),
+        v_s30=(150.0, 1500.0),
+    )
+
+    PARAMS = [
+        model.NumericParameter("mag", True, 3, 8.5),
+        model.NumericParameter("dist_rup", False),
+        model.NumericParameter("dist_hyp", False),
+        model.NumericParameter("depth_hyp", False),
+        model.NumericParameter("v_s30", True, 150.0, 1500.0),
+        model.CategoricalParameter("event_type", True, ["interface", "intraslab"]),
+        model.CategoricalParameter(
+            "tectonic_region", False, ["forearc", "backarc", "unknown"], "unknown"
+        ),
+    ]
+
+    def __init__(self, scenario, adjust_c1=None, adjust_c4=0, scale_atten=1.0):
+        """Initialize the model.
+
+        Args:
+            scenario (:class:`pygmm.model.Scenario`): earthquake scenario.
+        """
+        super().__init__(scenario)
+
+        n = len(self.COEFF)
+        if adjust_c1 is None:
+            # Default adjustments
+            if self.scenario.event_type == "intraslab":
+                self._adjust_c1 = -0.3 * np.ones(n)
+            else:
+                self._adjust_c1 = np.interp(
+                    np.log(np.maximum(0.01, self.COEFF.period)),
+                    np.log([0.3, 0.5, 1, 2, 3]),
+                    [0.2, 0.1, 0, -0.1, -0.2],
+                    left=0.2,
+                    right=-0.2,
+                )
+        else:
+            if isinstance(adjust_c1, float):
+                self._adjust_c1 = adjust_c1 * np.ones(n)
+            else:
+                self._adjust_c1 = np.asarray(adjust_c1)
+
+        self._adjust_c4 = adjust_c4
+        self._scale_atten = scale_atten
+
+        pga_ref = np.exp(self._calc_ln_resp(np.nan)[self.INDEX_PGA])
+        self._ln_resp = self._calc_ln_resp(pga_ref)
+        self._ln_std = self._calc_ln_std()
+
+    @property
+    def adjust_c1(self):
+        return self._adjust_c1
+
+    @property
+    def adjust_c4(self):
+        return self._adjust_c4
+
+    @property
+    def scale_atten(self):
+        return self._scale_atten
+
+    def _calc_ln_resp(self, pga_ref):
+        """Calculate the natural logarithm of the response.
+
+        Parameters
+        ----------
+        pga_ref : float
+            peak ground acceleration (g) at the reference
+            condition. If :class:`np.nan`, then no site term is applied.
+
+        Returns
+        -------
+        ln_resp : class:`np.array`:
+            natural log of the response
+
+        """
+        s = self._scenario
+        c = self.COEFF
+
+        f_event = 1 if s.event_type == "intraslab" else 0
+        dist = s.dist_hyp if s.event_type == "intraslab" else s.dist_rup
+
+        path_atten = (c.t_2 + c.t_14 * f_event + c.t_3 * (s.mag - 7.8)) * np.log(
+            dist + c.c_4 * np.exp(c.t_9 * (s.mag - 6))
+        )
+
+        ln_resp = (
+            c.t_1
+            + c.t_4 * self.adjust_c1
+            + path_atten
+            + self._scale_atten * c.t_6 * dist
+            + c.t_10 * f_event
+            + self._calc_f_mag(s.mag)
+            + self._calc_f_site(pga_ref)
+        )
+
+        if s.tectonic_region == "backarc":
+            ln_resp += self._calc_f_faba(dist)
+
+        if s.event_type == "intraslab":
+            ln_resp += self._calc_f_depth(s.depth_hyp)
+
+        return ln_resp
+
+    def _calc_f_mag(self, mag):
+        """Calculate the magnitude scaling. Equation 2.
+
+        Parameters
+        ----------
+        mag : float
+            moment magnitude
+
+        Returns
+        -------
+        f_mag : class:`np.array`:
+            magnitude scaling
+
+        """
+        c = self.COEFF
+        c_1 = 7.8
+        coeff = np.select([mag <= (c_1 + self.adjust_c1), True], [c.t_4, c.t_5])
+        f_mag = coeff * (mag - (c_1 + self.adjust_c1)) + c.t_13 * (10 - mag) ** 2
+        return f_mag
+
+    def _calc_f_depth(self, depth_hyp):
+        """Calculate the depth scaling. Equation 3.
+
+        Parameters
+        ----------
+        depth_hyp : float
+            depth to hypocenter [km]
+
+        Returns
+        -------
+        f_depth : class:`np.array`:
+            depth scaling
+
+        """
+        c = self.COEFF
+        f_depth = c.t_11 * (np.minimum(depth_hyp, 120) - 60)
+        return f_depth
+
+    def _calc_f_faba(self, dist):
+        """Calculate the forearc/backarc scaling. Equation 4.
+
+        Parameters
+        ----------
+        dist : float
+            depth to hypocenter [km]
+
+        Returns
+        -------
+        f_faba : class:`np.array`:
+            forearc/backarc scaling
+
+        """
+        c = self.COEFF
+        if self.scenario.event_type == "intraslab":
+            f_faba = c.t_7 + c.t_8 * np.log(np.maximum(dist, 85) / 40)
+        elif self.scenario.event_type == "interface":
+            f_faba = c.t_15 + c.t_16 * np.log(np.maximum(dist, 100) / 40)
+        else:
+            raise NotImplementedError
+
+        return f_faba
+
+    def _calc_f_site(self, pga_ref):
+        """Calculate the site amplification. Equation 5.
+
+        Parameters
+        ----------
+        pga_ref : float, default: np.nan
+            reference PGA (V_s30 = 1000 m/sec). If 'np.nan', then the ground
+            motion at the reference condition is computed.
+
+        Returns
+        -------
+        f_site : class:`np.array`:
+            site scaling
+
+        """
+        c = self.COEFF
+        v_s30 = 1000.0 if np.isnan(pga_ref) else self.scenario.v_s30
+        vs_ratio = np.minimum(v_s30, 1000) / c.v_lin
+
+        f_site = np.select(
+            [v_s30 < c.v_lin, True],
+            [
+                c.t_12 * np.log(vs_ratio)
+                - c.b * np.log(pga_ref + c.c)
+                + c.b * np.log(pga_ref + c.c * vs_ratio**c.n),
+                (c.t_12 + c.b * c.n) * np.log(vs_ratio),
+            ],
+        )
+        return f_site
+
+    def _calc_ln_std(self):
+        """Calculate the logarithmic standard deviation.
+
+        Returns
+        -------
+        ln_std : class:`np.array`:
+            natural log standard deviation
+
+        """
+        c = self.COEFF
+
+        ln_std = np.sqrt(c.phi**2 + c.tau**2)
+        return ln_std

pygmm/abrahamson_silva_1996.py

@@ -0,0 +1,121 @@
+"""Abrahamson and Silva (1996, :cite:`abrahamson96`) duration model."""
+
+import numpy as np
+
+from . import model
+
+__author__ = "Albert Kottke"
+
+
+class AbrahamsonSilva1996(model.Model):
+    """Abrahamson and Silva (1996, :cite:`abrahamson96`) duration model.
+
+    Parameters
+    ----------
+    scenario : :class:`pygmm.model.Scenario`
+        earthquake scenario
+
+    """
+
+    NAME = "Abrahamson Silva (1996)"
+    ABBREV = "AS96"
+
+    PARAMS = [
+        model.NumericParameter("mag", True, 4, 7.5),
+        model.NumericParameter("dist_rup", True, 0, 250),
+        # FIXME add site_cond to Scenario
+        model.CategoricalParameter("site_cond", True, ["soil", "rock"]),
+    ]
+
+    def __init__(self, scenario):
+        super().__init__(scenario)
+
+        s = self._scenario
+
+        stress_drop = np.exp(5.204 + 0.851 * (s.mag - 6))
+        moment = 10 ** (1.5 * s.mag + 16.05)
+
+        self._ln_dur = np.log(
+            (stress_drop / moment) ** (-1 / 3) / (4.9e6 * 3.2)
+            + 0.805 * (1 if s.site_cond == "soil" else 0)
+            + 0.063 * max(s.dist_rup - 10, 0)
+        ) + self.calc_ln_dur_incr(0.75)
+        self._std_err = 0.55
+
+    @property
+    def duration(self):
+        return np.exp(self._ln_dur)
+
+    @property
+    def std_err(self):
+        return self._std_err
+
+    @staticmethod
+    def calc_ln_dur_incr(nias):
+        # Mask out inappropriate values
+        nias = np.asarray(nias)
+        mask = (nias < 0.10) | (0.95 < nias)
+        nias[mask] = np.nan
+
+        # Compute the increment due to the difference in the normalized Arias
+        # intensity
+        ln_i_ratio = np.log((nias - 0.05) / (1 - nias))
+        ln_dur_incr = -0.532 + 0.552 * ln_i_ratio - 0.0262 * ln_i_ratio**2
+
+        return ln_dur_incr
+
+    def interp(self, nias, stds=None):
+        # Mask out inappropriate values
+        nias = np.asarray(nias)
+        mask = (nias < 0.10) | (0.95 < nias)
+        nias[mask] = np.nan
+
+        ln_dur = self._ln_dur + self.calc_ln_dur_incr(nias)
+
+        if stds is not None:
+            std_errs = np.interp(
+                nias,
+                [
+                    0.10,
+                    0.15,
+                    0.20,
+                    0.25,
+                    0.30,
+                    0.35,
+                    0.40,
+                    0.45,
+                    0.50,
+                    0.55,
+                    0.60,
+                    0.65,
+                    0.70,
+                    0.75,
+                    0.80,
+                    0.85,
+                    0.90,
+                    0.95,
+                ],
+                [
+                    0.843,
+                    0.759,
+                    0.713,
+                    0.691,
+                    0.674,
+                    0.660,
+                    0.646,
+                    0.636,
+                    0.628,
+                    0.616,
+                    0.605,
+                    0.594,
+                    0.582,
+                    0.565,
+                    0.545,
+                    0.528,
+                    0.510,
+                    0.493,
+                ],
+            )
+            ln_dur = ln_dur + np.array(stds)[:, np.newaxis] * std_errs
+
+        return np.exp(ln_dur)