ion-CSP 2.0.2__py3-none-any.whl

ion_CSP/log_and_time.py

@@ -0,0 +1,234 @@
+import os
+import sys
+import time
+import yaml
+import signal
+import logging
+import argparse
+from dpdispatcher.dlog import dlog
+
+
+def log_and_time(func):
+    """Decorator for recording log information and script runtime"""
+
+    def wrapper(script_name, work_dir, *args, **kwargs):
+        # 获取脚本所在目录, 在该目录下生成日志
+        log_file_path = os.path.join(work_dir, f"{script_name}_output.log")
+        # 配置日志记录
+        logging.basicConfig(
+            filename=log_file_path,  # 日志文件名
+            level=logging.INFO,  # 指定日志级别
+            format="%(asctime)s - %(levelname)s - %(message)s",  # 日志格式
+        )
+        # 获取程序开始执行时的CPU时间和Wall Clock时间
+        start_cpu, start_clock = time.process_time(), time.perf_counter()
+        # 记录程序开始信息
+        logging.info(f"Start running: {script_name}")
+        # 调用实际的函数, 如果出现错误, 报错的同时也将错误信息记录到日志中
+        result = None
+        try:
+            result = func(work_dir, *args, **kwargs)
+        except Exception as e:
+            logging.error(f"Error occurred: {e}", exc_info=True)
+            raise
+        print(
+            f"The script {script_name} has run successfully, and the output content has been recorded in the output.log file in the same directory."
+        )
+        # 获取程序结束时的CPU时间和Wall Clock时间
+        end_cpu, end_clock = time.process_time(), time.perf_counter()
+        # 计算CPU时间和Wall Clock时间的差值
+        cpu_time, wall_time = end_cpu - start_cpu, end_clock - start_clock
+        # 记录程序结束信息
+        logging.info(
+            f"End running: {script_name}\nWall time: {wall_time:.4f} sec, CPU time: {cpu_time:.4f} sec\n"
+        )
+        return result
+
+    return wrapper
+
+
+def merge_config(default_config, user_config, key):
+    return {**default_config[key], **user_config.get(key, {})}
+
+
+class StatusLogger:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(StatusLogger, cls).__new__(cls)
+            cls._instance.__init__(*args, **kwargs)
+        return cls._instance
+
+    def __init__(self, work_dir, task_name):
+        """Initialize workflow status logger and generate the .log and .yaml file to record the status"""
+        # 使用单例模式，避免重复的日志记录，缺点是再重新给定task_name之后会覆盖原来的实例，只能顺序调用
+        self.task_name = task_name
+        log_file = os.path.join(work_dir, "workflow_status.log")
+        yaml_file = os.path.join(work_dir, "workflow_status.yaml")
+        self.yaml_file = yaml_file
+        self._init_yaml()
+        if hasattr(self, "initialized"):
+            return
+        # 创建 logger 对象
+        self.logger = logging.getLogger("WorkflowLogger")
+        self.logger.setLevel(logging.INFO)
+        # 创建文件处理器
+        file_handler = logging.FileHandler(log_file)
+        formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+        file_handler.setFormatter(formatter)
+        # 添加处理器到 logger
+        self.logger.addHandler(file_handler)
+        # 控制日志信息的传播，不将logger的日志信息传播到全局
+        self.logger.propagate = False
+        # 注册信号处理器
+        signal.signal(signal.SIGINT, self._signal_handler)  # 捕捉 Ctrl + C
+        signal.signal(signal.SIGTERM, self._signal_handler)  # 捕捉 kill 命令
+        # 记录当前进程的 PID
+        self.logger.info(f"Process started with PID: {os.getpid()}")
+        # 初始化工作状态
+        self.initialized = True
+        self._init_yaml()
+
+    def set_running(self):
+        self.current_status = "RUNNING"
+        self.logger.info(f"{self.task_name} Status: {self.current_status}")
+        self.run_count += 1
+        self._update_yaml()
+
+    def set_success(self):
+        self.current_status = "SUCCESS"
+        self.logger.info(f"{self.task_name} Status: {self.current_status}\n")
+        self._update_yaml()
+
+    def is_successful(self):
+        """Check if the current task status is SUCCESS"""
+        return self.current_status == "SUCCESS"
+
+    def set_failure(self):
+        self.current_status = "FAILURE"
+        self.logger.error(f"{self.task_name} Status: {self.current_status}\n")
+        self._update_yaml()
+
+    def _signal_handler(self, signum, _):
+        """Handle termination signals and log the event"""
+        if signum == 2:
+            self.logger.warning(
+                f"Process {os.getpid()} has been interrupted by 'Ctrl + C'\n"
+            )
+        elif signum == 15:
+            self.logger.warning(
+                f"Process {os.getpid()} has been killed by 'kill <pid>' order\n"
+            )
+        else:
+            self.logger.warning(
+                f"Process {os.getpid()} received signal {signum}. Exiting ...\n"
+            )
+        self._set_killed()
+        sys.exit(0)
+
+    def _set_killed(self):
+        self.current_status = "KILLED"
+        self.logger.warning(f"{self.task_name} Status: {self.current_status}\n")
+        self._update_yaml()
+
+    def _init_yaml(self):
+        """Initialize the workflow_status.yaml file"""
+        # 初始化状态信息
+        status_info = {}
+        # 读取现有的 .yaml 文件
+        if os.path.exists(self.yaml_file):
+            with open(self.yaml_file, "r") as yaml_file:
+                status_info = yaml.safe_load(yaml_file) or {}
+        # 更新或添加当前任务的信息
+        if self.task_name not in status_info:
+            self.run_count = 0
+            self.current_status = "INITIAL"
+            status_info[self.task_name] = {
+                "run_count": self.run_count,
+                "current_status": self.current_status,
+            }
+        else:
+            self.run_count = status_info[self.task_name]["run_count"]
+            self.current_status = status_info[self.task_name]["current_status"]
+        # 写回更新后的内容
+        self._write_yaml(status_info=status_info)
+
+    def _update_yaml(self):
+        """Update the workflow_status.yaml file"""
+        with open(self.yaml_file, "r") as yaml_file:
+            status_info = yaml.safe_load(yaml_file)
+        status_info[self.task_name]["run_count"] = self.run_count
+        status_info[self.task_name]["current_status"] = self.current_status
+        # 写回更新后的内容
+        self._write_yaml(status_info=status_info)
+
+    def _write_yaml(self, status_info):
+        """Write the status_info into the workflow_status.yaml file"""
+        with open(self.yaml_file, "w") as yaml_file:
+            yaml.dump(status_info, yaml_file)
+
+
+def redirect_dpdisp_logging(custom_log_path):
+    # 移除所有文件处理器
+    for handler in list(dlog.handlers):
+        if isinstance(handler, logging.FileHandler):
+            dlog.removeHandler(handler)
+    # 创建新文件处理器并继承原始格式
+    new_handler = logging.FileHandler(custom_log_path)
+    # 复制原始处理器的格式
+    for h in dlog.handlers:
+        if isinstance(h, logging.StreamHandler):
+            new_handler.setFormatter(h.formatter)
+            break
+    # 添加新处理器
+    dlog.addHandler(new_handler)
+    dlog.info(f"LOG INIT:dpdispatcher log direct to {custom_log_path}")
+
+
+def get_work_dir_and_config():
+    """获取工作目录并加载配置文件
+    Returns:
+        tuple: (工作目录路径, 合并后的配置字典)
+    Raises:
+        SystemExit: 当输入无效时退出程序
+    """
+    parser = argparse.ArgumentParser(
+        description="The full workflow of ionic crystal design for a certain ion combination, including generation, mlp optimization, screening, vasp optimization and analysis."
+    )
+    parser.add_argument(
+        "work_dir",
+        type=str,
+        nargs="?",  # 使参数变为可选
+        default=None,
+        help="The working directory to run. If not specified, interactive input will be used",
+    )
+    args = parser.parse_args()
+
+    # 交互式输入逻辑
+    if args.work_dir is None:
+        while True:
+            work_dir = input(
+                "Please enter the working directory: "
+            ).strip()
+            if os.path.exists(work_dir) and os.path.isdir(work_dir):
+                args.work_dir = work_dir
+                break
+            print(f"Error: Directory '{work_dir}' does not exist. Please try again.")
+
+    # 配置文件读取逻辑
+    config_path = os.path.join(args.work_dir, "config.yaml")
+    try:
+        with open(config_path, "r") as file:
+            user_config = yaml.safe_load(file)
+    except FileNotFoundError:
+        print(f"Error: config.yaml not found in {args.work_dir}")
+        sys.exit(1)
+    except yaml.YAMLError as e:
+        print("Error parsing YAML file:")
+        print(f"  Line {e.problem_mark.line + 1}, Column {e.problem_mark.column + 1}")
+        print(f"  Details: {str(e)}")
+        sys.exit(1)
+
+    return args.work_dir, user_config
+

ion_CSP/mlp_opt.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+import time
+import numpy as np
+import multiprocessing
+from ase.io.vasp import read_vasp
+from ase.optimize import LBFGS
+from ase.constraints import UnitCellFilter
+from deepmd.calculator import DP
+
+# 根据脚本位置确定model.pt文件的位置, 减少错误发生
+base_dir = os.path.dirname(__file__)
+relative_path = './model.pt'
+file_path = os.path.join(base_dir, relative_path)
+calc = DP(file_path)
+'''
+structure optimization with DP model and ASE
+PSTRESS and fmax should exist in input.dat
+'''
+
+def get_element_num(elements):
+    '''Using the Atoms.symples to Know Element&Num'''
+    element = []
+    ele = {}
+    element.append(elements[0])
+    for x in elements: 
+        if x not in element :
+            element.append(x)
+    for x in element: 
+        ele[x] = elements.count(x)
+    return element, ele 
+        
+def write_CONTCAR(element, ele, lat, pos, index):
+    '''Write CONTCAR''' 
+    f = open(f'{base_dir}/CONTCAR_'+str(index),'w')
+    f.write('ASE-DPKit-Optimization\n')
+    f.write('1.0\n') 
+    for i in range(3):
+        f.write('%15.10f %15.10f %15.10f\n' % tuple(lat[i]))
+    for x in element: 
+        f.write(x + '  ')
+    f.write('\n') 
+    for x in element:
+        f.write(str(ele[x]) + '  ') 
+    f.write('\n') 
+    f.write('Direct\n')
+    na = sum(ele.values())
+    dpos = np.dot(pos,np.linalg.inv(lat))
+    for i in range(na): 
+        f.write('%15.10f %15.10f %15.10f\n' % tuple(dpos[i]))
+        
+def write_OUTCAR(element, ele, masses, volume, lat, pos, ene, force, stress, pstress, index):
+    '''Write OUTCAR'''
+    f = open(f'{base_dir}/OUTCAR_'+str(index),'w')
+    for x in element: 
+        f.write('VRHFIN =' + str(x) + '\n')
+    f.write('ions per type =')
+    for x in element:
+        f.write('%5d' % ele[x])
+    f.write('\nDirection     XX             YY             ZZ             XY             YZ             ZX\n') 
+    f.write('in kB') 
+    f.write('%15.6f' % stress[0])
+    f.write('%15.6f' % stress[1])
+    f.write('%15.6f' % stress[2])
+    f.write('%15.6f' % stress[3])
+    f.write('%15.6f' % stress[4])
+    f.write('%15.6f' % stress[5])
+    f.write('\n') 
+    ext_pressure = np.sum(stress[0] + stress[1] + stress[2])/3.0 - pstress
+    f.write('external pressure = %20.6f kB    Pullay stress = %20.6f  kB\n'% (ext_pressure, pstress))
+    f.write('volume of cell : %20.6f\n' % volume)
+    f.write('direct lattice vectors\n')
+    for i in range(3):
+        f.write('%10.6f %10.6f %10.6f\n' % tuple(lat[i]))
+    f.write('POSITION                                       TOTAL-FORCE(eV/Angst)\n')  
+    f.write('-------------------------------------------------------------------\n')
+    na = sum(ele.values()) 
+    for i in range(na): 
+        f.write('%15.6f %15.6f %15.6f' % tuple(pos[i])) 
+        f.write('%15.6f %15.6f %15.6f\n' % tuple(force[i]))
+    f.write('-------------------------------------------------------------------\n')
+    # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
+    atoms_density = 1.66054 * masses / volume
+    f.write('density = %20.6f\n' % atoms_density)
+    f.write('energy  without entropy= %20.6f %20.6f\n' % (ene, ene/na))
+    enthalpy = ene + pstress * volume / 1602.17733      
+    f.write('enthalpy TOTEN    = %20.6f %20.6f\n' % (enthalpy, enthalpy/na)) 
+        
+def get_indexes():
+    base_dir = os.path.dirname(__file__)
+    POSCAR_files = [f for f in os.listdir(base_dir) if f.startswith('POSCAR_')]
+    indexes = []
+    for filename in POSCAR_files:
+        index_part = filename[len('POSCAR_'):]
+        if index_part.isdigit():
+            index = int(index_part)
+            indexes.append(index)       
+    indexes.sort(key=lambda indexes: indexes)
+    return indexes
+
+def run_opt(index: int): 
+    '''Using the ASE&DP to Optimize Configures''' 
+    if os.path.isfile(f'{base_dir}/OUTCAR'):
+        os.system(f'mv {base_dir}/OUTCAR {base_dir}/OUTCAR-last')
+    fmax, pstress = 0.03, 0
+
+    print('Start to Optimize Structures by DP----------')
+        
+    Opt_Step = 2000
+    start = time.time() 
+    # pstress kbar
+    # kBar to eV/A^3
+    # 1 eV/A^3 = 160.21766028 GPa
+    # 1 / 160.21766028 ~ 0.006242
+    aim_stress = 1.0 * pstress * 0.01 * 0.6242 / 10.0 
+    atoms = read_vasp('POSCAR_'+str(index)) 
+    atoms.calc = calc 
+    ucf = UnitCellFilter(atoms, scalar_pressure=aim_stress)
+    # optimization
+    opt = LBFGS(ucf) 
+    opt.run(fmax=fmax,steps=Opt_Step) 
+    # atoms will be optimized and updated during the opt.run process
+    atoms_lat = atoms.cell 
+    atoms_pos = atoms.positions
+    atoms_force = atoms.get_forces() 
+    atoms_stress = atoms.get_stress() 
+    # eV/A^3 to GPa
+    atoms_stress = atoms_stress/(0.01*0.6242)
+    atoms_symbols = atoms.get_chemical_symbols() 
+    atoms_ene = atoms.get_potential_energy() 
+    atoms_masses = sum(atoms.get_masses())
+    atoms_vol = atoms.get_volume()
+    element, ele = get_element_num(atoms_symbols) 
+
+    write_CONTCAR(element, ele, atoms_lat, atoms_pos, index)
+    write_OUTCAR(element, ele, atoms_masses, atoms_vol, atoms_lat, atoms_pos, atoms_ene, atoms_force, -10.0 * atoms_stress, pstress, index)
+
+    stop = time.time()
+    _cwd = os.getcwd()
+    _cwd = os.path.basename(_cwd)
+    print(f'{_cwd} is done, time: {stop-start}')
+
+
+def main():
+    ctx=multiprocessing.get_context("spawn")
+    pool=ctx.Pool(8)
+    indexes = get_indexes()
+    pool.map(func=run_opt, iterable=indexes)
+    pool.close()
+    pool.join()
+
+if __name__=='__main__':
+    main()

ion_CSP/read_mlp_density.py

@@ -0,0 +1,144 @@
+import os
+import shutil
+import logging
+import subprocess
+from ase.io.vasp import read_vasp
+from ion_CSP.identify_molecules import identify_molecules, molecules_information
+
+class ReadMlpDensity:
+    
+    def __init__(self, work_dir:str):
+        # 获取脚本的当前目录
+        self.base_dir = work_dir
+        os.chdir(self.base_dir)
+        # 寻找同一目录下的2_mlp_optimized文件夹
+        self.folder_dir = os.path.join(self.base_dir, '2_mlp_optimized')
+        self.max_density_dir = os.path.join(self.folder_dir, 'max_density')
+        self.primitive_cell_dir = os.path.join(self.folder_dir, 'primitive_cell')
+        print(f"Processing MLP CONTCARs in {self.folder_dir}")
+        logging.info(f"Processing MLP CONTCARs in {self.folder_dir}")
+
+    def _sequentially_read_files(self, directory: str, prefix_name: str = 'POSCAR_'):
+        """
+        Private method: 
+        Extract numbers from file names, convert them to integers, sort them by sequence, and return a list containing both indexes and file names
+        """
+        # 获取dir文件夹中所有以prefix_name开头的文件，在此实例中为POSCAR_
+        files = [f for f in os.listdir(directory) if f.startswith(prefix_name)]
+        file_index_pairs = []
+        for filename in files:
+            index_part = filename[len(prefix_name):]  # 选取去除前缀'POSCAR_'的数字
+            if index_part.isdigit():  # 确保剩余部分全是数字
+                index = int(index_part)
+                file_index_pairs.append((index, filename))
+        file_index_pairs.sort(key=lambda pair: pair[0])
+        return file_index_pairs
+    
+    def read_density_and_sort(self, n_screen: int = 10, molecules_screen: bool = True, detail_log: bool = False):
+        """
+        Obtain the atomic mass and unit cell volume from the optimized CONTCAR file, and obtain the ion crystal density. Finally, take n CONTCAR files with the highest density and save them separately for viewing.
+        
+        :param n_screen: 取前n个最大密度的文件
+        """
+        os.chdir(self.base_dir)
+        # 获取所有以'CONTCAR_'开头的文件，并按数字顺序处理
+        CONTCAR_file_index_pairs = self._sequentially_read_files(self.folder_dir, prefix_name='CONTCAR_')
+        # 逐个处理文件
+        density_index_list = []
+        for _, CONTCAR_filename in CONTCAR_file_index_pairs:
+            atoms = read_vasp(os.path.join(self.folder_dir, CONTCAR_filename))
+            molecules, molecules_flag, initial_information = identify_molecules(atoms)
+            if detail_log:
+                molecules_information(molecules, molecules_flag, initial_information)
+            if molecules_screen:
+                if molecules_flag:
+                    atoms_volume = atoms.get_volume()  # 体积单位为立方埃（ų）
+                    atoms_masses = sum(atoms.get_masses())  # 质量单位为原子质量单位(amu)
+                    # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
+                    density = 1.66054 * atoms_masses / atoms_volume       
+                    density_index_list.append((density, CONTCAR_filename))
+            else:
+                atoms_volume = atoms.get_volume()  # 体积单位为立方埃（ų）
+                atoms_masses = sum(atoms.get_masses())  # 质量单位为原子质量单位(amu)
+                # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
+                density = 1.66054 * atoms_masses / atoms_volume       
+                density_index_list.append((density, CONTCAR_filename))
+        if molecules_screen:
+            print(f'Total optimized ionic crystals: {len(CONTCAR_file_index_pairs)}')
+            print(f'Screened ionic crystals with original ions: {len(density_index_list)}')
+            logging.info(f'Total optimized ionic crystals: {len(CONTCAR_file_index_pairs)}')
+            logging.info(f'Screened ionic crystals with original ions: {len(density_index_list)}')
+        # 根据密度降序排序
+        sorted_filename = sorted(density_index_list, key=lambda x: x[0], reverse=True)
+        # 将前n个最大密度的CONTCAR文件进行重命名并保存到max_density文件夹
+        if os.path.exists(self.max_density_dir):
+            backup_dir = os.path.join(self.folder_dir, 'backup', 'max_density')
+            os.makedirs(backup_dir, exist_ok=True)
+            for item in os.listdir(self.max_density_dir):
+                shutil.move(os.path.join(self.max_density_dir, item), os.path.join(backup_dir, item))
+        
+        os.makedirs(self.max_density_dir, exist_ok=True)
+        for density, CONTCAR_filename in sorted_filename[:n_screen]:
+            # 生成新的包含密度值的文件名，并重命名文件
+            # 密度转换为字符串，保留4位小数
+            density_str = f'{density:.4f}'
+            # 保留 CONTCAR 的序数信息，方便回推检查
+            number = CONTCAR_filename.split("_")[1]
+            OUTCAR_filename = f'OUTCAR_{number}'
+            new_CONTCAR_filename = f'CONTCAR_{density_str}_{number}'
+            new_OUTCAR_filename = f'OUTCAR_{density_str}_{number}'
+            shutil.copy(f'{self.folder_dir}/{CONTCAR_filename}', f'{self.max_density_dir}/{new_CONTCAR_filename}')
+            shutil.copy(f'{self.folder_dir}/{OUTCAR_filename}', f'{self.max_density_dir}/{new_OUTCAR_filename}')
+            print(f'New CONTCAR and OUTCAR of {density_str}_{number} are renamed and saved')
+            logging.info(f'New CONTCAR and OUTCAR of {density_str}_{number} are renamed and saved')
+
+    def phonopy_processing_max_density(self, specific_directory :str = None):
+        """
+        Use phonopy to check and generate symmetric primitive cells, reducing the complexity of subsequent optimization calculations, and preventing pyxtal.from_random from generating double proportioned supercells. 
+        """
+        if specific_directory:
+            self.phonopy_dir = os.path.join(self.base_dir, specific_directory)
+            self.primitive_cell_dir = os.path.join(os.path.dirname(self.phonopy_dir), 'primitive_cell')
+        else:
+            self.phonopy_dir = self.max_density_dir
+        if os.path.exists(self.primitive_cell_dir):
+            backup_dir = os.path.join(self.folder_dir, 'backup', 'primitive_cell')
+            os.makedirs(backup_dir, exist_ok=True)
+            for item in os.listdir(self.primitive_cell_dir):
+                shutil.move(os.path.join(self.primitive_cell_dir, item), os.path.join(backup_dir, item))
+        
+        os.makedirs(self.primitive_cell_dir, exist_ok=True)
+        CONTCAR_files = [f for f in os.listdir(self.phonopy_dir) if f.startswith('CONTCAR_')]
+        # 改变工作目录，便于运行shell命令进行phonopy对称性检查和原胞与常规胞的生成
+        os.chdir(self.phonopy_dir)
+        logging.info('Start running phonopy processing ...')
+        try:
+            for new_CONTCAR_filename in CONTCAR_files:
+                # 按顺序处理POSCAR文件，首先复制一份无数字后缀的POSCAR文件
+                shutil.copy(f'{self.phonopy_dir}/{new_CONTCAR_filename}', f'{self.phonopy_dir}/POSCAR')
+                with open(f'{self.primitive_cell_dir}/phonopy.log', 'a') as log:
+                    # 使用phonopy模块处理POSCAR结构文件，获取对称化的原胞和常规胞。
+                    # 应用晶体的对称操作优化后的原胞可以最好地符合晶体的对称性，减少后续优化计算的复杂性。
+                    log.write(f'\nProcessing file: {new_CONTCAR_filename}\n')
+                    result = subprocess.run(['nohup', 'phonopy', '--symmetry', 'POSCAR'], stderr=subprocess.STDOUT)
+                    log.write(f'Finished processing file: {new_CONTCAR_filename} with return code: {result.returncode}\n')
+                # 将phonopy生成的PPOSCAR（对称化原胞）和BPOSCAR（对称化常规胞）放到对应的文件夹中，并将文件名改回POSCAR_index
+                shutil.move(f'{self.phonopy_dir}/PPOSCAR', f'{self.primitive_cell_dir}/{new_CONTCAR_filename}')
+                # 复制对应的OUTCAR文件到primitive_cell目录下
+                density_number = new_CONTCAR_filename.split("CONTCAR_")[1]
+                new_OUTCAR_filename = f'OUTCAR_{density_number}'
+                shutil.copy(f'{self.max_density_dir}/{new_OUTCAR_filename}', f'{self.primitive_cell_dir}/{new_OUTCAR_filename}')
+            for_vasp_opt_dir = os.path.join(self.base_dir, '3_for_vasp_opt')
+            if os.path.exists(for_vasp_opt_dir):
+                shutil.rmtree(for_vasp_opt_dir)
+            shutil.copytree(self.primitive_cell_dir, for_vasp_opt_dir)
+            logging.info('The phonopy processing has been completed!!\nThe symmetrized primitive cells have been saved in POSCAR format to the primitive_cell folder.\nThe output content of phonopy has been saved to the phonopy.log file in the same directory.')
+            # 在 phonopy 成功进行对称化处理后，删除 2_mlp_optimized/max_density 文件夹以节省空间
+            shutil.rmtree(self.max_density_dir)
+        except FileNotFoundError:
+            logging.error(
+                "There are no CONTCAR structure files after screening.\nPlease check if the ions correspond to the crystals and adjust the screening criteria"
+            )
+            raise FileNotFoundError(
+                "There are no CONTCAR structure files after screening.\nPlease check if the ions correspond to the crystals and adjust the screening criteria"
+            )

ion_CSP/steps_opt_monitor.sh

@@ -0,0 +1,110 @@
+#!/bin/bash
+
+# 设置变量
+FOLDER=$1
+BASE_DIR="$FOLDER/3_for_vasp_opt"
+INCAR_1="INCAR_1"
+INCAR_2="INCAR_2"
+POTCAR_H="POTCAR_H"
+POTCAR_C="POTCAR_C"
+POTCAR_N="POTCAR_N"
+POTCAR_O="POTCAR_O"
+SUB_SCRIPT="JLU_184_sub.sh"
+FLAG_FILE="${BASE_DIR}/flag_${FOLDER}.txt"
+
+# 检查必要文件是否存在
+if [[ ! -f "$INCAR_1" || ! -f "$INCAR_2" || ! -f "$POTCAR_H" || ! -f "$POTCAR_C" || ! -f "$POTCAR_N" || ! -f "$POTCAR_O" || ! -f "$SUB_SCRIPT" ]]; then
+    echo "Necessary files are missing, please check the path."
+    exit 1
+fi
+
+# 创建 POTCAR 文件
+create_potcar_from_poscar() {
+    poscar_file="$1"
+    output_file="POTCAR"
+    > "$output_file"  # 清空文件
+
+    # 读取 POSCAR 文件的第六行（元素行）
+    read -r element_line < <(sed -n '6p' "$poscar_file")
+
+    # 将元素转换为数组
+    IFS=' ' read -r -a elements <<< "$element_line"
+
+    # 根据元素拼接 POTCAR
+    for element in "${elements[@]}"; do
+        case $element in
+            H) cat "$POTCAR_H" >> "$output_file" ;;
+            C) cat "$POTCAR_C" >> "$output_file" ;;
+            N) cat "$POTCAR_N" >> "$output_file" ;;
+            O) cat "$POTCAR_O" >> "$output_file" ;;
+            *) echo "Warning: POTCAR for element $element not found." ;;
+        esac
+    done
+}
+
+# 提交第一步优化任务
+for contcar in ${BASE_DIR}/CONTCAR_*; do
+    if [[ $contcar =~ CONTCAR_(.*) ]]; then
+        sample=${BASH_REMATCH[1]}
+        sample_dir="${BASE_DIR}/${sample}"
+        mkdir -p "$sample_dir"
+        cp "$contcar" "${sample_dir}/POSCAR"
+        cp "$INCAR_1" "${sample_dir}/INCAR"
+        create_potcar_from_poscar "${sample_dir}/POSCAR"  # 根据 POSCAR 创建 POTCAR
+        cp "POTCAR" "${sample_dir}/"  # 使用自动生成的 POTCAR
+        cp "$SUB_SCRIPT" "${sample_dir}/"
+        rm "POTCAR"
+        (cd "${sample_dir}" && bsub -J "${FOLDER}_1" < "${SUB_SCRIPT}")
+    fi
+done
+
+echo "All first step tasks have been submitted."
+
+# 提交监控任务
+monitor_job_id=$(bsub -J "m_$FOLDER" -n 1 -q normal -o /dev/null -e /dev/null <<EOF
+#!/bin/bash
+
+# 设置变量
+FOLDER=$FOLDER
+BASE_DIR="$BASE_DIR"
+INCAR_2="$INCAR_2"
+SUB_SCRIPT="$SUB_SCRIPT"
+FLAG_FILE="$FLAG_FILE"
+
+# 监控任务
+while true; do
+    # 检查第一步任务是否完成
+    if ! bjobs -J "${FOLDER}_1" | grep -q "RUN\|PEND"; then
+        echo "The first step task has been completed, ready to submit the second step task..."
+        break
+    fi
+    sleep 60  # 每60秒检查一次
+done
+
+# 提交第二步优化任务
+for sample in \$(ls \${BASE_DIR}); do
+    if [ -f "\${BASE_DIR}/\${sample}/CONTCAR" ]; then
+        sample_dir="\${BASE_DIR}/\${sample}"
+        mkdir -p "\${sample_dir}/fine"
+        cp "\${sample_dir}/CONTCAR" "\${sample_dir}/fine/POSCAR"
+        cp "\$INCAR_2" "\${sample_dir}/fine/INCAR"
+        cp "\${sample_dir}/POTCAR" "\${sample_dir}/fine/"
+        cp "\$SUB_SCRIPT" "\${sample_dir}/fine/"
+        (cd "\${sample_dir}/fine" && bsub -J "\${FOLDER}_2" < "\${SUB_SCRIPT}")
+    fi
+done
+
+# 等待第二步任务完成
+while true; do
+    if ! bjobs -J "\${FOLDER}_2" | grep -q "RUN\|PEND"; then
+        echo "All second step tasks have been completed, and the flag file is generated ..."
+        touch "\$FLAG_FILE"
+        break
+    fi
+    sleep 60  # 每60秒检查一次
+done
+
+EOF
+)
+
+echo "Monitoring task submitted, task ID: $monitor_job_id"