def test_load_connections(): JSON_STRING = """ {"systems": { "msd": { "connections": [], "inputs": {"b": 80.0, "f": 0.0, "k": 50.0, "m": 50.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "MassSpringDamper" }, "wave_sys": { "connections": [["signal", "msd", "f"]], "inputs": {"amplitude": 50.0, "freq": 0.1,"phaseRad": 0.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "SquareWave" } } } """ sim = Sim() file = tempfile.NamedTemporaryFile(delete=False, mode="w+") file.write(JSON_STRING) file.close() sim.load_config(file.name) sim.simulate(2, 0.1) res = sim.systems["msd"].states.x1 assert np.abs(sim.systems["msd"].states.x1 - 0.3240587706226495) < 1e-10
def test_load_composite_connections(): JSON_STRING = """ {"systems": { "controlled_spring": { "type": "CompositeSystem", "module": "pysim.compositesystem", "connections": [], "inputs": {"amp": 0.0}, "ports": { "in": { "amp": { "connections": [{"input": "amplitude", "subsystem": "wave_sys"}], "description": "amplitude of wave", "type": "scalar", "value": 0.0 } }, "out": { "out": { "connections": [{"output": "x1", "subsystem": "msd"}], "description": "position", "type": "scalar", "value": 0.0 }, "signal": { "connections": [{"output": "signal", "subsystem": "wave_sys"}], "description": "signal from wave", "type": "scalar", "value": 0.0 } } }, "stores": [], "subsystems": { "msd": { "connections": [], "inputs": {"b": 80.0, "f": 0.0, "k": 50.0, "m": 50.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "MassSpringDamper" }, "wave_sys": { "connections": [["signal", "msd", "f"]], "inputs": {"amplitude": 50.0, "freq": 0.1, "phaseRad": 0.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "SquareWave" } } } } } """ sim = Sim() file = tempfile.NamedTemporaryFile(delete=False, mode="w+") file.write(JSON_STRING) file.close() sim.load_config(file.name) sim.simulate(2, 0.1) assert np.abs(sim.systems["controlled_spring"].outputs.out-0.3240587706226495) < 1e-10
def test_load_connections(): JSON_STRING = """ {"systems": { "msd": { "connections": [], "inputs": {"b": 80.0, "f": 0.0, "k": 50.0, "m": 50.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "MassSpringDamper" }, "wave_sys": { "connections": [["signal", "msd", "f"]], "inputs": {"amplitude": 50.0, "freq": 0.1,"phaseRad": 0.0}, "module": "pysim.systems.defaultsystemcollection1", "stores": [], "type": "SquareWave" } } } """ sim = Sim() file = tempfile.NamedTemporaryFile(delete=False, mode="w+") file.write(JSON_STRING) file.close() sim.load_config(file.name) sim.simulate(2, 0.1) res = sim.systems["msd"].states.x1 assert np.abs(sim.systems["msd"].states.x1-0.3240587706226495) < 1e-10
def test_composite_vs_connected_outputs(): """Test that the same result is given regardless if two systems are connected externally or put together in a composite system""" sim = Sim() #Externally connected systems msd = MassSpringDamper() msd.inputs.b = 80 msd.inputs.m = 50 msd.inputs.f = 0 sim.add_system(msd) sw = SquareWave() sw.inputs.amplitude = 50 sw.inputs.freq = 0.1 sim.add_system(sw) sw.connections.add_connection("signal",msd,"f") #Composite system cd = ControlledSpring() sim.add_system(cd) sim.simulate(2, 0.1) assert cd.outputs.out == msd.states.x1
def test_der_as_output(): """Test that it is possible to connect a derivative as output The der output should behave as a normal output. That this is the case is tested by connecting two systems to each output (der/output) and compare them. """ sys1 = MassSpringDamper() sys2 = InOutTestSystem() sys3 = InOutTestSystem() sys1.connections.add_connection("dx2",sys2,"input_scalar") sys1.connections.add_connection("acceleration",sys3,"input_scalar") sys2.store("input_output_scalar") sys3.store("input_output_scalar") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) sim.add_system(sys3) sim.simulate(1,0.1) output_from_der = sys2.res.input_output_scalar output_from_output = sys3.res.input_output_scalar assert np.allclose(output_from_der, output_from_output)
def test_example_system(): """Test the example system against a known solutin""" sys = ExampleSystem() sim = Sim() sim.add_system(sys) sim.simulate(5,0.1) assert abs(sys.states.x - 0.609483796797075) < 1e-14
def test_der_as_output(): """Test that it is possible to connect a derivative as output The der output should behave as a normal output. That this is the case is tested by connecting two systems to each output (der/output) and compare them. """ sys1 = MassSpringDamper() sys2 = InOutTestSystem() sys3 = InOutTestSystem() sys1.connections.add_connection("dx2", sys2, "input_scalar") sys1.connections.add_connection("acceleration", sys3, "input_scalar") sys2.store("input_output_scalar") sys3.store("input_output_scalar") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) sim.add_system(sys3) sim.simulate(1, 0.1) output_from_der = sys2.res.input_output_scalar output_from_output = sys3.res.input_output_scalar assert np.allclose(output_from_der, output_from_output)
def test_connected_system(): """Check that the time for stored values in a discrete system is regurarly spaced""" #Create Simulaton sim = Sim() #Create, setup and add system to simulation sys = MassSpringDamper() sys.store("x1") sys.inputs.b = 50 sys.inputs.f = 0 sim.add_system(sys) controlsys = DiscretePID() controlsys.inputs.refsig = 1.0 controlsys.inputs.p = 1 controlsys.inputs.plim = 400.0 controlsys.inputs.i = 0 controlsys.inputs.stepsize = 0.3 controlsys.store("outsig") sim.add_system(controlsys) sys.connections.add_connection("x1", controlsys, "insig") sys.connections.add_connection("x2", controlsys, "dsig") controlsys.connections.add_connection("outsig", sys, "f") controlsys.inputs.d = 1 sim.simulate(5, 0.1) assert np.max(np.abs(np.diff(controlsys.res.time))-0.1) < 1e-14 assert np.max(np.abs(np.diff(sys.res.time))-0.1) < 1e-14
def test_connected_system(): """Check that the time for stored values in a discrete system is regurarly spaced""" #Create Simulaton sim = Sim() #Create, setup and add system to simulation sys = MassSpringDamper() sys.store("x1") sys.inputs.b = 50 sys.inputs.f = 0 sim.add_system(sys) controlsys = DiscretePID() controlsys.inputs.refsig = 1.0 controlsys.inputs.p = 1 controlsys.inputs.plim = 400.0 controlsys.inputs.i = 0 controlsys.inputs.stepsize = 0.3 controlsys.store("outsig") sim.add_system(controlsys) sys.connections.add_connection("x1", controlsys, "insig") sys.connections.add_connection("x2", controlsys, "dsig") controlsys.connections.add_connection("outsig", sys, "f") controlsys.inputs.d = 1 sim.simulate(5, 0.1) assert np.max(np.abs(np.diff(controlsys.res.time)) - 0.1) < 1e-14 assert np.max(np.abs(np.diff(sys.res.time)) - 0.1) < 1e-14
def test_vectormap_parameter(): """Test that it is possible to set a vectormap parameter""" sys = get_system() assert sys.pars.parameter_vectormap == {'a': [1, 2], 'b': [3, 4]} sim = Sim() sim.add_system(sys) sim.simulate(0.1, 0.1) assert sys.outputs.output_from_vectormap == 2
def test_matrix_parameter(): """Test that it is possible to set a vector parameter""" sys = get_system() assert sys.pars.parameter_matrix == [[1, 2, 3], [4, 5, 6]] sim = Sim() sim.add_system(sys) sim.simulate(0.1, 0.1) assert sys.outputs.output_from_matrix == 1
def test_map_parameter(): """Test that it is possible to set a map parameter""" sys = get_system() assert sys.pars.parameter_map == {'a': 1, 'b': 2} sim = Sim() sim.add_system(sys) sim.simulate(0.1, 0.1) assert sys.outputs.output_from_map == 1
def test_connected_subsystems(): """Test that subsystems can be connected""" cd = ControlledSpring() sim = Sim() sim.add_system(cd) sim.simulate(2, 0.1) assert np.abs(cd.outputs.out-0.3240587706226495) < 1e-10
def test_gettime(test_class): """Test that the elapsed time is returned from the simulation""" sys = test_class() sim = Sim() sim.add_system(sys) integrationlength = 2.0 assert sim.get_time() == 0.0 sim.simulate(integrationlength, 0.1) assert sim.get_time() == integrationlength
def test_gettime(test_class): """Test that the elapsed time is returned from the simulation""" sys = test_class() sim = Sim() sim.add_system(sys) integrationlength = 2.0 assert sim.get_time() == 0.0 sim.simulate(integrationlength, 0.1) assert sim.get_time() == integrationlength
def test_composite_prestep(): """Test that composite post step functionality is working""" sim = Sim() ps = PreStepCompositeSystem() sim.add_system(ps) sim.simulate(1, 1) assert np.all(ps.outputs.state_vector_derived == [-31.919999999999995, 54.71999999999999, -22.799999999999997])
def test_store_vector(): """Test that it is possible to store a boost vector""" sim = Sim() sys = RigidBody() sys.store("position") sys.inputs.force = [1, 0, 0] sim.add_system(sys) sim.simulate(20, 0.01) diff = sys.res.position[-1, :] - sys.states.position assert np.all(diff == np.array([0.0, 0.0, 0.0]))
def test_store_vector(): """Test that it is possible to store a boost vector""" sim = Sim() sys = RigidBody() sys.store("position") sys.inputs.force = [1,0,0] sim.add_system(sys) sim.simulate(20,0.01) diff = sys.res.position[-1,:]-sys.states.position assert np.all(diff == np.array([0.0, 0.0, 0.0]))
def test_store_matrix(test_class): """Test that it is possible to store a matrix""" sim = Sim() sys = test_class() ref_mat = np.array([[1, 0, 0], [0, 2, 0], [0, 0, 3]]) sys.store("input_output_matrix") sys.inputs.input_matrix = ref_mat sim.add_system(sys) sim.simulate(2, 0.1) assert np.all(sys.res.input_output_matrix[-1] == ref_mat)
def test_time_store(test_class): """Check that the time is stored, and that the stored values includes both the beginning and the end of the simulation""" sim = Sim() sys = test_class() sim.add_system(sys) sim.simulate(2, 0.1) reftime = np.linspace(0, 2, 21) simtime = sys.res.time assert np.all(np.abs(simtime - reftime) <= np.finfo(float).eps)
def test_store_der(test_class): """Test that it is possible to store a der""" sim = Sim() sys = test_class() sys.store("dx") sim.add_system(sys) sim.simulate(10, 0.1) dxres = sys.res.dx assert isinstance(dxres, np.ndarray) assert dxres.size == 101
def test_time_store(test_class): """Check that the time is stored, and that the stored values includes both the beginning and the end of the simulation""" sim = Sim() sys = test_class() sim.add_system(sys) sim.simulate(2, 0.1) reftime = np.linspace(0,2,21) simtime = sys.res.time assert np.all(np.abs(simtime-reftime) <= np.finfo(float).eps)
def test_system_store(): """Test that it is possible to store the output from a composite system""" cd = CompositeSpring() sim = Sim() sim.add_system(cd) cd.store("position") sim.simulate(2, 0.1) assert np.abs(cd.res.position[5]-0.90450499444532406) < 1e-7 assert np.abs(cd.res.position[-1]-0.3240587706226495) < 1e-7
def main(): """Test that the elapsed time is returned from the simulation""" sys = VanDerPol() sys.store("x") sys.store("y") sim = Sim() sim.add_system(sys) sim.simulate(20, 0.1) plt.plot(sys.res.time,sys.res.x) plt.plot(sys.res.time,sys.res.y) plt.show()
def test_composite_poststep(): """Test that composite post step functionality is working""" sim = Sim() ps = PostStepCompositeSystem() sim.add_system(ps) sim.simulate(2, 0.1) assert ps.outputs.state_scalar_out == 1.23*2 assert np.all(ps.outputs.state_vector_out == np.ones(3)*4.56*2) assert np.all(ps.outputs.state_matrix_out == np.ones((3,3))*7.89*2)
def test_store_der(test_class): """Test that it is possible to store a der""" sim = Sim() sys = test_class() sys.store("dx") sim.add_system(sys) sim.simulate(10, 0.1) dxres = sys.res.dx assert isinstance(dxres, np.ndarray) assert dxres.size == 101
def test_store_output(): """Test that it is possible to store a state""" sim = Sim() sys = SquareWave() sys.store("signal") sim.add_system(sys) sim.simulate(10, 0.1) res = sys.res.signal assert isinstance(res, np.ndarray) assert res.size == 101
def test_store_state(test_class): """Test that it is possible to store a state""" sim = Sim() sys = test_class() sys.store("x") sim.add_system(sys) sim.simulate(10, 0.1) xres = sys.res.x assert isinstance(xres, np.ndarray) assert xres.size == 101
def test_store_state(test_class): """Test that it is possible to store a state""" sim = Sim() sys = test_class() sys.store("x") sim.add_system(sys) sim.simulate(10, 0.1) xres = sys.res.x assert isinstance(xres, np.ndarray) assert xres.size == 101
def main(): """Test that the elapsed time is returned from the simulation""" sys = VanDerPol() sys.store("x") sys.store("y") sim = Sim() sim.add_system(sys) sim.simulate(20, 0.1) plt.plot(sys.res.time, sys.res.x) plt.plot(sys.res.time, sys.res.y) plt.show()
def test_store_output(): """Test that it is possible to store a state""" sim = Sim() sys = SquareWave() sys.store("signal") sim.add_system(sys) sim.simulate(10, 0.1) res = sys.res.signal assert isinstance(res,np.ndarray) assert res.size == 101
def test_composite_poststep(): """Test that composite post step functionality is working""" sim = Sim() ps = PostStepCompositeSystem() sim.add_system(ps) sim.simulate(2, 0.1) assert ps.outputs.state_scalar_out == 1.23 * 2 assert np.all(ps.outputs.state_vector_out == np.ones(3) * 4.56 * 2) assert np.all(ps.outputs.state_matrix_out == np.ones((3, 3)) * 7.89 * 2)
def test_store_matrix(test_class): """Test that it is possible to store a matrix""" sim = Sim() sys = test_class() ref_mat = np.array([[1,0,0], [0,2,0], [0,0,3]]) sys.store("input_output_matrix") sys.inputs.input_matrix =ref_mat sim.add_system(sys) sim.simulate(2,0.1) assert np.all(sys.res.input_output_matrix[-1]==ref_mat)
def test_store_after_added_system(test_class): """Tests that it is possible to first add a system to a simulation and then store parameters. """ sim = Sim() sys = test_class() sim.add_system(sys) sys.store("x") sim.simulate(10, 0.1) ressize = sys.res.x.size assert ressize == 101
def test_store_input(test_class): """Test that it is possible to store an input""" sim = Sim() sys = test_class() sys.store("a") sim.add_system(sys) sim.simulate(10, 0.1) ares = sys.res.a assert isinstance(ares,np.ndarray) assert ares.size == 101 assert np.all(ares==1.0)
def main(): """Test that the elapsed time is returned from the simulation""" vdp = VanDerPol() vdp.store("x") vdp.store("y") sim = Sim() sim.add_system(vdp, "Cython1") sim.simulate(20, 0.1) plt.plot(vdp.res.x) plt.plot(vdp.res.y) plt.show()
def test_store_after_added_system(test_class): """Tests that it is possible to first add a system to a simulation and then store parameters. """ sim = Sim() sys = test_class() sim.add_system(sys) sys.store("x") sim.simulate(10, 0.1) ressize = sys.res.x.size assert ressize == 101
def test_cpp_poststep(): """Test that cpp system post step functionality is working""" sim = Sim() ps = PostStepTestSystemCpp() sim.add_system(ps) sim.simulate(2, 0.1) assert ps.states.state_scalar == 1.23 * 2 assert np.all(ps.states.state_vector == np.ones(3) * 4.56 * 2) assert np.all(ps.states.state_matrix == np.zeros((3, 3)))
def test_state_break_smaller(): """Stop the simulation once the value of a state is larger than a preset value """ sim = Sim() sys = VanDerPol() sys.add_break_smaller("x",-1.0) sim.add_system(sys) sim.simulate(20,0.01) #If correct the simulation should break at time 2.52 assert sys.res.time[-1] == 2.52
def test_state_break_larger(): """Stop the simulation once the value of a state is larger than a preset value """ sim = Sim() sys = VanDerPol() sys.add_break_greater("y", 1.0) sim.add_system(sys) sim.simulate(20, 0.01) #If correct the simulation should break at time 0.79 assert sys.res.time[-1] == 0.79
def test_cpp_poststep(): """Test that cpp system post step functionality is working""" sim = Sim() ps = PostStepTestSystemCpp() sim.add_system(ps) sim.simulate(2, 0.1) assert ps.states.state_scalar == 1.23*2 assert np.all(ps.states.state_vector == np.ones(3)*4.56*2) assert np.all(ps.states.state_matrix == np.zeros((3,3)))
def test_store_input(test_class): """Test that it is possible to store an input""" sim = Sim() sys = test_class() sys.store("a") sim.add_system(sys) sim.simulate(10, 0.1) ares = sys.res.a assert isinstance(ares, np.ndarray) assert ares.size == 101 assert np.all(ares == 1.0)
def test_connected_adder_system(adder_class1,adder_class2): """Check that it is possible to connect systems to each other with boost vector outputs/inputs""" sys1 = adder_class1() sys2 = adder_class2() sys1.inputs.input1 = [1,2,3] sys1.connections.add_connection("output1",sys2,"input1") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) assert np.all(sys2.outputs.output1 == [0.0, 0.0, 0.0]) sim.simulate(1,0.1) assert np.all(sys2.outputs.output1 == [1.0, 2.0, 3.0])
def test_connected_adder_system(adder_class1, adder_class2): """Check that it is possible to connect systems to each other with boost vector outputs/inputs""" sys1 = adder_class1() sys2 = adder_class2() sys1.inputs.input1 = [1, 2, 3] sys1.connections.add_connection("output1", sys2, "input1") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) assert np.all(sys2.outputs.output1 == [0.0, 0.0, 0.0]) sim.simulate(1, 0.1) assert np.all(sys2.outputs.output1 == [1.0, 2.0, 3.0])
def test_interval_store(test_class): """Check that it is possible to change the interval between stored values. """ sim = Sim() sys = test_class() sys.set_store_interval(0.2) sim.add_system(sys) sim.simulate(2, 0.1) reftime = np.linspace(0,2,11) simtime = sys.res.time assert np.all(np.abs(simtime-reftime) <= np.finfo(float).eps)
def test_interval_store(test_class): """Check that it is possible to change the interval between stored values. """ sim = Sim() sys = test_class() sys.set_store_interval(0.2) sim.add_system(sys) sim.simulate(2, 0.1) reftime = np.linspace(0, 2, 11) simtime = sys.res.time assert np.all(np.abs(simtime - reftime) <= np.finfo(float).eps)
def test_connected_system(test_class1,test_class2): """Check that it is possible to connect systems to each other with matrix outputs/inputs""" sys1 = test_class1() sys2 = test_class2() refarray = [[1,2,3],[4,5,6],[7,8,9]] sys1.inputs.input_matrix = refarray sys1.connections.add_connection("input_output_matrix",sys2,"input_matrix") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) assert np.all(sys2.outputs.input_output_matrix == np.zeros((3,3))) sim.simulate(1,0.1) assert np.all(sys2.outputs.input_output_matrix == refarray)
def test_continue_store(test_class): """Test that it is possible to continue a simulation without storing values twice. """ sim = Sim() sys = test_class() sim.add_system(sys) sys.store("x") sim.simulate(1, 0.1) sim.simulate(1, 0.1) reftime = np.linspace(0, 2, 21) simtime = sys.res.time assert np.all(np.abs(simtime - reftime) <= np.finfo(float).eps)
def test_continue_store(test_class): """Test that it is possible to continue a simulation without storing values twice. """ sim = Sim() sys = test_class() sim.add_system(sys) sys.store("x") sim.simulate(1, 0.1) sim.simulate(1, 0.1) reftime = np.linspace(0,2,21) simtime = sys.res.time assert np.all(np.abs(simtime-reftime) <= np.finfo(float).eps)
def test_midsim_store(test_class): """Check that it is possible to store a variable mid-simulation and that the result array is properly aligned with the timesteps and contains np.nan for locations where the variable was not stored. """ sim = Sim() sys = test_class() sim.add_system(sys) sim.simulate(5, 1) sys.store("a") sim.simulate(5, 1) ares = sys.res.a assert np.all(np.isnan(ares[:6])) assert not np.any(np.isnan(ares[6:]))
def test_nan_connection_matrix(sys1_class,sys2_class): """Check that an exception is thrown if a scalar NaN is being copied to another system. """ sys1 = sys1_class() sys2 = sys2_class() sys1.inputs.input_matrix= [[float('nan'),0,0],[0,0,0],[0,0,0]] sys1.connections.add_connection("input_output_matrix",sys2,"input_matrix") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) with pytest.raises(RuntimeError): sim.simulate(0.1,0.1)
def test_connected_system(test_class1, test_class2): """Check that it is possible to connect systems to each other with matrix outputs/inputs""" sys1 = test_class1() sys2 = test_class2() refarray = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] sys1.inputs.input_matrix = refarray sys1.connections.add_connection("input_output_matrix", sys2, "input_matrix") sim = Sim() sim.add_system(sys1) sim.add_system(sys2) assert np.all(sys2.outputs.input_output_matrix == np.zeros((3, 3))) sim.simulate(1, 0.1) assert np.all(sys2.outputs.input_output_matrix == refarray)
def test_midsim_store(test_class): """Check that it is possible to store a variable mid-simulation and that the result array is properly aligned with the timesteps and contains np.nan for locations where the variable was not stored. """ sim = Sim() sys = test_class() sim.add_system(sys) sim.simulate(5, 1) sys.store("a") sim.simulate(5, 1) ares = sys.res.a assert np.all(np.isnan(ares[:6])) assert not np.any(np.isnan(ares[6:]))
def test_port_connections(): """Test the port connections to and from subsystems""" cs = CompositeTestSystem() ref_scalar = 5.0 ref_vector = (6.0, 7.0, 8.0) ref_matrix = ((9.0, 10.0, 11.0),(12.0, 13.0, 14.0),(15.0, 16.0, 17.0)) cs.inputs.scalar_in_0 = ref_scalar cs.inputs.vector_in_0 = ref_vector cs.inputs.matrix_in_0 = ref_matrix sim = Sim() sim.add_system(cs) sim.simulate(0.5, 0.1) assert cs.outputs.output_scalar_0 == ref_scalar assert_array_almost_equal(cs.outputs.output_vector_0, ref_vector, 18) assert_array_almost_equal(cs.outputs.output_matrix_0,ref_matrix, 18)
def test_boost_vector_states(): """Perform a basic simulation of a system with boost vector states""" sim = Sim() sys = RigidBody() sys.store("position") sys.inputs.force = [1.0,0.0,0.0] sys.inputs.mass = 1.0 sim.add_system(sys) sim.simulate(20,0.01) pos = sys.res.position diff = np.abs(pos[-1,:]-[200,0,0]) assert np.max(diff) <= 1
def test_boost_vector_states(): """Perform a basic simulation of a system with boost vector states""" sim = Sim() sys = RigidBody() sys.store("position") sys.inputs.force = [1.0, 0.0, 0.0] sys.inputs.mass = 1.0 sim.add_system(sys) sim.simulate(20, 0.01) pos = sys.res.position diff = np.abs(pos[-1, :] - [200, 0, 0]) assert np.max(diff) <= 1
def test_output_change(adder_class): """Tests that it is possible to change input array. To make sure that the input is actually used in the simulation this is done by setting a input, run a simulation and see that the output value has changed. """ sys = adder_class() refarray1 = np.array((0.0, 0.0, 0.0)) inputarray = (1.0, 2.0, 3.0) sys.inputs.input1 = inputarray x1 = sys.outputs.output1 assert np.array_equal(x1, refarray1) sim = Sim() sim.add_system(sys) sim.simulate(1, 0.1) x2 = sys.outputs.output1 assert np.array_equal(x2, inputarray)