import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om import dymos as dm from dymos.utils.testing_utils import assert_check_partials from dymos.transcriptions.common import TimeComp, PolynomialControlGroup from dymos.transcriptions.grid_data import GridData from dymos.phase.options import PolynomialControlOptionsDictionary from dymos.utils.lgl import lgl from dymos.utils.misc import CompWrapperConfig, GroupWrapperConfig TimeComp = CompWrapperConfig(TimeComp) PolynomialControlGroup = GroupWrapperConfig(PolynomialControlGroup) # Test 1: Let x = t**2, f = 2*t def f_a(t): return t**2 def f1_a(t): return 2 * t def f2_a(t): return 2.0 * np.ones_like(t)
import unittest import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal from openmdao.utils.testing_utils import use_tempdirs import dymos as dm from dymos.transcriptions.runge_kutta.components.runge_kutta_stepsize_comp import RungeKuttaStepsizeComp from dymos.utils.testing_utils import assert_check_partials from dymos.utils.misc import CompWrapperConfig RungeKuttaStepsizeComp = CompWrapperConfig(RungeKuttaStepsizeComp) @use_tempdirs class TestRKStepsizeComp(unittest.TestCase): def setUp(self): dm.options['include_check_partials'] = True def tearDown(self): dm.options['include_check_partials'] = False def test_rk_stepsize_comp(self): p = om.Problem(model=om.Group()) ivc = p.model.add_subsystem('ivc', om.IndepVarComp(), promotes_outputs=['*'])
import unittest import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal from dymos.utils.testing_utils import assert_check_partials import dymos as dm from dymos.transcriptions.runge_kutta.components.runge_kutta_k_comp import RungeKuttaKComp # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig RungeKuttaKComp = CompWrapperConfig(RungeKuttaKComp) class TestRKKComp(unittest.TestCase): def setUp(self): dm.options['include_check_partials'] = True def tearDown(self): dm.options['include_check_partials'] = False def test_rk_k_comp_rk4_scalar(self): state_options = {'y': {'shape': (1, ), 'units': 'm'}} p = om.Problem(model=om.Group()) ivc = p.model.add_subsystem('ivc', om.IndepVarComp(), promotes_outputs=['*'])
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials from dymos.transcriptions.pseudospectral.components import StateInterpComp from dymos.transcriptions.grid_data import GridData from dymos.utils.lgr import lgr # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig StateInterpComp = CompWrapperConfig(StateInterpComp) SHOW_PLOTS = False if SHOW_PLOTS: import matplotlib.pyplot as plt # Test 1: Let x = t**2, f = 2*t def x(t): return t**2 def f_x(t): return 2 * t # Test 1: Let v = t**3-10*t**2, f = 3*t**2 - 20*t
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from dymos.utils.testing_utils import assert_check_partials import dymos as dm from dymos.transcriptions.common.boundary_constraint_comp import BoundaryConstraintComp # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig BoundaryConstraintComp = CompWrapperConfig(BoundaryConstraintComp) class TestInitialScalarBoundaryValue(unittest.TestCase): def setUp(self): dm.options['include_check_partials'] = True self.p = om.Problem(model=om.Group()) ivp = self.p.model.add_subsystem('ivc', subsys=om.IndepVarComp(), promotes_outputs=['*']) ivp.add_output('x', val=np.arange(100)) self.p.model.add_design_var('x', lower=0, upper=100) bv_comp = self.p.model.add_subsystem( 'bv_comp', BoundaryConstraintComp(loc='initial'))
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from dymos.transcriptions.grid_data import GridData from dymos.transcriptions.pseudospectral.components import CollocationComp from dymos.transcriptions.pseudospectral.components.state_independents import StateIndependentsComp # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig CollocationComp = CompWrapperConfig(CollocationComp) StateIndependentsComp = CompWrapperConfig(StateIndependentsComp) class TestCollocationCompSolOpt(unittest.TestCase): # def setUp(self): def make_prob(self, transcription, n_segs, order, compressed): p = om.Problem(model=om.Group()) gd = GridData(num_segments=n_segs, segment_ends=np.arange(n_segs + 1), transcription=transcription, transcription_order=order, compressed=compressed)
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials from dymos.transcriptions.pseudospectral.components import CollocationComp from dymos.transcriptions.grid_data import GridData # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig CollocationComp = CompWrapperConfig(CollocationComp) class TestCollocationComp(unittest.TestCase): def setUp(self): transcription = 'gauss-lobatto' gd = GridData( num_segments=4, segment_ends=np.array([0., 2., 4., 5., 12.]), transcription=transcription, transcription_order=3) self.p = om.Problem(model=om.Group()) state_options = {'x': {'units': 'm', 'shape': (1,), 'fix_initial': True, 'fix_final': False, 'solve_segments': False, 'connected_initial': False, 'connected_final': False}, 'v': {'units': 'm/s', 'shape': (3, 2), 'fix_initial': False,
import unittest import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal from dymos.utils.testing_utils import assert_check_partials from dymos.transcriptions.runge_kutta.components.runge_kutta_state_predict_comp import \ RungeKuttaStatePredictComp import dymos as dm # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig RungeKuttaStatePredictComp = CompWrapperConfig(RungeKuttaStatePredictComp) class TestRKStatePredictComp(unittest.TestCase): def setUp(self) -> None: dm.options['include_check_partials'] = True def tearDown(self) -> None: dm.options['include_check_partials'] = False def test_rk_state_predict_comp_rk4(self): num_seg = 4 state_options = {'y': {'shape': (1, ), 'units': 'm'}} p = om.Problem(model=om.Group()) ivc = p.model.add_subsystem('ivc',
import unittest import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal from openmdao.utils.testing_utils import use_tempdirs from dymos.transcriptions.solve_ivp.components.segment_simulation_comp import SegmentSimulationComp from dymos.transcriptions.runge_kutta.test.rk_test_ode import TestODE from dymos.phase.options import TimeOptionsDictionary, StateOptionsDictionary from dymos.transcriptions.grid_data import GridData # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig SegmentSimulationComp = CompWrapperConfig(SegmentSimulationComp) @use_tempdirs class TestSegmentSimulationComp(unittest.TestCase): def test_simple_integration(self): p = om.Problem(model=om.Group()) time_options = TimeOptionsDictionary() time_options['units'] = 's' time_options['targets'] = 't' state_options = {} state_options['y'] = StateOptionsDictionary() state_options['y']['units'] = 'm' state_options['y']['targets'] = 'y' state_options['y']['rate_source'] = 'ydot'
import unittest import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal import dymos as dm from dymos.transcriptions.runge_kutta.components.runge_kutta_state_continuity_comp import \ RungeKuttaStateContinuityComp from dymos.utils.testing_utils import assert_check_partials # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig RungeKuttaStateContinuityComp = CompWrapperConfig( RungeKuttaStateContinuityComp) dm.options['include_check_partials'] = True class TestRungeKuttaContinuityComp(unittest.TestCase): def test_continuity_comp_scalar_no_iteration_fwd(self): num_seg = 4 state_options = { 'y': { 'shape': (1, ), 'units': 'm', 'targets': ['y'], 'defect_scaler': None, 'defect_ref': None, 'lower': None,
import unittest from parameterized import parameterized import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials from dymos.transcriptions.common import TimeComp from dymos.transcriptions.common.control_group import ControlInterpComp from dymos.transcriptions.grid_data import GridData # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig TimeComp = CompWrapperConfig(TimeComp) ControlInterpComp = CompWrapperConfig(ControlInterpComp) # Test 1: Let x = t**2, f = 2*t def f_a(t): return t**2 def f1_a(t): return 2 * t def f2_a(t): return 2.0 * np.ones_like(t)
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials from dymos.transcriptions.runge_kutta.components.runge_kutta_k_iter_group import RungeKuttaKIterGroup from dymos.transcriptions.runge_kutta.test.rk_test_ode import TestODE # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig RungeKuttaKIterGroup = CompWrapperConfig(RungeKuttaKIterGroup) class TestRungeKuttaKIterGroup(unittest.TestCase): def test_rk4_scalar_no_iteration(self): num_seg = 4 num_stages = 4 state_options = {'y': {'shape': (1, ), 'units': 'm', 'targets': ['y']}} p = om.Problem(model=om.Group()) ivc = p.model.add_subsystem('ivc', om.IndepVarComp(), promotes_outputs=['*']) ivc.add_output('initial_states_per_seg:y', shape=(num_seg, 1), units='m')
import itertools from parameterized import parameterized import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials, assert_near_equal from dymos.transcriptions.grid_data import GridData from dymos.transcriptions.common import GaussLobattoContinuityComp, RadauPSContinuityComp from dymos.phase.options import StateOptionsDictionary, ControlOptionsDictionary # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig GaussLobattoContinuityComp = CompWrapperConfig(GaussLobattoContinuityComp) RadauPSContinuityComp = CompWrapperConfig(RadauPSContinuityComp) class TestContinuityComp(unittest.TestCase): @parameterized.expand( itertools.product( ['gauss-lobatto', 'radau-ps'], # transcription ['compressed', 'uncompressed'], # compressed ), name_func=lambda f, n, p: '_'.join( ['test_continuity_comp', p.args[0], p.args[1]])) def test_continuity_comp(self, transcription='gauss-lobatto', compressed='compressed'):
import unittest import numpy as np from numpy.testing import assert_almost_equal import openmdao.api as om from openmdao.utils.assert_utils import assert_check_partials from dymos.phase.options import TimeOptionsDictionary, StateOptionsDictionary, \ ControlOptionsDictionary from dymos.transcriptions.common import EndpointConditionsComp # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig EndpointConditionsComp = CompWrapperConfig(EndpointConditionsComp) class TestEndpointConditionComp(unittest.TestCase): def test_scalar_state_and_control(self): n = 101 p = om.Problem(model=om.Group()) time_options = TimeOptionsDictionary() time_options['units'] = 's' state_options = {} state_options['x'] = StateOptionsDictionary() state_options['x']['units'] = 'm' state_options['x']['shape'] = (1, )
import numpy as np import openmdao.api as om from openmdao.utils.assert_utils import assert_near_equal from openmdao.utils.testing_utils import use_tempdirs import dymos as dm from dymos.transcriptions.runge_kutta.components.runge_kutta_state_advance_comp import \ RungeKuttaStateAdvanceComp from dymos.utils.testing_utils import assert_check_partials # Modify class so we can run it standalone. from dymos.utils.misc import CompWrapperConfig RungeKuttaStateAdvanceComp = CompWrapperConfig(RungeKuttaStateAdvanceComp) @use_tempdirs class TestRKStateAdvanceComp(unittest.TestCase): def setUp(self): dm.options['include_check_partials'] = True def tearDown(self): dm.options['include_check_partials'] = False def test_rk_state_advance_comp_rk4_scalar(self): state_options = {'y': {'shape': (1, ), 'units': 'm'}} p = om.Problem(model=om.Group())