Esempio n. 1
0
def run_detfl(yaml_file, uptake_funs, medium_funs=dict(), model=None, ini_sol=None):    # pass in

    params = read_config(yaml_file)

    for key, value in params.items():
        print('%s: %s' % (key, value))

    if model is None:
        model = load_json_model(params['model'])


    standard_solver_config(model)
    model.solver.configuration.verbosity = params['options']['verbose']

    time_data = run_dynamic_etfl(model,
                                 timestep=params['simulation']['timestep'],
                                 tfinal=params['simulation']['tfinal'],
                                 uptake_fun=uptake_funs,
                                 medium_fun=medium_funs,
                                 uptake_enz=params['assumptions']['uptake_enz'],
                                 S0=params['assumptions']['S0'],
                                 X0=params['assumptions']['X0'],
                                 inplace=params['options']['inplace'],
                                 initial_solution = ini_sol,
                                 chebyshev_include = params['options']['chebyshev_include'],
                                 dynamic_constraints = params['options']['constraints']
                                 )

    # plot_dynamics(model, time_data)
    out_path = join('outputs',params['tag']+get_timestr())
    makedirs(out_path)
    time_data.to_csv(join(out_path,'solution.csv'))
    write_yaml(params,join(out_path,'config.yaml'))

    return time_data
Esempio n. 2
0
    times = [x*timestep for x in range(1,10)]


    print("Test step fun:")
    print(times)
    for rxn, fun in glyc_glc_switch.items():
        values = [S0_glc]
        _ = [values.append(fun(t,values[-1])) for t in times]
        print(rxn, values)

    standard_solver_config(model)
    min_glycolysis_enz = prepare_model(model, S0_glyc=S0_gly, S0_glc=S0_glc)

    time_data = run_dynamic_etfl(model,
                                 timestep=timestep,
                                 tfinal=2.5,
                                 uptake_fun=get_uptake_funs(),
                                 medium_fun = glyc_glc_switch,
                                 S0={'EX_glyc_e':S0_gly, 'EX_glc__D_e':S0_glc},
                                 X0=X0,
                                 inplace=True,
                                 initial_solution = min_glycolysis_enz,
                                 chebyshev_include = [ForwardCatalyticConstraint,
                                                      BackwardCatalyticConstraint,
                                                      ExpressionCoupling]
                                 )

    plot_dynamics(model, time_data)
    time_data.to_csv('outputs/detfl_cheby_glyc.csv')
Esempio n. 3
0
    print(times)
    for rxn, fun in conc_funs.items():
        values = [S0[rxn]]
        _ = [values.append(fun(t, values[-1])) for t in times]
        print(rxn, values)

    standard_solver_config(model)
    model.solver.configuration.verbosity = 0

    min_glycolysis_enz = prepare_model(model,
                                       S0=S0,
                                       uptake_fun=get_uptake_funs())

    time_data = run_dynamic_etfl(model,
                                 timestep=timestep,
                                 tfinal=3,
                                 uptake_fun=get_uptake_funs(),
                                 medium_fun=conc_funs,
                                 S0=S0,
                                 X0=X0,
                                 inplace=True,
                                 initial_solution=min_glycolysis_enz,
                                 chebyshev_include=[
                                     ForwardCatalyticConstraint,
                                     BackwardCatalyticConstraint,
                                     ExpressionCoupling
                                 ])

    plot_dynamics(model, time_data)
    time_data.to_csv('outputs/detfl_cheby_monod_{}.csv'.format(model_tag))
Esempio n. 4
0
# Initial solution on lcts/glc mix
set_mix(10,5)
ini_sol = smol_model.optimize()

uptake_fun = {'EX_glc' :lambda x:10, # No point in putting kinetics, we just put fixed LBs
              'EX_lcts':lambda x:5}
medium_fun = {'EX_glc' :lambda t,x:max(0,x), # no negative concentrations
              'EX_lcts':lambda t,x:max(0,x)}

S0 = {'EX_glc' : 1, # No point in putting kinetics, we just put fixed LBs
      'EX_lcts': 1}
X0 = 1

# Dyno:
tsol =  run_dynamic_etfl(smol_model, timestep=0.01, tfinal=1, uptake_fun=uptake_fun, medium_fun=medium_fun,
                         uptake_enz=[],
                         S0=S0, X0=X0,
                         inplace=True,
                         initial_solution = ini_sol,
                         chebyshev_include=False,
                         dynamic_constraints={
                                'mRNA_degradation':False,
                                'mRNA_synthesis':False,
                                'enzyme_synthesis':True,
                                'enzyme_degradation':True,
                            },
                         mode='forward')

tsol.to_csv('outputs/tsol_small_model.csv')