docs: def build_expression_from_tree(self, runnable, regime, tree_node):
          """
          Recursively builds a Python expression from a parsed expression tree.
  
          @param runnable: Runnable object to which this expression would be added.
          @type runnable: lems.sim.runnable.Runnable
  
          @param regime: Dynamics regime being built.
          @type regime: lems.model.dynamics.Regime
  
          @param tree_node: Root node for the tree from which the expression
          is to be built.
          @type tree_node: lems.parser.expr.ExprNode
  
          @return: Generated Python expression.
          @rtype: string
          """
  
          component_type = self.model.component_types[runnable.component.type]
          dynamics = component_type.dynamics
          
          if tree_node.type == ExprNode.VALUE:
              if tree_node.value[0].isalpha():
                  if tree_node.value == 't':
                      return 'self.time_completed'
                  elif tree_node.value in component_type.requirements:
                      var_prefix = 'self'
                      v = tree_node.value
  
                      r = runnable
  
                      while (v not in r.instance_variables and
                             v not in r.derived_variables):
                          var_prefix = '{0}.{1}'.format(var_prefix, 'parent')
                          r = r.parent
                          if r == None:
                              raise SimBuildError("Unable to resolve required "
                                                  "variable '{0}'".format(v))
  
                      return '{0}.{1}'.format(var_prefix, v)
                  elif (tree_node.value in dynamics.derived_variables or (regime is not None and tree_node.value in regime.derived_variables)):
                      return 'self.{0}'.format(tree_node.value)
                  else:
                      return 'self.{0}_shadow'.format(tree_node.value)
              else:
                  return tree_node.value
          elif tree_node.type == ExprNode.FUNC1:
              pattern = '({0}({1}))'
              func = self.convert_func(tree_node.func)
              if 'random.uniform' in func:
                  pattern = '({0}(0,{1}))'
              return pattern.format(\
                  func,
                  self.build_expression_from_tree(runnable,
                                                  regime,
                                                  tree_node.param))
          else:
              return '({0}) {1} ({2})'.format(\
                  self.build_expression_from_tree(runnable,
                                                  regime,
                                                  tree_node.left),
                  self.convert_op(tree_node.op),
                  self.build_expression_from_tree(runnable,
                                                  regime,
                                                  tree_node.right))