def test_interface_fixed_line_soil(self):
"""
Tests an interface between a fixed line-element with and a non-fixed surface.
The surface has a prescribed vertical displacement of -0.1 m and a horizontal line load of -1 kN
The interface has a cohesion of 10 kN.
Expected shear stress in the interface is 10 kN
:return:
"""
test_name = 'test_interface_side_cohesive'
file_path = test_helper.get_file_path(os.path.join('.','test_interfaces', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
local_stress_vector = test_helper.get_local_stress_vector(simulation)
local_stress_vector_interface = [element for element in local_stress_vector if len(element) == 4]
x_stress = 10000
precision = 0.01 * x_stress # 1% precision
for local_stress_quad in local_stress_vector_interface:
error_gauss_1 = abs(x_stress - local_stress_quad[0][0])
error_gauss_2 = abs(x_stress - local_stress_quad[1][0])
self.assertLess(error_gauss_1, precision)
self.assertLess(error_gauss_2, precision)
def test_inclined_phreatic_line(self):
"""
test hydrostatic water pressure under an inclided phreatic line ranging over the width of the geometry
:return:
"""
test_name = 'test_inclinded_phreatic_line'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
water_pressure = test_helper.get_water_pressure(simulation)
p_bot_left = water_pressure[0]
p_bot_middle = water_pressure[47]
p_bot_right = water_pressure[185]
p_top_left = water_pressure[186]
p_top_middle = water_pressure[222]
p_top_right = water_pressure[250]
self.assertAlmostEqual(-10000, p_bot_left)
self.assertAlmostEqual(-7500, p_bot_middle)
self.assertAlmostEqual(-5000, p_bot_right)
self.assertAlmostEqual(0, p_top_left)
self.assertAlmostEqual(0, p_top_middle)
self.assertAlmostEqual(0, p_top_right)
def test_van_genuchten_above_phreatic_quad_4n(self):
test_name = 'test_soil_weight_van_genuchten_above_phreatic_quad_4n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
self.assert_total_stress(simulation, -35.21658185153758)
def test_weak_interface_on_beam(self):
"""
Tests an interface on a beam. In this test a calculation is done with a very weak interface.
Displacement in the beam element should be much greater than the displacement in the soil.
:return:
"""
# calculate case with strong interface
test_name = 'test_weak_interface_on_beam'
file_path = test_helper.get_file_path(
os.path.join('.', 'test_interfaces', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
model_part = simulation._list_of_output_processes[0].model_part
# Get beam and soil elements
beam_elements = [element for element in model_part.Elements if element.GetGeometry().PointsNumber() == 2]
soil_elements = [element for element in model_part.Elements if element.GetGeometry().PointsNumber() == 3]
# Get average x-displacement beam- and soil- elements
x_displacement_beam_elements = [test_helper.compute_mean_list([node.GetSolutionStepValue(Kratos.DISPLACEMENT)[0]
for node in beam_element.GetNodes()]) for beam_element in beam_elements]
x_displacement_soil_elements = [test_helper.compute_mean_list([node.GetSolutionStepValue(Kratos.DISPLACEMENT)[0]
for node in soil_element.GetNodes()]) for soil_element in soil_elements]
# Get max x-displacement beam- and soil- elements
max_x_disp_beam = max(x_displacement_beam_elements)
max_x_disp_soil = max(x_displacement_soil_elements)
# Assert if beam displacement is >> than soil displacement
self.assertGreater(max_x_disp_beam, 1e8 * max_x_disp_soil)
def test_saturated_below_phreatic_quad_8n(self):
test_name = 'test_soil_weight_saturated_below_phreatic_quad_8n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
self.assert_total_stress(simulation, -32.886751345948134)
def test_saturated_below_and_above_phreatic_quad_4n(self):
test_name = 'test_soil_weight_saturated_below_and_above_phreatic_quad_4n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
self.assert_total_stress(simulation, -36.44337567297406)
def test_SteadyState_DamConfinedFlow_2D3N(self):
test_name = 'test_SteadyState_DamConfinedFlow_2D3N'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
self.assert_outflow_discharge(simulation, 1.11309991)
def test_SteadyState_DamConfinedFlowWithSheetPile_2D6N(self):
test_name = 'test_SteadyState_DamConfinedFlowWithSheetPile_2D6N'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
self.assert_outflow_discharge(simulation, 0.827800245)
def test_excavation2(self):
"""
Test of a two surface geometry where 1 surface is deactivated, on the boundary between the 2 surfaces,
a no deformation condition is applied. Values are not checked on analytical value, but on the fact that at the
boundary, no deformations should occur, opposite of the boundary deformations should occur.
:return:
"""
test_name = 'excavation_test2'
file_path = test_helper.get_file_path(
os.path.join('.', 'excavation_tests', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
displacements = test_helper.get_displacement(simulation)
coordinates = test_helper.get_nodal_coordinates(simulation)
bottom_nodes = [5, 7, 9, 12]
# check if bottom nodes are not moving
for bottom_node in bottom_nodes:
self.assertEqual(0, displacements[bottom_node - 1][0])
self.assertEqual(0, displacements[bottom_node - 1][1])
self.assertEqual(0, displacements[bottom_node - 1][2])
top_nodes = [1, 2, 6, 10, 13]
top_y_displacement = [
0, 0, 0, 2.8486711671144066e-07, 3.3932412582166974e-07
]
for i in range(len(top_nodes)):
self.assertAlmostEqual(top_y_displacement[i],
displacements[top_nodes[i] - 1][1])
def test_excavation(self):
"""
Test of a two surface geometry where 1 surface is deactivated. Values are not checked on analytical value,
but on the fact that equal displacements should occur at both sides of the geometry.
:return:
"""
test_name = 'excavation_test'
file_path = test_helper.get_file_path(
os.path.join('.', 'excavation_tests', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
displacements = test_helper.get_displacement(simulation)
bottom_nodes = [5, 7, 9, 12]
# check if bottom nodes are not moving
for bottom_node in bottom_nodes:
self.assertEqual(0, displacements[bottom_node - 1][0])
self.assertEqual(0, displacements[bottom_node - 1][1])
self.assertEqual(0, displacements[bottom_node - 1][2])
top_nodes = [1, 2, 6, 10, 13]
top_y_displacement = [0, 0, 3.16312e-07, 3.14736e-07, 3.16312e-07]
for i in range(len(top_nodes)):
self.assertAlmostEqual(top_y_displacement[i],
displacements[top_nodes[i] - 1][1])
def test_base(self):
test_name = 'base_test'
file_path = test_helper.get_file_path(
os.path.join('.', 'excavation_tests', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
displacements = test_helper.get_displacement(simulation)
bottom_nodes = [5, 7, 9, 12]
# check if bottom nodes are not moving
for bottom_node in bottom_nodes:
self.assertEqual(0, displacements[bottom_node - 1][0])
self.assertEqual(0, displacements[bottom_node - 1][1])
self.assertEqual(0, displacements[bottom_node - 1][2])
top_nodes = [1, 2, 6, 10, 13]
top_y_displacement = [
3.31258e-07, 3.10315e-07, 3.01343e-07, 3.10315e-07, 3.31258e-07
]
for i in range(len(top_nodes)):
self.assertAlmostEqual(top_y_displacement[i],
displacements[top_nodes[i] - 1][1])
def test_excavation3(self):
"""
Test of a two surface geometry where an excavation is applied to 1 surface, but the excavation is deactivated.
Values are not checked on analytical value, but on the fact that all nodes should have a value equal to the base test.
:return:
"""
test_name = 'excavation_test3'
file_path = test_helper.get_file_path(
os.path.join('.', 'excavation_tests', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
displacements = test_helper.get_displacement(simulation)
bottom_nodes = [5, 7, 9, 12]
# check if bottom nodes are not moving
for bottom_node in bottom_nodes:
self.assertEqual(0, displacements[bottom_node - 1][0])
self.assertEqual(0, displacements[bottom_node - 1][1])
self.assertEqual(0, displacements[bottom_node - 1][2])
top_nodes = [1, 2, 6, 10, 13]
top_y_displacement = [
3.31258e-07, 3.10315e-07, 3.01343e-07, 3.10315e-07, 3.31258e-07
]
for i in range(len(top_nodes)):
self.assertAlmostEqual(top_y_displacement[i],
displacements[top_nodes[i] - 1][1])
def test_normal_load_tetra_10n(self):
test_name = 'test_normal_load_tetra_10n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
n_dim = 3
self.assert_linear_elastic_saturated_block(simulation, n_dim)
def test_quad_8n(self):
test_name = 'test_quad_8n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
top_node_nbrs = [0, 2, 4, 8, 12]
n_dim = 2
self.assert_linear_elastic_block(simulation, top_node_nbrs, n_dim)
def test_tetra_4n(self):
test_name = 'test_tetra_4n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
top_node_nbrs = [0, 2, 9, 3, 6, 13, 8, 14, 20]
n_dim = 3
self.assert_linear_elastic_block(simulation, top_node_nbrs, n_dim)
def test_benchmark1_5(self):
"""
test point load on circular tunnel with beam elements
:return:
"""
import math
from analytical_solutions import calculate_max_deflections_ring, calculate_bending_moments_ring
# Calculate
test_name = 'test_tunnel'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
# get results
moments = test_helper.get_moment(simulation)
displacements = test_helper.get_displacement(simulation)
max_x_disp = max(
[abs(displacement[0]) for displacement in displacements])
max_y_disp = max(
[abs(displacement[1]) for displacement in displacements])
z_moments = [moment[2] for moment in moments]
max_moment, min_moment = max(z_moments), min(z_moments)
# calculate analytical solution
point_load = -100
radius = 0.5
youngs_modulus = 1e6
m_inertia = 8.333e-8
eps_h, eps_v = calculate_max_deflections_ring(point_load, radius,
youngs_modulus,
m_inertia)
hor_deform_analytic = abs(eps_h * radius)
vert_deform_analytic = abs(eps_v * radius * 2)
max_moment_analytic = calculate_bending_moments_ring(
point_load, radius, 0)
min_moment_analytic = calculate_bending_moments_ring(
point_load, radius, math.pi / 2)
# calculate error between analytical solution and numerical solution
error_max_moment = abs(max_moment_analytic - max_moment)
error_min_moment = abs(min_moment_analytic - min_moment)
error_max_x_disp = abs(hor_deform_analytic - max_x_disp)
error_max_y_disp = abs(vert_deform_analytic - max_y_disp)
# assert if error is smaller than the precision
precision = 0.001
self.assertLess(error_max_moment, abs(max_moment * precision))
self.assertLess(error_min_moment, abs(min_moment * precision))
self.assertLess(error_max_x_disp, abs(max_x_disp * precision))
self.assertLess(error_max_y_disp, abs(max_y_disp * precision))
def test_triangle_3n_fic(self):
test_name = 'test_triangle_3n_fic'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
top_node_nbrs = [0, 1, 5]
n_dim = 2
self.assert_linear_elastic_block(simulation, top_node_nbrs, n_dim)
def test_interpolate_water_pressure_inclined(self):
"""
Test interpolate water pressure with an inclined phreatic line.
The geometry consists out of 3 blocks. On the top block, an inclined phreatic line is defined. On the bottom
block, 100 pressure is defined. The water pressure in the middle block is interpolated between the water pressure
in the top and bottom block
:return:
"""
test_name = 'interpolate_line_2'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
water_pressure = test_helper.get_water_pressure(simulation)
# Node numbers of the left and right boundary of the middle block
middle_left_n_nbrs = [181, 155, 134, 110, 92, 75, 59, 45]
middle_right_n_nbrs = [301, 287, 274, 260, 249, 235, 227, 217]
# Pore pressures at the corners of the middle block
p_top_middle_left = -10000
p_bot_middle_left = -100
p_top_middle_right = -5000
p_bot_middle_tight = -100
# Vertical coordinates of the left and right boundary nodes of the middle block
vert_coord_bound_mid = [-i / 7 * 0.5 + 1.0 for i in range(8)]
# Analytically calculate pore pressure along left and right boundary of the middle block
dpdy_left = (p_top_middle_left - p_bot_middle_left) / (
vert_coord_bound_mid[0] - vert_coord_bound_mid[-1])
dpdy_right = (p_top_middle_right - p_bot_middle_tight) / (
vert_coord_bound_mid[0] - vert_coord_bound_mid[-1])
p_middle_left_analytic = [
(dpdy_left * (y - vert_coord_bound_mid[0]) + p_top_middle_left)
for y in vert_coord_bound_mid
]
p_middle_right_analytic = [
(dpdy_right * (y - vert_coord_bound_mid[0]) + p_top_middle_right)
for y in vert_coord_bound_mid
]
# Assert
for idx, node_nr in enumerate(middle_left_n_nbrs):
self.assertAlmostEqual(p_middle_left_analytic[idx],
water_pressure[node_nr],
delta=1e-6)
for idx, node_nr in enumerate(middle_right_n_nbrs):
self.assertAlmostEqual(p_middle_right_analytic[idx],
water_pressure[node_nr],
delta=1e-6)
def test_reset_displacement_truss(self):
"""
Tests reset displacement in a truss in 4 stages
stage 1: load is applied / reset displacement is false
stage 2: load is applied / reset displacement is true
stage 3: load is applied / reset displacement is false
stage 4: load is removed / reset displacement is false
:return:
"""
# calculate strain
F = -1e10 # [N]
E = 2069e8 # [N/m2]
A = 1 # [m2]
eps = F / (E * A)
# get stages
test_name = 'geo_truss_with_reset_displacemnet'
project_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
n_stages = 4
stages = test_helper.get_stages(project_path, n_stages)
displacement_stages = [None] * n_stages
nodal_coordinates_stages = [None] * n_stages
# run stages and get results
for idx, stage in enumerate(stages):
stage.Run()
displacement_stages[idx] = test_helper.get_displacement(stage)
nodal_coordinates_stages[idx] = test_helper.get_nodal_coordinates(
stage)
# Assert
stage_nr = 0
for idx, node in enumerate(nodal_coordinates_stages[stage_nr]):
self.assertAlmostEqual(displacement_stages[stage_nr][idx][0],
eps * node[0])
stage_nr = 1
for idx, node in enumerate(nodal_coordinates_stages[stage_nr]):
self.assertAlmostEqual(displacement_stages[stage_nr][idx][0], 0)
stage_nr = 2
for idx, node in enumerate(nodal_coordinates_stages[stage_nr]):
self.assertAlmostEqual(displacement_stages[stage_nr][idx][0], 0)
stage_nr = 3
for idx, node in enumerate(nodal_coordinates_stages[stage_nr]):
self.assertAlmostEqual(displacement_stages[stage_nr][idx][0],
-eps * node[0])
def test_tetra_10n(self):
test_name = 'test_tetra_10n'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
top_node_nbrs = [
0, 3, 9, 28, 53, 1, 6, 13, 32, 10, 15, 21, 44, 76, 27, 34, 41, 64,
94, 51, 56, 74, 95, 110
]
n_dim = 3
self.assert_linear_elastic_block(simulation, top_node_nbrs, n_dim)
def test_interface_on_beam(self):
"""
Tests an interface on a beam. In this test a calculation is done with and without interface,
where the interface has a cohesion of 1000 kN and a stiffness of 1e12 Pa. Results should be approximately equal
:return:
"""
# calculate reference case without interface
test_name = 'test_beam'
file_path = test_helper.get_file_path(os.path.join('.','test_interfaces', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
base_displacement = test_helper.get_displacement(simulation)
base_x_displacement = [displacement[0] for displacement in base_displacement]
base_y_displacement = [displacement[1] for displacement in base_displacement]
max_base_x_displacement = max(base_x_displacement)
max_base_y_displacement, min_base_y_displacement = max(base_y_displacement), min(base_y_displacement)
# calculate case with strong interface
test_name = 'test_interface_on_beam'
file_path = test_helper.get_file_path(
os.path.join('.', 'test_interfaces', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
interface_displacement = test_helper.get_displacement(simulation)
interface_x_displacement = [displacement[0] for displacement in interface_displacement]
interface_y_displacement = [displacement[1] for displacement in interface_displacement]
max_interface_x_displacement = max(interface_x_displacement)
max_interface_y_displacement, min_interface_y_displacement = max(interface_y_displacement), min(interface_y_displacement)
# assert base displacement is approximately equal to displacement with interface
precision = 0.01
self.assertLess(abs(max_interface_x_displacement - max_base_x_displacement), precision*max_base_x_displacement)
self.assertLess(abs(max_interface_y_displacement - max_base_y_displacement), precision*max_base_y_displacement)
self.assertLess(abs(min_interface_y_displacement - min_base_y_displacement), precision*max_base_y_displacement)
def test_truss_between_soil(self):
"""
Two blocks of soil are attached with very stiff truss. A point load is applied to 1 soil block.
Check if displacements at both sides of the truss are equal.
:return:
"""
test_name = 'test_truss_between_soils'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
displacements = test_helper.get_displacement(simulation)
# check if displacement in soil at both sides of truss is equal
self.assertAlmostEqual(displacements[6][0], displacements[8][0])
def test_benchmark2_3(self):
"""
In this benchmark a four stage model is tested.
Stage 1: initialisation sand layer
Stage 2: addition of sheetpile
Stage 3: addition of dike
Stage 4: addition of water
The test is calculated using gravity loading.
This test compares minimum, maximum stress and displacement in the third and fourth stage.
:return:
"""
test_name = r'dike_with_sheetpile_all_stage'
project_path = test_helper.get_file_path(os.path.join('.', test_name))
n_stages = 3
stages = test_helper.run_stages(project_path, n_stages)
def test_benchmark1_1(self):
"""
In this benchmark Bia-axial shearing test conditions are tested in the Kratos-Geomechanics application.
In that way, this example can be used to verify elastic deformation with a linear elastic model.
:return:
"""
test_name = 'Biaxialshearstresswithlinearelasticmodel'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
strain_tensor = test_helper.get_green_lagrange_strain_tensor(
simulation)
# check strain_tensor on all gauss points
for i in range(len(strain_tensor)):
for j in range(len(strain_tensor[i])):
self.assertAlmostEqual(-0.00125, strain_tensor[i][j][0, 1])
def test_inclinded_phreatic_line_smaller_line(self):
"""
test hydrostatic water pressure under an inclided phreatic line ranging over a part of the geometry
:return:
"""
test_name = 'test_inclinded_phreatic_line_smaller_line'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
# Get water pressure in all the nodes
water_pressure = test_helper.get_water_pressure(simulation)
# get node information of the bottom nodes in the geometry
bottom_n_nbrs = [
0, 2, 4, 9, 16, 24, 34, 47, 61, 78, 96, 115, 136, 162, 185
]
x_coords_boundary_nodes = [i / 14 for i in range(15)]
# Set turning points of the phreatic line
head_values = [1, 1, 0.5, 0.5]
head_x_coords = [0, 0.3, 0.7, 1]
# Analytically calculate water pressure at the bottom of the geometry
dhdx = (head_values[2] - head_values[1]) / (head_x_coords[2] -
head_x_coords[1])
gamma_w = 10000
p_bottom_analytic = [
-head_values[1] *
gamma_w if x <= head_x_coords[1] else -head_values[2] *
gamma_w if x >= head_x_coords[2] else
-(dhdx * (x - head_x_coords[1]) + head_values[1]) * gamma_w
for x in x_coords_boundary_nodes
]
# assert
for idx, node_nr in enumerate(bottom_n_nbrs):
self.assertAlmostEqual(p_bottom_analytic[idx],
water_pressure[node_nr],
delta=1e-6)
def test_wave_through_drained_linear_elastic_soil(self):
"""
Test dynamic calculation on a drained linear elastic soil column. a line load of -1kN is instantly placed
on the soil column. The soil parameters are chosen such that after 0.002 seconds, the wave is reflected at the
bottom of the geometry such that half the stress in the soil column is cancelled out.
:return:
"""
test_name = 'test_1d_wave_prop_drained_soil.gid'
file_path = test_helper.get_file_path(os.path.join('.', test_name))
simulation = test_helper.run_kratos(file_path)
# get effective stress
efective_stresses = test_helper.get_cauchy_stress_tensor(simulation)
efective_stresses_yy = [
integration_point[1, 1] for element in efective_stresses
for integration_point in element
]
# get coordinates of the gauss points
gauss_coordinates = test_helper.get_gauss_coordinates(simulation)
gauss_coordinates_y = [
integration_point[1] for element in gauss_coordinates
for integration_point in element
]
# calculate the expected effective stress in the soil column
expected_effective_stresses_yy = [
-1000 if gauss_coordinate_y >= -0.49 else
0 if gauss_coordinate_y <= -0.51 else -500
for gauss_coordinate_y in gauss_coordinates_y
]
# calculate root mean square error
square_errors = [
(efective_stress_yy - expected_effective_stresses_yy[idx])**2
for idx, efective_stress_yy in enumerate(efective_stresses_yy)
]
rmse = (sum(square_errors) / len(square_errors))**0.5
# assert root mean square error, the allowable error is 10% of the applied load
self.assertLess(rmse, 100)
def test_benchmark2_2(self):
"""
In this benchmark a two stage model is tested, where a simple clay dike is put on top of a sand layer.
The test is calculated using gravity loading. And UMAT-Mohr-Coulomb
This test compares minimum, maximum stress in the last stage.
:return:
"""
test_name = os.path.join('Simple_Dike_Gravity_Loading',
'simple_dike_test_with_gravity_umat.gid')
project_path = test_helper.get_file_path(os.path.join('.', test_name))
n_stages = 2
stages = test_helper.run_stages(project_path, n_stages)
max_x_total_stress_plaxis = 0.0
min_x_total_stress_plaxis = -140430.9
max_y_total_stress_plaxis = -1377.6
min_y_total_stress_plaxis = -424253.415
cauchy_stresses_kratos = test_helper.get_cauchy_stress_tensor(
stages[-1])
x_cauchy_stress_kratos = [[
gauss_point[0, 0] for gauss_point in element
] for element in cauchy_stresses_kratos]
y_cauchy_stress_kratos = [[
gauss_point[1, 1] for gauss_point in element
] for element in cauchy_stresses_kratos]
min_x_cauchy_stress_kratos, max_x_cauchy_stress_kratos = min(
min(x_cauchy_stress_kratos)), max(max(x_cauchy_stress_kratos))
min_y_cauchy_stress_kratos, max_y_cauchy_stress_kratos = min(
min(y_cauchy_stress_kratos)), max(max(y_cauchy_stress_kratos))
relative_precision_stress = 0.05
absolute_precision_stress = 1e3
self.assertAlmostEqual(max_x_total_stress_plaxis,
max_x_cauchy_stress_kratos,
delta=max(
abs(max_x_total_stress_plaxis *
relative_precision_stress),
absolute_precision_stress))
self.assertAlmostEqual(min_x_total_stress_plaxis,
min_x_cauchy_stress_kratos,
delta=max(
abs(min_x_total_stress_plaxis *
relative_precision_stress),
absolute_precision_stress))
self.assertAlmostEqual(
max_y_total_stress_plaxis,
max_y_cauchy_stress_kratos,
delta=max(max_y_total_stress_plaxis * relative_precision_stress,
absolute_precision_stress))
self.assertAlmostEqual(min_y_total_stress_plaxis,
min_y_cauchy_stress_kratos,
delta=max(
abs(min_x_total_stress_plaxis *
relative_precision_stress),
absolute_precision_stress))
def test_benchmark1_4(self):
"""
test 1D consolidation on elastic soil.
:return:
"""
from analytical_solutions import calculate_1D_consolidation
# define number of stages
n_stages = 11
# get the parameter file names for all stages
test_name = '1D-Consolidation_all_stages'
file_path = test_helper.get_file_path(os.path.join('.', test_name))
parameter_file_names = [
os.path.join(file_path,
'ProjectParameters_stage' + str(i + 1) + '.json')
for i in range(n_stages)
]
# set stage parameters
parameters_stages = [None] * n_stages
os.chdir(file_path)
for idx, parameter_file_name in enumerate(parameter_file_names):
with open(parameter_file_name, 'r') as parameter_file:
parameters_stages[idx] = Kratos.Parameters(
parameter_file.read())
model = Kratos.Model()
stages = [
analysis.GeoMechanicsAnalysis(model, stage_parameters)
for stage_parameters in parameters_stages
]
# run stages and get water pressure results per stage
stage_water_pressure = [None] * n_stages
for idx, stage in enumerate(stages):
stage.Run()
stage_water_pressure[idx] = test_helper.get_water_pressure(stage)
# get y coords of all the nodes
coords = test_helper.get_nodal_coordinates(stages[0])
y_coords = [coord[1] + 1 for coord in coords]
# calculate analytical solution for all stages and calculate the error
sample_height = 1
t_vs = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0]
rmse_stages = [None] * (n_stages - 1)
for idx, t_v in enumerate(t_vs):
rel_p_stages = [
calculate_1D_consolidation(y_coord, sample_height, t_v) * -1
for y_coord in y_coords
]
errors_stage = [
stage_water_pressure[idx + 1][node_idx] - rel_p
for node_idx, rel_p in enumerate(rel_p_stages)
]
rmse_stages[idx] = (sum([error**2 for error in errors_stage]) /
len(errors_stage))**0.5
# assert if average error in all stages is below 1 percent
accuracy = 0.01
for rmse_stage in rmse_stages:
self.assertLess(rmse_stage, accuracy)
def test_wave_through_undrained_linear_elastic_soil(self):
test_name = 'test_1d_confined_undrained_wave.gid'
file_path = test_helper.get_file_path(os.path.join('.', test_name))
simulation = test_helper.run_kratos(file_path)
pass
def test_benchmark1_3(self):
"""
smooth rigid strip footing on elastic soil
:return:
"""
from analytical_solutions import rigid_footing
import math
#
test_name = 'smoothrigidfootingonelasticsoil_2'
file_path = test_helper.get_file_path(
os.path.join('.', test_name + '.gid'))
simulation = test_helper.run_kratos(file_path)
cauchy_stress_tensor = test_helper.get_cauchy_stress_tensor(simulation)
step_size = 0.005
B = 1
delta = 0.88
G = 500
nu = 0.333
settlement = 0.01
F = settlement * 2 * (1 + nu) * G / delta
sigma_v = rigid_footing(0, B, delta, G, nu, settlement)
print("sigma_v = " + str(sigma_v))
#
x = [i * step_size for i in range(int(B / step_size) + 1)]
xmid = [(x[i] + x[i + 1]) / 2 for i in range(len(x) - 1)]
# sigma_v = [2 / math.pi * F / 2 / (B * math.sqrt(1 - (xi / B) ** 2)) for xi in xmid]
model_part = simulation._list_of_output_processes[0].model_part
elements = model_part.Elements
distances = []
min_distance_elements = []
min_distance_idxs = []
for xi in xmid:
min_distance = 10**10
min_distance_element = None
for element_idx, element in enumerate(elements):
nodes = element.GetNodes()
#integration_points = element.GetIntegrationPoints()
centroid = [0, 0, 0]
centre_x = sum([node.X0 for node in nodes]) / len(nodes)
centre_y = sum([node.X0 for node in nodes]) / len(nodes)
centre_z = sum([node.X0 for node in nodes]) / len(nodes)
centroid = [[centre_x[i], centre_y[i], centre_z[i]]
for i in range(len(centre_x))]
for node in nodes:
centroid[0] = centroid[0] + node.X0
centroid[1] = centroid[1] + node.Y0
centroid[2] = centroid[2] + node.Z0
centroid = [x / len(nodes) for x in centroid]
# for integration_point in integration_points:
# distance = compute_distance(integration_point,[xi,0.0,0.0])
distance = test_helper.compute_distance(
centroid, [xi, 0.0, 0.0])
if distance < min_distance:
min_distance = distance
min_distance_element = element
min_distance_idx = element_idx
min_distance_elements.append(min_distance_element)
min_distance_idxs.append(min_distance_idx)
distances.append(min_distance)
cauchy_stresses_at_load = [
cauchy_stress_tensor[min_distance_idx]
for min_distance_idx in min_distance_idxs
]
reaction_force = [
(cauchy_stress_at_load[0][3] + cauchy_stress_at_load[1][3] +
cauchy_stress_at_load[2][3]) / 3 * step_size
for cauchy_stress_at_load in cauchy_stresses_at_load
]
cauchy_stress_tensor[min_distance_idxs]
