picurv_cli.source_expressions Namespace Reference

Data Structures
class	_LogicalRewriter
	Rewrite logical operators and chained comparisons into array operations. More...

Functions
None	validate_expression (str expression, names=EULERIAN_EXPRESSION_NAMES, random=False)
	Reject anything outside the expression language the runtime also evaluates.
int	_series_bound (node)
	The integer a series bound denotes: an integer literal, possibly negated.
None	_check_expression_node (node, names, indices, random)
	Check one node of a parsed expression, with the series indices enclosing it in scope.
None	_validate_expression (str expression)
	Reject Eulerian expression syntax outside the supported language.
	_solver_only (str name)
	A stand-in for a function only the runtime evaluates.
	evaluate_values (str expression, dict values)
	Evaluate an already validated expression over named arrays or scalars.
str	_number_text (value, dict params, str where)
	Render one numeric region parameter, which may name a declared parameter.
str	_region_distance (dict region, dict params, str where)
	Signed distance to a region's boundary, negative inside, as expression text.
str	_substitute_params (str expression, dict params)
	Replace declared parameter names in an expression by their values.
	_validate_at (str expression, names, bool random, str where)
	Validate an expression written in a configuration value, naming where it is.
str	lower_value (spec, names=PARTICLE_EXPRESSION_NAMES, random=True, where="value")
	Turn a field value - number, expression, or structured regions - into one expression.

Variables
dict	ALLOWED_FUNCTIONS
dict	FUNCTION_ARITY
tuple	SOLVER_ONLY_FUNCTIONS = ("besselj", "bessely", "ber", "bei")
int	MAX_SERIES_TERMS = 1000000
int	MAX_SERIES_DEPTH = 4
tuple	RANDOM_FUNCTIONS = ("uniform", "normal")
	EULERIAN_EXPRESSION_NAMES = frozenset({"x", "y", "z", "xi", "eta", "zeta", "i", "j", "k"})
	PARTICLE_EXPRESSION_NAMES = frozenset({"x", "y", "z", "t", "xi", "eta", "zeta", "L_xi", "L_eta", "L_zeta", "pid"})
	ALLOWED_NAMES = set(ALLOWED_FUNCTIONS) | EULERIAN_EXPRESSION_NAMES | {"pi"}
	_DECIMAL_LITERAL = re.compile(r"^(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$")
tuple	ALLOWED_AST_NODES
tuple	REGION_SHAPES = ("half_space", "slab", "box", "ball", "cylinder")
dict	EDGE_PROFILES
dict	_REGION_KEYS
tuple	_AXES = ("x", "y", "z")

Function Documentation

validate_expression()

None picurv_cli.source_expressions.validate_expression	(	str	expression,
			names = EULERIAN_EXPRESSION_NAMES,
			random = False
	)

Reject anything outside the expression language the runtime also evaluates.

Python expression syntax restricted to decimal numbers, the given names, pi, arithmetic, comparisons (chains included), and/or/not, and the documented functions at their fixed arities. uniform(n)/normal(n) are accepted only when random is true, with an optional stream n that must be a non-negative integer literal.

Parameters

[in]	expression	User expression.
[in]	names	Variables in scope, besides pi.
[in]	random	Whether per-particle random draws may be called.

Exceptions

ValueError

naming the first construct outside the language.

Definition at line 92 of file source_expressions.py.

def validate_expression(expression: str, names=EULERIAN_EXPRESSION_NAMES, random=False) -> None:
    """!
    @brief Reject anything outside the expression language the runtime also evaluates.
    @details Python expression syntax restricted to decimal numbers, the given names, `pi`,
             arithmetic, comparisons (chains included), `and`/`or`/`not`, and the
             documented functions at their fixed arities. `uniform(n)`/`normal(n)` are
             accepted only when @p random is true, with an optional stream `n` that must be
             a non-negative integer literal.
    @param[in] expression User expression.
    @param[in] names Variables in scope, besides `pi`.
    @param[in] random Whether per-particle random draws may be called.
    @throws ValueError naming the first construct outside the language.
    """
    if not isinstance(expression, str) or not expression.strip():
        raise ValueError("an expression must be a non-empty string.")
    if "\n" in expression or "\r" in expression:
        raise ValueError("an expression must fit on one line.")
    try:
        tree = ast.parse(expression, mode="eval")
        tokens = list(tokenize.generate_tokens(io.StringIO(expression).readline))
    except (SyntaxError, tokenize.TokenError) as exc:
        raise ValueError(f"expression '{expression}' is not valid syntax: {exc}.") from exc
    for token in tokens:
        if token.type == tokenize.NUMBER and not _DECIMAL_LITERAL.match(token.string):
            raise ValueError(f"'{token.string}' is not a decimal number; write numbers like 1, 0.5, or 2e-3.")
    _check_expression_node(tree.body, frozenset(names) | {"pi"}, (), random)
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

_series_bound()

int picurv_cli.source_expressions._series_bound (   node )

protected

The integer a series bound denotes: an integer literal, possibly negated.

Parameters

[in]

node

Bound node.

Returns

The bound.

Exceptions

ValueError

for anything else.

Definition at line 120 of file source_expressions.py.

def _series_bound(node) -> int:
    """!
    @brief The integer a series bound denotes: an integer literal, possibly negated.
    @param[in] node Bound node.
    @return The bound.
    @throws ValueError for anything else.
    """
    sign = 1
    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
        sign, node = (-1 if isinstance(node.op, ast.USub) else 1), node.operand
    if (not isinstance(node, ast.Constant) or type(node.value) not in (int, float)
            or node.value != int(node.value)):
        raise ValueError("series bounds must be integer numbers.")
    return sign * int(node.value)
 
 

Here is the caller graph for this function:

_check_expression_node()

None picurv_cli.source_expressions._check_expression_node (   node,   names,   indices,   random  )

protected

Check one node of a parsed expression, with the series indices enclosing it in scope.

Parameters

[in]	node	AST node.
[in]	names	Variables in scope, pi included.
[in]	indices	Indices of the enclosing series, outermost first.
[in]	random	Whether per-particle random draws may be called.

Exceptions

ValueError

naming the first construct outside the language.

Definition at line 136 of file source_expressions.py.

def _check_expression_node(node, names, indices, random) -> None:
    """!
    @brief Check one node of a parsed expression, with the series indices enclosing it in scope.
    @param[in] node AST node.
    @param[in] names Variables in scope, `pi` included.
    @param[in] indices Indices of the enclosing series, outermost first.
    @param[in] random Whether per-particle random draws may be called.
    @throws ValueError naming the first construct outside the language.
    """
    if not isinstance(node, ALLOWED_AST_NODES):
        raise ValueError(f"unsupported expression syntax: {type(node).__name__}.")
    if isinstance(node, ast.Constant) and type(node.value) not in (int, float):
        raise ValueError(f"only numbers may appear as constants, not {node.value!r}.")
    if isinstance(node, ast.Name):
        if node.id not in names and node.id not in indices:
            raise ValueError(f"unsupported expression name '{node.id}'.")
        return
    if isinstance(node, ast.Call):
        name = node.func.id if isinstance(node.func, ast.Name) else None
        if node.keywords:
            raise ValueError("functions take positional arguments only.")
        if name in RANDOM_FUNCTIONS and random:
            if len(node.args) > 1:
                raise ValueError(f"{name}() takes at most one stream argument.")
            if node.args:
                stream = node.args[0]
                if (not isinstance(stream, ast.Constant) or type(stream.value) not in (int, float)
                        or stream.value < 0 or stream.value != int(stream.value)):
                    raise ValueError(f"the stream of {name}() must be a non-negative integer literal.")
            return
        if name not in FUNCTION_ARITY:
            raise ValueError(f"'{name}' is not an available function.")
        if len(node.args) != FUNCTION_ARITY[name]:
            raise ValueError(f"{name}() takes {FUNCTION_ARITY[name]} argument(s).")
        if name == "sum":
            index, lower, upper, body = node.args
            if not isinstance(index, ast.Name):
                raise ValueError("a series sum(k, lo, hi, body) needs an index name first.")
            if index.id in names or index.id in indices:
                raise ValueError(f"the series index '{index.id}' reuses a name already in scope.")
            if len(indices) == MAX_SERIES_DEPTH:
                raise ValueError(f"series may nest at most {MAX_SERIES_DEPTH} deep.")
            if _series_bound(upper) - _series_bound(lower) + 1 > MAX_SERIES_TERMS:
                raise ValueError(f"a series may add at most {MAX_SERIES_TERMS} terms.")
            _check_expression_node(body, names, indices + (index.id,), random)
            return
        for argument in node.args:
            _check_expression_node(argument, names, indices, random)
        return
    for child in ast.iter_child_nodes(node):
        _check_expression_node(child, names, indices, random)
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

_validate_expression()

None picurv_cli.source_expressions._validate_expression ( str  expression )

protected

Reject Eulerian expression syntax outside the supported language.

Parameters

[in]

expression

User expression.

Definition at line 189 of file source_expressions.py.

def _validate_expression(expression: str) -> None:
    """!
    @brief Reject Eulerian expression syntax outside the supported language.
    @param[in] expression User expression.
    """
    validate_expression(expression, EULERIAN_EXPRESSION_NAMES, random=False)
 
 

Here is the call graph for this function:

_solver_only()

picurv_cli.source_expressions._solver_only ( str  name )

protected

A stand-in for a function only the runtime evaluates.

Parameters

[in]

name

Function name.

Returns

Callable that refuses evaluation.

Definition at line 272 of file source_expressions.py.

def _solver_only(name: str):
    """!
    @brief A stand-in for a function only the runtime evaluates.
    @param[in] name Function name.
    @return Callable that refuses evaluation.
    """
    def refuse(*arguments):
        """!
        @brief Refuse to evaluate, naming the function and where it can be used.
        @param[in] arguments The call's arguments, unused.
        @throws ValueError always.
        """
        del arguments
        raise ValueError(f"{name}() is evaluated only by the solver; use it in a velocity source, "
                         "not in an expression picurv evaluates before launch.")
    return refuse
 
 

Here is the caller graph for this function:

evaluate_values()

picurv_cli.source_expressions.evaluate_values	(	str	expression,
		dict	values
	)

Evaluate an already validated expression over named arrays or scalars.

Parameters

[in]	expression	Expression text.
[in]	values	Mapping of variable name to value or array.

Returns

Result as a float array, not yet checked for finiteness.

Definition at line 290 of file source_expressions.py.

def evaluate_values(expression: str, values: dict):
    """!
    @brief Evaluate an already validated expression over named arrays or scalars.
    @param[in] expression Expression text.
    @param[in] values Mapping of variable name to value or array.
    @return Result as a float array, not yet checked for finiteness.
    """
    tree = ast.fix_missing_locations(_LogicalRewriter().visit(ast.parse(expression, mode="eval")))
    env = dict(ALLOWED_FUNCTIONS)
    env.update({"logical_and": np.logical_and, "logical_or": np.logical_or,
                "logical_not": np.logical_not, "pi": math.pi,
                "series": lambda body, lo, hi: sum((body(k) for k in range(int(lo), int(hi) + 1)), 0.0)})
    for name in SOLVER_ONLY_FUNCTIONS:
        env[name] = _solver_only(name)
    env.update(values)
    with np.errstate(all="ignore"):
        # Globals, not locals: a series body is a lambda, which sees only the globals.
        value = eval(compile(tree, "<ic-expression>", "eval"), dict(env, __builtins__={}))
    return np.asarray(value, dtype=float)
 
 
#: Region shapes a structured field value may paint, later regions over earlier ones.

Here is the call graph for this function:

_number_text()

str picurv_cli.source_expressions._number_text (   value, dict  params, str  where  )

protected

Render one numeric region parameter, which may name a declared parameter.

Parameters

[in]	value	Number, or the name of a parameter.
[in]	params	Declared parameters.
[in]	where	Configuration path, for diagnostics.

Returns

Parenthesized numeric text.

Definition at line 329 of file source_expressions.py.

def _number_text(value, params: dict, where: str) -> str:
    """!
    @brief Render one numeric region parameter, which may name a declared parameter.
    @param[in] value Number, or the name of a parameter.
    @param[in] params Declared parameters.
    @param[in] where Configuration path, for diagnostics.
    @return Parenthesized numeric text.
    """
    if isinstance(value, str) and value in params:
        return repr(float(params[value]))
    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
        raise ValueError(f"{where} must be a finite number or a declared parameter name.")
    return repr(float(value))
 
 

Here is the caller graph for this function:

_region_distance()

str picurv_cli.source_expressions._region_distance ( dict  region, dict  params, str  where  )

protected

Signed distance to a region's boundary, negative inside, as expression text.

Parameters

[in]	region	Region mapping.
[in]	params	Declared parameters.
[in]	where	Configuration path, for diagnostics.

Returns

Expression text for the signed distance.

Definition at line 344 of file source_expressions.py.

def _region_distance(region: dict, params: dict, where: str) -> str:
    """!
    @brief Signed distance to a region's boundary, negative inside, as expression text.
    @param[in] region Region mapping.
    @param[in] params Declared parameters.
    @param[in] where Configuration path, for diagnostics.
    @return Expression text for the signed distance.
    """
    shape = region.get("shape")
    if shape not in REGION_SHAPES:
        raise ValueError(f"{where}.shape must be one of {', '.join(REGION_SHAPES)}.")
    extra = set(region) - _REGION_KEYS[shape] - {"shape", "value", "edge"}
    missing = _REGION_KEYS[shape] - set(region) - ({"side"} if shape == "half_space" else set())
    if extra or missing:
        raise ValueError(f"{where} ({shape}) takes {sorted(_REGION_KEYS[shape])}, plus value and edge.")
 
    def num(key, value=None):
        """!
        @brief Render a region number (a literal or a `params` name) as expression text.
        @param[in] key Region key, for diagnostics and as the default source of the number.
        @param[in] value Number to render in place of `region[key]`, if given.
        @return Expression text of the number.
        """
        return _number_text(region[key] if value is None else value, params, f"{where}.{key}")
 
    def axis_of(key="axis"):
        """!
        @brief Return the region's axis name, refusing anything but x, y, z.
        @param[in] key Region key holding the axis.
        @return Axis name.
        """
        axis = region.get(key)
        if axis not in _AXES:
            raise ValueError(f"{where}.{key} must be x, y, or z.")
        return axis
 
    def triple(key):
        """!
        @brief Render a three-coordinate region entry as a list of expression texts.
        @param[in] key Region key holding the three coordinates.
        @return List of three expression texts.
        """
        values = region.get(key)
        if not isinstance(values, list) or len(values) != 3:
            raise ValueError(f"{where}.{key} must be a list of three coordinates.")
        return [num(key, v) for v in values]
 
    if shape == "half_space":
        axis, side = axis_of(), region.get("side", "above")
        if side not in ("above", "below"):
            raise ValueError(f"{where}.side must be above or below.")
        return f"({num('at')} - {axis})" if side == "above" else f"({axis} - {num('at')})"
    if shape == "slab":
        axis = axis_of()
        return f"maximum({num('from')} - {axis}, {axis} - {num('to')})"
    if shape == "box":
        lower, upper = triple("min"), triple("max")
        terms = [f"maximum({lo} - {a}, {a} - {hi})" for a, lo, hi in zip(_AXES, lower, upper)]
        return f"maximum(maximum({terms[0]}, {terms[1]}), {terms[2]})"
    if shape == "ball":
        center = triple("center")
        return (f"sqrt(({_AXES[0]} - {center[0]})**2 + ({_AXES[1]} - {center[1]})**2 + "
                f"({_AXES[2]} - {center[2]})**2) - {num('radius')}")
    axis = axis_of()
    others = [a for a in _AXES if a != axis]
    center = region.get("center")
    if not isinstance(center, list) or len(center) != 2:
        raise ValueError(f"{where}.center must list the two coordinates across the axis ({', '.join(others)}).")
    c0, c1 = (num("center", v) for v in center)
    return f"sqrt(({others[0]} - {c0})**2 + ({others[1]} - {c1})**2) - {num('radius')}"
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

_substitute_params()

str picurv_cli.source_expressions._substitute_params ( str  expression, dict  params  )

protected

Replace declared parameter names in an expression by their values.

Parameters

[in]	expression	Expression text.
[in]	params	Declared parameters.

Returns

Expression text with parameters inlined.

Definition at line 416 of file source_expressions.py.

def _substitute_params(expression: str, params: dict) -> str:
    """!
    @brief Replace declared parameter names in an expression by their values.
    @param[in] expression Expression text.
    @param[in] params Declared parameters.
    @return Expression text with parameters inlined.
    """
    pieces, cursor = [], 0
    for token in tokenize.generate_tokens(io.StringIO(expression).readline):
        if token.type == tokenize.NAME and token.string in params:
            start, end = token.start[1], token.end[1]
            pieces.append(expression[cursor:start])
            pieces.append(f"({float(params[token.string])!r})")
            cursor = end
    pieces.append(expression[cursor:])
    return "".join(pieces)
 
 

_validate_at()

picurv_cli.source_expressions._validate_at ( str  expression,   names, bool  random, str  where  )

protected

Validate an expression written in a configuration value, naming where it is.

Parameters

[in]	expression	Expression text.
[in]	names	Variables the expression may use.
[in]	random	Whether random draws are allowed.
[in]	where	Configuration path of the value.

Exceptions

ValueError

naming where if the expression is outside the language.

Definition at line 434 of file source_expressions.py.

def _validate_at(expression: str, names, random: bool, where: str):
    """!
    @brief Validate an expression written in a configuration value, naming where it is.
    @param[in] expression Expression text.
    @param[in] names Variables the expression may use.
    @param[in] random Whether random draws are allowed.
    @param[in] where Configuration path of the value.
    @throws ValueError naming `where` if the expression is outside the language.
    """
    try:
        validate_expression(expression, names, random)
    except ValueError as e:
        raise ValueError(f"{where}: {e}") from None
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

lower_value()

str picurv_cli.source_expressions.lower_value	(		spec,
			names = PARTICLE_EXPRESSION_NAMES,
			random = True,
			where = "value"
	)

Turn a field value - number, expression, or structured regions - into one expression.

A mapping may declare params (named numbers usable in its expressions and region parameters) and gives either value or background with regions. Regions paint in order, a later region over an earlier one: a sharp region by where(d <= 0, v, before), a smoothed one by before*(1 - s) + v*s, with d the signed distance to the region and s its edge profile over edge.width. The result is validated like any expression.

Parameters

[in]	spec	Number, expression string, or mapping.
[in]	names	Variables in scope.
[in]	random	Whether random draws may be called.
[in]	where	Configuration path, for diagnostics.

Returns

Validated expression text.

Definition at line 449 of file source_expressions.py.

def lower_value(spec, names=PARTICLE_EXPRESSION_NAMES, random=True, where="value") -> str:
    """!
    @brief Turn a field value - number, expression, or structured regions - into one expression.
    @details A mapping may declare `params` (named numbers usable in its expressions and
             region parameters) and gives either `value` or `background` with `regions`.
             Regions paint in order, a later region over an earlier one: a sharp region by
             `where(d <= 0, v, before)`, a smoothed one by `before*(1 - s) + v*s`, with `d`
             the signed distance to the region and `s` its edge profile over `edge.width`.
             The result is validated like any expression.
    @param[in] spec Number, expression string, or mapping.
    @param[in] names Variables in scope.
    @param[in] random Whether random draws may be called.
    @param[in] where Configuration path, for diagnostics.
    @return Validated expression text.
    """
    params = {}
    if isinstance(spec, bool):
        raise ValueError(f"{where} must be a number, an expression, or a mapping.")
    if isinstance(spec, (int, float)):
        if not math.isfinite(spec):
            raise ValueError(f"{where} must be finite.")
        return repr(float(spec))
    if isinstance(spec, str):
        _validate_at(spec, names, random, where)
        return spec
    if not isinstance(spec, dict):
        raise ValueError(f"{where} must be a number, an expression, or a mapping.")
    unknown = set(spec) - {"params", "value", "background", "regions"}
    if unknown:
        raise ValueError(f"{where} does not take {sorted(unknown)}; it takes params, value, background, regions.")
    params = spec.get("params") or {}
    if not isinstance(params, dict):
        raise ValueError(f"{where}.params must be a mapping of names to numbers.")
    for name, number in params.items():
        reserved = set(names) | {"pi"} | set(FUNCTION_ARITY) | set(RANDOM_FUNCTIONS) | {"and", "or", "not"}
        if not isinstance(name, str) or not name.isidentifier() or name in reserved:
            raise ValueError(f"{where}.params name '{name}' is not a free identifier.")
        _number_text(number, {}, f"{where}.params.{name}")
    scope = set(names) | set(params)
 
    def expression_of(value, path):
        """!
        @brief Lower one value (number, `params` name, or expression) with parameters inlined.
        @param[in] value Configured value.
        @param[in] path Configuration path, for diagnostics.
        @return Expression text.
        """
        if isinstance(value, str) and value not in params:
            _validate_at(value, scope, random, path)
            return f"({_substitute_params(value, params)})"
        return _number_text(value, params, path)
 
    if "value" in spec:
        if "background" in spec or "regions" in spec:
            raise ValueError(f"{where} gives either value, or background with regions.")
        lowered = expression_of(spec["value"], f"{where}.value")
    else:
        regions = spec.get("regions")
        if not isinstance(regions, list) or not regions:
            raise ValueError(f"{where}.regions must be a non-empty list.")
        lowered = expression_of(spec.get("background", 0.0), f"{where}.background")
        for index, region in enumerate(regions):
            path = f"{where}.regions[{index}]"
            if not isinstance(region, dict) or "value" not in region:
                raise ValueError(f"{path} must be a mapping with a shape and a value.")
            distance = _region_distance(region, params, path)
            value = expression_of(region["value"], f"{path}.value")
            edge = region.get("edge")
            if edge is None:
                lowered = f"where({distance} <= 0, {value}, {lowered})"
                continue
            if not isinstance(edge, dict) or set(edge) != {"profile", "width"} or edge["profile"] not in EDGE_PROFILES:
                raise ValueError(f"{path}.edge must give profile ({', '.join(EDGE_PROFILES)}) and width.")
            width = _number_text(edge["width"], params, f"{path}.edge.width")
            if float(width) <= 0.0:
                raise ValueError(f"{path}.edge.width must be positive.")
            ramp = f"maximum(0, minimum(1, 0.5 - ({distance})/{width}))"
            blend = EDGE_PROFILES[edge["profile"]].format(s=ramp)
            lowered = f"({lowered})*(1 - {blend}) + {value}*{blend}"
    validate_expression(lowered, names, random)
    return lowered

Here is the call graph for this function:

Variable Documentation

ALLOWED_FUNCTIONS

dict picurv_cli.source_expressions.ALLOWED_FUNCTIONS

Initial value:

=  {
    "abs": np.abs,
    "atan2": np.arctan2,
    "cos": np.cos,
    "cosh": np.cosh,
    "erf": np.vectorize(math.erf, otypes=[float]),
    "exp": np.exp,
    "floor": np.floor,
    "log": np.log,
    "maximum": np.maximum,
    "minimum": np.minimum,
    "sin": np.sin,
    "sinh": np.sinh,
    "sqrt": np.sqrt,
    "tan": np.tan,
    "tanh": np.tanh,
    "where": np.where,
}

Definition at line 22 of file source_expressions.py.

FUNCTION_ARITY

dict picurv_cli.source_expressions.FUNCTION_ARITY

Initial value:

=  {"abs": 1, "cos": 1, "cosh": 1, "erf": 1, "exp": 1, "floor": 1, "log": 1, "sin": 1,
                  "sinh": 1, "sqrt": 1, "tan": 1, "tanh": 1, "atan2": 2, "maximum": 2, "minimum": 2,
                  "where": 3, "besselj": 2, "bessely": 2, "ber": 1, "bei": 1, "sum": 4}

Definition at line 42 of file source_expressions.py.

SOLVER_ONLY_FUNCTIONS

tuple picurv_cli.source_expressions.SOLVER_ONLY_FUNCTIONS = ("besselj", "bessely", "ber", "bei")

Definition at line 47 of file source_expressions.py.

MAX_SERIES_TERMS

int picurv_cli.source_expressions.MAX_SERIES_TERMS = 1000000

Definition at line 49 of file source_expressions.py.

MAX_SERIES_DEPTH

int picurv_cli.source_expressions.MAX_SERIES_DEPTH = 4

Definition at line 51 of file source_expressions.py.

RANDOM_FUNCTIONS

tuple picurv_cli.source_expressions.RANDOM_FUNCTIONS = ("uniform", "normal")

Definition at line 54 of file source_expressions.py.

EULERIAN_EXPRESSION_NAMES

picurv_cli.source_expressions.EULERIAN_EXPRESSION_NAMES = frozenset({"x", "y", "z", "xi", "eta", "zeta", "i", "j", "k"})

Definition at line 56 of file source_expressions.py.

PARTICLE_EXPRESSION_NAMES

picurv_cli.source_expressions.PARTICLE_EXPRESSION_NAMES = frozenset({"x", "y", "z", "t", "xi", "eta", "zeta", "L_xi", "L_eta", "L_zeta", "pid"})

Definition at line 59 of file source_expressions.py.

ALLOWED_NAMES

picurv_cli.source_expressions.ALLOWED_NAMES = set(ALLOWED_FUNCTIONS) | EULERIAN_EXPRESSION_NAMES | {"pi"}

Definition at line 60 of file source_expressions.py.

_DECIMAL_LITERAL

picurv_cli.source_expressions._DECIMAL_LITERAL = re.compile(r"^(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$")

protected

Definition at line 61 of file source_expressions.py.

ALLOWED_AST_NODES

tuple picurv_cli.source_expressions.ALLOWED_AST_NODES

Initial value:

=  (
    ast.Expression,
    ast.BinOp,
    ast.UnaryOp,
    ast.Call,
    ast.Name,
    ast.Load,
    ast.Constant,
    ast.Add,
    ast.Sub,
    ast.Mult,
    ast.Div,
    ast.Pow,
    ast.Mod,
    ast.Compare,
    ast.Eq,
    ast.NotEq,
    ast.Lt,
    ast.LtE,
    ast.Gt,
    ast.GtE,
    ast.USub,
    ast.UAdd,
    ast.BoolOp,
    ast.And,
    ast.Or,
    ast.Not,
)

Definition at line 62 of file source_expressions.py.

REGION_SHAPES

tuple picurv_cli.source_expressions.REGION_SHAPES = ("half_space", "slab", "box", "ball", "cylinder")

Definition at line 312 of file source_expressions.py.

EDGE_PROFILES

dict picurv_cli.source_expressions.EDGE_PROFILES

Initial value:

=  {
    "linear": "({s})",
    "smoothstep": "({s})*({s})*(3 - 2*({s}))",
    "cosine": "0.5*(1 - cos(pi*({s})))",
}

Definition at line 314 of file source_expressions.py.

_REGION_KEYS

dict picurv_cli.source_expressions._REGION_KEYS

protected

Initial value:

=  {
    "half_space": {"axis", "at", "side"},
    "slab": {"axis", "from", "to"},
    "box": {"min", "max"},
    "ball": {"center", "radius"},
    "cylinder": {"axis", "center", "radius"},
}

Definition at line 319 of file source_expressions.py.

_AXES

tuple picurv_cli.source_expressions._AXES = ("x", "y", "z")

protected

Definition at line 326 of file source_expressions.py.