[SofaGym] scale_factor and step_simulation

[Moose-Coder]

I'm editing the DiamondRobot scene so that it can be controlled by force instead of displacement. I want to simulate with dt=0.01, and I'm not sure how exactly scale_factor in configuraiton comes into play.
It seems that it's used as follows in the step_simulation() function in sofagym.simulate

def step_simulation(root, config, action, _startCmd, _getPos, viewer=None):
    """Realise one step in the simulation.

    Apply action and execute 5 times scale_factor simulation steps of dt s.

    Parameters:
    ----------
        root: <Sofa.Core>
            The scene.
        config: Dictionary
            The configuration of the environment.
        action: int
            The action to apply in the environment.
        _startCmd: function
            Initialize the command.
        _getPos: function
            Get the position of the object in the scene.

    Returns:
    --------
        position(s): list
            The positions of object(s) in the scene.

    """
    goal = config['goalPos']
    render = config['render']
    surface_size = config['display_size']

    root.GoalSetter.set_mo_pos(goal)

    # Create the command from action
    _startCmd(root, action, config["dt"]*(config["scale_factor"] - 1))
    pos = []
    # Realise scale_factor simulation steps of 0.01 s
    for i in range(config["scale_factor"]):
        Sofa.Simulation.animate(root, config["dt"])
        if render == 2:
            pos.append(_getPos(root))
            if viewer is not None:
                viewer.render_simulation(root)

    if render == 1:
        pos.append(_getPos(root))

    return pos

Specifically, why do we call _startCmd() with scale_factor - 1 and Sofa.Simulation.animate() with scale_factor without subtracting 1?
Also, I applied some open loop control input and it seems that these inputs are 100 times too big for the desired effect. Could this be caused by the dt=0.01? Here's the code for startCmd()

def apply_control(root, control_inputs, n_steps):
    """Change the force in the cable

    Parameters:
    ----------
        control_inputs: ndarray(4, )

    Returns:
    -------
        None.
    """

    cables = [root.Robot.Actuators.north, root.Robot.Actuators.west, root.Robot.Actuators.south,
              root.Robot.Actuators.east]
    for idx in range(4):
        curr_value = cables[idx].value.array()[0]
        cables[idx].value += control_inputs[idx] - curr_value #/n_steps

def startCmd(root, control_inputs, duration):
    """Initialize the command from root and action.

    Parameters:
    ----------
        rootNode: <Sofa.Core>
            The scene.
        control_inputs: ndarray (4, )
            The control input.
        duration: float
            Duration of the animation.

    Returns:
    ------
        None.

    """
    # Definition of the elements of the animation
    def executeAnimation(root, control_inputs, n_steps, factor):
        apply_control(root, control_inputs, n_steps)

    # Add animation in the scene
    root.AnimationManager.addAnimation(
        Animation(
            onUpdate=executeAnimation,
            params={"root": root,
                    "control_inputs": control_inputs,
                    "n_steps": duration},
            duration=duration, mode="once"))

[hugtalbot]

Your help would needed here as well @samuelmyoussef 🙏 thanks !

[Moose-Coder]

Thanks! I also noticed that my gets slower as the step counts grows. Is this expected? If not, what could have caused it?

[samuelmyoussef]

I'm not exactly sure what you're referencing by step counts, do you mean the longer the simulation runs or something else?

[Moose-Coder]

Yes exactly. The time required to simulate each step gets longer the longer the simulation runs.

[samuelmyoussef]

In DiamondEnv.py line 40, can you change save_data to false and see if it fixes it or not?

[samuelmyoussef]

The scale_factor comes into play when the actions change the displacement. It is used as a scale for the displacement so that the change is not too big or too small for each simulation step.

Since you'll be using force to control, you don't have to use it in your code so it could be set to 1, but we know about some issues when it's set to 1 that we are still trying to fix, so I suggest for now that you set it to at least 2 and check if it works or not.

[Moose-Coder]

I set it to 2 and added a "-1" in the for loop in step_simulation as follows:

for i in range(config["scale_factor" - 1]):

So effectively my _startcmd() duration is 1 and and the Sofa.Simulation.animate() is only called once.
Is this a valid quick fix? The simulation results look fairly reasonable.

[samuelmyoussef]

Yes, this should work for now

[github-actions[bot]]

⚠️ ⚠️ ⚠️
@Moose-Coder
Feedback has been given to you by the project reviewers, however we have not received a response from you. Without further news in the coming weeks, this discussion will be automatically closed in order to keep this forum clean and fresh 🌱 Thank you for your understanding

[github-actions[bot]]

⚠️ ⚠️ ⚠️
@Moose-Coder
In accordance with our forum management policy, the last reply is more than 4 months old and is therefore closed. Our objective is to keep the forum up to date and offer the best support experience.

Please feel free to reopen it if the topic is still active by providing us with an update. Please feel free to open a new thread at any time - we'll be happy to help where and when we can.