def test_encapsulation(self): from libcellml import Issue, Model e = Issue() self.assertIsNone(e.model()) name = 'moodle' m = Model() m.setName(name) e.setEncapsulation(m) self.assertIsInstance(e.encapsulation(), Model) self.assertEqual(e.encapsulation().name(), name)
def test_model(self): from libcellml import ImportSource, Model model = Model() model.setName('bert') x = ImportSource() self.assertIsNone(x.model()) x.setModel(model) self.assertEqual(x.model().name(), model.name()) x.setModel(None) self.assertIsNone(x.model())
def test_get_model(self): from libcellml import ImportSource, Model # libcellml::ModelPtr getModel() const; model = Model() model.setName('bert') x = ImportSource() self.assertIsNone(x.getModel()) x.setModel(model) self.assertEqual(x.getModel().getName(), model.getName()) x.setModel(None) self.assertIsNone(x.getModel())
def test_model(self): from libcellml import Issue, Model # ModelPtr model() e = Issue() self.assertIsNone(e.model()) name = 'moodle' m = Model() m.setName(name) e.setModel(m) self.assertIsInstance(e.model(), Model) self.assertEqual(e.model().name(), name)
def test_get_model(self): from libcellml import Error, Model # ModelPtr getModel() e = Error() self.assertIsNone(e.getModel()) name = 'moodle' m = Model() m.setName(name) e.setModel(m) self.assertIsInstance(e.getModel(), Model) self.assertEqual(e.getModel().getName(), name)
- the concept of component hierarchy and encapsulation (Tutorial 5) - the use of the API to create all of the entities in a model (Tutorial 3) - the content MathML2 markup for mathematical equations (Tutorial 4) - serialisation and printing of a model to a CellML file (Tutorial 1) """ from libcellml import Component, Model, Printer, Units, Validator, Variable from utilities.tutorial_utilities import print_errors_to_terminal if __name__ == "__main__": # 0 Setup stuff that is used throughout validator = Validator() model = Model() model.setName("Tutorial7_SodiumChannelModel") math_header = '<math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:cellml="http://www.cellml.org/cellml/2.0#">' math_footer = '</math>' print("-----------------------------------------------") print(" STEP 1: Creating the sodium channel") print("-----------------------------------------------") # 1.a Create the component instance, name it, and add to the model sodium_channel = Component() sodium_channel.setName("sodiumChannel") model.addComponent(sodium_channel) # 1.b Add the MathML representing the governing equations if True:
from libcellml import Component, Generator, GeneratorProfile, Model, Units, Validator, Variable from utilities.tutorial_utilities import print_errors_to_terminal, print_model_to_terminal if __name__ == "__main__": print("-----------------------------------------------------") print(" TUTORIAL 3: CREATE A MODEL USING THE API ") print("-----------------------------------------------------") # --------------------------------------------------------------------------- # STEP 1: Create the model instance # # 1.a Allocate the ModelPtr model = Model() model.setName("Tutorial3_model") # 1.b Create a component to use as an integrator, set its attributes and # add it to the model component = Component() component.setName("component") model.addComponent(component) # Checking that it worked print_model_to_terminal(model) # 1.c,d Create the MathML2 string representing the governing equation. The # header and footer are below already. math_header = '<math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:cellml="http://www.cellml.org/cellml/2.0#">' math_footer = '</math>'
# Setup useful things. math_header = '<math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:cellml="http://www.cellml.org/cellml/2.0#">\n' math_footer = '</math>' print('----------------------------------------------------------') print(' STEP 1: Setup the model ') print('----------------------------------------------------------') # 1.a # The first step is to create a Model item which will later contain the component and # the units it needs. model = Model() # 1.b # Each CellML element must have a name, which is set using the setName() function. model.setName('GateModel') # 1.c # We'll create a wrapper component whose only job is to encapsulate the other components. # This makes is a lot easier for this model to be reused, as the connections between # components internal to this one won't need to be re-established. # Note that the constructor for all named CellML entities is overloaded, so # you can pass it the name string at the time of creation. # Create a component named 'gate'. gate = Component('gate') # 1.d Finally we need to add the component to the model. This sets it at the top-level of # the components' encapsulation hierarchy. All other components need to be added # to this component, rather than the model. # Add the component to the model using the Model::addComponent() function. model.addComponent(gate)
This tutorial explores the ability of libCellML to generate files representing the model which can be solved in Python or C. By the time you have worked through Tutorial 6 you will be able to: - use the Generator functionality to create models in Python or C format - use the simple solver provided to run the created models. Tutorial 6 assumes that you are already comfortable with: - file manipulation and summarising using the utility functions """ from libcellml import Model, Parser, Validator if __name__ == "__main__": # 0 Create a new model instance representing the combined model and name it. model = Model() model.setName("Tutorial8_HHModel") validator = Validator() parser = Parser() print("-----------------------------------------------") print(" STEP 1: Read the membrane component") print("-----------------------------------------------") # 1.a Read the model provided for you in the "Tutorial8_MembraneModel.cellml" # file in the resources folder. # 1.b Create a temporary model for the membrane # 1.b Extract the membrane component from the parsed model and add it # to the combined model. Note that the membrane component's parent # must be cleared before adding it to the model.