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 __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 }
class ParameterValues(object): """ Parameters set for kinetic models wich can be indexed with symbols or """ 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 } #self._str_to_param = {p:model_params[p] for p in self._parameter_values} def __getitem__(self, item): if item.__class__ is str: return self._parameter_values[item] if item.__class__ is Symbol: return self._parameter_values[self._sym_to_str[item]] def __setitem__(self, item, value): if item.__class__ is str: self._parameter_values[item] = value if item.__class__ is Symbol: self._parameter_values[self._sym_to_str[item]] = value def items(self): return self._parameter_values.items() def keys(self): return self._parameter_values.keys() def values(self): return self._parameter_values.values()
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 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 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 __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([])
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 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 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
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)
class Reaction(object): """ Global reaction class """ 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([]) # Hooks to the mechanism attributes for convenience @property 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 @reactants.setter def reactants(self, value): self.mechanism.reactants = value @property 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 @property 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 @parameters.setter def parameters(self, value): for name, p in value.items(): p.suffix = self.name self.mechanism.parameters = value @property def rates(self): return self.mechanism.rates @rates.setter def rates(self, value): self.mechanism.rates = value def __str__(self): return "%s of with %s kinetics " % (self.name, self.mechanism) def parametrize(self, params): self.parameters = params
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
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() ])