def test_hertz_agreement_static_load_fftw():
""" Test that the load controlled static step gives approximately the same answer as the
analytical hertz solver
"""
try:
import pyfftw # noqa: F401
except ImportError:
warnings.warn(
"Could not import pyfftw, could not test the fftw backend")
return
with slippy.OverRideCuda():
# make surfaces
flat_surface = s.FlatSurface(shift=(0, 0))
round_surface = s.RoundSurface((1, 1, 1),
extent=(0.006, 0.006),
shape=(255, 255),
generate=True)
# set materials
steel = c.Elastic('Steel', {'E': 200e9, 'v': 0.3})
aluminum = c.Elastic('Aluminum', {'E': 70e9, 'v': 0.33})
flat_surface.material = aluminum
round_surface.material = steel
# create model
my_model = c.ContactModel('model-1', round_surface, flat_surface)
# set model parameters
total_load = 100
my_step = c.StaticStep('contact', normal_load=total_load)
my_model.add_step(my_step)
out = my_model.solve(skip_data_check=True)
final_load = sum(out['loads'].z.flatten() *
round_surface.grid_spacing**2)
# check the converged load is the same as the set load
npt.assert_approx_equal(final_load, total_load, 3)
# get the analytical hertz result
a_result = c.hertz_full([1, 1], [np.inf, np.inf], [200e9, 70e9],
[0.3, 0.33], 100)
# check max pressure
npt.assert_approx_equal(a_result['max_pressure'],
max(out['loads'].z.flatten()), 2)
# check contact area
found_area = round_surface.grid_spacing**2 * sum(
out['contact_nodes'].flatten())
npt.assert_approx_equal(a_result['contact_area'], found_area, 2)
# check deflection
npt.assert_approx_equal(a_result['total_deflection'],
out['interference'], 4)
def test_hertz_agreement_static_interference_fftw():
try:
import pyfftw # noqa: F401
slippy.CUDA = False
except ImportError:
warnings.warn(
"Could not import pyfftw, could not test the fftw backend")
return
with slippy.OverRideCuda():
"""Tests that the static normal interference step agrees with the analytical hertz solution"""
flat_surface = s.FlatSurface(shift=(0, 0))
round_surface = s.RoundSurface((1, 1, 1),
extent=(0.006, 0.006),
shape=(255, 255),
generate=True)
# set materials
steel = c.Elastic('Steel', {'E': 200e9, 'v': 0.3})
aluminum = c.Elastic('Aluminum', {'E': 70e9, 'v': 0.33})
flat_surface.material = aluminum
round_surface.material = steel
# create model
my_model = c.ContactModel('model-1', round_surface, flat_surface)
set_load = 100
a_result = c.hertz_full([1, 1], [np.inf, np.inf], [200e9, 70e9],
[0.3, 0.33], set_load)
my_step = c.StaticStep('step',
interference=a_result['total_deflection'])
my_model.add_step(my_step)
final_state = my_model.solve()
# check that the solution gives the set interference
npt.assert_approx_equal(final_state['interference'],
a_result['total_deflection'])
# check that the load converged to the correct results
num_total_load = round_surface.grid_spacing**2 * sum(
final_state['loads'].z.flatten())
npt.assert_approx_equal(num_total_load, set_load, significant=4)
# check that the max pressure is the same
npt.assert_approx_equal(a_result['max_pressure'],
max(final_state['loads'].z.flatten()),
significant=2)
# check that the contact area is in line with analytical solution
npt.assert_approx_equal(a_result['contact_area'],
round_surface.grid_spacing**2 *
sum(final_state['contact_nodes'].flatten()),
significant=2)
def test_hertz_agreement_pk_static_load_cuda_spatial_im():
""" Test that the load controlled static step gives approximately the same answer as the
analytical hertz solver
"""
try:
import cupy # noqa: F401
slippy.CUDA = True
except ImportError:
return
# make surfaces
flat_surface = s.FlatSurface(shift=(0, 0))
round_surface = s.RoundSurface((1, 1, 1), extent=(0.006, 0.006), shape=(255, 255), generate=True)
# set materials
steel_2 = c.Elastic('Steel_a', {'E': 200e9, 'v': 0.3}, use_frequency_domain=False)
aluminum_2 = c.Elastic('Aluminum_a', {'E': 70e9, 'v': 0.33}, use_frequency_domain=False)
flat_surface.material = aluminum_2
round_surface.material = steel_2
# create model
my_model = c.ContactModel('model-1', round_surface, flat_surface)
# set model parameters
total_load = 100
my_step = c.StaticStep('contact', normal_load=total_load, )
my_model.add_step(my_step)
out = my_model.solve(skip_data_check=True)
final_load = sum(out['loads_z'].flatten() * round_surface.grid_spacing ** 2)
# check the converged load is the same as the set load
npt.assert_approx_equal(final_load, total_load, 3)
# get the analytical hertz result
a_result = c.hertz_full([1, 1], [np.inf, np.inf], [200e9, 70e9], [0.3, 0.33], 100)
# check max pressure
npt.assert_approx_equal(a_result['max_pressure'], max(out['loads_z'].flatten()), 3)
# check contact area
found_area = round_surface.grid_spacing ** 2 * sum(out['contact_nodes'].flatten())
npt.assert_approx_equal(a_result['contact_area'], found_area, 2)
# check deflection
npt.assert_approx_equal(a_result['total_deflection'], out['interference'], 4)
def test_contact_stiffness():
"""
Test the contact stiffness sub model against a known analytical result
Also tests the example
"""
diameter = 1
resolution = 512
x, y = np.meshgrid(np.linspace(-diameter, diameter, resolution),
np.linspace(-diameter, diameter, resolution))
indenter_profile = np.array((x**2 + y**2) < (diameter / 2)**2,
dtype=np.float32)
grid_spacing = x[1, 1] - x[0, 0]
indenter = s.Surface(profile=indenter_profile, grid_spacing=grid_spacing)
half_space = s.FlatSurface(shape=(resolution, resolution),
grid_spacing=grid_spacing,
generate=True)
indenter.material = c.rigid
e, v = 200e9, 0.3
half_space.material = c.Elastic('steel', {'E': e, 'v': v})
reduced_modulus = 1 / ((1 - v**2) / e)
my_model = c.ContactModel('Contact_stiffness_example', half_space,
indenter)
step = c.StaticStep('loading', interference=1e-4, periodic_geometry=True)
sub_model = c.sub_models.ResultContactStiffness('stiffness',
definition='far points',
loading=False)
step.add_sub_model(sub_model)
my_model.add_step(step)
# we don't need to solve the contact model we already know what the contact nodes will be
contact_nodes = (x**2 + y**2) < (diameter / 2)**2
current_state = {
'contact_nodes': contact_nodes,
'loads_z': np.zeros_like(contact_nodes)
}
results = sub_model.solve(current_state)
numerical_stiffness = results['s_contact_stiffness_unloading_fp_z_0'] * (
2 * diameter)**2
analytical_stiffness = reduced_modulus * diameter
npt.assert_approx_equal(numerical_stiffness, analytical_stiffness, 2)
def test_example_mixed_lubrication():
"""tests the mixed lubrication example"""
radius = 0.01905 # The radius of the ball
load = 800 # The load on the ball in N
rolling_speed = 4 # The rolling speed in m/s (The mean speed of the surfaces)
youngs_modulus = 200e9 # The youngs modulus of the surfaces
p_ratio = 0.3 # The poission's ratio of the surfaces
grid_size = 65 # The number of points in the descretisation grid
eta_0 = 0.096 # Coefficient in the roelands pressure-viscosity equation
roelands_p_0 = 1 / 5.1e-9 # Coefficient in the roelands pressure-viscosity equation
roelands_z = 0.68 # Coefficient in the roelands pressure-viscosity equation
# Solving the hertzian contact
hertz_result = c.hertz_full([radius, radius], [float('inf'), float('inf')],
[youngs_modulus, youngs_modulus],
[p_ratio, p_ratio], load)
hertz_pressure = hertz_result['max_pressure']
hertz_a = hertz_result['contact_radii'][0]
hertz_deflection = hertz_result['total_deflection']
hertz_pressure_function = hertz_result['pressure_f']
ball = s.RoundSurface((radius,) * 3, shape=(grid_size, grid_size),
extent=(hertz_a * 4, hertz_a * 4), generate=True)
flat = s.FlatSurface()
steel = c.Elastic('steel', {'E': youngs_modulus, 'v': p_ratio})
ball.material = steel
flat.material = steel
oil = c.Lubricant('oil') # Making a lubricant object to contain our sub models
oil.add_sub_model('nd_viscosity', c.lubricant_models.nd_roelands(eta_0, roelands_p_0, hertz_pressure, roelands_z))
oil.add_sub_model('nd_density', c.lubricant_models.nd_dowson_higginson(hertz_pressure)) # adding dowson higginson
my_model = c.ContactModel('lubrication_test', ball, flat, oil)
reynolds = c.UnifiedReynoldsSolver(time_step=0,
grid_spacing=ball.grid_spacing,
hertzian_pressure=hertz_pressure,
radius_in_rolling_direction=radius,
hertzian_half_width=hertz_a,
dimentional_viscosity=eta_0,
dimentional_density=872)
# Find the hertzian pressure distribution as an initial guess
x, y = ball.get_points_from_extent()
x, y = x + ball._total_shift[0], y + ball._total_shift[1]
hertzian_pressure_dist = hertz_pressure_function(x, y)
# Making the step object
step = c.IterSemiSystem('main', reynolds, rolling_speed, 1, no_time=True, normal_load=load,
initial_guess=[hertz_deflection, hertzian_pressure_dist],
relaxation_factor=0.05, max_it_interference=3000, rtol_interference=1e-3,
rtol_pressure=1e-4, no_update_warning=False)
# Adding the step to the contact model
my_model.add_step(step)
state = my_model.solve()
# gap is all greater than 0
assert np.all(state['gap'] >= 0)
# loads are all greater than or equal to 0
assert np.all(state['pressure'] >= 0)
# sum of pressures is total normal load and this has converged
npt.assert_array_almost_equal(np.sum(state['pressure'])*ball.grid_spacing**2/load, 1.0, decimal=3)
assert state['converged']
import numpy as np
import numpy.testing as npt
import warnings
import slippy
import slippy.contact as c # noqa: E402
import slippy.surface as s # noqa: E402
steel = c.Elastic('Steel_2', {'E': 200e9, 'v': 0.3})
aluminum = c.Elastic('Aluminum_2', {'E': 70e9, 'v': 0.33})
def test_hertz_agreement_pk_static_load_fftw():
""" Test that the load controlled static step gives approximately the same answer as the
analytical hertz solver
"""
try:
import pyfftw # noqa: F401
except ImportError:
warnings.warn(
"Could not import pyfftw, could not test the fftw backend")
return
with slippy.OverRideCuda():
# make surfaces
flat_surface = s.FlatSurface(shift=(0, 0))
round_surface = s.RoundSurface((1, 1, 1),
extent=(0.006, 0.006),
shape=(255, 255),
generate=True)