def test_simulate(self):
dm = basico.load_example('LM')
data = basico.get_experiment_data_from_model()
self.assertTrue(len(data) == 5)
df = basico.run_time_course(100, automatic=False)
self.assertTrue(df.shape == (101, 5))
basico.remove_datamodel(dm)
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 test_add_function(self):
m = basico.new_model(name='TestModel_With_Inhibition')
basico.add_function(name='MassAction_inhibited',
infix='(1-a*I)*k*A*B', type='irreversible',
mapping={'I': 'modifier', 'A': 'substrate', 'B': 'substrate'})
f = basico.get_functions('MassAction_inhi')
self.assertTrue(len(f) == 1)
basico.add_reaction('R1', 'S1 + S2 -> S3; I', function='MassAction_inhibited')
r = basico.get_reactions('R1')
self.assertTrue(r is not None)
self.assertEqual(r['function'][0], 'MassAction_inhibited')
basico.remove_datamodel(m)
def test_load_biomodel(self):
dm = basico.load_biomodel(10)
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('Kholodenko2000' in basico.model_io.overview())
basico.remove_datamodel(dm)
dm = basico.load_biomodel("MODEL1006230012")
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('Stewart2009' in basico.model_io.overview())
params = basico.get_parameters()
self.assertEqual(params.shape[0], 176)
basico.remove_datamodel(dm)
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 test_new_model(self):
dm = basico.new_model()
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('New Model' in basico.model_io.overview())
basico.remove_datamodel(dm)
def test_load_biomodel(self):
dm = basico.load_biomodel(10)
self.assertTrue(dm is not None)
self.assertTrue(isinstance(dm, COPASI.CDataModel))
self.assertTrue('Kholodenko2000' in basico.model_io.overview())
basico.remove_datamodel(dm)
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())
basico.remove_datamodel(dm)
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