bstart-trb 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

bstart_trb/__init__.py

@@ -11,8 +11,8 @@ Features:
 - Dataclass wrapped results
 
 Example:
-    >>> from slice_wrapper import slice_stress, RollerParams, RacewayParams
-    >>> from slice_wrapper import CrownType, RacewayType
+    >>> from bstart_trb import slice_stress, RollerParams, RacewayParams
+    >>> from bstart_trb import CrownType, RacewayType
     >>> 
     >>> # Define cylindrical roller parameters
     >>> roller = RollerParams(
@@ -47,17 +47,17 @@ from .wrapper import (
 )
 
 __all__ = [
-    # 枚举类型
+    # Enum types
     "CrownType",
     "RacewayType",
-    # 数据类型
+    # Data types
     "RollerParams",
     "RacewayParams",
     "SliceResult",
-    # 计算函数
+    # Calculation functions
     "slice_stress",
     "batch_slice_stress",
     "is_fortran_available",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

bstart_trb/models.py

@@ -1,8 +1,9 @@
 """
-数据类型定义
+Data Type Definitions
 
-定义圆柱/圆锥滚子轴承切片计算所需的输入参数和输出结果的数据类。
-所有类都使用 dataclass 装饰器，支持完整的类型提示。
+Defines input parameter and output result data classes for
+cylindrical/tapered roller bearing slice calculation.
+All classes use the dataclass decorator with complete type hints.
 """
 
 from dataclasses import dataclass
@@ -13,62 +14,63 @@ from numpy.typing import NDArray
 
 
 class CrownType(IntEnum):
-    """凸度类型枚举
+    """Crown modification type enumeration.
     
-    用于指定滚子的凸度修形类型。
+    Specifies the crown modification type for the roller.
     
     Attributes:
-        STRAIGHT: 直线（无修形）
-        ARC: 圆弧凸度
-        LOGARITHMIC: 对数凸度（推荐，可实现最优应力分布）
+        STRAIGHT: No modification (straight profile)
+        ARC: Circular arc crown
+        LOGARITHMIC: Logarithmic crown (recommended for optimal stress distribution)
     """
     STRAIGHT = 0
-    """直线（无修形），边缘应力高"""
+    """No modification (straight profile), high edge stress"""
     
     ARC = 1
-    """圆弧凸度，需要指定圆弧半径"""
+    """Circular arc crown, requires arc radius specification"""
     
     LOGARITHMIC = 2
-    """对数凸度（推荐），理论上可实现均匀应力分布"""
+    """Logarithmic crown (recommended), theoretically achieves uniform stress distribution"""
 
 
 class RacewayType(IntEnum):
-    """滚道类型枚举
+    """Raceway type enumeration.
     
-    用于指定接触的滚道类型。
+    Specifies the type of raceway in contact.
     
     Attributes:
-        PLANE: 平面接触
-        INNER: 内圈滚道（凸面）
-        OUTER: 外圈滚道（凹面）
+        PLANE: Flat surface contact
+        INNER: Inner ring raceway (convex surface)
+        OUTER: Outer ring raceway (concave surface)
     """
     PLANE = 0
-    """平面接触"""
+    """Flat surface contact"""
     
     INNER = 1
-    """内圈滚道（凸面）"""
+    """Inner ring raceway (convex surface)"""
     
     OUTER = 2
-    """外圈滚道（凹面），注意 diameter 使用负值"""
+    """Outer ring raceway (concave surface), note: use negative diameter value"""
 
 
 @dataclass
 class RollerParams:
-    """滚子几何参数
+    """Roller geometry parameters.
     
-    定义圆柱/圆锥滚子的几何尺寸和修形参数。
+    Defines geometric dimensions and crown modification parameters
+    for cylindrical/tapered rollers.
     
     Attributes:
-        d1: 滚子小端直径 (mm)
-        d2: 滚子大端直径 (mm)，圆柱滚子 d1=d2
-        length: 滚子有效长度 (mm)
-        alfa: 滚子半圆锥角 (度)，圆柱滚子 alfa=0
-        tilt: 滚子倾斜角度 (度)，0 表示无倾斜
-        crown_type: 凸度类型，见 CrownType 枚举
-        curve_q: 设计载荷 (N)，用于计算对数凸度修形量
+        d1: Roller small end diameter (mm)
+        d2: Roller large end diameter (mm), d1=d2 for cylindrical rollers
+        length: Roller effective length (mm)
+        alfa: Roller half cone angle (degrees), alfa=0 for cylindrical rollers
+        tilt: Roller tilt angle (degrees), 0 means no tilt
+        crown_type: Crown modification type, see CrownType enum
+        curve_q: Design load (N), used for logarithmic crown calculation
     
     Example:
-        >>> # 圆柱滚子
+        >>> # Cylindrical roller
         >>> roller = RollerParams(
         ...     d1=10.0, d2=10.0, length=9.6,
         ...     alfa=0.0, tilt=0.0,
@@ -76,7 +78,7 @@ class RollerParams:
         ...     curve_q=14100.0
         ... )
         
-        >>> # 圆锥滚子
+        >>> # Tapered roller
         >>> taper_roller = RollerParams(
         ...     d1=8.0, d2=10.0, length=12.0,
         ...     alfa=10.0, tilt=0.0,
@@ -85,79 +87,79 @@ class RollerParams:
         ... )
     
     Note:
-        - 对数凸度修形在 load == curve_q 时可实现均匀应力分布
-        - tilt > 0 会导致一端应力集中，另一端可能脱离接触
+        - Logarithmic crown achieves uniform stress distribution when load == curve_q
+        - tilt > 0 causes stress concentration at one end, other end may lose contact
     """
     d1: float
-    """滚子小端直径 (mm)"""
+    """Roller small end diameter (mm)"""
     
     d2: float
-    """滚子大端直径 (mm)，圆柱滚子 d1=d2"""
+    """Roller large end diameter (mm), d1=d2 for cylindrical rollers"""
     
     length: float
-    """滚子有效长度 (mm)"""
+    """Roller effective length (mm)"""
     
     alfa: float = 0.0
-    """滚子半圆锥角 (度)，圆柱滚子 alfa=0"""
+    """Roller half cone angle (degrees), alfa=0 for cylindrical rollers"""
     
     tilt: float = 0.0
-    """滚子倾斜角度 (度)"""
+    """Roller tilt angle (degrees)"""
     
     crown_type: CrownType = CrownType.LOGARITHMIC
-    """凸度类型"""
+    """Crown modification type"""
     
     curve_q: float = 0.0
-    """设计载荷 (N)，用于对数凸度计算，0 表示使用实际载荷"""
+    """Design load (N), used for logarithmic crown calculation, 0 means use actual load"""
     
     def __post_init__(self):
-        """参数验证"""
+        """Parameter validation"""
         if self.d1 <= 0:
-            raise ValueError(f"滚子小端直径必须为正数，当前值: {self.d1}")
+            raise ValueError(f"Roller small end diameter must be positive, got: {self.d1}")
         if self.d2 <= 0:
-            raise ValueError(f"滚子大端直径必须为正数，当前值: {self.d2}")
+            raise ValueError(f"Roller large end diameter must be positive, got: {self.d2}")
         if self.length <= 0:
-            raise ValueError(f"滚子有效长度必须为正数，当前值: {self.length}")
+            raise ValueError(f"Roller effective length must be positive, got: {self.length}")
         if self.d1 > self.d2:
             import warnings
-            warnings.warn(f"滚子小端直径 d1={self.d1} 大于大端直径 d2={self.d2}，请确认")
+            warnings.warn(f"Roller small end diameter d1={self.d1} is greater than large end diameter d2={self.d2}, please verify")
         
-        # 转换枚举类型
+        # Convert enum type
         if isinstance(self.crown_type, int):
             self.crown_type = CrownType(self.crown_type)
     
     @property
     def is_cylindrical(self) -> bool:
-        """是否为圆柱滚子"""
+        """Whether this is a cylindrical roller"""
         return abs(self.d1 - self.d2) < 1e-6 and abs(self.alfa) < 1e-6
     
     @property
     def diameter(self) -> float:
-        """滚子直径（圆柱滚子）或平均直径（圆锥滚子）"""
+        """Roller diameter (cylindrical) or mean diameter (tapered)"""
         return (self.d1 + self.d2) / 2.0
 
 
 @dataclass
 class RacewayParams:
-    """滚道参数
+    """Raceway parameters.
     
-    定义滚道的几何特征。
+    Defines raceway geometric characteristics.
     
     Attributes:
-        diameter: 滚道直径 (mm)
-            - 内圈滚道：正值
-            - 外圈滚道：负值（Hertz 接触理论符号约定）
-        raceway_type: 滚道类型，见 RacewayType 枚举
-        fai: 滚道半圆锥角 (度)，圆柱滚子轴承为 0
+        diameter: Raceway diameter (mm)
+            - Inner ring raceway: positive value
+            - Outer ring raceway: negative value (Hertz contact theory sign convention)
+        raceway_type: Raceway type, see RacewayType enum
+        fai: Raceway half cone angle (degrees), 0 for cylindrical roller bearings
     
     Example:
-        >>> # 内圈滚道
+        >>> # Inner ring raceway
         >>> inner = RacewayParams(
         ...     diameter=110.0,
         ...     raceway_type=RacewayType.INNER,
         ...     fai=0.0
         ... )
         
-        >>> # 外圈滚道（注意负号）
+        >>> # Outer ring raceway (note negative sign)
         >>> outer = RacewayParams(
         ...     diameter=-150.0,
         ...     raceway_type=RacewayType.OUTER,
@@ -165,111 +167,111 @@ class RacewayParams:
         ... )
     
     Note:
-        外圈滚道 diameter 使用负值是 Hertz 接触理论的符号约定：
-        - 正曲率半径 → 凸面（滚子、内圈）
-        - 负曲率半径 → 凹面（外圈）
+        Outer ring raceway diameter uses negative value per Hertz contact theory convention:
+        - Positive radius of curvature → convex surface (roller, inner ring)
+        - Negative radius of curvature → concave surface (outer ring)
     """
     diameter: float
-    """滚道直径 (mm)，外圈使用负值"""
+    """Raceway diameter (mm), use negative value for outer ring"""
     
     raceway_type: RacewayType = RacewayType.INNER
-    """滚道类型"""
+    """Raceway type"""
     
     fai: float = 0.0
-    """滚道半圆锥角 (度)"""
+    """Raceway half cone angle (degrees)"""
     
     def __post_init__(self):
-        """参数验证"""
-        # 转换枚举类型
+        """Parameter validation"""
+        # Convert enum type
         if isinstance(self.raceway_type, int):
             self.raceway_type = RacewayType(self.raceway_type)
         
-        # 检查符号约定
+        # Check sign convention
         if self.raceway_type == RacewayType.OUTER and self.diameter > 0:
             import warnings
             warnings.warn(
-                f"外圈滚道 diameter 通常使用负值（当前值: {self.diameter}），"
-                "请确认是否正确"
+                f"Outer ring raceway diameter is typically negative (current value: {self.diameter}), "
+                "please verify if this is correct"
             )
 
 
 @dataclass
 class SliceResult:
-    """切片计算结果
+    """Slice calculation result.
     
-    包含滚子-滚道接触的切片应力分布计算结果。
+    Contains results of roller-raceway contact slice stress distribution calculation.
     
     Attributes:
-        n_slice: 切片数量
-        stress: 各切片接触中心应力 (MPa)
-        half_width: 各切片接触半宽度 (mm)
-        slice_force: 各切片接触力 (N)
-        deflection: 滚子变形量 (mm)
-        equilibrium_load: 平衡载荷 (N)
-        equilibrium_moment: 平衡力矩 (N·mm)
-        converged: 是否收敛
-        error_code: 错误码 (0=成功)
+        n_slice: Number of slices
+        stress: Contact center stress for each slice (MPa)
+        half_width: Contact half-width for each slice (mm)
+        slice_force: Contact force for each slice (N)
+        deflection: Roller deformation (mm)
+        equilibrium_load: Equilibrium load (N)
+        equilibrium_moment: Equilibrium moment (N·mm)
+        converged: Whether calculation converged
+        error_code: Error code (0=success)
     
     Example:
         >>> result = slice_stress(roller, raceway, load=1340.0, n_slice=30)
-        >>> print(f"最大应力: {result.max_stress:.0f} MPa")
-        >>> print(f"应力分布: {result.stress}")
-        >>> print(f"各切片力: {result.slice_force}")
+        >>> print(f"Max stress: {result.max_stress:.0f} MPa")
+        >>> print(f"Stress distribution: {result.stress}")
+        >>> print(f"Slice forces: {result.slice_force}")
     """
     n_slice: int
-    """切片数量"""
+    """Number of slices"""
     
     stress: NDArray[np.float64]
-    """各切片接触中心应力 (MPa)"""
+    """Contact center stress for each slice (MPa)"""
     
     half_width: NDArray[np.float64]
-    """各切片接触半宽度 (mm)"""
+    """Contact half-width for each slice (mm)"""
     
     slice_force: NDArray[np.float64]
-    """各切片接触力 (N)"""
+    """Contact force for each slice (N)"""
     
     deflection: float
-    """滚子变形量 (mm)"""
+    """Roller deformation (mm)"""
     
     equilibrium_load: float
-    """平衡载荷 (N)，应接近输入载荷"""
+    """Equilibrium load (N), should be close to input load"""
     
     equilibrium_moment: float
-    """平衡力矩 (N·mm)"""
+    """Equilibrium moment (N·mm)"""
     
     converged: bool = True
-    """是否收敛"""
+    """Whether calculation converged"""
     
     error_code: int = 0
-    """错误码: 0=成功, 1=方程求解失败, 2=切片数无效, 3=载荷无效"""
+    """Error code: 0=success, 1=equation solve failed, 2=invalid n_slice, 3=invalid load"""
     
     @property
     def max_stress(self) -> float:
-        """最大接触应力 (MPa)"""
+        """Maximum contact stress (MPa)"""
         return float(np.max(self.stress)) if len(self.stress) > 0 else 0.0
     
     @property
     def min_stress(self) -> float:
-        """最小接触应力 (MPa)，不包括 0（非接触区）"""
+        """Minimum contact stress (MPa), excluding 0 (non-contact zones)"""
         nonzero = self.stress[self.stress > 0]
         return float(np.min(nonzero)) if len(nonzero) > 0 else 0.0
     
     @property
     def mean_stress(self) -> float:
-        """平均接触应力 (MPa)，仅计算接触区"""
+        """Mean contact stress (MPa), calculated for contact zone only"""
         nonzero = self.stress[self.stress > 0]
         return float(np.mean(nonzero)) if len(nonzero) > 0 else 0.0
     
     @property
     def contact_slices(self) -> int:
-        """接触切片数量（应力 > 0）"""
+        """Number of slices in contact (stress > 0)"""
         return int(np.sum(self.stress > 0))
     
     @property
     def stress_uniformity(self) -> float:
-        """应力均匀度 (0~1)，1 表示完全均匀
+        """Stress uniformity (0~1), 1 means perfectly uniform.
         
-        定义为: 1 - (最大应力 - 最小应力) / 平均应力
+        Defined as: 1 - (max_stress - min_stress) / mean_stress
         """
         if self.mean_stress == 0:
             return 0.0
@@ -277,54 +279,54 @@ class SliceResult:
         return max(0.0, 1.0 - variation)
     
     def get_slice_positions(self, roller_length: float) -> NDArray[np.float64]:
-        """获取各切片的中心位置
+        """Get center position of each slice.
         
         Args:
-            roller_length: 滚子有效长度 (mm)
+            roller_length: Roller effective length (mm)
         
         Returns:
-            各切片中心位置，从 0 到 roller_length
+            Center position of each slice, from 0 to roller_length
         """
-        h = roller_length / self.n_slice / 2  # 半切片宽度
+        h = roller_length / self.n_slice / 2  # Half slice width
         positions = np.array([h * (2 * i + 1) for i in range(self.n_slice)])
         return positions
     
     def get_slice_width(self, roller_length: float) -> float:
-        """获取切片宽度
+        """Get slice width.
         
         Args:
-            roller_length: 滚子有效长度 (mm)
+            roller_length: Roller effective length (mm)
         
         Returns:
-            单个切片的宽度 (mm)
+            Width of a single slice (mm)
         """
         return roller_length / self.n_slice
     
     def get_slice_spacing(self, roller_length: float) -> float:
-        """获取相邻切片中心之间的间距
+        """Get spacing between adjacent slice centers.
         
-        注意：切片间距 = 切片宽度 = roller_length / n_slice
+        Note: Slice spacing = slice width = roller_length / n_slice
         
         Args:
-            roller_length: 滚子有效长度 (mm)
+            roller_length: Roller effective length (mm)
         
         Returns:
-            相邻切片中心之间的间距 (mm)
+            Spacing between adjacent slice centers (mm)
         """
         return roller_length / self.n_slice
     
     def print_slice_info(self, roller_length: float) -> None:
-        """打印切片划分信息
+        """Print slice division information.
         
         Args:
-            roller_length: 滚子有效长度 (mm)
+            roller_length: Roller effective length (mm)
         """
         width = self.get_slice_width(roller_length)
         positions = self.get_slice_positions(roller_length)
-        print(f"切片划分信息:")
-        print(f"  滚子有效长度: {roller_length} mm")
-        print(f"  切片数量: {self.n_slice}")
-        print(f"  切片宽度: {width:.6f} mm")
-        print(f"  切片宽度 × 切片数 = {width * self.n_slice:.6f} mm")
-        print(f"  第一片中心位置: {positions[0]:.6f} mm")
-        print(f"  最后片中心位置: {positions[-1]:.6f} mm")
+        print(f"Slice division info:")
+        print(f"  Roller effective length: {roller_length} mm")
+        print(f"  Number of slices: {self.n_slice}")
+        print(f"  Slice width: {width:.6f} mm")
+        print(f"  Slice width × n_slice = {width * self.n_slice:.6f} mm")
+        print(f"  First slice center position: {positions[0]:.6f} mm")
+        print(f"  Last slice center position: {positions[-1]:.6f} mm")

bstart_trb/wrapper.py

@@ -1,8 +1,8 @@
 """
-Python 包装层
+Python Wrapper Layer
 
-提供圆柱/圆锥滚子轴承切片应力计算的高级 Python 接口。
-封装底层 Fortran 计算核心（通过 f2py）。
+Provides high-level Python interface for cylindrical/tapered roller bearing
+slice stress calculation. Wraps the underlying Fortran computational core (via f2py).
 """
 
 from typing import Optional, Sequence, Callable, Tuple
@@ -17,7 +17,7 @@ from .models import (
     SliceResult,
 )
 
-# 尝试导入 f2py 编译的模块
+# Try to import f2py compiled module
 _FORTRAN_AVAILABLE = False
 _taper_calculate: Optional[Callable[..., Tuple[
     NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], float, float, float, int
@@ -30,8 +30,8 @@ try:
 except ImportError:
     import warnings
     warnings.warn(
-        "Fortran 计算核心未编译，请运行 'python build.py' 编译模块。"
-        "当前切片计算功能不可用。"
+        "Fortran core not compiled. Please run 'python build.py' to compile. "
+        "Slice calculation functionality is currently unavailable."
     )
 
 
@@ -41,73 +41,73 @@ def slice_stress(
     load: float,
     n_slice: int = 30,
 ) -> SliceResult:
-    """计算滚子-滚道接触的切片应力分布
+    """Calculate slice stress distribution for roller-raceway contact.
     
-    使用影响系数法（Influence Coefficient Method）计算滚子与滚道
-    接触时各切片的应力分布，考虑凸度修形和滚子倾斜的影响。
+    Uses the Influence Coefficient Method to calculate stress distribution
+    across slices, considering crown modification and roller tilt effects.
     
     Args:
-        roller: 滚子几何参数
-        raceway: 滚道参数
-        load: 滚子载荷 (N)
-        n_slice: 切片数量 (1-50)，默认 30
+        roller: Roller geometry parameters
+        raceway: Raceway parameters
+        load: Roller load (N)
+        n_slice: Number of slices (1-50), default 30
     
     Returns:
-        SliceResult: 包含各切片应力、接触半宽度等计算结果
+        SliceResult: Contains stress, contact half-width, and other results for each slice
     
     Raises:
-        RuntimeError: Fortran 模块未编译时抛出
-        ValueError: 参数无效时抛出
+        RuntimeError: When Fortran module is not compiled
+        ValueError: When parameters are invalid
     
     Example:
-        >>> from slice_wrapper import slice_stress, RollerParams, RacewayParams
-        >>> from slice_wrapper import CrownType, RacewayType
+        >>> from bstart_trb import slice_stress, RollerParams, RacewayParams
+        >>> from bstart_trb import CrownType, RacewayType
         >>> 
-        >>> # 定义滚子参数
+        >>> # Define roller parameters
         >>> roller = RollerParams(
         ...     d1=10.0, d2=10.0, length=9.6,
         ...     crown_type=CrownType.LOGARITHMIC,
         ...     curve_q=14100.0
         ... )
         >>> 
-        >>> # 定义外圈滚道参数（注意直径为负值）
+        >>> # Define outer ring raceway parameters (note negative diameter)
         >>> raceway = RacewayParams(
         ...     diameter=-150.0,
         ...     raceway_type=RacewayType.OUTER
         ... )
         >>> 
-        >>> # 计算切片应力
+        >>> # Calculate slice stress
         >>> result = slice_stress(roller, raceway, load=1340.0, n_slice=30)
-        >>> print(f"最大应力: {result.max_stress:.0f} MPa")
-        >>> print(f"应力均匀度: {result.stress_uniformity:.2%}")
+        >>> print(f"Max stress: {result.max_stress:.0f} MPa")
+        >>> print(f"Stress uniformity: {result.stress_uniformity:.2%}")
     
     Note:
-        - 切片数 n_slice 最大支持 50
-        - 对数凸度 (crown_type=2) 在 load == curve_q 时可实现均匀应力分布
-        - 外圈滚道的 diameter 应使用负值（Hertz 接触符号约定）
+        - Maximum n_slice is 50
+        - Logarithmic crown (crown_type=2) achieves uniform stress when load == curve_q
+        - Outer ring raceway diameter should be negative (Hertz contact sign convention)
     
     Theory:
-        该函数使用影响系数法求解滚子-滚道接触问题：
-        1. 将滚子沿轴向分成 n_slice 个切片
-        2. 建立切片间的弹性耦合关系（影响系数矩阵）
-        3. 使用高斯消元法求解线性方程组
-        4. 迭代收敛得到各切片的接触应力分布
+        This function uses the influence coefficient method to solve roller-raceway contact:
+        1. Divides roller axially into n_slice slices
+        2. Establishes elastic coupling between slices (influence coefficient matrix)
+        3. Solves linear system using Gaussian elimination
+        4. Iterates to convergence to obtain contact stress distribution
     """
     if not _FORTRAN_AVAILABLE or _taper_calculate is None:
         raise RuntimeError(
-            "Fortran 计算核心未编译。请先运行 'python build.py' 编译模块。"
+            "Fortran core not compiled. Please run 'python build.py' first."
         )
     
-    # 参数验证
+    # Parameter validation
     if load <= 0:
-        raise ValueError(f"载荷必须为正数，当前值: {load}")
+        raise ValueError(f"Load must be positive, got: {load}")
     if not 1 <= n_slice <= 50:
-        raise ValueError(f"切片数必须在 1-50 之间，当前值: {n_slice}")
+        raise ValueError(f"n_slice must be between 1-50, got: {n_slice}")
     
-    # 确定设计载荷
+    # Determine design load
     curve_q = roller.curve_q if roller.curve_q > 0 else load
     
-    # 调用 Fortran 计算（此时 _taper_calculate 已确保不为 None）
+    # Call Fortran calculation (_taper_calculate is guaranteed non-None here)
     p, a, q_slice, dc, q1, qm, ierr = _taper_calculate(
         d1=roller.d1,
         d2=roller.d2,
@@ -123,7 +123,7 @@ def slice_stress(
         curveq=curve_q,
     )
     
-    # 构建结果
+    # Build result
     return SliceResult(
         n_slice=n_slice,
         stress=np.array(p, dtype=np.float64),
@@ -143,25 +143,26 @@ def batch_slice_stress(
     loads: Sequence[float],
     n_slice: int = 30,
 ) -> list[SliceResult]:
-    """批量计算多个载荷下的切片应力分布
+    """Batch calculate slice stress distribution for multiple loads.
     
-    对多个载荷值进行切片应力计算，适用于载荷分布已知的情况。
+    Calculates slice stress for multiple load values, suitable when
+    load distribution is known.
     
     Args:
-        roller: 滚子几何参数
-        raceway: 滚道参数
-        loads: 载荷序列 (N)，支持 list[int], list[float], NDArray 等
-        n_slice: 切片数量，默认 30
+        roller: Roller geometry parameters
+        raceway: Raceway parameters
+        loads: Load sequence (N), supports list[int], list[float], NDArray, etc.
+        n_slice: Number of slices, default 30
     
     Returns:
-        list[SliceResult]: 各载荷对应的计算结果列表
+        list[SliceResult]: List of calculation results for each load
     
     Example:
-        >>> # 假设已知各滚子的载荷分布
+        >>> # Assuming known load distribution for each roller
         >>> loads = [1340.0, 1128.3, 689.2, 324.8]
         >>> results = batch_slice_stress(roller, raceway, loads)
         >>> for i, result in enumerate(results):
-        ...     print(f"载荷 {loads[i]:.1f}N: 最大应力 {result.max_stress:.0f} MPa")
+        ...     print(f"Load {loads[i]:.1f}N: Max stress {result.max_stress:.0f} MPa")
     """
     results = []
     for load in loads:
@@ -169,7 +170,7 @@ def batch_slice_stress(
             result = slice_stress(roller, raceway, load, n_slice)
             results.append(result)
         else:
-            # 无载荷，返回零结果
+            # Zero load, return zero result
             results.append(SliceResult(
                 n_slice=n_slice,
                 stress=np.zeros(n_slice),
@@ -185,9 +186,9 @@ def batch_slice_stress(
 
 
 def is_fortran_available() -> bool:
-    """检查 Fortran 计算核心是否可用
+    """Check if Fortran computational core is available.
     
     Returns:
-        bool: True 表示 Fortran 模块已编译可用
+        bool: True if Fortran module is compiled and available
     """
     return _FORTRAN_AVAILABLE

bstart_trb-0.2.2.dist-info/METADATA

@@ -0,0 +1,289 @@
+Metadata-Version: 2.4
+Name: bstart-trb
+Version: 0.2.2
+Summary: Add your description here
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: numpy>=2.0.0
+Provides-Extra: demo
+Requires-Dist: openpyxl>=3.1.5; extra == 'demo'
+Requires-Dist: pandas>=2.0.0; extra == 'demo'
+Requires-Dist: plotly>=5.0.0; extra == 'demo'
+Description-Content-Type: text/markdown
+
+# BSTART-TRB
+
+**Cylindrical/Tapered Roller Bearing Slice Stress Calculation Module**
+
+A high-performance Python package for calculating contact stress distribution in roller bearings using the slice method with Fortran computational core.
+
+## Features
+
+- 🚀 **Fast Fortran Core**: Compiled Fortran code via f2py for optimal performance
+- 📦 **Pre-compiled Binary**: No Fortran compiler required for installation
+- 🎯 **Type-Safe**: Complete type hints and IDE support
+- 🔬 **Accurate**: Uses influence coefficient method based on elastic contact theory
+- 📊 **Flexible**: Supports various crown types (linear, circular, logarithmic)
+
+## Installation
+
+```bash
+pip install bstart-trb
+```
+
+**Note**: This package includes pre-compiled binaries for Windows (x64) + Python 3.11. Support for other platforms coming soon.
+
+## Quick Start
+
+```python
+from bstart_trb import (
+    slice_stress,
+    RollerParams,
+    RacewayParams,
+    CrownType,
+    RacewayType,
+)
+
+# Define cylindrical roller parameters
+roller = RollerParams(
+    d1=10.0,              # Small end diameter (mm)
+    d2=10.0,              # Large end diameter (mm)
+    length=9.6,           # Effective length (mm)
+    alfa=0.0,             # Half cone angle (degrees)
+    tilt=0.0,             # Tilt angle (degrees)
+    crown_type=CrownType.LOGARITHMIC,
+    curve_q=14100.0,      # Design load (N)
+)
+
+# Define outer ring raceway parameters
+raceway = RacewayParams(
+    diameter=-150.0,      # Negative for concave surface (mm)
+    raceway_type=RacewayType.OUTER,
+    fai=0.0,              # Half cone angle (degrees)
+)
+
+# Calculate slice stress distribution
+result = slice_stress(roller, raceway, load=1340.86, n_slice=30)
+
+# Access scalar results
+print(f"Converged: {result.converged}")
+print(f"Max stress: {result.max_stress:.0f} MPa")
+print(f"Mean stress: {result.mean_stress:.0f} MPa")
+print(f"Contact deflection: {result.deflection:.6f} mm")
+print(f"Stress uniformity: {result.stress_uniformity:.2%}")
+print(f"Contact slices: {result.contact_slices}/{result.n_slice}")
+
+# Access array results
+print(f"Stress distribution: {result.stress}")         # MPa per slice
+print(f"Contact half-widths: {result.half_width}")     # mm per slice
+print(f"Slice forces: {result.slice_force}")           # N per slice
+
+# Get slice positions along roller length
+positions = result.get_slice_positions(roller.length)  # mm
+print(f"Slice positions: {positions}")
+```
+
+## Return Value: `SliceResult`
+
+The `slice_stress()` function returns a `SliceResult` object containing:
+
+### Array Attributes
+
+| Attribute | Type | Unit | Description |
+|-----------|------|------|-------------|
+| `stress` | `NDArray[float64]` | MPa | Contact stress at each slice center |
+| `half_width` | `NDArray[float64]` | mm | Contact half-width at each slice |
+| `slice_force` | `NDArray[float64]` | N | Contact force at each slice |
+
+### Scalar Attributes
+
+| Attribute | Type | Unit | Description |
+|-----------|------|------|-------------|
+| `n_slice` | `int` | - | Number of slices |
+| `deflection` | `float` | mm | Roller deformation |
+| `equilibrium_load` | `float` | N | Equilibrium load (should match input) |
+| `equilibrium_moment` | `float` | N·mm | Equilibrium moment |
+| `converged` | `bool` | - | Whether the iteration converged |
+| `error_code` | `int` | - | 0=success, 1=solve failed, 2=invalid n_slice, 3=invalid load |
+
+### Computed Properties
+
+| Property | Type | Unit | Description |
+|----------|------|------|-------------|
+| `max_stress` | `float` | MPa | Maximum contact stress |
+| `min_stress` | `float` | MPa | Minimum contact stress (non-zero) |
+| `mean_stress` | `float` | MPa | Mean contact stress (contact zone only) |
+| `contact_slices` | `int` | - | Number of slices in contact (stress > 0) |
+| `stress_uniformity` | `float` | 0~1 | Stress uniformity (1 = perfectly uniform) |
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `get_slice_positions(roller_length)` | `NDArray[float64]` | Center position of each slice (mm) |
+| `get_slice_width(roller_length)` | `float` | Width of each slice (mm) |
+| `get_slice_spacing(roller_length)` | `float` | Spacing between slice centers (mm) |
+
+## Other Functions
+
+### `batch_slice_stress()`
+
+Calculate stress for multiple loads at once:
+
+```python
+from bstart_trb import batch_slice_stress
+
+loads = [1340.0, 1128.3, 689.2, 324.8]
+results = batch_slice_stress(roller, raceway, loads, n_slice=30)
+
+for i, result in enumerate(results):
+    print(f"Load {loads[i]:.1f}N: Max stress {result.max_stress:.0f} MPa")
+```
+
+### `is_fortran_available()`
+
+Check if Fortran core is available:
+
+```python
+from bstart_trb import is_fortran_available
+
+if is_fortran_available():
+    print("Fortran core ready")
+else:
+    print("Fortran core not compiled")
+```
+
+## Enum Types
+
+### `CrownType` - Crown Modification Types
+
+| Value | Name | Description |
+|-------|------|-------------|
+| 0 | `STRAIGHT` | No crown modification - high edge stress |
+| 1 | `ARC` | Circular crown - requires arc radius |
+| 2 | `LOGARITHMIC` | Logarithmic crown (recommended) - optimal stress distribution |
+
+### `RacewayType` - Raceway Types
+
+| Value | Name | Description |
+|-------|------|-------------|
+| 0 | `PLANE` | Flat surface contact |
+| 1 | `INNER` | Inner ring raceway (convex surface) |
+| 2 | `OUTER` | Outer ring raceway (concave surface) - use negative diameter |
+
+## Key Parameters Explained
+
+### Roller Parameters
+
+| Parameter | Unit | Description |
+|-----------|------|-------------|
+| `d1` | mm | Roller small end diameter (equal to d2 for cylindrical) |
+| `d2` | mm | Roller large end diameter |
+| `length` | mm | Effective roller length |
+| `alfa` | deg | Roller half cone angle (0 for cylindrical) |
+| `tilt` | deg | Roller tilt angle (see below) |
+| `crown_type` | - | Crown modification type (see enum) |
+| `curve_q` | N | Design load for crown optimization (see below) |
+
+### Raceway Parameters
+
+| Parameter | Unit | Description |
+|-----------|------|-------------|
+| `diameter` | mm | Raceway diameter (**negative for outer ring**) |
+| `raceway_type` | - | Inner/Outer raceway type |
+| `fai` | deg | Raceway half cone angle |
+
+### Calculation Parameters
+
+| Parameter | Unit | Description |
+|-----------|------|-------------|
+| `load` | N | Applied load on roller |
+| `n_slice` | - | Number of slices (default 30, max 50) |
+
+### Understanding `curve_q` (Design Load)
+
+The `curve_q` parameter determines the logarithmic crown profile. It affects stress distribution:
+
+| Condition | Stress Distribution |
+|-----------|---------------------|
+| `load == curve_q` | **Uniform** - optimal crown compensation |
+| `load < curve_q` | Center high, edge low - edge may lose contact |
+| `load > curve_q` | Edge high, center low - edge stress concentration |
+
+**Tip**: Set `curve_q` to your most common operating load.
+
+### Understanding `tilt` (Tilt Angle)
+
+Roller tilt causes asymmetric stress distribution:
+
+```
+tilt = 0 (normal):          tilt > 0 (tilted):
+┌──────────────────┐        ┌──────────────────┐
+│  uniform stress  │        │ high │    low    │
+└──────────────────┘        └──────────────────┘
+```
+
+Sources of tilt: shaft deflection, mounting errors, housing deformation.
+
+### Why Outer Ring Uses Negative Diameter?
+
+Hertz contact theory sign convention:
+- **Positive curvature** → Convex surface (roller, inner ring)
+- **Negative curvature** → Concave surface (outer ring)
+
+Example: Outer ring with 150mm diameter → `diameter = -150.0`
+
+## What is Slice Calculation?
+
+The slice method divides the roller-raceway contact into multiple slices along the roller length to accurately calculate stress distribution. This is essential for:
+
+- Capturing edge stress concentration effects
+- Analyzing the impact of crown modifications
+- Predicting bearing life more accurately
+- Understanding load distribution along roller length
+
+## Theory
+
+This package implements the **influence coefficient method** based on elastic half-space contact theory:
+
+1. Discretizes roller into slices
+2. Calculates elastic coupling between slices (influence coefficient matrix)
+3. Solves linear system using Gaussian elimination
+4. Iterates to convergence for contact area and load balance
+
+The method is more accurate than simplified Hertz formulas as it accounts for:
+- Elastic coupling between slices
+- Dynamic contact area determination
+- Edge loading effects
+- Crown modification influence
+
+## Requirements
+
+- Python >= 3.11
+- NumPy >= 2.0.0
+
+## Platform Support
+
+| Platform | Status |
+|----------|--------|
+| Windows (x64) | ✅ Supported |
+| Linux | 🚧 Coming soon |
+| macOS | 🚧 Coming soon |
+
+## License
+
+MIT License - See LICENSE file for details.
+
+## Author
+
+Gu Lei
+
+## References
+
+- Harris, T.A., Kotzalas, M.N. - *Rolling Bearing Analysis*, 5th Edition
+- Johnson, K.L. - *Contact Mechanics*
+- ISO/TS 16281:2008 - Rolling bearings calculation methods
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.

bstart_trb-0.2.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+bstart_trb/__init__.py,sha256=32QmnLdTE53qkVgDvDZBH2Z1v3I-4qG8JlcVlQDcbU4,1560
+bstart_trb/_taper_slice.pyi,sha256=X5xMWlbdGl46RQmunOaFbh9BFjeqTMP0Hp7b_waJuaA,4896
+bstart_trb/libtaper_sl.J4R3HUMRYTOGZPKAVTEOISVEHZMIJTJT.gfortran-win_amd64.dll,sha256=9fWV89mKt1_6Q8f_votoG1vlvxsy4qgDVWXQAZ0vmUA,108562
+bstart_trb/models.py,sha256=tRpkcJE50I9jL3y03EgITJ1iMv57gRFkr1tl6OeXDWw,11503
+bstart_trb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bstart_trb/wrapper.py,sha256=CadOcW31MVZ8WsTwG5Ksp_ZAacf_D96XJJ4gqYb70MM,6565
+bstart_trb/_taper_slice.cp311-win_amd64.pyd,sha256=WDAXF_NTj7DRIEA6--kX1W3TMPGQD5u8JVRt-hR_9L4,64000
+bstart_trb-0.2.2.dist-info/METADATA,sha256=jRClXe7c3JBUEWgsMsYT9vkUTWjldlM5aLma2y1ZogQ,9502
+bstart_trb-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+bstart_trb-0.2.2.dist-info/licenses/LICENSE,sha256=YCXLtJfjUPyklZ7pN5gxOeMOr5QCAvip4Sdnl_xcCu8,1084
+bstart_trb-0.2.2.dist-info/RECORD,,

bstart_trb-0.2.1.dist-info/METADATA

@@ -1,153 +0,0 @@
-Metadata-Version: 2.4
-Name: bstart-trb
-Version: 0.2.1
-Summary: Add your description here
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: numpy>=2.0.0
-Provides-Extra: demo
-Requires-Dist: openpyxl>=3.1.5; extra == 'demo'
-Requires-Dist: pandas>=2.0.0; extra == 'demo'
-Requires-Dist: plotly>=5.0.0; extra == 'demo'
-Description-Content-Type: text/markdown
-
-# BSTART-TRB
-
-**Cylindrical/Tapered Roller Bearing Slice Stress Calculation Module**
-
-A high-performance Python package for calculating contact stress distribution in roller bearings using the slice method with Fortran computational core.
-
-## Features
-
-- 🚀 **Fast Fortran Core**: Compiled Fortran code via f2py for optimal performance
-- 📦 **Pre-compiled Binary**: No Fortran compiler required for installation
-- 🎯 **Type-Safe**: Complete type hints and IDE support
-- 🔬 **Accurate**: Uses influence coefficient method based on elastic contact theory
-- 📊 **Flexible**: Supports various crown types (linear, circular, logarithmic)
-
-## Installation
-
-```bash
-pip install bstart-trb
-```
-
-**Note**: This package includes pre-compiled binaries for Windows (x64). Support for other platforms coming soon.
-
-## Quick Start
-
-```python
-from bstart_trb import (
-    slice_stress,
-    RollerParams,
-    RacewayParams,
-    CrownType,
-    RacewayType,
-)
-
-# Define cylindrical roller parameters
-roller = RollerParams(
-    d1=10.0,              # Small end diameter (mm)
-    d2=10.0,              # Large end diameter (mm)
-    length=9.6,           # Effective length (mm)
-    alfa=0.0,             # Half cone angle (degrees)
-    tilt=0.0,             # Tilt angle (degrees)
-    crown_type=CrownType.LOGARITHMIC,
-    curve_q=14100.0,      # Design load (N)
-)
-
-# Define outer ring raceway parameters
-raceway = RacewayParams(
-    diameter=-150.0,      # Negative for concave surface (mm)
-    raceway_type=RacewayType.OUTER,
-    fai=0.0,              # Half cone angle (degrees)
-)
-
-# Calculate slice stress distribution
-result = slice_stress(roller, raceway, load=1340.86, n_slice=30)
-
-# Access results
-print(f"Max stress: {result.max_stress:.0f} MPa")
-print(f"Contact deflection: {result.deflection:.6f} mm")
-print(f"Stress uniformity: {result.stress_uniformity:.2%}")
-print(f"Contact slices: {result.contact_slices}/{result.n_slice}")
-```
-
-## What is Slice Calculation?
-
-The slice method divides the roller-raceway contact into multiple slices along the roller length to accurately calculate stress distribution. This is essential for:
-
-- Capturing edge stress concentration effects
-- Analyzing the impact of crown modifications
-- Predicting bearing life more accurately
-- Understanding load distribution along roller length
-
-## Key Parameters
-
-### Roller Parameters
-
-- `d1`, `d2`: Roller diameters (mm) - equal for cylindrical rollers
-- `length`: Effective roller length (mm)
-- `alfa`: Half cone angle (degrees) - 0 for cylindrical rollers
-- `tilt`: Roller tilt angle (degrees)
-- `crown_type`: Crown modification type
-  - `STRAIGHT`: No crown modification
-  - `CIRCULAR`: Circular crown
-  - `LOGARITHMIC`: Logarithmic crown (recommended)
-- `curve_q`: Design load (N) for optimal stress distribution
-
-### Raceway Parameters
-
-- `diameter`: Raceway diameter (mm) - negative for outer ring (concave)
-- `raceway_type`: `INNER` or `OUTER`
-- `fai`: Raceway cone angle (degrees)
-
-### Calculation Parameters
-
-- `load`: Applied load on roller (N)
-- `n_slice`: Number of slices (default 30, max 50)
-
-## Theory
-
-This package implements the **influence coefficient method** based on elastic half-space contact theory:
-
-1. Discretizes roller into slices
-2. Calculates elastic coupling between slices (influence coefficient matrix)
-3. Solves linear system using Gaussian elimination
-4. Iterates to convergence for contact area and load balance
-
-The method is more accurate than simplified Hertz formulas as it accounts for:
-- Elastic coupling between slices
-- Dynamic contact area determination
-- Edge loading effects
-- Crown modification influence
-
-## Requirements
-
-- Python >= 3.11
-- NumPy >= 2.0.0
-
-## Platform Support
-
-| Platform | Status |
-|----------|--------|
-| Windows (x64) | ✅ Supported |
-| Linux | 🚧 Coming soon |
-| macOS | 🚧 Coming soon |
-
-## License
-
-MIT License - See LICENSE file for details.
-
-## Author
-
-Gu Lei
-
-## References
-
-- Harris, T.A., Kotzalas, M.N. - *Rolling Bearing Analysis*, 5th Edition
-- Johnson, K.L. - *Contact Mechanics*
-- ISO/TS 16281:2008 - Rolling bearings calculation methods
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit issues or pull requests.

bstart_trb-0.2.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-bstart_trb/__init__.py,sha256=rT8U08bYmQerx7pncsk5YBzuvB7U8NfURK1pkIWQYdU,1561
-bstart_trb/_taper_slice.pyi,sha256=X5xMWlbdGl46RQmunOaFbh9BFjeqTMP0Hp7b_waJuaA,4896
-bstart_trb/libtaper_sl.J4R3HUMRYTOGZPKAVTEOISVEHZMIJTJT.gfortran-win_amd64.dll,sha256=9fWV89mKt1_6Q8f_votoG1vlvxsy4qgDVWXQAZ0vmUA,108562
-bstart_trb/models.py,sha256=pbdcbYXjcL3TwSEGulStj0Zj6-lJ4w1_DSRzcpslPcM,10599
-bstart_trb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bstart_trb/wrapper.py,sha256=sDJ97Ptx1YCnwUiKRD1g79YQp7ZSKeI0P_XF3HPcXWc,6354
-bstart_trb/_taper_slice.cp311-win_amd64.pyd,sha256=WDAXF_NTj7DRIEA6--kX1W3TMPGQD5u8JVRt-hR_9L4,64000
-bstart_trb-0.2.1.dist-info/METADATA,sha256=JkVuPTqQ_uZg27l0WUQyosT6-0vjOqD61A5YCYvZ0c4,4565
-bstart_trb-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-bstart_trb-0.2.1.dist-info/licenses/LICENSE,sha256=YCXLtJfjUPyklZ7pN5gxOeMOr5QCAvip4Sdnl_xcCu8,1084
-bstart_trb-0.2.1.dist-info/RECORD,,