def load_model_from_cellml(cellml_filename, mmt_filename): """Load a model into Myokit from cellml file format. Parameters ---------- cellml_filename : str Path to the CellML model mmt_filename : str Path to location to save the MMT model Returns ------- None """ if 'cellml' not in myokit.formats.importers(): raise Exception('cellml support not detected in your Myokit') importer = myokit.formats.importer('cellml') model = importer.model(cellml_filename) # Try to parse the stimulus protocol from the CellML model try: model, prot = convert_protocol(model) myokit.save_model(mmt_filename, model) # If the names of variables do not match, just load the model as is except KeyError: myokit.save_model(mmt_filename, model) sim = load_simulation_from_mmt(mmt_filename) return sim
def save_model(self): """ Tests if the correct parts are saved/loaded from disk using the ``save_model()`` method. """ ipath = os.path.join(myotest.DIR_DATA, 'lr-1991.mmt') opath = os.path.join(myotest.DIR_OUT, 'loadsavetest.mmt') if os.path.exists(opath): os.remove(opath) # Test example loading m = myokit.load_model('example') self.assertIsInstance(m, myokit.Model) # Test file loading m = myokit.load_model(ipath) self.assertIsInstance(m, myokit.Model) if os.path.exists(opath): os.remove(opath) try: myokit.save_model(opath, m) # Test no other parts were written with open(opath, 'r') as f: text = f.read() self.assertTrue('[[model]]' in text) self.assertFalse('[[protocol]]' in text) self.assertFalse('[[script]]' in text) # Test reloading mm = myokit.load_model(opath) self.assertIsInstance(mm, myokit.Model) self.assertEqual(mm.code(), m.code()) finally: os.remove(opath)
def test_save_model(self): """ Test if the correct parts are saved/loaded from disk using the ``save_model()`` method. """ ipath = os.path.join(DIR_DATA, 'lr-1991.mmt') # Test example loading m = myokit.load_model('example') self.assertIsInstance(m, myokit.Model) # Test file loading m = myokit.load_model(ipath) self.assertIsInstance(m, myokit.Model) with TemporaryDirectory() as d: opath = d.path('loadsave.mmt') myokit.save_model(opath, m) # Test no other parts were written with open(opath, 'r') as f: text = f.read() self.assertTrue('[[model]]' in text) self.assertFalse('[[protocol]]' in text) self.assertFalse('[[script]]' in text) # Test reloading mm = myokit.load_model(opath) self.assertIsInstance(mm, myokit.Model) self.assertEqual(mm.code(), m.code())
def save_steady_state_to_mmt(s, steady_state: list, list_of_models_names: list, save_location: str): """ Saves the steady states as new mmt models. The structure of the (if necessary created) folder is: save_location\\one folder per model\\one .mmt model per experimental condition. :param s: myokit.Simulation or list of myokit.Simulation. Contains the model(s) for which the steady-state will be computed. :param steady_state: list. List of length the number of models, and each index contains the number of different experimental conditions provided with data_exp. Refer to steady_state[i][j] for the i-th model steady-state under j-th experimental conditions :param list_of_models_names: list of strings. List of the names of the models. If not specified, the models will be named model #. :param save_location: string. Link to the folder where to save the new model produced. If more than one model is provided, sub-directories matching the models names in list_of_models_names will be created, and a .mmt file created for each steady-state of the model (generated previously with different experimental conditions). :return: None """ # Check the inputs in the function if len(steady_state) != len(list_of_models_names): raise ValueError('Steady_state and list_of_models_names should have ' 'the same length.') # Create the folder of save if not existing yet if not os.path.exists(save_location): os.makedirs(save_location) # Write the models into the folder, with one folder per model for i in range(len(list_of_models_names)): folder = os.path.join(save_location, list_of_models_names[i]) if not os.path.exists(folder): os.makedirs(folder) # Create a sub-folder for each experimental condition desired for j in range(len(steady_state[0])): save_filename = os.path.join( folder, list_of_models_names[i] + '_exp_cond_' + str(j) + '.mmt') s[i].set_default_state(steady_state[i][j]) model_to_save = s[i]._model myokit.save_model(save_filename, model_to_save) return None
def test_multiline_string_indent(self): """ Test what happens when you load save a string that gets auto-indented. """ # Create model with multi-line meta-data property d1 = 'First line\n\nSecond line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk with TemporaryDirectory() as d: opath = d.path('multiline.mmt') myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d1, d2) # Create model with indented multi-line meta-data property d1 = ' First line\n\n Second line' dr = 'First line\n\nSecond line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk with TemporaryDirectory() as d: opath = d.path('multiline.mmt') myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d2, dr) # Create model with strangely indented multi-line meta-data property d1 = ' First line\n\n Second line' dr = 'First line\n\n Second line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk with TemporaryDirectory() as d: opath = d.path('multiline.mmt') myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d2, dr)
def multiline_string_indent(self): """ Tests what happens when you load save a string that gets auto-indented. """ # Create model with multi-line meta-data property d1 = 'First line\n\nSecond line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk opath = os.path.join(myotest.DIR_OUT, 'multiline.mmt') if os.path.exists(opath): os.remove(opath) try: myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d1, d2) finally: # Tidy up if os.path.exists(opath): os.remove(opath) # Create model with indented multi-line meta-data property d1 = ' First line\n\n Second line' dr = 'First line\n\nSecond line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk opath = os.path.join(myotest.DIR_OUT, 'multiline.mmt') if os.path.exists(opath): os.remove(opath) try: myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d2, dr) finally: # Tidy up if os.path.exists(opath): os.remove(opath) # Create model with strangely indented multi-line meta-data property d1 = ' First line\n\n Second line' dr = 'First line\n\n Second line' m1 = myokit.Model() m1.meta['desc'] = d1 e = m1.add_component('engine') v = e.add_variable('time') v.set_binding('time') v.set_rhs(0) # Store to disk opath = os.path.join(myotest.DIR_OUT, 'multiline.mmt') if os.path.exists(opath): os.remove(opath) try: myokit.save_model(opath, m1) # Load and compare the meta-data string m2 = myokit.load_model(opath) d2 = m2.meta['desc'] self.assertEqual(d2, dr) finally: # Tidy up if os.path.exists(opath): os.remove(opath)