# Generated Code

The following is python code generated by the CellML API from this CellML file. (Back to language selection)

The raw code is available.

```# Size of variable arrays:
sizeAlgebraic = 1
sizeStates = 1
sizeConstants = 6
from math import *
from numpy import *

def createLegends():
legend_states = [""] * sizeStates
legend_rates = [""] * sizeStates
legend_algebraic = [""] * sizeAlgebraic
legend_voi = ""
legend_constants = [""] * sizeConstants
legend_voi = "t in component y_channel (millisecond)"
legend_states[0] = "y in component y_channel (dimensionless)"
legend_constants[0] = "V in component y_channel (millivolt)"
legend_constants[1] = "E_y in component y_channel (millivolt)"
legend_algebraic[0] = "i_y in component y_channel (microA_per_cm2)"
legend_constants[2] = "g_y in component y_channel (milliS_per_cm2)"
legend_constants[3] = "gamma in component y_channel (dimensionless)"
legend_constants[4] = "alpha_y in component y_channel (per_millisecond)"
legend_constants[5] = "beta_y in component y_channel (per_millisecond)"
legend_rates[0] = "d/dt y in component y_channel (dimensionless)"
return (legend_states, legend_algebraic, legend_voi, legend_constants)

def initConsts():
constants = [0.0] * sizeConstants; states = [0.0] * sizeStates;
states[0] = 0
constants[0] = 0
constants[1] = -85
constants[2] = 36
constants[3] = 4
constants[4] = 1
constants[5] = 2
return (states, constants)

def computeRates(voi, states, constants):
rates = [0.0] * sizeStates; algebraic = [0.0] * sizeAlgebraic
rates[0] = constants[4]*(1.00000-states[0])-constants[5]*states[0]
return(rates)

def computeAlgebraic(constants, states, voi):
algebraic = array([[0.0] * len(voi)] * sizeAlgebraic)
states = array(states)
voi = array(voi)
algebraic[0] = constants[2]*(power(states[0], constants[3]))*(constants[0]-constants[1])
return algebraic

def solve_model():
"""Solve model with ODE solver"""
from scipy.integrate import ode
# Initialise constants and state variables
(init_states, constants) = initConsts()

# Set timespan to solve over
voi = linspace(0, 10, 500)

# Construct ODE object to solve
r = ode(computeRates)
r.set_integrator('vode', method='bdf', atol=1e-06, rtol=1e-06, max_step=1)
r.set_initial_value(init_states, voi[0])
r.set_f_params(constants)

# Solve model
states = array([[0.0] * len(voi)] * sizeStates)
states[:,0] = init_states
for (i,t) in enumerate(voi[1:]):
if r.successful():
r.integrate(t)
states[:,i+1] = r.y
else:
break

# Compute algebraic variables
algebraic = computeAlgebraic(constants, states, voi)
return (voi, states, algebraic)

def plot_model(voi, states, algebraic):
"""Plot variables against variable of integration"""
import pylab
(legend_states, legend_algebraic, legend_voi, legend_constants) = createLegends()
pylab.figure(1)
pylab.plot(voi,vstack((states,algebraic)).T)
pylab.xlabel(legend_voi)
pylab.legend(legend_states + legend_algebraic, loc='best')
pylab.show()

if __name__ == "__main__":
(voi, states, algebraic) = solve_model()
plot_model(voi, states, algebraic)
```
Source
Derived from workspace Models for the OpenCOR and PMR tutorial by Peter Hunter at changeset 1368c1579b75.
This exposure was expired.
Collaboration
To begin collaborating on this work, please use your git client and issue this command: