delta-theory 6.9.0__tar.gz → 6.10.1__tar.gz

{delta_theory-6.9.0 → delta_theory-6.10.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: delta-theory
-Version: 6.9.0
+Version: 6.10.1
 Summary: Unified materials strength and fatigue prediction based on geometric first principles
 Author: Tamaki
-Author-email: Masamichi Iizumi <masamichi@miosync.com>
+Author-email: Masamichi Iizumi <m.iizumi@miosync.email>
 Maintainer-email: Masamichi Iizumi <masamichi@miosync.com>
 License: MIT
 Project-URL: Homepage, https://github.com/miosync/delta-theory

{delta_theory-6.9.0 → delta_theory-6.10.1}/core/__init__.py

@@ -1,13 +1,13 @@
 """
 δ-Theory Core Library
 =====================
-
 Unified yield stress and fatigue life prediction based on geometric first principles.
 
 Modules:
     - unified_yield_fatigue_v6_9: Main yield + fatigue model (v6.9b)
     - dbt_unified: Ductile-Brittle Transition Temperature prediction
     - materials: Material database
+    - fatigue_redis_api: FatigueData-AM2022 Redis API
 """
 
 from .unified_yield_fatigue_v6_9 import (
@@ -31,5 +31,29 @@ from .dbt_unified import (
 
 from .materials import MaterialGPU
 
-__version__ = "6.9.0"
+from .fatigue_redis_api import FatigueDB  # ← 追加！
+
+__version__ = "6.10.1"  # ← バージョンも上げる！
 __author__ = "Masamichi Iizumi & Tamaki"
+
+__all__ = [
+    # v6.9
+    "Material",
+    "MATERIALS", 
+    "calc_sigma_y",
+    "fatigue_life_const_amp",
+    "generate_sn_curve",
+    "yield_by_mode",
+    "FATIGUE_CLASS_PRESET",
+    # DBT
+    "DBTUnified",
+    "DBTCore",
+    "GrainSizeView",
+    "TemperatureView",
+    "SegregationView",
+    "MATERIAL_FE",
+    # Materials
+    "MaterialGPU",
+    # FatigueDB
+    "FatigueDB",  # ← 追加！
+]

{delta_theory-6.9.0/validation → delta_theory-6.10.1/core}/fatigue_redis_api.py

@@ -32,6 +32,7 @@ Date: 2026-02-02
 import json
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass
+import os
 
 try:
     from upstash_redis import Redis
@@ -42,10 +43,17 @@ except ImportError:
 # =============================================================================
 # Configuration
 # =============================================================================
-UPSTASH_URL = "https://casual-crayfish-21486.upstash.io"
-UPSTASH_TOKEN = "AVPuAAIncDFiNWEyN2ExYmEzZGU0N2I5ODlkNmUxMjRkM2UzNWMwY3AxMjE0ODY"
-
+UPSTASH_URL = os.environ.get("UPSTASH_URL")
+UPSTASH_TOKEN = os.environ.get("UPSTASH_TOKEN")
 
+class FatigueDB:
+    def __init__(self, url: str = None, token: str = None):
+        _url = url or UPSTASH_URL
+        _token = token or UPSTASH_TOKEN
+        if not _url or not _token:
+            raise ValueError("UPSTASH_URL and UPSTASH_TOKEN required! Set env vars or pass directly.")
+        self.redis = Redis(url=_url, token=_token)
+        
 # =============================================================================
 # Data Classes
 # =============================================================================
@@ -320,15 +328,153 @@ Updated: {meta['updated']}
 # =============================================================================
 # CLI
 # =============================================================================
+def build_cli():
+    import argparse
+    
+    p = argparse.ArgumentParser(
+        description='FatigueData-AM2022 Redis API - δ理論検証用'
+    )
+    sub = p.add_subparsers(dest='cmd', required=True)
+    
+    # list
+    sp_list = sub.add_parser('list', help='材料一覧')
+    sp_list.add_argument('--top', type=int, default=20)
+    sp_list.add_argument('--sort', choices=['sn_count', 'name'], default='sn_count')
+    
+    # search
+    sp_search = sub.add_parser('search', help='材料検索')
+    sp_search.add_argument('query', help='検索クエリ (例: Ti, 316, Al)')
+    
+    # info
+    sp_info = sub.add_parser('info', help='材料詳細')
+    sp_info.add_argument('material', help='材料名')
+    
+    # get-sn
+    sp_sn = sub.add_parser('get-sn', help='S-Nデータ取得')
+    sp_sn.add_argument('material', help='材料名')
+    sp_sn.add_argument('--R', type=float, default=None, help='応力比フィルタ')
+    sp_sn.add_argument('--with-sigma-y', action='store_true', help='σ_yありのみ')
+    sp_sn.add_argument('--output', '-o', help='CSV出力ファイル')
+    sp_sn.add_argument('--limit', type=int, default=20, help='表示件数')
+    
+    # delta
+    sp_delta = sub.add_parser('delta', help='δ理論検証用データ (r計算済み)')
+    sp_delta.add_argument('material', help='材料名')
+    sp_delta.add_argument('--R', type=float, default=-1.0)
+    sp_delta.add_argument('--output', '-o', help='CSV出力ファイル')
+    
+    # summary
+    sub.add_parser('summary', help='DB全体サマリー')
+    
+    return p
+
+
+def cmd_list(db, args):
+    print(f"\n📦 材料一覧 (top {args.top}, sort={args.sort}):")
+    print("-" * 70)
+    print(f"{'Material':<25} {'S-N':>8} {'ε-N':>8} {'σ_y range':>20}")
+    print("-" * 70)
+    for mat in db.list_materials(sort_by=args.sort)[:args.top]:
+        sy_min = mat.get('sigma_y_min', '-')
+        sy_max = mat.get('sigma_y_max', '-')
+        sy_range = f"{sy_min}-{sy_max}" if sy_min != '-' else '-'
+        print(f"{mat['name']:<25} {mat['sn_count']:>8} {mat['en_count']:>8} {sy_range:>20}")
+
+
+def cmd_search(db, args):
+    results = db.search_materials(args.query)
+    print(f"\n🔍 検索: '{args.query}' → {len(results)}件")
+    for name in results:
+        info = db.get_material_info(name)
+        print(f"   {name}: S-N={info['sn_count']}, σ_y={info.get('sigma_y_min')}-{info.get('sigma_y_max')} MPa")
+
+
+def cmd_info(db, args):
+    info = db.get_material_info(args.material)
+    if not info:
+        print(f"❌ Material '{args.material}' not found")
+        return
+    
+    print(f"\n📋 {args.material}")
+    print("=" * 50)
+    print(f"  S-N points:    {info['sn_count']}")
+    print(f"  ε-N points:    {info['en_count']}")
+    print(f"  da/dN points:  {info['dadn_count']}")
+    print(f"  σ_y range:     {info.get('sigma_y_min')} - {info.get('sigma_y_max')} MPa")
+    
+    # R値の分布
+    sn_data = db.get_sn(args.material)
+    R_values = set(d.get('R') for d in sn_data if d.get('R') is not None)
+    print(f"  R values:      {sorted(R_values)}")
+
+
+def cmd_get_sn(db, args):
+    data = db.get_sn(args.material, R=args.R, with_sigma_y=args.with_sigma_y)
+    
+    print(f"\n📊 {args.material} S-N data")
+    if args.R is not None:
+        print(f"   R = {args.R}")
+    if args.with_sigma_y:
+        print(f"   (σ_y required)")
+    print(f"   Total: {len(data)} points")
+    print("-" * 70)
+    
+    if args.output:
+        import csv
+        with open(args.output, 'w', newline='') as f:
+            w = csv.DictWriter(f, fieldnames=['N', 'S', 'R', 'sigma_y', 'sigma_uts', 'runout', 'doi'])
+            w.writeheader()
+            w.writerows(data)
+        print(f"✅ Saved to {args.output}")
+    else:
+        print(f"{'N':>12} {'S [MPa]':>10} {'R':>6} {'σ_y':>10} {'runout':>8}")
+        print("-" * 50)
+        for d in data[:args.limit]:
+            print(f"{d['N']:>12.0f} {d['S']:>10.1f} {d.get('R', '-'):>6} {d.get('sigma_y', '-'):>10} {d.get('runout', 0):>8}")
+        if len(data) > args.limit:
+            print(f"   ... and {len(data) - args.limit} more (use --output for full data)")
+
+
+def cmd_delta(db, args):
+    data = db.get_sn_for_delta(args.material, R=args.R)
+    
+    print(f"\n🔬 {args.material} δ-theory data (R={args.R})")
+    print(f"   Total: {len(data)} points with σ_y")
+    if data:
+        print(f"   r range: {min(d['r'] for d in data):.4f} - {max(d['r'] for d in data):.4f}")
+    print("-" * 70)
+    
+    if args.output:
+        import csv
+        with open(args.output, 'w', newline='') as f:
+            w = csv.DictWriter(f, fieldnames=['N', 'S', 'sigma_y', 'r', 'runout', 'doi'])
+            w.writeheader()
+            w.writerows(data)
+        print(f"✅ Saved to {args.output}")
+    else:
+        print(f"{'N':>12} {'S [MPa]':>10} {'σ_y [MPa]':>12} {'r':>10} {'runout':>8}")
+        print("-" * 60)
+        for d in data[:20]:
+            print(f"{d['N']:>12.0f} {d['S']:>10.1f} {d['sigma_y']:>12.1f} {d['r']:>10.4f} {d.get('runout', 0):>8}")
+        if len(data) > 20:
+            print(f"   ... and {len(data) - 20} more")
+
+
 if __name__ == '__main__':
-    db = FatigueDB()
-    print(db.summary())
+    parser = build_cli()
+    args = parser.parse_args()
     
-    print("\n📦 Top 5 materials by S-N count:")
-    for mat in db.list_materials()[:5]:
-        print(f"   {mat['name']}: {mat['sn_count']} S-N, σ_y={mat.get('sigma_y_min')}-{mat.get('sigma_y_max')} MPa")
+    db = FatigueDB()
     
-    print("\n🔍 Ti-6Al-4V S-N (R=-1, with σ_y):")
-    ti64 = db.get_sn_for_delta('Ti-6Al-4V', R=-1.0)
-    print(f"   {len(ti64)} points")
-    print(f"   r range: {min(d['r'] for d in ti64):.4f} - {max(d['r'] for d in ti64):.4f}")
+    if args.cmd == 'summary':
+        print(db.summary())
+    elif args.cmd == 'list':
+        cmd_list(db, args)
+    elif args.cmd == 'search':
+        cmd_search(db, args)
+    elif args.cmd == 'info':
+        cmd_info(db, args)
+    elif args.cmd == 'get-sn':
+        cmd_get_sn(db, args)
+    elif args.cmd == 'delta':
+        cmd_delta(db, args)

{delta_theory-6.9.0 → delta_theory-6.10.1}/core/unified_yield_fatigue_v6_9.py

@@ -25,6 +25,24 @@ from typing import Dict, Literal, Optional, Tuple
 
 import numpy as np
 
+# ==============================================================================
+# Optional import: DBT/DBTT unified model (separate module)
+# ------------------------------------------------------------------------------
+# Place dbt_unified.py in the same folder as this file.
+# Then you can do:
+#   from unified_yield_fatigue_v6_9b_tau_classes import DBTUnified
+#   model = DBTUnified()
+#
+# The import is optional so that this module remains usable even if dbt_unified.py
+# is not present in your runtime environment.
+try:
+    from dbt_unified import DBTUnified, DBTCore, Material as DBTMaterial, MATERIAL_FE
+except Exception:
+    DBTUnified = None
+    DBTCore = None
+    DBTMaterial = None
+    MATERIAL_FE = None
+
 # ==============================================================================
 # Physical constants
 # ==============================================================================
@@ -484,40 +502,74 @@ def generate_sn_curve(
         Ns.append(out['N_fail'])
     return np.array(Ns, dtype=float)
 
+# ==============================================================================
+# Alloy validation helper (for FatigueDB integration)
+# ==============================================================================
+
+def get_minimal_material(structure: Literal['BCC', 'FCC', 'HCP']) -> Material:
+    """結晶構造から最小限のMaterialを取得（合金検証用ヘルパー）
+    
+    FatigueDB等の実験データ検証時、σ_yは実測値を使うため
+    structure (r_th, n_cl) のみが必要なケース用
+    """
+    base = {'BCC': MATERIALS['Fe'], 'FCC': MATERIALS['Cu'], 'HCP': MATERIALS['Ti']}
+    return base[structure]
+
+
 # ==============================================================================
 # CLI
 # ==============================================================================
 
 def cmd_point(args: argparse.Namespace) -> None:
-    mat0 = MATERIALS[args.metal]
-    mat = replace(
-        mat0,
-        A_texture=float(args.A_texture),
-        T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
-        R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
-        c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
-    )
+    # material 取得（metal or structure_only）
+    if args.metal is None and args.structure_only is None:
+        raise SystemExit("Error: --metal or --structure_only required")
+    
+    if args.structure_only:
+        mat = get_minimal_material(args.structure_only)
+    else:
+        mat0 = MATERIALS[args.metal]
+        mat = replace(
+            mat0,
+            A_texture=float(args.A_texture),
+            T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
+            R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
+            c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
+        )
 
-    y = calc_sigma_y(
-        mat,
-        T_K=args.T_K,
-        c_wt_percent=args.c_wt,
-        k_ss=args.k_ss,
-        solute_type=args.solute_type,
-        eps=args.eps,
-        rho_0=args.rho_0,
-        r_ppt_nm=args.r_ppt_nm,
-        f_ppt=args.f_ppt,
-        gamma_apb=args.gamma_apb,
-        A_ppt=args.A_ppt,
-    )
+    # σ_y 計算 or override
+    if args.sigma_y_override is not None:
+        sigma_y = args.sigma_y_override
+        y = {
+            'sigma_y': sigma_y,
+            'sigma_base': sigma_y,
+            'delta_ss': 0.0,
+            'delta_wh': 0.0,
+            'delta_ppt': 0.0,
+            'ppt_mechanism': 'N/A (override)',
+        }
+    else:
+        y = calc_sigma_y(
+            mat,
+            T_K=args.T_K,
+            c_wt_percent=args.c_wt,
+            k_ss=args.k_ss,
+            solute_type=args.solute_type,
+            eps=args.eps,
+            rho_0=args.rho_0,
+            r_ppt_nm=args.r_ppt_nm,
+            f_ppt=args.f_ppt,
+            gamma_apb=args.gamma_apb,
+            A_ppt=args.A_ppt,
+        )
+        sigma_y = y['sigma_y']
 
     # Fatigue (optional)
     if args.sigma_a is not None:
         out = fatigue_life_const_amp(
             mat,
             sigma_a_MPa=float(args.sigma_a),
-            sigma_y_tension_MPa=float(y['sigma_y']),
+            sigma_y_tension_MPa=float(sigma_y),
             A_ext=float(args.A_ext),
             mode=args.mode,
             D_fail=args.D_fail,
@@ -528,14 +580,16 @@ def cmd_point(args: argparse.Namespace) -> None:
     else:
         out = None
 
+    # 表示
+    label = f"structure={mat.structure}" if args.structure_only else f"metal={mat.name} ({mat.structure})"
     print("=" * 88)
-    print(f"v6.9b point | metal={mat.name} ({mat.structure}) | mode={args.mode}")
+    print(f"v6.9b point | {label} | mode={args.mode}")
     print("=" * 88)
 
     # Yield summary
     y_mode, diag = yield_by_mode(
         mat,
-        sigma_y_tension_MPa=float(y['sigma_y']),
+        sigma_y_tension_MPa=float(sigma_y),
         mode=args.mode,
         C_class=args.C_class,
         bcc_w110=args.bcc_w110,
@@ -543,11 +597,15 @@ def cmd_point(args: argparse.Namespace) -> None:
     )
 
     print("[Yield v5.0]")
-    print(f"  σ_base   = {y['sigma_base']:.2f} MPa")
-    print(f"  Δσ_ss    = {y['delta_ss']:.2f} MPa")
-    print(f"  Δσ_wh    = {y['delta_wh']:.2f} MPa  (rho_0={args.rho_0:.2e})")
-    print(f"  Δσ_ppt   = {y['delta_ppt']:.2f} MPa  ({y['ppt_mechanism']})")
-    print(f"  σ_y(t)   = {y['sigma_y']:.2f} MPa")
+    if args.sigma_y_override is not None:
+        print(f"  σ_y(override) = {sigma_y:.2f} MPa")
+    else:
+        print(f"  σ_base   = {y['sigma_base']:.2f} MPa")
+        print(f"  Δσ_ss    = {y['delta_ss']:.2f} MPa")
+        print(f"  Δσ_wh    = {y['delta_wh']:.2f} MPa  (rho_0={args.rho_0:.2e})")
+        print(f"  Δσ_ppt   = {y['delta_ppt']:.2f} MPa  ({y['ppt_mechanism']})")
+        print(f"  σ_y(t)   = {y['sigma_y']:.2f} MPa")
+    
     print("[Class factors v4.1]")
     print(f"  C_class  = {args.C_class:.4f}  (apply to HCP: {args.apply_C_class_hcp})")
     print(f"  bcc_w110 = {args.bcc_w110:.3f}")
@@ -577,35 +635,47 @@ def cmd_point(args: argparse.Namespace) -> None:
 
 def cmd_calibrate(args: argparse.Namespace) -> None:
     """Calibrate A_ext from one (σ_a, N_fail) point."""
-    mat0 = MATERIALS[args.metal]
-    mat = replace(
-        mat0,
-        A_texture=float(args.A_texture),
-        T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
-        R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
-        c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
-    )
+    # material 取得
+    if args.metal is None and args.structure_only is None:
+        raise SystemExit("Error: --metal or --structure_only required")
+    
+    if args.structure_only:
+        mat = get_minimal_material(args.structure_only)
+    else:
+        mat0 = MATERIALS[args.metal]
+        mat = replace(
+            mat0,
+            A_texture=float(args.A_texture),
+            T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
+            R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
+            c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
+        )
 
-    y = calc_sigma_y(
-        mat,
-        T_K=args.T_K,
-        c_wt_percent=args.c_wt,
-        k_ss=args.k_ss,
-        solute_type=args.solute_type,
-        eps=args.eps,
-        rho_0=args.rho_0,
-        r_ppt_nm=args.r_ppt_nm,
-        f_ppt=args.f_ppt,
-        gamma_apb=args.gamma_apb,
-        A_ppt=args.A_ppt,
-    )
+    # σ_y
+    if args.sigma_y_override is not None:
+        sigma_y = args.sigma_y_override
+    else:
+        y = calc_sigma_y(
+            mat,
+            T_K=args.T_K,
+            c_wt_percent=args.c_wt,
+            k_ss=args.k_ss,
+            solute_type=args.solute_type,
+            eps=args.eps,
+            rho_0=args.rho_0,
+            r_ppt_nm=args.r_ppt_nm,
+            f_ppt=args.f_ppt,
+            gamma_apb=args.gamma_apb,
+            A_ppt=args.A_ppt,
+        )
+        sigma_y = y['sigma_y']
 
     preset = FATIGUE_CLASS_PRESET.get(mat.structure, FATIGUE_CLASS_PRESET['FCC'])
     r_th, n = preset['r_th'], preset['n']
 
     y_mode, _ = yield_by_mode(
         mat,
-        sigma_y_tension_MPa=float(y['sigma_y']),
+        sigma_y_tension_MPa=float(sigma_y),
         mode=args.mode,
         C_class=args.C_class,
         bcc_w110=args.bcc_w110,
@@ -625,11 +695,12 @@ def cmd_calibrate(args: argparse.Namespace) -> None:
     A_eff = rate_needed / ((r - r_th) ** n)
     A_ext = A_eff / A_int
 
+    label = f"structure={mat.structure}" if args.structure_only else f"metal={mat.name} ({mat.structure})"
     print("=" * 88)
     print("v6.9b calibrate A_ext")
     print("=" * 88)
-    print(f"metal={mat.name} ({mat.structure}), mode={args.mode}")
-    print(f"σ_y(tension) = {y['sigma_y']:.3f} MPa")
+    print(f"{label}, mode={args.mode}")
+    print(f"σ_y = {sigma_y:.3f} MPa {'(override)' if args.sigma_y_override else '(calc)'}")
     print(f"yield(mode)  = {y_mode:.3f} MPa")
     print(f"amp          = {args.sigma_a:.3f} MPa {'(τ_a)' if args.mode=='shear' else ''}")
     print(f"r={r:.6f}, r_th={r_th:.3f}, n={n:.2f}")
@@ -638,33 +709,45 @@ def cmd_calibrate(args: argparse.Namespace) -> None:
 
 
 def cmd_sn(args: argparse.Namespace) -> None:
-    mat0 = MATERIALS[args.metal]
-    mat = replace(
-        mat0,
-        A_texture=float(args.A_texture),
-        T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
-        R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
-        c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
-    )
+    # material 取得
+    if args.metal is None and args.structure_only is None:
+        raise SystemExit("Error: --metal or --structure_only required")
+    
+    if args.structure_only:
+        mat = get_minimal_material(args.structure_only)
+    else:
+        mat0 = MATERIALS[args.metal]
+        mat = replace(
+            mat0,
+            A_texture=float(args.A_texture),
+            T_twin=(float(args.T_twin) if args.T_twin is not None else mat0.T_twin),
+            R_comp=(float(args.R_comp) if args.R_comp is not None else mat0.R_comp),
+            c_a=float(args.c_a) if args.c_a is not None else mat0.c_a,
+        )
 
-    y = calc_sigma_y(
-        mat,
-        T_K=args.T_K,
-        c_wt_percent=args.c_wt,
-        k_ss=args.k_ss,
-        solute_type=args.solute_type,
-        eps=args.eps,
-        rho_0=args.rho_0,
-        r_ppt_nm=args.r_ppt_nm,
-        f_ppt=args.f_ppt,
-        gamma_apb=args.gamma_apb,
-        A_ppt=args.A_ppt,
-    )
+    # σ_y
+    if args.sigma_y_override is not None:
+        sigma_y = args.sigma_y_override
+    else:
+        y = calc_sigma_y(
+            mat,
+            T_K=args.T_K,
+            c_wt_percent=args.c_wt,
+            k_ss=args.k_ss,
+            solute_type=args.solute_type,
+            eps=args.eps,
+            rho_0=args.rho_0,
+            r_ppt_nm=args.r_ppt_nm,
+            f_ppt=args.f_ppt,
+            gamma_apb=args.gamma_apb,
+            A_ppt=args.A_ppt,
+        )
+        sigma_y = y['sigma_y']
 
     sigmas = np.linspace(args.sigma_min, args.sigma_max, args.num)
     Ns = generate_sn_curve(
         mat,
-        sigma_y_tension_MPa=float(y['sigma_y']),
+        sigma_y_tension_MPa=float(sigma_y),
         A_ext=args.A_ext,
         sigmas_MPa=sigmas,
         mode=args.mode,
@@ -674,17 +757,18 @@ def cmd_sn(args: argparse.Namespace) -> None:
         apply_C_class_hcp=args.apply_C_class_hcp,
     )
 
+    label = f"structure={mat.structure}" if args.structure_only else f"metal={mat.name} ({mat.structure})"
     print("=" * 88)
-    print(f"v6.9b S-N | metal={mat.name} ({mat.structure}) | mode={args.mode}")
+    print(f"v6.9b S-N | {label} | mode={args.mode}")
     print("=" * 88)
-    print(f"σ_y(tension)={y['sigma_y']:.3f} MPa | A_ext={args.A_ext:.3e} | D_fail={args.D_fail:.3f}")
+    print(f"σ_y={sigma_y:.3f} MPa {'(override)' if args.sigma_y_override else '(calc)'} | A_ext={args.A_ext:.3e} | D_fail={args.D_fail:.3f}")
 
     header_amp = 'sigma_a_MPa' if args.mode != 'shear' else 'tau_a_MPa'
     print(f"{header_amp:>12} {'N_fail':>14} {'log10N':>10} {'r':>10} {'note':>10}")
     for s, N in zip(sigmas, Ns):
         y_mode, _ = yield_by_mode(
             mat,
-            sigma_y_tension_MPa=float(y['sigma_y']),
+            sigma_y_tension_MPa=float(sigma_y),
             mode=args.mode,
             C_class=args.C_class,
             bcc_w110=args.bcc_w110,
@@ -702,7 +786,14 @@ def build_parser() -> argparse.ArgumentParser:
     sub = p.add_subparsers(dest='cmd', required=True)
 
     def add_common(sp: argparse.ArgumentParser):
-        sp.add_argument('--metal', required=True, choices=sorted(MATERIALS.keys()))
+        # metal OR structure_only
+        sp.add_argument('--metal', choices=sorted(MATERIALS.keys()), default=None,
+                        help='Material from database')
+        sp.add_argument('--structure_only', choices=['BCC', 'FCC', 'HCP'], default=None,
+                        help='Use structure preset only (for alloy validation)')
+        sp.add_argument('--sigma_y_override', type=float, default=None,
+                        help='Override σ_y with experimental value [MPa]')
+        
         sp.add_argument('--T_K', type=float, default=300.0)
         sp.add_argument('--c_wt', type=float, default=0.0, help='solute wt%% (e.g., 0.10 for 0.10 wt%%)')
         sp.add_argument('--k_ss', type=float, default=0.0, help='solid-solution k [MPa/(wt%%)^n]')
@@ -751,12 +842,36 @@ def build_parser() -> argparse.ArgumentParser:
 
     return p
 
-
 def main() -> None:
     parser = build_parser()
     args = parser.parse_args()
     args.func(args)
 
+BANNER = """
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ███╗   ███╗██╗ ██████╗ ███████╗██╗   ██╗███╗   ██╗ ██████╗
+  ████╗ ████║██║██╔═══██╗██╔════╝╚██╗ ██╔╝████╗  ██║██╔════╝
+  ██╔████╔██║██║██║   ██║███████╗ ╚████╔╝ ██╔██╗ ██║██║     
+  ██║╚██╔╝██║██║██║   ██║╚════██║  ╚██╔╝  ██║╚██╗██║██║     
+  ██║ ╚═╝ ██║██║╚██████╔╝███████║   ██║   ██║ ╚████║╚██████╗
+  ╚═╝     ╚═╝╚═╝ ╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═══╝ ╚═════╝
+                                                     
+                 δ-theory Unified Model v6.9b
+          ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+           v5.0 Yield × v6.8 Fatigue × τ/σ Class
+          
+      BCC: r_th=0.65   FCC: r_th=0.02   HCP: r_th=0.20
+              Λ(D) = D/(1-D) → Λ=1 : failure
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+
+def main() -> None:
+    print(BANNER)
+    parser = build_parser()
+    args = parser.parse_args()
+    args.func(args)
 
 if __name__ == '__main__':
     main()

{delta_theory-6.9.0 → delta_theory-6.10.1}/delta_theory.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: delta-theory
-Version: 6.9.0
+Version: 6.10.1
 Summary: Unified materials strength and fatigue prediction based on geometric first principles
 Author: Tamaki
-Author-email: Masamichi Iizumi <masamichi@miosync.com>
+Author-email: Masamichi Iizumi <m.iizumi@miosync.email>
 Maintainer-email: Masamichi Iizumi <masamichi@miosync.com>
 License: MIT
 Project-URL: Homepage, https://github.com/miosync/delta-theory

{delta_theory-6.9.0 → delta_theory-6.10.1}/delta_theory.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ apps/delta_fatigue_app.py
 core/Universal_Lindemann.py
 core/__init__.py
 core/dbt_unified.py
+core/fatigue_redis_api.py
 core/materials.py
 core/unified_yield_fatigue_v6_9.py
 delta_theory.egg-info/PKG-INFO
@@ -14,6 +15,4 @@ delta_theory.egg-info/dependency_links.txt
 delta_theory.egg-info/entry_points.txt
 delta_theory.egg-info/requires.txt
 delta_theory.egg-info/top_level.txt
-tests/test_core.py
-validation/__init__.py
-validation/fatigue_redis_api.py
+tests/test_core.py

delta_theory-6.10.1/delta_theory.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+apps
+core

{delta_theory-6.9.0 → delta_theory-6.10.1}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "delta-theory"
-version = "6.9.0"
+version = "6.10.1"
 description = "Unified materials strength and fatigue prediction based on geometric first principles"
 readme = "README.md"
 license = {text = "MIT"}
 authors = [
-    {name = "Masamichi Iizumi", email = "masamichi@miosync.com"},
+    {name = "Masamichi Iizumi", email = "m.iizumi@miosync.email"},
     {name = "Tamaki"},
 ]
 maintainers = [

delta_theory-6.9.0/delta_theory.egg-info/top_level.txt

@@ -1,3 +0,0 @@
-apps
-core
-validation

delta_theory-6.9.0/validation/__init__.py

@@ -1,10 +0,0 @@
-"""
-δ-Theory Validation Tools
-=========================
-
-Tools for validating δ-theory predictions against experimental data.
-"""
-
-from .fatigue_redis_api import FatigueDB
-
-__all__ = ["FatigueDB"]