ucla-geotech-tools 1.0.0__tar.gz

ucla_geotech_tools-1.0.0/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Scott J. Brandenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ucla_geotech_tools-1.0.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.1
+Name: ucla_geotech_tools
+Version: 1.0.0
+Summary: A collection of software tools developed by the UCLA geotechnical group
+License: LICENSE.txt
+Author: Scott J. Brandenberg
+Requires-Python: >=3.8,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy (>=1.22,<2.0)
+Requires-Dist: scipy (>=1.8,<2.0)
+Description-Content-Type: text/markdown
+
+# auto_fchp
+
+Return the high-pass corner frequency value that stabilizes the displacement of a ground motion record.
+
+    The high-pass corner frequency, fchp, is selected to satisfy two objectives:
+        1. A polynomial is fit to the filtered displacement record, and the amplitude of the polynomial fit
+        divided by the amplitude of the filtered displacement record is within a tolerance of a specified target.
+        2. The amplitude of the initial portion of the displacement record before the p-wave arrival divided by
+        the amplitude of the filtered displacement record is within a tolerance of a specified target.
+
+    The value of fchp is computed numerically using the Scipy package optimize.ridder(). Two initial values
+    of fchp are provided that bracket the root, and the Scipy package solves for the root that minimizes the
+    objective function. The tolerance is on the value of fchp (i.e., xtol in optimize.ridder)
+
+    A value of fchp is obtained first to satisfy objective 1. Objective 2 is optional, and if it is applied,
+    the value of fchp from objective 1 is checked against objective 2. If the residual from objective 2 is
+    less than or equal to zero, fchp is set equal to the value from objective 1. Otherwise, iterations are
+    performed to satisfy objective 2.
+
+## Installation  
+```python
+pip install ucla_geotech_tools.auto_fchp
+```
+
+## Functions
+```python
+get_fchp_sp(dt, acc, **kwargs)
+"""Args:
+        dt (float): time step in seconds
+        acc (numpy array, dtype=float): acceleration array in L/s/s, where L is length (e.g., meters)
+
+    Keyword Args:
+        target: desired ratio of polynomial fit amplitude to displacement amplitude (default=0.02)
+        tol: tolerance for fchp (default=0.001)
+        poly_order: order of polynomial to fit to filtered displacement record (default=6)
+        maxiter: maximum number of iterations (default=30)
+        fchp_min: minimum frequency in Hz to consider for fchp (default=0.001)
+        fchp_max: maximum frequency in Hz to consider for fchp (default=0.5)
+        tukey_alpha: alpha parameter for scipy.signal.windows.tukey (default=0.05)
+        apply_disp_ratio: flag to indicate whether to apply objective 2 (default=0)
+        disp_ratio_time: duration in seconds of the initial portion of the record before the p-wave arrival (default=30)
+        disp_ratio_target: target ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+"""
+get_residual1(fchp, *args):
+    """Return the residual defined as disp_fit/disp_filt - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        poly_order = Order of polynomial to fit to filtered displacement
+        target = Desired ratio of polynomial fit amplitude to displacement signal amplitude
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+        coef = Coefficients of polynomial fit to displacement record
+        disp_fit = Numpy array containing polynomial fit ordinates at each time
+    """
+
+
+get_residual2(fchp, *args):
+    """Return the residual defined as disp_init/disp - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        disp_time = Duration of initial portion of record before p-wave arrival
+        disp_target = Desired ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+    """
+```
+

ucla_geotech_tools-1.0.0/README.md

@@ -0,0 +1,80 @@
+# auto_fchp
+
+Return the high-pass corner frequency value that stabilizes the displacement of a ground motion record.
+
+    The high-pass corner frequency, fchp, is selected to satisfy two objectives:
+        1. A polynomial is fit to the filtered displacement record, and the amplitude of the polynomial fit
+        divided by the amplitude of the filtered displacement record is within a tolerance of a specified target.
+        2. The amplitude of the initial portion of the displacement record before the p-wave arrival divided by
+        the amplitude of the filtered displacement record is within a tolerance of a specified target.
+
+    The value of fchp is computed numerically using the Scipy package optimize.ridder(). Two initial values
+    of fchp are provided that bracket the root, and the Scipy package solves for the root that minimizes the
+    objective function. The tolerance is on the value of fchp (i.e., xtol in optimize.ridder)
+
+    A value of fchp is obtained first to satisfy objective 1. Objective 2 is optional, and if it is applied,
+    the value of fchp from objective 1 is checked against objective 2. If the residual from objective 2 is
+    less than or equal to zero, fchp is set equal to the value from objective 1. Otherwise, iterations are
+    performed to satisfy objective 2.
+
+## Installation  
+```python
+pip install ucla_geotech_tools.auto_fchp
+```
+
+## Functions
+```python
+get_fchp_sp(dt, acc, **kwargs)
+"""Args:
+        dt (float): time step in seconds
+        acc (numpy array, dtype=float): acceleration array in L/s/s, where L is length (e.g., meters)
+
+    Keyword Args:
+        target: desired ratio of polynomial fit amplitude to displacement amplitude (default=0.02)
+        tol: tolerance for fchp (default=0.001)
+        poly_order: order of polynomial to fit to filtered displacement record (default=6)
+        maxiter: maximum number of iterations (default=30)
+        fchp_min: minimum frequency in Hz to consider for fchp (default=0.001)
+        fchp_max: maximum frequency in Hz to consider for fchp (default=0.5)
+        tukey_alpha: alpha parameter for scipy.signal.windows.tukey (default=0.05)
+        apply_disp_ratio: flag to indicate whether to apply objective 2 (default=0)
+        disp_ratio_time: duration in seconds of the initial portion of the record before the p-wave arrival (default=30)
+        disp_ratio_target: target ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+"""
+get_residual1(fchp, *args):
+    """Return the residual defined as disp_fit/disp_filt - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        poly_order = Order of polynomial to fit to filtered displacement
+        target = Desired ratio of polynomial fit amplitude to displacement signal amplitude
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+        coef = Coefficients of polynomial fit to displacement record
+        disp_fit = Numpy array containing polynomial fit ordinates at each time
+    """
+
+
+get_residual2(fchp, *args):
+    """Return the residual defined as disp_init/disp - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        disp_time = Duration of initial portion of record before p-wave arrival
+        disp_target = Desired ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+    """
+```

ucla_geotech_tools-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "ucla_geotech_tools"
+version = "1.0.0"
+description = "A collection of software tools developed by the UCLA geotechnical group"
+authors = ["Scott J. Brandenberg"]
+license = "LICENSE.txt"
+readme = "README.md"
+
+packages = [
+    {include = "ucla_geotech_tools", from = "src"},
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+numpy = "^1.22"
+scipy = "^1.8"
+
+[tool.poetry.group.test.dependencies]
+obspy = "^1.4.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

ucla_geotech_tools-1.0.0/src/ucla_geotech_tools/auto_fchp.py

@@ -0,0 +1,193 @@
+import scipy as sp
+import numpy as np
+
+
+def get_residual1(fchp, *args):
+    """Return the residual defined as disp_fit/disp_filt - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        poly_order = Order of polynomial to fit to filtered displacement
+        target = Desired ratio of polynomial fit amplitude to displacement signal amplitude
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+        coef = Coefficients of polynomial fit to displacement record
+        disp_fit = Numpy array containing polynomial fit ordinates at each time
+    """
+    Fdisp = args[0]
+    time = args[1]
+    poly_order = args[2]
+    target = args[3]
+    freq = args[4]
+    filter_order = args[5]
+    filt = np.zeros(len(Fdisp))
+    filt[freq > 0] = 1 / np.sqrt(1 + (fchp / freq[freq > 0]) ** (2 * filter_order))
+    Fdisp_filt = Fdisp * filt
+    disp_filt = np.fft.irfft(Fdisp_filt)
+    coef = np.polyfit(time[0 : len(disp_filt)], disp_filt, poly_order)
+    disp_fit = np.polyval(coef, time)
+    return np.max(np.abs(disp_fit)) / np.max(np.abs(disp_filt)) - target
+
+
+def get_residual2(fchp, *args):
+    """Return the residual defined as disp_init/disp - target.
+
+    Args:
+        fchp = High-pass corner frequency
+        Fdisp = Numpy array containing Fourier coefficients of displacement record
+        time = Numpy array containing time values
+        disp_time = Duration of initial portion of record before p-wave arrival
+        disp_target = Desired ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+        freq = Numpy array containing frequency values
+
+    Computed variables:
+        filt = Coefficients of 5th order Butterworth filter
+        Fdisp_filt = Numpy array containing Fourier coefficients of filtered displacement record
+        disp_filt = Numpy array containing filtered displacement record
+    """
+    Fdisp = args[0]
+    time = args[1]
+    disp_time = args[2]
+    disp_target = args[3]
+    freq = args[4]
+    filter_order = args[5]
+    filt = np.zeros(len(Fdisp))
+    filt[freq > 0] = 1 / np.sqrt(1 + (fchp / freq[freq > 0]) ** (2 * filter_order))
+    Fdisp_filt = Fdisp * filt
+    disp_filt = np.fft.irfft(Fdisp_filt)
+    return (
+        np.max(np.abs(disp_filt[time <= disp_time])) / np.max(np.abs(disp_filt))
+        - disp_target
+    )
+
+
+def get_fchp(dt, acc, **kwargs):
+    """Return the high-pass corner frequency value that stabilizes the displacement of a ground motion record.
+
+    The high-pass corner frequency, fchp, is selected to satisfy two objectives:
+        1. A polynomial is fit to the filtered displacement record, and the amplitude of the polynomial fit
+        divided by the amplitude of the filtered displacement record is within a tolerance of a specified target.
+        2. The amplitude of the initial portion of the displacement record before the p-wave arrival divided by
+        the amplitude of the filtered displacement record is within a tolerance of a specified target.
+
+    The value of fchp is computed numerically using the Scipy package optimize.ridder(). Two initial values
+    of fchp are provided that bracket the root, and the Scipy package solves for the root that minimizes the
+    objective function. The tolerance is on the value of fchp (i.e., xtol in optimize.ridder)
+
+    A value of fchp is obtained first to satisfy objective 1. Objective 2 is optional, and if it is applied,
+    the value of fchp from objective 1 is checked against objective 2. If the residual from objective 2 is
+    less than or equal to zero, fchp is set equal to the value from objective 1. Otherwise, iterations are
+    performed to satisfy objective 2.
+
+    Args:
+        dt (float): time step in seconds
+        acc (numpy array, dtype=float): acceleration array in L/s/s
+
+    Keyword Args:
+        target: desired ratio of polynomial fit amplitude to displacement amplitude (default=0.02)
+        tol: tolerance for fchp (default=0.001)
+        poly_order: order of polynomial to fit to filtered displacement record (default=6)
+        maxiter: maximum number of iterations (default=30)
+        fchp_min: minimum frequency in Hz to consider for fchp (default=0.001)
+        fchp_max: maximum frequency in Hz to consider for fchp (default=0.5)
+        tukey_alpha: alpha parameter for scipy.signal.windows.tukey (default=0.05)
+        apply_disp_ratio: flag to indicate whether to apply objective 2 (default=0)
+        disp_ratio_time: duration in seconds of the initial portion of the record before the p-wave arrival (default=30)
+        disp_ratio_target: target ratio of amplitude of initial portion of displacement record to amplitude of displacement record
+    """
+    options = [
+        "dt",
+        "acc",
+        "target",
+        "tol",
+        "poly_order",
+        "maxiter",
+        "fchp_min",
+        "fchp_max",
+        "filter_order",
+        "tukey_alpha",
+        "filter_type",
+        "disp_ratio",
+        "disp_ratio_time",
+        "disp_ratio_target",
+    ]
+
+    for key, value in kwargs.items():
+        if key not in options:
+            print(
+                key
+                + " is not a valid argument. Please see documentation. Using default values for all parameters that are not specified."
+            )
+            exit(1)
+
+    target = kwargs.get("target", 0.02)
+    tol = kwargs.get("tol", 0.001)
+    poly_order = kwargs.get("poly_order", 6)
+    maxiter = kwargs.get("maxiter", 30)
+    fchp_min = kwargs.get("fchp_min", 0.001)
+    fchp_max = kwargs.get("fchp_max", 0.5)
+    filter_order = kwargs.get("filter_order", 5.0)
+    tukey_alpha = kwargs.get("tukey_alpha", 0.05)
+    apply_disp_ratio = kwargs.get("apply_disp_ratio", 0)
+    disp_ratio_time = kwargs.get("disp_ratio_time", 30)
+    disp_ratio_target = kwargs.get("disp_ratio_target", 0.02)
+
+    # Signal pre-processing. Subtract weighted mean, apply tukey window, define time, take FFT, compute Fdisp
+    if len(acc) % 2 != 0:
+        acc = acc[0:-1]
+    window = sp.signal.windows.tukey(len(acc), alpha=tukey_alpha)
+    meanacc = np.average(acc, weights=window)
+    acc = window * (acc - meanacc)
+    time = np.linspace(0, dt * len(acc), len(acc))
+    Facc = np.fft.rfft(acc)
+    freq = np.fft.rfftfreq(len(acc), dt)
+    Fdisp = np.zeros(len(Facc), dtype="complex")
+    Fdisp[freq > 0] = Facc[freq > 0] / -((2 * np.pi * freq[freq > 0]) ** 2)
+
+    # Solve fchp for objective 1
+    R0 = get_residual1(fchp_min, Fdisp, time, poly_order, target, freq, filter_order)
+    R2 = get_residual1(fchp_max, Fdisp, time, poly_order, target, freq, filter_order)
+    if np.sign(R0) != np.sign(R2):
+        fchp = sp.optimize.ridder(
+            get_residual1,
+            fchp_min,
+            fchp_max,
+            args=(Fdisp, time, poly_order, target, freq, filter_order),
+            xtol=tol,
+            maxiter=maxiter,
+        )
+    elif np.sign(R0) < 0:
+        fchp = minfc
+    elif np.sign(R2) > 0:
+        fchp = fchp_max
+
+    # Solve fchp for objective 2 if apply_disp_ratio is not zero
+    if apply_disp_ratio == 0:
+        return fchp
+    R0 = get_residual2(
+        fchp, Fdisp, time, disp_ratio_time, disp_ratio_target, freq, filter_order
+    )
+    R2 = get_residual2(
+        fchp_max, Fdisp, time, disp_ratio_time, disp_ratio_target, freq, filter_order
+    )
+    if np.sign(R0) != np.sign(R2):
+        fchp = sp.optimize.ridder(
+            get_residual2,
+            fchp,
+            fchp_max,
+            args=(Fdisp, time, disp_ratio_time, disp_ratio_target, freq, filter_order),
+            xtol=tol,
+            maxiter=maxiter,
+        )
+    elif np.sign(R0) < 0:
+        fchp = fchp
+    elif np.sign(R2) > 0:
+        fchp = fchp_max
+
+    return fchp

ucla_geotech_tools-1.0.0/src/ucla_geotech_tools/response_spectrum.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+def get_ngawest2_T():
+    return(np.asarray([0.01, 0.02, 0.022, 0.025, 0.029, 0.030, 0.032, 0.035, 0.036, 0.040, 0.042, 0.044, 0.045, 0.046, 0.048, 0.050, 0.055, 0.060, 0.065, 0.067, 0.070, 0.075, 0.080, 0.085, 0.090, 0.095, 0.100, 0.11, 0.12, 0.13, 0.133, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.22, 0.24, 0.25, 0.26, 0.28, 0.29, 0.30, 0.32, 0.34, 0.35, 0.36, 0.38, 0.40, 0.42, 0.44, 0.45, 0.46, 0.48, 0.50, 0.55, 0.60, 0.65, 0.667, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.5, 2.6, 2.8, 3.0, 3.2, 3.4, 3.5, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 20.0]))
+
+def next_fast_len(target):
+    I2 = 0
+    while(2.0**I2<target):
+        I2+=1
+    I3 = 0
+    while(3.0**I3<target):
+        I3+=1
+    I5 = 0
+    while(5.0**I5<target):
+        I5+=1
+    return np.min([2.0**I2, 3.0**I3, 5.0**I5])
+
+def get_ARS(T,D,motions,dt,zeropad):
+    if(zeropad==1):
+        NFFT = next_fast_len(len(motions))
+    else:
+        NFFT = len(motions[0])
+    freq = np.fft.rfftfreq(NFFT,dt)
+    Fmotions = np.fft.rfft(motions)
+    Sa = [None]*len(motions)
+    for i, Fmotion in enumerate(Fmotions):
+        Fconvolved_motion = Fmotion/(1.0+2.0j*D*freq*T[:,np.newaxis]-freq**2*T[:,np.newaxis]**2)
+        convolved_motion = np.fft.irfft(Fconvolved_motion)
+        Sa[i] = np.max(np.absolute(convolved_motion),axis=1)
+    return np.asarray(Sa)
+                    
+
+def get_response_spectrum(**kwargs):
+    if('motions' not in kwargs):
+        print('you must specify motions')
+        exit(1)
+    if('dt' not in kwargs):
+        print('you must specify dt')
+        exit(1)
+    verbose = kwargs.get('verbose',1)
+    T = kwargs.get('T',get_ngawest2_T())
+    motions = kwargs['motions']
+    D = kwargs.get('D',0.05)
+    zeropad = kwargs.get('zeropad',1)
+    dt = kwargs['dt']
+    if('RotD' in kwargs):
+        if((motions.shape[0]!=2)):
+            print('You must specify two motions instead of '+ str(motions.shape[0]) + ' if you specify RotD')
+            exit(1)
+        RotD = np.asarray(kwargs['RotD'],dtype='float64')
+        if(len(RotD)==1):
+            RotD = RotD.reshape((RotD.size, 1))
+        return get_rotD_ARS(T,D,motions[0],motions[1],dt,zeropad,RotD,100)
+    else:
+        return get_ARS(T,D,motions,dt,zeropad)