Metadata-Version: 2.4
Name: qtmodel
Version: 2.8.2
Summary: Python API and local engineering utilities for Qiaotong bridge software
Author: Qiaotong
Keywords: bridge,finite-element,qiaotong,engineering
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Topic :: Scientific/Engineering
Requires-Python: <4,>=3.10
Description-Content-Type: text/markdown
Requires-Dist: requests>=2.28
Requires-Dist: psutil>=5.9

# qtmodel

`qtmodel` 是桥通软件的 Python API 包，提供有限元模型创建与修改、模型查询、
求解结果读取、结构检算，以及不依赖桥通进程的截面几何和截面特性计算。

> 当前版本：`2.8.2` · Python：`3.10+` · 文档生成日期：`2026-08-20`
> 本文件由 `tools/create_readme.py` 从源码签名和 docstring 自动生成，请勿手工维护函数清单。

## 安装

```bash
python -m pip install --upgrade qtmodel
```

## 使用约定

```python
from qtmodel import QtServer, bridge, cdb, mdb, odb

print(QtServer.get_connection_status())
```

- `mdb`：创建、修改或删除当前桥通模型对象；
- `odb`：读取当前模型、视图和分析结果；
- `cdb`：调用结构检算接口；
- `bridge`：桥梁级组合检算门面；
- Core 类：连接检查、截面 Schema、几何和本地截面特性计算。

## API 数量

| 命名空间 | 公开方法数 |
| --- | ---: |
| `core` | 18 |
| `mdb` | 271 |
| `odb` | 116 |
| `cdb` | 117 |
| `bridge` | 2 |
| **合计** | **524** |

# Core：连接与本地计算

## `section_db`

### `SectionProperty.from_dict`

源码：`qtmodel/core/section_db.py` · `SectionProperty.from_dict`

```python
SectionProperty.from_dict(data: Mapping[str, Any])
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionProperty
result = SectionProperty.from_dict(data=...)
```

### `SectionProperty.units`

源码：`qtmodel/core/section_db.py` · `SectionProperty.units`

```python
SectionProperty.units()
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionProperty
result = SectionProperty.units()
```

### `SectionDB.supported_types`

源码：`qtmodel/core/section_db.py` · `SectionDB.supported_types`

```python
SectionDB.supported_types()
```

返回全部支持字典形式 ``sec_info`` 的截面类型。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.supported_types()
```

### `SectionDB.get_schema`

源码：`qtmodel/core/section_db.py` · `SectionDB.get_schema`

```python
SectionDB.get_schema(sec_type: str)
```

返回指定截面的 Agent 友好、JSON 可序列化 Schema。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.get_schema(sec_type=...)
```

### `SectionDB.get_all_schemas`

源码：`qtmodel/core/section_db.py` · `SectionDB.get_all_schemas`

```python
SectionDB.get_all_schemas()
```

返回全部截面 Schema。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.get_all_schemas()
```

### `SectionDB.parameter_values_from_sequence`

源码：`qtmodel/core/section_db.py` · `SectionDB.parameter_values_from_sequence`

```python
SectionDB.parameter_values_from_sequence(sec_type: str, sec_info: Sequence[Any])
```

把 ``PyModelExporter`` 的有序 ``sec_info`` 还原为语义参数字典。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.parameter_values_from_sequence(sec_type=..., sec_info=...)
```

### `SectionDB.normalize_parameter_updates`

源码：`qtmodel/core/section_db.py` · `SectionDB.normalize_parameter_updates`

```python
SectionDB.normalize_parameter_updates(sec_type: str, updates: Mapping[str, Any], strict: bool=True)
```

把 ``W``、``宽度``、``宽度(W)`` 等更新键归一到稳定参数短码。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.normalize_parameter_updates(sec_type=..., updates=...)
```

### `SectionDB.build_parameter_section_kwargs`

源码：`qtmodel/core/section_db.py` · `SectionDB.build_parameter_section_kwargs`

```python
SectionDB.build_parameter_section_kwargs(sec_type: str, sec_info: Mapping[str, Any], strict: bool=False)
```

将有含义的截面参数字典转换为底层 ``add_section`` 参数。

#### 示例

```python
from qtmodel import SectionDB
result = SectionDB.build_parameter_section_kwargs(sec_type=..., sec_info=...)
```

## `section_geometry`

### `SectionGeometryDB.supported_types`

源码：`qtmodel/core/section_geometry.py` · `SectionGeometryDB.supported_types`

```python
SectionGeometryDB.supported_types()
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionGeometryDB
result = SectionGeometryDB.supported_types()
```

### `SectionGeometryDB.get_source_info`

源码：`qtmodel/core/section_geometry.py` · `SectionGeometryDB.get_source_info`

```python
SectionGeometryDB.get_source_info(sec_type: str)
```

返回 Python 移植所依据的 C# 方法和几何表达类型。

#### 示例

```python
from qtmodel import SectionGeometryDB
result = SectionGeometryDB.get_source_info(sec_type=...)
```

### `SectionGeometryDB.generate`

源码：`qtmodel/core/section_geometry.py` · `SectionGeometryDB.generate`

```python
SectionGeometryDB.generate(sec_type: str, sec_info: Sequence[float]=None, **options: Any)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionGeometryDB
result = SectionGeometryDB.generate(sec_type=...)
```

## `section_property_solver`

### `SectionPropertySolver.calculate`

源码：`qtmodel/core/section_property_solver.py` · `SectionPropertySolver.calculate`

```python
SectionPropertySolver.calculate(shape: Union[SectionShape, Mapping[str, Any]], elastic_modulus_ratio: Optional[float]=None, reference_role: str='main', material_factors: Optional[Mapping[str, float]]=None)
```

返回与桥通字段兼容的 ``SectionProperty``。

``elastic_modulus_ratio`` 表示主材/辅材弹性模量比。以主材为换算基准时
辅材系数为 ``1 / ratio``；以辅材为基准时主材系数为 ``ratio``。
``material_factors`` 可为任意 role 显式指定换算系数，优先级更高。

#### 示例

```python
from qtmodel import SectionPropertySolver
result = SectionPropertySolver.calculate(shape=...)
```

### `SectionPropertySolver.calculate_detailed`

源码：`qtmodel/core/section_property_solver.py` · `SectionPropertySolver.calculate_detailed`

```python
SectionPropertySolver.calculate_detailed(shape: Union[SectionShape, Mapping[str, Any]], elastic_modulus_ratio: Optional[float]=None, reference_role: str='main', material_factors: Optional[Mapping[str, float]]=None)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionPropertySolver
result = SectionPropertySolver.calculate_detailed(shape=...)
```

## `section_shape`

### `SectionPoint.from_value`

源码：`qtmodel/core/section_shape.py` · `SectionPoint.from_value`

```python
SectionPoint.from_value(value: Any)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionPoint
result = SectionPoint.from_value(value=...)
```

### `SectionLoopSegment.from_dict`

源码：`qtmodel/core/section_shape.py` · `SectionLoopSegment.from_dict`

```python
SectionLoopSegment.from_dict(value: Mapping[str, Any])
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionLoopSegment
result = SectionLoopSegment.from_dict(value=...)
```

### `SectionLine.from_value`

源码：`qtmodel/core/section_shape.py` · `SectionLine.from_value`

```python
SectionLine.from_value(value: Any)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionLine
result = SectionLine.from_value(value=...)
```

### `SectionShapePart.from_dict`

源码：`qtmodel/core/section_shape.py` · `SectionShapePart.from_dict`

```python
SectionShapePart.from_dict(value: Mapping[str, Any])
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionShapePart
result = SectionShapePart.from_dict(value=...)
```

### `SectionShape.from_dict`

源码：`qtmodel/core/section_shape.py` · `SectionShape.from_dict`

```python
SectionShape.from_dict(value: Mapping[str, Any])
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import SectionShape
result = SectionShape.from_dict(value=...)
```

# MDB：建模与模型修改

## `mdb_analysis_setting`

### `mdb.update_project_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_project_setting`

```python
mdb.update_project_setting(project: str='', company: str='', designer: str='', reviewer: str='', date_time: str='', gravity: float=9.8, temperature: float=0, description: str='')
```

更新总体设置

#### 参数

>     project (str): 项目名，可为空字符串。
>     company (str): 公司名，可为空字符串。
>     designer (str): 设计人员。
>     reviewer (str): 复核人员。
>     date_time (str): 日期/时间显示文本，C# 不解析日期格式。
>     gravity (float): 重力加速度，固定按 ``m/s²`` 解释，通常取正值 9.8。
>     temperature (float): 设计基准温度，摄氏度，可为负数。
>     description (str): 项目说明。

#### 示例

```python
from qtmodel import mdb
   mdb.update_project_setting(project="项目名",gravity=9.8,temperature=20)
Returns: 无
```

### `mdb.update_global_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_global_setting`

```python
mdb.update_global_setting(solver_type: int=0, calculation_type: int=2, thread_count: int=12)
```

更新整体设置

#### 参数

>     solver_type (int): 仅用 0 稀疏矩阵求解器、1 变带宽求解器。
>     calculation_type (int): 0 单线程、1 用户指定线程数、2 自动设置。
>     thread_count (int): 仅在 ``calculation_type=1`` 时使用，合法范围为
>         ``1..Environment.ProcessorCount``；越界时 C# 回退为全部逻辑处理器数。

#### 示例

```python
from qtmodel import mdb
   mdb.update_global_setting(solver_type=0,calculation_type=2,thread_count=12)
Returns: 无
```

### `mdb.update_construction_stage_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_construction_stage_setting`

```python
mdb.update_construction_stage_setting(do_analysis: bool=True, to_end_stage: bool=True, other_stage_name: str='', analysis_type: int=0, do_creep_analysis: bool=True, cable_tension_position: int=0, consider_completion_stage: bool=True, shrink_creep_type: int=2, creep_load_type: int=1, sub_step_info: Optional[tuple[bool, int, int, int, int, int]]=None)
```

更新施工阶段设置

#### 参数

>     do_analysis (bool): 是否执行施工阶段分析。
>     to_end_stage (bool): ``True`` 计算至最后阶段；``False`` 计算至
>         ``other_stage_name`` 指定阶段。
>     other_stage_name (str): 非最终阶段的名称。HTTP 层将名称转换为从 1
>         开始的阶段号；仅在 ``to_end_stage=False`` 时有效。
>     analysis_type (int): 0 线性、1 非线性、2 部分非线性。
>     do_creep_analysis (bool): 是否考虑收缩/徐变分析。
>     cable_tension_position (int): 0 I端、1 J端、2 平均索力。
>     consider_completion_stage (bool): 是否把成桥受力状态形成的几何刚度
>         计入运营阶段。
>     shrink_creep_type (int): 0 仅徐变、1 仅收缩、2 收缩和徐变。
>     creep_load_type (int): 二期荷载龄期位置：1 开始、2 中间、3 结束。
>     sub_step_info (tuple[bool,int,int,int,int,int] | None): 固定 6 项，依次为
>         是否细分，以及 10/100/1000/5000/10000 天区间步数；步数应为正整数。
>         ``None`` 使用 C# 默认 ``[True,2,5,7,10,20]``。

#### 示例

```python
from qtmodel import mdb
    mdb.update_construction_stage_setting(do_analysis=True, to_end_stage=False, other_stage_name="1",analysis_type=0,
        do_creep_analysis=True, cable_tension_position=0, consider_completion_stage=True,shrink_creep_type=2)
Returns: 无
```

### `mdb.update_live_load_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_live_load_setting`

```python
mdb.update_live_load_setting(lateral_spacing: float=0.1, vertical_spacing: float=1, damper_calc_type: int=-1, displacement_calc_type: int=-1, force_calc_type: int=-1, reaction_calc_type: int=-1, link_calc_type: int=-1, constrain_calc_type: int=-1, eccentricity: float=0.0, displacement_track: bool=False, force_track: bool=False, reaction_track: bool=False, link_track: bool=False, constrain_track: bool=False, damper_groups: Optional[list[str]]=None, displacement_groups: Optional[list[str]]=None, force_groups: Optional[list[str]]=None, reaction_groups: Optional[list[str]]=None, link_groups: Optional[list[str]]=None, constrain_groups: Optional[list[str]]=None)
```

更新移动荷载分析设置

#### 参数

>     lateral_spacing (float): 横向加密间距，当前长度单位，工程上应大于 0。
>     vertical_spacing (float): 纵向加密间距，当前长度单位，应大于 0。
>     damper_calc_type (int): 阻尼器约束方程：-1 不计算、0 全部、1 指定组。
>     displacement_calc_type (int): 位移结果：-1 不计算、0 全部、1 指定组。
>     force_calc_type (int): 单元内力：-1 不计算、0 全部、1 指定组。
>     reaction_calc_type (int): 反力：-1 不计算、0 全部、1 指定组。
>     link_calc_type (int): 弹性连接：-1 不计算、0 全部、1 指定组。
>     constrain_calc_type (int): 约束方程：-1 不计算、0 全部、1 指定组。
>     eccentricity (float): 离心力系数，无量纲。
>     displacement_track: 是否追踪位移
>     force_track: 是否追踪内力
>     reaction_track: 是否追踪反力
>     link_track: 是否追踪连接
>     constrain_track: 是否追踪约束方程
>     damper_groups: 模拟阻尼器约束方程计算类选项为组时边界组名称
>     displacement_groups: 位移计算类选项为组时结构组名称
>     force_groups: 内力计算类选项为组时结构组名称
>     reaction_groups: 反力计算类选项为组时边界组名称
>     link_groups:  弹性连接计算类选项为组时边界组名称
>     constrain_groups: 约束方程计算类选项为组时边界组名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_live_load_setting(lateral_spacing=0.1, vertical_spacing=1, displacement_calc_type=1)
    mdb.update_live_load_setting(lateral_spacing=0.1, vertical_spacing=1, displacement_calc_type=2,displacement_track=True,
        displacement_groups=["结构组1","结构组2"])
Returns: 无
```

### `mdb.update_non_linear_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_non_linear_setting`

```python
mdb.update_non_linear_setting(non_linear_type: int=1, non_linear_method: int=1, max_loading_steps: int=1, max_iteration_times: int=30, accuracy_of_displacement: float=0.0001, accuracy_of_force: float=0.0001)
```

更新非线性设置

#### 参数

>     non_linear_type (int): 0 部分非线性、1 完全非线性。
>     non_linear_method (int): 0 修正牛顿法、1 牛顿法。
>     max_loading_steps (int): 最大加载步数，应为正整数。
>     max_iteration_times (int): 每加载步最大迭代次数，应为正整数。
>     accuracy_of_displacement (float): 位移相对收敛精度，应大于 0。
>     accuracy_of_force (float): 内力相对收敛精度，应大于 0。

#### 示例

```python
from qtmodel import mdb
    mdb.update_non_linear_setting(non_linear_type=-1, non_linear_method=1, max_loading_steps=-1, max_iteration_times=30,
        accuracy_of_displacement=0.0001, accuracy_of_force=0.0001)
Returns: 无
```

### `mdb.update_operation_stage_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_operation_stage_setting`

```python
mdb.update_operation_stage_setting(do_analysis: bool=True, final_stage: str='', static_load_cases: Optional[list[str]]=None, sink_load_cases: Optional[list[str]]=None, live_load_cases: Optional[list[str]]=None)
```

更新运营阶段分析设置

#### 参数

>     do_analysis (bool): 是否执行运营阶段分析。
>     final_stage (str): 运营分析继承的最终施工阶段名，必须已存在。
>     static_load_cases (list[str] | None): 要计算的普通静力工况名称。
>     sink_load_cases (list[str] | None): 要计算的沉降工况名称。
>     live_load_cases (list[str] | None): 要计算的影响面活载工况名称。
>         三类列表为 ``None`` 或空时分别关闭对应分析，名称需精确匹配。

#### 示例

```python
from qtmodel import mdb
    mdb.update_operation_stage_setting(do_analysis=True, final_stage="上二恒",static_load_cases=None)
Returns: 无
```

### `mdb.update_self_vibration_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_self_vibration_setting`

```python
mdb.update_self_vibration_setting(do_analysis: bool=True, method: int=1, matrix_type: int=0, mode_num: int=3)
```

更新自振分析设置

#### 参数

>     do_analysis (bool): 是否执行自振分析。
>     method (int): 1 子空间迭代、2 滤频、3 多重 Ritz、4 Lanczos。
>     matrix_type (int): 0 集中质量矩阵、1 一致质量矩阵。
>     mode_num (int): 要求解的振型数量，应为正整数且不超过模型有效自由度数。

#### 示例

```python
from qtmodel import mdb
    mdb.update_self_vibration_setting(do_analysis=True,method=1,matrix_type=0,mode_num=3)
Returns: 无
```

### `mdb.update_response_spectrum_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_response_spectrum_setting`

```python
mdb.update_response_spectrum_setting(do_analysis: bool=True, kind: int=1, damping: str='', by_mode: bool=False, damping_ratio: Union[float, List[float]]=0.05)
```

更新反应谱设置

#### 参数

>     do_analysis (bool): 是否执行反应谱分析。
>     kind (int): 振型组合方式，1 SRSS、2 CQC。
>     damping (str) : 阻尼名称，默认为空代表无阻尼
>     by_mode (bool): [弃用]
>     damping_ratio (float | list[float]): [弃用]

#### 示例

```python
from qtmodel import mdb
    mdb.update_response_spectrum_setting(do_analysis=True,kind=1,damping_ratio=0.05)
Returns: 无
```

### `mdb.update_time_history_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_time_history_setting`

```python
mdb.update_time_history_setting(do_analysis: bool=True, output_all: bool=True, groups: Optional[list[str]]=None, calc_method: int=1)
```

更新时程分析设置

#### 参数

>     do_analysis (bool): 是否执行时程分析。
>     output_all (bool): 是否输出全部单元结果；C# 当前始终输出全部节点结果。
>     groups (list[str] | None): 当 ``output_all=False`` 时需要输出单元结果的已有结构组名称；
>     calc_method: 1-积分法 2-振型叠加法

#### 示例

```python
from qtmodel import mdb
    mdb.update_time_history_setting(do_analysis=True,output_all=True)
Returns: 无
```

### `mdb.update_bulking_setting`

源码：`qtmodel/mdb/mdb_analysis_setting.py` · `MdbAnalysisSetting.update_bulking_setting`

```python
mdb.update_bulking_setting(do_analysis: bool=True, mode_count: int=3, stage_id: int=-1, calculate_kind: int=1, stressed: bool=True, constant_cases: Optional[list[str]]=None, variable_cases: list[str]=None)
```

更新线性屈曲分析设置（方法名 ``bulking`` 为历史拼写）。

#### 参数

>     do_analysis (bool): 是否执行线性屈曲分析。
>     mode_count (int): 屈曲模态数量，应为正整数。
>     stage_id (int): 基准施工阶段号；``-1`` 或非正数取最后施工阶段，
>         正整数必须对应已有阶段。
>     calculate_kind (int): 恒载归类方式，1 计为不变荷载、2 计为可变荷载。
>     stressed (bool): ``True`` 采用基准阶段末受力状态，``False`` 采用无应力状态。
>     constant_cases (list[str] | None): 不变荷载工况名称集合。
>     variable_cases (list[str] | None): 可变荷载工况名称集合。启用分析时通常
>         至少指定一个；所有名称必须是已存在的普通静力工况。

#### 示例

```python
from qtmodel import mdb
    mdb.update_bulking_setting(do_analysis=True,mode_count=3,variable_cases=["工况1","工况2"])
Returns: 无
```

## `mdb_boundary`

### `mdb.add_effective_width`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_effective_width`

```python
mdb.add_effective_width(element_ids, factor_i: float, factor_j: float, dz_i: float, dz_j: float, group_name: str='默认边界组', factor_i_z: float=0, factor_j_z: float=0, dy_i: float=0, dy_j: float=0, factor_i_ax: float=0, factor_j_ax: float=0)
```

添加有效宽度系数

#### 参数

>    element_ids:边界单元号支持整形和整形列表且支持XtoYbyN形式
>    factor_i:I端截面Iy折减系数
>    factor_j:J端截面Iy折减系数
>    dz_i:I端截面形心变换量
>    dz_j:J端截面形心变换量
>    factor_i_z:J端截面形心变换量
>    factor_j_z:J端截面形心变换量
>    dy_i:J端截面形心变换量
>    dy_j:J端截面形心变换量
>    factor_i_ax:J端截面形心变换量
>    factor_j_ax:J端截面形心变换量
>    group_name:边界组名

#### 示例

```python
from qtmodel import mdb
   mdb.add_effective_width(element_ids=[1,2,3,4],factor_i=0.1,factor_j=0.1,dz_i=0.1,dz_j=0.1)
   mdb.add_effective_width(element_ids="1to4",factor_i=0.1,factor_j=0.1,dz_i=0.1,dz_j=0.1)
Returns: 无
```

### `mdb.add_boundary_group`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_boundary_group`

```python
mdb.add_boundary_group(name: str='')
```

新建边界组

#### 参数

>     name:边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_boundary_group(name="边界组1")
Returns: 无
```

### `mdb.add_general_elastic_support_property`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_general_elastic_support_property`

```python
mdb.add_general_elastic_support_property(name: str='', data_matrix: list[float]=None)
```

添加一般弹性支承特性，默认单位为N,m

#### 参数

>     name:一般弹性支承特性名称，支持覆盖添加
>     data_matrix:一般弹性支承刚度矩阵(数据需按列输入至列表,共计21个参数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_general_elastic_support_property(name = "特性1", data_matrix=[i for i in range(1,22)])
Returns: 无
```

### `mdb.add_general_elastic_support`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_general_elastic_support`

```python
mdb.add_general_elastic_support(node_id=None, property_name: str='', group_name: str='默认边界组')
```

添加一般弹性支承特性

#### 参数

>     node_id:节点号,支持整数或整数型列表且支持XtoYbyN形式字符串
>     property_name:一般弹性支承特性名
>     group_name:一般弹性支承边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_general_elastic_support(node_id=1, property_name = "特性1",group_name="边界组1")
Returns: 无
```

### `mdb.add_general_support`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_general_support`

```python
mdb.add_general_support(node_id: Union[int, str, list[int]]=1, boundary_info: Union[list[bool], list[int]]=None, group_name: str='默认边界组', index: int=-1)
```

添加一般支承

#### 参数

>      node_id:节点编号,支持整数或整数型列表且支持XtoYbyN形式字符串
>      boundary_info:边界信息  [X,Y,Z,Rx,Ry,Rz]  ture-固定 false-自由,也可传数值列表(0-自由 1-固定)
>      group_name:边界组名,默认为默认边界组

#### 示例

```python
from qtmodel import mdb
    mdb.add_general_support(node_id=1, boundary_info=[True,True,True,False,False,False])
    mdb.add_general_support(node_id="1to100", boundary_info=[True,True,True,False,False,False])
    mdb.add_general_support(node_id="1to100", boundary_info=[1,1,1,0,0,0])
Returns: 无
```

### `mdb.add_elastic_support`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_elastic_support`

```python
mdb.add_elastic_support(node_id, support_type: int=1, boundary_info: list[float]=None, group_name: str='默认边界组', index: int=-1)
```

添加弹性支承

#### 参数

>      node_id:节点编号,支持数或列表且支持XtoYbyN形式字符串
>      support_type:支承类型 1-线性  2-受拉  3-受压
>      boundary_info:边界信息 受拉和受压时列表长度为2-[direct(1-X 2-Y 3-Z),stiffness]  线性时列表长度为6-[kx,ky,kz,krx,kry,krz]
>      group_name:边界组

#### 示例

```python
from qtmodel import mdb
    mdb.add_elastic_support(node_id=1,support_type=1,boundary_info=[1e6,0,1e6,0,0,0])
    mdb.add_elastic_support(node_id=1,support_type=2,boundary_info=[1,1e6])
    mdb.add_elastic_support(node_id=1,support_type=3,boundary_info=[1,1e6])
Returns: 无
```

### `mdb.add_elastic_link`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_elastic_link`

```python
mdb.add_elastic_link(index: int=-1, link_type: int=1, start_id: int=1, end_id: int=2, beta_angle: float=0, boundary_info: list[float]=None, group_name: str='默认边界组', dis_ratio: float=0.5, kx: float=0, gap: float=0, friction: float=0)
```

添加弹性连接，建议指定index(弹性连接编号)

#### 参数

>     index:弹性连接编号,默认自动识别
>     link_type:节点类型 1-一般弹性连接 2-刚性连接 3-受拉弹性连接 4-受压弹性连接
>     start_id:起始节点号
>     end_id:终节点号
>     beta_angle:贝塔角
>     boundary_info:边界信息 (仅一般弹性连接需要)
>     group_name:边界组名
>     dis_ratio:距i端距离比 (仅一般弹性连接需要)
>     kx:受拉或受压刚度
>     gap:间隙
>     friction:摩擦系数

#### 示例

```python
from qtmodel import mdb
    mdb.add_elastic_link(link_type=1,start_id=1,end_id=2,boundary_info=[1e6,1e6,1e6,0,0,0])
    mdb.add_elastic_link(link_type=2,start_id=1,end_id=2)
    mdb.add_elastic_link(link_type=3,start_id=1,end_id=2,kx=1e6)
Returns: 无
```

### `mdb.add_master_slave_links`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_master_slave_links`

```python
mdb.add_master_slave_links(node_ids: List[Tuple[int, int]]=None, boundary_info: List[bool]=None, group_name: str='默认边界组')
```

添加多个主节点对应的主从约束

#### 参数

>     node_ids: [(masterNodeId, slaveNodeId), ...]
>     boundary_info: 约束自由度列表 [Ux, Uy, Uz, Rx, Ry, Rz]，True=约束/耦合，False=不约束
>     group_name: 边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_master_slave_links(node_ids=[(1,2),(3,4)], boundary_info=[True,True,True,False,False,False])
Returns: 无
```

### `mdb.add_master_slave_link`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_master_slave_link`

```python
mdb.add_master_slave_link(master_id: int, slave_id: Union[int, str, List[int]]=None, boundary_info: list[bool]=None, group_name: str='默认边界组', index: int=-1)
```

添加单个主节点对应的主从约束

#### 参数

>      master_id:主节点号
>      slave_id:从节点号，支持整数或整数型列表且支持XtoYbyN形式字符串
>      boundary_info:边界信息 [X,Y,Z,Rx,Ry,Rz] ture-固定 false-自由 默认全部固定
>      group_name:边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_master_slave_link(master_id=1,slave_id=[2,3],boundary_info=[True,True,True,False,False,False])
    mdb.add_master_slave_link(master_id=1,slave_id="2to3",boundary_info=[True,True,True,False,False,False])
Returns: 无
```

### `mdb.add_beam_constraint`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_beam_constraint`

```python
mdb.add_beam_constraint(beam_id: int, info_i: list[bool]=None, info_j: list[bool]=None, group_name: str='默认边界组', index: int=-1)
```

添加梁端约束

#### 参数

>      beam_id:梁号
>      info_i:i端约束信息 [X,Y,Z,Rx,Ry,Rz] ture-固定 false-自由
>      info_j:j端约束信息 [X,Y,Z,Rx,Ry,Rz] ture-固定 false-自由
>      group_name:边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_beam_constraint(beam_id=2,info_i=[True,True,True,False,False,False],info_j=[True,True,True,False,False,False])
Returns: 无
```

### `mdb.add_constraint_equation`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_constraint_equation`

```python
mdb.add_constraint_equation(name: str, sec_node: int, sec_dof: int=1, master_info: Union[list[tuple[int, int, float]], list[list[float]]]=None, group_name: str='默认边界组', index: int=-1)
```

添加约束方程

#### 参数

>      name:约束方程名
>      sec_node:从节点号
>      sec_dof: 从节点自由度 1-x 2-y 3-z 4-rx 5-ry 6-rz
>      master_info:主节点约束信息列表
>      group_name:边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_constraint_equation(name="1",sec_dof=1,sec_node=4,master_info=[(6,1,1)],group_name="默认边界组")
Returns: 无
```

### `mdb.add_node_axis`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.add_node_axis`

```python
mdb.add_node_axis(node_id: int, input_type: int=1, coord_info: list[list[float]]=None, angle_info: Union[tuple[float, float, float], list[float]]=None)
```

添加节点坐标

#### 参数

>      node_id:节点号
>      input_type:输入方式 1-角度 2-三点  3-向量
>      coord_info:局部坐标信息  -List<List<float>>(三点 or 向量)
>      angle_info:角度信息

#### 示例

```python
from qtmodel import mdb
    mdb.add_node_axis(input_type=1,node_id=1,angle_info=(45,45,45))
    mdb.add_node_axis(input_type=2,node_id=1,coord_info=[[0,0,1],[0,1,0],[1,0,0]])
    mdb.add_node_axis(input_type=3,node_id=1,coord_info=[[0,0,1],[0,1,0]])
Returns: 无
```

### `mdb.update_general_support`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_general_support`

```python
mdb.update_general_support(index: int, node_id: int, boundary_info: list[bool], group_name: str='默认边界组', new_id: int=-1)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_general_support(index=..., node_id=..., boundary_info=...)
```

### `mdb.update_elastic_support`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_elastic_support`

```python
mdb.update_elastic_support(index: int, node_id: int, support_type: int, boundary_info: list[float], group_name: str='默认边界组', new_id: int=-1)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_elastic_support(index=..., node_id=..., support_type=..., boundary_info=...)
```

### `mdb.update_elastic_link`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_elastic_link`

```python
mdb.update_elastic_link(index: int, link_type: int, start_id: int, end_id: int, beta_angle: float=0.0, boundary_info: list[float]=None, group_name: str='默认边界组', dis_ratio: float=0.5, kx: float=0.0, gap: float=0.0, friction: float=0.0, new_id: int=-1)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_elastic_link(index=..., link_type=..., start_id=..., end_id=...)
```

### `mdb.update_master_slave_link`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_master_slave_link`

```python
mdb.update_master_slave_link(index: int, master_id: int, slave_id: int, boundary_info: list[bool], group_name: str='默认边界组', new_id: int=-1)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_master_slave_link(index=..., master_id=..., slave_id=..., boundary_info=...)
```

### `mdb.update_beam_constraint`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_beam_constraint`

```python
mdb.update_beam_constraint(index: int, beam_id: int, info_i: list[bool], info_j: list[bool], group_name: str='默认边界组')
```

原位修改梁端约束属性；梁端约束编号在修改过程中保持不变。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_beam_constraint(index=..., beam_id=..., info_i=..., info_j=...)
```

### `mdb.update_constraint_equation`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_constraint_equation`

```python
mdb.update_constraint_equation(index: int, name: str, sec_node: int, sec_dof: int, master_info: Union[list[tuple[int, int, float]], list[list[float]]], group_name: str='默认边界组', new_id: int=-1)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_constraint_equation(index=..., name=..., sec_node=..., sec_dof=..., master_info=...)
```

### `mdb.update_node_axis`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_node_axis`

```python
mdb.update_node_axis(node_id: int, input_type: int=1, coord_info: list[list[float]]=None, angle_info: Union[tuple[float, float, float], list[float]]=None)
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_node_axis(node_id=...)
```

### `mdb.update_boundary_group`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_boundary_group`

```python
mdb.update_boundary_group(name: str, new_name: str)
```

更改边界组名

#### 参数

>     name:边界组名
>     new_name:新边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.update_boundary_group("旧边界组","新边界组")
Returns: 无
```

### `mdb.update_node_axis_id`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_node_axis_id`

```python
mdb.update_node_axis_id(node_id: int, new_id: int)
```

更新节点局部坐标系编号（仅改编号，不改坐标系内容）

#### 参数

>     node_id: 原节点号（被更新的节点）
>     new_id:  新节点号（更新后的节点号）

#### 示例

```python
from qtmodel import mdb
    mdb.update_node_axis_id(node_id=10, new_id=20)
Returns: 无
```

### `mdb.update_general_elastic_support_property_name`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.update_general_elastic_support_property_name`

```python
mdb.update_general_elastic_support_property_name(name: str, new_name: str)
```

更新一般弹性支承特性名称（仅改名）

#### 参数

>     name: 原特性名
>     new_name: 新特性名

#### 示例

```python
from qtmodel import mdb
    mdb.update_general_elastic_support_property_name(name="特性1", new_name="特性2")
Returns: 无
```

### `mdb.remove_effective_width`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_effective_width`

```python
mdb.remove_effective_width(element_ids, group_name: str='默认边界组')
```

删除有效宽度系数

#### 参数

>    element_ids:边界单元号支持整形和整形列表且支持XtoYbyN形式
>    group_name:边界组名

#### 示例

```python
from qtmodel import mdb
   mdb.remove_effective_width(element_ids=[1,2,3,4],group_name="边界组1")
   mdb.remove_effective_width(element_ids="1to4",group_name="边界组1")
Returns: 无
```

### `mdb.remove_boundary_group`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_boundary_group`

```python
mdb.remove_boundary_group(name: str='')
```

按照名称删除边界组

#### 参数

>     name: 边界组名称，默认删除所有边界组 (非必须参数)

#### 示例

```python
from qtmodel import mdb
    mdb.remove_boundary_group()
    mdb.remove_boundary_group(name="边界组1")
Returns: 无
```

### `mdb.remove_all_boundary`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_all_boundary`

```python
mdb.remove_all_boundary()
```

根据边界组名称、边界的类型和编号删除边界信息,默认时删除所有边界信息
Args:无

#### 示例

```python
from qtmodel import mdb
    mdb.remove_all_boundary()
Returns: 无
```

### `mdb.remove_boundary`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_boundary`

```python
mdb.remove_boundary(remove_id: int, kind: str, group_name: str='默认边界组', extra_name='I')
```

根据节点号删除一般支撑、弹性支承/根据弹性连接I或J端(需指定)节点号删除弹性连接/根据单元号删除梁端约束/根据从节点号和约束方程名删除约束方程/根据从节点号删除主从约束

#### 参数

>     remove_id:节点号 or 单元号  or 从节点号
>     kind:边界类型  ["一般支承", "弹性支承","一般弹性支承", "主从约束", "一般/受拉/受压/刚性弹性连接", "约束方程", "梁端约束"]
>     group_name:边界所处边界组名
>     extra_name:删除弹性连接或约束方程时额外标识,约束方程名或指定删除弹性连接节点类型 I/J

#### 示例

```python
from qtmodel import mdb
    mdb.remove_boundary(remove_id=11, kind="一般弹性连接",group_name="边界组1", extra_name="J")
    mdb.remove_boundary(remove_id=12, kind="约束方程",group_name="边界组1", extra_name="约束方程名")
Returns: 无
```

### `mdb.remove_general_elastic_support_property`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_general_elastic_support_property`

```python
mdb.remove_general_elastic_support_property(name: str='')
```

添加一般弹性支承特性

#### 参数

>     name:一般弹性支承特性名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_general_elastic_support_property(name = "特性1")
Returns: 无
```

### `mdb.remove_node_axis`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_node_axis`

```python
mdb.remove_node_axis(node_id: int=-1)
```

删除节点局部坐标

#### 参数

>      node_id:节点号，不为正数时则删除所有节点局部坐标

#### 示例

```python
from qtmodel import mdb
    mdb.remove_node_axis(node_id=1)
Returns: 无
```

### `mdb.remove_elastic_link`

源码：`qtmodel/mdb/mdb_boundary.py` · `MdbBoundary.remove_elastic_link`

```python
mdb.remove_elastic_link(link_ids: Union[int, List[int], str]=-1)
```

根据弹性连接编号删除弹性连接

#### 参数

>      link_ids:弹性连接号，不为正数时则删除所有弹性连接

#### 示例

```python
from qtmodel import mdb
    mdb.remove_elastic_link(link_ids=1)
Returns: 无
```

## `mdb_construction_stage`

### `mdb.add_construction_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.add_construction_stage`

```python
mdb.add_construction_stage(name: str='', duration: int=0, active_structures: Optional[list[tuple[str, float, int, int]]]=None, delete_structures: Optional[list[str]]=None, active_boundaries: Optional[list[tuple[str, int]]]=None, delete_boundaries: Optional[list[str]]=None, active_loads: Optional[list[tuple[str, int]]]=None, delete_loads: Optional[list[tuple[str, int]]]=None, temp_loads: Optional[list[str]]=None, index: int=-1, tendon_cancel_loss: float=0, constraint_cancel_type: int=2)
```

添加施工阶段信息

#### 参数

>    name:施工阶段信息
>    duration:时长
>    active_structures:激活结构组信息 [(结构组名,龄期,安装方法,计自重施工阶段id),...]
>                        _计自重施工阶段id 0-不计自重,1-本阶段 n-第n阶段(可能用到尚未添加的施工阶段请先添加)
>                        _安装方法 1-变形法 2-无应力法 3-接线法 4-切线法
>    delete_structures:钝化结构组信息 [结构组1，结构组2,...]
>    active_boundaries:激活边界组信息 [(边界组1，位置),...]
>                        _位置 0-变形前 1-变形后
>    delete_boundaries:钝化边界组信息 [边界组1，边界组2,...]
>    active_loads:激活荷载组信息 [(荷载组1,时间),...]
>                        _时间 0-开始 1-结束
>    delete_loads:钝化荷载组信息 [(荷载组1,时间),...]
>                        _时间 0-开始 1-结束
>    temp_loads:临时荷载信息 [荷载组1，荷载组2,..]
>    index:施工阶段号，从1开始计数
>    tendon_cancel_loss:钝化预应力单元后预应力损失
>    constraint_cancel_type:钝化梁端约束释放计算方法1-变形法 2-无应力法

#### 示例

```python
from qtmodel import mdb
   mdb.add_construction_stage(name="施工阶段1",duration=5,active_structures=[("结构组1",5,1,1),("结构组2",5,1,1)],
        active_boundaries=[("默认边界组",1)],active_loads=[("默认荷载组1",0)])
Returns: 无
```

### `mdb.update_weight_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.update_weight_stage`

```python
mdb.update_weight_stage(name: str='', structure_group_name: str='', weight_stage_id: int=1)
```

更新施工阶段自重

#### 参数

>    name:施工阶段信息
>    structure_group_name:结构组名
>    weight_stage_id: 计自重阶段号 (0-不计自重,1-本阶段 n-第n阶段)

#### 示例

```python
from qtmodel import mdb
   mdb.update_weight_stage(name="施工阶段1",structure_group_name="默认结构组",weight_stage_id=1)
Returns: 无
```

### `mdb.update_construction_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.update_construction_stage`

```python
mdb.update_construction_stage(name: str='', new_name='', duration: int=0, active_structures: Optional[list[tuple[str, float, int, int]]]=None, delete_structures: Optional[list[str]]=None, active_boundaries: Optional[list[tuple[str, int]]]=None, delete_boundaries: Optional[list[str]]=None, active_loads: Optional[list[tuple[str, int]]]=None, delete_loads: Optional[list[tuple[str, int]]]=None, temp_loads: Optional[list[str]]=None, tendon_cancel_loss: float=0, constraint_cancel_type: int=2)
```

更新施工阶段信息

#### 参数

>    name:施工阶段信息
>    new_name:新施工阶段名
>    duration:时长
>    active_structures:激活结构组信息 [(结构组名,龄期,安装方法,计自重施工阶段id),...]
>                        _计自重施工阶段id 0-不计自重,1-本阶段 n-第n阶段
>                        _安装方法1-变形法 2-接线法 3-无应力法
>    delete_structures:钝化结构组信息 [结构组1，结构组2,...]
>    active_boundaries:激活边界组信息 [(边界组1，位置),...]
>                        _位置 0-变形前 1-变形后
>    delete_boundaries:钝化边界组信息 [边界组1，结构组2,...]
>    active_loads:激活荷载组信息 [(荷载组1,时间),...]
>                        _时间 0-开始 1-结束
>    delete_loads:钝化荷载组信息 [(荷载组1,时间),...]
>                        _时间 0-开始 1-结束
>    temp_loads:临时荷载信息 [荷载组1，荷载组2,..]
>    tendon_cancel_loss:钝化预应力单元后预应力损失
>    constraint_cancel_type:钝化梁端约束释放计算方法1-变形法 2-无应力法

#### 示例

```python
from qtmodel import mdb
   mdb.update_construction_stage(name="施工阶段1",duration=5,active_structures=[("结构组1",5,1,1),("结构组2",5,1,1)],
       active_boundaries=[("默认边界组",1)],active_loads=[("默认荷载组1",0)])
Returns: 无
```

### `mdb.update_construction_stage_id`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.update_construction_stage_id`

```python
mdb.update_construction_stage_id(stage_id: Union[int, List[int], str], target_id: int=3)
```

更新部分施工阶段到指定编号位置之前，例如将1号施工阶段插入到3号之前即为1号与2号施工阶段互换

#### 参数

>     stage_id:修改施工阶段编号且支持XtoYbyN形式字符串
>     target_id:目标施工阶段编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_construction_stage_id(1,3)
    mdb.update_construction_stage_id([1,2,3],9)
Returns:无
```

### `mdb.update_all_stage_setting_type`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.update_all_stage_setting_type`

```python
mdb.update_all_stage_setting_type(setting_type: int=1)
```

更新施工阶段安装方式

#### 参数

>     setting_type:安装方式 (1-接线法 2-无应力法 3-变形法 4-切线法)

#### 示例

```python
from qtmodel import mdb
   mdb.update_all_stage_setting_type(setting_type=1)
Returns: 无
```

### `mdb.update_section_connection_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.update_section_connection_stage`

```python
mdb.update_section_connection_stage(name: str, new_name='', sec_id: int=1, element_id=None, stage_name='', age: float=0, weight_type: int=0)
```

更新施工阶段联合截面

#### 参数

>     name:名称
>     new_name:新名称
>     sec_id:截面号
>     element_id:单元号，支持整型和整型列表且支持XtoYbyN形式字符串
>     stage_name:结合阶段名
>     age:材龄
>     weight_type:辅材计自重方式 0-由主材承担  1-由整体承担 2-不计辅材自重

#### 示例

```python
from qtmodel import mdb
    mdb.update_section_connection_stage(name="联合阶段",sec_id=1,element_id=[2,3,4,5],stage_name="施工阶段1")
    mdb.update_section_connection_stage(name="联合阶段",sec_id=1,element_id="2to5",stage_name="施工阶段1")
Returns:无
```

### `mdb.remove_construction_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.remove_construction_stage`

```python
mdb.remove_construction_stage(name: str='')
```

按照施工阶段名删除施工阶段,默认删除所有施工阶段

#### 参数

>     name:所删除施工阶段名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_construction_stage(name="施工阶段1")
Returns: 无
```

### `mdb.merge_all_stages`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.merge_all_stages`

```python
mdb.merge_all_stages(name: str='一次成桥', setting_type: int=1, weight_type: int=1, age: float=5, boundary_type: int=0, load_type: int=0, tendon_cancel_loss: float=0, constraint_cancel_type: int=1)
```

合并当前所有施工阶段

#### 参数

>     name: 阶段名称
>     setting_type: 安装方式 1-变形法安装 2-无应力安装，默认为1
>     weight_type: 自重类型 -1-其他结构考虑 0-不计自重 1-本阶段，默认为1
>     age: 加载龄期，默认为5
>     boundary_type: 边界类型 0-变形前 1-变形后，默认为0
>     load_type: 荷载类型 0-开始 1-结束，默认为0
>     tendon_cancel_loss: 钝化预应力单元后预应力损失率，默认为0
>     constraint_cancel_type: 钝化梁端约束释放计算方法 1-变形法 2-无应力法，默认为1

#### 示例

```python
from qtmodel import mdb
    mdb.merge_all_stages(name="合并阶段", setting_type=1, weight_type=1, age=5)
Returns: 无
```

### `mdb.add_section_connection_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.add_section_connection_stage`

```python
mdb.add_section_connection_stage(name: str, sec_id: int, element_id=None, stage_name='', age: float=0, weight_type: int=0)
```

添加施工阶段联合截面

#### 参数

>     name:名称
>     sec_id:截面号
>     element_id:单元号，支持整型和整型列表,支持XtoYbyN形式字符串
>     stage_name:结合阶段名
>     age:材龄
>     weight_type:辅材计自重方式 0-由主材承担  1-由整体承担 2-不计辅材自重

#### 示例

```python
from qtmodel import mdb
    mdb.add_section_connection_stage(name="联合阶段",sec_id=1,element_id=[2,3,4,5],stage_name="施工阶段1")
Returns:无
```

### `mdb.add_element_to_connection_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.add_element_to_connection_stage`

```python
mdb.add_element_to_connection_stage(element_id, name: str)
```

添加单元到施工阶段联合截面

#### 参数

>     element_id:单元号，支持整型和整型列表且支持XtoYbyN形式字符串
>     name:联合阶段名

#### 示例

```python
from qtmodel import mdb
    mdb.add_element_to_connection_stage([1,2,3,4],"联合阶段")
Returns:无
```

### `mdb.remove_section_connection_stage`

源码：`qtmodel/mdb/mdb_construction_stage.py` · `MdbConstructionStage.remove_section_connection_stage`

```python
mdb.remove_section_connection_stage(name: str)
```

删除施工阶段联合截面

#### 参数

>     name:名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_section_connection_stage(name="联合阶段")
Returns:无
```

## `mdb_dynamic_load`

### `mdb.add_dynamic_damping`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_dynamic_damping`

```python
mdb.add_dynamic_damping(name: str, damping_kind: int=1, user_defined: bool=False, mass_factor: float=0.0, stiffness_factor: float=0.0, model_shape1: Optional[tuple[float, float]]=None, model_shape2: Optional[tuple[float, float]]=None, group_damping: Optional[list]=None, extra_damping: Optional[list[float]]=None, model_damping: Optional[list[float]]=None)
```

添加阻尼定义；同名时更新原定义。

#### 参数

>     name: 阻尼定义名称。
>     damping_kind: 1-单一阻尼，2-质量刚度矩阵组阻尼，3-应变能组阻尼，4-模态阻尼。
>     user_defined: 单一阻尼是否直接定义质量因子和刚度因子。
>     mass_factor: 直接定义时的质量因子。
>     stiffness_factor: 直接定义时的刚度因子。
>     model_shape1: 单一阻尼的(周期1, 阻尼比1)。
>     model_shape2: 单一阻尼的(周期2, 阻尼比2)。
>     group_damping: 组阻尼数据。类型2为[(材料号,周期1,周期2,阻尼比), ...]；
>         类型3为[(材料号,阻尼比), ...]。
>     extra_damping: 类型2为[周期1,周期2,阻尼比,质量因子,刚度因子]；类型3为[阻尼比]。
>     model_damping: 类型4的各阶模态阻尼比。

#### 示例

```python
from qtmodel import mdb
    mdb.add_dynamic_damping("Rayleigh", model_shape1=(1.0, 0.05), model_shape2=(2.0, 0.05))
    mdb.add_dynamic_damping("Modal", damping_kind=4, model_damping=[0.05, 0.05, 0.04])
```

### `mdb.add_load_to_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_load_to_mass`

```python
mdb.add_load_to_mass(name: str, factor: float=1)
```

添加荷载转为质量

#### 参数

>     name: 荷载工况名称
>     factor: 系数

#### 示例

```python
from qtmodel import mdb
    mdb.add_load_to_mass(name="荷载工况",factor=1)
Returns: 无
```

### `mdb.add_nodal_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_nodal_mass`

```python
mdb.add_nodal_mass(node_id, mass_info: tuple[float, float, float, float]=None)
```

添加节点质量

#### 参数

>     node_id: 节点号（支持 int / list[int] / "1to100" 这类字符串，按你现有 QtDataHelper 解析）
>     mass_info: (mx, my, mz, mrx) 四个值（示例，按你软件定义为准）

#### 示例

```python
from qtmodel import mdb
    mdb.add_nodal_mass(node_id=1, mass_info=(1.0, 2.0, 3.0, 0.0))
    mdb.add_nodal_mass(node_id="1to10", mass_info=(1.0, 1.0, 1.0, 0.0))
Returns: 无
```

### `mdb.add_boundary_element_property`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_boundary_element_property`

```python
mdb.add_boundary_element_property(index: int=-1, name: str='', kind: str='钩', info_x: list[float]=None, info_y: list[float]=None, info_z: list[float]=None, weight: float=0, pin_stiffness: float=0, pin_yield: float=0, description: str='')
```

添加边界单元特性

#### 参数

>     index: 边界单元特性编号,默认自动识别
>     name: 边界单元特性名称
>     kind: 类型名，支持:粘滞阻尼器、支座摩阻、滑动摩擦摆(具体参考界面数据名)
>     info_x: 自由度X信息(参考界面数据，例如粘滞阻尼器为[阻尼系数,速度指数]，支座摩阻为[安装方向0/1,弹性刚度/摩擦系数,恒载支承力N])
>     info_y: 自由度Y信息,默认则不考虑该自由度
>     info_z: 自由度Z信息
>     weight: 重量（单位N）
>     pin_stiffness: 剪力销刚度
>     pin_yield: 剪力销屈服力
>     description: 说明

#### 示例

```python
from qtmodel import mdb
    mdb.add_boundary_element_property(name="边界单元特性",kind="粘滞阻尼器",info_x=[0.05,1])
Returns: 无
```

### `mdb.add_boundary_element_link`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_boundary_element_link`

```python
mdb.add_boundary_element_link(index: int=-1, property_name: str='', node_i: int=1, node_j: int=2, beta: float=0, node_system: int=0, group_name: str='默认边界组')
```

添加边界单元连接

#### 参数

>     index: 边界单元连接号
>     property_name: 边界单元特性名称
>     node_i: 起始节点
>     node_j: 终止节点
>     beta: 角度
>     node_system: 参考坐标系0-单元 1-整体
>     group_name: 边界组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_boundary_element_link(property_name="边界单元特性",node_i=1,node_j=2,group_name="边界组1")
Returns: 无
```

### `mdb.add_nodal_dynamic_load`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_nodal_dynamic_load`

```python
mdb.add_nodal_dynamic_load(index: int=-1, node_id: int=1, case_name: str='', function_name: str='', force_type: int=1, factor: float=1, time: float=1)
```

添加节点动力荷载

#### 参数

>     index: 节点动力荷载编号,默认自动识别
>     node_id: 节点号
>     case_name: 时程工况名
>     function_name: 函数名称
>     force_type: 荷载类型 1-X 2-Y 3-Z 4-负X 5-负Y 6-负Z
>     factor: 系数
>     time: 到达时间

#### 示例

```python
from qtmodel import mdb
    mdb.add_nodal_dynamic_load(node_id=1,case_name="时程工况1",function_name="函数1",time=10)
Returns: 无
```

### `mdb.add_ground_motion`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_ground_motion`

```python
mdb.add_ground_motion(case_name: str='', info_x: Optional[tuple[str, float, float]]=None, info_y: Optional[tuple[str, float, float]]=None, info_z: Optional[tuple[str, float, float]]=None)
```

添加地面加速度

#### 参数

>     case_name: 工况名称
>     info_x: X方向时程分析函数信息列表(函数名,系数,到达时间)
>     info_y: Y方向时程分析函数信息列表
>     info_z: Z方向时程分析函数信息列表

#### 示例

```python
from qtmodel import mdb
    mdb.add_ground_motion(case_name="时程工况1",info_x=("函数名",1,10))
Returns: 无
```

### `mdb.add_time_history_case`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_time_history_case`

```python
mdb.add_time_history_case(index: int=-1, name: str='', description: str='', analysis_kind: int=0, nonlinear_groups: Optional[list]=None, duration: float=1, time_step: float=0.01, min_step: float=0.0001, tolerance: float=0.0001, damping: str='', mode_superposition_kind: int=1, new_mark_gama: float=0.5, new_mark_beta: float=0.25, damp_type: Optional[int]=None, single_damping: Optional[tuple[float, float, float, float]]=None, group_damping: Optional[list[tuple[str, float, float, float]]]=None)
```

添加时程工况

#### 参数

>    index: 时程工况编号,默认自动识别
>    name: 时程工况名
>    description: 描述
>    analysis_kind: 分析类型(0-线性 1-边界非线性)
>    nonlinear_groups: 非线性结构组列表
>    duration: 分析时间
>    time_step: 分析时间步长
>    min_step: 最小收敛步长
>    tolerance: 收敛容限
>    damping:阻尼名，默认为空代表无阻尼
>    mode_superposition_kind: 1-Wilson法 2-NewMark法
>    new_mark_gama: NewMark法 Gama值
>    new_mark_beta: NewMark法 Beta值
>    damp_type: [已弃用]组阻尼类型(0-不计阻尼 1-单一阻尼 2-组阻尼)
>    single_damping: [已弃用]单一阻尼信息列表(周期1,阻尼比1,周期2,阻尼比2)
>    group_damping: [已弃用]组阻尼信息列表[(材料名1,周期1,周期2,阻尼比),(材料名2,周期1,周期2,阻尼比)...]

#### 示例

```python
from qtmodel import mdb
   mdb.add_time_history_case(name="时程工况1",analysis_kind=0,duration=10,time_step=0.02,damp_type=2,
       group_damping=[("材料1",8,1,0.05),("材料2",8,1,0.05),("材料3",8,1,0.02)])
Returns: 无
```

### `mdb.update_time_history_case`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_time_history_case`

```python
mdb.update_time_history_case(name: str='', new_name: str='', description: str='', analysis_kind: int=0, nonlinear_groups: Optional[list]=None, duration: float=1, time_step: float=0.01, min_step: float=0.0001, tolerance: float=0.0001, damping: str='', mode_superposition_kind: int=1, new_mark_gama: float=0.5, new_mark_beta: float=0.25)
```

更改时程工况

#### 参数

>    name: 时程工况名
>    new_name: 新时程工况名
>    description: 描述
>    analysis_kind: 分析类型(0-线性 1-边界非线性)
>    nonlinear_groups: 非线性结构组列表
>    duration: 分析时间
>    time_step: 分析时间步长
>    min_step: 最小收敛步长
>    tolerance: 收敛容限
>    damping:阻尼名，默认为空代表无阻尼
>    mode_superposition_kind: 1-Wilson法 2-NewMark法
>    new_mark_gama: NewMark法 Gama值
>    new_mark_beta: NewMark法 Beta值

#### 示例

```python
from qtmodel import mdb
   mdb.add_time_history_case(name="时程工况1",analysis_kind=0,duration=10,time_step=0.02,damp_type=2,
       group_damping=[("材料1",8,1,0.05),("材料2",8,1,0.05),("材料3",8,1,0.02)])
Returns: 无
```

### `mdb.add_time_history_function`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_time_history_function`

```python
mdb.add_time_history_function(name: str='', factor: float=1.0, kind: int=0, function_info: list=None)
```

添加时程函数

#### 参数

>     name: 名称
>     factor: 放大系数
>     kind: 0-无量纲 1-加速度 2-力 3-力矩
>     function_info: 函数信息[(时间1,数值1),(时间2,数值2)]

#### 示例

```python
from qtmodel import mdb
    mdb.add_time_history_function(name="时程函数1",factor=1,function_info=[(0,0),(0.02,0.1),[0.04,0.3]])
Returns: 无
```

### `mdb.add_vehicle_dynamic_load`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_vehicle_dynamic_load`

```python
mdb.add_vehicle_dynamic_load(node_ids=None, function_name: str='', case_name: str='', kind: int=1, speed_kmh: float=120, braking: bool=False, braking_a: float=0.8, braking_d: float=0, time: float=0, direction: int=6, gap: float=14, factor: float=1, vehicle_info_kn: list[float]=None)
```

添加列车动力荷载

#### 参数

>     node_ids: 节点纵列节点编号集合，支持XtoYbyN形式字符串
>     function_name: 函数名
>     case_name: 工况名
>     kind: 类型 1-ZK型车辆 2-动车组
>     speed_kmh: 列车速度(km/h)
>     braking: 是否考虑制动
>     braking_a: 制动加速度(m/s²)
>     braking_d: 制动时车头位置(m)
>     time: 上桥时间(s)
>     direction: 荷载方向 1-X 2-Y 3-Z 4-负X 5-负Y 6-负Z
>     gap: 加载间距(m)
>     factor: 放大系数
>     vehicle_info_kn: 车辆参数,参数为空时则选取界面默认值,注意单位输入单位为KN
>         ZK型车辆: [dW1,dW2,P1,P2,P3,P4,dD1,dD2,D1,D2,D3,LoadLength]
>         动力组: [L1,L2,L3,P,N]

#### 示例

```python
from qtmodel import mdb
    mdb.add_vehicle_dynamic_load("1to100",function_name="时程函数名",case_name="时程工况名",kind=1,speed_kmh=120,time=10)
    mdb.add_vehicle_dynamic_load([1,2,3,4,5,6,7],function_name="时程函数名",case_name="时程工况名",kind=1,speed_kmh=120,time=10)
Returns:无
```

### `mdb.update_dynamic_damping`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_dynamic_damping`

```python
mdb.update_dynamic_damping(name: str, new_name: str='', damping_kind: int=1, user_defined: bool=False, mass_factor: float=0.0, stiffness_factor: float=0.0, model_shape1: Optional[tuple[float, float]]=None, model_shape2: Optional[tuple[float, float]]=None, group_damping: Optional[list]=None, extra_damping: Optional[list[float]]=None, model_damping: Optional[list[float]]=None)
```

按名称更新阻尼定义。参数含义与add_dynamic_damping相同。

#### 参数

>     name: 现有阻尼定义名称。
>     new_name: 新名称，为空时保留原名称。
>     damping_kind: 1-单一阻尼，2-质量刚度矩阵组阻尼，3-应变能组阻尼，4-模态阻尼。
>     user_defined: 单一阻尼是否直接定义因子。
>     mass_factor: 直接定义时的质量因子。
>     stiffness_factor: 直接定义时的刚度因子。
>     model_shape1: 单一阻尼的(周期1, 阻尼比1)。
>     model_shape2: 单一阻尼的(周期2, 阻尼比2)。
>     group_damping: 质量刚度矩阵或应变能组阻尼数据。
>     extra_damping: 附加质量阻尼数据。
>     model_damping: 各阶模态阻尼比。

#### 示例

```python
from qtmodel import mdb
    mdb.update_dynamic_damping("Rayleigh", new_name="Rayleigh-2",
        model_shape1=(1.0, 0.05), model_shape2=(2.0, 0.05))
```

### `mdb.update_load_to_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_load_to_mass`

```python
mdb.update_load_to_mass(name: str='', factor: float=1)
```

更新荷载转为质量

#### 参数

>     name:荷载工况名称
>     factor:荷载工况系数

#### 示例

```python
from qtmodel import mdb
    mdb.update_load_to_mass(name="工况1",factor=1)
Returns: 无
```

### `mdb.update_nodal_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_nodal_mass`

```python
mdb.update_nodal_mass(node_id: int, new_node_id: int=-1, mass_info: tuple[float, float, float, float]=None)
```

更新节点质量

#### 参数

>     node_id:节点编号
>     new_node_id:新节点编号，默认不改变节点
>     mass_info:[m,rmX,rmY,rmZ]

#### 示例

```python
from qtmodel import mdb
    mdb.add_nodal_mass(node_id=1,mass_info=(100,0,0,0))
Returns: 无
```

### `mdb.update_boundary_element_property_name`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_boundary_element_property_name`

```python
mdb.update_boundary_element_property_name(name: str='', new_name: str='')
```

更新边界单元特性名

#### 参数

>     name: 原边界单元特性名称
>     new_name: 更新后边界单元特性名称，默认时不修改

#### 示例

```python
from qtmodel import mdb
    mdb.update_boundary_element_property_name(name="边界特性1",new_name="边界特性2")
Returns: 无
```

### `mdb.update_boundary_element_link`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_boundary_element_link`

```python
mdb.update_boundary_element_link(index: int, property_name: str='', node_i: int=1, node_j: int=2, beta: float=0, node_system: int=0, group_name: str='默认边界组')
```

更新边界单元连接

#### 参数

>     index: 根据边界单元连接id选择待更新对象
>     property_name: 边界单元特性名
>     node_i: 起始节点点
>     node_j: 终点节点号
>     beta: 角度参数
>     node_system: 0-单元坐标系 1-整体坐标系
>     group_name: 边界组名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_boundary_element_link(index=1,property_name="边界单元特性名",node_i=101,node_j=102,beta=30.0)
Returns: 无
```

### `mdb.update_time_history_case_name`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_time_history_case_name`

```python
mdb.update_time_history_case_name(name: str='', new_name: str='')
```

更新时程工况

#### 参数

>     name: 时程工况号
>     new_name: 时程工况名

#### 示例

```python
from qtmodel import mdb
    mdb.update_time_history_case_name(name="TH1",new_name="TH2")
Returns: 无
```

### `mdb.update_time_history_function_name`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_time_history_function_name`

```python
mdb.update_time_history_function_name(name: str, new_name: str='')
```

更新时程函数

#### 参数

>     name: 更新前函数名
>     new_name: 更新后函数名，默认不更新名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_time_history_function_name(name="函数名1",new_name="函数名2")
Returns: 无
```

### `mdb.update_nodal_dynamic_load`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_nodal_dynamic_load`

```python
mdb.update_nodal_dynamic_load(index: int=-1, node_id: int=1, case_name: str='', function_name: str='', direction: int=1, factor: float=1, time: float=1)
```

更新节点动力荷载

#### 参数

>     index: 待修改荷载编号
>     node_id: 节点号
>     case_name: 时程工况名
>     function_name: 函数名称
>     direction: 荷载类型 1-X 2-Y 3-Z 4-负X 5-负Y 6-负Z
>     factor: 系数
>     time: 到达时间

#### 示例

```python
from qtmodel import mdb
    mdb.update_nodal_dynamic_load(index=1,node_id=101,case_name="Earthquake_X",function_name="EQ_function",direction=1,factor=1.2,time=0.0 )
Returns: 无
```

### `mdb.update_ground_motion`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_ground_motion`

```python
mdb.update_ground_motion(index: int, case_name: str='', info_x: Optional[tuple[str, float, float]]=None, info_y: Optional[tuple[str, float, float]]=None, info_z: Optional[tuple[str, float, float]]=None)
```

更新地面加速度

#### 参数

>     index: 地面加速度编号
>     case_name: 时程工况名
>     info_x: X方向时程分析函数信息数据(函数名,系数,到达时间)
>     info_y: Y方向信息
>     info_z: Z方向信息

#### 示例

```python
from qtmodel import mdb
    mdb.update_ground_motion(index=1,case_name="Earthquake_X",
        info_x=("EQ_X_func", 1.0, 0.0),info_y=("EQ_Y_func", 0.8, 0.0),info_z=("EQ_Z_func", 0.6, 0.0) )
Returns: 无
```

### `mdb.remove_dynamic_damping`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_dynamic_damping`

```python
mdb.remove_dynamic_damping(name: str)
```

按名称删除阻尼定义。

#### 参数

>     name: 阻尼定义名称。

#### 示例

```python
from qtmodel import mdb
    mdb.remove_dynamic_damping("Rayleigh")
```

### `mdb.remove_time_history_load_case`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_time_history_load_case`

```python
mdb.remove_time_history_load_case(name: str)
```

通过时程工况名删除时程工况

#### 参数

>     name: 时程工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_time_history_load_case("工况名")
Returns: 无
```

### `mdb.remove_time_history_function`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_time_history_function`

```python
mdb.remove_time_history_function(ids=None, name: str='')
```

通过函数编号删除时程函数

#### 参数

>     ids: 删除时程函数编号集合支持XtoYbyN形式，默认为空时则按照名称删除
>     name: 编号集合为空时则按照名称删除

#### 示例

```python
from qtmodel import mdb
    mdb.remove_time_history_function(ids=[1,2,3])
    mdb.remove_time_history_function(ids="1to3")
    mdb.remove_time_history_function(name="函数名")
Returns: 无
```

### `mdb.remove_load_to_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_load_to_mass`

```python
mdb.remove_load_to_mass(name: str='')
```

删除荷载转为质量,默认删除所有荷载转质量

#### 参数

>     name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_load_to_mass(name="荷载工况")
Returns: 无
```

### `mdb.remove_nodal_mass`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_nodal_mass`

```python
mdb.remove_nodal_mass(node_id=None)
```

删除节点质量

#### 参数

>      node_id:节点号,自动忽略不存在的节点质量

#### 示例

```python
from qtmodel import mdb
    mdb.remove_nodal_mass(node_id=1)
    mdb.remove_nodal_mass(node_id=[1,2,3,4])
    mdb.remove_nodal_mass(node_id="1to5")
Returns: 无
```

### `mdb.remove_boundary_element_property`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_boundary_element_property`

```python
mdb.remove_boundary_element_property(name: str)
```

删除边界单元特性
Args: 无

#### 示例

```python
from qtmodel import mdb
    mdb.remove_boundary_element_property(name="特性名")
Returns: 无
```

### `mdb.remove_boundary_element_link`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_boundary_element_link`

```python
mdb.remove_boundary_element_link(ids=None)
```

删除边界单元连接

#### 参数

>     ids:所删除的边界单元连接号且支持XtoYbyN形式字符串

#### 示例

```python
from qtmodel import mdb
    mdb.remove_boundary_element_link(ids=1)
    mdb.remove_boundary_element_link(ids=[1,2,3,4])
Returns: 无
```

### `mdb.remove_ground_motion`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_ground_motion`

```python
mdb.remove_ground_motion(name: str)
```

删除地面加速度

#### 参数

>     name: 工况名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_ground_motion("时程工况名")
Returns: 无
```

### `mdb.remove_nodal_dynamic_load`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_nodal_dynamic_load`

```python
mdb.remove_nodal_dynamic_load(ids=None)
```

删除节点动力荷载

#### 参数

>     ids:所删除的节点动力荷载编号且支持XtoYbyN形式字符串

#### 示例

```python
from qtmodel import mdb
    mdb.remove_nodal_dynamic_load(ids=1)
    mdb.remove_nodal_dynamic_load(ids=[1,2,3,4])
Returns: 无
```

### `mdb.add_spectrum_function`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_spectrum_function`

```python
mdb.add_spectrum_function(name: str='', factor: float=1.0, kind: int=0, function_info: list[tuple[float, float]]=None)
```

添加反应谱函数

#### 参数

>     name:反应谱函数名
>     factor:反应谱调整系数
>     kind:反应谱类型 0-无量纲 1-加速度 2-位移
>     function_info:反应谱函数信息[(时间1,数值1),[时间2,数值2]]

#### 示例

```python
from qtmodel import mdb
    mdb.add_spectrum_function(name="反应谱函数1",factor=1.0,function_info=[(0,0.02),(1,0.03)])
Returns: 无
```

### `mdb.add_spectrum_case`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.add_spectrum_case`

```python
mdb.add_spectrum_case(name: str='', description: str='', kind: int=1, info_x: Optional[tuple[str, float]]=None, info_y: Optional[tuple[str, float]]=None, info_z: Optional[tuple[str, float]]=None)
```

添加反应谱工况

#### 参数

>      name:荷载工况名
>      description:说明
>      kind:组合方式 1-求模 2-求和
>      info_x: 反应谱X向信息 (X方向函数名,系数)
>      info_y: 反应谱Y向信息 (Y方向函数名,系数)
>      info_z: 反应谱Z向信息 (Z方向函数名,系数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_spectrum_case(name="反应谱工况",info_x=("函数1",1.0))
Returns: 无
```

### `mdb.update_spectrum_function_name`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_spectrum_function_name`

```python
mdb.update_spectrum_function_name(name: str='', new_name: str='')
```

更新反应谱函数

#### 参数

>     name: 函数名称
>     new_name: 新函数名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_spectrum_function_name(name="函数名1",new_name="函数名2")
Returns: 无
```

### `mdb.update_spectrum_case_name`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.update_spectrum_case_name`

```python
mdb.update_spectrum_case_name(name: str, new_name: str='')
```

更新反应谱工况

#### 参数

>     name: 工况名称
>     new_name: 新工况名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_spectrum_case_name(name="工况名1",new_name="工况名2")
Returns: 无
```

### `mdb.remove_spectrum_case`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_spectrum_case`

```python
mdb.remove_spectrum_case(name: str)
```

删除反应谱工况

#### 参数

>     name: 工况名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_spectrum_case("工况名")
Returns: 无
```

### `mdb.remove_spectrum_function`

源码：`qtmodel/mdb/mdb_dynamic_load.py` · `MdbDynamicLoad.remove_spectrum_function`

```python
mdb.remove_spectrum_function(ids=None, name: str='')
```

删除反应谱函数

#### 参数

>     ids: 删除反应谱工况函数编号集合支持XtoYbyN形式，默认为空时则按照名称删除
>     name: 编号集合为空时则按照名称删除

#### 示例

```python
from qtmodel import mdb
    mdb.remove_spectrum_function(name="工况名")
Returns: 无
```

## `mdb_live_load`

### `mdb.add_standard_vehicle`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_standard_vehicle`

```python
mdb.add_standard_vehicle(name: str, standard_code: int=1, load_type: str='公路I级车道', load_length: float=0, factor: float=1.0, n: int=6, calc_fatigue: Union[bool, List[bool]]=None)
```

添加标准车辆

#### 参数

>      name: 车辆荷载名称
>      standard_code: 荷载规范
>         _1-中国铁路桥涵规范(TB10002-2017)
>         _2-城市桥梁设计规范(CJJ11-2019)
>         _3-公路工程技术标准(JTJ 001-97)
>         _4-公路桥涵设计通规(JTG D60-2004
>         _5-公路桥涵设计通规(JTG D60-2015)
>         _6-城市轨道交通桥梁设计规范(GB/T51234-2017)
>         _7-市域铁路设计规范2017(T/CRS C0101-2017)
>      load_type: 荷载类型,支持类型参考软件内界面
>      load_length: 默认为0即不限制荷载长度  (铁路桥涵规范2017 所需参数)
>      factor: 默认为1.0(铁路桥涵规范2017 ZH荷载所需参数)
>      n:车厢数: 默认6节车厢 (城市轨道交通桥梁规范2017 所需参数)
>      calc_fatigue:疲劳荷载模式是否计算三种类型疲劳荷载 (公路桥涵设计通规2015 所需参数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_standard_vehicle("高速铁路",standard_code=1,load_type="ZK高速铁路")
Returns: 无
```

### `mdb.add_user_vehicle`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_user_vehicle`

```python
mdb.add_user_vehicle(name: str, load_type: str='车辆荷载', p: Union[float, List[float]]=270000, q: float=10500, dis: list[float]=None, load_length: float=500, n: int=6, empty_load: float=90000, width: float=1.5, wheelbase: float=1.8, min_dis: float=1.5)
```

添加用户定义车辆

#### 参数

>      name: 车辆荷载名称
>      load_type: 荷载类型,支持类型 -车辆/车道荷载 列车普通活载 城市轻轨活载 旧公路人群荷载 轮重集合
>      p: 荷载Pk或Pi列表
>      q: 均布荷载Qk或荷载集度dW
>      dis:荷载距离Li列表
>      load_length: 荷载长度  (列车普通活载 所需参数)
>      n:车厢数: 默认6节车厢 (列车普通活载 所需参数)
>      empty_load:空载 (列车普通活载、城市轻轨活载 所需参数)
>      width:宽度 (旧公路人群荷载 所需参数)
>      wheelbase:轮间距 (轮重集合 所需参数)
>      min_dis:车轮距影响面最小距离 (轮重集合 所需参数))

#### 示例

```python
from qtmodel import mdb
    mdb.add_user_vehicle(name="车道荷载",load_type="车道荷载",p=270000,q=10500)
Returns: 无
```

### `mdb.add_node_tandem`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_node_tandem`

```python
mdb.add_node_tandem(name: str, node_ids: Union[str, List[int]], order_by_x: bool=True)
```

添加节点纵列,默认以最小X对应节点作为纵列起点

#### 参数

>      name:节点纵列名
>      node_ids:节点列表，支持XToYbyN字符串
>      order_by_x:是否开启自动排序，按照X坐标从小到大排序

#### 示例

```python
from qtmodel import mdb
    mdb.add_node_tandem(name="节点纵列1",node_ids=[1,2,3,4,5,6,7])
    mdb.add_node_tandem(name="节点纵列1",node_ids="1to7")
Returns: 无
```

### `mdb.add_influence_plane`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_influence_plane`

```python
mdb.add_influence_plane(name: str, tandem_names: list[str])
```

添加影响面

#### 参数

>      name:影响面名称
>      tandem_names:节点纵列名称组

#### 示例

```python
from qtmodel import mdb
    mdb.add_influence_plane(name="影响面1",tandem_names=["节点纵列1","节点纵列2"])
Returns: 无
```

### `mdb.add_lane_line`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_lane_line`

```python
mdb.add_lane_line(name: str, influence_name: str, tandem_name: str, offset: float=0, lane_width: float=0, optimize: bool=False, direction: int=0)
```

添加车道线

#### 参数

>      name:车道线名称
>      influence_name:影响面名称
>      tandem_name:节点纵列名
>      offset:偏移
>      lane_width:车道宽度
>      optimize:是否允许车辆摆动
>      direction:0-向前  1-向后

#### 示例

```python
from qtmodel import mdb
    mdb.add_lane_line(name="车道1",influence_name="影响面1",tandem_name="节点纵列1",offset=0,lane_width=3.1)
Returns: 无
```

### `mdb.add_live_load_case`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_live_load_case`

```python
mdb.add_live_load_case(name: str, influence_plane: str, span: float, sub_case: list[tuple[str, float, list[str]]]=None, trailer_code: str='', special_code: str='', is_save: bool=True)
```

添加移动荷载工况

#### 参数

>      name:活载工况名
>      influence_plane:影响线名
>      span:跨度
>      sub_case:子工况信息 [(车辆名称,系数,["车道1","车道2"])...]
>      trailer_code:考虑挂车时挂车车辆名
>      special_code:考虑特载时特载车辆名
>      is_save:是否保存子工况结果

#### 示例

```python
from qtmodel import mdb
    mdb.add_live_load_case(name="活载工况1",influence_plane="影响面1",span=100,sub_case=[("车辆名称",1.0,["车道1","车道2"]),])
Returns: 无
```

### `mdb.add_car_relative_factor`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_car_relative_factor`

```python
mdb.add_car_relative_factor(name: str, code_index: int, cross_factors: list[float]=None, longitude_factor: float=-1, impact_factor: float=-1, frequency: float=14)
```

添加移动荷载工况汽车折减

#### 参数

>      name:活载工况名
>      code_index: 汽车折减规范编号  0-无 1-公规2015 2-公规2004
>      cross_factors:横向折减系数列表,自定义时要求长度为8,否则按照规范选取
>      longitude_factor:纵向折减系数，大于0时为自定义，否则为规范自动选取
>      impact_factor:冲击系数大于1时为自定义，否则按照规范自动选取
>      frequency:桥梁基频

#### 示例

```python
from qtmodel import mdb
    mdb.add_car_relative_factor(name="活载工况1",code_index=1,cross_factors=[1.2,1,0.78,0.67,0.6,0.55,0.52,0.5])
Returns: 无
```

### `mdb.add_train_relative_factor`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_train_relative_factor`

```python
mdb.add_train_relative_factor(name: str, code_index: int=1, cross_factors: Optional[list[float]]=None, calc_fatigue: bool=False, line_count: int=0, longitude_factor: float=-1, impact_factor: float=-1, fatigue_factor: float=-1, bridge_kind: int=0, fill_thick: float=0.5, rise: float=1.5, calc_length: float=50)
```

添加移动荷载工况汽车折减

#### 参数

>     name:活载工况名
>     code_index: 火车折减规范编号  0-无 1-铁规ZK 2-铁规ZKH
>     cross_factors:横向折减系数列表,自定义时要求长度为8,否则按照规范选取
>     calc_fatigue:是否计算疲劳
>     line_count: 疲劳加载线路数
>     longitude_factor:纵向折减系数，大于0时为自定义，否则为规范自动选取
>     impact_factor:强度冲击系数大于1时为自定义，否则按照规范自动选取
>     fatigue_factor:疲劳系数
>     bridge_kind:桥梁类型 0-无 1-简支 2-结合 3-涵洞 4-空腹式
>     fill_thick:填土厚度 (规ZKH ZH钢筋/素混凝土、石砌桥跨结构以及涵洞所需参数)
>     rise:拱高 (规ZKH ZH活载-空腹式拱桥所需参数)
>     calc_length:计算跨度(铁规ZKH ZH活载-空腹式拱桥所需参数)或计算长度(铁规ZK ZC活载所需参数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_train_relative_factor(name="活载工况1",code_index=1,cross_factors=[1.2,1,0.78,0.67,0.6,0.55,0.52,0.5],calc_length=50)
Returns: 无
```

### `mdb.add_metro_relative_factor`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.add_metro_relative_factor`

```python
mdb.add_metro_relative_factor(name: str, cross_factors: list[float]=None, longitude_factor: float=-1, impact_factor: float=-1)
```

添加移动荷载工况汽车折减

#### 参数

>      name:活载工况名
>      cross_factors:横向折减系数列表,自定义时要求长度为8,否则按照规范选取
>      longitude_factor:纵向折减系数，大于0时为自定义，否则为规范自动选取
>      impact_factor:强度冲击系数大于1时为自定义，否则按照规范自动选取

#### 示例

```python
from qtmodel import mdb
    mdb.add_metro_relative_factor(name="活载工况1",cross_factors=[1.2,1,0.78,0.67,0.6,0.55,0.52,0.5],
        longitude_factor=1,impact_factor=1)
Returns: 无
```

### `mdb.update_vehicle_name`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.update_vehicle_name`

```python
mdb.update_vehicle_name(name: str, new_name: str='')
```

更新标准车辆

#### 参数

>      name: 车辆荷载名称
>      new_name: 新车辆荷载名称,默认不修改

#### 示例

```python
from qtmodel import mdb
    mdb.update_vehicle_name(name ="高速铁路1",new_name = "高速铁路2")
Returns: 无
```

### `mdb.update_influence_plane_name`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.update_influence_plane_name`

```python
mdb.update_influence_plane_name(name: str, new_name: str='')
```

更新影响面

#### 参数

>      name:影响面名称
>      new_name:更改后影响面名称，若无更改则默认

#### 示例

```python
from qtmodel import mdb
    mdb.update_influence_plane_name(name="影响面1",new_name="影响面2")
Returns: 无
```

### `mdb.update_lane_line_name`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.update_lane_line_name`

```python
mdb.update_lane_line_name(name: str, new_name: str='')
```

更新车道线

#### 参数

>      name:车道线名称
>      new_name:更改后车道名,默认为不更改

#### 示例

```python
from qtmodel import mdb
    mdb.update_lane_line_name(name="车道1",new_name="车道2")
Returns: 无
```

### `mdb.update_node_tandem_name`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.update_node_tandem_name`

```python
mdb.update_node_tandem_name(name: str, new_name: str='')
```

更新节点纵列,默认以最小X对应节点作为纵列起点

#### 参数

>      name:节点纵列名
>      new_name: 新节点纵列名，默认不修改

#### 示例

```python
from qtmodel import mdb
    mdb.update_node_tandem_name(name="节点纵列1",new_name="节点纵列2")
Returns: 无
```

### `mdb.update_live_load_case_name`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.update_live_load_case_name`

```python
mdb.update_live_load_case_name(name: str, new_name: str='')
```

更新移动荷载工况

#### 参数

>      name:活载工况名
>      new_name:新移动荷载名

#### 示例

```python
from qtmodel import mdb
    mdb.update_live_load_case_name(name="活载工况1",new_name="活载工况2")
Returns: 无
```

### `mdb.remove_vehicle`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.remove_vehicle`

```python
mdb.remove_vehicle(index: int=-1, name: str='')
```

删除车辆信息

#### 参数

>     index:车辆编号
>     name:车辆名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_vehicle(name="车辆名称")
    mdb.remove_vehicle(index=1)
Returns: 无
```

### `mdb.remove_node_tandem`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.remove_node_tandem`

```python
mdb.remove_node_tandem(index: int=-1, name: str='')
```

按照节点纵列编号/节点纵列名 删除节点纵列

#### 参数

>      index:节点纵列编号
>      name:节点纵列名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_node_tandem(index=1)
    mdb.remove_node_tandem(name="节点纵列1")
Returns: 无
```

### `mdb.remove_influence_plane`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.remove_influence_plane`

```python
mdb.remove_influence_plane(index: int=-1, name: str='')
```

按照影响面编号/影响面名称 删除影响面

#### 参数

>      index:影响面编号
>      name:影响面名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_influence_plane(index=1)
    mdb.remove_influence_plane(name="影响面1")
Returns: 无
```

### `mdb.remove_lane_line`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.remove_lane_line`

```python
mdb.remove_lane_line(index: int=-1, name: str='')
```

按照车道线编号或车道线名称 删除车道线

#### 参数

>      index:车道线编号，默认时则按照名称删除车道线
>      name:车道线名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_lane_line(index=1)
    mdb.remove_lane_line(name="车道线1")
Returns: 无
```

### `mdb.remove_live_load_case`

源码：`qtmodel/mdb/mdb_live_load.py` · `MdbLiveLoad.remove_live_load_case`

```python
mdb.remove_live_load_case(index: int=-1, name: str='')
```

删除移动荷载工况，默认值时则按照工况名删除

#### 参数

>      index:移动荷载工况编号
>      name:移动荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_live_load_case(name="活载工况1")
    mdb.remove_live_load_case(index=1)
Returns: 无
```

## `mdb_load`

### `mdb.add_load_case`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.add_load_case`

```python
mdb.add_load_case(name: str='', case_type: str='施工阶段荷载')
```

添加荷载工况

#### 参数

>     name:工况名
>     case_type:荷载工况类型
>     _"施工阶段荷载", "恒载", "活载", "制动力", "风荷载","体系温度荷载","梯度温度荷载",
>     _"长轨伸缩挠曲力荷载", "脱轨荷载", "船舶撞击荷载","汽车撞击荷载","长轨断轨力荷载", "用户定义荷载"

#### 示例

```python
from qtmodel import mdb
    mdb.add_load_case(name="工况1",case_type="施工阶段荷载")
Returns: 无
```

### `mdb.add_load_group`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.add_load_group`

```python
mdb.add_load_group(name: str='')
```

根据荷载组名称添加荷载组

#### 参数

>      name: 荷载组名称

#### 示例

```python
from qtmodel import mdb
    mdb.add_load_group(name="荷载组1")
Returns: 无
```

### `mdb.update_sink_group`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.update_sink_group`

```python
mdb.update_sink_group(name: str='', new_name: str='', sink: float=0.1, node_ids: Union[int, List[int]]=None)
```

更新沉降组

#### 参数

>      name: 沉降组名
>      new_name: 新沉降组名,默认不修改
>      sink: 沉降值
>      node_ids: 节点编号，支持数或列表

#### 示例

```python
from qtmodel import mdb
    mdb.update_sink_group(name="沉降1",sink=0.1,node_ids=[1,2,3])
Returns: 无
```

### `mdb.update_load_case`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.update_load_case`

```python
mdb.update_load_case(name: str, new_name: str='', case_type: str='施工阶段荷载')
```

更新荷载工况

#### 参数

>    name:工况名
>    new_name:新工况名
>    case_type:荷载工况类型
>    _"施工阶段荷载", "恒载", "活载", "制动力", "风荷载","体系温度荷载","梯度温度荷载",
>    _"长轨伸缩挠曲力荷载", "脱轨荷载", "船舶撞击荷载","汽车撞击荷载","长轨断轨力荷载", "用户定义荷载"

#### 示例

```python
from qtmodel import mdb
   mdb.add_load_case(name="工况1",case_type="施工阶段荷载")
Returns: 无
```

### `mdb.update_load_group_name`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.update_load_group_name`

```python
mdb.update_load_group_name(name: str, new_name: str='')
```

根据荷载组名称更新荷载组

#### 参数

>    name: 荷载组名称
>    new_name: 荷载组名称

#### 示例

```python
from qtmodel import mdb
  mdb.update_load_group_name(name="荷载组1",new_name="荷载组2")
Returns: 无
```

### `mdb.remove_load_case`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.remove_load_case`

```python
mdb.remove_load_case(index: int=-1, name: str='')
```

删除荷载工况,参数均为默认时删除全部荷载工况

#### 参数

>     index:荷载编号
>     name:荷载名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_load_case(index=1)
    mdb.remove_load_case(name="工况1")
    mdb.remove_load_case()
Returns: 无
```

### `mdb.remove_load_group`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.remove_load_group`

```python
mdb.remove_load_group(name: str='')
```

根据荷载组名称删除荷载组,参数为默认时删除所有荷载组

#### 参数

>      name: 荷载组名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_load_group(name="荷载组1")
Returns: 无
```

### `mdb.add_load_combine`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.add_load_combine`

```python
mdb.add_load_combine(index: int=-1, name: str='', combine_type: int=1, describe: str='', combine_info: list[tuple[str, str, float]]=None)
```

添加荷载组合，支持自动覆盖

#### 参数

>     index:荷载组合编号
>     name:荷载组合名
>     combine_type:荷载组合类型 1-叠加  2-判别  3-包络 4-SRss 5-AbsSum 6-除永久作用强制叠加其他判别叠加
>     describe:描述
>     combine_info:荷载组合信息 [(荷载工况类型,工况名,系数)...] 工况类型如下
>         _"ST"-静力荷载工况  "CS"-施工阶段荷载工况  "CB"-荷载组合
>         _"MV"-移动荷载工况  "SM"-沉降荷载工况_ "RS"-反应谱工况 "TH"-时程分析

#### 示例

```python
from qtmodel import mdb
    mdb.add_load_combine(name="荷载组合1",combine_type=1,describe="无",combine_info=[("CS","合计值",1),("CS","恒载",1)])
Returns: 无
```

### `mdb.remove_load_combine`

源码：`qtmodel/mdb/mdb_load.py` · `MdbLoad.remove_load_combine`

```python
mdb.remove_load_combine(index: int=-1, name: str='')
```

删除荷载组合

#### 参数

>     index: 默认时则按照name删除荷载组合
>     name:指定删除荷载组合名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_load_combine(name="荷载组合1")
Returns: 无
```

## `mdb_model_delete`

### `mdb.delete_model_object`

源码：`qtmodel/mdb/mdb_model_delete.py` · `MdbModelDelete.delete_model_object`

```python
mdb.delete_model_object(object_type: str, index: int, *, subtype: str='', case_name: str='', group_name: str='')
```

源码暂未提供函数说明。

#### 示例

```python
from qtmodel import mdb
result = mdb.delete_model_object(object_type=..., index=...)
```

## `mdb_project`

### `mdb.ensure_running`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.ensure_running`

```python
mdb.ensure_running(exe_path='C:\\Program Files\\BRDI\\Qiaotong\\qiaotong.exe', wait_seconds=10)
```

若未检测到桥通进程，则启动桥通桌面程序。

#### 参数

>     exe_path (str | pathlib.Path): ``qiaotong.exe`` 的完整路径。默认使用
>         桥通标准安装目录。路径不存在时抛出 ``FileNotFoundError``。
>     wait_seconds (float): 启动后最多保留等待循环的秒数，应为非负数；
>         默认 10 秒。该等待不保证 HTTP 服务已经可用。

#### 示例

```python
from qtmodel import mdb
   mdb.ensure_running()
```

#### 返回

>     None: 已运行时立即返回；否则创建桌面进程后返回。

#### 说明

>     当前实现启动后不会在循环中再次检查进程或 HTTP 就绪状态，只等待
>     ``wait_seconds``。需要可靠连接时应随后调用一个轻量 API 验证服务。

### `mdb.set_url`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.set_url`

```python
mdb.set_url(url: str='http://localhost:55125/pythonForQt/')
```

设置此 Python 客户端请求的桥通 HTTP API 根地址。

#### 参数

>     url (str): 完整根 URL，通常为
>         ``http://localhost:55125/pythonForQt/``，应包含协议、端口和末尾
>         斜杠。远程地址必须能从当前 Python 进程访问。

#### 示例

```python
from qtmodel import mdb
    mdb.set_url()
```

#### 返回

>     None: 仅修改进程内的 ``QtServer.URL``，不会修改桥通服务端配置。

### `mdb.set_version`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.set_version`

```python
mdb.set_version(version: str=QtServer.QT_VERSION)
```

设置发送给桥通的 API 数据协议版本。

#### 参数

>     version (str): 严格的 ``主版本.次版本.修订号`` 三段数字，例如
>         ``"2.2.0"``；各段必须为非负整数。

#### 示例

```python
from qtmodel import mdb
    mdb.set_version("2.2.0")
```

#### 返回

>     None: 目标版本不高于本 SDK 内置 ``QtServer.QT_VERSION`` 时生效；
>     若目标版本更高，为避免客户端冒充未知协议版本，会保持当前版本不变。

### `mdb.undo_model`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.undo_model`

```python
mdb.undo_model()
```

撤销桥通当前工程中的最近一次可撤销建模操作。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.undo_model()
```

#### 返回

>     None: 命令结果未向调用方透传。无活动工程或无可撤销项时由服务端处理。

### `mdb.redo_model`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.redo_model`

```python
mdb.redo_model()
```

重做最近一次由 ``undo_model`` 撤销的建模操作。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.redo_model()
```

#### 返回

>     None: 命令结果未向调用方透传。

### `mdb.update_model`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.update_model`

```python
mdb.update_model()
```

要求桥通提交/刷新当前模型及界面状态。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.update_model()
```

#### 返回

>     None: 此方法不执行有限元求解，仅同步模型和显示状态。

### `mdb.update_to_pre`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.update_to_pre`

```python
mdb.update_to_pre()
```

将桥通界面切换到前处理（建模）状态。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.update_to_pre()
```

#### 返回

>     None: 不改变已有分析结果，但后续建模写操作应在此状态执行。

### `mdb.update_to_post`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.update_to_post`

```python
mdb.update_to_post()
```

将桥通界面切换到后处理（结果查看）状态。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.update_to_post()
```

#### 返回

>     None: 工程尚未成功求解时，切换后也可能没有可用结果。

### `mdb.do_solve`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.do_solve`

```python
mdb.do_solve(read_timeout: int=600, wait: bool=True, poll_interval: float=2.0, max_wait: Optional[float]=None, status_read_timeout: int=30, sync: bool=True)
```

运行项目分析计算。

#### 参数

>     read_timeout (int): 启动/同步求解 HTTP 请求的读取超时秒数，应为正数。
>     wait (bool): ``sync=False`` 时，是否由 Python 轮询直至后台求解完成。
>         ``False`` 立即返回启动状态。
>     poll_interval (float): 轮询间隔秒数，实际最小值 0.1；建议 2~5 秒。
>     max_wait (float | None): Python 轮询总等待上限秒数；``None`` 不设上限。
>     status_read_timeout (int): 每次状态查询的 HTTP 读取超时秒数。
>     sync (bool): ``True`` 要求 C# 在本次 HTTP 请求内等待求解完成；大型
>         模型可能超过代理/网络超时。``False`` 使用后台任务，结合 ``wait``
>         决定是否在 Python 侧轮询。

#### 示例

```python
from qtmodel import mdb
    mdb.do_solve()
    mdb.do_solve(wait=True, max_wait=1800)
```

#### 返回

>     dict: 求解状态，字段为 ``ok/state/is_running/message/started_at/``
>     ``finished_at/project``。``sync=False, wait=False`` 返回刚启动的
>     ``running`` 状态；同步或轮询等待时返回最终状态。

#### 说明

>     方法会先切换到前处理并刷新模型。若已有求解任务运行，C# 不会重复
>     启动，而是返回当前任务状态。

### `mdb.get_solve_status`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.get_solve_status`

```python
mdb.get_solve_status(read_timeout: int=30)
```

查询当前桥通进程中最近一次分析任务的状态。

#### 参数

>     read_timeout (int): 单次 HTTP 状态请求的读取超时秒数，必须为正数。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_solve_status()
```

#### 返回

>     dict: C# ``SolverRunner`` 返回的状态对象：
>     ``ok`` 表示任务未失败/取消；``state`` 为 ``idle``、``running``、
>     ``succeeded``、``failed`` 或 ``canceled``；``is_running`` 为是否仍在
>     运行；另含 ``message``、``started_at``、``finished_at`` 和当前
>     ``project`` 文件路径。时间字段未发生时为 ``None``。

### `mdb.wait_solve`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.wait_solve`

```python
mdb.wait_solve(poll_interval: float=5, max_wait: Optional[float]=None, read_timeout: int=30)
```

轮询求解状态，直到成功、失败、取消或超时。

#### 参数

>     poll_interval (float): 两次状态查询之间的秒数；小于 0.1 会按 0.1
>         秒处理，建议大型模型使用 2~5 秒。
>     max_wait (float | None): 总等待上限秒数；``None`` 表示不设上限。
>     read_timeout (int): 每次状态 HTTP 请求的读取超时秒数。

#### 示例

```python
from qtmodel import mdb
result = mdb.wait_solve()
```

#### 返回

>     dict: 最终状态对象，字段同 ``get_solve_status``。用户终止求解时会
>     原样返回取消状态；其他 ``failed/canceled`` 状态抛出 ``RuntimeError``。

#### 异常

>     TimeoutError: 超过 ``max_wait`` 仍未结束。
>     RuntimeError: 求解失败，或并非“用户终止”的取消。

### `mdb.initial`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.initial`

```python
mdb.initial()
```

初始化并新建一个空白模型。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.initial()
```

#### 返回

>     None: 若当前工程有未保存修改，是否提示或保留由桥通界面决定。

### `mdb.open_file`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.open_file`

```python
mdb.open_file(file_path: str)
```

打开bfmd文件

#### 参数

>     file_path: 文件全路径

#### 示例

```python
from qtmodel import mdb
    mdb.open_file(file_path="a.bfmd")
Returns: 无
```

### `mdb.close_project`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.close_project`

```python
mdb.close_project()
```

关闭桥通当前活动工程。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.close_project()
```

#### 返回

>     None: 未保存修改的交互处理由桥通桌面端决定。

### `mdb.save_file`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.save_file`

```python
mdb.save_file(file_path: str='')
```

保存bfmd文件，默认保存为当前路径

#### 参数

>     file_path: 文件全路径

#### 示例

```python
from qtmodel import mdb
    mdb.save_file(file_path="a.bfmd")
Returns: 无
```

### `mdb.import_command`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.import_command`

```python
mdb.import_command(command: str)
```

导入MCT命令

#### 参数

>     command:MCT命令字符

#### 示例

```python
from qtmodel import mdb
    mdb.import_command(command="*SECTION")
Returns: 无
```

### `mdb.import_file`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.import_file`

```python
mdb.import_file(file_path: str)
```

导入文件,导入文件为桥通所在主机文件

#### 参数

>     file_path:导入文件(.mct/.qdat/.dxf/.3dx)

#### 示例

```python
from qtmodel import mdb
    mdb.import_file(file_path="a.mct")
Returns: 无
```

### `mdb.export_file`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.export_file`

```python
mdb.export_file(file_path: str, convert_sec_group: bool=False, type_kind: int=2, group_name: Union[List[str], str, None]=None, export_steel_box_check: bool=False, export_concrete_check: bool=False)
```

导出命令为导出到本机所在地址，默认输出截面特性和截面信息。

#### 参数

>     file_path: 导出文件全路径，支持格式(.mct/.qdat/.obj/.txt/.py)
>     convert_sec_group: 是否将变截面组转换为变截面
>     type_kind:
>         输出文件类型：
>         0 - 仅输出截面特性和材料特性（仅供 qdat 输出）
>         1 - 仅输出模型文件
>         2 - 输出截面特性和截面信息
>     group_name:
>         导出时指定结构组数据。
>         仅供 obj、apdl、混凝土检算文件导出。
>         当 export_concrete_check=True 时，必须传入非空字符串。
>     export_steel_box_check: 是否导出钢箱梁检算数据
>     export_concrete_check: 是否导出混凝土检算数据

#### 示例

```python
from qtmodel import mdb
    mdb.export_file(file_path="a.mct")

    mdb.export_file(
        file_path="concrete_check.txt",
        group_name="默认结构组",
        export_concrete_check=True
    )
```

#### 返回

>     无

### `mdb.export_qt_helper`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.export_qt_helper`

```python
mdb.export_qt_helper(file_path: str)
```

输出桥通qdat命令帮助文档,仅支持最新帮助文档,保存路径为调用主机下

#### 参数

>     file_path:导出文件全路径，支持格式(.txt/.qdat)

#### 示例

```python
from qtmodel import mdb
    mdb.export_qt_helper(file_path="a.qdat")
Returns: 无
```

### `mdb.update_view_stage`

源码：`qtmodel/mdb/mdb_project.py` · `MdbProject.update_view_stage`

```python
mdb.update_view_stage(stage_name: str)
```

更新施工阶段显示，通过指定施工阶段名切换视图显示

#### 参数

>     stage_name:施工阶段名称

#### 示例

```python
from qtmodel import mdb
    mdb.update_view_stage(stage_name="一次成桥")
Returns: 无
```

## `mdb_property`

### `mdb.add_material`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.add_material`

```python
mdb.add_material(index: int=-1, name: str='', mat_type: int=1, standard: int=1, database: str='C50', construct_factor: float=1, modified: bool=False, data_info: list[float]=None, creep_id: int=-1, f_cuk: float=0, composite_info: Optional[tuple[str, str]]=None)
```

添加材料

#### 参数

>     index:材料编号,默认为最大Id+1
>     name:材料名称，默认覆盖添加
>     mat_type: 材料类型,1-混凝土 2-钢材 3-预应力 4-钢筋 5-自定义 6-组合材料
>     standard:规范序号,参考UI 默认从1开始
>     database:数据库名称
>     construct_factor:构造系数
>     modified:是否修改默认材料参数,默认不修改 (可选参数)
>     data_info:材料参数列表[弹性模量,容重,泊松比,热膨胀系数] (可选参数)
>     creep_id:徐变材料id (可选参数)
>     f_cuk: 立方体抗压强度标准值 (可选参数)
>     composite_info: 主材名和辅材名 (仅组合材料需要)

#### 示例

```python
from qtmodel import mdb
    mdb.add_material(index=1,name="混凝土材料1",mat_type=1,standard=1,database="C50")
    mdb.add_material(index=1,name="自定义材料1",mat_type=5,data_info=[3.5e10,2.5e4,0.2,1.5e-5])
Returns: 无
```

### `mdb.add_time_parameter`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.add_time_parameter`

```python
mdb.add_time_parameter(index: int=-1, name: str='', code_index: int=1, time_parameter: list[float]=None, creep_data: list[tuple[str, float]]=None, shrink_data: str='')
```

添加收缩徐变材料

#### 参数

>     index:材料编号,默认为最大Id+1
>     name: 收缩徐变名
>     code_index: 1-公规JTG3362-2018  2-公规JTGD62-2004 3-公规JTJ023-85 4-铁规TB10092-2017
>         5-地铁GB50157-2013  6-老化理论  7-BS5400_4_1990  8-AASHTO_LRFD_2017    1000-AASHTO_LRFD_2017
>     time_parameter: 对应规范的收缩徐变参数列表,默认不改变规范中信息 (可选参数)
>     creep_data: 徐变数据 [(函数名,龄期)...]
>     shrink_data: 收缩函数名

#### 示例

```python
from qtmodel import mdb
    mdb.add_time_parameter(name="收缩徐变材料1",code_index=1)
Returns: 无
```

### `mdb.add_creep_function`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.add_creep_function`

```python
mdb.add_creep_function(name: str, creep_data: list[tuple[float, float]], scale_factor: float=1)
```

添加徐变函数

#### 参数

>     name:徐变函数名
>     creep_data:徐变数据[(时间,徐变系数)...]
>     scale_factor:缩放系数

#### 示例

```python
from qtmodel import mdb
    mdb.add_creep_function(name="徐变函数名",creep_data=[(5,0.5),(100,0.75)])
Returns: 无
```

### `mdb.add_shrink_function`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.add_shrink_function`

```python
mdb.add_shrink_function(name: str, shrink_data: list[tuple[float, float]]=None, scale_factor: float=1)
```

添加收缩函数

#### 参数

>     name:收缩函数名
>     shrink_data:收缩数据[(时间,收缩系数)...]
>     scale_factor:缩放系数

#### 示例

```python
from qtmodel import mdb
    mdb.add_shrink_function(name="收缩函数名",shrink_data=[(5,0.5),(100,0.75)])
    mdb.add_shrink_function(name="收缩函数名",scale_factor=1.2)
Returns: 无
```

### `mdb.remove_shrink_function`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.remove_shrink_function`

```python
mdb.remove_shrink_function(name: str='')
```

删除收缩函数

#### 参数

>     name:收缩函数名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_shrink_function(name="收缩函数名")
Returns: 无
```

### `mdb.remove_creep_function`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.remove_creep_function`

```python
mdb.remove_creep_function(name: str='')
```

删除徐变函数

#### 参数

>     name:徐变函数名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_creep_function(name="徐变函数名")
Returns: 无
```

### `mdb.update_material_time_parameter`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_material_time_parameter`

```python
mdb.update_material_time_parameter(name: str='', time_parameter_name: str='', f_cuk: float=0)
```

将收缩徐变参数连接到材料

#### 参数

>     name: 材料名
>     time_parameter_name: 收缩徐变名称
>     f_cuk: 材料标准抗压强度,仅自定义材料是需要输入

#### 示例

```python
from qtmodel import mdb
    mdb.update_material_time_parameter(name="C60",time_parameter_name="收缩徐变1",f_cuk=5e7)
Returns: 无
```

### `mdb.update_material_id`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_material_id`

```python
mdb.update_material_id(name: str, new_id: int)
```

更新材料编号

#### 参数

>     name:材料名称
>     new_id:新编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_material_id(name="材料1",new_id=2)
Returns: 无
```

### `mdb.update_material`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_material`

```python
mdb.update_material(index: int, name: str, mat_type: int=1, standard: int=1, database: str='C50', construct_factor: float=1, modified: bool=False, data_info: list[float]=None, creep_id: int=-1, f_cuk: float=0, composite_info: Optional[tuple[str, str]]=None, new_id: int=-1)
```

原位更新已有材料完整定义并迁移所有模型引用。

``data_info`` 固定为 ``[弹性模量, 容重, 泊松比, 热膨胀系数]``。
用户自定义材料（``mat_type=5``）以及 ``modified=True`` 的数据库
材料必须提供该数组。``new_id`` 省略时保持原编号。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_material(index=..., name=...)
```

### `mdb.update_time_parameter_id`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_time_parameter_id`

```python
mdb.update_time_parameter_id(name: str, new_id: int)
```

更新时间依存材料编号

#### 参数

>     name:时间依存材名称
>     new_id:新时间依存材编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_time_parameter_id(name="时间依存材料1",new_id=2)
Returns: 无
```

### `mdb.remove_material`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.remove_material`

```python
mdb.remove_material(index: int=-1, name: str='')
```

删除指定材料

#### 参数

>     index:指定材料编号，默认则删除所有材料
>     name: 指定材料名，材料名为空时按照index删除

#### 示例

```python
from qtmodel import mdb
    mdb.remove_material()
    mdb.remove_material(index=1)
Returns: 无
```

### `mdb.update_material_construction_factor`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_material_construction_factor`

```python
mdb.update_material_construction_factor(name: str, factor: float=1)
```

更新材料构造系数

#### 参数

>     name:指定材料编号，默认则删除所有材料
>     factor:指定材料编号，默认则删除所有材料

#### 示例

```python
from qtmodel import mdb
    mdb.update_material_construction_factor(name="材料1",factor=1.0)
Returns: 无
```

### `mdb.remove_time_parameter`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.remove_time_parameter`

```python
mdb.remove_time_parameter(name: str='')
```

删除指定时间依存材料

#### 参数

>     name: 指定收缩徐变材料名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_time_parameter("收缩徐变材料1")
Returns: 无
```

### `mdb.add_thickness`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.add_thickness`

```python
mdb.add_thickness(index: int=-1, name: str='', t: float=0, thick_type: int=0, bias_info: tuple[int, float]=None, rib_pos: int=0, dist_v: float=0, dist_l: float=0, rib_v: list[float]=None, rib_l: list[float]=None, calc_type: int=0)
```

添加板厚

#### 参数

>     index: 板厚id
>     name: 板厚名称
>     t: 板厚度
>     thick_type: 板厚类型 0-普通板 1-加劲肋板
>     bias_info: 默认不偏心,偏心时输入列表[type(0-厚度比 1-数值),value]
>     rib_pos: 肋板位置 0-下部 1-上部
>     dist_v: 纵向截面肋板间距
>     dist_l: 横向截面肋板间距
>     rib_v: 纵向肋板信息
>     rib_l: 横向肋板信息
>     calc_type: 0-加劲肋采用梁单元  1-等效板厚

#### 示例

```python
from qtmodel import mdb
    mdb.add_thickness(name="厚度1", t=0.2,thick_type=0,bias_info=(0,0.8))
    mdb.add_thickness(name="厚度2", t=0.2,thick_type=1,rib_pos=0,dist_v=0.1,rib_v=[1,1,0.02,0.02])
Returns: 无
```

### `mdb.update_thickness_id`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_thickness_id`

```python
mdb.update_thickness_id(index: int, new_id: int)
```

更新板厚编号

#### 参数

>     index: 板厚id
>     new_id: 新板厚id

#### 示例

```python
from qtmodel import mdb
    mdb.update_thickness_id(1,2)
Returns: 无
```

### `mdb.update_thickness`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.update_thickness`

```python
mdb.update_thickness(index: int, name: str, t: float, thick_type: int=0, bias_info: tuple[int, float]=None, rib_pos: int=0, dist_v: float=0, dist_l: float=0, rib_v: list[float]=None, rib_l: list[float]=None, calc_type: int=0, new_id: int=-1)
```

原位更新已有板厚完整定义并迁移关联板单元。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_thickness(index=..., name=..., t=...)
```

### `mdb.remove_thickness`

源码：`qtmodel/mdb/mdb_property.py` · `MdbProperty.remove_thickness`

```python
mdb.remove_thickness(index: int=-1, name: str='')
```

删除板厚

#### 参数

>      index:板厚编号,默认时删除所有板厚信息
>      name:默认按照编号删除,如果不为空则按照名称删除

#### 示例

```python
from qtmodel import mdb
    mdb.remove_thickness()
    mdb.remove_thickness(index=1)
    mdb.remove_thickness(name="板厚1")
Returns: 无
```

## `mdb_section`

### `mdb.list_parameter_section_types`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.list_parameter_section_types`

```python
mdb.list_parameter_section_types()
```

返回所有支持字典形式 ``sec_info`` 的参数化截面类型。

#### 示例

```python
from qtmodel import mdb
result = mdb.list_parameter_section_types()
```

### `mdb.get_parameter_section_schema`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.get_parameter_section_schema`

```python
mdb.get_parameter_section_schema(sec_type: str)
```

获取指定截面的参数含义、顺序、类型、单位、别名和调用示例。

Agent 在添加不熟悉的截面前，应先调用本方法查询 ``sec_info``。

#### 参数

>     sec_type: 截面类型，例如 ``"矩形"``、``"混凝土箱梁"``。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_parameter_section_schema(sec_type=...)
```

#### 返回

>     JSON 可序列化的截面参数 Schema。

### `mdb.get_parameter_section_shape`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.get_parameter_section_shape`

```python
mdb.get_parameter_section_shape(sec_type: str, sec_info: Mapping[str, Any], mat_combine: list[float]=None, name: str='')
```

根据参数即时生成截面形状，但不向模型添加截面。

该方法调用纯 Python 几何生成器；公式由 C# 端
``UpdateSectionPoint`` / ``UpdateByParam`` 移植而来，运行时不连接
Qt、不发送 HTTP 请求，也不加载 C# DLL。Agent 应先调用
:meth:`get_parameter_section_schema` 查询参数含义。

#### 参数

>     sec_type: 参数化截面类型。
>     sec_info: 有含义的截面参数字典，长度单位通常为 m。
>     mat_combine: 组合材料参数，可选，顺序与 ``add_parameter_section`` 相同。
>     name: 仅用于返回结果的临时名称。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_parameter_section_shape(sec_type=..., sec_info=...)
```

#### 返回

>     统一的 :class:`SectionShape`，不会修改当前模型。

### `mdb.get_parameter_section_property_local`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.get_parameter_section_property_local`

```python
mdb.get_parameter_section_property_local(sec_type: str, sec_info: Mapping[str, Any], mat_combine: list[float]=None, reference_role: str='main', name: str='')
```

在本地计算参数化截面的可严格验证几何特性。

本方法不会连接桥通或修改当前模型。当前计算面积、形心、Iy、Iz、
Iyz、内外轮廓周长、包围框和四个控制点；组合截面按
``mat_combine[0]``（主材/辅材弹性模量比）进行换算。

#### 参数

>     sec_type: 参数化截面类型。
>     sec_info: 有含义的参数字典，坐标和厚度单位为 m。
>     mat_combine: 组合材料参数，可选；第一项为主材/辅材弹模比。
>     reference_role: 换算基准，``main`` 或 ``secondary``。
>     name: 临时截面名称。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_parameter_section_property_local(sec_type=..., sec_info=...)
```

#### 返回

>     包含 ``SectionProperty``、包围框、控制点及各部件特性的详细结果。

### `mdb.get_section_property_local`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.get_section_property_local`

```python
mdb.get_section_property_local(sec_type: str, sec_info: Union[list[float], Mapping[str, Any]]=None, mat_combine: list[float]=None, reference_role: str='main', **shape_options: Any)
```

按 ``get_section_shape`` 的参数本地计算截面几何特性。

自定义线圈可在 ``shape_options`` 中传 ``loop_segments``，自定义线宽
可传 ``sec_lines``。多条线宽按矩形条带叠加，交点不进行布尔去重。

#### 参数

>     sec_type (str): ``SectionDB`` 支持的参数截面名，或自定义线圈/线宽/
>         组合截面类型名称。
>     sec_info (list[float] | Mapping[str, Any] | None): 按 C# 固定顺序的尺寸
>         数组，或 ``{"W": ..., "H": ...}`` 语义参数字典；所需键和值范围
>         由 ``SectionDB.get_schema(sec_type)`` 定义，长度尺寸通常应大于 0。
>     mat_combine (list[float] | None): 组合截面固定 5 项材料比值：
>         ``[Es/Ec, 密度比s/c, 钢泊松比, 混凝土泊松比, 热膨胀系数比s/c]``。
>     reference_role (str): 组合截面换算基准，仅用 ``"main"`` 主材或
>         ``"secondary"`` 辅材；普通截面用默认值即可。
>     **shape_options: 与 ``get_section_shape`` 同名的几何选项，例如
>         ``loop_segments``、``sec_lines``、``rib_info``、``rib_place``。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_section_property_local(sec_type=...)
```

#### 返回

>     SectionPropertyResult: 含 ``property``、包围盒、控制点、分部特性及
>     换算信息；``to_dict()`` 明确给出单位（m、m²、m⁴）、已计算字段、
>     未计算字段和几何积分假设。本方法不连接桥通、不写模型。

### `mdb.get_section_shape`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.get_section_shape`

```python
mdb.get_section_shape(sec_type: str, sec_info: Union[list[float], Mapping[str, Any]]=None, index: int=1, name: str='', symmetry: bool=True, chamfer_info: list[str]=None, sec_right: list[float]=None, chamfer_right: list[str]=None, box_num: int=3, box_height: float=2, box_other_info: dict[str, list[float]]=None, box_other_right: dict[str, list[float]]=None, mat_combine: list[float]=None, rib_info: dict[str, list[float]]=None, rib_place: list=None, loop_segments: list=None, sec_lines: list=None, secondary_loop_segments: list=None, sec_property: list[float]=None, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_x: float=0, bias_y: float=0)
```

按 ``add_section`` 的数据即时生成任意截面形状，不修改模型。

参数化截面可直接传有序 ``sec_info``；普通参数化截面也可传字典。
自定义线圈使用 ``loop_segments``，自定义线宽使用 ``sec_lines``；
钢梁可传 ``rib_info``/``rib_place``，组合截面可传
``secondary_loop_segments``/``mat_combine``。本方法为纯 Python
本地计算，不要求 Qt 主程序正在运行。

#### 参数

>     sec_type (str): 截面类型的桥通中文名称。
>     sec_info (list[float] | Mapping[str, Any] | None): 参数截面的有序尺寸
>         列表或语义字典；字典键模式可由 ``list_parameter_section_types`` /
>         ``SectionDB.get_schema`` 查询。
>     index (int): 形状元数据中的截面号，正整数；纯本地预览不会占用模型号。
>     name (str): 形状名称；空值自动使用“截面类型+预览”。
>     symmetry (bool): 参数截面左右是否对称。
>     chamfer_info (list[str] | None): 左侧/对称侧倒角字符串，顺序取决于
>         ``sec_type`` 的 C# 参数定义。
>     sec_right (list[float] | None): 非对称截面的右侧尺寸数组。
>     chamfer_right (list[str] | None): 非对称截面右侧倒角数组。
>     box_num (int): 箱室数量，应为正整数；仅箱梁类截面使用。
>     box_height (float): 箱梁基准高度，单位 m，通常应大于 0。
>     box_other_info (dict[str, list[float]] | None): 多箱室左/通用附加尺寸。
>     box_other_right (dict[str, list[float]] | None): 非对称右侧附加尺寸。
>     mat_combine (list[float] | None): 组合材料固定 5 项比值，定义同
>         ``get_section_property_local``。
>     rib_info (dict[str, list[float]] | None): 钢梁加劲肋规格字典。
>     rib_place (list | None): 加劲肋布置记录列表，格式同 ``add_section``。
>     loop_segments (list | None): 主材线圈；每项为含 ``main`` 外圈和可选
>         ``sub1/sub2...`` 孔洞点列的字典，点为 ``[y,z]`` 或 ``(y,z)``。
>     sec_lines (list | None): 线宽截面条带 ``[y1,z1,y2,z2,thickness]``。
>     secondary_loop_segments (list | None): 组合截面辅材线圈，格式同主材。
>     sec_property (list[float] | None): 兼容建模契约的显式截面特性；本地
>         形状生成不使用它覆盖几何。
>     bias_type (str): 偏心类型，如 ``"中心"`` 或桥通支持的边缘/自定义类型。
>     center_type (str): 偏心参照中心，如 ``"质心"``；须使用桥通枚举文本。
>     shear_consider (bool): 是否记录考虑剪切变形。
>     bias_x (float): 自定义偏心局部 x 坐标，单位 m，仅自定义偏心有效。
>     bias_y (float): 自定义偏心局部 y 坐标，单位 m，仅自定义偏心有效。

#### 示例

```python
from qtmodel import mdb
result = mdb.get_section_shape(sec_type=...)
```

#### 返回

>     SectionShape: 可序列化的局部截面几何；参数截面无效、点列不闭合或
>     尺寸数目不符时抛出面向 Agent 的 ``ValueError``。

### `mdb.add_parameter_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_parameter_section`

```python
mdb.add_parameter_section(index: int=1, name: str='', sec_type: str='矩形', sec_info: dict=None, mat_combine: list[float]=None, sec_property: list[float]=None, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_x: float=0, bias_y: float=0)
```

添加参数化截面

#### 参数

>     index: 截面编号,默认自动识别
>     name:截面名称
>     sec_type:参数截面类型名称
>     sec_info:有含义的截面参数字典，键名统一使用小写。可先调用
>         get_parameter_section_schema 查询
>     mat_combine:组合截面材料参数，可选。顺序为[弹性模量比、密度比、钢材泊松比、混凝土泊松比、热膨胀系数比]
>     sec_property:截面特性(参考UI界面共计29个参数)，可选参数，指定截面特性时不进行截面计算
>     bias_type:偏心类型 默认中心
>     center_type:中心类型 默认质心
>     shear_consider:考虑剪切 bool 默认考虑剪切变形
>     bias_x:自定义偏心点x坐标 (仅自定义类型偏心需要,相对于center_type偏移)
>     bias_y:自定义偏心点y坐标 (仅自定义类型偏心需要,相对于center_type偏移)

#### 示例

```python
from qtmodel import mdb
    mdb.add_parameter_section(
        index=271,
        name="新建矩形截面271",
        sec_type="矩形",
        sec_info={"w": 2, "h": 2}
    )
    mdb.add_parameter_section(
            index=271, name="新建混凝土箱梁271", sec_type="混凝土箱梁",
            sec_info=dict(b=24, n=3, h=2, symmetry=True, h1=0.2, h2=0.4,
             h2a=0.1, h2b=0.13, b1=3, b1a=1, b1b=2, b2=1, i1=0.02,
             i2=0, b0=12, b3=5, b4=6, t1=0.28, t2=0.3, t3=0.5, t4=0.5,
              r1=0.5, r2=0.2, c1="1*0.2,0.1*0.2", c2="0.5*0.15,0.3*0.2",
              c3="0.4*0.2", c4="0.5*0.2")
        )
    mdb.add_parameter_section(
        index=271,
        name="新建带肋钢梁271",
        sec_type="带肋钢梁",
        sec_info={
            "tb": 0.016,"h": 2.5,"nh": 4,"nv": 4,"hrt": 0.25,
            "hrw": 0.2,"trt": 0.016,"trw": 0.016,"dh": 0.3,
            "dv": 0.5,"tt": 0.016,"tw": 0.02,"w": 2
        }
    )
Returns: 无
```

### `mdb.add_custom_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_custom_section`

```python
mdb.add_custom_section(index: int=1, name: str='', sec_type: str='矩形', mat_combine: list[float]=None, loop_segments: Union[list[dict[str, list[list[float]]]], list[dict[str, list[tuple]]]]=None, sec_lines: Union[list[tuple[float, float, float, float, float]], list[list[float]]]=None, secondary_loop_segments: Union[list[dict[str, list[list[float]]]], list[dict[str, list[tuple]]]]=None, sec_property: list[float]=None, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_x: float=0, bias_y: float=0)
```

添加自定义截面，截面类型包括自定义线圈截面、自定义线宽截面、自定义特性截面、自定义组合截面

#### 参数

>     index: 截面编号,默认自动识别
>     name:截面名称
>     sec_type:参数截面类型名称(截面类型仅包括:自定义线圈截面、自定义线宽截面、自定义特性截面、自定义组合截面)
>     mat_combine: 组合截面材料信息 (仅组合材料需要) [弹性模量比s/c、密度比s/c、钢材泊松比、混凝土泊松比、热膨胀系数比s/c]
>     loop_segments:自定义线圈坐标集合 list[dict],必须为如下所示:{"main":[[x1,y1],[x2,y2]...],"sub1":[[x1,y1],[x2,y2]...],"sub2":[[x1,y1],[x2,y2]...]}
>     sec_lines:自定义线宽集合,必须为如下所示:[[x1,y1,x2,y3,thick],...]
>     secondary_loop_segments:辅材线圈坐标集合 list[dict] (同loop_segments)，建议以左下角为组合截面原点建立截面
>     sec_property:截面特性(参考UI界面共计29个参数)，可选参数，指定截面特性时不进行截面计算
>     bias_type:偏心类型 默认中心
>     center_type:中心类型 默认质心
>     shear_consider:考虑剪切 bool 默认考虑剪切变形
>     bias_x:自定义偏心点x坐标 (仅自定义类型偏心需要,相对于center_type偏移)
>     bias_y:自定义偏心点y坐标 (仅自定义类型偏心需要,相对于center_type偏移)

#### 示例

```python
from qtmodel import mdb
result = mdb.add_custom_section()
```

### `mdb.add_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_section`

```python
mdb.add_section(index: int=1, name: str='', sec_type: str='矩形', sec_info: Union[list[float], Mapping[str, Any]]=None, symmetry: bool=True, chamfer_info: list[str]=None, sec_right: list[float]=None, chamfer_right: list[str]=None, box_num: int=3, box_height: float=2, box_other_info: dict[str, list[float]]=None, box_other_right: dict[str, list[float]]=None, mat_combine: list[float]=None, rib_info: dict[str, list[float]]=None, rib_place: Union[list[tuple[int, int, float, str, int, str]], list[list]]=None, loop_segments: Union[list[dict[str, list[list[float]]]], list[dict[str, list[tuple]]]]=None, sec_lines: Union[list[tuple[float, float, float, float, float]], list[list[float]]]=None, secondary_loop_segments: Union[list[dict[str, list[list[float]]]], list[dict[str, list[tuple]]]]=None, sec_property: list[float]=None, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_x: float=0, bias_y: float=0)
```

添加单一截面信息,如果截面号存在则自动覆盖添加

#### 参数

>     index: 截面编号,默认自动识别
>     name:截面名称
>     sec_type:参数截面类型名称(详见UI界面)
>     sec_info:截面信息。兼容旧版有序列表，也可传有含义的参数字典；Agent 优先使用字典
>     symmetry:混凝土截面是否对称 (仅混凝土箱梁截面需要)
>     chamfer_info:混凝土截面倒角信息 (仅混凝土箱梁截面需要)
>     sec_right:混凝土截面右半信息 (对称时可忽略，仅混凝土箱梁截面需要)
>     chamfer_right:混凝土截面右半倒角信息 (对称时可忽略，仅混凝土箱梁截面需要)
>     box_num: 混凝土箱室数 (仅混凝土箱梁截面需要)
>     box_height: 混凝土箱梁梁高 (仅混凝土箱梁截面需要)
>     box_other_info: 混凝土箱梁额外信息(键包括"i1" "B0" "B4" "T4" 值为列表)
>     box_other_right: 混凝土箱梁额外信息(对称时可忽略，键包括"i1" "B0" "B4" "T4" 值为列表)
>     mat_combine: 组合截面材料信息 (仅组合材料需要) [弹性模量比s/c、密度比s/c、钢材泊松比、混凝土泊松比、热膨胀系数比s/c]
>     rib_info:肋板信息
>     rib_place:肋板位置 list[tuple[布置具体部位,参考点0-下/左,距参考点间距,肋板名，加劲肋位置0-上/左 1-下/右 2-两侧,加劲肋名]]
>         _布置具体部位(工字钢梁) 1-上左 2-上右 3-腹板 4-下左 5-下右
>         _布置具体部位(箱型钢梁) 1-上左 2-上中 3-上右 4-左腹板 5-右腹板 6-下左 7-下中 8-下右
>     loop_segments:线圈坐标集合 list[dict] dict示例:{"main":[[x1,y1],[x2,y2]...],"sub1":[[x1,y1],[x2,y2]...],"sub2":[[x1,y1],[x2,y2]...]}
>     sec_lines:线宽集合[[x1,y1,x2,y3,thick],]
>     secondary_loop_segments:辅材线圈坐标集合 list[dict] (同loop_segments)，建议以左下角为组合截面原点建立截面
>     sec_property:截面特性(参考UI界面共计29个参数)，可选参数，指定截面特性时不进行截面计算
>     bias_type:偏心类型 默认中心
>     center_type:中心类型 默认质心
>     shear_consider:考虑剪切 bool 默认考虑剪切变形
>     bias_x:自定义偏心点x坐标 (仅自定义类型偏心需要,相对于center_type偏移)
>     bias_y:自定义偏心点y坐标 (仅自定义类型偏心需要,相对于center_type偏移)

#### 示例

```python
from qtmodel import mdb
    mdb.add_section(name="截面1",sec_type="矩形",sec_info=[2,4],bias_type="中心")
    mdb.add_section(name="截面2",sec_type="混凝土箱梁",box_height=2,box_num=3,
        sec_info=[0.2,0.4,0.1,0.13,3,1,2,1,0.02,0,12,5,6,0.28,0.3,0.5,0.5,0.5,0.2],
        chamfer_info=["1*0.2,0.1*0.2","0.5*0.15,0.3*0.2","0.4*0.2","0.5*0.2"])
    mdb.add_section(name="钢梁截面1",sec_type="工字钢梁",sec_info=[0,0,0.5,0.5,0.5,0.5,0.7,0.02,0.02,0.02])
    mdb.add_section(name="钢梁截面2",sec_type="箱型钢梁",sec_info=[0,0.15,0.25,0.5,0.25,0.15,0.4,0.15,0.7,0.02,0.02,0.02,0.02],
        rib_info = {"板肋1": [0.1,0.02],"T形肋1":[0.1,0.02,0.02,0.02]},
        rib_place = [(1, 0, 0.1, "板肋1", 2, "默认名称1"),(1, 0, 0.2, "板肋1", 2, "默认名称1")])
Returns: 无
```

### `mdb.add_single_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_single_section`

```python
mdb.add_single_section(index: int=-1, name: str='', sec_type: str='矩形', sec_data: dict=None)
```

以字典形式添加单一截面,如果截面号存在则自动覆盖添加

#### 参数

>     index:截面编号
>     name:截面名称
>     sec_type:截面类型
>     sec_data:截面信息字典，键值参考添加add_section方法参数

#### 示例

```python
from qtmodel import mdb
    mdb.add_single_section(index=1,name="变截面1",sec_type="矩形",
        sec_data={"sec_info":[1,2],"bias_type":"中心"})
Returns: 无
```

### `mdb.add_tapper_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_tapper_section`

```python
mdb.add_tapper_section(index: int, name: str='', sec_type: str='矩形', sec_begin: dict=None, sec_end: dict=None, shear_consider: bool=True, sec_normalize: bool=False)
```

添加变截面,字典参数参考单一截面,如果截面号存在则自动覆盖添加

#### 参数

>     index:截面编号
>     name:截面名称
>     sec_type:截面类型
>     sec_begin:截面始端截面信息字典，键值参考添加add_section方法参数
>     sec_end:截面末端截面信息字典，键值参考添加add_section方法参数
>     shear_consider:考虑剪切变形
>     sec_normalize:变截面线段线圈重新排序

#### 示例

```python
from qtmodel import mdb
    mdb.add_tapper_section(index=1,name="变截面1",sec_type="矩形",
        sec_begin={"sec_info":[1,2],"bias_type":"中心"},
        sec_end={"sec_info":[2,2],"bias_type":"中心"})
Returns: 无
```

### `mdb.calculate_section_property`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.calculate_section_property`

```python
mdb.calculate_section_property()
```

重新计算所有截面特性
Args: 无

#### 示例

```python
from qtmodel import mdb
    mdb.calculate_section_property()
Returns: 无
```

### `mdb.remove_unused_sections`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.remove_unused_sections`

```python
mdb.remove_unused_sections()
```

删除未使用截面
Args: 无

#### 示例

```python
from qtmodel import mdb
    mdb.remove_unused_sections()
Returns: 无
```

### `mdb.add_tapper_section_by_id`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_tapper_section_by_id`

```python
mdb.add_tapper_section_by_id(index: int=-1, name: str='', begin_id: int=1, end_id: int=1, shear_consider: bool=True, sec_normalize: bool=False)
```

添加变截面,需先建立单一截面

#### 参数

>     index:截面编号
>     name:截面名称
>     begin_id:截面始端编号
>     end_id:截面末端编号
>     shear_consider:考虑剪切变形
>     sec_normalize: 开启变截面线圈和线宽自适应排序 (避免两端截面绘制顺序导致的渲染和计算失效)

#### 示例

```python
from qtmodel import mdb
    mdb.add_tapper_section_by_id(name="变截面1",begin_id=1,end_id=2)
Returns: 无
```

### `mdb.update_section_bias`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_section_bias`

```python
mdb.update_section_bias(index: int=1, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_point: list[float]=None, side_i: bool=True)
```

更新截面偏心

#### 参数

>      index:截面编号
>      bias_type:偏心类型
>      center_type:中心类型
>      shear_consider:考虑剪切
>      bias_point:自定义偏心点(仅自定义类型偏心需要)
>      side_i: 是否为截面I,否则为截面J(仅变截面需要)

#### 示例

```python
from qtmodel import mdb
    mdb.update_section_bias(index=1,bias_type="中上",center_type="几何中心")
    mdb.update_section_bias(index=1,bias_type="自定义",bias_point=[0.1,0.2])
Returns: 无
```

### `mdb.update_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_section`

```python
mdb.update_section(index: int, name: str, sec_type: str, sec_info: Union[list[float], Mapping[str, Any]], symmetry: bool=True, chamfer_info: list[str]=None, sec_right: list[float]=None, chamfer_right: list[str]=None, box_num: int=3, box_height: float=2, box_other_info: dict[str, list[float]]=None, box_other_right: dict[str, list[float]]=None, mat_combine: list[float]=None, rib_info: dict[str, list[float]]=None, rib_place: Union[list[tuple[int, int, float, str, int, str]], list[list]]=None, loop_segments=None, sec_lines=None, secondary_loop_segments=None, bias_type: str='中心', center_type: str='质心', shear_consider: bool=True, bias_x: float=0, bias_y: float=0)
```

通过 C# ``SectionCommonAction.EditSections`` 修改单一截面。

``sec_info`` 可使用有序列表，也可使用 ``{"W": 20, "H": 6}``
这样的语义参数字典。修改会同步替换模型中对原截面的引用，并由桥通按
新尺寸重新计算截面特性。

#### 参数

>     index (int): 已存在截面号，必须大于 0。
>     name (str): 修改后的截面名，不应为空。
>     sec_type (str): 修改后的桥通截面类型名称。
>     sec_info (list[float] | Mapping[str, Any]): 尺寸序列或语义参数字典。
>     symmetry (bool): 是否左右对称。
>     chamfer_info (list[str] | None): 对称/左端倒角数据。
>     sec_right (list[float] | None): 非对称右侧尺寸。
>     chamfer_right (list[str] | None): 非对称右侧倒角。
>     box_num (int): 箱室数，正整数，仅箱梁类使用。
>     box_height (float): 箱梁基准高度，单位 m。
>     box_other_info (dict[str,list[float]] | None): 箱梁附加尺寸。
>     box_other_right (dict[str,list[float]] | None): 右侧箱梁附加尺寸。
>     mat_combine (list[float] | None): 组合材料固定 5 项比值。
>     rib_info (dict[str,list[float]] | None): 加劲肋规格。
>     rib_place (list | None): 加劲肋布置记录。
>     loop_segments (list | None): 主材线圈点列。
>     sec_lines (list | None): 线宽条带 ``[y1,z1,y2,z2,thickness]``。
>     secondary_loop_segments (list | None): 辅材线圈点列。
>     bias_type (str): 桥通偏心类型文本。
>     center_type (str): 桥通中心类型文本。
>     shear_consider (bool): 是否考虑剪切变形。
>     bias_x (float): 自定义偏心第一坐标，单位 m。
>     bias_y (float): 自定义偏心第二坐标，单位 m。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_section(index=..., name=..., sec_type=..., sec_info=...)
```

#### 返回

>     str: C# 修改成功信息。此接口原位修改且会替换引用，不创建新截面。

### `mdb.update_tapper_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_tapper_section`

```python
mdb.update_tapper_section(index: int, name: str, sec_type: str, sec_begin: dict, sec_end: dict, shear_consider: bool=True, sec_normalize: bool=False)
```

通过 C# ``SectionActions.UpdateTapperSection`` 原位修改变截面。

``sec_begin`` 和 ``sec_end`` 分别表示 I、J 端截面数据；C# 最终通过
``SectionCommonAction.EditSections`` 同步替换模型中的截面引用。

#### 参数

>     index (int): 已存在变截面号，必须大于 0。
>     name (str): 修改后的变截面名称。
>     sec_type (str): I/J 两端共同的参数截面类型名称。
>     sec_begin (dict): I 端完整截面参数，至少含 ``sec_info``，可含
>         ``symmetry/chamfer_info/sec_right/box_num/...``，字段同 ``add_section``。
>     sec_end (dict): J 端完整截面参数，格式同 ``sec_begin``。
>     shear_consider (bool): 两端截面是否考虑剪切变形。
>     sec_normalize (bool): 是否由 C# 对 I/J 端线圈拓扑进行归一化；仅当
>         两端点序/分段需建立一一对应时开启，已同拓扑数据建议传 ``False``。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_tapper_section(index=..., name=..., sec_type=..., sec_begin=..., sec_end=...)
```

#### 返回

>     str: C# 修改成功信息。端字典类型错误会在 Python 侧抛出 ``TypeError``。

### `mdb.update_section_property`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_section_property`

```python
mdb.update_section_property(index: int, sec_property: list[float], side_i: bool=True)
```

更新截面特性

#### 参数

>     index:截面号
>     sec_property:截面特性值参考UI共计26个数值
>     side_i:是否为I端截面(仅变截面需要)

#### 示例

```python
from qtmodel import mdb
    mdb.update_section_property(index=1,sec_property=[i for i in range(1,27)])
Returns: 无
```

### `mdb.update_section_id`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_section_id`

```python
mdb.update_section_id(index: int, new_id: int)
```

更新截面编号

#### 参数

>     index: 原编号
>     new_id: 新编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_section_id(index=1,new_id=2)
Returns:无
```

### `mdb.remove_section`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.remove_section`

```python
mdb.remove_section(ids=None)
```

删除截面信息,默认则删除所有截面

#### 参数

>     ids: 截面编号

#### 示例

```python
from qtmodel import mdb
    mdb.remove_section(1)
    mdb.remove_section("1to100")
Returns: 无
```

### `mdb.add_tapper_section_group`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_tapper_section_group`

```python
mdb.add_tapper_section_group(ids=None, name: str='', factor_w: float=1.0, factor_h: float=1.0, ref_w: int=0, ref_h: int=0, dis_w: float=0, dis_h: float=0, parameter_info: dict[str, str]=None)
```

添加变截面组

#### 参数

>      ids:变截面组单元号,支持XtoYbyN类型字符串
>      name: 变截面组名
>      factor_w: 宽度方向变化阶数 线性(1.0) 非线性(!=1.0)
>      factor_h: 高度方向变化阶数 线性(1.0) 非线性(!=1.0)
>      ref_w: 宽度方向参考点 0-i 1-j
>      ref_h: 高度方向参考点 0-i 1-j
>      dis_w: 宽度方向距离
>      dis_h: 高度方向距离
>      parameter_info:参数化变截面组信息,键为参数名(参考UI)值为如下三种类型
>          1(非线性),指数,参考点(I/J),距离
>          2(自定义),变化长1,终点值1,变化长2,终点值2...
>          3(圆弧),半径,参考点(I/J)

#### 示例

```python
from qtmodel import mdb
    mdb.add_tapper_section_group(ids=[1,2,3,4],name="变截面组1")
    mdb.add_tapper_section_group(ids=[1,2,3,4],name="参数化变截面组",parameter_info={"梁高(H)":"1,2,I,0"})
Returns: 无
```

### `mdb.add_elements_to_tapper_section_group`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_elements_to_tapper_section_group`

```python
mdb.add_elements_to_tapper_section_group(name: str, ids=None)
```

添加单元到变截面组

#### 参数

>   name:变截面组名称
>   ids:新增单元编号

#### 示例

```python
from qtmodel import mdb
  mdb.add_elements_to_tapper_section_group("变截面组1",ids=[1,2,3,4,5,6])
  mdb.add_elements_to_tapper_section_group("变截面组1",ids="1to6")
Returns:无
```

### `mdb.add_tapper_section_from_group`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.add_tapper_section_from_group`

```python
mdb.add_tapper_section_from_group(name: str='')
```

将变截面组转为变截面

#### 参数

>     name: 变截面组名，默认则转化全部变截面组

#### 示例

```python
from qtmodel import mdb
    mdb.add_tapper_section_from_group()
    mdb.add_tapper_section_from_group("变截面组1")
Returns: 无
```

### `mdb.update_tapper_section_group`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.update_tapper_section_group`

```python
mdb.update_tapper_section_group(name: str, new_name='', ids=None, factor_w: float=1.0, factor_h: float=1.0, ref_w: int=0, ref_h: int=0, dis_w: float=0, dis_h: float=0, parameter_info: dict[str, str]=None)
```

更新变截面组

#### 参数

>      name:变截面组组名
>      new_name: 新变截面组名
>      ids:变截面组包含的单元号,支持XtoYbyN形式字符串
>      factor_w: 宽度方向变化阶数 线性(1.0) 非线性(!=1.0)
>      factor_h: 高度方向变化阶数 线性(1.0) 非线性(!=1.0)
>      ref_w: 宽度方向参考点 0-i 1-j
>      ref_h: 高度方向参考点 0-i 1-j
>      dis_w: 宽度方向距离
>      dis_h: 高度方向距离
>      parameter_info:参数化变截面组信息,键为参数名(参考UI)值为如下三种类型
>          1(非线性),指数,参考点(I/J),距离
>          2(自定义),变化长1,终点值1,变化长2,终点值2...
>          3(圆弧),半径,参考点(I/J)

#### 示例

```python
from qtmodel import mdb
    mdb.update_tapper_section_group(name="变截面组1",ids=[1,2,3,4])
    mdb.update_tapper_section_group(name="变截面组2",ids="1t0100")
Returns: 无
```

### `mdb.remove_tapper_section_group`

源码：`qtmodel/mdb/mdb_section.py` · `MdbSection.remove_tapper_section_group`

```python
mdb.remove_tapper_section_group(name: str='')
```

删除变截面组，默认删除所有变截面组

#### 参数

>     name:变截面组名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_tapper_section_group()
    mdb.remove_tapper_section_group("变截面组1")
Returns:无
```

## `mdb_sink_load`

### `mdb.add_sink_group`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.add_sink_group`

```python
mdb.add_sink_group(name: str='', sink: float=0.1, node_ids: Union[int, List[int], str]=None)
```

新增或按同名覆盖一个节点沉降组。

#### 参数

>      name (str): 沉降组唯一名称，不应为空；同名存在时 C# 端执行修改。
>      sink (float): 沉降量，单位为模型当前长度单位。C# 接口类型为
>          ``double`` 且未设置硬范围；工程上通常传非负沉降幅值，方向按
>          桥通沉降荷载约定解释。
>      node_ids (int | list[int] | str): 关联支承节点号。支持单个整数、
>          整数列表以及 ``"1to10by2"`` 范围字符串；节点必须已存在，
>          不应为 ``None`` 或空集合。

#### 示例

```python
from qtmodel import mdb
    mdb.add_sink_group(name="沉降1",sink=0.1,node_ids=[1,2,3])
```

#### 返回

>     str: 服务端成功信息。任一节点不存在时由 C# 查询节点逻辑报错。

### `mdb.add_sink_case`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.add_sink_case`

```python
mdb.add_sink_case(name: str, sink_groups: Union[str, List[str]]=None)
```

新增或按同名覆盖一个沉降工况。

#### 参数

>     name (str): 沉降工况唯一名称，不应为空；同名存在时 C# 端执行修改。
>     sink_groups (str | list[str]): 已存在的沉降组名或名称列表。每个名称
>         必须由 ``add_sink_group`` 创建；``None`` 会被发送为 null，C# 端
>         将直接不执行创建，空列表则会创建不含子沉降组的工况。

#### 示例

```python
from qtmodel import mdb
result = mdb.add_sink_case(name=...)
```

#### 返回

>     str: 服务端成功信息。当前 C# 固定设置 ``nMin=1``、``nMax=1``、
>     ``adjustedFactor=1``，这些组合参数不能由本方法传入。

### `mdb.add_concurrent_reaction`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.add_concurrent_reaction`

```python
mdb.add_concurrent_reaction(names: Union[str, List[str]])
```

设置沉降分析采用的并发反力结构组。

#### 参数

>     names (str | list[str]): 一个或多个已存在的结构组名称，不能为空。
>         这里不是沉降工况名；所有名称必须能在模型结构组中精确匹配。

#### 示例

```python
from qtmodel import mdb
result = mdb.add_concurrent_reaction(names=...)
```

#### 返回

>     str: 服务端成功信息。调用会用本次列表整体替换现有并发反力组；
>     找不到任一结构组时抛出服务端错误。

### `mdb.add_concurrent_force`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.add_concurrent_force`

```python
mdb.add_concurrent_force(names: Union[str, List[str]])
```

设置沉降分析采用的并发内力结构组。

#### 参数

>     names (str | list[str]): 一个或多个已存在的结构组名称，不能为空；
>         每个名称均需精确匹配，且不是荷载工况名称。

#### 示例

```python
from qtmodel import mdb
result = mdb.add_concurrent_force(names=...)
```

#### 返回

>     str: 服务端成功信息。调用会整体替换现有并发内力组设置。

### `mdb.update_sink_case`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.update_sink_case`

```python
mdb.update_sink_case(name: str, new_name: str='', sink_groups: Union[str, List[str]]=None)
```

修改已有沉降工况的名称和所属沉降组。

#### 参数

>     name (str): 当前沉降工况名，必须已存在。
>     new_name (str): 新的**沉降工况名**；空字符串表示保持 ``name``。
>     sink_groups (str | list[str]): 修改后的完整沉降组名称集合，并非增量
>         添加；各沉降组必须已存在。``None`` 时 C# 端直接不执行修改。

#### 示例

```python
from qtmodel import mdb
    mdb.update_sink_case(name="沉降工况1",sink_groups=["沉降1","沉降2"])
```

#### 返回

>     str: 服务端成功信息。C# 端会重新创建工况数据并仍固定采用
>     ``nMin=1``、``nMax=1``、``adjustedFactor=1``。

### `mdb.remove_sink_group`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.remove_sink_group`

```python
mdb.remove_sink_group(name: str='')
```

按照名称删除沉降组

#### 参数

>      name:沉降组名,默认删除所有沉降组

#### 示例

```python
from qtmodel import mdb
    mdb.remove_sink_group()
    mdb.remove_sink_group(name="沉降1")
Returns: 无
```

### `mdb.remove_sink_case`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.remove_sink_case`

```python
mdb.remove_sink_case(name='')
```

按照名称删除沉降工况,不输入名称时默认删除所有沉降工况

#### 参数

>     name:沉降工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_sink_case()
    mdb.remove_sink_case(name="沉降1")
Returns: 无
```

### `mdb.remove_concurrent_reaction`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.remove_concurrent_reaction`

```python
mdb.remove_concurrent_reaction()
```

清空沉降分析的全部并发反力结构组设置。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.remove_concurrent_reaction()
```

#### 返回

>     str: 服务端成功信息；不会删除结构组本身或沉降工况。

### `mdb.remove_concurrent_force`

源码：`qtmodel/mdb/mdb_sink_load.py` · `MdbSinkLoad.remove_concurrent_force`

```python
mdb.remove_concurrent_force()
```

清空沉降分析的全部并发内力结构组设置。

#### 参数

>     无。

#### 示例

```python
from qtmodel import mdb
    mdb.remove_concurrent_force()
```

#### 返回

>     str: 服务端成功信息；不会删除结构组本身或沉降工况。

## `mdb_static_load`

### `mdb.add_nodal_force`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_nodal_force`

```python
mdb.add_nodal_force(node_id, case_name: str='', load_info: list[float]=None, group_name: str='默认荷载组', index: int=-1)
```

添加节点荷载

#### 参数

>     node_id:节点编号且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     load_info:荷载信息列表 [Fx,Fy,Fz,Mx,My,Mz]
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_nodal_force(node_id=1,case_name="荷载工况1",load_info=[1,1,1,1,1,1],group_name="默认结构组")
    mdb.add_nodal_force(node_id="1to100",case_name="荷载工况1",load_info=[1,1,1,1,1,1],group_name="默认结构组")
Returns: 无
```

### `mdb.update_nodal_force`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.update_nodal_force`

```python
mdb.update_nodal_force(index: int, case_name: str, load_info: list[float], group_name: str='默认荷载组')
```

按工况和编号原位修改节点力；节点与工况不可变。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_nodal_force(index=..., case_name=..., load_info=...)
```

### `mdb.add_node_displacement`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_node_displacement`

```python
mdb.add_node_displacement(node_id, case_name: str='', load_info: Union[tuple[float, float, float, float, float, float], List[float]]=None, group_name: str='默认荷载组', index: int=-1)
```

添加节点位移

#### 参数

>     node_id:节点编号,支持整型或整数型列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     load_info:节点位移列表 [Dx,Dy,Dz,Rx,Ry,Rz]
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_node_displacement(case_name="荷载工况1",node_id=1,load_info=(1,0,0,0,0,0),group_name="默认荷载组")
    mdb.add_node_displacement(case_name="荷载工况1",node_id=[1,2,3],load_info=(1,0,0,0,0,0),group_name="默认荷载组")
Returns: 无
```

### `mdb.update_node_displacement`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.update_node_displacement`

```python
mdb.update_node_displacement(index: int, case_name: str, load_info: Union[tuple[float, float, float, float, float, float], List[float]], group_name: str='默认荷载组')
```

按工况和编号原位修改节点强制位移；节点与工况不可变。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_node_displacement(index=..., case_name=..., load_info=...)
```

### `mdb.add_beam_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_beam_element_load`

```python
mdb.add_beam_element_load(element_id, case_name: str='', load_type: int=1, coord_system: int=3, is_abs=False, list_x: Union[float, List[float]]=None, list_load: Union[float, List[float]]=None, group_name='默认荷载组', load_bias: tuple[bool, int, int, float]=(False, 1, 1, 0.1), projected: bool=False, index: int=-1)
```

添加梁单元荷载

#### 参数

>     element_id:单元编号,支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     load_type:荷载类型 (1-集中力 2-集中弯矩 3-分布力 4-分布弯矩)
>     coord_system:坐标系 (1-整体X  2-整体Y 3-整体Z  4-局部X  5-局部Y  6-局部Z)
>     is_abs: 荷载位置输入方式，True-绝对值   False-相对值
>     list_x:荷载位置信息 ,荷载距离单元I端的距离，可输入绝对距离或相对距离
>     list_load:荷载数值信息
>     group_name:荷载组名
>     load_bias:偏心荷载 (是否偏心,0-中心 1-偏心,偏心坐标系-int,偏心距离)
>     projected:荷载是否投影

#### 示例

```python
from qtmodel import mdb
    mdb.add_beam_element_load(element_id=1,case_name="荷载工况1",load_type=1,list_x=0.5,list_load=100)
    mdb.add_beam_element_load(element_id="1to100",case_name="荷载工况1",load_type=3,list_x=[0.4,0.8],list_load=[100,200])
Returns: 无
```

### `mdb.update_beam_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.update_beam_element_load`

```python
mdb.update_beam_element_load(index: int, case_name: str, source_load_type: int, load_type: int, coord_system: int, list_x: Union[float, List[float]], list_load: Union[float, List[float]], group_name: str='默认荷载组', load_bias: tuple[bool, int, int, float]=(False, 0, 1, 0.0), projected: bool=False)
```

原位修改一个梁/杆/索单元荷载；位置始终采用0..1相对距离。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_beam_element_load(index=..., case_name=..., source_load_type=..., load_type=..., coord_system=..., list_x=..., list_load=...)
```

### `mdb.add_initial_tension_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_initial_tension_load`

```python
mdb.add_initial_tension_load(element_id, case_name: str='', group_name: str='默认荷载组', tension: float=0, tension_type: int=1, application_type: int=1, stiffness: float=0)
```

添加初始拉力

#### 参数

>      element_id:单元编号支持数或列表且支持XtoYbyN形式字符串
>      case_name:荷载工况名
>      tension:初始拉力
>      tension_type:张拉类型  0-增量 1-全量
>      group_name:荷载组名
>      application_type:计算方式 1-体外力 2-体内力 3-转为索长张拉
>      stiffness:索刚度参与系数

#### 示例

```python
from qtmodel import mdb
    mdb.add_initial_tension_load(element_id=1,case_name="工况1",tension=100,tension_type=1)
Returns: 无
```

### `mdb.add_cable_length_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_cable_length_load`

```python
mdb.add_cable_length_load(element_id, case_name: str='', group_name: str='默认荷载组', length: float=0, tension_type: int=1)
```

添加索长张拉

#### 参数

>     element_id:单元编号支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     length:长度
>     tension_type:张拉类型  0-增量 1-全量
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_cable_length_load(element_id=1,case_name="工况1",length=1,tension_type=1)
Returns: 无
```

### `mdb.add_plate_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_plate_element_load`

```python
mdb.add_plate_element_load(element_id, case_name: str='', load_type: int=1, load_place: int=1, coord_system: int=3, group_name: str='默认荷载组', list_load: Union[float, List[float]]=None, list_xy: tuple[float, float]=None, index: int=-1)
```

添加版单元荷载

#### 参数

>      element_id:单元编号支持数或列表
>      case_name:荷载工况名
>      load_type:荷载类型 (1-集中力  2-集中弯矩  3-分布力  4-分布弯矩)
>      load_place:荷载位置 (0-面IJKL 1-边IJ  2-边JK  3-边KL  4-边LI ) (仅分布荷载需要)
>      coord_system:坐标系  (1-整体X  2-整体Y 3-整体Z  4-局部X  5-局部Y  6-局部Z)
>      group_name:荷载组名
>      list_load:荷载列表
>      list_xy:荷载位置信息 [IJ方向绝对距离x,IL方向绝对距离y]  (仅集中荷载需要)

#### 示例

```python
from qtmodel import mdb
    mdb.add_plate_element_load(element_id=1,case_name="工况1",load_type=1,group_name="默认荷载组",list_load=[1000],list_xy=(0.2,0.5))
Returns: 无
```

### `mdb.update_plate_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.update_plate_element_load`

```python
mdb.update_plate_element_load(index: int, case_name: str, source_load_type: int, load_type: int, load_place: int, coord_system: int, group_name: str, list_load: Union[float, List[float]], list_xy: tuple[float, float]=None)
```

原位修改一个板集中、线分布或面分布荷载；不能跨荷载族变更。

#### 示例

```python
from qtmodel import mdb
result = mdb.update_plate_element_load(index=..., case_name=..., source_load_type=..., load_type=..., load_place=..., coord_system=..., group_name=..., list_load=...)
```

### `mdb.add_distribute_plane_load_type`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_distribute_plane_load_type`

```python
mdb.add_distribute_plane_load_type(name: str, load_type: int, point_list: list[list[float]], load: float=0, copy_x: str=None, copy_y: str=None, describe: str='')
```

添加分配面荷载类型

#### 参数

>     name:荷载类型名称
>     load_type:荷载类型  1-集中荷载 2-线荷载 3-面荷载
>     point_list:点列表，集中力时为列表内元素为 [x,y,force] 线荷载与面荷载时为 [x,y]
>     load:荷载值,仅线荷载与面荷载需要
>     copy_x:复制到x轴距离，与UI一致，支持3@2形式字符串，逗号分隔
>     copy_y:复制到y轴距离，与UI一致，支持3@2形式字符串，逗号分隔
>     describe:描述

#### 示例

```python
from qtmodel import mdb
    mdb.add_distribute_plane_load_type(name="荷载类型1",load_type=1,point_list=[[1,0,10],[1,1,10],[1,2,10]])
    mdb.add_distribute_plane_load_type(name="荷载类型2",load_type=2,point_list=[[1,0],[1,1]],load=10)
Returns: 无
```

### `mdb.add_distribute_plane_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.add_distribute_plane_load`

```python
mdb.add_distribute_plane_load(index: int=-1, case_name: str='', type_name: str='', point1: Union[tuple[float, float, float], list[float]]=None, point2: Union[tuple[float, float, float], list[float]]=None, point3: Union[tuple[float, float, float], list[float]]=None, plate_ids: list[int]=None, coord_system: int=3, group_name: str='默认荷载组')
```

添加分配面荷载类型

#### 参数

>     index:荷载编号,默认自动识别
>     case_name:工况名
>     type_name:荷载类型名称
>     point1:第一点(原点)
>     point2:第一点(在x轴上)
>     point3:第一点(在y轴上)
>     plate_ids:指定板单元。默认时为全部板单元
>     coord_system:描述
>     group_name:描述

#### 示例

```python
from qtmodel import mdb
    mdb.add_distribute_plane_load(index=1,case_name="工况1",type_name="荷载类型1",point1=(0,0,0),
        point2=(1,0,0),point3=(0,1,0),group_name="默认荷载组")
Returns: 无
```

### `mdb.update_distribute_plane_load_type`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.update_distribute_plane_load_type`

```python
mdb.update_distribute_plane_load_type(name: str='', new_name: str='', load_type: int=1, point_list: list[list[float]]=None, load: float=0, copy_x: str=None, copy_y: str=None, describe: str='')
```

更新板单元面荷载类型

#### 参数

>     name:荷载类型名称
>     new_name:新名称，默认不修改名称
>     load_type:荷载类型  1-集中荷载 2-线荷载 3-面荷载
>     point_list:点列表，集中力时为列表内元素为 [x,y,force] 线荷载与面荷载时为 [x,y]
>     load:荷载值,仅线荷载与面荷载需要
>     copy_x:复制到x轴距离，与UI一致，支持3@2形式字符串，逗号分隔
>     copy_y:复制到y轴距离，与UI一致，支持3@2形式字符串，逗号分隔
>     describe:描述

#### 示例

```python
from qtmodel import mdb
    mdb.update_distribute_plane_load_type(name="荷载类型1",load_type=1,point_list=[[1,0,10],[1,1,10],[1,2,10]])
    mdb.update_distribute_plane_load_type(name="荷载类型2",load_type=2,point_list=[[1,0],[1,1]],load=10)
Returns: 无
```

### `mdb.remove_nodal_force`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_nodal_force`

```python
mdb.remove_nodal_force(node_id, case_name: str='', group_name='默认荷载组')
```

删除节点荷载

#### 参数

>      node_id:节点编号且支持XtoYbyN形式字符串
>      case_name:荷载工况名
>      group_name:指定荷载组

#### 示例

```python
from qtmodel import mdb
    mdb.remove_nodal_force(case_name="荷载工况1",node_id=1,group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_nodal_displacement`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_nodal_displacement`

```python
mdb.remove_nodal_displacement(node_id, case_name: str='', group_name='默认荷载组')
```

删除节点位移荷载

#### 参数

>     node_id:节点编号,支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     group_name:指定荷载组

#### 示例

```python
from qtmodel import mdb
    mdb.remove_nodal_displacement(case_name="荷载工况1",node_id=1,group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_initial_tension_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_initial_tension_load`

```python
mdb.remove_initial_tension_load(element_id, case_name: str, group_name: str='默认荷载组')
```

删除初始拉力

#### 参数

>     element_id:单元编号支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_initial_tension_load(element_id=1,case_name="工况1",group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_beam_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_beam_element_load`

```python
mdb.remove_beam_element_load(element_id, case_name: str='', load_type: int=1, group_name='默认荷载组')
```

删除梁单元荷载

#### 参数

>     element_id:单元号支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     load_type:荷载类型 (1-集中力   2-集中弯矩  3-分布力   4-分布弯矩)
>     group_name:荷载组名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_beam_element_load(case_name="工况1",element_id=1,load_type=1,group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_plate_element_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_plate_element_load`

```python
mdb.remove_plate_element_load(element_id, case_name: str, load_type: int, group_name='默认荷载组')
```

删除指定荷载工况下指定单元的板单元荷载

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     load_type: 板单元类型 1集中力   2-集中弯矩  3-分布线力  4-分布线弯矩  5-分布面力  6-分布面弯矩
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_plate_element_load(case_name="工况1",element_id=1,load_type=1,group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_cable_length_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_cable_length_load`

```python
mdb.remove_cable_length_load(element_id, case_name: str, group_name: str='默认荷载组')
```

删除索长张拉

#### 参数

>     element_id:单元号支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_cable_length_load(case_name="工况1",element_id=1, group_name= "默认荷载组")
Returns: 无
```

### `mdb.remove_distribute_plane_load`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_distribute_plane_load`

```python
mdb.remove_distribute_plane_load(index: int=-1)
```

根据荷载编号删除分配面荷载

#### 参数

>     index: 指定荷载编号，默认则删除所有分配面荷载

#### 示例

```python
from qtmodel import mdb
    mdb.remove_distribute_plane_load()
    mdb.remove_distribute_plane_load(index=1)
Returns: 无
```

### `mdb.remove_distribute_plane_load_type`

源码：`qtmodel/mdb/mdb_static_load.py` · `MdbStaticLoad.remove_distribute_plane_load_type`

```python
mdb.remove_distribute_plane_load_type(name: str=-1)
```

删除分配面荷载类型

#### 参数

>     name: 指定荷载类型，默认则删除所有分配面荷载

#### 示例

```python
from qtmodel import mdb
    mdb.remove_distribute_plane_load_type("类型1")
Returns: 无
```

## `mdb_structure`

### `mdb.generate_curve_node_data`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.generate_curve_node_data`

```python
mdb.generate_curve_node_data(fixed_y=8.4, start_node_id=1, mirror=True, count=48, curve_points=None, span_list=None)
```

生成曲线节点数据 [[id, x, y, z], ...]

#### 参数

>     fixed_y:
>         固定 y 坐标。
>     start_node_id:
>         起始节点号。
>     mirror:
>         是否镜像生成另一半。
>     count:
>         半边总单元数量。
>         例如 count=48，则半边生成 49 个节点。
>     curve_points:
>         曲线控制点列表 [(x, z), ...]。
>         函数会根据这些点线性插值得到 z。
>     span_list:
>         分跨位置列表，表示半边曲线内部的分跨 x 坐标。
>         span_list=[36.0] 表示分成 2 段。
>         span_list=[24.0, 48.0] 表示分成 3 段。
>         span_list=None 或 [] 表示不分跨，整段直接分 count 个单元。

#### 示例

```python
from qtmodel import mdb
    mdb.generate_curve_node_data(fixed_y=4,curve_points=[(1,1),(2.5,3),(3.5,4)],count=4)
```

#### 返回

>     node_data: [[id, x, y, z], ...]

### `mdb.add_node`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_node`

```python
mdb.add_node(node_data: list[float], intersected: bool=False, is_merged: bool=False, merge_error: float=0.001, numbering_type: int=0, start_id: int=1)
```

根据坐标信息添加单个节点，可指定节点编号，也可不指定节点编号。

#### 参数

>     node_data:
>         [id, x, y, z]：指定节点编号；
>         [x, y, z]：不指定节点编号。
>         指定节点编号时，不进行交叉分割、合并、自动编号等操作。
>     intersected: 是否交叉分割。
>     is_merged: 是否忽略位置重复节点。
>     merge_error: 合并容许误差。
>     numbering_type:
>         节点编号方式：
>         0 - 未使用的最小号码；
>         1 - 最大号码加 1；
>         2 - 用户定义号码。
>     start_id: 自定义节点起始编号，仅 numbering_type=2 时使用。

#### 示例

```python
from qtmodel import mdb
    mdb.add_node(node_data=[1, 1.0, 2.0, 3.0])
    mdb.add_node(node_data=[1.0, 2.0, 3.0])
```

#### 返回

>     无

### `mdb.add_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_nodes`

```python
mdb.add_nodes(node_data: list[list[float]], intersected: bool=False, is_merged: bool=False, merge_error: float=0.001, numbering_type: int=0, start_id: int=1)
```

根据坐标信息和节点编号添加一组节点，可指定节点号，或不指定节点号

#### 参数

>      node_data: [[id,x,y,z]...]  或[[x,y,z]...]  指定节点编号时不进行交叉分割、合并、编号等操作
>      intersected: 是否交叉分割
>      is_merged: 是否忽略位置重复节点
>      merge_error: 合并容许误差
>      numbering_type:编号方式 0-未使用的最小号码 1-最大号码加1 2-用户定义号码
>      start_id:自定义节点起始编号(用户定义号码时使用)

#### 示例

```python
from qtmodel import mdb
    mdb.add_nodes(node_data=[[1,1,2,3],[2,1,2,3]])
Returns: 无
```

### `mdb.update_node`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_node`

```python
mdb.update_node(node_id: int, new_id: int=-1, x: float=1, y: float=1, z: float=1)
```

根据节点号修改节点坐标

#### 参数

>      node_id: 旧节点编号
>      new_id: 新节点编号,默认为-1时不改变节点编号
>      x: 更新后x坐标
>      y: 更新后y坐标
>      z: 更新后z坐标

#### 示例

```python
from qtmodel import mdb
    mdb.update_node(node_id=1,new_id=2,x=2,y=2,z=2)
Returns: 无
```

### `mdb.update_node_id`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_node_id`

```python
mdb.update_node_id(node_id: int, new_id: int)
```

修改节点Id

#### 参数

>      node_id: 节点编号
>      new_id: 新节点编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_node_id(node_id=1,new_id=2)
Returns: 无
```

### `mdb.merge_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.merge_nodes`

```python
mdb.merge_nodes(ids=None, tolerance: float=0.0001)
```

根据坐标信息和节点编号添加节点，默认自动识别编号

#### 参数

>      ids: 合并节点集合,默认全部节点,支持列表和XtoYbyN形式字符串
>      tolerance: 合并容许误差

#### 示例

```python
from qtmodel import mdb
    mdb.merge_nodes()
Returns: 无
```

### `mdb.move_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.move_nodes`

```python
mdb.move_nodes(ids=None, offset_x: float=0, offset_y: float=0, offset_z: float=0)
```

移动节点坐标，默认移动所有节点

#### 参数

>     ids:节点号
>     offset_x:X轴偏移量
>     offset_y:Y轴偏移量
>     offset_z:Z轴偏移量

#### 示例

```python
from qtmodel import mdb
    mdb.move_nodes(ids=1,offset_x=1.5,offset_y=1.5,offset_z=1.5)
Returns: 无
```

### `mdb.translate_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.translate_nodes`

```python
mdb.translate_nodes(node_ids, dx: float, dy: float, dz: float)
```

严格平移一组明确节点，供受控语义事务使用。

与兼容接口 ``move_nodes`` 不同，本接口不允许省略节点编号，也不会把空数组
解释为全部节点。桥通会在一次原生复合命令中移动全部节点，并禁止自动分割单元。

#### 示例

```python
from qtmodel import mdb
result = mdb.translate_nodes(node_ids=..., dx=..., dy=..., dz=...)
```

### `mdb.remove_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.remove_nodes`

```python
mdb.remove_nodes(ids=None)
```

删除指定节点,默认删除所有节点

#### 参数

>     ids:节点编号,支持多种类型

#### 示例

```python
from qtmodel import mdb
    mdb.remove_nodes()
    mdb.remove_nodes(ids=1)
    mdb.remove_nodes(ids=[1,2,3])
Returns: 无
```

### `mdb.renumber_nodes`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.renumber_nodes`

```python
mdb.renumber_nodes(ids: Optional[list[int]]=None, new_ids: Optional[list[int]]=None)
```

节点编号重排序，默认按1升序重排所有节点

#### 参数

>     ids:原修改节点号
>     new_ids:新节点号

#### 示例

```python
from qtmodel import mdb
    mdb.renumber_nodes()
    mdb.renumber_nodes([7,9,22],[1,2,3])
Returns: 无
```

### `mdb.add_element`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_element`

```python
mdb.add_element(index: int=1, ele_type: int=1, node_ids: list[int]=None, beta_angle: float=0, mat_id: int=-1, sec_id: int=-1, initial_type: int=1, initial_value: float=0, plate_type: int=0)
```

根据单元编号和单元类型添加单元

#### 参数

>     index:单元编号
>     ele_type:单元类型 1-梁 2-杆 3-索 4-板
>     node_ids:单元对应的节点列表 [i,j] 或 [i,j,k,l]
>     beta_angle:贝塔角
>     mat_id:材料编号
>     sec_id:截面编号或者板厚
>     initial_type:索单元初始参数类型 1-初始拉力 2-初始水平力 3-无应力长度
>     initial_value:索单元初始始参数值
>     plate_type:板单元类型  0-薄板 1-厚板

#### 示例

```python
from qtmodel import mdb
    mdb.add_element(index=1,ele_type=1,node_ids=[1,2],beta_angle=1,mat_id=1,sec_id=1)
Returns: 无
```

### `mdb.add_elements`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_elements`

```python
mdb.add_elements(ele_data: list[list[float]]=None)
```

根据单元编号和单元类型添加单元

#### 参数

>     ele_data:单元信息
>         [编号,类型(1-梁 2-杆),materialId,sectionId,betaAngle,nodeI,nodeJ]
>         [编号,类型(3-索),materialId,sectionId,betaAngle,nodeI,nodeJ,张拉类型(1-初拉力 2-初始水平力 3-无应力长度),张拉值]
>         [编号,类型(4-板),materialId,thicknessId,betaAngle,nodeI,nodeJ,nodeK,nodeL,plate_type(0-薄板 1-厚板)]

#### 示例

```python
from qtmodel import mdb
    mdb.add_elements(ele_data=[
        [1,1,1,1,0,1,2],
        [2,2,1,1,0,1,2],
        [3,3,1,1,0,1,2,1,100],
        [4,4,1,1,0,1,2,3,4,0]])
Returns: 无
```

### `mdb.add_beam_between`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_beam_between`

```python
mdb.add_beam_between(start_id: int, end_id: int, node_start: int, node_end: int, beta_angle: float=0, mat_id: int=1, sec_id: int=1, gap: Optional[list[float]]=None, using_exist_node: bool=True)
```

根据起始节点和终止节点平均添加或按间距添加梁单元。

#### 参数

>     start_id: 新建单元起始编号
>     end_id: 新建单元终止编号
>     node_start: 起始节点号
>     node_end: 终止节点号
>     beta_angle: beta角，默认0
>     mat_id: 材料号，默认1
>     sec_id: 截面号，默认1
>     gap: 间距列表；数量等于 end_id - start_id + 1 时按间距创建，否则C#侧按等分创建
>     using_exist_node: 是否优先使用已有重合节点，默认True

#### 示例

```python
from qtmodel import mdb
    mdb.add_beam_between(start_id=1001,end_id=1010,
        node_start=1,node_end=20,beta_angle=0,mat_id=1,
        sec_id=1,gap=[2.0] * 10,using_exist_node=True)
Returns: 无
```

### `mdb.revert_local_orientation`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.revert_local_orientation`

```python
mdb.revert_local_orientation(ids=None)
```

反转杆系单元局部方向

#### 参数

>     ids: 杆系单元编号,支持整形、列表、XtoYbyZ形式字符串

#### 示例

```python
from qtmodel import mdb
    mdb.revert_local_orientation(1)
Returns: 无
```

### `mdb.update_element_id`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element_id`

```python
mdb.update_element_id(old_id: int, new_id: int)
```

更改单元编号

#### 参数

>     old_id: 单元编号
>     new_id: 新单元编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_element_id(1,2)
Returns: 无
```

### `mdb.update_element`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element`

```python
mdb.update_element(old_id: int, new_id: int=-1, ele_type: int=1, node_ids: list[int]=None, beta_angle: float=0, mat_id: int=-1, sec_id: int=-1, initial_type: int=1, initial_value: float=0, plate_type: int=0)
```

根据单元编号和单元类型添加单元

#### 参数

>     old_id:原单元编号
>     new_id:现单元编号，默认不修改原单元Id
>     ele_type:单元类型 1-梁 2-杆 3-索 4-板
>     node_ids:单元对应的节点列表 [i,j] 或 [i,j,k,l]
>     beta_angle:贝塔角
>     mat_id:材料编号
>     sec_id:截面编号
>     initial_type:索单元初始参数类型 1-初始拉力 2-初始水平力 3-无应力长度
>     initial_value:索单元初始始参数值
>     plate_type:板单元类型  0-薄板 1-厚板

#### 示例

```python
from qtmodel import mdb
    mdb.update_element(old_id=1,ele_type=1,node_ids=[1,2],beta_angle=1,mat_id=1,sec_id=1)
Returns: 无
```

### `mdb.update_frame_type`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_frame_type`

```python
mdb.update_frame_type(element_ids: list[int], element_type: int, initial_type: int=1, initial_value: float=0)
```

修改杆系单元类型

#### 参数

>     element_ids: 需要修改的单元编号列表
>     element_type: 单元类型 1-梁 2-杆 3-索
>     initial_type: 索单元初始参数类型 1-初始拉力 2-初始水平力 3-无应力长度
>     initial_value: 索单元初始参数值

#### 示例

```python
from qtmodel import mdb
    mdb.update_frame_type(element_ids=[1, 2, 3], element_type=1)
    mdb.update_frame_type(element_ids=[101, 102], element_type=3, initial_type=1, initial_value=100)
```

#### 返回

>     无

### `mdb.update_element_material`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element_material`

```python
mdb.update_element_material(ids=None, mat_id: int=1)
```

更新指定单元的材料号

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     mat_id: 材料编号

#### 示例

```python
from qtmodel import mdb
    mdb.update_element_material(ids=1,mat_id=2)
Returns: 无
```

### `mdb.update_element_beta`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element_beta`

```python
mdb.update_element_beta(ids=None, beta: float=0)
```

更新指定单元的贝塔角

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     beta: 贝塔角度数

#### 示例

```python
from qtmodel import mdb
    mdb.update_element_beta(ids=1,beta=90)
Returns: 无
```

### `mdb.update_element_section`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element_section`

```python
mdb.update_element_section(ids, sec_id: int=1)
```

更新杆系单元截面或板单元板厚

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     sec_id: 截面号或板厚号

#### 示例

```python
from qtmodel import mdb
    mdb.update_element_section(ids=1,sec_id=2)
Returns: 无
```

### `mdb.update_frame_section`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_frame_section`

```python
mdb.update_frame_section(ids, sec_id: int=1)
```

更新杆系单元截面

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     sec_id: 截面号

#### 示例

```python
from qtmodel import mdb
    mdb.update_frame_section(ids=1,sec_id=2)
Returns: 无
```

### `mdb.update_plate_thick`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_plate_thick`

```python
mdb.update_plate_thick(ids, thick_id: int=1)
```

更新板单元截面

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     thick_id: 板厚号

#### 示例

```python
from qtmodel import mdb
    mdb.update_plate_thick(ids=1,thick_id=2)
Returns: 无
```

### `mdb.update_element_node`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_element_node`

```python
mdb.update_element_node(element_id: int, node_ids: list[int])
```

更新单元节点

#### 参数

>     element_id: 单元编号
>     node_ids: 杆系单元时为[i,j] 板单元[i,j,k,l]

#### 示例

```python
from qtmodel import mdb
    mdb.update_element_node(1,[1,2])
    mdb.update_element_node(2,[1,2,3,4])
Returns: 无
```

### `mdb.remove_elements`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.remove_elements`

```python
mdb.remove_elements(ids=None, remove_free: bool=False)
```

删除指定编号的单元,默认则删除所有单元

#### 参数

>     ids: 单元编号,支持整形、列表、XtoYbyZ形式字符串
>     remove_free: 是否删除自由节点

#### 示例

```python
from qtmodel import mdb
    mdb.remove_elements()
    mdb.remove_elements(ids=1)
Returns: 无
```

### `mdb.renumber_elements`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.renumber_elements`

```python
mdb.renumber_elements(element_ids: Optional[list[int]]=None, new_ids: Optional[list[int]]=None)
```

单元编号重排序，默认按1升序重排所有节点

#### 参数

>     element_ids:被修改单元号
>     new_ids:新单元号

#### 示例

```python
from qtmodel import mdb
    mdb.renumber_elements()
    mdb.renumber_elements([7,9,22],[1,2,3])
Returns: 无
```

### `mdb.add_structure_group`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_structure_group`

```python
mdb.add_structure_group(name: str='', node_ids=None, element_ids=None)
```

添加结构组

#### 参数

>     name: 结构组名
>     node_ids: 节点编号列表,支持XtoYbyN类型字符串(可选参数)
>     element_ids: 单元编号列表,支持XtoYbyN类型字符串(可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_structure_group(name="新建结构组1")
    mdb.add_structure_group(name="新建结构组2",node_ids=[1,2,3,4],element_ids=[1,2])
    mdb.add_structure_group(name="新建结构组2",node_ids="1to10 11to21by2",element_ids=[1,2])
Returns: 无
```

### `mdb.update_structure_group_name`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_structure_group_name`

```python
mdb.update_structure_group_name(name: str='', new_name: str='')
```

更新结构组名

#### 参数

>     name: 结构组名
>     new_name: 新结构组名(可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.update_structure_group_name(name="结构组1",new_name="新结构组")
Returns: 无
```

### `mdb.update_structure_group`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.update_structure_group`

```python
mdb.update_structure_group(name: str='', new_name: str='', node_ids=None, element_ids=None)
```

更新结构组信息

#### 参数

>     name: 结构组名
>     new_name: 新结构组名
>     node_ids: 节点编号列表,支持XtoYbyN类型字符串(可选参数)
>     element_ids: 单元编号列表,支持XtoYbyN类型字符串(可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.update_structure_group(name="结构组",new_name="新建结构组",node_ids=[1,2,3,4],element_ids=[1,2])
Returns: 无
```

### `mdb.remove_structure_group`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.remove_structure_group`

```python
mdb.remove_structure_group(name: str='')
```

可根据结构与组名删除结构组，当组名为默认则删除所有结构组

#### 参数

>     name:结构组名称

#### 示例

```python
from qtmodel import mdb
    mdb.remove_structure_group(name="新建结构组1")
    mdb.remove_structure_group()
Returns: 无
```

### `mdb.add_structure_to_group`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.add_structure_to_group`

```python
mdb.add_structure_to_group(name: str='', node_ids=None, element_ids=None)
```

为结构组添加节点和/或单元

#### 参数

>     name: 结构组名
>     node_ids: 节点编号列表(可选参数)
>     element_ids: 单元编号列表(可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.add_structure_to_group(name="现有结构组1",node_ids=[1,2,3,4],element_ids=[1,2])
Returns: 无
```

### `mdb.remove_structure_from_group`

源码：`qtmodel/mdb/mdb_structure.py` · `MdbStructure.remove_structure_from_group`

```python
mdb.remove_structure_from_group(name: str='', node_ids=None, element_ids=None)
```

为结构组删除节点、单元

#### 参数

>     name: 结构组名
>     node_ids: 节点编号列表(可选参数)
>     element_ids: 单元编号列表(可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.remove_structure_from_group(name="现有结构组1",node_ids=[1,2,3,4],element_ids=[1,2])
Returns: 无
```

## `mdb_temperature_load`

### `mdb.add_custom_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_custom_temperature`

```python
mdb.add_custom_temperature(element_id, case_name: str='', group_name: str='默认荷载组', orientation: int=1, temperature_data: List[tuple[int, float, float]]=None)
```

添加梁自定义温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     group_name:指定荷载组,后续升级开放指定荷载组删除功能
>     orientation: 1-局部坐标z 2-局部坐标y
>     temperature_data:自定义数据[(参考位置1-顶 2-底,高度,温度)...]

#### 示例

```python
from qtmodel import mdb
    mdb.add_custom_temperature(case_name="荷载工况1",element_id=1,orientation=1,temperature_data=[(1,1,20),(1,2,10)])
Returns: 无
```

### `mdb.add_element_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_element_temperature`

```python
mdb.add_element_temperature(element_id, case_name: str='', temperature: float=1, group_name: str='默认荷载组')
```

添加单元温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     temperature:最终温度
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_element_temperature(element_id=1,case_name="自重",temperature=1,group_name="默认荷载组")
Returns: 无
```

### `mdb.add_system_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_system_temperature`

```python
mdb.add_system_temperature(case_name: str='', temperature: float=1, group_name: str='默认荷载组')
```

添加系统温度

#### 参数

>     case_name:荷载工况名
>     temperature:最终温度
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_system_temperature(case_name="荷载工况",temperature=20,group_name="默认荷载组")
Returns: 无
```

### `mdb.add_gradient_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_gradient_temperature`

```python
mdb.add_gradient_temperature(element_id, case_name: str='', temperature: float=1, section_oriental: int=1, element_type: int=1, group_name: str='默认荷载组')
```

添加梯度温度
    element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
    case_name:荷载工况名
    temperature:温差
    section_oriental:截面方向,默认截面Y向 (仅梁单元需要, 0-截面Y向  1-截面Z向)
    element_type:单元类型,默认为梁单元 (1-梁单元  2-板单元)
    group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_gradient_temperature(element_id=1,case_name="荷载工况1",group_name="荷载组名1",temperature=10)
    mdb.add_gradient_temperature(element_id=2,case_name="荷载工况2",group_name="荷载组名2",temperature=10,element_type=2)
Returns: 无
```

### `mdb.add_beam_section_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_beam_section_temperature`

```python
mdb.add_beam_section_temperature(element_id, case_name: str='', code_index: int=1, sec_type: int=1, t1: float=0, t2: float=0, t3: float=0, t4: float=0, thick: float=0, group_name: str='默认荷载组')
```

添加梁截面温度

#### 参数

>     element_id:单元编号，支持整数或整数型列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     code_index:规范编号  (1-公路规范2015  2-美规2017)
>     sec_type:截面类型(1-混凝土 2-组合梁)
>     t1:温度1
>     t2:温度2
>     t3:温度3
>     t4:温度4
>     thick:厚度
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_beam_section_temperature(element_id=1,case_name="工况1",code_index=1,sec_type=1,t1=-4.2,t2=-1)
Returns: 无
```

### `mdb.add_index_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_index_temperature`

```python
mdb.add_index_temperature(element_id, case_name: str='', temperature: float=0, index: float=1, group_name: str='默认荷载组')
```

添加指数温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     temperature:温差
>     index:指数
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_index_temperature(element_id=1,case_name="工况1",temperature=20,index=2)
Returns: 无
```

### `mdb.add_top_plate_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_top_plate_temperature`

```python
mdb.add_top_plate_temperature(element_id, case_name: str='', temperature: float=0, group_name: str='默认荷载组')
```

添加顶板温度

#### 参数

>      element_id:单元编号
>      case_name:荷载
>      temperature:温差，最终温度于初始温度之差
>      group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_top_plate_temperature(element_id=1,case_name="工况1",temperature=40,group_name="默认荷载组")
Returns: 无
```

### `mdb.remove_element_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_element_temperature`

```python
mdb.remove_element_temperature(element_id, case_name: str)
```

删除指定单元温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_element_temperature(case_name="荷载工况1",element_id=1)
Returns: 无
```

### `mdb.remove_top_plate_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_top_plate_temperature`

```python
mdb.remove_top_plate_temperature(element_id, case_name: str)
```

删除梁单元顶板温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_top_plate_temperature(case_name="荷载工况1",element_id=1)
Returns: 无
```

### `mdb.remove_beam_section_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_beam_section_temperature`

```python
mdb.remove_beam_section_temperature(element_id, case_name: str)
```

删除指定梁或板单元梁截面温度

#### 参数

>     case_name:荷载工况名
>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串

#### 示例

```python
from qtmodel import mdb
    mdb.remove_beam_section_temperature(case_name="工况1",element_id=1)
Returns: 无
```

### `mdb.remove_gradient_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_gradient_temperature`

```python
mdb.remove_gradient_temperature(element_id, case_name: str)
```

删除梁或板单元梯度温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_gradient_temperature(case_name="工况1",element_id=1)
Returns: 无
```

### `mdb.remove_custom_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_custom_temperature`

```python
mdb.remove_custom_temperature(element_id, case_name: str)
```

删除梁单元自定义温度

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_custom_temperature(case_name="工况1",element_id=1)
Returns: 无
```

### `mdb.remove_index_temperature`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_index_temperature`

```python
mdb.remove_index_temperature(element_id, case_name: str)
```

删除梁单元指数温度且支持XtoYbyN形式字符串

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名

#### 示例

```python
from qtmodel import mdb
    mdb.remove_index_temperature(case_name="工况1",element_id=1)
Returns: 无
```

### `mdb.add_deviation_parameter`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_deviation_parameter`

```python
mdb.add_deviation_parameter(name: str='', parameters: list[float]=None)
```

添加制造误差

#### 参数

>     name:名称
>     parameters:参数列表
>         _梁杆单元为[轴向,I端X向转角,I端Y向转角,I端Z向转角,J端X向转角,J端Y向转角,J端Z向转角]
>         _板单元为[X向位移,Y向位移,Z向位移,X向转角,Y向转角]

#### 示例

```python
from qtmodel import mdb
    mdb.add_deviation_parameter(name="梁端制造误差",parameters=[1,0,0,0,0,0,0])
    mdb.add_deviation_parameter(name="板端制造误差",parameters=[1,0,0,0,0])
Returns: 无
```

### `mdb.add_deviation_load`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.add_deviation_load`

```python
mdb.add_deviation_load(element_id, case_name: str='', parameters: Union[str, List[str]]=None, group_name: str='默认荷载组')
```

添加制造误差荷载

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     parameters:参数名列表
>         _梁杆单元为制造误差参数名称
>         _板单元为[I端误差名,J端误差名,K端误差名,L端误差名]
>     group_name:荷载组名

#### 示例

```python
from qtmodel import mdb
    mdb.add_deviation_load(element_id=1,case_name="工况1",parameters="梁端误差")
    mdb.add_deviation_load(element_id=2,case_name="工况1",parameters=["板端误差1","板端误差2","板端误差3","板端误差4"])
Returns: 无
```

### `mdb.update_deviation_parameter`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.update_deviation_parameter`

```python
mdb.update_deviation_parameter(name: str='', new_name: str='', element_type: int=1, parameters: list[float]=None)
```

更新制造误差参数

#### 参数

>     name:名称
>     new_name:新名称，默认不修改名称
>     element_type:单元类型  1-梁单元  2-板单元
>     parameters:参数列表
>          _梁杆单元为[轴向,I端X向转角,I端Y向转角,I端Z向转角,J端X向转角,J端Y向转角,J端Z向转角]
>         _板单元为[X向位移,Y向位移,Z向位移,X向转角,Y向转角]

#### 示例

```python
from qtmodel import mdb
    mdb.update_deviation_parameter(name="梁端制造误差",element_type=1,parameters=[1,0,0,0,0,0,0])
    mdb.update_deviation_parameter(name="板端制造误差",element_type=1,parameters=[1,0,0,0,0])
Returns: 无
```

### `mdb.remove_deviation_parameter`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_deviation_parameter`

```python
mdb.remove_deviation_parameter(name: str, para_type: int=1)
```

删除指定制造偏差参数

#### 参数

>     name:制造偏差参数名
>     para_type:制造偏差类型 1-梁单元  2-板单元

#### 示例

```python
from qtmodel import mdb
    mdb.remove_deviation_parameter(name="参数1",para_type=1)
Returns: 无
```

### `mdb.remove_deviation_load`

源码：`qtmodel/mdb/mdb_temperature_load.py` · `MdbTemperatureLoad.remove_deviation_load`

```python
mdb.remove_deviation_load(element_id, case_name: str, group_name: str='默认荷载组')
```

删除指定制造偏差荷载

#### 参数

>     element_id:单元编号，支持数或列表且支持XtoYbyN形式字符串
>     case_name:荷载工况名
>     group_name: 荷载组

#### 示例

```python
from qtmodel import mdb
    mdb.remove_deviation_load(case_name="工况1",element_id=1,group_name="荷载组1")
Returns: 无
```

## `mdb_tendon`

### `mdb.add_tendon_group`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_tendon_group`

```python
mdb.add_tendon_group(name: str='')
```

按照名称添加钢束组，添加时可指定钢束组id

#### 参数

>     name: 钢束组名称

#### 示例

```python
from qtmodel import mdb
    mdb.add_tendon_group(name="钢束组1")
Returns: 无
```

### `mdb.add_tendon_property`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_tendon_property`

```python
mdb.add_tendon_property(name: str='', tendon_type: int=0, material_name: str='', duct_type: int=1, steel_type: int=1, steel_detail: list[float]=None, loos_detail: Optional[Union[list, tuple]]=None, slip_info: Optional[tuple[float, float]]=None)
```

添加钢束特性

#### 参数

>      name:钢束特性名
>      tendon_type: 0-PRE 1-POST 2-体外
>      material_name: 钢材材料所属名称
>      duct_type: 1-金属波纹管  2-塑料波纹管  3-铁皮管  4-钢管  5-抽芯成型
>      steel_type: 1-钢绞线  2-螺纹钢筋
>      steel_detail: 钢束详细信息
>         _钢绞线[钢束面积,孔道直径,摩阻系数,偏差系数]_
>         _螺纹钢筋[钢筋直径,钢束面积,孔道直径,摩阻系数,偏差系数,张拉方式(1-一次张拉 2-超张拉)]_
>      loos_detail: 松弛信息[公规,张拉,松弛]/[铁规，松弛]/[英规,Kp,松弛天数]/[美规,KL] (仅钢绞线需要,默认为[1,1,1])
>         _规范:1-公规 2-铁规_ 3-不考虑松弛 4-英规 5-美规
>         _张拉方式:1-一次张拉 2-超张拉_
>         _松弛类型：1-一般松弛 2-低松弛_
>      slip_info: 滑移信息[始端距离,末端距离] 默认为[0.006, 0.006]

#### 示例

```python
from qtmodel import mdb
    mdb.add_tendon_property(name="钢束1",tendon_type=0,material_name="预应力材料",duct_type=1,steel_type=1,
                            steel_detail=[0.00014,0.10,0.25,0.0015],loos_detail=[1,1,1])
Returns: 无
```

### `mdb.add_tendon_3d`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_tendon_3d`

```python
mdb.add_tendon_3d(name: str, property_name: str='', group_name: str='默认钢束组', num: int=1, line_type: int=1, position_type=1, control_points: Optional[list[tuple[float, float, float, float]]]=None, point_insert: tuple[float, float, float]=None, tendon_direction: Optional[tuple[float, float, float]]=None, rotation_angle: float=0, rotate_bias: tuple[float, float]=None, track_group: str='默认结构组', projection: bool=True)
```

添加三维钢束，支持覆盖添加

#### 参数

>      name:钢束名称
>      property_name:钢束特性名称
>      group_name:默认钢束组
>      num:根数
>      line_type:1-导线点  2-折线点
>      position_type: 定位方式 1-直线  2-轨迹线
>      control_points: 控制点信息[(x1,y1,z1,r1),(x2,y2,z2,r2)....]
>      point_insert: 定位方式 (直线时为插入点坐标[x,y,z]  轨迹线时[插入端(1-I 2-J),插入方向(1-ij 2-ji),插入单元id])
>      tendon_direction:直线钢束X方向向量  默认为x轴即[1,0,0] (轨迹线不用赋值)
>      rotation_angle:绕钢束旋转角度
>      rotate_bias:绕钢束旋转偏心X、Y
>      track_group:轨迹线结构组名  (直线时不用赋值)
>      projection:直线钢束投影 (默认为true)

#### 示例

```python
from qtmodel import mdb
    mdb.add_tendon_3d("BB1",property_name="22-15",num=2,position_type=1,
            control_points=[(0,0,-1,0),(10,0,-1,0)],point_insert=(0,0,0))
    mdb.add_tendon_3d("BB1",property_name="22-15",num=2,position_type=2,
            control_points=[(0,0,-1,0),(10,0,-1,0)],point_insert=(1,1,1),track_group="轨迹线结构组1")
Returns: 无
```

### `mdb.add_tendon_2d`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_tendon_2d`

```python
mdb.add_tendon_2d(name: str, property_name: str='', group_name: str='默认钢束组', num: int=1, line_type: int=1, position_type: int=1, symmetry: int=2, control_points: list[tuple[float, float, float]]=None, control_points_lateral: Optional[list[tuple[float, float, float]]]=None, point_insert: tuple[float, float, float]=None, tendon_direction: Optional[tuple[float, float, float]]=None, rotation_angle: float=0, rotate_bias: tuple[float, float]=None, track_group: str='默认结构组', projection: bool=True)
```

添加三维钢束，支持覆盖添加

#### 参数

>      name:钢束名称
>      property_name:钢束特性名称
>      group_name:默认钢束组
>      num:根数
>      line_type:1-导线点  2-折线点
>      position_type: 定位方式 1-直线  2-轨迹线
>      symmetry: 对称点 0-左端点 1-右端点 2-不对称
>      control_points: 控制点信息[(x1,z1,r1),(x2,z2,r2)....]
>      control_points_lateral: 控制点横弯信息[(x1,y1,r1),(x2,y2,r2)....]，无横弯时不必输入
>      point_insert: 定位方式 (直线时为插入点坐标[x,y,z]  轨迹线时[插入端(1-I 2-J),插入方向(1-ij 2-ji),插入单元id])
>      tendon_direction:直线钢束X方向向量  默认为x轴即[1,0,0] (轨迹线不用赋值)
>      rotation_angle:绕钢束旋转角度
>      rotate_bias:绕钢束旋转偏心X、Y
>      track_group:轨迹线结构组名  (直线时不用赋值)
>      projection:直线钢束投影 (默认为true)

#### 示例

```python
from qtmodel import mdb
    mdb.add_tendon_2d(name="BB1",property_name="22-15",num=2,position_type=1,
            control_points=[(0,-1,0),(10,-1,0)],point_insert=(0,0,0))
    mdb.add_tendon_2d(name="BB1",property_name="22-15",num=2,position_type=2,
            control_points=[(0,-1,0),(10,-1,0)],point_insert=(1,1,1),track_group="轨迹线结构组1")
Returns: 无
```

### `mdb.add_tendon_elements`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_tendon_elements`

```python
mdb.add_tendon_elements(ids)
```

添加预应力单元

#### 参数

>      ids:单元编号支持数或列表且支持XtoYbyN形式字符串

#### 示例

```python
from qtmodel import mdb
    mdb.add_tendon_elements(ids=[1,2,4,6])
Returns: 无
```

### `mdb.add_pre_stress`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.add_pre_stress`

```python
mdb.add_pre_stress(case_name: str='', tendon_name: Union[str, List[str]]='', tension_type: int=2, force: float=1395000, group_name: str='默认荷载组')
```

添加预应力

#### 参数

>      case_name:荷载工况名
>      tendon_name:钢束名,支持钢束名或钢束名列表
>      tension_type:预应力类型 (0-始端 1-末端 2-两端)
>      force:预应力
>      group_name:荷载组

#### 示例

```python
from qtmodel import mdb
    mdb.add_pre_stress(case_name="荷载工况名",tendon_name="钢束1",force=1390000)
Returns: 无
```

### `mdb.update_tendon_property_material`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_tendon_property_material`

```python
mdb.update_tendon_property_material(name: str, material_name: str)
```

更新钢束特性材料

#### 参数

>     name:钢束特性名
>     material_name:材料名

#### 示例

```python
from qtmodel import mdb
    mdb.update_tendon_property_material("特性1",material_name="材料1")
Returns:无
```

### `mdb.update_tendon_property`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_tendon_property`

```python
mdb.update_tendon_property(name: str, new_name: str='', tendon_type: int=0, material_name: str='', duct_type: int=1, steel_type: int=1, steel_detail: list[float]=None, loos_detail: tuple[int, int, int]=None, slip_info: tuple[float, float]=None)
```

更新钢束特性

#### 参数

>     name:钢束特性名
>     new_name:新钢束特性名,默认不修改
>     tendon_type: 0-PRE 1-POST 2-体外
>     material_name: 钢材材料名
>     duct_type: 1-金属波纹管  2-塑料波纹管  3-铁皮管  4-钢管  5-抽芯成型
>     steel_type: 1-钢绞线  2-螺纹钢筋
>     steel_detail: 钢束详细信息
>         _钢绞线[钢束面积,孔道直径,摩阻系数,偏差系数]
>         _螺纹钢筋[钢筋直径,钢束面积,孔道直径,摩阻系数,偏差系数,张拉方式(1-一次张拉 2-超张拉)]
>     loos_detail: 松弛信息[规范(1-公规 2-铁规),张拉(1-一次张拉 2-超张拉),松弛(1-一般松弛 2-低松弛)] (仅钢绞线需要,默认为[1,1,1])
>     slip_info: 滑移信息[始端距离,末端距离] 默认为[0.006, 0.006]

#### 示例

```python
from qtmodel import mdb
    mdb.update_tendon_property(name="钢束1",tendon_type=0,material_name="材料1",duct_type=1,steel_type=1,
                            steel_detail=[0.00014,0.10,0.25,0.0015],loos_detail=(1,1,1))
Returns:无
```

### `mdb.update_tendon_name`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_tendon_name`

```python
mdb.update_tendon_name(name: str, new_name: str='')
```

更新钢束名称

#### 参数

>     name:原钢束名
>     new_name:新钢束名

#### 示例

```python
from qtmodel import mdb
    mdb.update_tendon_name("钢束1","钢束2")
Returns: 无
```

### `mdb.update_element_component_type`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_element_component_type`

```python
mdb.update_element_component_type(ids=None, component_type: int=2)
```

赋予单元构件类型

#### 参数

>     ids: 钢束构件所在单元编号集合且支持XtoYbyN形式字符串
>     component_type:0-钢结构构件 1-钢筋混凝土构件 2-预应力混凝土构件

#### 示例

```python
from qtmodel import mdb
   mdb.update_element_component_type(ids=[1,2,3,4],component_type=2)
Returns: 无
```

### `mdb.update_tendon`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_tendon`

```python
mdb.update_tendon(name: str, new_name: str='', tendon_2d: bool=True, property_name: str='', group_name: str='默认钢束组', num: int=1, line_type: int=1, symmetry: int=2, control_points: Optional[list[tuple]]=None, control_points_lateral: Optional[list[tuple[float, float, float]]]=None, position_type: int=1, point_insert: Optional[tuple[float, float, float]]=None, tendon_direction: Optional[tuple[float, float, float]]=None, rotation_angle: float=0, rotate_bias: Optional[tuple[float, float]]=None, track_group: str='默认结构组', projection: bool=True)
```

更新钢束信息，支持二维钢束和三维钢束

#### 参数

>     name: 原钢束名称
>     new_name: 新钢束名称，为空时不修改名称
>     tendon_2d: 是否为二维钢束，True-二维钢束，False-三维钢束
>     property_name: 钢束特性名称
>     group_name: 钢束组名称
>     num: 根数
>     line_type: 线型，1-导线点，2-折线点
>     symmetry: 二维钢束对称点，0-左端点，1-右端点，2-不对称
>     control_points:
>         二维钢束控制点: [(x1,z1,r1),(x2,z2,r2),...]
>         三维钢束控制点: [(x1,y1,z1,r1),(x2,y2,z2,r2),...]
>     control_points_lateral: 二维钢束横弯控制点 [(x1,y1,r1),(x2,y2,r2),...]，无横弯时不必输入
>     position_type: 定位方式，1-直线，2-轨迹线
>     point_insert:
>         直线时为插入点坐标 [x,y,z]
>         轨迹线时为 [插入端(1-I 2-J), 插入方向(1-ij 2-ji), 插入单元id]
>     tendon_direction: 直线钢束X方向向量，默认为x轴即 [1,0,0]，轨迹线不用赋值
>     rotation_angle: 绕钢束旋转角度
>     rotate_bias: 绕钢束旋转偏心 X、Y
>     track_group: 轨迹线结构组名，直线时不用赋值
>     projection: 直线钢束是否投影

#### 示例

```python
from qtmodel import mdb
    mdb.update_tendon(
        name="BB1",
        new_name="BB2",
        tendon_2d=True,
        property_name="22-15",
        num=2,
        position_type=1,
        control_points=[(0, -1, 0), (10, -1, 0)],
        point_insert=(0, 0, 0)
    )

    mdb.update_tendon(
        name="BB1",
        tendon_2d=False,
        property_name="22-15",
        num=2,
        position_type=1,
        control_points=[(0, 0, -1, 0), (10, 0, -1, 0)],
        point_insert=(0, 0, 0)
    )
```

#### 返回

>     无

### `mdb.update_tendon_group`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.update_tendon_group`

```python
mdb.update_tendon_group(name: str, new_name: str='')
```

更新钢束组名

#### 参数

>     name:原钢束组名
>     new_name:新钢束组名

#### 示例

```python
from qtmodel import mdb
    mdb.update_tendon_group("钢束组1","钢束组2")
Returns: 无
```

### `mdb.remove_tendon`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.remove_tendon`

```python
mdb.remove_tendon(name: str='', index: int=-1)
```

按照名称或编号删除钢束,默认时删除所有钢束

#### 参数

>      name:钢束名称
>      index:钢束编号

#### 示例

```python
from qtmodel import mdb
    mdb.remove_tendon(name="钢束1")
    mdb.remove_tendon(index=1)
    mdb.remove_tendon()
Returns: 无
```

### `mdb.remove_tendon_property`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.remove_tendon_property`

```python
mdb.remove_tendon_property(name: str='', index: int=-1)
```

按照名称或编号删除钢束组,默认时删除所有钢束组

#### 参数

>      name:钢束组名称
>      index:钢束组编号

#### 示例

```python
from qtmodel import mdb
    mdb.remove_tendon_property(name="钢束特性1")
    mdb.remove_tendon_property(index=1)
    mdb.remove_tendon_property()
Returns: 无
```

### `mdb.remove_pre_stress`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.remove_pre_stress`

```python
mdb.remove_pre_stress(tendon_name: str='')
```

删除预应力

#### 参数

>      tendon_name:钢束组,默认则删除所有预应力荷载

#### 示例

```python
from qtmodel import mdb
    mdb.remove_pre_stress(tendon_name="钢束1")
    mdb.remove_pre_stress()
Returns: 无
```

### `mdb.remove_tendon_group`

源码：`qtmodel/mdb/mdb_tendon.py` · `MdbTendon.remove_tendon_group`

```python
mdb.remove_tendon_group(name: str='')
```

按照钢束组名称或钢束组编号删除钢束组，两参数均为默认时删除所有钢束组

#### 参数

>      name:钢束组名称,默认自动识别 (可选参数)

#### 示例

```python
from qtmodel import mdb
    mdb.remove_tendon_group(name="钢束组1")
Returns: 无
```

# ODB：模型、视图与结果读取

## `odb_model_boundary`

### `odb.get_boundary_group_names`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_boundary_group_names`

```python
odb.get_boundary_group_names()
```

获取所有边界组名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_boundary_group_names()
```

#### 返回

>     list[str]: 边界组名称列表，例如 ``["默认边界组"]``；没有边界组时为空列表。

### `odb.get_general_support_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_general_support_data`

```python
odb.get_general_support_data()
```

获取所有边界组中的一般支承。

#### 示例

```python
from qtmodel import odb
result = odb.get_general_support_data()
```

#### 返回

>     list[dict]: 每项包含：
>
>         - ``index: int``：支承内部编号。
>         - ``node_id: int``：支承节点号。
>         - ``boundary_info: list[bool]``：按 ``[X,Y,Z,RX,RY,RZ]``
>           排列的固定状态；``True`` 表示固定。
>         - ``group_name: str``：边界组名。

### `odb.get_elastic_link_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_elastic_link_data`

```python
odb.get_elastic_link_data()
```

获取所有弹性连接。

#### 示例

```python
from qtmodel import odb
result = odb.get_elastic_link_data()
```

#### 返回

>     list[dict]: 每项包含 ``index: int``、``link_type: int``、
>     ``start_id: int``、``end_id: int``、``beta_angle: float``、
>     ``group_name: str``，以及：
>
>         - ``boundary_info: list[float]``：``[Kx,Ky,Kz,Krx,Kry,Krz]``。
>         - ``dis_ratio: float``：连接位置的距离比。
>         - ``kx: float``：X 向刚度，与 ``boundary_info[0]`` 同源。
>         - ``gap: float``：间隙值。
>         - ``friction: float``：摩擦系数。
>
>     ``link_type`` 的含义与 ``mdb.add_elastic_link`` 一致。

### `odb.get_elastic_support_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_elastic_support_data`

```python
odb.get_elastic_support_data()
```

获取所有弹性支承。

#### 示例

```python
from qtmodel import odb
result = odb.get_elastic_support_data()
```

#### 返回

>     list[dict]: 每项包含 ``index: int``、``node_id: int``、
>     ``support_type: int``、``group_name: str`` 和
>     ``boundary_info: list[float]``。其中 ``boundary_info`` 固定为
>     ``[Kx,Ky,Kz,Krx,Kry,Krz]``，分别为三个平动和三个转动刚度。

### `odb.get_master_slave_link_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_master_slave_link_data`

```python
odb.get_master_slave_link_data()
```

获取所有主从约束关系。

#### 示例

```python
from qtmodel import odb
result = odb.get_master_slave_link_data()
```

#### 返回

>     list[dict]: 每项包含 ``index: int``、``master_id: int``、
>     ``slave_id: int``、``group_name: str`` 和 ``boundary_info: list[bool]``。
>     ``boundary_info`` 顺序为 ``[X,Y,Z,RX,RY,RZ]``；``True`` 表示
>     从节点的该自由度与主节点耦合。

### `odb.get_node_local_axis_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_node_local_axis_data`

```python
odb.get_node_local_axis_data()
```

获取节点局部坐标系。

#### 示例

```python
from qtmodel import odb
result = odb.get_node_local_axis_data()
```

#### 返回

>     list[dict]: 每项包含：
>
>         - ``node_id: int``：节点号。
>         - ``input_type: int``：当前 C# 查询固定返回 ``3``，表示按基向量表达。
>         - ``coord_info: list[list[float]]``：3×3 矩阵，依次为局部
>           X、Y、Z 轴在全局坐标系中的单位向量。

### `odb.query_boundary_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.query_boundary_data`

```python
odb.query_boundary_data(boundary_type: str, boundary_ids=None, group_names=None, node_ids=None, element_ids=None, offset: int=0, limit: int=20)
```

在桥通服务端筛选一种边界或约束并返回当前页。

#### 示例

```python
from qtmodel import odb
result = odb.query_boundary_data(boundary_type=...)
```

### `odb.query_node_local_axis_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.query_node_local_axis_data`

```python
odb.query_node_local_axis_data(node_ids=None, structure_group_names=None, near=None, tolerance=None, bbox=None, offset: int=0, limit: int=20)
```

在服务端按节点或空间条件筛选节点局部坐标系。

#### 示例

```python
from qtmodel import odb
result = odb.query_node_local_axis_data()
```

### `odb.get_beam_constraint_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_beam_constraint_data`

```python
odb.get_beam_constraint_data()
```

获取所有梁端约束/释放数据。

#### 示例

```python
from qtmodel import odb
result = odb.get_beam_constraint_data()
```

#### 返回

>     list[dict]: 每项包含 ``index: int``、``beam_id: int``、
>     ``group_name: str``、``info_i: list[bool]`` 和 ``info_j: list[bool]``。
>     I/J 端列表顺序均为 ``[X,Y,Z,RX,RY,RZ]``；``True`` 表示该端
>     自由度受约束，``False`` 表示释放。

### `odb.get_constraint_equation_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_constraint_equation_data`

```python
odb.get_constraint_equation_data()
```

获取所有约束方程。

#### 示例

```python
from qtmodel import odb
result = odb.get_constraint_equation_data()
```

#### 返回

>     list[dict]: 每项包含 ``index``、``name``、``sec_node``、
>     ``sec_dof``、``master_info`` 和 ``group_name``。``sec_dof`` 取值
>     ``1..6``，依次对应 ``X,Y,Z,RX,RY,RZ``。``master_info`` 为
>     ``[[master_node, master_dof, factor], ...]``，主自由度也取 ``1..6``。

### `odb.get_effective_width_data`

源码：`qtmodel/odb/odb_model_boundary.py` · `OdbModelBoundary.get_effective_width_data`

```python
odb.get_effective_width_data()
```

获取所有单元有效宽度/截面折减数据。

#### 示例

```python
from qtmodel import odb
result = odb.get_effective_width_data()
```

#### 返回

>     list[dict]: 每项包含：
>
>         - ``element_ids: int``：单元号；历史键名是复数，实际为单个整数。
>         - ``factor_i`` / ``factor_j``：I/J 端绕 y 轴惯性矩折减系数。
>         - ``factor_i_z`` / ``factor_j_z``：I/J 端绕 z 轴惯性矩折减系数。
>         - ``factor_i_ax`` / ``factor_j_ax``：I/J 端面积折减系数。
>         - ``dy_i`` / ``dy_j``：I/J 端形心 y 偏移。
>         - ``dz_i`` / ``dz_j``：I/J 端形心 z 偏移。
>         - ``group_name: str``：边界组名。

## `odb_model_load`

### `odb.get_tendon_property_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_tendon_property_data`

```python
odb.get_tendon_property_data()
```

获取全部钢束特性。

#### 示例

```python
from qtmodel import odb
result = odb.get_tendon_property_data()
```

#### 返回

>     list[dict]: 每项公共字段为 ``name``、``tendon_type``、
>     ``material_name``、``duct_type``、``steel_type`` 和 ``steel_detail``。
>
>     对钢绞线，``steel_detail`` 为
>     ``[area, duct_diameter, friction_factor, deviation_factor]``；
>     ``loos_detail``（若存在）第 1 项为规范类型，后续项随规范而变：
>     公路规范为 ``[规范类型, 张拉等级, 松弛等级]``，铁路规范为
>     ``[规范类型, 张拉等级]``，BS5400 为 ``[规范类型, Kp, Tdays]``，
>     AASHTO LRFD 为 ``[规范类型, Kl]``。
>
>     对预应力钢筋，``steel_detail`` 为
>     ``[diameter, area, duct_diameter, friction_factor,
>     deviation_factor, tension_grade]``。

### `odb.get_tendon_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_tendon_data`

```python
odb.get_tendon_data()
```

获取全部钢束并转换为 :class:`Tendon` 对象。

#### 示例

```python
from qtmodel import odb
result = odb.get_tendon_data()
```

#### 返回

>     list[Tendon]: 每个对象至少包含名称、二维/三维标志、钢束特性名、
>     钢束组名、根数和对称方式。可选字段含义如下：
>
>         - ``line_type``：线型；``1`` 导线点，``2`` 折线点。
>         - ``control_points``：二维点为 ``[x,y,r]``，三维点由服务端类型决定。
>         - ``control_points_lateral``：二维钢束横弯控制点 ``[x,y,r]``。
>         - ``position_type``：``1`` 直线定位，``2`` 轨迹线定位。
>         - ``point_insert``：直线定位时为 ``[x,y,z]``；轨迹线定位时为
>           ``[插入侧, 钢束方向, 起始单元号]``。
>         - ``tendon_direction``：直线定位方向向量 ``[dx,dy,dz]``。
>         - ``rotate_angle`` / ``rotate_bias``：旋转角及二维偏心。
>         - ``track_group``：轨迹线定位所用结构组。
>         - ``projection``：直线定位时是否投影到结构线上。

### `odb.get_load_case_names`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_case_names`

```python
odb.get_load_case_names()
```

获取全部荷载工况名称，模型无荷载工况时返回空列表。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_case_names()
```

### `odb.get_load_group_names`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_group_names`

```python
odb.get_load_group_names()
```

获取全部荷载组名称，供创建或修改荷载前核对。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_group_names()
```

### `odb.get_load_case_summaries`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_case_summaries`

```python
odb.get_load_case_summaries()
```

获取荷载工况类型和荷载数量，不展开具体荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_case_summaries()
```

### `odb.get_load_case_detail`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_case_detail`

```python
odb.get_load_case_detail(load_case_id: int, offset: int=0, limit: int=50)
```

按工况编号分页获取荷载类型、对象引用和标量参数。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_case_detail(load_case_id=...)
```

### `odb.get_load_combination_summaries`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_combination_summaries`

```python
odb.get_load_combination_summaries()
```

获取荷载组合目录，不展开参与项。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_combination_summaries()
```

### `odb.get_load_combination_detail`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_load_combination_detail`

```python
odb.get_load_combination_detail(combination_id: int, offset: int=0, limit: int=50)
```

按组合编号分页获取参与项及其系数。

#### 示例

```python
from qtmodel import odb
result = odb.get_load_combination_detail(combination_id=...)
```

### `odb.get_pre_stress_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_pre_stress_load_data`

```python
odb.get_pre_stress_load_data()
```

获取全部工况中的预应力张拉荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_pre_stress_load_data()
```

#### 返回

>     list[dict]: 每项包含 ``case_name: str``、``tendon_name: str``、
>     ``tendon_type: int``、``force: float`` 和 ``group_name: str``。
>     ``tendon_type`` 的 C# 底层值为 ``0`` 始端、``1`` 末端、``2`` 两端；
>     注意它与部分 MDB 接口采用的 1 起始编号可能不同。

### `odb.get_node_mass_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_node_mass_data`

```python
odb.get_node_mass_data()
```

获取节点附加质量。

#### 示例

```python
from qtmodel import odb
result = odb.get_node_mass_data()
```

#### 返回

>     list[dict]: 每项含 ``node_id: int`` 和 ``mass_info: tuple[float,...]``。
>     当前 C# 返回的 ``mass_info`` 恰为 4 项：
>     ``[mass_x, inertia_x, inertia_y, inertia_z]``。服务端当前未输出
>     ``mass_y``、``mass_z``，调用方不应把该数组误认为 6 自由度完整质量。

### `odb.get_nodal_force_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_nodal_force_load_data`

```python
odb.get_nodal_force_load_data()
```

获取全部工况中的节点力荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_nodal_force_load_data()
```

#### 返回

>     list[dict]: 每项含 ``index``、``node_id``、``case_name``、``group_name`` 和
>     ``load_info=[Fx,Fy,Fz,Mx,My,Mz]``。

### `odb.get_nodal_displacement_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_nodal_displacement_load_data`

```python
odb.get_nodal_displacement_load_data()
```

获取全部工况中的节点强制位移。

#### 示例

```python
from qtmodel import odb
result = odb.get_nodal_displacement_load_data()
```

#### 返回

>     list[dict]: 每项含 ``index``、``node_id``、``case_name``、``group_name`` 和
>     ``load_info=[Dx,Dy,Dz,Rx,Ry,Rz]``。

### `odb.get_beam_element_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_beam_element_load_data`

```python
odb.get_beam_element_load_data()
```

获取梁/杆单元集中荷载与分布荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_beam_element_load_data()
```

#### 返回

>     list[dict]: 公共字段为 ``index``、``element_id``、``case_name``、``load_type``、
>     ``coord_system``、``list_load``、``list_x``、``group_name`` 和
>     ``load_bias``。集中荷载的 ``list_load``、``list_x`` 各 1 项；分布荷载
>     各 2 项，并额外包含 ``projected: bool``。``load_bias`` 为
>     ``[is_bias, position, coordinate_system, distance]``。

### `odb.get_plate_element_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_plate_element_load_data`

```python
odb.get_plate_element_load_data()
```

获取板单元集中、线分布和面分布荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_plate_element_load_data()
```

#### 返回

>     list[dict]: 每项公共字段为 ``index``、``element_id``、``case_name``、
>     ``load_type``、``load_place``、``coord_system``、``group_name`` 和
>     ``list_load``。集中荷载另有 ``list_xy=[dx,dy]``；线荷载的
>     ``list_load`` 为 2 项；面荷载为 I/J/K/L 四角的 4 项。

### `odb.query_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.query_load_data`

```python
odb.query_load_data(load_family: str, load_ids=None, target_ids=None, case_names=None, group_names=None, offset: int=0, limit: int=20)
```

在桥通服务端筛选一种节点或单元荷载并返回当前页。

#### 示例

```python
from qtmodel import odb
result = odb.query_load_data(load_family=...)
```

### `odb.get_initial_tension_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_initial_tension_load_data`

```python
odb.get_initial_tension_load_data()
```

获取索/杆单元初拉力荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_initial_tension_load_data()
```

#### 返回

>     list[dict]: 每项含 ``element_id``、``case_name``、``group_name``、
>     ``tension: float``、``tension_type: int``、``application_type: int``
>     和 ``stiffness: bool``。``application_type`` 返回 ``1..3``；具体意义
>     与 ``mdb.add_initial_tension`` 的同名参数一致。

### `odb.get_cable_length_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_cable_length_load_data`

```python
odb.get_cable_length_load_data()
```

获取索单元无应力长度荷载。

#### 示例

```python
from qtmodel import odb
result = odb.get_cable_length_load_data()
```

#### 返回

>     list[dict]: 每项含 ``element_id``、``case_name``、``group_name``、
>     ``length: float`` 和 ``tension_type: int``。这里的 ``length`` 是
>     无应力长度，不是当前变形后几何长度。

### `odb.get_deviation_parameters`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_deviation_parameters`

```python
odb.get_deviation_parameters()
```

查询制造偏差数据（注意当前服务端命令存在历史命名对调）。

#### 示例

```python
from qtmodel import odb
result = odb.get_deviation_parameters()
```

#### 返回

>     list[dict]: 按当前 C# 实现，本方法实际返回已施加的偏差荷载：
>     ``element_id``、``case_name``、``parameters: list[str]`` 和
>     ``group_name``。梁单元通常只有 1 个参数名，板单元可有多个。

#### 说明

>     命令名为 ``GET-DEVIATION-PARAMETER``，但当前 C# 方法体读取的是
>     各荷载工况的偏差荷载；这是服务端历史命名问题。

### `odb.get_deviation_load_data`

源码：`qtmodel/odb/odb_model_load.py` · `OdbModelLoad.get_deviation_load_data`

```python
odb.get_deviation_load_data()
```

查询制造偏差参数库（注意当前服务端命令存在历史命名对调）。

#### 示例

```python
from qtmodel import odb
result = odb.get_deviation_load_data()
```

#### 返回

>     list[dict]: 按当前 C# 实现，每项为 ``name: str`` 和
>     ``parameters: list[float]``。梁偏差参数为 7 项：轴向偏差、起点
>     X/Y/Z 角度偏差、终点 X/Y/Z 角度偏差；板偏差当前返回 5 项。

#### 说明

>     命令名为 ``GET-DEVIATION-LOAD``，但当前 C# 方法体读取的是偏差
>     参数库。板偏差的 C# 序列化还会重复输出 X 位移，需谨慎解释第 4 项。

## `odb_model_material`

### `odb.get_material_data`

源码：`qtmodel/odb/odb_model_material.py` · `OdbModelMaterial.get_material_data`

```python
odb.get_material_data()
```

获取全部材料及其建模属性。

#### 示例

```python
from qtmodel import odb
result = odb.get_material_data()
```

#### 返回

>     list[dict]: 每项公共字段为：
>
>         - ``index: int``、``name: str``：材料编号和名称。
>         - ``mat_type: int``：``1`` 混凝土，``2`` 钢材，``3`` 预应力材料，
>           ``4`` 钢筋，``5`` 用户自定义，``6`` 组合材料。
>         - ``construct_factor: float``：施工阶段材料系数。
>         - ``data_info: list[float]``：固定顺序
>           ``[弹性模量, 单位重, 泊松比, 线膨胀系数]``。
>
>     数据库材料通常另含 ``standard: int``、``database: str``、
>     ``modified: bool``。混凝土及用户材料可能含 ``creep_id``，``-1``
>     表示未关联收缩徐变；用户材料含 ``f_cuk``；组合材料含
>     ``composite_info=[主材料名, 辅材料名]``。

### `odb.get_material_summaries`

源码：`qtmodel/odb/odb_model_material.py` · `OdbModelMaterial.get_material_summaries`

```python
odb.get_material_summaries()
```

获取材料编号、名称、类型和数据库牌号，不展开力学参数。

#### 示例

```python
from qtmodel import odb
result = odb.get_material_summaries()
```

### `odb.get_material_detail`

源码：`qtmodel/odb/odb_model_material.py` · `OdbModelMaterial.get_material_detail`

```python
odb.get_material_detail(material_id: int)
```

按材料编号获取公共力学参数和类型专用参数。

#### 示例

```python
from qtmodel import odb
result = odb.get_material_detail(material_id=...)
```

### `odb.get_thickness_data`

源码：`qtmodel/odb/odb_model_material.py` · `OdbModelMaterial.get_thickness_data`

```python
odb.get_thickness_data()
```

获取全部普通板厚和带加劲肋板厚。

#### 示例

```python
from qtmodel import odb
result = odb.get_thickness_data()
```

#### 返回

>     list[dict]: 每项至少含 ``thick_id: int``、``name: str``、
>     ``t: float`` 和 ``thick_type: int``。``thick_type=0`` 为普通板厚，
>     可含 ``bias_info=None`` 或 ``[offset_type, offset_value]``；
>     ``thick_type=1`` 为加劲板厚，另含 ``rib_pos``、纵横向肋间距
>     ``dist_v``/``dist_l`` 及随肋型变化的 ``rib_v``/``rib_l`` 数据。

## `odb_model_overview`

### `odb.get_model_summary`

源码：`qtmodel/odb/odb_model_overview.py` · `OdbModelOverview.get_model_summary`

```python
odb.get_model_summary()
```

获取只含模型状态和实体数量的轻量摘要。

#### 示例

```python
from qtmodel import odb
result = odb.get_model_summary()
```

### `odb.get_analysis_context`

源码：`qtmodel/odb/odb_model_overview.py` · `OdbModelOverview.get_analysis_context`

```python
odb.get_analysis_context()
```

获取结果查询前所需的分析设置和已求解阶段标量。

#### 示例

```python
from qtmodel import odb
result = odb.get_analysis_context()
```

### `odb.get_project_metadata`

源码：`qtmodel/odb/odb_model_overview.py` · `OdbModelOverview.get_project_metadata`

```python
odb.get_project_metadata()
```

获取当前工程保存的名称、单位、人员、日期和描述。

#### 示例

```python
from qtmodel import odb
result = odb.get_project_metadata()
```

### `odb.get_code_check_context`

源码：`qtmodel/odb/odb_model_overview.py` · `OdbModelOverview.get_code_check_context`

```python
odb.get_code_check_context()
```

获取设计活载以及当前已打开检算工况的基本设计上下文。

#### 示例

```python
from qtmodel import odb
result = odb.get_code_check_context()
```

## `odb_model_section`

### `odb.get_section_shape`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_shape`

```python
odb.get_section_shape(sec_id: int)
```

获取可供程序和 AI 理解的统一截面几何。

#### 参数

>     sec_id (int): 目标截面编号，应为正整数。

#### 示例

```python
from qtmodel import odb
result = odb.get_section_shape(sec_id=...)
```

#### 返回

>     :class:`SectionShape`。线圈截面位于 ``parts[*].loop_segments``，
>     线宽截面位于 ``parts[*].lines``；组合截面通过 ``role`` 区分
>     ``main`` 与 ``secondary``，变截面分别使用 ``begin_parts`` 和
>     ``end_parts``。所有坐标和厚度单位均为 m。

### `odb.get_section_data`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_data`

```python
odb.get_section_data(sec_id: int, position: int=0)
```

获取截面的原始类型、参数和特性字典。

#### 参数

>     sec_id (int): 目标截面编号，应大于 ``0``。
>     position (int): 变截面端部，``0`` 为 I/始端，``1`` 为 J/末端；
>         普通截面忽略该参数。

#### 示例

```python
from qtmodel import odb
result = odb.get_section_data(sec_id=...)
```

#### 返回

>     dict: 服务端 ``GetSectionInfo`` 返回的截面详细信息，字段会随截面类型变化。

#### 警告

>     当前 Python 发送键 ``position``，而 C# 路由读取历史拼写 ``postion``，
>     因而在服务端修正兼容前通常总会查询始端。需要可靠区分变截面两端时，
>     应优先使用 :meth:`get_section_property` 或 :meth:`get_section_shape`。

### `odb.get_section_property`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_property`

```python
odb.get_section_property(index: int)
```

获取指定普通或变截面的统一截面特性对象。

#### 参数

>     index (int): 截面号。必须是 ``int`` 且不能是 ``bool``。

#### 示例

```python
from qtmodel import odb
result = odb.get_section_property(index=...)
```

#### 返回

>     SectionProperty 对象。普通截面直接读取 Ax、Iy 等属性；变截面通过
>     ``sec_begin`` 和 ``sec_end`` 读取始、末端截面特性。主要字段包括
>     面积 ``Ax/Ay/Az``、惯性矩 ``Ix/Iy/Iz/Iyz``、形心 ``CentY/CentZ``、
>     外/内周长 ``PeriO/PeriI``、剪切中心和静矩 ``Sys/Szs``。

### `odb.get_section_names`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_names`

```python
odb.get_section_names()
```

获取模型中截面编号到名称的映射。

#### 示例

```python
from qtmodel import odb
result = odb.get_section_names()
```

#### 返回

>     dict[int, str]: ``{截面号: 截面名称}``。由于 JSON 对象键规则，
>     某些解析环境可能得到字符串键；原帮助中写的 ``list[int]`` 不正确。

### `odb.query_section_summaries`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.query_section_summaries`

```python
odb.query_section_summaries(section_ids: list[int]=None, query: str='', section_type: str='', offset: int=0, limit: int=50)
```

分页查询截面编号、名称和类型摘要。

#### 参数

>     section_ids (list[int] | None): 可选的明确截面编号，最多 100 个；
>         返回项保持输入顺序，并通过 ``missing_section_ids`` 报告不存在的编号。
>     query (str): 截面名称的大小写不敏感子串。
>     section_type (str): :meth:`get_section_data` 使用的截面类型精确名称。
>     offset (int): 从零开始的分页偏移量。
>     limit (int): 本页最大条数，范围为 1..100。

#### 示例

```python
from qtmodel import odb
result = odb.query_section_summaries()
```

#### 返回

>     dict: 包含 ``items``、``total``、``offset``、``limit`` 和
>     ``truncated``；每项包含 ``section_id``、``name``、
>     ``section_type`` 和 ``is_tapered``。

### `odb.get_section_property_by_loops`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_property_by_loops`

```python
odb.get_section_property_by_loops(loop_segments: list[dict[str, list[list[float]]]]=None)
```

不写入模型，直接计算线圈几何的截面特性。

#### 参数

>     loop_segments (list[dict[str, list[list[float]]]]): 闭合区域列表。
>         每个字典必须含 ``main`` 外圈，可含 ``sub1``、``sub2`` 等孔洞；
>         每个点为 ``[y,z]``/``[x,y]`` 二维坐标且必须是有限数值。每个有效
>         线圈至少需要 3 个非共线点。首尾不重复时 C# 服务端会自动补首点闭合。

#### 示例

```python
from qtmodel import odb
    dict_item1 = {"main": [[9.25, 0.0], [18.4, 0.0], [18.5, 0.0], [18.5, 2.5], [9.25, 2.5], [0.0, 2.5], [0.0, 0.0], [0.1, 0.0]],
                 "sub1": [[6.35, 0.5], [2.55, 0.5], [2.55, 1.0], [2.55, 2.0], [6.35, 2.0]],
                 "sub2": [[9.25, 0.5], [11.55, 0.5], [11.55, 2.0], [9.25, 2.0], [6.95, 2.0], [6.95, 0.5]],
                 "sub3": [[12.15, 0.5], [15.95, 0.5], [15.95, 1.0], [15.95, 2.0], [12.15, 2.0]]}
    odb.get_section_property_by_loops([dict_item1])
```

#### 返回

>     dict: 与 :class:`SectionProperty` 字段一致的 29 项截面特性字典。
>     该方法创建临时截面计算，不会加入当前模型。

### `odb.get_section_property_by_lines`

源码：`qtmodel/odb/odb_model_section.py` · `OdbModelSection.get_section_property_by_lines`

```python
odb.get_section_property_by_lines(sec_lines: Union[list[tuple[float, float, float, float, float]], list[list[float]]]=None)
```

不写入模型，直接计算线宽型截面的截面特性。

#### 参数

>     sec_lines: 线段列表；每条严格按 ``[x1,y1,x2,y2,width]`` 表达，
>         前四项为中心线起终点坐标，第五项 ``width`` 为线宽/板厚且应大于
>         ``0``。所有数值必须有限；无效行会被 C# 服务端跳过。

#### 示例

```python
from qtmodel import odb
    sec_lines = [[0.0, 2.284, 5.51093, 2.284, 0.016], [0.152479, 2.284, 0.200597, 2.04341, 0.008],
                           [0.200597, 2.04341, 0.201664, 2.0389, 0.008], [0.201664, 2.0389, 0.203149, 2.03451, 0.008],
                           [0.203149, 2.03451, 0.205006, 2.03026, 0.008]]
    odb.get_section_property_by_lines(sec_lines)
```

#### 返回

>     dict: 与 :class:`SectionProperty` 字段一致的截面特性字典。
>     线段应能组成可计算的连通截面；该方法不会把临时截面加入模型。

## `odb_model_section_mcp`

### `odb.get_section_semantic_info`

源码：`qtmodel/odb/odb_model_section_mcp.py` · `OdbModelSectionMcp.get_section_semantic_info`

```python
odb.get_section_semantic_info(index: int)
```

查询一个截面的类型、名称及 W/H 等参数语义。

#### 参数

>     index (int): 截面号，必须是大于 0 的整数；``bool`` 不被视为整数。

#### 示例

```python
from qtmodel import odb
result = odb.get_section_semantic_info(index=...)
```

#### 返回

>     dict: 有工程时含 ``status='ready'``、``has_project``、``index``、
>     ``name``、``sec_type``、``section_kind``、``creation_method``、
>     ``parameterized`` 和 ``model_revision``。可参数化的单截面另含
>     ``parameter_values``、逐参数 ``parameters``、``editable_parameters``
>     与 ``schema.sec_info_order``；变截面则在 ``endpoints.I/J`` 中分别给出。
>     无打开工程时返回 ``status='no_project'``、说明和建议动作。

#### 异常

>     ValueError: ``index`` 非法，或导出脚本中未找到唯一匹配截面。

### `odb.build_parameter_section_copy_spec`

源码：`qtmodel/odb/odb_model_section_mcp.py` · `OdbModelSectionMcp.build_parameter_section_copy_spec`

```python
odb.build_parameter_section_copy_spec(source_index: int, parameter_updates: Mapping[str, Any], target_index: int=None, target_name: str='')
```

生成复制单一参数截面所需的完整参数，但不写入模型。

#### 参数

>     source_index (int): 已存在源截面号，必须大于 0；当前仅支持由
>         ``mdb.add_section`` 导出且能被 ``SectionDB`` 参数化的单一截面。
>     parameter_updates (Mapping[str, Any]): 非空尺寸参数更新，例如
>         ``{'W': 2.5, 'H': 3.0}``。键可使用 ``SectionDB`` 支持的规范键/
>         别名；值必须符合对应截面参数类型与约束，未知键会报错。
>     target_index (int | None): 新截面号，必须大于 0 且不得已存在；
>         ``None`` 自动取当前最大截面号加 1。
>     target_name (str): 新截面名；去除首尾空格后为空时自动生成为
>         ``源名称_副本目标号``。

#### 示例

```python
from qtmodel import odb
result = odb.build_parameter_section_copy_spec(source_index=..., parameter_updates=...)
```

#### 返回

>     dict: 含 ``operation``、源/目标语义、逐项 ``changes``、
>     ``creation_method='add_section'``、可直接传入 MDB 的完整
>     ``creation_arguments``、``model_revision`` 和 ``warnings``。

#### 异常

>     ValueError: 更新为空、截面不支持参数化复制、目标号冲突、参数未知，
>         或更新前后完全相同。
>     RuntimeError: 当前未打开工程。

### `odb.build_parameter_section_update_spec`

源码：`qtmodel/odb/odb_model_section_mcp.py` · `OdbModelSectionMcp.build_parameter_section_update_spec`

```python
odb.build_parameter_section_update_spec(index: int, parameter_updates: Mapping[str, Any], end: str='')
```

生成原位修改参数截面的完整规格，但不执行修改。

#### 参数

>     index (int): 待修改截面号，必须是大于 0 的整数且唯一存在。
>     parameter_updates (Mapping[str, Any]): 非空尺寸参数字典；键和值遵循
>         当前 ``sec_type`` 的 ``SectionDB`` 参数模式，只能修改 ``sec_info``
>         尺寸，不能在此修改偏心、倒角或已计算截面特性。
>     end (str): 单一截面省略或传 ``'SINGLE'``；变截面必须传 ``'I'`` 或
>         ``'J'``（不区分大小写），表示只改指定端。

#### 示例

```python
from qtmodel import odb
result = odb.build_parameter_section_update_spec(index=..., parameter_updates=...)
```

#### 返回

>     dict: 含 ``operation='update_parameter_section'``、源/目标语义、
>     ``changes``、``update_method``（``update_section`` 或
>     ``update_tapper_section``）、完整 ``update_arguments``、
>     ``model_revision`` 和写入风险提示。规格会移除旧 ``sec_property``，
>     以便桥通按新尺寸重新计算。

#### 异常

>     ValueError: 截面/端别/参数非法、导出参数无法安全解析或无实际变化。
>     RuntimeError: 当前未打开工程。

## `odb_model_stage`

### `odb.get_stage_names`

源码：`qtmodel/odb/odb_model_stage.py` · `OdbModelStage.get_stage_names`

```python
odb.get_stage_names()
```

获取按阶段顺序排列的全部施工阶段名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_stage_names()
```

#### 返回

>     list[str]: 阶段名称列表；原类型标注 ``list[int]`` 不正确，
>     C# 服务端实际返回名称字符串。

### `odb.get_construction_stage_summaries`

源码：`qtmodel/odb/odb_model_stage.py` · `OdbModelStage.get_construction_stage_summaries`

```python
odb.get_construction_stage_summaries()
```

获取施工阶段编号、时长、累计时长和结果可用状态。

#### 示例

```python
from qtmodel import odb
result = odb.get_construction_stage_summaries()
```

### `odb.get_elements_of_stage`

源码：`qtmodel/odb/odb_model_stage.py` · `OdbModelStage.get_elements_of_stage`

```python
odb.get_elements_of_stage(stage_id: int)
```

获取指定施工阶段中处于激活状态的单元号。

#### 参数

>     stage_id (int): 施工阶段编号，通常为 ``1..len(get_stage_names())``。

#### 示例

```python
from qtmodel import odb
result = odb.get_elements_of_stage(stage_id=...)
```

#### 返回

>     list[int]: 该阶段有效单元号；阶段不存在时由桥通服务端报错或返回空列表。

### `odb.get_nodes_of_stage`

源码：`qtmodel/odb/odb_model_stage.py` · `OdbModelStage.get_nodes_of_stage`

```python
odb.get_nodes_of_stage(stage_id: int)
```

获取指定施工阶段中处于激活状态的节点号。

#### 参数

>     stage_id (int): 施工阶段编号，通常从 ``1`` 开始。

#### 示例

```python
from qtmodel import odb
result = odb.get_nodes_of_stage(stage_id=...)
```

#### 返回

>     list[int]: 该阶段有效节点号。

### `odb.get_groups_of_stage`

源码：`qtmodel/odb/odb_model_stage.py` · `OdbModelStage.get_groups_of_stage`

```python
odb.get_groups_of_stage(stage_id: int)
```

获取指定阶段所关联的结构组、边界组和荷载组。

#### 参数

>     stage_id (int): 施工阶段编号，通常从 ``1`` 开始。

#### 示例

```python
from qtmodel import odb
result = odb.get_groups_of_stage(stage_id=...)
```

#### 返回

>     dict[str, list[str]]: 固定包含中文键 ``"结构组"``、``"边界组"``、
>     ``"荷载组"``，每个值都是组名称列表。例如
>     ``{"结构组": ["主梁"], "边界组": [], "荷载组": ["一期恒载"]}``。

## `odb_model_structure`

### `odb.get_overlap_nodes`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_overlap_nodes`

```python
odb.get_overlap_nodes(round_num: int=4)
```

按坐标舍入精度查找重合节点组。

#### 参数

>     round_num (int): 坐标比较保留的小数位数，必须为非负整数；默认 ``4``。

#### 示例

```python
from qtmodel import odb
result = odb.get_overlap_nodes()
```

#### 返回

>     list[list[int]]: 每个子列表是一组位于同一坐标的节点号；没有重合时为空列表。

### `odb.get_node_id`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_node_id`

```python
odb.get_node_id(x: float=0, y: float=0, z: float=0, tolerance: float=0.0001)
```

获取目标坐标容差球内找到的第一个节点号。

#### 参数

>     x (float): 全局 X 坐标。
>     y (float): 全局 Y 坐标。
>     z (float): 全局 Z 坐标。
>     tolerance (float): 三维欧氏距离容差，应大于 ``0``；服务端采用严格
>         ``distance < tolerance`` 判断。

#### 示例

```python
from qtmodel import odb
result = odb.get_node_id()
```

#### 返回

>     int: 节点号；没有节点满足容差时返回 ``-1``。

### `odb.get_group_nodes`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_group_nodes`

```python
odb.get_group_nodes(group_name: str='默认结构组')
```

获取指定结构组包含的节点号。

#### 参数

>     group_name (str): 已存在的结构组名称，不能为空。

#### 示例

```python
from qtmodel import odb
result = odb.get_group_nodes()
```

#### 返回

>     list[int]: 节点号列表，不包含节点坐标。

### `odb.get_node_data`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_node_data`

```python
odb.get_node_data(ids=None)
```

获取指定节点或全部节点的编号与全局坐标。

#### 参数

>     ids (int | list[int] | str | None): 节点号；支持 ``"1to10by2"``。
>         ``None`` 或解析后的空列表表示获取全部节点。

#### 示例

```python
from qtmodel import odb
result = odb.get_node_data()
```

#### 返回

>     list[Node]: ``Node`` 属性为 ``node_id: int`` 及 ``x/y/z: float``。
>         返回顺序与输入编号顺序一致；获取全部时采用模型节点顺序。

### `odb.query_node_data`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.query_node_data`

```python
odb.query_node_data(node_ids=None, structure_group_names=None, near=None, tolerance=None, bbox=None, offset: int=0, limit: int=20)
```

在桥通服务端筛选节点并返回一页轻量坐标数据。

至少应提供 ``node_ids``、``structure_group_names``、``near`` 或
``bbox`` 中的一项。多个条件同时提供时取交集；``near`` 使用三维欧氏
距离并必须与 ``tolerance`` 一起提供。该接口不会先把全部节点传到
Python，适合大型模型的 MCP 查询。

#### 示例

```python
from qtmodel import odb
result = odb.query_node_data()
```

### `odb.resolve_node_selection`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.resolve_node_selection`

```python
odb.resolve_node_selection(node_ids=None, structure_group_names=None, bbox=None, coordinate_filters=None, exclude_node_ids=None, max_nodes: int=20000)
```

在桥通进程内解析节点条件，返回稳定编号集合和空间摘要。

本接口供 MCP 冻结选择集使用。它不会返回逐节点坐标；多个包含条件取
交集，``exclude_node_ids`` 在最后排除。``coordinate_filters`` 每项包含
``axis``（``x/y/z``）、``operator``（``gt/gte/lt/lte``）和 ``value``。

#### 示例

```python
from qtmodel import odb
result = odb.resolve_node_selection()
```

### `odb.get_elements_by_point`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_elements_by_point`

```python
odb.get_elements_by_point(x: float=0, y: float=0, z: float=0, tolerance: float=1)
```

获取中心点位于目标坐标容差范围内的单元号。

单元中心点按组成节点坐标的算术平均值计算，并非搜索穿过该点的任意单元。

#### 参数

>     x, y, z (float): 目标点全局坐标。
>     tolerance (float): 中心点距离容差，应大于等于 ``0``。

#### 示例

```python
from qtmodel import odb
result = odb.get_elements_by_point()
```

#### 返回

>     list[int]: 满足条件的单元号。

### `odb.get_elements_by_material`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_elements_by_material`

```python
odb.get_elements_by_material(name: str='')
```

获取引用指定材料名称的所有单元号。

#### 参数

>     name (str): 已存在的材料名称；按名称而不是材料编号查询。

#### 示例

```python
from qtmodel import odb
result = odb.get_elements_by_material()
```

#### 返回

>     list[int]: 引用该材料的单元号。

### `odb.get_elements_by_section`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_elements_by_section`

```python
odb.get_elements_by_section(index: int=1)
```

获取指定截面的梁、杆或索单元号。

#### 参数

>     index (int): 截面编号，应大于 ``0``。

#### 示例

```python
from qtmodel import odb
result = odb.get_elements_by_section()
```

#### 返回

>     list[int]: 引用目标截面的单元号。

#### 警告

>     当前 C# 路由未把请求参数传给查询函数，实际总是按默认截面号 ``1``
>     查询。因此在服务端修正前，传入非 ``1`` 的 ``index`` 不会生效。

### `odb.get_overlap_elements`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_overlap_elements`

```python
odb.get_overlap_elements()
```

获取连接关系和几何位置重合的单元组。

#### 示例

```python
from qtmodel import odb
result = odb.get_overlap_elements()
```

#### 返回

>     list[list[int]]: 每个子列表为一组重合单元号；无重合单元时为空列表。

### `odb.get_structure_group_names`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_structure_group_names`

```python
odb.get_structure_group_names()
```

获取全部结构组名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_structure_group_names()
```

#### 返回

>     list[str]: 名称列表，模型无结构组时为空列表。

### `odb.get_structure_group_summaries`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_structure_group_summaries`

```python
odb.get_structure_group_summaries()
```

获取结构组名称及节点、单元数量，不展开成员编号。

#### 示例

```python
from qtmodel import odb
result = odb.get_structure_group_summaries()
```

### `odb.get_structure_group`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_structure_group`

```python
odb.get_structure_group(group_name: str='默认结构组')
```

获取单个结构组的成员编号及详细节点/单元数据。

#### 参数

>     group_name (str): 结构组名称；空字符串会回退到 ``"默认结构组"``。

#### 示例

```python
from qtmodel import odb
result = odb.get_structure_group()
```

#### 返回

>     dict: 包含 ``id: int``、``name: str``、``node_ids: list[int]``、
>     ``element_ids: list[int]``、``nodes: list`` 和 ``elements: list[dict]``。
>     ``nodes`` 为 C# Tuple 序列化数据，``elements`` 字段结构与
>     :meth:`get_element_data` 的底层字典一致。

#### 异常

>     RuntimeError: 服务端找不到指定结构组时。

### `odb.get_structure_group_element_ids`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_structure_group_element_ids`

```python
odb.get_structure_group_element_ids(group_name: str='默认结构组')
```

获取结构组中的单元号。

#### 参数

>     group_name (str): 结构组名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_structure_group_element_ids()
```

#### 返回

>     list[int]: 单元号列表。

### `odb.get_structure_group_node_ids`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_structure_group_node_ids`

```python
odb.get_structure_group_node_ids(group_name: str='默认结构组')
```

获取结构组中的节点号。

#### 参数

>     group_name (str): 结构组名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_structure_group_node_ids()
```

#### 返回

>     list[int]: 节点号列表。

### `odb.get_element_data`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_element_data`

```python
odb.get_element_data(ids=None)
```

获取指定单元或全部单元并转换为 :class:`Element` 对象。

#### 参数

>     ids (int | list[int] | str | None): 单元号；支持 ``"1to10by2"``。
>         ``None`` 或空列表表示全部单元。

#### 示例

```python
from qtmodel import odb
result = odb.get_element_data()
```

#### 返回

>     list[Element]: 公共属性为 ``index``、``ele_type``、``node_ids``、
>     ``mat_id``、``sec_id``、``beta_angle``。``ele_type`` 为 ``BEAM``、
>     ``LINK``、``CABLE`` 或 ``PLATE``；索单元另有 ``initial_type`` 和
>     ``initial_value``；板单元的 ``sec_id`` 实际表示板厚编号。

### `odb.query_element_data`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.query_element_data`

```python
odb.query_element_data(element_ids=None, structure_group_names=None, element_type: str='', node_ids=None, node_match: str='any', material_ids=None, section_ids=None, thickness_ids=None, offset: int=0, limit: int=20)
```

在桥通服务端筛选单元并返回一页完整单元定义。

#### 示例

```python
from qtmodel import odb
result = odb.query_element_data()
```

### `odb.get_all_element_ids`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_all_element_ids`

```python
odb.get_all_element_ids()
```

获取全部单元编号。

#### 示例

```python
from qtmodel import odb
result = odb.get_all_element_ids()
```

#### 返回

>     list[int]: 单元号列表。该方法只提取编号，数据量小于
>     :meth:`get_element_data` 返回的对象列表。

### `odb.get_element_type`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_element_type`

```python
odb.get_element_type(element_id: int)
```

获取指定单元的类型名称。

#### 参数

>     element_id (int): 已存在的单元号，必须大于 ``0``。

#### 示例

```python
from qtmodel import odb
result = odb.get_element_type(element_id=...)
```

#### 返回

>     str: ``"BEAM"``、``"PLATE"``、``"CABLE"`` 或 ``"LINK"``。

### `odb.get_group_elements`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_group_elements`

```python
odb.get_group_elements(group_name: str='默认结构组')
```

获取指定结构组中的单元号。

#### 参数

>     group_name (str): 已存在的结构组名称。

#### 示例

```python
from qtmodel import odb
result = odb.get_group_elements()
```

#### 返回

>     list[int]: 单元号列表。

### `odb.get_element_weight`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_element_weight`

```python
odb.get_element_weight(ids=None)
```

获取指定或全部单元的自重。

#### 参数

>     ids (int | list[int] | str | None): 单元号；``None`` 或空列表表示全部。

#### 示例

```python
from qtmodel import odb
result = odb.get_element_weight()
```

#### 返回

>     dict[int, float]: ``{单元号: 重量}``。JSON 对象键经解析后可能表现为
>     字符串，使用前可按需要转换为 ``int``；重量采用当前力单位。

### `odb.get_span_data`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_span_data`

```python
odb.get_span_data()
```

获取全部跨度信息定义。

#### 示例

```python
from qtmodel import odb
result = odb.get_span_data()
```

#### 返回

>     list[dict]: 每项含 ``id: int``、``name: str``、
>     ``element_ids: list[int]`` 和 ``support_ids: list[int]``。

### `odb.get_span_supports`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_span_supports`

```python
odb.get_span_supports(span_info_name: str='')
```

获取指定跨度信息定义中的支承节点号。

#### 参数

>     span_info_name (str): 跨度信息名称，可从 :meth:`get_span_data` 获取。

#### 示例

```python
from qtmodel import odb
result = odb.get_span_supports()
```

#### 返回

>     list[int]: 支承节点号。

#### 警告

>     当前 Python 请求键为 ``span_info_name``，而 C# 路由读取
>     ``spaninfo_name``。服务端修正兼容前，该参数可能被当作空字符串。

### `odb.get_span_elements`

源码：`qtmodel/odb/odb_model_structure.py` · `OdbModelStructure.get_span_elements`

```python
odb.get_span_elements(span_info_name: str='')
```

获取指定跨度信息定义包含的单元号。

#### 参数

>     span_info_name (str): 跨度信息名称，可从 :meth:`get_span_data` 获取。

#### 示例

```python
from qtmodel import odb
result = odb.get_span_elements()
```

#### 返回

>     list[int]: 跨度内单元号。

#### 警告

>     当前 Python 请求键为 ``span_name``，而 C# 路由读取
>     ``spaninfo_name``。服务端修正兼容前，该参数可能被当作空字符串。

## `odb_result_data`

### `odb.get_reaction`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_reaction`

```python
odb.get_reaction(ids, envelop_type=1, stage_id: int=1, result_kind: int=1, increment_type: int=1, case_name='', is_time_history: bool=False)
```

获取支座节点反力。

#### 参数

>     ids: 节点编号,支持整数或整数型列表支持XtoYbyN形式字符串
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     stage_id: 施工阶段号 -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     result_kind: 施工阶段数据类型：1-合计，2-预应力，3-收缩徐变，4-恒载
>     increment_type: 1-全量    2-增量
>     case_name: 运营阶段所需荷载工况名
>     is_time_history: 运营阶段所需荷载工况名是否为时程分析

#### 示例

```python
from qtmodel import odb
    odb.get_reaction(ids=1,stage_id=1)
    odb.get_reaction(ids=[1,2,3],stage_id=1)
    odb.get_reaction(ids="1to3",stage_id=1)
    odb.get_reaction(ids=1,stage_id=-1,case_name="工况名")
```

#### 返回

>     list[dict]: 每项为 ``{node_id,fx,fy,fz,mx,my,mz}``；
>     ``is_time_history=True`` 时另含 ``time: float``。时程反力当前只查询
>     ``ids`` 中的第一个节点。

### `odb.get_deformation`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_deformation`

```python
odb.get_deformation(ids, envelop_type=1, stage_id: int=1, result_kind: int=1, increment_type: int=1, case_name='', is_time_history: bool=False, is_local=False)
```

获取节点变形结果,支持单个节点和节点列表

#### 参数

>     ids: 查询结果的节点号支持XtoYbyN形式字符串
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     stage_id: 施工阶段号 -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     result_kind: 施工阶段为 1-合计、2-预应力、3-收缩徐变、4-恒载；
>         时程分析为 1-位移、2-速度、3-加速度
>     increment_type: 1-全量    2-增量
>     case_name: 运营阶段所需荷载工况名
>     is_time_history: 是否为时程分析
>     is_local: 是否为输出局部坐标系

#### 示例

```python
from qtmodel import odb
    odb.get_deformation(ids=1,stage_id=1)
    odb.get_deformation(ids=[1,2,3],stage_id=1)
    odb.get_deformation(ids="1to3",stage_id=1)
    odb.get_deformation(ids=1,stage_id=-1,case_name="工况名")
```

#### 返回

>     list[dict]: 每项为 ``{node_id,dx,dy,dz,rx,ry,rz}``；时程结果另含
>     ``time``。``is_local=True`` 时分量按节点局部坐标系表达。时程分支
>     当前只使用 ``ids`` 中第一个节点。

### `odb.get_element_stress`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_element_stress`

```python
odb.get_element_stress(ids, envelop_type: int=1, stage_id: int=1, result_kind: int=1, increment_type: int=1, case_name='')
```

获取单元应力,支持单个单元和单元列表

#### 参数

>     ids: 单元编号,支持整数或整数型列表
>     envelop_type:施工阶段包络类型 1-最大 2-最小 3-包络
>     stage_id: 施工阶段号 -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     result_kind: 施工阶段数据类型：1-合计，2-预应力，3-收缩徐变，4-恒载
>     increment_type: 1-全量    2-增量
>     case_name: 运营阶段所需荷载工况名

#### 示例

```python
from qtmodel import odb
    odb.get_element_stress(ids=1,stage_id=1)
    odb.get_element_stress(ids=[1,2,3],stage_id=1)
    odb.get_element_stress(ids=1,stage_id=-1,case_name="工况名")
```

#### 返回

>     list[dict]: 返回结构随单元类型变化。梁/杆/索/连接含 ``element_id``、
>     ``stress_i``、``stress_j``，每端包含角点应力和轴力/弯矩应力分量；
>     板含 I/J/K/L 上表面 ``stress_i/j/k/l`` 与下表面
>     ``stress_i2/j2/k2/l2``，每点为 ``{Sx,Sy,Sxy,S1,S2}``；组合梁的
>     I/J 为主材，I2/J2 为辅材。

### `odb.get_element_force`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_element_force`

```python
odb.get_element_force(ids, stage_id: int=1, envelop_type: int=1, result_kind: int=1, increment_type: int=1, case_name='', is_time_history: bool=False, is_boundary_element: bool=False)
```

获取单元内力,支持单个单元和单元列表

#### 参数

>     ids: 单元编号支持整数或整数列表且支持XtoYbyN形式字符串
>     stage_id: 施工阶段号 -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     envelop_type: 1-最大 2-最小 3-包络
>     result_kind: 施工阶段数据类型：1-合计，2-预应力，3-收缩徐变，4-恒载
>     increment_type: 1-全量    2-增量
>     case_name: 运营阶段所需荷载工况名
>     is_time_history: 是否为时程分析
>     is_boundary_element: 是否为时程分析边界单元连接

#### 示例

```python
from qtmodel import odb
    odb.get_element_force(ids=1,stage_id=1)
    odb.get_element_force(ids=[1,2,3],stage_id=1)
    odb.get_element_force(ids=1,stage_id=-1,case_name="工况名")
```

#### 返回

>     list[dict]: 梁单元含 ``element_id``、``force_i``、``force_j``，
>     每端为 ``{Fx,Fy,Fz,Mx,My,Mz}``；索/杆按桁架格式返回 ``Ni/Nj``
>     及 I/J 端 ``Fx/Fy/Fz``；板单元含 I/J/K/L 四点内力；时程结果另含
>     ``time``。``is_boundary_element=True`` 仅用于时程边界连接结果。

### `odb.get_self_concurrent_reaction`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_self_concurrent_reaction`

```python
odb.get_self_concurrent_reaction(node_id: int, case_name: str)
```

获取自并发反力

#### 参数

>   node_id:单个节点号
>   case_name:工况号

#### 示例

```python
from qtmodel import odb
  odb.get_self_concurrent_reaction(node_id=1,case_name="工况1_Fx最大")
```

#### 返回

>     dict: 单个反力字典 ``{node_id,fx,fy,fz,mx,my,mz}``，不是列表。
>     ``case_name`` 必须使用结果库中的完整自并发结果名，通常带
>     ``_Fx最大`` 等控制分量后缀。

### `odb.get_all_concurrent_reaction`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_all_concurrent_reaction`

```python
odb.get_all_concurrent_reaction(node_id: int, case_name: str)
```

获取完全并发反力

#### 参数

>   node_id:单个节点号
>   case_name:工况号

#### 示例

```python
from qtmodel import odb
  odb.get_all_concurrent_reaction(node_id=1,case_name="工况1_Fx最大")
```

#### 返回

>     list[dict]: 荷载组合全部组成项在目标节点处的反力列表；每项为
>     ``{node_id,fx,fy,fz,mx,my,mz}``。

### `odb.get_concurrent_force`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_concurrent_force`

```python
odb.get_concurrent_force(ids=None, case_name: str='')
```

获取单元并发内力

#### 参数

>   ids:单元号支持XtoYbyN形式字符串
>   case_name:工况号

#### 示例

```python
from qtmodel import odb
  odb.get_concurrent_force(ids=1,case_name="工况1_Fx最大")
  odb.get_concurrent_force(ids="1to19",case_name="工况1_Fx最大")
```

#### 返回

>     list[dict]: 按单元类型返回与 :meth:`get_element_force` 相同的内力字典。
>     ``case_name`` 必须是带控制分量/最大最小后缀的并发结果名称。

### `odb.get_elastic_link_force`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_elastic_link_force`

```python
odb.get_elastic_link_force(ids, result_kind=1, stage_id=-1, envelop_type=0, increment_type=1, case_name='')
```

获取弹性连接内力

#### 参数

>     ids: 弹性连接ID集合,支持整数和整数列表且支持XtoYbyN字符串
>     result_kind: 施工阶段荷载类型1-合计 2-预应力 3-收缩徐变 4-恒载
>     stage_id: -1为运营阶段 0-施工阶段包络 n-施工阶段
>     envelop_type: 包络类型，1-最大 2-最小
>     increment_type: 增量类型，1-全量 2-增量
>     case_name: 工况名称，默认为空

#### 示例

```python
from qtmodel import odb
    odb.get_elastic_link_force(ids=[1,2,3], result_kind=1, stage_id=1)
```

#### 返回

>     list[dict]: 每项仍使用通用节点力字段
>     ``{node_id,fx,fy,fz,mx,my,mz}``；其中 ``node_id`` 在本方法中实际
>     表示弹性连接 ID，而不是模型节点号。

### `odb.get_constrain_equation_force`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_constrain_equation_force`

```python
odb.get_constrain_equation_force(ids, result_kind=1, stage_id=1, envelop_type=0, increment_type=1, case_name='')
```

查询约束方程内力

#### 参数

>     ids: 约束方程ID列表支持整数和整数列表且支持XtoYbyN字符串
>     result_kind: 施工阶段荷载类型1-合计 2-预应力 3-收缩徐变 4-恒载
>     stage_id: -1为运营阶段 0-施工阶段包络 n-施工阶段
>     envelop_type: 包络类型，1-最大 2-最小
>     increment_type: 增量类型，1-全量 2-增量
>     case_name: 工况名称

#### 示例

```python
from qtmodel import odb
    odb.get_constrain_equation_force(ids=[1,2,3], result_kind=1, stage_id=1)
```

#### 返回

>     list[dict]: 每项仍使用 ``{node_id,fx,fy,fz,mx,my,mz}``；其中
>     ``node_id`` 在本方法中实际表示约束方程 ID。

### `odb.get_cable_element_length`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_cable_element_length`

```python
odb.get_cable_element_length(ids, stage_id=-1, increment_type=1)
```

查询无应力索长

#### 参数

>     ids: 索单元ID集合，支持整数和整数列表且支持XtoYbyN字符串
>     stage_id: 施工阶段ID,默认为运营阶段
>     increment_type: 1-全量，2-增量；运营阶段只返回成桥结果

#### 示例

```python
from qtmodel import odb
    odb.get_cable_element_length(ids=[1,2,3], stage_id=1)
```

#### 返回

>     list[dict]: 每项通常含 ``element_id``、``unstressed_length``、
>     I/J 端方向余弦 ``cos_a_xi/yi/zi``、``cos_a_xj/yj/zj`` 以及
>     I 到 J 的 ``dx/dy/dz``。

### `odb.get_period_and_vibration_results`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_period_and_vibration_results`

```python
odb.get_period_and_vibration_results()
```

获取当前模型全部自振模态的频率及参与质量结果。

仅在已完成自振特征值分析后有数据；列表按模态号升序排列。平动与转动
分量数组的固定顺序均为 ``[DX, DY, DZ, RX, RY, RZ]``。

#### 参数

>     无。

#### 示例

```python
from qtmodel import odb
    odb.get_period_and_vibration_results()
```

#### 返回

>     list[dict]: 每项通常包含：
>
>     - ``mode`` (int): 模态号，从 1 开始；
>     - ``angel_frequency`` (float): 角频率，字段名沿用服务端拼写；
>     - ``engineering_frequency`` (float): 工程频率；
>     - ``participate_mass`` (list[float]): 本阶参与质量，分量顺序见上；
>     - ``sum_participate_mass`` (list[float]): 累计参与质量；
>     - ``participate_factor`` (list[float]): 振型参与系数。
>
>     模型未求解、自振分析未启用或指定结果不存在时通常返回空列表。

### `odb.get_vibration_modal_results`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_vibration_modal_results`

```python
odb.get_vibration_modal_results(mode: int=1)
```

获取指定自振模态的节点振型向量。

#### 参数

>     mode (int): 模态号，从 1 开始，且不得大于本次分析实际求出的模态数。
>         默认 1。

#### 示例

```python
from qtmodel import odb
    odb.get_vibration_modal_results(mode=1)
```

#### 返回

>     list[dict]: 每个节点一项，结构为
>     ``{node_id, dx, dy, dz, rx, ry, rz}``。六个分量为归一化后的振型
>     分量，不是带实际量纲的运营位移。

### `odb.get_buckling_eigenvalue`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_buckling_eigenvalue`

```python
odb.get_buckling_eigenvalue()
```

获取线性屈曲分析的全部特征值。

#### 参数

>     无。

#### 示例

```python
from qtmodel import odb
    odb.get_buckling_eigenvalue()
```

#### 返回

>     list[dict]: 按模态号排列，每项为 ``{mode, eigenvalue}``：
>     ``mode`` 为从 1 开始的屈曲模态号，``eigenvalue`` 为相对于分析中
>     基准荷载组合的荷载放大系数。未完成屈曲分析时通常为空列表。

### `odb.get_buckling_modal_results`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_buckling_modal_results`

```python
odb.get_buckling_modal_results(mode: int=1)
```

获取指定线性屈曲模态的节点向量。

#### 参数

>     mode (int): 屈曲模态号，从 1 开始，不得大于已求得的模态数。
>         默认 1。

#### 示例

```python
from qtmodel import odb
    odb.get_buckling_modal_results(mode=1)
```

#### 返回

>     list[dict]: 每个节点一项，结构为
>     ``{node_id, dx, dy, dz, rx, ry, rz}``。结果为归一化模态向量，
>     只表示屈曲形态，不能直接当作真实位移。

### `odb.get_tendon_loss_results`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_tendon_loss_results`

```python
odb.get_tendon_loss_results(name: str, stage_id: int=1)
```

获取某根预应力钢束在指定施工阶段的应力/损失分布。

#### 参数

>     name (str): 钢束名称，必须与模型中的钢束名称完全一致。
>     stage_id (int): 施工阶段编号，从 1 开始；默认 1。该阶段必须已激活
>         此钢束并已具有施工阶段分析结果。

#### 示例

```python
from qtmodel import odb
    odb.get_tendon_loss_results(name="T1", stage_id=2)
```

#### 返回

>     list[dict]: 沿钢束/所属梁单元分点排列，每项字段为：
>     ``tendon_name`` 钢束名、``beam_id`` 梁单元号、``position`` 单元内
>     位置、``effective_s`` 有效应力、``instance_s`` 当前/瞬时应力、
>     ``except_s`` 期望或控制应力、``ratio`` 有效应力比。
>
>     各应力量纲跟随当前工程单位制；无匹配钢束或无该阶段结果时为空列表。

### `odb.get_tendon_position_result`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_tendon_position_result`

```python
odb.get_tendon_position_result(name: str)
```

获取一根预应力钢束离散后的三维全局坐标。

#### 参数

>     name (str): 钢束名称，区分模型中实际保存的名称；不得为空。

#### 示例

```python
from qtmodel import odb
    odb.get_tendon_position_result(name="T1")
```

#### 返回

>     list: 按钢束走向排列的坐标点。C# 源端元素为
>     ``Tuple<double, double, double>``；经 HTTP 序列化后通常表现为
>     ``[x, y, z]``，也可能表现为 ``{item1, item2, item3}``，调用方应同时
>     兼容两种 JSON 形态。坐标采用模型全局坐标系和当前长度单位。

### `odb.get_tendon_length_result`

源码：`qtmodel/odb/odb_result_data.py` · `OdbResultData.get_tendon_length_result`

```python
odb.get_tendon_length_result()
```

获取模型中各预应力钢束的长度、端部有效应力及伸长量汇总。

#### 参数

>     无。

#### 示例

```python
from qtmodel import odb
    odb.get_tendon_length_result()
```

#### 返回

>     list[dict]: 每根钢束一项，字段为：
>
>     - ``tendon_name``：钢束名称；
>     - ``start_stage``：开始参与计算的施工阶段；
>     - ``stress_length`` / ``un_stress_length``：有应力/无应力长度；
>     - ``effect_stress_i`` / ``effect_stress_j``：I/J 端有效应力；
>     - ``elongation_i`` / ``elongation_j``：I/J 端张拉伸长量；
>     - ``elongation``：总伸长量。
>
>     长度、应力均跟随工程当前单位制；仅在相关分析完成后有效。

## `odb_result_plot`

### `odb.plot_reaction_result`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_reaction_result`

```python
odb.plot_reaction_result(file_path: str='', stage_id: int=1, case_name: str='', show_increment: bool=False, envelop_type: int=1, component: int=1, show_number: bool=True, text_rotation=0, max_min_kind: int=-1, show_legend: bool=True, digital_count=3, text_exponential: bool=True, arrow_scale: float=1, is_time_history: bool=False, time_kind: int=1, time_tick: float=1.0)
```

保存结果图片到指定文件甲

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     component: 分量编号 1-Fx 2-Fy 3-Fz 4-Fxyz 5-Mx 6-My 7-Mz 8-Mxyz
>     show_number: 数值选项卡开启
>     show_legend: 图例选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     arrow_scale:箭头大小
>     is_time_history:是否为时程分析结果
>     time_kind:时程分析类型 1-时刻 2-最大 3-最小
>     time_tick:时程分析时刻

#### 示例

```python
from qtmodel import odb
    odb.plot_reaction_result(file_path=r"D:\图片\反力图.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_displacement_result`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_displacement_result`

```python
odb.plot_displacement_result(file_path: str='', stage_id: int=1, case_name: str='', show_increment: bool=False, envelop_type: int=1, component: int=1, show_deformed: bool=True, deformed_scale: float=1.0, deformed_actual: bool=False, show_number: bool=True, text_rotation=0, max_min_kind: int=1, show_legend: bool=True, digital_count=3, text_exponential: bool=True, show_undeformed: bool=True, is_time_history: bool=False, deform_kind: int=1, time_kind: int=1, time_tick: float=1.0)
```

保存结果图片到指定文件甲

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     component: 位移分量编号 1-Dx 2-Dy 3-Dz 4-Rx 5-Ry 6-Rz
>         7-Dxy 8-Dyz 9-Dxz 10-Dxyz
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     show_undeformed: 显示变形前
>     is_time_history:是否为时程分析结果
>     time_kind:时程分析类型 1-时刻 2-最大 3-最小
>     deform_kind:时程分析变形类型 1-位移 2-速度 3-加速度
>     time_tick:时程分析时刻

#### 示例

```python
from qtmodel import odb
    odb.plot_displacement_result(file_path=r"D:\图片\变形图.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_beam_element_force`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_beam_element_force`

```python
odb.plot_beam_element_force(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, component: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1, is_time_history: bool=False, time_kind: int=1, time_tick: float=1.0)
```

绘制梁单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     component: 梁内力分量，仅支持 1-Fx 2-Fy 3-Fz 4-Mx 5-My 6-Mz；
>         旧文档中的 Dx/Dy 等位移分量不适用于本方法
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部
>     is_time_history:是否为时程分析结果
>     time_kind:时程分析类型 1-时刻 2-最大 3-最小
>     time_tick:时程分析时刻

#### 示例

```python
from qtmodel import odb
    odb.plot_beam_element_force(file_path=r"D:\图片\梁内力.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_truss_element_force`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_truss_element_force`

```python
odb.plot_truss_element_force(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, component: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1, is_time_history: bool=False, time_kind: int=1, time_tick: float=1.0)
```

绘制杆单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     component: 分量编号 0-N 1-Fx 2-Fy 3-Fz
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部
>     is_time_history:是否为时程分析结果
>     time_kind:时程分析类型 1-时刻 2-最大 3-最小
>     time_tick:时程分析时刻

#### 示例

```python
from qtmodel import odb
    odb.plot_truss_element_force(file_path=r"D:\图片\杆内力.png",case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_plate_element_force`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_plate_element_force`

```python
odb.plot_plate_element_force(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, force_kind: int=1, component: int=1, show_number: bool=False, text_rotate: int=0, max_min_kind: int=1, show_deformed: bool=True, deformed_scale: float=1.0, deformed_actual: bool=False, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, is_time_history: bool=False, time_kind: int=1, time_tick: float=1.0)
```

绘制板单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     component: 分量编号 1-Fxx 2-Fyy 3-Fxy 4-Mxx 5-Myy 6-Mxy
>     force_kind: 内力选项 1-单元 2-节点平均
>     case_name: 详细荷载工况名
>     stage_id: 阶段编号
>     envelop_type: 包络类型
>     show_number: 是否显示数值
>     show_deformed: 是否显示变形形状
>     show_undeformed: 是否显示未变形形状
>     deformed_actual: 是否显示实际变形
>     deformed_scale: 变形比例
>     show_legend: 是否显示图例
>     text_rotate: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 是否以指数形式显示
>     max_min_kind: 最大最小值显示类型
>     show_increment: 是否显示增量结果
>     is_time_history:是否为时程分析结果
>     time_kind:时程分析类型 1-时刻 2-最大 3-最小
>     time_tick:时程分析时刻

#### 示例

```python
from qtmodel import odb
    odb.plot_plate_element_force(file_path=r"D:\图片\板内力.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_composite_beam_force`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_composite_beam_force`

```python
odb.plot_composite_beam_force(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, mat_type: int=1, component: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1)
```

绘制组合梁单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     mat_type: 材料类型 1-主材 2-辅材 3-主材+辅材
>     component: 分量编号 1-Fx 2-Fy 3-Fz 4-Mx 5-My 6-Mz
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部

#### 示例

```python
from qtmodel import odb
    odb.plot_composite_beam_force(file_path=r"D:\图片\组合梁内力.png",mat_type=0,component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_beam_element_stress`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_beam_element_stress`

```python
odb.plot_beam_element_stress(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, component: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1)
```

绘制梁单元应力结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     component: 分量编号 1-轴力 2-Mzx 3-My 4-组合包络 5-左上 6-右上 7-右下 8-左下
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部

#### 示例

```python
from qtmodel import odb
    odb.plot_beam_element_stress(file_path=r"D:\图片\梁应力.png",show_line_chart=False,component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_truss_element_stress`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_truss_element_stress`

```python
odb.plot_truss_element_stress(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1)
```

绘制杆单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大  2-最小
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部

#### 示例

```python
from qtmodel import odb
    odb.plot_truss_element_stress(file_path=r"D:\图片\杆应力.png",case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_composite_beam_stress`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_composite_beam_stress`

```python
odb.plot_composite_beam_stress(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, mat_type: int=0, component: int=1, show_line_chart: bool=True, line_scale: float=1.0, flip_plot: bool=True, show_deformed: bool=True, deformed_actual: bool=False, deformed_scale: float=1.0, show_number: bool=False, text_rotation: int=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1)
```

绘制组合梁单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     stage_id: -1-运营阶段  0-施工阶段包络 n-施工阶段号
>     case_name: 详细荷载工况名,参考桥通结果输出,例如： CQ:成桥(合计)
>     show_increment: 是否显示增量结果
>     envelop_type: 施工阶段包络类型 1-最大 2-最小
>     mat_type: 材料类型 1-主材 2-辅材
>     component: 分量编号 1-轴力分量 2-Mz分量 3-My分量 4-包络 5-左上 6-右上 7-左下 8-右下
>     show_line_chart: 折线图选项卡开启
>     line_scale:折线图比例
>     flip_plot:反向绘制
>     show_deformed: 变形选项卡开启
>     deformed_scale:变形比例
>     deformed_actual:是否显示实际变形
>     show_number: 数值选项卡开启
>     text_rotation: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 指数显示开启
>     max_min_kind: 数值选项卡内最大最小值显示 0-不显示最大最小值  1-显示最大值和最小值  2-最大绝对值 3-最大值 4-最小值
>     show_legend: 图例选项卡开启
>     show_undeformed: 显示变形前
>     position: 位置编号 1-始端 2-末端 3-绝对最大 4-全部

#### 示例

```python
from qtmodel import odb
    odb.plot_composite_beam_stress(file_path=r"D:\图片\组合梁应力.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_plate_element_stress`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_plate_element_stress`

```python
odb.plot_plate_element_stress(file_path: str='', stage_id: int=1, case_name: str='合计', show_increment: bool=False, envelop_type: int=1, stress_kind: int=0, component: int=1, show_number: bool=False, text_rotate: int=0, max_min_kind: int=1, show_deformed: bool=True, deformed_scale: float=1.0, deformed_actual: bool=False, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False, position: int=1)
```

绘制板单元结果图并保存到指定文件

#### 参数

>     file_path: 保存路径名
>     component: 分量编号 1-Fxx 2-Fyy 3-Fxy 4-Mxx 5-Myy 6-Mxy
>     stress_kind: 力类型 1-单元 2-节点平均
>     case_name: 详细荷载工况名
>     stage_id: 阶段编号
>     envelop_type: 包络类型
>     show_number: 是否显示数值
>     show_deformed: 是否显示变形形状
>     show_undeformed: 是否显示未变形形状
>     deformed_actual: 是否显示实际变形
>     deformed_scale: 变形比例
>     show_legend: 是否显示图例
>     text_rotate: 数值选项卡内文字旋转角度
>     digital_count: 小数点位数
>     text_exponential: 是否以指数形式显示
>     max_min_kind: 最大最小值显示类型
>     show_increment: 是否显示增量结果
>     position: 位置 1-板顶 2-板底 3-绝对值最大

#### 示例

```python
from qtmodel import odb
    odb.plot_plate_element_stress(file_path=r"D:\图片\板应力.png",component=1,case_name="CQ:成桥(合计)",stage_id=-1)
Returns: Base64字符串
```

### `odb.plot_modal_result`

源码：`qtmodel/odb/odb_result_plot.py` · `OdbResultPlot.plot_modal_result`

```python
odb.plot_modal_result(file_path: str='', mode: int=1, mode_kind: int=1, show_number: bool=True, text_rotate: float=0, max_min_kind: int=1, show_legend: bool=True, digital_count: int=3, text_exponential: bool=True, show_undeformed: bool=False)
```

绘制模态结果，可选择自振模态和屈曲模态结果

#### 参数

>    file_path: 保存路径名
>    mode: 模态号
>    mode_kind: 1-自振模态 2-屈曲模态
>    show_number: 是否显示数值
>    show_undeformed: 是否显示未变形形状
>    show_legend: 是否显示图例
>    text_rotate: 数值选项卡内文字旋转角度
>    digital_count: 小数点位数
>    text_exponential: 是否以指数形式显示
>    max_min_kind: 最大最小值显示类型

#### 示例

```python
from qtmodel import odb
   odb.plot_modal_result(file_path=r"D:\图片\自振模态.png",mode=1)
   odb.plot_modal_result(file_path=r"D:\图片\屈曲模态.png",mode=1,mode_kind=2)
Returns: Base64字符串
```

## `odb_view`

### `odb.display_node_id`

源码：`qtmodel/odb/odb_view.py` · `OdbView.display_node_id`

```python
odb.display_node_id(show_id: bool=True)
```

打开或关闭节点编号显示。

#### 参数

>     show_id (bool): ``True`` 显示全部可见节点的编号，``False`` 隐藏。

#### 示例

```python
from qtmodel import odb
    odb.display_node_id()
    odb.display_node_id(False)
```

#### 返回

>     str: 服务端执行信息；该返回值不是节点编号数据。

### `odb.display_element_id`

源码：`qtmodel/odb/odb_view.py` · `OdbView.display_element_id`

```python
odb.display_element_id(show_id: bool=True)
```

设置单元号显示

#### 参数

>     show_id (bool): ``True`` 显示全部可见单元编号，``False`` 隐藏。

#### 示例

```python
from qtmodel import odb
    odb.display_element_id()
    odb.display_element_id(False)
```

#### 返回

>     str: 服务端执行信息。

### `odb.set_view_camera`

源码：`qtmodel/odb/odb_view.py` · `OdbView.set_view_camera`

```python
odb.set_view_camera(camera_point: tuple[float, float, float], focus_point: tuple[float, float, float], camera_rotate: tuple[float, float, float]=(45, 45, 0), scale: float=0.5)
```

通过相机点、焦点、旋转量和缩放系数设置三维相机。

#### 参数

>     camera_point (tuple[float, float, float]): 相机全局坐标 ``(x,y,z)``。
>     focus_point (tuple[float, float, float]): 相机注视点全局坐标 ``(x,y,z)``。
>     camera_rotate (tuple[float, float, float]): 绕 X/Y/Z 的旋转角度，单位为度。
>     scale (float): 视图缩放系数，必须为正数；小于 1 缩小、大于 1 放大。

#### 示例

```python
from qtmodel import odb
    odb.set_view_camera(camera_point=(-100,-100,100),focus_point=(0,0,0))
```

#### 返回

>     str: 服务端执行信息。

#### 警告

>     当前 C# ``UIViewOperator.SetViewCamera`` 校验数组长度为 10，却读取
>     ``direction[10]``；按现有源码调用会发生越界。修复服务端为读取
>     ``direction[9]`` 后本接口才能可靠工作。

### `odb.set_view_direction`

源码：`qtmodel/odb/odb_view.py` · `OdbView.set_view_direction`

```python
odb.set_view_direction(direction: int=1, horizontal_degree: float=0, vertical_degree: float=0, scale: float=1)
```

切换预设观察方向，并叠加水平/竖向旋转与缩放。

#### 参数

>     direction (int): 预设编号，仅使用 1~10：1 空间视图1、2 前视图、
>         3 空间视图2、4 左视图、5 顶视图、6 右视图、7 空间视图3、
>         8 后视图、9 空间视图4、10 底视图。
>     horizontal_degree (float): 水平附加旋转角，单位为度。
>     vertical_degree (float): 竖向附加旋转角，单位为度。
>     scale (float): 正缩放系数，1 表示预设默认比例。

#### 示例

```python
from qtmodel import odb
   odb.set_view_direction(direction=1,scale=1.2)
```

#### 返回

>     str: 服务端执行信息。

### `odb.activate_structure`

源码：`qtmodel/odb/odb_view.py` · `OdbView.activate_structure`

```python
odb.activate_structure(node_ids=None, element_ids=None)
```

将给定节点和单元设为当前可见/活动结构。

#### 参数

>     node_ids (int | list[int] | str | None): 节点号；字符串支持
>         ``"1to10"``、``"1to10by2"``。``None`` 表示不限定节点。
>     element_ids (int | list[int] | str | None): 单元号，格式同上。
>         两者均为空时用于恢复全部结构。

#### 示例

```python
from qtmodel import odb
   odb.activate_structure(node_ids=[1,2,3],element_ids=[1,2,3])
```

#### 返回

>     str: 服务端执行信息，不返回活动结构列表。

### `odb.set_unit`

源码：`qtmodel/odb/odb_view.py` · `OdbView.set_unit`

```python
odb.set_unit(unit_force: str='KN', unit_length: str='MM')
```

修改结果图和窗口标注采用的显示单位，不转换模型输入数据。

#### 参数

>     unit_force (str): 力单位，支持 ``N``、``KN``、``TONF``、``KIPS``、
>         ``LBF``；建议使用大写。
>     unit_length (str): 长度单位，支持 ``M``、``MM``、``CM``、``IN``、
>         ``FT``；建议使用大写。

#### 示例

```python
from qtmodel import odb
   odb.set_unit(unit_force="N",unit_length="M")
```

#### 返回

>     str: 服务端确认信息。设置只作用于显示和后续结果图。

### `odb.reset_display`

源码：`qtmodel/odb/odb_view.py` · `OdbView.reset_display`

```python
odb.reset_display()
```

清除当前窗口中边界、荷载、钢束等附加显示，恢复基础模型显示。

#### 参数

>     无。

#### 示例

```python
from qtmodel import odb
   odb.reset_display()
```

#### 返回

>     str: 服务端执行信息；不会删除对应模型数据。

### `odb.save_png`

源码：`qtmodel/odb/odb_view.py` · `OdbView.save_png`

```python
odb.save_png(file_path: str)
```

将当前模型窗口保存为 PNG；路径为空时直接返回图像 Base64。

#### 参数

>     file_path (str): PNG 完整路径；父目录应已存在。传 ``""`` 时不写盘，
>         返回当前窗口 PNG 的 Base64 字符串。

#### 示例

```python
from qtmodel import odb
   odb.save_png(file_path="D:\QT\aa.png")
```

#### 返回

>     str: 非空路径时为服务端保存确认信息；空路径时为 PNG Base64 字符串。

### `odb.set_render`

源码：`qtmodel/odb/odb_view.py` · `OdbView.set_render`

```python
odb.set_render(flag: bool=True)
```

设置实体/截面的消隐渲染开关。

#### 参数

>     flag (bool): ``True`` 开启消隐渲染，``False`` 使用非消隐/线框显示。

#### 示例

```python
from qtmodel import odb
   odb.set_render(flag=True)
```

#### 返回

>     str: 服务端执行信息。

### `odb.change_construct_stage`

源码：`qtmodel/odb/odb_view.py` · `OdbView.change_construct_stage`

```python
odb.change_construct_stage(stage: int=0)
```

切换当前窗口显示的施工阶段。

#### 参数

>     stage (int): 施工阶段号；0 表示基本模型，正整数表示对应施工阶段。
>         当前 C# HTTP 接收类型为 ``int``，不能按旧说明传阶段名称字符串。

#### 示例

```python
from qtmodel import odb
   odb.change_construct_stage(0)
   odb.change_construct_stage(stage=1)
```

#### 返回

>     str: 服务端执行信息。仅改变当前显示阶段，不执行重新求解。

### `odb.get_current_png`

源码：`qtmodel/odb/odb_view.py` · `OdbView.get_current_png`

```python
odb.get_current_png()
```

获取当前窗口 PNG 图像的 Base64 编码。

#### 参数

>     无。

#### 示例

```python
from qtmodel import odb
    odb.get_current_png()
```

#### 返回

>     str: PNG 二进制内容的 Base64 字符串，通常不含文件路径。

# CDB：结构检算

## `cdb_concrete_check`

### `cdb.add_check_load_combine`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_check_load_combine`

```python
cdb.add_check_load_combine(name: str='', combine_type: int=1, standard: int=1, combine_method: int=1, combine_info: Optional[list[tuple[str, float, float]]]=None)
```

添加混凝土检算荷载组合

#### 参数

>     name: 名称
>     combine_type: 组合类型
>         -JTG-D60: 1-基本 2-偶然 3-标准 4-频遇 5-准永久 6-疲劳 7-临时
>         -TB-2017： 1-主力 2-主加附 3-主加特殊 4-临时
>     standard: 规范类型，1-JTG D60-2015，2-TB 2017
>     combine_method: 组合方式 1-相加并判别  2-包络
>     combine_info: 荷载组合明细，格式为 [(荷载工况, 不利系数, 有利系数)]

#### 示例

```python
from qtmodel import cdb
   cdb.add_check_load_combine(name="P1+P2", combine_info=[("P1 (ST)", 1, 1)])
Returns: QtServer.send_dict 的返回值
```

### `cdb.remove_check_load_combine`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_check_load_combine`

```python
cdb.remove_check_load_combine(name: str='')
```

删除混凝土检算荷载组合

#### 参数

>     name: 名称

#### 示例

```python
from qtmodel import cdb
   cdb.remove_check_load_combine(name="P1+P2")
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_concrete_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_concrete_check_case`

```python
cdb.add_concrete_check_case(name: str='', standard: int=1, structure_type: int=1, group_name: Union[str, list[str]]='默认结构组', component_force_type: int=1, user_force_type: Optional[list[bool]]=None, cal_setting_type: int=0)
```

添加混凝土检算工况

#### 参数

>     name: 名称。
>     standard: 规范类型。
>         1 - JTG 3362-2018
>         2 - TB 10092-2017
>
>     structure_type: 结构类型，按后端结构类型枚举取值。
>
>     group_name: 结构组名称或结构组名称列表。
>         支持：
>             "默认结构组"
>             ["默认结构组", "结构组1"]
>
>     component_force_type: 构件受力类型。
>         0 - 自动判别受力构件
>         1 - 轴向受压（拉）构件，主要考虑 Fx
>         2 - 竖向平面受弯构件，主要考虑 Fz、My
>         3 - 横向平面受弯构件，主要考虑 Fy、Mz
>         4 - 双向空间受弯构件，主要考虑 Fy、Fz、My、Mz
>         5 - 竖向平面压（拉）弯构件，主要考虑 Fx、Fz、My
>         6 - 横向平面压（拉）弯构件，主要考虑 Fx、Fy、Mz
>         7 - 双向空间压（拉）弯构件，主要考虑 Fx、Fy、Fz、My、Mz
>         8 - 自定义，使用 user_force_type 指定参与检算的受力分量
>
>     user_force_type: 自定义受力分量列表，仅当 component_force_type=8 时使用。
>         格式为 [Fx, Fy, Fz, Mx, My, Mz]。
>         例如：
>             [True, False, True, False, True, False]
>         表示参与 Fx、Fz、My。
>
>     cal_setting_type: 计算设置类型，按后端计算设置枚举取值。
>         0 - 默认计算设置

#### 示例

```python
from qtmodel import cdb
    cdb.add_concrete_check_case(
        name="混凝土检算",
        standard=1,
        structure_type=1,
        group_name="默认结构组",
        component_force_type=0
    )
    cdb.add_concrete_check_case(
        name="自定义受力检算",
        standard=1,
        structure_type=1,
        group_name=["默认结构组"],
        component_force_type=8,
        user_force_type=[True, False, True, False, True, False]
    )
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.get_concrete_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_concrete_check_case`

```python
cdb.get_concrete_check_case(name: str='')
```

获取当前混凝土检算工况信息。

#### 参数

>     name: 工况名称。为空时返回当前模型中编号最大的混凝土检算工况。

#### 示例

```python
from qtmodel import cdb
    cdb.get_concrete_check_case()
    cdb.get_concrete_check_case(name="混凝土检算")
```

#### 返回

>     QtServer.send_dict 的返回值。返回字段包括：
>         name: 工况名称。
>         standard: 规范类型，取值与 add_concrete_check_case 的 standard 一致。
>         structure_type: 结构类型，取值与 add_concrete_check_case 的 structure_type 一致。
>         group_name: 结构组名称列表。
>         component_force_type: 构件受力类型。
>         user_force_type: 自定义受力分量列表，格式为 [Fx, Fy, Fz, Mx, My, Mz]。
>         cal_setting_type: 检算荷载组合设置类型。

### `cdb.remove_concrete_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_concrete_check_case`

```python
cdb.remove_concrete_check_case(name: str='')
```

删除混凝土检算工况

#### 参数

>     name: 名称

#### 示例

```python
from qtmodel import cdb
   cdb.remove_concrete_check_case(name="混凝土检算")
Returns: QtServer.send_dict 的返回值
```

### `cdb.import_concrete_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.import_concrete_check_case`

```python
cdb.import_concrete_check_case(case_name: str='', read_timeout: int=600)
```

导入并同步混凝土检算工况数据。
该接口对应 C# 端 ConcreteCheckActions.ImportCheckCase(caseName)，
用于将 ProjectManager 中已有检算工况同步生成/更新为 CSAN 检算数据。

#### 参数

>     case_name: 工况名，必须已存在于 ProjectManager 的混凝土检算工况列表中。
>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
   cdb.import_concrete_check_case(case_name="混凝土检算")
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.solve_concrete_check`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.solve_concrete_check`

```python
cdb.solve_concrete_check(show_view: bool=False, modal: bool=True, auto_close: bool=True, read_timeout: int=600, wait: bool=False, poll_interval: float=2.0, max_wait: Optional[float]=None, status_read_timeout: int=30, sync: bool=False)
```

执行混凝土检算分析。

#### 参数

>     show_view: 是否显示混凝土检算分析进度窗口。
>         True  - 显示分析进度窗口，并通过窗口执行/展示检算过程。
>         False - 不显示分析进度窗口，直接执行混凝土检算分析。
>
>     modal: 是否以模态窗口方式显示，仅当 show_view=True 时有效。
>         True  - 使用 ShowDialog 显示窗口，窗口关闭后才返回。
>         False - 使用 Show 显示窗口，窗口显示后立即返回。
>     auto_close: 计算完成后是否自动关闭分析窗口，仅当 show_view=True 时有效（默认自动关闭，手动关闭不及时可能影响程序运行）
>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。
>     wait: 是否在 Python 侧轮询等待后台检算完成。False 时只启动任务并立即返回启动状态。
>     poll_interval: wait=True 时的轮询间隔，单位为秒。
>     max_wait: wait=True 时的最大等待时间，单位为秒；None 表示不限制。
>     status_read_timeout: 查询检算状态接口的超时时间，单位为秒。
>     sync: 是否要求后端同步执行旧逻辑。长模型不推荐使用，可能再次触发 HTTP 502/超时。

#### 示例

```python
from qtmodel import cdb
    # 启动后台混凝土检算，不显示分析窗口
    cdb.solve_concrete_check()
    # 启动后轮询等待完成
    cdb.solve_concrete_check(wait=True, max_wait=1800)
    # 显示分析窗口并执行混凝土检算
    cdb.solve_concrete_check(show_view=True)
    # 显示模态分析窗口，计算完成自动关闭，等待 1800 秒
    cdb.solve_concrete_check(
        show_view=True,
        modal=True,
        auto_close=True,
        read_timeout=1800
    )
```

#### 返回

>     wait=False 时返回启动状态；wait=True 时返回最终状态。

### `cdb.get_concrete_check_solve_status`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_concrete_check_solve_status`

```python
cdb.get_concrete_check_solve_status(read_timeout: int=30)
```

查询混凝土检算后台任务状态。

#### 参数

>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
   cdb.get_concrete_check_solve_status()
```

#### 返回

>     后端状态字典，典型字段包括 state、is_running、message、started_at、finished_at。

### `cdb.get_solve_concrete_check_status`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_solve_concrete_check_status`

```python
cdb.get_solve_concrete_check_status(read_timeout: int=30)
```

查询混凝土检算后台任务状态，保留与后端命令名一致的别名。

#### 参数

>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
   cdb.get_solve_concrete_check_status()
```

#### 返回

>     后端状态字典，典型字段包括 state、is_running、message、started_at、finished_at。

### `cdb.wait_concrete_check_solve`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.wait_concrete_check_solve`

```python
cdb.wait_concrete_check_solve(poll_interval: float=5, max_wait: Optional[float]=None, read_timeout: int=30)
```

轮询等待混凝土检算后台任务完成。

#### 参数

>     poll_interval: 状态查询间隔，单位为秒。
>     max_wait: 最大等待时间，单位为秒；None 表示不限制。
>     read_timeout: 单次状态查询的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
   cdb.wait_concrete_check_solve(poll_interval=5, max_wait=1800)
```

#### 返回

>     state 为 succeeded 时的状态字典。

#### 异常

>     RuntimeError: 后台任务 failed/canceled。
>     TimeoutError: 等待超过 max_wait。

### `cdb.update_check_material`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_check_material`

```python
cdb.update_check_material(name: str='', properties: Optional[list[float]]=None, model: int=1, parameter_data: Optional[list[float]]=None, curve_data: Optional[list[tuple[float, float]]]=None, user_material: int=1, user_standard: int=1)
```

根据材料详情更新混凝土检算材料。只有需要修改的材料才入CheckMaterialData，否则直接引用桥通前处理数据

#### 参数

>     name: 材料名称。
>     properties: 一般材料特性，依据材料规范填写，不可为空。
>         JTG 3362-2018 公路规范: [弹性模量, fcuk, fck, ftk, ftd]
>         JTG D62-2004 公路规范: [弹性模量, fcuk, fck, ftk, ftd]
>         TB 1002-2017 铁路规范: [弹性模量, fcuk, fc, ftc]
>         ASTM 美国材料试验协会: [弹性模量, fc', fr]
>         AASHTO: [弹性模量, fc', fr]
>         BS 5400-1990: [弹性模量, fcu]
>         铁路极限状态法: [弹性模量, fcuk, fck, fctk]
>     model: 应力应变曲线模型类型，详细参考parameter_data注释，混凝土材料中1-损伤演化模型...
>     parameter_data: 自定义模式参数。
>         混凝土材料:
>             1-损伤演化模型:
>                 [fcr, εcr, εcu, αc, 承载力计算极限强度, 极限应变]
>             2-修正 KentPark 模型:
>                 [fcr, ε0, ε1, εcu, ρv, σyh, 承载力计算极限强度]
>             3-有约束混凝土:
>                 [fc, fcc, ρs, fkh, 承载力计算极限强度, 极限应变]
>             4-无约束混凝土:
>                 [fc, εcc, εuu, 承载力计算极限强度, 极限应变]
>             5-钢管混凝土:
>                 [fc, ε0, εcu, 承载力计算极限强度, 极限应变]
>             6-美规:
>                 [fc, ε0, εcu, 承载力计算极限强度, 极限应变]
>             7-英规:
>                 [fc, ε0, εcu, 承载力计算极限强度, 极限应变]
>             8-自定义:
>                 [抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>         钢材:
>             1-中规:
>                 [fs, fsu, ε1, εsu, 抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>         预应力:
>             1-中规:
>                 [fp, fpu, ε1, εpu, 抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>             2-英规:
>                 [fp, fpu, εpu, 抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>             3-美规:
>                 [fpu, εpu, 正常使用极限状态分项系数, 承载能力极限状态分项系数]
>         钢筋:
>             1-中规:
>                 [fs, fsu, ε1, εsu, 抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>             2-英规:
>                 [fs, fsu, εsu, 抗拉强度与抗压强度比, 承载力计算极限强度, 极限应变]
>             3-美规:
>                 [fy, fsu, 正常使用极限状态分项系数, 承载能力极限状态分项系数]
>     curve_data: 自定义模式数据应力应变曲线，格式为 [(应变, 应力)]。
>     user_material: 自定义材料时的材料类型，1-混凝土，2-钢材，3-预应力，4-钢筋。
>     user_standard: 自定义材料时的规范类型，取值按对应材料类型的下拉顺序填写。
>         当 user_material=1（混凝土）:
>             1-JTG 3362-2018（公路）
>             2-JTG D62-2004（公路）
>             3-JTJ 024-1985（公路）
>             4-TB 10002-2017（铁路）
>             5-ASTM 美国材料试验协会
>             6-AASHTO 17/20/24
>             7-BS 5400-1990
>             8-铁路极限状态法25规范
>         当 user_material=2（钢材）:
>             1-JTG D64-2015（公路）
>             2-TB 10091-2017（铁路）
>             3-ASTM 美国材料试验协会
>             4-GB 50017-2017（钢构）
>             5-铁路极限状态法25规范
>         当 user_material=3（预应力）:
>             1-JTG 3362-2018（公路）
>             2-JTG D62-2004（公路）
>             3-JTJ 024-1985（公路）
>             4-TB 10002-2017（铁路）
>             5-国铁集团企业标准2022
>             6-ASTM 美国材料试验协会
>             7-铁路极限状态法25规范
>             8-BS5896-2012
>         当 user_material=4（钢筋）:
>             1-JTG 3362-2018（公路）
>             2-JTG D62-2004（公路）
>             3-JTJ 024-1985（公路）
>             4-TB 10002-2017（铁路）
>             5-铁路极限状态法25规范
>             6-ASTM 美国材料试验协会
>             7-BS 5400-1990

#### 示例

```python
from qtmodel import cdb
   cdb.update_check_material(name="混凝土", properties=[3.45e10, 5e7, 3.24e7, 2.65e6, 1.83e6], model=1)
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.open_concrete_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.open_concrete_check_case`

```python
cdb.open_concrete_check_case(name: str='', file_path: str='', read_timeout: int=600)
```

打开已有的混凝土检算工况。

#### 参数

>     name: 工况名称。当 file_path 为空时，后端会按  <默认检算数据目录_name.csa> 的方式解析文件路径。
>     file_path: 工况文件的完整路径。当提供 file_path 时，优先使用该路径，
>                不再通过 name 自动拼接默认路径。
>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
    cdb.open_concrete_check_case(name="ConcreteCaseUnit")
    cdb.open_concrete_check_case(file_path="D:/Temp/ConcreteCaseUnit.csa")
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.open_concrete_check_case_by_path`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.open_concrete_check_case_by_path`

```python
cdb.open_concrete_check_case_by_path(file_path: str='', read_timeout: int=600)
```

打开指定路径的CSAN检算工况，注意打开混凝土检算工况可能不在当前桥通工况列表

#### 参数

>     file_path: 工况文件的完整路径。当提供 file_path 时，优先使用该路径，
>                不再通过 name 自动拼接默认路径。
>     read_timeout: 等待 Qt 后端响应的超时时间，单位为秒。

#### 示例

```python
from qtmodel import cdb
    cdb.open_concrete_check_case(file_path="D:/Temp/ConcreteCaseUnit.csa")
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.save_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.save_check_case`

```python
cdb.save_check_case()
```

保存当前检算工况
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.save_check_case()
Returns: QtServer.send_dict 的返回值
```

### `cdb.save_as_check_case`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.save_as_check_case`

```python
cdb.save_as_check_case(file_path: str)
```

另存当前检算工况

#### 参数

>     file_path: 检算工况文件路径

#### 示例

```python
from qtmodel import cdb
   cdb.save_as_check_case(file_path="D:/Temp/case.cck")
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_check_case_basic_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_check_case_basic_info`

```python
cdb.update_check_case_basic_info(specification_type: int=1, design_safety_level: int=1, is_user_defined_gama0: bool=False, gama0: float=1.1, production_process: int=1, component_type: int=1, strengthening_design_method_type: int=1, shell_or_beam_type: int=1, structure_type: int=1, steel_type: str='Q345', steel_plate_thickness: float=16, load_modifier_factor_type: int=1, is_normal_section_bearing: bool=True, is_oblique_section_shear_bearing: bool=False, is_normal_section_stress: bool=False, is_shear_and_principal_stress: bool=False, is_crack_width: bool=False, is_normal_section_anti_crack: bool=False, is_oblique_section_anti_crack: bool=False, is_prestress_radio: bool=False, is_moment_curvature_curve: bool=False, is_pm_bearing_curve: bool=False, is_my_mz_bearing_curve: bool=False, is_cal_fatigue: bool=False, is_bending_capacity: bool=False, is_plastic_hinge_shear_capacity: bool=False, is_interface_shear_bearing: bool=False)
```

根据检算工况基础信息更新当前 CSAN2 BasicInfo。
对应 C# 调用链为 ConcreteCheckConverter.UpdateCheckCaseBasicInfo ->
CsanBasicInfoActions.UpdateCheckCaseBasicInfo -> BasicInfo.Update。
枚举型参数均按 C# 界面下拉框的 1 起始顺序传入；后端会校验枚举范围、
gama0 > 0、steel_plate_thickness > 0，并校验至少选择一个且符合当前规范、
构件类型、加固方式的规范计算项目。

#### 参数

>     specification_type: 检算规范类型。
>         1-《公路钢筋混凝土及预应力混凝土桥涵设计规范》(JTG 3362-2018)
>         2-《铁路桥涵混凝土结构设计规范》(TB 10092-2017 J 462-2017)
>         3-《公路钢混组合桥梁设计与施工规范》(JTG/T D64-01-2015)
>         4-BS 5400-4:1990
>         5-《铁路桥涵设计规范(极限状态法)》
>         6-AASHTO LRFD Bridge Design Specifications, 9th Edition, 2020
>         7-《公路桥梁抗震设计规范》(JTG/T 2231-01-2020)
>         8-《公路桥梁加固设计规范》(JTG/T 5431-2025)
>     design_safety_level: 设计安全等级。非美规且 is_user_defined_gama0=False 时，
>         计算转换按等级取结构重要性系数。
>         1-一级，gama0=1.1
>         2-二级，gama0=1.0
>         3-三级，gama0=0.9
>     is_user_defined_gama0: 是否自定义结构重要性系数。
>         True-使用 gama0；False-非美规按 design_safety_level 自动取值。
>         AASHTO_2020 不使用该字段，改用 load_modifier_factor_type。
>     gama0: 自定义结构重要性系数，必须大于 0。
>     production_process: 制作工艺类型。
>         1-预制构件
>         2-现场浇筑
>     component_type: 构件类型。
>         1-钢筋混凝土
>         2-B类构件
>         3-A类构件
>         4-全预应力构件
>     strengthening_design_method_type: 加固设计方法类型，主要用于 specification_type=8。
>         1-增大截面加固
>         2-粘贴钢板加固
>         3-粘贴纤维复合材料加固
>         4-增设体外预应力加固，C# 枚举存在但当前基础信息界面未启用，
>           在 JTG/T 5431-2025 校验中会报错。
>     shell_or_beam_type: 板或梁结构类型。
>         1-板式结构
>         2-梁式结构
>     structure_type: 结构类型。
>         1-桥跨结构及顶帽
>         2-其他结构
>     steel_type: 钢材牌号，按名称匹配，支持 Q235、Q345、Q370、Q390、Q420、Q460、Q500。
>     steel_plate_thickness: 钢材板厚，单位 mm。C# 接口按 int 接收，且必须大于 0；
>         主要用于 JTG/T D64-01-2015 钢混组合桥梁规范。
>     load_modifier_factor_type: 荷载调整系数 η，仅 AASHTO_2020 时参与前处理。
>         1-0.95
>         2-1.00
>         3-1.05
>         4-1.10
>     is_normal_section_bearing: 是否计算正截面承载力。
>     is_oblique_section_shear_bearing: 是否计算斜截面抗剪承载力。
>     is_normal_section_stress: 是否计算正截面应力。
>     is_shear_and_principal_stress: 是否计算剪应力与主应力。
>     is_crack_width: 是否计算裂缝宽度。
>     is_normal_section_anti_crack: 是否计算正截面抗裂。
>     is_oblique_section_anti_crack: 是否计算斜截面抗裂。
>     is_prestress_radio: 是否计算预应力度。字段名沿用后端 radio 拼写。
>     is_moment_curvature_curve: 是否计算弯矩曲率曲线分析。
>     is_pm_bearing_curve: 是否计算 PM 承载力曲线分析。
>     is_my_mz_bearing_curve: 是否计算 MyMz 承载力曲线分析。
>     is_cal_fatigue: 是否计算应力幅。当前 C# API 校验未将该项加入任何规范允许列表，
>         传 True 会触发“规范计算项目选择错误”。
>     is_bending_capacity: 是否计算弯曲能力。
>     is_plastic_hinge_shear_capacity: 是否计算塑性铰斜截面抗剪承载力。
>     is_interface_shear_bearing: 是否计算结合面抗剪承载力。
>         公共规则: 至少一个计算项目为 True，且所有 True 项必须在当前组合允许范围内。
>         JTG 3362-2018:
>             通用: 正截面承载力、斜截面抗剪承载力、正截面应力、剪应力与主应力、
>                   弯矩曲率曲线、PM 承载力曲线、MyMz 承载力曲线。
>             钢筋混凝土可额外选裂缝宽度；B类构件可额外选正截面抗裂、斜截面抗裂、
>             裂缝宽度；A类构件和全预应力构件可额外选正截面抗裂、斜截面抗裂。
>         TB 10092-2017:
>             通用同 JTG 3362-2018。
>             钢筋混凝土可额外选裂缝宽度；B类构件可额外选裂缝宽度、预应力度；
>             A类构件可额外选预应力度；全预应力构件可额外选正截面抗裂、预应力度。
>         JTG/T D64-01-2015:
>             通用: 正截面承载力、正截面应力、弯矩曲率曲线、PM 承载力曲线、
>                   MyMz 承载力曲线。
>             钢筋混凝土和 B类构件可额外选裂缝宽度。
>         BS 5400-4:1990:
>             通用: 正截面承载力、斜截面抗剪承载力、正截面应力。
>             钢筋混凝土和 B类构件可额外选裂缝宽度。
>         铁路极限状态法:
>             通用: 正截面承载力、斜截面抗剪承载力、正截面应力、剪应力与主应力。
>             钢筋混凝土和 B类构件可额外选裂缝宽度；A类构件可额外选预应力度；
>             全预应力构件可额外选正截面抗裂、预应力度。
>         AASHTO_2020:
>             通用: 正截面承载力、斜截面抗剪承载力、正截面应力。
>             钢筋混凝土可额外选裂缝宽度；B类构件可额外选裂缝宽度、剪应力与主应力；
>             A类构件和全预应力构件可额外选剪应力与主应力。
>         JTG/T 2231-01-2020:
>             可选正截面承载力、斜截面抗剪承载力、弯曲能力、塑性铰斜截面抗剪承载力、
>             弯矩曲率曲线、PM 承载力曲线、MyMz 承载力曲线。
>         JTG/T 5431-2025:
>             通用: 正截面承载力、斜截面抗剪承载力。
>             增大截面加固时可额外选结合面抗剪承载力；其中钢筋混凝土可选裂缝宽度，
>             B类构件可选正截面抗裂、斜截面抗裂、裂缝宽度，A类构件和全预应力构件
>             可选正截面抗裂、斜截面抗裂。
>             粘贴钢板加固或粘贴纤维复合材料加固时，钢筋混凝土和 B类构件可额外选裂缝宽度。

#### 示例

```python
from qtmodel import cdb
   cdb.update_check_case_basic_info(specification_type=1, design_safety_level=1)
   cdb.update_check_case_basic_info(
       specification_type=8,
       component_type=2,
       strengthening_design_method_type=1,
       is_normal_section_bearing=True,
       is_crack_width=True,
       is_interface_shear_bearing=True
   )

Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_basic_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_basic_info`

```python
cdb.get_check_case_basic_info()
```

获取检算工况基本信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_basic_info()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_material_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_material_info`

```python
cdb.get_check_case_material_info(material_id: int=1)
```

获取指定检算材料信息

#### 参数

>     material_id: 材料编号

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_material_info(material_id=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_material_infos`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_material_infos`

```python
cdb.get_check_case_material_infos()
```

获取全部检算材料信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_material_infos()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_material_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_material_data`

```python
cdb.get_check_material_data()
```

获取全部检算材料信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_material_data()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_vertical_prestress_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_vertical_prestress_info`

```python
cdb.get_check_case_vertical_prestress_info()
```

获取检算工况竖向预应力信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_vertical_prestress_info()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_stirrup_infos`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_stirrup_infos`

```python
cdb.get_check_case_stirrup_infos()
```

获取检算工况箍筋信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_stirrup_infos()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_stirrup_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_stirrup_data`

```python
cdb.get_stirrup_data()
```

获取全部箍筋信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_stirrup_data()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_section_loop`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_section_loop`

```python
cdb.get_check_case_section_loop()
```

获取检算工况截面线圈数据
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_section_loop()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_reinforcement_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_reinforcement_data`

```python
cdb.get_check_case_reinforcement_data()
```

获取检算工况普通钢筋数据
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_reinforcement_data()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_section_reinforcement_situation_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_section_reinforcement_situation_table_info`

```python
cdb.get_check_case_section_reinforcement_situation_table_info()
```

获取当前检算工况截面配筋信息表。
Args:无

#### 示例

```python
from qtmodel import cdb
    infos = cdb.get_check_case_section_reinforcement_situation_table_info()
    first_info = infos[0]
    print(first_info.section_id, first_info.reinforcement_ratio)
```

#### 返回

>     list[SectionReinforcementSituationTableInfo]: 截面配筋信息表记录列表。

### `cdb.get_check_case_prestress_tendon_sec_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_prestress_tendon_sec_info`

```python
cdb.get_check_case_prestress_tendon_sec_info()
```

获取当前检算工况截面预应力钢束信息。
Args:无

#### 示例

```python
from qtmodel import cdb
    infos = cdb.get_check_case_prestress_tendon_sec_info()
    first_info = infos[0]
    print(first_info.stage_id, first_info.unit_id)
```

#### 返回

>     list[PrestressTendonSecInfo]: 截面预应力钢束信息记录列表。

### `cdb.get_reinforcement_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_reinforcement_data`

```python
cdb.get_reinforcement_data()
```

获取全部纵向钢筋坐标信息
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_reinforcement_data()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_section_property`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_section_property`

```python
cdb.get_check_case_section_property()
```

获取检算工况截面特性
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_section_property()
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_element_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_element_table_info`

```python
cdb.update_element_table_info(element_info: Optional[list[float]]=None)
```

更新指定单元基本信息

#### 参数

>     element_info: 单个单元基本信息行

#### 示例

```python
from qtmodel import cdb
   cdb.update_element_table_info(element_info=[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_combined_beam_element_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_combined_beam_element_table_info`

```python
cdb.update_combined_beam_element_table_info(combined_beam_element_table_info: Optional[list[float]]=None)
```

更新单行组合梁单元信息。

#### 参数

>     combined_beam_element_table_info: 单行组合梁单元信息，格式为：
>         [单元号, 辅材材料号, I端Pz, I端Myz, I端Mzz, J端Pz, J端Myz, J端Mzz, 结合施工阶段号, 结构类型]
>         后端会校验单元号、辅材钢材材料号、结合施工阶段号、结构类型是否有效。
>         结合施工阶段号必须存在于荷载表格“施工组合”中对应单元的 stage_id。
>         结构类型从 1 开始取值：
>             1-钢筋混凝土构件
>             2-预应力钢筋混凝土构件
>             3-钢结构构件
>             4-钢-钢筋混凝土组合结构(主材为钢)
>             5-钢-预应力混凝土组合结构(主材为钢)
>             6-钢筋混凝土-钢组合结构(主材为钢筋混凝土，用于加固设计)
>             7-预应力混凝土-钢组合结构(主材为预应力混凝土，用于加固设计)

#### 示例

```python
from qtmodel import cdb
   cdb.update_combined_beam_element_table_info(combined_beam_element_table_info=[1, 6, 0, 0, 0, 0, 0, 0, 35, 5])
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_element_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_element_table_info`

```python
cdb.get_element_table_info()
```

获取单元基本信息表
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_element_table_info()
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_combined_beam_element_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_combined_beam_element_table_info`

```python
cdb.get_combined_beam_element_table_info()
```

获取组合梁单元信息表
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.get_combined_beam_element_table_info()
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_element_torsion_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_element_torsion_stirrup`

```python
cdb.add_element_torsion_stirrup(ele_id: int, stirrup_i: int=1, stirrup_j: int=1)
```

添加或覆盖单个单元抗扭箍筋设置。

#### 参数

>     ele_id: 当前 ProjectManager StructureData 中的单元号。
>     stirrup_i: I 端抗扭箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j: J 端抗扭箍筋号，来自 ReinforcementData.StirrupItems。

#### 示例

```python
from qtmodel import cdb
   cdb.add_element_torsion_stirrup(ele_id=1, stirrup_i=1, stirrup_j=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_element_torsion_stirrups`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_element_torsion_stirrups`

```python
cdb.add_element_torsion_stirrups(element_stirrups: Optional[list[tuple[int, int, int]]]=None)
```

批量添加或覆盖单元抗扭箍筋设置。

#### 参数

>     element_stirrups: 单元抗扭箍筋数据列表，格式为
>         [(ele_id, stirrup_i, stirrup_j)]。

#### 示例

```python
from qtmodel import cdb
   cdb.add_element_torsion_stirrups(
       element_stirrups=[
           (1, 1, 1),
           (2, 1, 1)
       ]
   )
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_element_torsion_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_element_torsion_stirrup`

```python
cdb.update_element_torsion_stirrup(ele_id: int, stirrup_i: int=1, stirrup_j: int=1)
```

修改一个已有的单元抗扭箍筋设置。

#### 参数

>     ele_id: 单元号，该单元必须已经存在单元抗扭箍筋数据。
>     stirrup_i: I 端抗扭箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j: J 端抗扭箍筋号，来自 ReinforcementData.StirrupItems。

#### 示例

```python
from qtmodel import cdb
   cdb.update_element_torsion_stirrup(ele_id=1, stirrup_i=1, stirrup_j=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_element_torsion_stirrup_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_element_torsion_stirrup_data`

```python
cdb.get_element_torsion_stirrup_data(ele_id: int=-1, ele_ids: Optional[list[int]]=None)
```

获取单元抗扭箍筋数据。

#### 参数

>     ele_id: 单元号。大于 0 时只返回该单元数据。
>     ele_ids: 单元号列表。非空时只返回列表中单元的数据。

#### 示例

```python
from qtmodel import cdb
   infos = cdb.get_element_torsion_stirrup_data()
   infos = cdb.get_element_torsion_stirrup_data(ele_id=1)
   infos = cdb.get_element_torsion_stirrup_data(ele_ids=[1, 2])
```

#### 返回

>     list[ElementTorsionStirrupData]: 单元抗扭箍筋数据列表。

### `cdb.add_element_shear_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_element_shear_stirrup`

```python
cdb.add_element_shear_stirrup(ele_id: int, stirrup_i_y: int=1, stirrup_i_x: int=1, stirrup_j_y: int=1, stirrup_j_x: int=1)
```

添加或覆盖单个单元抗剪箍筋设置。

#### 参数

>     ele_id: 当前 ProjectManager StructureData 中的单元号。
>     stirrup_i_y: I 端竖向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_i_x: I 端横向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j_y: J 端竖向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j_x: J 端横向箍筋号，来自 ReinforcementData.StirrupItems。

#### 示例

```python
from qtmodel import cdb
   cdb.add_element_shear_stirrup(ele_id=1, stirrup_i_y=1, stirrup_i_x=1, stirrup_j_y=1, stirrup_j_x=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_element_shear_stirrups`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_element_shear_stirrups`

```python
cdb.add_element_shear_stirrups(element_stirrups: Optional[list[tuple[int, int, int, int, int]]]=None)
```

批量添加或覆盖单元抗剪箍筋设置。

#### 参数

>     element_stirrups: 单元箍筋数据列表，格式为
>         [(ele_id, stirrup_i_y, stirrup_i_x, stirrup_j_y, stirrup_j_x)].

#### 示例

```python
from qtmodel import cdb
   cdb.add_element_shear_stirrups(element_stirrups=[(1, 1, 1, 1, 1), (2, 1, 1, 1, 1)])
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_element_shear_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_element_shear_stirrup`

```python
cdb.update_element_shear_stirrup(ele_id: int, stirrup_i_y: int=1, stirrup_i_x: int=1, stirrup_j_y: int=1, stirrup_j_x: int=1)
```

修改一个已有的单元抗剪箍筋设置。

#### 参数

>     ele_id: 单元号，该单元必须已经存在单元箍筋数据。
>     stirrup_i_y: I 端竖向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_i_x: I 端横向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j_y: J 端竖向箍筋号，来自 ReinforcementData.StirrupItems。
>     stirrup_j_x: J 端横向箍筋号，来自 ReinforcementData.StirrupItems。

#### 示例

```python
from qtmodel import cdb
   cdb.update_element_shear_stirrup(ele_id=1, stirrup_i_y=1, stirrup_i_x=1, stirrup_j_y=1, stirrup_j_x=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_element_shear_stirrup_data`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_element_shear_stirrup_data`

```python
cdb.get_element_shear_stirrup_data(ele_id: int=-1, ele_ids: Optional[list[int]]=None)
```

获取单元抗剪箍筋数据。

#### 参数

>     ele_id: 单元号。大于 0 时只返回该单元数据。
>     ele_ids: 单元号列表。非空时只返回列表中单元的数据。

#### 示例

```python
from qtmodel import cdb
   infos = cdb.get_element_shear_stirrup_data()
   infos = cdb.get_element_shear_stirrup_data(ele_id=1)
   infos = cdb.get_element_shear_stirrup_data(ele_ids=[1, 2])
```

#### 返回

>     list[ElementShearStirrupData]: 单元抗剪箍筋数据列表。

### `cdb.remove_element_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_element_stirrup`

```python
cdb.remove_element_stirrup(ele_id: int=-1, remove_shear: bool=True, remove_torsion: bool=True)
```

删除单元箍筋设置。

#### 参数

>     ele_id: 单元号。小于等于 0 时删除全部单元箍筋设置。
>     remove_shear: 是否删除抗剪箍筋
>     remove_torsion: 是否删除抗扭箍筋

#### 示例

```python
from qtmodel import cdb
   cdb.remove_element_stirrup(ele_id=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_check_case_load_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_check_case_load_table_info`

```python
cdb.add_check_case_load_table_info(combine_type: int=1, element_id: int=1, force_i: Optional[list[float]]=None, force_j: Optional[list[float]]=None, combine_name: str='', load_type: Optional[int]=None)
```

添加一行检算荷载表数据

#### 参数

>     combine_type: 荷载表组合类型
>     element_id: 单元编号
>     force_i: I 端内力 [Fx, Fy, Fz, Mx, My, Mz]
>     force_j: J 端内力 [Fx, Fy, Fz, Mx, My, Mz]
>     combine_name: 组合名称
>     load_type: 荷载类型字段

#### 示例

```python
from qtmodel import cdb
   cdb.add_check_case_load_table_info(combine_type=1, element_id=1, force_i=[0, 0, 0, 0, 0, 0], force_j=[0, 0, 0, 0, 0, 0])
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_check_case_load_table_infos`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_check_case_load_table_infos`

```python
cdb.add_check_case_load_table_infos(combine_type: int=1, load_table: Optional[list[dict[str, Any]]]=None)
```

批量添加检算荷载表数据

#### 参数

>     combine_type: 荷载组合类型
>     load_table: 荷载表数据列表

#### 示例

```python
from qtmodel import cdb
   cdb.add_check_case_load_table_infos(load_type=1, load_table=[{"element_id": 1, "force_i": [0, 0, 0, 0, 0, 0], "force_j": [0, 0, 0, 0, 0, 0]}])
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_check_case_load_table_infos`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_check_case_load_table_infos`

```python
cdb.update_check_case_load_table_infos(load_type: int=1, load_table: Optional[list[dict[str, Any]]]=None)
```

更新检算荷载表数据

#### 参数

>     load_type: 荷载表类型
>     load_table: 荷载表数据列表,其中单位为kN、m

#### 示例

```python
from qtmodel import cdb
   cdb.update_check_case_load_table_infos(load_type=1, load_table=[])
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_load_table_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_load_table_info`

```python
cdb.get_check_case_load_table_info(combine_type: int=1, specific_load_type_name: str='')
```

获取检算荷载表信息

#### 参数

>     combine_type: 荷载表类型
>     specific_load_type_name: 指定荷载类型显示名称，为空时按 load_type 获取

#### 示例

```python
from qtmodel import cdb
   cdb.get_check_case_load_table_info(load_type=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_concrete_check_stress_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_concrete_check_stress_info`

```python
cdb.get_concrete_check_stress_info(stress_type: int=1, specific_load_type_name: str='')
```

获取混凝土检算应力信息。

#### 参数

>     stress_type: 应力组合类型，从 1 开始取值，顺序同 C# 应力界面组合选项。
>         详细表可查看 CdbConcreteCheck.STRESS_TYPE_OPTIONS。
>         非 AASHTO 2020：1-标准值组合，2-频遇组合，3-准永久值组合，4-主力组合，
>             5-主加附组合，6-施工组合，7-主加特殊组合，8-恒载作用，9-预应力作用，
>             10-使用组合Ⅰ，11-使用组合Ⅱ，12-使用组合Ⅲ，13-使用组合Ⅳ，14-永久作用组合。
>         AASHTO 2020：1-使用组合Ⅰ，2-使用组合Ⅱ，3-使用组合Ⅲ，4-使用组合Ⅳ，
>             5-永久作用组合，6-施工组合。
>     specific_load_type_name: 指定应力组合类型显示名称，为空时按 stress_type 获取。

#### 示例

```python
from qtmodel import cdb
   items = cdb.get_concrete_check_stress_info(stress_type=1)
   print(items[0].element_id, items[0].stress_i)
Returns: list[CheckStressItem]
```

### `cdb.update_concrete_check_stress_item`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_concrete_check_stress_item`

```python
cdb.update_concrete_check_stress_item(stress_type: int=1, stress_item: Optional[Union[CheckStressItem, dict[str, Any]]]=None, specific_load_type_name: str='')
```

更新单条混凝土检算应力信息。

#### 参数

>     stress_type: 应力组合类型，从 1 开始取值，顺序同 C# 应力界面组合选项。
>         详细表可查看 CdbConcreteCheck.STRESS_TYPE_OPTIONS。
>         非 AASHTO 2020：1-标准值组合，2-频遇组合，3-准永久值组合，4-主力组合，
>             5-主加附组合，6-施工组合，7-主加特殊组合，8-恒载作用，9-预应力作用，
>             10-使用组合Ⅰ，11-使用组合Ⅱ，12-使用组合Ⅲ，13-使用组合Ⅳ，14-永久作用组合。
>         AASHTO 2020：1-使用组合Ⅰ，2-使用组合Ⅱ，3-使用组合Ⅲ，4-使用组合Ⅳ，
>             5-永久作用组合，6-施工组合。
>     stress_item: 应力信息，支持 CheckStressItem 或 dict。
>     specific_load_type_name: 指定应力组合类型显示名称，为空时按 stress_type 获取。

#### 示例

```python
from qtmodel import cdb
   item = CheckStressItem(element_id=1, condition_name="LC1", stress_i=[1, 2, 3, 4], stress_j=[5, 6, 7, 8])
   cdb.update_concrete_check_stress_item(stress_type=1, stress_item=item)
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_concrete_check_stress_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_concrete_check_stress_info`

```python
cdb.update_concrete_check_stress_info(stress_type: int=1, stress_table: Optional[list[Union[CheckStressItem, dict[str, Any]]]]=None, specific_load_type_name: str='')
```

批量更新混凝土检算应力信息。

#### 参数

>     stress_type: 应力组合类型，从 1 开始取值，顺序同 C# 应力界面组合选项。
>         详细表可查看 CdbConcreteCheck.STRESS_TYPE_OPTIONS。
>         非 AASHTO 2020：1-标准值组合，2-频遇组合，3-准永久值组合，4-主力组合，
>             5-主加附组合，6-施工组合，7-主加特殊组合，8-恒载作用，9-预应力作用，
>             10-使用组合Ⅰ，11-使用组合Ⅱ，12-使用组合Ⅲ，13-使用组合Ⅳ，14-永久作用组合。
>         AASHTO 2020：1-使用组合Ⅰ，2-使用组合Ⅱ，3-使用组合Ⅲ，4-使用组合Ⅳ，
>             5-永久作用组合，6-施工组合。
>     stress_table: 应力信息列表，支持 CheckStressItem 或 dict。
>     specific_load_type_name: 指定应力组合类型显示名称，为空时按 stress_type 获取。

#### 示例

```python
from qtmodel import cdb
   item = CheckStressItem(element_id=1, condition_name="LC1", stress_i=[1, 2, 3, 4], stress_j=[5, 6, 7, 8])
   cdb.update_concrete_check_stress_info(stress_type=1, stress_table=[item])
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_check_case_result_info`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_check_case_result_info`

```python
cdb.get_check_case_result_info(result_type: str='', table_type: int=0, load_combination_type: str='', element_id: int=0, beam_end_mark: int=0, shear_direction_type: int=0)
```

获取检算结果信息。

#### 参数

>     result_type: 结果类型中文名称。可选值包括：
>         "正截面承载力"、"斜截面抗剪承载力"、"正截面应力"、"剪应力与主应力"、
>         "裂缝宽度"、"正截面抗裂"、"斜截面抗裂"、"预应力度"、"弯曲能力"、
>         "塑性铰斜截面抗剪承载力"、"弯矩曲率曲线分析"、"pm承载力曲线分析"、
>         "mymz承载力曲线分析"、"应力幅"。
>     table_type: 结果表类型，0 为默认表，1 为总表，2 为详表。
>     load_combination_type: 荷载组合类型名称，可选参数，仅详表需要
>     element_id: 单元编号，可选参数，仅详表需要
>     beam_end_mark: 梁端标记，0 为 I 端，1 为 J 端，2 为 IJ 端，可选参数，仅详表需要
>     shear_direction_type: 剪切方向类型，可选参数，仅斜截面抗剪总表需要 0-Vertical  1-Lateral  2-Bidirectional

#### 示例

```python
from qtmodel import cdb
    cdb.get_check_case_result_info(result_type="正截面承载力", table_type=1)
```

#### 返回

>     QtServer.send_dict 的返回值。

### `cdb.update_normal_section_bearing_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_normal_section_bearing_analysis_setting`

```python
cdb.update_normal_section_bearing_analysis_setting(normal_section_bearing_calculation_type: int=1)
```

更新正截面承载力分析设置

#### 参数

>     normal_section_bearing_calculation_type: 正截面承载力计算类型（从 1 开始的枚举序号）：
>         1 - 同比例变化
>         2 - 轴力不变
>         3 - My 不变
>         4 - Mz 不变
>         5 - 轴力与 My 不变
>         6 - 轴力与 Mz 不变
>         7 - My 与 Mz 不变

#### 示例

```python
from qtmodel import cdb
   cdb.update_normal_section_bearing_analysis_setting(normal_section_bearing_calculation_type=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_normal_section_bearing_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_normal_section_bearing_analysis_setting`

```python
cdb.get_normal_section_bearing_analysis_setting()
```

获取正截面承载力分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_normal_section_bearing_analysis_setting()
```

#### 返回

>     dict: 包含 normal_section_bearing_calculation_type，枚举取值含义与对应更新接口一致。

### `cdb.update_oblique_section_shear_bearing_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_oblique_section_shear_bearing_analysis_setting`

```python
cdb.update_oblique_section_shear_bearing_analysis_setting(reinforcement_height_multiple: float=1.0, is_consider_as_simple_support: bool=False, shear_strength_material_factor: float=1.0, oblique_section_shear_direction_type: int=1)
```

更新斜截面抗剪承载力分析设置

#### 参数

>     reinforcement_height_multiple: 配筋高度倍数
>     is_consider_as_simple_support: 是否按简支构件考虑
>     shear_strength_material_factor: 抗剪强度材料系数
>     oblique_section_shear_direction_type: 斜截面抗剪方向类型（从 1 开始的枚举序号）：
>         1 - 竖向（截面 z 向）
>         2 - 横向（截面 y 向）
>         3 - 双向

#### 示例

```python
from qtmodel import cdb
   cdb.update_oblique_section_shear_bearing_analysis_setting(reinforcement_height_multiple=1.0)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_oblique_section_shear_bearing_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_oblique_section_shear_bearing_analysis_setting`

```python
cdb.get_oblique_section_shear_bearing_analysis_setting()
```

获取斜截面抗剪承载力分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_oblique_section_shear_bearing_analysis_setting()
```

#### 返回

>     dict: 包含 reinforcement_height_multiple、is_consider_as_simple_support、
>         shear_strength_material_factor、oblique_section_shear_direction_type。

### `cdb.update_limit_state_method_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_limit_state_method_analysis_setting`

```python
cdb.update_limit_state_method_analysis_setting(cal_fatigue: bool=False, fatigue_limit_steel_bar: float=145.0, fatigue_limit_prestress: float=150.0, is_consider_as_simple_support: bool=False, is_consider_construction_load: bool=False)
```

更新极限状态法分析设置

#### 参数

>     cal_fatigue: 是否计算疲劳
>     fatigue_limit_steel_bar: 普通钢筋疲劳限值
>     fatigue_limit_prestress: 预应力筋疲劳限值
>     is_consider_as_simple_support: 是否按简支构件考虑
>     is_consider_construction_load: 是否考虑施工荷载

#### 示例

```python
from qtmodel import cdb
   cdb.update_limit_state_method_analysis_setting(cal_fatigue=True)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_limit_state_method_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_limit_state_method_analysis_setting`

```python
cdb.get_limit_state_method_analysis_setting()
```

获取极限状态法分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_limit_state_method_analysis_setting()
```

#### 返回

>     dict: 包含 cal_fatigue、fatigue_limit_steel_bar、fatigue_limit_prestress、
>         is_consider_as_simple_support、is_consider_construction_load。

### `cdb.update_normal_stress_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_normal_stress_analysis_setting`

```python
cdb.update_normal_stress_analysis_setting(aashto2020_normal_stress_rebar_type: int=1, tendon_allowable_stress_amplitude: float=69.0, flange_web_slenderness_ratio: float=15.0, construction_stage_concrete_tensile_limit: float=1.4, service_combination3_concrete_tension_limit: float=2.1)
```

更新正应力分析设置

#### 参数

>     aashto2020_normal_stress_rebar_type: AASHTO 2020 正应力钢筋类型（从 1 开始的枚举序号）：
>         1 - 直钢筋以及在高应力区域无交叉焊缝的焊接钢丝网
>         2 - 在高应力区域带有交叉焊缝的直焊接钢丝网
>     tendon_allowable_stress_amplitude: 钢束容许应力幅
>     flange_web_slenderness_ratio: 翼缘腹板宽厚比限值
>     construction_stage_concrete_tensile_limit: 施工阶段混凝土拉应力限值
>     service_combination3_concrete_tension_limit: 服务组合 3 混凝土拉应力限值

#### 示例

```python
from qtmodel import cdb
   cdb.update_normal_stress_analysis_setting(aashto2020_normal_stress_rebar_type=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_normal_stress_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_normal_stress_analysis_setting`

```python
cdb.get_normal_stress_analysis_setting()
```

获取正应力分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_normal_stress_analysis_setting()
```

#### 返回

>     dict: 包含 aashto2020_normal_stress_rebar_type、tendon_allowable_stress_amplitude、
>         flange_web_slenderness_ratio、construction_stage_concrete_tensile_limit、
>         service_combination3_concrete_tension_limit。

### `cdb.update_crack_width_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_crack_width_analysis_setting`

```python
cdb.update_crack_width_analysis_setting(highway_environment_category_type: int=1, railway_environment_category_type: int=1, railway_limit_environment_category_type: int=1, crack_setting_type: int=1, clear_protective_thickness: float=30.0, steel_bar_type: int=1, effect_coefficient_type: int=1, user_specified_effect_coefficient: float=0.0, is_epoxy_resin_rebar: bool=False, is_welded_rebar_skeleton: bool=False, mq_mg: float=1.0, protective_thickness: float=30.0, exposure_coefficient: float=1.0)
```

更新裂缝宽度分析设置

#### 参数

>     highway_environment_category_type: 公路环境类别（从 1 开始的枚举序号）：
>         1 - Ⅰ类：一般环境
>         2 - Ⅱ类：冻融环境
>         3 - Ⅲ类：近海或海洋氯化物环境
>         4 - Ⅳ类：除冰盐等其他氯化物环境
>         5 - Ⅴ类：盐结晶环境
>         6 - Ⅵ类：化学腐蚀环境
>         7 - Ⅶ类：磨蚀环境
>     railway_environment_category_type: 铁路环境类别（从 1 开始的枚举序号）：
>         1 - 碳化环境
>         2 - 氯盐环境
>         3 - 化学腐蚀环境
>         4 - 盐类结晶破坏环境
>         5 - 冻融破坏环境
>         6 - 磨蚀环境
>     railway_limit_environment_category_type: 铁路限值环境类别（从 1 开始的枚举序号）：
>         1 - 碳化环境
>         2 - 氯盐环境Ⅰ
>         3 - 氯盐环境Ⅱ
>         4 - 化学腐蚀环境Ⅰ
>         5 - 化学腐蚀环境Ⅱ
>         6 - 盐类结晶破坏环境Ⅰ
>         7 - 盐类结晶破坏环境Ⅱ
>         8 - 冻融破坏环境Ⅰ
>         9 - 冻融破坏环境Ⅱ
>         10 - 磨蚀环境Ⅰ
>         11 - 磨蚀环境Ⅱ
>     crack_setting_type: 裂缝限值类型（从 1 开始的枚举序号）：
>         1 - 0
>         2 - 0.10
>         3 - 0.15
>         4 - 0.20
>         5 - 0.25
>         6 - 禁止使用
>     clear_protective_thickness: 净保护层厚度
>     steel_bar_type: 钢筋类型（从 1 开始的枚举序号）：
>         1 - 带肋钢筋
>         2 - 光圆钢筋
>     effect_coefficient_type: 作用影响系数类型（从 1 开始的枚举序号）：
>         1 - 根据输入荷载由软件自动计算
>         2 - 用户指定（使用 user_specified_effect_coefficient）
>     user_specified_effect_coefficient: 用户指定效应系数
>     is_epoxy_resin_rebar: 是否为环氧树脂涂层钢筋
>     is_welded_rebar_skeleton: 是否为焊接钢筋骨架
>     mq_mg: 活载弯矩与恒载弯矩比值
>     protective_thickness: 保护层厚度
>     exposure_coefficient: 暴露系数

#### 示例

```python
from qtmodel import cdb
   cdb.update_crack_width_analysis_setting(crack_setting_type=1, protective_thickness=30.0)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_crack_width_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_crack_width_analysis_setting`

```python
cdb.get_crack_width_analysis_setting()
```

获取裂缝宽度分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_crack_width_analysis_setting()
```

#### 返回

>     dict: 包含 highway_environment_category_type、railway_environment_category_type、
>         railway_limit_environment_category_type、crack_setting_type、clear_protective_thickness、
>         steel_bar_type、effect_coefficient_type、user_specified_effect_coefficient、
>         is_epoxy_resin_rebar、is_welded_rebar_skeleton、mq_mg、protective_thickness、
>         exposure_coefficient。

### `cdb.update_moment_curvature_curve_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_moment_curvature_curve_analysis_setting`

```python
cdb.update_moment_curvature_curve_analysis_setting(moment_curvature_type: int=1, moment_curvature_model_type: int=1)
```

更新弯矩曲率曲线分析设置

#### 参数

>     moment_curvature_type: 弯矩曲率类型（从 1 开始的枚举序号）：
>         1 - 轴力 P 变化
>         2 - 弯矩 M 变化
>     moment_curvature_model_type: 弯矩曲率模型类型（从 1 开始的枚举序号）：
>         1 - 双线性模型
>         2 - 理想弹塑性模型

#### 示例

```python
from qtmodel import cdb
   cdb.update_moment_curvature_curve_analysis_setting(moment_curvature_type=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_moment_curvature_curve_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_moment_curvature_curve_analysis_setting`

```python
cdb.get_moment_curvature_curve_analysis_setting()
```

获取弯矩曲率曲线分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_moment_curvature_curve_analysis_setting()
```

#### 返回

>     dict: 包含 moment_curvature_type、moment_curvature_model_type，枚举取值含义与对应更新接口一致。

### `cdb.update_bearing_curve_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_bearing_curve_analysis_setting`

```python
cdb.update_bearing_curve_analysis_setting(bearing_curve_count: int=20, angle_between_m_and_y_axis: float=0.0, force_p: float=0.0)
```

更新承载力曲线分析设置

#### 参数

>     bearing_curve_count: 承载力曲线计算点数
>     angle_between_m_and_y_axis: 弯矩方向与 y 轴夹角
>     force_p: 轴力 P

#### 示例

```python
from qtmodel import cdb
   cdb.update_bearing_curve_analysis_setting(bearing_curve_count=20, force_p=0.0)
Returns: QtServer.send_dict 的返回值
```

### `cdb.get_bearing_curve_analysis_setting`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.get_bearing_curve_analysis_setting`

```python
cdb.get_bearing_curve_analysis_setting()
```

获取承载力曲线分析设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   setting = cdb.get_bearing_curve_analysis_setting()
```

#### 返回

>     dict: 包含 bearing_curve_count、angle_between_m_and_y_axis、force_p。

### `cdb.add_parameter_reinforcement`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_parameter_reinforcement`

```python
cdb.add_parameter_reinforcement(sec_id: int, position: int=0, has_outer: bool=True, has_inner: bool=True, outer_type: int=0, inner_type: int=0, outer_info: Optional[list[list[float]]]=None, inner_info: Optional[list[list[float]]]=None, tapper_sec_group: bool=False, tapper_interpolation_id: int=-1, tapper_group_name: str='')
```

添加参数化配筋，单位默认为国际单位制m,当存在数据时默认覆盖数据

#### 参数

>     sec_id: 截面编号
>     position: 变截面专用参数 0-I端  1-J端
>     has_outer: 是否包含外侧配筋
>     has_inner: 是否包含内侧配筋
>     outer_type: 外侧配筋类型 0-按照间距  1-按照数量
>     inner_type: 内侧配筋类型 0-按照间距  1-按照数量
>     outer_info: 外侧配筋参数列表  [直径，钢筋材料号，层边距，钢筋间距/数量，每束根数]
>     inner_info: 内侧配筋参数列表  [直径，钢筋材料号，层边距，钢筋间距/数量，每束根数]
>     tapper_sec_group: 是否操作变截面组中的插值截面；为 True 时 sec_id 表示变截面组编号
>     tapper_interpolation_id: 变截面组中的插值截面编号，从 1 开始；tapper_sec_group=True 时必填
>     tapper_group_name: 变截面组名称；tapper_sec_group=True 时必填

#### 示例

```python
from qtmodel import cdb
   cdb.add_parameter_reinforcement(sec_id=1, outer_info=[[0.016, 4, 0.05, 0.15, 1]])
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_part_parameter_reinforcement`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_part_parameter_reinforcement`

```python
cdb.add_part_parameter_reinforcement(sec_id: int, position: int=0, base_line_id: int=1, distribution_type: int=0, direction_type: int=0, diameter: float=0.02, material_id: int=1, layer_margin: float=0.05, spacing_or_number: float=0.15, number_of_pieces_per_bundle: int=1, start_offset: float=0, end_offset: float=0, tapper_sec_group: bool=False, tapper_interpolation_id: int=-1, tapper_group_name: str='')
```

添加局部参数化配筋,默认单位是m

#### 参数

>     sec_id: 截面编号
>     position: 布置位置类型
>     base_line_id: 由截面分段生成的基准线号，从 1 开始。
>     distribution_type: 分布方式，0-按间距分布，1-按数量分布。
>     direction_type: 布置方向，0-向内布置，1-向外布置。
>     diameter: 钢筋直径。
>     material_id: 钢筋材料号。
>     layer_margin: 层边距。
>     spacing_or_number: distribution_type=0 时表示间距，distribution_type=1 时表示数量。
>     number_of_pieces_per_bundle: 每束钢筋根数。
>     start_offset: 起点偏移值。
>     end_offset: 终点偏移值。
>     tapper_sec_group: 是否操作变截面组中的插值截面；为 True 时 sec_id 表示变截面组编号。
>     tapper_interpolation_id: 变截面组中的插值截面编号，从 1 开始；tapper_sec_group=True 时必填。
>     tapper_group_name: 变截面组名称；tapper_sec_group=True 时必填。

#### 示例

```python
from qtmodel import cdb
   cdb.add_part_parameter_reinforcement(sec_id=1, base_line_id=11, distribution_type=0, direction_type=0)
Returns: QtServer.send_dict 的返回值
```

### `cdb.remove_part_parameter_reinforcement`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_part_parameter_reinforcement`

```python
cdb.remove_part_parameter_reinforcement(sec_id: int, position: int=0, base_line_id: int=-1)
```

删除指定截面的局部参数化钢筋。

#### 参数

>     sec_id: 截面号。
>     position: 截面位置，变截面时 0-I 端，1-J 端。
>     base_line_id: 基准线号。小于 0 时删除该截面全部局部参数化钢筋。

#### 示例

```python
from qtmodel import cdb
   cdb.remove_part_parameter_reinforcement(sec_id=1, position=0, base_line_id=11)
Returns: QtServer.send_dict 鐨勮繑鍥炲€?
```

### `cdb.add_reinforcement_by_point`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_reinforcement_by_point`

```python
cdb.add_reinforcement_by_point(sec_id: int, position: int=0, bar_data: Optional[Union[list[tuple[float, float, float, int]], list[list[float]]]]=None, tapper_sec_group: bool=False, tapper_interpolation_id: int=-1, tapper_group_name: str='')
```

按坐标点添加纵向钢筋

#### 参数

>     sec_id: 截面编号
>     position: 布置位置类型
>     bar_data: 钢筋数据列表，格式为 [(x, y, 直径, 材料号)]
>     tapper_sec_group: 是否操作变截面组中的插值截面；为 True 时 sec_id 表示变截面组编号。
>     tapper_interpolation_id: 变截面组中的插值截面编号，从 1 开始；tapper_sec_group=True 时必填。
>     tapper_group_name: 变截面组名称；tapper_sec_group=True 时必填。

#### 示例

```python
from qtmodel import cdb
   cdb.add_reinforcement_by_point(sec_id=1, bar_data=[(0, 0, 20, 1)])
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_reinforcement_by_point`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_reinforcement_by_point`

```python
cdb.update_reinforcement_by_point(sec_id: int, position: int=0, bar_data: Optional[Union[list[tuple[float, float, float, int]], list[list[float]]]]=None)
```

更新所有自定义钢筋.

#### 参数

>     sec_id: 截面号。
>     position: 截面位置，变截面时 0-I 端，1-J 端。
>     bar_data: 钢筋点列表，格式为 [(x, y, 直径, 材料号)]。

#### 示例

```python
from qtmodel import cdb
   cdb.update_reinforcement_by_point(sec_id=1, bar_data=[(0, 0, 20, 1)])
Returns: QtServer.send_dict 的返回值
```

### `cdb.add_check_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.add_check_stirrup`

```python
cdb.add_check_stirrup(stirrup_id: int, name: str, stirrup_type: int=1, rebar_material_id: int=1, limbs_number: int=2, loops_number: int=2, stirrup_diameter: float=20, stirrup_spacing: float=0.2, core_diameter: float=1.5)
```

添加一个混凝土检算箍筋定义。

#### 参数

>     stirrup_id: 箍筋定义编号。
>     name: 箍筋定义名称。
>     stirrup_type: 箍筋类型，1-普通箍筋，2-螺旋式箍筋。
>     rebar_material_id: 钢筋材料号。
>     limbs_number: 普通箍筋的肢数。
>     loops_number: 螺旋式箍筋的环数。
>     stirrup_diameter: 箍筋直径，单位 mm。
>     stirrup_spacing: 箍筋间距，单位 m。
>     core_diameter: 螺旋式箍筋核心直径，单位 m。

#### 示例

```python
from qtmodel import cdb
   cdb.add_check_stirrup(stirrup_id=1, name="default", stirrup_type=1, rebar_material_id=1, limbs_number=2, stirrup_diameter=20, stirrup_spacing=0.2)
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_check_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_check_stirrup`

```python
cdb.update_check_stirrup(stirrup_id: int, name: str, stirrup_type: int=1, rebar_material_id: int=1, limbs_number: int=2, loops_number: int=2, stirrup_diameter: float=20, stirrup_spacing: float=0.2, core_diameter: float=1.5)
```

修改一个混凝土检算箍筋定义。

#### 参数

>     stirrup_id: 箍筋定义编号。C# 端优先按编号查找，编号未找到时再按名称查找。
>     name: 箍筋定义名称。
>     stirrup_type: 箍筋类型，1-普通箍筋，2-螺旋式箍筋。
>     rebar_material_id: 钢筋材料号。
>     limbs_number: 普通箍筋的肢数。
>     loops_number: 螺旋式箍筋的环数。
>     stirrup_diameter: 箍筋直径，单位 mm。
>     stirrup_spacing: 箍筋间距，单位 m。
>     core_diameter: 螺旋式箍筋核心直径，单位 m。

#### 示例

```python
from qtmodel import cdb
   cdb.update_check_stirrup(stirrup_id=1, name="default", stirrup_type=2, rebar_material_id=1, loops_number=2, stirrup_diameter=20, stirrup_spacing=0.2, core_diameter=2)
Returns: QtServer.send_dict 的返回值
```

### `cdb.remove_check_stirrup`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_check_stirrup`

```python
cdb.remove_check_stirrup(stirrup_id: int=-1, name: str='')
```

删除一个混凝土检算箍筋定义。

#### 参数

>     stirrup_id: 箍筋定义编号。C# 端优先按编号删除。
>     name: 箍筋定义名称。stirrup_id 小于等于 0 或编号未找到时按名称删除。

#### 示例

```python
from qtmodel import cdb
   cdb.remove_check_stirrup(stirrup_id=1)
Returns: QtServer.send_dict 的返回值
```

### `cdb.update_vertical_steel_tendon`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.update_vertical_steel_tendon`

```python
cdb.update_vertical_steel_tendon(limbs_number: int=0, single_limb_area: float=804.0, spacing: float=0.2, effective_prestress: float=800.0, strength_design_value: float=900.0)
```

修改竖向钢束设置。

#### 参数

>     limbs_number: 肢数。
>     single_limb_area: 单肢面积，单位 mm^2。
>     spacing: 钢束间距，单位 m。
>     effective_prestress: 有效预应力，单位 MPa。
>     strength_design_value: 强度设计值 fpd，单位 MPa。

#### 示例

```python
from qtmodel import cdb
   cdb.update_vertical_steel_tendon(limbs_number=0, single_limb_area=804, spacing=0.2, effective_prestress=800, strength_design_value=900)
Returns: QtServer.send_dict 的返回值
```

### `cdb.remove_vertical_steel_tendon`

源码：`qtmodel/cdb/cdb_concrete_check.py` · `CdbConcreteCheck.remove_vertical_steel_tendon`

```python
cdb.remove_vertical_steel_tendon()
```

通过重置为界面默认值来删除竖向钢束设置。
Args: 无

#### 示例

```python
from qtmodel import cdb
   cdb.remove_vertical_steel_tendon()
Returns: QtServer.send_dict 的返回值
```

## `cdb_steel_box_check`

### `cdb.add_steel_box_construct_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.add_steel_box_construct_check`

```python
cdb.add_steel_box_construct_check(sec_id: int, material_id: int)
```

添加钢箱梁构造验算项目。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     material_id: 钢板材料 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.add_steel_box_construct_check(sec_id=1, material_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.add_steel_box_transverse_rib`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.add_steel_box_transverse_rib`

```python
cdb.add_steel_box_transverse_rib(name: str, rib_type: int, rib_info: list[float], length_unit: str='mm')
```

添加全局横向加劲肋。

#### 参数

>     name: 加劲肋名称，需唯一。
>     rib_type: 加劲肋类型，参见 RibType 枚举；常用值为 ShapeU=1、Plate=2、ShapeT=3。
>     rib_info: 几何参数数组，单位由 length_unit 控制；板肋为 [H, B]，T 肋为 [H, B, tw, tf]，U 肋为 [H, B1, B2, t, r]。
>     length_unit: rib_info 中长度参数的单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.add_steel_box_transverse_rib(name="应力验算1", rib_type=1, rib_info=[300, 200])
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.add_steel_box_longitudinal_rib`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.add_steel_box_longitudinal_rib`

```python
cdb.add_steel_box_longitudinal_rib(sec_id: int, name: str, rib_type: int, rib_info: list[float], length_unit: str='mm')
```

为指定构造验算截面添加纵向加劲肋。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     name: 加劲肋名称，在该截面的纵向加劲肋集合内需唯一。
>     rib_type: 加劲肋类型，参见 RibType 枚举；常用值为 ShapeU=1、Plate=2、ShapeT=3。
>     rib_info: 几何参数数组，单位由 length_unit 控制；板肋为 [H, B]，T 肋为 [H, B, tw, tf]，U 肋为 [H, B1, B2, t, r]。
>     length_unit: rib_info 中长度参数的单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.add_steel_box_longitudinal_rib(sec_id=1, name="应力验算1", rib_type=1, rib_info=[300, 200])
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_top_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_top_check`

```python
cdb.update_steel_box_top_check(sec_id: int, region_index: int=0, has_transverse_rib: int=-1, is_orthotropic_plate: int=-1, press_type: int=-1, top_plate_type: int=-1, a: float=None, b: float=None, t: float=None, longitudinal_rib_name: str='', longitudinal_rib_num: int=-1, transverse_rib_name: str='', transverse_rib_gap: float=None, stiffness_type: int=-1, length_unit: str='mm')
```

更新顶板构造验算参数。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     region_index: 顶板区域序号；0 表示保留当前区域，1 对应“上桥面1”，依次类推。
>     has_transverse_rib: 是否有横向加劲肋；-1 保留，0 否，1 是。
>     is_orthotropic_plate: 是否按正交异性板考虑；-1 保留，0 否，1 是。
>     press_type: 受力类型，参见 SteelGirderPressType 枚举；-1 保留。
>     top_plate_type: 顶板类型，参见 SteelTopPlateType 枚举；-1 保留。
>     a: 受压板纵向计算长度。
>     b: 受压板横向计算宽度。
>     t: 顶板厚度。
>     longitudinal_rib_name: 纵向加劲肋名称；空字符串表示保留当前值。
>     longitudinal_rib_num: 纵向加劲肋数量；-1 保留。
>     transverse_rib_name: 横向加劲肋名称；空字符串表示保留当前值。
>     transverse_rib_gap: 横向加劲肋间距。
>     stiffness_type: 加劲构造类型，参见 SteelGirderStiffnessType 枚举；-1 保留。
>     length_unit: a、b、t、transverse_rib_gap 的长度单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_top_check(sec_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_bot_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_bot_check`

```python
cdb.update_steel_box_bot_check(sec_id: int, region_index: int=0, has_transverse_rib: int=-1, press_type: int=-1, a: float=None, b: float=None, t: float=None, longitudinal_rib_name: str='', longitudinal_rib_num: int=-1, transverse_rib_name: str='', transverse_rib_gap: float=None, stiffness_type: int=-1, length_unit: str='mm')
```

更新底板构造验算参数。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     region_index: 底板区域序号；0 表示保留当前区域，1 对应“下桥面1”，依次类推。
>     has_transverse_rib: 是否有横向加劲肋；-1 保留，0 否，1 是。
>     press_type: 受力类型，参见 SteelGirderPressType 枚举；-1 保留。
>     a: 受压板纵向计算长度。
>     b: 受压板横向计算宽度。
>     t: 底板厚度。
>     longitudinal_rib_name: 纵向加劲肋名称；空字符串表示保留当前值。
>     longitudinal_rib_num: 纵向加劲肋数量；-1 保留。
>     transverse_rib_name: 横向加劲肋名称；空字符串表示保留当前值。
>     transverse_rib_gap: 横向加劲肋间距。
>     stiffness_type: 加劲构造类型，参见 SteelGirderStiffnessType 枚举；-1 保留。
>     length_unit: a、b、t、transverse_rib_gap 的长度单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_bot_check(sec_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_web_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_web_check`

```python
cdb.update_steel_box_web_check(sec_id: int, region_index: int=0, calculate_shear: int=-1, calculate_press: int=-1, normal_stress: float=None, shear_stress: float=None, h: float=None, a: float=None, b: float=None, web_construct_type: int=-1, t: float=None, longitudinal_rib_name: str='', longitudinal_rib_num: int=-1, transverse_rib_name: str='', transverse_rib_gap: float=None, stiffness_type: int=-1, length_unit: str='mm', stress_unit: str='Mpa')
```

更新腹板构造验算参数。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     region_index: 腹板区域序号；0 表示保留当前区域，1 对应“腹板1”，依次类推。
>     calculate_shear: 是否进行受剪验算；-1 保留，0 否，1 是。
>     calculate_press: 是否进行受压验算；-1 保留，0 否，1 是。
>     normal_stress: 腹板法向应力，单位由 stress_unit 控制。
>     shear_stress: 腹板剪应力，单位由 stress_unit 控制。
>     h: 腹板计算高度。
>     a: 受压腹板纵向计算长度。
>     b: 腹板横向计算宽度。
>     web_construct_type: 腹板构造类型，参见 SteelWebConstructType 枚举；-1 保留。
>     t: 腹板厚度。
>     longitudinal_rib_name: 纵向加劲肋名称；空字符串表示保留当前值。
>     longitudinal_rib_num: 纵向加劲肋数量；-1 保留。
>     transverse_rib_name: 横向加劲肋名称；空字符串表示保留当前值。
>     transverse_rib_gap: 横向加劲肋间距。
>     stiffness_type: 加劲构造类型，参见 SteelGirderStiffnessType 枚举；-1 保留。
>     length_unit: h、a、b、t、transverse_rib_gap 的长度单位，默认 mm。
>     stress_unit: normal_stress、shear_stress 的应力单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_web_check(sec_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_flange_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_flange_check`

```python
cdb.update_steel_box_flange_check(sec_id: int, top_press_type: int=-1, bot_press_type: int=-1, top_data: list[float]=None, bot_data: list[float]=None, has_top_rib: int=-1, has_bot_rib: int=-1, length_unit: str='mm')
```

更新翼缘板构造验算参数。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     top_press_type: 上翼缘受力类型，参见 SteelGirderPressType 枚举；-1 保留。
>     bot_press_type: 下翼缘受力类型，参见 SteelGirderPressType 枚举；-1 保留。
>     top_data: 上翼缘参数数组 [topBc, topTc, topS1, topSc]。
>     bot_data: 下翼缘参数数组 [botBt, botTt, botS2, botSt]。
>     has_top_rib: 上翼缘是否有加劲肋；-1 保留，0 否，1 是。
>     has_bot_rib: 下翼缘是否有加劲肋；-1 保留，0 否，1 是。
>     length_unit: top_data、bot_data 中长度参数的单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_flange_check(sec_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_diaphragm_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_diaphragm_check`

```python
cdb.update_steel_box_diaphragm_check(sec_id: int, idw: float=None, ld: float=None, ac: float=None, ao: float=None, td: float=None, top_rib_name: str='', bot_rib_name: str='', web_rib_name: str='', slant_support_rib_name: str='', ab: float=None, diaphragm_type: int=-1, beta: float=None, truss_type: int=-1, lb: float=None, length_unit: str='mm')
```

更新横隔板构造验算参数。

#### 参数

>     sec_id: 钢箱梁截面 ID。
>     idw: 横隔板截面抗扭惯性矩参数，单位为 length_unit^6。
>     ld: 横隔板间距或相关长度参数。
>     ac: 箱梁核心面积参数，单位为 length_unit^2。
>     ao: 箱梁开孔面积参数，单位为 length_unit^2。
>     td: 横隔板厚度。
>     top_rib_name: 顶板横向肋名称；空字符串表示保留当前值。
>     bot_rib_name: 底板横向肋名称；空字符串表示保留当前值。
>     web_rib_name: 腹板横向肋名称；空字符串表示保留当前值。
>     slant_support_rib_name: 斜撑横向肋名称；空字符串表示保留当前值。
>     ab: 单个斜撑面积参数，单位为 length_unit^2。
>     diaphragm_type: 横隔板类型，参见 DiaphragmType 枚举；-1 保留。
>     beta: 开口率修正系数。
>     truss_type: 桁架类型，参见 SteelGirderDiaphragmCheck.Types.TrussType 枚举；-1 保留。
>     lb: 桁架斜撑长度。
>     length_unit: idw、ld、ac、ao、td、ab、lb 的基础长度单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_diaphragm_check(sec_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.get_steel_box_top_check_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_top_check_result`

```python
cdb.get_steel_box_top_check_result(sec_id: int)
```

获取顶板构造验算结果。

#### 参数

>     sec_id: 钢箱梁截面 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_top_check_result(sec_id=1)
```

#### 返回

>     顶板验算结果字典。

### `cdb.get_steel_box_bot_check_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_bot_check_result`

```python
cdb.get_steel_box_bot_check_result(sec_id: int)
```

获取底板构造验算结果。

#### 参数

>     sec_id: 钢箱梁截面 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_bot_check_result(sec_id=1)
```

#### 返回

>     底板验算结果字典。

### `cdb.get_steel_box_web_check_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_web_check_result`

```python
cdb.get_steel_box_web_check_result(sec_id: int)
```

获取腹板构造验算结果。

#### 参数

>     sec_id: 钢箱梁截面 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_web_check_result(sec_id=1)
```

#### 返回

>     腹板受剪和受压验算结果字典。

### `cdb.get_steel_box_flange_check_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_flange_check_result`

```python
cdb.get_steel_box_flange_check_result(sec_id: int)
```

获取翼缘板构造验算结果。

#### 参数

>     sec_id: 钢箱梁截面 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_flange_check_result(sec_id=1)
```

#### 返回

>     翼缘板验算结果字典。

### `cdb.get_steel_box_diaphragm_check_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_diaphragm_check_result`

```python
cdb.get_steel_box_diaphragm_check_result(sec_id: int)
```

获取横隔板构造验算结果。

#### 参数

>     sec_id: 钢箱梁截面 ID。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_diaphragm_check_result(sec_id=1)
```

#### 返回

>     横隔板验算结果字典。

### `cdb.get_steel_box_construct_check_context`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_construct_check_context`

```python
cdb.get_steel_box_construct_check_context(sec_id: int=-1, include_results: int=1, auto_calculate: int=0, length_unit: str='mm', stress_unit: str='Mpa')
```

获取钢箱梁构造验算完整上下文，适合给 AI 一次性读取全部构造验算信息。

#### 参数

>     sec_id: 截面 ID；-1 或小于等于 0 表示返回全部构造验算截面。
>     include_results: 是否包含已有结果；0 不包含，非 0 包含，默认 1。
>     auto_calculate: 返回前是否临时调用 CoreCalculate 计算结果；0 不计算，非 0 计算。该计算不会写回模型。
>     length_unit: 输出长度、面积、惯性矩的基础长度单位，默认 mm。
>     stress_unit: 输出应力的单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_construct_check_context()
```

#### 返回

>     包含全局横向肋、截面、材料、每个验算项各部位输入和结果的上下文字典。

### `cdb.get_steel_box_construct_check_item_context`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_construct_check_item_context`

```python
cdb.get_steel_box_construct_check_item_context(sec_id: int, include_results: int=1, auto_calculate: int=0, length_unit: str='mm', stress_unit: str='Mpa')
```

获取单个钢箱梁截面的构造验算详细部位信息。

#### 参数

>     sec_id: 需要查询的钢箱梁截面 ID。
>     include_results: 是否包含已有结果；0 不包含，非 0 包含，默认 1。
>     auto_calculate: 返回前是否临时调用 CoreCalculate 计算结果；0 不计算，非 0 计算。该计算不会写回模型。
>     length_unit: 输出长度、面积、惯性矩的基础长度单位，默认 mm。
>     stress_unit: 输出应力的单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_construct_check_item_context(sec_id=1)
```

#### 返回

>     单个截面的材料、加劲肋、顶板、底板、腹板、翼缘和横隔板上下文字典。

### `cdb.get_steel_box_construct_check_schema`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_construct_check_schema`

```python
cdb.get_steel_box_construct_check_schema()
```

获取钢箱梁构造验算字段解释信息。

#### 参数

>     无。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_construct_check_schema()
```

#### 返回

>     字段说明、单位说明、枚举值和可用 API 名称字典。

### `cdb.add_steel_box_stress_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.add_steel_box_stress_check`

```python
cdb.add_steel_box_stress_check(name: str, structure_group_name: str, material_id: int, standard_code: int=-1)
```

添加钢箱梁应力验算工况。

#### 参数

>     name: 应力验算工况名称，需唯一。
>     structure_group_name: 结构组名称，用于定位参与验算的钢箱梁构件。
>     material_id: 钢材材料 ID。
>     standard_code: 规范枚举值；-1 表示使用默认值。

#### 示例

```python
from qtmodel import cdb
    cdb.add_steel_box_stress_check(name="应力验算1", structure_group_name="钢箱梁组", material_id=1)
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.remove_steel_box_stress_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.remove_steel_box_stress_check`

```python
cdb.remove_steel_box_stress_check(name: str)
```

删除钢箱梁应力验算工况。

#### 参数

>     name: 要删除的应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.remove_steel_box_stress_check(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.delete_steel_box_stress_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.delete_steel_box_stress_check`

```python
cdb.delete_steel_box_stress_check(name: str)
```

删除钢箱梁应力验算工况。

#### 参数

>     name: 要删除的应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.delete_steel_box_stress_check(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_check_default_data`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_check_default_data`

```python
cdb.import_steel_box_stress_check_default_data(name: str)
```

从当前模型刷新应力验算默认数据。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_check_default_data(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_stress_basic_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_stress_basic_info`

```python
cdb.update_steel_box_stress_basic_info(name: str, standard_code: int=-1, safety_level: int=-1, normal_strength: int=-1, shear_strength: int=-1, reduced_strength: int=-1, fatigue_check: int=-1, global_stability: int=-1, additivity_type: int=-1, stability_mode: int=-1, fatigue_model: int=-1, reduced_standard: int=-1, gama_ff: float=None, ks: float=None, gama_mf: float=None, sigma_c: float=None, sigma_d: float=None, tau_c: float=None, tau_l: float=None, gama_middle: float=None, gama_end: float=None, gap_node1: int=-1, gap_node2: int=-1, stress_unit: str='Mpa')
```

更新钢箱梁应力验算基本控制参数。

#### 参数

>     name: 应力验算工况名称。
>     standard_code: 规范枚举值；-1 保留。
>     safety_level: 安全等级枚举值；-1 保留。
>     normal_strength: 是否进行正应力强度验算；-1 保留，0 否，1 是。
>     shear_strength: 是否进行剪应力强度验算；-1 保留，0 否，1 是。
>     reduced_strength: 是否进行折减应力验算；-1 保留，0 否，1 是。
>     fatigue_check: 是否进行疲劳验算；-1 保留，0 否，1 是。
>     global_stability: 是否进行整体稳定验算；-1 保留，0 否，1 是。
>     additivity_type: 应力叠加类型枚举值；-1 保留。
>     stability_mode: 稳定验算模式枚举值；-1 保留。
>     fatigue_model: 疲劳模型枚举值；-1 保留。
>     reduced_standard: 折减应力标准枚举值；-1 保留。
>     gama_ff: 疲劳荷载分项系数。
>     ks: 疲劳相关系数。
>     gama_mf: 疲劳抗力分项系数。
>     sigma_c: 正应力容许值或控制值，单位由 stress_unit 控制。
>     sigma_d: 疲劳应力幅控制值，单位由 stress_unit 控制。
>     tau_c: 剪应力容许值或控制值，单位由 stress_unit 控制。
>     tau_l: 剪应力疲劳控制值，单位由 stress_unit 控制。
>     gama_middle: 跨中区域系数。
>     gama_end: 支点或端部区域系数。
>     gap_node1: 缺口或特殊节点 1；-1 保留。
>     gap_node2: 缺口或特殊节点 2；-1 保留。
>     stress_unit: 应力单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_stress_basic_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_stress_stability_check`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_stress_stability_check`

```python
cdb.update_steel_box_stress_stability_check(name: str, check_type: int=-1, l1: float=None, h: float=None, b0: float=None, fy: float=None, length_unit: str='mm', stress_unit: str='Mpa')
```

更新钢箱梁应力验算中的整体稳定参数。

#### 参数

>     name: 应力验算工况名称。
>     check_type: 稳定验算类型枚举值；-1 保留。
>     l1: 计算长度或等效长度，单位由 length_unit 控制。
>     h: 构件高度或截面高度，单位由 length_unit 控制。
>     b0: 计算宽度，单位由 length_unit 控制。
>     fy: 钢材屈服强度，单位由 stress_unit 控制。
>     length_unit: l1、h、b0 的长度单位，默认 mm。
>     stress_unit: fy 的应力单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_stress_stability_check(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_stress_second_system_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_stress_second_system_info`

```python
cdb.update_steel_box_stress_second_system_info(name: str, vehicle_group_factor: float=None, combo_reduce_factor: float=None, top_max_tension: float=None, top_max_compression: float=None, bot_max_tension: float=None, bot_max_compression: float=None, stress_unit: str='Mpa')
```

更新二次体系应力控制参数。

#### 参数

>     name: 应力验算工况名称。
>     vehicle_group_factor: 车辆组合作用系数。
>     combo_reduce_factor: 组合折减系数。
>     top_max_tension: 顶板最大拉应力，单位由 stress_unit 控制。
>     top_max_compression: 顶板最大压应力，单位由 stress_unit 控制。
>     bot_max_tension: 底板最大拉应力，单位由 stress_unit 控制。
>     bot_max_compression: 底板最大压应力，单位由 stress_unit 控制。
>     stress_unit: 应力单位，默认 Mpa。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_stress_second_system_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_stress_support_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_stress_support_info`

```python
cdb.update_steel_box_stress_support_info(name: str, support_data: list[list[float]], length_unit: str='mm')
```

更新局部支承承压验算输入数据。

#### 参数

>     name: 应力验算工况名称。
>     support_data: 支承数据二维数组，格式同 update_steel_box_stress_support_infos。
>     length_unit: support_data 中长度、面积等几何参数的基础长度单位，默认 mm。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_stress_support_info(name="应力验算1", support_data=[[...]])
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.calc_steel_box_stress_support_infos`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.calc_steel_box_stress_support_infos`

```python
cdb.calc_steel_box_stress_support_infos(name: str, user_define: int=0)
```

计算局部支承承压验算结果。

#### 参数

>     name: 应力验算工况名称。
>     user_define: 是否使用用户自定义输入；0 使用程序默认或模型数据，1 使用用户输入。

#### 示例

```python
from qtmodel import cdb
    cdb.calc_steel_box_stress_support_infos(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.update_steel_box_stress_load_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.update_steel_box_stress_load_info`

```python
cdb.update_steel_box_stress_load_info(name: str, load_type: int, load_data: list[list[float]], case_names: list[str]=None)
```

更新钢箱梁应力验算荷载信息。

#### 参数

>     name: 应力验算工况名称。
>     load_type: 荷载类型枚举值。
>     load_data: 荷载数据二维数组，每行格式为
>         [element_id, fxi, fyi, fzi, mxi, myi, mzi,
>          fxj, fyj, fzj, mxj, myj, mzj, stage, type, component]。
>     case_names: 荷载工况名称列表；为空时使用服务端默认或当前数据。

#### 示例

```python
from qtmodel import cdb
    cdb.update_steel_box_stress_load_info(name="应力验算1", load_type=1, load_data=[[...]])
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_load_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_load_info`

```python
cdb.import_steel_box_stress_load_info(name: str)
```

从当前后处理结果导入应力验算荷载数据。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_load_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_element_section_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_element_section_info`

```python
cdb.import_steel_box_stress_element_section_info(name: str)
```

从当前模型导入单元-截面对应信息。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_element_section_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_effective_section_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_effective_section_info`

```python
cdb.import_steel_box_stress_effective_section_info(name: str)
```

从当前模型导入有效截面信息。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_effective_section_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_reduced_point_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_reduced_point_info`

```python
cdb.import_steel_box_stress_reduced_point_info(name: str, fatigue_point: int=0)
```

导入折减应力或疲劳验算点。

#### 参数

>     name: 应力验算工况名称。
>     fatigue_point: 0 导入折减应力验算点，1 导入疲劳验算点。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_reduced_point_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.import_steel_box_stress_fatigue_point_info`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.import_steel_box_stress_fatigue_point_info`

```python
cdb.import_steel_box_stress_fatigue_point_info(name: str)
```

导入疲劳验算点。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.import_steel_box_stress_fatigue_point_info(name="应力验算1")
```

#### 返回

>     服务端返回的执行结果字符串。

### `cdb.calc_steel_box_stress_normal_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.calc_steel_box_stress_normal_result`

```python
cdb.calc_steel_box_stress_normal_result(name: str)
```

计算正应力强度验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.calc_steel_box_stress_normal_result(name="应力验算1")
```

#### 返回

>     正应力强度验算结果。

### `cdb.calc_steel_box_stress_shear_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.calc_steel_box_stress_shear_result`

```python
cdb.calc_steel_box_stress_shear_result(name: str)
```

计算剪应力强度验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.calc_steel_box_stress_shear_result(name="应力验算1")
```

#### 返回

>     剪应力强度验算结果。

### `cdb.calc_steel_box_stress_reduced_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.calc_steel_box_stress_reduced_result`

```python
cdb.calc_steel_box_stress_reduced_result(name: str)
```

计算折减应力验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.calc_steel_box_stress_reduced_result(name="应力验算1")
```

#### 返回

>     折减应力验算结果。

### `cdb.calc_steel_box_stress_fatigue_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.calc_steel_box_stress_fatigue_result`

```python
cdb.calc_steel_box_stress_fatigue_result(name: str)
```

钢箱梁应力检算疲劳结果获取

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.calc_steel_box_stress_fatigue_result(name="应力验算1")
```

#### 返回

>     疲劳验算结果。

### `cdb.get_steel_box_stress_check_item`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_stress_check_item`

```python
cdb.get_steel_box_stress_check_item(name: str)
```

获取完整钢箱梁应力验算工况数据。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_stress_check_item(name="应力验算1")
```

#### 返回

>     应力验算工况完整数据字典。

### `cdb.get_steel_box_stress_normal_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_stress_normal_result`

```python
cdb.get_steel_box_stress_normal_result(name: str)
```

获取正应力强度验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_stress_normal_result(name="应力验算1")
```

#### 返回

>     正应力强度验算结果。

### `cdb.get_steel_box_stress_shear_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_stress_shear_result`

```python
cdb.get_steel_box_stress_shear_result(name: str)
```

获取剪应力强度验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_stress_shear_result(name="应力验算1")
```

#### 返回

>     剪应力强度验算结果。

### `cdb.get_steel_box_stress_reduced_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_stress_reduced_result`

```python
cdb.get_steel_box_stress_reduced_result(name: str)
```

获取折减应力验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_stress_reduced_result(name="应力验算1")
```

#### 返回

>     折减应力验算结果。

### `cdb.get_steel_box_stress_fatigue_result`

源码：`qtmodel/cdb/cdb_steel_box_check.py` · `CdbSteelBoxCheck.get_steel_box_stress_fatigue_result`

```python
cdb.get_steel_box_stress_fatigue_result(name: str)
```

获取疲劳验算结果。

#### 参数

>     name: 应力验算工况名称。

#### 示例

```python
from qtmodel import cdb
    cdb.get_steel_box_stress_fatigue_result(name="应力验算1")
```

#### 返回

>     疲劳验算结果。

## `cdb_steel_truss_check`

### `cdb.extract_member_design_data`

源码：`qtmodel/cdb/cdb_steel_truss_check.py` · `CdbSteelTrussCheck.extract_member_design_data`

```python
cdb.extract_member_design_data(member_ids: list[int], load_cases: list[str])
```

Extract steel truss member design data.

#### 参数

>     member_ids: Member id list.
>     load_cases: Check load case / load combination name list.

#### 示例

```python
from qtmodel import cdb
    cdb.extract_member_design_data(
        member_ids=[101, 102, 103],
        load_cases=["CB主力", "CB主加附"],
    )
```

#### 返回

>     JSON string containing material_table, member_table, section_table,
>     load_table, and check_result.

### `cdb.check_member_tables`

源码：`qtmodel/cdb/cdb_steel_truss_check.py` · `CdbSteelTrussCheck.check_member_tables`

```python
cdb.check_member_tables(material_table: list, member_table: list, section_table: list, load_table: list, load_cases: list[str])
```

Check steel truss members from extracted design tables.

#### 参数

>     material_table: Material table.
>     member_table: Member table.
>     section_table: Section table.
>     load_table: Load table.
>     load_cases: Check load case / load combination name list.

#### 示例

```python
from qtmodel import cdb
    cdb.check_member_tables(
        material_table=material_table,
        member_table=member_table,
        section_table=section_table,
        load_table=load_table,
        load_cases=["CB主力", "CB主加附"],
    )
```

#### 返回

>     JSON string containing check_result.

## `门面补充`

### `cdb.update_model`

源码：`qtmodel/cdb/__init__.py` · `Cdb.update_model`

```python
cdb.update_model()
```

Refresh model information.

#### 示例

```python
from qtmodel import cdb
result = cdb.update_model()
```

# Bridge：桥梁级检算门面

## `bridge`

### `bridge.extract_member_design_data`

源码：`qtmodel/bridge.py` · `Bridge.extract_member_design_data`

```python
bridge.extract_member_design_data(member_ids: list[int], load_cases: list[str])
```

Extract steel truss member design data.

#### 参数

>     member_ids: Member id list.
>     load_cases: Check load case / load combination name list.

#### 示例

```python
from qtmodel import bridge
    bridge.extract_member_design_data(
        member_ids=[101, 102, 103],
        load_cases=["CB主力", "CB主加附"],
    )
```

#### 返回

>     JSON string containing material_table, member_table, section_table,
>     load_table, and check_result.

### `bridge.check_member_tables`

源码：`qtmodel/bridge.py` · `Bridge.check_member_tables`

```python
bridge.check_member_tables(material_table: list, member_table: list, section_table: list, load_table: list, load_cases: list[str])
```

Check steel truss members from extracted design tables.

#### 参数

>     material_table: Material table.
>     member_table: Member table.
>     section_table: Section table.
>     load_table: Load table.
>     load_cases: Check load case / load combination name list.

#### 示例

```python
from qtmodel import bridge
    bridge.check_member_tables(
        material_table=material_table,
        member_table=member_table,
        section_table=section_table,
        load_table=load_table,
        load_cases=["CB主力", "CB主加附"],
    )
```

#### 返回

>     JSON string containing check_result.
