[Question] how can i set different usd in different env

[437142188]

Question

when i use below code to set my env for parellel training, i cannot get different usd model correctly.

def _setup_scene(self):
        self.robot = Articulation(self.cfg.robot_cfg)
        # add ground plane
        spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())

        map_paths = [
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_02_collider.usd",
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_29_collider_1.usd",
        ]
        
        num_envs = self.scene.cfg.num_envs
        
        for env_idx in range(num_envs):
            map_path = map_paths[env_idx % len(map_paths)]
            
            prim_path = f"/World/envs/env_{env_idx}/narrow_gap_localmap"
            
            cfg = sim_utils.UsdFileCfg(
                usd_path=map_path,
                rigid_props=sim_utils.RigidBodyPropertiesCfg(
                    rigid_body_enabled=True,
                    kinematic_enabled=True,
                    disable_gravity=True,
                ),
                collision_props=sim_utils.CollisionPropertiesCfg(
                    collision_enabled=True,
                ),
                activate_contact_sensors=False,
            )
            
            cfg.func(
                prim_path, cfg,
                translation=(-1.0, -1.0, -0.1),
                orientation=(1, 0.0, 0.0, 0)
            )

        # clone and replicate
        self.scene.clone_environments(
            copy_from_source=False,
        )

        # add lights
        light_cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75))
        light_cfg.func("/World/Light", light_cfg)
        # add raycaster
        self.lidar_2d = MultiMeshRayCaster(self.cfg.lidar_2d)
        self.scene.sensors["lidar_2d"] = self.lidar_2d
        # add contact
        self.contact_sensor = ContactSensor(self.cfg.contact_sensor)
        self.scene.sensors["contact_sensor"] = self.contact_sensor

        # add articulation to scene
        self.scene.articulations["robot"] = self.robot

        self.scene.filter_collisions(
            global_prim_paths=["/World/ground"],
        )

        self.visualization_markers = define_markers()

        self.up_dir = torch.tensor([0.0, 0.0, 1.0]).cuda()  
        self.yaws = torch.zeros((self.cfg.scene.num_envs, 1)).cuda()
        self.commands = torch.randn((self.cfg.scene.num_envs, 3)).cuda()
        self.commands[:,-1] = 0.0
        self.commands = self.commands/torch.linalg.norm(self.commands, dim=1, keepdim=True)
        
        # offsets to account for atan range and keep things on [-pi, pi]
        ratio = self.commands[:,1]/(self.commands[:,0]+1E-8)
        gzero = torch.where(self.commands > 0, True, False)
        lzero = torch.where(self.commands < 0, True, False)
        plus = lzero[:,0]*gzero[:,1]
        minus = lzero[:,0]*lzero[:,1]
        offsets = torch.pi*plus - torch.pi*minus
        self.yaws = torch.atan(ratio).reshape(-1,1) + offsets.reshape(-1,1)

        self.marker_locations = torch.zeros((self.cfg.scene.num_envs, 3)).cuda()
        self.marker_offset = torch.zeros((self.cfg.scene.num_envs, 3)).cuda()
        self.marker_offset[:,-1] = 0.5
        self.forward_marker_orientations = torch.zeros((self.cfg.scene.num_envs, 4)).cuda()
        self.command_marker_orientations = torch.zeros((self.cfg.scene.num_envs, 4)).cuda()

as the picture shows, all the lidar in different env percept same mesh, although they visual not same type. Beside, all the envs have same collider feature that shows in env0 usd file, maybe i am not use correct usd import function, Thanks for help me!

Build Info

Describe the versions that you are currently using:

• Isaac Lab Version: 2.2.0
• Isaac Sim Version: 5.0.0

[RandomOakForest]

Thank you for posting this. Each environment is still “seeing” the same USD because all your gap meshes are being spawned in the source env before calling clone_environments, and the clone step is then replicating only that source layout and physics, not the per-env variation you expect. In other words, all lidar sensors end up ray-casting against the same collider set even if the visuals differ.¹²

In Isaac Lab, clone_environments(copy_from_source=False) only controls whether the original USD prims are shared or separately instantiated, but it still uses the source environment’s prims and physics setup as a template for all envs. To get different USD maps per environment, you must:²¹

1. Create an explicit per-environment root prim and spawn the USD into that prim, not directly into /World/envs/env_0/... before cloning.
2. Disable replication of that prim in the scene config so the cloning logic does not override your custom per-env USD placement.
3. Spawn the different USDs after clone_environments, using env_indices or per-env prim paths that already exist for each cloned env.

A robust approach is:

• In your InteractiveSceneCfg, set up the maps as generic USD prims that are not part of the replicated categories (articulations/sensors). Then, in _setup_scene:

def _setup_scene(self):
    self.robot = Articulation(self.cfg.robot_cfg)

    # ground first
    spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())

    # clone and replicate only robots, sensors, etc.
    self.scene.clone_environments(copy_from_source=False)

    # now spawn per-env USDs under each env root
    map_paths = [
        f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_02_collider.usd",
        f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_29_collider_1.usd",
    ]
    num_envs = self.scene.cfg.num_envs

    for env_idx in range(num_envs):
        map_path = map_paths[env_idx % len(map_paths)]
        # use the already-created env root
        prim_path = f"/World/envs/env_{env_idx}/narrow_gap_localmap"

        cfg = sim_utils.UsdFileCfg(
            usd_path=map_path,
            rigid_props=sim_utils.RigidBodyPropertiesCfg(
                rigid_body_enabled=True,
                kinematic_enabled=True,
                disable_gravity=True,
            ),
            collision_props=sim_utils.CollisionPropertiesCfg(
                collision_enabled=True,
            ),
            activate_contact_sensors=False,
        )
        cfg.func(
            prim_path=prim_path,
            cfg=cfg,
            translation=(-1.0, -1.0, -0.1),
            orientation=(1.0, 0.0, 0.0, 0.0),
        )

    # register robot & sensors AFTER cloning
    self.scene.articulations["robot"] = self.robot
    self.lidar_2d = MultiMeshRayCaster(self.cfg.lidar_2d)
    self.scene.sensors["lidar_2d"] = self.lidar_2d
    self.contact_sensor = ContactSensor(self.cfg.contact_sensor)
    self.scene.sensors["contact_sensor"] = self.contact_sensor

This sequence makes sure:

• clone_environments only builds env_0, env_1, ... roots and clones the robot/sensors layout.¹
• The narrow gap USD is spawned separately in each env with a different file path, so physics and ray-casting see different meshes per env.

Why lidar still saw same mesh

Ray casting uses the shared PhysX scene; if multiple USDs share the same prim name and are cloned from the same source env, they all reference the same underlying collider setup. By spawning after cloning into env-specific prim paths, each gap map has its own collider prims, and MultiMeshRayCaster can correctly intersect only what belongs to that env.³⁴

Footnotes

1. https://isaac-sim.github.io/IsaacLab/main/source/setup/walkthrough/technical_env_design.html ↩ ↩² ↩³

2. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.scene.html ↩ ↩²

3. https://isaac-sim.github.io/IsaacLab/main/source/how-to/multi_asset_spawning.html ↩

4. https://forums.developer.nvidia.com/t/collision-rigid-body-sim-not-working-with-different-assets/245386 ↩

[437142188]

@RandomOakForest thanks for your replay, i tried:
1,changed the order as your suggestion to make sure Spawn the different USDs after clone_environments
2,Disable replication of that prim in the scene config

i do not know how to Create an explicit per-environment root prim and spawn the USD into that prim. and i get below running view

From the terminal, it shows the warning:

2025-12-03T03:42:48Z [34,366ms] [Warning] [isaaclab.sim.spawners.from_files.from_files] A prim already exists at prim path: '/World/envs/env_0/narrow_gap_localmap'.
2025-12-03T03:42:48Z [34,367ms] [Warning] [isaaclab.sim.utils] Could not perform 'modify_rigid_body_properties' on any prims under: '/World/envs/env_0/narrow_gap_localmap'. This might be because of the following reasons:
    (1) The desired attribute does not exist on any of the prims.
    (2) The desired attribute exists on an instanced prim.
        Discovered list of instanced prim paths: []

i used directEnv workflow, could you please tell me how to Create an explicit per-environment root prim and spawn the USD into that prim in directEnvCfg. Thanks again~
My directEnv file :

def _setup_scene(self):
        self.robot = Articulation(self.cfg.robot_cfg)
        # add ground plane
        spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())
        # clone and replicate
        self.scene.clone_environments(
            copy_from_source=False,
        )

        map_paths = [
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_02_collider.usd",
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_29_collider_1.usd",
        ]
        
        num_envs = self.scene.cfg.num_envs
        
        for env_idx in range(num_envs):
            map_path = map_paths[env_idx % len(map_paths)]
            
            prim_path = f"/World/envs/env_{env_idx}/narrow_gap_localmap"
            
            cfg = sim_utils.UsdFileCfg(
                usd_path=map_path,
                rigid_props=sim_utils.RigidBodyPropertiesCfg(
                    rigid_body_enabled=True,
                    kinematic_enabled=True,
                    disable_gravity=True,
                ),
                collision_props=sim_utils.CollisionPropertiesCfg(
                    collision_enabled=True,
                ),
                activate_contact_sensors=False,
            )
            cfg.func(
                "/World/envs/env_.*/narrow_gap_localmap", cfg, translation=(-1.0, -1.0, -0.1), orientation=(1, 0.0, 0.0, 0)
            )
            
        # add lights
        light_cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75))
        light_cfg.func("/World/Light", light_cfg)
        # add articulation to scene
        self.scene.articulations["robot"] = self.robot

        
        # add raycaster
        self.lidar_2d = MultiMeshRayCaster(self.cfg.lidar_2d)
        self.scene.sensors["lidar_2d"] = self.lidar_2d
        # add contact
        self.contact_sensor = ContactSensor(self.cfg.contact_sensor)
        self.scene.sensors["contact_sensor"] = self.contact_sensor

and my directEnvCfg file :

# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# All rights reserved.
#
# SPDX-License-Identifier: Apache-2.0
import isaaclab.sim as sim_utils
import isaacsim.core.utils.prims as prim_utils

# from isaaclab_assets.robots.jetbot import JETBOT_CONFIG
#from isaaclab_assets.robots.sweeper_robot import SWEEPER_ROBOT_CFG
from isaaclab.sensors import ContactSensor, ContactSensorCfg, RayCaster, patterns
# from isaaclab.sensors import RayCasterCfg
from isaaclab.actuators import ImplicitActuatorCfg
from isaaclab.assets import ArticulationCfg, AssetBaseCfg, RigidObjectCfg
from isaaclab.envs import DirectRLEnvCfg
from isaaclab.scene import InteractiveSceneCfg
from isaaclab.sim import SimulationCfg
from isaaclab.utils import configclass
from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
from isaaclab.terrains import TerrainImporterCfg
from isaaclab.managers import EventTermCfg as EventTerm
from isaaclab.managers import SceneEntityCfg
import isaaclab.envs.mdp as mdp
from .sensors.ray_caster.multi_mesh_ray_caster_cfg import MultiMeshRayCasterCfg
from .sensors.ray_caster.ray_caster_cfg import RayCasterCfg
from dataclasses import MISSING
from typing import Optional, List

JETBOT_CONFIG = ArticulationCfg(
        spawn=sim_utils.UsdFileCfg(
            usd_path=f"/isaacsim_assets/v15-no-mop/v15_self_contained-no-mop/v15_self_contained-no-mop.usd",
            # usd_path=f"/isaacsim_assets/v15_self_contained-path/v15_self_contained-path.usd",
            activate_contact_sensors=True,
            mass_props=sim_utils.MassPropertiesCfg(mass=1.5),
        ),
        actuators={"wheel_acts": ImplicitActuatorCfg(joint_names_expr=["wheel_(left|right)_joint"], damping=None, stiffness=None)},
        
        init_state=ArticulationCfg.InitialStateCfg(
            pos=(0.0, 0.0, 0.05),  
            rot=(1.0, 0.0, 0.0, 0.0),  
            joint_pos={"wheel_left_joint": 0.0, "wheel_right_joint": 0.0}, 
            # vel=(0.0, 0.0, 0.0),  
            # ang_vel=(0.0, 0.0, 0.0)  
        ),
    )


@configclass
class EventCfg:
    """Configuration for randomization."""

    add_body_mass = EventTerm(
        func=mdp.randomize_rigid_body_mass,
        mode="startup",
        params={
            "asset_cfg": SceneEntityCfg("robot", body_names="base_footprint"),
            "mass_distribution_params": (0.975, 1.025),
            "operation": "scale",
        },
    )

@configclass
class IsaacLabTutorialEnvCfg(DirectRLEnvCfg):
    # env
    decimation = 2               
    episode_length_s = 50.0     
    dt= 1 / 50
    # - spaces definition
    action_space = 2
    observation_space = 45
    state_space = 0              
    # simulation
    sim: SimulationCfg = SimulationCfg(dt=dt, render_interval=decimation)

    # # robot(s)
    robot_cfg: ArticulationCfg = JETBOT_CONFIG.replace(prim_path="/World/envs/env_.*/robot")
    lidar_2d: MultiMeshRayCasterCfg = MultiMeshRayCasterCfg(
        prim_path="/World/envs/env_.*/robot/base_footprint/base_link/laser_link",
        update_period= dt * decimation,
        offset=MultiMeshRayCasterCfg.OffsetCfg(pos=(0.0, 0.0, 0.0)),  
        mesh_prim_paths=[
            MultiMeshRayCasterCfg.RaycastTargetCfg(target_prim_expr="{ENV_REGEX_NS}/narrow_gap_localmap"),
        ],
        ray_alignment="yaw",                       
        pattern_cfg=patterns.LidarPatternCfg(
            channels=1,               
            horizontal_fov_range=[-180, 180],
            horizontal_res=1.0,      
            vertical_fov_range=[-0, 0], 
        ),
        max_distance = 10.,
        debug_vis=True,              
    )

    contact_sensor: ContactSensorCfg = ContactSensorCfg(
        # prim_path="/World/envs/env_.*/robot/.*", history_length=2, update_period= dt, track_air_time=False
        prim_path="/World/envs/env_.*/robot/base_footprint", history_length=2, update_period= dt, track_air_time=False, debug_vis=True,
    )
    

    # scene
    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=100, env_spacing=2.0, replicate_physics=False)
    dof_names = ["wheel_left_joint", "wheel_right_joint"]

    #events
    events: EventCfg = EventCfg()