ion-CSP 2.0.8__py3-none-any.whl → 2.1.3__py3-none-any.whl

ion_CSP/__init__.py

@@ -1,8 +1,19 @@
-from importlib.metadata import version, PackageNotFoundError
+__author__ = "Ze Yang"
+__contact__ = "yangze1995007@163.com"
+__license__ = "MIT"
+__version__ = "2.1.3"
+__date__ = "2025-06-11"
+
 
 try:
-    __version__ = version("binary4fun")
-except PackageNotFoundError:
-    __version__ = "unknown version"
+    from importlib.metadata import version  # python >= 3.11
+except Exception:
+    try:
+        from importlib_metadata import version
+    except Exception:
+        pass
 
-name = "ion_CSP"
+try:
+    __version__ = version("ion_CSP")
+except Exception:
+    pass

ion_CSP/log_and_time.py

@@ -3,17 +3,24 @@ import sys
 import time
 import yaml
 import signal
+import inspect
 import logging
 import argparse
+import functools
 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):
+    @functools.wraps(func)
+    def wrapper(work_dir, *args, **kwargs):
+        # 使用inspect获取真实脚本文件名
+        module = inspect.getmodule(func)
+        script_path = module.__file__ if module else __file__
+        script_name = os.path.splitext(os.path.basename(script_path))[0]
         # 获取脚本所在目录, 在该目录下生成日志
         log_file_path = os.path.join(work_dir, f"{script_name}_output.log")
+        print(f"Log file path: {log_file_path}")
         # 配置日志记录
         logging.basicConfig(
             filename=log_file_path,  # 日志文件名
@@ -32,7 +39,7 @@ def log_and_time(func):
             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."
+            f"The script {script_name} has run successfully, and the output content has been recorded in the {script_name}_output.log file in the same directory."
         )
         # 获取程序结束时的CPU时间和Wall Clock时间
         end_cpu, end_clock = time.process_time(), time.perf_counter()
@@ -43,7 +50,6 @@ def log_and_time(func):
             f"End running: {script_name}\nWall time: {wall_time:.4f} sec, CPU time: {cpu_time:.4f} sec\n"
         )
         return result
-
     return wrapper
 
 

ion_CSP/read_mlp_density.py

@@ -81,8 +81,8 @@ class ReadMlpDensity:
         os.makedirs(self.max_density_dir, exist_ok=True)
         for density, CONTCAR_filename in sorted_filename[:n_screen]:
             # 生成新的包含密度值的文件名，并重命名文件
-            # 密度转换为字符串，保留4位小数
-            density_str = f'{density:.4f}'
+            # 密度转换为字符串，保留3位小数
+            density_str = f'{density:.3f}'
             mlp_densities.append(density_str)
             # 保留 CONTCAR 的序数信息，方便回推检查
             number = CONTCAR_filename.split("_")[1]

ion_CSP/task_manager.py

@@ -32,7 +32,7 @@ class TaskManager:
             # 使用 importlib 动态加载
             spec = importlib.util.spec_from_file_location(
                 "ion_CSP", 
-                os.path.join(self.project_root, "src/__init__.py")
+                os.path.join(self.project_root, "src/ion_CSP/__init__.py")
             )
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
@@ -47,6 +47,9 @@ class TaskManager:
             self.env = "DOCKER"
             self.workspace = Path("/app")
             self.log_dir = Path("/app/logs")
+        conda_env = os.getenv("CONDA_DEFAULT_ENV")
+        env_msg = conda_env if conda_env else "Not Conda Env"
+        self.envs = f"{self.env} ({env_msg})"
         self.workspace.mkdir(exist_ok=True)
 
     def _setup_logging(self):
@@ -224,8 +227,13 @@ class TaskManager:
         console_log = work_dir / f"main_{module}_console.log"
         pid_file = work_dir / "pid.txt"
 
+        # 动态加载模块
+        module_name = f"run.main_{module}"
+        spec = importlib.util.find_spec(module_name)
+        if not spec:
+            raise ImportError(f"Module {module_name} not found")
         # 启动子进程
-        cmd = ["python", "-m", f"src.main_{module}", str(work_dir)]
+        cmd = [sys.executable, "-m", module_name, str(work_dir)]
 
         with open(console_log, "w") as f:
             process = subprocess.Popen(
@@ -245,7 +253,7 @@ class TaskManager:
             process.terminate()
             return
         # 创建符号链接
-        output_log = work_dir / f"main_{module}.py_output.log"
+        output_log = work_dir / f"main_{module}_output.log"
         print(f"Original log file: {output_log}")
         std_log = Path(self.log_dir) / f"{module}_{process.pid}.log"
         try:
@@ -271,6 +279,9 @@ class TaskManager:
                 continue
             try:
                 file_path = log_file.resolve(strict=True)
+                if not os.path.exists(file_path):
+                    os.remove(log_file)
+                    continue
                 mtime = file_path.stat().st_mtime
                 log_tasks.append({
                     "pid": 0,  # 日志无PID
@@ -358,7 +369,7 @@ class TaskManager:
             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 Environment: {self.envs}")
             print(f"Current Directory: {self.workspace}")
             print(f"Log Base Directory: {self.log_dir}")
             print("=" * 50)

ion_CSP/vasp_processing.py

@@ -20,7 +20,7 @@ class VaspProcessing:
         self.vasp_optimized_dir = f"{work_dir}/4_vasp_optimized"
         self.param_dir = os.path.join(os.path.dirname(__file__), "../../param")
 
-    def dpdisp_vasp_tasks(
+    def dpdisp_vasp_optimization_tasks(
         self,
         machine: str,
         resources: str,
@@ -72,7 +72,7 @@ class VaspProcessing:
                 "POTCAR_C",
                 "POTCAR_N",
                 "POTCAR_O",
-                "sub.sh",
+                "sub_ori.sh",
             ]
             backward_files = ["log", "err"]
             # 将所有参数文件各复制一份到每个 task_dir 目录下
@@ -93,7 +93,7 @@ class VaspProcessing:
                 )
 
             remote_task_dir = f"{parent}pop{pop}"
-            command = "chmod +x sub.sh && ./sub.sh"
+            command = "chmod +x sub_ori.sh && ./sub_ori.sh"
             task = Task(
                 command=command,
                 task_work_path=remote_task_dir,
@@ -139,7 +139,240 @@ class VaspProcessing:
             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):
+    def dpdisp_vasp_relaxation_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.vasp_optimized_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_
+        vasp_optimized_folders = [
+            f
+            for f in os.listdir(self.vasp_optimized_dir)
+            if os.path.isdir(f) and f != "data"
+        ]
+        # 创建一个嵌套列表来存储每个节点的任务并将文件平均依次分配给每个节点
+        # 例如：对于10个结构文件任务分发给4个节点的情况，则4个节点领到的任务分别[0, 4, 8], [1, 5, 9], [2, 6], [3, 7]
+        node_jobs = [[] for _ in range(nodes)]
+        for index, file in enumerate(vasp_optimized_folders):
+            node_index = index % nodes
+            node_jobs[node_index].append(index)
+        task_list = []
+        for pop in range(nodes):
+            forward_files = [
+                "INCAR_3",
+                "POTCAR_H",
+                "POTCAR_C",
+                "POTCAR_N",
+                "POTCAR_O",
+                "sub_supple.sh",
+            ]
+            backward_files = ["log", "err"]
+            # 将所有参数文件各复制一份到每个 task_dir 目录下
+            task_dir = os.path.join(self.vasp_optimized_dir, f"{parent}pop{pop}")
+            os.makedirs(task_dir, exist_ok=True)
+            for file in forward_files:
+                shutil.copyfile(f"{self.param_dir}/{file}", f"{task_dir}/{file}")
+            for job_i in node_jobs[pop]:
+                # 将分配好的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}",
+                )
+                # 每个POSCAR文件在优化后都取回对应的CONTCAR和OUTCAR输出文件
+                backward_files.append(f"{vasp_dir}/*")
+                backward_files.append(f"{vasp_dir}/fine/*")
+                backward_files.append(f"{vasp_dir}/fine/final/*")
+
+            remote_task_dir = f"{parent}pop{pop}"
+            command = "chmod +x sub_supple.sh && ./sub_supple.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.vasp_optimized_dir,
+            machine=machine,
+            resources=resources,
+            task_list=task_list,
+        )
+        submission.run_submission()
+
+        for pop in range(nodes):
+            # 从传回的 pop 文件夹中将结果文件取到 4_vasp_optimized 目录
+            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",
+                )
+            # 在成功完成 VASP 分步优化后，删除 4_vasp_optimized /{parent}/pop{n} 文件夹以节省空间
+            shutil.rmtree(task_dir)
+        if machine_inform["context_type"] == "SSHContext":
+            # 如果调用远程服务器，则删除data级目录
+            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(f"{self.param_dir}/{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
         """
@@ -148,6 +381,7 @@ class VaspProcessing:
         numbers, mlp_densities, mlp_energies = [], [], []
         rough_densities, rough_energies = [], []
         fine_densities, fine_energies = [], []
+        final_densities, final_energies = [], []
         ions_checks, packing_coefficients = [], []
         for folder in os.listdir(vasp_opt_dir):
             vasp_opt_path = os.path.join(vasp_opt_dir, folder)
@@ -166,7 +400,7 @@ class VaspProcessing:
                         for line in lines:
                             if "TOTEN" in line:
                                 values = line.split()
-                                mlp_energy = round(float(values[-2]), 2)
+                                mlp_energy = round(float(values[-2]), 1)
                 except FileNotFoundError:
                     logging.error(
                         f"  No avalible MLP OUTCAR_{mlp_density}_{number} found"
@@ -180,8 +414,8 @@ class VaspProcessing:
                         rough_atoms.get_masses()
                     )  # 质量单位为原子质量单位(amu)
                     # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
-                    rough_density = round(1.66054 * atoms_masses / atoms_volume, 4)
-                    rough_energy = round(rough_atoms.get_total_energy(), 2)
+                    rough_density = round(1.66054 * atoms_masses / atoms_volume, 3)
+                    rough_energy = round(rough_atoms.get_total_energy(), 1)
                     logging.info(
                         f"  MLP_Density: {mlp_density}, MLP_Energy: {mlp_energy}"
                     )
@@ -211,9 +445,9 @@ class VaspProcessing:
                     )  # 质量单位为原子质量单位(amu)
                     # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
                     fine_density = round(
-                        1.66054 * fine_atoms_masses / fine_atoms_volume, 4
+                        1.66054 * fine_atoms_masses / fine_atoms_volume, 3
                     )
-                    fine_energy = round(fine_atoms.get_total_energy(), 2)
+                    fine_energy = round(fine_atoms.get_total_energy(), 1)
                     logging.info(
                         f"  Fine_Density: {fine_density}, Fine_Energy: {fine_energy}"
                     )
@@ -226,6 +460,49 @@ class VaspProcessing:
                     )
                     fine_density, fine_energy, molecules_flag = False, False, False
 
+                final_density, final_energy = (
+                    False,
+                    False,
+                )
+                if relaxation:
+                    # 读取三级目录下的 OUTCAR 文件
+                    final_OUTCAR_file_path = os.path.join(
+                        vasp_opt_path, "fine", "final", "OUTCAR"
+                    )
+                    try:
+                        final_atoms = read_vasp_out(final_OUTCAR_file_path)
+                        molecules, molecules_flag, initial_information = (
+                            identify_molecules(final_atoms)
+                        )
+                        if not initial_information:
+                            raise KeyError("No available initial molecules")
+                        final_atoms_volume = (
+                            final_atoms.get_volume()
+                        )  # 体积单位为立方埃（ų）
+                        final_atoms_masses = sum(
+                            final_atoms.get_masses()
+                        )  # 质量单位为原子质量单位(amu)
+                        # 1.66054这一转换因子用于将原子质量单位转换为克，以便在宏观尺度上计算密度g/cm³
+                        final_density = round(
+                            1.66054 * final_atoms_masses / final_atoms_volume, 3
+                        )
+                        final_energy = round(final_atoms.get_total_energy(), 1)
+                        logging.info(
+                            f"  Final_Density: {final_density}, Final_Energy: {final_energy}"
+                        )
+                        molecules_information(
+                            molecules, molecules_flag, initial_information
+                        )
+                    except (ParseError, FileNotFoundError):
+                        logging.error(
+                            f"  Unfinished final optimization job of CONTCAR_{mlp_density}_{number}"
+                        )
+                        final_density, final_energy, molecules_flag = (
+                            False,
+                            False,
+                            False,
+                        )
+
                 # 读取根目录下的 config.yaml 信息与对应的 .json 文件
                 config_path = os.path.join(self.base_dir, "config.yaml")
                 with open(config_path, "r") as file:
@@ -242,9 +519,14 @@ class VaspProcessing:
                             property = json.load(file)
                         molecular_volume = float(property["volume"])
                         molecular_volumes += molecular_volume * count
-                    packing_coefficient = round(
-                        molecular_volumes / fine_atoms_volume, 4
-                    )
+                    if relaxation:
+                        packing_coefficient = round(
+                            molecular_volumes / final_atoms_volume, 3
+                        )
+                    else:
+                        packing_coefficient = round(
+                            molecular_volumes / fine_atoms_volume, 3
+                        )
                 except (FileNotFoundError, UnboundLocalError):
                     packing_coefficient = False
 
@@ -253,6 +535,8 @@ class VaspProcessing:
                 rough_energies.append(rough_energy)
                 fine_densities.append(fine_density)
                 fine_energies.append(fine_energy)
+                final_densities.append(final_density)
+                final_energies.append(final_energy)
                 ions_checks.append(molecules_flag)
                 packing_coefficients.append(packing_coefficient)
 
@@ -273,6 +557,19 @@ class VaspProcessing:
                 "Fine_Density",
                 "Ions_Check",
             ]
+            if relaxation:
+                header = [
+                    "Number",
+                    "MLP_E",
+                    "Rough_E",
+                    "Fine_E",
+                    "Final_E",
+                    "MLP_Density",
+                    "Rough_Density",
+                    "Fine_Density",
+                    "Final_Density",
+                    "Ions_Check",
+                ]
             if packing_coefficients:
                 header.append("Pack_Coef")
             datas = list(
@@ -288,12 +585,82 @@ class VaspProcessing:
                     (*packing_coefficients,) if packing_coefficients else (),
                 )
             )
+            if relaxation:
+                datas = list(
+                    zip(
+                        numbers,
+                        mlp_energies,
+                        rough_energies,
+                        fine_energies,
+                        final_energies,
+                        mlp_densities,
+                        rough_densities,
+                        fine_densities,
+                        final_densities,
+                        ions_checks,
+                        (*packing_coefficients,) if packing_coefficients else (),
+                    )
+                )
             if molecules_prior:
-                # 如果设置了 molecules_prior 参数为 True，则优先第7列（从0列开始）Ions_Check 为 True 的结果，再根据第6列的 Fine_Density 降序排序
-                datas.sort(key=lambda x: (not x[7], -float(x[6])))
+                # 如果设置了 molecules_prior 参数为 True，则优先第倒数Ions_Check 为 True 的结果，再根据第6列的 Fine_Density 降序排序
+                datas.sort(key=lambda x: (not x[-2], -float(x[-3])))
             else:
                 # 否则，直接根据第6列（从0列开始）的 Fine_Density 降序排序
-                datas.sort(key=lambda x: -float(x[6]))
+                datas.sort(key=lambda x: -float(x[-3]))
             writer.writerow(header)
             for data in datas:
                 writer.writerow(data)
+
+    def export_max_density_structure(self):
+        """
+        Read the structure number from the vasp_sensitiy_energy.csv file in the results folder, then search for the corresponding folder based on that sequence number, copy the highest density and highest precision CONTCAR file, and rename it POSCAR
+        """
+        # 找到 vas_density_energy.csv 文件
+        csv_file_path = os.path.join(self.base_dir, "vasp_density_energy.csv")
+        if os.path.exists(csv_file_path):
+            # 读取 CSV 文件
+            with open(csv_file_path, "r") as csvfile:
+                reader = csv.reader(csvfile)
+                # 跳过表头读取第一行结构序号，即符合结构筛选要求的最大密度结构
+                first_row = next(reader)
+                structure_number = str(first_row[0])
+            # 根据结构序号构建要查找的文件夹路径
+            vasp_optimized_dir = os.path.join(self.base_dir, "4_vasp_optimized")
+            for vasp_folder_name in os.listdir(vasp_optimized_dir):
+                vasp_folder_path = os.path.join(vasp_optimized_dir, vasp_folder_name)
+                if os.path.isdir(vasp_folder_path) and vasp_folder_name.endswith(
+                    structure_number
+                ):
+                    # 查找 CONTCAR 文件
+                    final_contcar_path = os.path.join(
+                        vasp_folder_path, "fine", "final", "CONTCAR"
+                    )
+                    fine_contcar_path = os.path.join(
+                        vasp_folder_path, "fine", "CONTCAR"
+                    )
+                    logging.info(
+                        f"Trying to get the final structure from {vasp_folder_path}"
+                    )
+                    if os.path.exists(final_contcar_path):
+                        # 复制 CONTCAR 文件到 combo_n 文件夹并重命名为 POSCAR
+                        shutil.copy(
+                            final_contcar_path, os.path.join(self.base_dir, "POSCAR")
+                        )
+                        logging.info(
+                            f"Renamed CONTCAR to POSCAR in {self.base_dir}, copied from {final_contcar_path}"
+                        )
+                    elif os.path.exists(fine_contcar_path):
+                        logging.info(
+                            f"CONTCAR not found in {os.path.join(vasp_folder_path, 'fine', 'final')}"
+                        )
+                        # 复制 CONTCAR 文件到 combo_n 文件夹并重命名为 POSCAR
+                        shutil.copy(
+                            fine_contcar_path, os.path.join(self.base_dir, "POSCAR")
+                        )
+                        logging.info(
+                            f"Renamed CONTCAR to POSCAR in {self.base_dir}, copied from {fine_contcar_path}"
+                        )
+                    else:
+                        print(f"Eligible CONTCAR not found in {vasp_folder_path}")
+        else:
+            logging.info(f"CSV file not found in {self.base_dir}")