def vertices_ND_slice(self, p_bounds=None, log_out=False):
keys = []
free_variables = []
lower = VariablePool(names=self.independent_variables)
upper = VariablePool(names=self.independent_variables)
if p_bounds is None:
p_bounds = {}
for key in lower:
if key in p_bounds:
try:
lower[key] = min(p_bounds[key])
except:
lower[key] = p_bounds[key]
try:
upper[key] = max(p_bounds[key])
except:
upper[key] = p_bounds[key]
else:
lower[key]=1e-20
upper[key]=1e20
if lower[key] != upper[key]:
keys.append(key)
free_variables.append(lower.keys().index(key))
vertices_data=DSCaseVerticesForNDSlice(self._swigwrapper,
lower._swigwrapper,
upper._swigwrapper)
vertices_raw = DSMatrixArrayMatrix(vertices_data, 0)
vertices=[]
for v in vertices_raw:
vertices.append([v[i] for i in xrange(len(v)) if i in free_variables])
connectivity = DSMatrixArrayMatrix(vertices_data, 1)
return keys, vertices, connectivity
def bounding_box(self, p_bounds=None, log_out=False):
lower = VariablePool(names=self.independent_variables)
upper = VariablePool(names=self.independent_variables)
boundkeys = lower.keys()
for key in lower:
lower[key] = 1e-20
upper[key] = 1e20
if p_bounds is not None:
for key,value in p_bounds.iteritems():
if key not in lower:
continue;
try:
min_value,max_value = value
except TypeError:
min_value = value
max_value = value
boundkeys.remove(key)
if min_value > max_value:
raise ValueError, 'Min cannot be larger than max'
lower[key] = min_value
upper[key] = max_value
box = {}
for key in boundkeys:
box[key] = DSCaseBoundingRangeForVariableWithConstraints(self._swigwrapper,
key,
lower._swigwrapper,
upper._swigwrapper)
if log_out is False:
box[key] = [10**i[0] for i in box[key]]
else:
box[key] = [i[0] for i in box[key]]
return box
def _parse_equations(self, Xi=None, match_Xi=None, **kwargs):
auxiliary_variables = self.auxiliary_variables
if Xi is not None:
Xi = [i for i in Xi]
elif match_Xi is not None:
Xi = match_Xi.independent_variables
if Xi is None:
swigwrapper = DSSWIGDesignSpaceParseWrapper(
self.equations.system, len(self.equations), auxiliary_variables, len(auxiliary_variables)
)
else:
swigwrapper = DSSWIGDesignSpaceParseWrapperWithXi(
self.equations.system, len(self.equations), auxiliary_variables, len(auxiliary_variables), Xi, len(Xi)
)
self.set_swigwrapper(swigwrapper)
gma = DSDesignSpaceGMASystem(self._swigwrapper)
eqs = DSGMASystemEquations(gma)
equation_list = list()
for i in xrange(0, DSGMASystemNumberOfEquations(gma)):
expr = DSExpressionAtIndexOfExpressionArray(eqs, i)
equation_list.append(DSExpressionAsString(expr))
DSExpressionFree(expr)
DSSecureFree(eqs)
Xda = VariablePool()
Xda.set_swigwrapper(DSVariablePoolCopy(DSGMASystemXd_a(gma)))
equations = Equations(equation_list, auxiliary_variables=Xda.keys(), latex_symbols=self._latex)
self._equations = equations
def _valid_parameter_set_bounded(self, p_bounds, optimize=None, minimize=True):
lower = VariablePool(names=self.independent_variables)
upper = VariablePool(names=self.independent_variables)
for i in lower:
lower[i] = 1e-20
upper[i] = 1e20
if i not in p_bounds:
continue
k = p_bounds[i]
try:
lower[i] = min(k)
upper[i] = max(k)
except:
lower[i] = k
upper[i] = k
if optimize is not None:
variablepool = DSCaseValidParameterSetAtSliceByOptimizingFunction(self._swigwrapper,
lower._swigwrapper,
upper._swigwrapper,
optimize,
minimize)
else:
variablepool = DSCaseValidParameterSetAtSlice(self._swigwrapper,
lower._swigwrapper,
upper._swigwrapper)
pvals = VariablePool()
pvals.set_swigwrapper(variablepool)
return pvals
def update_latex_symbols(self, symbols):
self._latex.update(symbols)
equation_list = list()
for i in xrange(0, DSGMASystemNumberOfEquations(self._swigwrapper)):
expr = DSExpressionAtIndexOfExpressionArray(eqs, i)
equation_list.append(DSExpressionAsString(expr))
DSExpressionFree(expr)
DSSecureFree(eqs)
Xda = VariablePool()
Xda.set_swigwrapper(DSVariablePoolCopy(DSGMASystemXd_a(gma)))
equations = Equations(equation_list,
auxiliary_variables=Xda.keys(),
latex_symbols=self._latex)
self._equations = equations
def steady_state(self, parameter_values, log_out=False):
Xd = VariablePool(names=self.dependent_variables)
p_vals = VariablePool(names=self.independent_variables)
for i in p_vals:
p_vals[i] = parameter_values[i]
cases = self.valid_subcases(p_bounds=p_vals)
steady_states = dict()
for i in cases:
case = self(i)
ssys = case.ssystem
ss = DSSSystemSteadyStateValues(ssys._swigwrapper, parameter_values._swigwrapper)
var_names = Xd.keys()
if log_out is False:
steady_states[str(i)] = {var_names[j]:10**ss[j][0] for j in xrange(len(var_names))}
else:
steady_states[str(i)] = {var_names[j]:ss[j][0] for j in xrange(len(var_names))}
return steady_states
def steady_state_flux(self, parameter_values, log_out=False):
steady_states = self.steady_state(parameter_values)
Xd = VariablePool(names=self.dependent_variables)
fluxes = dict()
case_swigwrapper = DSCyclicalCaseOriginalCase(self._swigwrapper)
for i in steady_states:
Xd.update(steady_states[i])
flux = DSSSystemSteadyStateFluxForDependentVariables(DSCaseSSystem(case_swigwrapper),
Xd._swigwrapper,
parameter_values._swigwrapper)
var_names = Xd.keys()
if log_out is False:
flux = {('V_' + var_names[j]):10**flux[j][0] for j in xrange(len(var_names))}
else:
flux = {('V_' + var_names[j]):flux[j][0] for j in xrange(len(var_names))}
fluxes[i] = flux
return fluxes
def set_swigwrapper(self, gma_swigwrapper):
self._swigwrapper = gma_swigwrapper
Xd = VariablePool()
Xd.set_swigwrapper(DSGMASystemXd(gma_swigwrapper))
for i in VariablePool():
if i not in self.dependent_variables:
raise NameError, 'Dependent Variables are inconsistent'
Xi = VariablePool()
Xi.set_swigwrapper(DSVariablePoolCopy(DSGMASystemXi(gma_swigwrapper)))
self._dependent_variables = Xd.copy()
self._independent_variables = Xi
Xd.set_swigwrapper(None)
def steady_state_function(self, function, parameter_values):
if isinstance(function, Expression):
expr = function
else:
expr = Expression(function)
p_values = VariablePool(names=self.independent_variables)
for key in p_values:
p_values[key] = parameter_values[key]
ss = self.steady_state(p_values, log_out=False)
flux = self.steady_state_flux(p_values, log_out=False)
values = dict()
for subcase in ss:
p_values.update(ss[subcase])
p_values.update(flux[subcase])
value = expr.eval_with_values(p_vals=p_values)
values[subcase] = value
return values
def valid_parameter_set(self, p_bounds=None, optimize=None, minimize=True, strict=True):
if p_bounds is not None:
pvals = self._valid_parameter_set_bounded(p_bounds,
optimize=optimize,
minimize=minimize)
return pvals
if optimize is not None:
variablepool = DSCaseValidParameterSetByOptimizingFunction(self._swigwrapper,
optimize,
minimize)
else:
variablepool = DSCaseValidParameterSet(self._swigwrapper)
pvals = VariablePool()
pvals.set_swigwrapper(variablepool)
for i in pvals:
if pvals[i] == 0.0 or pvals[i] == float('inf'):
return self._valid_parameter_set_bounded({i:[1e-20, 1e20] for i in self.independent_variables},
optimize=optimize,
minimize=minimize)
return pvals
def _parse_equations(self, **kwargs):
auxiliary_variables = self.auxiliary_variables
swigwrapper = DSSWIGGMASystemParseWrapper(self.equations.system,
len(self.equations),
auxiliary_variables,
len(auxiliary_variables)
)
self.set_swigwrapper(swigwrapper)
eqs = DSGMASystemEquations(self._swigwrapper)
equation_list = list()
for i in xrange(0, DSGMASystemNumberOfEquations(self._swigwrapper)):
expr = DSExpressionAtIndexOfExpressionArray(eqs, i)
equation_list.append(DSExpressionAsString(expr))
DSExpressionFree(expr)
DSSecureFree(eqs)
Xda = VariablePool()
Xda.set_swigwrapper(DSVariablePoolCopy(DSGMASystemXd_a(gma)))
equations = Equations(equation_list,
auxiliary_variables=Xda.keys(),
latex_symbols=self._latex)
self._equations = equations
def _is_valid_point_in_statespace(self, v_bounds, p_bounds):
Xd_t = VariablePool()
independent = VariablePool(names=self.independent_variables)
ssys = self.ssystem
for key in independent:
value = float(p_bounds[key])
independent[key] = value
for key in self.dependent_variables:
if key in ssys.auxiliary_variables:
continue
value = float(v_bounds[key])
Xd_t[key] = value
dependent = VariablePool(names=self.dependent_variables)
dependent.update(v_bounds)
if len(ssys.auxiliary_variables) > 0:
aux = ssys.value_for_auxiliary_variables(Xd_t, independent)
dependent.update(aux)
return DSCaseIsValidInStateSpaceAtPoint(self._swigwrapper,
dependent._swigwrapper,
independent._swigwrapper)
def set_swigwrapper(self, ssys_swigwrapper):
self._swigwrapper = ssys_swigwrapper
if self._swigwrapper is None:
return
Xd = VariablePool()
Xd.set_swigwrapper(DSVariablePoolCopy(DSSSystemXd(ssys_swigwrapper)))
Xi = VariablePool()
Xi.set_swigwrapper(DSVariablePoolCopy(DSSSystemXi(ssys_swigwrapper)))
self._independent_variables = Xi
self._dependent_variables = Xd
def set_swigwrapper(self, case_swigwrapper):
self._swigwrapper = case_swigwrapper
Xd = VariablePool()
Xd.set_swigwrapper(DSVariablePoolCopy(DSCaseXd(case_swigwrapper)))
for i in VariablePool():
if i not in self.dependent_variables:
raise NameError, 'Dependent Variables are inconsistent'
Xi = VariablePool()
Xi.set_swigwrapper(DSVariablePoolCopy(DSCaseXi(case_swigwrapper)))
self._independent_variables = Xi
def steady_state_flux(self, parameter_values, log_out=False):
Xd = VariablePool()
Xd.set_swigwrapper(DSSSystemXd(self._swigwrapper))
flux = DSSSystemSteadyStateFlux(self._swigwrapper, parameter_values._swigwrapper)
var_names = Xd.keys()
if log_out is False:
steady_states = {("V_" + var_names[i]): 10 ** flux[i][0] for i in xrange(len(var_names))}
else:
steady_states = {("V_" + var_names[i]): flux[i][0] for i in xrange(len(var_names))}
Xd.set_swigwrapper(None)
return steady_states
def steady_state(self, parameter_values, log_out=False):
if DSSSystemHasSolution(self._swigwrapper) is False:
return None
Xd = VariablePool()
Xd.set_swigwrapper(DSSSystemXd(self._swigwrapper))
steady_states = DSSSystemSteadyStateValues(self._swigwrapper, parameter_values._swigwrapper)
var_names = Xd.keys()
if log_out is False:
steady_states = {var_names[i]: 10 ** steady_states[i][0] for i in xrange(len(var_names))}
else:
steady_states = {var_names[i]: steady_states[i][0] for i in xrange(len(var_names))}
Xd.set_swigwrapper(None)
return steady_states
def set_swigwrapper(self, case_swigwrapper):
self._swigwrapper = case_swigwrapper
Xd = VariablePool()
Xd.set_swigwrapper(DSVariablePoolCopy(DSSSystemXd(DSCaseSSystem(case_swigwrapper))))
for i in VariablePool():
if i not in self.dependent_variables:
raise NameError, 'Dependent Variables are inconsistent'
self._dependent_variables = Xd
Xi = VariablePool()
Xi.set_swigwrapper(DSVariablePoolCopy(DSSSystemXi(DSCaseSSystem(case_swigwrapper))))
self._independent_variables = Xi
eqs = list()
eqs_expr = DSSSystemEquations(DSCaseSSystem(case_swigwrapper))
for i in xrange(0, len(super(Case, self).equations)):
eqs.append(DSExpressionAsString(DSExpressionAtIndexOfExpressionArray(eqs_expr, i)))
DSExpressionFree(DSExpressionAtIndexOfExpressionArray(eqs_expr, i))
DSSecureFree(eqs_expr)
self._ssystem = SSystem(self._equations,
name=self.name,
swigwrapper=DSCaseSSystem(case_swigwrapper),
latex_symbols=self._latex)
def consistent_parameter_and_state(self):
variablepool = DSCaseConsistentParameterAndStateSet(self._swigwrapper)
pstate = VariablePool()
pstate.set_swigwrapper(variablepool)
return pstate
def set_swigwrapper(self, ds_swigwrapper):
self._swigwrapper = ds_swigwrapper
Xd = VariablePool()
Xd.set_swigwrapper(DSGMASystemXd(DSDesignSpaceGMASystem(ds_swigwrapper)))
## for i in VariablePool():
## if i not in self.dependent_variables:
## raise NameError, 'Dependent Variables are inconsistent'
self._dependent_variables = Xd.copy()
Xd.set_swigwrapper(None)
Xi = VariablePool()
Xi.set_swigwrapper(DSDesignSpaceXi(ds_swigwrapper))
self._independent_variables = Xi.copy()
Xi.set_swigwrapper(None)
def valid_parameter_and_state(self):
variablepool = DSCaseValidParameterAndStateSet(self._swigwrapper)
pstate = VariablePool()
pstate.set_swigwrapper(variablepool)
return pstate
def variables(self):
vp = DSExpressionVariablesInExpression(self._swigwrapper)
pv = VariablePool()
pv.set_swigwrapper(vp)
return pv.keys()
def set_swigwrapper(self, swigwrapper):
self._swigwrapper = swigwrapper
## ds_swigwrapper = DSCyclicalCaseInternalDesignSpace(swigwrapper)
Xd = VariablePool()
Xd.set_swigwrapper(DSCyclicalCaseXd(swigwrapper))
for i in VariablePool():
if i not in self.dependent_variables:
raise NameError, 'Dependent Variables are inconsistent'
Xi = VariablePool()
Xi.set_swigwrapper(DSCyclicalCaseXi(swigwrapper))
self._independent_variables = Xi.copy()
self._dependent_variables = Xd.copy()
Xd.set_swigwrapper(None)
Xi.set_swigwrapper(None)
eqs = list()
eqs_expr = DSSSystemEquations(DSCyclicalCaseSSystem(self._swigwrapper))
for i in xrange(0, DSCyclicalCaseNumberOfEquations(self._swigwrapper)):
eqs.append(DSExpressionAsString(DSExpressionAtIndexOfExpressionArray(eqs_expr, i)))
DSExpressionFree(DSExpressionAtIndexOfExpressionArray(eqs_expr, i))
DSSecureFree(eqs_expr)
self._ssystem = SSystem(self._equations,
name=self.name,
swigwrapper=DSSSystemCopy(DSCyclicalCaseSSystem(swigwrapper)))
