CellMLToNektar.optimize.RushLarsenAnalyser Class Reference

Inheritance diagram for CellMLToNektar.optimize.RushLarsenAnalyser:

Collaboration diagram for CellMLToNektar.optimize.RushLarsenAnalyser:

Public Member Functions
def	__init__
def	analyse_model

Private Member Functions
def	_check_var

Private Attributes
	_var
	_conv
	_alpha
	_beta
	_ab_pattern
	_alt_ab_pattern
	_tau
	_inf
	_ti_pattern
	_alt_ti_pattern

Detailed Description

Analyse a model to identify Hodgkin-Huxley style gating variable equations.

We look for ODEs whose definition matches "alpha*(1-x) - beta*x" (where x is
the state variable, and alpha & beta are any expression).  Alternatively for
models which already have tau & inf variables, we match against "(inf-x)/tau".

To allow for when units conversions have been performed, we chase 'simple'
assignments and (the semantically equivalent) variable mappings until reaching
an 'interesting' defining equation.  We also need to allow the whole RHS to be
multiplied by a constant.  If this occurs, the constant conversion factor is
also stored; otherwise we store None.

Stores a dictionary on the document root mapping cellml_variable instances to
4-tuples.  The tuple is either ('ab', alpha, beta, conv) or ('ti', tau, inf, conv)
depending on which formulation has been used.  Note that the expressions in these
are not cloned copies - they are the original objects still embedded within the
relevant ODE.  The units conversion factor 'conv' is stored as a Python double.

Definition at line 1428 of file optimize.py.

Constructor & Destructor Documentation

def CellMLToNektar.optimize.RushLarsenAnalyser.__init__

(

self

)

Create the patterns to match against.

Definition at line 1447 of file optimize.py.

    def __init__(self):
        """Create the patterns to match against."""
        em = ExpressionMatcher
        self._var = em.V()
        self._conv = em.N()
        # Alpha/beta form
        self._alpha = em.X()
        self._beta = em.X()
        self._ab_pattern = em.R(em.A('minus', [em.A('times', [self._alpha,
                                                              em.A('minus', [em.N(1), self._var])]),
                                               em.A('times', [self._beta, self._var])]))
        self._alt_ab_pattern = em.R(em.A('times', [self._conv, self._ab_pattern]))
        # Tau/inf form
        self._tau = em.X()
        self._inf = em.X()
        self._ti_pattern = em.R(em.A('divide', [em.A('minus', [self._inf, self._var]),
                                                self._tau]))
        self._alt_ti_pattern = em.R(em.A('times', [self._conv, self._ti_pattern]))