def setUp(self):
gd = GridData(num_segments=2, segment_ends=np.array([0., 2., 4.]),
transcription='radau-ps', transcription_order=3)
self.gd = gd
self.p = om.Problem(model=om.Group())
control_opts = {'u': {'units': 'm', 'shape': (1,), 'dynamic': True, 'opt': True},
'v': {'units': 'm', 'shape': (3, 2), 'dynamic': True, 'opt': True}}
indep_comp = om.IndepVarComp()
self.p.model.add_subsystem('indep', indep_comp, promotes=['*'])
indep_comp.add_output('controls:u',
val=np.zeros((gd.subset_num_nodes['all'], 1)), units='m')
indep_comp.add_output('controls:v',
val=np.zeros((gd.subset_num_nodes['all'], 3, 2)), units='m')
self.p.model.add_subsystem('endpoint_defect_comp',
subsys=ControlEndpointDefectComp(grid_data=gd,
control_options=control_opts))
self.p.model.connect('controls:u', 'endpoint_defect_comp.controls:u')
self.p.model.connect('controls:v', 'endpoint_defect_comp.controls:v')
self.p.setup(force_alloc_complex=True)
self.p['controls:u'] = np.random.random((gd.subset_num_nodes['all'], 1))
self.p['controls:v'] = np.random.random((gd.subset_num_nodes['all'], 3, 2))
self.p.run_model()
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'
gd = GridData(num_segments=4, transcription='gauss-lobatto', transcription_order=3)
seg0_comp = SegmentSimulationComp(index=0, grid_data=gd, method='RK45',
atol=1.0E-9, rtol=1.0E-9,
ode_class=TestODE, time_options=time_options,
state_options=state_options)
p.model.add_subsystem('segment_0', subsys=seg0_comp)
p.setup(check=True)
p.set_val('segment_0.time', [0, 0.25, 0.5])
p.set_val('segment_0.initial_states:y', 0.5)
p.run_model()
assert_rel_error(self,
p.get_val('segment_0.states:y', units='m')[-1, ...],
1.425639364649936,
tolerance=1.0E-6)
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,
'fix_final': True, 'solve_segments': False,
'connected_initial': False, 'connected_final': False}}
indep_comp = om.IndepVarComp()
self.p.model.add_subsystem('indep', indep_comp, promotes_outputs=['*'])
indep_comp.add_output(
'dt_dstau',
val=np.zeros((gd.subset_num_nodes['col']))
)
indep_comp.add_output(
'f_approx:x',
val=np.zeros((gd.subset_num_nodes['col'], 1)), units='m')
indep_comp.add_output(
'f_computed:x',
val=np.zeros((gd.subset_num_nodes['col'], 1)), units='m')
indep_comp.add_output(
'f_approx:v',
val=np.zeros((gd.subset_num_nodes['col'], 3, 2)), units='m/s')
indep_comp.add_output(
'f_computed:v',
val=np.zeros((gd.subset_num_nodes['col'], 3, 2)), units='m/s')
self.p.model.add_subsystem('defect_comp',
subsys=CollocationComp(grid_data=gd,
state_options=state_options))
self.p.model.connect('f_approx:x', 'defect_comp.f_approx:x')
self.p.model.connect('f_approx:v', 'defect_comp.f_approx:v')
self.p.model.connect('f_computed:x', 'defect_comp.f_computed:x')
self.p.model.connect('f_computed:v', 'defect_comp.f_computed:v')
self.p.model.connect('dt_dstau', 'defect_comp.dt_dstau')
self.p.setup(force_alloc_complex=True)
self.p['dt_dstau'] = np.random.random(gd.subset_num_nodes['col'])
self.p['f_approx:x'] = np.random.random((gd.subset_num_nodes['col'], 1))
self.p['f_approx:v'] = np.random.random((gd.subset_num_nodes['col'], 3, 2))
self.p['f_computed:x'] = np.random.random((gd.subset_num_nodes['col'], 1))
self.p['f_computed:v'] = np.random.random((gd.subset_num_nodes['col'], 3, 2))
self.p.run_model()
def setUp(self):
dm.options['include_check_partials'] = True
transcription = 'radau-ps'
self.gd = gd = GridData(num_segments=2,
transcription_order=3,
segment_ends=[0.0, 3.0, 10.0],
transcription=transcription)
ndn = gd.subset_num_nodes['state_disc']
self.p = om.Problem(model=om.Group())
controls = {
'a': ControlOptionsDictionary(),
'b': ControlOptionsDictionary(),
'c': ControlOptionsDictionary(),
'd': ControlOptionsDictionary()
}
controls['a'].update({'units': 'm', 'shape': (1, ), 'opt': False})
controls['b'].update({'units': 's', 'shape': (3, ), 'opt': False})
controls['c'].update({'units': 'kg', 'shape': (3, 3), 'opt': False})
ivc = om.IndepVarComp()
self.p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('a_disc', val=np.zeros((ndn, 1)), units='m')
ivc.add_output('b_disc', val=np.zeros((ndn, 3)), units='s')
ivc.add_output('c_disc', val=np.zeros((ndn, 3, 3)), units='kg')
path_comp = PathConstraintComp(num_nodes=gd.num_nodes)
self.p.model.add_subsystem('path_constraints', subsys=path_comp)
path_comp._add_path_constraint_configure('a',
shape=(1, ),
lower=0,
upper=10,
units='m')
path_comp._add_path_constraint_configure('b',
shape=(3, ),
lower=0,
upper=10,
units='s')
path_comp._add_path_constraint_configure('c',
shape=(3, 3),
lower=0,
upper=10,
units='kg')
self.p.model.connect('a_disc', 'path_constraints.all_values:a')
self.p.model.connect('b_disc', 'path_constraints.all_values:b')
self.p.model.connect('c_disc', 'path_constraints.all_values:c')
self.p.setup()
self.p.run_model()
def setUp(self):
self.grid_data = gd = GridData(num_segments=3, segment_ends=np.array([0., 2., 4., 10.0]),
transcription='gauss-lobatto', transcription_order=[3, 3, 3])
num_disc_nodes = gd.subset_num_nodes['state_disc']
num_col_nodes = gd.subset_num_nodes['col']
self.p = om.Problem(model=om.Group())
state_options = {'u': {'units': 'm', 'shape': (1,)},
'v': {'units': 'm', 'shape': (3, 2)}}
ode_outputs = {'vehicle_cg': {'units': 'm', 'shape': (3,)}}
indep_comp = om.IndepVarComp()
self.p.model.add_subsystem('indep', indep_comp, promotes=['*'])
indep_comp.add_output('state_disc:u',
val=np.zeros((num_disc_nodes, 1)), units='m')
indep_comp.add_output('state_disc:v',
val=np.zeros((num_disc_nodes, 3, 2)), units='m')
indep_comp.add_output('state_col:u',
val=np.zeros((num_col_nodes, 1)), units='m')
indep_comp.add_output('state_col:v',
val=np.zeros((num_col_nodes, 3, 2)), units='m')
indep_comp.add_output('ode_disc:cg',
val=np.zeros((num_disc_nodes, 3)), units='m')
indep_comp.add_output('ode_col:cg',
val=np.zeros((num_col_nodes, 3)), units='m')
glic = self.p.model.add_subsystem('interleave_comp',
subsys=GaussLobattoInterleaveComp(grid_data=gd))
glic.add_var('u', **state_options['u'])
glic.add_var('v', **state_options['v'])
glic.add_var('vehicle_cg', **ode_outputs['vehicle_cg'])
self.p.model.connect('state_disc:u', 'interleave_comp.disc_values:u')
self.p.model.connect('state_disc:v', 'interleave_comp.disc_values:v')
self.p.model.connect('state_col:u', 'interleave_comp.col_values:u')
self.p.model.connect('state_col:v', 'interleave_comp.col_values:v')
self.p.model.connect('ode_disc:cg', 'interleave_comp.disc_values:vehicle_cg')
self.p.model.connect('ode_col:cg', 'interleave_comp.col_values:vehicle_cg')
self.p.setup(force_alloc_complex=True)
self.p['state_disc:u'] = np.random.random((num_disc_nodes, 1))
self.p['state_disc:v'] = np.random.random((num_disc_nodes, 3, 2))
self.p['state_col:u'] = np.random.random((num_col_nodes, 1))
self.p['state_col:v'] = np.random.random((num_col_nodes, 3, 2))
self.p.run_model()
def test_state_interp_comp_lobatto_vectorized_different_orders(self):
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order=[3, 5],
segment_ends=segends,
transcription='gauss-lobatto')
p = om.Problem(model=om.Group())
states = {'pos': {'units': 'm', 'shape': (2,)}}
X_ivc = om.IndepVarComp()
p.model.add_subsystem('X_ivc', X_ivc, promotes=['state_disc:pos'])
X_ivc.add_output('state_disc:pos',
val=np.zeros((gd.subset_num_nodes['state_disc'], 2)), units='m')
F_ivc = om.IndepVarComp()
p.model.add_subsystem('F_ivc', F_ivc, promotes=['staterate_disc:pos'])
F_ivc.add_output('staterate_disc:pos',
val=np.zeros((gd.subset_num_nodes['state_disc'], 2)),
units='m/s')
dt_dtau_ivc = om.IndepVarComp()
p.model.add_subsystem('dt_dstau_ivc', dt_dtau_ivc, promotes=['dt_dstau'])
dt_dtau_ivc.add_output('dt_dstau', val=0.0*np.zeros(gd.subset_num_nodes['col']), units='s')
p.model.add_subsystem('state_interp_comp',
subsys=StateInterpComp(transcription='gauss-lobatto',
grid_data=gd,
state_options=states,
time_units='s'))
p.model.connect('state_disc:pos', 'state_interp_comp.state_disc:pos')
p.model.connect('staterate_disc:pos', 'state_interp_comp.staterate_disc:pos')
p.model.connect('dt_dstau', 'state_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
segends_disc = np.array((0, 3, 3, 6.5, 10))
p['state_disc:pos'][:, 0] = [x(t) for t in segends_disc] # [0.0, 25.0, 25.0, 100.0]
p['staterate_disc:pos'][:, 0] = [f_x(t) for t in segends_disc]
p['state_disc:pos'][:, 1] = [v(t) for t in segends_disc]
p['staterate_disc:pos'][:, 1] = [f_v(t) for t in segends_disc]
p['dt_dstau'] = [3.0/2., 7.0/2, 7.0/2]
p.run_model()
cpd = p.check_partials(compact_print=True, method='cs')
assert_check_partials(cpd, atol=5.0E-5)
def test_results_radau(self):
gd = GridData(num_segments=3,
transcription_order=[5, 3, 3],
segment_ends=_segends,
transcription='radau-ps')
p = om.Problem(model=om.Group())
ivc = p.model.add_subsystem(name='ivc', subsys=om.IndepVarComp(), promotes_outputs=['*'])
ivc.add_output('t_initial', val=0.0, units='s')
ivc.add_output('t_duration', val=100.0, units='s')
p.model.add_subsystem('time',
TimeComp(num_nodes=gd.num_nodes, node_ptau=gd.node_ptau,
node_dptau_dstau=gd.node_dptau_dstau, units='s'))
p.model.connect('t_initial', 'time.t_initial')
p.model.connect('t_duration', 'time.t_duration')
p.setup(check=True, force_alloc_complex=True)
p.run_model()
# Affine transform the nodes [0, 100]
dt_dptau = (p['t_duration'] - p['t_initial']) / 2.0
nodes = []
dt_dstau_per_node = []
for i in range(gd.num_segments):
a, b = gd.segment_ends[i], gd.segment_ends[i + 1] # segment ends in phase tau space
# ratio of phase tau to segment tau within the segment
dptau_dstau = (b - a) / 2.0
dt_dstau = dt_dptau * dptau_dstau * np.ones(gd.subset_num_nodes_per_segment['all'][i])
dt_dstau_per_node.extend(dt_dstau.tolist())
# nodes of current segment in segment tau space
nodes_segi_stau = _lgr_nodes[gd.transcription_order[i]]
# nodes of current segment in phase tau space
nodes_segi_ptau = a + (nodes_segi_stau + 1) * dptau_dstau
# nodes in time
nodes_time = (nodes_segi_ptau + 1) * dt_dptau
nodes.extend(nodes_time.tolist())
assert_almost_equal(p['time.time'], nodes, decimal=4)
assert_almost_equal(p['time.dt_dstau'], dt_dstau_per_node)
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)
state_options = {
'x': {
'units': 'm',
'shape': (1, ),
'fix_initial': True,
'fix_final': False,
'solve_segments': True,
'connected_initial': False,
'connected_final': False
},
'v': {
'units': 'm/s',
'shape': (3, 2),
'fix_initial': False,
'fix_final': True,
'solve_segments': True,
'connected_initial': False,
'connected_final': False
}
}
subsys = StateIndependentsComp(grid_data=gd,
state_options=state_options)
p.model.add_subsystem('defect_comp', subsys=subsys)
self.state_idx_map = {}
for state_name, options in state_options.items():
self._make_state_idx_map(state_name, options, gd,
self.state_idx_map)
subsys.configure_io(self.state_idx_map)
p.setup()
p.final_setup()
return p
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'
# Non-standard way to assign state options, so we need this
state_options['y']['shape'] = (1, )
gd = GridData(num_segments=4, transcription='gauss-lobatto', transcription_order=3)
sim_options = SimulateOptionsDictionary()
sim_options['rtol'] = 1.0E-9
sim_options['atol'] = 1.0E-9
seg0_comp = SegmentSimulationComp(index=0, grid_data=gd, simulate_options=sim_options,
ode_class=TestODE, time_options=time_options,
state_options=state_options)
p.model.add_subsystem('segment_0', subsys=seg0_comp)
p.setup(check=True)
p.set_val('segment_0.time', [0, 0.25, 0.5])
p.set_val('segment_0.initial_states:y', 0.5)
p.run_model()
assert_near_equal(p.get_val('segment_0.states:y', units='m')[-1, ...],
1.425639364649936,
tolerance=1.0E-6)
def test_state_interp_comp_radau(self):
gd = GridData(num_segments=1,
transcription_order=3,
segment_ends=np.array([0, 10]),
transcription='radau-ps')
p = om.Problem(model=om.Group())
states = {
'x': {
'units': 'm',
'shape': (1, )
},
'v': {
'units': 'm/s',
'shape': (1, )
}
}
X_ivc = om.IndepVarComp()
p.model.add_subsystem('X_ivc',
X_ivc,
promotes=['state_disc:x', 'state_disc:v'])
X_ivc.add_output('state_disc:x',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m')
X_ivc.add_output('state_disc:v',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m/s')
dt_dtau_ivc = om.IndepVarComp()
dt_dtau_ivc.add_output('dt_dstau',
val=0.0 * np.zeros(gd.subset_num_nodes['col']),
units='s')
p.model.add_subsystem('dt_dstau_ivc',
dt_dtau_ivc,
promotes=['dt_dstau'])
p.model.add_subsystem('state_interp_comp',
subsys=StateInterpComp(transcription='radau-ps',
grid_data=gd,
state_options=states,
time_units='s'))
p.model.connect('state_disc:x', 'state_interp_comp.state_disc:x')
p.model.connect('state_disc:v', 'state_interp_comp.state_disc:v')
p.model.connect('dt_dstau', 'state_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
lgr_nodes, lgr_weights = lgr(3, include_endpoint=True)
t_disc = (lgr_nodes + 1.0) * 5.0
t_col = t_disc[:-1]
# Test 1: Let x = t**2, f = 2*t
p['state_disc:x'] = t_disc**2
# Test 1: Let v = t**3-10*t**2, f = 3*t**2 - 20*t
p['state_disc:v'] = t_disc**3 - 10 * t_disc**2
p['dt_dstau'] = 10 / 2.0
p.run_model()
if SHOW_PLOTS: # pragma: no cover
f, ax = plt.subplots(2, 1)
t_disc = np.array([0, 5, 10])
t_col = np.array([2.5, 7.5])
t = np.linspace(0, 10, 100)
x1 = t**2
xdot1 = 2 * t
x2 = t**3 - 10 * t**2
xdot2 = 3 * t**2 - 20 * t
ax[0].plot(t, x1, 'b-', label='$x$')
ax[0].plot(t, xdot1, 'b--', label='$\dot{x}$')
ax[0].plot(t_disc, p['state_disc:x'], 'bo', label='$X_d:x$')
ax[0].plot(t_col,
p['state_interp_comp.state_col:x'],
'bv',
label='$X_c:x$')
ax[0].plot(t_col,
p['state_interp_comp.staterate_col:x'],
marker='v',
color='None',
mec='b',
label='$Xdot_c:x$')
ax[1].plot(t, x2, 'r-', label='$v$')
ax[1].plot(t, xdot2, 'r--', label='$\dot{v}$')
ax[1].plot(t_disc, p['state_disc:v'], 'ro', label='$X_d:v$')
ax[1].plot(t_col,
p['state_interp_comp.state_col:v'],
'rv',
label='$X_c:v$')
ax[1].plot(t_col,
p['state_interp_comp.staterate_col:v'],
marker='v',
color='None',
mec='r',
label='$Xdot_c:v$')
ax[0].legend(loc='upper left', ncol=3)
ax[1].legend(loc='upper left', ncol=3)
plt.show()
# Test 1
assert_almost_equal(p['state_interp_comp.staterate_col:x'][:, 0],
2 * t_col)
# Test 2
assert_almost_equal(p['state_interp_comp.staterate_col:v'][:, 0],
3 * t_col**2 - 20 * t_col)
cpd = p.check_partials(compact_print=True, method='cs')
assert_check_partials(cpd, atol=1.0E-5)
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)
state_options = {
'x': {
'units': 'm',
'shape': (1, ),
'fix_initial': True,
'fix_final': False,
'solve_segments': False,
'connected_initial': False
},
'v': {
'units': 'm/s',
'shape': (3, 2),
'fix_initial': False,
'fix_final': True,
'solve_segments': True,
'connected_initial': False
}
}
indep_comp = om.IndepVarComp()
p.model.add_subsystem('indep', indep_comp, promotes_outputs=['*'])
indep_comp.add_output('dt_dstau',
val=np.zeros((gd.subset_num_nodes['col'])))
indep_comp.add_output('f_approx:x',
val=np.zeros((gd.subset_num_nodes['col'], 1)),
units='m')
indep_comp.add_output('f_computed:x',
val=np.zeros((gd.subset_num_nodes['col'], 1)),
units='m')
indep_comp.add_output('f_approx:v',
val=np.zeros((gd.subset_num_nodes['col'], 3, 2)),
units='m/s')
indep_comp.add_output('f_computed:v',
val=np.zeros((gd.subset_num_nodes['col'], 3, 2)),
units='m/s')
p.model.add_subsystem('defect_comp',
subsys=CollocationComp(
grid_data=gd, state_options=state_options))
indep = StateIndependentsComp(grid_data=gd,
state_options=state_options)
p.model.add_subsystem('state_indep', indep, promotes_outputs=['*'])
p.model.connect('f_approx:x', 'defect_comp.f_approx:x')
p.model.connect('f_approx:v', 'defect_comp.f_approx:v')
p.model.connect('f_computed:x', 'defect_comp.f_computed:x')
p.model.connect('f_computed:v', 'defect_comp.f_computed:v')
p.model.connect('dt_dstau', 'defect_comp.dt_dstau')
p.model.connect('defect_comp.defects:v', 'state_indep.defects:v')
p.setup(force_alloc_complex=True)
p['dt_dstau'] = np.random.random(gd.subset_num_nodes['col'])
p['f_approx:x'] = np.random.random((gd.subset_num_nodes['col'], 1))
p['f_approx:v'] = np.random.random((gd.subset_num_nodes['col'], 3, 2))
p['f_computed:x'] = np.random.random((gd.subset_num_nodes['col'], 1))
p['f_computed:v'] = np.random.random(
(gd.subset_num_nodes['col'], 3, 2))
p.run_model()
p.model.run_apply_nonlinear()
# p.model.list_outputs(residuals=True, print_arrays=True)
return p
def test_polynomial_control_group_matrix_rungekutta(self):
transcription = 'runge-kutta'
compressed = True
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order='RK4',
segment_ends=segends,
transcription=transcription,
compressed=compressed)
p = om.Problem(model=om.Group())
controls = {'a': PolynomialControlOptionsDictionary()}
controls['a']['units'] = 'm'
controls['a']['order'] = 3
controls['a']['opt'] = True
controls['a']['shape'] = (3, 1)
ivc = om.IndepVarComp()
p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('t_initial', val=0.0, units='s')
ivc.add_output('t_duration', val=10.0, units='s')
p.model.add_subsystem('time_comp',
subsys=TimeComp(num_nodes=gd.num_nodes, node_ptau=gd.node_ptau,
node_dptau_dstau=gd.node_dptau_dstau, units='s'),
promotes_inputs=['t_initial', 't_duration'],
promotes_outputs=['time', 'dt_dstau'])
polynomial_control_group = PolynomialControlGroup(grid_data=gd,
polynomial_control_options=controls,
time_units='s')
p.model.add_subsystem('polynomial_control_group',
subsys=polynomial_control_group,
promotes_inputs=['*'],
promotes_outputs=['*'])
# p.model.connect('dt_dstau', 'control_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
p['t_initial'] = 0.0
p['t_duration'] = 3.0
p.run_model()
control_nodes_ptau, _ = lgl(controls['a']['order'] + 1)
t_control_input = p['t_initial'] + 0.5 * (control_nodes_ptau + 1) * p['t_duration']
t_all = p['time']
p['polynomial_controls:a'][:, 0, 0] = f_a(t_control_input)
p['polynomial_controls:a'][:, 1, 0] = f_b(t_control_input)
p['polynomial_controls:a'][:, 2, 0] = f_c(t_control_input)
p.run_model()
a0_value_expected = f_a(t_all)
a1_value_expected = f_b(t_all)
a2_value_expected = f_c(t_all)
a0_rate_expected = f1_a(t_all)
a1_rate_expected = f1_b(t_all)
a2_rate_expected = f1_c(t_all)
a0_rate2_expected = f2_a(t_all)
a1_rate2_expected = f2_b(t_all)
a2_rate2_expected = f2_c(t_all)
assert_almost_equal(p['polynomial_control_values:a'][:, 0, 0],
a0_value_expected)
assert_almost_equal(p['polynomial_control_values:a'][:, 1, 0],
a1_value_expected)
assert_almost_equal(p['polynomial_control_values:a'][:, 2, 0],
a2_value_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate'][:, 0, 0],
a0_rate_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate'][:, 1, 0],
a1_rate_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate'][:, 2, 0],
a2_rate_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate2'][:, 0, 0],
a0_rate2_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate2'][:, 1, 0],
a1_rate2_expected)
assert_almost_equal(p['polynomial_control_rates:a_rate2'][:, 2, 0],
a2_rate2_expected)
np.set_printoptions(linewidth=1024)
cpd = p.check_partials(method='cs', out_stream=None)
assert_check_partials(cpd)
def test_polynomial_control_group_scalar_gl(self):
transcription = 'gauss-lobatto'
compressed = True
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order=5,
segment_ends=segends,
transcription=transcription,
compressed=compressed)
p = om.Problem(model=om.Group())
controls = {
'a': PolynomialControlOptionsDictionary(),
'b': PolynomialControlOptionsDictionary()
}
controls['a']['units'] = 'm'
controls['a']['order'] = 3
controls['a']['shape'] = (1, )
controls['a']['opt'] = True
controls['b']['units'] = 'm'
controls['b']['order'] = 3
controls['b']['shape'] = (1, )
controls['b']['opt'] = True
ivc = om.IndepVarComp()
p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('t_initial', val=0.0, units='s')
ivc.add_output('t_duration', val=10.0, units='s')
p.model.add_subsystem('time_comp',
subsys=TimeComp(
num_nodes=gd.num_nodes,
node_ptau=gd.node_ptau,
node_dptau_dstau=gd.node_dptau_dstau,
units='s'),
promotes_inputs=['t_initial', 't_duration'],
promotes_outputs=['time', 'dt_dstau'])
polynomial_control_group = PolynomialControlGroup(
grid_data=gd, polynomial_control_options=controls, time_units='s')
p.model.add_subsystem('polynomial_control_group',
subsys=polynomial_control_group,
promotes_inputs=['*'],
promotes_outputs=['*'])
p.setup(force_alloc_complex=True)
p['t_initial'] = 0.0
p['t_duration'] = 3.0
p.run_model()
control_nodes_ptau, _ = lgl(controls['a']['order'] + 1)
t_control_input = p['t_initial'] + 0.5 * (control_nodes_ptau +
1) * p['t_duration']
t_all = p['time']
p['polynomial_controls:a'][:, 0] = f_a(t_control_input)
p['polynomial_controls:b'][:, 0] = f_b(t_control_input)
p.run_model()
a_value_expected = f_a(t_all)
b_value_expected = f_b(t_all)
a_rate_expected = f1_a(t_all)
b_rate_expected = f1_b(t_all)
a_rate2_expected = f2_a(t_all)
b_rate2_expected = f2_b(t_all)
assert_almost_equal(p['polynomial_control_values:a'],
np.atleast_2d(a_value_expected).T)
assert_almost_equal(p['polynomial_control_values:b'],
np.atleast_2d(b_value_expected).T)
assert_almost_equal(p['polynomial_control_rates:a_rate'],
np.atleast_2d(a_rate_expected).T)
assert_almost_equal(p['polynomial_control_rates:b_rate'],
np.atleast_2d(b_rate_expected).T)
assert_almost_equal(p['polynomial_control_rates:a_rate2'],
np.atleast_2d(a_rate2_expected).T)
assert_almost_equal(p['polynomial_control_rates:b_rate2'],
np.atleast_2d(b_rate2_expected).T)
np.set_printoptions(linewidth=1024)
cpd = p.check_partials(compact_print=False,
out_stream=None,
method='cs')
assert_check_partials(cpd)
def test_control_interp_matrix_2x2(self,
transcription='gauss-lobatto',
compressed=True):
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order=5,
segment_ends=segends,
transcription=transcription,
compressed=compressed)
p = om.Problem(model=om.Group())
controls = {'a': {'units': 'm', 'shape': (2, 2), 'dynamic': True}}
ivc = om.IndepVarComp()
p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('controls:a',
val=np.zeros(
(gd.subset_num_nodes['control_input'], 2, 2)),
units='m')
ivc.add_output('t_initial', val=0.0, units='s')
ivc.add_output('t_duration', val=10.0, units='s')
p.model.add_subsystem('time_comp',
subsys=TimeComp(
num_nodes=gd.num_nodes,
node_ptau=gd.node_ptau,
node_dptau_dstau=gd.node_dptau_dstau,
units='s'),
promotes_inputs=['t_initial', 't_duration'],
promotes_outputs=['time', 'dt_dstau'])
p.model.add_subsystem('control_interp_comp',
subsys=ControlInterpComp(
grid_data=gd,
control_options=controls,
time_units='s'),
promotes_inputs=['controls:*'])
p.model.connect('dt_dstau', 'control_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
p['t_initial'] = 0.0
p['t_duration'] = 3.0
p.run_model()
t = p['time']
control_input_idxs = gd.subset_node_indices['control_input']
p['controls:a'][:, 0, 0] = f_a(t[control_input_idxs])
p['controls:a'][:, 0, 1] = f_b(t[control_input_idxs])
p['controls:a'][:, 1, 0] = f_c(t[control_input_idxs])
p['controls:a'][:, 1, 1] = f_d(t[control_input_idxs])
p.run_model()
a0_value_expected = f_a(t)
a1_value_expected = f_b(t)
a2_value_expected = f_c(t)
a3_value_expected = f_d(t)
a0_rate_expected = f1_a(t)
a1_rate_expected = f1_b(t)
a2_rate_expected = f1_c(t)
a3_rate_expected = f1_d(t)
a0_rate2_expected = f2_a(t)
a1_rate2_expected = f2_b(t)
a2_rate2_expected = f2_c(t)
a3_rate2_expected = f2_d(t)
assert_almost_equal(p['control_interp_comp.control_values:a'][:, 0, 0],
a0_value_expected)
assert_almost_equal(p['control_interp_comp.control_values:a'][:, 0, 1],
a1_value_expected)
assert_almost_equal(p['control_interp_comp.control_values:a'][:, 1, 0],
a2_value_expected)
assert_almost_equal(p['control_interp_comp.control_values:a'][:, 1, 1],
a3_value_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate'][:, 0, 0],
a0_rate_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate'][:, 0, 1],
a1_rate_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate'][:, 1, 0],
a2_rate_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate'][:, 1, 1],
a3_rate_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate2'][:, 0, 0],
a0_rate2_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate2'][:, 0, 1],
a1_rate2_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate2'][:, 1, 0],
a2_rate2_expected)
assert_almost_equal(
p['control_interp_comp.control_rates:a_rate2'][:, 1, 1],
a3_rate2_expected)
with np.printoptions(linewidth=100000, edgeitems=100000):
cpd = p.check_partials(compact_print=True, method='cs')
assert_check_partials(cpd)
def test_state_interp_comp_lobatto(self):
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order=3,
segment_ends=segends,
transcription='gauss-lobatto')
p = om.Problem(model=om.Group())
states = {
'x': {
'units': 'm',
'shape': (1, )
},
'v': {
'units': 'm/s',
'shape': (1, )
}
}
X_ivc = om.IndepVarComp()
p.model.add_subsystem('X_ivc',
X_ivc,
promotes=['state_disc:x', 'state_disc:v'])
X_ivc.add_output('state_disc:x',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m')
X_ivc.add_output('state_disc:v',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m/s')
F_ivc = om.IndepVarComp()
p.model.add_subsystem(
'F_ivc', F_ivc, promotes=['staterate_disc:x', 'staterate_disc:v'])
F_ivc.add_output('staterate_disc:x',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m/s')
F_ivc.add_output('staterate_disc:v',
val=np.zeros(gd.subset_num_nodes['state_disc']),
units='m/s**2')
dt_dtau_ivc = om.IndepVarComp()
p.model.add_subsystem('dt_dstau_ivc',
dt_dtau_ivc,
promotes=['dt_dstau'])
dt_dtau_ivc.add_output('dt_dstau',
val=0.0 * np.zeros(gd.subset_num_nodes['col']),
units='s')
p.model.add_subsystem('state_interp_comp',
subsys=StateInterpComp(
transcription='gauss-lobatto',
grid_data=gd,
state_options=states,
time_units='s'))
p.model.connect('state_disc:x', 'state_interp_comp.state_disc:x')
p.model.connect('state_disc:v', 'state_interp_comp.state_disc:v')
p.model.connect('staterate_disc:x',
'state_interp_comp.staterate_disc:x')
p.model.connect('staterate_disc:v',
'state_interp_comp.staterate_disc:v')
p.model.connect('dt_dstau', 'state_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
segends_disc = segends[np.array((0, 1, 1, 2), dtype=int)]
p['state_disc:x'] = [x(t) for t in segends_disc]
p['staterate_disc:x'] = [f_x(t) for t in segends_disc]
p['state_disc:v'] = [v(t) for t in segends_disc]
p['staterate_disc:v'] = [f_v(t) for t in segends_disc]
p['dt_dstau'] = (segends[1:] - segends[:-1]) / 2.0
p.run_model()
t_disc = segends_disc
t_col = (segends[1:] + segends[:-1]) / 2.0
if SHOW_PLOTS: # pragma: no cover
f, ax = plt.subplots(2, 1)
t = np.linspace(0, 10, 100)
x1 = x(t)
xdot1 = f_x(t)
x2 = v(t)
xdot2 = f_v(t)
ax[0].plot(t, x1, 'b-', label='$x$')
ax[0].plot(t, xdot1, 'b--', label=r'$\dot{x}$')
ax[0].plot(t_disc, p['state_disc:x'], 'bo', label='$X_d:x$')
ax[0].plot(t_col,
p['state_interp_comp.state_col:x'],
'bv',
label='$X_c:x$')
ax[0].plot(t_col,
p['state_interp_comp.staterate_col:x'],
marker='v',
color='None',
mec='b',
label='$Xdot_c:x$')
ax[1].plot(t, x2, 'r-', label='$v$')
ax[1].plot(t, xdot2, 'r--', label=r'$\dot{v}$')
ax[1].plot(t_disc, p['state_disc:v'], 'ro', label='$X_d:v$')
ax[1].plot(t_col,
p['state_interp_comp.state_col:v'],
'rv',
label='$X_c:v$')
ax[1].plot(t_col,
p['state_interp_comp.staterate_col:v'],
marker='v',
color='None',
mec='r',
label='$Xdot_c:v$')
ax[0].legend(loc='upper left', ncol=3)
ax[1].legend(loc='upper left', ncol=3)
plt.show()
# Test 1
assert_almost_equal(p['state_interp_comp.state_col:x'][:, 0], x(t_col))
assert_almost_equal(p['state_interp_comp.staterate_col:x'][:, 0],
f_x(t_col))
# Test 2
assert_almost_equal(p['state_interp_comp.state_col:v'][:, 0], v(t_col))
assert_almost_equal(p['state_interp_comp.staterate_col:v'][:, 0],
f_v(t_col))
cpd = p.check_partials(compact_print=True, method='cs')
assert_check_partials(cpd, atol=5.0E-5)
def setUp(self):
transcription = 'runge-kutta'
self.gd = gd = GridData(num_segments=2,
transcription_order='RK4',
segment_ends=[0.0, 3.0, 10.0],
transcription=transcription)
nn = 4
self.p = Problem(model=Group())
controls = {
'a': ControlOptionsDictionary(),
'b': ControlOptionsDictionary(),
'c': ControlOptionsDictionary(),
'd': ControlOptionsDictionary()
}
controls['a'].update({'units': 'm', 'shape': (1, ), 'opt': False})
controls['b'].update({'units': 's', 'shape': (3, ), 'opt': False})
controls['c'].update({'units': 'kg', 'shape': (3, 3), 'opt': False})
ivc = IndepVarComp()
self.p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('a_disc', val=np.zeros((nn, 1)), units='m')
ivc.add_output('b_disc', val=np.zeros((nn, 3)), units='s')
ivc.add_output('c_disc', val=np.zeros((nn, 3, 3)), units='kg')
path_comp = RungeKuttaPathConstraintComp(grid_data=gd)
self.p.model.add_subsystem('path_constraints', subsys=path_comp)
path_comp._add_path_constraint('a',
var_class='ode',
shape=(1, ),
lower=0,
upper=10,
units='m')
path_comp._add_path_constraint('b',
var_class='input_control',
shape=(3, ),
lower=0,
upper=10,
units='s')
path_comp._add_path_constraint('c',
var_class='control_rate2',
shape=(3, 3),
lower=0,
upper=10,
units='kg')
self.p.model.connect('a_disc', 'path_constraints.all_values:a')
self.p.model.connect('b_disc', 'path_constraints.all_values:b')
self.p.model.connect('c_disc', 'path_constraints.all_values:c')
self.p.setup()
self.p.run_model()
def make_prob(self, transcription, n_segs, order, compressed):
gd = GridData(num_segments=n_segs,
segment_ends=np.arange(n_segs + 1),
transcription=transcription,
transcription_order=order,
compressed=compressed)
state_options = {
'x': {
'units': 'm',
'shape': (1, ),
'fix_initial': True,
'fix_final': False,
'solve_segments': True,
'connected_initial': False
},
'v': {
'units': 'm/s',
'shape': (3, 2),
'fix_initial': True,
'fix_final': False,
'solve_segments': True,
'connected_initial': False
}
}
num_col_nodes = gd.subset_num_nodes['col']
num_col_nodes_per_seg = gd.subset_num_nodes_per_segment['col']
p = om.Problem(model=om.Group())
indep_comp = om.IndepVarComp()
p.model.add_subsystem('indep', indep_comp, promotes_outputs=['*'])
indep_comp.add_output('dt_dstau',
val=np.repeat(
np.arange(n_segs) + 1,
num_col_nodes_per_seg))
indep_comp.add_output('f_approx:x',
val=np.ones((num_col_nodes, 1)),
units='m')
indep_comp.add_output('f_computed:x',
val=np.ones((num_col_nodes, 1)) * 2,
units='m')
indep_comp.add_output('f_approx:v',
val=np.ones((num_col_nodes, 3, 2)),
units='m/s')
indep_comp.add_output('f_computed:v',
val=np.ones((num_col_nodes, 3, 2)) * 2,
units='m/s')
p.model.add_subsystem('defect_comp',
subsys=CollocationComp(
grid_data=gd, state_options=state_options))
indep = StateIndependentsComp(grid_data=gd,
state_options=state_options)
p.model.add_subsystem('state_indep', indep, promotes_outputs=['*'])
p.model.connect('f_approx:x', 'defect_comp.f_approx:x')
p.model.connect('f_approx:v', 'defect_comp.f_approx:v')
p.model.connect('f_computed:x', 'defect_comp.f_computed:x')
p.model.connect('f_computed:v', 'defect_comp.f_computed:v')
p.model.connect('dt_dstau', 'defect_comp.dt_dstau')
p.model.connect('defect_comp.defects:x', 'state_indep.defects:x')
p.model.connect('defect_comp.defects:v', 'state_indep.defects:v')
p.setup(force_alloc_complex=True)
return p
def test_control_interp_scalar(self,
transcription='gauss-lobatto',
compressed=True):
segends = np.array([0.0, 3.0, 10.0])
gd = GridData(num_segments=2,
transcription_order=5,
segment_ends=segends,
transcription=transcription,
compressed=compressed)
p = om.Problem(model=om.Group())
controls = {
'a': {
'units': 'm',
'shape': (1, ),
'dynamic': True
},
'b': {
'units': 'm',
'shape': (1, ),
'dynamic': True
}
}
ivc = om.IndepVarComp()
p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('controls:a',
val=np.zeros((gd.subset_num_nodes['control_input'], 1)),
units='m')
ivc.add_output('controls:b',
val=np.zeros((gd.subset_num_nodes['control_input'], 1)),
units='m')
ivc.add_output('t_initial', val=0.0, units='s')
ivc.add_output('t_duration', val=10.0, units='s')
p.model.add_subsystem('time_comp',
subsys=TimeComp(
num_nodes=gd.num_nodes,
node_ptau=gd.node_ptau,
node_dptau_dstau=gd.node_dptau_dstau,
units='s'),
promotes_inputs=['t_initial', 't_duration'],
promotes_outputs=['time', 'dt_dstau'])
p.model.add_subsystem('control_interp_comp',
subsys=ControlInterpComp(
grid_data=gd,
control_options=controls,
time_units='s'),
promotes_inputs=['controls:*'])
p.model.connect('dt_dstau', 'control_interp_comp.dt_dstau')
p.setup(force_alloc_complex=True)
p['t_initial'] = 0.0
p['t_duration'] = 3.0
p.run_model()
t = p['time']
p['controls:a'][:, 0] = f_a(t[gd.subset_node_indices['control_input']])
p['controls:b'][:, 0] = f_b(t[gd.subset_node_indices['control_input']])
p.run_model()
a_value_expected = f_a(t)
b_value_expected = f_b(t)
a_rate_expected = f1_a(t)
b_rate_expected = f1_b(t)
a_rate2_expected = f2_a(t)
b_rate2_expected = f2_b(t)
assert_almost_equal(p['control_interp_comp.control_values:a'],
np.atleast_2d(a_value_expected).T)
assert_almost_equal(p['control_interp_comp.control_values:b'],
np.atleast_2d(b_value_expected).T)
assert_almost_equal(p['control_interp_comp.control_rates:a_rate'],
np.atleast_2d(a_rate_expected).T)
assert_almost_equal(p['control_interp_comp.control_rates:b_rate'],
np.atleast_2d(b_rate_expected).T)
assert_almost_equal(p['control_interp_comp.control_rates:a_rate2'],
np.atleast_2d(a_rate2_expected).T)
assert_almost_equal(p['control_interp_comp.control_rates:b_rate2'],
np.atleast_2d(b_rate2_expected).T)
np.set_printoptions(linewidth=1024)
cpd = p.check_partials(compact_print=False,
out_stream=None,
method='cs')
assert_check_partials(cpd)
def test_continuity_comp(self, transcription='gauss-lobatto', compressed='compressed'):
num_seg = 3
gd = GridData(num_segments=num_seg,
transcription_order=[5, 3, 3],
segment_ends=[0.0, 3.0, 10.0, 20],
transcription=transcription,
compressed=compressed == 'compressed')
self.p = om.Problem(model=om.Group())
ivp = self.p.model.add_subsystem('ivc', subsys=om.IndepVarComp(), promotes_outputs=['*'])
nn = gd.subset_num_nodes['all']
ivp.add_output('x', val=np.arange(nn), units='m')
ivp.add_output('y', val=np.arange(nn), units='m/s')
ivp.add_output('u', val=np.zeros((nn, 3)), units='deg')
ivp.add_output('v', val=np.arange(nn), units='N')
ivp.add_output('u_rate', val=np.zeros((nn, 3)), units='deg/s')
ivp.add_output('v_rate', val=np.arange(nn), units='N/s')
ivp.add_output('u_rate2', val=np.zeros((nn, 3)), units='deg/s**2')
ivp.add_output('v_rate2', val=np.arange(nn), units='N/s**2')
ivp.add_output('t_duration', val=121.0, units='s')
self.p.model.add_design_var('x', lower=0, upper=100)
state_options = {'x': StateOptionsDictionary(),
'y': StateOptionsDictionary()}
control_options = {'u': ControlOptionsDictionary(),
'v': ControlOptionsDictionary()}
state_options['x']['units'] = 'm'
state_options['y']['units'] = 'm/s'
control_options['u']['units'] = 'deg'
control_options['u']['shape'] = (3,)
control_options['u']['continuity'] = True
control_options['v']['units'] = 'N'
if transcription == 'gauss-lobatto':
cnty_comp = GaussLobattoContinuityComp(grid_data=gd, time_units='s',
state_options=state_options,
control_options=control_options)
elif transcription == 'radau-ps':
cnty_comp = RadauPSContinuityComp(grid_data=gd, time_units='s',
state_options=state_options,
control_options=control_options)
else:
raise ValueError('unrecognized transcription')
self.p.model.add_subsystem('cnty_comp', subsys=cnty_comp)
# The sub-indices of state_disc indices that are segment ends
num_seg_ends = gd.subset_num_nodes['segment_ends']
segment_end_idxs = np.reshape(gd.subset_node_indices['segment_ends'],
newshape=(num_seg_ends, 1))
if compressed != 'compressed':
self.p.model.connect('x', 'cnty_comp.states:x', src_indices=segment_end_idxs)
self.p.model.connect('y', 'cnty_comp.states:y', src_indices=segment_end_idxs)
self.p.model.connect('t_duration', 'cnty_comp.t_duration')
size_u = nn * np.prod(control_options['u']['shape'])
src_idxs_u = np.arange(size_u).reshape((nn,) + control_options['u']['shape'])
src_idxs_u = src_idxs_u[gd.subset_node_indices['segment_ends'], ...]
size_v = nn * np.prod(control_options['v']['shape'])
src_idxs_v = np.arange(size_v).reshape((nn,) + control_options['v']['shape'])
src_idxs_v = src_idxs_v[gd.subset_node_indices['segment_ends'], ...]
# if transcription =='radau-ps' or compressed != 'compressed':
self.p.model.connect('u', 'cnty_comp.controls:u', src_indices=src_idxs_u,
flat_src_indices=True)
self.p.model.connect('u_rate', 'cnty_comp.control_rates:u_rate', src_indices=src_idxs_u,
flat_src_indices=True)
self.p.model.connect('u_rate2', 'cnty_comp.control_rates:u_rate2', src_indices=src_idxs_u,
flat_src_indices=True)
# if transcription =='radau-ps' or compressed != 'compressed':
self.p.model.connect('v', 'cnty_comp.controls:v', src_indices=src_idxs_v,
flat_src_indices=True)
self.p.model.connect('v_rate', 'cnty_comp.control_rates:v_rate', src_indices=src_idxs_v,
flat_src_indices=True)
self.p.model.connect('v_rate2', 'cnty_comp.control_rates:v_rate2', src_indices=src_idxs_v,
flat_src_indices=True)
self.p.setup(check=True, force_alloc_complex=True)
self.p['x'] = np.random.rand(*self.p['x'].shape)
self.p['y'] = np.random.rand(*self.p['y'].shape)
self.p['u'] = np.random.rand(*self.p['u'].shape)
self.p['v'] = np.random.rand(*self.p['v'].shape)
self.p['u_rate'] = np.random.rand(*self.p['u'].shape)
self.p['v_rate'] = np.random.rand(*self.p['v'].shape)
self.p['u_rate2'] = np.random.rand(*self.p['u'].shape)
self.p['v_rate2'] = np.random.rand(*self.p['v'].shape)
self.p.run_model()
if compressed != 'compressed':
for state in ('x', 'y'):
xpectd = self.p[state][segment_end_idxs, ...][2::2, ...] - \
self.p[state][segment_end_idxs, ...][1:-1:2, ...]
assert_near_equal(self.p['cnty_comp.defect_states:{0}'.format(state)],
xpectd.reshape((num_seg - 1,) + state_options[state]['shape']))
for ctrl in ('u', 'v'):
xpectd = self.p[ctrl][segment_end_idxs, ...][2::2, ...] - \
self.p[ctrl][segment_end_idxs, ...][1:-1:2, ...]
if compressed != 'compressed':
assert_near_equal(self.p['cnty_comp.defect_controls:{0}'.format(ctrl)],
xpectd.reshape((num_seg-1,) + control_options[ctrl]['shape']))
np.set_printoptions(linewidth=1024)
cpd = self.p.check_partials(method='cs', out_stream=None)
assert_check_partials(cpd)
def setUp(self):
transcription = 'gauss-lobatto'
self.gd = gd = GridData(num_segments=2,
transcription_order=3,
segment_ends=[0.0, 3.0, 10.0],
transcription=transcription)
ndn = gd.subset_num_nodes['state_disc']
ncn = gd.subset_num_nodes['col']
nn = ndn + ncn
self.p = Problem(model=Group())
controls = {
'a': ControlOptionsDictionary(),
'b': ControlOptionsDictionary(),
'c': ControlOptionsDictionary(),
'd': ControlOptionsDictionary()
}
controls['a'].update({'units': 'm', 'shape': (1, ), 'opt': False})
controls['b'].update({'units': 's', 'shape': (3, ), 'opt': False})
controls['c'].update({'units': 'kg', 'shape': (3, 3), 'opt': False})
ivc = IndepVarComp()
self.p.model.add_subsystem('ivc', ivc, promotes_outputs=['*'])
ivc.add_output('a_disc', val=np.zeros((ndn, 1)), units='m')
ivc.add_output('a_col', val=np.zeros((ncn, 1)), units='m')
ivc.add_output('b_disc', val=np.zeros((ndn, 3)), units='s')
ivc.add_output('b_col', val=np.zeros((ncn, 3)), units='s')
ivc.add_output('c_disc', val=np.zeros((ndn, 3, 3)), units='kg')
ivc.add_output('c_col', val=np.zeros((ncn, 3, 3)), units='kg')
ivc.add_output('a_ctrl', val=np.zeros((nn, 1)), units='m')
ivc.add_output('b_ctrl', val=np.zeros((nn, 3)), units='s')
ivc.add_output('c_ctrl', val=np.zeros((nn, 3, 3)), units='kg')
path_comp = GaussLobattoPathConstraintComp(grid_data=gd)
self.p.model.add_subsystem('path_constraints', subsys=path_comp)
path_comp._add_path_constraint('a',
var_class='ode',
shape=(1, ),
lower=0,
upper=10,
units='m')
path_comp._add_path_constraint('b',
var_class='ode',
shape=(3, ),
lower=0,
upper=10,
units='s')
path_comp._add_path_constraint('c',
var_class='ode',
shape=(3, 3),
lower=0,
upper=10,
units='kg')
path_comp._add_path_constraint('a_ctrl',
var_class='time',
shape=(1, ),
lower=0,
upper=10,
units='m')
path_comp._add_path_constraint('b_ctrl',
var_class='indep_control',
shape=(3, ),
lower=0,
upper=10,
units='s')
path_comp._add_path_constraint('c_ctrl',
var_class='control_rate',
shape=(3, 3),
lower=0,
upper=10,
units='kg')
self.p.model.connect('a_disc', 'path_constraints.disc_values:a')
self.p.model.connect('a_col', 'path_constraints.col_values:a')
self.p.model.connect('b_disc', 'path_constraints.disc_values:b')
self.p.model.connect('b_col', 'path_constraints.col_values:b')
self.p.model.connect('c_disc', 'path_constraints.disc_values:c')
self.p.model.connect('c_col', 'path_constraints.col_values:c')
self.p.model.connect('a_ctrl', 'path_constraints.all_values:a_ctrl')
self.p.model.connect('b_ctrl', 'path_constraints.all_values:b_ctrl')
self.p.model.connect('c_ctrl', 'path_constraints.all_values:c_ctrl')
self.p.setup()
self.p['a_disc'] = np.random.rand(*self.p['a_disc'].shape)
self.p['a_col'] = np.random.rand(*self.p['a_col'].shape)
self.p['b_disc'] = np.random.rand(*self.p['b_disc'].shape)
self.p['b_col'] = np.random.rand(*self.p['b_col'].shape)
self.p['c_disc'] = np.random.rand(*self.p['c_disc'].shape)
self.p['c_col'] = np.random.rand(*self.p['c_col'].shape)
self.p['a_ctrl'] = np.random.rand(*self.p['a_ctrl'].shape)
self.p['b_ctrl'] = np.random.rand(*self.p['b_ctrl'].shape)
self.p['c_ctrl'] = np.random.rand(*self.p['c_ctrl'].shape)
self.p.run_model()