How to make start_time, stop_time, and step_size user-configurable in PythonFMU?

[MengnanLi91]

Description:

When I run an FMU with fmpy.simulate_fmu, I can pass start_time, stop_time, and step_size as arguments.
However, when I implement my own FMU class with pythonfmu, I’m not sure how to make these values configurable at runtime.
I tried using setup_experiment(maybe not the right way):

class Moose2FMU(Fmi2Slave):
    def __init__(self):
        ...
        self.start_time: Real = 0.0
        self.stop_time: Real = 0.0
        self.step_size: Real = 0.1
        self.tolerance: Real = 1.0e-3
        ...

    def setup_experiment(self, start_time: float,
                         stop_time: Optional[float],
                         tolerance: Optional[float]) -> bool:
        self.start_time = start_time
        self.stop_time = stop_time
        self.tolerance = tolerance
        return True

But the values don’t seem to take effect.

The only way I can set them successfully is by using default_experiment in construction phase:

self.default_experiment = DefaultExperiment(start_time=0.0, stop_time=2.0, step_size=0.5)

This works, but it fixes the values at build time — I can’t change them at runtime when running the FMU, which is inconvenient.

Question:
What’s the correct way in pythonfmu to allow start_time, stop_time, and step_size set by the user (via fmpy.simulate_fmu) to be applied in my custom FMU class?

[markaren]

setup_experiment is supposed to be the way to do it. DefaultExperiment is just text added to the XML that may or may not be used, depending on the user and defaults of the importer.

Are you saying that start_time -> 0 while stop_time and tolerance is always None, even when set from FMPy?

Edit: Are you explicitly setting these values from FMPy? If not, it will probably default to FMPY defaults or it may ise the DefaultExperiment from PythonFMU.

[MengnanLi91]

Yes, I set it in FMPy as below but the fmu doesn't pick up this values. It only use the default ones set with DefaultExperiment

    result = simulate_fmu(
        moose_filename,
        start_time=0,
        stop_time=2.0,
        step_size =0.5,
        debug_logging=True,
        output      = ['time','moose_time', 'diffused', "rep_value"]
    )

The complete code is here idaholab/moose#30912 Maybe I miss something.
Where does setup_experiment get value of start_time and stop_time?

[markaren]

setup_experiment get the values from the importing tool, so if it uses the DefaultExperiment values, it is FMPy providing those values..

[MengnanLi91]

DefaultExperiment is called in to_xml, so once the fmu is built, user can not change it in the running phase unless using setup_experiment?

[markaren]

DefaultExperiment is just a hint to the user what sensible defaults to use. The importing tool decides what to actually use. That information is passed to setup_experiment in the FMU.

[MengnanLi91]

I did some experiments and found the step_size seems not pass to do_step() correctly when using fmpy.simulate_fmu. See the simple case below. When the demofmu is manually run using fmu.doStep(), the step_size is correctly set. When I use simulate_fmu, the user setstep_size is not passed(simulate_fmu calles doStep(), it should be the same but it's not. Source code seem correct : https://github.com/CATIA-Systems/FMPy/blob/cbdd472621261556eacb76e127ef8c944d1cb88e/src/fmpy/simulation.py#L1302). I am not sure if it is an issue with fmpy.simulate_fmu or an issue when do_step talks to doStep()

Demofmu

from pythonfmu import Fmi2Slave, Fmi2Causality, Real

class DemoFMU(Fmi2Slave):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.y = 0.0
        self.register_variable(Real("y", causality=Fmi2Causality.output, getter=lambda: self.y))

    # robust to older/newer call patterns
    def setup_experiment(self, start_time: float, stop_time=None, tolerance=None, **kwargs) -> bool:
        print(f"start={start_time}, stop={stop_time}, tol={tolerance}")
        return True

    def do_step(self, current_time: float, step_size: float) -> bool:
        print(f"t={current_time}, h={step_size}")
        return True

Run script

from fmpy import simulate_fmu
from fmpy import simulate_fmu, extract, read_model_description, instantiate_fmu

def run_sim(filename, t0, t1, dt):
    return simulate_fmu(
        filename,
        start_time=t0,
        stop_time=t1,
        step_size=dt,
        debug_logging=True,
    )

def run_sim_step_by_step(filename, t0, t1, dt):

    unzipdir = extract(filename)
    md = read_model_description(unzipdir)
    fmu = instantiate_fmu(unzipdir=unzipdir, model_description=md)

    fmu.instantiate()
    fmu.setupExperiment(startTime=t0, stopTime=t1)
    fmu.enterInitializationMode()

    t = t0
    while t < t1 - 1e-15:
        fmu.doStep(currentCommunicationPoint=t, communicationStepSize=dt)
        t = min(t + dt, t1)

def main():
    t0, t1, dt = 0.0, 2.0, 0.5
    filename = 'DemoFMU.fmu'
    result = run_sim(filename, t0, t1, dt)
    #run_sim_step_by_step(filename, t0, t1, dt)

if __name__ == "__main__":
    main()

Results from run_sim

start=0.0, stop=2.0, tol=None
t=0.0, h=0.004
t=0.004, h=0.004
t=0.008, h=0.004
...
t=1.996, h=0.0040000000000000036

Results from run_sim_step_by_step

start=0.0, stop=2.0, tol=None
t=0.0, h=0.5
t=0.5, h=0.5
t=1.0, h=0.5
t=1.5, h=0.5