x.add_process(['opt', 'D1', 'D2', 'F', 'G', 'opt'], arrow=True)
x.connect('opt', 'D1', r'x, z, y_2')
x.connect('opt', 'D2', r'z, y_1')
x.connect('opt', 'D3', r'z, y_1')
x.connect('opt', 'F', r'x, z')
x.connect('opt', 'F', r'y_1, y_2')
# you can also stack variables
x.connect('opt', 'G', r'y_1, y_2', stack=True)
x.connect('D1', 'opt', r'\mathcal{R}(y_1)')
x.connect('D2', 'opt', r'\mathcal{R}(y_2)')
x.connect('F', 'opt', r'f')
x.connect('G', 'opt', r'g', stack=True)
# can specify inputs to represent external information coming into the XDSM
x.add_input('D1', r'P_1')
x.add_input('D2', r'P_2')
# can put outputs on the left or right sides
x.add_output('opt', r'x^*, z^*', side='right')
x.add_output('D1', r'y_1^*', side='left')
x.add_output('D2', r'y_2^*', side='left')
x.add_output('F', r'f^*', side='right')
x.add_output('G', r'g^*', side='right')
x.write('kitchen_sink', cleanup=False)
x.connect('subopt', 'MM', 'z_2')
x.connect('opt', 'G2', 'z')
x.connect('opt', 'F', 'x, z')
x.connect('opt', 'F', 'y_1, y_2')
# you can also stack variables
x.connect('opt', 'H', 'y_1, y_2', stack=True)
x.connect('D1', 'opt', r'\mathcal{R}(y_1)')
x.connect('D2', 'opt', r'\mathcal{R}(y_2)')
x.connect('F', 'opt', 'f')
x.connect('H', 'opt', 'h', stack=True)
# can specify inputs to represent external information coming into the XDSM
x.add_input('D1', 'P_1')
x.add_input('D2', 'P_2')
x.add_input('opt', r'x_0', stack=True)
# can put outputs on the left or right sides
x.add_output('opt', r'x^*, z^*', side='right')
x.add_output('D1', r'y_1^*', side='left')
x.add_output('D2', r'y_2^*', side='left')
x.add_output('F', r'f^*', side='right')
x.add_output('H', r'h^*', side='right')
x.add_output('opt', r'y^*', side='left')
x.add_process(['output_opt', 'opt', 'left_output_opt'])
x.write('kitchen_sink', cleanup=False)
x.write_sys_specs('sink_specs')
x.connect("subopt", "MM", "z_2")
x.connect("opt", "G2", "z")
x.connect("opt", "F", "x, z")
x.connect("opt", "F", "y_1, y_2")
# you can also stack variables
x.connect("opt", "H", "y_1, y_2", stack=True)
x.connect("D1", "opt", r"\mathcal{R}(y_1)")
x.connect("D2", "opt", r"\mathcal{R}(y_2)")
x.connect("F", "opt", "f")
x.connect("H", "opt", "h", stack=True)
# can specify inputs to represent external information coming into the XDSM
x.add_input("D1", "P_1")
x.add_input("D2", "P_2")
x.add_input("opt", r"x_0", stack=True)
# can put outputs on the left or right sides
x.add_output("opt", r"x^*, z^*", side=RIGHT)
x.add_output("D1", r"y_1^*", side=LEFT)
x.add_output("D2", r"y_2^*", side=LEFT)
x.add_output("F", r"f^*", side=RIGHT)
x.add_output("H", r"h^*", side=RIGHT)
x.add_output("opt", r"y^*", side=LEFT)
x.add_process(["output_opt", "opt", "left_output_opt"])
x.write("kitchen_sink", cleanup=False)
x.write_sys_specs("sink_specs")
comp = 'Analysis'
group = 'Metamodel'
func = 'Function'
x = XDSM()
x.add_system('d1', comp, r'\TwolineComponent{10em}{Discipline 1}{$y_1 = z_1^2 + z_2 + x_1 - 0.2y_2$}')
x.add_system('d2', comp, r'\TwolineComponent{8em}{Discipline 2}{$y_2 = \sqrt{y_1} + z_1 + z_2$}')
x.add_system('f', func, r'\TwolineComponent{10em}{Objective}{$f = x^2 + z_1 + y_1 + e^{-y_2}$}')
x.add_system('g1', func, r'\TwolineComponent{7em}{Constraint 1}{$g1 = 3.16-y_1 $}')
x.add_system('g2', func, r'\TwolineComponent{7em}{Constraint 2}{$g_2 = y_2 - 24.0$}')
x.connect('d1', 'd2', r'$y_1$')
x.connect('d1', 'f', r'$y_1$')
x.connect('d1', 'g1', r'$y_1$')
x.connect('d2', 'd1', r'$y_2$')
x.connect('d2', 'f', r'$y_2$')
x.connect('d2', 'g2', r'$y_2$')
x.add_input('d1', r'$x, z_1, z_2$')
x.add_input('d2', r'$z_1, z_2$')
x.add_input('f', r'$x, z_1$')
x.add_output('f', r'$f$', side='right')
x.add_output('g1', r'$g_1$', side='right')
x.add_output('g2', r'$g_2$', side='right')
x.write('sellar_xdsm')
from pyxdsm.XDSM import XDSM, OPT, SOLVER, FUNC, GROUP
x = XDSM()
x.add_system("prob1_opt", OPT, "Optimize\_Prob1")
x.add_system("d_airfoil", FUNC, "DesignAirfoil", stack=True)
x.add_system("comp_mod_power", FUNC, "ComputeModifiedPower")
x.connect("prob1_opt", "d_airfoil", "airfoil\_design")
x.connect("comp_mod_power", "prob1_opt", "modified\_power")
x.connect("d_airfoil", "comp_mod_power", "aerodynamic\_eff", stack=True)
x.connect("d_airfoil", "comp_mod_power2", "aerodynamic\_eff*", stack=True)
x.add_input("d_airfoil", "wind\_speeds", stack=True)
x.add_system("prob2_opt", OPT, "Optimize\_Prob2")
x.add_system("comp_pitch_angles", GROUP, "ComputeOptPitchAngle", stack=True)
x.add_system("comp_mod_power2", FUNC, "ComputeModifiedPower")
x.connect("prob2_opt", "comp_pitch_angles", "drag\_modifier")
x.connect("comp_mod_power2", "prob2_opt", "powers, modified\_power")
x.connect("comp_pitch_angles", "comp_mod_power2", "powers*", stack=True)
x.connect("comp_pitch_angles", "comp_mod_power", "powers**", stack=True)
x.add_input("comp_pitch_angles", "wind\_speeds", stack=True)
x.write("run_sequential_top_level")
DOE = "DOE"
IFUNC = "ImplicitFunction"
FUNC = "Function"
GROUP = "Group"
IGROUP = "ImplicitGroup"
METAMODEL = "Metamodel"
DataIO = "DataIO"
DataInter = "DataInter"
x.add_system("D1", FUNC, ["Discipline1", "y_1=z_1^2+z_2+x_1-0.2y_2"])
x.add_system("D2", FUNC, ["Discipline2", "y_2=sqrt(y_1)+z_1+z_2"])
x.add_system("OBJ", FUNC, ["Objective", "f=x^2+z_2+y_1+exp(-y_2)"])
x.add_system("G1", FUNC, ["Constraint1", "g_1=3.16-y_1"])
x.add_system("G2", FUNC, ["Constraint2", "g_2=y_2-24"])
x.add_input("D1", "x,z_1,z_2")
x.add_input("D2", "z_1,z_2")
x.add_input("OBJ", "x,z_2")
x.connect("D1", "D2", "y_1")
x.connect("D1", "OBJ", "y_1")
x.connect("D1", "G1", "y_1")
x.connect("D2", "OBJ", "y_2")
x.connect("D2", "G2", "y_2")
x.connect("D2", "D1", "y_2")
x.add_output("OBJ", "f", side="right")
x.add_output("G1", "g_1", side="right")
x.add_output("G2", "g_2", side="right")
# spec_name = 'xyz' (changes the spec name from defalt 'e_comp' to 'xyz')
x.add_system('Optimizer', opt, ['Optimizer'], spec_name=False)
x.add_system('e_solver', solver, ['Solver'], spec_name=False)
x.add_system('pack_design', func, ['Pack'])
x.add_system('PCM', func, ['PCM'])
x.add_system('heat_pipe', func, ['Heat pipe'])
x.add_system('Struct', func, ['Struct'])
# Optimizer
x.connect('Optimizer', 'pack_design',
['energy_{required}', 'eta_{batt}', 'I_{batt}'])
# Pack Size
x.add_input('pack_design', [
'L_{pack}', 'W_{pack}', 'L_{cell}', 'W_{cell}', 'H_{cell}', 'mass_{cell}',
'voltage_{low,cell}', 'voltage_{nom,cell}', 'dischargeRate_{cell}',
'Q_{max}', 'V_{batt}'
])
x.connect('pack_design', 'PCM', ['n_{cpk}', 'n_{kps}'])
x.connect('pack_design', 'Struct', 'mass_{cell}')
x.add_output('pack_design', ['n_{series}', 'n_{parallel}'], side='right')
# PCM
x.connect('PCM', 'pack_design', 't_{PCM}')
x.connect('PCM', 'Struct', 'mass_{PCM}')
# HP
x.add_input('heat_pipe', ['d_{init}', 'rho_{HP}', 'L_{pack}'])
x.connect('heat_pipe', 'Struct', 'mass_{HP}')
x.connect('heat_pipe', 'pack_design', 't_{HP}')
# Connect Dymos outputs to subsystems
x.connect('DYMOS', 'battery', ['SOC', 'V_{thev}','Q_{fire}','PCM_{sat}'])
# Connect Solver states to subsystems
x.connect('e_solver', 'e_comp', '')
x.connect('e_solver', 'battery', '')
# Connect Zappy outputs to subsystems
x.connect('e_comp', 'battery', 'I_{batt}')
x.add_output('e_comp', 'Q_{lines}', side='right') # output to thermal phase
# x.add_output('e_comp', r'C_{max}', side='right')
# Connect Battery outputs to subsystems
x.add_input('battery', ['n_{series}','n_{parallel}','Q_{max}'])
x.connect('battery', 'DYMOS', ['dXdt:SOC', 'dXdt:V_{thev}','dXdt:PCM_{sat}'])
x.connect('battery', 'e_comp', 'V_{batt,actual}')
x.connect('battery', 'e_solver', '')
x.connect('battery', 'TMS', ['T_{cold}'])
x.add_output('battery', ['T_{batt}'], side='right')
x.add_input('TMS', ['A_{cold}'])
x.connect('TMS','battery',['Q_{rej}'])
# # Connect Thermal outputs to subsystems
# x.add_input('tms_comp', [r'W_{coolant}', 'mass_{res,coolant}',r'mass_{motor}',r'mass_{battery}',r'width_{ACC}',r'height_{ACCc}',r'height_{ACCa}',r'Area_{throat}'])
# x.connect('tms_comp', 'DYMOS', ['dXdt:T_{coolant}','dXdt:T_{batt}','dXdt:T_{motor}'])
# x.add_output('tms_comp', 'Power_{TMS}', side='right')
# x.add_output('tms_comp', r'T_{coolant}', side='right')
from pyxdsm.XDSM import XDSM
x = XDSM()
# Define styles
OPT = "Optimization"
SUBOPT = "SubOptimization"
SOLVER = "MDA"
DOE = "DOE"
IFUNC = "ImplicitFunction"
FUNC = "Function"
GROUP = "Group"
IGROUP = "ImplicitGroup"
METAMODEL = "Metamodel"
DataIO = "DataIO"
DataInter = "DataInter"
x.add_system("opt", OPT, [r"\text{Optimizer}"])
x.add_system("D1", FUNC, ["Discipline1", "f(x,y)=(x-3)^2+xy+(y+4)^2-3"])
x.add_input("opt", "x^{(0)},y^{(0)}")
x.connect("opt", "D1", "x,y")
x.connect("D1", "opt", "f")
x.add_output("opt", "x^*,y^*", side="left")
x.add_output("D1", "f^*", side="left")
x.write("xdsm_single_disp")
#
opt = 'Optimization'
solver = 'MDA'
group = 'Group'
func = 'Function'
x = XDSM()
x.add_system('d1', func, [r'Discipline 1', 'y_1 = z_1^2 + z_2 + x_1 - 0.2y_2'])
x.add_system('d2', func, [r'Discipline 2', 'y_2 = \sqrt{y_1} + z_1 + z_2'])
x.add_system('f', func, [r'Objective', 'f = x^2 + z_1 + y_1 + e^{-y_2}'])
x.add_system('g1', func, [r'Constraint 1', 'g1 = 3.16-y_1 '])
x.add_system('g2', func, [r'Constraint 2', 'g_2 = y_2 - 24.0'])
x.connect('d1', 'd2', r'y_1')
x.connect('d1', 'f', r'y_1')
x.connect('d1', 'g1', r'y_1')
x.connect('d2', 'd1', r'y_2')
x.connect('d2', 'f', r'y_2')
x.connect('d2', 'g2', r'y_2')
x.add_input('d1', r'x, z_1, z_2')
x.add_input('d2', r'z_1, z_2')
x.add_input('f', r'x, z_1')
x.add_output('f', r'f', side='right')
x.add_output('g1', r'g_1', side='right')
x.add_output('g2', r'g_2', side='right')
x.write('sellar_xdsm')
#
opt = 'Optimization'
solver = 'MDA'
ecomp = 'Analysis'
icomp = 'ImplicitAnalysis'
group = 'Metamodel'
func = 'Function'
x = XDSM()
x.add_system('opt', opt, r'\text{Optimizer}')
x.add_system('des',
icomp, [r'\text{Discipline Design}', r'\text{Models}'],
stack=True)
x.add_system('miss',
icomp, [r'\text{Mission Performance}', r'\text{Models}'],
stack=True)
x.add_input('des', [r'\text{Discipline}', r'\text{Design Inputs}'])
x.add_input('miss', [r'\text{Mission Inputs}'])
x.connect('opt', 'des', [r'\text{Discipline}', r'\text{Design Variables}'])
x.connect('opt', 'miss', [r'\text{Optimal Control}', r'\text{Variables}'])
x.connect('des', 'miss',
[r'\text{Discipline Design}', r'\text{Characteristics}'])
x.connect('des', 'opt', [r'\text{Design Constraints}'])
x.connect('miss', 'opt',
[r'\text{Objective Function,}', r'\text{Operational Constraints}'])
x.write('General_XDSM')
FUNC = "Function"
GROUP = "Group"
IGROUP = "ImplicitGroup"
METAMODEL = "Metamodel"
DataIO = "DataIO"
DataInter = "DataInter"
x.add_system("opt", OPT, [r"\text{Optimizer}"])
x.add_system("solver", SOLVER, [r"\text{MDA}"])
x.add_system("D1", FUNC, ["Discipline1", "y_{21}=x_1+x_2"])
x.add_system("D2", FUNC, ["Discipline2", "y_{12}=x_1/2+x_2"])
x.add_system("OBJ", FUNC, ["Objective", "f=x_1^2+x_2^2+x_3^2"])
x.add_system("G1", FUNC, ["Constraint1", "g_1=y_{12}^t/2+3x_1/4+1"])
x.add_system("G2", FUNC, ["Constraint2", "g_2=-y_{21}^t-x_1+x_3"])
x.add_input("opt", "x_1^{(0)},x_2^{(0)},x_3^{(0)}")
x.connect("opt", "D1", "x_1,x_2")
x.connect("opt", "D2", "x_1,x_2")
x.connect("opt", "OBJ", "x_1,x_2,x_3")
x.connect("opt", "G1", "x_1")
x.connect("opt", "G2", "x_1,x_3")
x.connect("solver", "G1", "y_{12}^t")
x.connect("solver", "G2", "y_{21}^t")
x.connect("D1", "solver", "y_{21}")
x.connect("D2", "solver", "y_{12}")
x.connect("OBJ", "opt", "f")
x.connect("G1", "opt", "g_1")
x.connect("G2", "opt", "g_2")
# spec_name = False (don't write a spec)
# spec_name = 'xyz' (changes the spec name from defalt 'e_comp' to 'xyz')
x.add_system('Optimizer', opt, ['Optimizer'], spec_name=False)
x.add_system('case', func, ['Case'], spec_name=False)
# x.add_system('battery', func, ['Battery'], spec_name=False)
x.add_system('PCM', func, ['PCM'], spec_name=False)
x.add_system('heat_pipe', func, ['Heat pipe'], spec_name=False)
x.add_system('pack', func, ['Pack'], spec_name=False)
x.add_system('transient', func, ['Temp Transient'], spec_name=False)
# Optimizer
#x.connect('Optimizer','pack', ['energy_{required}','eta_{batt}','I_{batt}'])
x.add_input('Optimizer',['T_{neighbor,limit}','Q_{runaway}'])
x.connect('Optimizer','case',['t_{case}'])
x.connect('Optimizer','heat_pipe', ['D_{hp}, (W_{hp})','t_{wall}','t_{wick}','t_{case}','epsilon_{hp}'])
x.connect('Optimizer','transient', ['D_{hp}, (W_{hp})','t_{wall}','t_{wick}','epsilon_{hp}'])
x.connect('Optimizer','PCM', ['t_{pcm}','porosity_{pcm}'])
x.connect('Optimizer','pack',['t_{case}'])
# Case
x.add_input('case',['L_{cell}', 'W_{cell}', 'H_{cell}'])
x.connect('case','pack',['mass_{case}'])
#x.add_output('case', ['mass_{battery}'], side='right')
# Battery
# x.connect('battery', 'pack',['mass_{cell}','A_{cell}','t_{cell}'])
# x.connect('battery', 'transient',['mass_{cell}','A_{cell}'])
x.add_system('F', func, r'$F$')
# stacked can be used to represent multiple instances that can be run in parallel
x.add_system('G', func, r'$G$', stack=True)
x.connect('opt', 'D1', r'$x, z, y_2$')
x.connect('opt', 'D2', r'$z, y_1$')
x.connect('opt', 'F', r'$x, z$')
x.connect('opt', 'F', r'$y_1, y_2$')
# you can also stack variables
x.connect('opt', 'G', r'$y_1, y_2$', stack=True)
x.connect('D1', 'opt', r'$\mathcal{R}(y_1)$')
x.connect('D2', 'opt', r'$\mathcal{R}(y_2)$')
x.connect('F', 'opt', r'$f$')
x.connect('G', 'opt', r'$g$', stack=True)
# can specify inputs to represent external information coming into the XDSM
x.add_input('D1', r'$P_1$')
x.add_input('D2', r'$P_2$')
# can put outputs on the left or right sides
x.add_output('opt', r'$x^*, z^*$', side='right')
x.add_output('D1', r'$y_1^*$', side='left')
x.add_output('D2', r'$y_2^*$', side='left')
x.add_output('F', r'$f^*$', side='right')
x.add_output('G', r'$g^*$', side='right')
x.write('idf')
# Create subsystem components
# spec_name = False (don't write a spec)
# spec_name = 'xyz' (changes the spec name from defalt 'e_comp' to 'xyz')
x.add_system('dymos', solver, ['Dymos'], spec_name=False)
x.add_system('battery', func, ['Battery'], spec_name=False, stack=True)
x.add_system('PCM', func, ['PCM'], spec_name=False, stack=True)
x.add_system('heat_pipe', func, ['Heat pipe'], spec_name=False)
# Dymos
#x.connect('dymos','Optimizer','T_{neighbor}')
x.connect('dymos', 'heat_pipe', 'T_{wall}', stack=True)
x.connect('dymos', 'PCM', 'T_{pcm}', stack=True)
x.connect('dymos', 'battery', 'T_{cell}', stack=True)
# Battery
x.add_input('battery', ['rho/cp_{cell}', 'q_{in,cell}'])
x.connect('battery', 'PCM', ['q_{in,pcm}'], stack=True)
x.connect('battery', 'dymos', 'dT_{cells}/dt', stack=True)
# x.add_output('battery', ['n_{series}','n_{parallel}'], side='right')
# PCM
x.add_input(
'PCM',
['t_{pad}, A_{pad}', 'porosity', 'rho/LH/K/cp_{foam/pcm}', 'T_{hi/lo}'])
x.connect('PCM', 'dymos', 'dT_{pcm}/dt', stack=True)
x.connect('PCM', 'heat_pipe', 'q_{in,hp}', stack=True)
x.connect('PCM', 'battery', 'q_{out,pcm}', stack=True)
x.add_output('PCM', ['PS'], side='right', stack=True)
# HP
x.add_input('heat_pipe', ['geometry (round/flat)', 'num_{cells}'])
