def gen_dim1sin_E_Igamv_the_aDmagDt_bilinear():
"""Test case generation for dim1sin_E_Igamv_the_aDmagDt_bilinear
2014-03-22"""
#dim1sin_E_Igamv_the_aDmagDt_bilinear(m, eigs, tvals, Igamv, a, mag_vs_depth, mag_vs_time, omega_phase = None, dT=1.0):
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
mag_vs_time = PolyLine([0,2,4],[0,2,2])
mag_vs_depth = PolyLine([0, 1], [1, 2])#y = (1+z)
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
fn=OrderedDict()
fn['single_load'] = {'m': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a':a,
'mag_vs_depth': [mag_vs_depth], 'mag_vs_time': [mag_vs_time]}
fn['double_load'] = {'m': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a':a,
'mag_vs_depth': [mag_vs_depth]*2, 'mag_vs_time': [mag_vs_time]*2}
fn['omega_phase'] = {'m': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a':a,
'mag_vs_depth': [mag_vs_depth], 'mag_vs_time': [mag_vs_time],'omega_phase': [omega_phase]}
for k, v in fn.items():
print(k)
print (dim1sin_E_Igamv_the_aDmagDt_bilinear(**v))
print('#'*10+'\n')
class test_dim1sin_E_Igamv_the_abmag_bilinear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_abmag_bilinear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
because this fn is basically a glorified wrapper we really just need to
test if all the args are passed properly.
"""
#dim1sin_E_Igamv_the_abmag_bilinear(m, eigs, tvals, Igamv, a, b, mag_vs_depth, mag_vs_time, omega_phase=None, dT=1.0):
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
mag_vs_time = PolyLine([0,2,4],[0,2,2])
mag_vs_depth = PolyLine([0, 1], [1, 2])#y = (1+z)
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
def test_single_load(self):
assert_allclose(dim1sin_E_Igamv_the_abmag_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a, 'b':self.b,
'mag_vs_depth': [self.mag_vs_depth], 'mag_vs_time': [self.mag_vs_time]}),
np.array([[ 0.81302649, 3.71707495],
[ 1.16885336, 5.34387942],
[ 0.91557876, 4.18593358]]))
def test_double_load(self):
assert_allclose(dim1sin_E_Igamv_the_abmag_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a, 'b':self.b,
'mag_vs_depth': [self.mag_vs_depth]*2, 'mag_vs_time': [self.mag_vs_time]*2}),
2*np.array([[ 0.81302649, 3.71707495],
[ 1.16885336, 5.34387942],
[ 0.91557876, 4.18593358]]))
def test_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_abmag_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a, 'b':self.b,
'mag_vs_depth': [self.mag_vs_depth], 'mag_vs_time': [self.mag_vs_time], 'omega_phase': [self.omega_phase]}),
np.array([[-0.72431765, -1.13467717],
[-1.04132046, -1.63127676],
[-0.81568051, -1.27780132]]))
class test_dim1sin_E_Igamv_the_aDmagDt_bilinear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_aDmagDt_bilinear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
because this fn is basically a glorified wrapper we really just need to
test if all the args are passed properly.
"""
#dim1sin_E_Igamv_the_aDmagDt_bilinear(m, eigs, tvals, Igamv, a, mag_vs_depth, mag_vs_time, omega_phase = None, dT=1.0):
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
mag_vs_time = PolyLine([0,2,4],[0,2,2])
mag_vs_depth = PolyLine([0, 1], [1, 2])#y = (1+z)
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
def test_single_load(self):
assert_allclose(dim1sin_E_Igamv_the_aDmagDt_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a,
'mag_vs_depth': [self.mag_vs_depth], 'mag_vs_time': [self.mag_vs_time]}),
np.array([[ 0.81245149, 0.40883755],
[ 1.19316194, 0.60041665],
[ 0.99156737, 0.4989713 ]]))
def test_double_load(self):
assert_allclose(dim1sin_E_Igamv_the_aDmagDt_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a,
'mag_vs_depth': [self.mag_vs_depth]*2, 'mag_vs_time': [self.mag_vs_time]*2}),
2*np.array([[ 0.81245149, 0.40883755],
[ 1.19316194, 0.60041665],
[ 0.99156737, 0.4989713 ]]))
def test_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_aDmagDt_bilinear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a':self.a,
'mag_vs_depth': [self.mag_vs_depth], 'mag_vs_time': [self.mag_vs_time], 'omega_phase': [self.omega_phase]}),
np.array([[-0.85117901, 1.38905894],
[-1.25003698, 2.03996458],
[-1.0388329 , 1.69529571]]))
class test_dim1sin_E_Igamv_the_deltamag_linear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_deltamag_linear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
because this fn is basically a glorified wrapper we really just need to
test if all the args are passed properly.
"""
#dim1sin_E_Igamv_the_deltamag_linear(m, eigs, tvals, Igamv, zvals, a, mag_vs_time, omega_phase=None, dT=1.0):
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
mag_vs_time = PolyLine([0,2,4],[0,2,2])
mag_vs_depth = PolyLine([0, 1], [1, 2])#y = (1+z)
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
zvals=[0.2]
pseudo_k=[1000]
def test_single_load(self):
assert_allclose(dim1sin_E_Igamv_the_deltamag_linear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals':self.zvals, 'pseudo_k':self.pseudo_k,
'mag_vs_time': [self.mag_vs_time]}),
np.array([[ 73.08636239, 334.14346275],
[ 143.25900215, 654.9656801 ],
[ 207.72035757, 949.67648264]]))
def test_double_load(self):
assert_allclose(dim1sin_E_Igamv_the_deltamag_linear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals':self.zvals*2, 'pseudo_k':self.pseudo_k*2,
'mag_vs_time': [self.mag_vs_time]*2}),
2*np.array([[ 73.08636239, 334.14346275],
[ 143.25900215, 654.9656801 ],
[ 207.72035757, 949.67648264]]))
def test_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_deltamag_linear(
**{'m': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals':self.zvals, 'pseudo_k':self.pseudo_k,
'mag_vs_time': [self.mag_vs_time], 'omega_phase': [self.omega_phase]}),
np.array([[ -65.11195277, -102.00089187],
[-127.62809745, -199.93533007],
[-185.05611264, -289.89897759]]))
def gen_dim1sin_E_Igamv_the_BC_aDfDt_linear():
"""Test case generation for dim1sin_E_Igamv_the_BC_aDfDt_linear.
2014-03-22"""
#dim1sin_E_Igamv_the_BC_aDfDt_linear(drn, m, eigs, tvals, Igamv, a, top_vs_time, bot_vs_time, top_omega_phase=None, bot_omega_phase=None, dT=1.0):
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
fn=OrderedDict()
fn['no_bc'] = {'drn': 0, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': None, 'bot_vs_time':None}
fn['top_vs_time_drn_0']={'drn': 0, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': [top_vs_time], 'bot_vs_time':None}
fn['top_vs_time_drn_1']={'drn': 1, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': [top_vs_time], 'bot_vs_time':None}
fn['bot_vs_time_drn_0']={'drn': 0, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': None,'bot_vs_time':[bot_vs_time]}
fn['bot_vs_time_top_vs_time_drn_1']={'drn': 1, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': [top_vs_time],'bot_vs_time':[bot_vs_time]}
fn['test_top_vs_time_drn_0_omega_phase']={'drn': 0, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a,
'top_vs_time': [top_vs_time],
'bot_vs_time':None,
'top_omega_phase': [omega_phase]}
fn['test_bot_vs_time_drn_0_omega_phase']={'drn': 0, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a,
'top_vs_time': None,
'bot_vs_time':[bot_vs_time],
'bot_omega_phase': [omega_phase]}
fn['bot_vs_time_top_vs_time_drn_1_double_loads']={'drn': 1, 'm': m, 'eigs':eigs, 'tvals':tvals,'Igamv':Igamv,
'a': a, 'top_vs_time': [top_vs_time, top_vs_time],'bot_vs_time':[bot_vs_time, bot_vs_time]}
# print(dim1sin_E_Igamv_the_BC_abf_linear(0,m,eigs,tvals,Igamv, a,b, top_vs_time=None, bot_vs_time=None))
for k, v in fn.items():
print(k)
print (dim1sin_E_Igamv_the_BC_aDfDt_linear(**v))
print('#'*10+'\n')
def test_check_attribute_PolyLines_have_same_x_limits():
"""test for check_attribute_PolyLines_have_same_x_limits function"""
#check_attribute_PolyLines_have_same_x_limits(obj, attributes=[])
a = EmptyClass()
a.a = None
a.b = PolyLine([0,4],[4,5])
a.c = [PolyLine([0,4],[6,3]), PolyLine([0,5],[6,3])]
a.d = PolyLine([0,2,4], [3,2,4])
assert_raises(ValueError, check_attribute_PolyLines_have_same_x_limits, a,
attributes=[['a','b','c','d']])
assert_raises(ValueError, check_attribute_PolyLines_have_same_x_limits, a,
attributes=[['c']])
assert_equal(check_attribute_PolyLines_have_same_x_limits(a,
attributes=[['a','b','d']]), None)
class test_dim1sin_E_Igamv_the_BC_deltaf_linear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_BC_deltaf_linear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
- I've not included layers in the a part
- I've the test case data was generated by evaluating the function
i.e. it's not an independant test. I think it is OK because
the Speccon1dVR testing whcih uses all these fns uses independant data
"""
#dim1sin_E_Igamv_the_BC_deltaf_linear(drn, m, eigs, tvals, Igamv, zvals, pseudo_k, top_vs_time, bot_vs_time, top_omega_phase=None, bot_omega_phase=None, dT=1.0)
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
zvals=[0.2]
pseudo_k=[1000]
def test_no_BC(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': None, 'bot_vs_time':None}),
np.array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]))
def test_top_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 58.46908991, 267.3147702 ],
[ 114.60720172, 523.97254408],
[ 166.17628606, 759.74118611]]))
def test_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 73.08636239, 334.14346275],
[ 143.25900215, 654.9656801 ],
[ 207.72035757, 949.67648264]]))
def test_bot_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': None, 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 14.61727248, 66.82869255],
[ 28.65180043, 130.99313602],
[ 41.54407151, 189.93529653]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 87.70363487, 400.97215531],
[ 171.91080258, 785.95881612],
[ 249.26442909, 1139.61177917]]))
def test_top_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k,
'top_vs_time': [self.top_vs_time],
'bot_vs_time':None,
'top_omega_phase': [self.omega_phase]}),
np.array([[ -52.08956221, -81.6007135 ],
[-102.10247796, -159.94826406],
[-148.04489011, -231.91918207]]))
def test_bot_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k,
'top_vs_time': None,
'bot_vs_time':[self.bot_vs_time],
'bot_omega_phase': [self.omega_phase]}),
np.array([[-13.02239055, -20.40017837],
[-25.52561949, -39.98706601],
[-37.01122253, -57.97979552]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
assert_allclose(dim1sin_E_Igamv_the_BC_deltaf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'zvals': self.zvals, 'pseudo_k':self.pseudo_k, 'top_vs_time': [self.top_vs_time,self.top_vs_time], 'bot_vs_time':[self.bot_vs_time,self.bot_vs_time]}),
np.array([[ 175.40726974, 801.94431061],
[ 343.82160516, 1571.91763224],
[ 498.52885818, 2279.22355834]]))
class test_dim1sin_E_Igamv_the_BC_aDfDt_linear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_BC_aDfDt_linear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
- I've not included layers in the a part
- I've the test case data was generated by evaluating the function
i.e. it's not an independant test. I think it is OK because
the Speccon1dVR testing whcih uses all these fns uses independant data
"""
#dim1sin_E_Igamv_the_BC_aDfDt_linear(drn, m, eigs, tvals, Igamv, a, top_vs_time, bot_vs_time, top_omega_phase=None, bot_omega_phase=None, dT=1.0):
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
def test_no_BC(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': None, 'bot_vs_time':None}),
np.array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]))
def test_top_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 0.14946707, 0.07521403],
[ 0.25246136, 0.12704228],
[ 0.28406245, 0.14294441]]))
def test_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 0.48095928, 0.24202579],
[ 0.72281165, 0.36372947],
[ 0.63781491, 0.32095785]]))
def test_bot_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': None, 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.33149221, 0.16681176],
[ 0.47035029, 0.23668719],
[ 0.35375246, 0.17801345]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.81245149, 0.40883755],
[ 1.19316194, 0.60041665],
[ 0.99156737, 0.4989713 ]]))
def test_top_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a,
'top_vs_time': [self.top_vs_time],
'bot_vs_time':None,
'top_omega_phase': [self.omega_phase]}),
np.array([[-0.15659179, 0.2555458 ],
[-0.26449556, 0.4316365 ],
[-0.297603 , 0.48566529]]))
def test_bot_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a,
'top_vs_time': None,
'bot_vs_time':[self.bot_vs_time],
'bot_omega_phase': [self.omega_phase]}),
np.array([[-0.34729361, 0.56675657],
[-0.49277071, 0.80416404],
[-0.37061495, 0.60481521]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
assert_allclose(dim1sin_E_Igamv_the_BC_aDfDt_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time,self.top_vs_time], 'bot_vs_time':[self.bot_vs_time,self.bot_vs_time]}),
np.array([[ 1.62490297, 0.8176751 ],
[ 2.38632387, 1.20083331],
[ 1.98313474, 0.9979426 ]]))
class test_dim1sin_E_Igamv_the_BC_D_aDf_linear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_BC_D_aDf_linear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
- I've not included layers in the a part
- I've the test case data was generated by evaluating the function
i.e. it's not an independant test. I think it is OK because
the Speccon1dVR testing whcih uses all these fns uses independant data
"""
#dim1sin_E_Igamv_the_BC_D_aDf_linear(drn, m, eigs, tvals, Igamv, a, top_vs_time, bot_vs_time, top_omega_phase=None, bot_omega_phase=None, dT=1.0):
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
def test_no_BC(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': None, 'bot_vs_time':None}),
np.array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]))
def test_top_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[-0.16911333, -0.77316906],
[-0.26048565, -1.19091408],
[-0.24402578, -1.11566119]]))
def test_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]))
def test_bot_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': None, 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.16911333, 0.77316906],
[ 0.26048565, 1.19091408],
[ 0.24402578, 1.11566119]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.16911333, 0.77316906],
[ 0.26048565, 1.19091408],
[ 0.24402578, 1.11566119]]))
def test_top_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a,
'top_vs_time': [self.top_vs_time],
'bot_vs_time':None,
'top_omega_phase': [self.omega_phase]}),
np.array([[ 0.15066148, 0.23601818],
[ 0.23206422, 0.36353935],
[ 0.21740027, 0.3405676 ]]))
def test_bot_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a,
'top_vs_time': None,
'bot_vs_time':[self.bot_vs_time],
'bot_omega_phase': [self.omega_phase]}),
np.array([[-0.15066148, -0.23601818],
[-0.23206422, -0.36353935],
[-0.21740027, -0.3405676 ]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
assert_allclose(dim1sin_E_Igamv_the_BC_D_aDf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'top_vs_time': [self.top_vs_time,self.top_vs_time], 'bot_vs_time':[self.bot_vs_time,self.bot_vs_time]}),
np.array([[ 0.33822666, 1.54633812],
[ 0.52097131, 2.38182817],
[ 0.48805155, 2.23132237]]))
class test_dim1sin_E_Igamv_the_BC_abf_linear(unittest.TestCase):
"""tests for dim1sin_E_Igamv_the_BC_abf_linear
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
- I've the test case data was generated by evaluating the function
i.e. it's not an independant test. I think it is OK because
the Speccon1dVR testing whcih uses all these fns uses independant data
"""
#dim1sin_E_Igamv_the_BC_abf_linear(drn, m, eigs, tvals, Igamv, a, b, top_vs_time, bot_vs_time, top_omega_phase=None, bot_omega_phase=None, dT=1.0):
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
b = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
Igamv = np.identity(3)
eigs = np.ones(3)
def test_no_BC(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': None, 'bot_vs_time':None}),
np.array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]))
def test_top_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 0.13262919, 0.60636726],
[ 0.21993155, 1.00550484],
[ 0.23855946, 1.09066975]]))
def test_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':None}),
np.array([[ 0.47282784, 2.1617211 ],
[ 0.69439245, 3.17469213],
[ 0.57706911, 2.63830166]]))
def test_bot_vs_time_drn_0(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': None, 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.34019865, 1.55535384],
[ 0.4744609 , 2.16918729],
[ 0.33850965, 1.54763191]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': [self.top_vs_time], 'bot_vs_time':[self.bot_vs_time]}),
np.array([[ 0.81302649, 3.71707495],
[ 1.16885336, 5.34387942],
[ 0.91557876, 4.18593358]]))
def test_top_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b,
'top_vs_time': [self.top_vs_time],
'bot_vs_time':None,
'top_omega_phase': [self.omega_phase]}),
np.array([[-0.1181581 , -0.18510014],
[-0.19593495, -0.30694118],
[-0.21253038, -0.33293869]]))
def test_bot_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 0, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b,
'top_vs_time': None,
'bot_vs_time':[self.bot_vs_time],
'bot_omega_phase': [self.omega_phase]}),
np.array([[-0.30307978, -0.47478852],
[-0.42269275, -0.66216779],
[-0.30157506, -0.47243132]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
assert_allclose(dim1sin_E_Igamv_the_BC_abf_linear(
**{'drn': 1, 'm': self.m, 'eigs':self.eigs, 'tvals':self.tvals,'Igamv':self.Igamv,
'a': self.a, 'b':self.b, 'top_vs_time': [self.top_vs_time,self.top_vs_time], 'bot_vs_time':[self.bot_vs_time,self.bot_vs_time]}),
np.array([[ 1.62605298, 7.43414989],
[ 2.33770671, 10.68775884],
[ 1.83115753, 8.37186715]]))
def gen_dim1sin_integrate_af():
"""Test case data generation for dim1sin_integrate_af."""
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0, 2.0, 3.0])
v_E_Igamv_the = np.ones((3, 2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0, 2, 4], [0, 2, 2])
bot_vs_time = PolyLine([0, 2, 4], [0, 2, 2])
omega_phase = (1, 2)
a = PolyLine([0, 1], [1, 2]) # y = 1 + z
g = np.array([1.0,
2.0]) # this is interpolated from top_vs_time at t = 1, 3
z1_, z2_, z_, m_, g_, t_, omega_, phase_ = sympy.symbols(
'z1_, z2_, z_, m_, g_, t_, omega_, phase_')
top1 = g_ * (1 - z_)
top2 = g_
bot1 = g_ * z_
print(g[np.newaxis, :] * z1[:, np.newaxis])
mapping = [('z1_', 'z1[:,np.newaxis]'), ('z2_', 'z2[:,np.newaxis]'),
('m_', 'm[np.newaxis,:]'), ('g_', 'g[np.newaxis,:]'),
('t_', 'tvals[np.newaxis,:]'), ('omega_', 'omega_phase[0]'),
('phase_', 'omega_phase[1]')]
fn = OrderedDict()
fn['no_bc'] = sympy.integrate(
sympy.sin(m_ * z_) * (1 + z_), (z_, z1_, z2_))
#anything other than fn['no_bc'] only contains the bc part
fn['top_vs_time_drn_0'] = sympy.integrate(top1 * (1 + z_), (z_, z1_, z2_))
fn['top_vs_time_drn_1'] = sympy.integrate(top2 * (1 + z_), (z_, z1_, z2_))
fn['bot_vs_time_drn_0'] = sympy.integrate(bot1 * (1 + z_), (z_, z1_, z2_))
fn['bot_vs_time_top_vs_time_drn_1'] = sympy.integrate(
(top2 + bot1) * (1 + z_), (z_, z1_, z2_))
fn['top_vs_time_drn_0_omega_phase'] = sympy.integrate(
sympy.cos(omega_ * t_ + phase_) * top1 * (1 + z_), (z_, z1_, z2_))
fn['bot_vs_time_drn_0_omega_phase'] = sympy.integrate(
sympy.cos(omega_ * t_ + phase_) * bot1 * (1 + z_), (z_, z1_, z2_))
fn['bot_vs_time_top_vs_time_drn_1_double_loads'] = 2 * sympy.integrate(
(top2 + bot1) * (1 + z_), (z_, z1_, z2_))
#no_bc part
sout = str(fn['no_bc'])
for k, v in mapping:
sout = sout.replace(k, v)
print('no_bc')
print(sout)
print('#' * 10)
if SAFE:
no_bc = (np.dot(eval(sout), v_E_Igamv_the))
print(no_bc)
print('#' * 10 + '\n')
for s, f in fn.items():
if s == "no_bc":
continue
sout = str(f)
for k, v in mapping:
sout = sout.replace(k, v)
print(s)
print(sout)
print('#' * 10)
if SAFE:
print(no_bc + eval(sout))
print('#' * 10 + '\n')
class test_plot_generic_loads(temp_cls):
"""tests for plot_generic_loads"""
# plot_generic_loads(load_triples, load_names, ylabels=None,
# trange = None, H = 1.0, RLzero=None, prop_dict={})
vs_time1 = PolyLine(np.array([0, 10]), np.array([0, 1]))
vs_depth1 = PolyLine(np.array([0, 0.4, 1]), np.array([1.0, 1.0, 0.5]))
omega_phase1 = (0.5, 0.3)
triple1 = (vs_time1, vs_depth1, omega_phase1)
vs_time2 = PolyLine(np.array([0, 9]), np.array([0, 2]))
vs_depth2 = PolyLine(np.array([0, 0.4, 1]), np.array([1.0, 1.0, 0.8]))
omega_phase2 = None
triple2 = (vs_time2, vs_depth2, omega_phase2)
load_names = ['a', 'b']
def test_defaults(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names)
assert_equal(len(fig.get_axes()), 4)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
ax3 = fig.get_axes()[2]
line3 = ax3.get_lines()[0]
ax4 = fig.get_axes()[3]
line4 = ax4.get_lines()[0]
#first row of charts
assert_allclose(line1.get_xydata()[0], np.array([0, 0]))
assert_allclose(line1.get_xydata()[-1],
np.array([10, 1 * np.cos(0.5 * 10 + 0.3)]))
assert_allclose(line2.get_xydata()[0], np.array([1, 0]))
assert_allclose(line2.get_xydata()[-1], np.array([0.5, 1]))
#2nd row of charts
assert_allclose(line3.get_xydata()[0], np.array([0, 0]))
assert_allclose(line3.get_xydata()[-1], np.array([9, 2]))
assert_allclose(line4.get_xydata()[0], np.array([1, 0]))
assert_allclose(line4.get_xydata()[-1], np.array([0.8, 1]))
assert_equal(ax1.get_xlabel(), '')
assert_equal(ax1.get_ylabel(), 'y0')
assert_equal(ax2.get_xlabel(), '')
assert_equal(ax2.get_ylabel(), 'Depth, z')
assert_equal(ax3.get_xlabel(), 'Time')
assert_equal(ax3.get_ylabel(), 'y1')
assert_equal(ax4.get_xlabel(), 'Load factor')
assert_equal(ax4.get_ylabel(), 'Depth, z')
assert_equal(line1.get_label(), 'a0')
assert_equal(line2.get_label(), 'a0')
assert_equal(line3.get_label(), 'b0')
assert_equal(line4.get_label(), 'b0')
ok_(not ax1.get_legend() is None)
ok_(not ax3.get_legend() is None)
def test_ylabels(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
ylabels=['one', 'two'])
ax1 = fig.get_axes()[0]
ax3 = fig.get_axes()[2]
assert_equal(ax1.get_ylabel(), 'one')
assert_equal(ax3.get_ylabel(), 'two')
def test_trange(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
trange=(2, 3))
ax1 = fig.get_axes()[0]
ax3 = fig.get_axes()[2]
assert_allclose(ax1.get_xlim(), (2, 3))
assert_allclose(ax3.get_xlim(), (2, 3))
def test_H(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
H=2.0)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
ax3 = fig.get_axes()[2]
line3 = ax3.get_lines()[0]
ax4 = fig.get_axes()[3]
line4 = ax4.get_lines()[0]
#first row of charts
assert_allclose(line1.get_xydata()[0], np.array([0, 0]))
assert_allclose(line1.get_xydata()[-1],
np.array([10, 1 * np.cos(0.5 * 10 + 0.3)]))
assert_allclose(line2.get_xydata()[0], np.array([1, 0]))
assert_allclose(line2.get_xydata()[-1], np.array([0.5, 2]))
#2nd row of charts
assert_allclose(line3.get_xydata()[0], np.array([0, 0]))
assert_allclose(line3.get_xydata()[-1], np.array([9, 2]))
assert_allclose(line4.get_xydata()[0], np.array([1, 0]))
assert_allclose(line4.get_xydata()[-1], np.array([0.8, 2]))
def test_RLzero(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
H=2.0,
RLzero=1)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
ax3 = fig.get_axes()[2]
line3 = ax3.get_lines()[0]
ax4 = fig.get_axes()[3]
line4 = ax4.get_lines()[0]
#first row of charts
assert_allclose(line1.get_xydata()[0], np.array([0, 0]))
assert_allclose(line1.get_xydata()[-1],
np.array([10, 1 * np.cos(0.5 * 10 + 0.3)]))
assert_allclose(line2.get_xydata()[0], np.array([1, 1]))
assert_allclose(line2.get_xydata()[-1], np.array([0.5, -1]))
#2nd row of charts
assert_allclose(line3.get_xydata()[0], np.array([0, 0]))
assert_allclose(line3.get_xydata()[-1], np.array([9, 2]))
assert_allclose(line4.get_xydata()[0], np.array([1, 1]))
assert_allclose(line4.get_xydata()[-1], np.array([0.8, -1]))
assert_equal(ax2.get_ylabel(), 'RL')
assert_equal(ax4.get_ylabel(), 'RL')
def test_propdict_fig_prop_figsize(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={'fig_prop': {
'figsize': (8, 9)
}})
assert_allclose(fig.get_size_inches(), (8, 9))
def test_propdict_has_legend(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={'has_legend': False})
ax1 = fig.get_axes()[0]
ax3 = fig.get_axes()[2]
assert_equal(ax1.get_legend(), None)
assert_equal(ax3.get_legend(), None)
def test_prop_dict_styles(self):
fig = plot_generic_loads(
[[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={
'styles': [{
'markersize': 12,
'marker': '^'
}, {
'markersize': 3,
'marker': 's'
}]
})
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
ax3 = fig.get_axes()[2]
line3 = ax3.get_lines()[0]
ax4 = fig.get_axes()[3]
line4 = ax4.get_lines()[0]
assert_equal(line1.get_marker(), '^')
assert_equal(line1.get_markersize(), 12)
assert_equal(line2.get_marker(), '^')
assert_equal(line2.get_markersize(), 12)
assert_equal(line3.get_marker(), 's')
assert_equal(line3.get_markersize(), 3)
assert_equal(line4.get_marker(), 's')
assert_equal(line4.get_markersize(), 3)
def test_prop_dict_time_axis_label(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={'time_axis_label': 'hello'})
ax1 = fig.get_axes()[0]
ax3 = fig.get_axes()[2]
assert_equal(ax1.get_xlabel(), '')
assert_equal(ax3.get_xlabel(), 'hello')
def test_prop_dict_depth_axis_label(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={'depth_axis_label': 'hello'})
ax2 = fig.get_axes()[1]
ax4 = fig.get_axes()[3]
assert_equal(ax2.get_xlabel(), '')
assert_equal(ax4.get_xlabel(), 'hello')
def test_propdict_legend_prop_title(self):
fig = plot_generic_loads([[self.triple1], [self.triple2]],
load_names=self.load_names,
prop_dict={'legend_prop': {
'title': 'abc'
}})
ax1 = fig.get_axes()[0]
ax3 = fig.get_axes()[2]
assert_equal(ax1.get_legend().get_title().get_text(), 'abc')
assert_equal(ax3.get_legend().get_title().get_text(), 'abc')
class test_plot_single_material_vs_depth(temp_cls):
"""tests for plot_single_material_vs_depth"""
# plot_single_material_vs_depth(z_x, xlabels, H = 1.0, RLzero=None,
# prop_dict={})
z1 = np.array([0., 0.5, 1.])
x1 = np.array([1., 1.5, 2.])
x2 = np.array([2., 2.5, 3.])
a = PolyLine(z1, x1)
b = PolyLine(z1, x2)
xlabels = ['a', 'b']
def test_defaults(self):
fig = plot_single_material_vs_depth((self.a, self.b), self.xlabels)
assert_equal(len(fig.get_axes()), 2)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
assert_allclose(line1.get_xydata()[0], np.array([1., 0.]))
assert_allclose(line1.get_xydata()[-1], np.array([2., 1]))
assert_allclose(line2.get_xydata()[0], np.array([2., 0.]))
assert_allclose(line2.get_xydata()[-1], np.array([3., 1]))
assert_equal(ax1.get_xlabel(), 'a')
assert_equal(ax2.get_xlabel(), 'b')
assert_equal(ax1.get_ylabel(), 'Depth, z')
assert_equal(ax2.get_ylabel(), '')
def test_prop_dict_ylabel(self):
fig = plot_single_material_vs_depth((self.a, self.b),
self.xlabels,
prop_dict={'ylabel': 'hello'})
ax1 = fig.get_axes()[0]
assert_equal(ax1.get_ylabel(), 'hello')
def test_H(self):
fig = plot_single_material_vs_depth((self.a, self.b),
self.xlabels,
H=2)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
assert_allclose(line1.get_xydata()[0], np.array([1., 0.]))
assert_allclose(line1.get_xydata()[-1], np.array([2., 2]))
assert_allclose(line2.get_xydata()[0], np.array([2., 0.]))
assert_allclose(line2.get_xydata()[-1], np.array([3., 2]))
def test_RLzero(self):
fig = plot_single_material_vs_depth((self.a, self.b),
self.xlabels,
H=2,
RLzero=1)
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
assert_allclose(line1.get_xydata()[0], np.array([1., 1]))
assert_allclose(line1.get_xydata()[-1], np.array([2., -1]))
assert_allclose(line2.get_xydata()[0], np.array([2., 1]))
assert_allclose(line2.get_xydata()[-1], np.array([3., -1]))
assert_equal(ax1.get_ylabel(), 'RL')
def test_propdict_fig_prop_figsize(self):
fig = plot_single_material_vs_depth(
(self.a, self.b),
self.xlabels,
prop_dict={'fig_prop': {
'figsize': (8, 9)
}})
assert_allclose(fig.get_size_inches(), (8, 9))
def test_prop_dict_styles(self):
fig = plot_single_material_vs_depth(
(self.a, self.b),
self.xlabels,
prop_dict={'styles': [{
'markersize': 12,
'marker': '^'
}]})
ax1 = fig.get_axes()[0]
line1 = ax1.get_lines()[0]
ax2 = fig.get_axes()[1]
line2 = ax2.get_lines()[0]
assert_equal(line1.get_marker(), '^')
assert_equal(line1.get_markersize(), 12)
assert_equal(line2.get_marker(), '^')
assert_equal(line2.get_markersize(), 12)
def test_SpecBeam_const_mat_deflection_shape_stationary_load():
"""static point load at beam centre, analytical vs numerical
properties from moving load case (but with k3=0) in Figure 7 of ding et al"""
# expected values are digitised from Ding et al 2012.
expected_50terms_x = np.array([
70.68, 71.275, 71.785, 72.189, 72.529, 72.848, 73.209, 73.677, 74.06,
74.378, 74.74, 75.122, 75.505, 75.781, 76.079, 76.312, 76.525, 76.716,
76.95, 77.12, 77.418, 77.715, 77.907, 78.204, 78.459, 78.778, 79.224,
79.522, 79.883, 80.181, 80.436, 80.606, 80.776, 81.01, 81.137, 81.307,
81.477, 81.626, 81.902, 82.179, 82.497, 82.774, 82.986, 83.263, 83.539,
84.028, 84.368, 84.623, 84.878, 85.239, 85.728, 86.153, 86.684, 87.386,
87.853, 88.363, 88.81, 89.341, 89.788
])
# this was generated with use_analytical=False
expected_50terms_displacement = np.array([
1.65264432e-04, 2.63028987e-04, 2.72285077e-04, 2.14305202e-04,
1.15107602e-04, -2.68417019e-05, -1.91982014e-04, -4.49035633e-04,
-6.36376878e-04, -7.29821557e-04, -8.36195689e-04, -7.26860083e-04,
-5.95623829e-04, -3.27010071e-04, 3.04509524e-05, 3.09942290e-04,
6.76583319e-04, 1.05404663e-03, 1.51648858e-03, 1.85245069e-03,
2.52742529e-03, 3.22449986e-03, 3.67513393e-03, 4.31941644e-03,
4.85502315e-03, 5.52505664e-03, 6.09193410e-03, 6.46152111e-03,
6.55576573e-03, 6.55576573e-03, 6.51361055e-03, 6.30277232e-03,
6.09193410e-03, 5.80172148e-03, 5.64421292e-03, 5.34652107e-03,
4.98944993e-03, 4.67648758e-03, 4.09677209e-03, 3.47328742e-03,
2.72692475e-03, 2.07679122e-03, 1.64296844e-03, 1.09554783e-03,
5.50103467e-04, -9.78991467e-05, -5.05740583e-04, -6.39483464e-04,
-7.26860083e-04, -8.42366564e-04, -6.98673331e-04, -5.42409810e-04,
-2.50752820e-04, 7.72841199e-05, 2.20332813e-04, 2.93525229e-04,
2.50445556e-04, 1.59399796e-04, 3.45668416e-05
])
#no longer correct:
expected_200terms_x = np.array([
70.064, 70.404, 70.723, 71.02, 71.36, 71.679, 71.955, 72.317, 72.614,
72.976, 73.273, 73.571, 73.911, 74.23, 74.527, 74.867, 75.165, 75.505,
75.866, 76.164, 76.483, 76.801, 77.12, 77.418, 77.779, 78.098, 78.438,
78.693, 79.033, 79.352, 79.671, 79.989, 80.308, 80.648, 80.967, 81.286,
81.583, 81.924, 82.264, 82.582, 82.88, 83.199, 83.539, 83.815, 84.134,
84.495, 84.793, 85.112, 85.43, 85.749, 86.047, 86.429, 86.727, 87.046,
87.365, 87.683, 87.981, 88.342, 88.64, 88.959, 89.277, 89.617, 89.958
])
expected_200terms_displacement = np.array([
-2.90800000e-05, -2.90800000e-05, -6.13900000e-05, -7.75400000e-05,
-7.75400000e-05, -1.09900000e-04, -1.26000000e-04, -1.26000000e-04,
-1.26000000e-04, -1.42200000e-04, -1.09900000e-04, -1.09900000e-04,
-9.37000000e-05, -2.90800000e-05, 3.55400000e-05, 1.64800000e-04,
2.94000000e-04, 4.55600000e-04, 7.30200000e-04, 1.02100000e-03,
1.40900000e-03, 1.86100000e-03, 2.37800000e-03, 2.99200000e-03,
3.68700000e-03, 4.43000000e-03, 5.22100000e-03, 5.96400000e-03,
6.67500000e-03, 7.27300000e-03, 7.58000000e-03, 7.48300000e-03,
6.95000000e-03, 6.06100000e-03, 4.99500000e-03, 3.88000000e-03,
2.83000000e-03, 1.94200000e-03, 1.16600000e-03, 5.20200000e-04,
5.17000000e-05, -2.55300000e-04, -4.33000000e-04, -5.46000000e-04,
-5.78400000e-04, -5.62200000e-04, -4.81400000e-04, -4.33000000e-04,
-3.19900000e-04, -2.39100000e-04, -1.74500000e-04, -1.26000000e-04,
-4.52300000e-05, -1.29200000e-05, 1.93900000e-05, 1.93900000e-05,
3.55400000e-05, 6.78500000e-05, 3.55400000e-05, 5.17000000e-05,
3.55400000e-05, 1.93900000e-05, 1.93900000e-05
])
t = np.linspace(0, 160 / 2 / 20, 400)
xvals = np.linspace(0, 160, 200)
#see Dingetal2012 Table 2 for material properties
pdict = OrderedDict(
E=6.998 * 1e9, #Pa
rho=2373, #kg/m3
L=160, #m
#v_norm=0.01165,
kf=5.41e-4,
#Fz_norm=1.013e-4,
mu_norm=39.263,
k1_norm=97.552,
#k3_norm=2.497e6,
nterms=50,
BC="SS",
nquad=20,
# moving_loads_x_norm=[[0]],
# moving_loads_Fz_norm=[[1.013e-4]],
# moving_loads_v_norm=[0.01165,],
# stationary_loads_x=None,
# stationary_loads_vs_t=None,
# stationary_loads_omega_phase=None,
stationary_loads_x_norm=[0.5],
stationary_loads_vs_t_norm=[
PolyLine([0, t[-1] / 160 * np.sqrt(6.998 * 1e9 / 2373.)],
[1.013e-4, 1.013e-4])
],
#self.L * np.sqrt(self.E / self.rho)
# stationary_loads_omega_phase_norm=None,
tvals=t,
xvals=xvals,
use_analytical=False,
implementation="vectorized",
# implementation="fortran",
)
a = SpecBeam(**pdict)
a.runme()
# a = SpecBeam(**pdict)
#
# a.calulate_qk(t=t)
yall = a.defl[:,
-1] #a.wofx(x=xvals, tslice=slice(-1, None, None), normalise_w=False)[:,0]
ycompare = np.interp(expected_50terms_x, xvals, yall)
print(repr(ycompare))
if DEBUG:
title = 'SpecBeam, stationary load, analytical vs numerical, deflection shape for point load applied at midpoint\n prop from moving load Figure 7 of Ding et al (2012)'
print(title)
print(' '.join(['{:>9s}'] * 4).format('t', 'expect', 'calc', 'diff'))
for i, j, k in zip(expected_50terms_x, expected_50terms_displacement,
ycompare):
print(' '.join(['{:9.4f}'] * 4).format(i, j, k, j - k))
print()
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot("111")
ax.set_xlabel("x, m")
ax.set_ylabel("w, m")
ax.set_xlim(70, 90)
ax.set_title(title)
ax.plot(expected_50terms_x,
expected_50terms_displacement,
label="expect n=50",
color='green',
marker='o',
ls='-')
ax.plot(expected_200terms_x,
expected_200terms_displacement,
label="expect n=200",
color='black',
marker=None,
ls='-')
ax.plot(xvals, yall, label="calc n=50")
ax.plot(expected_50terms_x,
ycompare,
label="calc, n=50 (compare)",
color='red',
marker='s',
ms=4,
ls=':')
ax.grid()
leg = ax.legend(loc='upper left')
leg.draggable()
plt.show()
assert_allclose(expected_50terms_displacement, ycompare, atol=2.4e-4)
def test_SpecBeam_const_mat_midpoint_defl_runme_analytical_200():
"""Test SpecBeam for constant mat: close to Ding et al Figure 8, displacement vs time at
beam midpoint (using the runme method) but with k3=0"""
start_time0 = time.time()
ftime = datetime.datetime.fromtimestamp(start_time0).strftime(
'%Y-%m-%d %H%M%S')
# expected values are digitised from Ding et al 2012.
expected_50terms_t = np.array([
3.511, 3.553, 3.576, 3.605, 3.621, 3.637, 3.651, 3.661, 3.676, 3.693,
3.701, 3.717, 3.733, 3.743, 3.761, 3.777, 3.79, 3.804, 3.822, 3.833,
3.848, 3.862, 3.877, 3.899, 3.919, 3.94, 3.956, 3.97, 3.978, 3.99,
4.001, 4.014, 4.025, 4.041, 4.052, 4.064, 4.076, 4.086, 4.094, 4.104,
4.112, 4.123, 4.134, 4.146, 4.159, 4.172, 4.18, 4.192, 4.212, 4.221,
4.234, 4.255, 4.273, 4.292, 4.324, 4.357, 4.373, 4.399, 4.418, 4.445
])
#old values for k3~=0
# expected_50terms_displacement = np.array(
# [ -1.30900000e-04, 8.85900000e-05, 2.63900000e-04,
# 3.30200000e-04, 3.30500000e-04, 2.87100000e-04,
# 2.00000000e-04, 9.09500000e-05, -8.36000000e-05,
# -3.01800000e-04, -4.32800000e-04, -6.07300000e-04,
# -7.59900000e-04, -8.90900000e-04, -9.99800000e-04,
# -1.02100000e-03, -9.99100000e-04, -8.67700000e-04,
# -5.61300000e-04, -2.11300000e-04, 2.04300000e-04,
# 7.29200000e-04, 1.42900000e-03, 2.41300000e-03,
# 3.46300000e-03, 4.29400000e-03, 5.08100000e-03,
# 5.62800000e-03, 5.86800000e-03, 6.19600000e-03,
# 6.39300000e-03, 6.52500000e-03, 6.59100000e-03,
# 6.48200000e-03, 6.32900000e-03, 6.02300000e-03,
# 5.69600000e-03, 5.45500000e-03, 5.06200000e-03,
# 4.75600000e-03, 4.40700000e-03, 3.90400000e-03,
# 3.35800000e-03, 2.87800000e-03, 2.35300000e-03,
# 1.82900000e-03, 1.52300000e-03, 9.98700000e-04,
# 5.18300000e-04, 2.12500000e-04, -4.95200000e-05,
# -2.67600000e-04, -3.76500000e-04, -3.76100000e-04,
# -2.00600000e-04, 1.87300000e-05, 1.06500000e-04,
# 1.94500000e-04, 1.94900000e-04, 1.30000000e-04])
expected_50terms_displacement = np.array([
-1.74400116e-05, 2.56595529e-04, 3.64963938e-04, 3.96163257e-04,
3.52239419e-04, 2.55908617e-04, 1.36296573e-04, 3.12193756e-05,
-1.48035583e-04, -3.73050108e-04, -4.80427236e-04, -6.84847774e-04,
-8.61705766e-04, -9.44268811e-04, -1.02333177e-03, -1.00753661e-03,
-9.18192599e-04, -7.32771117e-04, -3.72382730e-04, -7.79760498e-05,
4.06998900e-04, 9.37679667e-04, 1.57072235e-03, 2.58323632e-03,
3.52928135e-03, 4.47726082e-03, 5.12406706e-03, 5.61329890e-03,
5.84231170e-03, 6.13309619e-03, 6.32505191e-03, 6.46203546e-03,
6.49032925e-03, 6.39329339e-03, 6.23960924e-03, 5.99242067e-03,
5.67177967e-03, 5.35598822e-03, 5.07919623e-03, 4.69552191e-03,
4.37030991e-03, 3.90678952e-03, 3.43034780e-03, 2.90774639e-03,
2.35231514e-03, 1.82145021e-03, 1.51724930e-03, 1.09014092e-03,
4.86434682e-04, 2.61200867e-04, -5.02752907e-06, -2.99906282e-04,
-4.26188536e-04, -4.46910518e-04, -3.09328219e-04, -6.53887601e-05,
4.77786782e-05, 1.84483472e-04, 2.30390682e-04, 2.18090273e-04
])
expected_200terms_t = np.array([
3.503, 3.519, 3.539, 3.556, 3.576, 3.595, 3.613, 3.632, 3.651, 3.667,
3.69, 3.708, 3.727, 3.746, 3.766, 3.782, 3.801, 3.822, 3.84, 3.856,
3.878, 3.896, 3.915, 3.933, 3.951, 3.97, 3.99, 4.009, 4.027, 4.046,
4.067, 4.085, 4.102, 4.122, 4.141, 4.159, 4.178, 4.197, 4.217, 4.234,
4.252, 4.273, 4.291, 4.31, 4.329, 4.347, 4.368, 4.386, 4.405, 4.423,
4.442, 4.46, 4.479, 4.495
])
expected_200terms_displacement = np.array([
7.04000000e-08, 2.22800000e-05, 2.27000000e-05, 1.23200000e-06,
2.35100000e-05, 2.39300000e-05, 2.46400000e-06, -1.89700000e-05,
-6.22700000e-05, -1.27500000e-04, -1.70700000e-04, -2.57800000e-04,
-3.44800000e-04, -4.53600000e-04, -5.40600000e-04, -5.84000000e-04,
-5.61700000e-04, -4.73800000e-04, -2.54900000e-04, 1.17100000e-04,
6.85900000e-04, 1.51700000e-03, 2.50100000e-03, 3.70300000e-03,
5.01500000e-03, 6.26200000e-03, 7.20200000e-03, 7.61800000e-03,
7.39900000e-03, 6.74400000e-03, 5.91400000e-03, 5.01800000e-03,
4.10100000e-03, 3.22700000e-03, 2.50600000e-03, 1.85000000e-03,
1.32600000e-03, 9.11400000e-04, 5.84000000e-04, 3.00200000e-04,
1.47600000e-04, 3.87500000e-05, -4.82900000e-05, -1.13400000e-04,
-1.13000000e-04, -1.34500000e-04, -1.34000000e-04, -1.33600000e-04,
-1.11400000e-04, -6.72600000e-05, -6.68400000e-05, -6.64500000e-05,
-4.41700000e-05, -4.38200000e-05
])
t = np.linspace(0, 4.5, 400)
#see Dingetal2012 Table 2 for material properties
pdict = OrderedDict(
E=6.998 * 1e9, #Pa
rho=2373, #kg/m3
L=160, #m
#v_norm=0.01165,
kf=5.41e-4,
#Fz_norm=1.013e-4,
mu_norm=39.263,
k1_norm=97.552,
# k3_norm=2.497e6,
nterms=200,
BC="SS",
nquad=20,
k1bar=PolyLine([0, 0.5], [0.5, 1], [1, 1], [1, 1]),
# k1bar=PolyLine([0,0.5],[0.5,1],[2,1],[2,1]),
moving_loads_x_norm=[[0]],
moving_loads_Fz_norm=[[1.013e-4]],
moving_loads_v_norm=[
0.01165,
],
tvals=t,
# tvals=np.array([4.0]),
xvals_norm=np.array([0.5]),
use_analytical=True,
implementation="vectorized",
# implementation="fortran",
force_calc=True,
)
a = SpecBeam(**pdict)
a.runme()
# a.calulate_qk(t=t)
#
# yall = a.wofx(x_norm=0.5, normalise_w=False)
ycompare = np.interp(expected_200terms_t, t, a.defl[0, :])
# print(repr(ycompare))
print("n=", pdict['nterms'])
end_time0 = time.time()
elapsed_time = (end_time0 - start_time0)
print("Total run time={}".format(str(timedelta(seconds=elapsed_time))))
if DEBUG:
title = 'SpecBeam, const mat prop vs Ding et al (2012) \nFigure 8 Displacement at Midpoint of beam but with k3=0'
print(title)
print(' '.join(['{:>9s}'] * 4).format('t', 'expect', 'calc', 'diff'))
for i, j, k in zip(expected_200terms_t, expected_200terms_displacement,
ycompare):
print(' '.join(['{:9.4f}'] * 4).format(i, j, k, j - k))
print()
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot("111")
ax.set_xlabel("time, s")
ax.set_ylabel("w, m")
ax.set_xlim(3.5, 4.5)
ax.set_title(title)
ax.plot(expected_50terms_t,
expected_50terms_displacement,
label="expect n=50",
color='green',
marker='o',
ls='-')
ax.plot(expected_200terms_t,
expected_200terms_displacement,
label="expect n=200",
color='black',
marker=None,
ls='-')
ax.plot(t, a.defl, label="calc n=200")
ax.plot(expected_200terms_t,
ycompare,
label="calc, n=200 (compare)",
color='red',
marker='s',
ms=4,
ls=':')
leg = ax.legend(loc='upper left')
leg.draggable()
plt.show()
assert_allclose(expected_200terms_displacement, ycompare, atol=2.4e-4)
def test_SpecBeam_const_mat_midpoint_defl():
"""Test SpecBeam for constant mat: Figure 8, displacement vs time at beam midpoint"""
# expected values are digitised from Ding et al 2012.
expected_50terms_t = np.array([
3.511, 3.553, 3.576, 3.605, 3.621, 3.637, 3.651, 3.661, 3.676, 3.693,
3.701, 3.717, 3.733, 3.743, 3.761, 3.777, 3.79, 3.804, 3.822, 3.833,
3.848, 3.862, 3.877, 3.899, 3.919, 3.94, 3.956, 3.97, 3.978, 3.99,
4.001, 4.014, 4.025, 4.041, 4.052, 4.064, 4.076, 4.086, 4.094, 4.104,
4.112, 4.123, 4.134, 4.146, 4.159, 4.172, 4.18, 4.192, 4.212, 4.221,
4.234, 4.255, 4.273, 4.292, 4.324, 4.357, 4.373, 4.399, 4.418, 4.445
])
expected_50terms_displacement = np.array([
-1.30900000e-04, 8.85900000e-05, 2.63900000e-04, 3.30200000e-04,
3.30500000e-04, 2.87100000e-04, 2.00000000e-04, 9.09500000e-05,
-8.36000000e-05, -3.01800000e-04, -4.32800000e-04, -6.07300000e-04,
-7.59900000e-04, -8.90900000e-04, -9.99800000e-04, -1.02100000e-03,
-9.99100000e-04, -8.67700000e-04, -5.61300000e-04, -2.11300000e-04,
2.04300000e-04, 7.29200000e-04, 1.42900000e-03, 2.41300000e-03,
3.46300000e-03, 4.29400000e-03, 5.08100000e-03, 5.62800000e-03,
5.86800000e-03, 6.19600000e-03, 6.39300000e-03, 6.52500000e-03,
6.59100000e-03, 6.48200000e-03, 6.32900000e-03, 6.02300000e-03,
5.69600000e-03, 5.45500000e-03, 5.06200000e-03, 4.75600000e-03,
4.40700000e-03, 3.90400000e-03, 3.35800000e-03, 2.87800000e-03,
2.35300000e-03, 1.82900000e-03, 1.52300000e-03, 9.98700000e-04,
5.18300000e-04, 2.12500000e-04, -4.95200000e-05, -2.67600000e-04,
-3.76500000e-04, -3.76100000e-04, -2.00600000e-04, 1.87300000e-05,
1.06500000e-04, 1.94500000e-04, 1.94900000e-04, 1.30000000e-04
])
expected_200terms_t = np.array([
3.503, 3.519, 3.539, 3.556, 3.576, 3.595, 3.613, 3.632, 3.651, 3.667,
3.69, 3.708, 3.727, 3.746, 3.766, 3.782, 3.801, 3.822, 3.84, 3.856,
3.878, 3.896, 3.915, 3.933, 3.951, 3.97, 3.99, 4.009, 4.027, 4.046,
4.067, 4.085, 4.102, 4.122, 4.141, 4.159, 4.178, 4.197, 4.217, 4.234,
4.252, 4.273, 4.291, 4.31, 4.329, 4.347, 4.368, 4.386, 4.405, 4.423,
4.442, 4.46, 4.479, 4.495
])
expected_200terms_displacement = np.array([
7.04000000e-08, 2.22800000e-05, 2.27000000e-05, 1.23200000e-06,
2.35100000e-05, 2.39300000e-05, 2.46400000e-06, -1.89700000e-05,
-6.22700000e-05, -1.27500000e-04, -1.70700000e-04, -2.57800000e-04,
-3.44800000e-04, -4.53600000e-04, -5.40600000e-04, -5.84000000e-04,
-5.61700000e-04, -4.73800000e-04, -2.54900000e-04, 1.17100000e-04,
6.85900000e-04, 1.51700000e-03, 2.50100000e-03, 3.70300000e-03,
5.01500000e-03, 6.26200000e-03, 7.20200000e-03, 7.61800000e-03,
7.39900000e-03, 6.74400000e-03, 5.91400000e-03, 5.01800000e-03,
4.10100000e-03, 3.22700000e-03, 2.50600000e-03, 1.85000000e-03,
1.32600000e-03, 9.11400000e-04, 5.84000000e-04, 3.00200000e-04,
1.47600000e-04, 3.87500000e-05, -4.82900000e-05, -1.13400000e-04,
-1.13000000e-04, -1.34500000e-04, -1.34000000e-04, -1.33600000e-04,
-1.11400000e-04, -6.72600000e-05, -6.68400000e-05, -6.64500000e-05,
-4.41700000e-05, -4.38200000e-05
])
t = np.linspace(0, 4.5, 400)
#see Dingetal2012 Table 2 for material properties
pdict = OrderedDict(
E=6.998 * 1e9, #Pa
rho=2373, #kg/m3
L=160, #m
#v_norm=0.01165,
kf=5.41e-4,
#Fz_norm=1.013e-4,
mu_norm=39.263,
k1_norm=97.552,
k3_norm=2.497e6,
nterms=50,
BC="SS",
nquad=20,
k1bar=PolyLine([0, 0.5], [0.5, 1], [1, 1], [1, 1]),
moving_loads_x_norm=[[0]],
moving_loads_Fz_norm=[[1.013e-4]],
moving_loads_v_norm=[
0.01165,
],
tvals=t,
xvals_norm=0.5)
a = SpecBeam(**pdict)
a.calulate_qk(t=t)
yall = a.wofx(x_norm=0.5, normalise_w=False)
ycompare = np.interp(expected_50terms_t, t, yall)
if DEBUG:
title = 'SpecBeam, const mat prop vs Ding et al (2012) \nFigure 8 Displacement at Midpoint of beam'
print(title)
print(' '.join(['{:>9s}'] * 4).format('t', 'expect', 'calc', 'diff'))
for i, j, k in zip(expected_50terms_t, expected_50terms_displacement,
ycompare):
print(' '.join(['{:9.4f}'] * 4).format(i, j, k, j - k))
print()
fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot("111")
ax.set_xlabel("time, s")
ax.set_ylabel("w, m")
ax.set_xlim(3.5, 4.5)
ax.set_title(title)
ax.plot(expected_50terms_t,
expected_50terms_displacement,
label="expect n=50",
color='green',
marker='o',
ls='-')
ax.plot(expected_200terms_t,
expected_200terms_displacement,
label="expect n=200",
color='black',
marker=None,
ls='-')
ax.plot(t, yall, label="calc n=50")
ax.plot(expected_50terms_t,
ycompare,
label="calc, n=50 (compare)",
color='red',
marker='s',
ms=4,
ls=':')
leg = ax.legend(loc='upper left')
leg.draggable()
plt.show()
assert_allclose(expected_50terms_displacement, ycompare, atol=2.4e-4)
x = np.zeros(len(alphas))
y = np.zeros(len(alphas))
for j, alpha in enumerate(alphas):
v_crit = np.sqrt(2 / pdict["rho"] / pdict["A"] *
np.sqrt(pdict["k1"] * pdict["E"] * pdict["I"]))
v_raw = v_crit * alpha
c_crit = np.sqrt(4 * pdict["rho"] * pdict["A"] * pdict["k1"])
c_raw = c_crit * beta
tmax = pdict["L"] / v_raw
if end_damp == 0:
pdict["mu"] = c_raw
pdict["mubar"] = PolyLine([0, 1], [1, 1])
else:
if beta == 0:
pdict["mu"] = c_crit
pdict["mubar"] = PolyLine(
[0, end_damp, end_damp, 1 - end_damp, 1 - end_damp, 1],
[1, 1, 0, 0, 1, 1])
else:
pdict["mu"] = c_raw
pdict["mubar"] = PolyLine(
[0, end_damp, end_damp, 1 - end_damp, 1 - end_damp, 1], [
c_crit / c_raw, c_crit / c_raw, 1, 1, c_crit / c_raw,
c_crit / c_raw
])
pdict["tvals"] = np.linspace(tmax * xeval[0], tmax * xeval[1], nt)
class test_dim1sin_integrate_af(unittest.TestCase):
"""tests for dim1sin_integrate_af
see geotecha.speccon.test.speccon1d_test_data_gen.py
for test case data generation
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
"""
#dim1sin_integrate_af(m, z, tvals, v_E_Igamv_the, drn, a, top_vs_time = None, bot_vs_time=None, top_omega_phase=None, bot_omega_phase=None)
# artificallially create 3 eigs, 2 zs and 2 ts
outz = np.array([[0.2, 0.4], [0.4, 0.6]])
z1 = outz[:, 0]
z2 = outz[:, 1]
m = np.array([1.0,2.0, 3.0])
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
a = PolyLine([0, 1], [1, 2])# y = 1 + z
g = np.array([1.0,2.0])# this is interpolated from top_vs_time at t = 1, 3
def test_no_BC(self):
#expected is from:
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
a = self.a),
np.array([[ 0.42612566, 0.42612566],
[ 0.69057191, 0.69057191]]))
def test_top_vs_time_drn_0(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
a=self.a,
top_vs_time = [self.top_vs_time]),
np.array([[ 0.60745899, 0.78879232],
[ 0.83990524, 0.98923858]]))
#
def test_top_vs_time_drn_1(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
a = self.a,
top_vs_time = [self.top_vs_time]),
np.array([[ 0.68612566, 0.94612566],
[ 0.99057191, 1.29057191]]))
#
def test_bot_vs_time_drn_0(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
a=self.a,
bot_vs_time = [self.bot_vs_time]),
np.array([[ 0.50479232, 0.58345899],
[ 0.84123858, 0.99190524]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
a=self.a,
top_vs_time = [self.top_vs_time],
bot_vs_time = [self.bot_vs_time]),
np.array([[ 0.76479232, 1.10345899],
[ 1.14123858, 1.59190524]]))
def test_top_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
a=self.a,
top_vs_time = [self.top_vs_time],
top_omega_phase=[self.omega_phase]),
np.array([[ 0.24660702, 0.52900048],
[ 0.54273303, 0.77529235]]))
def test_bot_vs_time_drn_0_omega_phase(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
a=self.a,
bot_vs_time = [self.bot_vs_time],
bot_omega_phase=[self.omega_phase]),
np.array([[ 0.34824625, 0.47075517],
[ 0.54141304, 0.77604878]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
assert_allclose(dim1sin_integrate_af(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
a=self.a,
top_vs_time = [self.top_vs_time, self.top_vs_time],
bot_vs_time = [self.bot_vs_time, self.bot_vs_time]),
np.array([[ 1.10345899, 1.78079232],
[ 1.59190524, 2.49323858]]))
def test_check_attributes_that_should_have_same_x_limits(self):
a = InputFileLoaderCheckerSaver()
a.a = PolyLine([0, 1], [2, 5])
a.c = PolyLine([0, 7], [5, 6])
a._attributes_that_should_have_same_x_limits = ['a c'.split()]
assert_raises(ValueError, a.check_input_attributes)
class test_dim1sin_f(unittest.TestCase):
"""tests for dim1sin_f
These are not exhasutive tests.
- I've used top_vs_time=bot_vs_time, top_omega_phase=bot_omega_phase,
so I can't tell if the code uses each correctly of if I've typed
bot_vs_time instead of top_vs_time
"""
#dim1sin_f(m, outz, tvals, v_E_Igamv_the, drn, top_vs_time, bot_vs_time, top_omega_phase, bot_omega_phase)
# artificallially create 3 eigs, 2 zs and 2 ts
outz = np.array([0.2, 0.4])
m = np.array([1.0,2.0, 3.0]) #1x2
v_E_Igamv_the = np.ones((3,2), dtype=float)
tvals = np.array([1.0, 3])
top_vs_time = PolyLine([0,2,4],[0,2,2])
bot_vs_time = PolyLine([0,2,4],[0,2,2])
omega_phase = (1,2)
def test_no_BC(self):
#expected is from:
#np.dot(np.sin(outz[:,np.newaxis] * m[np.newaxis,:]), v_E_Igamv_the)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0),
np.array([[ 1.15273015, 1.15273015],
[ 2.03881352, 2.03881352]]))
def test_top_vs_time_drn_0(self):
#expected is from:
#test no_bc + top_vs time interplolated at tvals and depth z (mag_vs_depth reduces to zero at bottom)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
top_vs_time = [self.top_vs_time]),
np.array([[ 1*0.8+1.15273015, 2*0.8+1.15273015],
[ 1*0.6+2.03881352, 2*0.6+2.03881352]]))
def test_top_vs_time_drn_1(self):
#expected is from:
#test no_bc + top_vs time interplolated at tvals and depth z (mag vs depth is uniform top to bottom)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
top_vs_time = [self.top_vs_time]),
np.array([[ 1+1.15273015, 2+1.15273015],
[ 1+2.03881352, 2+2.03881352]]))
def test_bot_vs_time_drn_0(self):
#expected is from:
#test no_bc + bot_vs time interplolated at tvals and depth z (mag_vs_depth reduces to zero at top)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
bot_vs_time = [self.bot_vs_time]),
np.array([[ 1*0.2+1.15273015, 2*0.2+1.15273015],
[ 1*0.4+2.03881352, 2*0.4+2.03881352]]))
def test_bot_vs_time_top_vs_time_drn_1(self):
#expected is from:
#test no_bc + top_vs_time and bot_vs time interplolated at tvals and depth z (mag_vs_depth is uniform from top plus reduces to zero at top)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
top_vs_time = [self.top_vs_time],
bot_vs_time = [self.bot_vs_time]),
np.array([[ 1+1*0.2+1.15273015, 2+2*0.2+1.15273015],
[ 1+1*0.4+2.03881352, 2+2*0.4+2.03881352]]))
def test_top_vs_time_drn_0_omega_phase(self):
#expected is from:
#test no_bc + cos(omega*t+phase) multiplied top_vs time interplolated at tvals and depth z (mag_vs_depth reduces to zero at bottom)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
top_vs_time = [self.top_vs_time],
top_omega_phase=[self.omega_phase]),
np.array([[ 1*0.8*np.cos(1*1+2)+1.15273015, 2*0.8*np.cos(1*3+2)+1.15273015],
[ 1*0.6*np.cos(1*1+2)+2.03881352, 2*0.6*np.cos(1*3+2)+2.03881352]]))
def test_bot_vs_time_drn_0_omega_phase(self):
#expected is from:
#test no_bc + bot_vs time interplolated at tvals and depth z (mag_vs_depth reduces to zero at top)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=0,
bot_vs_time = [self.bot_vs_time],
bot_omega_phase=[self.omega_phase]),
np.array([[ 1*0.2*np.cos(1*1+2)+1.15273015, 2*0.2*np.cos(1*3+2)+1.15273015],
[ 1*0.4*np.cos(1*1+2)+2.03881352, 2*0.4*np.cos(1*3+2)+2.03881352]]))
def test_bot_vs_time_top_vs_time_drn_1_double_loads(self):
#expected is from:
#test no_bc + top_vs_time and bot_vs time interplolated at tvals and depth z (mag_vs_depth is uniform from top plus reduces to zero at top)
assert_allclose(dim1sin_f(self.m,
self.outz,
self.tvals,
self.v_E_Igamv_the,
drn=1,
top_vs_time = [self.top_vs_time, self.top_vs_time],
bot_vs_time = [self.bot_vs_time, self.bot_vs_time]),
np.array([[ 2+2*0.2+1.15273015, 4+4*0.2+1.15273015],
[ 2+2*0.4+2.03881352, 4+4*0.4+2.03881352]]))
