bstart-trb 0.1.0__tar.gz

bstart_trb-0.1.0/.gitignore

@@ -0,0 +1,30 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Compiled extensions (built by CI)
+*.so
+*.dylib
+
+# 注意：不再忽略 .pyd 文件，因为需要将预编译的二进制文件打包
+# 如果需要排除特定的 .pyd 文件，请在下面明确列出
+# *.pyd
+
+# Build artifacts
+*.mod
+*.o
+
+# IDE
+.idea/
+.vscode/
+
+# Test outputs
+*.html
+*.json

bstart_trb-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gu Lei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bstart_trb-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: bstart-trb
+Version: 0.1.0
+Summary: Cylindrical/Tapered Roller Bearing Slice Stress Calculation Module
+Project-URL: Homepage, https://github.com/yourusername/bstart-trb
+Project-URL: Repository, https://github.com/yourusername/bstart-trb
+Project-URL: Documentation, https://github.com/yourusername/bstart-trb#readme
+Author-email: Gu Lei <gulei@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: bearing,contact,f2py,fortran,hertz,roller,stress
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Fortran
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.12
+Requires-Dist: numpy>=2.0.0
+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 slice_wrapper 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.12
+- 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.1.0/README_PYPI.md

@@ -0,0 +1,140 @@
+# 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 slice_wrapper 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.12
+- 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.1.0/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "bstart-trb"
+version = "0.1.0"
+description = "Cylindrical/Tapered Roller Bearing Slice Stress Calculation Module"
+readme = "README_PYPI.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+authors = [
+    {name = "Gu Lei", email = "gulei@example.com"}
+]
+keywords = ["bearing", "roller", "stress", "contact", "hertz", "fortran", "f2py"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Manufacturing",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Fortran",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Operating System :: Microsoft :: Windows",
+]
+dependencies = [
+    "numpy>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/bstart-trb"
+Repository = "https://github.com/yourusername/bstart-trb"
+Documentation = "https://github.com/yourusername/bstart-trb#readme"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["slice_wrapper"]
+artifacts = [
+    "slice_wrapper/*.pyd",
+    "slice_wrapper/*.so",
+]
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "slice_wrapper/__init__.py",
+    "slice_wrapper/models.py",
+    "slice_wrapper/wrapper.py",
+    "slice_wrapper/_taper_slice.pyi",
+    "slice_wrapper/py.typed",
+    "slice_wrapper/_taper_slice.cp312-win_amd64.pyd",
+    "README_PYPI.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[dependency-groups]
+dev = [
+    "hatchling>=1.28.0",
+    "twine>=6.2.0",
+]

bstart_trb-0.1.0/slice_wrapper/__init__.py

@@ -0,0 +1,63 @@
+"""
+Cylindrical/Tapered Roller Bearing Slice Stress Calculation Module
+
+This module provides slice calculation for roller-raceway contact stress distribution,
+using Fortran compiled core via f2py.
+
+Features:
+- No file I/O, direct memory transfer
+- Complete type hints
+- Native NumPy array support
+- Dataclass wrapped results
+
+Example:
+    >>> from slice_wrapper import slice_stress, RollerParams, RacewayParams
+    >>> from slice_wrapper import CrownType, RacewayType
+    >>> 
+    >>> # Define cylindrical 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
+    >>> 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"Max stress: {result.max_stress:.0f} MPa")
+"""
+
+from .models import (
+    CrownType,
+    RacewayType,
+    RollerParams,
+    RacewayParams,
+    SliceResult,
+)
+
+from .wrapper import (
+    slice_stress,
+    batch_slice_stress,
+    is_fortran_available,
+)
+
+__all__ = [
+    # 枚举类型
+    "CrownType",
+    "RacewayType",
+    # 数据类型
+    "RollerParams",
+    "RacewayParams",
+    "SliceResult",
+    # 计算函数
+    "slice_stress",
+    "batch_slice_stress",
+    "is_fortran_available",
+]
+
+__version__ = "0.1.0"

bstart_trb-0.1.0/slice_wrapper/_taper_slice.pyi

@@ -0,0 +1,140 @@
+"""
+Type stubs for _taper_slice Fortran extension module.
+
+This module provides Python type hints for the f2py compiled Fortran module.
+"""
+
+from typing import Tuple
+import numpy as np
+from numpy.typing import NDArray
+
+def taper_calculate(
+    d1: float,
+    d2: float,
+    rl: float,
+    alfa: float,
+    q: float,
+    tilt: float,
+    m1: int,
+    n_slice: int,
+    m2: int,
+    dr1: float,
+    fai: float,
+    curveq: float,
+) -> Tuple[
+    NDArray[np.float64],  # p: Contact center stress for each slice (MPa)
+    NDArray[np.float64],  # a: Contact half-width for each slice (mm)
+    NDArray[np.float64],  # q_slice: Contact force for each slice (N)
+    float,                 # dc: Roller deflection (mm)
+    float,                 # q1: Equilibrium load (N)
+    float,                 # qm: Equilibrium moment (N·mm)
+    int,                   # ierr: Error code (0=success)
+]:
+    """Calculate slice stress distribution for roller-raceway contact
+    
+    Uses the Influence Coefficient Method to calculate contact stress.
+    
+    Args:
+        d1: Roller small-end diameter (mm)
+        d2: Roller large-end diameter (mm), d1=d2 for cylindrical roller
+        rl: Roller effective length (mm)
+        alfa: Roller half-cone angle (deg), alfa=0 for cylindrical roller
+        q: Roller load (N)
+        tilt: Roller tilt angle (deg)
+        m1: Crown type - 0:straight, 1:arc, 2:logarithmic
+        n_slice: Number of slices (1-50)
+        m2: Raceway type - 0:plane, 1:inner, 2:outer
+        dr1: Raceway diameter (mm), use negative value for outer ring
+        fai: Raceway half-cone angle (deg)
+        curveq: Design load (N), for logarithmic crown calculation
+    
+    Returns:
+        Tuple containing:
+        - p: Contact center stress array (MPa), shape=(n_slice,)
+        - a: Contact half-width array (mm), shape=(n_slice,)
+        - q_slice: Contact force array (N), shape=(n_slice,)
+        - dc: Roller deflection (mm)
+        - q1: Equilibrium load (N), should be close to input load q
+        - qm: Equilibrium moment (N·mm)
+        - ierr: Error code
+            - 0: Calculation successful
+            - 1: Equation solving failed
+            - 2: Invalid slice count (n_slice < 1 or > 50)
+            - 3: Invalid load (q <= 0)
+    
+    Example:
+        >>> import _taper_slice
+        >>> p, a, q_slice, dc, q1, qm, ierr = _taper_slice.taper_calculate(
+        ...     d1=10.0, d2=10.0, rl=9.6, alfa=0.0,
+        ...     q=1340.86, tilt=0.0, m1=2, n_slice=30,
+        ...     m2=2, dr1=-150.0, fai=0.0, curveq=14100.0
+        ... )
+        >>> print(f"Max stress: {max(p):.0f} MPa")
+        >>> print(f"Slice force sum: {sum(q_slice):.2f} N")
+    
+    Note:
+        - Outer ring raceway (m2=2) dr1 should use negative value (Hertz contact sign convention)
+        - Logarithmic crown (m1=2) achieves uniform stress distribution when q=curveq
+        - Recommended n_slice >= 20 for sufficient accuracy
+    """
+    ...
+
+
+class taper_slice_mod:
+    """Fortran module taper_slice_mod
+    
+    Contains the core calculation subroutines for slice stress analysis.
+    Usually not called directly; use taper_calculate instead.
+    """
+    
+    # Module constants
+    POISSON: float
+    """Poisson's ratio (default: 0.3)"""
+    
+    ELASTIC_MOD: float
+    """Elastic modulus in MPa (default: 2.06e5)"""
+    
+    PI: float
+    """Pi constant"""
+    
+    DEG2RAD: float
+    """Degree to radian conversion factor"""
+    
+    MAX_SLICES: int
+    """Maximum number of slices (50)"""
+    
+    @staticmethod
+    def calculate_slice_stress(
+        d1: float,
+        d2: float,
+        rl: float,
+        alfa: float,
+        q: float,
+        tilt: float,
+        m1: int,
+        n_slice: int,
+        m2: int,
+        dr1: float,
+        fai: float,
+        curveq: float,
+        pl: float,
+        rc: float,
+    ) -> Tuple[
+        NDArray[np.float64],  # p: Contact center stress for each slice (MPa)
+        NDArray[np.float64],  # a: Contact half-width for each slice (mm)
+        NDArray[np.float64],  # q_slice: Contact force for each slice (N)
+        float,                 # dc: Roller deflection (mm)
+        float,                 # q1: Equilibrium load (N)
+        float,                 # qm: Equilibrium moment (N·mm)
+        int,                   # ierr: Error code (0=success)
+    ]:
+        """Full interface for slice stress calculation (includes arc crown params)
+        
+        This is the full interface including arc crown parameters pl and rc.
+        For most use cases, use taper_calculate instead which provides defaults.
+        
+        Additional Args:
+            pl: Parallel length (mm), only for arc crown (m1=1)
+            rc: Crown radius (mm), only for arc crown (m1=1)
+        """
+        ...

bstart_trb-0.1.0/slice_wrapper/models.py

@@ -0,0 +1,330 @@
+"""
+数据类型定义
+
+定义圆柱/圆锥滚子轴承切片计算所需的输入参数和输出结果的数据类。
+所有类都使用 dataclass 装饰器，支持完整的类型提示。
+"""
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Optional
+import numpy as np
+from numpy.typing import NDArray
+
+
+class CrownType(IntEnum):
+    """凸度类型枚举
+    
+    用于指定滚子的凸度修形类型。
+    
+    Attributes:
+        STRAIGHT: 直线（无修形）
+        ARC: 圆弧凸度
+        LOGARITHMIC: 对数凸度（推荐，可实现最优应力分布）
+    """
+    STRAIGHT = 0
+    """直线（无修形），边缘应力高"""
+    
+    ARC = 1
+    """圆弧凸度，需要指定圆弧半径"""
+    
+    LOGARITHMIC = 2
+    """对数凸度（推荐），理论上可实现均匀应力分布"""
+
+
+class RacewayType(IntEnum):
+    """滚道类型枚举
+    
+    用于指定接触的滚道类型。
+    
+    Attributes:
+        PLANE: 平面接触
+        INNER: 内圈滚道（凸面）
+        OUTER: 外圈滚道（凹面）
+    """
+    PLANE = 0
+    """平面接触"""
+    
+    INNER = 1
+    """内圈滚道（凸面）"""
+    
+    OUTER = 2
+    """外圈滚道（凹面），注意 diameter 使用负值"""
+
+
+@dataclass
+class RollerParams:
+    """滚子几何参数
+    
+    定义圆柱/圆锥滚子的几何尺寸和修形参数。
+    
+    Attributes:
+        d1: 滚子小端直径 (mm)
+        d2: 滚子大端直径 (mm)，圆柱滚子 d1=d2
+        length: 滚子有效长度 (mm)
+        alfa: 滚子半圆锥角 (度)，圆柱滚子 alfa=0
+        tilt: 滚子倾斜角度 (度)，0 表示无倾斜
+        crown_type: 凸度类型，见 CrownType 枚举
+        curve_q: 设计载荷 (N)，用于计算对数凸度修形量
+    
+    Example:
+        >>> # 圆柱滚子
+        >>> roller = RollerParams(
+        ...     d1=10.0, d2=10.0, length=9.6,
+        ...     alfa=0.0, tilt=0.0,
+        ...     crown_type=CrownType.LOGARITHMIC,
+        ...     curve_q=14100.0
+        ... )
+        
+        >>> # 圆锥滚子
+        >>> taper_roller = RollerParams(
+        ...     d1=8.0, d2=10.0, length=12.0,
+        ...     alfa=10.0, tilt=0.0,
+        ...     crown_type=CrownType.LOGARITHMIC,
+        ...     curve_q=20000.0
+        ... )
+    
+    Note:
+        - 对数凸度修形在 load == curve_q 时可实现均匀应力分布
+        - tilt > 0 会导致一端应力集中，另一端可能脱离接触
+    """
+    d1: float
+    """滚子小端直径 (mm)"""
+    
+    d2: float
+    """滚子大端直径 (mm)，圆柱滚子 d1=d2"""
+    
+    length: float
+    """滚子有效长度 (mm)"""
+    
+    alfa: float = 0.0
+    """滚子半圆锥角 (度)，圆柱滚子 alfa=0"""
+    
+    tilt: float = 0.0
+    """滚子倾斜角度 (度)"""
+    
+    crown_type: CrownType = CrownType.LOGARITHMIC
+    """凸度类型"""
+    
+    curve_q: float = 0.0
+    """设计载荷 (N)，用于对数凸度计算，0 表示使用实际载荷"""
+    
+    def __post_init__(self):
+        """参数验证"""
+        if self.d1 <= 0:
+            raise ValueError(f"滚子小端直径必须为正数，当前值: {self.d1}")
+        if self.d2 <= 0:
+            raise ValueError(f"滚子大端直径必须为正数，当前值: {self.d2}")
+        if self.length <= 0:
+            raise ValueError(f"滚子有效长度必须为正数，当前值: {self.length}")
+        if self.d1 > self.d2:
+            import warnings
+            warnings.warn(f"滚子小端直径 d1={self.d1} 大于大端直径 d2={self.d2}，请确认")
+        
+        # 转换枚举类型
+        if isinstance(self.crown_type, int):
+            self.crown_type = CrownType(self.crown_type)
+    
+    @property
+    def is_cylindrical(self) -> bool:
+        """是否为圆柱滚子"""
+        return abs(self.d1 - self.d2) < 1e-6 and abs(self.alfa) < 1e-6
+    
+    @property
+    def diameter(self) -> float:
+        """滚子直径（圆柱滚子）或平均直径（圆锥滚子）"""
+        return (self.d1 + self.d2) / 2.0
+
+
+@dataclass
+class RacewayParams:
+    """滚道参数
+    
+    定义滚道的几何特征。
+    
+    Attributes:
+        diameter: 滚道直径 (mm)
+            - 内圈滚道：正值
+            - 外圈滚道：负值（Hertz 接触理论符号约定）
+        raceway_type: 滚道类型，见 RacewayType 枚举
+        fai: 滚道半圆锥角 (度)，圆柱滚子轴承为 0
+    
+    Example:
+        >>> # 内圈滚道
+        >>> inner = RacewayParams(
+        ...     diameter=110.0,
+        ...     raceway_type=RacewayType.INNER,
+        ...     fai=0.0
+        ... )
+        
+        >>> # 外圈滚道（注意负号）
+        >>> outer = RacewayParams(
+        ...     diameter=-150.0,
+        ...     raceway_type=RacewayType.OUTER,
+        ...     fai=0.0
+        ... )
+    
+    Note:
+        外圈滚道 diameter 使用负值是 Hertz 接触理论的符号约定：
+        - 正曲率半径 → 凸面（滚子、内圈）
+        - 负曲率半径 → 凹面（外圈）
+    """
+    diameter: float
+    """滚道直径 (mm)，外圈使用负值"""
+    
+    raceway_type: RacewayType = RacewayType.INNER
+    """滚道类型"""
+    
+    fai: float = 0.0
+    """滚道半圆锥角 (度)"""
+    
+    def __post_init__(self):
+        """参数验证"""
+        # 转换枚举类型
+        if isinstance(self.raceway_type, int):
+            self.raceway_type = RacewayType(self.raceway_type)
+        
+        # 检查符号约定
+        if self.raceway_type == RacewayType.OUTER and self.diameter > 0:
+            import warnings
+            warnings.warn(
+                f"外圈滚道 diameter 通常使用负值（当前值: {self.diameter}），"
+                "请确认是否正确"
+            )
+
+
+@dataclass
+class SliceResult:
+    """切片计算结果
+    
+    包含滚子-滚道接触的切片应力分布计算结果。
+    
+    Attributes:
+        n_slice: 切片数量
+        stress: 各切片接触中心应力 (MPa)
+        half_width: 各切片接触半宽度 (mm)
+        slice_force: 各切片接触力 (N)
+        deflection: 滚子变形量 (mm)
+        equilibrium_load: 平衡载荷 (N)
+        equilibrium_moment: 平衡力矩 (N·mm)
+        converged: 是否收敛
+        error_code: 错误码 (0=成功)
+    
+    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}")
+    """
+    n_slice: int
+    """切片数量"""
+    
+    stress: NDArray[np.float64]
+    """各切片接触中心应力 (MPa)"""
+    
+    half_width: NDArray[np.float64]
+    """各切片接触半宽度 (mm)"""
+    
+    slice_force: NDArray[np.float64]
+    """各切片接触力 (N)"""
+    
+    deflection: float
+    """滚子变形量 (mm)"""
+    
+    equilibrium_load: float
+    """平衡载荷 (N)，应接近输入载荷"""
+    
+    equilibrium_moment: float
+    """平衡力矩 (N·mm)"""
+    
+    converged: bool = True
+    """是否收敛"""
+    
+    error_code: int = 0
+    """错误码: 0=成功, 1=方程求解失败, 2=切片数无效, 3=载荷无效"""
+    
+    @property
+    def max_stress(self) -> float:
+        """最大接触应力 (MPa)"""
+        return float(np.max(self.stress)) if len(self.stress) > 0 else 0.0
+    
+    @property
+    def min_stress(self) -> float:
+        """最小接触应力 (MPa)，不包括 0（非接触区）"""
+        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)，仅计算接触区"""
+        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）"""
+        return int(np.sum(self.stress > 0))
+    
+    @property
+    def stress_uniformity(self) -> float:
+        """应力均匀度 (0~1)，1 表示完全均匀
+        
+        定义为: 1 - (最大应力 - 最小应力) / 平均应力
+        """
+        if self.mean_stress == 0:
+            return 0.0
+        variation = (self.max_stress - self.min_stress) / self.mean_stress
+        return max(0.0, 1.0 - variation)
+    
+    def get_slice_positions(self, roller_length: float) -> NDArray[np.float64]:
+        """获取各切片的中心位置
+        
+        Args:
+            roller_length: 滚子有效长度 (mm)
+        
+        Returns:
+            各切片中心位置，从 0 到 roller_length
+        """
+        h = roller_length / self.n_slice / 2  # 半切片宽度
+        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:
+        """获取切片宽度
+        
+        Args:
+            roller_length: 滚子有效长度 (mm)
+        
+        Returns:
+            单个切片的宽度 (mm)
+        """
+        return roller_length / self.n_slice
+    
+    def get_slice_spacing(self, roller_length: float) -> float:
+        """获取相邻切片中心之间的间距
+        
+        注意：切片间距 = 切片宽度 = roller_length / n_slice
+        
+        Args:
+            roller_length: 滚子有效长度 (mm)
+        
+        Returns:
+            相邻切片中心之间的间距 (mm)
+        """
+        return roller_length / self.n_slice
+    
+    def print_slice_info(self, roller_length: float) -> None:
+        """打印切片划分信息
+        
+        Args:
+            roller_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")

bstart_trb-0.1.0/slice_wrapper/wrapper.py

@@ -0,0 +1,193 @@
+"""
+Python 包装层
+
+提供圆柱/圆锥滚子轴承切片应力计算的高级 Python 接口。
+封装底层 Fortran 计算核心（通过 f2py）。
+"""
+
+from typing import Optional, Sequence, Callable, Tuple
+import numpy as np
+from numpy.typing import NDArray
+
+from .models import (
+    RollerParams,
+    RacewayParams,
+    CrownType,
+    RacewayType,
+    SliceResult,
+)
+
+# 尝试导入 f2py 编译的模块
+_FORTRAN_AVAILABLE = False
+_taper_calculate: Optional[Callable[..., Tuple[
+    NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], float, float, float, int
+]]] = None
+
+try:
+    from . import _taper_slice
+    _taper_calculate = _taper_slice.taper_calculate
+    _FORTRAN_AVAILABLE = True
+except ImportError:
+    import warnings
+    warnings.warn(
+        "Fortran 计算核心未编译，请运行 'python build.py' 编译模块。"
+        "当前切片计算功能不可用。"
+    )
+
+
+def slice_stress(
+    roller: RollerParams,
+    raceway: RacewayParams,
+    load: float,
+    n_slice: int = 30,
+) -> SliceResult:
+    """计算滚子-滚道接触的切片应力分布
+    
+    使用影响系数法（Influence Coefficient Method）计算滚子与滚道
+    接触时各切片的应力分布，考虑凸度修形和滚子倾斜的影响。
+    
+    Args:
+        roller: 滚子几何参数
+        raceway: 滚道参数
+        load: 滚子载荷 (N)
+        n_slice: 切片数量 (1-50)，默认 30
+    
+    Returns:
+        SliceResult: 包含各切片应力、接触半宽度等计算结果
+    
+    Raises:
+        RuntimeError: Fortran 模块未编译时抛出
+        ValueError: 参数无效时抛出
+    
+    Example:
+        >>> from slice_wrapper import slice_stress, RollerParams, RacewayParams
+        >>> from slice_wrapper import CrownType, RacewayType
+        >>> 
+        >>> # 定义滚子参数
+        >>> roller = RollerParams(
+        ...     d1=10.0, d2=10.0, length=9.6,
+        ...     crown_type=CrownType.LOGARITHMIC,
+        ...     curve_q=14100.0
+        ... )
+        >>> 
+        >>> # 定义外圈滚道参数（注意直径为负值）
+        >>> raceway = RacewayParams(
+        ...     diameter=-150.0,
+        ...     raceway_type=RacewayType.OUTER
+        ... )
+        >>> 
+        >>> # 计算切片应力
+        >>> result = slice_stress(roller, raceway, load=1340.0, n_slice=30)
+        >>> print(f"最大应力: {result.max_stress:.0f} MPa")
+        >>> print(f"应力均匀度: {result.stress_uniformity:.2%}")
+    
+    Note:
+        - 切片数 n_slice 最大支持 50
+        - 对数凸度 (crown_type=2) 在 load == curve_q 时可实现均匀应力分布
+        - 外圈滚道的 diameter 应使用负值（Hertz 接触符号约定）
+    
+    Theory:
+        该函数使用影响系数法求解滚子-滚道接触问题：
+        1. 将滚子沿轴向分成 n_slice 个切片
+        2. 建立切片间的弹性耦合关系（影响系数矩阵）
+        3. 使用高斯消元法求解线性方程组
+        4. 迭代收敛得到各切片的接触应力分布
+    """
+    if not _FORTRAN_AVAILABLE or _taper_calculate is None:
+        raise RuntimeError(
+            "Fortran 计算核心未编译。请先运行 'python build.py' 编译模块。"
+        )
+    
+    # 参数验证
+    if load <= 0:
+        raise ValueError(f"载荷必须为正数，当前值: {load}")
+    if not 1 <= n_slice <= 50:
+        raise ValueError(f"切片数必须在 1-50 之间，当前值: {n_slice}")
+    
+    # 确定设计载荷
+    curve_q = roller.curve_q if roller.curve_q > 0 else load
+    
+    # 调用 Fortran 计算（此时 _taper_calculate 已确保不为 None）
+    p, a, q_slice, dc, q1, qm, ierr = _taper_calculate(
+        d1=roller.d1,
+        d2=roller.d2,
+        rl=roller.length,
+        alfa=roller.alfa,
+        q=load,
+        tilt=roller.tilt,
+        m1=int(roller.crown_type),
+        n_slice=n_slice,
+        m2=int(raceway.raceway_type),
+        dr1=raceway.diameter,
+        fai=raceway.fai,
+        curveq=curve_q,
+    )
+    
+    # 构建结果
+    return SliceResult(
+        n_slice=n_slice,
+        stress=np.array(p, dtype=np.float64),
+        half_width=np.array(a, dtype=np.float64),
+        slice_force=np.array(q_slice, dtype=np.float64),
+        deflection=float(dc),
+        equilibrium_load=float(q1),
+        equilibrium_moment=float(qm),
+        converged=(ierr == 0),
+        error_code=int(ierr),
+    )
+
+
+def batch_slice_stress(
+    roller: RollerParams,
+    raceway: RacewayParams,
+    loads: Sequence[float],
+    n_slice: int = 30,
+) -> list[SliceResult]:
+    """批量计算多个载荷下的切片应力分布
+    
+    对多个载荷值进行切片应力计算，适用于载荷分布已知的情况。
+    
+    Args:
+        roller: 滚子几何参数
+        raceway: 滚道参数
+        loads: 载荷序列 (N)，支持 list[int], list[float], NDArray 等
+        n_slice: 切片数量，默认 30
+    
+    Returns:
+        list[SliceResult]: 各载荷对应的计算结果列表
+    
+    Example:
+        >>> # 假设已知各滚子的载荷分布
+        >>> 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")
+    """
+    results = []
+    for load in loads:
+        if load > 0:
+            result = slice_stress(roller, raceway, load, n_slice)
+            results.append(result)
+        else:
+            # 无载荷，返回零结果
+            results.append(SliceResult(
+                n_slice=n_slice,
+                stress=np.zeros(n_slice),
+                half_width=np.zeros(n_slice),
+                slice_force=np.zeros(n_slice),
+                deflection=0.0,
+                equilibrium_load=0.0,
+                equilibrium_moment=0.0,
+                converged=True,
+                error_code=0,
+            ))
+    return results
+
+
+def is_fortran_available() -> bool:
+    """检查 Fortran 计算核心是否可用
+    
+    Returns:
+        bool: True 表示 Fortran 模块已编译可用
+    """
+    return _FORTRAN_AVAILABLE