def test_variable(self):
from libcellml import Component, Variable
# VariablePtr variable(size_t index)
c = Component()
v = Variable()
name = 'green'
v.setName(name)
self.assertIsNone(c.variable(0))
self.assertIsNone(c.variable(1))
self.assertIsNone(c.variable(-1))
c.addVariable(v)
self.assertIsNone(c.variable(1))
self.assertIsNone(c.variable(-1))
self.assertIsNotNone(c.variable(0))
self.assertEqual(c.variable(0).name(), name)
del [c, v, name]
# VariablePtr variable(const std::string &name)
c = Component()
v = Variable()
name = 'green'
v.setName(name)
self.assertIsNone(c.variable(name))
c.addVariable(v)
self.assertIsNone(c.variable('red'))
self.assertIsNotNone(c.variable(name))
self.assertEqual(c.variable(name).name(), name)
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_variable_count(self):
from libcellml import Component, Variable
# size_t variableCount()
c = Component()
self.assertEqual(c.variableCount(), 0)
c.addVariable(Variable())
self.assertEqual(c.variableCount(), 1)
c.addVariable(Variable())
self.assertEqual(c.variableCount(), 2)
c.removeVariable('')
self.assertEqual(c.variableCount(), 1)
c.removeVariable('')
self.assertEqual(c.variableCount(), 0)
def test_remove_all_variables(self):
from libcellml import Component, Variable
# void removeAllVariables()
c = Component()
v1 = Variable()
v2 = Variable()
c.addVariable(v1)
c.addVariable(v2)
self.assertTrue(c.hasVariable(v1))
self.assertTrue(c.hasVariable(v2))
c.removeAllVariables()
self.assertFalse(c.hasVariable(v1))
self.assertFalse(c.hasVariable(v2))
def test_create_destroy(self):
from libcellml import AnalyserExternalVariable
from libcellml import Component
from libcellml import Model
from libcellml import Variable
m = Model('model')
c = Component('component')
v = Variable('test')
self.assertTrue(m.addComponent(c))
self.assertTrue(c.addVariable(v))
aev = AnalyserExternalVariable(v)
self.assertEqual(v.name(), aev.variable().name())
d0 = Variable('d0')
d1 = Variable('d1')
d2 = Variable('d2')
d3 = Variable('d3')
c.addVariable(d0)
c.addVariable(d1)
c.addVariable(d2)
c.addVariable(d3)
self.assertTrue(aev.addDependency(d0))
self.assertTrue(aev.addDependency(d1))
self.assertTrue(aev.addDependency(d2))
self.assertTrue(aev.addDependency(d3))
self.assertEqual(4, aev.dependencyCount())
self.assertIsNotNone(aev.dependency(0))
self.assertIsNotNone(aev.dependency(m, c.name(), d1.name()))
self.assertIsNotNone(aev.dependencies())
self.assertTrue(aev.containsDependency(d0))
self.assertTrue(aev.containsDependency(m, c.name(), d1.name()))
self.assertTrue(aev.removeDependency(1))
self.assertTrue(aev.removeDependency(d0))
self.assertTrue(aev.removeDependency(m, c.name(), d2.name()))
aev.removeAllDependencies()
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_variable_interfaces(self):
from libcellml import Component, Model, Variable
m = Model()
c1 = Component("c1")
c2 = Component("c2")
v1 = Variable("v1")
v2 = Variable("v2")
c1.addVariable(v1)
c2.addVariable(v2)
m.addComponent(c1)
m.addComponent(c2)
Variable.addEquivalence(v1, v2)
m.fixVariableInterfaces()
self.assertEqual("public", v1.interfaceType())
self.assertEqual("public", v2.interfaceType())
def test_has_variable(self):
from libcellml import Component, Variable
# bool hasVariable(const VariablePtr &variable)
c = Component()
v = Variable("second")
self.assertFalse(c.hasVariable(v))
c.addVariable(v)
self.assertTrue(c.hasVariable(v))
self.assertFalse(c.hasVariable(Variable()))
del [c, v]
# bool hasVariable(const std::string &name)
c = Component()
self.assertFalse(c.hasVariable(''))
v1 = Variable()
c.addVariable(v1)
self.assertFalse(c.hasVariable('blue'))
self.assertTrue(c.hasVariable(''))
name = 'yellow'
v2 = Variable()
v2.setName(name)
v1.setName('orange')
c.addVariable(v2)
self.assertTrue(c.hasVariable(name))
vTaken = c.takeVariable(0)
self.assertEqual('orange', vTaken.name())
self.assertTrue(c.variableCount() == 1)
del [c, v1, v2, vTaken, name]
def test_has_variable(self):
from libcellml import Component, Variable
# bool hasVariable(const VariablePtr &variable)
c = Component()
v = Variable()
self.assertFalse(c.hasVariable(v))
c.addVariable(v)
self.assertTrue(c.hasVariable(v))
self.assertFalse(c.hasVariable(Variable()))
del(c, v)
# bool hasVariable(const std::string &name)
c = Component()
self.assertFalse(c.hasVariable(''))
v1 = Variable()
c.addVariable(v1)
self.assertFalse(c.hasVariable('blue'))
self.assertTrue(c.hasVariable(''))
name = 'yellow'
v2 = Variable()
v2.setName(name)
c.addVariable(v2)
self.assertTrue(c.hasVariable(name))
del(c, v1, v2, name)
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_remove_variable(self):
from libcellml import Component, Variable
# bool removeVariable(size_t index)
c = Component()
self.assertFalse(c.removeVariable(0))
self.assertFalse(c.removeVariable(-1))
self.assertFalse(c.removeVariable(1))
c.addVariable(Variable())
self.assertFalse(c.removeVariable(-1))
self.assertFalse(c.removeVariable(1))
self.assertTrue(c.removeVariable(0))
self.assertFalse(c.removeVariable(0))
del c
# bool removeVariable(const std::string &name)
c = Component()
self.assertFalse(c.removeVariable(''))
v1 = Variable()
c.addVariable(v1)
self.assertTrue(c.removeVariable(''))
self.assertFalse(c.removeVariable(''))
name = 'blue'
v1.setName(name)
self.assertFalse(c.removeVariable(name))
c.addVariable(v1)
self.assertTrue(c.removeVariable(name))
self.assertFalse(c.removeVariable(name))
del [c, v1, name]
# bool removeVariable(const VariablePtr &variable)
c = Component()
v1 = Variable("second")
v2 = Variable("meter")
self.assertFalse(c.removeVariable(v1))
c.addVariable(v1)
self.assertFalse(c.removeVariable(v2))
self.assertTrue(c.removeVariable(v1))
self.assertFalse(c.removeVariable(v1))
</apply>"
# 1.e Include the MathML strings in the component
component.setMath(math_header)
component.appendMath(equation)
component.appendMath(math_footer)
# 1.f Create a validator and use it to check the model so far
validator = Validator()
validator.validateModel(model)
print_errors_to_terminal(validator)
# 1.g Create some variables and add them to the component
time = Variable()
time.setName("t")
component.addVariable(time)
distance = Variable()
distance.setName("x")
component.addVariable(distance)
# 1.e Assign units to the variables
time.setUnits("millisecond")
distance.setUnits("league")
# Check it work and print the validation errors to the terminal
print("-----------------------------------------------------")
print(" Printing the model at Step 1 ")
print("-----------------------------------------------------")
print_model_to_terminal(model)
def test_add_variable(self):
from libcellml import Component, Variable
c = Component()
v = Variable()
c.addVariable(v)
</apply>\
</apply>\
</apply>'
sodium_channel.setMath(math_header)
sodium_channel.appendMath(equation1)
sodium_channel.appendMath(equation2)
sodium_channel.appendMath(equation3)
sodium_channel.appendMath(math_footer)
# 1.c Add the variables
if True:
V = Variable()
V.setName("V")
V.setUnits("mV")
sodium_channel.addVariable(V)
t = Variable()
t.setName("t")
t.setUnits("ms")
sodium_channel.addVariable(t)
h = Variable()
h.setName("h")
h.setUnits("dimensionless")
sodium_channel.addVariable(h)
m = Variable()
m.setName("m")
m.setUnits("dimensionless")
sodium_channel.addVariable(m)
# end 3
print('----------------------------------------------------------')
print(' STEP 4: Add the variables ')
print('----------------------------------------------------------')
# The issues reported by the validator are related to the MathML string that we entered
# in Step 2 requiring variables which don't yet exist. These must be created, named,
# and added to their parent component.
# 4.a
# Create items for the missing variables and add them to the gateEquations component.
# You will need to be sure to give them names which match exactly those reported by the
# validator, or are present in the MathML string.
gateEquations.addVariable(Variable('t'))
gateEquations.addVariable(Variable('alpha_X'))
gateEquations.addVariable(Variable('beta_X'))
gateEquations.addVariable(Variable('X'))
# 4.b
# Validate again, and expect errors relating to missing units.
# Note that you can use the helper function print_issues(validator) to print your
# issues to the screen instead of repeating the code from 3.b.
validator.validateModel(model)
print_issues(validator)
# end 4
print('----------------------------------------------------------')
print(' STEP 5: Add the units ')
print("-----------------------------------------------")
print_encapsulation_structure_to_terminal(model)
# 5.a Creating the environment component and adding it to the model
environment = Component()
environment.setName("environment")
model.addComponent(environment)
# 5.b Add variables to the environment component.
if True:
V = Variable()
V.setName("V")
V.setInitialValue(-85)
V.setUnits("mV")
environment.addVariable(V)
t = Variable()
t.setName("t")
t.setUnits("ms")
environment.addVariable(t)
# 5.c Add the new component to the model and validate
validator.validateModel(model)
print_errors_to_terminal(validator)
print("\n-----------------------------------------------")
print(" STEP 6: Connect the equivalent variables")
print("-----------------------------------------------")
# 6.a Connecting the membrane to its sibling environment, and the channels to their
i_K.setUnits("microA_per_cm2")
# Note that no initial value is needed for this variable as its value is defined by equation2
g_K = Variable()
g_K.setName("g_K")
g_K.setUnits("milliS_per_cm2")
g_K.setInitialValue(36.0)
gamma = Variable()
gamma.setName("gamma")
gamma.setUnits("dimensionless")
gamma.setInitialValue(4.0)
# 3.c Adding the variables to the component. Note that Variables are
# added by their pointer (cf. their name)
component.addVariable(t)
component.addVariable(V)
component.addVariable(E_K)
component.addVariable(gamma)
component.addVariable(i_K)
component.addVariable(g_K)
component.addVariable(alpha_n)
component.addVariable(beta_n)
component.addVariable(n)
# 3.d Call the validator and print the messages to the terminal.
# Expected errors refer to units referred to by these variables, but
# which don't (yet) exist in the model.
validator.validateModel(model)
print_errors_to_terminal(validator)
# We can use these issues as we need to. The simplest way is to print the descriptions
# to the terminal.
# 2.d
# Retrieve the number of issues encountered using the validator.issueCount() function,
# then retrieve the issue items from the validator using their index and the validator.issue(index)
# function.
print('The validator has found {} issues.'.format(validator.issueCount()))
for i in range(0, validator.issueCount()):
print(validator.issue(i).description())
print()
# 2.e
# Create the variables needed and add them to the potassium channel component.
# Revalidate and expect errors related to variables without units.
k_channel_equations.addVariable(Variable('E_K'))
k_channel_equations.addVariable(Variable('i_K'))
k_channel_equations.addVariable(Variable('g_K'))
k_channel_equations.addVariable(Variable('V'))
k_channel_equations.addVariable(Variable('t'))
k_channel_equations.addVariable(Variable('n'))
validator.validateModel(model)
print_issues(validator)
# 2.f
# Create the missing Units items and add them to the model. These are:
# - milli-volts
# - milli-seconds
# - milli-moles
# - micro-Amperes per square centimetre
print(" Step 2: Create the variables ")
print("-------------------------------------------------------------")
# 2.a
# Create the variables listed by the validator: d, a, b, c, time, y_s, y_f.
sharks = Variable("y_s")
fish = Variable("y_f")
time = Variable("time")
a = Variable("a")
b = Variable("b")
c = Variable("c")
d = Variable("d")
# 2.b
# Add the variables into the component.
component.addVariable(sharks)
component.addVariable(fish)
component.addVariable(time)
component.addVariable(a)
component.addVariable(b)
component.addVariable(c)
component.addVariable(d)
# 2.c
# Call the validator again to check the model.
validator.validateModel(model)
print_issues(validator)
# end 2
print("-------------------------------------------------------------")
