add class to evalute c++ density functions from picmi meta-data output

[PrometheusPi]

This PR adds a helper class that converts the c++ code string from PICMI free density formula to a sympy expression and enables evaluating it.

[PrometheusPi]

@chillenzer I would be happy to implement any idea to shorten this parser.

[ikbuibui]

My main comment is that I think the ternary op handling and parsing can be done in init, maybe use sympy.Piecewise for the ternary op, and then an evaluate will become quite straightforward.
You will need to provide the symbol e.g. y to init though.
This can be useful depending on how this is used.
Offline discussion: This feature is a stopgap till we start storing sympy expressions instead of recreating them from C++. This code is not intended to be kept in long term.
Other small comments below

[ikbuibui]

Suggested change

	__all__ = ["FindTime", "MemoryCalculator", "FieldIonization", "FLYonPICRateCalculationReference", "cpp_fct_reader"]
	__all__ = ["FindTime", "MemoryCalculator", "FieldIonization", "FLYonPICRateCalculationReference", "CppFctReader"]

Doesn't follow naming scheme.

[ikbuibui]

Personally I also prefer Fn for functions instead of Fct

[ikbuibui]

missing corresponding file close.

[PrometheusPi]

I added a comment how to generate this file

[ikbuibui]

I was wondering if you need a call to file close at the end of main to prevent resource leaks.
https://stackoverflow.com/questions/7395542/is-explicitly-closing-files-important

[PrometheusPi]

Valid point
will fix

[chillenzer]

Offline discussion: The idiomatic approach would probably be to define the corresponding transformations and add them to a call list sympy_parser.parse_expr(s, transformations=transformations). But it is unclear whether we want to build all that infrastructure for some transitional code that will be removed in due time. (Saying this is a sure way for a piece of code to become critical infrastructure relied upon by generations and generations of future users (see https://xkcd.com/2730/).)

[chillenzer]

Suggested change

	file = open("pypicongpu.json")
	sim_dict = json.load(file)
	with open("pypicongpu.json") as file:
	sim_dict = json.load(file)

[PrometheusPi]

Done (already suggested by @ikbuibui)

[chillenzer]

Suggested change

	while s[0].isspace():
	s = s[1:]
	while s[-1].isspace():
	s = s[:-1]
	s = s.strip()

[PrometheusPi]

Thanks - I forgot about that method :-)

[chillenzer]

Is this needed only a single time? Otherwise we'd need at least a while loop here.

Suggested change

	if s[0] == "(" and s[-1] == ")":
	s = s[1:-1]
	while s.startswith('('):
	if not s.endswith(')'):
	raise ValueError(f"Missing closing parenthesis in {s=}.")
	s = s[1:-1]

[PrometheusPi]

I like your code

[chillenzer]

This won't be sufficient. There's a long list of pmacc::math functions that could be generated. It might be more reliable to do s.replace('pmacc::math::', 'std') (or just remove the prefix).

[PrometheusPi]

That's true - I will s.replace('pmacc::math::', ' ')

[chillenzer]

Algorithm for detecting matching parenthesis (adapted for this problem):

from itertools import groupby
from sympy import Piecewise


def nesting_level(c):
    if c == "?":
        return 1
    if c == ":":
        return -1
    return 0


class Counter:
    counter = 0

    def __add__(self, addition):
        self.counter += addition
        return self.counter


def parse_branchless(string):
    # ... do parsing with guaranteed no ternary operators...
    return string


def parse_with_keys(keys_and_expressions):
    if len(keys_and_expressions) == 1:
        return parse_branchless(keys_and_expressions[0][1].strip("?:() "))

    condition = parse_with_keys(keys_and_expressions[:1])
    # poor man's index finding because list.index doesn't support key functions
    else_index = (
        next(
            filter(
                lambda x: x[1][0] == keys_and_expressions[0][0],
                enumerate(keys_and_expressions[1:]),
            )
        )[0]
        + 1
    )
    then_expression = parse_with_keys(keys_and_expressions[1:else_index])
    else_expression = parse_with_keys(keys_and_expressions[else_index:])
    # should be
    # return Piecewise([(then_expression, condition), (else_expression, True)])
    # but I didn't implement the parse function
    return [(then_expression, condition), (else_expression, True)]


def parse(string):
    counter = Counter()
    return parse_with_keys(
        list(
            map(
                lambda x: (x[0], "".join(x[1])),
                groupby(s, lambda c: counter + nesting_level(c)),
            )
        )
    )


if __name__ == "__main__":
    # a little demonstration
    s = "c>1 ? (c<3 ? 5: 6) : (c<-5 ? 42 : 2)"
    print(parse(s))

[PrometheusPi]

I will add this tomorrow

[PrometheusPi]

I might need some more time to do so

[chillenzer]

Heads-up: Nitpicking coming your way!

I'd probably even unindent that last line. That way the file will only be kept open for as long as it is really necessary. In general, that's a good thing to aim for in order to avoid various risks of file corruption, blocking other code's access, etc. but also to more clearly communicate the dependencies in your code. (json.load(...)'s return value might still hold a reference to the file and its [] operators could potentially rely on that file still being open.)

In practice, the dictionary look-up afterwards is certainly completely irrelevant in that respect but one might choose following such style rules in the harmless and simple cases, so they come naturally in the dangerous and difficult-to-decipher ones as well.

Suggested change

	with open("pypicongpu.json") as file:
	sim_dict = json.load(file)
	density_fct_str = sim_dict["species_initmanager"]["operations"]["simple_density"][0]["profile"]["data"][
	"function_body"
	]
	with open("pypicongpu.json") as file:
	sim_dict = json.load(file)
	density_fct_str = sim_dict["species_initmanager"]["operations"]["simple_density"][0]["profile"]["data"][
	"function_body"
	]