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())
