def _setup(self, root):
super(KonaOptimizer, self)._setup(root)
self.system = root
self.pmeta = self.get_desvar_metadata()
self.params = list(iterkeys(self.pmeta))
self.objs = list(iterkeys(self.get_objectives()))
self.con_meta = self.get_constraint_metadata()
self.cons = list(iterkeys(self.con_meta))
# Size Problem
s_primal = 0
for param in itervalues(self.pmeta):
s_primal += param['size']
self.size_primal = s_primal
# set up the mapping between KONA vectors and OpenMDAO variables
self.pmeta = self.get_desvar_metadata()
# make a list of state vars
all_vars = set(self.system.unknowns.keys())
primal_vars = set(iterkeys(self.pmeta))
o_vars = set(iterkeys(self.get_objectives()))
d_vars = set(iterkeys(self.get_constraint_metadata()))
end=0
o_var_idx = []
for o_var in self.objs:
size = self.system.unknowns.metadata(o_var)['size']
start = end
end += size
o_var_idx.append((start, end))
self.objective_vars = tuple(zip(o_vars, o_var_idx))
end = 0
p_var_idx = []
for p_var in primal_vars:
size = self.pmeta[p_var]['size']
start = end
end += size
p_var_idx.append((start, end))
self.primal_vars = tuple(zip(primal_vars, p_var_idx))
self.size_primal = end
s_var_names = list(all_vars - primal_vars - o_vars - d_vars)
s_var_idx = []
end = 0
for s_var in s_var_names:
meta = self.system.unknowns.metadata(s_var)
size = meta['size']
start = end
end += size
s_var_idx.append((start, end))
self.state_vars = tuple(zip(s_var_names, s_var_idx))
self.size_state = end
d_vars_lower_ieq = []
d_var_idx_lower_ieq = []
d_var_bound_lower_ieq = []
d_vars_upper_ieq = []
d_var_idx_upper_ieq = []
d_var_bound_upper_ieq = []
d_vars_eq = []
d_var_idx_eq = []
d_var_bound_eq = []
d_vars = []
d_var_idx = []
end_eq = 0
end_ieq_lb = 0
end_ieq_ub = 0
self.size_dual_eq = 0
self.size_dual_ieq_lb = 0
self.size_dual_ieq_ub = 0
# user specified constraints
for d_var, d_meta in iteritems(self.get_constraint_metadata()):
size = d_meta['size']
d_vars.append(d_var)
d_var_idx.append((start,end))
if d_meta['equals'] is not None:
start_eq = end_eq
end_eq += size
d_vars_eq.append(d_var)
d_var_idx_eq.append((start_eq, end_eq))
d_var_bound_eq.append(d_meta['equals'])
self.size_dual_eq += size
if d_meta['lower'] is not None:
start_ieq_lb = end_ieq_lb
end_ieq_lb += size
d_vars_lower_ieq.append(d_var)
d_var_idx_lower_ieq.append((start_ieq_lb, end_ieq_lb))
d_var_bound_lower_ieq.append(d_meta['lower'])
self.size_dual_ieq_lb += size
if d_meta['upper'] is not None:
start_ieq_ub = end_ieq_ub
end_ieq_ub += size
d_vars_upper_ieq.append(d_var)
d_var_idx_upper_ieq.append((start_ieq_ub, end_ieq_ub))
d_var_bound_upper_ieq.append(d_meta['upper'])
self.size_dual_ieq_ub += size
self.dual_vars_eq = tuple(zip(d_vars_eq, d_var_idx_eq, d_var_bound_eq))
self.dual_vars_ieq_ub = tuple(zip(d_vars_upper_ieq, d_var_idx_upper_ieq, d_var_bound_upper_ieq))
self.dual_vars_ieq_lb = tuple(zip(d_vars_lower_ieq, d_var_idx_lower_ieq, d_var_bound_lower_ieq))
# print(self.dual_vars_ieq_lb)
p_vars_lb = []
p_var_idx_lb = []
p_var_bound_lb = []
p_vars_ub = []
p_var_idx_ub = []
p_var_bound_ub = []
end_lb = 0
end_ub = 0
self.size_primal_lb = 0
self.size_primal_ub = 0
# bounds constraints
for p_var in primal_vars:
meta_low = self.pmeta[p_var]['lower']
meta_high = self.pmeta[p_var]['upper']
size = self.pmeta[p_var]['size']
if meta_low is not None and np.any(meta_low > -1e99):
start_lb = end_lb
end_lb += size
p_vars_lb.append(p_var)
p_var_idx_lb.append((start_lb, end_lb))
p_var_bound_lb.append(meta_low)
self.size_primal_lb += size
if meta_high is not None and np.any(meta_high < 1e99):
start_ub = end_ub
end_ub += size
p_vars_ub.append(p_var)
p_var_idx_ub.append((start_ub, end_ub))
p_var_bound_ub.append(meta_high)
self.size_primal_ub += size
self.primal_vars_lb = tuple(zip(p_vars_lb, p_var_idx_lb, p_var_bound_lb))
self.primal_vars_ub = tuple(zip(p_vars_ub, p_var_idx_ub, p_var_bound_ub))
self.allocator = Allocator(self.size_primal, self.size_state, self.size_dual_eq,
self.size_dual_ieq_lb, self.size_dual_ieq_ub,
self.size_primal_lb, self.size_primal_ub)
# Set up specific data transfers for objective and
# constraints needed for eval_obj and eval_constraints methods
obj_cnames, self._obj_comps = self._comps_from_vars(self._objs)
con_cnames, self._con_comps = self._comps_from_vars(self._cons)
self._obj_xfers = []
self._con_xfers = []
for grp in self.root.subgroups(recurse=True, include_self=True):
for cname in obj_cnames:
tup = (name_relative_to(grp.pathname, cname), 'fwd', None)
if tup in grp._data_xfer:
self._obj_xfers.append((grp, grp._data_xfer[tup]))
for cname in con_cnames:
tup = (name_relative_to(grp.pathname, cname), 'fwd', None)
if tup in grp._data_xfer:
self._con_xfers.append((grp, grp._data_xfer[tup]))
self._push_primal_nl = self._build_primal_state_vec_xfer('primal', push=True,
nonlinear=True)
self._pull_primal_nl = self._build_primal_state_vec_xfer('primal', push=False,
nonlinear=True)
self._push_primal_ln = self._build_primal_state_vec_xfer('primal', push=True,
nonlinear=False)
self._pull_primal_ln = self._build_primal_state_vec_xfer('primal', push=False,
nonlinear=False)
self._push_state_nl = self._build_primal_state_vec_xfer('state', push=True,
nonlinear=True)
self._pull_state_nl = self._build_primal_state_vec_xfer('state', push=False,
nonlinear=True)
self._push_state_ln = self._build_primal_state_vec_xfer('state', push=True,
nonlinear=False)
self._pull_state_ln = self._build_primal_state_vec_xfer('state', push=False,
nonlinear=False)
self._push_resid_nl = self._build_primal_state_vec_xfer('resid', push=True,
nonlinear=True)
self._pull_resid_nl = self._build_primal_state_vec_xfer('resid', push=False,
nonlinear=True)
self._push_resid_ln = self._build_primal_state_vec_xfer('resid', push=True,
nonlinear=False)
self._pull_resid_ln = self._build_primal_state_vec_xfer('resid', push=False,
nonlinear=False)
self._push_dual_nl = self._build_dual_vec_xfer(push=True,
nonlinear=True)
self._pull_dual_nl = self._build_dual_vec_xfer(push=False,
nonlinear=True)
self._push_dual_ln = self._build_dual_vec_xfer(push=True,
nonlinear=False)
self._pull_dual_ln = self._build_dual_vec_xfer(push=False,
nonlinear=False)
