Rigidbody Solver Limitations

[kv-ep]

I am running into a couple of issues with the rigidbody solver:

1. Performance: In the included code snippet, I spawn 125 spheres and let them drop onto a plane. After increasing the maximum collision pairs, I was able to get the contact behavior for this simple case to work, but the performance is extremely poor. Running on a 4090 laptop, this runs at ~0.5fps, which at the current timestep makes it 1/200th of realtime. This same scenario runs in realtime or better with PhysX (for the equivalent dt & substeps). Is there any way to improve the performance of my script?
2. Mesh Collisions: In this same script, I added a simple mesh cone below the particles, but was unable to get them to collide with it (they would pass through it as if it didn't exist). Do I have some setting improperly specified, or is it not possible currently to have thin-walled shell collisions?

# from pathlib import Path
import argparse
import numpy as np
import genesis as gs


def main():
    """Entry point"""
    parser = argparse.ArgumentParser()
    parser.add_argument("-v", "--vis", action="store_true", default=False)
    args = parser.parse_args()

    gs.init(seed=0, precision="32", logging_level="debug")

    scene = gs.Scene(
        sim_options=gs.options.SimOptions(
            dt=1e-2,
            substeps=10,
            gravity=(0.0, -9.81, 0.0),
        ),
        rigid_options=gs.options.RigidOptions(
            max_collision_pairs=10000,
        ),
        show_viewer=args.vis,
        viewer_options=gs.options.ViewerOptions(
            camera_pos=(5.0, 0.25, 0.0),
            camera_lookat=(0.0, 0.25, 0.0),
            camera_up=(0.0, 1.0, 0.0),
            camera_fov=30,
        ),
        vis_options=gs.options.VisOptions(),
    )

    # Funnel portion of code
    # directory = Path(__file__).resolve().parent
    # scene.add_entity(
    #     material=gs.materials.Rigid(),
    #     morph=gs.morphs.Mesh(
    #         file=(directory / "hopper.obj").as_posix(),
    #         convexify=False,
    #         decompose_nonconvex=False,
    #         fixed=True,
    #         decimate=False,
    #     ),
    # )
    scene.add_entity(gs.morphs.Plane(normal=(0, 1, 0)))

    for x in np.linspace(-0.08, 0.08, 5):
        for y in np.linspace(0.2, 0.4, 5):
            for z in np.linspace(-0.08, 0.08, 5):
                scene.add_entity(
                    material=gs.materials.Rigid(),
                    morph=gs.morphs.Sphere(pos=(x, y, z), radius=0.02),
                )
    scene.build()

    for _ in range(1000):
        scene.step()


if __name__ == "__main__":
    main()

[Kashu7100]

Is there any reason why you are using substeps=10?

[kv-ep]

I was looking for an equivalent dt of 1e-3 (this is the baseline where we run most of our PhysX simulations). From other solvers, I'm used to this parameter being used to perform multiple simulation steps on the GPU without host synchronization, making it a more efficient way of achieving that 1e-3 delta time compared to simply setting the dt=1e-3 and using 1 substep. Testing also seemed to agree with this.

However, that was all my speculation, is there a more appropriate/efficient way to be using substeps in my scenario?