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