flash-sim 0.0.1__py3-none-any.whl

flash/_core/interface.py

@@ -0,0 +1,90 @@
+"""Standalone interface — BaseSimulator for standalone mode.
+
+This module provides the BaseSimulator abstract class for use when
+physimx_core is not installed (standalone mode).
+
+When physimx_core IS installed, flash/__init__.py will import from
+physimx_core.interface instead.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .schema import CapabilityCard, InputVar, SimulationRequest, SimulationResult
+
+
+class BaseSimulator(ABC):
+    """Abstract base class for all physics simulation plugins.
+
+    A simulator plugin must implement:
+      - ``capability()``  → declare what physics it can simulate.
+      - ``simulate(request)`` → run one simulation and return results.
+
+    Optionally, it may also implement:
+      - ``simulate_batch(requests)`` → run many simulations (parallel-capable).
+    """
+
+    @abstractmethod
+    def capability(self) -> CapabilityCard:
+        """Return a machine-readable declaration of this simulator's capabilities."""
+        ...
+
+    @abstractmethod
+    def simulate(self, request: SimulationRequest) -> SimulationResult:
+        """Execute one simulation and return structured results.
+
+        Parameters
+        ----------
+        request : SimulationRequest
+            Input containing parameters, work_dir, etc.
+
+        Returns
+        -------
+        SimulationResult
+            Output. ``result.success`` indicates whether the simulation converged.
+        """
+        ...
+
+    def validate_params(self, params: Dict[str, Any]) -> None:
+        """Validate simulation parameters.
+        
+        Default implementation checks temperature range.
+        Raises ValueError if validation fails.
+        """
+        cap = self.capability()
+        input_schema = cap.input_schema
+        for key, spec in input_schema.items():
+            if key in params:
+                val = params[key]
+                if spec.low is not None and val < spec.low:
+                    raise ValueError(f"{key}={val} < minimum {spec.low}")
+                if spec.high is not None and val > spec.high:
+                    raise ValueError(f"{key}={val} > maximum {spec.high}")
+
+    # ----- optional overrides (with sensible defaults) -------------------
+
+    def simulate_batch(
+        self,
+        requests: list[SimulationRequest],
+        parallel: bool = False,
+        max_workers: int = 4,
+    ) -> list[SimulationResult]:
+        """Run multiple simulations, optionally in parallel.
+
+        The default implementation calls ``self.simulate`` in a loop.
+        Plugins that support native parallelism should override this method.
+        """
+        import concurrent.futures
+
+        if not parallel:
+            return [self.simulate(req) for req in requests]
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(self.simulate, req) for req in requests]
+            return [f.result() for f in concurrent.futures.as_completed(futures)]
+
+
+__all__ = ["BaseSimulator"]

flash/_core/registry.py

@@ -0,0 +1,35 @@
+"""Standalone simulator registry (minimal, no physimx_core dependency).
+
+When physimx_core is not installed, this module provides a basic registry
+for FlashSimulator so that registry-dependent tests can pass.
+"""
+
+from typing import Any, Dict, Optional
+
+_registry: Dict[str, Any] = {}
+
+
+def register_simulator(name: str, simulator_class: Any) -> None:
+    """Register a simulator class by name."""
+    _registry[name.lower()] = simulator_class
+
+
+def get_simulator(name: str) -> Optional[Any]:
+    """Get a registered simulator class by name."""
+    return _registry.get(name.lower())
+
+
+def list_simulators() -> list:
+    """List all registered simulator names."""
+    return list(_registry.keys())
+
+
+# Auto-register FlashSimulator if available
+try:
+    from flash.interface import FlashSimulator
+    register_simulator("flash", FlashSimulator)
+except ImportError:
+    pass
+
+
+__all__ = ["register_simulator", "get_simulator", "list_simulators"]

flash/_core/schema.py

@@ -0,0 +1,118 @@
+"""Standalone schema — dataclass versions of physimx_core.schema.
+
+This module provides dataclass-based versions of the schema classes
+for use when physimx_core is not installed (standalone mode).
+
+When physimx_core IS installed, flash/__init__.py will import from
+physimx_core.schema instead (which uses pydantic for validation).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+# =======================================================================
+# Enums
+# =======================================================================
+
+class SimulationStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    TIMEOUT = "timeout"
+
+
+class SimulatorType(str, Enum):
+    FLASH = "FLASH"
+    FLYCHK = "FLYCHK"
+    UNKNOWN = "UNKNOWN"
+
+
+class PhysicsDomain(str, Enum):
+    HEDP = "HEDP"          # High-Energy-Density Physics
+    ICF = "ICF"            # Inertial Confinement Fusion
+    LASER = "LASER"        # Laser-Plasma Interaction
+    MAGNETIC = "MAGNETIC"  # Magnetic Fusion
+    PLASMA = "PLASMA"      # Plasma Physics
+    GENERAL = "GENERAL"    # General plasma physics
+
+
+# =======================================================================
+# Data Models (dataclass-based, no pydantic dependency)
+# =======================================================================
+
+@dataclass
+class InputVar:
+    """Input variable specification."""
+    low: float
+    high: float
+    unit: str = ""
+
+
+@dataclass
+class OutputVar:
+    """Output variable specification."""
+    dimensions: List[str] = field(default_factory=list)
+    unit: str = ""
+
+
+@dataclass
+class SimulationRequest:
+    """Simulation request (standalone version, dataclass-based)."""
+    request_id: str = field(default_factory=lambda: datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f"))
+    simulator_type: Optional[SimulatorType] = None
+    params: Dict[str, Any] = field(default_factory=dict)
+    work_dir: Optional[Path] = None
+    timeout: Optional[float] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class SimulationResult:
+    """Simulation result (standalone version, dataclass-based)."""
+    request_id: str = ""
+    status: SimulationStatus = SimulationStatus.PENDING
+    output_data: Dict[str, Any] = field(default_factory=dict)
+    raw_output_path: Optional[Path] = None
+    execution_time: float = 0.0
+    error_message: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def success(self) -> bool:
+        return self.status == SimulationStatus.SUCCESS
+
+
+@dataclass
+class CapabilityCard:
+    """Simulator capability declaration (standalone, dataclass-based)."""
+    simulator_name: str = ""
+    simulator_type: SimulatorType = SimulatorType.UNKNOWN
+    version: str = ""
+    physics_domains: List[PhysicsDomain] = field(default_factory=list)
+    supported_dimensions: List[int] = field(default_factory=list)
+    input_schema: Dict[str, Any] = field(default_factory=dict)
+    output_schema: Dict[str, Any] = field(default_factory=dict)
+    estimated_runtime: str = ""
+    parallel_scalable: bool = False
+    requires_license: bool = False
+    homepage: str = ""
+    documentation: str = ""
+    physics_domain: PhysicsDomain = PhysicsDomain.GENERAL  # legacy compat
+    input_vars: Dict[str, InputVar] = field(default_factory=dict)
+    output_vars: Dict[str, OutputVar] = field(default_factory=dict)
+    description: str = ""
+
+
+__all__ = [
+    "SimulationStatus", "SimulatorType", "PhysicsDomain",
+    "InputVar", "OutputVar", "SimulationRequest", "SimulationResult",
+    "CapabilityCard",
+]

flash/config/__init__.py

@@ -0,0 +1,105 @@
+"""
+FLASH 仿真基本配置
+═════════════════════
+
+管理 FLASH 仿真的运行配置，包括：
+  - 本地运行 vs 超算 SSH 运行
+  - 超算硬件配置（节点数、CPU/GPU、内存）
+  - FLASH 可执行文件路径
+  - 编译选项
+
+用法示例：
+  from flash.config import FlashConfig, get_default_config
+
+  config = get_default_config()
+  config.mode = "ssh"  # 切换到超算模式
+  config.ssh.host = "ssh.cn-zhongwei-1.paracloud.com"
+  config.save()
+"""
+
+from pathlib import Path
+from typing import Optional, Dict, Any
+import json
+
+
+DEFAULT_CONFIG_PATH = Path.home() / ".physimx" / "flash_config.json"
+
+
+class FlashConfig:
+    """FLASH 运行配置。"""
+
+    def __init__(
+        self,
+        mode: str = "local",
+        flash_exe_path: Optional[str] = None,
+        ssh_host: Optional[str] = None,
+        ssh_port: int = 22,
+        ssh_username: Optional[str] = None,
+        ssh_password: Optional[str] = None,
+        nodes: int = 1,
+        ppn: int = 32,
+        walltime: str = "01:00:00",
+    ):
+        self.mode = mode  # "local" | "ssh"
+        self.flash_exe_path = flash_exe_path
+        self.ssh_host = ssh_host
+        self.ssh_port = ssh_port
+        self.ssh_username = ssh_username
+        self.ssh_password = ssh_password
+        self.nodes = nodes
+        self.ppn = ppn
+        self.walltime = walltime
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "mode": self.mode,
+            "flash_exe_path": self.flash_exe_path,
+            "ssh_host": self.ssh_host,
+            "ssh_port": self.ssh_port,
+            "ssh_username": self.ssh_username,
+            "ssh_password": self.ssh_password,
+            "nodes": self.nodes,
+            "ppn": self.ppn,
+            "walltime": self.walltime,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "FlashConfig":
+        return cls(**d)
+
+    def save(self, path: Optional[Path] = None):
+        """保存配置到 ~/.physimx/flash_config.json。"""
+        path = path or DEFAULT_CONFIG_PATH
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
+        print(f"[配置] 已保存: {path}")
+
+    @classmethod
+    def load(cls, path: Optional[Path] = None) -> "FlashConfig":
+        """从文件加载配置。"""
+        path = path or DEFAULT_CONFIG_PATH
+        if not path.exists():
+            return cls()  # 返回默认配置
+        with open(path, encoding="utf-8") as f:
+            d = json.load(f)
+        return cls.from_dict(d)
+
+    def __repr__(self) -> str:
+        return (
+            f"FlashConfig(mode={self.mode!r}, "
+            f"ssh={self.ssh_host if self.ssh_host else 'N/A'})"
+        )
+
+
+def get_default_config() -> FlashConfig:
+    """获取默认配置（优先从文件加载）。"""
+    return FlashConfig.load()
+
+
+if __name__ == "__main__":
+    config = get_default_config()
+    print("当前配置:", config)
+    config.mode = "local"
+    config.save()
+    print("配置已保存到:", DEFAULT_CONFIG_PATH)