ion-CSP 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

ion_CSP/__main__.py

@@ -0,0 +1,5 @@
+from .task_manager import main
+
+if __name__ == "__main__":
+    main()
+    

ion_CSP/gen_opt.py

@@ -238,7 +238,7 @@ class CrystalGenerator:
             # 如果在本地运行作业，则只在后续创建一级目录
             parent = ""
             # 如果是本地运行，则根据显存占用率阈值，等待可用的GPU
-            selected_gpu = wait_for_gpu(memory_percent_threshold=30, wait_time=300)
+            selected_gpu = wait_for_gpu(memory_percent_threshold=40, wait_time=600)
             os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu)
 
         from dpdispatcher import Resources, Task, Submission

ion_CSP/identify_molecules.py

@@ -75,12 +75,12 @@ def molecules_information(molecules: List[Dict[str, int]], molecules_flag: bool,
         output = []
         for element in fixed_order:
             if element in molecule:
-                output.append(f"{element} {molecule[element]}") 
+                output.append(f"{element}{molecule[element]}") 
         # 如果有其他元素，添加到输出中
         for element in molecule:
             if element not in fixed_order:
-                output.append(f"{element} {molecule[element]}")
-        formatted_output =  ' '.join(output)
+                output.append(f"{element}{molecule[element]}")
+        formatted_output = ''.join(output)
         logging.info(f'  Molecule {idx + 1} (Total Atoms: {total_atoms}, Count: {count}): {formatted_output}')
     if molecules_flag:
         logging.info('Molecular Comparison Successful\n')

ion_CSP/task_manager.py

@@ -0,0 +1,396 @@
+import os
+import re
+import sys
+import time
+import psutil
+import logging
+import subprocess
+import importlib.util
+from pathlib import Path
+
+
+class TaskManager:
+    """任务管理器类 - Manages task execution and monitoring"""
+
+    def __init__(self):
+        """初始化任务管理器 - Initialize task manager"""
+        self.env = "LOCAL"
+        self.project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        self.workspace = Path.cwd()
+        self.log_base = "logs"
+        self.log_dir = self.workspace / self.log_base
+        self.version = self._get_version()
+        self._detect_env()
+        self._setup_logging()
+
+    def __repr__(self):
+        return f"Taskmanager(version={self.version}, env={self.env}, project_root={self.project_root}, workspace={self.workspace}, log_base={self.log_base}, log_dir={self.log_dir})"
+
+    def _get_version(self):
+        """版本获取"""
+        try:
+            # 使用 importlib 动态加载
+            spec = importlib.util.spec_from_file_location(
+                "ion_CSP", 
+                os.path.join(self.project_root, "src/__init__.py")
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            return module.__version__
+        except Exception as e:
+            logging.error(f"Version detection failed: {e}")
+            return "unknown"
+
+    def _detect_env(self):
+        """检测运行环境 - Detect execution environment"""
+        if Path("/.dockerenv").exists() or "DOCKER" in os.environ:
+            self.env = "DOCKER"
+            self.workspace = Path("/app")
+            self.log_dir = Path("/app/logs")
+        self.workspace.mkdir(exist_ok=True)
+
+    def _setup_logging(self):
+        """配置日志系统 - Configure logging system"""
+        self.log_dir = self.workspace / self.log_base
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+            handlers=[
+                logging.FileHandler(self.log_dir / "system.log"),
+                logging.StreamHandler(),
+            ],
+        )
+
+    def _cleanup_task_files(self, module: str, pid: int):
+        """清理任务相关文件"""
+        log_file = self.log_dir / f"{module}_{pid}.log"
+        if log_file.exists():
+            log_file.unlink()
+            print(f"Cleaned up orphaned log: {log_file.name}")
+            
+    def _safe_kill(self, module: str, pid: int):
+        """安全终止进程并清理残留资源 - Safely kill process and cleanup orphan resources"""
+        try:
+            proc = psutil.Process(pid)
+            # 先尝试优雅终止并等待进程推出
+            proc.terminate()
+            print(f"Termination signal sent to PID {pid}")
+
+            # 正确处理进程退出状态
+            try:
+                exit_code = proc.wait(timeout=5)
+                print(f"PID {pid} exited with code {exit_code}")
+                exit_code = 0  # 正常退出
+            except psutil.TimeoutExpired:
+                print(f"PID {pid} did not exit gracefully, forcing termination...")
+                proc.kill()
+                exit_code = -1  # 强制终止标记
+            # 清理残留文件
+            self._cleanup_task_files(module, pid)
+            input("\nPress Enter to continue...")
+            return exit_code
+
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            print(f"PID {pid} already terminated")
+            self._cleanup_task_files(module, pid)
+            input("\nPress Enter to continue...")
+            return -2  # 进程不存在标记
+        except Exception as e:
+            print(f"Error terminating process: {str(e)}")
+            input("\nPress Enter to continue...")
+            return -3  # 其他错误标记
+
+    def _is_pid_running(self, pid: int):
+        """检查进程是否仍在运行 - Check the process status according to PID"""
+        try:
+            proc = psutil.Process(pid)
+            return proc.status() in (psutil.STATUS_RUNNING, psutil.STATUS_SLEEPING)
+        except psutil.NoSuchProcess:
+            return False
+
+    def _is_valid_task_pid(self, pid: int):
+        """验证PID是否属于当前程序的任务进程 - Valid the task PID according to log file"""
+        try:
+            proc = psutil.Process(pid)
+            cmdline = " ".join(proc.cmdline())
+
+            # 检查模块标识和Python环境
+            return "python" in proc.name().lower() and (
+                "main_CSP" in cmdline or "main_EE" in cmdline
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+
+    def _display_tasks(self, tasks, total, current_page, total_pages, function):
+        """标准化任务显示 - Standardized tasks display"""
+        display = "logs" if function == "view" else "tasks" 
+        print(f"\033cPage {current_page}/{total_pages} ({total} {display})")
+        if function == "kill":
+            for i, task in enumerate(tasks, 1):
+                print(
+                    f"{i:3}) [{task['module']}] PID:{task['pid']:5} [{task['status']}] - {task['real_log']}"
+                )
+        elif function == "view":
+            for i, task in enumerate(tasks, 1):
+                print(
+                    f"{i:3}) [{task['module']}] - {task['real_log']}"
+                )
+        else:
+            raise ValueError(f"Not supported function {function}. Available function: 'view' and 'kill' ")
+        print("\nPage {} of {}".format(current_page, total_pages))
+        # 分页控制
+        print("\nOptions:")
+        if function == "view":
+            print("n) Next page | p) Previous page | f) Filter | q) Quit")
+        elif function == "kill":
+            print("n) Next page | p) Previous page | f) Filter | k) Kill | q) Quit")
+        else:
+            raise ValueError("Unexpected function parameter")
+
+    def _paginate_tasks(self, tasks, function, page_size=10):
+        """通用分页函数 - Universal tasks pagination"""
+        total = len(tasks)
+        pages = (total + page_size - 1) // page_size
+        current_page = 0
+        filter_bool = False
+        
+        while True:
+            start = current_page * page_size
+            end = start + page_size
+            page_tasks = tasks[start:end]
+            if not filter_bool:
+            # 显示当前页内容
+                self._display_tasks(page_tasks, total, current_page+1, pages, function)
+            
+            choice = input().strip().upper()
+            if choice == 'N' and current_page < pages-1:
+                current_page += 1
+            elif choice == 'P' and current_page > 0:
+                current_page -= 1
+            elif function == "kill" and choice == "K":
+                try:
+                    task_num = input("Enter task number to kill: ").strip()
+                    if not task_num.isdigit():
+                        raise ValueError
+                    # 计算全局任务索引
+                    global_index = current_page * 10 + (int(task_num) - 1)
+                    if 0 <= global_index < len(tasks):
+                        selected_index = global_index
+                        confirm = input(
+                            f"Confirm termination of {tasks[selected_index]['module']} PID {tasks[selected_index]['pid']}? (y/n): "
+                        ).lower()
+                        if confirm == "y":
+                            self._safe_kill(
+                                module=tasks[selected_index]["module"],
+                                pid=tasks[selected_index]["pid"],
+                            )
+                            break
+                    else:
+                        print("Invalid task number")
+                        input("\nPress Enter to continue...")
+                except ValueError:
+                    print("Please enter a valid number")
+                    input("\nPress Enter to continue...")
+            elif function == "view" and choice.isdigit():
+                # 计算全局任务索引
+                global_index = current_page * 10 + (int(choice) - 1)
+                if 0 <= global_index < len(tasks):
+                    selected_index = global_index
+                    os.system(f"less {tasks[selected_index]['real_log']}")
+                else:
+                    print("Invalid selection")
+                    input("\nPress Enter to continue...")
+            elif choice == 'Q':
+                break
+            elif choice == 'F':
+                filter_module = input("Please enter a valid module name (CSP or EE)\n")
+                if filter_module in ("CSP", "EE"):
+                    self.view_filtered_tasks(filter_module, function)
+                    break
+                else:
+                    print("Invalid task number")
+                    input("\nPress Enter to continue...")
+            else:
+                print("Invalid command")
+                input("\nPress Enter to continue...")
+
+    def task_runner(self, module: str, work_dir: str):
+        """任务执行器 - Task execution handler"""
+        work_dir = Path(work_dir)
+        work_dir.mkdir(exist_ok=True)
+
+        console_log = work_dir / f"main_{module}_console.log"
+        pid_file = work_dir / "pid.txt"
+
+        # 启动子进程
+        cmd = ["python", "-m", f"src.main_{module}", str(work_dir)]
+
+        with open(console_log, "w") as f:
+            process = subprocess.Popen(
+                cmd,
+                stdout=f,
+                stderr=subprocess.STDOUT,
+                preexec_fn=os.setsid if os.name != "nt" else None,
+            )
+
+        # 等待PID文件创建
+        time.sleep(1)
+        try:
+            with open(pid_file, "w") as f:
+                f.write(str(process.pid))
+        except Exception as e:
+            logging.error(f"Error writing PID file: {e}")
+            process.terminate()
+            return
+        # 创建符号链接
+        output_log = work_dir / f"main_{module}.py_output.log"
+        print(f"Original log file: {output_log}")
+        std_log = Path(self.log_dir) / f"{module}_{process.pid}.log"
+        try:
+            output_log = output_log.resolve()
+            std_log.symlink_to(output_log)
+            os.remove(pid_file)
+        except FileExistsError:
+            os.remove(std_log)
+            std_log.symlink_to(output_log)
+
+        logging.info(f"Started {module} module (PID: {process.pid})")
+        print(f"Task started (PID: {process.pid})")
+        print(f"Normalized log file: {std_log}")
+
+    def view_logs(self, page_size: int = 10):
+        """查看日志 - View task logs"""
+        log_tasks = []
+        log_pattern = re.compile(r"(CSP|EE)_\d+$")  # 正则匹配规范文件名
+        for log_file in self.log_dir.glob("**/*.log"):
+            if not log_pattern.match(log_file.stem):
+                continue
+            try:
+                file_path = log_file.resolve(strict=True)
+                mtime = file_path.stat().st_mtime
+                log_tasks.append({
+                    "pid": 0,  # 日志无PID
+                    "module": log_file.stem.split("_")[0].upper(),
+                    "real_log": str(file_path),
+                    "mtime": mtime,
+                    "log_name": log_file.name,
+                    "status": "Static"
+                })
+            except Exception as e:
+                logging.error(f"Error processing {log_file}: {e}")
+                continue
+        self._paginate_tasks(log_tasks, function="view", page_size=page_size)
+
+    def safe_terminate(self):
+        """安全终止任务 - Safe task termination"""
+        tasks = self.get_related_tasks()
+        if not tasks:
+            print("No running tasks found")
+            input("\nPress Enter to continue...")
+            return
+
+        # 分页显示任务列表
+        filter_bool = False
+        while True:
+            print("\033c", end="")  # 清屏指令
+            # 显示当前页任务
+            print(f"\nRunning tasks ({len(tasks)} in total):")
+            if not filter_bool:
+                self._paginate_tasks(tasks, function="kill")
+                break
+
+    def view_filtered_tasks(self, module_filter: str, function: str):
+        """带分页的过滤任务显示"""
+        all_tasks = self.get_related_tasks()
+        filtered = [t for t in all_tasks if t["module"] == module_filter.upper()]
+        if not filtered:
+            print("No matching tasks found")
+            input("\nPress Enter to continue...")
+            return
+        print(f"\033cFiltered Tasks ({len(filtered)}):")
+        self._paginate_tasks(filtered, function)  # 复用通用分页逻辑
+
+    def get_related_tasks(self):
+        """获取实时任务列表并验证状态 - Get relatd tasks list and validate the status"""
+        tasks = []
+        log_pattern = re.compile(r"(CSP|EE)_\d+$")  # 正则匹配规范文件名
+
+        for log_file in self.log_dir.glob("**/*.log"):
+            if not log_pattern.match(log_file.stem):
+                continue  # 跳过非标准日志文件
+            try:
+                # 使用正则提取模块和PID
+                match = re.match(r"(CSP|EE)_(\d+)$", log_file.stem)
+                module = match.group(1).upper()
+                pid = int(match.group(2))
+
+                # 验证进程状态
+                if self._is_valid_task_pid(pid):
+                    # 获取实际日志路径
+                    real_log_path = str(log_file.resolve(strict=True))
+                    # 获取文件修改时间戳
+                    mtime = log_file.stat().st_mtime
+                    status = "Running" if self._is_pid_running(pid) else "Terminated"
+                    task_info = (
+                        {
+                            "pid": pid,
+                            "module": module,
+                            "real_log": real_log_path,
+                            "mtime": mtime,
+                            "status": status,
+                        }
+                    )
+                    tasks.append(task_info)
+            except (ValueError, IndexError) as e:
+                logging.error(f"Error parsing log file {log_file}: {e}")
+                continue
+        # 按修改时间降序排列（最新在前）
+        tasks.sort(key=lambda t: t["mtime"], reverse=True)
+        return tasks
+
+    def main_menu(self):
+        """主菜单循环 - Main menu loop"""
+        while True:
+            os.system("clear" if os.name == "posix" else "cls")
+            print("========== Task Execution Sys1tem ==========")
+            print(f"Current Version: {self.version}")
+            print(f"Current Environment: {self.env}")
+            print(f"Current Directory: {self.workspace}")
+            print(f"Log Base Directory: {self.log_dir}")
+            print("=" * 50)
+            print("1) Run EE Module")
+            print("2) Run CSP Module")
+            print("3) View Logs")
+            print("4) Terminate Tasks")
+            print("q) Exit")
+            print("=" * 50)
+
+            choice = input("Please enter operation: ").strip().lower()
+            if choice == "1":
+                work_dir = input("Enter EE working directory: ").strip()
+                self.task_runner("EE", work_dir)
+                input("\nPress Enter to continue...")
+            elif choice == "2":
+                work_dir = input("Enter CSP working directory: ").strip()
+                self.task_runner("CSP", work_dir)
+                input("\nPress Enter to continue...")
+            elif choice == "3":
+                self.view_logs()
+            elif choice == "4":
+                self.safe_terminate()
+            elif choice == "q":
+                print("\033c", end="")  # 清屏指令
+                sys.exit(0)
+            else:
+                print("Invalid selection")
+                input("\nPress Enter to continue...")
+
+
+def main():
+    manager = TaskManager()
+    manager.main_menu()
+
+
+if __name__ == "__main__":
+    main()

ion_CSP/vasp_processing.py

@@ -224,7 +224,7 @@ class VaspProcessing:
                     logging.error(
                         f"  Unfinished fine optimization job of CONTCAR_{mlp_density}_{number}"
                     )
-                    fine_density, fine_energy = False, False
+                    fine_density, fine_energy, molecules_flag = False, False, False
 
                 # 读取根目录下的 config.yaml 信息与对应的 .json 文件
                 config_path = os.path.join(self.base_dir, "config.yaml")
@@ -245,8 +245,8 @@ class VaspProcessing:
                     packing_coefficient = round(
                         molecular_volumes / fine_atoms_volume, 4
                     )
-                except FileNotFoundError:
-                    raise
+                except (FileNotFoundError, UnboundLocalError):
+                    packing_coefficient = False
 
                 mlp_energies.append(mlp_energy)
                 rough_densities.append(rough_density)

ion_csp-2.0.4.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: ion_CSP
+Version: 2.0.4
+Summary: Crystal Structure Design Software Based on Molecular/Ionic Configuration.
+Home-page: https://github.com/bagabaga007/ion_CSP
+Author: Ze Yang
+Author-email: Ze Yang <yangze1995007@163.com>
+License-Expression: MIT
+Keywords: ion_crystal, crystal_structure_prediction
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ase==3.23.0
+Requires-Dist: deepmd-kit==3.0.1
+Requires-Dist: torch==2.5.0
+Requires-Dist: dpdispatcher==0.6.7
+Requires-Dist: numpy==1.26.4
+Requires-Dist: paramiko==3.5.1
+Requires-Dist: pyxtal==1.0.4
+Requires-Dist: phonopy==2.28.0
+Requires-Dist: rdkit==2024.3.3
+Requires-Dist: pytest==8.3.4
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Crystal Structure Design Software V2.0
+
+## 项目概述
+基于分子/离子构型的晶体结构设计软件通过结合经验公式、机器学习势函数微调、第一性原理分步优化和分子/离子识别技术，实现了从分子/离子构型出发的高效晶体结构筛选。该软件采用模块化设计，支持全流程自动化材料筛选，在保证预测精度的同时显著提升计算效率。
+
+## 功能特性
+### 核心功能
+- **双模块工作流**  
+  - **EE模块**：基于经验评估的离子组合生成  
+  - **CSP模块**：基于离子晶体结构预测的优化筛选  
+- **智能任务管理**  
+  - 实时进程监控（PID跟踪）
+  - 日志文件自动符号链接
+  - 进程安全终止与资源清理
+- **高级日志系统**  
+  - 分页浏览（10条/页）
+  - 模块过滤（CSP/EE）
+  - 软链接解析显示实际路径
+
+### 技术特性
+- 跨平台支持（Linux/Docker）
+- 基于Python 3.11+的面向对象架构
+- 集成psutil进程管理
+- 结构化日志记录系统
+
+## 安装指南
+### 环境要求
+| 组件        | 最低版本 |
+|-------------|----------|
+| Python      | 3.11     |
+| psutil      | 5.9      |
+| Docker      | 20.10    |
+| ase         | 3.23.0   |
+| deepmd-kit  | 3.0.1    |
+| torch       | 2.5.0    |
+| dpdispatcher| 0.6.7    |
+| numpy       | 1.26.4   |
+| paramiko    | 3.5.1    |
+| pyxtal      | 1.0.4    |
+| phonopy     | 2.28.0   |
+| rdkit       | 2023.03.3|
+
+### 安装步骤
+```bash
+# 创建虚拟环境
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+
+# 安装依赖
+pip install ion-csp
+```
+
+## 快速入门
+### 交互模式
+```bash
+ion-csp
+```
+启动交互式命令行界面，支持以下操作：
+- 模块选择
+- 日志查看
+- 进程管理
+
+### 脚本调用
+#### EE模块示例
+```bash
+./scripts/main_EE.sh examples/example_1
+```
+从SMILES表格生成离子组合
+
+#### CSP模块示例
+```bash
+./scripts/main_CSP.sh examples/example_2
+```
+从离子组合生成并优化晶体结构
+
+## 技术架构
+```mermaid
+graph TD
+    A[用户界面] --> B[任务管理器]
+    B --> C[EE模块]
+    B --> D[CSP模块]
+    B --> E[日志系统]
+    B --> F[任务调度]
+    C --> G[经验评估引擎]
+    D --> H[晶体预测引擎]
+    E --> I[结构化日志]
+    F --> J[进程终止]
+```
+
+## 贡献指南
+1. Fork仓库并创建特性分支
+2. 编写单元测试覆盖新功能
+3. 提交Pull Request时注明关联Issue
+4. 遵循PEP8代码规范
+
+## 许可证
+本项目采用MIT许可证，详见LICENSE文件。
+
+## 技术支持
+- **文档更新**：2025年5月
+- **最新版本**：v2.0.4
+- **问题追踪**：https://github.com/bagabaga007/ion_CSP/issues
+
+---
+
+# Crystal Structure Design Software V2.0
+
+## Project Overview
+This software enables efficient crystal structure screening from molecular/ion configurations by integrating empirical formulas, tuned machine learning potentials, stepwise first-principles optimization, and molecular/ion recognition techniques. The modular architecture ensures extensibility and maintainability while maintaining prediction accuracy.
+
+## Key Features
+### Core Functionalities
+- **Dual-Module Workflow**
+  - **EE Module**: Empirical evaluation-based ion combination generation
+  - **CSP Module**: Ion crystal structure prediction and optimization
+- **Intelligent Task Management**
+  - Real-time process monitoring (PID tracking)
+  - Automatic log file symlink creation
+  - Safe process termination with resource cleanup
+- **Advanced Logging System**
+  - Paginated log viewing (10 entries/page)
+  - Module-based filtering (CSP/EE)
+  - Symlink resolution for actual log paths
+
+### Technical Specifications
+- Cross-platform support (Linux/Docker)
+- Object-oriented architecture with Python 3.11+
+- Integrated process management via psutil
+- Structured logging system
+
+## Installation
+### Prerequisites
+| Component   | Min Version |
+|-------------|-------------|
+| Python      | 3.11     |
+| psutil      | 5.9      |
+| Docker      | 20.10    |
+| ase         | 3.23.0   |
+| deepmd-kit  | 3.0.1    |
+| torch       | 2.5.0    |
+| dpdispatcher| 0.6.7    |
+| numpy       | 1.26.4   |
+| paramiko    | 3.5.1    |
+| pyxtal      | 1.0.4    |
+| phonopy     | 2.28.0   |
+| rdkit       | 2023.03.3|
+
+### Installation Steps
+```bash
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+
+# Install dependencies
+pip install ion-csp
+```
+
+## Quick Start
+### Interactive Mode
+```bash
+ion-csp
+```
+Launches CLI interface with:
+- Module selection
+- Log management
+- Process control
+
+### Script Execution
+#### EE Module Example
+```bash
+./scripts/main_EE.sh examples/example_1
+```
+Generates ion combinations from SMILES tables
+
+#### CSP Module Example
+```bash
+./scripts/main_CSP.sh examples/example_2
+```
+Optimizes crystal structures from ion combinations
+
+## Technical Architecture
+```mermaid
+graph TD
+    A[User Interface] --> B[Task Manager]
+    B --> C[EE Module]
+    B --> D[CSP Module]
+    B --> E[Log System]
+    B --> F[Task Scheduler]
+    C --> G[Empirical Evaluation Engine]
+    D --> H[Crystal Prediction Engine]
+    E --> I[Structured Logs]
+    F --> J[Process Termination]
+```
+
+## Contribution Guide
+1. Fork repository and create feature branch
+2. Write unit tests for new features
+3. Submit PR with issue reference
+4. Follow PEP8 coding standards
+
+## License
+MIT License, see LICENSE file.
+
+## Support
+- Documentation last updated: May 2025
+- Latest version: v2.0.4
+- Issue tracker: https://github.com/bagabaga007/ion_CSP/issues

ion_csp-2.0.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+ion_CSP/__init__.py,sha256=M5RcbYDdt-UBVpsDKiJWJqLvSFfoBfU6aTUVccgK_BE,190
+ion_CSP/__main__.py,sha256=XlNCx5eMSrL7yld9ddSYXhjXvg2ZYGD_uk9LdqNabvs,74
+ion_CSP/convert_SMILES.py,sha256=4fndMcuIEypYtkXWBoS7W7uEXkZXVLeMDshdXEIk5kY,13864
+ion_CSP/empirical_estimate.py,sha256=_U5VRWSIAiJGcxnP3mnCHn8zKzviFEQhQwN7TjPTnCU,29089
+ion_CSP/gen_opt.py,sha256=aVZmf2RqePCwZShgpNvzqfntNAW0I0yctWHGXoe3mgw,19463
+ion_CSP/identify_molecules.py,sha256=hFKXS0Jjd7LyMsYGc9RmnoRPu1ibXF9fYO_9lR3wTfo,4634
+ion_CSP/log_and_time.py,sha256=6RKegXF8Gc1HqzAbE-PT9ejX3Ncyuz3v3FivujJt8to,9072
+ion_CSP/mlp_opt.py,sha256=ox4Qxg4D6WzrB8dxVnUWmAngnOA_wdcInP5UhBWsH4c,5535
+ion_CSP/read_mlp_density.py,sha256=ktGNHYWLi4VrdJK_Hg2ac2-JM2QlVt9iymLxdixkLb8,9663
+ion_CSP/steps_opt_monitor.sh,sha256=1klPjnK0gqkDbvI9PtjdK5qidJ5G0Mo8q1SfrlLW5xM,3330
+ion_CSP/task_manager.py,sha256=PGtlvlJb7uzb1YcJyhP7cURQqOO4nNM-VacyZwVXixs,16088
+ion_CSP/upload_download.py,sha256=Hiz5jKOy9x26hJJdcpt-owQdVUbzzGuGOelro6JozY8,23801
+ion_CSP/vasp_processing.py,sha256=eQTMKIPBzi1X4HHTqWkHE1Lt8dvCCV-MXPCR3RtKYZ0,13977
+ion_csp-2.0.4.dist-info/licenses/LICENSE,sha256=2J6A8GT2iIf2LhuWO1_0ilgx7ijzzpQ2BXU7rHKe8Cc,1068
+ion_csp-2.0.4.dist-info/METADATA,sha256=r9ijfq_Yo5mTqMnCzNT9vYVF-FDSxN9bkHtU99FDdUw,6380
+ion_csp-2.0.4.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+ion_csp-2.0.4.dist-info/entry_points.txt,sha256=NexQJDs9f69kJA2DgoU6tsA3V8a66nadJRem1U_c_6g,54
+ion_csp-2.0.4.dist-info/top_level.txt,sha256=aYZa43dDebjLpWPN6bDIlBb6BVwA8gk4ajEjDDK9b9I,8
+ion_csp-2.0.4.dist-info/RECORD,,

{ion_csp-2.0.2.dist-info → ion_csp-2.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ion_csp-2.0.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ion-csp = ion_CSP.task_manager:main

ion_CSP/app.py

@@ -1,201 +0,0 @@
-#!/usr/bin/env python3
-import os
-import sys
-import time
-import signal
-import logging
-import subprocess
-from pathlib import Path
-from datetime import datetime
-
-
-class TaskManager:
-    def __init__(self):
-        self.env = "LOCAL"
-        self.workspace = Path.cwd()
-        self.log_base = self.workspace / "logs"
-        self._detect_env()
-        self._setup_logging()
-
-    def _detect_env(self):
-        """环境检测"""
-        if Path("/.dockerenv").exists() or "DOCKER" in os.environ:
-            self.env = "DOCKER"
-            self.workspace = Path("/app")
-            self.log_base = Path("/app/logs")
-        self.workspace.mkdir(exist_ok=True)
-        self.log_base.mkdir(exist_ok=True)
-
-    def _setup_logging(self):
-        """日志配置"""
-        logging.basicConfig(
-            level=logging.INFO,
-            format="%(asctime)s - %(levelname)s - %(message)s",
-            handlers=[
-                logging.FileHandler(self.log_base / "system.log"),
-                logging.StreamHandler(),
-            ],
-        )
-
-    def normalize_path(self, path):
-        """路径标准化"""
-        path = Path(path).resolve()
-        if self.env == "DOCKER":
-            return str(path.relative_to(self.workspace))
-        return str(path)
-
-    def _get_pid(self, module, work_dir):
-        """获取进程PID"""
-        log_file = Path(work_dir) / f"main_{module}_console.log"
-        if not log_file.exists():
-            return None
-        try:
-            with open(log_file, "r") as f:
-                for line in f:
-                    if "PYTHON_PID:" in line:
-                        return int(line.split(":")[-1].strip())
-        except Exception as e:
-            logging.error(f"Error reading PID from log: {e}")
-        return None
-
-    def task_runner(self, module, work_dir):
-        """任务执行器"""
-        work_dir = Path(work_dir)
-        work_dir.mkdir(exist_ok=True)
-
-        console_log = work_dir / f"main_{module}_console.log"
-        pid_file = work_dir / "pid.txt"
-
-        # 启动子进程
-        cmd = ["python", "-m", f"src.main_{module}", str(work_dir)]
-
-        with open(console_log, "w") as f:
-            process = subprocess.Popen(
-                cmd,
-                stdout=f,
-                stderr=subprocess.STDOUT,
-                preexec_fn=os.setsid if os.name != "nt" else None,
-            )
-
-        # 等待PID文件创建
-        time.sleep(1)
-        try:
-            with open(pid_file, "w") as f:
-                f.write(str(process.pid))
-        except Exception as e:
-            logging.error(f"Error writing PID file: {e}")
-            process.terminate()
-            return
-        # 创建符号链接
-        output_log = work_dir / f"main_{module}.py_output.log"
-        print(f"Original log file: {output_log}")
-        std_log = self.log_base / f"{module}_{process.pid}.log"
-        try:
-            std_log.symlink_to(output_log)
-            os.remove(pid_file)
-        except FileExistsError:
-            os.remove(std_log)
-            std_log.symlink_to(output_log)
-
-        logging.info(f"Started {module} module (PID: {process.pid})")
-        print(f"Task started (PID: {process.pid})")
-        print(f"Normalized log file: {std_log}")
-
-    def terminate_task(self, pid):
-        """终止任务"""
-        try:
-            os.killpg(os.getpgid(pid), signal.SIGTERM)
-            print(f"Successfully terminated PID {pid}")
-        except ProcessLookupError:
-            print(f"No process found with PID {pid}")
-        except Exception as e:
-            print(f"Error terminating process: {e}")
-
-    def view_logs(self, page_size=10):
-        """查看日志"""
-        log_files = sorted(
-            self.log_base.glob("**/*.log"), key=os.path.getmtime, reverse=True
-        )
-        if not log_files:
-            print("No logs found")
-            return
-        total_files = len(log_files)
-        total_pages = (total_files + page_size - 1) // page_size  # 计算总页数
-        
-        current_page = 0
-        while True:
-            start_index = current_page * page_size
-            end_index = start_index + page_size
-            print("\nAvailable logs:")
-
-            # 显示当前页的日志文件
-            for i, f in enumerate(log_files[start_index:end_index], start_index + 1):
-                print(
-                    f"{i}) {f.name} ({datetime.fromtimestamp(f.stat().st_mtime).strftime('%Y-%m-%d %H:%M')})"
-                )
-
-            print("\nPage {} of {}".format(current_page + 1, total_pages))
-            if current_page > 0:
-                print("Enter 'p' to go to the previous page.")
-            if current_page < total_pages - 1:
-                print("Enter 'n' to go to the next page.")
-            print("Enter log number to view (q to cancel): ")
-
-            choice = input().strip()
-            if choice.isdigit():
-                choice_index = int(choice) - 1
-                if 0 <= choice_index < total_files:
-                    os.system(f"less {log_files[choice_index]}")
-                else:
-                    print("Invalid selection")
-            elif choice == "n" and current_page < total_pages - 1:
-                current_page += 1
-            elif choice == "p" and current_page > 0:
-                current_page -= 1
-            elif choice == "q":
-                break
-            else:
-                print("Invalid command")
-
-    def main_menu(self):
-        """主菜单循环"""
-        while True:
-            os.system("clear" if os.name == "posix" else "cls")
-            print("========== Task Execution System ==========")
-            print(f"Current Environment: {self.env}")
-            print(f"Current Directory: {self.workspace}")
-            print(f"Log Base Directory: {self.log_base}")
-            print("=" * 50)
-            print("1) Run EE Module")
-            print("2) Run CSP Module")
-            print("3) View Logs")
-            print("4) Terminate Task")
-            print("q) Exit")
-            print("=" * 50)
-
-            choice = input("Please select one of the operation: ").strip()
-            if choice == "1":
-                work_dir = input("Enter EE working directory: ").strip()
-                self.task_runner("EE", work_dir)
-            elif choice == "2":
-                work_dir = input("Enter CSP working directory: ").strip()
-                self.task_runner("CSP", work_dir)
-            elif choice == "3":
-                self.view_logs()
-            elif choice == "4":
-                pid = input("Enter PID to terminate: ").strip()
-                if pid.isdigit():
-                    self.terminate_task(int(pid))
-                else:
-                    print("Invalid PID format")
-            elif choice == "q":
-                print("Exiting system...")
-                sys.exit(0)
-            else:
-                print("Invalid selection")
-            input("\nPress Enter to continue...")
-
-
-if __name__ == "__main__":
-    manager = TaskManager()
-    manager.main_menu()

ion_csp-2.0.2.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: ion_CSP
-Version: 2.0.2
-Summary: Crystal Structure Design Software Based on Molecular/Ionic Configuration.
-Home-page: https://github.com/bagabaga007/ion_CSP
-Author: yangze
-Author-email: Ze Yang <yangze1995007@163.com>
-License: MIT License
-        
-        Copyright (c) [2025] [ion_CSP]
-        
-        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.
-        
-Keywords: ion_crystal, crystal_structure_prediction
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ase==3.23.0
-Requires-Dist: deepmd-kit==3.0.1
-Requires-Dist: torch==2.5.0
-Requires-Dist: dpdispatcher==0.6.7
-Requires-Dist: numpy==1.26.4
-Requires-Dist: paramiko==3.5.1
-Requires-Dist: pyxtal==1.0.4
-Requires-Dist: phonopy==2.28.0
-Requires-Dist: rdkit==2023.03.3
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# 基于分子/离子构型的晶体结构设计软件 V2.0
-
-基于分子/离子构型的晶体结构设计软件可以从分子/离子构型出发，结合经验公式、微调的机器学习势、第一性原理分步优化以及分子/离子识别方法，可以高效且有导向地筛选同时满足结构要求和性质要求的分子/离子晶体结构。该软件实现了分子/离子晶体结构的设计、构建、分析、筛选、评估全流程的自动化与模块化，保证了流程的扩展性和可重用性，能够在保证结果精度的同时，显著提高材料筛选效率。在整个流程中提供了多种检查功能以及结果可视化功能，方便用户使用。该软件使用Python语言编写，提供了完整的面向对象编程支持，在具有较高运行效率的同时使程序更易于理解、扩展和维护。
-
-# 安装
-
-在项目根目录下使用以下命令安装依赖：
-
-pip install -r requirements.txt
-
-pip install -e .
-
-chmod +x ./scripts/*.sh
-
-# 使用示例
-
-### 使用交互式功能自主选择
-./scripts/main.sh
-
-#### 使用经验评估（EE）模块从SMILES表格开始生成离子组合
-./scripts/main_EE.sh examples/example_1
-
-
-#### 使用离子晶体结构预测（CSP）模块从离子组合开始生成晶体并筛选和优化
-./scripts/main_CSP.sh examples/example_2
-
-# 功能
-使用经验评估（EE）模块从SMILES表格开始生成离子组合。
-
-使用离子晶体结构预测（CSP）模块从离子组合开始生成晶体并筛选和优化。
-
-# 联系
-如有问题，请联系 yangze1995007@163.com。

ion_csp-2.0.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-ion_CSP/__init__.py,sha256=M5RcbYDdt-UBVpsDKiJWJqLvSFfoBfU6aTUVccgK_BE,190
-ion_CSP/app.py,sha256=MnuVdzV6yiTG__SPuWeQ05V0rwYqoJtez2XpdmRZOrU,6996
-ion_CSP/convert_SMILES.py,sha256=4fndMcuIEypYtkXWBoS7W7uEXkZXVLeMDshdXEIk5kY,13864
-ion_CSP/empirical_estimate.py,sha256=_U5VRWSIAiJGcxnP3mnCHn8zKzviFEQhQwN7TjPTnCU,29089
-ion_CSP/gen_opt.py,sha256=i9BxV6881YEO5PQZfYqu4wpJ_JfDfTqn0o2XJ90s9UU,19463
-ion_CSP/identify_molecules.py,sha256=yzLMWpGW1YM1B4a9cg4Jd1CekTWtXsPWAt-TpwL1Rks,4638
-ion_CSP/log_and_time.py,sha256=6RKegXF8Gc1HqzAbE-PT9ejX3Ncyuz3v3FivujJt8to,9072
-ion_CSP/mlp_opt.py,sha256=ox4Qxg4D6WzrB8dxVnUWmAngnOA_wdcInP5UhBWsH4c,5535
-ion_CSP/read_mlp_density.py,sha256=ktGNHYWLi4VrdJK_Hg2ac2-JM2QlVt9iymLxdixkLb8,9663
-ion_CSP/steps_opt_monitor.sh,sha256=1klPjnK0gqkDbvI9PtjdK5qidJ5G0Mo8q1SfrlLW5xM,3330
-ion_CSP/upload_download.py,sha256=Hiz5jKOy9x26hJJdcpt-owQdVUbzzGuGOelro6JozY8,23801
-ion_CSP/vasp_processing.py,sha256=Pd-_muPDMst-DKj6vGR34e7IFWsSyGiP7q-aMGZXatA,13911
-ion_csp-2.0.2.dist-info/licenses/LICENSE,sha256=2J6A8GT2iIf2LhuWO1_0ilgx7ijzzpQ2BXU7rHKe8Cc,1068
-ion_csp-2.0.2.dist-info/METADATA,sha256=OfnWFxuY9bXCwIpbkwJVqh8ZQyM1l78YWr6k44ZmVFk,3719
-ion_csp-2.0.2.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-ion_csp-2.0.2.dist-info/entry_points.txt,sha256=l8q_8U8whrkzO1-8RIppbDco-520Cy3Pq1N5LyLTTLc,49
-ion_csp-2.0.2.dist-info/top_level.txt,sha256=aYZa43dDebjLpWPN6bDIlBb6BVwA8gk4ajEjDDK9b9I,8
-ion_csp-2.0.2.dist-info/RECORD,,

ion_csp-2.0.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-gen_opt = scripts.gen_opt:main