osis-python 0.1.0__py3-none-any.whl

pyosis/boundary/interface.py

@@ -0,0 +1,90 @@
+"""
+Interfaces of OSIS functions
+
+========
+
+"""
+
+
+from typing import Literal
+from ..core import REGISTRY
+
+# @REGISTRY.register("Boundary")
+# def osis_boundary(nBd: int=1, eBoundaryType: Literal["GENERAL", "MSTSLV", "RELEASE", "ELSTCSPT"]="GENERAL", params: Dict[str, Any]={}):
+#     '''
+#     创建边界
+    
+#     Args:
+#         nBd (int): 边界编号
+#         eBoundaryType (str): 边界类型，不区分大小写。GENERAL = 一般边界，MSTSLV = 主从约束，RELEASE = 释放梁端约束，ELSTCSPT = 节点弹性支承
+#         params (Dict[str, Any]): 对应边界类型所需要的参数
+#     Returns:
+#         tuple (bool, str): 是否成功，失败原因
+#     '''
+#     pass
+
+@REGISTRY.register("Boundary")
+def osis_boundary_general(nBd: int, eBoundaryType: Literal["GENERAL"]="GENERAL", nCoor: int = -1, bX: bool = 1, bY: bool = 1, bZ: bool = 1, bRX: bool = 1, bRY: bool = 1, bRZ: bool = 1, bRW: bool = 1):
+    '''
+    定义或修改一般边界
+    
+    Args:
+        nBd (int): 编号
+        eBoundaryType (str): 固定为 GENERAL
+        nCoor (int): 局部坐标系编号，-1代表缺省
+        bX (bool): 0 = 释放，1 = 约束
+        bY (bool): 0 = 释放，1 = 约束
+        bZ (bool): 0 = 释放，1 = 约束
+        bRX (bool): 0 = 释放，1 = 约束
+        bRY (bool): 0 = 释放，1 = 约束
+        bRZ (bool): 0 = 释放，1 = 约束
+        bRW (bool): 0 = 释放，1 = 约束
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+
+@REGISTRY.register("AsgnBd")
+def osis_assign_boundary(nBd: int=1, eOP: Literal["a", "s", "r", "aa", "ra"]="a", param: list=[]):
+    '''
+    分配边界给节点(一般支撑，节点弹性支撑)
+    
+    Args:
+        nBd (int): 边界编号
+        eOP (str): 操作
+            * a = 添加
+            * s = 替换
+            * r = 移除
+            * aa = 添加全部
+            * ra = 移除全部
+        param (list): 待操作的编号，支持的格式：*，*to*，*by*（仅用于替换）。
+            例子：[2,3,5,"8to10"] ["2by3","5by6","8by10"] 重合的编号自动忽略
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("BdGrp")
+def osis_boundary_group(strName: str, eOP: Literal["c", "a", "s", "r", "aa", "ra", "m", "d"], param: list=[]):
+    '''
+    添加或移除边界组
+    
+    Args:
+        strName (str): 边界组名
+        eOP (str): 操作
+            * c = 创建
+            * a = 添加
+            * s = 替换
+            * r = 移除
+            * aa = 添加全部
+            * ra = 移除全部
+            * m = 修改组名
+            * d = 删除
+        param (list): 待操作的编号，支持的格式：*, *to*; *by*，仅用于替换。
+            例子：[2,3,5,"8to10"] ["2by3","5by6","8by10"] 重合的编号自动忽略
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass

pyosis/control/__init__.py

@@ -0,0 +1 @@
+from .interface import *

pyosis/control/interface.py

@@ -0,0 +1,182 @@
+"""
+Interfaces of OSIS functions
+
+========
+
+"""
+
+
+from ..core import OSISEngine, REGISTRY
+
+@REGISTRY.register("Acel")
+def osis_acel(dG: float = 9.8066):
+    '''
+    定义或修改重力加速度值
+    
+    Args:
+        dG (float): 重力加速度值
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcTendon")
+def osis_calc_tendon(bFlag: int=1):
+    '''
+    是否计算预应力
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcConForce")
+def osis_calc_con_force(bFlag: int=1):
+    '''
+    是否计算并发反力
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcShrink")
+def osis_calc_shrink(bFlag: int=1):
+    '''
+    是否计算收缩
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcCreep")
+def osis_calc_creep(bFlag: int=1):
+    '''
+    是否计算徐变
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcCreep")
+def osis_calc_shear(bFlag: int=1):
+    '''
+    是否计算剪切
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("CalcRlx")
+def osis_calc_rlx(bFlag: int=1):
+    '''
+    是否计算钢束松弛
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("ModLocCoor")
+def osis_mod_loc_coor(bFlag: int=1):
+    '''
+    是否修改变截面单元局部坐标轴来计算内力/应力
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("IncTendon")
+def osis_inc_tendon(bFlag: int=1):
+    '''
+    是否考虑钢束自重及钢束对截面几何特性的影响
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("NL")
+def osis_nl(bGeom: int=0, bLink: int=0):
+    '''
+    非线性控制开关
+
+    Args:
+        bGeom (bool): 
+            * 0 = 关闭几何非线性开关
+            * 1 = 打开几何非线性开关、大位移大转角
+        bLink (bool): 
+            * 0 = 不考虑非线性连接单元
+            * 1 = 考虑非线性连接单元
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("LnSrch")
+def osis_ln_srch(bFlag: int=1):
+    '''
+    求解设置线性搜索开关
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("AutoTs")
+def osis_auto_ts(bFlag: int=1):
+    '''
+    是否定义自动计算时间荷载步
+    
+    Args:
+        bFlag (bool): 1=开，0=关
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass
+
+@REGISTRY.register("ModOpt")
+def osis_mod_opt(nMod: int=1):
+    '''
+    定义模态分析所需的特征值最大数目
+    
+    Args:
+        nMod (int): 需要计算的特征值最大数目（缺省值：1）
+
+    Returns:
+        tuple (bool, str): 是否成功，失败原因
+    '''
+    pass

pyosis/core/PyInterface.pyi

@@ -0,0 +1,153 @@
+'''
+PyInterface 的 高亮提示文件
+'''
+
+from typing import Any, Dict, Tuple
+
+class PyInterface:
+    _instance = None
+    
+    @classmethod
+    def GetInstance(cls) -> 'PyInterface':
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    # def setProjects(self, project: Any) -> None: ...
+
+    def OSIS_Run(self, strCmd: str, mode: str) -> Tuple[bool, str]:
+        return True, ""
+    
+    # def OSIS_Replot(self) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_Clear(self) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_Solve(self) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_Acel(self, dG: float) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcTendon(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcConForce(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcShrink(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcCreep(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcShear(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CalcRlx(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_ModLocCoor(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_IncTendon(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_NL(self, bGeom: int, bLink: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_LnSrch(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_AutoTs(self, bFlag: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_ModOpt(self, nMod: int) -> tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_CrpShrk(self, nNO: int, strName: str, dAvgHumidity: float, nBirthTime: int, dTypeCoeff: float, nBirthByShrinking: int) -> Tuple[bool, str]: 
+    #     return True, ""
+
+    # def OSIS_Material(self, nMat: int, strName: str, eMaterialType: str, eCode: str, eGrade: str, nCrepShrk: int, dDmp: float, params: dict={}) -> Tuple[bool, str]:    # 需要修改
+    #     return True, ""
+    
+    # def OSIS_MaterialDel(self, nMat: int) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_MaterialMod(self, nOld: int, nNew: int) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_Section(self, nSec: int, strName: str, eSectionType: str, params: Dict[str, Any]) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_SectionOffset(self, nSec: int, offsetTypeY: str, dOffsetValueY: float, offsetTypeZ: str, dOffsetValueZ: float) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_SectionMesh(self, nSec: int, bMeshMethod: int, dMeshSize: float) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_SectionDel(self, nSec: int) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_SectionMod(self, nOld: int, nNew: int) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_Node(self, nNO: int, x: float, y: float, z: float) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_NodeDel(self, nNO: int) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_NodeMod(self, nOld: int, nNew: int) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_Element(self, nEle: int, eElementType: str, params: Dict[str, Any]) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_ElementDel(self, nEle: int) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_ElementMod(self, nOld: int, nNew: int) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_Boundary(self, nBd: int, eBoundaryType: str, params: Dict[str, Any]) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_AsgnBd(self, nBd: int, eOP: str, nodeNOs: list) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_Load(self, eLoadType: str, strLCName: str, params: Dict[str, Any]) -> Tuple[bool, str]:
+    #     return True, ""
+
+    # def OSIS_LoadCase(self, strName: str, eLoadCaseType: str, dScalar: float, strPrompt: str) -> Tuple[bool, str]:
+    #     return True, ""
+    
+    # def OSIS_LiveGrade(self, strName: str, eCode: str, eLiveLoadType: str, params: Dict[str, Any]) -> Tuple[bool, str]:
+    #     return True, ""
+
+    def OSIS_ElemForce(self, strLCName: str, eDataItem: str, eElementType: str) -> Tuple[bool, str, Any]:
+        return True, "", None
+
+    def OSIS_QBOverall(self, eBridgeType: str, spans: list, bIsElasticConnection: bool, 
+                       dKxOfAbutment1: float, dKyOfAbutment1: float, dKzOfAbutment1: float, 
+                       dKxOfAbutment2: float, dKyOfAbutment2: float, dKzOfAbutment2: float, dElasticLength: float) -> Tuple[bool, str]:
+        return True, ""
+    
+    def OSIS_QBPortrait(self, eBridgeType: str, dEleLengthMin: float, dEleLengthMax: float, S1: float, L1: float, F1: float, Tb: float, Tw: float, D1: float) -> Tuple[bool, str]:
+        return True, ""
+    
+    def OSIS_QBLoad(self, eBridgeType: str,
+                    bHaveDeadLoad: bool, bHavePavement: bool, bHaveRail: bool, bHaveSidewalk: bool, bHaveSideBeam: bool, bHaveMiddleBeam: bool,
+                    bHaveMovingLoad: bool, bHaveTemperEff: bool, bHaveTemperGradient: bool, bHaveSupSettle: bool,
+                    dDeadLoadFactor: float, dPavementIntensity: float, dRailIntensity: float, dSidewalkIntensity: float, dCrowdLoad: float,
+                    dSideBeamPointLoad: float, dMiddleBeamPointLoad: float, 
+                    dTransVehDistribution: float, bIsSelfDefine: bool, dFundFreq: float, dWarming: float, dCooling: float, 
+                    T1: float, T2: float, dSupSettle: float) -> Tuple[bool, str]:
+        return True, ""
+
+    def OSIS_QBTendon(self, eBridgeType: str, tendonInfo: list) -> Tuple[bool, str]:
+        return True, ""
+
+    def OSIS_QBStage(self, eBridgeType: str, stageInfo: list) -> Tuple[bool, str]:
+        return True, ""

pyosis/core/__init__.py

@@ -0,0 +1,12 @@
+"""
+pyosis.core 的 Docstring
+--------
+
+OSISEngine中的函数，将会分发到各个模块，被再次封装，意图为：
+- 避免麻烦的OSISEngine::GetInstance().OSIS_XXX调用方式
+- 将各个模块分类开以实现逻辑清晰
+- 将函数命名格式转换成python的常用格式，便于人与AI的理解
+"""
+
+from .engine import OSISEngine
+from .command import REGISTRY, osis_run, set_run_mode

pyosis/core/command.py

@@ -0,0 +1,180 @@
+'''
+pyosis.core.command 的 Docstring
+
+===
+# OSIS命令流兼容
+'''
+
+import datetime
+import inspect
+import functools
+from typing import Dict, Any, Tuple, Literal
+from .engine import OSISEngine
+
+def osis_run(strCmd: str="", mode: Literal["stash", "exec"]="exec") -> Tuple[bool, str, Any]:
+    '''
+    直接以命令流的形式运行OSIS功能
+    
+    Args:
+        strCmd: 完整的命令流
+        mode: 运行模式，此参数为了同时执行多条命令提高效率
+            * 使用 stash 仅会将命令流存到OSIS中，不会执行
+            * 收到 exec 信号才会执行暂存包括当前的所有命令流。
+
+    Returns:
+        tuple (bool, str, Any): 是否成功，失败原因，其他结果数据
+    '''
+    e = OSISEngine.GetInstance()
+    return e.OSIS_Run(strCmd, mode)
+
+def _log(text, filename="pyosis.log"):
+    """简单的日志函数"""
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(filename, 'a', encoding='utf-8') as f:
+        f.write(f"[{timestamp}] {text}\n")
+        f.close()
+
+
+class OSISFunctionRegistry:
+    """
+    OSIS函数注册表.通过装饰器注册函数，可指定命令流名称
+
+    ---
+    Attributes:
+        commands (dict): 存储所有注册的命令，键为命令流名称，值为对应的函数
+    
+    Example:
+        >>> REGISTRY = OSISFunctionRegistry()
+        >>> 
+        >>> @REGISTRY.register("BdGrp")
+        ... def boundary_group(name, op, params=None):      # 函数名写全名便于人和**AI**理解
+        ...     '''边界组操作'''
+        ...     pass
+        >>> 
+        >>> # 调用函数会自动转换为命令字符串
+        >>> result = boundary_group(2, "a", [2, 3, 5, "8to10"]) # 会自动组装成 “ BdGrp,2,a,2,3,5,8to10; ” 并发给OSIS执行
+        >>> print(result)
+        (True, "")
+        >>>  
+        >>> @REGISTRY.register("test")
+        ... def test_func(a: str, b: bool, c: float, d: int=None):
+        ...     '''示例'''
+        ...     pass
+        >>> test_func("name", True, 1.0, None)  # 组装成 test,name,1,1.0;   # 参数值为None会被忽略
+        >>> test_func("name", True, "", 1)      # 组装成 test,name,1,,1;    # 需要空参数忽略参数类型填一个空字符串： ""
+        >>> 
+
+    
+    """
+    
+    def __init__(self):
+        self.commands = {}      # func_name -> info
+        self.run_mode = "stash"     # 命令处理模式，默认暂存
+    
+    def register(self, cmd_name=None):
+        """
+        注册函数装饰器
+        
+        Args:
+            cmd_name: 命令别名，不提供则使用函数名
+        """
+        def decorator(func):
+            name = cmd_name or func.__name__
+            
+            # 保存函数信息
+            self.commands[func.__name__] = {
+                'func': func,
+                'name': func.__name__,
+                'cmd_name': name,
+                'doc': func.__doc__ or '',
+                'module': func.__module__
+            }
+            
+            # 创建包装函数
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):   # 函数执行时，都会走这个路径
+                # 包装参数
+                cmd = self._process_arguments(func, cmd_name, *args, **kwargs)
+                # 发送到软件
+                return self._execute_command(cmd)
+            
+            return wrapper
+        
+        return decorator
+
+    def _process_arguments(self, func, cmd_name, *args, **kwargs):
+        """处理参数并生成命令字符串"""
+        
+        # 获取函数签名
+        sig = inspect.signature(func)
+        
+        # 绑定用户参数
+        try:
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+        except TypeError as e:
+            raise ValueError(f"参数错误: {e}")
+        
+        # 收集参数值
+        param_values = []
+        
+        for param_name, param in sig.parameters.items():    # 参数值为空字符串时会加一个空的参数
+            value = bound.arguments[param_name]
+            
+            # 自动展开list/tuple
+            if isinstance(value, (list, tuple)):
+                for item in value:
+                    param_values.append(str(item))
+            # 自动展开dict，只取值
+            elif isinstance(value, dict):
+                for val in value.values():
+                    param_values.append(str(val))
+            elif isinstance(value, bool):
+                param_values.append(str(int(value)))
+            elif value is None:
+                # 参数值为空字符串时会加一个空的参数
+                # 如果希望生成 cmd,a,b,,d;的命令格式，c参数需要忽略参数类型填写空字符串：""
+                # param_values.append("")     # 加一个空字符串
+                continue        # 如果为None则跳过解析
+            else:
+                # 普通值
+                param_values.append(str(value))
+        
+        # 生成命令字符
+        return f"{cmd_name},{','.join(param_values)};" if len(param_values) != 0 else f"{cmd_name};"
+    
+    def _execute_command(self, cmd) -> Tuple[bool, str, Any]:
+        """执行命令（发送到软件）"""
+        _log(cmd)
+        return osis_run(cmd, self.run_mode)
+    
+    def list_commands(self):
+        """列出所有命令"""
+        for cmd_name, info in self.commands.items():
+            print(f"{cmd_name}: {info['doc'].split(chr(10))[0] if info['doc'] else '无描述'}")
+    
+    def get_command(self, cmd_name):
+        """获取函数信息"""
+        return self.commands.get(cmd_name)
+    
+    def count_command(self):
+        """计算总共多少个函数"""
+        return len(self.commands)
+    
+    def set_run_mode(self, mode: Literal["stash", "exec"]="exec"):
+        '''设置命令运行模式，默认是暂存，可以提高性能'''
+        self.mode = mode
+
+# 全局函数注册表实例
+REGISTRY = OSISFunctionRegistry()       # 作用为提供python函数和命令流的映射关系，保证参数个数与顺序正常，python函数一定要注册一下
+
+def set_run_mode(mode: Literal["stash", "exec"]="exec"):
+    '''
+    设置全局命令运行模式，默认是暂存，可以提高性能
+    
+    Args:
+        mode: 运行模式，此参数为了同时执行多条命令提高效率
+            * 使用 stash 仅会将命令流存到OSIS中，不会执行
+            * 收到 exec 信号才会执行暂存包括当前的所有命令流。
+    '''
+    REGISTRY.set_run_mode(mode)

pyosis/core/engine.py

@@ -0,0 +1,13 @@
+import os
+import sys
+
+# 查找dll路径
+current_dir =os.path.dirname(os.path.abspath(__file__))
+# dll_dir= os.path.abspath(os.path.join(current_dir, "../../../../bin64"))
+
+if os.path.exists(os.path.join(current_dir, "PyInterface.pyi")):
+    from PyInterface import PyInterface as OSISEngine       # 如果有pyi，认为pyd已经被找到了，直接导入就行
+else:
+    from .PyInterface import PyInterface as OSISEngine      # 如果没有pyi，认为只是简单实验下能不能跑，不用打开pyd
+
+

pyosis/element/__init__.py

@@ -0,0 +1 @@
+from .interface import *