pwact 0.1.28__tar.gz → 0.2.1__tar.gz

pwact-0.2.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: pwact
+Version: 0.2.1
+Summary: PWACT is an open-source automated active learning platform based on PWMLFF for efficient data sampling.
+Home-page: https://github.com/LonxunQuantum/PWact
+Author: LonxunQuantum
+Author-email: lonxun@pwmat.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Dependencies
+
+Please refer to the [`user manual`](http://doc.lonxun.com/PWMLFF/pwact/)

pwact-0.2.1/README.md

@@ -0,0 +1,3 @@
+# Dependencies
+
+Please refer to the [`user manual`](http://doc.lonxun.com/PWMLFF/pwact/)

pwact-0.2.1/pwact/active_learning/environment.py

@@ -0,0 +1,18 @@
+import subprocess
+import pkg_resources
+def check_envs():
+    # for pwmat
+    comm_info()
+
+def comm_info():
+    print("\n" + "=" * 50) 
+    print("         PWACT Basic Information")
+    print("=" * 50) 
+    print("Version: 0.2.0")
+    print("Compatible pwdata: >= 0.5.0")
+    print("Compatible MatPL: >= 2025.3")
+    print("Contact: support@pwmat.com")
+    print("Citation: https://github.com/LonxunQuantum/MatPL")
+    print("Manual online: http://doc.lonxun.com/PWMLFF/")
+    print("=" * 50)  
+    print("\n\n")

{pwact-0.1.28 → pwact-0.2.1}/pwact/active_learning/explore/run_model_md.py

@@ -30,8 +30,10 @@ from pwact.utils.draw.hist_model_devi import draw_hist_list
 from pwact.utils.app_lib.lammps import make_lammps_input
 from pwact.data_format.configop import save_config, get_atom_type
 
+from pwdata import Config
 import os
 import glob
+import numpy as np
 import pandas as pd
 """
 md_dir:
@@ -66,11 +68,13 @@ class Explore(object):
         self.explore_dir = os.path.join(self.input_param.root_dir, itername, TEMP_STRUCTURE.tmp_run_iter_dir, AL_STRUCTURE.explore)
         self.md_dir = os.path.join(self.explore_dir, EXPLORE_FILE_STRUCTURE.md)
         self.select_dir = os.path.join(self.explore_dir, EXPLORE_FILE_STRUCTURE.select)
+        self.direct_dir = os.path.join(self.explore_dir, EXPLORE_FILE_STRUCTURE.direct)
         self.kpu_dir = os.path.join(self.explore_dir, EXPLORE_FILE_STRUCTURE.kpu) # for kpu calculate
        
         self.real_explore_dir = os.path.join(self.input_param.root_dir, itername, AL_STRUCTURE.explore)
         self.real_md_dir = os.path.join(self.real_explore_dir, EXPLORE_FILE_STRUCTURE.md)
         self.real_select_dir = os.path.join(self.real_explore_dir, EXPLORE_FILE_STRUCTURE.select)
+        self.real_direct_dir = os.path.join(self.real_explore_dir, EXPLORE_FILE_STRUCTURE.direct)
         self.real_kpu_dir = os.path.join(self.real_explore_dir, EXPLORE_FILE_STRUCTURE.kpu) # for kpu calculate
 
     def back_explore(self):
@@ -334,6 +338,14 @@ class Explore(object):
                     os.path.join(self.select_dir, "model_devi_distribution-{}.png".format(os.path.basename(md_sys_dir)))
                 )
         copy_dir(self.select_dir, self.real_select_dir)
+        if self.input_param.strategy.direct:
+            # delete nouse files
+            del_file_list_by_patten(self.direct_dir, "slurm-*")
+            del_file_list_by_patten(self.direct_dir, "*tag*")
+            # copy direct dir
+            copy_dir(source_dir=self.direct_dir,
+                    target_dir=self.real_direct_dir)
+            
     
     '''
     description: 
@@ -369,4 +381,102 @@ class Explore(object):
         print("Image select result:\n {}\n\n".format(summary_info))
         return summary
 
+    
+    def make_drct_work(self):
+        md_work_list = []
+        # read candidate.csv
+        candidate = pd.read_csv(os.path.join(self.select_dir, EXPLORE_FILE_STRUCTURE.candidate))
+        # make scf work dir
+        image_list = None
+        for index, row in candidate.iterrows():
+            config_index    = int(row["config_index"])
+            sub_md_sys_path = row["file_path"]
+            atom_names = None
+            with open(os.path.join(sub_md_sys_path, LAMMPS.atom_type_file), 'r') as rf:
+                line = rf.readline()
+                atom_names = line.split()
+            if image_list is None:
+                image_list = Config(data_path=os.path.join(sub_md_sys_path, EXPLORE_FILE_STRUCTURE.traj, "{}{}".format(config_index, LAMMPS.traj_postfix)), 
+                                    format=PWDATA.lammps_dump, atom_names=atom_names)
+            else:
+                image_list.append(Config(data_path=os.path.join(sub_md_sys_path, EXPLORE_FILE_STRUCTURE.traj, "{}{}".format(config_index, LAMMPS.traj_postfix)), 
+                                    format=PWDATA.lammps_dump, atom_names=atom_names))
+        # cvt_lammps.dump to extxyz
+        image_list.to(data_path=self.direct_dir, format=PWDATA.extxyz, data_name="{}".format(EXPLORE_FILE_STRUCTURE.candidate_xyz))
+        # copy direct script
+        copy_file(self.input_param.strategy.direct_script, os.path.join(self.direct_dir, os.path.basename(self.input_param.strategy.direct_script)))
+        # make direct work slurm file
+                           
+        self.make_drct_slurm_jobs([self.direct_dir])
+
+    def make_drct_slurm_jobs(self, md_work_list:list[str]):
+        # delete old job file
+        del_file_list_by_patten(self.direct_dir, "*{}".format(EXPLORE_FILE_STRUCTURE.direct_job))
+        group_list = split_job_for_group(1, md_work_list, 1)
+        for g_index, group in enumerate(group_list):
+            if group[0] == "NONE":
+                continue
+            jobname = "direct{}".format(g_index)
+            tag_name = "{}-{}".format(g_index, EXPLORE_FILE_STRUCTURE.direct_tag)
+            tag = os.path.join(self.direct_dir, tag_name)
+
+            run_cmd = self.resource.direct_resource.command
+
+            group_slurm_script = set_slurm_script_content(
+                            gpu_per_node=self.resource.direct_resource.gpu_per_node, 
+                            number_node = self.resource.direct_resource.number_node, #1
+                            cpu_per_node = self.resource.direct_resource.cpu_per_node,
+                            queue_name = self.resource.direct_resource.queue_name,
+                            custom_flags = self.resource.direct_resource.custom_flags,
+                            env_script = self.resource.direct_resource.env_script,
+                            job_name = jobname,
+                            run_cmd_template = run_cmd,
+                            group = group,
+                            job_tag = tag,
+                            task_tag = EXPLORE_FILE_STRUCTURE.direct_tag,
+                            task_tag_faild = EXPLORE_FILE_STRUCTURE.direct_tag_faild,
+                            parallel_num=self.resource.direct_resource.parallel_num,
+                            check_type=None
+                            )
+            slurm_script_name = "{}-{}".format(g_index, EXPLORE_FILE_STRUCTURE.direct_job)
+            slurm_job_file = os.path.join(self.direct_dir, slurm_script_name)
+            write_to_file(slurm_job_file, group_slurm_script, "w")
+
+    def do_drct_jobs(self):
+        mission = Mission()
+        slurm_remain, slurm_success = get_slurm_job_run_info(self.direct_dir, \
+            job_patten="*-{}".format(EXPLORE_FILE_STRUCTURE.direct_job), \
+            tag_patten="*-{}".format(EXPLORE_FILE_STRUCTURE.direct_tag))
+        # for slurm remain, check if tags done
+        slurm_done = True if len(slurm_remain) == 0 and len(slurm_success) > 0 else False
+        if slurm_done is False:
+            slurm_remain = recheck_slurm_by_jobtag(slurm_remain, EXPLORE_FILE_STRUCTURE.md_tag)
+        if len(slurm_remain) > 0:
+            #recover slurm jobs
+            if len(slurm_remain) > 0:
+                print("Run these MD Direct Jobs:\n")
+                print(slurm_remain)
+                for i, script_path in enumerate(slurm_remain):
+                    slurm_job = SlurmJob()
+                    tag_name = "{}-{}".format(os.path.basename(script_path).split('-')[0].strip(), EXPLORE_FILE_STRUCTURE.direct_tag)
+                    tag = os.path.join(os.path.dirname(script_path),tag_name)
+                    slurm_job.set_tag(tag, job_type=SLURM_JOB_TYPE.direct)
+                    slurm_job.set_cmd(script_path)
+                    mission.add_job(slurm_job)
+
+            if len(mission.job_list) > 0:
+                mission.commit_jobs()
+                mission.check_running_job()
+                mission.all_job_finished()
+    
+    def post_drct(self):
+        select_idx = np.loadtxt(os.path.join(self.direct_dir, "{}".format(EXPLORE_FILE_STRUCTURE.select_idx)))
+        count = 0
+        with open(os.path.join(self.direct_dir, EXPLORE_FILE_STRUCTURE.candidate_xyz), 'r') as file:
+            for line in file:
+                count += line.count("Lattice")
         
+        summary = "Direct selection: Before : {} configs, After : {} selected.\n\n".format(select_idx.shape[0], count)
+        write_to_file(os.path.join(self.input_param.root_dir, EXPLORE_FILE_STRUCTURE.iter_select_file), summary, mode='a')
+        print(summary)
+        return summary

{pwact-0.1.28 → pwact-0.2.1}/pwact/active_learning/explore/select_image.py

@@ -90,6 +90,11 @@ def select_image(
     accurate_pd =None
     rand_candi =None
     remove_candi =None
+    
+    error_pd = pd.DataFrame(columns=EXPLORE_FILE_STRUCTURE.devi_columns)
+    accurate_pd = pd.DataFrame(columns=EXPLORE_FILE_STRUCTURE.devi_columns)
+    rand_candi = pd.DataFrame(columns=EXPLORE_FILE_STRUCTURE.devi_columns)
+    remove_candi = pd.DataFrame(columns=EXPLORE_FILE_STRUCTURE.devi_columns)
 
     for md in md_sys_dict.keys():
         sys_dict = md_sys_dict[md]
@@ -104,10 +109,10 @@ def select_image(
                 _lower = lower
                 _higer = higer
             tmp_error_pd, tmp_accurate_pd, tmp_rand_candi, tmp_remove_candi = select_pd(tmp_devi_pd, _lower, _higer, select_num)
-            error_pd = pd.concat([error_pd, tmp_error_pd]) if error_pd is not None else tmp_error_pd
-            accurate_pd = pd.concat([accurate_pd, tmp_accurate_pd]) if error_pd is not None else tmp_accurate_pd
-            rand_candi = pd.concat([rand_candi, tmp_rand_candi]) if error_pd is not None else tmp_rand_candi
-            remove_candi = pd.concat([remove_candi, tmp_remove_candi]) if error_pd is not None else tmp_remove_candi
+            error_pd = pd.concat([error_pd, tmp_error_pd])
+            accurate_pd = pd.concat([accurate_pd, tmp_accurate_pd])
+            rand_candi = pd.concat([rand_candi, tmp_rand_candi])
+            remove_candi = pd.concat([remove_candi, tmp_remove_candi])
     right_md, error_md = count_mdstop_info(model_devi_files)
     md_run_info = "A total of {} MD trajectories were run. with {} trajectories correctly executed and {} trajectories normally completed. \nFor detailed information, refer to File {}.".format(len(right_md) + len(error_md), len(right_md), len(error_md), EXPLORE_FILE_STRUCTURE.md_traj_error_record)
     
@@ -245,7 +250,7 @@ def count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi, md_run
         format(error_pd.shape[0], EXPLORE_FILE_STRUCTURE.failed)
     if md_run_info is not None:
         summary_info += md_run_info
-        summary_info += "\n\n"
+        summary_info += "\n"
 
         summary += md_run_info 
         summary += "\n"

pwact-0.2.1/pwact/active_learning/init_bulk/direct.py

@@ -0,0 +1,182 @@
+"""
+    do md with bigmodel
+    --/work_path/
+    ------------/relax
+    -----------------/*_init_config/*_init_.config, etot.input, pseudo files, final.config, mvms_relax
+    ------------/super_cell_scale
+    -----------------/*_init_config/scale.config, from final.config or *_init_.config
+    ------------/perturb
+    --------------------/*_init_config/scale.config or final.config
+    ----------------------------------/structures/*.config_perturb
+    
+    ------------/AIMD
+    -----------------/*_init_config/*_config_dir the config file from pertub or *_init_.config
+    -------------------------------/etot.input, atom.config, ...
+    or
+    ------------/BIGMODEL
+    -----------------/*_init_config/*_config_dir the config file from pertub or *_init_.config
+    -------------------------------/bigmodel_md_script.py, POSCAR, ...
+    ------------/DIRECT
+    -----------------/*_init_config/*_config_dir the config file from pertub or *_init_.config
+    -------------------------------/direct_script.py, POSCAR, ...
+
+    -----------/result
+    -----------------/*_init_config/relax_mvm_*_init_config if need; aimd_mvm_*_init_config if need
+    
+"""
+import os
+
+from pwact.active_learning.user_input.resource import Resource
+from pwact.active_learning.user_input.init_bulk_input import InitBulkParam
+from pwact.active_learning.init_bulk.duplicate_scale import get_config_files_with_order
+
+from pwact.utils.constant import PWMAT, INIT_BULK, TEMP_STRUCTURE, SLURM_OUT, DFT_STYLE
+from pwact.active_learning.slurm.slurm import SlurmJob, Mission
+from pwact.utils.slurm_script import get_slurm_job_run_info, split_job_for_group, set_slurm_script_content
+    
+from pwact.utils.file_operation import write_to_file, link_file, del_file_list_by_patten, copy_file
+from pwact.utils.app_lib.common import link_pseudo_by_atom, set_input_script
+from pwact.data_format.configop import save_config, get_atom_type
+
+class DIRECT(object):
+    def __init__(self, resource: Resource, input_param:InitBulkParam):
+        self.resource = resource
+        self.input_param = input_param
+        self.init_configs = self.input_param.sys_config
+        self.relax_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.relax)
+        self.super_cell_scale_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.super_cell_scale)
+        self.pertub_dir = os.path.join(self.input_param.root_dir,TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.pertub)
+        self.bigmodel_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.bigmodel)
+        self.real_bigmodel_dir = os.path.join(self.input_param.root_dir, INIT_BULK.bigmodel)
+        self.direct_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.direct)
+        self.real_direct_dir = os.path.join(self.input_param.root_dir, INIT_BULK.direct)
+  
+    def make_bigmodel_work(self):
+        bigmodel_paths = []
+        for init_config in self.init_configs:
+            if init_config.bigmodel is False:
+                continue
+            init_config_name = "init_config_{}".format(init_config.config_index)
+            # config_list, config_type = get_config_files_with_order(self.super_cell_scale_dir, self.relax_dir, init_config_name, init_config.config, self.pertub_dir)
+            config_list, config_type = get_config_files_with_order(
+            super_cell_scale_dir=self.super_cell_scale_dir,
+            relax_dir=self.relax_dir,
+            init_config_dirname=init_config_name, 
+            init_config_path=init_config.config_file, 
+            pertub_dir=self.pertub_dir,
+            dft_style=self.resource.dft_style
+            )
+
+            for index, config in enumerate(config_list):
+                if config_type == INIT_BULK.pertub:
+                    tmp_config_dir = os.path.basename(os.path.basename(os.path.dirname(config)))
+                elif config_type == INIT_BULK.super_cell or config_type == INIT_BULK.scale:
+                    tmp_config_dir = os.path.basename(config).replace(DFT_STYLE.get_postfix(self.resource.dft_style), "")
+                elif config_type == INIT_BULK.relax:
+                    tmp_config_dir = INIT_BULK.relax
+                else:
+                    tmp_config_dir = INIT_BULK.init
+                bigmodel_dir = os.path.join(self.bigmodel_dir, init_config_name, tmp_config_dir, "{}_{}".format(index, INIT_BULK.bigmodel))
+                if not os.path.exists(bigmodel_dir):
+                    os.makedirs(bigmodel_dir)
+                
+                self.make_bigmodel_file(
+                    bigmodel_dir=bigmodel_dir, 
+                    config_file=config, 
+                    conifg_format=DFT_STYLE.get_format_by_postfix(os.path.basename(config)), 
+                    input_file=init_config.bigmodel_input_file)
+
+                bigmodel_paths.append(bigmodel_dir)
+        # make slurm script and slurm job
+        self.make_bigmodel_slurm_job_files(bigmodel_paths)
+    
+    def check_work_done(self):
+        slurm_remain, slurm_success = get_slurm_job_run_info(self.bigmodel_dir, \
+            job_patten="*-{}".format(INIT_BULK.bigmodel_job), \
+            tag_patten="*-{}".format(INIT_BULK.bigmodel_tag))
+        slurm_done = True if len(slurm_remain) == 0 and len(slurm_success) > 0 else False # len(slurm_remain) > 0 exist slurm jobs need to do
+        return slurm_done
+            
+    def do_bigmodel_jobs(self):
+        mission = Mission()
+        slurm_remain, slurm_success = get_slurm_job_run_info(self.bigmodel_dir, \
+            job_patten="*-{}".format(INIT_BULK.bigmodel_job), \
+            tag_patten="*-{}".format(INIT_BULK.bigmodel_tag))
+        slurm_done = True if len(slurm_remain) == 0 and len(slurm_success) > 0 else False # len(slurm_remain) > 0 exist slurm jobs need to do
+        if slurm_done is False:
+            #recover slurm jobs
+            if len(slurm_remain) > 0:
+                print("Run these bigmodel Jobs:\n")
+                print(slurm_remain)
+                for i, script_path in enumerate(slurm_remain):
+                    slurm_job = SlurmJob()
+                    tag_name = "{}-{}".format(os.path.basename(script_path).split('-')[0].strip(), INIT_BULK.bigmodel_tag)
+                    tag = os.path.join(os.path.dirname(script_path),tag_name)
+                    slurm_job.set_tag(tag)
+                    slurm_job.set_cmd(script_path)
+                    mission.add_job(slurm_job)
+
+            if len(mission.job_list) > 0:
+                mission.commit_jobs()
+                mission.check_running_job()
+                mission.all_job_finished()
+                # mission.move_slurm_log_to_slurm_work_dir()
+
+    '''
+    description: 
+        input_file is aimd input control file, for vasp is incar, for pwmat is etot.input
+    return {*}
+    author: wuxingxing
+    '''    
+    def make_bigmodel_file(
+            bigmodel_dir=str, 
+            config_file=str, 
+            conifg_format=str, 
+            input_file=str):
+        #1. set config file, cvt to poscar format
+        target_config = save_config(config=config_file, 
+                            input_format=conifg_format,
+                            wrap = False, 
+                            direct = True, 
+                            sort = True, 
+                            save_format=DFT_STYLE.poscar, 
+                            save_path=bigmodel_dir, 
+                            save_name=DFT_STYLE.get_normal_config(DFT_STYLE.vasp)
+                            )
+
+        atom_type_list, _ = get_atom_type(config_file, conifg_format)
+        #2. copy script file
+        copy_file(input_file, os.path.join(bigmodel_dir, os.path.basename(input_file)))
+
+    def make_bigmodel_slurm_job_files(self, bigmodel_dir_list:list[str]):
+        del_file_list_by_patten(self.bigmodel_dir, "*{}".format(INIT_BULK.bigmodel_job))
+        group_list = split_job_for_group(self.resource.explore_resource.group_size, bigmodel_dir_list, self.resource.explore_resource.parallel_num)
+        for group_index, group in enumerate(group_list):
+            if group[0] == "NONE":
+                continue
+            jobname = "bigmodel{}".format(group_index)
+            tag_name = "{}-{}".format(group_index, INIT_BULK.bigmodel_tag)
+            tag = os.path.join(self.bigmodel_dir, tag_name)
+            run_cmd = self.resource.explore_resource.command
+            group_slurm_script = set_slurm_script_content(gpu_per_node=self.resource.explore_resource.gpu_per_node, 
+                number_node = self.resource.explore_resource.number_node, 
+                cpu_per_node = self.resource.explore_resource.cpu_per_node,
+                queue_name = self.resource.explore_resource.queue_name,
+                custom_flags = self.resource.explore_resource.custom_flags,
+                env_script = self.resource.explore_resource.env_script,
+                job_name = jobname,
+                run_cmd_template = run_cmd,
+                group = group,
+                job_tag = tag,
+                task_tag = INIT_BULK.bigmodel_tag, 
+                task_tag_faild = INIT_BULK.bigmodel_tag_failed,
+                parallel_num=self.resource.dft_resource.parallel_num,
+                check_type=self.resource.dft_style
+                )
+            slurm_script_name = "{}-{}".format(group_index, INIT_BULK.bigmodel_job)
+            slurm_job_file =  os.path.join(self.bigmodel_dir, slurm_script_name)
+            write_to_file(slurm_job_file, group_slurm_script, "w")
+
+    def do_post_process(self):
+        if os.path.exists(self.bigmodel_dir):
+            link_file(self.bigmodel_dir, self.real_bigmodel_dir)

{pwact-0.1.28 → pwact-0.2.1}/pwact/active_learning/init_bulk/duplicate_scale.py

@@ -1,5 +1,5 @@
 import os
-
+import bisect
 from pwact.utils.file_operation import search_files, link_file, copy_file, write_to_file
 from pwact.utils.constant import INIT_BULK, DFT_STYLE, TEMP_STRUCTURE