stbkit 0.1.0a9.dev1__py3-none-any.whl

stbkit/tools/converters/_internal/stb_latest_to_element_data/member/member_plane.py

@@ -0,0 +1,103 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_reporting import Reporter
+
+from stbkit.api import stb_latest
+from stbkit.api.experimental.repository import RepositoryLatest
+
+from ....._internal.data_model.element_data import ElementPlane, ElementType
+from ....._internal.vectors import Vector3d
+from ... import coord_converter
+from ..section import sec
+
+
+def stb_wall_to_ifc_data(
+    stb_wall: stb_latest.StbWall,
+    node_coords: dict[int, Vector3d],
+    repo: RepositoryLatest,
+    stb_id_to_planes: dict[int, ElementPlane],
+    reporter: Reporter,
+) -> ElementPlane:
+    points: list[Vector3d] = []
+    node_ids: list[int] = list(stb_wall.stb_node_id_order.content)
+    node_points: list[Vector3d] = [node_coords[id] for id in node_ids]
+    for id in node_ids:
+        point: Vector3d = node_coords[id]
+        if stb_wall.stb_wall_offset_list_or_none is not None:
+            for stb_offset in stb_wall.stb_wall_offset_list.stb_wall_offset:
+                if stb_offset.id_node == id:
+                    offset: Vector3d = Vector3d(
+                        stb_offset.offset_x,
+                        stb_offset.offset_y,
+                        stb_offset.offset_z,
+                    )
+                    point += offset
+                    break
+        points.append(point)
+    thickness: float = sec.get_wall_t(repo, stb_wall, reporter)
+    (_vx, _vy, vz) = coord_converter.axis_vector_plate(points)
+    points = [point - thickness / 2.0 * vz for point in points]
+    name: str = str(stb_wall.id)
+
+    if stb_wall.name:
+        name += f"_{stb_wall.name}"
+    plate: ElementPlane = ElementPlane(
+        element_type=ElementType.WALL,
+        name=name,
+        guid=stb_wall.guid_or_none,
+        points=points,
+        thickness=thickness,
+        path=stb_wall._path_xml(),
+        node_ids=node_ids,
+        node_points=node_points,
+    )
+    stb_id_to_planes[stb_wall.id] = plate
+    return plate
+
+
+def stb_slab_to_ifc_data(
+    stb_slab: stb_latest.StbSlab,
+    node_coords: dict[int, Vector3d],
+    repo: RepositoryLatest,
+    stb_id_to_planes: dict[int, ElementPlane],
+    reporter: Reporter,
+) -> ElementPlane:
+    points: list[Vector3d] = []
+    node_ids: list[int] = list(stb_slab.stb_node_id_order.content)
+    node_points: list[Vector3d] = [node_coords[id] for id in node_ids]
+    for id in node_ids:
+        point: Vector3d = node_coords[id]
+        if stb_slab.stb_slab_offset_list_or_none:
+            for stb_offset in stb_slab.stb_slab_offset_list.stb_slab_offset:
+                if stb_offset.id_node == id:
+                    offset: Vector3d = Vector3d(
+                        stb_offset.offset_x,
+                        stb_offset.offset_y,
+                        stb_offset.offset_z,
+                    )
+                    point += offset
+                    break
+        points.append(point)
+    thickness: float = sec.get_slab_depth(repo, stb_slab, reporter)
+    (_vx, _vy, vz) = coord_converter.axis_vector_plate(points)
+    points = [point - thickness * vz for point in points]
+    name: str = str(stb_slab.id)
+
+    if stb_slab.name:
+        name += f"_{stb_slab.name}"
+    plate: ElementPlane = ElementPlane(
+        element_type=ElementType.SLAB,
+        name=name,
+        guid=stb_slab.guid_or_none,
+        points=points,
+        thickness=thickness,
+        path=stb_slab._path_xml(),
+        node_ids=node_ids,
+        node_points=node_points,
+    )
+    stb_id_to_planes[stb_slab.id] = plate
+    return plate

stbkit/tools/converters/_internal/stb_latest_to_element_data/open.py

@@ -0,0 +1,70 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_exceptions import NoneAccessError
+from stbkit.core.stb_reporting import Code, Phase, Reporter
+
+from stbkit.api.stb_latest import StbModel, StbOpenArrangement, StbSecOpenRc
+
+from ...._internal.data_model.element_data import ElementPlane
+from ...._internal.vectors import Vector2d
+
+
+def add_open(
+    stb_model: StbModel,
+    stb_id_to_planes: dict[int, ElementPlane],
+    *,
+    reporter: Reporter,
+) -> None:
+    """開口の追加
+    TODO:回転は未実装"""
+    try:
+        stb_opens: list[StbOpenArrangement] = (
+            stb_model.stb_members.stb_open_arrangements.stb_open_arrangement
+        )
+        stb_sec_opens: list[StbSecOpenRc] = stb_model.stb_sections.stb_sec_open_rc
+    except NoneAccessError:
+        return
+    for stb_open in stb_opens:
+        if stb_open.rotate_or_none is not None and stb_open.rotate != 0.0:
+            reporter.warning(
+                message="開口の回転は未実装です",
+                code=Code.NOT_IMPLEMENTED,
+                phase=Phase.CONVERT_GEOMETRY,
+                stb_element=stb_open,
+                attr_name="rotate",
+            )
+        stb_sec_open: StbSecOpenRc | None = next(
+            filter(
+                lambda obj: obj is not None and obj.id == stb_open.id_section,
+                stb_sec_opens,
+            ),
+            None,
+        )
+        if not stb_sec_open:
+            continue
+        plane: ElementPlane = stb_id_to_planes[stb_open.id_member]
+        if not plane.thickness:
+            continue
+        opens: list[list[Vector2d]] = plane.opens
+        x = stb_open.position_x
+        y = stb_open.position_y
+        if (
+            stb_sec_open.length_x_or_none is None
+            or stb_sec_open.length_y_or_none is None
+        ):
+            continue
+        w = stb_sec_open.length_x
+        h = stb_sec_open.length_y
+        if x is not None and y is not None and w and h:
+            opens.append(
+                [
+                    Vector2d(x, y),
+                    Vector2d(x + w, y),
+                    Vector2d(x + w, y + h),
+                    Vector2d(x, y + h),
+                ]
+            )

stbkit/tools/converters/_internal/stb_latest_to_element_data/section/sec.py

@@ -0,0 +1,214 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.data_model.common import StBridgeElement
+from stbkit.core.stb_exceptions import (
+    NoneAccessError,
+    ReferenceElementNotFoundError,
+    SchemaError,
+)
+from stbkit.core.stb_reporting import Code, Phase, Reporter
+
+from stbkit.api import stb_latest
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import (
+    StbBeam,
+    StbBrace,
+    StbColumn,
+    StbFoundationColumn,
+    StbGirder,
+    StbParapet,
+    StbPile,
+    StbPost,
+    StbSecBeamRc,
+    StbSecBeamS,
+    StbSecBeamSrc,
+    StbSecBraceS,
+    StbSecColumnCft,
+    StbSecColumnRc,
+    StbSecColumnS,
+    StbSecColumnSrc,
+    StbSecFoundationRc,
+    StbSecParapetRc,
+    StbSecPileRc,
+    StbSecPileS,
+    StbSecUndefined,
+    StbStripFooting,
+)
+
+from ....._internal.constants import UNKNOWN_ELEMENT_SIZE_MM
+from ....._internal.data_model.shape_data import (
+    SHAPE_PAIRS_UNDEFINED,
+    ShapePair,
+)
+from ....._internal.utils.unit_utils import mm_to_m
+from ....._internal.vectors import Vector2d
+from . import (
+    sec_beam_rc,
+    sec_beam_s,
+    sec_beam_src,
+    sec_brace_s,
+    sec_column_cft,
+    sec_column_rc,
+    sec_column_s,
+    sec_column_src,
+    sec_foundation,
+    sec_parapet_rc,
+    sec_pile_rc,
+    sec_pile_s,
+)
+
+
+def get_shapes_element_line(
+    repo: RepositoryLatest,
+    ele: StbColumn
+    | StbGirder
+    | StbPost
+    | StbBeam
+    | StbBrace
+    | StbStripFooting
+    | StbPile
+    | StbFoundationColumn
+    | StbParapet,
+    reporter: Reporter,
+) -> list[ShapePair] | tuple[list[ShapePair], list[ShapePair]] | None:
+    if isinstance(ele, StbFoundationColumn):
+        foundation_column_shapes: list[ShapePair] = []
+        if ele.id_section_fd_or_none is not None:
+            try:
+                section_fd: StbSecColumnRc = repo.get(StbSecColumnRc, ele.id_section_fd)
+                shapes_fd: list[ShapePair] = sec_column_rc.stb_sec_column_rc_to_shapes(
+                    section_fd
+                )
+                if shapes_fd:
+                    foundation_column_shapes.extend(shapes_fd)
+            except ReferenceElementNotFoundError:
+                pass
+        if ele.id_section_wr_or_none is not None:
+            try:
+                section_wr: StbSecColumnRc = repo.get(StbSecColumnRc, ele.id_section_wr)
+                shapes_wr: list[ShapePair] = sec_column_rc.stb_sec_column_rc_to_shapes(
+                    section_wr
+                )
+                if shapes_wr:
+                    if (ele.offset_wr_x_or_none or ele.offset_wr_y_or_none) and (
+                        ele.offset_fd_x_or_none or ele.offset_fd_y_or_none
+                    ):
+                        rotate: float = ele.rotate_or_none or 0.0
+                        offset_fd: Vector2d = Vector2d(
+                            ele.offset_fd_x_or_none or 0.0,
+                            ele.offset_fd_y_or_none or 0.0,
+                        )
+                        offset_wr: Vector2d = Vector2d(
+                            ele.offset_wr_x_or_none or 0.0,
+                            ele.offset_wr_y_or_none or 0.0,
+                        )
+                        offset_wr = offset_wr.rotate(-rotate) - offset_fd.rotate(
+                            -rotate
+                        )
+                        for item in shapes_wr:
+                            item.start.offset = offset_wr
+                            if item.end:
+                                item.end.offset = offset_wr
+                    foundation_column_shapes.extend(shapes_wr)
+            except ReferenceElementNotFoundError:
+                pass
+        return foundation_column_shapes
+    try:
+        section: StBridgeElement = repo.deref(ele).id_section
+    except ReferenceElementNotFoundError:
+        return None
+    except SchemaError:
+        reporter.error(
+            message="断面参照が不正です",
+            code=Code.SCHEMA_ERROR,
+            phase=Phase.CONVERT_GEOMETRY,
+            stb_element=ele,
+            attr_name="id_section",
+        )
+        return None
+    match section:
+        case StbSecColumnRc():
+            return sec_column_rc.stb_sec_column_rc_to_shapes(section)
+        case StbSecColumnS():
+            return sec_column_s.stb_sec_column_s_to_shapes(repo, section, reporter)
+        case StbSecColumnSrc():
+            return sec_column_src.stb_sec_column_src_to_shapes(repo, section, reporter)
+        case StbSecColumnCft():
+            return sec_column_cft.stb_sec_column_cft_to_shapes(repo, section, reporter)
+        case StbSecBeamRc():
+            return sec_beam_rc.stb_sec_beam_rc_to_shapes(section)
+        case StbSecBeamS():
+            return sec_beam_s.stb_sec_beam_s_to_shapes(repo, section, reporter)
+        case StbSecBeamSrc():
+            return sec_beam_src.stb_sec_beam_src_to_shapes(repo, section, reporter)
+        case StbSecBraceS():
+            return sec_brace_s.stb_sec_brace_s_to_shapes(repo, section, reporter)
+        case StbSecFoundationRc():
+            shapes, _ = sec_foundation.stb_sec_foundation_rc_to_shapes_and_depth(
+                section, reporter
+            )
+            return shapes
+        case StbSecPileRc():
+            return sec_pile_rc.stb_sec_pile_rc_to_shapes(section, reporter)
+        case StbSecPileS():
+            shapes, _ = sec_pile_s.stb_sec_pile_s_to_shapes_and_length(section)
+            return shapes
+        case StbSecParapetRc():
+            return sec_parapet_rc.stb_sec_parapet_rc_to_shapes(section, reporter)
+        case StbSecUndefined():
+            return SHAPE_PAIRS_UNDEFINED
+        case _:
+            return None
+
+
+def get_slab_depth(
+    repo: RepositoryLatest, stb_slab: stb_latest.StbSlab, reporter: Reporter
+) -> float:
+    try:
+        section = repo.deref(stb_slab).id_section_or_none
+    except SchemaError:
+        section = None
+    if isinstance(section, stb_latest.StbSecSlabRc):
+        try:
+            return section.stb_sec_slab_rc_conventional.stb_sec_figure_slab_rc_conventional.stb_sec_slab_rc_conventional_straight.depth
+        except NoneAccessError:
+            pass
+    reporter.warning(
+        message=(
+            f"スラブ断面id={stb_slab.id_section_or_none}が"
+            f"見つかりませんでした。d={UNKNOWN_ELEMENT_SIZE_MM}mmで代替します"
+        ),
+        code=Code.MISSING_ATTRIBUTE,
+        phase=Phase.CONVERT_IFC,
+        stb_element=stb_slab,
+        attr_name="id_section",
+    )
+    return mm_to_m(UNKNOWN_ELEMENT_SIZE_MM)
+
+
+def get_wall_t(
+    repo: RepositoryLatest, stb_wall: stb_latest.StbWall, reporter: Reporter
+) -> float:
+    try:
+        section = repo.deref(stb_wall).id_section_or_none
+    except SchemaError:
+        section = None
+    if isinstance(section, stb_latest.StbSecWallRc):
+        fig: stb_latest.StbSecFigureWallRc = section.stb_sec_figure_wall_rc
+        if fig.stb_sec_wall_rc_straight:
+            return fig.stb_sec_wall_rc_straight.t
+    reporter.warning(
+        message=(
+            f"壁断面id={stb_wall.id_section_or_none}が"
+            f"見つかりませんでした。t={UNKNOWN_ELEMENT_SIZE_MM}mmで代替します"
+        ),
+        code=Code.MISSING_ATTRIBUTE,
+        phase=Phase.CONVERT_IFC,
+        stb_element=stb_wall,
+        attr_name="id_section",
+    )
+    return mm_to_m(UNKNOWN_ELEMENT_SIZE_MM)

stbkit/tools/converters/_internal/stb_latest_to_element_data/section/sec_beam_rc.py

@@ -0,0 +1,67 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.api.stb_latest import (
+    StbSecBeamRc,
+    StbSecBeamSrc,
+    StbSecBeamStraight,
+    StbSecBeamTaper,
+    StbSecFigureBeamRc,
+    StbSecFigureBeamSrc,
+)
+
+from ....._internal.data_model.shape_data import (
+    SHAPE_PAIR_UNKNOWN,
+    ShapePair,
+    ShapeRectangle,
+)
+
+
+def stb_figure_beam_rc_to_shapes(
+    figure: StbSecFigureBeamRc | StbSecFigureBeamSrc, name: str
+) -> ShapePair:
+    if figure.stb_sec_beam_straight_or_none:
+        straight: StbSecBeamStraight = figure.stb_sec_beam_straight
+        return ShapePair(
+            ShapeRectangle(
+                name=name,
+                width_x=straight.width,
+                width_y=straight.depth,
+            )
+        )
+    elif figure.stb_sec_beam_taper_or_none:
+        taper: StbSecBeamTaper = figure.stb_sec_beam_taper
+        shape_start: ShapeRectangle = ShapeRectangle(
+            name=name + "_start",
+            width_x=taper.start_width,
+            width_y=taper.start_depth,
+        )
+        shape_end: ShapeRectangle = ShapeRectangle(
+            name=name + "_end",
+            width_x=taper.end_width,
+            width_y=taper.end_depth,
+        )
+        return ShapePair(shape_start, shape_end)
+    else:
+        return SHAPE_PAIR_UNKNOWN
+
+
+def stb_sec_beam_rc_to_shapes(
+    stb_sec_beam_rc: StbSecBeamRc,
+) -> list[ShapePair]:
+    result: list[ShapePair] = []
+    for figure in stb_sec_beam_rc.stb_sec_figure_beam_rc:
+        result.append(stb_figure_beam_rc_to_shapes(figure, stb_sec_beam_rc.name))
+    return result
+
+
+def stb_sec_beam_src_to_shapes_rc(
+    stb_sec_beam_src: StbSecBeamSrc,
+) -> list[ShapePair]:
+    result: list[ShapePair] = []
+    for figure in stb_sec_beam_src.stb_sec_figure_beam_src:
+        result.append(stb_figure_beam_rc_to_shapes(figure, stb_sec_beam_src.name))
+    return result

stbkit/tools/converters/_internal/stb_latest_to_element_data/section/sec_beam_s.py

@@ -0,0 +1,97 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_exceptions import StbError
+from stbkit.core.stb_reporting import Code, Phase, Reporter
+
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import (
+    StbSecBeamS,
+    StbSecBeamSrc,
+    StbSecSteelFigureBeamS,
+    StbSecSteelFigureBeamSrc,
+)
+
+from ....._internal.data_model.shape_data import (
+    Shape,
+    ShapePair,
+)
+from ....._internal.vectors import Vector2d
+from . import sec_steel
+
+
+def stb_sec_beam_s_to_shapes(
+    repo: RepositoryLatest,
+    sec_b_s: StbSecBeamS | StbSecBeamSrc,
+    reporter: Reporter,
+) -> list[ShapePair]:
+    result: list[ShapePair] = []
+    try:
+        figure_b: StbSecSteelFigureBeamS | StbSecSteelFigureBeamSrc = (
+            sec_b_s.stb_sec_steel_figure_beam_s
+            if isinstance(sec_b_s, StbSecBeamS)
+            else sec_b_s.stb_sec_steel_figure_beam_src
+        )
+        for s_s_b_s_shape in (
+            figure_b.stb_sec_steel_beam_s_shape
+            if isinstance(figure_b, StbSecSteelFigureBeamS)
+            else figure_b.stb_sec_steel_beam_src_shape
+        ):
+            straight = s_s_b_s_shape.stb_sec_steel_beam_straight_or_none
+            taper = s_s_b_s_shape.stb_sec_steel_beam_taper_or_none
+            if straight:
+                shape: Shape = sec_steel.stb_sec_steel_name_to_shape(
+                    repo, straight.shape, reporter
+                )
+                if (
+                    straight.vertical_offset_or_none
+                    or straight.horizontal_offset_or_none
+                ):
+                    offset: Vector2d = Vector2d(
+                        straight.horizontal_offset_or_none or 0.0,
+                        straight.vertical_offset_or_none or 0.0,
+                    )
+                    shape.offset = offset
+                if not shape:
+                    return []
+                result.append(ShapePair(shape))
+            elif taper:
+                shape_start: Shape = sec_steel.stb_sec_steel_name_to_shape(
+                    repo, taper.start_shape, reporter
+                )
+                if (
+                    taper.start_horizontal_offset_or_none
+                    or taper.start_vertical_offset_or_none
+                ):
+                    offset_start: Vector2d = Vector2d(
+                        taper.start_horizontal_offset_or_none or 0.0,
+                        taper.start_vertical_offset_or_none or 0.0,
+                    )
+                    shape_start.offset = offset_start
+                shape_end: Shape = sec_steel.stb_sec_steel_name_to_shape(
+                    repo, taper.end_shape, reporter
+                )
+                if (
+                    taper.end_horizontal_offset_or_none
+                    or taper.end_vertical_offset_or_none
+                ):
+                    offset_end: Vector2d = Vector2d(
+                        taper.end_horizontal_offset_or_none or 0.0,
+                        taper.end_vertical_offset_or_none or 0.0,
+                    )
+                    shape_end.offset = offset_end
+                result.append(
+                    ShapePair(
+                        shape_start,
+                        shape_end,
+                    )
+                )
+        return result
+    except (StbError, RuntimeError, AssertionError, TypeError, ValueError) as e:
+        reporter.warning(
+            message=str(e), code=Code.UNEXPECTED_ERROR, phase=Phase.CONVERT_IFC
+        )
+        return result

stbkit/tools/converters/_internal/stb_latest_to_element_data/section/sec_beam_src.py

@@ -0,0 +1,28 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_reporting import Reporter
+
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import StbSecBeamSrc
+
+from ....._internal.data_model.shape_data import ShapePair
+from ...stb_latest_to_element_data.section import (
+    sec_beam_rc,
+    sec_beam_s,
+)
+
+
+def stb_sec_beam_src_to_shapes(
+    repo: RepositoryLatest,
+    sec_b_s: StbSecBeamSrc,
+    reporter: Reporter,
+) -> tuple[list[ShapePair], list[ShapePair]]:
+    result_rc: list[ShapePair] = sec_beam_rc.stb_sec_beam_src_to_shapes_rc(sec_b_s)
+    result_s: list[ShapePair] = sec_beam_s.stb_sec_beam_s_to_shapes(
+        repo, sec_b_s, reporter
+    )
+    return result_rc, result_s

stbkit/tools/converters/_internal/stb_latest_to_element_data/section/sec_brace_s.py

@@ -0,0 +1,49 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_reporting import Code, Phase, Reporter
+
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import (
+    StbSecBraceS,
+    StbSecSteelBraceSSame,
+    StbSecSteelFigureBraceS,
+)
+
+from ....._internal.data_model.shape_data import (
+    Shape,
+    ShapePair,
+)
+from .sec_steel import stb_sec_steel_name_to_shape
+
+
+def stb_sec_brace_s_to_shapes(
+    repo: RepositoryLatest,
+    stb_sec_brace_s: StbSecBraceS,
+    reporter: Reporter,
+) -> list[ShapePair]:
+    """
+    TODO:
+        - 2断面、3断面は非対応"""
+    result: list[ShapePair] = []
+    figure: StbSecSteelFigureBraceS | None = (
+        stb_sec_brace_s.stb_sec_steel_figure_brace_s_or_none
+    )
+    if figure is None:
+        reporter.warning(
+            "StbSecSteelFigureBrace_Sが設定されていません。",
+            code=Code.SCHEMA_ERROR,
+            phase=Phase.CONVERT_IFC,
+            stb_element=stb_sec_brace_s,
+        )
+
+        return result
+    if figure.stb_sec_steel_brace_s_same_or_none is not None:
+        same: StbSecSteelBraceSSame | None = figure.stb_sec_steel_brace_s_same_or_none
+        if same:
+            shape: Shape = stb_sec_steel_name_to_shape(repo, same.shape, reporter)
+            result.append(ShapePair(shape))
+    return result