Inheritance diagram for CellMLToNektar.optimize.RushLarsenAnalyser:

[legend]

Public Member Functions
def	__init__ (self)

def	analyse_model (self, doc)

Private Member Functions
def	_check_var (self, var, ode_expr, mapping)

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

◆ init()

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]))
    

Member Function Documentation

◆ _check_var()

def CellMLToNektar.optimize.RushLarsenAnalyser._check_var	(	self,
		var,
		ode_expr,
		mapping
	)

private

Definition at line 1479 of file optimize.py.

    def _check_var(self, var, ode_expr, mapping):
        rhs = ode_expr.eq.rhs
        self._var.set_variable(ode_expr.eq.lhs.diff.dependent_variable)
        if self._ab_pattern.match(rhs):
            mapping[var] = ('ab', self._alpha.matched, self._beta.matched, None)
        elif self._alt_ab_pattern.match(rhs):
            mapping[var] = ('ab', self._alpha.matched, self._beta.matched, self._conv.value)
        elif self._ti_pattern.match(rhs):
            mapping[var] = ('ti', self._tau.matched, self._inf.matched, None)
        elif self._alt_ti_pattern.match(rhs):
            mapping[var] = ('ti', self._tau.matched, self._inf.matched, self._conv.value)

Referenced by CellMLToNektar.optimize.RushLarsenAnalyser.analyse_model().

◆ analyse_model()

def CellMLToNektar.optimize.RushLarsenAnalyser.analyse_model	(	self,
		doc
	)

Definition at line 1466 of file optimize.py.

    def analyse_model(self, doc):
        # First, find linear ODEs that have the potential to be gating variables
        la = LinearityAnalyser()
        V = doc._cml_config.V_variable
        state_vars = doc.model.find_state_vars()
        free_var = doc.model.find_free_vars()[0]
        linear_vars = la.find_linear_odes(state_vars, V, free_var)
        # Next, check they match dn/dt = a (1-n) - b n
        doc._cml_rush_larsen = {}
        for var in linear_vars:
            ode_expr = var.get_ode_dependency(free_var)
            self._check_var(var, ode_expr, doc._cml_rush_larsen)
    