def load_petab(yaml_file, output_dir, out_name=None):
"""Loads the petab file as specified in the yaml file
This file will be converted using the petab_copasi_importer, and serialized to the specified
output directory.
:param yaml_file: the yaml file of the petab description
:type yaml_file: str
:param output_dir: the output directory to write the files in
:type output_dir: str
:param out_name: optional base name of the copasi file. if it is not specified ith will be
the basename of the yaml file
:type out_name: str or None
:return: the full path to the cps file loded
"""
# convert to COPASI file
converter = copasi_petab_importer.PEtabConverter.from_yaml(
yaml_file, out_dir=output_dir, out_name=out_name)
converter.convert()
# load into basico
cps_file = os.path.join(output_dir, converter.out_name + '.cps')
basico.load_model(cps_file)
return cps_file
def test_load_example(self):
dm = basico.load_example('brusselator')
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('The Brusselator' in basico.model_io.overview())
# save model to string
copasi = basico.save_model_to_string()
basico.remove_datamodel(dm)
# try to load the model from string
dm = basico.load_model(copasi)
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('The Brusselator' in basico.model_io.overview())
# save model as temp file
sbml_name = tempfile.mktemp()
basico.save_model(sbml_name, type='sbml')
cps_name = tempfile.mktemp()
basico.save_model(cps_name, type='copasi')
# model and data
basico.save_model_and_data(cps_name, delete_data_on_exit=True)
basico.remove_datamodel(dm)
def __init__(self,
sbml_file,
max_t=10,
output=None,
changes=None,
use_numbers=False,
change_unit=True,
method='stochastic') -> None:
"""
"""
self.sbml_file = sbml_file
self.output = output
if self.output is None:
# assume X Y for now, as thats what is in the example
self.output = ['X', 'Y']
self.dm = basico.load_model(sbml_file)
# many sbml models do not define realistic units, and
# since we compute in particle numbers, we usually do not run
# for gazillion particles, so set substance unit to 1
if change_unit:
basico.set_model_unit(substance_unit='1', model=self.dm)
self.max_t = max_t
# allow to override parameters
self.changes = changes
if changes is not None:
self.apply_parameters(changes)
self.use_numbers = False
self.method = method
def load_model(self, **kwargs):
"""Loads the model into basico
If the `cps_file` is in the arguments, then this will be loaded. otherwise this instances
petab_problem, will be written to files, converted to COPASI and then loaded (at which point
the cps_file generated will be set).
:param kwargs:
- 'cps_file' (str): if present this file will be loaded rather than the petab problem
:return: None
"""
if 'cps_file' in kwargs:
self.cps_file = kwargs['cps_file']
basico.load_model(self.cps_file)
else:
files = write_problem_to(self.petab_problem, self.working_dir,
self.name)
self.cps_file = load_petab(files['problem'], self.working_dir)
def run_models_copasi(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()
model: CDataModel = load_model(str(path))
load_time = time.time() - start_time # [s]
if model is None:
raise RuntimeError(
f"COPASI model could not be loaded: '{model_id}'")
# run optimization
start_time = time.time()
df = run_copasi_time_course(
model=model,
start_time=START,
duration=END - START,
step_number=STEPS,
a_tol=ABSOLUTE_TOLERANCE,
r_tol=RELATIVE_TOLERANCE,
)
simulate_time = time.time() - start_time # [s]
status = "success"
except (ValueError, RuntimeError) as err:
print(f"ERROR in '{model_id}'", err)
simulate_time = np.NaN
status = "failure"
# store result
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
def __init__(
self,
sbml_file: str,
changes: Dict[str, float] = None,
change_unit: bool = True,
method: str = "stochastic",
t0: float = None,
duration: float = None,
num_steps: int = None,
automatic: bool = True,
use_numbers: bool = False,
output: List[str] = None,
model_name: str = None,
):
"""
Parameters
----------
sbml_file:
SBML file containing the model definition.
changes:
Parametric changes to apply to the SBML model.
change_unit:
Whether to change units to 1, useful for discrete simulations
(particle numbers).
method:
Simulation method, can be any method supported by
`basico.run_time_course`, in particular:
* deterministic, lsoda: the LSODA implementation
* stochastic: the Gibson & Bruck Gillespie implementation
* directMethod: Gillespie Direct Method
* others: hybridode45, hybridlsoda, adaptivesa, tauleap, radau5,
sde
t0, duration, num_steps:
Initial time point, duration, number of steps. Definition and
combination as in `basico.run_time_course`.
automatic:
Whether to use automatic steps, or the specified interval / number
of steps.
use_numbers:
Whether to return all elements collected.
output:
Species to output. Defaults to all.
model_name:
Model name, for identification e.g. in the database.
"""
# a maybe informative model name
if model_name is None:
model_name = os.path.splitext(os.path.basename(sbml_file))[0]
self.model_name = model_name
super().__init__(name=f"BasicoModel_{model_name}", )
self.sbml_file = sbml_file
self.dm = basico.load_model(sbml_file)
# many sbml models do not define realistic units, and
# since we compute in particle numbers, we usually do not run
# for particles, so set substance unit to 1
if change_unit:
basico.set_model_unit(substance_unit='1', model=self.dm)
self.change_unit = change_unit
# allow to override parameters
if changes is not None:
self.apply_parameters(changes)
self.changes = changes
self.t0 = t0
self.duration = duration
self.num_steps = num_steps
self.automatic = automatic
self.use_numbers = use_numbers
self.output = output
self.method = method
use_concentrations = kwargs.get('use_concentrations', True)
if 'use_numbers' in kwargs and kwargs['use_numbers']:
use_concentrations = False
return __build_result_from_ts(task.getTimeSeries(), use_concentrations)
if __name__ == "__main__":
from code.comparisonpy import MODELS_DIR
from basico import load_model, model_io # , run_time_course
for mid in [
"BIOMD0000000514",
"BIOMD0000000515",
"BIOMD0000000516",
]:
model_path = MODELS_DIR / "biomodels" / f"{mid}.xml"
model: CDataModel = load_model(str(model_path))
df = run_time_course(
model=model,
start_time=0,
duration=100,
step_number=100,
a_tol=1E-10,
r_tol=1E-10,
)
print(df)
def setUp(self):
self.model = basico.load_model(
os.path.join(os.path.dirname(__file__),
'multiple_experiments.cps'))
self.assertTrue(
self.model.getModel().getObjectName() == 'multiple_experiments')
def test_save(self):
cps_name = tempfile.mktemp()
basico.save_model_and_data(cps_name, delete_data_on_exit=True)
d2 = basico.load_model(cps_name)
self.assertIsNotNone(d2)
basico.remove_datamodel(d2)
def generate_model(self, model_file, output_dir):
import basico
import COPASI
file_name = os.path.join(
output_dir, 'model-{0}-{1}.cps'.format(
self.id,
os.path.splitext(os.path.basename(model_file))[0]))
report_name = os.path.join(
output_dir, 'report-{0}-{1}.txt'.format(
self.id,
os.path.splitext(os.path.basename(model_file))[0]))
dm = basico.load_model(model_file)
if dm is None:
return None
if 'format' in self.settings and self.settings['format'] == 'copasi':
# disable all other scheduled tasks
if self.settings['task'] != 'as-is':
for task in dm.getTaskList():
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(False)
task = None
need_report = False
if self.settings['task'] == TaskTypes.asIs:
need_report = True
for temp_task in dm.getTaskList():
assert (isinstance(temp_task, COPASI.CCopasiTask))
if temp_task.isScheduled():
task = temp_task
break
if task is None:
logging.error('No active task found for test {0}'.format(
self.id))
return None
elif self.settings['task'] == TaskTypes.steadystate:
need_report = True
task = dm.getTask('Steady-State')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
task.setUpdateModel(True)
method = task.getMethod()
if 'Resolution' in self.settings:
method.getParameter('Resolution').setDblValue(
float(self.settings['Resolution']))
if 'Use Newton' in self.settings:
method.getParameter('Use Newton').setBoolValue(
self.settings['Use Newton'].lower() == 'true')
if 'Use Integration' in self.settings:
method.getParameter('Use Integration').setBoolValue(
self.settings['Use Integration'].lower() == 'true')
if 'Use Back Integration' in self.settings:
method.getParameter('Use Back Integration').setBoolValue(
self.settings['Use Back Integration'].lower() == 'true')
if 'Iteration Limit' in self.settings:
method.getParameter('Iteration Limit').setUIntValue(
int(self.settings['Iteration Limit']))
if 'Maximum duration for forward integration' in self.settings:
method.getParameter(
'Maximum duration for forward integration').setUDblValue(
float(self.settings[
'Maximum duration for forward integration']))
if 'Maximum duration for backward integration' in self.settings:
method.getParameter(
'Maximum duration for backward integration').setUDblValue(
float(self.settings[
'Maximum duration for backward integration']))
if 'Target Criterion' in self.settings:
p = method.getParameter('Target Criterion')
if p is None:
method.addParameter('Target Criterion',
COPASI.CCopasiParameter.Type_STRING)
p = method.getParameter('Target Criterion')
p.setStringValue(self.settings['Target Criterion'])
elif self.settings['task'] == TaskTypes.timecourse:
need_report = True
task = dm.getTask('Time-Course')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
task.setUpdateModel(True)
problem = task.getProblem()
assert (isinstance(problem, COPASI.CTrajectoryProblem))
if 'method' in self.settings:
task.setMethodType(
COPASI.CCopasiMethod_TypeNameToEnum(
self.settings['method']))
if 'duration' in self.settings:
problem.setDuration(float(self.settings['duration']))
if 'steps' in self.settings:
problem.setStepNumber(int(self.settings['steps']))
problem = task.getProblem()
if 'StepNumber' in self.settings:
problem.getParameter('StepNumber').setUIntValue(
int(self.settings['StepNumber']))
if 'StepSize' in self.settings:
problem.getParameter('StepSize').setDblValue(
float(self.settings['StepSize']))
if 'Duration' in self.settings:
problem.getParameter('Duration').setDblValue(
float(self.settings['Duration']))
COPASI.COutputAssistant.getListOfDefaultOutputDescriptions()
COPASI.COutputAssistant.createDefaultOutput(1000, task, dm)
elif self.settings['task'] == TaskTypes.scan:
need_report = True
task = dm.getTask('Scan')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
elif self.settings['task'] == TaskTypes.efm:
need_report = True
task = dm.getTask('Elementary Flux Modes')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
elif self.settings['task'] == TaskTypes.optimization:
need_report = True
task = dm.getTask('Optimization')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
if 'method' in self.settings:
task.setMethodType(
COPASI.CCopasiMethod_TypeNameToEnum(
self.settings['method']))
elif self.settings['task'] == TaskTypes.parameterEstimation:
need_report = True
task = dm.getTask('Parameter Estimation')
assert (isinstance(task, COPASI.CFitTask))
task.setScheduled(True)
if 'method' in self.settings:
task.setMethodType(
COPASI.CCopasiMethod_TypeNameToEnum(
self.settings['method']))
problem = task.getProblem()
assert (isinstance(problem, COPASI.CFitProblem))
# need to copy data files
exp_set = problem.getExperimentSet()
assert (isinstance(exp_set, COPASI.CExperimentSet))
for i in range(exp_set.getExperimentCount()):
exp = exp_set.getExperiment(i)
assert (isinstance(exp, COPASI.CExperiment))
filename = exp.getFileNameOnly()
if not os.path.isfile(filename) and os.path.isfile(
os.path.join(os.path.dirname(model_file), filename)):
filename = os.path.join(os.path.dirname(model_file),
filename)
if os.path.isfile(filename):
with open(filename, 'r') as data_file:
data = data_file.read()
new_file = os.path.join(output_dir,
os.path.basename(filename))
with open(new_file, 'w') as new_data_file:
new_data_file.write(data)
exp.setFileName(filename)
elif self.settings['task'] == TaskTypes.mca:
need_report = True
task = dm.getTask('Metabolic Control Analysis')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
task.setUpdateModel(True)
elif self.settings['task'] == TaskTypes.lyap:
need_report = True
task = dm.getTask('Lyapunov Exponents')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
elif self.settings['task'] == TaskTypes.tssa:
need_report = True
task = dm.getTask('Time Scale Separation Analysis')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
if 'method' in self.settings:
task.setMethodType(
COPASI.CCopasiMethod_TypeNameToEnum(
self.settings['method']))
problem = task.getProblem()
if 'StepNumber' in self.settings:
problem.getParameter('StepNumber').setUIntValue(
int(self.settings['StepNumber']))
if 'StepSize' in self.settings:
problem.getParameter('StepSize').setDblValue(
float(self.settings['StepSize']))
if 'Duration' in self.settings:
problem.getParameter('Duration').setDblValue(
float(self.settings['Duration']))
elif self.settings['task'] == TaskTypes.sensitivities:
need_report = True
task = dm.getTask('Sensitivities')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
elif self.settings['task'] == TaskTypes.moieties:
need_report = True
task = dm.getTask('Moieties')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
reports = dm.getReportDefinitionList()
assert (isinstance(reports, COPASI.CReportDefinitionVector))
reports.removeByName('Moieties')
new_report = reports.createReportDefinition(
'Moieties', 'Link Matrix and Stoichiometry matrix')
assert (isinstance(new_report, COPASI.CReportDefinition))
new_report.setIsTable(False)
new_report.addFooterItem(dm.getModel().getObject(
COPASI.CCommonName('Array=Link matrix(ann)')).getCN())
new_report.addFooterItem(COPASI.CCommonName('String=\n'))
new_report.addFooterItem(dm.getModel().getObject(
COPASI.CCommonName('Array=Stoichiometry(ann)')).getCN())
task.getReport().setReportDefinition(new_report)
elif self.settings['task'] == TaskTypes.crossSection:
need_report = True
task = dm.getTask('Cross Section')
assert (isinstance(task, COPASI.CCopasiTask))
task.setScheduled(True)
COPASI.COutputAssistant.getListOfDefaultOutputDescriptions()
COPASI.COutputAssistant.createDefaultOutput(1000, task, dm)
elif self.settings['task'] == TaskTypes.lna:
need_report = True
task = dm.getTask('Linear Noise Approximation')
task.setScheduled(True)
problem = task.getProblem()
problem.getParameter('Steady-State').setStringValue(
dm.getTask(TaskTypes.steadystate).getKey())
if task is not None and need_report:
report = task.getReport()
assert (isinstance(report, COPASI.CReport))
report.setConfirmOverwrite(False)
report.setAppend(False)
report.setTarget(report_name)
logging.debug('\t Task is: {0}'.format(task.getObjectName()))
logging.debug('\t Method is: {0}'.format(
task.getMethod().getObjectName()))
if dm.saveModel(file_name, True):
basico.remove_datamodel(dm)
return file_name
basico.remove_datamodel(dm)
return None
