def test_initialize(self):
"""
Test the method initialize in FMUModelCS2
"""
self._bounce=load_fmu(CS2, path_to_fmus_cs2, False)
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
for i in range(10):
self._bounce.initialize(relTol = 10**-i) #Initialize multiple times with different relTol
self._bounce.reset_slave()
self._bounce.initialize() #Initialize with default options
self._bounce.reset_slave()
self._bounce.initialize(tStart = 4.5)
nose.tools.assert_almost_equal(self._bounce.time, 4.5)
self._bounce.reset_slave()
#Try to simulate past the defined stop
self._coupledCS2.initialize(tStop=1.0 , StopTimeDefined = True)
step_size=0.1
total_time=0
for i in range(10):
self._coupledCS2.do_step(total_time, step_size)
total_time += step_size
status=self._coupledCS2.do_step(total_time, step_size)
assert status != 0
self._coupledCS2.reset_slave()
#Try to initialize twice when not supported
self._coupledCS2.initialize()
nose.tools.assert_raises(FMUException, self._coupledCS2.initialize)
def test_correct_loading(self):
model = load_fmu("Modelica_Mechanics_Rotational_Examples_CoupledClutches_ME.fmu",path_to_fmus_me1)
assert isinstance(model, FMUModelME1)
model = load_fmu("Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",path_to_fmus_cs1)
assert isinstance(model, FMUModelCS1)
def test_get_directional_derivative(self):
"""
Test the method get_directional_derivative in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
bounce.initialize()
coupled.initialize(tolControlled=False)
nose.tools.assert_raises(FMUException, bounce.get_directional_derivative, [1], [1], [1])
nose.tools.assert_raises(FMUException, coupled.get_directional_derivative, [1], [1], [1,2])
states_list = coupled.get_states_list()
der_list = coupled.get_derivatives_list()
states_ref = [s.value_reference for s in states_list.values()]
der_ref = [s.value_reference for s in der_list.values()]
nose.tools.assert_raises(FMUException, coupled.get_directional_derivative, [1], [der_ref[0]], [1])
dir_der = coupled.get_directional_derivative(states_ref, der_ref, [1]*len(states_ref))
assert len(dir_der) == len(der_list)
nose.tools.assert_almost_equal(dir_der[1], 0)
nose.tools.assert_almost_equal(dir_der[2], 1.000000)
dir_der2 = coupled.get_directional_derivative(states_ref, der_ref, [2]*len(states_ref))
assert len(dir_der) == len(der_list)
diff = dir_der2 - 2*dir_der
nose.tools.assert_almost_equal(sum(diff), 0)
def test_get_derivatives(self):
"""
Test the method get_derivatives in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
bounce.initialize()
coupled.initialize(tolControlled=False)
nx = bounce.get_ode_sizes()[0]
der=bounce.get_derivatives()
assert nx == len(der)
nose.tools.assert_almost_equal(der[0], 4.000000)
nose.tools.assert_almost_equal(der[1], -9.810000)
bounce.set_real(1, 2.)
bounce.set_real(2, -5.)
der=bounce.get_derivatives()
nose.tools.assert_almost_equal(der[0], 2.000000)
nose.tools.assert_almost_equal(der[1], -5.000000)
der_list = coupled.get_derivatives_list()
der_ref = N.array([s.value_reference for s in der_list.values()])
der = coupled.get_derivatives()
diff = N.sort(N.array([coupled.get_real(i) for i in der_ref]))-N.sort(der)
nose.tools.assert_almost_equal(N.sum(diff), 0.)
def test_default_simulation(self):
"""
This test the default values of the simulation using simulate.
"""
#Writing continuous
bounce = load_fmu('bouncingBall.fmu', path_to_fmus_me1)
opts = bounce.simulate_options()
opts["CVode_options"]["rtol"] = 1e-4
opts["CVode_options"]["atol"] = 1e-6
res = bounce.simulate(final_time=3., options=opts)
nose.tools.assert_almost_equal(res.solver.rtol, 1e-4, 6)
assert res.solver.iter == 'Newton'
nose.tools.assert_almost_equal(res.initial('h'),1.000000,5)
nose.tools.assert_almost_equal(res.final('h'),-0.9804523,5)
nose.tools.assert_almost_equal(res.final('time'),3.000000,5)
#Writing continuous
bounce = load_fmu('bouncingBall.fmu', path_to_fmus_me1)
#bounce.initialize(options={'initialize':False})
res = bounce.simulate(final_time=3.,
options={'initialize':True,'CVode_options':{'iter':'FixedPoint','rtol':1e-6,'atol':1e-6}})
nose.tools.assert_almost_equal(res.solver.rtol, 0.00000100, 7)
assert res.solver.iter == 'FixedPoint'
nose.tools.assert_almost_equal(res.initial('h'),1.000000,5)
nose.tools.assert_almost_equal(res.final('h'),-0.98018113,5)
nose.tools.assert_almost_equal(res.final('time'),3.000000,5)
def test_log_file_name(self):
model = load_fmu("bouncingBall.fmu",path_to_fmus_me1)
assert os.path.exists("bouncingBall_log.txt")
model = load_fmu("bouncingBall.fmu",path_to_fmus_me1,log_file_name="Test_log.txt")
assert os.path.exists("Test_log.txt")
model = FMUModelME1("bouncingBall.fmu",path_to_fmus_me1)
assert os.path.exists("bouncingBall_log.txt")
model = FMUModelME1("bouncingBall.fmu",path_to_fmus_me1,log_file_name="Test_log.txt")
assert os.path.exists("Test_log.txt")
def test_log_file_name(self):
model = load_fmu("bouncingBall.fmu",os.path.join(path_to_fmus,"CS1.0"))
assert os.path.exists("bouncingBall_log.txt")
model = load_fmu("bouncingBall.fmu",os.path.join(path_to_fmus,"CS1.0"),log_file_name="Test_log.txt")
assert os.path.exists("Test_log.txt")
model = FMUModelCS1("bouncingBall.fmu",os.path.join(path_to_fmus,"CS1.0"))
assert os.path.exists("bouncingBall_log.txt")
model = FMUModelCS1("bouncingBall.fmu",os.path.join(path_to_fmus,"CS1.0"),log_file_name="Test_log.txt")
assert os.path.exists("Test_log.txt")
def test_multiple_loadings_and_simulations(self):
model = load_fmu("bouncingBall.fmu",path_to_fmus_me1,enable_logging=False)
res = model.simulate(final_time=1.0)
h_res = res.final('h')
for i in range(40):
model = load_fmu("bouncingBall.fmu",path_to_fmus_me1,enable_logging=False)
res = model.simulate(final_time=1.0)
assert N.abs(h_res - res.final('h')) < 1e-4
def setUp(self):
"""
Load the test model.
"""
self._bounce = load_fmu('bouncingBall.fmu',path_to_fmus_me1)
self._dq = load_fmu('dq.fmu',path_to_fmus_me1)
self._bounce.initialize()
self._dq.initialize()
self._bounceSim = FMIODE(self._bounce)
self._dqSim = FMIODE(self._dq)
def test_init(self):
"""
Test the method __init__ in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
assert bounce.get_identifier() == 'BouncingBall2'
nose.tools.assert_raises(FMUException, FMUModelME2, fmu=CS2, path=path_to_fmus_cs2, enable_logging=False)
nose.tools.assert_raises(FMUException, FMUModelME2, fmu=CS1, path=path_to_fmus_cs1, enable_logging=False)
nose.tools.assert_raises(FMUException, FMUModelME2, fmu=ME1, path=path_to_fmus_me1, enable_logging=False)
def setUp(self):
"""
Sets up the test case.
"""
self.rlc = load_fmu('RLC_Circuit.fmu')
self._bounce = load_fmu('bouncingBall.fmu',path_to_fmus_me1)
self._dq = load_fmu('dq.fmu',path_to_fmus_me1)
self._bounce.initialize()
self._dq.initialize()
self.dep = load_fmu("DepParTests_DepPar1.fmu")
self.dep.initialize()
def test_instantiate_model(self):
"""
Test the method instantiate_model in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
for i in range(5):
name1 = 'model1' + str(i)
#name2 = 'model2' + str(i)
#coupled.instantiate_model(name=name2)
bounce.instantiate_model(name=name1)
def test_reset_slave(self):
"""
Test the method reset_slave in FMUModelCS2
"""
self._bounce=load_fmu(CS2, path_to_fmus_cs2, False)
self._bounce.initialize()
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
self._coupledCS2.initialize()
self._bounce.reset_slave()
self._bounce.initialize()
self._coupledCS2.reset_slave()
self._coupledCS2.initialize()
def test_reset(self):
"""
Test the method reset in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
bounce.initialize()
coupled.initialize(tolControlled=False)
bounce.reset()
coupled.reset()
assert bounce.time is None
assert coupled.time is None
def test_simulate_options(self):
"""
Test the method simultaion_options in FMUModelCS2
"""
#Do the setUp
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
#Test the result file
res=self._coupledCS2.simulate()
assert res.result_file == 'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result.txt'
assert os.path.exists(res.result_file)
self._coupledCS2.reset_slave()
opts = {'result_file_name':'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result_test.txt'}
res=self._coupledCS2.simulate(options=opts)
assert res.result_file == 'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result_test.txt'
assert os.path.exists(res.result_file)
#Test the option in the simulate method
self._coupledCS2.reset_slave()
opts={}
opts['ncp'] = 250
opts['initialize'] = False
self._coupledCS2.initialize()
res=self._coupledCS2.simulate(options=opts)
assert len(res['time']) == 251
def test_initialize(self):
"""
Test the method initialize in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
coupled.initialize(tolControlled=False)
nose.tools.assert_almost_equal(coupled.time, 0.0)
nose.tools.assert_raises(FMUException, coupled.initialize, tolControlled=False) #Cant initialize twice in a row
bounce.initialize()
nose.tools.assert_almost_equal(bounce.time, 0.0)
bounce.reset()
bounce.initialize(relativeTolerance=1e-7)
def test_terminate(self):
"""
Test the method terminate in FMUModelME2
"""
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
coupled.initialize(tolControlled=False)
coupled.terminate()
def test_relation_geinit(self):
model = load_fmu("RelationTests_RelationGEInit.fmu")
res = model.simulate(final_time=0.1)
nose.tools.assert_almost_equal(res.initial("x"),0.0,places=3)
nose.tools.assert_almost_equal(res.initial("y"),1.0,places=3)
def test_simulate_options(self):
"""
Test the method simulate_options in FMUModelME2
"""
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
opts=coupled.simulate_options()
assert opts['initialize']
assert not opts['with_jacobian']
assert opts['ncp'] == 0
#Test the result file
res=coupled.simulate()
assert res.result_file == 'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result.txt'
assert os.path.exists(res.result_file)
coupled.reset()
opts = {'result_file_name':'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result_test.txt'}
res=coupled.simulate(options=opts)
assert res.result_file == 'Modelica_Mechanics_Rotational_Examples_CoupledClutches_result_test.txt'
assert os.path.exists(res.result_file)
#Test the option in the simulate method
coupled.reset()
opts={}
opts['ncp'] = 250
opts['initialize'] = False
coupled.initialize(tolControlled=False)
res=coupled.simulate(options=opts)
assert len(res['time']) > 250
def test_event_iteration(self):
"""
This tests FMUs with event iteration (JModelica.org).
"""
fmu_name = compile_fmu('EventIter.EventMiddleIter', os.path.join(path_to_mos,'EventIter.mo'))
model = load_fmu(fmu_name)
sim_res = model.simulate(final_time=10)
nose.tools.assert_almost_equal(sim_res.initial('x'), 2.00000, 4)
nose.tools.assert_almost_equal(sim_res.final('x'), 10.000000, 4)
nose.tools.assert_almost_equal(sim_res.final('y'), 3.0000000, 4)
nose.tools.assert_almost_equal(sim_res.final('z'), 2.0000000, 4)
fmu_name = compile_fmu('EventIter.EventStartIter', os.path.join(path_to_mos,'EventIter.mo'))
model = FMUModel(fmu_name)
sim_res = model.simulate(final_time=10)
nose.tools.assert_almost_equal(sim_res.initial('x'), 1.00000, 4)
nose.tools.assert_almost_equal(sim_res.initial('y'), -1.00000, 4)
nose.tools.assert_almost_equal(sim_res.initial('z'), 1.00000, 4)
nose.tools.assert_almost_equal(sim_res.final('x'), -2.000000, 4)
nose.tools.assert_almost_equal(sim_res.final('y'), -1.0000000, 4)
nose.tools.assert_almost_equal(sim_res.final('z'), 4.0000000, 4)
def test_check_against_unneccesary_derivatives_eval(self):
name = compile_fmu("RLC_Circuit",os.path.join(path_to_mofiles,"RLC_Circuit.mo"), compiler_options={"generate_html_diagnostics":True, "log_level":6})
model = load_fmu(name, log_level=6)
model.set("_log_level", 6)
model.initialize()
len_log = len(model.get_log())
model.time = 1e-4
model.get_derivatives()
assert len(model.get_log()) > len_log
len_log = len(model.get_log())
model.get_derivatives()
len_log_diff = len(model.get_log())-len_log
model.time = 1e-4
len_log = len(model.get_log())
model.get_derivatives()
assert len(model.get_log())-len_log_diff == len_log
len_log = len(model.get_log())
model.continuous_states = model.continuous_states
model.get_derivatives()
assert len(model.get_log())-len_log_diff == len_log
len_log = len(model.get_log())
model.continuous_states = model.continuous_states+1
model.get_derivatives()
assert len(model.get_log())-len_log_diff > len_log
def test_reset(self):
"""
Test resetting an FMU. (Multiple instances is NOT supported on Dymola
FMUs)
"""
#Writing continuous
bounce = load_fmu('bouncingBall.fmu', path_to_fmus_me1)
opts = bounce.simulate_options()
opts["CVode_options"]["rtol"] = 1e-4
opts["CVode_options"]["atol"] = 1e-6
#bounce.initialize()
res = bounce.simulate(final_time=3., options=opts)
nose.tools.assert_almost_equal(res.initial('h'),1.000000,5)
nose.tools.assert_almost_equal(res.final('h'),-0.9804523,5)
bounce.reset()
#bounce.initialize()
nose.tools.assert_almost_equal(bounce.get('h'), 1.00000,5)
res = bounce.simulate(final_time=3.,options=opts)
nose.tools.assert_almost_equal(res.initial('h'),1.000000,5)
nose.tools.assert_almost_equal(res.final('h'),-0.9804523,5)
def test_cc_with_dopri(self):
model = load_fmu("Modelica_Mechanics_Rotational_Examples_CoupledClutches.fmu")
opts = model.simulate_options()
opts["solver"] = "Dopri5"
res = model.simulate(final_time=1.5,options=opts)
assert (N.abs(res.final("J1.w") - 3.2450903041811698)) < 1e-3
def test_singular_system_event_1(self):
model = load_fmu("EventIter_SingularSystem1.fmu")
#Check that we can initialize without error!
model.initialize()
nose.tools.assert_almost_equal(model.get("mode"), 0.0)
nose.tools.assert_almost_equal(model.get("sa"), 0.0)
def setUp(self):
"""
Sets up the test case.
"""
self.m = load_fmu('LoggerTest.fmu')
self.m.set_debug_logging(True)
self.m.set('_log_level',6)
self.m.set_log_level(5)
def test_simulation_with_reset_cs(self):
model = load_fmu("Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",path_to_fmus_cs1)
res1 = model.simulate(final_time=1.5)
assert (res1["J1.w"][-1] - 3.245091100366517) < 1e-4
model.reset()
res2 = model.simulate(final_time=1.5)
assert (res2["J1.w"][-1] - 3.245091100366517) < 1e-4
def test_time(self):
"""
Test the method get/set_time in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
coupled.reset()
assert coupled.time is None
coupled.initialize(tolControlled=False)
nose.tools.assert_almost_equal(coupled._get_time(), 0.0)
coupled._set_time(2.71)
nose.tools.assert_almost_equal(coupled.time , 2.71)
coupled._set_time(1.00)
nose.tools.assert_almost_equal(coupled._get_time() , 1.00)
nose.tools.assert_raises(TypeError, coupled._set_time, '2.0')
nose.tools.assert_raises(TypeError, coupled._set_time, N.array([1.0, 1.0]))
def test_get_event_indicators(self):
"""
Test the method get_event_indicators in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
bounce.initialize()
coupled.initialize(tolControlled=False)
assert len(bounce.get_event_indicators()) == 1
assert len(coupled.get_event_indicators()) == 54
event_ind = bounce.get_event_indicators()
nose.tools.assert_almost_equal(event_ind[0],1.000000)
bounce.continuous_states = N.array([5.]*2)
event_ind = bounce.get_event_indicators()
nose.tools.assert_almost_equal(event_ind[0],5.000000)
def test_get_tolerances(self):
"""
Test the method get_tolerances in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
bounce.initialize()
coupled.initialize(tolControlled=False)
[rtol,atol] = bounce.get_tolerances()
assert rtol == 0.0001
nose.tools.assert_almost_equal(atol[0],0.0000010)
nose.tools.assert_almost_equal(atol[1],0.0000010)
[rtol,atol] = coupled.get_tolerances()
assert rtol == 0.0001
nose.tools.assert_almost_equal(atol[0],0.0000010)
def test_init(self):
"""
Test the method __init__ in FMUModelCS2
"""
self._bounce=load_fmu(CS2, path_to_fmus_cs2, False)
assert self._bounce.get_identifier() == 'BouncingBall2'
nose.tools.assert_raises(FMUException, FMUModelCS2, fmu=ME2, path=path_to_fmus_me2)
nose.tools.assert_raises(FMUException, FMUModelCS2, fmu=CS1, path=path_to_fmus_cs1)
nose.tools.assert_raises(FMUException, FMUModelCS2, fmu=ME1, path=path_to_fmus_me1)
def setUp(self):
"""
Sets up the test case.
"""
self._model = load_fmu(Test_FMI_Compile.fmuname)
def test_model_types_platfrom(self):
dep = load_fmu(Test_FMUModelME1.depPar1)
assert dep.model_types_platform == "standard32"
def test_reinit_writeback(self):
model = load_fmu("Reinit_ReinitWriteback.fmu")
model.simulate(start_time=0, final_time=21)
def test_simulate(self):
"""
Test the main features of the method simulate() in FMUmodelCS2
"""
#Set up for simulation
self._bounce = load_fmu(CS2, path_to_fmus_cs2, False)
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
#Try simulate the bouncing ball
res = self._bounce.simulate()
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.0)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
self._bounce.reset_slave()
for i in range(5):
res = self._bounce.simulate(start_time=0.1,
final_time=1.0,
options={'ncp': 500})
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.1)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
assert sim_time.all(
) >= sim_time[0] - 1e-4 #Check that the time is increasing
assert sim_time.all(
) <= sim_time[-1] + 1e+4 #Give it some marginal
height = res['HIGHT']
assert height.all(
) >= -1e-4 #The height of the ball should be non-negative
nose.tools.assert_almost_equal(res.final('HIGHT'), 0.63489609999,
4)
if i > 0: #check that the results stays the same
diff = height_old - height
nose.tools.assert_almost_equal(diff[-1], 0.0)
height_old = height
self._bounce.reset_slave()
#Try to simulate the coupled-clutches
res_coupled = self._coupledCS2.simulate()
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 1.0)
self._coupledCS2.reset_slave()
for i in range(10):
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
res_coupled = self._coupledCS2.simulate(start_time=0.0,
final_time=2.0)
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 2.0)
assert sim_time_coupled.all(
) >= sim_time_coupled[0] - 1e-4 #Check that the time is increasing
assert sim_time_coupled.all(
) <= sim_time_coupled[-1] + 1e+4 #Give it some marginal
#val_J1 = res_coupled['J1.w']
#val_J2 = res_coupled['J2.w']
#val_J3 = res_coupled['J3.w']
#val_J4 = res_coupled['J4.w']
val = [
res_coupled.final('J1.w'),
res_coupled.final('J2.w'),
res_coupled.final('J3.w'),
res_coupled.final('J4.w')
]
if i > 0: #check that the results stays the same
for j in range(len(val)):
nose.tools.assert_almost_equal(val[j], val_old[j])
val_old = val
self._coupledCS2.reset_slave()
#Compare to something we know is correct
cs1_model = load_fmu(
'Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu',
path_to_fmus_cs1, False)
res1 = cs1_model.simulate(final_time=10,
options={'result_file_name': 'result1'})
self._coupledCS2 = load_fmu(CoupledCS2, path_to_fmus_cs2, False)
res2 = self._coupledCS2.simulate(
final_time=10, options={'result_file_name': 'result2'})
diff1 = res1.final("J1.w") - res2.final("J1.w")
diff2 = res1.final("J2.w") - res2.final("J2.w")
diff3 = res1.final("J3.w") - res2.final("J3.w")
diff4 = res1.final("J4.w") - res2.final("J4.w")
nose.tools.assert_almost_equal(abs(diff1), 0.000, 1)
nose.tools.assert_almost_equal(abs(diff2), 0.000, 1)
nose.tools.assert_almost_equal(abs(diff3), 0.000, 1)
nose.tools.assert_almost_equal(abs(diff4), 0.000, 1)
def setUp(self):
"""
Sets up the test case.
"""
self.m = load_fmu(Test_RaisesIfNonConverge.fmu)
def test_simulate(self):
"""
Test the main features of the method simulate() in FMUmodelCS2
"""
#Set up for simulation
bounce = load_fmu(self.bouncing_name)
coupled = load_fmu(self.coupled_name)
#Try simulate the bouncing ball
res = bounce.simulate()
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.0)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
bounce.reset()
for i in range(5):
res = bounce.simulate(start_time=0.1,
final_time=1.0,
options={'ncp': 500})
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.1)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
assert sim_time.all(
) >= sim_time[0] - 1e-4 #Check that the time is increasing
assert sim_time.all(
) <= sim_time[-1] + 1e-4 #Give it some marginal
height = res['h']
assert height.all(
) >= -1e-4 #The height of the ball should be non-negative
nose.tools.assert_almost_equal(res.final('h'), 6.0228998448008104,
4)
if i > 0: #check that the results stays the same
diff = height_old - height
nose.tools.assert_almost_equal(diff[-1], 0.0)
height_old = height
bounce.reset()
#Try to simulate the coupled-clutches
res_coupled = coupled.simulate()
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 1.5)
coupled.reset()
for i in range(10):
coupled = load_fmu(self.coupled_name)
res_coupled = coupled.simulate(start_time=0.0, final_time=2.0)
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 2.0)
assert sim_time_coupled.all(
) >= sim_time_coupled[0] - 1e-4 #Check that the time is increasing
assert sim_time_coupled.all(
) <= sim_time_coupled[-1] + 1e-4 #Give it some marginal
#val_J1 = res_coupled['J1.w']
#val_J2 = res_coupled['J2.w']
#val_J3 = res_coupled['J3.w']
#val_J4 = res_coupled['J4.w']
val = [
res_coupled.final('J1.w'),
res_coupled.final('J2.w'),
res_coupled.final('J3.w'),
res_coupled.final('J4.w')
]
if i > 0: #check that the results stays the same
for j in range(len(val)):
nose.tools.assert_almost_equal(val[j], val_old[j])
val_old = val
coupled.reset()
"""
def test_version(self):
"""
This tests the (get)-property of version.
"""
rlc = load_fmu(Test_FMUModelCS1.rlc_circuit)
assert rlc._get_version() == '1.0'
def test_asseert_fail(self):
model = load_fmu(Test_FMUModelCS1.assert_fail)
nose.tools.assert_raises(Exception, model.simulate)
def test_valid_platforms(self):
"""
This tests the (get)-property of types platform
"""
rlc = load_fmu('RLC_Circuit.fmu')
assert rlc._get_types_platform() == 'standard32'
def test_unknown_solver(self):
rlc = load_fmu(Test_FMUModelCS1.rlc_circuit)
rlc.set("_cs_solver", 2) #Does not exists
nose.tools.assert_raises(FMUException, rlc.simulate)
def test_version(self):
negated_alias = load_fmu(Test_FMUModelBase.negAliasFmu)
assert negated_alias.get_version() == "1.0"
def test_instantiate_model(self):
"""
Test the method instantiate_model in FMUModelME2
"""
for i in range(5):
bounce = load_fmu(self.bouncing_name)
def setUp(self):
"""
Sets up the test case.
"""
self.m = load_fmu(self.fmu)
def test_version(self):
bounce = load_fmu(self.bouncing_name)
assert bounce.get_version() == "2.0"
coupled = load_fmu(self.coupled_name)
assert coupled.get_version() == "2.0"
def test_initialize_once(self):
negated_alias = load_fmu(Test_FMUModelBase.negAliasFmu)
negated_alias.initialize()
nose.tools.assert_raises(FMUException, negated_alias.initialize)
def test_event_infinite_iteration_2(self):
model = load_fmu("EventIter_EventInfiniteIteration2.fmu")
nose.tools.assert_raises(FMUException, model.initialize)
def main():
model_path = get_model_path()
# 1. Solve the initialization problem
# Compile the stationary initialization model into an FMU
init_fmu = compile_fmu("TanksPkg.ThreeTanksInit", model_path)
init_model = load_fmu(init_fmu)
# Set input for Stationary point A
u_0_a = 0
init_model.set('u', u_0_a)
# Solve the initialization problem using FMI
init_model.initialize()
# Store stationary point A
[h1_0_a, h2_0_a, h3_0_a] = init_model.get(['h1', 'h2', 'h3'])
# Print some data for stationary point A
print_stationary_point('A', h1_0_a, h2_0_a, h3_0_a, u_0_a)
# Set inputs for Stationary point B
init_model.reset() # reset the FMU so that we can initialize it again
u_0_b = 88.0
init_model.set('u', u_0_b)
# Solve the initialization problem using FMI
init_model.initialize()
# Store stationary point B
[h1_0_b, h2_0_b, h3_0_b] = init_model.get(['h1', 'h2', 'h3'])
# Print some data for stationary point B
print_stationary_point('B', h1_0_b, h2_0_b, h3_0_b, u_0_b)
init_res = simulate_tanks(model_path,
u=u_0_b,
with_plots=True,
with_full_traj_obj=True)
h1_sim = init_res['h1']
h2_sim = init_res['h2']
h3_sim = init_res['h3']
h1_sim_final = h1_sim[-1]
h2_sim_final = h2_sim[-1]
h3_sim_final = h3_sim[-1]
print("Final values of the simulation:", h1_sim_final, h2_sim_final,
h3_sim_final)
# 3. Solve the optimal control problem
# Compile and load optimization problem
op = transfer_optimization_problem("TanksPkg.three_tanks_time_optimal",
model_path)
# Set initial values
# op.set('h1_final', h1_sim_final)
# op.set('h2_final', h2_sim_final)
# op.set('h3_final', h3_sim_final)
op.set('h1_final', float(h1_0_b))
op.set('h2_final', float(h2_0_b))
op.set('h3_final', float(h3_0_b))
op.set('u_max', U_MAX)
# Set options
opt_opts = op.optimize_options()
# opt_opts['n_e'] = 80 # Number of elements
opt_opts['variable_scaling'] = False
opt_opts['init_traj'] = init_res
# opt_opts['nominal_traj'] = init_res
opt_opts['IPOPT_options']['tol'] = 1e-3
opt_opts['verbosity'] = 1
print("OPTIMISATION OPTIONS:")
for option, value in opt_opts.items():
print('\t', option, ':', value)
# Solve the optimal control problem
res = op.optimize(options=opt_opts)
# Extract variable profiles
h1_res = res['h1']
h2_res = res['h2']
h3_res = res['h3']
u_res = res['u']
time_res = res['time']
print("Final value of time:", time_res[-1])
print(dir(res))
# Plot the results
plot_results(h1_res,
h2_res,
h3_res,
time_res,
u_res,
title="Trajektorie optymalne")
normalised_u = []
for val in u_res:
if val < 50:
normalised_u.append(0)
else:
normalised_u.append(U_MAX)
for i in range(10):
try:
sim_result = simulate_tanks(model_path,
u=normalised_u,
t_final=time_res[-1],
with_plots=True)
plot_with_optimal_trajectories(time_res, sim_result['time'],
sim_result["h1"], sim_result["h2"],
sim_result["h3"], h1_res, h2_res,
h3_res, normalised_u)
break
except FMUException:
pass
def test_simulate(self):
"""
Test the method simulate in FMUModelME2
"""
bounce = load_fmu(ME2, path_to_fmus_me2, False)
coupled = load_fmu(CoupledME2, path_to_fmus_me2)
#Try simulate the bouncing ball
res = bounce.simulate()
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.0)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
bounce.reset()
opts = bounce.simulate_options()
opts["CVode_options"]["rtol"] = 1e-6
opts["CVode_options"]["atol"] = 1e-6
opts["ncp"] = 500
for i in range(5):
res = bounce.simulate(start_time=0.1, final_time=1.0, options=opts)
sim_time = res['time']
nose.tools.assert_almost_equal(sim_time[0], 0.1)
nose.tools.assert_almost_equal(sim_time[-1], 1.0)
assert sim_time.all(
) >= sim_time[0] - 1e-4 #Check that the time is increasing
assert sim_time.all(
) <= sim_time[-1] + 1e+4 #Give it some marginal
height = res['HIGHT']
assert height.all(
) >= -1e-4 #The height of the ball should be non-negative
nose.tools.assert_almost_equal(res.final('HIGHT'), 0.6269474005, 4)
if i > 0: #check that the results stays the same
diff = height_old - height
nose.tools.assert_almost_equal(diff[-1], 0.0)
height_old = height
bounce.reset()
#Try to simulate the coupled-clutches
res_coupled = coupled.simulate()
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 1.0)
coupled.reset()
for i in range(10):
res_coupled = coupled.simulate(start_time=0.0, final_time=2.0)
sim_time_coupled = res_coupled['time']
nose.tools.assert_almost_equal(sim_time_coupled[0], 0.0)
nose.tools.assert_almost_equal(sim_time_coupled[-1], 2.0)
assert sim_time_coupled.all(
) >= sim_time_coupled[0] - 1e-4 #Check that the time is increasing
assert sim_time_coupled.all(
) <= sim_time_coupled[-1] + 1e+4 #Give it some marginal
#val_J1 = res_coupled['J1.w']
#val_J2 = res_coupled['J2.w']
#val_J3 = res_coupled['J3.w']
#val_J4 = res_coupled['J4.w']
val = [
res_coupled.final('J1.w'),
res_coupled.final('J2.w'),
res_coupled.final('J3.w'),
res_coupled.final('J4.w')
]
if i > 0: #check that the results stays the same
for j in range(len(val)):
nose.tools.assert_almost_equal(val[j], val_old[j])
val_old = val
coupled.reset()
#Compare to something we know is correct
me1_model = load_fmu(
'Modelica_Mechanics_Rotational_Examples_CoupledClutches_ME.fmu',
path_to_fmus_me1, False)
res1 = me1_model.simulate(final_time=2.,
options={'result_file_name': 'result1'})
coupled = load_fmu(CoupledME2, path_to_fmus_me2, False)
res2 = coupled.simulate(final_time=2.,
options={'result_file_name': 'result2'})
diff1 = res1.final("J1.w") - res2.final("J1.w")
diff2 = res1.final("J2.w") - res2.final("J2.w")
diff3 = res1.final("J3.w") - res2.final("J3.w")
diff4 = res1.final("J4.w") - res2.final("J4.w")
nose.tools.assert_almost_equal(abs(diff1), 0.0000, 2)
nose.tools.assert_almost_equal(abs(diff2), 0.0000, 2)
nose.tools.assert_almost_equal(abs(diff3), 0.0000, 2)
nose.tools.assert_almost_equal(abs(diff4), 0.0000, 2)
#Try simualte the robot
robot = load_fmu(Robot, path_to_fmus_me2)
result = robot.simulate()
def test_simulation_cs(self):
model = load_fmu(
"Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",
path_to_fmus_cs1)
res = model.simulate(final_time=1.5)
assert (res.final("J1.w") - 3.245091100366517) < 1e-4
def test_event_infinite_iteration_3(self):
model = load_fmu("EventIter_EventInfiniteIteration3.fmu")
nose.tools.assert_raises(FMUException, model.simulate)
def test_get_string(self):
model = load_fmu(self.string1)
for i in range(100): #Test so that memory issues are detected
assert model.get("str")[0] == "hej"
def test_exception_output_derivatives(self):
model = load_fmu(
"Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",
path_to_fmus_cs1)
nose.tools.assert_raises(FMUException, model.get_output_derivatives,
"u", 1)
def test_types_platform(self):
model = load_fmu(
"Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",
path_to_fmus_cs1)
assert model.types_platform == "standard32"
def test_default_simulation_stop_time(self):
model = load_fmu(
"Modelica_Mechanics_Rotational_Examples_CoupledClutches_CS.fmu",
path_to_fmus_cs1)
res = model.simulate()
assert N.abs(1.5 - res.final('time')) < 1e-4
def test_integer_start_time(self):
model = load_fmu("NegatedAliasCS2.fmu")
#Assert that there is no exception when reloading the file
res = model.simulate(start_time=0)
