def __init__(self, name, value, dimension = None, description = ''):
"""
Constructor.
See instance variable documentation for more info on derived parameters.
"""
self.name = name
""" Name of the derived parameter.
@type: str """
self.dimension = dimension
""" Physical dimensions of the derived parameter.
@type: str """
self.value = value
""" Value of the derived parameter.
@type: str """
self.description = description
""" Description of the derived parameter.
@type: str """
try:
ep = ExprParser(self.value)
self.expression_tree = ep.parse()
except:
raise ParseError("Parse error when parsing value expression "
"'{0}' for derived parameter {1}",
self.value, self.name)
def __init__(self, name, value, dimension=None, description=''):
"""
Constructor.
See instance variable documentation for more info on derived parameters.
"""
self.name = name
""" Name of the derived parameter.
@type: str """
self.dimension = dimension
""" Physical dimensions of the derived parameter.
@type: str """
self.value = value
""" Value of the derived parameter.
@type: str """
self.description = description
""" Description of the derived parameter.
@type: str """
try:
ep = ExprParser(self.value)
self.expression_tree = ep.parse()
except:
raise ParseError(
"Parse error when parsing value expression "
"'{0}' for derived parameter {1}", self.value, self.name)
def __init__(self, condition, value):
"""
Constructor.
"""
self.condition = condition
""" Condition for this case.
@type: str """
self.value = value
""" Value if the condition is true.
@type: str """
self.condition_expression_tree = None
""" Parse tree for the case condition expression.
@type: lems.parser.expr.ExprNode """
self.value_expression_tree = None
""" Parse tree for the case condition expression.
@type: lems.parser.expr.ExprNode """
try:
self.value_expression_tree = ExprParser(self.value).parse()
if not self.condition:
self.condition_expression_tree = None
else:
self.condition_expression_tree = ExprParser(self.condition).parse()
except:
raise ParseError("Parse error when parsing case with condition "
"'{0}' and value {1}",
self.condition, self.value)
def __init__(self, variable, value):
"""
Constructor.
See instance variable documentation for more info on parameters.
"""
Action.__init__(self)
self.variable = variable
""" Name of the variable for which the time derivative is being specified.
@type: str """
self.value = value
""" Derivative expression.
@type: str """
self.expression_tree = None
""" Parse tree for the time derivative expression.
@type: lems.parser.expr.ExprNode """
try:
self.expression_tree = ExprParser(value).parse()
except:
raise ParseError("Parse error when parsing state assignment "
"value expression "
"'{0}' for state variable {1}",
self.value, self.variable)
def __init__(self, variable, value):
"""
Constructor.
@param variable: Name of the state variable
@type variable: string
@param value: Time derivative expression of the given state variable.
@type value: string
"""
self.variable = variable
""" State variable whose time derivative is stored in this object.
@type: string """
self.value = value
""" Time derivative expression for the state variable.
@type: string """
try:
self.expression_tree = ExprParser(value).parse()
""" Parse tree for the time derivative expression.
@type: lems.parser.expr.ExprNode """
except:
raise ParseError("Parse error when parsing value expression "
"'{0}' for derived variable {1}".format(\
self.value,
self.variable))
def parse_expr(self, expr, val, should_fail=False):
print('\n--- Parsing %s, checking against %s' % (expr, val))
ep = ExprParser(expr)
try:
pt = ep.parse()
print("Expr: %s " % expr)
print("Parsed as: %s " % (str(pt)))
print("Expected : %s " % (val))
print("Math : %s " % (pt.to_python_expr()))
assert str(pt) == val
print("Success")
except Exception as e:
if not should_fail:
print("Exception thrown %s" % e)
assert 1 == 2
else:
print("Successfully failed")
def parse_expr(self, expr, val, should_fail=False):
print('\n--- Parsing %s, checking against %s'%(expr, val))
ep = ExprParser(expr)
try:
pt = ep.parse()
print("Expr: %s "%expr)
print("Parsed as: %s "%(str(pt)))
print("Expected : %s "%(val))
print("Math : %s "%(pt.to_python_expr()))
assert str(pt) == val
print("Success")
except Exception as e:
if not should_fail:
print("Exception thrown %s"%e)
assert 1==2
else:
print("Successfully failed")
def __init__(self, name, **params):
"""
Constructor.
See instance variable documentation for more info on parameters.
"""
self.name = name
""" Name of the derived variable.
@type: str """
self.dimension = params['dimension'] if 'dimension' in params else None
""" Dimension of the derived variable or None if computed.
@type: str """
self.exposure = params['exposure'] if 'exposure' in params else None
""" Exposure name for the derived variable.
@type: str """
self.select = params['select'] if 'select' in params else None
""" Selection path/expression for the derived variable.
@type: str """
self.expression = params[
'expression'] if 'expression' in params else None
""" Value of the derived variable.
@type: str """
self.reduce = params['reduce'] if 'reduce' in params else None
""" Reduce method for the derived variable.
@type: str """
self.required = params['required'] if 'required' in params else None
""" Requried or not.
@type: str """
self.expression_tree = None
""" Parse tree for the time derivative expression.
@type: lems.parser.expr.ExprNode """
if self.expression != None:
try:
self.expression_tree = ExprParser(self.expression).parse()
except:
raise ParseError(
"Parse error when parsing value expression "
"'{0}' for derived variable {1}", self.expression,
self.name)
def __init__(self, test):
"""
Constructor.
@param test: Test expression.
@type test: string
"""
EventHandler.__init__(self, EventHandler.ON_CONDITION)
self.test = test
""" Test expression.
@type: string """
self.expression_tree = ExprParser(test).parse()
""" Parse tree for the test expression.
def __init__(self, test):
"""
Constructor.
See instance variable documentation for more details on parameters.
"""
EventHandler.__init__(self)
self.test = test
""" Condition to be tested for.
@type: str """
try:
self.expression_tree = ExprParser(test).parse()
except:
raise ParseError("Parse error when parsing OnCondition test '{0}'", test)
def __init__(self, variable, value):
"""
Constructor.
@param variable: Name of the state variable
@type variable: string
@param value: Assignment expression of the given state variable.
@type value: string
"""
Action.__init__(self, Action.STATE_ASSIGNMENT)
self.variable = variable
""" State variable whose assignment expression is stored in this
object.
@type: string """
self.value = value
""" Assignment expression for the state variable.
@type: string """
self.expression_tree = ExprParser(value).parse()
""" Parse tree for the assignment expression.
def __init__(self, name, exposure, dimension, value, select, reduce):
"""
Constructor.
@param name: Name (internal) of the derived variable.
@type name: string
@param exposure: Name (external) of the derived variable.
@type exposure: string
@param dimension: Dimension of the derived variable.
@type dimension: string
@param value: Value expression for the derived variable.
@type value: string
@param select: Target component selection for reduction operations.
@type select: string
@param reduce: Reduce operation.
@type reduce: string
"""
self.name = name
""" Internal name of the derived variable. This is the name used to
refer to this variable inside the <Behavior> element.
@type: string """
self.exposure = exposure
""" Exposure name of the derived variable. This is the name used to
refer to this variable from other objects.
@type: string """
self.dimension = dimension
""" Dimension of this derived variable.
@type: string """
self.value = value
""" Expression used for computing the value of the derived variable.
@type: string """
self.select = select
""" Selected target object for the reduce operation.
@type: string """
self.reduce = reduce
""" Reduce operation to be applied over the selected target.
@type: string """
if value != None:
try:
self.expression_tree = ExprParser(value).parse()
""" Parse tree for the time derivative expression.
@type: lems.parser.expr.ExprNode """
except:
raise ParseError("Parse error when parsing value expression "
"'{0}' for derived variable {1}".format(\
self.value,
self.name))
else:
self.expression_tree = None
