def test_clean(self): from libcellml import Component, Model, Units, Variable, Printer model = Model() c1 = Component('c1') c2 = Component() c2.setId('c2') c3 = Component() c4 = Component() u1 = Units('used') u2 = Units() u2.setId('u2') u3 = Units() v = Variable('x') model.addComponent(c1) model.addComponent(c2) model.addComponent(c3) model.addComponent(c4) model.addUnits(u1) model.addUnits(u2) model.addUnits(u3) c3.addVariable(v) self.assertEqual(4, model.componentCount()) self.assertEqual(3, model.unitsCount()) # Call the Model.clean() function to remove the empty items (c4 and u3). model.clean() self.assertEqual(3, model.componentCount()) self.assertEqual(2, model.unitsCount())
def test_units(self): from libcellml import Model, Units # UnitsPtr units(size_t index) name = 'naaame' m = Model() u = Units() u.setName(name) self.assertIsNone(m.units(0)) self.assertIsNone(m.units(1)) self.assertIsNone(m.units(-1)) m.addUnits(u) self.assertIsNone(m.units(1)) self.assertIsNone(m.units(-1)) self.assertIsNotNone(m.units(0)) self.assertEqual(m.units(0).name(), name) del [m, u, name] # UnitsPtr units(const std::string &name) name = 'kermit' m = Model() u = Units() u.setName(name) self.assertIsNone(m.units(name)) m.addUnits(u) self.assertIsNotNone(m.units(name)) self.assertEqual(m.units(name).name(), name) del [m, u, name]
def test_imports(self): from libcellml import Model, ImportSource, Units m = Model() u = Units() u.setImportSource(ImportSource()) m.addUnits(u) self.assertTrue(m.hasImports()) self.assertEqual(1, m.importSourceCount()) i = ImportSource() i.setUrl('actual_url') m.addImportSource(i) self.assertEqual(2, m.importSourceCount()) i1 = m.importSource(0) self.assertTrue(m.hasImportSource(i)) m.removeImportSource(0) self.assertEqual(1, m.importSourceCount()) m.removeAllImportSources() self.assertEqual(0, m.importSourceCount())
def test_add_units(self): from libcellml import Model, Units # void addUnits(const UnitsPtr &units) m = Model() u = Units() m.addUnits(u)
def test_remove_all_units(self): from libcellml import Model, Units # void removeAllUnits() m = Model() u1 = Units() u2 = Units() m.addUnits(u1) m.addUnits(u2) m.removeAllUnits() self.assertFalse(m.removeUnits(u1)) self.assertFalse(m.removeUnits(u2)) del [m, u1, u2]
def test_units_count(self): from libcellml import Model, Units # size_t unitsCount() m = Model() self.assertEqual(m.unitsCount(), 0) m.addUnits(Units()) self.assertEqual(m.unitsCount(), 1) m.addUnits(Units()) self.assertEqual(m.unitsCount(), 2) m.removeAllUnits() self.assertEqual(m.unitsCount(), 0) del m
def test_take_units(self): from libcellml import Model, Units # UnitsPtr takeUnits(size_t index) name = 'piggy' m = Model() u = Units() u.setName(name) self.assertIsNone(m.takeUnits(0)) self.assertIsNone(m.takeUnits(-1)) self.assertIsNone(m.takeUnits(1)) m.addUnits(u) self.assertIsNone(m.takeUnits(-1)) self.assertIsNone(m.takeUnits(1)) self.assertIsNotNone(m.takeUnits(0)) self.assertIsNone(m.takeUnits(0)) m.addUnits(Units()) m.addUnits(u) self.assertEqual(m.takeUnits(1).name(), name) del [m, u] # UnitsPtr takeUnits(const std::string &name) name = 'aloha' m = Model() u = Units() u.setName(name) self.assertIsNone(m.takeUnits(name)) m.addUnits(u) self.assertEqual(m.takeUnits(name).name(), name) self.assertIsNone(m.takeUnits(name)) del [m, u, name]
def test_has_units(self): from libcellml import Model, Units # bool hasUnits(const std::string &name) name = 'loud' m = Model() u = Units() u.setName(name) m.addUnits(u) self.assertFalse(m.hasUnits('hi')) self.assertTrue(m.hasUnits(name)) # bool hasUnits(const UnitsPtr &units) self.assertTrue(m.hasUnits(u)) v = Units() self.assertFalse(m.hasUnits(v))
def test_assign_id(self): from libcellml import Annotator, Component, Model, Units from libcellml import Unit, CellmlElementType annotator = Annotator() model = Model() component1 = Component("c1") component2 = Component("c2") component3 = Component("c3") component3.setId("id3") units = Units("u1") units.addUnit("volt") model.addComponent(component1) model.addComponent(component2) component2.addComponent(component3) model.addUnits(units) annotator.setModel(model) self.assertEqual("", component1.id()) self.assertEqual("", component2.id()) self.assertEqual("", units.unitId(0)) annotator.assignId(component1) self.assertEqual("b4da55", component1.id()) self.assertEqual("", component2.id()) self.assertEqual("", units.unitId(0)) annotator.assignId(Unit(units, 0)) self.assertEqual("b4da55", component1.id()) self.assertEqual("", component2.id()) self.assertEqual("b4da56", units.unitId(0)) self.assertEqual("", annotator.assignId(None, CellmlElementType.UNDEFINED)) item = annotator.item("id3") annotator.assignId(item) self.assertEqual("b4da57", component3.id()) # For coverage only. annotator._assignId(component2)
def test_link_units(self): from libcellml import Component, Model, Units, Variable m = Model() c = Component() v = Variable() u = Units("orange") self.assertFalse(m.hasUnlinkedUnits()) m.addUnits(u) v.setUnits("orange") c.addVariable(v) m.addComponent(c) self.assertTrue(m.hasUnlinkedUnits()) m.linkUnits() self.assertFalse(m.hasUnlinkedUnits())
def test_clone(self): from libcellml import Component, Model, Units, Variable m = Model() c1 = Component("c1") c2 = Component("c2") v = Variable("v1") u = Units("apple") m.addComponent(c1) m.addComponent(c2) c1.addVariable(v) v.setUnits(u) m.addUnits(u) mCloned = m.clone() self.assertEqual(2, mCloned.componentCount()) self.assertEqual(1, mCloned.unitsCount()) self.assertEqual(1, mCloned.component(0).variableCount()) self.assertEqual("apple", mCloned.component(0).variable(0).units().name())
def test_replace_units(self): from libcellml import Model, Units # bool replaceUnits(size_t index, const UnitsPtr &units) m = Model() u1 = Units() u1.setName('a') m.addUnits(u1) u2 = Units() u2.setName('b') self.assertTrue(m.replaceUnits(0, u2)) self.assertFalse(m.replaceUnits(1, u1)) self.assertFalse(m.replaceUnits(-1, u1)) self.assertEqual(m.getUnits(0).getName(), 'b') del(m, u1, u2) # bool replaceUnits(const std::string &name, const UnitsPtr &units) m = Model() a = Units() a.setName('a') m.addUnits(a) b = Units() b.setName('b') self.assertFalse(m.replaceUnits('b', a)) self.assertTrue(m.replaceUnits('a', b)) self.assertTrue(m.replaceUnits('b', a)) self.assertFalse(m.replaceUnits('b', a)) del(m, a, b) # bool replaceUnits(const UnitsPtr &oldUnits, const UnitsPtr &newUnits) m = Model() a = Units() m.addUnits(a) b = Units() self.assertFalse(m.replaceUnits(b, a)) self.assertTrue(m.replaceUnits(a, b)) self.assertTrue(m.replaceUnits(b, a)) self.assertFalse(m.replaceUnits(b, a)) del(m, a, b)
def test_remove_units(self): from libcellml import Model, Units # bool removeUnits(size_t index) m = Model() u = Units() self.assertFalse(m.removeUnits(0)) self.assertFalse(m.removeUnits(1)) self.assertFalse(m.removeUnits(-1)) m.addUnits(u) self.assertFalse(m.removeUnits(1)) self.assertFalse(m.removeUnits(-1)) self.assertTrue(m.removeUnits(0)) self.assertFalse(m.removeUnits(0)) del(m, u) # bool removeUnits(const std::string &name) name = 'bert' m = Model() u = Units() u.setName(name) self.assertFalse(m.removeUnits(name)) m.addUnits(u) self.assertFalse(m.removeUnits('ernie')) self.assertTrue(m.removeUnits(name)) del(m, u, name) # bool removeUnits(const UnitsPtr &units) m = Model() u1 = Units() u2 = Units() self.assertFalse(m.removeUnits(u1)) m.addUnits(u1) self.assertFalse(m.removeUnits(u2)) self.assertTrue(m.removeUnits(u1)) self.assertFalse(m.removeUnits(u1)) del(m, u1, u2)
microA_per_cm2 = Units('microA_per_cm2') microA_per_cm2.addUnit('ampere', 'micro') microA_per_cm2.addUnit('metre', 'centi', -2.0) mS_per_cm2 = Units('milliS_per_cm2') mS_per_cm2.addUnit('siemens', 'milli') mS_per_cm2.addUnit('metre', 'centi', -2.0) ms = Units('ms') ms.addUnit('second', 'milli') mM = Units('mM') mM.addUnit('mole', 'milli') model.addUnits(ms) model.addUnits(mV) model.addUnits(mM) model.addUnits(microA_per_cm2) model.addUnits(mS_per_cm2) # 2.g # Set the units on each of the variables. # Call the validator again, and expect there to be no errors. k_channel_equations.variable('E_K').setUnits(mV) k_channel_equations.variable('i_K').setUnits(microA_per_cm2) k_channel_equations.variable('g_K').setUnits(mS_per_cm2) k_channel_equations.variable('V').setUnits(mV) k_channel_equations.variable('t').setUnits(ms) k_channel_equations.variable('n').setUnits('dimensionless')
millisecond.addUnit("second", "milli") # "second" is a built-in unit, used inside millisecond with the # prefix "milli". NB this is equivalent to specifying a prefix # integer value of -3, corresponding to the power of 10 by # which the base is multiplied. league = Units() league.setName("league") league.addUnit("metre", 3, 1.0, 5.556) # "metre" is a built-in unit. A league is equal to 5556m, but here # we illustrate the overloaded function by passing a prefix of 3 # (indicating a factor of 10^3), an exponent of 1, and a # multiplier of 5.556. # 2.b Add the units to the model model.addUnits(millisecond) model.addUnits(league) # 2.c Validate the model again and output the errors # validator.validateModel(model) # print_errors_to_terminal(validator) # 2.d Change the constant "b" to have a hard-coded value of 2.0 in the MathML # and amend the component's math block. equation2 = '<apply><eq/>\ <apply><diff/>\ <bvar>\ <ci>t</ci>\ </bvar>\ <ci>x</ci>\ </apply>\
# we need from the set of built-in units, we just need to define the # relationship. NB: Even though units are used by Variables, which sit # 'inside' Components, Units sit inside the Model itself. This helps you to # reuse Units when you have more than one component (more on that in # Tutorial 5) # 3.a # Define the relationship between our custom units and the built-in # units. There is a list of built-in units and their definitions # available in section 19.2 of the CellML2 specification. # First we create the "month" units, which will be equivalent to # 60*60*24*30 = 2,592,000 seconds. month = Units("month") month.addUnit("second", 1, 2592000) # Setting a month to be 2592000 seconds. model.addUnits(month) # "second" is a built-in unit, used with a multiplier of 2592000. # Note that this could have been written: # month.addUnit("second", "mega", 1, 2.592) # month.addUnit("second", 5, 25.92) # 3.b # Create units which represent "per_month", which # is simply the inverse of the "month" unit above. per_month = Units() per_month.setName("per_month") per_month.addUnit("month", -1) model.addUnits(per_month) # 3.c
# 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 removed before adding it to the model. membrane = membrane_model.component("membrane") membrane.removeParent() model.addComponent(membrane) # 1.c Validate the combined model. We expect to see errors from: # - missing units, as we have only added the component so far validator.validateModel(model) print_errors_to_terminal(validator) # 1.d Import the units from the membraneModel into the combined model for u in range(0, membrane_model.unitsCount()): model.addUnits(membrane_model.units(u)) # 1.e No errors expected this time :) validator.validateModel(model) print_errors_to_terminal(validator) print("\n-----------------------------------------------") print(" STEP 2: Read the sodium channel") print("-----------------------------------------------") # 2.a Read the model created in Tutorial 7 representing the sodium channel. # Note that if you didn't do that tutorial you can simply copy the CellML file # from Tutorial7_SodiumChannelModel.cellml in the resources folder. read_file2 = open("../resources/tutorial7_SodiumChannelModel.cellml", "r")
# - alpha_X and beta_X, rates, have units of *per millisecond*. # 5.a # Create the units which will be needed by your variables and add them to the model. ms = Units('ms') per_ms = Units('per_ms') # 5.b # Add Unit items to the units you created to define them. ms.addUnit('second', 'milli') per_ms.addUnit('second', 'milli', -1) # 5.c # Add the Units to the model (not the component) so that other components can make # use of them too. model.addUnits(ms) model.addUnits(per_ms) # 5.d # Use the setUnits function to associate them with the appropriate variables. gateEquations.variable('t').setUnits(ms) gateEquations.variable('alpha_X').setUnits(per_ms) gateEquations.variable('beta_X').setUnits(per_ms) gateEquations.variable('X').setUnits('dimensionless') # 5.e # Validate again, and expect no errors. validator.validateModel(model) print_issues(validator) # end 5