# 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 = 0
sizeStates = 3
sizeConstants = 3
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 main (dimensionless)"
legend_states[0] = "x in component main (dimensionless)"
legend_states[1] = "y in component main (dimensionless)"
legend_states[2] = "z in component main (dimensionless)"
legend_constants[0] = "sigma in component main (dimensionless)"
legend_constants[1] = "rho in component main (dimensionless)"
legend_constants[2] = "beta in component main (dimensionless)"
legend_rates[0] = "d/dt x in component main (dimensionless)"
legend_rates[1] = "d/dt y in component main (dimensionless)"
legend_rates[2] = "d/dt z in component main (dimensionless)"
return (legend_states, legend_algebraic, legend_voi, legend_constants)

def initConsts():
constants = [0.0] * sizeConstants; states = [0.0] * sizeStates;
states[0] = 1
states[1] = 1
states[2] = 1
constants[0] = 10
constants[1] = 28
constants[2] = 2.66667
return (states, constants)

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

def computeAlgebraic(constants, states, voi):
algebraic = array([[0.0] * len(voi)] * sizeAlgebraic)
states = array(states)
voi = array(voi)
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 97073ce481e4.
This exposure was expired.
Collaboration
To begin collaborating on this work, please use your git client and issue this command: