pytabs.analysis_results_setup

  1# pyTABS - ETABS .NET API python wrapper
  2# AnalysisResultsSetup - cAnalysisResultsSetup interface
  3__all__ = ['AnalysisResultsSetup']
  4
  5# import ETABS namespace and pyTABS error handler
  6from pytabs.etabs_config import *
  7from pytabs.error_handle import *
  8
  9
 10# import custom enumerations
 11from pytabs.enumerations import (eResultsSetupStepOutOption, eResultsSetupComboOutOption)
 12
 13
 14class AnalysisResultsSetup:
 15    """AnalysisResultsSetup interface"""
 16    def __init__(self, sap_model : etabs.cSapModel) -> None:
 17        # link of SapModel interface
 18        self.sap_model = sap_model
 19        # create AnalysisResultsSetup interface
 20        self.analysis_results_setup = etabs.cAnalysisResultsSetup(sap_model.Results.Setup)
 21        
 22        # relate custom enumerations
 23        self.eResultsSetupStepOutOption = eResultsSetupStepOutOption
 24        self.eResultsSetupComboOutOption =  eResultsSetupComboOutOption
 25        
 26        
 27    # Analysis Results Setup Methods
 28    def deselect_all_cases_combos_for_output(self) -> None:
 29        """Deselects all load cases and response combinations for output."""
 30        handle(self.analysis_results_setup.DeselectAllCasesAndCombosForOutput())
 31
 32
 33    def get_case_selected_for_output(self, case_name : str) -> bool:
 34        """Checks if a load case is selected for output.
 35
 36        :param case_name: name of an existing load case
 37        :type case_name: str
 38        :return: `True` if the Case selected for output, `False` otherwise
 39        :rtype: bool
 40        """
 41        [ret, selected] = self.analysis_results_setup.GetCaseSelectedForOutput(case_name)
 42        handle(ret)
 43        return selected
 44
 45
 46    def get_combo_selected_for_output(self, combo_name : str) -> bool:
 47        """Checks if a load combination is selected for output.
 48
 49        :param combo_name: name of an existing combination
 50        :type combo_name: str
 51        :return: `True` if the Combination selected for output, `False` otherwise
 52        :rtype: bool
 53        """
 54        [ret, selected] = self.analysis_results_setup.GetComboSelectedForOutput(combo_name)
 55        handle(ret)
 56        return selected
 57    
 58    
 59    def get_base_reaction_location(self) -> tuple[float, float, float]:
 60        """Retrieves the global coordinates of the location at which the base reactions are reported.
 61
 62        :return: global coordinate of 3d point where base reactions are reported (gx, gy, gz)
 63        :rtype: tuple[float, float, float]
 64        """
 65        gx = float()
 66        gy = float()
 67        gz = float()
 68        [ret, gx, gy, gz] = self.analysis_results_setup.GetOptionBaseReactLoc(gx, gy, gz)
 69        handle(ret)
 70        return (gx, gy, gz)
 71    
 72
 73    def get_buckling_mode_setup(self) -> tuple[int, int, bool]:
 74        """Retrieves the mode buckling range for output. 
 75        
 76        :return: return[0] - first buckling mode, return[1] - last buckling mode, return[2] - all buckling modes
 77        :rtype: tuple[int, int, bool]"""
 78
 79        start_buckling_mode = int()
 80        end_buckling_mode = int()
 81        all_buckling_modes = bool()
 82        [ret, start_buckling_mode,
 83        end_buckling_mode, all_buckling_modes] = self.analysis_results_setup.GetOptionBucklingMode(start_buckling_mode,
 84                                                                                                   end_buckling_mode,
 85                                                                                                   all_buckling_modes)
 86        handle(ret)
 87        return (start_buckling_mode, end_buckling_mode, all_buckling_modes)
 88
 89
 90    def get_direct_history_setup(self) -> eResultsSetupStepOutOption:
 91        """Retrieves the output option for direct history results.
 92
 93        :return: one of step out options (envelopes, step-by-step or last-step)
 94        :rtype: eResultsSetupStepOutOption
 95        """
 96        option = int()
 97        [ret, option] = self.analysis_results_setup.GetOptionDirectHist(option)
 98        handle(ret)
 99        return eResultsSetupStepOutOption(option)
100
101
102    def get_modal_history_setup(self) -> eResultsSetupStepOutOption:
103        """Retrieves the output option for modal history results. 
104
105        :return: one of step out options (envelopes, step-by-step or last-step)
106        :rtype: eResultsSetupStepOutOption
107        """
108        option = int()
109        [ret, option] = self.analysis_results_setup.GetOptionModalHist(option)
110        handle(ret)
111        return eResultsSetupStepOutOption(option)
112
113
114    def get_mode_shape_setup(self) -> tuple[bool, int, int]:
115        """Retrieves the mode shape range for output.
116
117        :return: return[0] - all modes, return[1] - first mode, return[2] - last mode
118        :rtype: tuple[bool, int, int]
119        """
120        start_mode = int()
121        end_mode = int()
122        all_modes = bool()
123        [ret, start_mode, end_mode, all_modes] = self.analysis_results_setup.GetOptionModeShape(start_mode, end_mode, all_modes)
124        handle(ret)
125        return (all_modes, start_mode, end_mode)
126    
127    
128    # TODO GetOptionMultiStepStatic - setup options within ETABS unknown
129    
130
131    def get_combination_setup(self) -> eResultsSetupComboOutOption:
132        """Retrieves the combination option setup.
133
134        :return: one of combo options (envelopes or multiple)
135        :rtype: eResultsSetupComboOutOption
136        """
137        option = int()
138        [ret, option] = self.analysis_results_setup.GetOptionMultiValuedCombo(option)
139        handle(ret)
140        return eResultsSetupComboOutOption(option)
141    
142    
143    def get_nonlinear_setup(self) -> eResultsSetupStepOutOption:
144        """Retrieves the non-linear static results option.
145
146        :return: one of step out options (envelopes, step-by-step or last-step)
147        :rtype: eResultsSetupStepOutOption
148        """
149        option = int()
150        [ret, option] = self.analysis_results_setup.GetOptionNLStatic(option)
151        handle(ret)
152        return eResultsSetupStepOutOption(option)
153    
154    
155    def set_case_selected_for_output(self, case_name : str, select_state : bool = True) -> None:
156        """Sets a load case selected for output flag.
157
158        :param case_name: name of existing load case
159        :type case_name: str
160        :param select_state: select case for output, defaults to `True`
161        :type select_state: bool, optional
162        """
163        handle(self.analysis_results_setup.SetCaseSelectedForOutput(case_name, select_state))
164    
165    
166    def set_combo_selected_for_output(self, combo_name : str, select_state : bool = True) -> None:
167        """Sets a combination selected for output flag.
168
169        :param combo_name: name of the existing combination
170        :type combo_name: str
171        :param select_state: select combination for output defaults to `True`
172        :type select_state: bool, optional
173        """
174        handle(self.analysis_results_setup.SetComboSelectedForOutput(combo_name, select_state))
175
176
177    def set_base_reaction_location(self, point : tuple[float, float, float]) -> None:
178        """Sets the global coordinates of the location at which the base reactions are reported.
179
180        :param point: global coordinate of 3d point where base reactions are to be reported (gx, gy, gz)
181        :type point: tuple[float, float, float]
182        """
183        handle(self.analysis_results_setup.SetOptionBaseReactLoc(point[0], point[1], point[2]))
184    
185    
186    def set_buckling_mode_setup(self, start_buckling_mode : int, end_buckling_mode : int, all_buckling_modes : bool = False) -> None: 
187        """Sets the buckling mode range for output. 
188        
189        :param start_buckling_mode: first buckling mode number 
190        :type start_buckling_mode: int
191        :param end_buckling_mode: last buckling mode number 
192        :type start_buckling_mode: int
193        :param all_buckling_modes: all buckling modes, defaults to `False` 
194        :type start_buckling_mode: bool, optional 
195        """
196        handle(self.analysis_results_setup.SetOptionBucklingMode(start_buckling_mode, end_buckling_mode, all_buckling_modes))
197        
198        
199    def set_direct_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
200        """Sets the direct history results option.
201        
202        :param option: one of step out options (envelopes, step-by-step or last-step)
203        :type option:  eResultsSetupStepOutOption
204        """
205        handle(self.analysis_results_setup.SetOptionDirectHist(option.value))
206
207
208    def set_modal_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
209        """Sets the modal history results option.
210        
211        :param option: one of step out options (envelopes, step-by-step or last-step)
212        :type option:  eResultsSetupStepOutOption
213        """
214        handle(self.analysis_results_setup.SetOptionModalHist(option.value))
215        
216        
217    def set_mode_shape_setup(self, start_mode : int, end_mode : int, all_modes : bool = False) -> None:
218        """Sets the mode shape range for output.
219
220        :param start_mode: first mode number
221        :type start_mode: int
222        :param end_mode: last mode number
223        :type end_mode: int
224        :param all_modes: all modes, defaults to False
225        :type all_modes: bool, optional
226        """
227        handle(self.analysis_results_setup.SetOptionModeShape(start_mode, end_mode, all_modes))
228
229
230    # TODO SetOptionMultiStepStatic - setup options within ETABS unknown
231    
232
233    def set_combination_setup(self, option : eResultsSetupComboOutOption) -> None:
234        """Sets the non-linear static results option.
235        
236        :param option: one of combo options (envelopes or multiple)
237        :type option: eResultsSetupComboOutOption
238        """
239        handle(self.analysis_results_setup.SetOptionMultiValuedCombo(option.value))
240
241
242    def set_nonlinear_setup(self, option : eResultsSetupStepOutOption) -> None:
243        """Sets the non-linear static results option.
244        
245        :param option: one of step out options (envelopes, step-by-step or last-step)
246        :type option: eResultsSetupStepOutOption
247        """
248        handle(self.analysis_results_setup.SetOptionNLStatic(option.value))
class AnalysisResultsSetup:
 15class AnalysisResultsSetup:
 16    """AnalysisResultsSetup interface"""
 17    def __init__(self, sap_model : etabs.cSapModel) -> None:
 18        # link of SapModel interface
 19        self.sap_model = sap_model
 20        # create AnalysisResultsSetup interface
 21        self.analysis_results_setup = etabs.cAnalysisResultsSetup(sap_model.Results.Setup)
 22        
 23        # relate custom enumerations
 24        self.eResultsSetupStepOutOption = eResultsSetupStepOutOption
 25        self.eResultsSetupComboOutOption =  eResultsSetupComboOutOption
 26        
 27        
 28    # Analysis Results Setup Methods
 29    def deselect_all_cases_combos_for_output(self) -> None:
 30        """Deselects all load cases and response combinations for output."""
 31        handle(self.analysis_results_setup.DeselectAllCasesAndCombosForOutput())
 32
 33
 34    def get_case_selected_for_output(self, case_name : str) -> bool:
 35        """Checks if a load case is selected for output.
 36
 37        :param case_name: name of an existing load case
 38        :type case_name: str
 39        :return: `True` if the Case selected for output, `False` otherwise
 40        :rtype: bool
 41        """
 42        [ret, selected] = self.analysis_results_setup.GetCaseSelectedForOutput(case_name)
 43        handle(ret)
 44        return selected
 45
 46
 47    def get_combo_selected_for_output(self, combo_name : str) -> bool:
 48        """Checks if a load combination is selected for output.
 49
 50        :param combo_name: name of an existing combination
 51        :type combo_name: str
 52        :return: `True` if the Combination selected for output, `False` otherwise
 53        :rtype: bool
 54        """
 55        [ret, selected] = self.analysis_results_setup.GetComboSelectedForOutput(combo_name)
 56        handle(ret)
 57        return selected
 58    
 59    
 60    def get_base_reaction_location(self) -> tuple[float, float, float]:
 61        """Retrieves the global coordinates of the location at which the base reactions are reported.
 62
 63        :return: global coordinate of 3d point where base reactions are reported (gx, gy, gz)
 64        :rtype: tuple[float, float, float]
 65        """
 66        gx = float()
 67        gy = float()
 68        gz = float()
 69        [ret, gx, gy, gz] = self.analysis_results_setup.GetOptionBaseReactLoc(gx, gy, gz)
 70        handle(ret)
 71        return (gx, gy, gz)
 72    
 73
 74    def get_buckling_mode_setup(self) -> tuple[int, int, bool]:
 75        """Retrieves the mode buckling range for output. 
 76        
 77        :return: return[0] - first buckling mode, return[1] - last buckling mode, return[2] - all buckling modes
 78        :rtype: tuple[int, int, bool]"""
 79
 80        start_buckling_mode = int()
 81        end_buckling_mode = int()
 82        all_buckling_modes = bool()
 83        [ret, start_buckling_mode,
 84        end_buckling_mode, all_buckling_modes] = self.analysis_results_setup.GetOptionBucklingMode(start_buckling_mode,
 85                                                                                                   end_buckling_mode,
 86                                                                                                   all_buckling_modes)
 87        handle(ret)
 88        return (start_buckling_mode, end_buckling_mode, all_buckling_modes)
 89
 90
 91    def get_direct_history_setup(self) -> eResultsSetupStepOutOption:
 92        """Retrieves the output option for direct history results.
 93
 94        :return: one of step out options (envelopes, step-by-step or last-step)
 95        :rtype: eResultsSetupStepOutOption
 96        """
 97        option = int()
 98        [ret, option] = self.analysis_results_setup.GetOptionDirectHist(option)
 99        handle(ret)
100        return eResultsSetupStepOutOption(option)
101
102
103    def get_modal_history_setup(self) -> eResultsSetupStepOutOption:
104        """Retrieves the output option for modal history results. 
105
106        :return: one of step out options (envelopes, step-by-step or last-step)
107        :rtype: eResultsSetupStepOutOption
108        """
109        option = int()
110        [ret, option] = self.analysis_results_setup.GetOptionModalHist(option)
111        handle(ret)
112        return eResultsSetupStepOutOption(option)
113
114
115    def get_mode_shape_setup(self) -> tuple[bool, int, int]:
116        """Retrieves the mode shape range for output.
117
118        :return: return[0] - all modes, return[1] - first mode, return[2] - last mode
119        :rtype: tuple[bool, int, int]
120        """
121        start_mode = int()
122        end_mode = int()
123        all_modes = bool()
124        [ret, start_mode, end_mode, all_modes] = self.analysis_results_setup.GetOptionModeShape(start_mode, end_mode, all_modes)
125        handle(ret)
126        return (all_modes, start_mode, end_mode)
127    
128    
129    # TODO GetOptionMultiStepStatic - setup options within ETABS unknown
130    
131
132    def get_combination_setup(self) -> eResultsSetupComboOutOption:
133        """Retrieves the combination option setup.
134
135        :return: one of combo options (envelopes or multiple)
136        :rtype: eResultsSetupComboOutOption
137        """
138        option = int()
139        [ret, option] = self.analysis_results_setup.GetOptionMultiValuedCombo(option)
140        handle(ret)
141        return eResultsSetupComboOutOption(option)
142    
143    
144    def get_nonlinear_setup(self) -> eResultsSetupStepOutOption:
145        """Retrieves the non-linear static results option.
146
147        :return: one of step out options (envelopes, step-by-step or last-step)
148        :rtype: eResultsSetupStepOutOption
149        """
150        option = int()
151        [ret, option] = self.analysis_results_setup.GetOptionNLStatic(option)
152        handle(ret)
153        return eResultsSetupStepOutOption(option)
154    
155    
156    def set_case_selected_for_output(self, case_name : str, select_state : bool = True) -> None:
157        """Sets a load case selected for output flag.
158
159        :param case_name: name of existing load case
160        :type case_name: str
161        :param select_state: select case for output, defaults to `True`
162        :type select_state: bool, optional
163        """
164        handle(self.analysis_results_setup.SetCaseSelectedForOutput(case_name, select_state))
165    
166    
167    def set_combo_selected_for_output(self, combo_name : str, select_state : bool = True) -> None:
168        """Sets a combination selected for output flag.
169
170        :param combo_name: name of the existing combination
171        :type combo_name: str
172        :param select_state: select combination for output defaults to `True`
173        :type select_state: bool, optional
174        """
175        handle(self.analysis_results_setup.SetComboSelectedForOutput(combo_name, select_state))
176
177
178    def set_base_reaction_location(self, point : tuple[float, float, float]) -> None:
179        """Sets the global coordinates of the location at which the base reactions are reported.
180
181        :param point: global coordinate of 3d point where base reactions are to be reported (gx, gy, gz)
182        :type point: tuple[float, float, float]
183        """
184        handle(self.analysis_results_setup.SetOptionBaseReactLoc(point[0], point[1], point[2]))
185    
186    
187    def set_buckling_mode_setup(self, start_buckling_mode : int, end_buckling_mode : int, all_buckling_modes : bool = False) -> None: 
188        """Sets the buckling mode range for output. 
189        
190        :param start_buckling_mode: first buckling mode number 
191        :type start_buckling_mode: int
192        :param end_buckling_mode: last buckling mode number 
193        :type start_buckling_mode: int
194        :param all_buckling_modes: all buckling modes, defaults to `False` 
195        :type start_buckling_mode: bool, optional 
196        """
197        handle(self.analysis_results_setup.SetOptionBucklingMode(start_buckling_mode, end_buckling_mode, all_buckling_modes))
198        
199        
200    def set_direct_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
201        """Sets the direct history results option.
202        
203        :param option: one of step out options (envelopes, step-by-step or last-step)
204        :type option:  eResultsSetupStepOutOption
205        """
206        handle(self.analysis_results_setup.SetOptionDirectHist(option.value))
207
208
209    def set_modal_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
210        """Sets the modal history results option.
211        
212        :param option: one of step out options (envelopes, step-by-step or last-step)
213        :type option:  eResultsSetupStepOutOption
214        """
215        handle(self.analysis_results_setup.SetOptionModalHist(option.value))
216        
217        
218    def set_mode_shape_setup(self, start_mode : int, end_mode : int, all_modes : bool = False) -> None:
219        """Sets the mode shape range for output.
220
221        :param start_mode: first mode number
222        :type start_mode: int
223        :param end_mode: last mode number
224        :type end_mode: int
225        :param all_modes: all modes, defaults to False
226        :type all_modes: bool, optional
227        """
228        handle(self.analysis_results_setup.SetOptionModeShape(start_mode, end_mode, all_modes))
229
230
231    # TODO SetOptionMultiStepStatic - setup options within ETABS unknown
232    
233
234    def set_combination_setup(self, option : eResultsSetupComboOutOption) -> None:
235        """Sets the non-linear static results option.
236        
237        :param option: one of combo options (envelopes or multiple)
238        :type option: eResultsSetupComboOutOption
239        """
240        handle(self.analysis_results_setup.SetOptionMultiValuedCombo(option.value))
241
242
243    def set_nonlinear_setup(self, option : eResultsSetupStepOutOption) -> None:
244        """Sets the non-linear static results option.
245        
246        :param option: one of step out options (envelopes, step-by-step or last-step)
247        :type option: eResultsSetupStepOutOption
248        """
249        handle(self.analysis_results_setup.SetOptionNLStatic(option.value))

AnalysisResultsSetup interface

AnalysisResultsSetup(sap_model: ETABSv1.cSapModel)
17    def __init__(self, sap_model : etabs.cSapModel) -> None:
18        # link of SapModel interface
19        self.sap_model = sap_model
20        # create AnalysisResultsSetup interface
21        self.analysis_results_setup = etabs.cAnalysisResultsSetup(sap_model.Results.Setup)
22        
23        # relate custom enumerations
24        self.eResultsSetupStepOutOption = eResultsSetupStepOutOption
25        self.eResultsSetupComboOutOption =  eResultsSetupComboOutOption
def deselect_all_cases_combos_for_output(self) -> None:
29    def deselect_all_cases_combos_for_output(self) -> None:
30        """Deselects all load cases and response combinations for output."""
31        handle(self.analysis_results_setup.DeselectAllCasesAndCombosForOutput())

Deselects all load cases and response combinations for output.

def get_case_selected_for_output(self, case_name: str) -> bool:
34    def get_case_selected_for_output(self, case_name : str) -> bool:
35        """Checks if a load case is selected for output.
36
37        :param case_name: name of an existing load case
38        :type case_name: str
39        :return: `True` if the Case selected for output, `False` otherwise
40        :rtype: bool
41        """
42        [ret, selected] = self.analysis_results_setup.GetCaseSelectedForOutput(case_name)
43        handle(ret)
44        return selected

Checks if a load case is selected for output.

Parameters
  • case_name: name of an existing load case
Returns

True if the Case selected for output, False otherwise

def get_combo_selected_for_output(self, combo_name: str) -> bool:
47    def get_combo_selected_for_output(self, combo_name : str) -> bool:
48        """Checks if a load combination is selected for output.
49
50        :param combo_name: name of an existing combination
51        :type combo_name: str
52        :return: `True` if the Combination selected for output, `False` otherwise
53        :rtype: bool
54        """
55        [ret, selected] = self.analysis_results_setup.GetComboSelectedForOutput(combo_name)
56        handle(ret)
57        return selected

Checks if a load combination is selected for output.

Parameters
  • combo_name: name of an existing combination
Returns

True if the Combination selected for output, False otherwise

def get_base_reaction_location(self) -> tuple[float, float, float]:
60    def get_base_reaction_location(self) -> tuple[float, float, float]:
61        """Retrieves the global coordinates of the location at which the base reactions are reported.
62
63        :return: global coordinate of 3d point where base reactions are reported (gx, gy, gz)
64        :rtype: tuple[float, float, float]
65        """
66        gx = float()
67        gy = float()
68        gz = float()
69        [ret, gx, gy, gz] = self.analysis_results_setup.GetOptionBaseReactLoc(gx, gy, gz)
70        handle(ret)
71        return (gx, gy, gz)

Retrieves the global coordinates of the location at which the base reactions are reported.

Returns

global coordinate of 3d point where base reactions are reported (gx, gy, gz)

def get_buckling_mode_setup(self) -> tuple[int, int, bool]:
74    def get_buckling_mode_setup(self) -> tuple[int, int, bool]:
75        """Retrieves the mode buckling range for output. 
76        
77        :return: return[0] - first buckling mode, return[1] - last buckling mode, return[2] - all buckling modes
78        :rtype: tuple[int, int, bool]"""
79
80        start_buckling_mode = int()
81        end_buckling_mode = int()
82        all_buckling_modes = bool()
83        [ret, start_buckling_mode,
84        end_buckling_mode, all_buckling_modes] = self.analysis_results_setup.GetOptionBucklingMode(start_buckling_mode,
85                                                                                                   end_buckling_mode,
86                                                                                                   all_buckling_modes)
87        handle(ret)
88        return (start_buckling_mode, end_buckling_mode, all_buckling_modes)

Retrieves the mode buckling range for output.

Returns

return[0] - first buckling mode, return[1] - last buckling mode, return[2] - all buckling modes

def get_direct_history_setup(self) -> pytabs.enumerations.eResultsSetupStepOutOption:
 91    def get_direct_history_setup(self) -> eResultsSetupStepOutOption:
 92        """Retrieves the output option for direct history results.
 93
 94        :return: one of step out options (envelopes, step-by-step or last-step)
 95        :rtype: eResultsSetupStepOutOption
 96        """
 97        option = int()
 98        [ret, option] = self.analysis_results_setup.GetOptionDirectHist(option)
 99        handle(ret)
100        return eResultsSetupStepOutOption(option)

Retrieves the output option for direct history results.

Returns

one of step out options (envelopes, step-by-step or last-step)

def get_modal_history_setup(self) -> pytabs.enumerations.eResultsSetupStepOutOption:
103    def get_modal_history_setup(self) -> eResultsSetupStepOutOption:
104        """Retrieves the output option for modal history results. 
105
106        :return: one of step out options (envelopes, step-by-step or last-step)
107        :rtype: eResultsSetupStepOutOption
108        """
109        option = int()
110        [ret, option] = self.analysis_results_setup.GetOptionModalHist(option)
111        handle(ret)
112        return eResultsSetupStepOutOption(option)

Retrieves the output option for modal history results.

Returns

one of step out options (envelopes, step-by-step or last-step)

def get_mode_shape_setup(self) -> tuple[bool, int, int]:
115    def get_mode_shape_setup(self) -> tuple[bool, int, int]:
116        """Retrieves the mode shape range for output.
117
118        :return: return[0] - all modes, return[1] - first mode, return[2] - last mode
119        :rtype: tuple[bool, int, int]
120        """
121        start_mode = int()
122        end_mode = int()
123        all_modes = bool()
124        [ret, start_mode, end_mode, all_modes] = self.analysis_results_setup.GetOptionModeShape(start_mode, end_mode, all_modes)
125        handle(ret)
126        return (all_modes, start_mode, end_mode)

Retrieves the mode shape range for output.

Returns

return[0] - all modes, return[1] - first mode, return[2] - last mode

def get_combination_setup(self) -> pytabs.enumerations.eResultsSetupComboOutOption:
132    def get_combination_setup(self) -> eResultsSetupComboOutOption:
133        """Retrieves the combination option setup.
134
135        :return: one of combo options (envelopes or multiple)
136        :rtype: eResultsSetupComboOutOption
137        """
138        option = int()
139        [ret, option] = self.analysis_results_setup.GetOptionMultiValuedCombo(option)
140        handle(ret)
141        return eResultsSetupComboOutOption(option)

Retrieves the combination option setup.

Returns

one of combo options (envelopes or multiple)

def get_nonlinear_setup(self) -> pytabs.enumerations.eResultsSetupStepOutOption:
144    def get_nonlinear_setup(self) -> eResultsSetupStepOutOption:
145        """Retrieves the non-linear static results option.
146
147        :return: one of step out options (envelopes, step-by-step or last-step)
148        :rtype: eResultsSetupStepOutOption
149        """
150        option = int()
151        [ret, option] = self.analysis_results_setup.GetOptionNLStatic(option)
152        handle(ret)
153        return eResultsSetupStepOutOption(option)

Retrieves the non-linear static results option.

Returns

one of step out options (envelopes, step-by-step or last-step)

def set_case_selected_for_output(self, case_name: str, select_state: bool = True) -> None:
156    def set_case_selected_for_output(self, case_name : str, select_state : bool = True) -> None:
157        """Sets a load case selected for output flag.
158
159        :param case_name: name of existing load case
160        :type case_name: str
161        :param select_state: select case for output, defaults to `True`
162        :type select_state: bool, optional
163        """
164        handle(self.analysis_results_setup.SetCaseSelectedForOutput(case_name, select_state))

Sets a load case selected for output flag.

Parameters
  • case_name: name of existing load case
  • select_state: select case for output, defaults to True
def set_combo_selected_for_output(self, combo_name: str, select_state: bool = True) -> None:
167    def set_combo_selected_for_output(self, combo_name : str, select_state : bool = True) -> None:
168        """Sets a combination selected for output flag.
169
170        :param combo_name: name of the existing combination
171        :type combo_name: str
172        :param select_state: select combination for output defaults to `True`
173        :type select_state: bool, optional
174        """
175        handle(self.analysis_results_setup.SetComboSelectedForOutput(combo_name, select_state))

Sets a combination selected for output flag.

Parameters
  • combo_name: name of the existing combination
  • select_state: select combination for output defaults to True
def set_base_reaction_location(self, point: tuple[float, float, float]) -> None:
178    def set_base_reaction_location(self, point : tuple[float, float, float]) -> None:
179        """Sets the global coordinates of the location at which the base reactions are reported.
180
181        :param point: global coordinate of 3d point where base reactions are to be reported (gx, gy, gz)
182        :type point: tuple[float, float, float]
183        """
184        handle(self.analysis_results_setup.SetOptionBaseReactLoc(point[0], point[1], point[2]))

Sets the global coordinates of the location at which the base reactions are reported.

Parameters
  • point: global coordinate of 3d point where base reactions are to be reported (gx, gy, gz)
def set_buckling_mode_setup( self, start_buckling_mode: int, end_buckling_mode: int, all_buckling_modes: bool = False) -> None:
187    def set_buckling_mode_setup(self, start_buckling_mode : int, end_buckling_mode : int, all_buckling_modes : bool = False) -> None: 
188        """Sets the buckling mode range for output. 
189        
190        :param start_buckling_mode: first buckling mode number 
191        :type start_buckling_mode: int
192        :param end_buckling_mode: last buckling mode number 
193        :type start_buckling_mode: int
194        :param all_buckling_modes: all buckling modes, defaults to `False` 
195        :type start_buckling_mode: bool, optional 
196        """
197        handle(self.analysis_results_setup.SetOptionBucklingMode(start_buckling_mode, end_buckling_mode, all_buckling_modes))

Sets the buckling mode range for output.

Parameters
  • start_buckling_mode: first buckling mode number
  • end_buckling_mode: last buckling mode number
  • all_buckling_modes: all buckling modes, defaults to False
def set_direct_history_setup(self, option: pytabs.enumerations.eResultsSetupStepOutOption) -> None:
200    def set_direct_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
201        """Sets the direct history results option.
202        
203        :param option: one of step out options (envelopes, step-by-step or last-step)
204        :type option:  eResultsSetupStepOutOption
205        """
206        handle(self.analysis_results_setup.SetOptionDirectHist(option.value))

Sets the direct history results option.

Parameters
  • option: one of step out options (envelopes, step-by-step or last-step)
def set_modal_history_setup(self, option: pytabs.enumerations.eResultsSetupStepOutOption) -> None:
209    def set_modal_history_setup(self, option : eResultsSetupStepOutOption) -> None: 
210        """Sets the modal history results option.
211        
212        :param option: one of step out options (envelopes, step-by-step or last-step)
213        :type option:  eResultsSetupStepOutOption
214        """
215        handle(self.analysis_results_setup.SetOptionModalHist(option.value))

Sets the modal history results option.

Parameters
  • option: one of step out options (envelopes, step-by-step or last-step)
def set_mode_shape_setup(self, start_mode: int, end_mode: int, all_modes: bool = False) -> None:
218    def set_mode_shape_setup(self, start_mode : int, end_mode : int, all_modes : bool = False) -> None:
219        """Sets the mode shape range for output.
220
221        :param start_mode: first mode number
222        :type start_mode: int
223        :param end_mode: last mode number
224        :type end_mode: int
225        :param all_modes: all modes, defaults to False
226        :type all_modes: bool, optional
227        """
228        handle(self.analysis_results_setup.SetOptionModeShape(start_mode, end_mode, all_modes))

Sets the mode shape range for output.

Parameters
  • start_mode: first mode number
  • end_mode: last mode number
  • all_modes: all modes, defaults to False
def set_combination_setup(self, option: pytabs.enumerations.eResultsSetupComboOutOption) -> None:
234    def set_combination_setup(self, option : eResultsSetupComboOutOption) -> None:
235        """Sets the non-linear static results option.
236        
237        :param option: one of combo options (envelopes or multiple)
238        :type option: eResultsSetupComboOutOption
239        """
240        handle(self.analysis_results_setup.SetOptionMultiValuedCombo(option.value))

Sets the non-linear static results option.

Parameters
  • option: one of combo options (envelopes or multiple)
def set_nonlinear_setup(self, option: pytabs.enumerations.eResultsSetupStepOutOption) -> None:
243    def set_nonlinear_setup(self, option : eResultsSetupStepOutOption) -> None:
244        """Sets the non-linear static results option.
245        
246        :param option: one of step out options (envelopes, step-by-step or last-step)
247        :type option: eResultsSetupStepOutOption
248        """
249        handle(self.analysis_results_setup.SetOptionNLStatic(option.value))

Sets the non-linear static results option.

Parameters
  • option: one of step out options (envelopes, step-by-step or last-step)