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