Source code for load_cases.mechanical_load_case.api.mechanical_load_case_api

import typing

from more.api.exceptions.api_exception import NameNotUniqueError
from more.api.simulation.load_cases.load_case_setup import LoadCaseSetupPipeline
from more.api.simulation.load_cases.load_setup import LoadSetup
from more.api.utils.change_duplicate_name import change_duplicate_name

from more.api.utils.interface_registries import register_api_implementation
from more.load_cases.mechanical_load_case import MechanicalLoadCase
from more.load_cases.utils.data_table_dependent_loads_handler.api.data_table_dependent_loads_handler_api import DataTableDependentLoadsHandlerAPI
from more.load_cases.utils.data_table_dependent_loads_handler.api.data_table_dependent_loads_handler_api_mixin import \
    DataTableDependentLoadsHandlerApiMixin
from more import log

log.init_logging()
logger = log.getLogger(__name__)

def _mechanical_load_case_api_setup(api) -> 'MechanicalLoadCaseSetup':
    simulation_setup = api.create_simulation_setup()
    load_case_container_setup = simulation_setup.create_load_case_container_setup()
    return load_case_container_setup.create_load_case_setup(lc_type='Mechanical load case')




@register_api_implementation(core_class=MechanicalLoadCase)
class MechanicalLoadCaseSetup(LoadCaseSetupPipeline, DataTableDependentLoadsHandlerApiMixin):
    """ The API handler for mechanical load cases

    The following example shows how to create a mechanical load case using the API, it is assumed that these steps were performed
    in each of the examples for other methods in this class.

    .. admonition:: Example
        :class: note

        ..
            >>> import more.project
            >>> proj = more.project.Project()

        >>> from more.api import ApiGateway
        >>> api = ApiGateway(proj=proj)
        >>> simulation_setup = api.create_simulation_setup()
        >>> lcc_setup = simulation_setup.create_load_case_container_setup().set_name(name='Example LCC')
        >>> load_case_setup = lcc_setup.create_load_case_setup(lc_type='Mechanical load case').set_name(name='Example LC')

        ..
            >>> isinstance(load_case_setup, MechanicalLoadCaseSetup)
            True
            >>> isinstance(load_case_setup._load_case, MechanicalLoadCase)
            True

    The next example shows how to get an API object for an already existing load case.

    .. admonition:: Example
        :class: note

        ..
            >>> import more.project
            >>> proj = more.project.Project()

        >>> from more.api import ApiGateway
        >>> api = ApiGateway(proj=proj)
        >>> simulation_setup = api.create_simulation_setup()
        >>> lcc_setup = simulation_setup.create_load_case_container_setup().set_name(name='Example LCC')

        ..
            >>> _load_case_setup = lcc_setup.create_load_case_setup(lc_type='Mechanical load case').set_name(name='Example LC')

        >>> load_case_setup = lcc_setup.get_load_case_setup(name='Example LC') # The load case must already exist

        ..
            >>> isinstance(load_case_setup, MechanicalLoadCaseSetup)
            True
            >>> isinstance(load_case_setup._load_case, MechanicalLoadCase)
            True


    """

    def __init__(self, item: MechanicalLoadCase):
        super().__init__(item)
        self._load_case = item

        # Backwards compatibility
        self.load_case = item
        self._data_table_dependent_loads_handler_api = DataTableDependentLoadsHandlerAPI(
            data_table_dependent_loads_handler=self._load_case.data_table_dependent_loads_handler)



    def get_name(self) -> str:
        """ Returns the name of the load case

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)

            >>> load_case_setup.set_name(name='new_name')
            <more...>
            >>> load_case_setup.get_name()
            'new_name'

        Returns
        -------
        name: str
            The name of the load case


        """
        return self._load_case.name




    def set_name(self, name: str, resolve_duplicate_name: bool = False) -> 'MechanicalLoadCaseSetup':
        """ Sets the name of the load case

        See example at the top to see how to create a MechanicalLoadCaseSetup object


        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> lcc = api.create_simulation_setup().create_load_case_container_setup()
                >>> load_case_setup = lcc.create_load_case_setup(lc_type='Mechanical load case')
                >>> second_load_case_setup = lcc.create_load_case_setup(lc_type='Mechanical load case')

            >>> load_case_setup.set_name(name='new_name')
            <more...>
            >>> second_load_case_setup.set_name(name='new_name', resolve_duplicate_name=True).get_name()
            'new_name 1'


             ..
                >>> load_case_setup._load_case.name
                'new_name'

                Trying to set the name to a non-string value
                >>> load_case_setup.set_name(name=None)
                Traceback (most recent call last):
                ...
                TypeError: ...

                Setting a non-unique name
                >>> load_case_setup.set_name('new_name')
                Traceback (most recent call last):
                ...
                more.api.exceptions.api_exception.NameNotUniqueError: ...



        Parameters
        ----------
        name : str
            The new name for the load case
        resolve_duplicate_name: bool
            Whether to automatically assign a new name when the chosen one is already taken

        Returns
        -------
        self: MechanicalLoadCaseSetup

        Raises
        ------
        NameNotUniqueError
            Raised if the given name is not unique
        TypeError
            Raised if the given name is not a string

        """
        if not isinstance(name, str):
            raise TypeError('The given name must be of type string, but a: \"{}\" was given'.format(type(name)))
        created_names = [lc.name for lc in self._load_case.parent.elements]
        if name in created_names:
            if not resolve_duplicate_name:
                raise NameNotUniqueError(
                    f'The given name: \"{name}\" is already given in the list: \"{created_names}\"')
            else:
                name = change_duplicate_name(name=name, names_list=created_names)
        self._load_case.name = name
        return self




    def get_load_setup(self, index: int) -> LoadSetup:
        """ Gets a load setup object for an existing load

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)
                >>> _load_setup_1 = load_case_setup.create_load_setup(load_type='Link load')
                >>> _load_setup_2 = load_case_setup.create_load_setup(load_type='Link load')

            >>> load_setup = load_case_setup.get_load_setup(index=1) # Two loads must already exist

             ..
                >>> _load_setup_2._load == load_setup._load
                True
                >>> len(load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements)
                2
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements[1] == load_setup._load
                True

                >>> load_case_setup.get_load_setup(index=None)
                Traceback (most recent call last):
                ...
                TypeError: ...




        Parameters
        ----------
        index : int
            The index of the load in the load table

        Returns
        -------
        LoadSetup: LoadSetup

        Raises
        ------
        TypeError
            Raised if the index is not an integer

        """

        return self._data_table_dependent_loads_handler_api.get_load_setup(index=index)




    def create_load_setup(self, load_type: str) -> LoadSetup:
        """ Creates a load of a specified type

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)

            >>> link_load_setup = load_case_setup.create_load_setup(load_type='Link load')
            >>> composition_acc_load_setup = load_case_setup.create_load_setup(load_type='Composition acceleration')

             ..
                >>> len(load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements)
                2
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements[1] == composition_acc_load_setup._load
                True
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements[0] == link_load_setup._load
                True

                >>> load_case_setup.create_load_setup(load_type='Non existent load type')
                Traceback (most recent call last):
                ...
                more.api.exceptions.api_exception.NameNotFoundError: ...
                >>> load_case_setup.create_load_setup(load_type='Heat flow')
                Traceback (most recent call last):
                ...
                more.api.exceptions.api_exception.NotCompatibleError: ...



        Parameters
        ----------
        index : int
            The index of the load in the load table

        Returns
        -------
        LoadSetup: LoadSetup

        Raises
        ------
        NameNotFoundError
            Raised if not load with the specified type was found
        NotCompatibleError
            Raised if the specified load type exists, but is not compatible with this load case

        """
        return self._data_table_dependent_loads_handler_api.create_load_setup(load_type=load_type)





    def remove_load_setup(self, index: int) -> 'MechanicalLoadCaseSetup':
        """ Removes the load under the specified index

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)
                >>> _load_setup_1 = load_case_setup.create_load_setup(load_type='Link load')
                >>> _load_setup_2 = load_case_setup.create_load_setup(load_type='Link load')

            >>> load_case_setup = load_case_setup.remove_load_setup(index=1) # Two loads must already exist

             ..
                >>> len(load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements)
                1
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.loads_container.elements[0] == _load_setup_1._load
                True

                >>> load_case_setup.remove_load_setup(index=None)
                Traceback (most recent call last):
                ...
                TypeError: ...



        Parameters
        ----------
        index : int
            The index of the load in the load table

        Returns
        -------
        MechanicalLoadCaseSetup: MechanicalLoadCaseSetup

        Raises
        ------
        TypeError
            Raised if the index is not an integer


        """

        self._data_table_dependent_loads_handler_api.remove_load_setup(index=index)
        return self




    def set_time_dependent_data_bool(self, value: bool) -> 'MechanicalLoadCaseSetup':
        """ Sets whether data table data should be used in the load case

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)

            >>> load_case_setup = load_case_setup.set_time_dependent_data_bool(value=True)

             ..
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.table_dependent_data.time_dependent_data == True
                True
                >>> load_case_setup = load_case_setup.set_time_dependent_data_bool(value=False)
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.table_dependent_data.time_dependent_data == False
                True


        Parameters
        ----------
        value : bool
            A boolean value specifying whether data table dependence should be used

        Returns
        -------
        MechanicalLoadCaseSetup: MechanicalLoadCaseSetup


        """
        self._data_table_dependent_loads_handler_api.set_time_dependent_data_bool(value=value)
        return self




    def set_data_table_by_name(self, data_table_name: str) -> 'MechanicalLoadCaseSetup':
        """Sets the data table to be used in this load case

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)
                >>> data_table_setup = api.create_simulation_setup() \\
                ...    .create_data_table_setup(data_table_type_name='Transient data table') \\
                ...    .set_name(name='data_table_name')

            >>> print("Available data tables: {}".format(load_case_setup.available_data_table_names)) # To check which data tables are available
            Available data tables: ...
            >>> load_case_setup = load_case_setup.set_data_table_by_name(data_table_name='data_table_name')

            ..
                >>> load_case_setup._load_case.data_table_dependent_loads_handler.table_dependent_data.single_data_table_choice == data_table_setup._data_table
                True

                >>> load_case_setup.set_data_table_by_name(data_table_name='Non-existent data table')
                Traceback (most recent call last):
                ...
                more.api.exceptions.api_exception.NameNotFoundError: ...


        Parameters
        ----------
        data_table_name: str
            The name of the data table to set

        Returns
        -------
        self: MechanicalLoadCaseSetup

        Raises
        ------
        NameNotFoundError
            Raised if the data table was not found

        """
        self._data_table_dependent_loads_handler_api.set_data_table_by_name(data_table_name=data_table_name)
        return self




    def get_data_table_query_config(self):
        """ Returns the api object for setting up the data table query for this load case

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)
                >>> data_table_setup = api.create_simulation_setup() \\
                ...    .create_data_table_setup(data_table_type_name='Transient data table') \\
                ...    .set_name(name='data_table_name')

            >>> print("Available data tables: {}".format(load_case_setup.available_data_table_names)) # To check which data tables are available
            Available data tables: ...
            >>> load_case_setup = load_case_setup \\
            ... .set_data_table_by_name(data_table_name='data_table_name') \\
            ... .set_time_dependent_data_bool(value=True)
            >>> query_config = load_case_setup.get_data_table_query_config()

            ..
                >>> query_config._initial_partial_find_creator.data_table == data_table_setup._data_table
                True
                >>> _ = load_case_setup.set_time_dependent_data_bool(value=False)
                >>> load_case_setup.get_data_table_query_config()
                Traceback (most recent call last):
                ...
                more.api.exceptions.api_exception.NotCompatibleError: The current load case setup is not compatible with a data table query config, most probably the time dependency was set to false

        Returns
        -------
        Query config
            An object for configuring the data table querying in the load case

        Raises
        ------
        NotCompatibleError
            Raised if the current load case configuration is not compatible with a query config object


        """
        return self._data_table_dependent_loads_handler_api.get_data_table_query_config()




    def set_time_dependent_data_column_index(self, index: int) -> 'MechanicalLoadCaseSetup':
        """ Deprecated method

        .. admonition:: Deprecated
            :class: warning

            `set_time_dependent_data_column_index` will be removed in a future MORe release, it is replaced by the more general :meth:`~.get_data_table_query_config`

        """
        logger.warning(
            'Deprecation: \"set_time_dependent_data_column_index\" will be removed in a future MORe release, it is replaced by \"get_data_table_query_config\"')
        self._data_table_dependent_loads_handler_api.set_time_dependent_data_column_index(index=index)
        return self




    def set_time_dependent_data_table_by_name(self, data_table_name: str) -> 'MechanicalLoadCaseSetup':
        """ Deprecated method

        .. admonition:: Deprecated
            :class: warning

            `set_time_dependent_data_table_by_name` will be removed in a future MORe release, it is replaced by :meth:`~.set_data_table_by_name`

        """
        logger.warning(
            'Deprecation: \"set_time_dependent_data_table_by_name\" will be removed in a future MORe release, it is replaced by \"set_data_table_by_name\"')
        return self.set_data_table_by_name(data_table_name=data_table_name)



    @property
    def available_data_table_names(self) -> typing.List[str]:
        """ Returns the names of compatible data tables

        .. admonition:: Example
            :class: note

            ..
                >>> import more.project
                >>> proj = more.project.Project()
                >>> from more.api import ApiGateway
                >>> api = ApiGateway(proj=proj)
                >>> load_case_setup = _mechanical_load_case_api_setup(api=api)
                >>> data_table_setup = api.create_simulation_setup() \\
                ...    .create_data_table_setup(data_table_type_name='Transient data table') \\
                ...    .set_name(name='data_table_name')

            >>> print("Available data tables: {}".format(load_case_setup.available_data_table_names)) # To check which data tables are available
            Available data tables: ...

            ..
                >>> len(load_case_setup.available_data_table_names) == 1
                True

        Returns
        ------
        available_data_tables: Dict(str, str)
            A list with the names of compatible data tables

        """
        return self._data_table_dependent_loads_handler_api.available_data_table_names

    @property
    def available_data_tables_dict(self) -> typing.Dict[str, str]:
        """ Deprecated method

                .. admonition:: Deprecated
                    :class: warning

                    `available_data_tables_dict` will be removed in a future MORe release, it is replaced by :meth:`~.available_data_table_names`

                """
        logger.warning(
            'Deprecation: \"available_data_tables_dict\" will be removed in a future MORe release, it is replaced by \"available_data_table_names\"')
        return self._data_table_dependent_loads_handler_api.available_data_tables_dict