def capacity_vesic_1975(sl,
fd,
h_l=0,
h_b=0,
vertical_load=1,
slope=0,
base_tilt=0,
verbose=0,
gwl=1e6,
**kwargs):
"""
Calculates the foundation capacity according Vesics(1975)
#Gunaratne, Manjriker. 2006. "Spread Footings: Analysis and Design."
Ref: http://geo.cv.nctu.edu.tw/foundation/download/
BearingCapacityOfFoundations.pdf
:param sl: Soil object
:param fd: Foundation object
:param h_l: Horizontal load parallel to length
:param h_b: Horizontal load parallel to width
:param vertical_load: Vertical load
:param slope: ground slope
:param base_tilt: The slope of the underside of the foundation
:param verbose: verbosity
:return: ultimate bearing stress
"""
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
if fd.length > fd.width: # TODO: deal with plane strain
fd_length = fd.length
fd_width = fd.width
else:
fd_length = fd.width
fd_width = fd.length
area_foundation = fd_length * fd_width
c_a = 0.6 - 1.0 * sl.cohesion
horizontal_load = np.sqrt(h_l**2 + h_b**2)
fd.nq_factor = ((np.tan(np.pi / 4 + sl.phi_r / 2))**2 *
np.exp(np.pi * np.tan(sl.phi_r)))
if sl.phi_r == 0:
fd.nc_factor = 5.14
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
fd.ng_factor = 2.0 * (fd.nq_factor + 1) * np.tan(sl.phi_r)
# shape factors:
s_c = 1.0 + fd.nq_factor / fd.nc_factor * fd_width / fd_length
s_q = 1 + fd_width / fd_length * np.tan(sl.phi_r)
s_g = max(1.0 - 0.4 * fd_width / fd_length,
0.6) # add limit of 0.6 based on Vesic
# depth factors:
if fd.depth / fd_width > 1:
k = np.arctan(fd.depth / fd_width)
else:
k = fd.depth / fd_width
d_c = 1 + 0.4 * k
d_q = 1 + 2 * np.tan(sl.phi_r) * (1 - np.sin(sl.phi_r))**2 * k
d_g = 1.0
# load inclination factors
m__b = (2.0 + fd_width / fd_length) / (1 + fd_width / fd_length)
m_l = (2.0 + fd_length / fd_width) / (1 + fd_length / fd_width)
m = np.sqrt(m__b**2 + m_l**2)
if sl.phi_r == 0:
i_q = 1.0
i_g = 1.0
else:
i_q = (1.0 - horizontal_load /
(vertical_load + area_foundation * c_a / np.tan(sl.phi_r)))**m
i_g = (1.0 - horizontal_load /
(vertical_load + area_foundation * c_a / np.tan(sl.phi_r)))**(
m + 1)
i_c = i_q - (1 - i_q) / (fd.nq_factor - 1)
check_i_c = 1 - m * horizontal_load / (area_foundation * c_a *
fd.nc_factor)
if abs(check_i_c - i_c) / i_c > 0.001:
raise DesignError
# ground slope factors:
if sl.phi_r == 0:
# g_c = slope / 5.14
g_c = i_q
else:
g_c = i_q - (1 - i_q) / (5.14 * np.tan(sl.phi_r))
g_q = (1.0 - np.tan(slope))**2
g_g = g_q
# tilted base factors
if sl.phi_r == 0:
b_c = g_c
else:
b_c = 1 - 2 * base_tilt / (5.14 * np.tan(sl.phi_r))
b_q = (1.0 - base_tilt * np.tan(sl.phi_r))**2
b_g = b_q
# stress at footing base:
if gwl == 0:
q_d = sl.unit_eff_weight * fd.depth
unit_weight = sl.unit_bouy_weight
elif gwl > 0 and gwl < fd.depth:
q_d = (sl.unit_dry_weight * gwl) + (sl.unit_bouy_weight *
(fd.depth - gwl))
unit_weight = sl.unit_bouy_weight
elif gwl >= fd.depth and gwl <= fd.depth + fd_width:
sl.average_unit_bouy_weight = sl.unit_bouy_weight + (
((gwl - fd.depth) / fd_width) *
(sl.unit_dry_weight - sl.unit_bouy_weight))
q_d = sl.unit_dry_weight * fd.depth
unit_weight = sl.average_unit_bouy_weight
elif gwl > fd.depth + fd_width:
q_d = sl.unit_dry_weight * fd.depth
unit_weight = sl.unit_dry_weight
if verbose:
log("Nc: ", fd.nc_factor)
log("N_qV: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("d_c: ", d_c)
log("d_q: ", d_q)
log("d_g: ", d_g)
log("i_c: ", i_c)
log("i_q: ", i_q)
log("i_g: ", i_g)
log("g_c: ", g_c)
log("g_q: ", g_q)
log("g_g: ", g_g)
log("b_c: ", b_c)
log("b_q: ", b_q)
log("b_g: ", b_g)
log("q_d: ", q_d)
# Capacity
fd.q_ult = (sl.cohesion * fd.nc_factor * s_c * d_c * i_c * g_c * b_c +
q_d * fd.nq_factor * s_q * d_q * i_q * g_q * b_q +
0.5 * fd_width * unit_weight * fd.ng_factor * s_g * d_g * i_g *
g_g * b_g)
if verbose:
log("qult: ", fd.q_ult)
return fd.q_ult
def capacity_salgado_2008(sl,
fd,
h_l=0,
h_b=0,
vertical_load=1,
verbose=0,
**kwargs):
"""
Calculates the capacity according to
The Engineering of Foundations textbook by Salgado
ISBN: 0072500581
The method combines load factors from Bolton (1979) and shape factors from Brinch-Hansen (1970)
:param sl: Soil object
:param fd: Foundation object
:param h_l: Horizontal load parallel to length
:param h_b: Horizontal load parallel to width
:param vertical_load: Vertical load
:param verbose: verbosity
:return: ultimate bearing stress
"""
# Need to make adjustments if sand has DR<40% or
# clay has liquidity indices greater than 0.7
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
h_eff_b = kwargs.get("h_eff_b", 0)
h_eff_l = kwargs.get("h_eff_l", 0)
ip_axis_2d = kwargs.get('ip_axis_2d', None)
# TODO: implement phi as fn of sigma_m
temp_fd_length = fd.length
temp_fd_width = fd.width
if ip_axis_2d is not None:
if ip_axis_2d == 'width':
temp_fd_length = temp_fd_width * 100
elif ip_axis_2d == 'length':
temp_fd_width = temp_fd_length * 100
else:
raise ValueError(
f"ip_axis_2d must be either 'width' or 'length', not {ip_axis_2d}"
)
v_l = kwargs.get("loc_v_l", temp_fd_length / 2) # given in fd coordinates
v_b = kwargs.get("loc_v_b", temp_fd_width / 2)
if temp_fd_length > temp_fd_width: # TODO: deal with plane strain
fd_length = temp_fd_length
fd_width = temp_fd_width
loc_v_l = v_l
loc_v_b = v_b
loc_h_b = h_b
loc_h_l = h_l
else:
fd_length = temp_fd_width
fd_width = temp_fd_length
loc_v_l = v_b
loc_v_b = v_l
loc_h_b = h_l
loc_h_l = h_b
ecc_b = loc_h_b * h_eff_b / vertical_load
ecc_l = loc_h_l * h_eff_l / vertical_load
width_eff = min(fd_width, 2 * (loc_v_b + ecc_b),
2 * (fd_width - loc_v_b - ecc_b))
length_eff = min(fd_length, 2 * (loc_v_l + ecc_l),
2 * (fd_length - loc_v_l - ecc_l))
# check para 3.4.1
if width_eff / 2 < fd_width / 6:
DesignError("failed on eccentricity")
# LOAD FACTORS:
fd.nq_factor = np.exp(np.pi * np.tan(sl.phi_r)) * (
1 + np.sin(sl.phi_r)) / (1 - np.sin(sl.phi_r))
fd.ng_factor = 1.5 * (fd.nq_factor - 1) * np.tan(sl.phi_r)
# fd.ng_factor = (fd.nq_factor - 1) * np.tan(1.32 * sl.phi_r)
if sl.phi_r == 0:
fd.nc_factor = 5.14
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
# shape factors:
s_q = 1 + (width_eff / length_eff) * np.sin(sl.phi_r)
s_g = max(1 - 0.4 * width_eff / length_eff, 0.6)
s_c = 1.0
# depth factors:
d_over_b = min(1, fd.depth / width_eff) # limit to 1
d_q = 1 + 2 * np.tan(sl.phi_r) * (1 - np.sin(sl.phi_r))**2 * d_over_b
d_g = 1.0
d_c = 1.0
# stress at footing base:
q_d = sl.unit_dry_weight * fd.depth
if verbose:
log("width_eff: ", width_eff)
log("length_eff: ", length_eff)
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("d_c: ", d_c)
log("d_q: ", d_q)
log("d_g: ", d_g)
log("q_d: ", q_d)
# Capacity
fd.q_ult = (
sl.cohesion * fd.nc_factor * s_c * d_c +
q_d * fd.nq_factor * s_q * d_q +
0.5 * width_eff * sl.unit_dry_weight * fd.ng_factor * s_g * d_g)
if verbose:
log("qult: ", fd.q_ult)
return fd.q_ult
def capacity_nzs_vm4_2011(sl,
fd,
h_l=0,
h_b=0,
vertical_load=1,
slope=0,
verbose=0,
**kwargs):
"""
calculates the capacity according to
Appendix B verification method 4 of the NZ building code
:param sl: Soil object
:param fd: Foundation object
:param h_l: Horizontal load parallel to length
:param h_b: Horizontal load parallel to width
:param vertical_load: Vertical load
:param slope: ground slope
:param verbose: verbosity
:return: ultimate bearing stress
"""
# Need to make adjustments if sand has DR<40% or
# clay has liquidity indices greater than 0.7
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
horizontal_load = np.sqrt(h_l**2 + h_b**2)
v_l = kwargs.get("loc_v_l", fd.length / 2) # given in fd coordinates
v_b = kwargs.get("loc_v_b", fd.width / 2)
h_eff_b = kwargs.get("h_eff_b", 0)
h_eff_l = kwargs.get("h_eff_l", 0)
if fd.length > fd.width: # TODO: deal with plane strain
fd_length = fd.length
fd_width = fd.width
loc_v_l = v_l
loc_v_b = v_b
loc_h_b = h_b
loc_h_l = h_l
else:
fd_length = fd.width
fd_width = fd.length
loc_v_l = v_b
loc_v_b = v_l
loc_h_b = h_l
loc_h_l = h_b
ecc_b = loc_h_b * h_eff_b / vertical_load
ecc_l = loc_h_l * h_eff_l / vertical_load
width_eff = min(fd_width, 2 * (loc_v_b + ecc_b),
2 * (fd_width - loc_v_b - ecc_b))
length_eff = min(fd_length, 2 * (loc_v_l + ecc_l),
2 * (fd_length - loc_v_l - ecc_l))
area_foundation = length_eff * width_eff
# check para 3.4.1
if width_eff / 2 < fd_width / 6:
raise DesignError("failed on eccentricity")
# LOAD FACTORS:
fd.nq_factor = ((np.tan(np.pi / 4 + sl.phi_r / 2))**2 *
np.exp(np.pi * np.tan(sl.phi_r)))
if sl.phi_r == 0:
fd.nc_factor = 5.14
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
fd.ng_factor = 2.0 * (fd.nq_factor - 1) * np.tan(sl.phi_r)
# shape factors:
s_c = 1.0 + fd.nq_factor / fd.nc_factor * width_eff / length_eff
s_q = 1 + width_eff / length_eff * np.tan(sl.phi_r)
s_g = max(1.0 - 0.4 * width_eff / length_eff,
0.6) # add limit of 0.6 based on Vesics
# depth factors:
if fd.depth / width_eff > 1:
k = np.arctan(fd.depth / width_eff)
else:
k = fd.depth / width_eff
if sl.phi_r == 0:
d_c = 1 + 0.4 * k
d_q = 1.0
else:
d_q = (1 + 2 * np.tan(sl.phi_r) * (1 - np.sin(sl.phi_r))**2 * k)
d_c = d_q - (1 - d_q) / (fd.nq_factor * np.tan(sl.phi_r))
d_g = 1.0
# load inclination factors:
if sl.phi_r == 0:
i_c = 0.5 * (1 + np.sqrt(1 - horizontal_load /
(area_foundation * sl.cohesion)))
i_q = 1.0
i_g = 1.0
else:
if h_b == 0:
i_q = 1 - horizontal_load / (vertical_load + area_foundation *
sl.cohesion / np.tan(sl.phi_r))
i_g = i_q
elif h_b > 0 and h_l == 0:
i_q = ((1 - 0.7 * horizontal_load /
(vertical_load +
area_foundation * sl.cohesion / np.tan(sl.phi_r)))**3)
i_g = ((1 - horizontal_load /
(vertical_load +
area_foundation * sl.cohesion / np.tan(sl.phi_r)))**3)
else:
raise DesignError("not setup for bi-directional loading")
i_c = (i_q * fd.nq_factor - 1) / (fd.nq_factor - 1)
# ground slope factors:
g_c = 1 - slope * (1.0 - fd.depth / (2 * width_eff)) / 150
g_q = (1 - np.tan(slope * (1 - fd.depth / (2 * width_eff))))**2
g_g = g_q
# stress at footing base:
q_d = sl.unit_dry_weight * fd.depth
if verbose:
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("H: ", horizontal_load)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("d_c: ", d_c)
log("d_q: ", d_q)
log("d_g: ", d_g)
log("i_c: ", i_c)
log("i_q: ", i_q)
log("i_g: ", i_g)
log("g_c: ", g_c)
log("g_q: ", g_q)
log("g_g: ", g_g)
# Capacity
fd.q_ult = (sl.cohesion * fd.nc_factor * s_c * d_c * i_c * g_c +
q_d * fd.nq_factor * s_q * d_q * i_q * g_q + 0.5 * width_eff *
sl.unit_dry_weight * fd.ng_factor * s_g * d_g * i_g * g_g)
if verbose:
log("q_ult: ", fd.q_ult)
return fd.q_ult
def capacity_meyerhof_1963(sl,
fd,
gwl=1e6,
h_l=0,
h_b=0,
vertical_load=1,
axis_inf=None,
verbose=0,
**kwargs):
"""
Calculates the foundation capacity according Meyerhoff (1963)
http://www.engs-comp.com/meyerhof/index.shtml
:param sl: Soil object
:param fd: Foundation object
:param h_l: Horizontal load parallel to length
:param h_b: Horizontal load parallel to width
:param vertical_load: Vertical load
:param verbose: verbosity
:return: ultimate bearing stress
"""
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
horizontal_load = np.sqrt(h_l**2 + h_b**2)
if axis_inf is None:
if fd.length > fd.width:
fd_length = fd.length
fd_width = fd.width
else:
fd_length = fd.width
fd_width = fd.length
elif axis_inf == 'width':
fd_width = fd.length
fd_length = None
elif axis_inf == 'length':
fd_width = fd.width
fd_length = None
else:
raise ValueError(
f'axis_inf must be either: None, "width", or "length" not {axis_inf}'
)
fd.nq_factor = ((np.tan(np.pi / 4 + sl.phi_r / 2))**2 *
np.exp(np.pi * np.tan(sl.phi_r)))
if sl.phi_r == 0:
fd.nc_factor = 5.14
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
fd.ng_factor = (fd.nq_factor - 1) * np.tan(1.4 * sl.phi_r)
if verbose:
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
kp = (np.tan(np.pi / 4 + sl.phi_r / 2))**2
# shape factors
if fd_length is None:
s_c = 1
s_q = 1
else:
s_c = 1 + 0.2 * kp * fd_width / fd_length
if sl.phi > 10:
s_q = 1.0 + 0.1 * kp * fd_width / fd_length
else:
s_q = 1.0
s_g = s_q
# depth factors
d_c = 1 + 0.2 * np.sqrt(kp) * fd.depth / fd_width
if sl.phi > 10:
d_q = 1 + 0.1 * np.sqrt(kp) * fd.depth / fd_width
else:
d_q = 1.0
d_g = d_q
# inclination factors:
theta_load = np.arctan(horizontal_load / vertical_load)
i_c = (1 - theta_load / (np.pi * 0.5))**2
i_q = i_c
if sl.phi > 0:
i_g = (1 - theta_load / sl.phi_r)**2
else:
i_g = 0
# stress at footing base:
if gwl == 0:
q_d = sl.unit_bouy_weight * fd.depth
unit_weight = sl.unit_bouy_weight
elif gwl > 0 and gwl < fd.depth:
q_d = (sl.unit_dry_weight * gwl) + (sl.unit_bouy_weight *
(fd.depth - gwl))
unit_weight = sl.unit_bouy_weight
elif gwl >= fd.depth and gwl <= fd.depth + fd_width:
sl.average_unit_bouy_weight = sl.unit_bouy_weight + (
((gwl - fd.depth) / fd_width) *
(sl.unit_dry_weight - sl.unit_bouy_weight))
q_d = sl.unit_dry_weight * fd.depth
unit_weight = sl.average_unit_bouy_weight
elif gwl > fd.depth + fd_width:
q_d = sl.unit_dry_weight * fd.depth
unit_weight = sl.unit_dry_weight
if verbose:
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("d_c: ", d_c)
log("d_q: ", d_q)
log("d_g: ", d_g)
log("i_c: ", i_c)
log("i_q: ", i_q)
log("i_g: ", i_g)
log("q_d: ", q_d)
# Capacity
fd.q_ult = (sl.cohesion * fd.nc_factor * s_c * d_c * i_c +
q_d * fd.nq_factor * s_q * d_q * i_q +
0.5 * fd_width * unit_weight * fd.ng_factor * s_g * d_g * i_g)
return fd.q_ult
def capacity_hansen_1970(sl,
fd,
h_l=0,
h_b=0,
vertical_load=1,
slope=0,
base_tilt=0,
verbose=0,
**kwargs):
"""
Calculates the foundation capacity according Hansen (1970)
Ref: http://bestengineeringprojects.com/civil-projects/
hansens-bearing-capacity-theory/
:param sl: Soil object
:param fd: Foundation object
:param h_l: Horizontal load parallel to length
:param h_b: Horizontal load parallel to width
:param vertical_load: Vertical load
:param slope: ground slope
:param base_tilt: The slope of the underside of the foundation
:param verbose: verbosity
:return: ultimate bearing stress
"""
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
if fd.length > fd.width: # TODO: deal with plane strain
fd_length = fd.length
fd_width = fd.width
else:
fd_length = fd.width
fd_width = fd.length
area_foundation = fd_length * fd_width
horizontal_load = np.sqrt(h_l**2 + h_b**2)
c_a = 0.6 - 1.0 * sl.cohesion
fd.nq_factor = ((np.tan(np.pi / 4 + sl.phi_r / 2))**2 *
np.exp(np.pi * np.tan(sl.phi_r)))
if sl.phi_r == 0:
fd.nc_factor = 5.14
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
fd.ng_factor = 1.5 * (fd.nq_factor - 1) * np.tan(sl.phi_r)
# shape factors
if sl.phi_r == 0:
s_c = 0.2 * fd_width / fd_length
else:
s_c = 1.0 + fd.nq_factor / fd.nc_factor * fd_width / fd_length
s_q = 1.0 + fd_width / fd_length * np.sin(sl.phi_r)
s_g = 1.0 - 0.4 * fd_width / fd_length
# depth factors:
if fd.depth / fd_width > 1:
k = np.arctan(fd.depth / fd_width)
else:
k = fd.depth / fd_width
d_c = 1 + 0.4 * k
if sl.phi == 0:
d_c = 0.4 * k
d_q = 1 + 2 * np.tan(sl.phi_r) * (1 - np.sin(sl.phi_r))**2 * k
d_g = 1.0
# incline load factors:
if sl.phi_r == 0:
i_q = 1.0
i_c = 0.5 - 0.5 * np.sqrt(1 - horizontal_load / area_foundation * c_a)
i_g = 1.0
else:
i_q = ((1.0 - 0.5 * horizontal_load /
(vertical_load + area_foundation * c_a / np.tan(sl.phi_r)))**5)
i_c = i_q - (1 - i_q) / (fd.nq_factor - 1)
i_g = ((1 - (0.7 * horizontal_load) /
(vertical_load + area_foundation * c_a / np.tan(sl.phi_r)))**5)
# slope factors:
if sl.phi_r == 0:
g_c = (slope / np.pi * 180) / 147
else:
g_c = 1.0 - (slope / np.pi * 180) / 147
g_q = 1 - 0.5 * np.tan(slope)**5
g_g = g_q
# base tilt factors:
if sl.phi_r == 0:
b_c = (base_tilt / np.pi * 180) / 147
else:
b_c = 1.0 - (base_tilt / np.pi * 180) / 147
b_q = (np.exp(-0.0349 * (base_tilt / np.pi * 180) * np.tan(sl.phi_r)))
b_g = (np.exp(-0.0471 * (base_tilt / np.pi * 180) * np.tan(sl.phi_r)))
if verbose:
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("d_c: ", d_c)
log("d_q: ", d_q)
log("d_g: ", d_g)
log("i_c: ", i_c)
log("i_q: ", i_q)
log("i_g: ", i_g)
log("g_c: ", g_c)
log("g_q: ", g_q)
log("g_g: ", g_g)
log("b_c: ", b_c)
log("b_q: ", b_q)
log("b_g: ", b_g)
# stress at footing base:
q_d = sl.unit_dry_weight * fd.depth
# Capacity
if sl.phi_r == 0:
fd.q_ult = (sl.cohesion * fd.nc_factor *
(1 + s_c + d_c - i_c - g_c - b_c) + q_d)
else:
fd.q_ult = (sl.cohesion * fd.nc_factor * s_c * d_c * i_c * g_c * b_c +
q_d * fd.nq_factor * s_q * d_q * i_q * g_q * b_q +
0.5 * fd_width * sl.unit_dry_weight * fd.ng_factor * s_g *
d_g * i_g * g_g * b_g)
def capacity_terzaghi_1943(sl, fd, round_footing=False, verbose=0, **kwargs):
"""
Calculates the foundation capacity according Terzaghi (1943)
Ref: http://geo.cv.nctu.edu.tw/foundation/
download/BearingCapacityOfFoundations.pdf
:param sl: Soil object
:param fd: Foundation object
:param round_footing: if True, then foundation is round
:param verbose: verbosity
:return: ultimate bearing stress
Note: the shape factor of 1.3 is used for aspect ratio > 6
"""
if not kwargs.get("disable_requires", False):
models.check_required(sl, ["phi_r", "cohesion", "unit_dry_weight"])
models.check_required(fd, ["length", "width", "depth"])
if fd.length > fd.width: # TODO: deal with plane strain
fd_length = fd.length
fd_width = fd.width
else:
fd_length = fd.width
fd_width = fd.length
a02 = ((np.exp(np.pi * (0.75 - sl.phi / 360) * np.tan(sl.phi_r)))**2)
a0_check = (np.exp((270 - sl.phi) / 180 * np.pi * np.tan(sl.phi_r)))
if (a02 - a0_check) / a02 > 0.001:
raise DesignError
fd.nq_factor = (a02 / (2 * (np.cos((45 + sl.phi / 2) * np.pi / 180))**2))
fd.ng_factor = (2 * (fd.nq_factor + 1) * np.tan(sl.phi_r) /
(1 + 0.4 * np.sin(4 * sl.phi_r)))
if sl.phi_r == 0:
fd.nc_factor = 5.7
else:
fd.nc_factor = (fd.nq_factor - 1) / np.tan(sl.phi_r)
# shape factors:
if round_footing:
s_c = 1.3
s_g = 0.6
elif fd_length / fd_width < 5:
s_c = 1.3
s_g = 0.8
else:
s_c = 1.0
s_g = 1.0
s_q = 1.0
# stress at footing base:
q_d = sl.unit_dry_weight * fd.depth
# Capacity
fd.q_ult = (sl.cohesion * fd.nc_factor * s_c + q_d * fd.nq_factor * s_q +
0.5 * fd_width * sl.unit_dry_weight * fd.ng_factor * s_g)
if verbose:
log("Nc: ", fd.nc_factor)
log("Nq: ", fd.nq_factor)
log("Ng: ", fd.ng_factor)
log("s_c: ", s_c)
log("s_q: ", s_q)
log("s_g: ", s_g)
log("qult: ", fd.q_ult)
return fd.q_ult
