ion-CSP 2.1.8__py3-none-any.whl → 2.2.0__py3-none-any.whl

ion_CSP/__init__.py

@@ -1,12 +1,12 @@
 __author__ = "Ze Yang"
 __contact__ = "yangze1995007@163.com"
 __license__ = "MIT"
-__version__ = "2.1.8"
-__date__ = "2025-06-23"
+__version__ = "2.2.0"
+__date__ = "2025-06-27"
 
 
 try:
-    from importlib.metadata import version  # python >= 3.11
+    from importlib.metadata import version
 except Exception:
     try:
         from importlib_metadata import version

ion_CSP/convert_SMILES.py

@@ -72,7 +72,13 @@ class SmilesProcessing:
             basename: The corresponding basename.
         """
         mol = Chem.MolFromSmiles(smiles)
-        mol = Chem.AddHs(mol)
+        try:
+            mol = Chem.AddHs(mol)
+        except Exception as e:
+            logging.error(
+                f"Error occurred while adding hydrogens to molecule {basename} with charge {charge}: {e}"
+            )
+            return 1, basename  # 返回错误码1表示失败
         try:
             # 生成3D坐标
             AllChem.EmbedMolecule(mol)

ion_CSP/empirical_estimate.py

@@ -53,7 +53,14 @@ x.fchk //指定计算文件
 
 class EmpiricalEstimation:
     
-    def __init__(self, work_dir: str, folders: List[str], ratios: List[int], sort_by: str):
+    def __init__(
+        self,
+        work_dir: str,
+        folders: List[str],
+        ratios: List[int],
+        sort_by: str,
+        optimized_dir: str = "1_2_Gaussian_optimized",
+    ):
         """
         This class is designed to process Gaussian calculation files, perform electrostatic potential analysis using Multiwfn, and estimate the nitrogen content or density of ion crystal combinations. The class will also generate .csv files containing sorted nitrogen content or density based on the specified sorting criterion.
 
@@ -64,17 +71,91 @@ class EmpiricalEstimation:
             sort_by: A string indicating the sorting criterion, either 'density' or 'nitrogen'.
         """
         self.base_dir = work_dir
-        os.chdir(self.base_dir)
+        self.gaussian_optimized_dir = os.path.join(self.base_dir, optimized_dir)
+        os.chdir(self.gaussian_optimized_dir)
         # 确保所取的文件夹数与配比数是对应的
         if len(folders) != len(ratios):
             raise ValueError('The number of folders must match the number of ratios.')
         self.folders = folders
         self.ratios = ratios
         self.sort_by = sort_by
-        if sort_by not in ("density", "nitrogen"):
-            raise ValueError(f"The sort_by parameter must be either 'density' or 'nitrogen', but got '{sort_by}'")
+        if sort_by not in ("density", "nitrogen", "NC_ratio"):
+            raise ValueError(f"The sort_by parameter must be either 'density' 'nitrogen' or 'NC_ratio', but got '{sort_by}'")
         self.density_csv = "sorted_density.csv"
         self.nitrogen_csv = "sorted_nitrogen.csv"
+        self.NC_ratio_csv = "specific_NC_ratio.csv"
+        # 检查Multiwfn可执行文件是否存在
+        self.multiwfn_path = self._check_multiwfn_executable()
+    
+    def _check_multiwfn_executable(self):
+        '''
+        Private method:
+        Check if the Multiwfn executable file exists in the system PATH.
+        If not, raise a FileNotFoundError with an appropriate error message.
+        '''
+        multiwfn_path = shutil.which("Multiwfn_noGUI") or shutil.which("Multiwfn")
+        if not multiwfn_path:
+            error_msg = (
+                "Error: No detected Multiwfn executable file (Multiwfn or Multiwfn_GUI), please check:\n "
+                "1. Has Multiwfn been installed correctly?\n"
+                "2. Has Multiwfn been added to the system PATH environment variable"
+            )
+            print(error_msg)
+            logging.error(error_msg)
+            raise FileNotFoundError("No detected Multiwfn executable file (Multiwfn or Multiwfn_GUI)")
+        else:
+            print(f"Multiwfn executable found at: {multiwfn_path}")
+            logging.info(f"Multiwfn executable found at: {multiwfn_path}")
+        return multiwfn_path
+
+    def _multiwfn_cmd_build(self, input_content, output_file=None):
+        '''
+        Private method:
+        Build the Multiwfn command to be executed based on the input content.
+        This method is used to create the input file for Multiwfn.
+
+        :params
+            input_content: The content to be written to the input file for Multiwfn.
+        '''
+        # 创建 input.txt 用于存储 Multiwfn 命令内容
+        with open('input.txt', 'w') as input_file:
+            input_file.write(input_content)
+        if output_file:
+            with open('output.txt', 'w') as output_file, open('input.txt', 'r') as input_file:
+                try:
+                    # 通过 input.txt 执行 Multiwfn 命令, 并将输出结果重定向到 output.txt 中
+                    subprocess.run([self.multiwfn_path], stdin=input_file, stdout=output_file, check=True)
+                except subprocess.CalledProcessError as e:
+                    logging.error(
+                        f"Error executing Multiwfn command with input {input_content}: {e}"
+                    )
+                except Exception as e:
+                    logging.error(f"Unexpected error: {e}")
+                    raise
+                finally:
+                    # 清理临时文件
+                    try:
+                        os.remove("input.txt")
+                    except Exception as e:
+                        logging.warning(f"Cannot remove temporary file input.txt: {str(e)}")
+        else:
+            with open("input.txt", "r") as input_file:
+                try:
+                    # 通过 input.txt 执行 Multiwfn 命令, 并将输出结果重定向到 output.txt 中
+                    subprocess.run([self.multiwfn_path], stdin=input_file, check=True)
+                except subprocess.CalledProcessError as e:
+                    logging.error(
+                        f"Error executing Multiwfn command with input {input_content}: {e}"
+                    )
+                except Exception as e:
+                    logging.error(f"Unexpected error: {e}")
+                    raise
+                finally:
+                    # 清理临时文件
+                    try:
+                        os.remove("input.txt")
+                    except Exception as e:
+                        logging.warning(f"Cannot remove temporary file input.txt: {str(e)}")
 
     def multiwfn_process_fchk_to_json(self, specific_directory: str = None):
         '''
@@ -130,59 +211,6 @@ class EmpiricalEstimation:
                     logging.error(f'Error with moving bad files: {e}')
         logging.info(f'\nElectrostatic potential analysis by Multiwfn for {folder} folder has completed, and the results have been stored in the corresponding json files.\n')
 
-    def _check_multiwfn_executable(self):
-        '''
-        Private method:
-        Check if the Multiwfn executable file exists in the system PATH.
-        If not, raise a FileNotFoundError with an appropriate error message.
-        '''
-        multiwfn_path = shutil.which("Multiwfn_noGUI") or shutil.which("Multiwfn")
-        if not multiwfn_path:
-            error_msg = (
-                "Error: No detected Multiwfn executable file (Multiwfn or Multiwfn_GUI), please check:\n "
-                "1. Has Multiwfn been installed correctly?\n"
-                "2. Has Multiwfn been added to the system PATH environment variable"
-            )
-            print(error_msg)
-            logging.error(error_msg)
-            raise FileNotFoundError("No detected Multiwfn executable file (Multiwfn or Multiwfn_GUI)")
-        return multiwfn_path
-
-    def _multiwfn_cmd_build(self, input_content):
-        '''
-        Private method:
-        Build the Multiwfn command to be executed based on the input content.
-        This method is used to create the input file for Multiwfn.
-
-        :params
-            input_content: The content to be written to the input file for Multiwfn.
-        '''
-        # 检查Multiwfn可执行文件是否存在
-        multiwfn_path = self._check_multiwfn_executable()
-        # 创建 input.txt 用于存储 Multiwfn 命令内容
-        with open('input.txt', 'w') as input_file:
-            input_file.write(input_content)
-        # 通过 input.txt 执行 Multiwfn 命令, 并将输出结果重定向到output.txt中
-        cmd = [multiwfn_path, "<", "input.txt", ">", "output.txt"]
-        try:
-            subprocess.run(cmd, shell=True, capture_output=True)
-        except subprocess.CalledProcessError as e:
-            error_msg = f"Multiwfn execution failed (return code {e.returncode}): Error output: {e.stderr}"
-            print(error_msg)
-            logging.error(error_msg)
-            raise
-        except Exception as e:
-            error_msg = f"Unexpected Error: {str(e)}"
-            print(error_msg)
-            logging.error(error_msg)
-            raise
-        finally:
-            # 清理临时文件
-            try:
-                os.remove("input.txt")
-            except Exception as e:
-                logging.warning(f"无法删除临时文件 input.txt: {str(e)}")
-
     def _single_multiwfn_fchk_to_json(self, fchk_filename: str):
         '''
         Private method: 
@@ -196,7 +224,10 @@ class EmpiricalEstimation:
         print(f'Multiwfn processing {fchk_filename}')
         logging.info(f'Multiwfn processing {fchk_filename}')
         result_flag = True
-        self._multiwfn_cmd_build(input_content=f"{fchk_filename}\n12\n0\nq\n")
+        self._multiwfn_cmd_build(
+            input_content=f"{fchk_filename}\n12\n0\n-1\n-1\nq\n", 
+            output_file='output.txt')
+        print(f'Finished processing {fchk_filename}')
 
         # 获取目录以及 .fchk 文件的无后缀文件名, 即 refcode
         folder, filename = os.path.split(fchk_filename)
@@ -207,12 +238,6 @@ class EmpiricalEstimation:
         except Exception as e:
             logging.error(f"Error reading output.txt: {e}")
             raise
-        finally:
-            # 清理临时文件
-            try:
-                os.remove("output.txt")
-            except Exception as e:
-                logging.warning(f"无法删除临时文件 output.txt: {str(e)}")
         # 提取所需数据
         volume_match = re.search(r'Volume:\s*([\d.]+)\s*Bohr\^3\s+\(\s*([\d.]+)\s*Angstrom\^3\)', output_content)
         density_match = re.search(r'Estimated density according to mass and volume \(M/V\):\s*([\d.]+)\s*g/cm\^3', output_content)
@@ -263,6 +288,10 @@ class EmpiricalEstimation:
                 json.dump(result, json_file, indent=4)
             shutil.copyfile(src=f"{folder}/{refcode}.json", dst=f"Optimized/{folder}/{refcode}.json")
         logging.info(f'Finished processing {fchk_filename}')
+        try:
+            os.remove("output.txt")
+        except Exception as e:
+            logging.warning(f"Cannot remove temporary file output.txt: {str(e)}")
         return result_flag
 
     def gaussian_log_to_optimized_gjf(self, specific_directory: str = None):
@@ -321,14 +350,10 @@ class EmpiricalEstimation:
         refcode, _ = os.path.splitext(filename)
         
         try:
-            # 创建 input.txt 用于存储 Multiwfn 命令内容
-            with open('input.txt', 'w') as input_file:
-                input_file.write(f"{log_filename}\ngi\nOptimized/{folder}/{refcode}.gjf\nq\n")
             # Multiwfn首先载入优化任务的out/log文件, 然后输入gi, 再输入要保存的gjf文件名, 此时里面的结构就是优化最后一帧的, 还避免了使用完全图形界面  
-            try:         
-                subprocess.run('Multiwfn_noGUI < input.txt', shell=True, capture_output=True)
-            except FileNotFoundError:
-                subprocess.run('Multiwfn < input.txt', shell=True, capture_output=True)
+            self._multiwfn_cmd_build(
+                input_content=f"{log_filename}\ngi\nOptimized/{folder}/{refcode}.gjf\nq\n"
+            )
             if os.path.exists(f"Optimized/{folder}/{refcode}.gjf"):
                 print(f'Finished converting {refcode} .log to .gjf')
                 logging.info(f'Finished converting {refcode} .log to .gjf')
@@ -339,6 +364,45 @@ class EmpiricalEstimation:
             print(f'Error with processing {log_filename}: {e}')
             logging.error(f'Error with processing {log_filename}: {e}')
 
+    def _read_gjf_elements(self, gjf_file):
+        """
+        Private method:
+        Read the elements from a .gjf file and return a dictionary with element counts.
+
+        :params
+            gjf_file: The full path of the .gjf file to be processed.
+
+        :return: A dictionary with element symbols as keys and their counts as values.
+        """
+        # 根据每一个组合中的组分找到对应的 JSON 文件并读取其中的性质内容
+        with open(gjf_file, "r") as file:
+            lines = file.readlines()
+        atomic_counts = {}
+        # 找到原子信息的开始行
+        start_reading = False
+        for line in lines:
+            line = line.strip()
+            # 跳过注释和空行
+            if line.startswith("%") or line.startswith("#") or not line:
+                continue
+            # 检测只包含两个数字的行
+            parts = line.split()
+            if (
+                len(parts) == 2
+                and parts[0].lstrip("-").isdigit()
+                and parts[1].isdigit()
+            ):
+                start_reading = True
+                continue
+            if start_reading:
+                element = parts[0]  # 第一个部分是元素符号
+                # 更新元素计数
+                if element in atomic_counts:
+                    atomic_counts[element] += 1
+                else:
+                    atomic_counts[element] = 1
+        return atomic_counts
+
     def nitrogen_content_estimate(self):
         """
         Evaluate the priority of ion crystal combinations based on nitrogen content and generate .csv files
@@ -380,73 +444,62 @@ class EmpiricalEstimation:
             writer.writerow(header)  # 写入表头
             writer.writerows(data)  # 写入排序后的数
 
-    def _read_gjf_elements(self, gjf_file):
+    def carbon_nitrogen_ratio_estimate(self):
         """
-        Private method:
-        Read the elements from a .gjf file and return a dictionary with element counts.
+        Evaluate the priority of ion crystal combinations based on carbon and nitrogen ratio
+        (C:N < 1:8) and sort by oxygen content, then generate .csv files.
+        """
+        atomic_masses = {"H": 1.008, "C": 12.01, "N": 14.01, "O": 16.00}
+        # 获取所有 .gjf 文件
+        combinations = self._generate_combinations(suffix=".gjf")
+        filtered_data = []
 
-        :params
-            gjf_file: The full path of the .gjf file to be processed.
+        for combo in combinations:
+            total_atoms = 0
+            carbon_atoms = 0
+            nitrogen_atoms = 0
+            oxygen_atoms = 0
 
-        :return: A dictionary with element symbols as keys and their counts as values.
-        """
-        # 根据每一个组合中的组分找到对应的 JSON 文件并读取其中的性质内容
-        with open(gjf_file, 'r') as file:
-            lines = file.readlines()
-        atomic_counts = {}
-        # 找到原子信息的开始行
-        start_reading = False
-        for line in lines:
-            line = line.strip()
-            # 跳过注释和空行
-            if line.startswith("%") or line.startswith("#") or not line:
-                continue
-            # 检测只包含两个数字的行
-            parts = line.split()
-            if len(parts) == 2 and parts[0].lstrip("-").isdigit() and parts[1].isdigit():
-                start_reading = True
-                continue
-            if start_reading:
-                element = parts[0]  # 第一个部分是元素符号
-                # 更新元素计数
-                if element in atomic_counts:
-                    atomic_counts[element] += 1
-                else:
-                    atomic_counts[element] = 1
-        return atomic_counts
+            for gjf_file, ion_count in combo.items():
+                atomic_counts = self._read_gjf_elements(gjf_file)
+                for element, atom_count in atomic_counts.items():
+                    if element in atomic_masses:
+                        total_atoms += atom_count * ion_count
+                        if element == "C":
+                            carbon_atoms += atom_count * ion_count
+                        elif element == "N":
+                            nitrogen_atoms += atom_count * ion_count
+                        elif element == "O":
+                            oxygen_atoms += atom_count * ion_count
+                    else:
+                        raise ValueError(
+                            "Contains element information not included, unable to calculate ratios"
+                        )
 
-    def _generate_combinations(self, suffix: str):
-        """
-        Private method:
-        Generate all valid combinations of files based on the specified suffix and ratios.
+            # 计算 C:N 比率
+            if carbon_atoms != 0:  # 确保氮的质量大于 0，避免除以零
+                nitrogen_carbon_ratio = round(nitrogen_atoms / carbon_atoms, 2)
+            else:
+                nitrogen_carbon_ratio = 100.0
+            filtered_data.append((combo, nitrogen_carbon_ratio, oxygen_atoms))
 
-        :params
-            suffix: The file suffix to filter the files in the folders.
+        # 根据氧含量排序
+        filtered_data.sort(key=lambda x: (-x[1], -x[2]))
 
-        :return: A list of dictionaries representing the combinations of files with their respective ratios.
-        """
-        # 获取所有符合后缀名条件的文件
-        all_files = []
-        for folder in self.folders:
-            suffix_files = [os.path.join(folder, f) for f in os.listdir(folder) if f.endswith(suffix)]
-            suffix_files.sort()
-            print(f'Valid {suffix} file number in {folder}: {len(suffix_files)}')
-            logging.info(f"Valid {suffix} file number in {folder}: {len(suffix_files)}")
-            if not suffix_files:
-                raise FileNotFoundError(f'No available {suffix} files in {folder} folder')
-            all_files.append(suffix_files)
+        # 写入排序后的 .csv 文件
+        with open(self.NC_ratio_csv, "w", newline="", encoding="utf-8") as csv_file:
+            writer = csv.writer(csv_file)
+            # 动态生成表头
+            num_components = len(combinations[0]) if combinations else 0
+            header = [f"Component {i + 1}" for i in range(num_components)] + ["N_C_Ratio", "O_Atoms"]
+            writer.writerow(header)  # 写入表头
 
-        # 对所有文件根据其文件夹与配比进行组合
-        combinations = []
-        for folder_files in itertools.product(*all_files):
-            # 根据给定的配比生成字典形式的组合
-            ratio_combination = {}
-            for folder_index, count in enumerate(self.ratios):
-                ratio_combination.update({folder_files[folder_index]: count})
-            combinations.append(ratio_combination)
-        print(f'Valid combination number: {len(combinations)}')
-        logging.info(f'Valid combination number: {len(combinations)}')
-        return combinations
+            # 写入筛选后的组合和氧含量
+            for combo, nitrogen_carbon_ratio, oxygen_content in filtered_data:
+                cleaned_combo = [name.replace(".gjf", "") for name in combo]
+                writer.writerow(
+                    cleaned_combo + [nitrogen_carbon_ratio, oxygen_content]
+                )  # 写入每一行
 
     def empirical_estimate(self):
         """
@@ -518,6 +571,39 @@ class EmpiricalEstimation:
             writer.writerow(header)  # 写入表头
             writer.writerows(data)  # 写入排序后的数
 
+    def _generate_combinations(self, suffix: str):
+        """
+        Private method:
+        Generate all valid combinations of files based on the specified suffix and ratios.
+
+        :params
+            suffix: The file suffix to filter the files in the folders.
+
+        :return: A list of dictionaries representing the combinations of files with their respective ratios.
+        """
+        # 获取所有符合后缀名条件的文件
+        all_files = []
+        for folder in self.folders:
+            suffix_files = [os.path.join(folder, f) for f in os.listdir(folder) if f.endswith(suffix)]
+            suffix_files.sort()
+            print(f'Valid {suffix} file number in {folder}: {len(suffix_files)}')
+            logging.info(f"Valid {suffix} file number in {folder}: {len(suffix_files)}")
+            if not suffix_files:
+                raise FileNotFoundError(f'No available {suffix} files in {folder} folder')
+            all_files.append(suffix_files)
+
+        # 对所有文件根据其文件夹与配比进行组合
+        combinations = []
+        for folder_files in itertools.product(*all_files):
+            # 根据给定的配比生成字典形式的组合
+            ratio_combination = {}
+            for folder_index, count in enumerate(self.ratios):
+                ratio_combination.update({folder_files[folder_index]: count})
+            combinations.append(ratio_combination)
+        print(f'Valid combination number: {len(combinations)}')
+        logging.info(f'Valid combination number: {len(combinations)}')
+        return combinations
+
     def _copy_combo_file(self, combo_path, folder_basename, file_type):
         """
         Private method:
@@ -529,7 +615,7 @@ class EmpiricalEstimation:
             file_type: The type of file to be copied (e.g., '.gjf', '.json').
         """
         filename = f"{folder_basename}{file_type}"
-        source_path = os.path.join(self.base_dir, 'Optimized', filename)
+        source_path = os.path.join(self.gaussian_optimized_dir, "Optimized", filename)
         # 复制指定后缀名文件到对应的 combo_n 文件夹
         if os.path.exists(source_path):
             if os.path.exists(os.path.join(combo_path, os.path.basename(filename))):
@@ -539,7 +625,9 @@ class EmpiricalEstimation:
                 shutil.copy(source_path, combo_path)
                 logging.info(f'Copied {os.path.basename(source_path)} to {combo_path}')
         else:
-            logging.error(f'File of {filename} does not exist in {self.base_dir}')
+            logging.error(
+                f"File of {filename} does not exist in {self.gaussian_optimized_dir}"
+            )
 
     def make_combo_dir(self, target_dir: str, num_combos: int, ion_numbers: List[int]):
         """
@@ -554,6 +642,8 @@ class EmpiricalEstimation:
             base_csv = self.density_csv
         elif self.sort_by == 'nitrogen':
             base_csv = self.nitrogen_csv
+        elif self.sort_by == "NC_ratio":
+            base_csv = self.NC_ratio_csv
         if not target_dir:
             target_dir = f'../2_{self.sort_by}_combos'
         with open(base_csv, mode='r', newline='') as file:
@@ -582,15 +672,15 @@ class EmpiricalEstimation:
                     gjf_names.append(f"{folder_basename.split('/')[1]}.gjf")
                 
                 # 生成上级目录路径并解析 .yaml 文件
-                parent_dir = os.path.dirname(self.base_dir)
+                parent_dir = self.base_dir
                 parent_config_path = os.path.join(parent_dir, 'config.yaml')
-                base_config_path = os.path.join(self.base_dir, "config.yaml")
+                base_config_path = os.path.join(self.gaussian_optimized_dir, "config.yaml")
                 try:
                     with open(parent_config_path, 'r') as file:
                         config = yaml.safe_load(file)
                 except FileNotFoundError as e:
                     logging.warning(f"No available config.yaml file in parent directory: {parent_dir} \n{e}")
-                    logging.info(f"Trying to load config.yaml file from base directory: {self.base_dir}")
+                    logging.info(f"Trying to load config.yaml file from base directory: {parent_dir}")
                     try:
                         with open(base_config_path, 'r') as file:
                             try:
@@ -598,11 +688,10 @@ class EmpiricalEstimation:
                             except yaml.YAMLError as e:
                                 logging.error(f"YAML configuration file parsing failed: {e}")
                     except FileNotFoundError as e:
-                        logging.error(f"No available config.yaml file either in parent directory: {parent_dir} and base directory {self.base_dir} \n{e}")
+                        logging.error(
+                            f"No available config.yaml file either in parent directory: {parent_dir} and base directory {self.gaussian_optimized_dir} \n{e}"
+                        )
                         raise
-                except PermissionError:
-                    logging.error(f'No read permission for the path: {parent_dir}')
-                    raise
                 except Exception as e:
                     logging.error(f'Unexpected error: {e}')
                     raise
@@ -620,4 +709,3 @@ class EmpiricalEstimation:
                         yaml.dump(config, file)
                 except Exception as e:
                     logging.error(f"Unexpected error: {e}")
-                

ion_CSP/run/main_EE.py

@@ -1,4 +1,3 @@
-import os
 import logging
 from ion_CSP.convert_SMILES import SmilesProcessing
 from ion_CSP.empirical_estimate import EmpiricalEstimation
@@ -31,11 +30,10 @@ DEFAULT_CONFIG = {
 @log_and_time
 def main(work_dir, config):
     logging.info(f"Using config: {config}")
-    empirical_estimate_dir = os.path.join(work_dir, "1_2_Gaussian_optimized")
     tasks = {
         "0_convertion": lambda: convertion_task(work_dir, config),
-        "0_estimation": lambda: estimation_task(empirical_estimate_dir, config),
-        "0_update_combo": lambda: combination_task(empirical_estimate_dir, config),
+        "0_estimation": lambda: estimation_task(work_dir, config),
+        "0_update_combo": lambda: combination_task(work_dir, config),
     }
     for task_name, task_func in tasks.items():
         task_logger = StatusLogger(work_dir=work_dir, task_name=task_name)
@@ -52,7 +50,7 @@ def main(work_dir, config):
         task_logger = StatusLogger(work_dir=work_dir, task_name="0_update_combo")
         try:
             task_logger.set_running()
-            combination_task(empirical_estimate_dir, config)
+            combination_task(work_dir, config)
             task_logger.set_success()
         except Exception:
             task_logger.set_failure()
@@ -94,14 +92,6 @@ def estimation_task(work_dir, config):
     estimation.multiwfn_process_fchk_to_json()
     # 由于后续晶体生成不支持 .log 文件，需要将 Gaussian 优化得到的 .log 文件最后一帧转为 .gjf 结构文件
     estimation.gaussian_log_to_optimized_gjf()
-    # 如果依据密度排序，则需要经验公式根据配比生成离子晶体组合，读取 .json 文件并将静电势分析得到的各离子性质代入经验公式
-    if config["empirical_estimate"]["sort_by"] == "density":
-        # 最终将预测的离子晶体密度以及对应的组分输出到 .csv 文件并根据密度从大到小排序
-        estimation.empirical_estimate()
-    # 如果依据氮含量排序，则调用另一套根据 .gjf 文件中化学分布信息
-    elif config["empirical_estimate"]["sort_by"] == "nitrogen":
-        # 最终将预测的离子晶体氮含量以及对应的组分输出到 .csv 文件并根据氮含量从大到小排序
-        estimation.nitrogen_content_estimate()
 
 def combination_task(work_dir, config):
     # 在工作目录下准备 Gaussian 优化处理后具有 .gjf、.fchk 和 .log 文件的文件夹, 并提供对应的离子配比
@@ -111,6 +101,14 @@ def combination_task(work_dir, config):
         ratios=config["empirical_estimate"]["ratios"],
         sort_by=config["empirical_estimate"]["sort_by"],
     )
+    # 如果依据密度排序，则需要经验公式根据配比生成离子晶体组合，读取 .json 文件并将静电势分析得到的各离子性质代入经验公式
+    if config["empirical_estimate"]["sort_by"] == "density":
+        # 最终将预测的离子晶体密度以及对应的组分输出到 .csv 文件并根据密度从大到小排序
+        combination.empirical_estimate()
+    # 如果依据氮含量排序，则调用另一套根据 .gjf 文件中化学分布信息
+    elif config["empirical_estimate"]["sort_by"] == "nitrogen":
+        # 最终将预测的离子晶体氮含量以及对应的组分输出到 .csv 文件并根据氮含量从大到小排序
+        combination.nitrogen_content_estimate()
     # 基于排序依据 sort_by 对应的 .csv 文件创建 combo_n 文件夹，并复制相应的 .gjf 结构文件。
     if config["empirical_estimate"]["make_combo_dir"]:
         combination.make_combo_dir(

ion_CSP/task_manager.py

@@ -31,7 +31,7 @@ class TaskManager:
         try:
             return importlib.metadata.version("ion_CSP")
         except importlib.metadata.PackageNotFoundError:
-            logging.error("Version detection failed")
+            logging.error("Package not found")
             return "unknown"
         except Exception as e:
             logging.error(f"Version detection failed: {e}")

ion_CSP/vasp_processing.py

@@ -140,9 +140,7 @@ class VaspProcessing:
             task_dir = os.path.join(self.for_vasp_opt_dir, f"{parent}pop{pop}")
             for job_i in node_jobs[pop]:
                 vasp_dir = mlp_contcar_files[job_i].split("CONTCAR_")[1]
-                shutil.copytree(
-                    f"{task_dir}/{vasp_dir}", f"{self.vasp_optimized_dir}/{vasp_dir}"
-                )
+                shutil.copytree(f"{task_dir}/{vasp_dir}", f"{self.vasp_optimized_dir}/{vasp_dir}", dirs_exist_ok=True)
             # 在成功完成 VASP 分步优化后，删除 3_for_vasp_opt/{parent}/pop{n} 文件夹以节省空间
             shutil.rmtree(task_dir)
         if machine_inform["context_type"] == "SSHContext":
@@ -219,14 +217,15 @@ class VaspProcessing:
                 # 将分配好的POSCAR文件添加到对应的上传文件中
                 vasp_dir = vasp_optimized_folders[job_i]
                 fine_optimized_file = f"{vasp_dir}/fine/CONTCAR"
-                forward_files.append(fine_optimized_file)
-                os.makedirs(
-                    os.path.dirname(f"{task_dir}/{fine_optimized_file}"), exist_ok=True
-                )
-                shutil.copyfile(
-                    f"{self.vasp_optimized_dir}/{fine_optimized_file}",
-                    f"{task_dir}/{fine_optimized_file}",
-                )
+                if os.path.exists(fine_optimized_file):
+                    forward_files.append(fine_optimized_file)
+                    os.makedirs(
+                        os.path.dirname(f"{task_dir}/{fine_optimized_file}"), exist_ok=True
+                    )
+                    shutil.copyfile(
+                        f"{self.vasp_optimized_dir}/{fine_optimized_file}",
+                        f"{task_dir}/{fine_optimized_file}",
+                    )
                 # 每个POSCAR文件在优化后都取回对应的CONTCAR和OUTCAR输出文件
                 backward_files.append(f"{vasp_dir}/*")
                 backward_files.append(f"{vasp_dir}/fine/*")
@@ -255,10 +254,16 @@ class VaspProcessing:
             task_dir = os.path.join(self.vasp_optimized_dir, f"{parent}pop{pop}")
             for job_i in node_jobs[pop]:
                 vasp_dir = vasp_optimized_folders[job_i]
-                shutil.copytree(
-                    f"{task_dir}/{vasp_dir}/fine/final",
-                    f"{self.vasp_optimized_dir}/{vasp_dir}/fine/final",
-                )
+                try:
+                    shutil.copytree(
+                        f"{task_dir}/{vasp_dir}/fine/final",
+                        f"{self.vasp_optimized_dir}/{vasp_dir}/fine/final", 
+                        dirs_exist_ok=True,
+                    )
+                except FileNotFoundError:
+                    logging.error(
+                        f"No final optimization results found for {vasp_dir} in {task_dir}"
+                    )
             # 在成功完成 VASP 分步优化后，删除 4_vasp_optimized /{parent}/pop{n} 文件夹以节省空间
             shutil.rmtree(task_dir)
         if machine_inform["context_type"] == "SSHContext":
@@ -266,127 +271,6 @@ class VaspProcessing:
             shutil.rmtree(os.path.join(self.vasp_optimized_dir, parent))
         logging.info("Batch VASP optimization completed!!!")
 
-    def dpdisp_vasp_complete_tasks(
-        self,
-        machine: str,
-        resources: str,
-        nodes: int = 1,
-    ):
-        """
-        Based on the dpdispatcher module, prepare and submit files for optimization on remote server or local machine.
-        """
-        # 调整工作目录，减少错误发生
-        os.chdir(self.for_vasp_opt_dir)
-        # 读取machine.json和resources.json的参数
-        if machine.endswith(".json"):
-            machine = Machine.load_from_json(machine)
-        elif machine.endswith(".yaml"):
-            machine = Machine.load_from_yaml(machine)
-        else:
-            raise KeyError("Not supported machine file type")
-        if resources.endswith(".json"):
-            resources = Resources.load_from_json(resources)
-        elif resources.endswith(".yaml"):
-            resources = Resources.load_from_yaml(resources)
-        else:
-            raise KeyError("Not supported resources file type")
-        # 由于dpdispatcher对于远程服务器以及本地运行的forward_common_files的默认存放位置不同，因此需要预先进行判断，从而不改动优化脚本
-        machine_inform = machine.serialize()
-        if machine_inform["context_type"] == "SSHContext":
-            # 如果调用远程服务器，则创建二级目录
-            parent = "data/"
-        elif machine_inform["context_type"] == "LocalContext":
-            # 如果在本地运行作业，则只在后续创建一级目录
-            parent = ""
-
-        # 获取dir文件夹中所有以prefix_name开头的文件，在此实例中为POSCAR_
-        mlp_contcar_files = [
-            f for f in os.listdir(self.for_vasp_opt_dir) if f.startswith("CONTCAR_")
-        ]
-        # 创建一个嵌套列表来存储每个节点的任务并将文件平均依次分配给每个节点
-        # 例如：对于10个结构文件任务分发给4个节点的情况，则4个节点领到的任务分别[0, 4, 8], [1, 5, 9], [2, 6], [3, 7]
-        node_jobs = [[] for _ in range(nodes)]
-        for index, file in enumerate(mlp_contcar_files):
-            node_index = index % nodes
-            node_jobs[node_index].append(index)
-        task_list = []
-        for pop in range(nodes):
-            forward_files = [
-                "INCAR_1",
-                "INCAR_2",
-                "INCAR_3",
-                "POTCAR_H",
-                "POTCAR_C",
-                "POTCAR_N",
-                "POTCAR_O",
-                "sub_final.sh",
-            ]
-            backward_files = ["log", "err"]
-            # 将所有参数文件各复制一份到每个 task_dir 目录下
-            task_dir = os.path.join(self.for_vasp_opt_dir, f"{parent}pop{pop}")
-            os.makedirs(task_dir, exist_ok=True)
-            for file in forward_files:
-                shutil.copyfile(self.param_dir.joinpath(file), f"{task_dir}/{file}")
-            for job_i in node_jobs[pop]:
-                # 将分配好的POSCAR文件添加到对应的上传文件中
-                forward_files.append(mlp_contcar_files[job_i])
-                vasp_dir = mlp_contcar_files[job_i].split("CONTCAR_")[1]
-                # 每个POSCAR文件在优化后都取回对应的CONTCAR和OUTCAR输出文件
-                backward_files.append(f"{vasp_dir}/*")
-                backward_files.append(f"{vasp_dir}/fine/*")
-                backward_files.append(f"{vasp_dir}/fine/final/*")
-                shutil.copyfile(
-                    f"{self.for_vasp_opt_dir}/{mlp_contcar_files[job_i]}",
-                    f"{task_dir}/{mlp_contcar_files[job_i]}",
-                )
-
-            remote_task_dir = f"{parent}pop{pop}"
-            command = "chmod +x sub_final.sh && ./sub_final.sh"
-            task = Task(
-                command=command,
-                task_work_path=remote_task_dir,
-                forward_files=forward_files,
-                backward_files=backward_files,
-            )
-            task_list.append(task)
-
-        submission = Submission(
-            work_base=self.for_vasp_opt_dir,
-            machine=machine,
-            resources=resources,
-            task_list=task_list,
-        )
-        submission.run_submission()
-
-        # 创建用于存放优化后文件的 4_vasp_optimized 目录
-        os.makedirs(self.vasp_optimized_dir, exist_ok=True)
-        mlp_outcar_files = [
-            f for f in os.listdir(self.for_vasp_opt_dir) if f.startswith("OUTCAR_")
-        ]
-        for mlp_contcar, mlp_outcar in zip(mlp_contcar_files, mlp_outcar_files):
-            shutil.copyfile(
-                f"{self.for_vasp_opt_dir}/{mlp_contcar}",
-                f"{self.vasp_optimized_dir}/{mlp_contcar}",
-            )
-            shutil.copyfile(
-                f"{self.for_vasp_opt_dir}/{mlp_outcar}",
-                f"{self.vasp_optimized_dir}/{mlp_outcar}",
-            )
-        for pop in range(nodes):
-            # 从传回的 pop 文件夹中将结果文件取到 4_vasp_optimized 目录
-            task_dir = os.path.join(self.for_vasp_opt_dir, f"{parent}pop{pop}")
-            for job_i in node_jobs[pop]:
-                vasp_dir = mlp_contcar_files[job_i].split("CONTCAR_")[1]
-                shutil.copytree(
-                    f"{task_dir}/{vasp_dir}", f"{self.vasp_optimized_dir}/{vasp_dir}"
-                )
-            # 在成功完成 VASP 分步优化后，删除 3_for_vasp_opt/{parent}/pop{n} 文件夹以节省空间
-            shutil.rmtree(task_dir)
-        if machine_inform["context_type"] == "SSHContext":
-            # 如果调用远程服务器，则删除data级目录
-            shutil.rmtree(os.path.join(self.for_vasp_opt_dir, parent))
-        logging.info("Batch VASP optimization completed!!!")
-
     def read_vaspout_save_csv(self, molecules_prior: bool, relaxation: bool = False):
         """
         Read VASP output files in batches and save energy and density to corresponding CSV files in the directory
@@ -625,6 +509,17 @@ class VaspProcessing:
             writer.writerow(header)
             for data in datas:
                 writer.writerow(data)
+                
+        logging.info(
+            f"Maximum MLP Density: {max(mlp_densities)}, Structure Number: {numbers[mlp_densities.index(max(mlp_densities))]}"
+        )
+        logging.info(
+            f"Maximum Fine Density: {max(fine_densities)}, Structure Number: {numbers[fine_densities.index(max(fine_densities))]}"
+        )
+        if relaxation:
+            logging.info(
+                f"Maximum Final Density: {max(final_densities)}, Structure Number: {numbers[final_densities.index(max(final_densities))]}"
+            )
 
     def export_max_density_structure(self):
         """

{ion_csp-2.1.8.dist-info → ion_csp-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ion_CSP
-Version: 2.1.8
+Version: 2.2.0
 Summary: Crystal Structure Design Software Based on Molecular/Ionic Configuration.
 Home-page: https://github.com/bagabaga007/ion_CSP
 Author: Ze Yang
@@ -28,7 +28,7 @@ Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 
-# 基于分子/离子构型的晶体结构设计软件 V2.1
+# 基于分子/离子构型的晶体结构设计软件 V2.2
 
 ## 项目概述
 

{ion_csp-2.1.8.dist-info → ion_csp-2.2.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-ion_CSP/__init__.py,sha256=9fEgjaiU5zoBKrOtVe14YmIhZJkFf_8u26EnBlod6Tw,374
+ion_CSP/__init__.py,sha256=1WGzlZrB669L2oFjKynPwf89qMUaSmlCttuR4864M_Y,356
 ion_CSP/__main__.py,sha256=XlNCx5eMSrL7yld9ddSYXhjXvg2ZYGD_uk9LdqNabvs,74
-ion_CSP/convert_SMILES.py,sha256=78StHwYm_hkP0CZhxa_AM5ywnjy6TGBNm6edyzhMTZ4,15337
-ion_CSP/empirical_estimate.py,sha256=bnV8Ak_UA5dWv-e4enChc-aAJ_2mlvtObxBZPmCbrsI,33965
+ion_CSP/convert_SMILES.py,sha256=HAexqf6HXZAqRuMww5BKmU68MIO3d7XIaUtPKv_QwMs,15595
+ion_CSP/empirical_estimate.py,sha256=aSidH3jyoG39ky-kDNUY0ix8hPefeVVWmPABVjTmy0g,37866
 ion_CSP/gen_opt.py,sha256=F_gEopuOO-b-tHfS0V4OMeThktY2QvPGWCVRXOCemfk,21605
 ion_CSP/identify_molecules.py,sha256=GxDWq815Bk_Fq_SR8fe-dbrbEi1YgATVa7UINw3hAu4,5535
 ion_CSP/log_and_time.py,sha256=Db53LAM2KH_ty6M9_5FF8xDGiULgExh7pcKOvFtS7DQ,11697
 ion_CSP/mlp_opt.py,sha256=uJaqjNYLzc4dRogNcGIP_Ukta_fMd5YdYVf9cNweOA4,7029
 ion_CSP/read_mlp_density.py,sha256=KwVgniroT46uFQ7_HROd5Fk9YxJCMip1jnufWvHHEiw,12104
 ion_CSP/steps_opt_monitor.sh,sha256=1klPjnK0gqkDbvI9PtjdK5qidJ5G0Mo8q1SfrlLW5xM,3330
-ion_CSP/task_manager.py,sha256=-tZXcK9S2igh--K_Ry_SSk0w4UEI6rqu4L48FIRUNyk,16576
+ion_CSP/task_manager.py,sha256=JglPNDKpsv-bjbCm42D4k6GegDkSylX4oDWAdFa-oSU,16569
 ion_CSP/upload_download.py,sha256=HXxVQMUydEoHe2vV89wR7De4Ut1lEte6pmp8Q82decI,23800
-ion_CSP/vasp_processing.py,sha256=fuDqJU7vy3TGbvPFJMBXgN2C-VFCndcdkWCMJ0DqHfE,33249
+ion_CSP/vasp_processing.py,sha256=Q4OotC5eK4RN4R3GZu5DnLk7wnkYSh-yC1oeGvrtT5U,28436
 ion_CSP/model/model.pt,sha256=5D9HTP5b7jUOv3kHltT71ORzhgt5p96awjbqC4oZVjQ,24649402
 ion_CSP/model/options/README.md,sha256=ifoeNXF2CfwqUjt3Xmh5qUl-e4hfP4eMV4EkqV7GU30,182
 ion_CSP/model/options/model.ckpt-4000000.pt,sha256=5D9HTP5b7jUOv3kHltT71ORzhgt5p96awjbqC4oZVjQ,24649402
@@ -28,16 +28,16 @@ ion_CSP/param/sub_ori.sh,sha256=JBERlc-VOVCNaKGwiJR8oq7Nyf0KV4JpHEVT5sE5s8E,2497
 ion_CSP/param/sub_supple.sh,sha256=23cam7WyW7-80J8O-Bs45qYkabk3mxZDgiHZvf48KBM,1887
 ion_CSP/run/__init__.py,sha256=_9EAXp4cv41ARbxahCkihwqY4F00Y18tBeTauWeD9mw,186
 ion_CSP/run/main_CSP.py,sha256=UaYHlh7BSxar4uGppPi-V0cFDpB14212Oy6gta59LfA,5898
-ion_CSP/run/main_EE.py,sha256=4L0VbbgUaYaDJM-6EjffphxMoWAHaZchEaSCVJxsdls,6345
+ion_CSP/run/main_EE.py,sha256=8TFlJx7QhJKGc4qZ2O0ESRYrlySp3r1WjeGLkUBeL5k,6217
 ion_CSP/run/run_convert_SMILES.py,sha256=85a8-UXPxPo3Yw_iYED_QF47yNTvYRnJHm3PC1d-d_Q,2056
 ion_CSP/run/run_empirical_estimate.py,sha256=U_yvQ5gMiBkDEabHXLJSAEm0EzGHhSKs6xmWoEC_gjc,2831
 ion_CSP/run/run_gen_opt.py,sha256=_Zcsu0FkuZTfiGKSWNaK17LiyQ3qrP30F66UN5QemCo,2727
 ion_CSP/run/run_read_mlp_density.py,sha256=aSJjWS1jH-D7qzx7RnpMPSTH7KEZp2b35dg1b2OQSCM,1864
 ion_CSP/run/run_upload_download.py,sha256=wuTAdy4bgdduD7TJtgHwo_fTpHKlkAwmgRknClDLYDo,2436
 ion_CSP/run/run_vasp_processing.py,sha256=hziE4cZwmIWvVaZtwHn9Dl35apYSLlMvSVIbCyd5mFg,1612
-ion_csp-2.1.8.dist-info/licenses/LICENSE,sha256=yeL9PshY_rGAt3GKqn8U7NafHifpmZipb-Owu0DDrHo,1070
-ion_csp-2.1.8.dist-info/METADATA,sha256=w6C2UdafCraaU8Cl-5kPRC6Q0BXAPZ8AzQ2anwCeAIg,6314
-ion_csp-2.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ion_csp-2.1.8.dist-info/entry_points.txt,sha256=NexQJDs9f69kJA2DgoU6tsA3V8a66nadJRem1U_c_6g,54
-ion_csp-2.1.8.dist-info/top_level.txt,sha256=aYZa43dDebjLpWPN6bDIlBb6BVwA8gk4ajEjDDK9b9I,8
-ion_csp-2.1.8.dist-info/RECORD,,
+ion_csp-2.2.0.dist-info/licenses/LICENSE,sha256=yeL9PshY_rGAt3GKqn8U7NafHifpmZipb-Owu0DDrHo,1070
+ion_csp-2.2.0.dist-info/METADATA,sha256=7vO9oy9g9NEA_XQWdWBZSXda1VxTcE8NzuyCvr06VQ8,6314
+ion_csp-2.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ion_csp-2.2.0.dist-info/entry_points.txt,sha256=NexQJDs9f69kJA2DgoU6tsA3V8a66nadJRem1U_c_6g,54
+ion_csp-2.2.0.dist-info/top_level.txt,sha256=aYZa43dDebjLpWPN6bDIlBb6BVwA8gk4ajEjDDK9b9I,8
+ion_csp-2.2.0.dist-info/RECORD,,