def test_get_variable_valueref(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu",
me2_xml_path,
_connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu",
me2_xml_path,
_connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
nose.tools.assert_raises(fmi.FMUException,
coupled.get_variable_valueref, "J1.w")
vr_1 = coupled.get_variable_valueref("First.J1.w")
vr_2 = coupled.get_variable_valueref("Second.J1.w")
assert vr_1 != vr_2
var_name_1 = coupled.get_variable_by_valueref(vr_1)
var_name_2 = coupled.get_variable_by_valueref(vr_2)
assert var_name_1 == "First.J1.w"
assert var_name_2 == "Second.J1.w"
def test_model_variables(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
vars = coupled.get_model_variables()
vars_1 = model_cc_1.get_model_variables()
vars_2 = model_cc_2.get_model_variables()
assert len(vars) == len(vars_1) + len(vars_2)
vars = coupled.get_model_variables(include_alias=False)
vars_1 = model_cc_1.get_model_variables(include_alias=False)
vars_2 = model_cc_2.get_model_variables(include_alias=False)
assert len(vars) == len(vars_1) + len(vars_2)
vars = coupled.get_model_variables(include_alias=False, type=fmi.FMI2_INTEGER)
vars_1 = model_cc_1.get_model_variables(include_alias=False, type=fmi.FMI2_INTEGER)
vars_2 = model_cc_2.get_model_variables(include_alias=False, type=fmi.FMI2_INTEGER)
assert len(vars) == len(vars_1) + len(vars_2)
def test_caching(self):
negated_alias = FMUModelME2("NegatedAlias.fmu",
os.path.join(file_path, "files", "FMUs",
"XML", "ME2.0"),
_connect_dll=False)
assert len(negated_alias.cache) == 0 #No starting cache
vars_1 = negated_alias.get_model_variables()
vars_2 = negated_alias.get_model_variables()
assert id(vars_1) == id(vars_2)
vars_3 = negated_alias.get_model_variables(filter="*")
assert id(vars_1) != id(vars_3)
vars_4 = negated_alias.get_model_variables(type=0)
assert id(vars_3) != id(vars_4)
vars_5 = negated_alias.get_model_time_varying_value_references()
vars_7 = negated_alias.get_model_time_varying_value_references()
assert id(vars_5) != id(vars_1)
assert id(vars_5) == id(vars_7)
negated_alias = FMUModelME2("NegatedAlias.fmu",
os.path.join(file_path, "files", "FMUs",
"XML", "ME2.0"),
_connect_dll=False)
assert len(negated_alias.cache) == 0 #No starting cache
vars_6 = negated_alias.get_model_variables()
assert id(vars_1) != id(vars_6)
def test_inputs_list(self):
model_sub_1 = FMUModelME2("LinearStability.SubSystem1.fmu",
me2_xml_path,
_connect_dll=False)
model_sub_2 = FMUModelME2("LinearStability.SubSystem2.fmu",
me2_xml_path,
_connect_dll=False)
model_full = FMUModelME2("LinearStability.FullSystem.fmu",
me2_xml_path,
_connect_dll=False)
models = [("First", model_sub_1), ("Second", model_sub_2)]
connections = [(model_sub_1, "y1", model_sub_2, "u2"),
(model_sub_2, "y2", model_sub_1, "u1")]
coupled = CoupledFMUModelME2(models, connections=connections)
#Inputs should not be listed if they are internally connected
vars = coupled.get_input_list().keys()
assert len(vars) == 0
coupled = CoupledFMUModelME2(models, connections=[])
vars = coupled.get_input_list().keys()
assert "First.u1" in vars
assert "Second.u2" in vars
def test_loading(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu",
me2_xml_path,
_connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu",
me2_xml_path,
_connect_dll=False)
models = [model_cc_1, model_cc_2]
connections = []
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models,
connections)
models = [("First", model_cc_1), model_cc_2]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models,
connections)
models = [("First", model_cc_1), ("First", model_cc_2)]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models,
connections)
models = [("First", model_cc_1), ("Second", model_cc_2)]
coupled = CoupledFMUModelME2(models, connections)
connections = [("k")]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models,
connections)
connections = [(model_cc_1, "J1.phi", model_cc_2, "J2.phi")]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models,
connections)
def __init__(self, negated_aliases, *args, **kwargs):
FMUModelME2.__init__(self, *args, **kwargs)
self.continuous_states = np.zeros(self.get_ode_sizes()[0])
self.nominal_continuous_states = np.ones(self.get_ode_sizes()[0])
self.variables = self.get_model_variables(include_alias=False)
self.negated_aliases = negated_aliases
self.states = self.get_states_list()
self.reset()
def test_alias(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
aliases = coupled.get_variable_alias("First.J4.phi")
assert "First.J4.phi" in aliases.keys()
assert coupled.get_variable_alias_base("First.J4.phi") == "First.J4.flange_a.phi"
def test_ode_sizes(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
[nbr_states, nbr_event_ind] = coupled.get_ode_sizes()
assert nbr_states == 16
assert nbr_event_ind == 66
def test_variable_causality(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
nose.tools.assert_raises(fmi.FMUException, coupled.get_variable_causality, "J1.w")
causality = coupled.get_variable_causality("First.J1.w")
assert causality == model_cc_1.get_variable_causality("J1.w")
def test_reversed_connections(self):
model_sub_1 = FMUModelME2("LinearStability.SubSystem1.fmu", me2_xml_path, _connect_dll=False)
model_sub_2 = FMUModelME2("LinearStability.SubSystem2.fmu", me2_xml_path, _connect_dll=False)
model_full = FMUModelME2("LinearStability.FullSystem.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_sub_1), ("Second", model_sub_2)]
connections = [(model_sub_2,"y1",model_sub_1,"u2"),
(model_sub_1,"y2",model_sub_2,"u1")]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models, connections)
connections = [(model_sub_2,"u2",model_sub_1,"y1"),
(model_sub_1,"u1",model_sub_2,"y2")]
nose.tools.assert_raises(fmi.FMUException, CoupledFMUModelME2, models, connections)
def test_unicode_description(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "Description.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
desc = model.get_variable_description("x")
assert desc == "Test symbols '' ‘’"
def test_get_variable_description(self):
model = FMUModelME2("CoupledClutches.fmu",
os.path.join(file_path, "files", "FMUs", "XML",
"ME2.0"),
_connect_dll=False)
assert model.get_variable_description(
"J1.phi") == "Absolute rotation angle of component"
def test_log_file_name(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "CoupledClutches.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
path, file_name = os.path.split(full_path)
assert model.get_log_file_name() == file_name.replace(".","_")[:-4]+"_log.txt"
def test_states_list(self):
model_cc_1 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
model_cc_2 = FMUModelME2("CoupledClutches.fmu", me2_xml_path, _connect_dll=False)
models = [("First", model_cc_1), ("Second", model_cc_2)]
connections = []
coupled = CoupledFMUModelME2(models, connections)
states = coupled.get_states_list()
for state in states:
assert state.startswith("First.") or state.startswith("Second.")
var = coupled.get_variable_by_valueref(states[state].value_reference)
alias_vars = coupled.get_variable_alias(var).keys()
assert state in alias_vars
def test_get_erronous_nominals(self):
model = FMUModelME2("NominalTests.NominalTest4.fmu",
os.path.join(file_path, "files", "FMUs", "XML",
"ME2.0"),
_connect_dll=False)
nose.tools.assert_almost_equal(model.get_variable_nominal("x"), 2.0)
nose.tools.assert_almost_equal(model.get_variable_nominal("y"), 1.0)
nose.tools.assert_almost_equal(
model.get_variable_nominal("x", _override_erroneous_nominal=False),
-2.0)
nose.tools.assert_almost_equal(
model.get_variable_nominal("y", _override_erroneous_nominal=False),
0.0)
x_vref = model.get_variable_valueref("x")
y_vref = model.get_variable_valueref("y")
nose.tools.assert_almost_equal(
model.get_variable_nominal(valueref=x_vref), 2.0)
nose.tools.assert_almost_equal(
model.get_variable_nominal(valueref=y_vref), 1.0)
nose.tools.assert_almost_equal(
model.get_variable_nominal(valueref=x_vref,
_override_erroneous_nominal=False),
-2.0)
nose.tools.assert_almost_equal(
model.get_variable_nominal(valueref=y_vref,
_override_erroneous_nominal=False), 0.0)
def test_loading_xml_me2(self):
model = FMUModelME2("CoupledClutches.fmu",
os.path.join(file_path, "files", "FMUs", "XML",
"ME2.0"),
_connect_dll=False)
assert model.get_name() == "CoupledClutches", model.get_name()
def test_units(self):
model = FMUModelME2("CoupledClutches.fmu", os.path.join(file_path, "files", "FMUs", "XML", "ME2.0"), _connect_dll=False)
assert model.get_variable_unit("J1.w") == "rad/s", model.get_variable_unit("J1.w")
assert model.get_variable_unit("J1.phi") == "rad", model.get_variable_unit("J1.phi")
nose.tools.assert_raises(FMUException, model.get_variable_unit, "clutch1.useHeatPort")
nose.tools.assert_raises(FMUException, model.get_variable_unit, "clutch1.sss")
nose.tools.assert_raises(FMUException, model.get_variable_unit, "clutch1.sss")
def test_output_dependencies_2(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "CoupledClutches.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
[state_dep, input_dep] = model.get_output_dependencies()
assert len(state_dep.keys()) == 0, len(state_dep.keys())
assert len(input_dep.keys()) == 0, len(input_dep.keys())
def test_display_units(self):
model = FMUModelME2("CoupledClutches.fmu",
os.path.join(file_path, "files", "FMUs", "XML",
"ME2.0"),
_connect_dll=False)
assert model.get_variable_display_unit("J1.phi") == "deg"
nose.tools.assert_raises(FMUException, model.get_variable_display_unit,
"J1.w")
def test_derivative_dependencies(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "NoState.Example1.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
[state_dep, input_dep] = model.get_derivatives_dependencies()
assert len(state_dep.keys()) == 0, len(state_dep.keys())
assert len(input_dep.keys()) == 0, len(input_dep.keys())
def test_declared_enumeration_type(self):
model = FMUModelME2("Enumerations.Enumeration3.fmu",
os.path.join(file_path, "files", "FMUs", "XML",
"ME2.0"),
_connect_dll=False)
enum = model.get_variable_declared_type("x")
assert len(enum.items.keys()) == 2
enum = model.get_variable_declared_type("home")
assert len(enum.items.keys()) == 4
nose.tools.assert_raises(FMUException,
model.get_variable_declared_type, "z")
def test_loading_wrong_model(self):
model_sub1 = FMUModelCS2("LinearStability.SubSystem1.fmu",
cs2_xml_path,
_connect_dll=False)
model_sub2 = FMUModelME2("LinearStability.SubSystem2.fmu",
me2_xml_path,
_connect_dll=False)
models = [model_sub1, model_sub2]
connections = [(model_sub1, "y1", model_sub2, "u2"),
(model_sub2, "y2", model_sub1, "u1")]
nose.tools.assert_raises(FMUException, Master, models, connections)
def test_output_dependencies(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "OutputTest2.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
[state_dep, input_dep] = model.get_output_dependencies()
assert state_dep["y1"][0] == "x1"
assert state_dep["y1"][1] == "x2"
assert state_dep["y2"][0] == "x2"
assert state_dep["y3"][0] == "x1"
assert input_dep["y1"][0] == "u1"
assert input_dep["y3"][0] == "u1"
assert len(input_dep["y2"]) == 0
def test_declared_enumeration_type(self):
model = FMUModelME2("Enumerations.Enumeration3.fmu", os.path.join(file_path, "files", "FMUs", "XML", "ME2.0"), _connect_dll=False)
enum = model.get_variable_declared_type("x")
assert len(enum.items.keys()) == 2, len(enum.items.keys())
enum = model.get_variable_declared_type("home")
assert len(enum.items.keys()) == 4, len(enum.items.keys())
assert enum.items[1][0] == "atlantis"
assert enum.name == "Enumerations.Enumeration3.cities", "Got: " + enum.name
assert enum.description == "", "Got: " + enum.description
nose.tools.assert_raises(FMUException, model.get_variable_declared_type, "z")
def test_get_scalar_variable(self):
negated_alias = FMUModelME2("NegatedAlias.fmu", os.path.join(file_path, "files", "FMUs", "XML", "ME2.0"), _connect_dll=False)
sc_x = negated_alias.get_scalar_variable("x")
assert sc_x.name == "x", sc_x.name
assert sc_x.value_reference >= 0, sc_x.value_reference
assert sc_x.type == fmi.FMI2_REAL, sc_x.type
assert sc_x.variability == fmi.FMI2_CONTINUOUS, sc_x.variability
assert sc_x.causality == fmi.FMI2_LOCAL, sc_x.causality
assert sc_x.initial == fmi.FMI2_INITIAL_APPROX, sc_x.initial
nose.tools.assert_raises(FMUException, negated_alias.get_scalar_variable, "not_existing")
def test_relative_quantity(self):
full_path = os.path.join(file_path, "files", "FMUs", "XML", "ME2.0", "test_type_definitions.fmu")
model = FMUModelME2(full_path, _connect_dll=False)
rel = model.get_variable_relative_quantity("real_with_attr")
assert rel == True, "Relative quantity should be True"
rel = model.get_variable_relative_quantity("real_with_attr_false")
assert rel == False, "Relative quantity should be False"
rel = model.get_variable_relative_quantity("real_without_attr")
assert rel == False, "Relative quantity should be (default) False"
rel = model.get_variable_relative_quantity("real_with_typedef")
assert rel == True, "Relative quantity should be True"
nose.tools.assert_raises(FMUException, model.get_variable_relative_quantity, "int_with_attr")
def test_get_time_varying_variables(self):
model = FMUModelME2("CoupledClutches.fmu", os.path.join(file_path, "files", "FMUs", "XML", "ME2.0"), _connect_dll=False)
[r,i,b] = model.get_model_time_varying_value_references()
[r_f, i_f, b_f] = model.get_model_time_varying_value_references(filter="*")
assert len(r) == len(r_f)
assert len(i) == len(i_f)
assert len(b) == len(b_f)
vars = model.get_variable_alias("J4.phi")
for var in vars:
[r,i,b] = model.get_model_time_varying_value_references(filter=var)
assert len(r) == 1, len(r)
[r,i,b] = model.get_model_time_varying_value_references(filter=list(vars.keys()))
assert len(r) == 1, len(r)
