def BiCalculateCracklength(a, b, dk, t, w, pmax, r, accu=0.001):
# 对于CT试件，依据E647标准，已知SIF时利用二分法计算裂纹长度
# 裂纹自高载后的扩展长度+循环塑性区尺寸是已知值，但循环区尺寸是扩展长度的函数且不易解，故采用二分法求解
# 求解的方程可表示为求解长度a使方程：
# dk(a) - dk(输入值) = 0
# input arguments:
# a, b: 二分法的左右两端(裂纹长度可能存在的范围)
# dk：已知的SIF值
# t, w: 试件的thickness、width，可由类读取
# pmax, r：试验中循环载荷峰值和应力比，可由类读取
# accu：二分法精度，默认为0.001
# return arguments:
# result: 数组，第0位为解的值x，第1位为此时函数的值
i = 0 # 计数器
# 计算二分法左端的函数值
ya = mts_analysis.DeltaKCalculating(
b=t, w=w, a=a, pmax=pmax, pmin=pmax * r) - dk
# 计算二分法右端的函数值
yb = mts_analysis.DeltaKCalculating(
b=t, w=w, a=b, pmax=pmax, pmin=pmax * r) - dk
result = []
# 若两端为0的情况：
if ya == 0:
result.append(a)
result.append(ya)
elif yb == 0:
result.append(b)
result.append(yb)
else:
# 若两端不为零->进入二分法
while i >= 0:
c = (a + b) / 2
# 计算中点的函数值
yc = mts_analysis.DeltaKCalculating(
b=t, w=w, a=c, pmax=pmax, pmin=pmax * r) - dk
# 判断解的范围精度是否满足accu的设定
if np.abs(b - a) < accu:
result.append(c)
result.append(yc)
print('Find Zero_point due to tolrance at c=' + str(c))
break
if yc == 0:
result.append(c)
result.append(yc)
print('Find Zero_point due to Midpoint_value=0 at c=' + str(c))
break
elif yc * ya < 0:
b = c
i = i + 1
continue
elif yc * yb < 0:
i = i + 1
a = c
continue
else:
print(
'ERROR: Unexpected situation come across.Check the process.'
)
break
return result
def WheelerCalculatingBaseParis(a_wheeler,
b,
w,
ys,
pmax,
r,
aol,
rol,
plasticzonefactor,
m1,
c,
m,
eta=0):
# usage: 以裂纹长度a指定计算范围，计算基于Paris公式的Wheeler模型
# NOTE：数据的起始点必须是高载后！
# input parameter:
# alist：输入需要计算的裂纹长度数组
# b, w, ys：试件基本参数thickness，width和yield strength
# pmax，r：加载基本参数循环载荷峰值pmax和应力比r
# aol，rol：高载时裂纹长度aol及其对应的塑性区尺寸rol
# plasticzonefactor：塑性区尺寸计算时的塑性区尺寸系数，若plasticzonefactor='Xiaoping'，则采用Xiaoping模型计算
# m1：由WheelerFitting函数拟合得到的Wheeler迟滞参数的指数系数，表征迟滞恢复的快慢
# c，m：基础Paris公式参数
# eta：裂纹长度修正，相当于延长裂纹的长度（即等效裂纹概念），作用于Wheeler系数的分母，默认不修正
# return parameter:
# dadn_wheeler, dk_wheeler, a_wheeler，cp_wheeler模型计算结果对应的dadn，SIF变幅dk和裂纹长度a，及迟滞系数cp
dk_wheeler = mts_analysis.DeltaKCalculating(b=b,
w=w,
a=a_wheeler,
pmax=pmax,
pmin=pmax * r)
kmax_wheeler = np.array([dk / (1 - r) for dk in dk_wheeler])
rm_wheeler = PlasticZoneWithFactor(kmax=kmax_wheeler,
ys=ys,
factor=plasticzonefactor,
t=b)
left_wheeler = a_wheeler + rm_wheeler + eta
right_wheeler = aol + rol
# 迟滞计算参数和数据准备，由裂纹长度a出发
cp = []
for seq, _ in enumerate(a_wheeler):
if left_wheeler[seq] < right_wheeler:
cpi = (rm_wheeler[seq] / (aol + rol - a_wheeler[seq] - eta))**m1
else:
cpi = 1
cp.append(cpi)
cp = np.array(cp)
# 迟滞系数cp计算
dadn_wheeler = []
for seq, _ in enumerate(dk_wheeler):
dadn = cp[seq] * (c * dk_wheeler[seq]**m)
try:
dadn_wheeler.append(dadn[0])
except IndexError:
dadn_wheeler.append(dadn)
dadn_wheeler = np.array(dadn_wheeler)
# Wheeler模型 拟合函数计算
return dadn_wheeler, dk_wheeler, a_wheeler, cp
def FCGRandDKbyOriginalData(b, w, a, n, pmax, pmin, ys, r, kclosure=[], fop=[], threshold=0):
# usage: 依据标准E647-11由载荷峰谷值、裂纹长度、循环次数计算FCGR并进行有效性检查
# input parameter:
# b：试件厚度thickness，mm
# w：试件宽度Width，mm
# a：裂纹长度数组，mm
# n：循环次数数组
# pmax：载荷峰值数组，N
# pmin：载荷谷值数组，N
# ys：材料屈服强度，GPa
# r：应力比
# kclosure：裂纹闭合时应力强度因子，默认为空数组（不输出）
# fop：裂纹闭合载荷，默认不输出
# threshold：DeltaK阈值筛选，将删去小于阈值的数据，默认为0（不筛选）
# return parameter：
# dadn_ligament_valid：裂纹扩展速率
# n_ligament_valid：循环次数
# dk_ligament_valid：SIF变幅
# a_ligament_valid：裂纹长度
dk = mts_analysis.DeltaKCalculating(b=b, w=w, a=a, pmax=pmax, pmin=pmin)
# 由裂纹长度依标准计算SIF变幅
dadn_poly, a_poly, n_poly, dk_poly = mts_analysis.FCGRateByPolynomial(a=a, n=n, dk=dk, num=4)
# 由裂纹长度和循环次数依多项式法计算FCGR
n_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=n_poly, r=r)
a_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=a_poly, r=r)
dadn_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=dadn_poly, r=r)
dk_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=dk_poly, r=r)
if len(kclosure) != 0:
kc_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=kclosure, r=r)
if len(fop) != 0:
fop_ligament_valid = mts_analysis.DataSelectByLigament(w=w, a=a_poly, dk=dk_poly, ys=ys, data=fop, r=r)
#print("Data Deleted by Ligament Check:", str(len(a_poly) - len(a_ligament_valid)))
# 依据标准进行韧带长度有效性筛选
n_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=n_ligament_valid)
a_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=a_ligament_valid)
dadn_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=dadn_ligament_valid)
dk_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=dk_ligament_valid)
if len(kclosure) != 0:
kc_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=kc_ligament_valid)
if len(fop) != 0:
fop_valid = mts_analysis.DataSelectByThreshold(threshold=threshold, parameter=dk_ligament_valid, data=fop_ligament_valid)
# 依据DeltaK阈值进行筛选（可用于筛去DeltaK小于Paris区域的值）
if len(kclosure) == 0:
if len(fop) == 0: # Kop,Fop均未输入的情况
return np.array(dadn_valid), np.array(n_valid), np.array(dk_valid), np.array(a_valid)
else: # Kop未输入，Fop输入的情况
return np.array(dadn_valid), np.array(n_valid), np.array(dk_valid), np.array(a_valid), np.array(fop_valid)
else:
if len(fop) == 0: # Kop输入，Fop未输入的情况
return np.array(dadn_valid), np.array(n_valid), np.array(dk_valid), np.array(a_valid), np.array(kc_valid)
else: # Kop,Fop均输入的情况
return np.array(dadn_valid), np.array(n_valid), np.array(dk_valid), np.array(a_valid), np.array(kc_valid), np.array(fop_valid)
def DeltaKPredict(w, thickness, start, final, load, r, step=1):
"""
对于CT试件，根据试件几何尺寸和载荷参数，输入的需要计算的起止裂纹长度，按照一定的步长，输出计算得到的dk
:param w: CT试件几何参数width
:param thickness: CT试件几何参数
:param start: 输入的需要计算的裂纹长度起点，单位mm，该长度含notch的长度
:param final: 输入的需要计算的裂纹长度终点，单位mm，该长度含notch的长度
:param load: 载荷峰值
:param r: 应力比
:param step: 计算的步长，默认为1mm
:return: dk: 裂纹长度范围内对应的应力强度因子变幅
"""
a = np.arange(start, final+step, step)
pmin = load * r
dk = mts_analysis.DeltaKCalculating(b=thickness, w=w, a=a, pmax=load, pmin=pmin)
return dk
def CpCalculatingBaseParis(a, b, w, ys, pmax, r, aol, rol, plasticzonefactor,
m1):
# usage: 计算裂纹长度a对应的Wheeler迟滞系数cp
# NOTE：数据的起始点必须是高载后！
# input parameter:
# a: 裂纹长度
# b, w, ys：试件基本参数thickness，width和yield strength
# pmax，r：加载基本参数循环载荷峰值pmax和应力比r
# aol，rol：高载时裂纹长度aol及其对应的塑性区尺寸rol
# plasticzonefactor：塑性区尺寸计算时的塑性区尺寸系数
# m1：由WheelerFitting函数拟合得到的Wheeler迟滞参数的指数系数，表征迟滞恢复的快慢
# return parameter:
# dadn_wheeler, dk_wheeler, a_wheeler，cp_wheeler模型计算结果对应的dadn，SIF变幅dk和裂纹长度a，及迟滞系数cp
a_wheeler = a
dk_wheeler = mts_analysis.DeltaKCalculating(b=b,
w=w,
a=a_wheeler,
pmax=pmax,
pmin=pmax * r)
kmax_wheeler = np.array([dk / (1 - r) for dk in dk_wheeler])
rm_wheeler = PlasticZoneWithFactor(kmax=kmax_wheeler,
ys=ys,
factor=plasticzonefactor)
left_wheeler = a_wheeler + rm_wheeler
right_wheeler = aol + rol
# 迟滞计算参数和数据准备，由裂纹长度a出发
cp = []
for seq, _ in enumerate(a_wheeler):
if left_wheeler[seq] < right_wheeler:
cpi = (rm_wheeler[seq] / (aol + rol - a_wheeler[seq]))**m1
else:
cpi = 1
cp.append(cpi)
cp = np.array(cp)
# 迟滞系数cp计算
return cp
# 读取数据并完成基本的FCG处理
specimen, width, notch_length, thickness, elastic_modulus, yield_strength, precrack_length = \
read_data.ReadTestInf(sequence=sequence[0])
cycles, cracklength, kmax, kmin, pmax, pmin, kclosure, closureload = \
read_data.ReadOriginResult(sequence=sequence[0], closure=True, cod=False)
dadn_Manual, n_Manual, dk_Manual, a_Manual, kc_Manual = \
experiment_calculation.FCGRandDKbyOriginalData(b=thickness, w=width, n=cycles, pmax=pmax, pmin=pmin,
a=cracklength,
ys=yield_strength, r=r, kclosure=kclosure,
threshold=threshold)
# Kmax at Overload计算
k_max_ol = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=aol_hold,
pmax=pol,
pmin=0)
# 塑性区系数及尺寸计算
factor = overload_analysis.FactorXiaoping(kmax=k_max_ol,
t=thickness,
ys=yield_strength)
r_ol = overload_analysis.PlasticZoneWithFactor(kmax=[k_max_ol],
ys=yield_strength,
factor=factor)
# 计算dK_eff
dkeff = []
dk_willenborg = []
for seq, value in enumerate(a_Manual):
specimen = OverloadSpecimen(name=sequence)
specimen.status_input_from_database()
specimen.basic_result_calculate()
#specimen.a_ol_applied -= 1.5
specimen.a_dadn_min = 13.8055
specimen.a_kc_max = specimen.a_alpha_end
specimen.a_alpha_end += 2.5
specimen.specimen_print()
# paris参数
c_ca, m_ca = paris_and_walker.ParisParameter(r=specimen.stress_ratio)
# Overload PLZ相关参数，塑性区系数为Irwin
kol = mts_analysis.DeltaKCalculating(b=specimen.thickness,
w=specimen.width,
a=specimen.a_ol_applied,
pmax=specimen.overload,
pmin=0)
plz_ol = overload_analysis.PlasticZoneWithFactor(kmax=np.array([kol]),
ys=specimen.yield_stress,
factor=plz_factor,
t=specimen.thickness)
# 数据筛选（筛选出dadn_min后的数据，标记为1）
dadn_1, dk_1, kc_1, n_1, a_1 = specimen.data_select_by_cracklength(
lowerlimit=specimen.a_dadn_min, upperlimit=specimen.a_kc_max)
# 移动平均
if moving_average:
print('Notice: moving average working!')
dadn_ave, dk_ave = closureanalysis.DoubleDataSelectMovingAverage(
data=specimen.dadn, reference=specimen.dk, ratio=0.2, numofaverage=7)
def AlphaModifiedCalculate(alpha_fade_rate, alpha_amplitude, pmax,
stress_ratio, thickness, width, a_amplitude, a_list,
c_ca, m_ca, a_start, a_end, dadn_start):
# Modified Alpha模型计算函数
# 该函数通过由已知起点(通常为a_kc_max_cal）和终点（通常为a_retard_end）的裂纹长度值和裂纹扩展速率
# 采用直线拟合得到Kop的值，代入已知的Alpha模型参数值计算
# 得到该段裂纹闭合效应主导的裂纹扩展速率模型
# input parameters:
# alpha_fade_rate: 模型衰减率参数
# alpha_amplitude: 模型峰值参数，常取2/pi
# pmax, stress_ratio: 载荷峰值，应力比
# thickness, width: CT试件几何参数厚度和宽度
# a_amplitude: 模型起点a0
# a_list：要计算的裂纹长度值的数组
# c_ca, m_ca：该应力比下的Paris公式参数
# a_start, a_end: 要输出的裂纹长度起止点
# dadn_start: 输入a0对应的dadn速率，通过反转Paris公式计算其dkeff
# return parameters:
# dk: 输入的a_list计算对应的dk
# dkeff_alpha_e: 输入的a_list对应的alpha模型下的dkeff
# dadn_alpha_e: 输入的a_list由alpha模型计算得到的dadn
# alpha_e: a_list各值对应的alpha值
# betas：a_list各值对应的无量纲裂纹长度参数值
kmax = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=a_list,
pmax=pmax,
pmin=0)
kmin = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=a_list,
pmax=pmax * stress_ratio,
pmin=0)
dk = kmax - kmin
# 计算无量纲量
betas = (a_list - a_amplitude) / a_amplitude
# 计算系数alpha
alpha_e = []
for beta in betas:
if beta < 0:
alpha_e.append(2 / np.pi)
else:
alpha_e.append(alpha_amplitude * np.exp(-alpha_fade_rate * beta))
alpha_e = np.array(alpha_e)
# 计算Kop
dk_start = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=a_start,
pmax=pmax,
pmin=pmax * stress_ratio)
dk_end = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=a_end,
pmax=pmax,
pmin=pmax * stress_ratio)
dkeff_start = mts_analysis.ParisInverseCalculation(c=c_ca,
m=m_ca,
dadn=dadn_start)
print("The Effective SIF when beta=0:" + str(dkeff_start))
pi = np.pi
kop_start = pi / 2 * (dk_start / (1 - stress_ratio) - dkeff_start -
(1 - 2 / pi) * dk_start * stress_ratio /
(1 - stress_ratio))
print("The Open SIF when beta=0 based on Alpha Method:" + str(kop_start))
kop_end = dk_end * (stress_ratio / (1 - stress_ratio))
dk_fit = [dk_start[0], dk_end]
kop_fit = [kop_start[0], kop_end]
k_kopfit_cal, b_kopfit_cal = mixed_model.LogLinearFit(y=kop_fit, x=dk_fit)
kop_cal = mixed_model.LogLinearFittedCalculate(k=k_kopfit_cal,
b=b_kopfit_cal,
x=dk)
# 计算dKeff
dkeff_alpha_e = kmax - alpha_e * kop_cal - (1 - alpha_e) * kmin
# 计算dadn
dadn_alpha_e = mts_analysis.ParisCalculating(c=c_ca,
m=m_ca,
dk=dkeff_alpha_e)
return dk, dkeff_alpha_e, dadn_alpha_e, alpha_e, betas
ad = a_fcgr_min - a_fcgr_max # retardation delay长度
# 实验数据读取和初步处理(本函数不能用BasicDataDispose封装API，因函数要调用细节数据）
specimen, width, notch_length, thickness, elastic_modulus, yield_strength, precrack_length = \
read_data.ReadTestInf(sequence=sequence[0])
cycles, cracklength, kmax, kmin, pmax, pmin = read_data.ReadOriginResult(
sequence[0], closure=False, cod=False)
dadn_Manual, n_Manual, dk_Manual, a_Manual = \
experiment_calculation.FCGRandDKbyOriginalData(b=thickness, w=width, n=cycles, pmax=pmax, pmin=pmin,
a=cracklength,
ys=yield_strength, r=stress_ratio, threshold=threshold)
# 高载参数计算
kol = mts_analysis.DeltaKCalculating(b=thickness,
w=width,
a=a_ol,
pmax=pol,
pmin=0)
rol = overload_analysis.PlasticZoneWithFactor(kmax=np.array([kol]),
ys=yield_strength,
factor=1 / math.pi)
# 以高载时裂纹长度aol筛选出高载后的数据
dadn_ola, dk_ola, n_ola, a_ola = \
mts_analysis.FCGDataSelectByThreshold(dadn=dadn_Manual, dk=dk_Manual, n=n_Manual, a=a_Manual,
threshold=a_fcgr_min, target='a', keepbigger=1)
# 高载段参数计算
kmax_ola = np.array([dk / (1 - stress_ratio) for dk in dk_ola])
rm_ola = overload_analysis.PlasticZoneWithFactor(kmax=kmax_ola,
ys=yield_strength,
def SalvatiWheelerCalculatingBaseParis(astart, afinal, b, w, ys, pmax, r, aol,
rol, plasticzonefactor, m1, c, m, apre,
rdol, delayfactor, m_mod):
# usage: 以裂纹长度a指定计算范围，计算基于Paris公式的Wheeler模型
# NOTE：数据的起始点必须是高载后！
# input parameter:
# astart, afinal: 计算的裂纹长度范围的起点和终点，起点推荐为高载时裂纹长度，终点建议为有效的最大值
# b, w, ys：试件基本参数thickness，width和yield strength
# pmax，r：加载基本参数循环载荷峰值pmax和应力比r
# aol，rol：高载时裂纹长度aol及其对应的塑性区尺寸rol
# plasticzonefactor：塑性区尺寸计算时的塑性区尺寸系数
# m1：由WheelerFitting函数拟合得到的Wheeler迟滞参数的指数系数，表征迟滞恢复的快慢
# c，m：基础Paris公式参数
# apre：高载起点（dadN最高值）
# rdol：采用延迟系数计算的延迟区rd,OL
# delayfactor：Yuen等提出的延迟系数
# m_mod：由Salvati延迟系数拟合得到的延迟指数
# return parameter:
# dadn_wheeler, dk_wheeler, a_wheeler，cp, cd:模型计算结果对应的dadn，SIF变幅dk和裂纹长度a，及迟滞和延迟系数cp,cd
a_wheeler = np.arange(astart, afinal, 0.02)
dk_wheeler = mts_analysis.DeltaKCalculating(b=b,
w=w,
a=a_wheeler,
pmax=pmax,
pmin=pmax * r)
kmax_wheeler = np.array([dk / (1 - r) for dk in dk_wheeler])
rm_wheeler = PlasticZoneWithFactor(kmax=kmax_wheeler,
ys=ys,
factor=plasticzonefactor)
left_wheeler = a_wheeler + rm_wheeler
right_wheeler = aol + rol
rd_wheeler = PlasticZoneWithFactor(kmax=kmax_wheeler,
ys=ys,
factor=delayfactor)
left_delay = a_wheeler + rd_wheeler
right_delay = apre + rdol
# 迟滞计算参数和数据准备，由裂纹长度a出发
cp = []
for seq, _ in enumerate(a_wheeler):
if left_wheeler[seq] < right_wheeler:
cpi = (rm_wheeler[seq] / (aol + rol - a_wheeler[seq]))**m1
else:
cpi = 1
cp.append(cpi)
cp = np.array(cp)
# 迟滞系数cp计算
cd = []
for seq, _ in enumerate(a_wheeler):
if left_delay[seq] < right_delay:
cdi = ((apre + rdol - a_wheeler[seq]) / rd_wheeler[seq])**m_mod
else:
cdi = 1
cd.append(cdi)
cd = np.array(cd)
dadn_salvati = []
for seq, _ in enumerate(dk_wheeler):
dadn = cd[seq] * cp[seq] * (c * dk_wheeler[seq]**m)
dadn_salvati.append(dadn)
dadn_salvati = np.array(dadn_salvati)
# Wheeler模型 拟合函数计算
return dadn_salvati, dk_wheeler, a_wheeler, cd, cp
# 计算塑性区大小
# 2018/10/15 Version 1.0
# Lu Yunchao
from FCGAnalysisLib import overload_analysis
from FCGAnalysisLib import mts_analysis
from FCGAnalysisLib import paris_and_walker
import numpy as np
sequence = ["yang-baoban_Lu-420-05"]
specimen_data = paris_and_walker.test_database2(specimen=sequence[0])
ys = 0.365 # GPa
a_ol = np.array([specimen_data["a_ol_applied"]]) # mm
p_ol = specimen_data["overload"] # N
p_max = specimen_data["maxload"]
a_kc_max = specimen_data["a_kc_max"]
print('specimen:'+sequence[0]+',a_ol_applied:'+str(a_ol)+'mm,overload:'+str(p_ol)+'N, maxload:'+str(p_max))
b = 2.5 # mm
w = 40 # mm
k_ol = np.array([mts_analysis.DeltaKCalculating(b=b, w=w, a=a_ol, pmax=p_ol, pmin=0)])
k_kc_max = np.array([mts_analysis.DeltaKCalculating(b=b, w=w, a=a_kc_max, pmax=p_max, pmin=0)])
factor = overload_analysis.FactorXiaoping(kmax=k_ol, t=b, ys=ys)
print(factor)
print(str(1/np.pi))
r_ol = overload_analysis.PlasticZoneWithFactor(kmax=k_ol, ys=ys, factor='Xiaoping', t=b)
r_kc_max = overload_analysis.PlasticZoneWithFactor(kmax=k_kc_max, ys=ys, factor='Xiaoping', t=b)
print("r_ol:", r_ol)
print("r_kc_max:", r_kc_max)
def BiSelection(a,
b,
const,
t,
w,
ys,
a_ol_applied,
pmax,
plz_factor,
accu=0.001):
# 利用二分法计算主导位置变化
# 裂纹自高载后的扩展长度+循环塑性区尺寸是已知值，但循环区尺寸是扩展长度的函数且不易解，故采用二分法求解
# 求解的方程可表示为求解长度da使方程：
# da + plz,reversing(da) - plz,ol * precentage(44% for OLR = 2, 80% for OLR = 1.5）= 0
# input arguments:
# a, b: 二分法的左右两端
# const：高载塑性区尺寸乘比例（44% or 80%）
# t, w, ys: 试件的thickness、width和yielding stress，可由类读取
# a_ol_applied：试验高载时对应裂纹长度，可由类读取
# pmax：试验中循环载荷峰值，可由类读取
# plz_factor：塑性区尺寸，可输入常数或Xiaoping，若输入Xiaoping则会自动根据试件尺寸计算
# accu：二分法精度，默认为0.001
# return arguments:
# result: 数组，第0位为解的值x，第1位为此时函数的值
i = 0 # 计数器
# 计算二分法左端的函数值
ka = mts_analysis.DeltaKCalculating(b=t,
w=w,
a=a_ol_applied + a,
pmax=pmax,
pmin=0)
plza = overload_analysis.PlasticZoneWithFactor(kmax=[ka],
factor=plz_factor,
ys=ys,
t=t)
ya = a + plza - const
# 计算二分法右端的函数值
kb = mts_analysis.DeltaKCalculating(b=t,
w=w,
a=a_ol_applied + b,
pmax=pmax,
pmin=0)
plzb = overload_analysis.PlasticZoneWithFactor(kmax=[kb],
factor=plz_factor,
ys=ys,
t=t)
yb = b + plzb - const
result = []
# 若两端为0的情况：
if ya == 0:
result.append(a)
result.append(ya)
elif yb == 0:
result.append(b)
result.append(yb)
else:
# 若两端不为零->进入二分法
while i >= 0:
c = (a + b) / 2
# 计算中点的函数值
kc = mts_analysis.DeltaKCalculating(b=t,
w=w,
a=a_ol_applied + c,
pmax=pmax,
pmin=0)
plzc = overload_analysis.PlasticZoneWithFactor(kmax=[kc],
factor=plz_factor,
ys=ys,
t=t)
yc = c + plzc - const
# 判断解的范围精度是否满足accu的设定
if np.abs(b - a) < accu:
result.append(c)
result.append(yc)
print('Find Zero_point due to tolrance at c=' + str(c))
break
if yc == 0:
result.append(c)
result.append(yc)
print('Find Zero_point due to Midpoint_value=0 at c=' + str(c))
break
elif yc * ya < 0:
b = c
i = i + 1
continue
elif yc * yb < 0:
i = i + 1
a = c
continue
else:
print(
'ERROR: Unexpected situation come across.Check the process.'
)
break
return result
specimen = mixed_model.OverloadSpecimen(name=sequence)
specimen.status_input_from_database()
specimen.basic_result_calculate()
# specimen.a_ol_applied -= 1.5
# specimen.a_dadn_min = 12.3506
# specimen.a_kc_max = specimen.a_alpha_end
specimen.a_alpha_end += 2
specimen.specimen_print()
# paris参数读取
c_ca, m_ca = paris_and_walker.ParisParameter(r=specimen.stress_ratio)
'''
高载塑性区尺寸计算
'''
# Overload PLZ相关参数，塑性区系数由参数指定
kol = mts_analysis.DeltaKCalculating(b=specimen.thickness, w=specimen.width,
a=specimen.a_ol_applied, pmax=specimen.overload, pmin=0)
plz_ol = overload_analysis.PlasticZoneWithFactor(kmax=np.array([kol]), ys=specimen.yield_stress,
factor=plz_factor, t=specimen.thickness)
'''
Try: 由塑性区比例特点计算Kop，代替实验实测值，进行Alpha模型计算
'''
# step1：数据筛选（拟合用4，计算用3，筛选出的数据上下限见参数lowerlimit和upperlimit）
dadn_3, dk_3, kc_3, n_3, a_3 = specimen.data_select_by_cracklength(lowerlimit=specimen.a_dadn_min-0.2,
upperlimit=specimen.a_retard_end+1.5)
dadn_4, dk_4, kc_4, n_4, a_4 = specimen.data_select_by_cracklength(lowerlimit=specimen.a_kc_max,
upperlimit=specimen.a_retard_end)
# step2：由比例采用二分法计算出主导位置交换的对应的裂纹长度a_kc_max的值
if specimen.overload != -1 and specimen.maxload != -1:
specimen.overload = 2000
specimen.a_ol_applied = 11.051
specimen.a_dadn_min = specimen.a_ol_applied + 0.537 - 0.2
specimen.a_retard_end = specimen.a_dadn_min + 2.270
specimen.specimen_print()
# paris参数拟合
c_ca = 4.7553e-10
m_ca = 3.6441
'''
高载塑性区尺寸计算
'''
# Overload PLZ相关参数，塑性区系数由参数指定
kol = mts_analysis.DeltaKCalculating(b=specimen.thickness,
w=specimen.width,
a=specimen.a_ol_applied,
pmax=specimen.overload,
pmin=0)
plz_ol = overload_analysis.PlasticZoneWithFactor(kmax=np.array([kol]),
ys=specimen.yield_stress,
factor=plz_factor,
t=specimen.thickness)
'''
Try: 由塑性区比例特点计算Kop，代替实验实测值，进行Alpha模型计算
'''
# step1：数据筛选（拟合用4，计算用3，筛选出的数据上下限见参数lowerlimit和upperlimit）
dk_dadn_min = mts_analysis.DeltaKCalculating(b=specimen.thickness,
w=specimen.width,
a=specimen.a_dadn_min,
pmax=specimen.maxload,
pmin=specimen.maxload *
