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)))