RSSeismicScripting 3.0.0__py3-none-any.whl

rsseismic/Results.py

@@ -0,0 +1,419 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import pandas as pd
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import from_result_database_entry
+from rsseismic._proto_converters import (
+    from_result_database_entry,
+    from_result_layer_entry,
+    from_result_motion_entry,
+)
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._result_bulk_dataframes import (
+    fetch_bulk_dataframes,
+    fetch_bulk_layer_series_dataframes,
+    fetch_bulk_profile_series_dataframes,
+    infer_el_convergence_motion_type_filter,
+    normalize_result_motion_type_filters,
+    resolve_layer_ids,
+    select_convergence_tab_motion_names,
+    select_displacement_animation_motion_names,
+    select_profile_motion_names,
+)
+from rsseismic._result_dataframes import data_table_to_dataframe, resolve_result_series_kind
+from rsseismic._rpc_helpers import require_success
+from rsseismic.generatedFiles import ResultsService_pb2 as ResultsService_pb2
+from rsseismic.generatedFiles import ResultsService_pb2_grpc as ResultsService_pb2_grpc
+from rsseismic.types import (
+    ResultDatabaseInfo,
+    ResultLayerSummary,
+    ResultMotionSummary,
+    ResultMotionType,
+    ResultSeriesKind,
+)
+
+
+class Results(_ProxyObject):
+    """
+    Query computed analysis results for an open project.
+
+    Access via ``model.Results``. After ``model.runCompute()``, use ``listResultDatabases``
+    or ``listResultMotions()`` to discover valid profile and motion names, then fetch
+    tabular data as pandas ``DataFrame`` objects.
+
+    Use ``getResultDatabasePath`` to see which result files exist for a profile/motion
+    pair before calling specialized queries (strain convergence, displacement animation, etc.).
+    """
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self._results_service = ResultsService_pb2_grpc.ResultsServiceStub(self._client.channel)
+
+    def getResultsRoot(self) -> str:
+        """Return the folder where RSSeismic stores computed results for this project."""
+        request = ResultsService_pb2.GetResultsRootRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._results_service.GetResultsRoot, request)
+        require_success(response, "GetResultsRoot")
+        return response.resultsRoot
+
+    def listResultDatabases(
+        self,
+        profileName: str = "",
+        onlyExisting: bool = False,
+    ) -> list[ResultDatabaseInfo]:
+        """
+        List profile/motion pairs and their result file paths.
+
+        When ``profileName`` is empty, entries for all profiles are returned.
+        When ``onlyExisting`` is True, only pairs whose main result database file
+        exists on disk are included.
+
+        Use the ``motionName`` values from these entries (or from ``listResultMotions``)
+        when calling result DataFrame methods — they may differ from names shown in
+        the Motion view, especially for complementary analyses.
+        """
+        request = ResultsService_pb2.ListResultDatabasesRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            onlyExisting=onlyExisting,
+        )
+        response = self._client.callFunction(self._results_service.ListResultDatabases, request)
+        require_success(response, "ListResultDatabases")
+        return [from_result_database_entry(entry) for entry in response.entries]
+
+    def getResultDatabasePath(
+        self,
+        profileName: str,
+        motionName: str,
+    ) -> ResultDatabaseInfo:
+        """
+        Return result file paths and availability flags for one profile and motion.
+
+        ``motionName`` must be a compute-aligned name from ``listResultDatabases`` or
+        ``listResultMotions`` after ``runCompute()``. Check fields such as
+        ``resultDatabaseExists``, ``strainConvergenceExists``, and
+        ``deconvolutionBedrockMotionExists`` before calling related DataFrame methods.
+        """
+        request = ResultsService_pb2.GetResultDatabasePathRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+        )
+        response = self._client.callFunction(self._results_service.GetResultDatabasePath, request)
+        require_success(response, "GetResultDatabasePath")
+        return from_result_database_entry(response.entry)
+
+    def listResultMotions(self) -> list[ResultMotionSummary]:
+        """
+        List motion names available for result queries after compute.
+
+        Includes complementary motions when project settings add them (for example
+        ``ChiChi-EL`` derived from selected motion ``ChiChi``). Prefer these names over
+        Motion-view labels when fetching results.
+        """
+        request = ResultsService_pb2.ListResultMotionsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._results_service.ListResultMotions, request)
+        require_success(response, "ListResultMotions")
+        return [from_result_motion_entry(motion) for motion in response.motions]
+
+    def listResultLayers(self, profileName: str) -> list[ResultLayerSummary]:
+        """
+        List layers that can be used with layer-scoped result queries for a profile.
+
+        Includes soil layers with result output enabled and the top-of-rock layer when
+        bedrock output is configured.
+        """
+        if not profileName:
+            raise ValueError("Profile name is required.")
+        request = ResultsService_pb2.ListResultLayersRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._results_service.ListResultLayers, request)
+        require_success(response, "ListResultLayers")
+        return [from_result_layer_entry(layer) for layer in response.layers]
+
+    def getTopOfRockLayerId(self, profileName: str) -> str:
+        """
+        Return the layer ID to use for top-of-rock result queries on a profile.
+
+        Raises ValueError when top of rock output is not available in
+        ``listResultLayers(profileName)``.
+        """
+        for layer in self.listResultLayers(profileName):
+            if layer.isTopOfRock:
+                return layer.layerID
+        raise ValueError(
+            f"Top of rock is not available for profile '{profileName}'. "
+            "Enable bedrockOutputDeconvolution and ensure the profile is configured for top of rock output."
+        )
+
+    def getLayerTimeHistoryDataFrame(
+        self,
+        profileName: str,
+        motionName: str,
+        layerID: str,
+    ) -> pd.DataFrame:
+        """
+        Return layer time-history results as a pandas DataFrame.
+
+        Columns typically include time, acceleration, velocity, and related series for
+        the given layer. For finite-element analysis, effective vertical stress may also
+        be included.
+
+        ``motionName`` must be compute-aligned. ``layerID`` comes from
+        ``listResultLayers(profileName)`` or ``listSoilLayers()`` on the same profile.
+        Column units are in ``dataframe.attrs["column_units"]`` when available.
+        """
+        request = ResultsService_pb2.GetLayerTimeHistoryTableRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+            layerID=layerID,
+        )
+        response = self._client.callFunction(
+            self._results_service.GetLayerTimeHistoryTable,
+            request,
+        )
+        require_success(response, "GetLayerTimeHistoryTable")
+        return data_table_to_dataframe(response.table)
+
+    def getProfileResultsDataFrame(
+        self,
+        profileName: str,
+        motionName: str,
+    ) -> pd.DataFrame:
+        """
+        Return profile-level summary results as a pandas DataFrame.
+
+        Provides depth-based summary columns for the profile (for example maximum strain
+        by layer). Not available for deconvolution profiles — use layer-scoped methods instead.
+
+        ``motionName`` must be compute-aligned after ``runCompute()``.
+        """
+        request = ResultsService_pb2.GetProfileResultsTableRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+        )
+        response = self._client.callFunction(
+            self._results_service.GetProfileResultsTable,
+            request,
+        )
+        require_success(response, "GetProfileResultsTable")
+        return data_table_to_dataframe(response.table)
+
+    def getResultSeriesDataFrame(
+        self,
+        profileName: str,
+        motionName: str,
+        kind: ResultSeriesKind,
+        layerID: str = "",
+    ) -> pd.DataFrame:
+        """
+        Return one result chart series as a pandas DataFrame.
+
+        Pass a ``ResultSeriesKind`` value for ``kind`` (for example ``MAX_STRAIN``,
+        ``PGA``, ``ACCELERATION``). When ``kind.requires_layer`` is True, ``layerID``
+        is required — use ``listResultLayers(profileName)`` to obtain valid IDs.
+
+        ``motionName`` must be compute-aligned after ``runCompute()``.
+        """
+        request = ResultsService_pb2.GetResultSeriesRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+            kind=resolve_result_series_kind(kind),
+            layerID=layerID,
+        )
+        response = self._client.callFunction(
+            self._results_service.GetResultSeries,
+            request,
+        )
+        require_success(response, "GetResultSeries")
+        return data_table_to_dataframe(response.table)
+
+    def getStrainConvergenceDataFrame(
+        self,
+        profileName: str,
+        motionName: str,
+    ) -> pd.DataFrame:
+        """
+        Return equivalent-linear strain convergence data as a pandas DataFrame.
+
+        Table columns show iteration and per-layer strain values. Requires equivalent-linear
+        analysis and a computed strain-convergence file for the motion. Check
+        ``getResultDatabasePath(...).strainConvergenceExists`` before calling.
+
+        For complementary equivalent-linear runs, pass the complementary motion name
+        (for example ``ChiChi-EL``).
+        """
+        request = ResultsService_pb2.GetStrainConvergenceTableRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+        )
+        response = self._client.callFunction(
+            self._results_service.GetStrainConvergenceTable,
+            request,
+        )
+        require_success(response, "GetStrainConvergenceTable")
+        return data_table_to_dataframe(response.table)
+
+    def getRealTimeDisplacementDataFrame(
+        self,
+        profileName: str,
+        motionName: str,
+    ) -> pd.DataFrame:
+        """
+        Return real-time relative displacement at each layer as a pandas DataFrame.
+
+        Requires the displacement animation option enabled in project settings and a
+        standard result database for the motion.
+        """
+        request = ResultsService_pb2.GetRealTimeDisplacementTableRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            motionName=motionName,
+        )
+        response = self._client.callFunction(
+            self._results_service.GetRealTimeDisplacementTable,
+            request,
+        )
+        require_success(response, "GetRealTimeDisplacementTable")
+        return data_table_to_dataframe(response.table)
+
+    def getAllStrainConvergenceDataFrames(
+        self,
+        profileName: str,
+        *,
+        skipErrors: bool = True,
+    ) -> dict[str, pd.DataFrame]:
+        """
+        Fetch strain convergence DataFrames for all motions on the Check convergence tab.
+
+        Uses the same motion list as that tab in the RSSeismic UI: primary equivalent-linear
+        motions, plus complementary EL motions when that option is enabled. Each entry is
+        loaded via ``getStrainConvergenceDataFrame``.
+
+        When ``skipErrors`` is True (default), motions without convergence data are skipped
+        instead of raising an error.
+        """
+        self._require_profile_name(profileName)
+        motion_names = select_convergence_tab_motion_names(
+            self.listResultMotions(),
+            self._resolve_el_convergence_motion_type_filter(),
+        )
+        return fetch_bulk_dataframes(
+            motion_names,
+            lambda motion_name: self.getStrainConvergenceDataFrame(profileName, motion_name),
+            skip_errors=skipErrors,
+        )
+
+    def getAllRealTimeDisplacementDataFrames(
+        self,
+        profileName: str,
+        *,
+        skipErrors: bool = True,
+    ) -> dict[str, pd.DataFrame]:
+        """
+        Fetch real-time displacement DataFrames for all result motions on a profile.
+
+        Uses the same motion list as the displacement animation tab. Requires the
+        displacement animation project setting. When ``skipErrors`` is True (default),
+        motions without data are skipped instead of raising an error.
+        """
+        self._require_profile_name(profileName)
+        motion_names = select_displacement_animation_motion_names(self.listResultMotions())
+        return fetch_bulk_dataframes(
+            motion_names,
+            lambda motion_name: self.getRealTimeDisplacementDataFrame(profileName, motion_name),
+            skip_errors=skipErrors,
+        )
+
+    def getAllResultSeriesDataFrames(
+        self,
+        profileName: str,
+        kind: ResultSeriesKind,
+        motionTypeFilters: Sequence[ResultMotionType] | None = None,
+        layerIds: Sequence[str] | None = None,
+        *,
+        skipErrors: bool = True,
+    ) -> dict[str, pd.DataFrame] | dict[tuple[str, str], pd.DataFrame]:
+        """
+        Fetch one result series kind for many motions (and layers when required).
+
+        Returns a dict keyed by motion name for profile-level series, or by
+        ``(motion_name, layer_id)`` when ``kind.requires_layer`` is True.
+
+        ``motionTypeFilters`` limits which motion variants are included (standard,
+        complementary equivalent-linear, complementary nonlinear total stress). Pass
+        ``None`` or an empty sequence to include all types.
+
+        ``layerIds`` limits layer-scoped series. When omitted or empty and ``kind``
+        requires a layer, all layers from ``listResultLayers(profileName)`` are used.
+
+        When ``skipErrors`` is True (default), missing combinations are skipped
+        instead of raising an error.
+        """
+        self._require_profile_name(profileName)
+        resolved_kind = ResultSeriesKind(resolve_result_series_kind(kind))
+        motion_type_filters = normalize_result_motion_type_filters(motionTypeFilters)
+        motion_names = select_profile_motion_names(
+            self._list_result_databases(profileName, onlyExisting=True),
+            profileName,
+            motion_type_filters,
+            require_result_database=True,
+        )
+
+        if resolved_kind.requires_layer:
+            layer_ids = resolve_layer_ids(
+                layerIds,
+                lambda: self.listResultLayers(profileName),
+            )
+            return fetch_bulk_layer_series_dataframes(
+                motion_names,
+                layer_ids,
+                lambda motion_name, layer_id: self.getResultSeriesDataFrame(
+                    profileName,
+                    motion_name,
+                    resolved_kind,
+                    layer_id,
+                ),
+                skip_errors=skipErrors,
+            )
+
+        return fetch_bulk_profile_series_dataframes(
+            motion_names,
+            lambda motion_name: self.getResultSeriesDataFrame(
+                profileName,
+                motion_name,
+                resolved_kind,
+            ),
+            skip_errors=skipErrors,
+        )
+
+    def _require_profile_name(self, profileName: str) -> None:
+        if not profileName:
+            raise ValueError("Profile name is required.")
+
+    def _list_result_databases(
+        self,
+        profileName: str,
+        *,
+        onlyExisting: bool,
+    ) -> list[ResultDatabaseInfo]:
+        return self.listResultDatabases(profileName=profileName, onlyExisting=onlyExisting)
+
+    def _resolve_el_convergence_motion_type_filter(self) -> frozenset[ResultMotionType] | None:
+        from rsseismic.ProjectSettings import ProjectSettings
+
+        data = ProjectSettings(self._client, self._objectId).Data
+        return infer_el_convergence_motion_type_filter(
+            data.getEnumValue("solutionType", str),
+            data.getEnumValue("analysisMode", str),
+            data.getBoolValue("equivalentLinear"),
+        )

rsseismic/SoilLayer.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic.generatedFiles import SoilLayerDataService_pb2_grpc as SoilLayerDataService_pb2_grpc
+from rsseismic.properties._PropertyAccessor import ProjectScopedPropertyAccessor
+from rsseismic.properties.soilLayer._generated import SoilLayerPropertiesMixin
+from rsseismic.ReferenceCurve import ReferenceCurve
+from rsseismic.SoilLayerCurve import SoilLayerCurve
+
+
+class SoilLayer(_ProxyObject, SoilLayerPropertiesMixin):
+    """
+    Read and edit properties for one soil layer on a profile.
+
+    Obtain an instance from ``model.Profiles.getSoilLayer(layerId)``. Layer IDs
+    come from ``model.Profiles.listSoilLayers()`` or ``listActiveSoilLayers()``.
+
+    Use the generated ``get*`` / ``set*`` helpers for scalar layer properties such as
+    thickness, unit weight, and soil model. Reference curves are edited through
+    ``layer.ReferenceCurve``; fitted dynamics and curve fitting use ``layer.Curve``.
+    """
+
+    def __init__(self, client: Client, modelId: str, layerId: str):
+        super().__init__(client, layerId)
+        self.modelId = modelId
+        stub = SoilLayerDataService_pb2_grpc.SoilLayerDataServiceStub(self._client.channel)
+        self.Data = ProjectScopedPropertyAccessor(client, modelId, layerId, stub)
+        self.ReferenceCurve = ReferenceCurve(client, modelId, layerId)
+        self.Curve = SoilLayerCurve(client, modelId, layerId)
+
+    @property
+    def layerId(self) -> str:
+        return self._objectId

rsseismic/SoilLayerCurve.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import (
+    from_discrete_points,
+    from_dynamics_points,
+    to_discrete_points,
+    to_dynamics_points,
+    to_gq_h_fitting_limits_proto,
+)
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import require_success
+from rsseismic.enums import FittingProcedureModel
+from rsseismic.generatedFiles import SoilLayerCurveDataService_pb2 as SoilLayerCurveDataService_pb2
+from rsseismic.generatedFiles import SoilLayerCurveDataService_pb2_grpc as SoilLayerCurveDataService_pb2_grpc
+from rsseismic.types import DiscretePoint, DynamicsPoint, GqHFittingLimits
+
+
+def _resolve_fitting_procedure(
+    fitting_procedure: FittingProcedureModel | str,
+) -> str:
+    if isinstance(fitting_procedure, FittingProcedureModel):
+        return fitting_procedure.value
+    return fitting_procedure
+
+
+class SoilLayerCurve(_ProxyObject):
+    """
+    Fitted dynamics and discrete-point curve data for a profile soil layer.
+
+    Access via ``layer.Curve`` on a ``SoilLayer`` from
+    ``model.Profiles.getSoilLayer(layerId)``. This is separate from
+    ``layer.ReferenceCurve``, which holds the reference curve used as input
+    for curve fitting.
+
+    Use ``getDynamics`` / ``setDynamics`` for the fitted layer curve, or
+    ``getDiscretePoints`` / ``setDiscretePoints`` when the layer uses a
+    discrete-points soil model. Call ``runCurveFit`` to fit dynamics from
+    the layer's reference curve.
+    """
+
+    def __init__(self, client: Client, modelId: str, layerId: str):
+        super().__init__(client, layerId)
+        self.modelId = modelId
+        self._service = SoilLayerCurveDataService_pb2_grpc.SoilLayerCurveDataServiceStub(
+            self._client.channel
+        )
+
+    @property
+    def layerId(self) -> str:
+        return self._objectId
+
+    def getDynamics(self) -> list[DynamicsPoint]:
+        """Return fitted dynamics points for the layer."""
+        request = SoilLayerCurveDataService_pb2.GetSoilLayerDynamicsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+        )
+        response = self._client.callFunction(self._service.GetDynamics, request)
+        require_success(response, "GetDynamics")
+        return from_dynamics_points(list(response.points))
+
+    def setDynamics(self, points: list[DynamicsPoint]) -> None:
+        """Set layer dynamics points."""
+        if not points:
+            raise ValueError("At least one dynamics point is required.")
+        request = SoilLayerCurveDataService_pb2.SetSoilLayerDynamicsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+            points=to_dynamics_points(points),
+        )
+        response = self._client.callFunction(self._service.SetDynamics, request)
+        require_success(response, "SetDynamics")
+
+    def getDiscretePoints(self) -> list[DiscretePoint]:
+        """Return discrete curve points (equivalent-linear analysis, Points soil model)."""
+        request = SoilLayerCurveDataService_pb2.GetDiscretePointsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+        )
+        response = self._client.callFunction(self._service.GetDiscretePoints, request)
+        require_success(response, "GetDiscretePoints")
+        return from_discrete_points(list(response.points))
+
+    def setDiscretePoints(self, points: list[DiscretePoint]) -> None:
+        """Set discrete curve points."""
+        if not points:
+            raise ValueError("At least one discrete point is required.")
+        request = SoilLayerCurveDataService_pb2.SetDiscretePointsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+            points=to_discrete_points(points),
+        )
+        response = self._client.callFunction(self._service.SetDiscretePoints, request)
+        require_success(response, "SetDiscretePoints")
+
+    def runCurveFit(
+        self,
+        fittingProcedure: FittingProcedureModel | str,
+        gqHLimits: Optional[GqHFittingLimits] = None,
+    ) -> int:
+        """
+        Fit layer dynamics from the layer's reference curve.
+
+        Args:
+            fittingProcedure: Fitting procedure, for example
+                ``FittingProcedureModel.MRDF`` or ``FittingProcedureModel.MRDF_UIUC``.
+            gqHLimits: Optional G–H fitting limits for procedures that support them.
+
+        Returns:
+            The number of fitted points.
+        """
+        request = SoilLayerCurveDataService_pb2.RunCurveFitRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+            fittingProcedure=_resolve_fitting_procedure(fittingProcedure),
+        )
+        if gqHLimits is not None:
+            request.gq_h_limits.CopyFrom(to_gq_h_fitting_limits_proto(gqHLimits))
+        response = self._client.callFunction(self._service.RunCurveFit, request)
+        require_success(response, "RunCurveFit")
+        return response.pointCount

rsseismic/SoilLayerOperations.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import (
+    from_append_layers_response,
+    from_delete_layer_response,
+    from_insert_layer_response,
+    from_move_layer_response,
+)
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import require_success
+from rsseismic.generatedFiles import SoilLayerService_pb2 as SoilLayerService_pb2
+from rsseismic.generatedFiles import SoilLayerService_pb2_grpc as SoilLayerService_pb2_grpc
+from rsseismic.types import AppendLayersResult, DeleteLayerResult, InsertLayerResult, MoveLayerResult
+
+
+class SoilLayerOperations(_ProxyObject):
+    """Structural soil layer operations (insert, delete, duplicate, move) for an open model."""
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self._soil_layer_service = SoilLayerService_pb2_grpc.SoilLayerServiceStub(self._client.channel)
+
+    def insertLayerBefore(
+        self,
+        referenceLayerID: str,
+        profileName: str = "",
+    ) -> InsertLayerResult:
+        """
+        Insert a soil layer before referenceLayerID.
+
+        referenceLayerID may be a soil layer GUID or the bedrock layer GUID.
+        """
+        request = SoilLayerService_pb2.InsertLayerBeforeRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            referenceLayerID=referenceLayerID,
+        )
+        response = self._client.callFunction(self._soil_layer_service.InsertLayerBefore, request)
+        require_success(response, "InsertLayerBefore")
+        return from_insert_layer_response(response)
+
+    def insertLayerAfter(
+        self,
+        referenceLayerID: str,
+        profileName: str = "",
+    ) -> InsertLayerResult:
+        """Insert a soil layer after a soil layer GUID."""
+        request = SoilLayerService_pb2.InsertLayerAfterRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            referenceLayerID=referenceLayerID,
+        )
+        response = self._client.callFunction(self._soil_layer_service.InsertLayerAfter, request)
+        require_success(response, "InsertLayerAfter")
+        return from_insert_layer_response(response)
+
+    def appendLayers(
+        self,
+        count: int = 1,
+        profileName: str = "",
+    ) -> AppendLayersResult:
+        """Append one or more soil layers before bedrock."""
+        request = SoilLayerService_pb2.AppendLayersRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            count=count,
+        )
+        response = self._client.callFunction(self._soil_layer_service.AppendLayers, request)
+        require_success(response, "AppendLayers")
+        return from_append_layers_response(response)
+
+    def deleteLayer(
+        self,
+        layerID: str,
+        profileName: str = "",
+    ) -> DeleteLayerResult:
+        """Delete a soil layer. At least one soil layer must remain."""
+        request = SoilLayerService_pb2.DeleteLayerRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            layerID=layerID,
+        )
+        response = self._client.callFunction(self._soil_layer_service.DeleteLayer, request)
+        require_success(response, "DeleteLayer")
+        return from_delete_layer_response(response)
+
+    def duplicateLayer(
+        self,
+        sourceLayerID: str,
+        insertAfter: bool = True,
+        profileName: str = "",
+    ) -> InsertLayerResult:
+        """Duplicate a soil layer before or after the source layer."""
+        request = SoilLayerService_pb2.DuplicateLayerRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            sourceLayerID=sourceLayerID,
+            insertAfter=insertAfter,
+        )
+        response = self._client.callFunction(self._soil_layer_service.DuplicateLayer, request)
+        require_success(response, "DuplicateLayer")
+        return from_insert_layer_response(response)
+
+    def moveLayer(
+        self,
+        layerID: str,
+        newIndex1Based: int,
+        profileName: str = "",
+    ) -> MoveLayerResult:
+        """Move a soil layer to a new 1-based index."""
+        request = SoilLayerService_pb2.MoveLayerRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            layerID=layerID,
+            newIndex1Based=newIndex1Based,
+        )
+        response = self._client.callFunction(self._soil_layer_service.MoveLayer, request)
+        require_success(response, "MoveLayer")
+        return from_move_layer_response(response)