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 _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 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 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 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 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 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 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 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)))
def variables(self):
vp = DSExpressionVariablesInExpression(self._swigwrapper)
pv = VariablePool()
pv.set_swigwrapper(vp)
return pv.keys()
def valid_parameter_and_state(self):
variablepool = DSCaseValidParameterAndStateSet(self._swigwrapper)
pstate = VariablePool()
pstate.set_swigwrapper(variablepool)
return pstate
def consistent_parameter_and_state(self):
variablepool = DSCaseConsistentParameterAndStateSet(self._swigwrapper)
pstate = VariablePool()
pstate.set_swigwrapper(variablepool)
return pstate
