def __init__(self, data, kmodel=None, index=None):
self.kmodel = kmodel
if type(data) == list:
# Todo check for indexable
self._data = [ParameterValues(d, kmodel=kmodel) for d in data]
if index is None:
self._index = TabDict((str(i), i) for i, _ in enumerate(data))
else:
self._index = TabDict((k, i) for i, k in enumerate(index))
elif type(data) == pd.DataFrame:
raise NotImplemented(
"Type {} is not supported yet in progress".format(type(data)))
elif type(data) == ParameterValues:
# Todo check for indexable
self._data = [d for d in data]
if index is None:
self._index = TabDict((str(i), i) for i, _ in enumerate(data))
else:
self._index = TabDict((k, i) for i, k in enumerate(index))
else:
raise TypeError("Type {} is not supported".format(type(data)))
def test_oracle_ode():
# Initialize parameter sampler
sampling_parameters = SimpleParameterSampler.Parameters(n_samples=1)
sampler = SimpleParameterSampler(sampling_parameters)
# Sample the model
parameter_population = sampler.sample(kmodel, flux_dict,
concentration_dict)
kmodel.compile_ode(sim_type=QSSA)
kmodel.initial_conditions = TabDict([
(k, v) for k, v in concentration_dict.items()
])
solutions = []
for parameters in parameter_population:
kmodel.parameters = parameters
this_sol_qssa = kmodel.solve_ode(np.linspace(0.0, 10.0, 1000),
solver_type='cvode')
solutions.append(this_sol_qssa)
this_sol_qssa.plot('test.html')
solpop = ODESolutionPopulation(solutions)
def __init__(self, parameter_values, kmodel=None):
"""
:param kmodel: KineticModel class
:param parameter_values: a dict contaning parameter names and values
"""
if parameter_values.__class__ is Series:
parameter_values = parameter_values.to_dict()
self._parameter_values = TabDict([
(str(p), v) for p, v in parameter_values.items()
])
# Check if this is a good solution
if kmodel is not None:
model_params = kmodel.parameters
self._str_to_sym = {
p: model_params[p].symbol
for p in model_params
}
else:
self._str_to_sym = {p: Symbol(p) for p in parameter_values}
self._sym_to_str = {
self._str_to_sym[p]: p
for p in self._parameter_values
}
def parameters(self):
parameters = TabDict((k, r)
for k, r in self.mechanism.parameters.items()
if r.type == PARAMETER)
parameters.update(
TabDict((k, r) for k, r in self.mechanism.reactants.items()
if r.type == PARAMETER))
for this_modifier in self.modifiers.values():
this_params = TabDict((k, r)
for k, r in this_modifier.parameters.items()
if r.type == PARAMETER)
this_params.update(
TabDict((k, r) for k, r in this_modifier.reactants.items()
if r.type == PARAMETER))
parameters.update(this_params)
return parameters
def reactants(self):
reactants = TabDict((k, r)
for k, r in self.mechanism.reactants.items()
if r.type == VARIABLE)
for this_modifier in self.modifiers.values():
this_reactants = TabDict(
("{}_{}".format(k, r.name), r)
for k, r in this_modifier.reactants.items()
if r.type == VARIABLE)
reactants.update(this_reactants)
if not self.mechanism.inhibitors is None:
regulators = TabDict((k, r)
for k, r in self.mechanism.inhibitors.items()
if r.type == VARIABLE)
reactants.update(regulators)
return reactants
def test_compile_mca():
"""
Compile the model
"""
kmodel.prepare(mca=True)
parameter_list = TabDict([(k, p.symbol)
for k, p in kmodel.parameters.items()
if p.name.startswith('vmax_forward')])
kmodel.compile_mca(sim_type=QSSA, parameter_list=parameter_list)
def get_all_reactants(model):
reactants = TabDict([])
for this_reaction in model.reactions.values():
this_rectants = TabDict([
(v.name, v) for v in this_reaction.mechanism.reactants.values()
])
for this_modifier in this_reaction.modifiers.values():
this_reactants = TabDict(
(r.name, r) for k, r in this_modifier.reactants.items())
reactants.update(this_reactants)
reactants.update(this_rectants)
reactants = deepcopy(reactants)
for r in reactants.values():
r.type = VARIABLE
return reactants
def prepare_mca(kinetic_model, **kwargs):
# Better since this is implemented now
all_variables = TabDict([(k,v.symbol) for k,v in kinetic_model.reactants.items()])
#Get depedent variables (i.e. concentrations)
reduced_stoichiometry, dependent_weights, independent_ix, dependent_ix = \
get_reduced_stoichiometry(kinetic_model, all_variables)
return reduced_stoichiometry,\
dependent_weights,\
independent_ix,\
dependent_ix
def reactant_stoichiometry(self):
reactant_stoichiometry = TabDict([])
for k, v in self.mechanism.reactant_stoichiometry.items():
if self.mechanism.reactants[k].type == VARIABLE:
this_reactant = self.mechanism.reactants[k]
if this_reactant in reactant_stoichiometry.keys():
reactant_stoichiometry[this_reactant] += v
else:
reactant_stoichiometry[this_reactant] = v
for this_modifier in self.modifiers.values():
for k, v in this_modifier.reactants.items():
if v.type == VARIABLE and this_modifier.reactant_stoichiometry[
k] != 0:
reactant_stoichiometry[
v] = this_modifier.reactant_stoichiometry[k]
return reactant_stoichiometry
def __init__(self,
name,
reactants,
mechanism,
parameters=None,
inhibitors=None,
enzyme=None):
self.name = name
self.enzyme = enzyme
if inhibitors is not None:
self.mechanism = mechanism(name=name,
reactants=reactants,
parameters=parameters,
inhibitors=inhibitors,
enzyme=enzyme)
else:
self.mechanism = mechanism(name=name,
reactants=reactants,
parameters=parameters,
enzyme=enzyme)
self.modifiers = TabDict([])
concentrations = load_concentrations(
solution.raw, tmodel, kmodel, concentration_scaling=CONCENTRATION_SCALING)
# Fetch equilibrium constants
load_equilibrium_constants(solution.raw,
tmodel,
kmodel,
concentration_scaling=CONCENTRATION_SCALING,
in_place=True)
"""
Sample the kinetic parameters based on linear stability
"""
kmodel.prepare(mca=True)
# Compile MCA functions
parameter_list = TabDict([(k, p.symbol) for k, p in kmodel.parameters.items()
if p.name.startswith('vmax_forward')])
kmodel.compile_mca(sim_type=QSSA, parameter_list=parameter_list)
# Define a function that calculates model output (flux control coefficients)
# from sampled model parameters
# Choose a subset of Vmax's to analyse
outputs_to_analyse = ['vmax_forward_ENO', 'vmax_forward_PGK']
def calculate_model_output(model_parameters):
# calculate all flux control coefficients
flux_control_coeff_0 = kmodel.flux_control_fun(fluxes, concentrations,
model_parameters._data)
this_skimpy_model.prepare(mca=True)
# Compile MCA functions
this_skimpy_model.compile_mca(sim_type=QSSA)
# Initialize parameter sampler
sampling_parameters = SimpleParameterSampler.Parameters(n_samples=5)
sampler = SimpleParameterSampler(sampling_parameters)
# Sample the model
parameter_population = sampler.sample(this_skimpy_model, flux_dict,
concentration_dict)
"""
Calculate control coefficients
"""
parameter_list = TabDict([(k, p.symbol)
for k, p in this_skimpy_model.parameters.items()
if p.name.startswith('vmax_forward')])
this_skimpy_model.compile_mca(sim_type=QSSA, parameter_list=parameter_list)
flux_control_coeff = this_skimpy_model.flux_control_fun(
flux_dict, concentration_dict, parameter_population)
"""
Integrate the ODEs
"""
this_skimpy_model.compile_ode(sim_type=QSSA)
this_skimpy_model.initial_conditions = TabDict([
(k, v) for k, v in concentration_dict.items()
])