Home

Welcome to the ngl_tools wiki!

smt

The supported modeling team developed a Python code that contains the following functions.

function	description
cpt_inverse_filter(**kwargs)	Compute qt,inv, fs,inv, and Ic,inv
convolve(*args)	Convolve trial tip resistance profile with filter and return convolved profile
remove_interface_function(*args)	Identify layer interfaces and sharpen cone profile
smooth_function(*args)	Apply smoothing to cone data
cpt_layering(*args)	Use clustering to identify layers in CPT profile

cpt_inverse_filter(**kwargs)

This function implements the thin-layer correction algorithm by Boulanger and DeJong (2018) to inverse-filter cone penetration test data to account for the effects of layering on measured CPT resistance.

Boulanger, R.W. and DeJong, J.T. (2018). 'Inverse filtering procedure to correct cone penetration data for thin-layer and transition effects.' Cone Penetration Testing 2018 - Hicks, Pisano & Peuchen (Eds). 2018 Delft University of Technology, The Netherlands, ISBN 978-1-138-58449-5.

Description of cpt_inverse_filter command. Variables enclosed in <> are optional. If multiple variables are enclosed in <>, those variables either must all be excluded or all be included.

qt = Numpy array of cone tip resistance values.
fs = Nump array of cone sleeve friction values.
z = Numpy array of depth values.
sigmav = Numpy array of initial vertical total stress values.
sigmavp = Numpy array of initial vertical effective stress values.
z50ref = Scalar dimensionless depth filter parameter. Default = 4.2.
m50 = Scalar filter exponent parameter. Default = 0.5.
mq = Scalar filter parameter for computing z50. Default = 2.0.
mz = Scalar filter parameter for computing w2. Default = 3.0
dc = Scalar cone diameter in same units as z. Default = 0.03568 m.
n_iter = Integer maximum number of iterations. Default = 500
remove_interface = Boolean indicating whether to apply the layer interface correction. Default = True.
rate_lim = Scalar limiting dimensionless rate change in qt for defining an interface. Default = 0.1. Only applies when remove_interface = True.
smooth = Boolean indicating whether to apply a smoothing window to inverted data. Default = True.
tol = Scalar convergence tolerance. Default = 1.0e-6.
low_pass = Boolean indicating whether to apply low pass filter after convergence. Default = True.

method 'remove_interface(qtrial,z,rateLim,dc)' applies the layer interface correction, and returns a vector of corrected qt values. All variables must be provided (i.e., no optional arguments).
method 'def convolve(qt, zprime, C1, C2, z50ref, m50, mq, mz)' convolves qt with the filter, and returns a vector of filtered qt values. zprime, C1, and C2 are pre-computed in "layer_correct" to save time.
method 'get_Ic_Q_Fr(qt, fs, sigmav, sigmavp, pa=101.325, maxiter=30)' returns soil behavior type index, dimensionless cone tip resistance, and dimensionless sleeve friction.

convolve(*args)

This function performs the convolution operation between the CPT tip resistance and the filter.
It is called by cpt_inverse_filter().

inputs: qt = Numpy array of cone tip resistance values.
zprime = Dimensionless depth between a given depth and the cone tip. zprime = (z - z_tip) / dc
dc = cone diameter
C1 = A filter parameter used to define the w1 filter.
C2 = A filter parameter that is 0.8 for points above the cone tip, and 1.0 below the cone tip.
z50ref = Scalar dimensionless depth filter parameter.
m50 = Scalar filter exponent parameter.
mq = Scalar filter parameter for computing z50.
mz = Scalar filter parameter for computing w2.

outputs:
qt_convolved = Numpy array of convolved cone tip resistance values.

remove_interface_function(*args)

This function identifies layer interfaces and transition zones and sharpens the cone profile following the procedure described by Boulanger and DeJong (2018). This function is called by cpt_inverse_filter().

inputs: qtrial = Numpy array of trial values of cone tip resistance obtained by convolution.
z = Numpy array of depth values.
rate_lim = Scalar valued limiting rate of change of the log of cone tip resistance for identifying a transition zone.
dc = Scalar valued cone diameter.

outputs:
q_corrected = Numpy array of cone penetration test values after sharpening.

smooth_function(*args)

A function to smooth the cone data. This function is called by cpt_inverse_filter().

inputs:
y = Numpy array of values to smooth.
span = Integer number of data points to include in smoothing window

outputs:
smooth_y = Numpy array of smoothed values.

cpt_layering(*args)

A function that uses the agglomerative clustering algorithm by Hudson et al. (2023) to automatically identify spatially contiguous soil layers with similar q_c1Ncs and I_c values.

Hudson, K. S., Ulmer, K., Zimmaro, P., Kramer, S. L., Stewart, J. P., and Brandenberg, S. J. (2023). "Unsupervised Machine Learning for Detecting Soil Layer Boundaries from Cone Penetration Test Data." Earthquake Engineering and Structural Dynamics, 52(11). link

argument	format	description
qc1Ncs	Numpy array, dtype=float	overburden- and fines-corrected cone tip resistance
Ic	Numpy array, dtype=float	soil behavior type index
depth	Numpy array, dtype=float	depth to cpt measurement point
dGWT	float	depth to groundwater table
num_layers	integer	number of layers. optional. default = None.
tknob	float	constant used to define layer thickness parameter in cost function. optional. default = 0.5

Note

If num_layers = None, the optimal number of layers is selected automatically based on a cost function that balances the distortion score with the desired layer thickness specified by the tknob parameter.

returns
ztop: Numpy array

Depths to the tops of the layers.

zbot : Numpy array

Depths to the bottoms of the layers.

qc1Ncs_lay: = Numpy array

qc1Ncs values for the layers.

Ic_lay: Numpy array

soil behavior type index values for the layers.