def psi_minus_linear_elasticity_model_C(epsilon, lamda, mu):
sqrt_delta = fe.conditional(
fe.gt(fe.tr(epsilon)**2 - 4 * fe.det(epsilon), 0),
fe.sqrt(fe.tr(epsilon)**2 - 4 * fe.det(epsilon)), 0)
eigen_value_1 = (fe.tr(epsilon) + sqrt_delta) / 2
eigen_value_2 = (fe.tr(epsilon) - sqrt_delta) / 2
tr_epsilon_minus = fe.conditional(fe.lt(fe.tr(epsilon), 0.),
fe.tr(epsilon), 0.)
eigen_value_1_minus = fe.conditional(fe.lt(eigen_value_1, 0.),
eigen_value_1, 0.)
eigen_value_2_minus = fe.conditional(fe.lt(eigen_value_2, 0.),
eigen_value_2, 0.)
return lamda / 2 * tr_epsilon_minus**2 + mu * (eigen_value_1_minus**2 +
eigen_value_2_minus**2)
def ratio_function_ufl(ratio, map_type):
if map_type == 'linear':
return fe.conditional(
fe.lt(ratio, -1. / 2.), 3. / 2. * ratio + 1. / 2.,
fe.conditional(fe.gt(ratio, 1. / 2.), 3. / 2. * ratio - 1. / 2.,
1. / 2. * ratio))
elif map_type == 'power':
return ratio**(2.)
elif map_type == 'identity':
return ratio
elif map_type == 'smooth':
return fe.conditional(fe.lt(ratio, -1./2.), -6*ratio**3 - 14*ratio**2 - 9*ratio - 2, \
fe.conditional(fe.gt(ratio, 1./2.), -6*ratio**3 + 14*ratio**2 - 9*ratio + 2, 1./2.* ratio))
else:
raise NotImplementedError("To be implemented")
def distance_function_segments_ufl(P, control_points, impact_radii):
if len(control_points) == 1:
return distance_function_point_ufl(P,
control_points[0]), impact_radii[0]
else:
rho1 = impact_radii[0]
rho2 = impact_radii[1]
df, xi = distance_function_line_segement_ufl(P, control_points[0],
control_points[1])
for i in range(len(control_points) - 1):
tmp_df, tmp_xi = distance_function_line_segement_ufl(
P, control_points[i], control_points[i + 1])
xi = fe.conditional(fe.lt(tmp_df, df), tmp_xi, xi)
rho1 = fe.conditional(fe.lt(tmp_df, df), impact_radii[i], rho1)
rho2 = fe.conditional(fe.lt(tmp_df, df), impact_radii[i + 1], rho2)
df = ufl.Min(tmp_df, df)
return df, (1 - xi) * rho1 + xi * rho2
def distance_function_line_segement_ufl(P, A=[-1, 0], B=[1, 0]):
AB = [None, None]
AB[0] = B[0] - A[0]
AB[1] = B[1] - A[1]
BP = [None, None]
BP[0] = P[0] - B[0]
BP[1] = P[1] - B[1]
AP = [None, None]
AP[0] = P[0] - A[0]
AP[1] = P[1] - A[1]
AB_BP = AB[0] * BP[0] + AB[1] * BP[1]
AB_AP = AB[0] * AP[0] + AB[1] * AP[1]
y = P[1] - B[1]
x = P[0] - B[0]
df1 = fe.sqrt(x**2 + y**2)
xi1 = 1
y = P[1] - A[1]
x = P[0] - A[0]
df2 = fe.sqrt(x**2 + y**2)
xi2 = 0
x1 = AB[0]
y1 = AB[1]
x2 = AP[0]
y2 = AP[1]
mod = fe.sqrt(x1**2 + y1**2)
df3 = np.absolute(x1 * y2 - y1 * x2) / mod
xi3 = fe.conditional(fe.gt(x2**2 + y2**2 - df3**2, 0),
fe.sqrt(x2**2 + y2**2 - df3**2) / mod, 0)
df = fe.conditional(fe.gt(AB_BP, 0), df1,
fe.conditional(fe.lt(AB_AP, 0), df2, df3))
xi = fe.conditional(fe.gt(AB_BP, 0), xi1,
fe.conditional(fe.lt(AB_AP, 0), xi2, xi3))
return df, xi
def inverse_ratio_function_ufl(ratio, map_type):
if map_type == 'linear':
return fe.conditional(
fe.lt(ratio, -1. / 4.), 2. / 3. * ratio - 1. / 3.,
fe.conditional(fe.gt(ratio, 1. / 4.), 2. / 3. * ratio + 1. / 3.,
2. * ratio))
elif map_type == 'power':
return ratio**(0.5)
elif map_type == 'identity':
return ratio
else:
raise NotImplementedError("To be implemented")
def psi_minus_Borden(F, mu, kappa):
J = fe.det(F)
U, Wbar = psi_aux_Borden(F, mu, kappa)
return fe.conditional(fe.lt(J, 1), U, 0)