pytabs.load_cases

  1# pyTABS - ETABS .NET API python wrapper
  2# LoadCases - cLoadCases interface 
  3__all__ = ['LoadCases']
  4
  5# import ETABS namespace and pyTABS error handler
  6from pytabs.etabs_config import *
  7from pytabs.error_handle import *
  8
  9# import of interfaces of load case types
 10from pytabs.case_direct_history_linear import CaseDirectHistoryLinear
 11from pytabs.case_direct_history_nonlinear import CaseDirectHistoryNonlinear
 12from pytabs.case_hyperstatic import CaseHyperStatic
 13from pytabs.case_modal_eigen import CaseModalEigen
 14from pytabs.case_modal_history_linear import CaseModalHistoryLinear
 15from pytabs.case_modal_history_nonlinear import CaseModalHistoryNonlinear
 16from pytabs.case_modal_ritz import CaseModalRitz
 17from pytabs.case_response_spectrum import CaseResponseSpectrum
 18from pytabs.case_static_linear import CaseStaticLinear
 19from pytabs.case_static_nonlinear import CaseStaticNonlinear
 20from pytabs.case_static_nonlinear_staged import CaseStaticNonlinearStaged
 21
 22# import typing
 23from typing import Union
 24from typing import TypedDict
 25
 26
 27class LoadCaseType(TypedDict):
 28    """TypedDict class for load case type return"""
 29    case_name : str
 30    case_type : etabs.eLoadCaseType
 31    sub_type : Union[None, str]
 32    design_type : etabs.eLoadPatternType
 33    design_type_option : str
 34    is_automatic : bool
 35
 36
 37class LoadCases:
 38    """LoadCases interface"""
 39    def __init__(self, sap_model : etabs.cSapModel) -> None:
 40        # link of SapModel interface
 41        self.sap_model = sap_model
 42        # create LoadCases interface
 43        self.load_cases = etabs.cLoadCases(sap_model.LoadCases)
 44        
 45        # create interface for individual case types
 46        self.direct_history_linear = CaseDirectHistoryLinear(sap_model)
 47        self.direct_history_nonlinear = CaseDirectHistoryNonlinear(sap_model)
 48        self.hyperstatic = CaseHyperStatic(sap_model)
 49        self.modal_eigen = CaseModalEigen(sap_model)
 50        self.modal_history_linear = CaseModalHistoryLinear(sap_model)
 51        self.modal_history_nonlinear = CaseModalHistoryNonlinear(sap_model)
 52        self.modal_ritz = CaseModalRitz(sap_model)
 53        self.response_spectrum = CaseResponseSpectrum(sap_model)
 54        self.static_linear = CaseStaticLinear(sap_model)
 55        self.static_nonlinear = CaseStaticNonlinear(sap_model)
 56        self.static_nonlinear_staged = CaseStaticNonlinearStaged(sap_model)
 57        
 58        # relate relevant ETABS enumerations
 59        self.eLoadCaseType = etabs.eLoadCaseType
 60        """EtabsModel `LoadCaseType` enumeration"""
 61
 62
 63    def change_name(self, case_name : str, new_case_name :str) -> None:
 64        """Changes the name of a defined Load Case.
 65
 66        :param case_name: name of defined load case to change
 67        :type case_name: str
 68        :param new_case_name: new name of load case
 69        :type new_case_name: str
 70        """
 71        handle(self.load_cases.ChangeName(case_name, new_case_name))
 72
 73
 74    def count(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> int:
 75        """Count of load cases of type if specified.
 76
 77        :param case_type: load case type enumeration, defaults to None
 78        :type case_type: Union[None, eLoadCaseType], optional
 79        :return: count of load case of type, if specified, else all
 80        :rtype: int
 81        """
 82        if case_type:
 83            return self.load_cases.Count(case_type)
 84        else:
 85            return self.load_cases.Count()
 86
 87
 88    def delete(self, case_name : str) -> None:
 89        """Deletes the specified load case.
 90
 91        :param case_name: name of existing load case
 92        :type case_name: str
 93        """
 94        handle(self.load_cases.Delete(case_name))
 95
 96
 97    def get_name_list(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> list[str]:
 98        """Retrieves the names of all defined load cases of the specified type.
 99
100        :param case_type: load case type enumeration, defaults to None
101        :type case_type: Union[None, eLoadCaseType], optional
102        :return: load case names of type, if specified, else all
103        :rtype: list[str]
104        """
105        number_names = int()
106        case_names = [str()]
107        if case_type:
108            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names, case_type)
109        else:
110            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names)
111        handle(ret)
112        return list(case_names)
113
114
115    def get_type(self, case_name : str) -> LoadCaseType:
116        """Retrieves the case type, design type, and auto flag for the specified load case.
117
118        :param case_name: name of existing load case
119        :type case_name: str
120        :return: load case type details
121        :rtype: LoadCaseType
122        """
123        case_type = etabs.eLoadCaseType.Buckling
124        sub_type = int()
125        design_type = etabs.eLoadPatternType.Notional
126        design_type_option = int()
127        is_automatic = int()
128        design_type_options_desc = {0: 'Program determined', 1: 'User specified'}
129        is_automatic_desc = {0: False, 1: True}
130        
131        [ref, case_type, sub_type, design_type, 
132         design_type_option, is_automatic] = self.load_cases.GetTypeOAPI_1(case_name, case_type, sub_type,
133                                                                           design_type, design_type_option, is_automatic)
134        handle(ref)
135        sub_type = self.__determine_sub_type(case_type, sub_type)
136        return {'case_name': case_name,
137                'case_type': case_type,
138                'sub_type': sub_type,
139                'design_type': design_type,
140                'design_type_option': design_type_options_desc[design_type_option],
141                'is_automatic': is_automatic_desc[is_automatic]}
142
143
144    def set_design_type(self, case_name : str, design_type_option : int, design_type : etabs.eLoadPatternType = etabs.eLoadPatternType.Dead) -> None:
145        """Set design type of existing load case.
146
147        :param case_name: name of existing load case
148        :type case_name: str
149        :param design_type_option: design type option (0 = Program determined, 1 = User specified)
150        :type design_type_option: int
151        :param design_type: design type, defaults to eLoadPatternType.Dead
152        :type design_type: eLoadPatternType, optional
153        """
154        handle(self.load_cases.SetDesignType(case_name, design_type_option, design_type))
155        
156
157    def __determine_sub_type(self, case_type : etabs.eLoadCaseType, sub_type : int) -> Union[None, str]:
158        """Private method to determine string of load case sub type.
159        """
160        if int(case_type) in [int(etabs.eLoadCaseType.NonlinearStatic), int(etabs.eLoadCaseType.Modal), int(etabs.eLoadCaseType.LinearHistory)]:
161            if int(case_type) == int(etabs.eLoadCaseType.NonlinearStatic):
162                sub_types_dict = {1: 'Nonlinear', 2: 'Nonlinear staged construction'}
163            elif int(case_type) == int(etabs.eLoadCaseType.Modal):
164                sub_types_dict = {1: 'Eigen', 2: 'Ritz'}
165            else:
166                sub_types_dict = {1: 'Transient', 2: 'Periodic'}
167            return sub_types_dict[sub_type]
class LoadCases:
 38class LoadCases:
 39    """LoadCases interface"""
 40    def __init__(self, sap_model : etabs.cSapModel) -> None:
 41        # link of SapModel interface
 42        self.sap_model = sap_model
 43        # create LoadCases interface
 44        self.load_cases = etabs.cLoadCases(sap_model.LoadCases)
 45        
 46        # create interface for individual case types
 47        self.direct_history_linear = CaseDirectHistoryLinear(sap_model)
 48        self.direct_history_nonlinear = CaseDirectHistoryNonlinear(sap_model)
 49        self.hyperstatic = CaseHyperStatic(sap_model)
 50        self.modal_eigen = CaseModalEigen(sap_model)
 51        self.modal_history_linear = CaseModalHistoryLinear(sap_model)
 52        self.modal_history_nonlinear = CaseModalHistoryNonlinear(sap_model)
 53        self.modal_ritz = CaseModalRitz(sap_model)
 54        self.response_spectrum = CaseResponseSpectrum(sap_model)
 55        self.static_linear = CaseStaticLinear(sap_model)
 56        self.static_nonlinear = CaseStaticNonlinear(sap_model)
 57        self.static_nonlinear_staged = CaseStaticNonlinearStaged(sap_model)
 58        
 59        # relate relevant ETABS enumerations
 60        self.eLoadCaseType = etabs.eLoadCaseType
 61        """EtabsModel `LoadCaseType` enumeration"""
 62
 63
 64    def change_name(self, case_name : str, new_case_name :str) -> None:
 65        """Changes the name of a defined Load Case.
 66
 67        :param case_name: name of defined load case to change
 68        :type case_name: str
 69        :param new_case_name: new name of load case
 70        :type new_case_name: str
 71        """
 72        handle(self.load_cases.ChangeName(case_name, new_case_name))
 73
 74
 75    def count(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> int:
 76        """Count of load cases of type if specified.
 77
 78        :param case_type: load case type enumeration, defaults to None
 79        :type case_type: Union[None, eLoadCaseType], optional
 80        :return: count of load case of type, if specified, else all
 81        :rtype: int
 82        """
 83        if case_type:
 84            return self.load_cases.Count(case_type)
 85        else:
 86            return self.load_cases.Count()
 87
 88
 89    def delete(self, case_name : str) -> None:
 90        """Deletes the specified load case.
 91
 92        :param case_name: name of existing load case
 93        :type case_name: str
 94        """
 95        handle(self.load_cases.Delete(case_name))
 96
 97
 98    def get_name_list(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> list[str]:
 99        """Retrieves the names of all defined load cases of the specified type.
100
101        :param case_type: load case type enumeration, defaults to None
102        :type case_type: Union[None, eLoadCaseType], optional
103        :return: load case names of type, if specified, else all
104        :rtype: list[str]
105        """
106        number_names = int()
107        case_names = [str()]
108        if case_type:
109            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names, case_type)
110        else:
111            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names)
112        handle(ret)
113        return list(case_names)
114
115
116    def get_type(self, case_name : str) -> LoadCaseType:
117        """Retrieves the case type, design type, and auto flag for the specified load case.
118
119        :param case_name: name of existing load case
120        :type case_name: str
121        :return: load case type details
122        :rtype: LoadCaseType
123        """
124        case_type = etabs.eLoadCaseType.Buckling
125        sub_type = int()
126        design_type = etabs.eLoadPatternType.Notional
127        design_type_option = int()
128        is_automatic = int()
129        design_type_options_desc = {0: 'Program determined', 1: 'User specified'}
130        is_automatic_desc = {0: False, 1: True}
131        
132        [ref, case_type, sub_type, design_type, 
133         design_type_option, is_automatic] = self.load_cases.GetTypeOAPI_1(case_name, case_type, sub_type,
134                                                                           design_type, design_type_option, is_automatic)
135        handle(ref)
136        sub_type = self.__determine_sub_type(case_type, sub_type)
137        return {'case_name': case_name,
138                'case_type': case_type,
139                'sub_type': sub_type,
140                'design_type': design_type,
141                'design_type_option': design_type_options_desc[design_type_option],
142                'is_automatic': is_automatic_desc[is_automatic]}
143
144
145    def set_design_type(self, case_name : str, design_type_option : int, design_type : etabs.eLoadPatternType = etabs.eLoadPatternType.Dead) -> None:
146        """Set design type of existing load case.
147
148        :param case_name: name of existing load case
149        :type case_name: str
150        :param design_type_option: design type option (0 = Program determined, 1 = User specified)
151        :type design_type_option: int
152        :param design_type: design type, defaults to eLoadPatternType.Dead
153        :type design_type: eLoadPatternType, optional
154        """
155        handle(self.load_cases.SetDesignType(case_name, design_type_option, design_type))
156        
157
158    def __determine_sub_type(self, case_type : etabs.eLoadCaseType, sub_type : int) -> Union[None, str]:
159        """Private method to determine string of load case sub type.
160        """
161        if int(case_type) in [int(etabs.eLoadCaseType.NonlinearStatic), int(etabs.eLoadCaseType.Modal), int(etabs.eLoadCaseType.LinearHistory)]:
162            if int(case_type) == int(etabs.eLoadCaseType.NonlinearStatic):
163                sub_types_dict = {1: 'Nonlinear', 2: 'Nonlinear staged construction'}
164            elif int(case_type) == int(etabs.eLoadCaseType.Modal):
165                sub_types_dict = {1: 'Eigen', 2: 'Ritz'}
166            else:
167                sub_types_dict = {1: 'Transient', 2: 'Periodic'}
168            return sub_types_dict[sub_type]

LoadCases interface

LoadCases(sap_model: ETABSv1.cSapModel)
40    def __init__(self, sap_model : etabs.cSapModel) -> None:
41        # link of SapModel interface
42        self.sap_model = sap_model
43        # create LoadCases interface
44        self.load_cases = etabs.cLoadCases(sap_model.LoadCases)
45        
46        # create interface for individual case types
47        self.direct_history_linear = CaseDirectHistoryLinear(sap_model)
48        self.direct_history_nonlinear = CaseDirectHistoryNonlinear(sap_model)
49        self.hyperstatic = CaseHyperStatic(sap_model)
50        self.modal_eigen = CaseModalEigen(sap_model)
51        self.modal_history_linear = CaseModalHistoryLinear(sap_model)
52        self.modal_history_nonlinear = CaseModalHistoryNonlinear(sap_model)
53        self.modal_ritz = CaseModalRitz(sap_model)
54        self.response_spectrum = CaseResponseSpectrum(sap_model)
55        self.static_linear = CaseStaticLinear(sap_model)
56        self.static_nonlinear = CaseStaticNonlinear(sap_model)
57        self.static_nonlinear_staged = CaseStaticNonlinearStaged(sap_model)
58        
59        # relate relevant ETABS enumerations
60        self.eLoadCaseType = etabs.eLoadCaseType
61        """EtabsModel `LoadCaseType` enumeration"""
eLoadCaseType

EtabsModel LoadCaseType enumeration

def change_name(self, case_name: str, new_case_name: str) -> None:
64    def change_name(self, case_name : str, new_case_name :str) -> None:
65        """Changes the name of a defined Load Case.
66
67        :param case_name: name of defined load case to change
68        :type case_name: str
69        :param new_case_name: new name of load case
70        :type new_case_name: str
71        """
72        handle(self.load_cases.ChangeName(case_name, new_case_name))

Changes the name of a defined Load Case.

Parameters
  • case_name: name of defined load case to change
  • new_case_name: new name of load case
def count(self, case_type: Optional[ETABSv1.eLoadCaseType] = None) -> int:
75    def count(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> int:
76        """Count of load cases of type if specified.
77
78        :param case_type: load case type enumeration, defaults to None
79        :type case_type: Union[None, eLoadCaseType], optional
80        :return: count of load case of type, if specified, else all
81        :rtype: int
82        """
83        if case_type:
84            return self.load_cases.Count(case_type)
85        else:
86            return self.load_cases.Count()

Count of load cases of type if specified.

Parameters
  • case_type: load case type enumeration, defaults to None
Returns

count of load case of type, if specified, else all

def delete(self, case_name: str) -> None:
89    def delete(self, case_name : str) -> None:
90        """Deletes the specified load case.
91
92        :param case_name: name of existing load case
93        :type case_name: str
94        """
95        handle(self.load_cases.Delete(case_name))

Deletes the specified load case.

Parameters
  • case_name: name of existing load case
def get_name_list(self, case_type: Optional[ETABSv1.eLoadCaseType] = None) -> list[str]:
 98    def get_name_list(self, case_type : Union[None, etabs.eLoadCaseType] = None) -> list[str]:
 99        """Retrieves the names of all defined load cases of the specified type.
100
101        :param case_type: load case type enumeration, defaults to None
102        :type case_type: Union[None, eLoadCaseType], optional
103        :return: load case names of type, if specified, else all
104        :rtype: list[str]
105        """
106        number_names = int()
107        case_names = [str()]
108        if case_type:
109            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names, case_type)
110        else:
111            [ret, number_names, case_names] = self.load_cases.GetNameList(number_names, case_names)
112        handle(ret)
113        return list(case_names)

Retrieves the names of all defined load cases of the specified type.

Parameters
  • case_type: load case type enumeration, defaults to None
Returns

load case names of type, if specified, else all

def get_type(self, case_name: str) -> pytabs.load_cases.LoadCaseType:
116    def get_type(self, case_name : str) -> LoadCaseType:
117        """Retrieves the case type, design type, and auto flag for the specified load case.
118
119        :param case_name: name of existing load case
120        :type case_name: str
121        :return: load case type details
122        :rtype: LoadCaseType
123        """
124        case_type = etabs.eLoadCaseType.Buckling
125        sub_type = int()
126        design_type = etabs.eLoadPatternType.Notional
127        design_type_option = int()
128        is_automatic = int()
129        design_type_options_desc = {0: 'Program determined', 1: 'User specified'}
130        is_automatic_desc = {0: False, 1: True}
131        
132        [ref, case_type, sub_type, design_type, 
133         design_type_option, is_automatic] = self.load_cases.GetTypeOAPI_1(case_name, case_type, sub_type,
134                                                                           design_type, design_type_option, is_automatic)
135        handle(ref)
136        sub_type = self.__determine_sub_type(case_type, sub_type)
137        return {'case_name': case_name,
138                'case_type': case_type,
139                'sub_type': sub_type,
140                'design_type': design_type,
141                'design_type_option': design_type_options_desc[design_type_option],
142                'is_automatic': is_automatic_desc[is_automatic]}

Retrieves the case type, design type, and auto flag for the specified load case.

Parameters
  • case_name: name of existing load case
Returns

load case type details

def set_design_type( self, case_name: str, design_type_option: int, design_type: ETABSv1.eLoadPatternType = <ETABSv1.eLoadPatternType object>) -> None:
145    def set_design_type(self, case_name : str, design_type_option : int, design_type : etabs.eLoadPatternType = etabs.eLoadPatternType.Dead) -> None:
146        """Set design type of existing load case.
147
148        :param case_name: name of existing load case
149        :type case_name: str
150        :param design_type_option: design type option (0 = Program determined, 1 = User specified)
151        :type design_type_option: int
152        :param design_type: design type, defaults to eLoadPatternType.Dead
153        :type design_type: eLoadPatternType, optional
154        """
155        handle(self.load_cases.SetDesignType(case_name, design_type_option, design_type))

Set design type of existing load case.

Parameters
  • case_name: name of existing load case
  • design_type_option: design type option (0 = Program determined, 1 = User specified)
  • design_type: design type, defaults to eLoadPatternType.Dead