def compareModels(sbmlModel, antModel):
'''
This code needs to be rewritten.
'''
import roadrunner, pylab, antimony
sbmlModel = "00001-sbml-l2v4.xml"
antModel = sbmlModel.replace(sbmlModel[-3:], "ant")
# Make a round trip to and from Antimony
antimony.loadSBMLFile(sbmlModel)
antimony.writeAntimonyFile(antModel, antimony.getModuleNames()[1])
antimony.loadAntimonyFile(antModel)
antimony.writeSBMLFile("test.xml", antimony.getModuleNames()[1])
rr1 = roadrunner.RoadRunner(sbmlModel)
rr2 = roadrunner.RoadRunner("test.xml")
result1 = rr1.simulate(0, 10, 101)
result2 = rr2.simulate(0, 10, 101)
result = result1 - result2
pylab.plot(result[:, 0], result[:, 1:])
pylab.show()
def fitness(self, x):
if self.rr is None:
self.rr = roadrunner.RoadRunner(self.sbml)
# Reset road runner for a new simulation
self.rr.resetToOrigin()
# Set the parameter values
self.rr.vs = x[0]
self.rr.vm = x[1]
self.rr.Km = x[2]
self.rr.KI = x[3]
self.rr.n = x[4]
self.rr.ks = x[5]
self.rr.vd = x[6]
self.rr.Kd = x[7]
self.rr.k1 = x[8]
self.rr.k2 = x[9]
# Run road runner
self.rr.timeCourseSelections = ['time', 'M', 'FC', 'FN']
result = self.rr.simulate(0, 96, 97)
# Compare simulation result with experiment data for all three
# species from hour 48 onwards
sum_of_squares_error = np.sum(np.square(np.array(result[48:, 1:])-self.experimentData))
# Nmmso finds the maximum so need to negate the sum of squares error
return -sum_of_squares_error
def timeit(name, path, loadTimeCap, runTimeCap):
print('Model: {}'.format(name), file=stderr)
startTime = time.time()
global regDetected
passFail = 'pass'
# Load the model
r=roadrunner.RoadRunner(path)
# use these settings for consistent performance
r.getIntegrator().setValue('relative_tolerance', rel_tol_default)
r.getIntegrator().setValue('absolute_tolerance', absolute_tol_default)
r.getIntegrator().setValue('stiff', False)
loadTime = time.time()
if loadTime-startTime > loadTimeCap:
regDetected = True
passFail = '***FAIL***'
m=r.simulate(start, end, steps)
endTime = time.time()
if endTime-loadTime > runTimeCap:
regDetected = True
passFail = '***FAIL***'
csvwriter.writerow([name, formatTime(loadTime-startTime), formatTime(endTime-loadTime), formatTime(endTime-startTime), passFail])
def simulator(self, model):
try:
import roadrunner as rr
self._simulator = rr.RoadRunner(model)
except ImportError:
print("libroadrunner is not installed!")
def setup_model(cls,
model_file,
inputs=[],
outputs=[],
integrator=None,
integrator_settings={}):
r"""Set up model class instance."""
import roadrunner
from yggdrasil.languages.Python.YggInterface import (YggInput,
YggOutput)
model = roadrunner.RoadRunner(model_file)
if integrator is not None:
model.setIntegrator(integrator)
for k, v in integrator_settings.items():
model.getIntegrator().setValue(k, v)
input_map = {}
output_map = {}
for x in inputs:
input_map[x['name']] = {
'vars': x.get('vars', []),
'comm': YggInput(x['name'], new_process=True)
}
for x in outputs:
output_map[x['name']] = {
'as_array': x.get('as_array', False),
'vars': x.get('vars', []),
'comm': YggOutput(x['name'], new_process=True)
}
return model, input_map, output_map
def __init__(self, string, sbml=None):
super().__init__()
self.knownatts.add("doc")
self.knownatts.add("rr")
self.knownatts.add("outputVariables")
self.knownatts.add("rr_default_int")
self.outputVariables = ['time']
print("This is the constructor method.")
if isfile(string):
super().__setattr__("doc", tesbml.readSBMLFromFile(string))
if self.doc.getModel() == None:
raise Exception("No SBML model present at '" + string + "'.")
elif sbml is not None:
self.doc = sbml.clone()
else:
self.doc = tesbml.readSBMLFromString(string)
if self.doc.getModel() == None:
raise Exception(
"Unable to parse string as an SBML model, or file not found."
)
self.rr = roadrunner.RoadRunner(self.doc.toSBML())
self.rr_default_int = self.rr.getIntegrator().getName()
self.saveModelElements()
self.saveRRElements()
self['time'] = 0
def loada(sbstr):
import antimony as sb
r = sb.loadAntimonyString(sbstr)
if r < 0:
raise RuntimeError('Failed to load Antimony model: {}'.format(
sb.getLastError()))
return roadrunner.RoadRunner(sb.getSBMLString(sb.getModuleNames()[-1]))
def main():
# Obtain SBML model from Biomodels and populate Road Runner
model = urllib.request.urlopen('http://www.ebi.ac.uk/biomodels-main/download?mid=BIOMD0000000299')
sbml = model.read().decode('utf-8')
rr = roadrunner.RoadRunner(sbml)
# Run the simulation and produce some fake experiment data. If you have
# actual experiment data you will not need to run this simulation.
rr.resetToOrigin()
rr.timeCourseSelections = ['time', 'M', 'FC', 'FN']
fake_experiment_data = rr.simulate(0, 96, 97)
# Reduce the experiment data to be the data from 48 hours
# onwards when limit cycle has been reached and remove the
# time from the experiment data
fake_experiment_data = np.array(fake_experiment_data[48:, 1:])
# Now run NMMSO to find the modes
nmmso = Nmmso(UniformRangeProblem(SbmlModelProblem(sbml, fake_experiment_data)), 10)
nmmso.add_listener(TraceListener(1))
my_result = nmmso.run(50000)
for mode_result in my_result:
print("Mode at {} has value {}".format(mode_result.location, mode_result.value))
def load_model(info=True):
""" Loads the latest model version. """
path = model_path()
logging.info(f'Model:{path}')
r = roadrunner.RoadRunner(path)
set_selections(r)
return r
def example(model_id: str) -> None:
"""XPP example conversion."""
# convert xpp to sbml
xpp_dir = Path(__file__).parent / "xpp_example"
out_dir = xpp_dir / "results"
xpp_file = xpp_dir / f"{model_id}.ode"
sbml_file = out_dir / f"{model_id}.xml"
xpp.xpp2sbml(xpp_file=xpp_file, sbml_file=sbml_file)
sbmlreport.create_report(sbml_file, output_dir=out_dir, validate=False)
# test simulation
r = roadrunner.RoadRunner(str(sbml_file))
s = r.simulate(start=0, end=1000, steps=100)
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(14, 7))
axes = (ax1, ax2)
for ax in axes:
for sid in r.timeCourseSelections[1:]:
ax.plot(s["time"], s[sid], label=sid)
ax2.set_yscale("log")
for ax in axes:
ax.set_ylabel("Value [?]")
ax.set_xlabel("Time [?]")
ax.legend()
fig.savefig(out_dir / f"{model_id}.png", bbox_inches="tight")
def example(model_id):
# convert xpp to sbml
xpp_dir = "./xpp_example"
out_dir = "./xpp_example/results"
xpp_file = os.path.join(xpp_dir, "{}.ode".format(model_id))
sbml_file = os.path.join(out_dir, "{}.xml".format(model_id))
xpp.xpp2sbml(xpp_file=xpp_file, sbml_file=sbml_file)
sbmlreport.create_report(sbml_file, target_dir=out_dir, validate=False)
# test simulation
r = roadrunner.RoadRunner(sbml_file)
s = r.simulate(start=0, end=1000, steps=100)
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(14, 7))
axes = (ax1, ax2)
for ax in axes:
for sid in r.timeCourseSelections[1:]:
ax.plot(s["time"], s[sid], label=sid)
ax2.set_yscale("log")
for ax in axes:
ax.set_ylabel("Value [?]")
ax.set_xlabel("Time [?]")
ax.legend()
fig.savefig(os.path.join(out_dir, "{}.png".format(model_id)), bbox_inches="tight")
def _process_models(self):
""" Process and prepare models for simulation.
Resolves the replacements and model couplings between the
different frameworks and creates models which can be simulated with
the different frameworks.
An important step is finding the fba rules in the top model.
:return:
:rtype:
"""
logging.debug('* _process_models')
###########################
# FBA rules
###########################
# process FBA assignment rules of the top model
self.flux_rules = DFBAModel._process_flux_rules(self.model_top)
###########################
# ODE model
###########################
# the roadrunner ode file is the flattened comp file.
# FBA parts do not change any of the kinetic subparts (only connections via replaced bounds
# and fluxes).
# Consequently, the ODE part can be solved as is, only the iterative update between ode and fba has
# to be performed
# remove FBA assignment rules from the model, so they can be set via the simulator
# not allowed to set assignment rules directly in roadrunner
for variable in self.flux_rules.values():
self.model_top.removeRuleByVariable(variable)
mixed_sbml_cleaned = tempfile.NamedTemporaryFile("w", suffix=".xml")
libsbml.writeSBMLToFile(self.doc_top, mixed_sbml_cleaned.name)
self.rr_comp = roadrunner.RoadRunner(mixed_sbml_cleaned.name)
###########################
# prepare FBA models
###########################
# FBA models are found based on the FBA modeling framework
mdoc = self.doc_top.getPlugin("comp")
for submodel in self.submodels[builder.MODEL_FRAMEWORK_FBA]:
mref = submodel.getModelRef()
emd = mdoc.getExternalModelDefinition(mref)
source = emd.getSource()
# check if relative path
if not os.path.exists(source):
s2 = os.path.join(self.sbml_dir, source)
if not os.path.exists(s2):
warnings.warn('FBA source cannot be resolved:' + source)
else:
source = s2
# Create FBA model and process
fba_model = FBAModel(submodel=submodel,
source=source,
model_top=self.model_top)
self.fba_models.append(fba_model)
def getRoadRunner(resource):
"""
return a RoadRunner instance loaded with one of the test files.
"""
data = pkgutil.get_data(__name__, resource)
r = roadrunner.RoadRunner()
r.load(data)
return r
def diffplot(self):
"""
Run the SBML test. Returns True or False depending on if the test passes or not.
If the test fails, any errors will be available in the SBMLTest.errors property.
"""
import matplotlib.pyplot as plt
self.errors = []
result = True
try:
# run the simulation
plt.figure(1)
r = rr.RoadRunner(self.sbmlFileName, _getLoadOptions())
# need to tweak the tolerances for the current integrator
opt = self.settings.copy()
opt.tweakTolerances()
opt.structuredResult = True
plt.subplot(211)
r.simulate(opt, plot=True, show=False)
plt.xlim([0, opt.duration])
r = rr.RoadRunner(self.sbmlFileName, _getLoadOptions())
# need to tweak the tolerances for the current integrator
opt = self.settings.copy()
opt.tweakTolerances()
opt.variableStep = True
opt.structuredResult = True
plt.subplot(212)
r.simulate(opt, plot=True, show=False)
plt.xlim([0, opt.duration])
plt.show()
except Exception as e:
result = False
self._addError(str(e))
return result
def load_model(sbml):
'''
Load an SBML file in roadrunner
'''
print 'Loading :', sbml
start = time.clock()
r = roadrunner.RoadRunner(sbml)
print 'SBML Rules load :', (time.clock() - start)
return r
def loadSBMLModel(sbml):
""" Load SBML model from a string or file.
:param sbml: SBML model
:type sbml: str | file
:returns: RoadRunner instance with model loaded
:rtype: roadrunner.RoadRunner
"""
return roadrunner.RoadRunner(sbml)
def loadSBMLModel(sbml):
"""Load SBML model with tellurium
:param sbml: SBML model
:type sbml: str | file
:returns: RoadRunner instance with model loaded
:rtype: roadrunner.RoadRunner
"""
return roadrunner.RoadRunner(sbml)
def simulate(self, tstart, tend, nsteps):
rr = roadrunner.RoadRunner(self.toSBML());
pop_tags = sorted(self.strains.keys());
selections = ['time'];
for i in range(len(self.strains)):
selections.append('N_' + pop_tags[i]);
rr.timeCourseSelections = selections;
result = rr.simulate(tstart, tend, nsteps);
return result;
def load_model(info=True):
""" Loads the latest model version. """
model_path = get_model_path()
if info:
print('Model:', model_path)
r = roadrunner.RoadRunner(model_path)
set_selections(r)
return r
def loadCellMLModel(cellml):
""" Load CellML model with tellurium.
:param cellml: CellML model
:type cellml: str | file
:returns: RoadRunner instance with model loaded
:rtype: roadrunner.RoadRunner
"""
sbml = cellmlToSBML(cellml)
return roadrunner.RoadRunner(sbml)
def test_fixed_step_simulation() -> None:
rr = roadrunner.RoadRunner(str(DEMO_SBML))
tend = 10.0
steps = 100
s = rr.simulate(start=0, end=tend, steps=steps)
# test end point reached
assert s[-1, 0] == 10
# test correct number of steps
assert len(s["time"]) == steps + 1
def pass_to_roadrunner(self):
"""
Warning, this function crashes Python
:return:
"""
import roadrunner # note: this causes RoadRunner::regenerate to crash if imported at top level!
rr = roadrunner.RoadRunner()
# passes ownership of the roadrunner model in self._obj to roadrunner
rr.setModel(self._obj)
return rr
def getRoadRunner(resource):
"""
return a RoadRunner instance loaded with one of the test files.
"""
data = pkgutil.get_data(__name__, resource)
r = roadrunner.RoadRunner()
if sys.version_info[0] < 3:
r.load(data)
else:
r.load(data.decode())
return r
def test_fixed_step_simulation():
rr = roadrunner.RoadRunner(data.GALACTOSE_SINGLECELL_SBML)
tend = 10.0
steps = 100
s = rr.simulate(start=0, end=tend, steps=steps)
# test end point reached
assert s[-1, 0] == 10
# test correct number of steps
assert len(s['time']) == steps + 1
def load_model(path, selections: List[str] = None) -> roadrunner.RoadRunner:
""" Loads the latest model version.
:param path: path to SBML model or SBML string
:param selections: boolean flag to set selections
:return: roadrunner instance
"""
logging.info("Loading: '{}'".format(path))
r = roadrunner.RoadRunner(path)
set_timecourse_selections(r, selections)
return r
def testEvents(fileName):
r = roadrunner.RoadRunner(fileName)
eventIds = r.model.getEventIds()
for eid in eventIds:
e = r.model.getEvent(eid)
e.setOnTrigger(onEventTrigger)
e.setOnAssignment(onEventAssignment)
r.simulate()
def loadAntimonyModel(ant):
"""Load Antimony model with tellurium.
See also: :func:`loada`
:param ant: Antimony model
:type ant: str | file
:returns: RoadRunner instance with model loaded
:rtype: roadrunner.RoadRunner
"""
sbml = antimonyToSBML(ant)
return roadrunner.RoadRunner(sbml)
def test_result():
r = roadrunner.RoadRunner(MODEL_REPRESSILATOR)
dfs = []
for _ in range(10):
s = r.simulate(0, 10, steps=10)
dfs.append(pd.DataFrame(s, columns=s.colnames))
result = Result(dfs)
assert result
assert result.nframes == 10
assert result.nrow == 11
assert result.data is not None
def load_model(model_path, timeCourseSelections=True):
""" Loads model and sets selections.
:param model_path:
:param set_selections boolean flag if timeCourseSelections are set on model.
:return:
"""
logging.info('Model:', model_path)
r = roadrunner.RoadRunner(model_path)
if timeCourseSelections:
set_selections(r)
return r
def run_models_roadrunner(model_paths: List[Path],
output_dir: Path) -> pd.DataFrame:
"""ODE optimization for all given models."""
results = []
n_models = len(model_paths)
for k, path in enumerate(model_paths):
model_id = path.stem
try:
# load model
start_time = time.time()
rr: roadrunner.RoadRunner = roadrunner.RoadRunner(str(path))
load_time = time.time() - start_time # [s]
model: roadrunner.ExecutableModel = rr.model
# set tolerances
integrator: roadrunner.Integrator = rr.integrator
integrator.setValue("absolute_tolerance", ABSOLUTE_TOLERANCE)
integrator.setValue("relative_tolerance", RELATIVE_TOLERANCE)
# set selections
rr.selections = [
"time"
] + model.getFloatingSpeciesIds() + model.getBoundarySpeciesIds()
# run optimization
start_time = time.time()
s = rr.simulate(start=START, end=END, steps=STEPS)
simulate_time = time.time() - start_time # [s]
# filter models with delay
if model_id in [
"BIOMD0000000024", "BIOMD0000000025", "BIOMD0000000034"
]:
raise RuntimeError("delays not supported")
status = "success"
except (RuntimeError) as err:
print(f"ERROR in '{model_id}'", err)
simulate_time = np.NaN
status = "failure"
# store result
df = pd.DataFrame(s, columns=s.colnames)
df.to_csv(output_dir / f"{model_id}.tsv", sep="\t", index=False)
res = (model_id, status, load_time, simulate_time)
results.append(res)
print("[{}/{}]".format(k, n_models), res)
df = pd.DataFrame(data=results,
columns=("model", "status", "load_time",
"simulate_time"))
return df