class DakotaBase(Driver):
"""
Base class for common DAKOTA operations, adds :class:`DakotaInput` instance.
The ``method`` and ``responses`` sections of `input` must be set
directly. :meth:`set_variables` is typically used to set the ``variables``
section.
"""
implements(IHasParameters, IHasObjectives)
output = Enum('normal',
iotype='in',
desc='Output verbosity',
values=('silent', 'quiet', 'normal', 'verbose', 'debug'))
stdout = Str('', iotype='in', desc='DAKOTA stdout filename')
stderr = Str('', iotype='in', desc='DAKOTA stderr filename')
tabular_graphics_data = \
Bool(iotype='in',
desc="Record evaluations to 'dakota_tabular.dat'")
def __init__(self):
super(DakotaBase, self).__init__()
# Set baseline input, don't touch 'interface'.
self.input = DakotaInput(environment=[],
method=[],
model=['single'],
variables=[],
responses=[])
def check_config(self, strict=False):
""" Verify valid configuration. """
super(DakotaBase, self).check_config(strict=strict)
parameters = self.get_parameters()
if not parameters:
self.raise_exception('No parameters, run aborted', ValueError)
objectives = self.get_objectives()
if not objectives:
self.raise_exception('No objectives, run aborted', ValueError)
def configure_input(self):
""" Configures input specification, must be overridden. """
self.raise_exception('configure_input', NotImplementedError)
def execute(self):
""" Write DAKOTA input and run. """
self.configure_input()
self.run_dakota()
def set_variables(self, need_start, uniform=False, need_bounds=True):
""" Set :class:`DakotaInput` ``variables`` section. """
parameters = self.get_parameters()
if uniform:
self.input.variables = [
'uniform_uncertain = %s' % self.total_parameters()
]
else:
self.input.variables = [
'continuous_design = %s' % self.total_parameters()
]
if need_start:
initial = [str(val) for val in self.eval_parameters(dtype=None)]
self.input.variables.append(' initial_point %s' %
' '.join(initial))
if need_bounds:
lbounds = [str(val) for val in self.get_lower_bounds(dtype=None)]
ubounds = [str(val) for val in self.get_upper_bounds(dtype=None)]
self.input.variables.extend([
' lower_bounds %s' % ' '.join(lbounds),
' upper_bounds %s' % ' '.join(ubounds)
])
names = []
for param in parameters.values():
for name in param.names:
names.append('%r' % name)
self.input.variables.append(' descriptors %s' % ' '.join(names))
def run_dakota(self):
"""
Call DAKOTA, providing self as data, after enabling or disabling
tabular graphics data in the ``environment`` section.
DAKOTA will then call our :meth:`dakota_callback` during the run.
"""
if not self.input.method:
self.raise_exception('Method not set', ValueError)
if not self.input.variables:
self.raise_exception('Variables not set', ValueError)
if not self.input.responses:
self.raise_exception('Responses not set', ValueError)
for i, line in enumerate(self.input.environment):
if 'tabular_graphics_data' in line:
if not self.tabular_graphics_data:
self.input.environment[i] = \
line.replace('tabular_graphics_data', '')
break
else:
if self.tabular_graphics_data:
self.input.environment.append('tabular_graphics_data')
infile = self.get_pathname() + '.in'
self.input.write_input(infile, data=self)
try:
run_dakota(infile, stdout=self.stdout, stderr=self.stderr)
except Exception:
self.reraise_exception()
def dakota_callback(self, **kwargs):
"""
Return responses from parameters. `kwargs` contains:
========== ==============================================
Key Definition
========== ==============================================
functions number of functions (responses, constraints)
---------- ----------------------------------------------
variables total number of variables
---------- ----------------------------------------------
cv list/array of continuous variable values
---------- ----------------------------------------------
div list/array of discrete integer variable values
---------- ----------------------------------------------
drv list/array of discrete real variable values
---------- ----------------------------------------------
av single list/array of all variable values
---------- ----------------------------------------------
cv_labels continuous variable labels
---------- ----------------------------------------------
div_labels discrete integer variable labels
---------- ----------------------------------------------
drv_labels discrete real variable labels
---------- ----------------------------------------------
av_labels all variable labels
---------- ----------------------------------------------
asv active set vector (bit1=f, bit2=df, bit3=d^2f)
---------- ----------------------------------------------
dvv derivative variables vector
---------- ----------------------------------------------
currEvalId current evaluation ID number
========== ==============================================
"""
cv = kwargs['cv']
asv = kwargs['asv']
self._logger.debug('cv %s', cv)
self._logger.debug('asv %s', asv)
self.set_parameters(cv)
self.run_iteration()
expressions = self.get_objectives().values()
if hasattr(self, 'get_eq_constraints'):
expressions.extend(self.get_eq_constraints().values())
if hasattr(self, 'get_ineq_constraints'):
expressions.extend(self.get_ineq_constraints().values())
fns = []
for i, expr in enumerate(expressions):
if asv[i] & 1:
val = expr.evaluate(self.parent)
if isinstance(val, list):
fns.extend(val)
else:
fns.append(val)
if asv[i] & 2:
self.raise_exception('Gradients not supported yet',
NotImplementedError)
if asv[i] & 4:
self.raise_exception('Hessians not supported yet',
NotImplementedError)
retval = dict(fns=array(fns))
self._logger.debug('returning %s', retval)
return retval
class DakotaBase(Driver):
"""
Base class for common DAKOTA operations, adds :class:`DakotaInput` instance.
The ``method`` and ``responses`` sections of `input` must be set
directly. :meth:`set_variables` is typically used to set the ``variables``
section.
"""
implements(IHasParameters, IHasObjectives)
output = 'normal',
#output = Enum('normal', iotype='in', desc='Output verbosity',
# values=('silent', 'quiet', 'normal', 'verbose', 'debug'))
stdout = ''
stderr = ''
tabular_graphics_data = True
def __init__(self):
super(DakotaBase, self).__init__()
# allow for special variable distributions
self.special_distribution_variables = []
self.clear_special_variables()
self.configured = None
# Set baseline input, don't touch 'interface'.
self.input = DakotaInput(environment=[],
method=[],
model=['single'],
variables=[],
responses=[])
def check_config(self, strict=False):
""" Verify valid configuration. """
super(DakotaBase, self).check_config(strict=strict)
parameters = self.get_parameters()
if not parameters and not self.special_distribution_variables:
self.raise_exception('No parameters, run aborted', ValueError)
objectives = self.get_objectives()
if not objectives:
self.raise_exception('No objectives, run aborted', ValueError)
def run_dakota(self):
"""
Call DAKOTA, providing self as data, after enabling or disabling
tabular graphics data in the ``environment`` section.
DAKOTA will then call our :meth:`dakota_callback` during the run.
"""
parameters = self.get_parameters()
#parameters = self._desvars
if not parameters:
self.raise_exception('No parameters, run aborted', ValueError)
if not self.methods:
raise ValueError('Method not set')
if not self.input.variables:
self.raise_exception('Variables not set', ValueError)
if not self.input.responses:
self.raise_exception('Responses not set', ValueError)
for i, line in enumerate(self.input.environment):
if 'tabular_graphics_data' in line:
if not self.tabular_graphics_data:
self.input.environment[i] = \
line.replace('tabular_graphics_data', '')
break
else:
if self.tabular_graphics_data:
self.input.environment.append('tabular_graphics_data')
infile = self.name + '.in'
self.input.write_input(infile, data=self)
#self.input.write_input(infile, data=self, other_data=self.other_model)
#from openmdao.core.mpi_wrap import MPI
from mpi4py import MPI
run_dakota(infile,
use_mpi=True,
mpi_comm=self.mpi_comm,
stdout=self.stdout,
stderr=self.stderr,
restart=0)
#if MPI:
# if self.mpi_comm:
# run_dakota(infile, use_mpi=True, mpi_comm = self.mpi_comm, stdout=self.stdout, stderr=self.stderr, restart=self.dakota_hotstart)
# else:
# run_dakota(infile, use_mpi=True, stdout=self.stdout, stderr=self.stderr, restart=self.dakota_hotstart)
#try:
# run_dakota(infile, stdout=self.stdout, stderr=self.stderr)
#except Exception:
# print sys.exc_info()
# exc_type, exc_value, exc_traceback = sys.exc_info()
# raise type('%s' % exc_type), exc_value, exc_traceback
# self.reraise_exception()
def dakota_callback(self, **kwargs):
"""
Return responses from parameters. `kwargs` contains:
========== ==============================================
Key Definition
========== ==============================================
functions number of functions (responses, constraints)
---------- ----------------------------------------------
variables total number of variables
---------- ----------------------------------------------
cv list/array of continuous variable values
---------- ----------------------------------------------
div list/array of discrete integer variable values
---------- ----------------------------------------------
drv list/array of discrete real variable values
---------- ----------------------------------------------
av single list/array of all variable values
---------- ----------------------------------------------
cv_labels continuous variable labels
---------- ----------------------------------------------
div_labels discrete integer variable labels
---------- ----------------------------------------------
drv_labels discrete real variable labels
---------- ----------------------------------------------
av_labels all variable labels
---------- ----------------------------------------------
asv active set vector (bit1=f, bit2=df, bit3=d^2f)
---------- ----------------------------------------------
dvv derivative variables vector
---------- ----------------------------------------------
currEvalId current evaluation ID number
========== ==============================================
"""
cv = kwargs['cv']
asv = kwargs['asv']
dvv = kwargs['dvv']
av_labels = kwargs['av_labels']
self.set_parameters(cv)
self.run_iteration()
expressions = self.get_objectives().values()
if hasattr(self, 'get_eq_constraints'):
expressions.extend(self.get_eq_constraints().values())
if hasattr(self, 'get_ineq_constraints'):
expressions.extend(self.get_ineq_constraints().values())
fns = []
fnGrads = []
for i, expr in enumerate(expressions):
if asv[i] & 1:
val = expr.evaluate(self.parent)
if isinstance(val, list):
fns.extend(val)
else:
fns.append(val)
if asv[i] & 2:
val = expr.evaluate_gradient(self.parent)
fnGrads.append(val)
# self.raise_exception('Gradients not supported yet',
# NotImplementedError)
if asv[i] & 4:
self.raise_exception('Hessians not supported yet',
NotImplementedError)
retval = dict(fns=array(fns), fnGrads=array(fnGrads))
self._logger.debug('returning %s', retval)
return retval
#print 'av_labs are ',av_labels , ' and cv is ', cv; quit()
#self._logger.debug('cv %s', cv)
#self._logger.debug('asv %s', asv)
#dvlist = [s for s in self.special_distribution_variables if s not in self.array_desvars]
#if True: #self.array_desvars:
# for i, var in enumerate(av_labels):
# if var in self.root.unknowns._dat.keys(): self.set_desvar(var, cv[i])
# elif re.findall("(.*)\[(.*)\]", var)[0][0] in self.root.unknowns._dat.keys():
# #print 'setting ',re.findall("(.*)\[(.*)\]", var)[0][0], int(re.findall("(.*)\[(.*)\]", var)[0][1]), ' as ', cv[i]
# self.set_desvar(re.findall("(.*)\[(.*)\]", var)[0][0], cv[i], index=[int(re.findall("(.*)\[(.*)\]", var)[0][1])])
#else:
# dvl = dvlist + self._desvars.keys() + self.special_distribution_variables
# #dvl = dvlist + self._desvars.keys()
# for i in range(len(cv)):
# if dvl[i] in self.root.unknowns._dat.keys(): self.set_desvar(dvl[i], cv[i])
# #self.set_desvar(dvl[i], cv[i])
# elif re.findall("(.*)\[(.*)\]", dvl[i])[0][0] in self.root.unknowns._dat.keys():
# self.set_desvar(re.findall("(.*)\[(.*)\]", dvl[i])[0][0], cv[i], index=[int(re.findall("(.*)\[(.*)\]", dvl[i])[0][1])])
#system = self.root
#metadata = self.metadata = create_local_meta(None, 'pydakrun%d'%world.Get_rank())
#system.ln_solver.local_meta = metadata
#self.iter_count += 1
#update_local_meta(metadata, (self.iter_count,))
#self.root.solve_nonlinear()
#system.solve_nonlinear(metadata=metadata)
#self.recorders.record_iteration(system, metadata)
#expressions = self.get_objectives().values()[0].tolist()#.update(self.get_constraints())
#cons = self.get_constraints()
#for c in cons:
# #expressions.append(-1*c)
# expressions.append(-1*self.get_constraints()[con])
#expressions = []
#for key in self.get_objectives():
# expressions += list(self.get_objectives()[key])
#for con in self.get_constraints().values():
# for c in con:
# expressions.append(-1*c)
#fns = []
#fnGrads = []
#for i in range(len(asv)):
# val = expressions[i]
# if asv[i] & 1 or asv[i]==0:
# fns.extend([val])
# if asv[i] & 2:
# objs = self.get_objectives().keys()
# gvars = []
# gvars_list = [] # we need to strip the descriptors of the [n] index
# gindexes = {} # then keep only the indexes of interest for each desvar
# seen = set()
# print kwargs['av_labels']
# vars_for_grads = kwargs['av_labels']
# for var in vars_for_grads:
# if var in self.root.unknowns._dat.keys(): gvars.append(var)
# else:
# vname = re.findall("(.*)\[(.*)\]", var)[0][0]
# if vname not in self.root.unknowns._dat.keys():
# raise ValueError("%s not in desvars"%vname)
# if vname not in seen:
# seen.add(vname)
# gvars_list.append(vname)
# ind = int(re.findall("(.*)\[(.*)\]", var)[0][1])
# if vname not in gindexes:
# gindexes[vname] = [ind]
# else: gindexes[vname].append(ind)
#
# # only supporting one objective for now. I'll have to find out more about
# # the ASV structure before continuing.
# for gvar in gvars_list:
# print gvars_list
# print 'gvar ', gvar
# grad = self._prob.calc_gradient([gvar], self.get_objectives().keys())[0]
# for ind in gindexes[gvar]:
# print ' index ', ind
# fnGrads.append(grad[ind])
# for gvar in gvars:
# grad = self._prob.calc_gradient([gvar], self.get_objectives().keys())[0]
# fnGrads.extend(grad)
# fnGrads = np.array([fnGrads])
# #print 'hey. grad is ', grad ; quit()
# #for lab in kwargs['av_labels']:
# #fnGrads.extend([val])
# #fnGrads.append([val])
# # self.raise_exception('Gradients not supported yet',
# # NotImplementedError)
# if asv[i] & 4:
# self.raise_exception('Hessians not supported yet',
# NotImplementedError)
#
# retval = dict(fns=array(fns), fnGrads = array(fnGrads))
# # print 'asv was ',asv
# # print 'returning ',retval
# #self._logger.debug('returning %s', retval)
# return retval
#
# We fully configure the input just before running the analysis as the user is liable to set
# several aspects of the optimization problem after calling pydakdriver.
# We only set the variables and responses blocks here, as the other input blocks are not dependant on
# additional configurations to the analysis.
def configure_input(self):
""" Configures input specification, must be overridden. """
# CONFIGURE VARIABLES
# Find regular parameters
parameters = [] # [ [name, value], ..]
dvars = self.get_parameters()
dvar_values = self.eval_parameters(dtype=None)
self.reg_params = parameters
for n, param in enumerate(dvars):
# if len(dvars[param]) == 1:
parameters.append([param, dvar_values[0]])
# else:
# for i, val in enumerate(dvars[param]):
# parameters.append([param + '[' + str(i) + ']', val])
# self.array_desvars.append(param + '[' + str(i) + ']')
self.input.reg_variables.append('continuous_design = %s' %
len(parameters))
secondaryV = False
for i in range(len(self.input.model)):
if 'secondary_variable_mapping' in self.input.model[i]:
secondaryV = True
if parameters:
state_params = []
for param in parameters:
if param not in self.special_distribution_variables:
state_params.append(param)
if state_params:
self.input.state_variables.append('continuous_state = %s' %
len(state_params))
initial = [] # initial points of regular paramters
for val in self.eval_parameters():
#for val in self.get_desvars().values():
# if isinstance(val, collections.Iterable):
# initial.extend(val)
# else:
initial.append(val)
self.input.reg_variables.append(' initial_point %s' %
' '.join(str(s) for s in initial))
if initial:
self.input.state_variables.append(
' initial_state %s' % ' '.join(str(s) for s in initial))
lbounds = self.get_lower_bounds(dtype=None)
#lbounds = []
#for val in self.eval_parameters():
#if not isinstance(val.lower, collections.Iterable):
# lbounds.extend(val["lower"] for _ in range(val['size']))
#else:
# lbounds.extend(val.lower())
ubounds = self.get_upper_bounds(dtype=None)
#ubounds = []
#for val in self.eval_parameters():
#for val in self._desvars.values():
#if not isinstance(val["upper"], collections.Iterable):
# ubounds.extend(val["upper"] for _ in range(val['size']))
#else:
# ubounds.extend(val.upper())
self.input.reg_variables.extend([
' lower_bounds %s' % ' '.join(str(bnd) for bnd in lbounds),
' upper_bounds %s' % ' '.join(str(bnd) for bnd in ubounds)
])
if lbounds and state_params:
self.input.state_variables.extend([
' lower_bounds %s' % ' '.join(str(bnd) for bnd in lbounds),
' upper_bounds %s' % ' '.join(str(bnd) for bnd in ubounds)
])
names = [s[0] for s in parameters]
self.input.reg_variables.append(' descriptors %s' %
' '.join("'" + str(nam) + "'"
for nam in names))
if names and state_params:
self.input.state_variables.append(' descriptors %s' %
' '.join("'" + str(nam) + "'"
for nam in names))
# Add special distributions cases
for var in self.special_distribution_variables:
if var in parameters: self.remove_parameter(var)
if ']' in var:
if int(re.findall("(.*)\[(.*)\]",
var)[0][1]) == 0 and re.findall(
"(.*)\[(.*)\]",
var)[0][0] not in self._desvars.keys():
self.add_parameter(re.findall("(.*)\[(.*)\]", var)[0][0])
else:
self.add_parameter(var, low=-99999999., high=99999999.)
if self.normal_descriptors:
# print(self.normal_means) ; quit()
self.input.uncertain_variables.extend([
'normal_uncertain = %s' % len(self.normal_means),
' means %s' % ' '.join(self.normal_means),
' std_deviations %s' % ' '.join(self.normal_std_devs),
" descriptors '%s'" % "' '".join(self.normal_descriptors),
' lower_bounds = %s' % ' '.join(self.normal_lower_bounds),
' upper_bounds = %s' % ' '.join(self.normal_upper_bounds)
])
if self.lognormal_descriptors:
self.input.uncertain_variables.extend([
'lognormal_uncertain = %s' % len(self.lognormal_means),
' means %s' % ' '.join(self.lognormal_means),
' std_deviations %s' % ' '.join(self.lognormal_std_devs),
" descriptors '%s'" % "' '".join(self.lognormal_descriptors)
])
if self.exponential_descriptors:
self.input.uncertain_variables.extend([
'exponential_uncertain = %s' %
len(self.exponential_descriptors),
' betas %s' % ' '.join(self.exponential_betas),
" descriptors ' %s'" %
"' '".join(self.exponential_descriptors)
])
if self.beta_descriptors:
self.input.uncertain_variables.extend([
'beta_uncertain = %s' % len(self.beta_descriptors),
' betas = %s' % ' '.join(self.beta_betas),
' alphas = %s' % ' '.join(self.beta_alphas),
" descriptors = '%s'" % "' '".join(self.beta_descriptors),
' lower_bounds = %s' % ' '.join(self.beta_lower_bounds),
' upper_bounds = %s' % ' '.join(self.beta_upper_bounds)
])
if self.gamma_descriptors:
self.input.uncertain_variables.extend([
'beta_uncertain = %s' % len(self.gamma_descriptors),
' betas = %s' % ' '.join(self.gamma_betas),
' alphas = %s' % ' '.join(self.gamma_alphas),
" descriptors = '%s'" % "' '".join(self.gamma_descriptors)
])
if self.weibull_descriptors:
self.input.uncertain_variables.extend([
'weibull_uncertain = %s' % len(self.weibull_descriptors),
' betas %s' % ' '.join(self.weibull_betas),
' alphas %s' % ' '.join(self.weibull_alphas),
" descriptors '%s'" % "' '".join(self.weibull_descriptors)
])
# CONFIGURE VARIABLES, METHOD, MODEL
for i in range(len(self.input.responses)):
if i != 0: self.input.variables.append('\nvariables\n')
self.input.variables.append("id_variables = 'vars%d'" % (i + 1))
if 'variable_options' in self.input.responses[i]:
self.input.variables.append(
self.input.responses[i]['variable_options'])
del self.input.responses[i]['variable_options']
if 'var_types' not in self.input.responses[i]:
if 'objective_functions' in self.input.responses[i]:
self.input.variables.append("\n".join(
self.input.reg_variables))
elif 'response_functions' in self.input.responses[i]:
self.input.variables.append(
"\n".join(self.input.uncertain_variables +
self.input.state_variables))
else:
raise ValueError(
"could not find response or objective in repsonse block %d %s"
) % (i, '\n'.join(self.input.responses[i]))
else:
for vartype in self.input.responses[i]['var_types']:
if vartype == 'uncertain':
self.input.variables.append("\n".join(
self.input.uncertain_variables))
elif vartype == 'design':
self.input.variables.append("\n".join(
self.input.reg_variables))
elif vartype == 'state':
self.input.variables.append("\n".join(
self.input.state_variables))
elif vartype == 'custom':
if self.custom_variables_blocks[i]:
self.input.variables.append("\n".join(
self.custom_variables_blocks[i]))
else:
raise ValueError(
"variable_block not specified but custom variables requested"
)
else:
raise ValueError("%s variable type is not supported" %
vartype)
del self.input.responses[i]['var_types']
objectives = self.get_objectives()
temp_list = []
for i in range(len(self.input.method)):
for key in self.input.method[i]:
temp_list.append("%s %s" % (key, self.input.method[i][key]))
self.methods = temp_list
self.input.method = temp_list
self.input.environment.append("method_pointer 'meth1'")
# Deal with variable mapping
#cons = []
#for con in self.get_constraints():
# for c in self.get_constraints()[con]:
# cons.append(-1 * c)
cons = []
secondary_responses = [[0] + [0 for _ in range(len(cons))]
for __ in range(len(cons))]
j = 0
for i in range(len(cons)):
secondary_responses[i][j + 1] = 1
j += 1
notnormps = [p[0] for p in parameters]
for x in self.reg_params:
if x[0] in notnormps: notnormps.remove(x[0])
names = [s[0] for s in parameters]
conlist = []
#for c in self.get_constraints():
# conlist.extend(self.get_constraints()[c])
temp_list = []
vm = None
for i in range(len(self.input.model)):
for key in self.input.model[i]:
temp_list.append("%s %s" % (key, self.input.model[i][key]))
if key == 'nested':
vect = [0] * (self.input.n_objectives[i] + len(cons))
maps = []
for j in range(self.input.n_objectives[i]):
s = vect
s[j] = 1
maps.append(s)
if "primary_response_mapping" not in self.input.model[i]:
vm = "primary_response_mapping "+\
"\n".join(" ".join(" ".join([str(a), str(a)]) for a in s) for s in maps)
else:
vm = " "
if vm:
temp_list.append(vm)
if "primary_variable_mapping" not in self.input.model[i]:
temp_list.append("primary_variable_mapping %s" %
" ".join("'" + str(nam) + "'"
for nam in names))
if cons:
if "secondary_response_mapping" not in self.input.model[
i]:
temp_list.append(
"secondary_response_mapping \n%s" % " \n".join(
" ".join(" ".join([str(s), str(s)])
for s in secondary_responses[i])
for i in range(len(cons))))
if "secondary_variable_mapping" in self.input.model[
i] and self.input.model[i][
"secondary_variable_mapping"] == "":
del self.input.model[i]["secondary_variable_mapping"]
temp_list.append(
"secondary_variable_mapping %s" %
" ".join("'mean'" if nam in self.
special_distribution_variables else "''"
for nam in names))
vm = 0
self.input.model = temp_list
temp_list = []
for i in range(len(self.input.responses)):
if 'objective_functions' in self.input.responses[i]:
self.input.responses[i][
'nonlinear_inequality_constraints'] = len(cons)
if 'response_functions' in self.input.responses[i]:
self.input.responses[i][
"response_functions"] = self.input.n_objectives[i] + len(
cons)
for key in self.input.responses[i]:
#temp_list.append(key)
if self.input.responses[i][key] or self.input.responses[i][
key] == 0:
temp_list.append(
str(key) + ' ' + str(self.input.responses[i][key]))
else:
temp_list.append(key)
self.input.responses = temp_list
self.configured = 1
# This is the entry point to initialize the analysis run
def execute(self):
""" Write DAKOTA input and run. """
self.configure_input()
#self._prob = problem
#if not self.configured: self.configure_input(problem) # this limits configuration to one time
self.run_dakota()
# --------------------------- special distribution magic ---------------------- #
def clear_special_variables(self):
for var in self.special_distribution_variables:
try:
self.remove_parameter(var)
except AttributeError:
pass
self.special_distribution_variables = []
self.normal_means = []
self.special_distribution_variables = []
self.normal_means = []
self.normal_std_devs = []
self.normal_descriptors = []
self.normal_lower_bounds = []
self.normal_upper_bounds = []
self.lognormal_means = []
self.lognormal_std_devs = []
self.lognormal_descriptors = []
self.exponential_betas = []
self.exponential_descriptors = []
self.beta_betas = []
self.beta_alphas = []
self.beta_descriptors = []
self.beta_lower_bounds = []
self.beta_upper_bounds = []
self.gamma_alphas = []
self.gamma_betas = []
self.gamma_descriptors = []
self.weibull_alphas = []
self.weibull_betas = []
self.weibull_descriptors = []
# adds a probability variable. This concept is unique to pydakdriver.
def add_special_distribution(self,
var,
dist,
alpha=_SET_AT_RUNTIME,
beta=_SET_AT_RUNTIME,
mean=_SET_AT_RUNTIME,
std_dev=_SET_AT_RUNTIME,
lower_bounds=_SET_AT_RUNTIME,
upper_bounds=_SET_AT_RUNTIME):
def check_set(option):
if option == _SET_AT_RUNTIME:
raise ValueError("INCOMPLETE DEFINITION FOR VARIABLE " +
str(var))
varlist = [] # handles array entries
if dist == 'normal':
check_set(std_dev)
check_set(mean)
# check_set(lower_bounds)
# check_set(upper_bounds)
# self.normal_lower_bounds.append(str(lower_bounds))
# self.normal_upper_bounds.append(str(upper_bounds))
if True: #str(type(mean)) in ['int', 'str']:
self.normal_means.append(str(mean))
self.normal_std_devs.append(str(std_dev))
self.normal_descriptors.append(var)
self.normal_lower_bounds.append(str(lower_bounds))
self.normal_upper_bounds.append(str(upper_bounds))
else:
self.normal_means.extend(str(m) for m in mean)
self.normal_std_devs.extend(str(s) for s in std_dev)
for i in range(len(mean)):
self.normal_descriptors.append(var + "[%d]" % i)
varlist.append(var + "[%d]" % i)
self.normal_lower_bounds.extend(str(l) for l in lower_bounds)
self.normal_upper_bounds.extend(str(u) for u in upper_bounds)
elif dist == 'lognormal':
check_set(std_dev)
check_set(mean)
self.lognormal_means.append(str(mean))
self.lognormal_std_devs.append(str(std_dev))
self.lognormal_descriptors.append(descriptor)
elif dist == 'exponential':
check_set(beta)
check_set(descriptor)
self.exponential_betas.append(str(beta))
self.exponential_descriptors.append(descriptor)
elif dist == 'beta':
check_set(beta)
check_set(alpha)
check_set(lower_bounds)
check_set(upper_bounds)
self.beta_betas.append(str(beta))
self.beta_alphas.append(str(alpha))
self.beta_descriptors.append(var)
self.beta_lower_bounds.append(str(lower_bounds))
self.beta_upper_bounds.append(str(upper_bounds))
elif dist == "gamma":
check_set(beta)
check_set(alpha)
self.gamma_alphas.append(str(alpha))
self.gamma_betas.append(str(beta))
self.gamma_descriptors.append(var)
self.weibull_betas.append(str(beta))
self.weibull_descriptors.append(var)
else:
raise ValueError(str(dist) + " is not a defined distribution")
if varlist:
for var in varlist:
self.special_distribution_variables.append(var)
else:
self.special_distribution_variables.append(var)
class DakotaBase(Driver):
"""
Base class for common DAKOTA operations, adds :class:`DakotaInput` instance.
The ``method`` and ``responses`` sections of `input` must be set
directly. :meth:`set_variables` is typically used to set the ``variables``
section.
"""
implements(IHasParameters, IHasObjectives)
output = Enum('normal', iotype='in', desc='Output verbosity',
values=('silent', 'quiet', 'normal', 'verbose', 'debug'))
stdout = Str('', iotype='in', desc='DAKOTA stdout filename')
stderr = Str('', iotype='in', desc='DAKOTA stderr filename')
tabular_graphics_data = \
Bool(iotype='in',
desc="Record evaluations to 'dakota_tabular.dat'")
def __init__(self):
super(DakotaBase, self).__init__()
# Set baseline input, don't touch 'interface'.
self.input = DakotaInput(environment=[],
method=[],
model=['single'],
variables=[],
responses=[])
def check_config(self, strict=False):
""" Verify valid configuration. """
super(DakotaBase, self).check_config(strict=strict)
parameters = self.get_parameters()
if not parameters:
self.raise_exception('No parameters, run aborted', ValueError)
objectives = self.get_objectives()
if not objectives:
self.raise_exception('No objectives, run aborted', ValueError)
def configure_input(self):
""" Configures input specification, must be overridden. """
self.raise_exception('configure_input', NotImplementedError)
def execute(self):
""" Write DAKOTA input and run. """
self.configure_input()
self.run_dakota()
def set_variables(self, need_start, uniform=False, need_bounds=True):
""" Set :class:`DakotaInput` ``variables`` section. """
parameters = self.get_parameters()
if uniform:
self.input.variables = [
'uniform_uncertain = %s' % self.total_parameters()]
else:
self.input.variables = [
'continuous_design = %s' % self.total_parameters()]
if need_start:
initial = [str(val) for val in self.eval_parameters(dtype=None)]
self.input.variables.append(
' initial_point %s' % ' '.join(initial))
if need_bounds:
lbounds = [str(val) for val in self.get_lower_bounds(dtype=None)]
ubounds = [str(val) for val in self.get_upper_bounds(dtype=None)]
self.input.variables.extend([
' lower_bounds %s' % ' '.join(lbounds),
' upper_bounds %s' % ' '.join(ubounds)])
names = []
for param in parameters.values():
for name in param.names:
names.append('%r' % name)
self.input.variables.append(
' descriptors %s' % ' '.join(names)
)
def run_dakota(self):
"""
Call DAKOTA, providing self as data, after enabling or disabling
tabular graphics data in the ``environment`` section.
DAKOTA will then call our :meth:`dakota_callback` during the run.
"""
if not self.input.method:
self.raise_exception('Method not set', ValueError)
if not self.input.variables:
self.raise_exception('Variables not set', ValueError)
if not self.input.responses:
self.raise_exception('Responses not set', ValueError)
for i, line in enumerate(self.input.environment):
if 'tabular_graphics_data' in line:
if not self.tabular_graphics_data:
self.input.environment[i] = \
line.replace('tabular_graphics_data', '')
break
else:
if self.tabular_graphics_data:
self.input.environment.append('tabular_graphics_data')
infile = self.get_pathname() + '.in'
self.input.write_input(infile, data=self)
try:
run_dakota(infile, stdout=self.stdout, stderr=self.stderr)
except Exception:
self.reraise_exception()
def dakota_callback(self, **kwargs):
"""
Return responses from parameters. `kwargs` contains:
========== ==============================================
Key Definition
========== ==============================================
functions number of functions (responses, constraints)
---------- ----------------------------------------------
variables total number of variables
---------- ----------------------------------------------
cv list/array of continuous variable values
---------- ----------------------------------------------
div list/array of discrete integer variable values
---------- ----------------------------------------------
drv list/array of discrete real variable values
---------- ----------------------------------------------
av single list/array of all variable values
---------- ----------------------------------------------
cv_labels continuous variable labels
---------- ----------------------------------------------
div_labels discrete integer variable labels
---------- ----------------------------------------------
drv_labels discrete real variable labels
---------- ----------------------------------------------
av_labels all variable labels
---------- ----------------------------------------------
asv active set vector (bit1=f, bit2=df, bit3=d^2f)
---------- ----------------------------------------------
dvv derivative variables vector
---------- ----------------------------------------------
currEvalId current evaluation ID number
========== ==============================================
"""
cv = kwargs['cv']
asv = kwargs['asv']
self._logger.debug('cv %s', cv)
self._logger.debug('asv %s', asv)
self.set_parameters(cv)
self.run_iteration()
expressions = self.get_objectives().values()
if hasattr(self, 'get_eq_constraints'):
expressions.extend(self.get_eq_constraints().values())
if hasattr(self, 'get_ineq_constraints'):
expressions.extend(self.get_ineq_constraints().values())
fns = []
for i, expr in enumerate(expressions):
if asv[i] & 1:
val = expr.evaluate(self.parent)
if isinstance(val, list):
fns.extend(val)
else:
fns.append(val)
if asv[i] & 2:
self.raise_exception('Gradients not supported yet',
NotImplementedError)
if asv[i] & 4:
self.raise_exception('Hessians not supported yet',
NotImplementedError)
retval = dict(fns=array(fns))
self._logger.debug('returning %s', retval)
return retval
class DakotaBase(Driver):
"""
Base class for common DAKOTA operations, adds :class:`DakotaInput` instance.
The ``method`` and ``responses`` sections of `input` must be set
directly. :meth:`set_variables` is typically used to set the ``variables``
section.
"""
implements(IHasParameters, IHasObjectives)
output = 'normal',
#output = Enum('normal', iotype='in', desc='Output verbosity',
# values=('silent', 'quiet', 'normal', 'verbose', 'debug'))
stdout = ''
stderr = ''
tabular_graphics_data = True
def __init__(self):
super(DakotaBase, self).__init__()
# allow for special variable distributions
self.special_distribution_variables = []
self.clear_special_variables()
self.configured = None
# Set baseline input, don't touch 'interface'.
self.input = DakotaInput(environment=[],
method=[],
model=['single'],
variables=[],
responses=[])
def check_config(self, strict=False):
""" Verify valid configuration. """
super(DakotaBase, self).check_config(strict=strict)
parameters = self.get_parameters()
if not parameters and not self.special_distribution_variables:
self.raise_exception('No parameters, run aborted', ValueError)
objectives = self.get_objectives()
if not objectives:
self.raise_exception('No objectives, run aborted', ValueError)
def run_dakota(self):
"""
Call DAKOTA, providing self as data, after enabling or disabling
tabular graphics data in the ``environment`` section.
DAKOTA will then call our :meth:`dakota_callback` during the run.
"""
parameters = self.get_parameters()
#parameters = self._desvars
if not parameters:
self.raise_exception('No parameters, run aborted', ValueError)
if not self.methods:
raise ValueError('Method not set')
if not self.input.variables:
self.raise_exception('Variables not set', ValueError)
if not self.input.responses:
self.raise_exception('Responses not set', ValueError)
for i, line in enumerate(self.input.environment):
if 'tabular_graphics_data' in line:
if not self.tabular_graphics_data:
self.input.environment[i] = \
line.replace('tabular_graphics_data', '')
break
else:
if self.tabular_graphics_data:
self.input.environment.append('tabular_graphics_data')
infile = self.name+ '.in'
self.input.write_input(infile, data=self)
#self.input.write_input(infile, data=self, other_data=self.other_model)
#from openmdao.core.mpi_wrap import MPI
from mpi4py import MPI
run_dakota(infile, use_mpi=True, mpi_comm = self.mpi_comm, stdout=self.stdout, stderr=self.stderr, restart=0)
#if MPI:
# if self.mpi_comm:
# run_dakota(infile, use_mpi=True, mpi_comm = self.mpi_comm, stdout=self.stdout, stderr=self.stderr, restart=self.dakota_hotstart)
# else:
# run_dakota(infile, use_mpi=True, stdout=self.stdout, stderr=self.stderr, restart=self.dakota_hotstart)
#try:
# run_dakota(infile, stdout=self.stdout, stderr=self.stderr)
#except Exception:
# print sys.exc_info()
# exc_type, exc_value, exc_traceback = sys.exc_info()
# raise type('%s' % exc_type), exc_value, exc_traceback
# self.reraise_exception()
def dakota_callback(self, **kwargs):
"""
Return responses from parameters. `kwargs` contains:
========== ==============================================
Key Definition
========== ==============================================
functions number of functions (responses, constraints)
---------- ----------------------------------------------
variables total number of variables
---------- ----------------------------------------------
cv list/array of continuous variable values
---------- ----------------------------------------------
div list/array of discrete integer variable values
---------- ----------------------------------------------
drv list/array of discrete real variable values
---------- ----------------------------------------------
av single list/array of all variable values
---------- ----------------------------------------------
cv_labels continuous variable labels
---------- ----------------------------------------------
div_labels discrete integer variable labels
---------- ----------------------------------------------
drv_labels discrete real variable labels
---------- ----------------------------------------------
av_labels all variable labels
---------- ----------------------------------------------
asv active set vector (bit1=f, bit2=df, bit3=d^2f)
---------- ----------------------------------------------
dvv derivative variables vector
---------- ----------------------------------------------
currEvalId current evaluation ID number
========== ==============================================
"""
cv = kwargs['cv']
asv = kwargs['asv']
dvv = kwargs['dvv']
av_labels = kwargs['av_labels']
self.set_parameters(cv)
self.run_iteration()
expressions = self.get_objectives().values()
if hasattr(self, 'get_eq_constraints'):
expressions.extend(self.get_eq_constraints().values())
if hasattr(self, 'get_ineq_constraints'):
expressions.extend(self.get_ineq_constraints().values())
fns = []
fnGrads = []
for i, expr in enumerate(expressions):
if asv[i] & 1:
val = expr.evaluate(self.parent)
if isinstance(val, list):
fns.extend(val)
else:
fns.append(val)
if asv[i] & 2:
val = expr.evaluate_gradient(self.parent)
fnGrads.append(val)
# self.raise_exception('Gradients not supported yet',
# NotImplementedError)
if asv[i] & 4:
self.raise_exception('Hessians not supported yet',
NotImplementedError)
retval = dict(fns=array(fns), fnGrads = array(fnGrads))
self._logger.debug('returning %s', retval)
return retval
#print 'av_labs are ',av_labels , ' and cv is ', cv; quit()
#self._logger.debug('cv %s', cv)
#self._logger.debug('asv %s', asv)
#dvlist = [s for s in self.special_distribution_variables if s not in self.array_desvars]
#if True: #self.array_desvars:
# for i, var in enumerate(av_labels):
# if var in self.root.unknowns._dat.keys(): self.set_desvar(var, cv[i])
# elif re.findall("(.*)\[(.*)\]", var)[0][0] in self.root.unknowns._dat.keys():
# #print 'setting ',re.findall("(.*)\[(.*)\]", var)[0][0], int(re.findall("(.*)\[(.*)\]", var)[0][1]), ' as ', cv[i]
# self.set_desvar(re.findall("(.*)\[(.*)\]", var)[0][0], cv[i], index=[int(re.findall("(.*)\[(.*)\]", var)[0][1])])
#else:
# dvl = dvlist + self._desvars.keys() + self.special_distribution_variables
# #dvl = dvlist + self._desvars.keys()
# for i in range(len(cv)):
# if dvl[i] in self.root.unknowns._dat.keys(): self.set_desvar(dvl[i], cv[i])
# #self.set_desvar(dvl[i], cv[i])
# elif re.findall("(.*)\[(.*)\]", dvl[i])[0][0] in self.root.unknowns._dat.keys():
# self.set_desvar(re.findall("(.*)\[(.*)\]", dvl[i])[0][0], cv[i], index=[int(re.findall("(.*)\[(.*)\]", dvl[i])[0][1])])
#system = self.root
#metadata = self.metadata = create_local_meta(None, 'pydakrun%d'%world.Get_rank())
#system.ln_solver.local_meta = metadata
#self.iter_count += 1
#update_local_meta(metadata, (self.iter_count,))
#self.root.solve_nonlinear()
#system.solve_nonlinear(metadata=metadata)
#self.recorders.record_iteration(system, metadata)
#expressions = self.get_objectives().values()[0].tolist()#.update(self.get_constraints())
#cons = self.get_constraints()
#for c in cons:
# #expressions.append(-1*c)
# expressions.append(-1*self.get_constraints()[con])
#expressions = []
#for key in self.get_objectives():
# expressions += list(self.get_objectives()[key])
#for con in self.get_constraints().values():
# for c in con:
# expressions.append(-1*c)
#fns = []
#fnGrads = []
#for i in range(len(asv)):
# val = expressions[i]
# if asv[i] & 1 or asv[i]==0:
# fns.extend([val])
# if asv[i] & 2:
# objs = self.get_objectives().keys()
# gvars = []
# gvars_list = [] # we need to strip the descriptors of the [n] index
# gindexes = {} # then keep only the indexes of interest for each desvar
# seen = set()
# print kwargs['av_labels']
# vars_for_grads = kwargs['av_labels']
# for var in vars_for_grads:
# if var in self.root.unknowns._dat.keys(): gvars.append(var)
# else:
# vname = re.findall("(.*)\[(.*)\]", var)[0][0]
# if vname not in self.root.unknowns._dat.keys():
# raise ValueError("%s not in desvars"%vname)
# if vname not in seen:
# seen.add(vname)
# gvars_list.append(vname)
# ind = int(re.findall("(.*)\[(.*)\]", var)[0][1])
# if vname not in gindexes:
# gindexes[vname] = [ind]
# else: gindexes[vname].append(ind)
#
# # only supporting one objective for now. I'll have to find out more about
# # the ASV structure before continuing.
# for gvar in gvars_list:
# print gvars_list
# print 'gvar ', gvar
# grad = self._prob.calc_gradient([gvar], self.get_objectives().keys())[0]
# for ind in gindexes[gvar]:
# print ' index ', ind
# fnGrads.append(grad[ind])
# for gvar in gvars:
# grad = self._prob.calc_gradient([gvar], self.get_objectives().keys())[0]
# fnGrads.extend(grad)
# fnGrads = np.array([fnGrads])
# #print 'hey. grad is ', grad ; quit()
# #for lab in kwargs['av_labels']:
# #fnGrads.extend([val])
# #fnGrads.append([val])
# # self.raise_exception('Gradients not supported yet',
# # NotImplementedError)
# if asv[i] & 4:
# self.raise_exception('Hessians not supported yet',
# NotImplementedError)
#
# retval = dict(fns=array(fns), fnGrads = array(fnGrads))
# # print 'asv was ',asv
# # print 'returning ',retval
# #self._logger.debug('returning %s', retval)
# return retval
#
# We fully configure the input just before running the analysis as the user is liable to set
# several aspects of the optimization problem after calling pydakdriver.
# We only set the variables and responses blocks here, as the other input blocks are not dependant on
# additional configurations to the analysis.
def configure_input(self):
""" Configures input specification, must be overridden. """
# CONFIGURE VARIABLES
# Find regular parameters
parameters = [] # [ [name, value], ..]
dvars = self.get_parameters()
dvar_values = self.eval_parameters(dtype=None)
self.reg_params = parameters
for n, param in enumerate(dvars):
# if len(dvars[param]) == 1:
parameters.append([param, dvar_values[0]])
# else:
# for i, val in enumerate(dvars[param]):
# parameters.append([param + '[' + str(i) + ']', val])
# self.array_desvars.append(param + '[' + str(i) + ']')
self.input.reg_variables.append('continuous_design = %s' % len(parameters))
secondaryV = False
for i in range(len(self.input.model)):
if 'secondary_variable_mapping' in self.input.model[i]: secondaryV=True
if parameters:
state_params = []
for param in parameters:
if param not in self.special_distribution_variables: state_params.append(param)
if state_params: self.input.state_variables.append('continuous_state = %s' % len(state_params))
initial = [] # initial points of regular paramters
for val in self.eval_parameters():
#for val in self.get_desvars().values():
# if isinstance(val, collections.Iterable):
# initial.extend(val)
# else:
initial.append(val)
self.input.reg_variables.append(
' initial_point %s' % ' '.join(str(s) for s in initial))
if initial: self.input.state_variables.append(
' initial_state %s' % ' '.join(str(s) for s in initial))
lbounds = self.get_lower_bounds(dtype=None)
#lbounds = []
#for val in self.eval_parameters():
#if not isinstance(val.lower, collections.Iterable):
# lbounds.extend(val["lower"] for _ in range(val['size']))
#else:
# lbounds.extend(val.lower())
ubounds = self.get_upper_bounds(dtype=None)
#ubounds = []
#for val in self.eval_parameters():
#for val in self._desvars.values():
#if not isinstance(val["upper"], collections.Iterable):
# ubounds.extend(val["upper"] for _ in range(val['size']))
#else:
# ubounds.extend(val.upper())
self.input.reg_variables.extend([
' lower_bounds %s' % ' '.join(str(bnd) for bnd in lbounds),
' upper_bounds %s' % ' '.join(str(bnd) for bnd in ubounds)])
if lbounds and state_params:
self.input.state_variables.extend([
' lower_bounds %s' % ' '.join(str(bnd) for bnd in lbounds),
' upper_bounds %s' % ' '.join(str(bnd) for bnd in ubounds)])
names = [s[0] for s in parameters]
self.input.reg_variables.append(
' descriptors %s' % ' '.join("'" + str(nam) + "'" for nam in names))
if names and state_params:
self.input.state_variables.append(
' descriptors %s' % ' '.join("'" + str(nam) + "'" for nam in names))
# Add special distributions cases
for var in self.special_distribution_variables:
if var in parameters: self.remove_parameter(var)
if ']' in var:
if int(re.findall("(.*)\[(.*)\]", var)[0][1])==0 and re.findall("(.*)\[(.*)\]", var)[0][0] not in self._desvars.keys():
self.add_parameter(re.findall("(.*)\[(.*)\]", var)[0][0])
else: self.add_parameter(var, low=-99999999., high=99999999.)
if self.normal_descriptors:
# print(self.normal_means) ; quit()
self.input.uncertain_variables.extend([
'normal_uncertain = %s' % len(self.normal_means),
' means %s' % ' '.join(self.normal_means),
' std_deviations %s' % ' '.join(self.normal_std_devs),
" descriptors '%s'" % "' '".join(self.normal_descriptors),
' lower_bounds = %s' % ' '.join(self.normal_lower_bounds),
' upper_bounds = %s' % ' '.join(self.normal_upper_bounds)
])
if self.lognormal_descriptors:
self.input.uncertain_variables.extend([
'lognormal_uncertain = %s' % len(self.lognormal_means),
' means %s' % ' '.join(self.lognormal_means),
' std_deviations %s' % ' '.join(self.lognormal_std_devs),
" descriptors '%s'" % "' '".join(self.lognormal_descriptors)
])
if self.exponential_descriptors:
self.input.uncertain_variables.extend([
'exponential_uncertain = %s' % len(self.exponential_descriptors),
' betas %s' % ' '.join(self.exponential_betas),
" descriptors ' %s'" % "' '".join(self.exponential_descriptors)
])
if self.beta_descriptors:
self.input.uncertain_variables.extend([
'beta_uncertain = %s' % len(self.beta_descriptors),
' betas = %s' % ' '.join(self.beta_betas),
' alphas = %s' % ' '.join(self.beta_alphas),
" descriptors = '%s'" % "' '".join(self.beta_descriptors),
' lower_bounds = %s' % ' '.join(self.beta_lower_bounds),
' upper_bounds = %s' % ' '.join(self.beta_upper_bounds)
])
if self.gamma_descriptors:
self.input.uncertain_variables.extend([
'beta_uncertain = %s' % len(self.gamma_descriptors),
' betas = %s' % ' '.join(self.gamma_betas),
' alphas = %s' % ' '.join(self.gamma_alphas),
" descriptors = '%s'" % "' '".join(self.gamma_descriptors)
])
if self.weibull_descriptors:
self.input.uncertain_variables.extend([
'weibull_uncertain = %s' % len(self.weibull_descriptors),
' betas %s' % ' '.join(self.weibull_betas),
' alphas %s' % ' '.join(self.weibull_alphas),
" descriptors '%s'" % "' '".join(self.weibull_descriptors)
])
# CONFIGURE VARIABLES, METHOD, MODEL
for i in range(len(self.input.responses)):
if i !=0: self.input.variables.append('\nvariables\n')
self.input.variables.append("id_variables = 'vars%d'"%(i+1))
if 'variable_options' in self.input.responses[i]:
self.input.variables.append(self.input.responses[i]['variable_options'])
del self.input.responses[i]['variable_options']
if 'var_types' not in self.input.responses[i]:
if 'objective_functions' in self.input.responses[i]:
self.input.variables.append("\n".join(self.input.reg_variables))
elif 'response_functions' in self.input.responses[i]:
self.input.variables.append("\n".join(self.input.uncertain_variables + self.input.state_variables))
else: raise ValueError("could not find response or objective in repsonse block %d %s")%(i, '\n'.join(self.input.responses[i]))
else:
for vartype in self.input.responses[i]['var_types']:
if vartype=='uncertain':
self.input.variables.append("\n".join(self.input.uncertain_variables))
elif vartype=='design':
self.input.variables.append("\n".join(self.input.reg_variables))
elif vartype=='state':
self.input.variables.append("\n".join(self.input.state_variables))
elif vartype=='custom':
if self.custom_variables_blocks[i]: self.input.variables.append("\n".join(self.custom_variables_blocks[i]))
else: raise ValueError("variable_block not specified but custom variables requested")
else: raise ValueError("%s variable type is not supported"%vartype)
del self.input.responses[i]['var_types']
objectives = self.get_objectives()
temp_list = []
for i in range(len(self.input.method)):
for key in self.input.method[i]:
temp_list.append("%s %s"%(key, self.input.method[i][key]))
self.methods = temp_list
self.input.method = temp_list
self.input.environment.append("method_pointer 'meth1'")
# Deal with variable mapping
#cons = []
#for con in self.get_constraints():
# for c in self.get_constraints()[con]:
# cons.append(-1 * c)
cons = []
secondary_responses = [[0] + [0 for _ in range(len(cons))] for __ in range(len(cons))]
j = 0
for i in range(len(cons)):
secondary_responses[i][j + 1] = 1
j += 1
notnormps = [p[0] for p in parameters]
for x in self.reg_params:
if x[0] in notnormps: notnormps.remove(x[0])
names = [s[0] for s in parameters]
conlist = []
#for c in self.get_constraints():
# conlist.extend(self.get_constraints()[c])
temp_list = []
vm = None
for i in range(len(self.input.model)):
for key in self.input.model[i]:
temp_list.append("%s %s"%(key, self.input.model[i][key]))
if key == 'nested':
vect = [0] *( self.input.n_objectives[i] + len(cons))
maps = []
for j in range(self.input.n_objectives[i]):
s = vect
s[j] = 1
maps.append(s)
if "primary_response_mapping" not in self.input.model[i]:
vm = "primary_response_mapping "+\
"\n".join(" ".join(" ".join([str(a), str(a)]) for a in s) for s in maps)
else: vm = " "
if vm:
temp_list.append(vm)
if "primary_variable_mapping" not in self.input.model[i]: temp_list.append("primary_variable_mapping %s"%" ".join("'" + str(nam) + "'" for nam in names))
if cons:
if "secondary_response_mapping" not in self.input.model[i]:
temp_list.append("secondary_response_mapping \n%s" % " \n".join( " ".join( " ".join([str(s), str(s)]) for s in secondary_responses[i]) for i in range(len(cons))))
if "secondary_variable_mapping" in self.input.model[i] and self.input.model[i]["secondary_variable_mapping"]=="":
del self.input.model[i]["secondary_variable_mapping"]
temp_list.append("secondary_variable_mapping %s"%" ".join("'mean'" if nam in self.special_distribution_variables else "''" for nam in names))
vm = 0
self.input.model = temp_list
temp_list = []
for i in range(len(self.input.responses)):
if 'objective_functions' in self.input.responses[i]:
self.input.responses[i]['nonlinear_inequality_constraints'] = len(cons)
if 'response_functions' in self.input.responses[i]:
self.input.responses[i]["response_functions"] = self.input.n_objectives[i] + len(cons)
for key in self.input.responses[i]:
#temp_list.append(key)
if self.input.responses[i][key] or self.input.responses[i][key]==0:
temp_list.append(str(key) + ' '+str(self.input.responses[i][key]))
else: temp_list.append(key)
self.input.responses = temp_list
self.configured = 1
# This is the entry point to initialize the analysis run
def execute(self):
""" Write DAKOTA input and run. """
self.configure_input()
#self._prob = problem
#if not self.configured: self.configure_input(problem) # this limits configuration to one time
self.run_dakota()
# --------------------------- special distribution magic ---------------------- #
def clear_special_variables(self):
for var in self.special_distribution_variables:
try: self.remove_parameter(var)
except AttributeError:
pass
self.special_distribution_variables = []
self.normal_means = []
self.special_distribution_variables = []
self.normal_means = []
self.normal_std_devs = []
self.normal_descriptors = []
self.normal_lower_bounds = []
self.normal_upper_bounds = []
self.lognormal_means= []
self.lognormal_std_devs = []
self.lognormal_descriptors = []
self.exponential_betas = []
self.exponential_descriptors = []
self.beta_betas = []
self.beta_alphas = []
self.beta_descriptors = []
self.beta_lower_bounds = []
self.beta_upper_bounds = []
self.gamma_alphas = []
self.gamma_betas = []
self.gamma_descriptors = []
self.weibull_alphas = []
self.weibull_betas = []
self.weibull_descriptors = []
# adds a probability variable. This concept is unique to pydakdriver.
def add_special_distribution(self, var, dist, alpha = _SET_AT_RUNTIME, beta = _SET_AT_RUNTIME,
mean = _SET_AT_RUNTIME, std_dev = _SET_AT_RUNTIME,
lower_bounds = _SET_AT_RUNTIME, upper_bounds = _SET_AT_RUNTIME ):
def check_set(option):
if option == _SET_AT_RUNTIME: raise ValueError("INCOMPLETE DEFINITION FOR VARIABLE "+str(var))
varlist = [] # handles array entries
if dist == 'normal':
check_set(std_dev)
check_set(mean)
# check_set(lower_bounds)
# check_set(upper_bounds)
# self.normal_lower_bounds.append(str(lower_bounds))
# self.normal_upper_bounds.append(str(upper_bounds))
if True:#str(type(mean)) in ['int', 'str']:
self.normal_means.append(str(mean))
self.normal_std_devs.append(str(std_dev))
self.normal_descriptors.append(var)
self.normal_lower_bounds.append(str(lower_bounds))
self.normal_upper_bounds.append(str(upper_bounds))
else:
self.normal_means.extend(str(m) for m in mean)
self.normal_std_devs.extend(str(s) for s in std_dev)
for i in range(len(mean)):
self.normal_descriptors.append(var+"[%d]"%i)
varlist.append(var+"[%d]"%i)
self.normal_lower_bounds.extend(str(l) for l in lower_bounds)
self.normal_upper_bounds.extend(str(u) for u in upper_bounds)
elif dist == 'lognormal':
check_set(std_dev)
check_set(mean)
self.lognormal_means.append(str(mean))
self.lognormal_std_devs.append(str(std_dev))
self.lognormal_descriptors.append(descriptor)
elif dist == 'exponential':
check_set(beta)
check_set(descriptor)
self.exponential_betas.append(str(beta))
self.exponential_descriptors.append(descriptor)
elif dist == 'beta':
check_set(beta)
check_set(alpha)
check_set(lower_bounds)
check_set(upper_bounds)
self.beta_betas.append(str(beta))
self.beta_alphas.append(str(alpha))
self.beta_descriptors.append(var)
self.beta_lower_bounds.append(str(lower_bounds))
self.beta_upper_bounds.append(str(upper_bounds))
elif dist == "gamma":
check_set(beta)
check_set(alpha)
self.gamma_alphas.append(str(alpha))
self.gamma_betas.append(str(beta))
self.gamma_descriptors.append(var)
self.weibull_betas.append(str(beta))
self.weibull_descriptors.append(var)
else:
raise ValueError(str(dist)+" is not a defined distribution")
if varlist:
for var in varlist:
self.special_distribution_variables.append(var)
else:
self.special_distribution_variables.append(var)