def test_beam_tutorial_viewmodel_using_data_from_sqlite_case_recorder_file(self):
top = Problem()
top.root = BeamTutorial()
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
top.driver.options['maxiter'] = 10000 #maximum number of solver iterations
top.driver.options['disp'] = False
#room length and width bounds
top.driver.add_desvar('ivc_rlength.room_length', lower=5.0*12.0, upper=50.0*12.0) #domain: 1in <= length <= 50ft
top.driver.add_desvar('ivc_rwidth.room_width', lower=5.0*12.0, upper=30.0*12.0) #domain: 1in <= width <= 30ft
top.driver.add_objective('d_neg_area.neg_room_area') #minimize negative area (or maximize area)
top.driver.add_constraint('d_len_minus_wid.length_minus_width', lower=0.0) #room_length >= room_width
top.driver.add_constraint('d_deflection.deflection', lower=720.0) #deflection >= 720
top.driver.add_constraint('d_bending.bending_stress_ratio', upper=0.5) #bending < 0.5
top.driver.add_constraint('d_shear.shear_stress_ratio', upper=1.0/3.0) #shear < 1/3
tempdir = mkdtemp()
case_recorder_filename = "tmp.sql"
filename = os.path.join(tempdir, case_recorder_filename)
recorder = SqliteRecorder(filename)
top.driver.add_recorder(recorder)
top.setup(check=False)
top.run()
view_model(filename, show_browser=False)
self.assertTrue(os.path.isfile('partition_tree_n2.html'))
os.remove('partition_tree_n2.html')
def store_model_view(self, open_in_browser=False):
# type: (bool) -> None
"""Implementation of the view_model() function for storage and (optionally) viewing in the browser.
Parameters
----------
open_in_browser : bool
Setting whether to attempt to automatically open the model view in the browser.
"""
if self._setup_status == 0:
self.setup()
view_model(self, outfile=self.model_view_path, show_browser=open_in_browser)
def test_viewmodel_using_bogus_recorder_file_type(self):
tempdir = mkdtemp()
case_recorder_filename = "tmp.bogus"
filename = os.path.join(tempdir, case_recorder_filename)
# Just make an empty file
open(filename, 'a').close()
try:
view_model(filename, show_browser=False)
except Exception as err:
self.assertEqual(str(err),
"The given filename is not one of the supported file formats: sqlite or hdf5")
def run_problem(prob):
prob.driver.options['debug_print'] = ['desvars', 'nl_cons', 'objs']
# prob.model.approx_totals(method='fd')
# Set up the problem
prob.setup()
from openmdao.api import view_model
view_model(prob, show_browser=False)
prob.run_driver()
def run(self):
"""
Method to actually run analysis or optimization. Also saves history in
a .db file and creates an N2 diagram to view the problem hierarchy.
"""
# Have more verbose output about optimization convergence
if self.prob_dict['print_level']:
self.prob.print_all_convergence()
# Save an N2 diagram for the problem
if self.prob_dict['record_db']:
view_model(self.prob, outfile=self.prob_dict['prob_name']+".html", show_browser=False)
# If `optimize` == True in prob_dict, perform optimization. Otherwise,
# simply pass the problem since analysis has already been run.
if not self.prob_dict['optimize']:
# Run a single analysis loop. This shouldn't actually be
# necessary, but sometimes the .db file is not complete unless we do this.
self.prob.run_once()
else:
# Perform optimization
self.prob.run()
# If the problem type is aero or aerostruct, we can compute the static margin.
# This is a naive tempoerary implementation that currently finite differences
# over the entire model to obtain the static margin.
if self.prob_dict['compute_static_margin'] and 'aero' in self.prob_dict['type']:
# Turn off problem recording (so nothing for these computations
# appears in the .db file) and get the current CL and CM.
self.prob.driver.recorders._recorders = []
CL = self.prob['wing_perf.CL']
CM = self.prob['CM'][1]
step = 1e-5
# Perturb alpha and run an analysis loop to obtain the new CL and CM.
self.prob['alpha'] += step
self.prob.run_once()
CL_new = self.prob['wing_perf.CL']
CM_new = self.prob['CM'][1]
# Un-perturb alpha and run a single analysis loop to get the problem
# back to where it was before we finite differenced.
self.prob['alpha'] -= step
self.prob.run_once()
# Compute, print, and save the static margin in metadata.
static_margin = -(CM_new - CM) / (CL_new - CL)
print("Static margin is:", static_margin)
self.prob.root.add_metadata('static_margin', static_margin)
def test_viewmodel_using_bogus_recorder_file_type(self):
tempdir = mkdtemp()
case_recorder_filename = "tmp.bogus"
filename = os.path.join(tempdir, case_recorder_filename)
# Just make an empty file
open(filename, 'a').close()
try:
view_model(filename, show_browser=False)
except Exception as err:
self.assertEqual(
str(err),
"The given filename is not one of the supported file formats: sqlite or hdf5"
)
def test_beam_tutorial_viewmodel_using_data_from_hdf5_case_recorder_file(self):
SKIP = False
try:
from openmdao.recorders.hdf5_recorder import HDF5Recorder
import h5py
except ImportError:
# Necessary for the file to parse
from openmdao.recorders.base_recorder import BaseRecorder
HDF5Recorder = BaseRecorder
SKIP = True
if SKIP:
raise unittest.SkipTest("Could not import HDF5Recorder. Is h5py installed?")
top = Problem()
top.root = BeamTutorial()
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
top.driver.options['maxiter'] = 10000 #maximum number of solver iterations
top.driver.options['disp'] = False
#room length and width bounds
top.driver.add_desvar('ivc_rlength.room_length', lower=5.0*12.0, upper=50.0*12.0) #domain: 1in <= length <= 50ft
top.driver.add_desvar('ivc_rwidth.room_width', lower=5.0*12.0, upper=30.0*12.0) #domain: 1in <= width <= 30ft
top.driver.add_objective('d_neg_area.neg_room_area') #minimize negative area (or maximize area)
top.driver.add_constraint('d_len_minus_wid.length_minus_width', lower=0.0) #room_length >= room_width
top.driver.add_constraint('d_deflection.deflection', lower=720.0) #deflection >= 720
top.driver.add_constraint('d_bending.bending_stress_ratio', upper=0.5) #bending < 0.5
top.driver.add_constraint('d_shear.shear_stress_ratio', upper=1.0/3.0) #shear < 1/3
tempdir = mkdtemp()
case_recorder_filename = "tmp.hdf5"
filename = os.path.join(tempdir, case_recorder_filename)
recorder = HDF5Recorder(filename)
top.driver.add_recorder(recorder)
top.setup(check=False)
top.run()
view_model(filename, show_browser=False)
self.assertTrue(os.path.isfile('partition_tree_n2.html'))
os.remove('partition_tree_n2.html')
def test_beam_tutorial_viewmodel_using_data_from_sqlite_case_recorder_file(
self):
top = Problem()
top.root = BeamTutorial()
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
top.driver.options[
'maxiter'] = 10000 #maximum number of solver iterations
top.driver.options['disp'] = False
#room length and width bounds
top.driver.add_desvar('ivc_rlength.room_length',
lower=5.0 * 12.0,
upper=50.0 *
12.0) #domain: 1in <= length <= 50ft
top.driver.add_desvar('ivc_rwidth.room_width',
lower=5.0 * 12.0,
upper=30.0 * 12.0) #domain: 1in <= width <= 30ft
top.driver.add_objective('d_neg_area.neg_room_area'
) #minimize negative area (or maximize area)
top.driver.add_constraint('d_len_minus_wid.length_minus_width',
lower=0.0) #room_length >= room_width
top.driver.add_constraint('d_deflection.deflection',
lower=720.0) #deflection >= 720
top.driver.add_constraint('d_bending.bending_stress_ratio',
upper=0.5) #bending < 0.5
top.driver.add_constraint('d_shear.shear_stress_ratio',
upper=1.0 / 3.0) #shear < 1/3
tempdir = mkdtemp()
case_recorder_filename = "tmp.sql"
filename = os.path.join(tempdir, case_recorder_filename)
recorder = SqliteRecorder(filename)
top.driver.add_recorder(recorder)
top.setup(check=False)
top.run()
view_model(filename, show_browser=False)
self.assertTrue(os.path.isfile('partition_tree_n2.html'))
os.remove('partition_tree_n2.html')
def run(self):
"""
Method to actually run analysis or optimization. Also saves history in
a .db file and creates an N2 diagram to view the problem hierarchy.
"""
# Uncomment this to use finite differences over the entire model
# self.prob.root.deriv_options['type'] = 'cs'
# Record optimization history to a database
# Data saved here can be examined using `plot_all.py`
recorder = SqliteRecorder(self.prob_dict['prob_name'] + ".db")
recorder.options['record_params'] = True
recorder.options['record_derivs'] = True
self.prob.driver.add_recorder(recorder)
# Profile (time) the problem
# profile.setup(self.prob)
# profile.start()
# Set up the problem
self.prob.setup()
# Uncomment this line to have more verbose output about convergence
# self.prob.print_all_convergence()
# Save an N2 diagram for the problem
view_model(self.prob,
outfile=self.prob_dict['prob_name'] + ".html",
show_browser=False)
# Run a single analysis loop to populate uninitialized values
self.prob.run_once()
# If `optimize` == True in prob_dict, perform optimization. Otherwise,
# simply pass the problem since analysis has already been run.
if not self.prob_dict['optimize']: # run analysis once
pass
else: # perform optimization
self.prob.run()
This is not a real run_file. It is only used to make the n2
diagram for the notional aerostructural problem used for demonstration in the docs.
"""
from openmdao.api import Problem, Group, ExecComp, IndepVarComp, view_model, ImplicitComponent
p = Problem()
dvs = p.model.add_subsystem('design_vars', IndepVarComp(), promotes=['*'])
dvs.add_output('x_aero')
dvs.add_output('x_struct')
aerostruct = p.model.add_subsystem('aerostruct_cycle', Group(), promotes=['*'])
#note the equations don't matter... just need a simple way to get inputs and outputs there
aerostruct.add_subsystem(
'aero',
ExecComp(['w = u+x_aero', 'Cl=u+x_aero', 'Cd = u + x_aero']),
promotes=['*'])
aerostruct.add_subsystem('struct',
ExecComp(['u = w+x_struct', 'mass=x_struct']),
promotes=['*'])
p.model.add_subsystem('objective', ExecComp('f=mass+Cl/Cd'), promotes=['*'])
p.model.add_subsystem('constraint', ExecComp('g=Cl'), promotes=['*'])
p.setup()
view_model(p,
outfile='aerostruct_n2.html',
embeddable=True,
draw_potential_connections=False,
show_browser=False)
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP' #'L-BFGS-B'#
prob.driver.options['maxiter'] = 200
prob.driver.options['tol'] = 1e-5
prob.driver.options['debug_print'] = [
'desvars', 'ln_cons', 'nl_cons', 'objs', 'totals'
]
prob.driver.options['disp'] = True
prob.set_solver_print(level=1)
prob.setup()
# Ask OpenMDAO to finite-difference across the model to compute the gradients for the optimizer
prob.model.approx_totals()
prob.run_driver()
view_model(prob, outfile="mdao2.html", show_browser=False)
# generate as file for OpenVSP
generate_geometry = False # True#
# view values calculations
view_values = False # True #
# plot the trajectory
plot_trajectory = False # True #
MDA_value = False
# visualize output values
if plot_trajectory == True:
#result_vizualization.view_traj_values(test)
result_vizualization.plot_trajectory(MDA_value)
cycle.add_subsystem('mass_group',mass_group() , promotes_inputs=['*'], promotes_outputs=['*'])
cycle.add_subsystem('trajectory',trajectory() , promotes_inputs=['*'], promotes_outputs=['*'])
# Linear and non-linear Solvers for MDA
cycle.nonlinear_solver = NonlinearBlockGS(maxiter =100) #NewtonSolver(maxiter =100)#
cycle.nonlinear_solver.options['rtol'] = 10**-6
cycle.nonlinear_solver.options['atol'] = 10**-6
cycle.linear_solver = DirectSolver()# LinearBlockGS(maxiter =100) #ScipyKrylov()
self.linear_solver = DirectSolver()# LinearBlockGS(maxiter =100) #ScipyKrylov()
# test of the MDA
test = Problem()
test.model = LAST_MDA()
test.set_solver_print(level=2)
test.setup()
test.run_model()
view_model(test, outfile="mda2.html", show_browser=False) # N² diagramm
# generate as file for OpenVSP
view_values = True # False #
plot_trajectory = True # False #
MDA_value = True
# visualize output values
if plot_trajectory == True:
result_vizualization.plot_trajectory(MDA_value)
if view_values == True:
result_vizualization.view_values(test)
def create_mda(self):
return Mda(self.scalers)
@staticmethod
def create_performance(self):
return Performance(self.scalers)
@staticmethod
def create_constraints(self):
return Constraints(self.scalers)
if __name__ == "__main__":
parser = OptionParser()
parser.add_option("-n",
"--no-n2",
action="store_false",
dest='n2_view',
default=True,
help="display N2 openmdao viewer")
(options, args) = parser.parse_args()
problem = Problem()
problem.model = SsbjMda()
problem.setup()
problem.final_setup()
if options.n2_view:
view_model(problem)
model.connect('A_sa', 'solar.A_sa')
model.connect('G_sc', 'solar.G_sc')
model.connect('eta_sa', 'solar.eta_sa')
model.connect('Z_sa', 'solar.Z_sa')
model.connect('T_0', 'massvel.T_0')
model.connect('v_e', 'massvel.v_e')
model.connect('battery.T_th', 'massvel.T_th')
#Setting Solvers
# model.nonlinear_solver = NewtonSolver(maxiter = 30, iprint = 2, rtol = 1e-10)
# model.linear_solver = DirectSolver()
#Set-up and Run
p.setup()
p.run_model()
print(p[f'massvel.istep_{N-1}.DV_tot_e'])
print(p['propul.DV_tot'])
view_model(p)
#Plotting
Re = [
(p['init_cond.R_0'] - 6378000) * 10**-3,
]
for i in range(N):
Re.append((p[f'istep_{i}.Re'] - 6378000) * 10**-3)
time = np.arange(N + 1) * timestep
plt.plot(time, Re)
plt.show()
"""
This is not a real run_file. It is only used to make the n2
diagram for the notional aerostructural problem used for demonstration in the docs.
"""
import openmdao.api as om
p = om.Problem()
dvs = p.model.add_subsystem('design_vars', om.IndepVarComp(), promotes=['*'])
dvs.add_output('x_aero')
dvs.add_output('x_struct')
aerostruct = p.model.add_subsystem('aerostruct_cycle', om.Group(), promotes=['*'])
#note the equations don't matter... just need a simple way to get inputs and outputs there
aerostruct.add_subsystem('aero',
om.ExecComp(['w = u+x_aero', 'Cl=u+x_aero', 'Cd = u + x_aero']),
promotes=['*'])
aerostruct.add_subsystem('struct', om.ExecComp(['u = w+x_struct', 'mass=x_struct']),
promotes=['*'])
p.model.add_subsystem('objective', om.ExecComp('f=mass+Cl/Cd'), promotes=['*'])
p.model.add_subsystem('constraint', om.ExecComp('g=Cl'), promotes=['*'])
p.setup()
om.view_model(p, outfile='aerostruct_n2.html', embeddable=True, show_browser=False)
# derivatives used for optimization.
prob.root.deriv_options['type'] = 'fd'
# Record the optimization history in `spatialbeam.db`. You can view
# this by running `python plot_all.py s` or `python OptView.py s`.
recorder = SqliteRecorder('spatialbeam.db')
recorder.options['record_params'] = True
recorder.options['record_derivs'] = True
prob.driver.add_recorder(recorder)
# Have OpenMDAO set up the problem that we have constructed.
prob.setup()
# Create an html output file showing the problem formulation and data
# passing with an interactive chart. Open this in any web browser.
view_model(prob, outfile="prob1.html", show_browser=False)
# Start timing and perform the optimization.
st = time.time()
prob.run()
print("\nrun time: {} secs".format(time.time() - st))
print(' tip')
print('thickness distribution:', prob['thickness'], "\n")
# Uncomment the following line to check the partial derivatives of each
# component and view their accuracy.
# prob.check_partial_derivatives(compact_print=True)
elif 'prob2' in input_arg or 'prob3' in input_arg:
# Set problem type. Any option not set here will be set in the method
root.connect('load_factor.n', 'structures_h.n')
root.connect('s_coord.node_coord', 'inter_h.node_coord')
root.connect('s_coord_all.node_coord_all', 'structures_h.node_coord_all')
#Multifidelity explicit connections
root.connect('structures.u', 'mult_filter.ul')
#Recorder Lo-Fi
recorder_l = SqliteRecorder('mda_l.sqlite3')
recorder_l.options['record_metadata'] = False
#Recorder Hi-Fi
recorder_h = SqliteRecorder('mda_h.sqlite3')
recorder_h.options['record_metadata'] = False
# recorder.options['includes'] =
top.root.mda_group_l.nl_solver.add_recorder(recorder_l)
top.root.mda_group_h.nl_solver.add_recorder(recorder_h)
#Define solver type
root.ln_solver = ScipyGMRES()
tic = timeit.default_timer()
top.setup()
toc = timeit.default_timer()
print("Set up time = " + str(toc - tic)) #elapsed time in seconds
view_model(top, show_browser=False)
tic = timeit.default_timer()
top.run()
toc = timeit.default_timer()
print("Run time = " + str(toc - tic)) #elapsed time in seconds
# sub-components
self.add_subsystem('dof', i, promotes=['*'])
self.add_subsystem('pc', PowerCurve(), promotes_inputs=['*'])
if __name__ == "__main__":
start = time()
# workflow setup
prob = Problem(PowerCurveTest())
prob.setup()
view_model(prob, outfile='N2/power_curve.html')
# define inputs
prob['dof.design_tsr'] = 7.0
prob['dof.cut_in_speed'] = 3.0
prob['dof.cut_out_speed'] = 25.0
prob['dof.swept_area'] = 12445.26
prob['dof.machine_rating'] = 5000.0
prob['dof.drive_train_efficiency'] = 0.95
prob['dof.rotor_cp'] = 0.467403
prob['dof.rotor_ct'] = 0.7410045
prob.run_model()
# print outputs
def main(maxiter):
# select which problem to solve
obj_flag = 1
print(locals())
print("solving %s problem" % objectives[obj_flag])
########################################################
################# FEA ####################
########################################################
# NB: only Q4 elements + integer-spaced mesh are assumed
nelx = 160
nely = 80
length_x = 160.
length_y = 80.
ls2fe_x = length_x / float(nelx)
ls2fe_y = length_y / float(nely)
num_nodes_x = nelx + 1
num_nodes_y = nely + 1
nELEM = nelx * nely
nNODE = num_nodes_x * num_nodes_y
# NB: nodes for plotting (quickfix...)
nodes = get_mesh(num_nodes_x, num_nodes_y, nelx, nely)
# Declare FEA object (OpenLSTO_FEA) ======================
fea_solver = py_FEA(lx=length_x,
ly=length_y,
nelx=nelx,
nely=nely,
element_order=2)
[node, elem, elem_dof] = fea_solver.get_mesh()
# validate the mesh
if nELEM != elem.shape[0]:
error("error found in the element")
if nNODE != node.shape[0]:
error("error found in the node")
nDOF_t = nNODE * 1 # each node has one temperature DOF
nDOF_e = nNODE * 2 # each node has two displacement DOFs
# constitutive properties =================================
E = 1.
nu = 0.3
f = -1 # dead load
K_cond = 0.1 # thermal conductivity
alpha = 1e-5 # thermal expansion coefficient
fea_solver.set_material(E=E, nu=nu, rho=1.0)
# Boundary Conditions =====================================
if 1:
coord_e = np.array([[0., 0.], [length_x, 0.]])
tol_e = np.array([[1e-3, 1e3], [1e-3, 1e+3]])
fea_solver.set_boundary(coord=coord_e, tol=tol_e)
BCid_e = fea_solver.get_boundary()
nDOF_e_wLag = nDOF_e + len(BCid_e) # elasticity DOF
coord = np.array([length_x * 0.5, 0.0]) # length_y])
tol = np.array([0.1, 1e-3])
GF_e_ = fea_solver.set_force(coord=coord, tol=tol, direction=1, f=-f)
GF_e = np.zeros(nDOF_e_wLag)
GF_e[:nDOF_e] = GF_e_
else: # cantilever bending
coord_e = np.array([[0, 0]])
tol_e = np.array([[1e-3, 1e10]])
fea_solver.set_boundary(coord=coord_e, tol=tol_e)
BCid_e = fea_solver.get_boundary()
nDOF_e_wLag = nDOF_e + len(BCid_e) # elasticity DOF
coord = np.array([length_x, length_y / 2])
tol = np.array([0.1, 0.1])
GF_e_ = fea_solver.set_force(coord=coord, tol=tol, direction=1, f=-1.0)
GF_e = np.zeros(nDOF_e_wLag)
GF_e[:nDOF_e] = GF_e_
xlo = np.array(range(0, nNODE, num_nodes_x))
xhi = np.array(range(nelx, nNODE, num_nodes_x))
# xfix = np.array([num_nodes_x*(nely/2-1), num_nodes_x*nely/2,
# num_nodes_x*(nely/2-1) + nelx, num_nodes_x*nely/2 + nelx])
xfix = np.append(xlo, xhi)
yfix = np.array(range(num_nodes_x * nely + 70, nNODE - 70))
# yloid = np.array(range(70, 91))
# fixID_d = np.append(xfix, yfix)
#fixID_d = np.unique(fixID_d)
#fixID = np.append(fixID_d, arange(70, 91))
# BCid_t = np.array(np.append(xfix, arange(70,91)), dtype=int)
BCid_t = np.array(np.append(yfix, arange(70, 91)), dtype=int)
nDOF_t_wLag = nDOF_t + len(BCid_t) # temperature DOF (zero temp)
GF_t = np.zeros(nDOF_t_wLag) # FORCE_HEAT (NB: Q matrix)
for ee in range(nELEM): # between element 70 to 91
GF_t[elem[ee]] += 10. # heat generation
GF_t[BCid_t] = 0.0
GF_t /= np.sum(GF_t)
#GF_t[nDOF_t:nDOF_t+len(fixID_d)+1] = 100.
# GF_t[:] = 0.0
########################################################
################# LSM ####################
########################################################
movelimit = 0.5
# Declare Level-set object
lsm_solver = py_LSM(nelx=nelx, nely=nely, moveLimit=movelimit)
if ((nelx == 160) and (nely == 80)): # 160 x 80 case
hole = array(
[[16, 14, 5], [48, 14, 5], [80, 14, 5], [112, 14, 5], [144, 14, 5],
[32, 27, 5], [64, 27, 5], [96, 27, 5], [128, 27, 5], [16, 40, 5],
[48, 40, 5], [80, 40, 5], [112, 40, 5], [144, 40, 5], [32, 53, 5],
[64, 53, 5], [96, 53, 5], [128, 53, 5], [16, 66, 5], [48, 66, 5],
[80, 66, 5], [112, 66, 5], [144, 66, 5]],
dtype=float)
# NB: level set value at the corners should not be 0.0
hole = append(
hole,
[[0., 0., 0.1], [0., 80., 0.1], [160., 0., 0.1], [160., 80., 0.1]],
axis=0)
lsm_solver.add_holes(locx=list(hole[:, 0]),
locy=list(hole[:, 1]),
radius=list(hole[:, 2]))
elif ((nelx == 80) and (nely == 40)):
hole = np.array(
[[8, 7, 2.5], [24, 7, 2.5], [40, 7, 2.5], [56, 7, 2.5],
[72, 7, 2.5], [16, 13.5, 2.5], [32, 13.5, 2.5], [48, 13.5, 2.5],
[64, 13.5, 2.5], [8, 20, 2.5], [24, 20, 2.5], [40, 20, 2.5],
[56, 20, 2.5], [72, 20, 2.5], [16, 26.5, 2.5], [32, 26.5, 2.5],
[48, 26.5, 2.5], [64, 26.5, 2.5], [8, 33, 2.5], [24, 33, 2.5],
[40, 33, 2.5], [56, 33, 2.5], [72, 33, 2.5]],
dtype=np.float)
# NB: level set value at the corners should not be 0.0
hole = append(
hole,
[[0., 0., 0.1], [0., 40., 0.1], [80., 0., 0.1], [80., 40., 0.1]],
axis=0)
lsm_solver.add_holes(locx=list(hole[:, 0]),
locy=list(hole[:, 1]),
radius=list(hole[:, 2]))
else:
lsm_solver.add_holes([], [], [])
lsm_solver.set_levelset()
for i_HJ in range(maxiter):
(bpts_xy, areafraction, seglength) = lsm_solver.discretise()
########################################################
############### OpenMDAO ################
########################################################
# Declare Group
if (objectives[obj_flag] == "compliance"):
model = ComplianceGroup(fea_solver=fea_solver,
lsm_solver=lsm_solver,
nelx=nelx,
nely=nely,
force=GF_e,
movelimit=movelimit,
BCid=BCid_e)
elif (objectives[obj_flag] == "stress"):
# TODO: sensitivity has not been verified yet
model = StressGroup(fea_solver=fea_solver,
lsm_solver=lsm_solver,
nelx=nelx,
nely=nely,
force=GF_e,
movelimit=movelimit,
pval=5.0,
E=E,
nu=nu)
elif (objectives[obj_flag] == "conduction"):
model = ConductionGroup(fea_solver=fea_solver,
lsm_solver=lsm_solver,
nelx=nelx,
nely=nely,
force=GF_t,
movelimit=movelimit,
K_cond=K_cond,
BCid=BCid_t)
elif (objectives[obj_flag] == "coupled_heat"):
model = HeatCouplingGroup(
fea_solver=fea_solver,
lsm_solver=lsm_solver,
nelx=nelx,
nely=nely,
force_e=GF_e,
force_t=GF_t,
movelimit=movelimit,
K_cond=K_cond,
BCid_e=BCid_e,
BCid_t=BCid_t,
E=E,
nu=nu,
alpha=alpha,
w=0.9
) # if w = 0.0, thermoelastic + conduction, if w = 1.0, conduction only
# One Problem per one OpenMDAO object
prob = Problem(model)
# optimize ...
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = 'IPOPT'
prob.driver.opt_settings['linear_solver'] = 'ma27'
prob.setup(check=False)
if i_HJ == 0:
view_model(prob)
prob.run_model()
# Total derivative using MAUD =====================
total = prob.compute_totals()
if (objectives[obj_flag] == "compliance"):
ff = total['compliance_comp.compliance', 'inputs_comp.Vn'][0]
gg = total['weight_comp.weight', 'inputs_comp.Vn'][0]
elif (objectives[obj_flag] == "stress"):
ff = total['pnorm_comp.pnorm', 'inputs_comp.Vn'][0]
gg = total['weight_comp.weight', 'inputs_comp.Vn'][0]
elif (objectives[obj_flag] == "conduction"):
ff = total['compliance_comp.compliance', 'inputs_comp.Vn'][0]
gg = total['weight_comp.weight', 'inputs_comp.Vn'][0]
elif (objectives[obj_flag] == "coupled_heat"):
ff = total['objective_comp.y', 'inputs_comp.Vn'][0]
gg = total['weight_comp.weight', 'inputs_comp.Vn'][0]
nBpts = int(bpts_xy.shape[0])
# # WIP checking sensitivity 10/23
Sf = -ff[:nBpts] # equal to M2DO-perturbation
Cf = np.multiply(Sf, seglength)
#np.savetxt('/home/hayoung/Desktop/a',Sf)
#exit()
Sg = -gg[:nBpts]
Cg = np.multiply(Sf, seglength)
# ## WIP
# previous ver.
# Cf = -ff[:nBpts]
# Cg = -gg[:nBpts]
# Sf = np.divide(Cf, seglength)
# Sg = np.divide(Cg, seglength)
# bracketing Sf and Sg
Sg[Sg < -1.5] = -1.5
Sg[Sg > 0.5] = 0.5
# Sg[:] = -1.0
Cg = np.multiply(Sg, seglength)
########################################################
############## suboptimize ################
########################################################
if 1:
suboptim = Solvers(bpts_xy=bpts_xy,
Sf=Sf,
Sg=Sg,
Cf=Cf,
Cg=Cg,
length_x=length_x,
length_y=length_y,
areafraction=areafraction,
movelimit=movelimit)
# suboptimization
if 1: # simplex
Bpt_Vel = suboptim.simplex(isprint=False)
else: # bisection..
Bpt_Vel = suboptim.bisection(isprint=False)
timestep = 1.0
np.savetxt('a.txt', Bpt_Vel)
elif 1: # works when Sf <- Sf / length is used (which means Cf <- actual Sf)
bpts_sens = np.zeros((nBpts, 2))
# issue: scaling problem
#
bpts_sens[:, 0] = Sf
bpts_sens[:, 1] = Sg
lsm_solver.set_BptsSens(bpts_sens)
scales = lsm_solver.get_scale_factors()
(lb2, ub2) = lsm_solver.get_Lambda_Limits()
constraint_distance = (0.4 * nelx * nely) - areafraction.sum()
model = LSM2D_slpGroup(lsm_solver=lsm_solver,
num_bpts=nBpts,
ub=ub2,
lb=lb2,
Sf=bpts_sens[:, 0],
Sg=bpts_sens[:, 1],
constraintDistance=constraint_distance,
movelimit=movelimit)
subprob = Problem(model)
subprob.setup()
subprob.driver = ScipyOptimizeDriver()
subprob.driver.options['optimizer'] = 'SLSQP'
subprob.driver.options['disp'] = True
subprob.driver.options['tol'] = 1e-10
subprob.run_driver()
lambdas = subprob['inputs_comp.lambdas']
displacements_ = subprob['displacement_comp.displacements']
# displacements_[displacements_ > movelimit] = movelimit
# displacements_[displacements_ < -movelimit] = -movelimit
timestep = abs(lambdas[0] * scales[0])
Bpt_Vel = displacements_ / timestep
np.savetxt('a.txt', Bpt_Vel)
# print(timestep)
del subprob
else: # branch: perturb-suboptim
bpts_sens = np.zeros((nBpts, 2))
# issue: scaling problem
#
bpts_sens[:, 0] = Sf
bpts_sens[:, 1] = Sg
lsm_solver.set_BptsSens(bpts_sens)
scales = lsm_solver.get_scale_factors()
(lb2, ub2) = lsm_solver.get_Lambda_Limits()
constraint_distance = (0.4 * nelx * nely) - areafraction.sum()
constraintDistance = np.array([constraint_distance])
scaled_constraintDist = lsm_solver.compute_scaledConstraintDistance(
constraintDistance)
def objF_nocallback(x):
displacement = lsm_solver.compute_displacement(x)
displacement_np = np.asarray(displacement)
return lsm_solver.compute_delF(displacement_np)
def conF_nocallback(x):
displacement = lsm_solver.compute_displacement(x)
displacement_np = np.asarray(displacement)
return lsm_solver.compute_delG(displacement_np,
scaled_constraintDist, 1)
cons = ({'type': 'eq', 'fun': lambda x: conF_nocallback(x)})
res = sp_optim.minimize(objF_nocallback,
np.zeros(2),
method='SLSQP',
options={'disp': True},
bounds=((lb2[0], ub2[0]), (lb2[1],
ub2[1])),
constraints=cons)
lambdas = res.x
displacements_ = lsm_solver.compute_unscaledDisplacement(lambdas)
displacements_[displacements_ > movelimit] = movelimit
displacements_[displacements_ < -movelimit] = -movelimit
timestep = 1.0 #abs(lambdas[0]*scales[0])
Bpt_Vel = displacements_ / timestep
# scaling
# Bpt_Vel = Bpt_Vel#/np.max(np.abs(Bpt_Vel))
lsm_solver.advect(Bpt_Vel, timestep)
lsm_solver.reinitialise()
print('loop %d is finished' % i_HJ)
area = areafraction.sum() / (nelx * nely)
try:
u = prob['temp_comp.disp']
compliance = np.dot(u, GF_t[:nNODE])
except:
u = prob['disp_comp.disp']
# compliance = np.dot(u, GF_e[:nDOF_e])
pass
if 1: # quickplot
plt.figure(1)
plt.clf()
plt.scatter(bpts_xy[:, 0], bpts_xy[:, 1], 10)
plt.axis("equal")
plt.savefig(saveFolder + "figs/bpts_%d.png" % i_HJ)
if obj_flag == 3 or obj_flag == 2:
plt.figure(2)
plt.clf()
[xx, yy] = np.meshgrid(range(0, 161), range(0, 81))
plt.contourf(xx, yy, np.reshape(u, [81, 161]))
plt.colorbar()
plt.axis("equal")
plt.scatter(bpts_xy[:, 0], bpts_xy[:, 1], 5)
plt.savefig(saveFolder + "figs/temp_%d.png" % i_HJ)
# print([compliance[0], area])
if (objectives[obj_flag] == "compliance"):
compliance = prob['compliance_comp.compliance']
print(compliance, area)
fid = open(saveFolder + "log.txt", "a+")
fid.write(str(compliance) + ", " + str(area) + "\n")
fid.close()
elif (objectives[obj_flag] == "stress"):
print(prob['pnorm_comp.pnorm'][0], area)
fid = open(saveFolder + "log.txt", "a+")
fid.write(
str(prob['pnorm_comp.pnorm'][0]) + ", " + str(area) + "\n")
fid.close()
elif (objectives[obj_flag] == "coupled_heat"):
obj1 = prob['objective_comp.x1'][0]
obj2 = prob['objective_comp.x2'][0]
obj = prob['objective_comp.y'][0]
print([obj1, obj2, obj, area])
fid = open(saveFolder + "log.txt", "a+")
fid.write(
str(obj1) + ", " + str(obj2) + ", " + str(obj) + ", " +
str(area) + "\n")
fid.close()
# Saving Phi
phi = lsm_solver.get_phi()
if i_HJ == 0:
raw = {}
raw['mesh'] = nodes
raw['nodes'] = nodes
raw['elem'] = elem
raw['GF_e'] = GF_e
raw['GF_t'] = GF_t
raw['BCid_e'] = BCid_e
raw['BCid_t'] = BCid_t
raw['E'] = E
raw['nu'] = nu
raw['f'] = f
raw['K_cond'] = K_cond
raw['alpha'] = alpha
raw['nelx'] = nelx
raw['nely'] = nely
raw['length_x'] = length_x
raw['length_y'] = length_y
raw['coord_e'] = coord_e
raw['tol_e'] = tol_e
filename = saveFolder + 'const.pkl'
with open(filename, 'wb') as f:
pickle.dump(raw, f)
raw = {}
raw['phi'] = phi
if obj_flag == 3:
raw['T'] = prob['temp_comp.disp']
filename = saveFolder + 'phi%03i.pkl' % i_HJ
with open(filename, 'wb') as f:
pickle.dump(raw, f)
del model
del prob
mem = virtual_memory()
print(str(mem.available / 1024. / 1024. / 1024.) + "GB")
if mem.available / 1024. / 1024. / 1024. < 3.0:
print("memory explodes at iteration %3i " % i_HJ)
return ()
# Create the aero point group for this flight condition and add it to the model
aero_group = AeroPoint(surfaces=[surface], rotational=True)
point_name = 'flight_condition_0'
prob.model.add_subsystem(point_name,
aero_group,
promotes_inputs=[
'v', 'alpha', 'beta', 'omega', 'Mach_number',
're', 'rho', 'cg'
])
# Connect the mesh from the geometry component to the analysis point
prob.model.connect(name + '.mesh', point_name + '.' + name + '.def_mesh')
# Perform the connections with the modified names within the
# 'aero_states' group.
prob.model.connect(name + '.mesh',
point_name + '.aero_states.' + name + '_def_mesh')
# Set up the problem
prob.setup()
# Create a n^2 diagram for user to view model connections
om.view_model(prob)
# Run analysis
prob.run_model()
print('CL', prob['flight_condition_0.wing_perf.CL'][0])
print('CD', prob['flight_condition_0.wing_perf.CD'][0])
def minimize(
self, # type: CharDB
objective, # type: str
define=None, # type: List[Tuple[str, int]]
cons=None, # type: Dict[str, Dict[str, float]]
vector_params=None, # type: Set[str]
debug=False, # type: bool
**kwargs # type: **kwargs
):
# type: (...) -> Dict[str, Union[np.ndarray, float]]
"""Find operating point that minimizes the given objective.
Parameters
----------
objective : str
the objective to minimize. Must be a scalar.
define : List[Tuple[str, int]]
list of expressions to define new variables. Each
element of the list is a tuple of string and integer. The string
contains a python assignment that computes the variable from
existing ones, and the integer indicates the variable shape.
Note that define can also be used to enforce relationships between
existing variables. Using transistor as an example, defining
'vgs = vds' will force the vgs of vds of the transistor to be
equal.
cons : Dict[str, Dict[str, float]]
a dictionary from variable name to constraints of that variable.
see OpenMDAO documentations for details on constraints.
vector_params : Set[str]
set of input variables that are vector instead of scalar. An input
variable is a vector if it can change across simulation environments.
debug : bool
True to enable debugging messages. Defaults to False.
**kwargs :
known parameter values.
Returns
-------
results : Dict[str, Union[np.ndarray, float]]
the results dictionary.
"""
cons = cons or {}
fidx_list = self._get_function_index(**kwargs)
builder = GroupBuilder()
params_ranges = dict(
zip(self._cont_params,
((vec[0], vec[-1]) for vec in self._cont_values)))
# add functions
fun_name_iter = itertools.chain(iter(self._data.keys()),
self.derived_parameters())
for name in fun_name_iter:
fun_list = []
for idx, env in enumerate(self.env_list):
fidx_list[0] = idx
fun_list.append(self._get_function_helper(name, fidx_list))
builder.add_fun(name,
fun_list,
self._cont_params,
params_ranges,
vector_params=vector_params)
# add expressions
for expr, ndim in define:
builder.add_expr(expr, ndim)
# update input bounds from constraints
input_set = builder.get_inputs()
var_list = builder.get_variables()
for name in input_set:
if name in cons:
setup = cons[name]
if 'equals' in setup:
eq_val = setup['equals']
builder.set_input_limit(name, equals=eq_val)
else:
vmin = vmax = None
if 'lower' in setup:
vmin = setup['lower']
if 'upper' in setup:
vmax = setup['upper']
builder.set_input_limit(name, lower=vmin, upper=vmax)
# build the group and make the problem
grp, input_bounds = builder.build()
top = omdao.Problem()
top.root = grp
opt_package = self.get_config('opt_package') # type: str
opt_settings = self.get_config('opt_settings')
if opt_package == 'scipy':
driver = top.driver = omdao.ScipyOptimizer()
print_opt_name = 'disp'
elif opt_package == 'pyoptsparse':
driver = top.driver = omdao.pyOptSparseDriver()
print_opt_name = 'print_results'
else:
raise ValueError('Unknown optimization package: %s' % opt_package)
driver.options['optimizer'] = self.get_config('opt_method')
driver.options[print_opt_name] = debug
driver.opt_settings.update(opt_settings)
# add constraints
constants = {}
for name, setup in cons.items():
if name not in input_bounds:
# add constraint
driver.add_constraint(name, **setup)
# add inputs
for name in input_set:
eq_val, lower, upper, ndim = input_bounds[name]
val = kwargs.get(name, self[name]) # type: float
if val is None:
val = eq_val
comp_name = 'comp__%s' % name
if val is not None:
val = np.atleast_1d(np.ones(ndim) * val)
constants[name] = val
top.root.add(comp_name,
omdao.IndepVarComp(name, val=val),
promotes=[name])
else:
avg = (lower + upper) / 2.0
span = upper - lower
val = np.atleast_1d(np.ones(ndim) * avg)
top.root.add(comp_name,
omdao.IndepVarComp(name, val=val),
promotes=[name])
driver.add_desvar(name,
lower=lower,
upper=upper,
adder=-avg,
scaler=1.0 / span)
# driver.add_desvar(name, lower=lower, upper=upper)
# add objective and setup
driver.add_objective(objective)
top.setup(check=debug)
# somehow html file is not viewable.
if debug:
omdao.view_model(top, outfile='CharDB_debug.html')
# set constants
for name, val in constants.items():
top[name] = val
top.run()
results = {
var: kwargs.get(var, self[var])
for var in self._discrete_params
}
for var in var_list:
results[var] = top[var]
return results
def test_beam_tutorial_viewmodel_using_data_from_hdf5_case_recorder_file(
self):
SKIP = False
try:
from openmdao.recorders.hdf5_recorder import HDF5Recorder
import h5py
except ImportError:
# Necessary for the file to parse
from openmdao.recorders.base_recorder import BaseRecorder
HDF5Recorder = BaseRecorder
SKIP = True
if SKIP:
raise unittest.SkipTest(
"Could not import HDF5Recorder. Is h5py installed?")
top = Problem()
top.root = BeamTutorial()
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
top.driver.options[
'maxiter'] = 10000 #maximum number of solver iterations
top.driver.options['disp'] = False
#room length and width bounds
top.driver.add_desvar('ivc_rlength.room_length',
lower=5.0 * 12.0,
upper=50.0 *
12.0) #domain: 1in <= length <= 50ft
top.driver.add_desvar('ivc_rwidth.room_width',
lower=5.0 * 12.0,
upper=30.0 * 12.0) #domain: 1in <= width <= 30ft
top.driver.add_objective('d_neg_area.neg_room_area'
) #minimize negative area (or maximize area)
top.driver.add_constraint('d_len_minus_wid.length_minus_width',
lower=0.0) #room_length >= room_width
top.driver.add_constraint('d_deflection.deflection',
lower=720.0) #deflection >= 720
top.driver.add_constraint('d_bending.bending_stress_ratio',
upper=0.5) #bending < 0.5
top.driver.add_constraint('d_shear.shear_stress_ratio',
upper=1.0 / 3.0) #shear < 1/3
tempdir = mkdtemp()
case_recorder_filename = "tmp.hdf5"
filename = os.path.join(tempdir, case_recorder_filename)
recorder = HDF5Recorder(filename)
top.driver.add_recorder(recorder)
top.setup(check=False)
top.run()
view_model(filename, show_browser=False)
self.assertTrue(os.path.isfile('partition_tree_n2.html'))
os.remove('partition_tree_n2.html')
recorder.options['record_metadata'] = False
recorder.options['includes'] = ['CDi', 'con_l_u', 'con_s', 't', 'a', 'chords', 'sweep', 'b', 'alpha', 'theta', 'tc', 'CD0', 'CDw', 'D', 'FB', 'con_area', 'con_h_1', 'con_h_2', 'con_h_3']
top.driver.add_recorder(recorder)
#Define solver type
root.ln_solver = ScipyGMRES()
start1 = time.time() #timer for set-up and re-order
top.setup()
order = root.list_auto_order() #This is to ensure that the mda_l group is executed always before the mda_h group
a, b = order[0].index('mda_group_h'), order[0].index('mda_group_l')
order[0].insert(a, order[0].pop(b))
root.set_order(order[0])
end1 = time.time()
view_model(top, show_browser=False) #generates an N2 diagram to visualize connections
#Setting initial values for design variables
top['t'] = t_0
top['chords'] = chords_0
top['sweep'] = sweep_0
top['b'] = b_0
top['alpha'] = alpha_0
top['theta'] = theta_0
top['tc'] = tc_0
start2 = time.time()
top.run()
end2 = time.time()
top.cleanup() # this closes all recorders
print("Set up time = " + str(end1 - start1))
probl.model.add_subsystem('trajectory',
trajectory(),
promotes_inputs=['*'],
promotes_outputs=['*'])
probl.model.nonlinear_solver = NewtonSolver()
probl.model.linear_solver = DirectSolver()
#probl.model.linear_solver = ScipyKrylov()
probl.model.nonlinear_solver.options['maxiter'] = 10**3
probl.model.nonlinear_solver.options['rtol'] = 10**-6
probl.set_solver_print(level=1)
probl.setup()
probl.run_model()
view_model(probl, outfile="trajectoryn2.html", show_browser=False)
test = probl
print('\n')
print('final altitude (km) =', test['alt_f'][0])
print('final speed (m/s)=', test['v_f'][0])
print('final fi= ', test['fi_f'][0])
print('final long= ', test['l_f'][0])
print("\n")
print("m_dot1:", test['m_dot1'][0])
# print("m_dot2:", test['m_dot2'][0])
print("Thrust 1 :", test['ft1'][0])
print('nx_max ', test['nx_max'][0])
print('alf_max ', test['alf_max'][0])
#"""
0.0, 152.8413, 692.3132, 1231.7851, 1771.257, 2077.937, 2385.88,
2693.823, 3167.965, 3613.9953, 4060.0257, 4506.056, 4882.4425,
5258.829, 5635.2155, 6011.602, 5169.536, 4327.47, 3485.404, 2222.305
]
span_fy = [
-3.5, -103.8047, 162.8256, 429.456, 696.0863, 702.4778, 701.8906,
701.3033, 720.8832, 725.5557, 730.2281, 734.9006, 732.7446, 730.5885,
728.4325, 726.2764, 558.9978, 391.7192, 224.4406, -26.4774
]
start = time()
# workflow setup
prob = Problem(RotorMechanicsTest())
prob.setup()
view_model(prob, outfile='N2/rotor_structure.html')
# define inputs
prob['dof.shaft_angle'] = shaft_angle
prob['dof.span_r'] = span_r
prob['dof.span_dr'] = span_dr
prob['dof.span_chord'] = span_chord
prob['dof.span_thickness'] = span_thickness
prob['dof.span_mass'] = span_mass
prob['dof.span_flap_stiff'] = span_flap_stiff
prob['dof.span_edge_stiff'] = span_edge_stiff
prob['dof.span_fx'] = span_fx
prob['dof.span_fy'] = span_fy
prob.run_model()
def test(self):
start = time()
# workflow setup
prob = Problem(self)
prob.setup()
view_model(prob, outfile='N2/rna.html')
# define inputs
prob['in_design_tsr'] = 1.0
prob['in_tf'] = 1.0
prob['in_chord_coefficients'] = np.ones(degree_bezier)
prob['in_twist_coefficients'] = np.ones(degree_bezier)
prob.run_model()
print 'span_r = ' + beautify(prob['rna.span_r'])
print 'span_dr = ' + beautify(prob['rna.span_dr'])
print 'span_chord = ' + beautify(prob['rna.span_chord'])
print 'span_twist = ' + beautify(prob['rna.span_twist'])
print 'pitch = ' + beautify(prob['rna.pitch'])
print 'rotor_cp = ' + str(prob['rna.rotor_cp'])
print 'rotor_ct = ' + str(prob['rna.rotor_ct'])
print 'rated_wind_speed = ' + beautify(prob['rna.rated_wind_speed'])
print 'wind_bin = ' + beautify(prob['rna.wind_bin'])
print 'power_bin = ' + beautify(prob['rna.power_bin'])
print 'span_stress_max = ' + str(max(prob['rna.span_stress_max']))
print 'tip_deflection = ' + beautify(prob['rna.tip_deflection'])
print 'rotor_mass = ' + beautify(prob['rna.rotor_mass'])
print 'hub_system_mass = ' + beautify(prob['rna.hub_system_mass'])
print 'nacelle_mass = ' + beautify(prob['rna.nacelle_mass'])
print 'gb_mass = ' + beautify(prob['rna.gearbox_mass'])
print 'rna_mass = ' + str(prob['rna.rotor_mass'][0] + prob['rna.hub_system_mass'][0] + prob['rna.nacelle_mass'][0])
print 'rna_cost = ' + beautify(prob['rna.cost_rna_total'])
print 'root_force = ' + beautify(prob['rna.rotor_force'])
print 'root_moment = ' + beautify(prob['rna.rotor_moment'])
print 'rotor_mass = ' + beautify(prob['rna.rotor_mass'])
print 'hub_mass = ' + beautify(prob['rna.hub_mass'])
print 'pitch_system_mass = ' + beautify(prob['rna.pitch_system_mass'])
print 'spinner_mass = ' + beautify(prob['rna.spinner_mass'])
print 'low_speed_shaft_mass = ' + beautify(prob['rna.low_speed_shaft_mass'])
print 'main_bearing_mass = ' + beautify(prob['rna.main_bearing_mass'])
print 'gearbox_mass = ' + beautify(prob['rna.gearbox_mass'])
print 'generator_mass = ' + beautify(prob['rna.generator_mass'])
print 'high_speed_side_mass = ' + beautify(prob['rna.high_speed_side_mass'])
print 'vs_electronics_mass = ' + beautify(prob['rna.vs_electronics_mass'])
print 'yaw_system_mass = ' + beautify(prob['rna.yaw_system_mass'])
print 'mainframe_mass = ' + beautify(prob['rna.mainframe_mass'])
print 'electrical_mass = ' + beautify(prob['rna.electrical_mass'])
print 'hvac_mass = ' + beautify(prob['rna.hvac_mass'])
print 'cover_mass = ' + beautify(prob['rna.cover_mass'])
print 'controls_mass = ' + beautify(prob['rna.controls_mass'])
print 'Done in ' + str(time() - start) + ' seconds'
# plots
font = {'family' : 'Tahoma', 'size' : 15}
plt.rc('font', **font)
fig = plt.figure()
x1 = fig.add_subplot(121)
x1.set_title('Chord distribution')
x1.set_xlabel('r [m]')
x1.set_ylabel('Chord [m]')
x1.plot(prob['rna.span_r'], prob['rna.span_chord'])
x2 = fig.add_subplot(122)
x2.set_title('Twist distribution')
x2.set_xlabel('r [m]')
x2.set_ylabel('Twist [deg]')
x2.plot(prob['rna.span_r'], prob['rna.span_twist'])
plt.show()
prob.model.connect("ivc.Cla_t", "Aerodynamics.cla_tail.Cla_t")
prob.model.connect("ivc.S_t", "Aerodynamics.cla_tail.S_t")
prob.model.connect("ivc.d_fuse_t", "Aerodynamics.cla_tail.d_fuse_t")
prob.model.connect("ivc.b_t", "Aerodynamics.cla_tail.b_t")
prob.model.connect("ivc.b", "Aerodynamics.wing_param.b")
prob.model.connect("ivc.taper", "Aerodynamics.wing_param.taper")
prob.model.connect("ivc.croot", "Aerodynamics.wing_param.croot")
prob.model.connect("ivc.W_0", "Weights.W_lg.W_0")
prob.model.connect("ivc.S_t", "Weights.W_tail.S_t")
prob.model.connect("ivc.S", "Weights.W_wing.S")
prob.model.connect("ivc.AR", "Weights.W_wing.AR")
prob.model.connect("ivc.q", "Weights.W_wing.q")
prob.model.connect("ivc.taper", "Weights.W_wing.taper")
prob.model.connect("ivc.thickness_ratio", "Weights.W_wing.thickness_ratio")
prob.model.connect("ivc.n", "Weights.W_wing.n")
prob.model.connect("ivc.W_0", "Weights.W_wing.W_0")
prob.model.connect("ivc.W_0", "Weights.W_wing_control.W_0")
# replace all "ivc.W_0" with "Weights.GrossWeightComp.W_0"
group.nonlinear_solver = NonlinearBlockGS(iprint=2, maxiter=30)
prob.setup()
prob.run_model()
#print(prob['cla_wing.CLa'])
#prob.check_partials(compact_print=True)
# TO RUN: 'python run.py'
# TO VISUALIZE: 'openmdao view_model run.py'
view_model(prob)
"""
This is not a real run_file. It is only used to make the n2
diagram for the notional aerostructural problem used for demonstration in the docs.
"""
from openmdao.api import Problem, Group, ExecComp, IndepVarComp, view_model, ImplicitComponent
p = Problem()
dvs = p.model.add_subsystem('design_vars', IndepVarComp(), promotes=['*'])
dvs.add_output('x_aero')
dvs.add_output('x_struct')
aerostruct = p.model.add_subsystem('aerostruct_cycle', Group(), promotes=['*'])
#note the equations don't matter... just need a simple way to get inputs and outputs there
aerostruct.add_subsystem('aero',
ExecComp(['w = u+x_aero', 'Cl=u+x_aero', 'Cd = u + x_aero']),
promotes=['*'])
aerostruct.add_subsystem('struct', ExecComp(['u = w+x_struct', 'mass=x_struct']),
promotes=['*'])
p.model.add_subsystem('objective', ExecComp('f=mass+Cl/Cd'), promotes=['*'])
p.model.add_subsystem('constraint', ExecComp('g=Cl'), promotes=['*'])
p.setup()
view_model(p, outfile='aerostruct_n2.html', embeddable=True, show_browser=False)
