integrals¶

Function summary¶

`EDload_coslinear`(loadtim, loadmag, omega, ...)	Integration of D[cos(omegatau+phase)load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`EDload_linear`(loadtim, loadmag, eigs, tvals)	Integration of D[load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`Eload_coslinear`(loadtim, loadmag, omega, ...)	Integration of cos(omegatau+phase)load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`Eload_linear`(loadtim, loadmag, eigs, tvals)	Integration of load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`dim1sin`(m, z)	sin(m*z) for each combination of m and z
`dim1sin_DD_abDDf_linear`(m, at, ab, bt, bb, ...)	Integration of sin(mi * z) * D[a(z) * b(z) D[sin(mj * z),z,2],z,2] between ztop and zbot where a(z) & b(z) is piecewise linear functions of z.
`dim1sin_D_aDb_linear`(m, at, ab, bt, bb, zt, zb)	Integrations of sin(mi * z) * D[a(z) * D[b(z), z], z] between ztop and zbot where a(z) is a piecewise linear function of z, and b(z) is a linear function of z.
`dim1sin_D_aDf_linear`(m, at, ab, zt, zb[, ...])	Integration of sin(mi * z) * D[a(z) * D[sin(mj * z),z],z] between ztop and zbot where a(z) is piecewise linear functions of z.
`dim1sin_a_linear_between`(m, at, ab, zt, zb, z)	Integrations of sin(mi * z) * a(z) between [z1, z2] where a(z) is a piecewise linear functions of z.
`dim1sin_ab_linear`(m, at, ab, bt, bb, zt, zb)	Integration of sin(mi * z) * a(z) * b(z) between ztop and zbot where a(z) and b(z) are piecewise linear functions of z.
`dim1sin_abc_linear`(m, at, ab, bt, bb, ct, ...)	Integrations of sin(mi * z) * a(z) * b(z) * c(z) between ztop and zbot where a(z), b(z), c(z) are piecewise linear functions of z.
`dim1sin_abf_linear`(m, at, ab, bt, bb, zt, zb)	Integration of sin(mi * z) * a(z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.
`dim1sin_af_linear`(m, at, ab, zt, zb[, ...])	Integration of sin(mi * z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.
`dim1sin_avg_between`(m, z)	Average of sin(m * z) between z1 and z2
`m_from_sin_mx`(i[, boundary])	Sine series eigenvalue of boundary value problem on [0, 1]
`pEDload_coslinear`(a, omega, phase, eigs, tvals)	Integration of D[cos(omegatau+phase)load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`pEDload_linear`(a, eigs, tvals[, dT])	Integration of D[load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`pEload_coslinear`(a, omega, phase, eigs, tvals)	Integration of cos(omegatau+phase)load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`pEload_linear`(a, eigs, tvals[, dT])	Integration of load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.
`pdim1sin_DD_abDDf_linear`(m, a, b, **kwargs)	Integration of sin(mi * z) * D[a(z) * b(z) D[sin(mj * z),z,2],z,2] between ztop and zbot where a(z) & b(z) is piecewise linear functions of z.
`pdim1sin_D_aDb_linear`(m, a, b, **kwargs)	Integrations of sin(mi * z) * D[a(z) * D[b(z), z], z] between ztop and zbot where a(z) is a piecewise linear function of z, and b(z) is a linear function of z.
`pdim1sin_D_aDf_linear`(m, a, **kwargs)	Integration of sin(mi * z) * D[a(z) * D[sin(mj * z),z],z] between ztop and zbot where a(z) is piecewise linear functions of z.
`pdim1sin_a_linear_between`(m, a, z, **kwargs)	Integrations of sin(mi * z) * a(z) between [z1, z2] where a(z) is a piecewise linear functions of z.
`pdim1sin_ab_linear`(m, a, b, **kwargs)	Integration of sin(mi * z) * a(z) * b(z) between ztop and zbot where a(z) and b(z) are piecewise linear functions of z.
`pdim1sin_abc_linear`(m, a, b, c, **kwargs)	Integrations of sin(mi * z) * a(z) * b(z) * c(z) between ztop and zbot where a(z), b(z), c(z) are piecewise linear functions of z.
`pdim1sin_abf_linear`(m, a, b, **kwargs)	Integration of sin(mi * z) * a(z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.
`pdim1sin_af_linear`(m, a, **kwargs)	Integration of sin(mi * z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.

Module listing¶

Integrals and eigenvalues for consolidation using spectral methods.

Most of the functions have been generated using geotecha.speccon.integrals_generate_code functions using sympy.

geotecha.speccon.integrals.EDload_coslinear(loadtim, loadmag, omega, phase, eigs, tvals, dT=1.0, implementation='vectorized')[source]¶

Integration of D[cos(omega*tau+phase)*load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

loadtim : 1d numpy.ndarray

List of times describing load application.

loadmag : 1d numpy.ndarray

List of load magnitudes.

omega, phase : float

Parameters that describe a cyclic load cos(omega * t + phase).

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

pEDload_coslinear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.edload_coslinear: Equivalent fortran function.
geotecha.speccon.integrals_generate_code.EDload_coslinear_implementations: Generation of code for this function.
EDload_linear: Similar function with no cosine term.
Eload_coslinear: Similar function but the combined loading function is not differentiated with respect to time.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in EDload_coslinear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{\frac{d{{\cos\left(\omega\tau+\textrm{phase}\right)}\sigma\left(\tau\right)}}{d\tau}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{\frac{d{{\cos\left(\omega\tau+\textrm{phase}\right)}\sigma\left(\tau\right)}}{d\tau}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`EDload_coslinear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by EDload_coslinear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.EDload_linear(loadtim, loadmag, eigs, tvals, dT=1.0, implementation='vectorized')[source]¶

Integration of D[load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

loadtim : 1d numpy.ndarray

List of times describing load application.

loadmag : 1d numpy.ndarray

List of load magnitudes.

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

pEDload_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.edload_linear: Equivalent fortran function.
geotecha.speccon.integrals_generate_code.EDload_linear_implementations: Generation of code for this function.
EDload_coslinear: Similar function with additional cosine term.
Eload_linear: Similar function but the time dependent loading function is not differentiated with repect to time.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in EDload_linear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{\frac{d{\sigma\left(\tau\right)}}{d\tau}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{\frac{d{\sigma\left(\tau\right)}}{d\tau}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`EDload_linear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by EDload_linear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.Eload_coslinear(loadtim, loadmag, omega, phase, eigs, tvals, dT=1.0, implementation='vectorized')[source]¶

Integration of cos(omega*tau+phase)*load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

loadtim : 1d numpy.ndarray

List of times describing load application.

loadmag : 1d numpy.ndarray

List of load magnitudes.

omega, phase : float

Parameters that describe a cyclic load cos(omega * t + phase).

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

pEload_coslinear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.eload_coslinear: Equivalent fortran function.
geotecha.speccon.integrals_generate_code.Eload_coslinear_implementations: Generation of code for this function.
Eload_linear: Similar function with no cosine term.
EDload_coslinear: Similar function but the combined loading function is differentiated with respect to time.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in Eload_coslinear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{{\cos\left(\omega\tau+\textrm{phase}\right)}{\sigma\left(\tau\right)}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{{\cos\left(\omega\tau+\textrm{phase}\right)}{\sigma\left(\tau\right)}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`Eload_coslinear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by Eload_coslinear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.Eload_linear(loadtim, loadmag, eigs, tvals, dT=1.0, implementation='vectorized')[source]¶

Integration of load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

loadtim : 1d numpy.ndarray

List of times describing load application.

loadmag : 1d numpy.ndarray

List of load magnitudes.

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

pEload_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.eload_linear: Equivalent fortran function.
geotecha.speccon.integrals_generate_code.Eload_linear_implementations: Generation of code for this function.
Eload_coslinear: Similar function with additional cosine term.
EDload_linear: Similar function but the time dependent loading function is differentiated with respect to time.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in Eload_linear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{{\sigma\left(\tau\right)}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{{\sigma\left(\tau\right)}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`Eload_linear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by Eload_linear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.dim1sin(m, z)[source]¶

sin(m*z) for each combination of m and z

Calculates array A[len(z), len(m)]

Parameters:

m : list of float

Eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

z : list of float

Normalised depth or z-coordinate should be between 0 and 1.

Returns:

A : numpy.ndarray

A 1d array size A[len(z), len(m)].

See also

m_from_sin_mx: used to generate ‘m’ input parameter

Notes

\[\mathbf{A}_{i,j}=\sin\left({m_j, z_i}\right)\]

geotecha.speccon.integrals.dim1sin_DD_abDDf_linear(m, at, ab, bt, bb, zt, zb, implementation='vectorized')[source]¶

Integration of sin(mi * z) * D[a(z) * b(z) D[sin(mj * z),z,2],z,2] between ztop and zbot where a(z) & b(z) is piecewise linear functions of z.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

bt : list of float

2nd property at top of each layer.

bb : list of float

2nd property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.integrals_generate_code.dim1sin_DD_abDDf_linear_implementations: Generation of code for this function.
pdim1sin_DD_abDDf_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_dd_abddf_linear: Equivalent fortran function.

Notes

The dim1sin_DD_abDDf_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{\frac{d^2}{dz^2}\left({a\left(z\right)}{b\left(z\right)}\frac{d^2\phi_j}{dz^2}\right)\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) and \(b\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer is defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

To make the above integration simpler we integate by parts to get:

\[\mathbf{A}_{i,j}= \left.{\frac{d}{dz}\left({a\left(z\right)}{b\left(z\right)}\frac{d^2\phi_j}{dz^2}\right)\phi_i}\right|_{z=0}^{z=1} - \left.{{a\left(z\right)}{b\left(z\right)}\frac{d^2\phi_j}{dz^2}\frac{d\phi_i}{dz}}\right|_{z=0}^{z=1} +\int_{0}^1{{a\left(z\right)}{b\left(z\right)}\frac{d^2\phi_j}{dz^2}\frac{d^2\phi_i}{dz^2}\,dz}\]

In this case the sine basis functions means the end point terms in the above equation are zero, leaving us with

\[\mathbf{A}_{i,j}= \int_{0}^1{{a\left(z\right)}{b\left(z\right)}\frac{d^2\phi_j}{dz^2}\frac{d^2\phi_i}{dz^2}\,dz}\]

geotecha.speccon.integrals.dim1sin_D_aDb_linear(m, at, ab, bt, bb, zt, zb, implementation='vectorized')[source]¶

Integrations of sin(mi * z) * D[a(z) * D[b(z), z], z] between ztop and zbot where a(z) is a piecewise linear function of z, and b(z) is a linear function of z.

Calulation of integrals is performed at each element of a 1d array (size depends on size of m).

Warning

The functions produced are set up to accept the b(z) input as piecewise linear, i.e. zt, zb, bt, bb etc. It is up to the user to ensure that the bt and bb are such that they define a continuous linear function. eg. to define b(z)=z+1 then use zt=[0,0.4], zb=[0.4, 1], bt=[1,1.4], bb=[1.4,2].

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

bt : list of float

2nd property at top of each layer.

bb : list of float

2nd property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 1d array size determined by size of m. Treat as column vector

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.speccon.integrals_generate_code.dim1sin_D_aDb_linear_implementations: Generation of code for this function.
pdim1sin_D_aDb_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_D_aDb_linear: Equivalent fortran function.

Notes

The dim1sin_D_aDb_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{\frac{d}{dz}\left({a\left(z\right)}\frac{d}{dz}{b\left(z\right)}\right)\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer is defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

\(b\left(z\right)\) is a linear function of \(z\) defined by

\[b\left(z\right) = b_t+\left({b_b-b_t}\right)z\]

with \(t\) and \(b\) subscripts now representing ‘top’ and ‘bottom’ of the profile respectively.

Using the product rule for differentiation the above integral can be split into:

\[\mathbf{A}_{i}=\int_{0}^1{\frac{da\left(z\right)}{dz}\frac{db\left(z\right)}{dz}\phi_i\,dz} + \int_{0}^1{a\left(z\right)\frac{d^2b\left(z\right)}{dz^2}\phi_i\,dz}\]

The right hand term is zero because \(b\left(z\right)\) is a continuous linear function so it’s second derivative is zero. The first derivative of \(b\left(z\right)\) is a constant so the left term can be integrated by parts to give:

\[\mathbf{A}_{i}=\frac{db\left(z\right)}{dz}\left( \left.\phi_i{a\left(z\right)}\right|_{z=0}^{z=1} - -\int_{0}^1{{a\left(z\right)}\frac{d\phi_i}{dz}\,dz} \right)\]

geotecha.speccon.integrals.dim1sin_D_aDf_linear(m, at, ab, zt, zb, implementation='vectorized')[source]¶

Integration of sin(mi * z) * D[a(z) * D[sin(mj * z),z],z] between ztop and zbot where a(z) is piecewise linear functions of z.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m)

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.speccon.integrals_generate_code.dim1sin_D_aDf_linear_implementations: Generation of code for this function.
pdim1sin_D_aDf_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_D_aDf_linear: Equivalent fortran function.

Notes

The dim1sin_D_aDf_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{\frac{d}{dz}\left({a\left(z\right)}\frac{d\phi_j}{dz}\right)\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer is defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

To make the above integration simpler we integate by parts to get:

\[\mathbf{A}_{i,j}= \left.\phi_i{a\left(z\right)}\frac{d\phi_j}{dz}\right|_{z=0}^{z=1} -\int_{0}^1{{a\left(z\right)}\frac{d\phi_j}{dz}\frac{d\phi_i}{dz}\,dz}\]

In this case the sine basis functions means the left term in the above equation is zero, leaving us with

\[\mathbf{A}_{i,j}= -\int_{0}^1{{a\left(z\right)}\frac{d\phi_j}{dz}\frac{d\phi_i}{dz}\,dz}\]

geotecha.speccon.integrals.dim1sin_a_linear_between(m, at, ab, zt, zb, z)[source]¶

Integrations of sin(mi * z) * a(z) between [z1, z2] where a(z) is a piecewise linear functions of z.

Calculates array A[len(z), len(m)].

Parameters:

m : list of float

Eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

z : list of list of float``

Normalised depth or z-coordinate pair should be two values between 0 and 1.

Returns:

A : numpy.ndarray

A 2d array size of size [len(z), len(m)].

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.speccon.integrals_generate_code.dim1sin_a_linear_between: Generation of code for this function.
pdim1sin_a_linear_between: Same function with PolyLine inputs.
geotecha.piecewise.piecewise_linear_1d.segments_between_xi_and_xj: Used in the function.

Notes

The dim1sin_a_linear_between, \(A\), is given by:

\[\mathbf{A}_{i,j}= \int_{z_1}^{z_2}{{a\left(z\right)}\phi_j\,dz}\]

where the basis function \(\phi_j\) is given by:

\[\phi_j\left(z\right)=\sin\left({m_j}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.dim1sin_ab_linear(m, at, ab, bt, bb, zt, zb, implementation='vectorized')[source]¶

Integration of sin(mi * z) * a(z) * b(z) between ztop and zbot where a(z) and b(z) are piecewise linear functions of z.

Calulation of integrals is performed at each element of a 1d array (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

bt : list of float

2nd property at top of each layer.

bb : list of float

2nd property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 1d array size determined by size of m. Treat as column vector

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.speccon.integrals_generate_code.dim1sin_ab_linear_implementations: Generation of code for this function.
pdim1sin_ab_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_ab_linear: Equivalent fortran function.

Notes

The dim1sin_ab_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{{a\left(z\right)}{b\left(z\right)}\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) and \(b\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.dim1sin_abc_linear(m, at, ab, bt, bb, ct, cb, zt, zb, implementation='vectorized')[source]¶

Integrations of sin(mi * z) * a(z) * b(z) * c(z) between ztop and zbot where a(z), b(z), c(z) are piecewise linear functions of z.

Calulation of integrals is performed at each element of a 1d array (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

bt : list of float

2nd property at top of each layer.

bb : list of float

2nd property at bottom of each layer.

ct : list of float

3rd property at top of each layer.

cb : list of float

3rd property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 1d array size determined by size of m. Treat as column vector.

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.speccon.integrals_generate_code.dim1sin_abc_linear_implementations: Generation of code for this function.
pdim1sin_abc_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_abc_linear: Equivalent fortran function.

Notes

The dim1sin_abc_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{{a\left(z\right)}{b\left(z\right)}{c\left(z\right)}\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\), \(b\left(z\right)\), and \(c\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.dim1sin_abf_linear(m, at, ab, bt, bb, zt, zb, implementation='vectorized')[source]¶

Integration of sin(mi * z) * a(z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

bt : list of float

2nd property at top of each layer.

bb : list of float

2nd property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.integrals_generate_code.dim1sin_abf_linear: Generation of code for this function.
pdim1sin_abf_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_abf_linear: Equivalent fortran function.

Notes

The dim1sin_abf_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{{a\left(z\right)}{b\left(z\right)}\phi_i\phi_j\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) and \(b\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.dim1sin_af_linear(m, at, ab, zt, zb, implementation='vectorized')[source]¶

Integration of sin(mi * z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.

Calculation of integrals is performed at each element of a square symmetric matrix (size depends on size of m)

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

at : list of float

Property at top of each layer.

ab : list of float

Property at bottom of each layer.

zt : list of float

Normalised depth or z-coordinate at top of each layer. zt[0] = 0

zb : list of float

Normalised depth or z-coordinate at bottom of each layer. zt[-1] = 1

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

m_from_sin_mx: Used to generate ‘m’ input parameter.
geotecha.integrals_generate_code.dim1sin_af_linear: Generation of code for this function.
pdim1sin_af_linear: Same function with PolyLine inputs.
geotecha.speccon.ext_integrals.dim1sin_af_linear: Equivalent fortran function.

Notes

The dim1sin_af_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{{a\left(z\right)}\phi_i\phi_j\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear function with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.dim1sin_avg_between(m, z)[source]¶

Average of sin(m * z) between z1 and z2

Integrate(sin(m*z), (z, z1, z2))/(z2-z1) for each combination of m and [z1,z2].

Calculates array A[len(z), len(m)].

Parameters:

m : list of float

Eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

z : list of list of float``

Normalised depth or z-coordinate pair should be two values between 0 and 1..

Returns:

A : numpy.ndarray

A 1d array size A[len(z), len(m)]

See also

m_from_sin_mx: used to generate ‘m’ input parameter

Notes

\[\mathbf{A}_{i,j}=\frac{1}{z_{2i}-z_{1i}}\int_{z_{1i}}^{z_{2i}}{\sin\left({m_j, z}\right)\,dz}\]

geotecha.speccon.integrals.m_from_sin_mx(i, boundary=0)[source]¶

Sine series eigenvalue of boundary value problem on [0, 1]

i th eigenvalue, M, of f(x) = sin(M*x) that satisfies:: f(0) = 0, f(1) = 0; for boundary = 0 i.e. PTPB f(0) = 0; f’(1) = 0; for boundary = 1 i.e. PTIB

Parameters:

i : int

Eigenvalue number in series to return.

boundary : {0, 1}, optional

Boundary condition. For ‘Pervious Top Pervious Bottom (PTPB)’, boundary = 0. For ‘Pervious Top Impervious Bottom (PTIB)’, boundary = 1. Default boundary=0.

Returns:

out : float

The i th eigenvalue

geotecha.speccon.integrals.pEDload_coslinear(a, omega, phase, eigs, tvals, dT=1.0, **kwargs)[source]¶

Integration of D[cos(omega*tau+phase)*load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Wrapper for EDload_coslinear to allow PolyLine inputs.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

a : PolyLine

PolyLine object representing piecewise linear load vs time. List of load magnitudes.

omega, phase : float

Parameters that describe a cyclic load cos(omega * t + phase).

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

pEDload_coslinear: Same function with PolyLine inputs.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in EDload_coslinear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{\frac{d{{\cos\left(\omega\tau+\textrm{phase}\right)}\sigma\left(\tau\right)}}{d\tau}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{\frac{d{{\cos\left(\omega\tau+\textrm{phase}\right)}\sigma\left(\tau\right)}}{d\tau}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`EDload_coslinear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by EDload_coslinear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.pEDload_linear(a, eigs, tvals, dT=1.0, **kwargs)[source]¶

Integration of D[load(tau), tau] * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Wrapper for EDload_linear to allow PolyLine inputs.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

a : PolyLine

PolyLine object representing piecewise linear load vs time.

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

EDload_linear: Wrapped function.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in EDload_linear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{\frac{d{\sigma\left(\tau\right)}}{d\tau}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{{\sigma\left(\tau\right)}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`EDload_linear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by EDload_linear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.pEload_coslinear(a, omega, phase, eigs, tvals, dT=1.0, **kwargs)[source]¶

Integration of cos(omega*tau+phase)*load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Wrapper for Eload_coslinear to allow PolyLine inputs.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

a : PolyLine

PolyLine object representing piecewise linear load vs time.

omega, phase : float

Parameters that describe a cyclic load cos(omega * t + phase).

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

Eload_coslinear: Wrapped function.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in Eload_coslinear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{{\cos\left(\omega\tau+\textrm{phase}\right)}{\sigma\left(\tau\right)}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{{\cos\left(\omega\tau+\textrm{phase}\right)}{\sigma\left(\tau\right)}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`Eload_coslinear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by Eload_coslinear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.pEload_linear(a, eigs, tvals, dT=1.0, **kwargs)[source]¶

Integration of load(tau) * exp(dT * eig * (t-tau)) between [0, t], where load(tau) is piecewise linear.

Wrapper for Eload_linear to allow PolyLine inputs.

Performs integrations involving a piecewise linear load. A 2d array of dimensions A[len(tvals), len(eigs)] is produced where the ‘i’th row of A contains the diagonal elements of the spectral ‘E’ matrix calculated for the time value tvals[i]. i.e. rows of this matrix will be assembled into the diagonal matrix ‘E’ elsewhere.

Parameters:

a : PolyLine

PolyLine object representing piecewise linear load vs time.

eigs : 1d numpy.ndarray

List of eigenvalues.

tvals : 1d numpy.ndarray`

List of time values to calculate integral at.

dT : float, optional

Time factor multiple (Default dT=1.0).

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 2d array of dimesnions A[len(tvals), len(eigs)]. The ‘i’th row of A is the diagonal elements of the spectral ‘E’ matrix calculated for the time tvals[i].

See also

Eload_linear: Wrapped function, see for equations and other related functions.

Notes

Assuming the load are formulated as the product of separate time and depth dependant functions:

\[\sigma\left({Z,t}\right)=\sigma\left({Z}\right)\sigma\left({t}\right)\]

the solution to the consolidation equation using the spectral method has the form:

\[u\left(Z,t\right)=\mathbf{\Phi v E}\left(\mathbf{\Gamma v}\right)^{-1}\mathbf{\theta}\]

The matrix \(E\) is a time dependent diagonal matrix due to time dependant loadings. The version of \(E\) calculated here in Eload_linear is from loading terms in the governing equation that are NOT differentiated wrt \(t\). The diagonal elements of \(E\) are given by:

\[\mathbf{E}_{i,i}=\int_{0}^t{{\sigma\left(\tau\right)}{\exp\left({(dT\left(t-\tau\right)\lambda_i}\right)}\,d\tau}\]

where

\(\lambda_i\) is the ith eigenvalue of the problem, \(dT\) is a time factor for numerical convienience, \(\sigma\left(\tau\right)\) is the time dependant portion of the loading function.

When the time dependant loading term \(\sigma\left(\tau\right)\) is piecewise in time. The contribution of each load segment is found by:

\[\mathbf{E}_{i,i}=\int_{t_s}^{t_f}{{\sigma\left(\tau\right)}\exp\left({dT\left(t-\tau\right)*\lambda_i}\right)\,d\tau}\]

where

\[t_s = \min\left(t,t_{increment\:start}\right)\]

\[t_f = \min\left(t,t_{increment\:end}\right)\]

(note that this function,`Eload_linear`, rather than use \(t_s\) and \(t_f\), explicitly finds increments that the current time falls in, falls after, and falls before and treates each case on it’s own.)

Each \(t\) value of interest requires a separate diagonal matrix \(E\). To use space more efficiently and to facilitate numpy broadcasting when using the results of the function, the diagonal elements of \(E\) for each time value t value are stored in the rows of array \(A\) returned by Eload_linear. Thus:

\[\begin{split}\mathbf{A}=\left(\begin{matrix}E_{0,0}(t_0)&E_{1,1}(t_0)& \cdots & E_{neig-1,neig-1}(t_0)\\ E_{0,0}(t_1)&E_{1,1}(t_1)& \cdots & E_{neig-1,neig-1}(t_1)\\ \vdots&\vdots&\ddots&\vdots \\ E_{0,0}(t_m)&E_{1,1}(t_m)& \cdots & E_{neig-1,neig-1}(t_m)\end{matrix}\right)\end{split}\]

geotecha.speccon.integrals.pdim1sin_DD_abDDf_linear(m, a, b, **kwargs)[source]¶

Integration of sin(mi * z) * D[a(z) * b(z) D[sin(mj * z),z,2],z,2] between ztop and zbot where a(z) & b(z) is piecewise linear functions of z.

Wrapper for dim1sin_DD_abDDf_linear to allow PolyLine inputs.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a, b : PolyLine object

PolyLine defining piecewise linear relationship.

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

dim1sin_D_aDb_linear: Wrapped function.

Notes

The dim1sin_D_aDb_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{\frac{d}{dz}\left({a\left(z\right)}\frac{d}{dz}{b\left(z\right)}\right)\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer is defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

\(b\left(z\right)\) is a linear function of \(z\) defined by

\[b\left(z\right) = b_t+\left({b_b-b_t}\right)z\]

with \(t\) and \(b\) subscripts now representing ‘top’ and ‘bottom’ of the profile respectively.

Using the product rule for differentiation the above integral can be split into:

\[\mathbf{A}_{i}=\int_{0}^1{\frac{da\left(z\right)}{dz}\frac{db\left(z\right)}{dz}\phi_i\,dz} + \int_{0}^1{a\left(z\right)\frac{d^2b\left(z\right)}{dz^2}\phi_i\,dz}\]

The right hand term is zero because \(b\left(z\right)\) is a continuous linear function so it’s second derivative is zero. The first derivative of \(b\left(z\right)\) is a constant so the left term can be integrated by parts to give:

\[\mathbf{A}_{i}=\frac{db\left(z\right)}{dz}\left( \left.\phi_i{a\left(z\right)}\right|_{z=0}^{z=1} - -\int_{0}^1{{a\left(z\right)}\frac{d\phi_i}{dz}\,dz} \right)\]

geotecha.speccon.integrals.pdim1sin_D_aDf_linear(m, a, **kwargs)[source]¶

Integration of sin(mi * z) * D[a(z) * D[sin(mj * z),z],z] between ztop and zbot where a(z) is piecewise linear functions of z.

Wrapper for dim1sin_D_aDf_linear to allow PolyLine inputs.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m)

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a : PolyLine object

PolyLine defining piecewise linear relationship.

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

dim1sin_D_aDf_linear: Wrapped function.

Notes

The dim1sin_D_aDf_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{\frac{d}{dz}\left({a\left(z\right)}\frac{d\phi_j}{dz}\right)\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer is defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

To make the above integration simpler we integate by parts to get:

\[\mathbf{A}_{i,j}= \left.\phi_i{a\left(z\right)}\frac{d\phi_j}{dz}\right|_{z=0}^{z=1} -\int_{0}^1{{a\left(z\right)}\frac{d\phi_j}{dz}\frac{d\phi_i}{dz}\,dz}\]

In this case the sine basis functions means the left term in the above equation is zero, leaving us with

\[\mathbf{A}_{i,j}= -\int_{0}^1{{a\left(z\right)}\frac{d\phi_j}{dz}\frac{d\phi_i}{dz}\,dz}\]

geotecha.speccon.integrals.pdim1sin_a_linear_between(m, a, z, **kwargs)[source]¶

Integrations of sin(mi * z) * a(z) between [z1, z2] where a(z) is a piecewise linear functions of z.

Wrapper for dim1sin_a_linear_between to allow PolyLine inputs.

Calculates array A[len(z), len(m)].

Parameters:

m : list of float

Eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a : PolyLine object

PolyLine defining piecewise linear relationship.

z : list of list of float``

Normalised depth or z-coordinate pair should be two values between 0 and 1.

Returns:

A : numpy.ndarray

A 2d array size of size [len(z), len(m)].

See also

dim1sin_a_linear_between: Wrapped function.

Notes

The dim1sin_a_linear_between, \(A\), is given by:

\[\mathbf{A}_{i,j}= \int_{z_1}^{z_2}{{a\left(z\right)}\phi_j\,dz}\]

where the basis function \(\phi_j\) is given by:

\[\phi_j\left(z\right)=\sin\left({m_j}z\right)\]

and \(a\left(z\right)\) is a piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.pdim1sin_ab_linear(m, a, b, **kwargs)[source]¶

Integration of sin(mi * z) * a(z) * b(z) between ztop and zbot where a(z) and b(z) are piecewise linear functions of z.

Wrapper for dim1sin_ab_linear to allow PolyLine inputs.

Calulation of integrals is performed at each element of a 1d array (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a, b : PolyLine object

PolyLine defining piecewise linear relationship.

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 1d array size determined by size of m. Treat as column vector.

See also

dim1sin_ab_linear: Wrapped function.

Notes

The dim1sin_ab_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{{a\left(z\right)}{b\left(z\right)}\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) and \(b\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.pdim1sin_abc_linear(m, a, b, c, **kwargs)[source]¶

Integrations of sin(mi * z) * a(z) * b(z) * c(z) between ztop and zbot where a(z), b(z), c(z) are piecewise linear functions of z.

Wrapper for dim1sin_abc_linear to allow PolyLine inputs.

Calulation of integrals is performed at each element of a 1d array (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a, b, c : PolyLine object

PolyLine defining piecewise linear relationship.

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A 1d array size determined by size of m. Treat as column vector.

See also

dim1sin_abc_linear: Wrapped function.

Notes

The dim1sin_abc_linear which should be treated as a column vector, \(A\) is given by:

\[\mathbf{A}_{i}=\int_{0}^1{{a\left(z\right)}{b\left(z\right)}{c\left(z\right)}\phi_i\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\), \(b\left(z\right)\), and \(c\left(z\right)\) are piecewise linear functions with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

geotecha.speccon.integrals.pdim1sin_abf_linear(m, a, b, **kwargs)[source]¶

Integration of sin(mi * z) * a(z) * a(z) * sin(mj * z) between ztop and zbot where a(z) is piecewise linear.

Wrapper for dim1sin_abf_linear to allow PolyLine inputs.

Calulation of integrals is performed at each element of a square symmetric matrix (size depends on size of m).

Parameters:

m : list of float

eigenvlaues of BVP. generate with geoteca.speccon.m_from_sin_mx

a, b : PolyLine object

PolyLine defining piecewise linear relationship.

implementation : [‘vectorized’, ‘scalar’, ‘fortran’], optional

Functional implementation: ‘scalar’ = python loops (slow), ‘fortran’ = fortran code (fastest), ‘vectorized’ = numpy(fast). Default implementation=’vectorized’. If fortran extention module cannot be imported then ‘vectorized’ version will be used. If anything other than ‘fortran’ or ‘scalar’ is used then default vectorized version will be used.

Returns:

A : numpy.ndarray

A square symmetric matrix, size determined by size of m.

See also

dim1sin_af_linear

Notes

The dim1sin_af_linear matrix, \(A\) is given by:

\[\mathbf{A}_{i,j}=\int_{0}^1{{a\left(z\right)}\phi_i\phi_j\,dz}\]

where the basis function \(\phi_i\) is given by:

\[\phi_i\left(z\right)=\sin\left({m_i}z\right)\]

and \(a\left(z\right)\) is a piecewise linear function with respect to \(z\), that within a layer are defined by:

\[a\left(z\right) = a_t+\frac{a_b-a_t}{z_b-z_t}\left(z-z_t\right)\]

with \(t\) and \(b\) subscripts representing ‘top’ and ‘bottom’ of each layer respectively.

Table Of Contents

Related Topics

This Page

integrals¶

Function summary¶

Module listing¶