class Test_JMI_DAE:
"""
This class tests pyjmi.simulation.assimulo.JMIDAE
"""
@classmethod
def setUpClass(cls):
"""
Compile the test model.
"""
#DAE test model
fpath_DAE = os.path.join(get_files_path(), 'Modelica',
'Pendulum_pack_no_opt.mo')
cpath_DAE = 'Pendulum_pack.Pendulum'
fname_DISC = compile_jmu(cpath_DAE, fpath_DAE)
fpath_DISC = os.path.join(get_files_path(), 'Modelica',
'IfExpExamples.mo')
cpath_DISC = 'IfExpExamples.IfExpExample2'
fname_DISC = compile_jmu(cpath_DISC, fpath_DISC)
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput_Nominal'
fname = compile_jmu(cpath,
fpath,
compiler_options={"enable_variable_scaling": True})
def setUp(self):
"""Load the test model."""
package_DAE = 'Pendulum_pack_Pendulum.jmu'
package_DISC = 'IfExpExamples_IfExpExample2.jmu'
package_INPUT = 'DoubleInput_Nominal.jmu'
# Load the dynamic library and XML data
self.m_DAE = JMUModel(package_DAE)
self.m_DISC = JMUModel(package_DISC)
self.m_INPUT = JMUModel(package_INPUT)
# Creates the solvers
self.DAE = JMIDAE(self.m_DAE)
self.DISC = JMIDAE(self.m_DISC)
@testattr(stddist=True)
def test_result_name_file(self):
"""
Tests user naming of result file (JMIDAE).
"""
res = self.m_DAE.simulate()
#Default name
assert res.result_file == "Pendulum_pack_Pendulum_result.txt"
assert os.path.exists(res.result_file)
res = self.m_DAE.simulate(
options={
"result_file_name": "Pendulum_pack_Pendulum_result_test.txt"
})
#User defined name
assert res.result_file == "Pendulum_pack_Pendulum_result_test.txt"
assert os.path.exists(res.result_file)
@testattr(stddist=True)
def test_eps(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.get/set_eps
"""
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, 'Test')
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, -1)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, 1)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, -1.0)
self.DAE.eps = 1.0
assert self.DAE.eps == 1.0
self.DAE.eps = 10.0
assert self.DAE.eps == 10.0
@testattr(stddist=True)
def test_max_eIteration(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.get/set_max_eIteration
"""
nose.tools.assert_raises(JMIModel_Exception,
self.DAE._set_max_eIteration, 'Test')
nose.tools.assert_raises(JMIModel_Exception,
self.DAE._set_max_eIteration, -1)
nose.tools.assert_raises(JMIModel_Exception,
self.DAE._set_max_eIteration, 1.0)
nose.tools.assert_raises(JMIModel_Exception,
self.DAE._set_max_eIteration, -1.0)
self.DAE.max_eIter = 1
assert self.DAE.max_eIter == 1
self.DAE.max_eIter = 10
assert self.DAE.max_eIter == 10
@testattr(stddist=True)
def test_check_eIter(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.check_eIter
"""
self.DAE.eps = 1e-4
b_mode = [1, -1, 0]
a_mode = [-1, 1, 1]
[eIter, iter] = self.DAE.check_eIter(b_mode, a_mode)
assert iter == True
assert eIter[0] == -1
assert eIter[1] == 1
assert eIter[2] == 1
b_mode = [2, 5, 1]
a_mode = [0, 2, 2]
[eIter, iter] = self.DAE.check_eIter(b_mode, a_mode)
assert iter == False
assert eIter[0] == 0
assert eIter[1] == 0
assert eIter[2] == 0
@testattr(stddist=True)
def test_scaled_input(self):
"""
Tests that simulation of scaled input works.
"""
t = N.linspace(0., 10., 100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t, u1, u2)))
res = self.m_INPUT.simulate(final_time=10,
input=(['u1', 'u2'], u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
@testattr(stddist=True)
def test_event_switch(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.event_switch
"""
solver = lambda x: 1
solver.verbosity = 1
solver.LOUD = 2
solver.sw = [False, False, True]
event_info = [1, 0, -1]
self.DAE.event_switch(solver, event_info)
assert solver.sw[0] == True
assert solver.sw[1] == False
assert solver.sw[2] == False
@testattr(stddist=True)
def test_f(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.f
"""
test_x = N.array([1., 1., 1., 1.])
test_dx = N.array([2., 2., 2., 2.])
test_t = 2
temp_f = self.DAE.res(test_t, test_x, test_dx)
assert temp_f[0] == -1.0
assert temp_f[2] == -1.0
assert temp_f[3] == -2.0
nose.tools.assert_almost_equal(temp_f[1], -1.158529, 5)
@testattr(stddist=True)
def test_g(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.g
"""
pass #DEPRECATED
#temp_g = self.DISC.g(2.,[1.,2.],[2.,0],[0,0])
#nose.tools.assert_almost_equal(temp_g[0], -0.429203, 5)
#nose.tools.assert_almost_equal(temp_g[1], 1.141592, 5)
@testattr(stddist=True)
def test_g_adjust(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.g
"""
pass #DEPRECATED
"""
self.DISC.eps = 2.0
temp_g_adjust = self.DISC.g_adjust(2.,[1.,2.],[2.,0],[0,0])
nose.tools.assert_almost_equal(temp_g_adjust[0], -2.429203, 5)
nose.tools.assert_almost_equal(temp_g_adjust[1], -0.858407, 5)
temp_g_adjust = self.DISC.g_adjust(2.,[1.,2.],[2.,0],[0,1])
nose.tools.assert_almost_equal(temp_g_adjust[0], -2.429203, 5)
nose.tools.assert_almost_equal(temp_g_adjust[1], 3.141592, 5)
"""
@testattr(stddist=True)
def test_init(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.__init__
"""
assert self.m_DAE == self.DAE._model
assert self.DAE.max_eIter == 50
assert self.DAE.eps == 1e-9
assert self.DAE.jac == self.DAE.j
temp_y0 = N.append(self.m_DAE.real_x.copy(), self.m_DAE.real_w.copy())
temp_yd0 = N.append(self.m_DAE.real_dx.copy(),
[0] * len(self.m_DAE.real_w))
temp_algvar = [1.0] * len(self.m_DAE.real_x) + [0.0] * len(
self.m_DAE.real_w)
for i in range(len(temp_y0)):
assert temp_y0[i] == self.DAE.y0[i]
assert temp_yd0[i] == self.DAE.yd0[i]
assert temp_algvar[i] == self.DAE.algvar[i]
#Test discontiniuous system
assert self.DISC._g_nbr == 2
assert self.DISC.state_events == self.DISC.g_adjust
@testattr(stddist=True)
def test_reset(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.reset
"""
self.DAE.t0 = 10.0
self.DAE._model.real_x = N.array([2., 2., 2., 2.])
self.DAE._model.real_dx = N.array([2., 2., 2., 2.])
self.DAE.reset()
assert self.DAE._model.t == 10.0
assert self.DAE._model.real_x[0] != 2.0
assert self.DAE._model.real_x[1] != 2.0
assert self.DAE._model.real_x[2] != 2.0
assert self.DAE._model.real_dx[0] != 2.0
assert self.DAE._model.real_dx[1] != 2.0
assert self.DAE._model.real_dx[2] != 2.0
assert self.DAE.y0[0] == 0.1
@testattr(stddist=True)
def test_event_iteration(self):
"""
This tests JMUs with event iteration (JModelica.org).
"""
#DEPRECATED!
pass
"""
jmu_name = compile_jmu('EventIter.EventMiddleIter', os.path.join(path_to_mos,'EventIter.mo'))
model = JMUModel(jmu_name)
sim_res = model.simulate(final_time=10)
x = sim_res['x']
y = sim_res['y']
z = sim_res['z']
nose.tools.assert_almost_equal(x[0], 2.00000, 4)
nose.tools.assert_almost_equal(x[-1], 10.000000, 4)
nose.tools.assert_almost_equal(y[-1], 3.0000000, 4)
nose.tools.assert_almost_equal(z[-1], 2.0000000, 4)
jmu_name = compile_jmu('EventIter.EventStartIter', os.path.join(path_to_mos,'EventIter.mo'))
model = JMUModel(jmu_name)
sim_res = model.simulate(final_time=10)
x = sim_res['x']
y = sim_res['y']
z = sim_res['z']
nose.tools.assert_almost_equal(x[0], 1.00000, 4)
nose.tools.assert_almost_equal(y[0], -1.00000, 4)
nose.tools.assert_almost_equal(z[0], 1.00000, 4)
nose.tools.assert_almost_equal(x[-1], -2.000000, 4)
nose.tools.assert_almost_equal(y[-1], -1.0000000, 4)
nose.tools.assert_almost_equal(z[-1], 4.0000000, 4)
"""
@testattr(stddist=True)
def test_j(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.j
"""
test_x = N.array([1., 1., 1., 1.])
test_dx = N.array([2., 2., 2., 2.])
test_t = 2
temp_j = self.DAE.j(0.1, test_t, test_x, test_dx)
#print temp_j
assert temp_j[0, 0] == -0.1
assert temp_j[0, 1] == 1.0
assert temp_j[1, 1] == -0.1
nose.tools.assert_almost_equal(temp_j[1, 0], 0.5403023, 5)
@testattr(stddist=True)
def test_handle_event(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.handle_event
"""
solver = lambda x: 1
solver.verbosity = 1
solver.NORMAL = solver.LOUD = 2
solver.t_sol = [[1.0]]
solver.y_sol = [[1., 1.]]
solver.yd_sol = [[1., 1.]]
solver.t = N.array(1.0)
solver.y = N.array([1., 1.])
solver.yd = N.array([1., 1.])
solver.sw = [False, True]
self.DISC.event_switch = lambda x, y: 1
self.DISC.init_mode = lambda x: 1
self.DISC.check_eIter = lambda x, y: [True, False]
self.DISC.handle_event(solver, [1, 1])
self.DISC.check_eIter = lambda x, y: [True, True]
self.DISC.handle_event(solver, [1, 1])
@testattr(stddist=True)
def test_init_mode(self):
"""
Tests pyjmi.simulation.assimulo.init_mode
"""
solver = lambda x: 1
solver.sw = [True, True]
solver.make_consistent = lambda x: 1
self.DISC.init_mode(solver)
assert self.DISC._model.sw[0] == 1
assert self.DISC._model.sw[1] == 1
@testattr(stddist=True)
def test_initiate(self):
"""
Tests pyjmi.simulation.assimulo.initiate
"""
#self.DAE.init_mode = lambda x:1
#self.DAE.initiate('Test')
#self.DISC.handle_event = lambda x,y:1
#solver = lambda x:1
#solver.switches = [False, False]
#self.DISC.initiate(solver)
#assert solver.switches[0] == True
#assert solver.switches[1] == True
pass
"""
@testattr(stddist = True)
def test_scaled_input(self):
#This tests simulation with scaled input.
fpath = os.path.join(get_files_path(), 'Modelica', 'VDP.mop')
cpath = 'VDP_pack.VDP_scaled_input'
# compile VDP
jmu_name = compile_jmu(cpath, fpath,
compiler_options={'enable_variable_scaling':True})
# Load the dynamic library and XML data
vdp = JMUModel(jmu_name)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)/10.0
u_traj = N.transpose(N.vstack((t,u1)))
res_scaled = vdp.simulate(final_time=10, input=(['u'],u_traj))
# compile VDP
jmu_name = compile_jmu(cpath, fpath,
compiler_options={'enable_variable_scaling':False})
# Load the dynamic library and XML data
vdp = JMUModel(jmu_name)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)
u_traj = N.transpose(N.vstack((t,u1)))
res = vdp.simulate(final_time=10, input=(['u'],u_traj))
nose.tools.assert_almost_equal(res["u"][0], res_scaled["u"][0], 3)
nose.tools.assert_almost_equal(res["u"][-1], res_scaled["u"][-1], 3)
"""
@testattr(stddist=True)
def test_order_input(self):
"""
This tests that the inputs are sorted in an correct value reference order
when being written to file.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'OrderInputs.mop')
cpath = 'OptimInputs'
unames = ['u1', 'u_e2', 'u_h3', 'u_c4', 'u_p5']
n = len(unames)
uvalues = [1., 2., 3., 4., 5.]
data = N.array([[0., 1., 2., 3., 4., 5.], [1., 1., 2., 3., 4., 5.],
[2., 1., 2., 3., 4., 5.]])
inputtuple = (unames, data)
jmu_name = compile_jmu(cpath, fpath)
model = JMUModel(jmu_name)
res = model.simulate(0, 2, input=inputtuple)
nose.tools.assert_almost_equal(res["u1"][-1], 1.000000000, 3)
nose.tools.assert_almost_equal(res["u_e2"][-1], 2.00000, 3)
nose.tools.assert_almost_equal(res["u_h3"][-1], 3.00000, 3)
nose.tools.assert_almost_equal(res["u_c4"][-1], 4.000000, 3)
nose.tools.assert_almost_equal(res["u_p5"][-1], 5.000000, 3)
nose.tools.assert_almost_equal(res["T.u1"][-1], 1.000000000, 3)
nose.tools.assert_almost_equal(res["T.u_e2"][-1], 2.00000, 3)
nose.tools.assert_almost_equal(res["T.u_h3"][-1], 3.00000, 3)
nose.tools.assert_almost_equal(res["T.u_c4"][-1], 4.000000, 3)
nose.tools.assert_almost_equal(res["T.u_p5"][-1], 5.000000, 3)
@testattr(stddist=True)
def test_double_input(self):
"""
This tests double input.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput'
# compile VDP
fname = compile_jmu(
cpath, fpath, compiler_options={'state_start_values_fixed': True})
# Load the dynamic library and XML data
dInput = JMUModel(fname)
t = N.linspace(0., 10., 100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t, u1, u2)))
res = dInput.simulate(final_time=10, input=(['u1', 'u2'], u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
#TEST REVERSE ORDER OF INPUT
# Load the dynamic library and XML data
dInput = JMUModel(fname)
t = N.linspace(0., 10., 100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t, u2, u1)))
res = dInput.simulate(final_time=10, input=(['u2', 'u1'], u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
@testattr(stddist=True)
def test_double_input_with_function(self):
"""
This tests double input with function.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput'
# compile VDP
fname = compile_jmu(
cpath, fpath, compiler_options={'state_start_values_fixed': True})
# Load the dynamic library and XML data
dInput = JMUModel(fname)
def func(t):
return N.array([N.cos(t), N.sin(t)])
res = dInput.simulate(final_time=10, input=(['u1', 'u2'], func))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
#TEST REVERSE ORDER OF INPUT
# Load the dynamic library and XML data
dInput = JMUModel(fname)
def func(t):
return [N.sin(t), N.cos(t)]
res = dInput.simulate(final_time=10, input=(['u2', 'u1'], func))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
class Test_JMI_DAE:
"""
This class tests pyjmi.simulation.assimulo.JMIDAE
"""
@classmethod
def setUpClass(cls):
"""
Compile the test model.
"""
#DAE test model
fpath_DAE = os.path.join(get_files_path(), 'Modelica',
'Pendulum_pack_no_opt.mo')
cpath_DAE = 'Pendulum_pack.Pendulum'
fname_DISC = compile_jmu(cpath_DAE, fpath_DAE)
fpath_DISC = os.path.join(get_files_path(), 'Modelica',
'IfExpExamples.mo')
cpath_DISC = 'IfExpExamples.IfExpExample2'
fname_DISC = compile_jmu(cpath_DISC, fpath_DISC)
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput_Nominal'
fname = compile_jmu(cpath, fpath,
compiler_options={"enable_variable_scaling":True})
def setUp(self):
"""Load the test model."""
package_DAE = 'Pendulum_pack_Pendulum.jmu'
package_DISC = 'IfExpExamples_IfExpExample2.jmu'
package_INPUT = 'DoubleInput_Nominal.jmu'
# Load the dynamic library and XML data
self.m_DAE = JMUModel(package_DAE)
self.m_DISC = JMUModel(package_DISC)
self.m_INPUT = JMUModel(package_INPUT)
# Creates the solvers
self.DAE = JMIDAE(self.m_DAE)
self.DISC = JMIDAE(self.m_DISC)
@testattr(stddist = True)
def test_result_name_file(self):
"""
Tests user naming of result file (JMIDAE).
"""
res = self.m_DAE.simulate()
#Default name
assert res.result_file == "Pendulum_pack_Pendulum_result.txt"
assert os.path.exists(res.result_file)
res = self.m_DAE.simulate(options={"result_file_name":
"Pendulum_pack_Pendulum_result_test.txt"})
#User defined name
assert res.result_file == "Pendulum_pack_Pendulum_result_test.txt"
assert os.path.exists(res.result_file)
@testattr(stddist = True)
def test_eps(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.get/set_eps
"""
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, 'Test')
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, -1)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, 1)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_eps, -1.0)
self.DAE.eps = 1.0
assert self.DAE.eps == 1.0
self.DAE.eps = 10.0
assert self.DAE.eps == 10.0
@testattr(stddist = True)
def test_max_eIteration(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.get/set_max_eIteration
"""
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_max_eIteration, 'Test')
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_max_eIteration, -1)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_max_eIteration, 1.0)
nose.tools.assert_raises(JMIModel_Exception, self.DAE._set_max_eIteration, -1.0)
self.DAE.max_eIter = 1
assert self.DAE.max_eIter == 1
self.DAE.max_eIter = 10
assert self.DAE.max_eIter == 10
@testattr(stddist = True)
def test_check_eIter(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.check_eIter
"""
self.DAE.eps = 1e-4
b_mode = [1, -1, 0]
a_mode = [-1, 1, 1]
[eIter, iter] = self.DAE.check_eIter(b_mode, a_mode)
assert iter == True
assert eIter[0] == -1
assert eIter[1] == 1
assert eIter[2] == 1
b_mode = [2, 5, 1]
a_mode = [0, 2, 2]
[eIter, iter] = self.DAE.check_eIter(b_mode, a_mode)
assert iter == False
assert eIter[0] == 0
assert eIter[1] == 0
assert eIter[2] == 0
@testattr(stddist = True)
def test_scaled_input(self):
"""
Tests that simulation of scaled input works.
"""
t = N.linspace(0.,10.,100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t,u1,u2)))
res = self.m_INPUT.simulate(final_time=10, input=(['u1','u2'],u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
@testattr(stddist = True)
def test_event_switch(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.event_switch
"""
solver = lambda x:1
solver.verbosity = 1
solver.LOUD = 2
solver.sw = [False, False, True]
event_info = [1, 0, -1]
self.DAE.event_switch(solver,event_info)
assert solver.sw[0] == True
assert solver.sw[1] == False
assert solver.sw[2] == False
@testattr(stddist = True)
def test_f(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.f
"""
test_x = N.array([1.,1.,1.,1.])
test_dx = N.array([2.,2.,2.,2.])
test_t = 2
temp_f = self.DAE.res(test_t,test_x,test_dx)
assert temp_f[0] == -1.0
assert temp_f[2] == -1.0
assert temp_f[3] == -2.0
nose.tools.assert_almost_equal(temp_f[1], -1.158529, 5)
@testattr(stddist = True)
def test_g(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.g
"""
pass #DEPRECATED
#temp_g = self.DISC.g(2.,[1.,2.],[2.,0],[0,0])
#nose.tools.assert_almost_equal(temp_g[0], -0.429203, 5)
#nose.tools.assert_almost_equal(temp_g[1], 1.141592, 5)
@testattr(stddist = True)
def test_g_adjust(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.g
"""
pass #DEPRECATED
"""
self.DISC.eps = 2.0
temp_g_adjust = self.DISC.g_adjust(2.,[1.,2.],[2.,0],[0,0])
nose.tools.assert_almost_equal(temp_g_adjust[0], -2.429203, 5)
nose.tools.assert_almost_equal(temp_g_adjust[1], -0.858407, 5)
temp_g_adjust = self.DISC.g_adjust(2.,[1.,2.],[2.,0],[0,1])
nose.tools.assert_almost_equal(temp_g_adjust[0], -2.429203, 5)
nose.tools.assert_almost_equal(temp_g_adjust[1], 3.141592, 5)
"""
@testattr(stddist = True)
def test_init(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.__init__
"""
assert self.m_DAE == self.DAE._model
assert self.DAE.max_eIter == 50
assert self.DAE.eps == 1e-9
assert self.DAE.jac == self.DAE.j
temp_y0 = N.append(self.m_DAE.real_x.copy(), self.m_DAE.real_w.copy())
temp_yd0 = N.append(self.m_DAE.real_dx.copy(),[0]*len(self.m_DAE.real_w))
temp_algvar = [1.0]*len(self.m_DAE.real_x) + [0.0]*len(self.m_DAE.real_w)
for i in range(len(temp_y0)):
assert temp_y0[i] == self.DAE.y0[i]
assert temp_yd0[i] == self.DAE.yd0[i]
assert temp_algvar[i] == self.DAE.algvar[i]
#Test discontiniuous system
assert self.DISC._g_nbr == 2
assert self.DISC.state_events == self.DISC.g_adjust
@testattr(stddist = True)
def test_reset(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.reset
"""
self.DAE.t0 = 10.0
self.DAE._model.real_x = N.array([2.,2.,2.,2.])
self.DAE._model.real_dx = N.array([2.,2.,2.,2.])
self.DAE.reset()
assert self.DAE._model.t == 10.0
assert self.DAE._model.real_x[0] != 2.0
assert self.DAE._model.real_x[1] != 2.0
assert self.DAE._model.real_x[2] != 2.0
assert self.DAE._model.real_dx[0] != 2.0
assert self.DAE._model.real_dx[1] != 2.0
assert self.DAE._model.real_dx[2] != 2.0
assert self.DAE.y0[0] == 0.1
@testattr(stddist = True)
def test_event_iteration(self):
"""
This tests JMUs with event iteration (JModelica.org).
"""
#DEPRECATED!
pass
"""
jmu_name = compile_jmu('EventIter.EventMiddleIter', os.path.join(path_to_mos,'EventIter.mo'))
model = JMUModel(jmu_name)
sim_res = model.simulate(final_time=10)
x = sim_res['x']
y = sim_res['y']
z = sim_res['z']
nose.tools.assert_almost_equal(x[0], 2.00000, 4)
nose.tools.assert_almost_equal(x[-1], 10.000000, 4)
nose.tools.assert_almost_equal(y[-1], 3.0000000, 4)
nose.tools.assert_almost_equal(z[-1], 2.0000000, 4)
jmu_name = compile_jmu('EventIter.EventStartIter', os.path.join(path_to_mos,'EventIter.mo'))
model = JMUModel(jmu_name)
sim_res = model.simulate(final_time=10)
x = sim_res['x']
y = sim_res['y']
z = sim_res['z']
nose.tools.assert_almost_equal(x[0], 1.00000, 4)
nose.tools.assert_almost_equal(y[0], -1.00000, 4)
nose.tools.assert_almost_equal(z[0], 1.00000, 4)
nose.tools.assert_almost_equal(x[-1], -2.000000, 4)
nose.tools.assert_almost_equal(y[-1], -1.0000000, 4)
nose.tools.assert_almost_equal(z[-1], 4.0000000, 4)
"""
@testattr(stddist = True)
def test_j(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.j
"""
test_x = N.array([1.,1.,1.,1.])
test_dx = N.array([2.,2.,2.,2.])
test_t = 2
temp_j = self.DAE.j(0.1,test_t,test_x,test_dx)
#print temp_j
assert temp_j[0,0] == -0.1
assert temp_j[0,1] == 1.0
assert temp_j[1,1] == -0.1
nose.tools.assert_almost_equal(temp_j[1,0], 0.5403023, 5)
@testattr(stddist = True)
def test_handle_event(self):
"""
Tests pyjmi.simulation.assimulo.JMIDAE.handle_event
"""
solver = lambda x:1
solver.verbosity = 1
solver.NORMAL = solver.LOUD = 2
solver.t_sol = [[1.0]]
solver.y_sol = [[1.,1.]]
solver.yd_sol = [[1.,1.]]
solver.t = N.array(1.0)
solver.y = N.array([1.,1.])
solver.yd = N.array([1.,1.])
solver.sw = [False,True]
self.DISC.event_switch = lambda x,y:1
self.DISC.init_mode = lambda x:1
self.DISC.check_eIter = lambda x,y: [True,False]
self.DISC.handle_event(solver, [1,1])
self.DISC.check_eIter = lambda x,y: [True,True]
self.DISC.handle_event(solver, [1,1])
@testattr(stddist = True)
def test_init_mode(self):
"""
Tests pyjmi.simulation.assimulo.init_mode
"""
solver = lambda x:1
solver.sw = [True, True]
solver.make_consistent = lambda x:1
self.DISC.init_mode(solver)
assert self.DISC._model.sw[0] == 1
assert self.DISC._model.sw[1] == 1
@testattr(stddist = True)
def test_initiate(self):
"""
Tests pyjmi.simulation.assimulo.initiate
"""
#self.DAE.init_mode = lambda x:1
#self.DAE.initiate('Test')
#self.DISC.handle_event = lambda x,y:1
#solver = lambda x:1
#solver.switches = [False, False]
#self.DISC.initiate(solver)
#assert solver.switches[0] == True
#assert solver.switches[1] == True
pass
"""
@testattr(stddist = True)
def test_scaled_input(self):
#This tests simulation with scaled input.
fpath = os.path.join(get_files_path(), 'Modelica', 'VDP.mop')
cpath = 'VDP_pack.VDP_scaled_input'
# compile VDP
jmu_name = compile_jmu(cpath, fpath,
compiler_options={'enable_variable_scaling':True})
# Load the dynamic library and XML data
vdp = JMUModel(jmu_name)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)/10.0
u_traj = N.transpose(N.vstack((t,u1)))
res_scaled = vdp.simulate(final_time=10, input=(['u'],u_traj))
# compile VDP
jmu_name = compile_jmu(cpath, fpath,
compiler_options={'enable_variable_scaling':False})
# Load the dynamic library and XML data
vdp = JMUModel(jmu_name)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)
u_traj = N.transpose(N.vstack((t,u1)))
res = vdp.simulate(final_time=10, input=(['u'],u_traj))
nose.tools.assert_almost_equal(res["u"][0], res_scaled["u"][0], 3)
nose.tools.assert_almost_equal(res["u"][-1], res_scaled["u"][-1], 3)
"""
@testattr(stddist = True)
def test_order_input(self):
"""
This tests that the inputs are sorted in an correct value reference order
when being written to file.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'OrderInputs.mop')
cpath = 'OptimInputs'
unames = ['u1', 'u_e2', 'u_h3', 'u_c4', 'u_p5']
n = len(unames)
uvalues = [1.,2.,3.,4.,5.]
data = N.array([[0.,1.,2.,3.,4.,5.],
[1.,1.,2.,3.,4.,5.],
[2.,1.,2.,3.,4.,5.]])
inputtuple = (unames,data)
jmu_name = compile_jmu(cpath,fpath)
model = JMUModel(jmu_name)
res = model.simulate(0,2,input=inputtuple)
nose.tools.assert_almost_equal(res["u1"][-1], 1.000000000, 3)
nose.tools.assert_almost_equal(res["u_e2"][-1], 2.00000, 3)
nose.tools.assert_almost_equal(res["u_h3"][-1], 3.00000, 3)
nose.tools.assert_almost_equal(res["u_c4"][-1], 4.000000, 3)
nose.tools.assert_almost_equal(res["u_p5"][-1], 5.000000, 3)
nose.tools.assert_almost_equal(res["T.u1"][-1], 1.000000000, 3)
nose.tools.assert_almost_equal(res["T.u_e2"][-1], 2.00000, 3)
nose.tools.assert_almost_equal(res["T.u_h3"][-1], 3.00000, 3)
nose.tools.assert_almost_equal(res["T.u_c4"][-1], 4.000000, 3)
nose.tools.assert_almost_equal(res["T.u_p5"][-1], 5.000000, 3)
@testattr(stddist = True)
def test_double_input(self):
"""
This tests double input.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput'
# compile VDP
fname = compile_jmu(cpath, fpath,
compiler_options={'state_start_values_fixed':True})
# Load the dynamic library and XML data
dInput = JMUModel(fname)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t,u1,u2)))
res = dInput.simulate(final_time=10, input=(['u1','u2'],u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
#TEST REVERSE ORDER OF INPUT
# Load the dynamic library and XML data
dInput = JMUModel(fname)
t = N.linspace(0.,10.,100)
u1 = N.cos(t)
u2 = N.sin(t)
u_traj = N.transpose(N.vstack((t,u2,u1)))
res = dInput.simulate(final_time=10, input=(['u2','u1'],u_traj))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
@testattr(stddist = True)
def test_double_input_with_function(self):
"""
This tests double input with function.
"""
fpath = os.path.join(get_files_path(), 'Modelica', 'DoubleInput.mo')
cpath = 'DoubleInput'
# compile VDP
fname = compile_jmu(cpath, fpath,
compiler_options={'state_start_values_fixed':True})
# Load the dynamic library and XML data
dInput = JMUModel(fname)
def func(t):
return N.array([N.cos(t),N.sin(t)])
res = dInput.simulate(final_time=10, input=(['u1','u2'],func))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
#TEST REVERSE ORDER OF INPUT
# Load the dynamic library and XML data
dInput = JMUModel(fname)
def func(t):
return [N.sin(t),N.cos(t)]
res = dInput.simulate(final_time=10, input=(['u2','u1'],func))
nose.tools.assert_almost_equal(res.initial('u1'), 1.000000000, 3)
nose.tools.assert_almost_equal(res.initial('u2'), 0.000000000, 3)
nose.tools.assert_almost_equal(res.final('u1'), -0.839071529, 3)
nose.tools.assert_almost_equal(res.final('u2'), -0.544021110, 3)
