API¤

class RING(ml_base.AbstractFilter):
    def __init__(
        self,
        params=None,
        lam=None,
        jit: bool = True,
        name=None,
        forward_factory=make_ring,
        **kwargs,
    ):
        "Untrained RING network"
        self.forward_lam_factory = partial(forward_factory, **kwargs)
        self.params = self._load_params(params)
        self.lam = lam
        self._name = name

        if jit:
            self.apply = jax.jit(self.apply, static_argnames="lam")

    def apply(self, X, params=None, state=None, y=None, lam=None):
        if lam is None:
            assert self.lam is not None
            lam = self.lam

        return super().apply(X, params, state, y, tuple(lam))

    def init(self, bs: Optional[int] = None, X=None, lam=None, seed: int = 1):
        assert X is not None, "Providing `X` via in `ringnet.init(X=X)` is required"
        if bs is not None:
            assert X.ndim == 4

        if X.ndim == 4:
            if bs is not None:
                assert bs == X.shape[0]
            else:
                bs = X.shape[0]
            X = X[0]

        # (T, N, F) -> (1, N, F) for faster .init call
        X = X[0:1]

        if lam is None:
            assert self.lam is not None
            lam = self.lam

        key = jax.random.PRNGKey(seed)
        params, state = self.forward_lam_factory(lam=lam).init(key, X)

        if bs is not None:
            state = jax.tree_map(lambda arr: jnp.repeat(arr[None], bs, axis=0), state)

        return params, state

    def _apply_batched(self, X, params, state, y, lam):
        if (params is None and self.params is None) or state is None:
            _params, _state = self.init(bs=X.shape[0], X=X, lam=lam)

        if params is None and self.params is None:
            params = _params
        elif params is None:
            params = self.params
        else:
            pass

        if state is None:
            state = _state

        yhat, next_state = jax.vmap(
            self.forward_lam_factory(lam=lam).apply, in_axes=(None, 0, 0)
        )(params, state, X)

        return yhat, next_state

    @staticmethod
    def _load_params(params: str | dict | None | Path):
        assert isinstance(params, (str, dict, type(None), Path))
        if isinstance(params, (Path, str)):
            return pickle_load(params)
        return params

    def nojit(self) -> "RING":
        ringnet = RING(params=self.params, lam=self.lam, jit=False)
        ringnet.forward_lam_factory = self.forward_lam_factory
        return ringnet

    def _pre_save(self, params=None, lam=None) -> None:
        if params is not None:
            self.params = params
        if lam is not None:
            self.lam = lam

    @staticmethod
    def _post_load(ringnet: "RING", jit: bool = True) -> "RING":
        if jit:
            ringnet.apply = jax.jit(ringnet.apply, static_argnames="lam")
        return ringnet

class RCMG:
    def __init__(
        self,
        sys: base.System | list[base.System],
        config: jcalc.MotionConfig | list[jcalc.MotionConfig] = jcalc.MotionConfig(),
        setup_fn: Optional[types.SETUP_FN] = None,
        finalize_fn: Optional[types.FINALIZE_FN] = None,
        add_X_imus: bool = False,
        add_X_imus_kwargs: dict = dict(),
        add_X_jointaxes: bool = False,
        add_X_jointaxes_kwargs: dict = dict(),
        add_y_relpose: bool = False,
        add_y_rootincl: bool = False,
        add_y_rootincl_kwargs: dict = dict(),
        sys_ml: Optional[base.System] = None,
        randomize_positions: bool = False,
        randomize_motion_artifacts: bool = False,
        randomize_joint_params: bool = False,
        randomize_hz: bool = False,
        randomize_hz_kwargs: dict = dict(),
        imu_motion_artifacts: bool = False,
        imu_motion_artifacts_kwargs: dict = dict(),
        dynamic_simulation: bool = False,
        dynamic_simulation_kwargs: dict = dict(),
        output_transform: Optional[Callable] = None,
        keep_output_extras: bool = False,
        use_link_number_in_Xy: bool = False,
        cor: bool = False,
        disable_tqdm: bool = False,
    ) -> None:
        "Random Chain Motion Generator"

        sys, config = utils.to_list(sys), utils.to_list(config)
        sys_ml = sys[0] if sys_ml is None else sys_ml

        for c in config:
            assert c.is_feasible()

        self.gens = []
        for _sys in sys:
            self.gens.append(
                _build_mconfig_batched_generator(
                    sys=_sys,
                    config=config,
                    setup_fn=setup_fn,
                    finalize_fn=finalize_fn,
                    add_X_imus=add_X_imus,
                    add_X_imus_kwargs=add_X_imus_kwargs,
                    add_X_jointaxes=add_X_jointaxes,
                    add_X_jointaxes_kwargs=add_X_jointaxes_kwargs,
                    add_y_relpose=add_y_relpose,
                    add_y_rootincl=add_y_rootincl,
                    add_y_rootincl_kwargs=add_y_rootincl_kwargs,
                    sys_ml=sys_ml,
                    randomize_positions=randomize_positions,
                    randomize_motion_artifacts=randomize_motion_artifacts,
                    randomize_joint_params=randomize_joint_params,
                    randomize_hz=randomize_hz,
                    randomize_hz_kwargs=randomize_hz_kwargs,
                    imu_motion_artifacts=imu_motion_artifacts,
                    imu_motion_artifacts_kwargs=imu_motion_artifacts_kwargs,
                    dynamic_simulation=dynamic_simulation,
                    dynamic_simulation_kwargs=dynamic_simulation_kwargs,
                    output_transform=output_transform,
                    keep_output_extras=keep_output_extras,
                    use_link_number_in_Xy=use_link_number_in_Xy,
                    cor=cor,
                )
            )

        self._n_mconfigs = len(config)
        self._size_of_generators = [self._n_mconfigs] * len(self.gens)

        self._disable_tqdm = disable_tqdm

    def _compute_repeats(self, sizes: int | list[int]) -> list[int]:
        "how many times the generators are repeated to create a batch of `sizes`"

        S, L = sum(self._size_of_generators), len(self._size_of_generators)

        def assert_size(size: int):
            assert self._n_mconfigs in utils.primes(size), (
                f"`size`={size} is not divisible by number of "
                + f"`mconfigs`={self._n_mconfigs}"
            )

        if isinstance(sizes, int):
            assert (sizes // S) > 0, f"Batchsize or size too small. {sizes} < {S}"
            assert sizes % S == 0, f"`size`={sizes} not divisible by {S}"
            repeats = L * [sizes // S]
        else:
            for size in sizes:
                assert_size(size)

            assert len(sizes) == len(
                self.gens
            ), f"len(`sizes`)={len(sizes)} != {len(self.gens)}"

            repeats = [
                size // size_of_gen
                for size, size_of_gen in zip(sizes, self._size_of_generators)
            ]
            assert 0 not in repeats

        return repeats

    def to_lazy_gen(
        self, sizes: int | list[int] = 1, jit: bool = True
    ) -> types.BatchedGenerator:
        return batch.generators_lazy(self.gens, self._compute_repeats(sizes), jit)

    @staticmethod
    def _number_of_executions_required(size: int) -> int:
        _, vmap = utils.distribute_batchsize(size)

        eager_threshold = utils.batchsize_thresholds()[1]
        primes = iter(utils.primes(vmap))
        n_calls = 1
        while vmap > eager_threshold:
            prime = next(primes)
            n_calls *= prime
            vmap /= prime

        return n_calls

    def to_list(self, sizes: int | list[int] = 1, seed: int = 1):
        "Returns list of unbatched sequences as numpy arrays."
        repeats = self._compute_repeats(sizes)
        sizes = list(jnp.array(repeats) * jnp.array(self._size_of_generators))

        reduced_repeats = []
        n_calls = []
        for size, repeat in zip(sizes, repeats):
            n_call = self._number_of_executions_required(size)
            gcd = utils.gcd(n_call, repeat)
            n_calls.append(gcd)
            reduced_repeats.append(repeat // gcd)
        jits = [N > 1 for N in n_calls]

        gens = []
        for i in range(len(repeats)):
            gens.append(
                batch.generators_lazy([self.gens[i]], [reduced_repeats[i]], jits[i])
            )

        return batch.generators_eager_to_list(gens, n_calls, seed, self._disable_tqdm)

    def to_pickle(
        self,
        path: str,
        sizes: int | list[int] = 1,
        seed: int = 1,
        overwrite: bool = True,
    ) -> None:
        data = tree_utils.tree_batch(self.to_list(sizes, seed))
        utils.pickle_save(data, path, overwrite=overwrite)

    def to_eager_gen(
        self,
        batchsize: int = 1,
        sizes: int | list[int] = 1,
        seed: int = 1,
        shuffle: bool = True,
        transform=None,
    ) -> types.BatchedGenerator:
        data = self.to_list(sizes, seed)
        assert len(data) >= batchsize
        return self.eager_gen_from_list(data, batchsize, shuffle, transform)

    @staticmethod
    def eager_gen_from_list(
        data: list[tree_utils.PyTree],
        batchsize: int,
        shuffle: bool = True,
        transform=None,
    ) -> types.BatchedGenerator:
        data = data.copy()
        n_batches, i = len(data) // batchsize, 0

        def generator(key: jax.Array):
            nonlocal i
            if shuffle and i == 0:
                random.shuffle(data)

            start, stop = i * batchsize, (i + 1) * batchsize
            batch = tree_utils.tree_batch(data[start:stop], backend="numpy")
            batch = utils.pytree_deepcopy(batch)
            if transform is not None:
                batch = transform(batch)

            i = (i + 1) % n_batches
            return batch

        return generator

@struct.dataclass
class System(_Base):
    "System object. Create using `System.create(path_xml)`"
    link_parents: list[int] = struct.field(False)
    links: Link
    link_types: list[str] = struct.field(False)
    link_damping: jax.Array
    link_armature: jax.Array
    link_spring_stiffness: jax.Array
    link_spring_zeropoint: jax.Array
    # simulation timestep size
    dt: float = struct.field(False)
    # geometries in the system
    geoms: list[Geometry]
    # root / base acceleration offset
    gravity: jax.Array = struct.field(default_factory=lambda: jnp.array([0, 0, -9.81]))

    integration_method: str = struct.field(
        False, default_factory=lambda: "semi_implicit_euler"
    )
    mass_mat_iters: int = struct.field(False, default_factory=lambda: 0)

    link_names: list[str] = struct.field(False, default_factory=lambda: [])

    model_name: Optional[str] = struct.field(False, default_factory=lambda: None)

    omc: list[MaxCoordOMC | None] = struct.field(True, default_factory=lambda: [])

    def num_links(self) -> int:
        return len(self.link_parents)

    def q_size(self) -> int:
        return sum([Q_WIDTHS[typ] for typ in self.link_types])

    def qd_size(self) -> int:
        return sum([QD_WIDTHS[typ] for typ in self.link_types])

    def name_to_idx(self, name: str) -> int:
        return self.link_names.index(name)

    def idx_to_name(self, idx: int, allow_world: bool = False) -> str:
        if allow_world and idx == -1:
            return "world"
        assert idx >= 0, "Worldbody index has no name."
        return self.link_names[idx]

    def idx_map(self, type: str) -> dict:
        "type: is either `l` or `q` or `d`"
        dict_int_slices = {}

        def f(_, idx_map, name: str, link_idx: int):
            dict_int_slices[name] = idx_map[type](link_idx)

        self.scan(f, "ll", self.link_names, list(range(self.num_links())))

        return dict_int_slices

    def parent_name(self, name: str) -> str:
        return self.idx_to_name(self.link_parents[self.name_to_idx(name)])

    def add_prefix(self, prefix: str = "") -> "System":
        return self.replace(link_names=[prefix + name for name in self.link_names])

    def change_model_name(
        self,
        new_name: Optional[str] = None,
        prefix: Optional[str] = None,
        suffix: Optional[str] = None,
    ) -> "System":
        if prefix is None:
            prefix = ""
        if suffix is None:
            suffix = ""
        if new_name is None:
            new_name = self.model_name
        name = prefix + new_name + suffix
        return self.replace(model_name=name)

    def change_link_name(self, old_name: str, new_name: str) -> "System":
        old_idx = self.name_to_idx(old_name)
        new_link_names = self.link_names.copy()
        new_link_names[old_idx] = new_name
        return self.replace(link_names=new_link_names)

    def add_prefix_suffix(
        self, prefix: Optional[str] = None, suffix: Optional[str] = None
    ) -> "System":
        if prefix is None:
            prefix = ""
        if suffix is None:
            suffix = ""
        new_link_names = [prefix + name + suffix for name in self.link_names]
        return self.replace(link_names=new_link_names)

    def _replace_free_with_cor(self) -> "System":
        # check that
        # - all free joints connect to -1
        # - all joints connecting to -1 are free joints
        for i, p in enumerate(self.link_parents):
            link_type = self.link_types[i]
            if (p == -1 and link_type != "free") or (link_type == "free" and p != -1):
                raise InvalidSystemError(
                    f"link={self.idx_to_name(i)}, parent="
                    f"{self.idx_to_name(p, allow_world=True)},"
                    f" joint={link_type}. Hint: Try setting `config.cor` to false."
                )

        def logic_replace_free_with_cor(name, olt, ola, old, ols, olz):
            # by default new is equal to old
            nlt, nla, nld, nls, nlz = olt, ola, old, ols, olz

            # old link type == free
            if olt == "free":
                # cor joint is (free, p3d) stacked
                nlt = "cor"
                # entries of old armature are 3*ang (spherical), 3*pos (p3d)
                nla = jnp.concatenate((ola, ola[3:]))
                nld = jnp.concatenate((old, old[3:]))
                nls = jnp.concatenate((ols, ols[3:]))
                nlz = jnp.concatenate((olz, olz[4:]))

            return nlt, nla, nld, nls, nlz

        return _update_sys_if_replace_joint_type(self, logic_replace_free_with_cor)

    def freeze(self, name: str | list[str]):
        if isinstance(name, list):
            sys = self
            for n in name:
                sys = sys.freeze(n)
            return sys

        def logic_freeze(link_name, olt, ola, old, ols, olz):
            nlt, nla, nld, nls, nlz = olt, ola, old, ols, olz

            if link_name == name:
                nlt = "frozen"
                nla = nld = nls = nlz = jnp.array([])

            return nlt, nla, nld, nls, nlz

        return _update_sys_if_replace_joint_type(self, logic_freeze)

    def unfreeze(self, name: str, new_joint_type: str):
        assert self.link_types[self.name_to_idx(name)] == "frozen"
        assert new_joint_type != "frozen"

        return self.change_joint_type(name, new_joint_type)

    def change_joint_type(
        self,
        name: str,
        new_joint_type: str,
        new_arma: Optional[jax.Array] = None,
        new_damp: Optional[jax.Array] = None,
        new_stif: Optional[jax.Array] = None,
        new_zero: Optional[jax.Array] = None,
        seed: int = 1,
    ):
        "By default damping, stiffness are set to zero."
        from ring.algorithms import get_joint_model

        q_size, qd_size = Q_WIDTHS[new_joint_type], QD_WIDTHS[new_joint_type]

        def logic_unfreeze_to_spherical(link_name, olt, ola, old, ols, olz):
            nlt, nla, nld, nls, nlz = olt, ola, old, ols, olz

            if link_name == name:
                nlt = new_joint_type
                q_zeros = jnp.zeros((q_size))
                qd_zeros = jnp.zeros((qd_size,))

                nla = qd_zeros if new_arma is None else new_arma
                nld = qd_zeros if new_damp is None else new_damp
                nls = qd_zeros if new_stif is None else new_stif
                nlz = q_zeros if new_zero is None else new_zero

                # unit quaternion
                if new_joint_type in ["spherical", "free", "cor"] and new_zero is None:
                    nlz = nlz.at[0].set(1.0)

            return nlt, nla, nld, nls, nlz

        sys = _update_sys_if_replace_joint_type(self, logic_unfreeze_to_spherical)

        jm = get_joint_model(new_joint_type)
        if jm.init_joint_params is not None:
            sys = sys.from_str(sys.to_str(), seed=seed)

        return sys

    def findall_imus(self) -> list[str]:
        return [name for name in self.link_names if name[:3] == "imu"]

    def findall_segments(self) -> list[str]:
        imus = self.findall_imus()
        return [name for name in self.link_names if name not in imus]

    def _bodies_indices_to_bodies_name(self, bodies: list[int]) -> list[str]:
        return [self.idx_to_name(i) for i in bodies]

    def findall_bodies_to_world(self, names: bool = False) -> list[int] | list[str]:
        bodies = [i for i, p in enumerate(self.link_parents) if p == -1]
        return self._bodies_indices_to_bodies_name(bodies) if names else bodies

    def find_body_to_world(self, name: bool = False) -> int | str:
        bodies = self.findall_bodies_to_world(names=name)
        assert len(bodies) == 1
        return bodies[0]

    def findall_bodies_with_jointtype(
        self, typ: str, names: bool = False
    ) -> list[int] | list[str]:
        bodies = [i for i, _typ in enumerate(self.link_types) if _typ == typ]
        return self._bodies_indices_to_bodies_name(bodies) if names else bodies

    def scan(self, f: Callable, in_types: str, *args, reverse: bool = False):
        """Scan `f` along each link in system whilst carrying along state.

        Args:
            f (Callable[..., Y]): f(y: Y, *args) -> y
            in_types: string specifying the type of each input arg:
                'l' is an input to be split according to link ranges
                'q' is an input to be split according to q ranges
                'd' is an input to be split according to qd ranges
            args: Arguments passed to `f`, and split to match the link.
            reverse (bool, optional): If `true` from leaves to root. Defaults to False.

        Returns:
            ys: Stacked output y of f.
        """
        return _scan_sys(self, f, in_types, *args, reverse=reverse)

    def parse(self) -> "System":
        """Initial setup of system. System object does not work unless it is parsed.
        Currently it does:
        - some consistency checks
        - populate the spatial inertia tensors
        - check that all names are unique
        - check that names are strings
        - check that all pos_min <= pos_max (unless traced)
        - order geoms in ascending order based on their parent link idx
        - check that all links have the correct size of
            - damping
            - armature
            - stiffness
            - zeropoint
        - check that n_links == len(sys.omc)
        """
        return _parse_system(self)

    def render(
        self,
        xs: Optional[Transform | list[Transform]] = None,
        camera: Optional[str] = None,
        show_pbar: bool = True,
        backend: str = "mujoco",
        render_every_nth: int = 1,
        **scene_kwargs,
    ) -> list[np.ndarray]:
        """Render frames from system and trajectory of maximal coordinates `xs`.

        Args:
            sys (base.System): System to render.
            xs (base.Transform | list[base.Transform]): Single or time-series
            of maximal coordinates `xs`.
            show_pbar (bool, optional): Whether or not to show a progress bar.
            Defaults to True.

        Returns:
            list[np.ndarray]: Stacked rendered frames. Length == len(xs).
        """
        return ring.rendering.render(
            self, xs, camera, show_pbar, backend, render_every_nth, **scene_kwargs
        )

    def render_prediction(
        self,
        xs: Transform | list[Transform],
        yhat: dict | jax.Array | np.ndarray,
        # by default we don't predict the global rotation
        transparent_segment_to_root: bool = True,
        **kwargs,
    ):
        "`xs` matches `sys`. `yhat` matches `sys_noimu`. `yhat` are child-to-parent."
        return ring.rendering.render_prediction(
            self, xs, yhat, transparent_segment_to_root, **kwargs
        )

    def delete_system(self, link_name: str | list[str], strict: bool = True):
        "Cut subsystem starting at `link_name` (inclusive) from tree."
        return ring.sys_composer.delete_subsystem(self, link_name, strict)

    def make_sys_noimu(self, imu_link_names: Optional[list[str]] = None):
        "Returns, e.g., imu_attachment = {'imu1': 'seg1', 'imu2': 'seg3'}"
        return ring.sys_composer.make_sys_noimu(self, imu_link_names)

    def inject_system(self, other_system: "System", at_body: Optional[str] = None):
        """Combine two systems into one.

        Args:
            sys (base.System): Large system.
            sub_sys (base.System): Small system that will be included into the
                large system `sys`.
            at_body (Optional[str], optional): Into which body of the large system
                small system will be included. Defaults to `worldbody`.

        Returns:
            base.System: _description_
        """
        return ring.sys_composer.inject_system(self, other_system, at_body)

    def morph_system(
        self,
        new_parents: Optional[list[int | str]] = None,
        new_anchor: Optional[int | str] = None,
    ):
        """Re-orders the graph underlying the system. Returns a new system.

        Args:
            sys (base.System): System to be modified.
            new_parents (list[int]): Let the i-th entry have value j. Then, after
                morphing the system the system will be such that the link corresponding
                to the i-th link in the old system will have as parent the link
                corresponding to the j-th link in the old system.

        Returns:
            base.System: Modified system.
        """
        return ring.sys_composer.morph_system(self, new_parents, new_anchor)

    @staticmethod
    def from_xml(path: str, seed: int = 1):
        return ring.io.load_sys_from_xml(path, seed)

    @staticmethod
    def from_str(xml: str, seed: int = 1):
        return ring.io.load_sys_from_str(xml, seed)

    def to_str(self) -> str:
        return ring.io.save_sys_to_str(self)

    def to_xml(self, path: str) -> None:
        ring.io.save_sys_to_xml(self, path)

    @classmethod
    def create(cls, path_or_str: str, seed: int = 1) -> "System":
        path = Path(path_or_str).with_suffix(".xml")

        exists = False
        try:
            exists = path.exists()
        except OSError:
            # file length too length
            pass

        if exists:
            return cls.from_xml(path, seed=seed)
        else:
            return cls.from_str(path_or_str)

    def coordinate_vector_to_q(
        self,
        q: jax.Array,
        custom_joints: dict[str, Callable] = {},
    ) -> jax.Array:
        """Map a coordinate vector `q` to the minimal coordinates vector of the sys"""
        # Does, e.g.
        # - normalize quaternions
        # - hinge joints in [-pi, pi]
        q_preproc = []

        def preprocess(_, __, link_type, q):
            to_q = ring.algorithms.jcalc.get_joint_model(
                link_type
            ).coordinate_vector_to_q
            # function in custom_joints has priority over JointModel
            if link_type in custom_joints:
                to_q = custom_joints[link_type]
            if to_q is None:
                raise NotImplementedError(
                    f"Please specify the custom joint `{link_type}`"
                    " either using the `custom_joints` arguments or using the"
                    " JointModel.coordinate_vector_to_q field."
                )
            new_q = to_q(q)
            q_preproc.append(new_q)

        self.scan(preprocess, "lq", self.link_types, q)
        return jnp.concatenate(q_preproc)

@dataclass
class MotionConfig:
    T: float = 60.0  # length of random motion
    t_min: float = 0.05  # min time between two generated angles
    t_max: float | TimeDependentFloat = 0.30  # max time ..

    dang_min: float | TimeDependentFloat = 0.1  # minimum angular velocity in rad/s
    dang_max: float | TimeDependentFloat = 3.0  # maximum angular velocity in rad/s

    # minimum angular velocity of euler angles used for `free and spherical joints`
    dang_min_free_spherical: float | TimeDependentFloat = 0.1
    dang_max_free_spherical: float | TimeDependentFloat = 3.0

    # max min allowed actual delta values in radians
    delta_ang_min: float | TimeDependentFloat = 0.0
    delta_ang_max: float | TimeDependentFloat = 2 * jnp.pi
    delta_ang_min_free_spherical: float | TimeDependentFloat = 0.0
    delta_ang_max_free_spherical: float | TimeDependentFloat = 2 * jnp.pi

    dpos_min: float | TimeDependentFloat = 0.001  # speed of translation
    dpos_max: float | TimeDependentFloat = 0.7
    pos_min: float | TimeDependentFloat = -2.5
    pos_max: float | TimeDependentFloat = +2.5

    # used by both `random_angle_*` and `random_pos_*`
    # only used if `randomized_interpolation` is set
    cdf_bins_min: int = 5
    # by default equal to `cdf_bins_min`
    cdf_bins_max: Optional[int] = None

    # flags
    randomized_interpolation_angle: bool = False
    randomized_interpolation_position: bool = False
    interpolation_method: str = "cosine"
    range_of_motion_hinge: bool = True
    range_of_motion_hinge_method: str = "uniform"

    # initial value of joints
    ang0_min: float = -jnp.pi
    ang0_max: float = jnp.pi
    pos0_min: float = 0.0
    pos0_max: float = 0.0

    # cor (center of rotation) custom fields
    cor_t_min: float = 0.2
    cor_t_max: float | TimeDependentFloat = 2.0
    cor_dpos_min: float | TimeDependentFloat = 0.00001
    cor_dpos_max: float | TimeDependentFloat = 0.5
    cor_pos_min: float | TimeDependentFloat = -0.4
    cor_pos_max: float | TimeDependentFloat = 0.4

    def is_feasible(self) -> bool:
        return _is_feasible_config1(self)

    def to_nomotion_config(self) -> "MotionConfig":
        kwargs = asdict(self)
        for key in [
            "dang_min",
            "dang_max",
            "delta_ang_min",
            "dang_min_free_spherical",
            "dang_max_free_spherical",
            "delta_ang_min_free_spherical",
            "dpos_min",
            "dpos_max",
        ]:
            kwargs[key] = 0.0
        nomotion_config = MotionConfig(**kwargs)
        assert nomotion_config.is_feasible()
        return nomotion_config

    @staticmethod
    def from_register(name: str) -> "MotionConfig":
        return _registered_motion_configs[name]