CellMLToNektar.optimize.PartialEvaluator Class Reference

Partial Evaluation #. More...

Inheritance diagram for CellMLToNektar.optimize.PartialEvaluator:

Public Member Functions
def	is_instantiable (self, expr)
def	parteval (self, doc, solver_info, lookup_tables_analyser=None)

Public Attributes
	doc
	solver_info
	lookup_tables_analyser

Private Member Functions
def	_debug (self, *args)
def	_expr_lhs (self, expr)
def	_describe_expr (self, expr)
def	_process_ci_elts (self, elt, func)
def	_rename_var (self, elt)
def	_do_reduce_eval_loop (self, expr_source)
def	_reduce_evaluate_expression (self, expr)
def	_get_assignment_exprs (self, skip_solver_info=True)
def	_is_source_of (self, v1, v2)
def	_check_retargetting (self, ci_elt)

Detailed Description

Partial Evaluation #.

Perform partial evaluation of a CellML model.

Definition at line 57 of file optimize.py.

Member Function Documentation

_check_retargetting()

def CellMLToNektar.optimize.PartialEvaluator._check_retargetting (   self,   ci_elt  )

private

Check if this new variable reference means a retarget needs to change.

A retarget occurs when a kept dynamic mapped variable is changed to computed
because its source variable(s) are only used once and are not kept.  But new
mathematics may use one or more of those sources, in which case we need to
revert the retarget.

Definition at line 207 of file optimize.py.

    def _check_retargetting(self, ci_elt):
        """Check if this new variable reference means a retarget needs to change.
        
        A retarget occurs when a kept dynamic mapped variable is changed to computed
        because its source variable(s) are only used once and are not kept.  But new
        mathematics may use one or more of those sources, in which case we need to
        revert the retarget.
        """
        # Is this a retarget?
        var = ci_elt.variable
        root_defn = var.get_source_variable(recurse=True).get_dependencies()
        if root_defn:
            root_defn = root_defn[0]
        else:
            return
        if (isinstance(root_defn, mathml_apply)
             and hasattr(root_defn, '_pe_process')
             and root_defn._pe_process == 'retarget'):
            # Are we a source of the 'new' assignee?
            assignee = root_defn._cml_assigns_to
            if not self._is_source_of(assignee, var):
                if var.get_type() == VarTypes.Computed:
                    # We were the original source variable; stop retargetting
                    self._debug('Ceasing re-target of', root_defn, 'to', assignee)
                    del root_defn._pe_process
                    root_defn._cml_assigns_to = var
                else:
                    # Re-target to var instead
                    self._debug('Changing re-target of', root_defn, 'from', assignee, 'to', var)
                    var._cml_var_type = VarTypes.Computed
                    root_defn._cml_assigns_to = var
                    var._cml_depends_on = [root_defn]
                    var._cml_source_var = None
                # assignee should now map to var
                assignee._cml_var_type = VarTypes.Mapped
                assignee._cml_source_var = var
                assignee._cml_depends_on = [var]
    

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.optimize.PartialEvaluator._is_source_of().

_debug()

def CellMLToNektar.optimize.PartialEvaluator._debug (   self, *  args  )

private

Output debug info from the PE process.

Definition at line 59 of file optimize.py.

    def _debug(self, *args):
        """Output debug info from the PE process."""
        logger = logging.getLogger('partial-evaluator')
        logger.debug(' '.join(map(str, args)))
 

Referenced by CellMLToNektar.optimize.PartialEvaluator._check_retargetting(), CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop(), CellMLToNektar.optimize.PartialEvaluator._reduce_evaluate_expression(), CellMLToNektar.optimize.PartialEvaluator._rename_var(), CellMLToNektar.cellml_metadata.RdfProcessor.add_statement(), CellMLToNektar.cellml_metadata.RdfProcessor.find_variables(), CellMLToNektar.cellml_metadata.RdfProcessor.get_target(), CellMLToNektar.cellml_metadata.RdfProcessor.namespace_member(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_model(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_statements(), and CellMLToNektar.cellml_metadata.RdfProcessor.replace_statement().

_describe_expr()

def CellMLToNektar.optimize.PartialEvaluator._describe_expr (   self,   expr  )

private

Describe this expression for debug info.

Definition at line 72 of file optimize.py.

    def _describe_expr(self, expr):
        """Describe this expression for debug info."""
        if isinstance(expr, mathml_apply):
            if expr.is_assignment() or expr.is_ode():
                return self._expr_lhs(expr)
            else:
                return '[nested apply]'
        elif isinstance(expr, mathml_ci):
            return expr.variable.fullname()
        elif isinstance(expr, mathml_cn):
            return u'cn[' + unicode(expr) + u']'
        else:
            return '[unknown]'
        

References CellMLToNektar.optimize.PartialEvaluator._expr_lhs().

Referenced by CellMLToNektar.optimize.PartialEvaluator._reduce_evaluate_expression().

_do_reduce_eval_loop()

def CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop (   self,   expr_source  )

private

Do the reduce/evaluate loop.

expr_source is a callable that returns an iterable over expressions.

Definition at line 103 of file optimize.py.

    def _do_reduce_eval_loop(self, expr_source):
        """Do the reduce/evaluate loop.
        
        expr_source is a callable that returns an iterable over expressions.
        """
        while True:
            self.doc.model._pe_repeat = u'no'
            for expr in list(expr_source()):
                self._reduce_evaluate_expression(expr)
            if self.doc.model._pe_repeat == u'no':
                break
            self._debug("----- looping -----")
        del self.doc.model._pe_repeat
    

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), CellMLToNektar.optimize.PartialEvaluator._reduce_evaluate_expression(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, and CellMLToNektar.translators.ConfigurationStore.doc.

_expr_lhs()

def CellMLToNektar.optimize.PartialEvaluator._expr_lhs (   self,   expr  )

private

Display the LHS of this expression.

Definition at line 64 of file optimize.py.

    def _expr_lhs(self, expr):
        """Display the LHS of this expression."""
        lhs = expr.assigned_variable()
        if isinstance(lhs, cellml_variable):
            return lhs.fullname()
        else:
            return lhs[0].fullname() + u'/' + lhs[1].fullname()
        

Referenced by CellMLToNektar.optimize.PartialEvaluator._describe_expr().

_get_assignment_exprs()

def CellMLToNektar.optimize.PartialEvaluator._get_assignment_exprs (   self,   skip_solver_info = True  )

private

Get an iterable over all assignments in the model that are mathml_apply instances.

Definition at line 160 of file optimize.py.

    def _get_assignment_exprs(self, skip_solver_info=True):
        """Get an iterable over all assignments in the model that are mathml_apply instances."""
        if not skip_solver_info:
            skip = set()
        else:
            skip = set(self.solver_info.get_modifiable_mathematics())
        for e in self.doc.model.get_assignments():
            if isinstance(e, mathml_apply) and e not in skip:
                assert e.is_ode() or e.is_assignment()
                yield e
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.optimize.PartialEvaluator.solver_info, and CellMLToNektar.optimize.LookupTableAnalyser.solver_info.

_is_source_of()

def CellMLToNektar.optimize.PartialEvaluator._is_source_of (   self,   v1,   v2  )

private

Test if v1 is a source of the mapped variable v2.

Definition at line 198 of file optimize.py.

    def _is_source_of(self, v1, v2):
        """Test if v1 is a source of the mapped variable v2."""
        if v1 is v2:
            return True
        elif v2.get_type() == VarTypes.Mapped:
            return self._is_source_of(v1, v2.get_source_variable())
        else:
            return False
    

References CellMLToNektar.optimize.PartialEvaluator._is_source_of().

Referenced by CellMLToNektar.optimize.PartialEvaluator._check_retargetting(), and CellMLToNektar.optimize.PartialEvaluator._is_source_of().

_process_ci_elts()

def CellMLToNektar.optimize.PartialEvaluator._process_ci_elts (   self,   elt,   func  )

private

Apply func to all ci elements in the tree rooted at elt.

Definition at line 86 of file optimize.py.

    def _process_ci_elts(self, elt, func):
        """Apply func to all ci elements in the tree rooted at elt."""
        if isinstance(elt, mathml_ci):
            func(elt)
        else:
            for e in elt.xml_element_children():
                self._process_ci_elts(e, func)
    

References CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), and CellMLToNektar.translators.ConfigurationStore._process_ci_elts().

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), CellMLToNektar.translators.ConfigurationStore._process_ci_elts(), and CellMLToNektar.optimize.PartialEvaluator.is_instantiable().

_reduce_evaluate_expression()

def CellMLToNektar.optimize.PartialEvaluator._reduce_evaluate_expression (   self,   expr  )

private

Reduce or evaluate a single expression.

Definition at line 117 of file optimize.py.

    def _reduce_evaluate_expression(self, expr):
        """Reduce or evaluate a single expression."""
        if hasattr(expr, '_pe_process'):
            # This expression has been reduced or evaluated already, but needs further
            # processing later so hasn't been removed yet.
            return
        if expr._get_binding_time() is BINDING_TIMES.static:
            # Evaluate
            try:
                value = expr.evaluate() # Needed here for the is_assignment case
            except:
                print "Error evaluating", self._describe_expr(expr)
                raise
            self._debug("Evaluated", self._describe_expr(expr), "to", value)
            if isinstance(expr, mathml_apply):
                if expr.is_ode():
                    # Replace the RHS with a <cn> element giving the value
                    rhs = expr.eq.rhs
                    new_elt = expr._eval_self()
                    expr.xml_insert_after(rhs, new_elt)
                    expr.xml_remove_child(rhs)
                elif expr.is_assignment():
                    # The variable assigned to will have its initial_value set,
                    # so we don't need the expression any more.  Flag it for removal.
                    expr._pe_process = u'remove'
                else:
                    # Replace the expression with a <cn> element giving the value
                    new_elt = expr._eval_self()
                    expr.xml_parent.xml_insert_after(expr, new_elt)
                    expr.xml_parent.xml_remove_child(expr)
            else:
                # Replace the expression with a <cn> element giving the value
                expr._reduce()
            # Update variable usage counts for the top-level apply case
            if isinstance(expr, mathml_apply):
                if expr.is_ode() or expr.is_assignment():
                    expr._update_usage_counts(expr.eq.rhs, remove=True)
                else:
                    expr._update_usage_counts(expr, remove=True)
        else:
            # Reduce
            expr._reduce()
    

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.optimize.PartialEvaluator._describe_expr().

Referenced by CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop().

_rename_var()

def CellMLToNektar.optimize.PartialEvaluator._rename_var (   self,   elt  )

private

Change this ci element to use a canonical name.

Definition at line 94 of file optimize.py.

    def _rename_var(self, elt):
        """Change this ci element to use a canonical name."""
        if elt.xml_parent.localName == u'bvar':
            # The free variable in a derivative must refer directly to the ultimate source,
            # since this is assumed in later stages and in code generation.
            elt._set_variable_obj(elt.variable.get_source_variable(recurse=True))
        elt._rename()
        self._debug("Using canonical name", unicode(elt))
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), and CellMLToNektar.optimize.PartialEvaluator._debug().

is_instantiable()

def CellMLToNektar.optimize.PartialEvaluator.is_instantiable	(		self,
			expr
	)

Determine whether special conditions mean that this assignment can be instantiated.

Normally an assignment can only be instantiated if the assigned-to variable is used only
once, in order to avoid code duplication.
However, if the definition under consideration for instantiation is a function only of a
single LT keying variable (and we will do LT) then code duplication doesn't really matter,
since the whole expression will be converted to a table anyway.  So we should instantiate
regardless of multiple uses in this case.

Note: this does check that only a single keying variable appears, but doesn't check for
the presence of expensive functions.  Of course, if there aren't any expensive functions,
the code duplication isn't that worrying.

Definition at line 171 of file optimize.py.

    def is_instantiable(self, expr):
        """Determine whether special conditions mean that this assignment can be instantiated.
        
        Normally an assignment can only be instantiated if the assigned-to variable is used only
        once, in order to avoid code duplication.
        However, if the definition under consideration for instantiation is a function only of a
        single LT keying variable (and we will do LT) then code duplication doesn't really matter,
        since the whole expression will be converted to a table anyway.  So we should instantiate
        regardless of multiple uses in this case.
        
        Note: this does check that only a single keying variable appears, but doesn't check for
        the presence of expensive functions.  Of course, if there aren't any expensive functions,
        the code duplication isn't that worrying.
        """
        instantiate = False
        if self.lookup_tables_analyser and self.doc.model.get_option('pe_instantiate_tables'):
            keying_vars = set()
            all_keying = [True]
            def func(ci_elt):
                if self.lookup_tables_analyser.is_keying_var(ci_elt.variable):
                    keying_vars.add(ci_elt.variable)
                else:
                    all_keying[0] = False
            self._process_ci_elts(expr.eq.rhs, func)
            instantiate = len(keying_vars) == 1 and all_keying[0]
        return instantiate
    

References CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), CellMLToNektar.translators.ConfigurationStore._process_ci_elts(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, and CellMLToNektar.optimize.PartialEvaluator.lookup_tables_analyser.

parteval()

def CellMLToNektar.optimize.PartialEvaluator.parteval	(		self,
			doc,
			solver_info,
			lookup_tables_analyser = None
	)

Do the partial evaluation.

Definition at line 245 of file optimize.py.

    def parteval(self, doc, solver_info, lookup_tables_analyser=None):
        """Do the partial evaluation."""
        self.doc = doc
        self.solver_info = solver_info
        self.lookup_tables_analyser = lookup_tables_analyser
        if lookup_tables_analyser:
            lookup_tables_analyser.doc = doc
        doc.partial_evaluator = self
        # Do BTA and reduce/eval of main model
        doc.model.do_binding_time_analysis()
        self._do_reduce_eval_loop(self._get_assignment_exprs)
        
        if solver_info.has_modifiable_mathematics():
            # Do BTA and reduce/eval of solver info section
            for expr in solver_info.get_modifiable_mathematics():
                if not (isinstance(expr, mathml_apply) and expr.is_top_level()):
                    self._process_ci_elts(expr, lambda ci: ci.variable._used())
                self._process_ci_elts(expr, self._check_retargetting)
            solver_info.do_binding_time_analysis()
            self._do_reduce_eval_loop(solver_info.get_modifiable_mathematics)
        
        # Process flagged expressions
        for expr in list(self._get_assignment_exprs()):
            if hasattr(expr, '_pe_process'):
                if expr._pe_process == u'remove':
                    if (expr._get_binding_time() == BINDING_TIMES.dynamic and
                        isinstance(expr._cml_assigns_to, cellml_variable) and
                        expr._cml_assigns_to.get_usage_count() > 1):
                        self._debug("Keeping", repr(expr), "due to SolverInfo")
                        continue
                    expr.xml_parent.xml_remove_child(expr)
                    self.doc.model._remove_assignment(expr)
                elif expr._pe_process == u'retarget':
                    lhs = expr.eq.lhs
                    var = expr._cml_assigns_to
                    ci = mathml_ci.create_new(lhs, var.fullname(cellml=True))
                    self._debug('Re-targetting', lhs, var, ci)
                    ci._set_variable_obj(var)
                    lhs.xml_parent.xml_insert_after(lhs, ci)
                    lhs.xml_parent.xml_remove_child(lhs)
        
        # Use canonical variable names in all ci elements
        for expr in list(self._get_assignment_exprs(False)):
            # If the assigned-to variable isn't used or kept, remove the assignment
            if isinstance(expr.eq.lhs, mathml_ci):
                var = expr.eq.lhs.variable
                if not (var.get_usage_count() or var.pe_keep):
                    expr.xml_parent.xml_remove_child(expr)
                    doc.model._remove_assignment(expr)
                    continue
            self._process_ci_elts(expr, self._rename_var)
        for expr in solver_info.get_modifiable_mathematics():
            self._process_ci_elts(expr, self._rename_var)
        solver_info.use_canonical_variable_names()
 
        # Tidy up kept variables, in case they aren't referenced in an eq'n.
        for var in doc.model.get_all_variables():
            if var.pe_keep:
                var._reduce()
        
        # Remove unused variables
        for var in list(doc.model.get_all_variables()):
            assert var.get_usage_count() >= 0
            if var.get_usage_count() == 0 and not var.pe_keep:
                var.xml_parent._del_variable(var)
 
        # Collapse into a single component
        new_comp = cellml_component.create_new(doc, u'c')
        new_comp._cml_created_by_pe = True
        old_comps = list(getattr(doc.model, u'component', []))
        doc.model._add_component(new_comp)
        # We iterate over a copy of the component list so we can delete components
        # from the model in this loop, and so the new component exists in the model
        # so we can add content to it.
        for comp in old_comps:
            # Move relevant contents into new_comp
            for units in list(getattr(comp, u'units', [])):
                # Copy all <units> elements
                # TODO: Just generate the ones we need, using _ensure_units_exist
                comp.xml_remove_child(units)
                new_comp.xml_append(units)
            for var in list(getattr(comp, u'variable', [])):
                # Only move used source variables
                self._debug('Variable', var.fullname(), 'usage', var.get_usage_count(),
                           'type', var.get_type(), 'kept', var.pe_keep)
                if (var.get_usage_count() and var.get_type() != VarTypes.Mapped) or var.pe_keep:
                    self._debug('Moving variable', var.fullname(cellml=True))
                    # Remove from where it was
                    comp._del_variable(var, keep_annotations=True)
                    # Set name to canonical version
                    var.name = var.fullname(cellml=True)
                    # Place in new component
                    new_comp._add_variable(var)
            # Don't copy reactions
            for math in list(getattr(comp, u'math', [])):
                # Copy all <math> elements with content
                if math.xml_children:
                    comp.xml_remove_child(math)
                    new_comp.xml_append(math)
                    # Invalidate cached links
                    math._unset_cached_links()
            doc.model._del_component(comp)
        # Remove groups & connections
        for group in list(getattr(doc.model, u'group', [])):
            doc.model.xml_remove_child(group)
        for conn in list(getattr(doc.model, u'connection', [])):
            doc.model.xml_remove_child(conn)
 
        # Remove unused variable assignments from the list
        vs = [v for v in doc.model.get_assignments() if isinstance(v, cellml_variable)]
        for v in vs:
            if not v.xml_parent is new_comp:
                doc.model._remove_assignment(v)
 
        # Remove interface attributes from variables
        for v in new_comp.variable:
            for iface in [u'public', u'private']:
                try:
                    delattr(v, iface+u'_interface')
                except AttributeError:
                    pass
 
        # Refresh expression dependency lists
        for expr in self._get_assignment_exprs(False):
            expr._cml_depends_on = list(expr.vars_in(expr.eq.rhs))
            if expr.is_ode():
                # Add dependency on the independent variable
                indep_var = expr.eq.lhs.diff.independent_variable
                if not indep_var in expr._cml_depends_on:
                    expr._cml_depends_on.append(indep_var)
                # Update ODE definition dependency if needed
                expr.eq.lhs.diff.dependent_variable._update_ode_dependency(indep_var, expr)
        return
 
 

Member Data Documentation

doc

CellMLToNektar.optimize.PartialEvaluator.doc

Definition at line 247 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_duplicate_tables(), CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop(), CellMLToNektar.optimize.LookupTableAnalyser._find_tables(), CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.translators.ConfigurationStore._find_variable(), CellMLToNektar.optimize.PartialEvaluator._get_assignment_exprs(), CellMLToNektar.optimize.LookupTableAnalyser.analyse_model(), CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable(), CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.translators.ConfigurationStore.expose_variables(), CellMLToNektar.translators.ConfigurationStore.find_current_vars(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.get_stimulus_assignment(), CellMLToNektar.optimize.PartialEvaluator.is_instantiable(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.lut_parameters(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_derived_quantities(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_equations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_get_i_ionic(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_intracellular_calcium(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), CellMLToNektar.translators.CellMLTranslator.output_lut_declarations(), CellMLToNektar.translators.CellMLTranslator.output_lut_deletion(), CellMLToNektar.translators.CellMLTranslator.output_lut_generation(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_indices(), CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_memory(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_rush_larsen_mathematics(), CellMLToNektar.translators.CellMLTranslator.output_table_index_generation(), CellMLToNektar.translators.ConfigurationStore.read_configuration_file(), CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations(), CellMLToNektar.translators.CellMLTranslator.scan_for_lookup_tables(), and CellMLToNektar.translators.ConfigurationStore.validate_metadata().

lookup_tables_analyser

CellMLToNektar.optimize.PartialEvaluator.lookup_tables_analyser

Definition at line 249 of file optimize.py.

Referenced by CellMLToNektar.optimize.PartialEvaluator.is_instantiable().

solver_info

CellMLToNektar.optimize.PartialEvaluator.solver_info

Definition at line 248 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), CellMLToNektar.optimize.PartialEvaluator._get_assignment_exprs(), and CellMLToNektar.optimize.LookupTableAnalyser.is_allowed_variable().