pwact 0.1.5__py3-none-any.whl → 0.1.9__py3-none-any.whl

pwact/active_learning/explore/run_model_md.py

@@ -48,7 +48,7 @@ class Explore(object):
         self.iter = get_iter_from_iter_name(self.itername)
         self.resource = resource
         self.input_param = input_param
-        self.sys_paths = self.input_param.explore.sys_configs
+        # self.sys_paths = self.input_param.explore.sys_configs
         self.md_job = self.input_param.explore.md_job_list[self.iter]
         # train work dir
         self.train_dir = os.path.join(self.input_param.root_dir, self.itername, TEMP_STRUCTURE.tmp_run_iter_dir, AL_STRUCTURE.train)
@@ -116,8 +116,6 @@ class Explore(object):
             jobname = "md{}".format(g_index)
             tag_name = "{}-{}".format(g_index, EXPLORE_FILE_STRUCTURE.md_tag)
             tag = os.path.join(self.md_dir, tag_name)
-            gpu_per_node = None
-            cpu_per_node = 1
 
             # if self.resource.explore_resource.gpu_per_node > 0:
             #     if self.input_param.strategy.uncertainty.upper() == UNCERTAINTY.committee.upper():
@@ -135,9 +133,9 @@ class Explore(object):
             run_cmd = self.resource.explore_resource.command
 
             group_slurm_script = set_slurm_script_content(
-                            gpu_per_node=gpu_per_node, 
+                            gpu_per_node=self.resource.explore_resource.gpu_per_node, 
                             number_node = self.resource.explore_resource.number_node, #1
-                            cpu_per_node = cpu_per_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,
@@ -188,15 +186,18 @@ class Explore(object):
                 
                         
     def set_md_files(self, md_index:int, md_dir:str, sys_index:int, temp_index:int, press_index:int, md_detail:MdDetail):
-        target_config = save_config(config=self.sys_paths[sys_index].sys_config,
-                                    input_format=self.sys_paths[sys_index].format,
+        target_config = save_config(config=md_detail.config_file_list[sys_index],
+                                    input_format=md_detail.config_file_format[sys_index],
                                     wrap = False, 
                                     direct = True, 
-                                    sort = True, 
+                                    sort = False, 
                                     save_format=PWDATA.lammps_lmp, 
                                     save_path=md_dir, 
                                     save_name=LAMMPS.lammps_sys_config)
-
+        # import dpdata
+        # _config = dpdata.System(md_detail.config_file_list[sys_index], fmt=md_detail.config_file_format[sys_index])
+        # target_config = os.path.join(md_dir, LAMMPS.lammps_sys_config)
+        # _config.to("lammps/lmp", target_config, frame_idx=0)
         #2. set forcefiled file
         md_model_paths = self.set_forcefiled_file(md_dir)
         
@@ -204,7 +205,7 @@ class Explore(object):
         input_lammps_file = os.path.join(md_dir, LAMMPS.input_lammps)
         press=md_detail.press_list[press_index] if press_index is not None else None
         # get atom type
-        atom_type_list, atomic_number_list = get_atom_type(self.sys_paths[sys_index].sys_config, self.sys_paths[sys_index].format)
+        atom_type_list, atomic_number_list = get_atom_type(md_detail.config_file_list[sys_index], md_detail.config_file_format[sys_index])
         atom_type_file = os.path.join(md_dir, LAMMPS.atom_type_file)
         write_to_file(atom_type_file, " ".join(atom_type_list), "w")
         restart_file = search_files(md_dir, "lmps.restart.*")

pwact/active_learning/init_bulk/aimd.py

@@ -150,7 +150,8 @@ class AIMD(object):
             # link in.skf path to aimd dir
             pseudo_names = []
             target_dir = os.path.join(aimd_dir, PWMAT.in_skf)
-            link_file(in_skf, target_dir)
+            if in_skf is not None:
+                link_file(in_skf, target_dir)
         #3. make dft input file
         set_input_script(
             input_file=input_file,

pwact/active_learning/init_bulk/init_bulk_run.py

@@ -4,6 +4,7 @@ from pwact.active_learning.init_bulk.relax import Relax
 from pwact.active_learning.init_bulk.duplicate_scale import do_pertub_work, do_post_pertub, pertub_done, \
     duplicate_scale_done, duplicate_scale, do_post_duplicate_scale
 from pwact.active_learning.init_bulk.aimd import AIMD
+from pwact.active_learning.init_bulk.relabel import Relabel
 from pwact.active_learning.user_input.init_bulk_input import InitBulkParam
 from pwact.active_learning.user_input.resource import Resource
 
@@ -39,7 +40,14 @@ def init_bulk_run(resource: Resource, input_param:InitBulkParam):
             aimd.make_aimd_work()
             aimd.do_aimd_jobs()
             aimd.do_post_process()
-    # do collection
+
+    # do relabel
+    if input_param.is_scf:
+        relabel = Relabel(resource, input_param)
+        if not relabel.check_work_done():
+            relabel.make_scf_work()
+            relabel.do_scf_jobs()
+            relabel.do_post_process()
     do_collection(resource, input_param)
        
 def do_collection(resource: Resource, input_param:InitBulkParam):
@@ -56,7 +64,11 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
     real_duplicate_scale_dir = os.path.join(input_param.root_dir, INIT_BULK.super_cell_scale) 
     real_pertub_dir = os.path.join(input_param.root_dir, INIT_BULK.pertub)
     real_aimd_dir = os.path.join(input_param.root_dir, INIT_BULK.aimd)
+
+    relabel_dir = os.path.join(input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.scf)
+    real_relabel_dir = os.path.join(input_param.root_dir, INIT_BULK.scf)
     
+        
     for init_config in init_configs:
         init_config_name = "init_config_{}".format(init_config.config_index)
         
@@ -97,7 +109,25 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
                     train_valid_ratio=input_param.train_valid_ratio, 
                     data_shuffle=input_param.data_shuffle, 
                     merge_data=True,
-                    interval=input_param.interval
+                    interval=1
+                )
+
+        #6 convert relabel datas
+        if init_config.scf:
+            source_scf = search_files(os.path.join(relabel_dir, init_config_name),\
+                 "*/*/*/{}".format(DFT_STYLE.get_aimd_config(resource.scf_style)))
+                 # init/0-aimd/0-scf/OUTCAR
+            if len(source_aimd) == 0:
+                continue
+            source_scf = sorted(source_scf, key=lambda x:int(os.path.basename(os.path.dirname(x)).split('-')[0]), reverse=False)
+            #5. convert the aimd files (for vasp is outcar, for pwmat is movement) to npy format
+            extract_pwdata(data_list=source_scf, 
+                    data_format=DFT_STYLE.get_format_by_postfix(os.path.basename(source_scf[0])),
+                    datasets_path=os.path.join(collection_dir, init_config_name, "scf_pwdata"), 
+                    train_valid_ratio=input_param.train_valid_ratio, 
+                    data_shuffle=input_param.data_shuffle, 
+                    merge_data=True,
+                    interval=1
                 )
 
     # delete link files
@@ -105,6 +135,7 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
     del_file(real_duplicate_scale_dir)
     del_file(real_pertub_dir)
     del_file(real_aimd_dir)
+    del_file(real_relabel_dir)
 
     # copy collection file to target
     copy_dir(collection_dir, real_collection_dir)
@@ -113,7 +144,7 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
         temp_work_dir = os.path.join(input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir)
         del_file_list([temp_work_dir])
 
-    # print the dir of pwdatas
+    # print the dir of pwdatas from aimd
     pwdatas = search_files(real_collection_dir, "*/{}".format(INIT_BULK.npy_format_save_dir))
     if len(pwdatas) > 0:
         pwdatas = sorted(pwdatas)
@@ -122,4 +153,14 @@ def do_collection(resource: Resource, input_param:InitBulkParam):
         # result_lines = result_lines[:-1] # Filter the last ','
         result_save_path = os.path.join(real_collection_dir, INIT_BULK.npy_format_name)
         write_to_file(result_save_path, result_lines, mode='w')
-        
+    
+    # print the dir of relabel_pwdatas from relabel
+    relebel_datas = search_files(real_collection_dir, "*/{}".format("scf_pwdata"))
+    if len(relebel_datas) > 0:
+        pwdatas = sorted(relebel_datas)
+        result_lines = ["\"{}\",".format(_) for _ in pwdatas]
+        result_lines = "\n".join(result_lines)
+        # result_lines = result_lines[:-1] # Filter the last ','
+        result_save_path = os.path.join(real_collection_dir, "scf_pwdata")
+        write_to_file(result_save_path, result_lines, mode='w')
+    

pwact/active_learning/init_bulk/relabel.py

@@ -0,0 +1,200 @@
+"""
+    realx dor strcuture
+    --/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, ...
+    -----------/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 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, search_files
+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, load_config
+
+class Relabel(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.aimd_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.aimd)
+        self.real_aimd_dir = os.path.join(self.input_param.root_dir, INIT_BULK.aimd)
+        
+        self.scf_dir = os.path.join(self.input_param.root_dir, TEMP_STRUCTURE.tmp_init_bulk_dir, INIT_BULK.scf)
+        self.real_scf_dir = os.path.join(self.input_param.root_dir, INIT_BULK.scf)
+       
+    def make_scf_work(self):
+        scf_paths = []
+        use_dftb = False
+        for init_config in self.init_configs:
+            if init_config.scf is False:
+                continue
+            init_config_name = "init_config_{}".format(init_config.config_index)
+            #1. read construtures from aimd dir
+
+            #2. set relabel dir 
+            #       read trajs from ./aimd/init_config_0/relax/0_aimd/
+            #       make scf dir ./relabel/init_config_0/relax/0_aimd/10-scf/files
+            traj_list = search_files(os.path.join(self.aimd_dir, init_config_name), "*/*aimd")
+            for traj_dir in traj_list:
+                scf_dir = os.path.join(self.scf_dir, init_config_name, \
+                    os.path.basename(os.path.dirname(traj_dir)),\
+                    os.path.basename(traj_dir))
+
+                traj_file_name = DFT_STYLE.get_aimd_config(self.resource.dft_style)
+
+                scf_lsit = self.make_scf_file(
+                    scf_dir      =scf_dir, 
+                    traj_file    =os.path.join(traj_dir, traj_file_name), 
+                    traj_format  =DFT_STYLE.get_format_by_postfix(traj_file_name), 
+                    interval     = self.input_param.interval,
+                    target_format=DFT_STYLE.get_pwdata_format(self.input_param.scf_style, is_cp2k_coord=True),
+                    input_file   =init_config.scf_input_file,
+                    kspacing     =init_config.scf_kspacing, 
+                    flag_symm    =init_config.scf_flag_symm,
+                    is_dftb      = False,
+                    in_skf       =None)
+
+                scf_paths.extend(scf_lsit)
+        # make slurm script and slurm job
+        self.make_scf_slurm_job_files(scf_paths, use_dftb)
+    
+    def check_work_done(self):
+        slurm_remain, slurm_success = get_slurm_job_run_info(self.scf_dir, \
+            job_patten="*-{}".format(INIT_BULK.scf_job), \
+            tag_patten="*-{}".format(INIT_BULK.scf_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_scf_jobs(self):
+        mission = Mission()
+        slurm_remain, slurm_success = get_slurm_job_run_info(self.scf_dir, \
+            job_patten="*-{}".format(INIT_BULK.scf_job), \
+            tag_patten="*-{}".format(INIT_BULK.scf_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 relabel 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.scf_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(error_type=SLURM_OUT.dft_out)
+                # mission.move_slurm_log_to_slurm_work_dir()
+
+    '''
+    description: 
+        input_file is scf input control file, for vasp is incar, for pwmat is etot.input
+    return {*}
+    author: wuxingxing
+    '''    
+    def make_scf_file(self, scf_dir:str, traj_file:str, traj_format:str, interval:int, target_format:str, \
+                input_file:str, kspacing:float=None, flag_symm:int=None, is_dftb:bool=False, in_skf:str=None):
+        config = load_config(format=traj_format, config=traj_file)
+        index_list = list(range(0, len(config), interval))
+        scf_lsit = []
+        for index in index_list:
+            save_dir = os.path.join(scf_dir, "{}-{}".format(index, INIT_BULK.scf))
+            if not os.path.exists(save_dir):
+                os.makedirs(save_dir)
+            #1. set config file
+            target_config = save_config(config=config[index], 
+                                        input_format=traj_format,# or None, the same
+                                        wrap = False, 
+                                        direct = True, 
+                                        sort = True, 
+                                        save_format=target_format, 
+                                        save_path=save_dir, 
+                                        save_name=DFT_STYLE.get_normal_config(self.input_param.scf_style))
+
+            atom_type_list, _ = get_atom_type(config[index])
+            #2. set pseudo files
+            # if not is_dftb:
+            pseudo_names = link_pseudo_by_atom(
+                pseudo_list     = self.input_param.dft_input.scf_pseudo, 
+                target_dir      = save_dir, 
+                atom_order      = atom_type_list, 
+                dft_style       = self.resource.scf_style,
+                basis_set_file  =self.input_param.dft_input.basis_set_file,
+                potential_file  =self.input_param.dft_input.potential_file
+                )
+            # else:
+            #     # link in.skf path to aimd dir
+            #     pseudo_names = []
+            #     target_dir = os.path.join(aimd_dir, PWMAT.in_skf)
+            #     link_file(in_skf, target_dir)
+            #3. make dft input file
+            set_input_script(
+                input_file=input_file,
+                config=target_config,
+                dft_style=self.resource.scf_style,
+                kspacing=kspacing, 
+                flag_symm=flag_symm, 
+                save_dir = save_dir,
+                pseudo_names=pseudo_names,
+                basis_set_file_name=self.input_param.dft_input.basis_set_file,# these for cp2k
+                potential_file_name=self.input_param.dft_input.potential_file
+            )
+            scf_lsit.append(save_dir)
+        return scf_lsit
+
+    def make_scf_slurm_job_files(self, scf_dir_list:list[str],use_dftb: bool=False):
+        group_list = split_job_for_group(self.resource.scf_resource.group_size, scf_dir_list, self.resource.scf_resource.parallel_num)
+        for group_index, group in enumerate(group_list):
+            if group[0] == "NONE":
+                continue
+            jobname = "scf{}".format(group_index)
+            tag_name = "{}-{}".format(group_index, INIT_BULK.scf_tag)
+            tag = os.path.join(self.scf_dir, tag_name)
+            run_cmd = self.resource.scf_resource.command
+            group_slurm_script = set_slurm_script_content(gpu_per_node=self.resource.scf_resource.gpu_per_node, 
+                number_node = self.resource.scf_resource.number_node, 
+                cpu_per_node = self.resource.scf_resource.cpu_per_node,
+                queue_name = self.resource.scf_resource.queue_name,
+                custom_flags = self.resource.scf_resource.custom_flags,
+                env_script = self.resource.scf_resource.env_script,
+                job_name = jobname,
+                run_cmd_template = run_cmd,
+                group = group,
+                job_tag = tag,
+                task_tag = INIT_BULK.scf_tag, 
+                task_tag_faild = INIT_BULK.scf_tag_failed,
+                parallel_num=self.resource.scf_resource.parallel_num,
+                check_type=self.resource.scf_style
+                )
+            slurm_script_name = "{}-{}".format(group_index, INIT_BULK.scf_job)
+            slurm_job_file =  os.path.join(self.scf_dir, slurm_script_name)
+            write_to_file(slurm_job_file, group_slurm_script, "w")
+
+    def do_post_process(self):
+        if os.path.exists(self.scf_dir):
+            link_file(self.scf_dir, self.real_scf_dir)

pwact/active_learning/init_bulk/relax.py

@@ -105,7 +105,8 @@ class Relax(object):
         else:
             # link in.skf path to aimd dir
             target_dir = os.path.join(relax_path, PWMAT.in_skf)
-            link_file(self.input_param.dft_input.in_skf, target_dir)
+            if self.input_param.dft_input.in_skf is not None:
+                link_file(self.input_param.dft_input.in_skf, target_dir)
             pseudo_names = []
         #3. make input file, for vasp is INCAR, for PWMAT is etot.input, for cp2k is inp file
         set_input_script(

pwact/active_learning/label/labeling.py

@@ -173,7 +173,8 @@ class Labeling(object):
         else:
             # link in.skf path to aimd dir
             target_dir = os.path.join(scf_dir, PWMAT.in_skf)
-            link_file(self.input_param.scf.in_skf, target_dir)
+            if self.input_param.scf.in_skf is not None:
+                link_file(self.input_param.scf.in_skf, target_dir)
             pseudo_names = []
         #2. make etot.input file
         set_input_script(

pwact/active_learning/test/test.py

@@ -1,23 +1,32 @@
 import numpy as np
 import argparse
-
-def make_kspacing_kpoints(config, kspacing):
-    with open(config, "r") as fp:
-        lines = fp.read().split("\n")
-    box = []
-    for idx, ii in enumerate(lines):
-        if "LATTICE" in ii.upper():
-            for kk in range(idx + 1, idx + 1 + 3):
-                vector = [float(jj) for jj in lines[kk].split()[0:3]]
-                box.append(vector)
-            box = np.array(box)
-            rbox = _reciprocal_box(box)
+import os
+import shutil
+import glob
+import json
+from pwdata.main import Config
+def make_kspacing_kpoints(config, format, kspacing):
+    config = Config(format=format, data_path=config)
+    # with open(config, "r") as fp:
+    #     lines = fp.read().split("\n")
+    # box = []
+    # for idx, ii in enumerate(lines):
+    #     if "LATTICE" in ii.upper():
+    #         for kk in range(idx + 1, idx + 1 + 3):
+    #             vector = [float(jj) for jj in lines[kk].split()[0:3]]
+    #             box.append(vector)
+    #         box = np.array(box)
+    #         rbox = _reciprocal_box(box)
+    box = config.images.lattice
+    rbox = _reciprocal_box(box)
     kpoints = [
-        round(2 * np.pi * np.linalg.norm(ii) / kspacing) for ii in rbox
+        max(1, round(2 * np.pi * np.linalg.norm(ii) / kspacing)) for ii in rbox
     ]
-    kpoints[0] = 1 if kpoints[0] == 0 else kpoints[0]
-    kpoints[1] = 1 if kpoints[1] == 0 else kpoints[1]
-    kpoints[2] = 1 if kpoints[2] == 0 else kpoints[2]
+    #DP pwmat multi kpoints will be slow, use round not ceil
+    # kpoints = [
+    #     max(1, (np.ceil(2 * np.pi * np.linalg.norm(ii) / ks).astype(int)))
+    #     for ii, ks in zip(rbox, [kspacing,kspacing,kspacing])
+    # ]
     ret = ""
     ret += "%d %d %d 0 0 0 " % (kpoints[0], kpoints[1], kpoints[2])
     print(ret)
@@ -27,10 +36,40 @@ def _reciprocal_box(box):
     rbox = np.linalg.inv(box)
     rbox = rbox.T
     return rbox
+
+def get_energy_dftb_vasp():
+    aimd_dir = "/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2/temp_init_bulk_work/aimd"#/init_config_0/init/0_aimd
+    scf_dir = "/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2/temp_init_bulk_work/scf"#init_config_0/init/0_aimd/0-scf
+    save_file = "/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2/energy_count_xtb.txt"
+    aimd_dir = glob.glob(os.path.join(aimd_dir, "init_config_*"))
+    aimd_dir = sorted(aimd_dir, key=lambda x: int(os.path.basename(x).split('_')[-1]))
+
+    save_text = []
+    for aimd in aimd_dir:
+        mvm_config = Config(format="pwmat/movement", data_path=os.path.join(aimd, "init/0_aimd/MOVEMENT"))
+        scf_list = glob.glob(os.path.join(scf_dir, os.path.basename(aimd), "init/0_aimd/*-scf"))
+        scf_list = sorted(scf_list, key=lambda x: int(os.path.basename(x).split('-')[0]))
+        for scf in scf_list:
+            index = int(os.path.basename(scf).split('-')[0])
+            scf_config = Config(format="vasp/outcar", data_path=os.path.join(scf, "OUTCAR"))
+            if index == 0:
+                base = scf_config.images[0].Ep - mvm_config.images[index].Ep
+            save_text.append("aimd {} index {} dftb_energy {} vasp_energy {} vasp_just {}"\
+                .format(os.path.basename(aimd), index, \
+                    mvm_config.images[index].Ep, scf_config.images[0].Ep,\
+                        scf_config.images[0].Ep - base))
     
+    with open(save_file, 'w') as wf:
+        for line in save_text:
+            wf.write(line)
+            wf.write("\n")
 if __name__=="__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-i', '--config', help="specify config file path of atom.config", type=str, default='atom.config')
-    parser.add_argument('-k', '--kspacing', help="specify the kspacing, the default 0.5", type=float, default=0.5)
-    args = parser.parse_args()
-    make_kspacing_kpoints(config=args.config, kspacing=args.kspacing)
+    # parser = argparse.ArgumentParser()
+    # parser.add_argument('-i', '--config', help="specify config file path of config", type=str, default='atom.config')
+    # parser.add_argument('-f', '--format', help="specify config file format config", type=str, default='pwmat/config')
+    # parser.add_argument('-k', '--kspacing', help="specify the kspacing, the default 0.5", type=float, default=0.5)
+    # args = parser.parse_args()
+    # make_kspacing_kpoints(config=args.config, format=args.format, kspacing=args.kspacing)
+    # make_kspacing_kpoints(config="/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2/temp_init_bulk_work/scf/init_config_0/init/0_aimd/0-scf/POSCAR",
+    #  format="vasp/poscar", kspacing=0.5)
+    get_energy_dftb_vasp()

pwact/active_learning/train/dp_kpu.py

@@ -58,7 +58,6 @@ class ModelKPU(object):
         # md work dir
         self.iter = get_iter_from_iter_name(self.itername)
         self.md_job = self.input_param.explore.md_job_list[self.iter]
-        self.sys_paths = self.input_param.explore.sys_configs
         # md work dir
         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)

pwact/active_learning/user_input/init_bulk_input.py

@@ -25,9 +25,12 @@ class InitBulkParam(object):
 
         # set sys_config detail
         self.dft_style = get_required_parameter("dft_style", json_dict).lower()
+        self.scf_style = get_parameter("scf_style", json_dict, None)
+
         self.sys_config:list[Stage] = []
         self.is_relax = False
         self.is_aimd = False
+        self.is_scf = False
         for index, config in enumerate(sys_configs):
             stage = Stage(config, index, sys_config_prefix, self.dft_style)
             self.sys_config.append(stage)
@@ -35,16 +38,22 @@ class InitBulkParam(object):
                 self.is_relax = True
             if stage.aimd:
                 self.is_aimd = True
+            if stage.scf:
+                self.is_scf = True
                 
         # for PWmat: set etot.input files and persudo files
         # for Vasp: set INCAR files and persudo files
-        self.dft_input = SCFParam(json_dict=json_dict, is_relax=self.is_relax, is_aimd=self.is_aimd, root_dir=self.root_dir, dft_style=self.dft_style)
+        self.dft_input = SCFParam(json_dict=json_dict, is_scf=self.is_scf, is_relax=self.is_relax, is_aimd=self.is_aimd, root_dir=self.root_dir, dft_style=self.dft_style, scf_style=self.scf_style)
         # check and set relax etot.input file
         for config in self.sys_config:
             if self.is_relax:
                 if config.relax_input_idx >= len(self.dft_input.relax_input_list):
                     raise Exception("Error! for config '{}' 'relax_input_idx' {} not in 'relax_input'!".format(os.path.basename(config.config_file), config.relax_input_idx))
                 config.set_relax_input_file(self.dft_input.relax_input_list[config.relax_input_idx])
+            if self.is_scf:
+                if not os.path.exists(self.dft_input.scf_input_list[0].input_file):
+                    raise Exception("Error! relabel dft input file {} not exisit!".format(self.dft_input.scf_input_list[0].input_file))
+                config.set_scf_input_file(self.dft_input.scf_input_list[0])
         # check and set aimd etot.input file
         for config in self.sys_config:
             if self.is_aimd:
@@ -73,7 +82,9 @@ class Stage(object):
         self.aimd = get_parameter("aimd", json_dict, True)
         self.aimd_input_idx = get_parameter("aimd_input_idx", json_dict, 0)
         self.aimd_input_file = None
-         
+        
+        self.scf = get_parameter("scf", json_dict, False)
+
         super_cell = get_parameter("super_cell", json_dict, [])
         super_cell = str_list_format(super_cell)
         if len(super_cell) > 0:
@@ -96,7 +107,7 @@ class Stage(object):
         else:
             self.scale = None
             
-        self.perturb = get_parameter("perturb", json_dict, 3)
+        self.perturb = get_parameter("perturb", json_dict, 0)
         if self.perturb == 0:
             self.perturb = None
         self.cell_pert_fraction = get_parameter("cell_pert_fraction", json_dict, 0.03)
@@ -107,6 +118,11 @@ class Stage(object):
         self.relax_kspacing = input_file.kspacing 
         self.relax_flag_symm = input_file.flag_symm
 
+    def set_scf_input_file(self, input_file:DFTInput):
+        self.scf_input_file = input_file.input_file
+        self.scf_kspacing = input_file.kspacing 
+        self.scf_flag_symm = input_file.flag_symm
+
     def set_aimd_input_file(self, input_file:DFTInput):
         self.aimd_input_file = input_file.input_file
         self.aimd_kspacing = input_file.kspacing

pwact/active_learning/user_input/iter_input.py

@@ -1,4 +1,6 @@
 import os
+import glob
+
 from pwact.utils.json_operation import get_parameter, get_required_parameter
 from pwact.utils.constant import MODEL_CMD, FORCEFILED, UNCERTAINTY, PWDATA
 from pwact.active_learning.user_input.train_param.train_param import TrainParam
@@ -96,9 +98,22 @@ class StrategyParam(object):
         res["model_num"] = self.model_num
 
 class SysConfig(object):
+    '''
+    description: 
+        for wildcard such as "scale-1.000/00000*/POSCAR"
+    param {*} self
+    param {str} sys_config
+    param {str} format
+    return {*}
+    author: wuxingxing
+    '''    
     def __init__(self, sys_config:str, format:str) -> None:
-        self.sys_config = sys_config
+        # self.sys_config = sys_config
         self.format = format
+        sys_config_list = glob.glob(sys_config)
+        self.sys_config = sorted(sys_config_list)
+
+        
 
 class ExploreParam(object):
     def __init__(self, json_dict, max_select:int=None) -> None:
@@ -107,6 +122,7 @@ class ExploreParam(object):
         if isinstance(sys_configs, str) or isinstance(sys_configs, dict):
             sys_configs = [sys_configs]
         self.sys_configs:list[SysConfig]=[]
+        # self.sys_configs[0] = config files with * and format
         for sys_config in sys_configs:
             if isinstance(sys_config, str):
                 config = os.path.join(sys_config_prefix, sys_config) if sys_config_prefix is not None else sys_config
@@ -129,7 +145,7 @@ class ExploreParam(object):
             if not isinstance(md_dict, list):
                 md_dict = [md_dict]
             for md_exp_id, md_exp in enumerate(md_dict):
-                iter_exp_md.append(MdDetail(md_exp_id, md_exp, max_select))
+                iter_exp_md.append(MdDetail(md_exp_id, md_exp, max_select, self.sys_configs))
             iter_md.append(iter_exp_md)
         return iter_md
     
@@ -138,7 +154,7 @@ class ExploreParam(object):
         return res
 
 class MdDetail(object):
-    def __init__(self, md_index: int, json_dict:dict, max_select:int=None) -> None:
+    def __init__(self, md_index: int, json_dict:dict, max_select:int=None, sys_configs:list[SysConfig]=None) -> None:
         self.md_index = md_index
         self.nsteps = get_required_parameter("nsteps", json_dict)
         self.md_dt = get_parameter("md_dt", json_dict, 0.001) #fs
@@ -156,27 +172,44 @@ class MdDetail(object):
         if not isinstance(self.temp_list, list):
             self.temp_list = [self.temp_list]
             
-        self.sys_idx = get_required_parameter("sys_idx", json_dict)
-        if not isinstance(self.sys_idx, list):
-            self.sys_idx = [self.sys_idx]
-        select_sys = get_parameter("select_sys", json_dict, None)
-        if select_sys is None:
+        sys_idx = get_required_parameter("sys_idx", json_dict)
+
+        if not isinstance(sys_idx, list):
+            self.sys_idx = [sys_idx]
+        _select_sys = get_parameter("select_sys", json_dict, None)
+        if _select_sys is None:
             if max_select is None:
-                select_sys = 100 # if the max_select and select_sys are all None, set the select_sys to 100 as default
+                _select_sys = 100 # if the max_select and select_sys are all None, set the select_sys to 100 as default
             else:
-                select_sys = max_select
-        if not isinstance(select_sys, list):
-            select_sys = [select_sys]
-        self.select_sys = []
-        if len(select_sys) > 0:
-            if len(select_sys) == 1:
-                for i in range(0, len(self.sys_idx)):
-                    self.select_sys.append(select_sys[0])
-            elif len(select_sys) == len(self.sys_idx):
-                self.select_sys = select_sys
+                _select_sys = max_select
+        if not isinstance(_select_sys, list):
+            _select_sys = [_select_sys]
+
+        select_sys = []
+        if len(_select_sys) > 0:
+            if len(_select_sys) == 1:
+                for i in range(0, len(sys_idx)):
+                    select_sys.append(_select_sys[0])
+            elif len(_select_sys) == len(sys_idx):
+                select_sys = _select_sys
             else:
                 raise Exception("The length of the 'select_sys' array needs to be consistent with'sys_idx'" )
-        
+        # reset select_sys and sys_idx by sys_configs
+        self.sys_idx = []
+        self.select_sys = []
+        self.config_file_list = []
+        self.config_file_format = []
+        file_id = 0
+        for index, sys_id in enumerate(sys_idx):
+            systems = sys_configs[sys_id].sys_config
+            system_format = sys_configs[sys_id].format
+            for system in systems:
+                self.config_file_list.append(system)
+                self.config_file_format.append(system_format)
+                self.sys_idx.append(file_id)
+                self.select_sys.append(select_sys[index])
+                file_id += 1
+
         self.kspacing = get_parameter("temps", json_dict, None)
         self.neigh_modify = get_parameter("neigh_modify", json_dict, 10)
         self.mass = get_parameter("mass",json_dict, None)

pwact/active_learning/user_input/resource.py

@@ -3,7 +3,8 @@ from pwact.utils.constant import AL_WORK, DFT_STYLE, SLURM_OUT, CP2K, LAMMPS
 
 class Resource(object):
     # _instance = None
-    def __init__(self, json_dict:dict, job_type:str=AL_WORK.run_iter, dft_style:str=None) -> None:
+    # scf_style for init_bulk relabel
+    def __init__(self, json_dict:dict, job_type:str=AL_WORK.run_iter, dft_style:str=None, scf_style:str=None) -> None:
         if job_type == AL_WORK.run_iter:
             self.train_resource = self.get_resource(get_required_parameter("train", json_dict))
             if self.train_resource.number_node > 1:
@@ -21,16 +22,29 @@ class Resource(object):
         # check dft resource
         self.dft_resource = self.get_resource(get_required_parameter("dft", json_dict))
         
+        if "scf" in json_dict.keys():
+            self.scf_resource = self.get_resource(get_parameter("scf", json_dict, None))
+        else:
+            self.scf_resource = None
         # dftb_command = get_parameter("dftb_command", json_dict["dft"], None)
         # if dftb_command is not None:
         #     self.dft_resource.dftb_command  = "{} > {}".format(dftb_command, SLURM_OUT.dft_out)
         self.dft_style = dft_style
+        self.scf_style = scf_style
         if DFT_STYLE.vasp.lower() == dft_style.lower():
             self.dft_resource.command = "{} > {}".format(self.dft_resource.command, SLURM_OUT.dft_out)
         elif DFT_STYLE.pwmat.lower() == dft_style.lower():
             self.dft_resource.command = "{} > {}".format(self.dft_resource.command, SLURM_OUT.dft_out)
         elif DFT_STYLE.cp2k.lower() == dft_style.lower():
             self.dft_resource.command = "{} {} > {}".format(self.dft_resource.command, CP2K.cp2k_inp, SLURM_OUT.dft_out)
+        
+        if self.scf_resource is not None and scf_style is not None:
+            if DFT_STYLE.vasp.lower() == scf_style.lower():
+                self.scf_resource.command = "{} > {}".format(self.scf_resource.command, SLURM_OUT.dft_out)
+            elif DFT_STYLE.pwmat.lower() == scf_style.lower():
+                self.scf_resource.command = "{} > {}".format(self.scf_resource.command, SLURM_OUT.dft_out)
+            elif DFT_STYLE.cp2k.lower() == scf_style.lower():
+                self.scf_resource.command = "{} {} > {}".format(self.scf_resource.command, CP2K.cp2k_inp, SLURM_OUT.dft_out)
 
     # @classmethod
     # def get_instance(cls, json_dict:dict = None):
@@ -90,4 +104,16 @@ class ResourceDetail(object):
         self.env_script = env_script
 
         if self.gpu_per_node is None and self.cpu_per_node is None:
-            raise Exception("ERROR! Both CPU and GPU resources are not specified!")
+            raise Exception("ERROR! Both CPU and GPU resources are not specified!")
+        # check param
+        if "$SLURM_NTASKS".lower() in command.lower():
+            pass
+        else:
+            if "mpirun -np" in command:
+                np_num = command.split()[2]
+                try:
+                    np_num = int(np_num)
+                    if np_num > cpu_per_node:
+                        raise Exception("the 'command' in resource.json {} set error! The nums of np can not be bigger than 'cpu_per_node'!".format(command))
+                except Exception:
+                    raise Exception("the 'command' in resource.json {} set error! The nums of np can not be parsed!".format(command))

pwact/active_learning/user_input/scf_param.py

@@ -9,7 +9,8 @@ class SCFParam(object):
         is_aimd:bool=False, 
         is_scf:bool=False, 
         root_dir:str=None, 
-        dft_style:str=None) -> None:
+        dft_style:str=None,
+        scf_style:str=None) -> None:# for scf relabel in init_bulk
         
         self.dft_style = dft_style
         self.root_dir = root_dir
@@ -18,11 +19,17 @@ class SCFParam(object):
         self.aimd_input_list = []
         self.scf_input_list = []
         self.pseudo = []
+        self.scf_pseudo = []
         self.use_dftb = False
+
         if is_scf:
-            self.scf_input_list = self.set_input(json_dict, flag_symm=0)
-            if self.scf_input_list[0].use_dftb:
-                self.use_dftb = True
+            if "scf_input" in json_dict.keys(): # for init_bulk relabel
+                json_scf = get_required_parameter("scf_input", json_dict)
+                self.scf_input_list = self.set_input(json_scf, flag_symm=0)
+            else: # for run_iter
+                self.scf_input_list = self.set_input(json_dict, flag_symm=0)
+                if self.scf_input_list[0].use_dftb:
+                    self.use_dftb = True
         if is_aimd:
             json_aimd = get_required_parameter("aimd_input", json_dict)
             self.aimd_input_list = self.set_input(json_aimd, flag_symm=0)
@@ -33,20 +40,33 @@ class SCFParam(object):
             self.relax_input_list = self.set_input(json_relax, flag_symm=3) 
             if self.relax_input_list[0].use_dftb:
                 self.use_dftb = True
-
-        # self.use_dftb = True if self.scf_input_list[0].use_dftb else False
-        # set pseudo potential files
-
-        # for cp2k is some dicts, not used, just read the user input file
-        # self.basis_set_file = get_parameter("basis_set_file_name", json_dict, None)
-        # self.potential_file = get_parameter("potential_file_name", json_dict, None)
-        # self.xc_functional = get_parameter("xc_functional", json_dict, "PBE")
-        # self.potential = get_parameter("potential", json_dict, None)
-        # self.basis_set = get_parameter("basis_set", json_dict, None)
-        
         # for pwmat, use 'pseudo' key
         # for vasp is INCAR file, use 'pseudo' key        
         pseudo = get_parameter("pseudo", json_dict, [])
+        self.pseudo = self._set_pseudo(pseudo, dft_style)
+        
+        if is_scf:
+            scf_pseudo = get_parameter("scf_pseudo", json_dict, [])
+            self.scf_pseudo = self._set_pseudo(scf_pseudo, scf_style)
+
+        # for pwmat-dftb is in_skf, a dir string
+        in_skf = get_parameter("in_skf", json_dict, None)
+        self.in_skf = None
+        if self.use_dftb:
+            if in_skf is not None:
+                self.in_skf = in_skf if os.path.isabs(in_skf) else os.path.abspath(in_skf)
+            #     if not os.path.exists(self.in_skf):
+            #         raise Exception("ERROR! The 'in_skf' dir {} not exsit!".format(self.in_skf))
+            # else:
+            #     raise Exception("ERROR! The 'USE_DFTB' is set in scf.input file, but the 'in_skf' dir not set!")
+        # else:
+        #     pass
+        # for cp2k
+        self.basis_set_file = get_parameter("basis_set_file", json_dict, None)
+        self.potential_file = get_parameter("potential_file", json_dict, None)
+
+    def _set_pseudo(self, pseudo, style:str):
+        res_pseudo = []
         if isinstance(pseudo, str):
             pseudo = list(pseudo)
         for pf in pseudo:
@@ -55,28 +75,13 @@ class SCFParam(object):
             if not os.path.isabs(pf):
                 pf = os.path.abspath(pf)
             # for vasp pseudo files, read the pseduo files and get the atom type in pseduo
-            if self.dft_style == DFT_STYLE.vasp:
+            if style == DFT_STYLE.vasp:
                 atom_type = get_vasp_pseudo_atom_type(pf)
             # for pwmat pseudo files, get the atom type from pseudo file name
-            elif self.dft_style == DFT_STYLE.pwmat:
+            elif style == DFT_STYLE.pwmat:
                 atom_type = os.path.basename(pf).split('.')[0]
-            self.pseudo.append([pf, atom_type])
-
-        # for pwmat-dftb is in_skf, a dir string
-        in_skf = get_parameter("in_skf", json_dict, None)
-        self.in_skf = None
-        if self.use_dftb:
-            if in_skf is not None:
-                self.in_skf = in_skf if os.path.isabs(in_skf) else os.path.abspath(in_skf)
-                if not os.path.exists(self.in_skf):
-                    raise Exception("ERROR! The 'in_skf' dir {} not exsit!".format(self.in_skf))
-            else:
-                raise Exception("ERROR! The 'USE_DFTB' is set in scf.input file, but the 'in_skf' dir not set!")
-        else:
-            pass
-        # for cp2k
-        self.basis_set_file = get_parameter("basis_set_file", json_dict, None)
-        self.potential_file = get_parameter("potential_file", json_dict, None)
+            res_pseudo.append([pf, atom_type])
+        return res_pseudo
 
     '''
     description: 

pwact/active_learning/user_input/train_param/train_param.py

@@ -239,6 +239,7 @@ class TrainParam(object):
         if self.seed is not None:
             params_dict["seed"] = self.seed
         params_dict["model_num"] = self.model_num
+        params_dict["chunk_size"] = self.chunk_size
         # params_dict["E_tolerance"] = self.descriptor.E_tolerance
         # params_dict["Rmax"] = self.descriptor.Rmax
         # params_dict["Rmin"] = self.Rmin

pwact/data_format/configop.py

@@ -12,8 +12,11 @@ param {str} format
 return {*}
 author: wuxingxing
 '''
-def get_atom_type(config_path:str, format:str):
-    image = Config.read(format=format, data_path=config_path, atom_names=None)
+def get_atom_type(config_path, format:str=None):
+    if isinstance(config_path, str):
+        image = Config.read(format=format, data_path=config_path, atom_names=None)
+    else:
+        image = config_path
     atomic_number_list = []
     atomic_name_list = []
     for atom in image.atom_type:
@@ -21,6 +24,10 @@ def get_atom_type(config_path:str, format:str):
         atomic_number_list.append(atom)
     return atomic_name_list, atomic_number_list
 
+def load_config(config, format, atom_names=None):
+    config = Config.read(format=format, data_path=config, atom_names=atom_names)
+    return config
+
 '''
 description: 
     the input config could be vasp/pwmat/cp2k format
@@ -30,7 +37,8 @@ author: wuxingxing
 '''
 def save_config(config, input_format:str = None, wrap = False, direct = True, sort = True, \
         save_format:str=None, save_path:str=None, save_name:str=None, atom_names: list[str] = None):
-    config = Config.read(format=input_format, data_path=config, atom_names=atom_names)
+    if isinstance(config, str):
+        config = Config.read(format=input_format, data_path=config, atom_names=atom_names)
     if isinstance(config, list): # for lammps dump traj, config will be list
         config = config[0]
     if save_format == PWDATA.cp2k_scf:
@@ -189,11 +197,11 @@ def extract_pwdata(data_list:list[str],
                 )
     
 if __name__ == "__main__":
-    in_config = "/data/home/wuxingxing/datas/al_dir/si_exp/init_bulk/collection/init_config_1/0.9_scale_pertub/0_pertub.config"
-    save_path = "/data/home/wuxingxing/datas/al_dir/si_exp/init_bulk/collection/init_config_1/0.9_scale_pertub"
-    image = Config.read(format="pwmat", data_path=in_config)
-    save_config(image, wrap=False, direct=True, sort=True,\
-        save_format="vasp", save_path=save_path, save_name="temp_poscar")
+    # in_config = "/data/home/wuxingxing/datas/al_dir/si_exp/init_bulk/collection/init_config_1/0.9_scale_pertub/0_pertub.config"
+    # save_path = "/data/home/wuxingxing/datas/al_dir/si_exp/init_bulk/collection/init_config_1/0.9_scale_pertub"
+    # image = Config.read(format="pwmat", data_path=in_config)
+    # save_config(image, wrap=False, direct=True, sort=True,\
+    #     save_format="vasp", save_path=save_path, save_name="temp_poscar")
     # save_config(image, wrap=False, direct=True, sort=True,\
     #     save_format="vasp", save_path=save_path, save_name="temp_poscar")
     
@@ -263,4 +271,22 @@ if __name__ == "__main__":
     #     save_name = "{}.config".format(os.path.basename(traj).split('.')[0])
     #     save_config(traj,  input_format="dump", wrap=False, direct=True, sort=True,\
     #     save_format="pwmat", save_path=save_dir, save_name=save_name)
-    #     print("{} to {} done!".format(traj, save_name))
+    #     print("{} to {} done!".format(traj, save_name))
+    import glob
+    data_dir1 = glob.glob(os.path.join("/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2/temp_init_bulk_work/scf/init_config_*")) #
+    data_dir2 = glob.glob(os.path.join("/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_bulk_hfo2_600k/temp_init_bulk_work/scf/init_config_*")) 
+    data_dir1.extend(data_dir2)
+    select_list = ["0-scf", "200-scf", "400-scf", "600-scf", "800-scf", "1000-scf"]
+    data_list = []
+    for dir in data_dir1:
+        _outcars = glob.glob(os.path.join(dir, "*/*/*/OUTCAR"))
+        for outcar in _outcars:
+            if os.path.basename(os.path.dirname(outcar)) in select_list:
+                data_list.append(outcar)
+
+    datasets_path = "/data/home/wuxingxing/datas/al_dir/HfO2/dftb/init_data_200"
+    extract_pwdata(data_list=data_list, 
+            data_format="vasp/outcar", 
+            datasets_path=datasets_path,
+            merge_data=True
+            )

pwact/main.py

@@ -35,7 +35,7 @@ def run_iter():
     resource = Resource(machine_info, dft_style=input_param.dft_style)
     os.chdir(input_param.root_dir)
     print("The work dir change to {}".format(os.getcwd()))
-    record = input_param.record_file
+    record = os.path.abspath(input_param.record_file)
     iter_rec = [0, -1]
     if os.path.isfile(record):
         with open (record) as frec :
@@ -145,7 +145,7 @@ def init_bulk():
         os.chdir(system_json["work_dir"])
     machine_info = convert_keys_to_lowercase(json.load(open(sys.argv[3])))
     input_param = InitBulkParam(system_info)
-    resource = Resource(machine_info, job_type=AL_WORK.init_bulk, dft_style=input_param.dft_style)
+    resource = Resource(machine_info, job_type=AL_WORK.init_bulk, dft_style=input_param.dft_style, scf_style=input_param.scf_style)
 
     os.chdir(input_param.root_dir)
     
@@ -155,12 +155,16 @@ def init_bulk():
 
 def to_pwdata(input_cmds:list):
     parser = argparse.ArgumentParser()
+    parser.add_argument('-t', '--worktype', help="specify work type, default is 'to_pwdata'", type=str, default='to_pwdata')
     parser.add_argument('-i', '--input', help='specify input outcars or movement files', nargs='+', type=str, default=None)
     parser.add_argument('-f', '--format', help="specify input file format, 'vasp/outcar' or 'pwmat/movement', default is 'pwmat/movement'", type=str, default="pwmat/movement")
     parser.add_argument('-s', '--savepath', help="specify stored directory, default is 'PWdata'", type=str, default='PWdata')
     parser.add_argument('-o', '--train_valid_ratio', help='specify stored directory, default=0.8', type=float, default=0.8)
-    parser.add_argument('-r', '--data_shuffle', help='specify stored directory, default is True', type=bool, required=False, default=True)
-    parser.add_argument('-m', '--merge', help='merge inputs to one, default is False', type=bool, required=False, default=False)
+    # parser.add_argument('-r', '--data_shuffle', help='specify stored directory, default is True', type=bool, required=False, default=True)
+    # parser.add_argument('-d', '--do_shuffle', help='if -d exits, doing the data shuffling', action='store_false')
+    parser.add_argument('-r', '--data_shuffle', help='Specify whether to do data shuffle operation, -r is True', action='store_true')
+    parser.add_argument('-m', '--merge', help='Specify whether to merge inputs to one, -m is True', action='store_true')
+    # parser.add_argument('-m', '--merge', help='merge inputs to one, default is False', type=bool, required=False, default=False)
     parser.add_argument('-g', '--gap', help='Trail point interval before and after, default is 1', type=int, default=1)
 
     parser.add_argument('-w', '--work_dir', help='specify work dir, default is current dir', type=str, default='./')

pwact/utils/app_lib/common.py

@@ -106,13 +106,15 @@ def set_input_script(
     ):
     if dft_style == DFT_STYLE.pwmat:
         target_file = os.path.join(save_dir, PWMAT.etot_input)
+        is_skf_file = os.path.exists(os.path.join(save_dir, PWMAT.in_skf))
         script = set_etot_input_by_file(    #do pwmat etot.input content check
             etot_input_file=input_file, 
             atom_config=config, 
             kspacing=kspacing, 
             flag_symm=flag_symm, 
             pseudo_names=pseudo_names,
-            is_scf = is_scf
+            is_scf = is_scf,
+            is_skf_file = is_skf_file
             )
         write_to_file(target_file, script, "w")
     elif dft_style == DFT_STYLE.vasp:

pwact/utils/app_lib/lammps.py

@@ -4,7 +4,7 @@ import os
 import numpy as np
 
 from pwact.utils.constant import FORCEFILED
-
+from pwdata.calculators.const import ELEMENTMASSTABLE
 def _sample_sphere():
     while True:
         vv = np.array([np.random.normal(), np.random.normal(), np.random.normal()])
@@ -29,16 +29,27 @@ def make_pair_style(md_type, forcefiled, atom_type:list[int], dump_info:str):
     pair_style += "pair_coeff       * * {}\n".format(atom_names)
     return pair_style
 
-def make_mass(mass):
-    if mass is None:
-        return ""
+# def make_mass(mass):
+#     if mass is None:
+#         return ""
     
+#     mass_str = "\n"
+#     if isinstance(mass, str):
+#         mass_str += "mass       {}\n".format(mass)
+#     else:
+#         for m in mass:
+#             mass_str += "mass       {}\n".format(m)
+#     return mass_str
+
+def make_mass(atom_type:list):
+    if isinstance(atom_type, str):
+        atom_type = [atom_type]
+    if atom_type is None:
+        return ""
     mass_str = "\n"
-    if isinstance(mass, str):
-        mass_str += "mass       {}\n".format(mass)
-    else:
-        for m in mass:
-            mass_str += "mass       {}\n".format(m)
+    
+    for i, atom in enumerate(atom_type):
+        mass_str += "mass   {}    {}\n".format(i+1, ELEMENTMASSTABLE[atom])
     return mass_str
 
 def set_ensemble(ensemble):
@@ -104,7 +115,7 @@ def make_lammps_input(
     )
     md_script += "change_box       all triclinic\n"
     
-    md_script += make_mass(mass)
+    md_script += make_mass(atom_type)
     dump_info = "out_freq ${{DUMP_FREQ}} out_file {} ".format(model_deviation_file)
     md_script += make_pair_style(md_type, forcefiled, atom_type, dump_info)
     #put_freq ${freq} out_file error

pwact/utils/app_lib/pwmat.py

@@ -320,7 +320,8 @@ def set_etot_input_by_file(
     flag_symm:int=None, 
     atom_config:str=None, 
     pseudo_names:list[str]=None,
-    is_scf = False # if True, job is scf, and 'OUT.MLMD = T' to etot.input
+    is_scf = False, # if True, job is scf, and 'OUT.MLMD = T' to etot.input
+    is_skf_file = False  # if True, set in.skf to etot.input file
     ):
     key_values, etot_lines = read_and_check_etot_input(etot_input_file)
     is_skf = False
@@ -343,9 +344,9 @@ def set_etot_input_by_file(
         else:
             new_etot_lines.append(etot_lines[index])
         index += 1
-    new_etot_lines.append("IN.ATOM = {}\n".format(os.path.basename(atom_config)))
+    new_etot_lines.append("\nIN.ATOM = {}\n".format(os.path.basename(atom_config)))
     # if dftb and need in_skf
-    if is_skf:
+    if is_skf and is_skf_file:
         new_etot_lines.append("IN.SKF = ./{}/\n".format(PWMAT.in_skf))
     # is not for dftb, reset the IN.PSP
     if "USE_DFTB" not in key_values.keys() or key_values["USE_DFTB"] is None and key_values["USE_DFTB"] == "F":

pwact/utils/constant.py

@@ -350,6 +350,11 @@ class INIT_BULK:
     aimd_tag = "tag.aimd.success"
     aimd_tag_failed ="tag.aimd.failed"
     
+    scf = "scf"
+    scf_job = "scf.job"
+    scf_tag = "tag.scf.success"
+    scf_tag_failed ="tag.scf.failed"
+
     collection = "collection"
     npy_format_save_dir = "PWdata"
     npy_format_name = "pwdata"

pwact/utils/file_operation.py

@@ -85,6 +85,8 @@ return {*}
 author: wuxingxing
 '''
 def write_to_file(file_path, line, mode='w'):
+    if not os.path.exists(os.path.dirname(file_path)):
+        os.makedirs(os.path.dirname(file_path))
     with open(file_path, mode) as wf:
         wf.write(line)
 
@@ -102,8 +104,8 @@ def merge_files_to_one(file_list:list[str], save_file:str):
             with open(file, 'r') as rf:
                 content = rf.read()
             wf.write(content)
-            if index < len(file_list) - 1:
-                wf.write("\n")
+            # if index < len(file_list) - 1:
+            #     wf.write("\n")
         
 '''
 description: 

{pwact-0.1.5.dist-info → pwact-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pwact
-Version: 0.1.5
+Version: 0.1.9
 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

{pwact-0.1.5.dist-info → pwact-0.1.9.dist-info}/RECORD

@@ -1,55 +1,56 @@
 pwact/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/main.py,sha256=KOZ2ptB3UaJazulm1YtQxmeL8wVM-cr-zlvUHh7bvmo,12077
+pwact/main.py,sha256=gSh39PCdbAodiAc0vlwNWnf-ZTsjZ6KaH0F9awPN5dQ,12627
 pwact/active_learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pwact/active_learning/environment.py,sha256=7jqZcYw5jNtMuW0TYlCIDCD4mUt6a7WdXq3PyXjLuG0,104
 pwact/active_learning/slurm.py,sha256=XVeVIRRQUXWixxbUqR-tJQS4CNhEJV8pvp74O4e5InM,13108
 pwact/active_learning/explore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/active_learning/explore/run_model_md.py,sha256=W_j_uOpYK4P2ee0vXfAkaNwILi4Kb7stu_m1Al6NO_4,18815
+pwact/active_learning/explore/run_model_md.py,sha256=GfdaT3W70VU0Ke12R0f2wcn92-nvi5yre5pU4lhyCYA,19112
 pwact/active_learning/explore/select_image.py,sha256=QAoD1CxaC5Xn3W5rQHxTNWMN53K2wABLsw03XCJEFPg,10527
 pwact/active_learning/init_bulk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/active_learning/init_bulk/aimd.py,sha256=E7G44OglroK1v5PMuw6NY8ZJ-PLi_bEdNRRT0tafLLo,10398
+pwact/active_learning/init_bulk/aimd.py,sha256=J-L83Bj4oJYaJvmd_W76oKamFMJhoImjM5B9FC1Uobw,10437
 pwact/active_learning/init_bulk/duplicate_scale.py,sha256=oVFB6umOhI8xGxNTPowvztxYgJPGAopU2bvV_NaHpdM,9463
-pwact/active_learning/init_bulk/init_bulk_run.py,sha256=Zee0Q1LkpSwg7_kVLc_YSwbQP74nDBbRmfKQJ6RM87M,6264
-pwact/active_learning/init_bulk/relax.py,sha256=VDQwXKTpWGHRu0w96elJHaYbCvKrG9j2vwNf0VZBKTk,10340
+pwact/active_learning/init_bulk/init_bulk_run.py,sha256=0rsGpjIqmlYwJvV2Gai1ZdhkB10T1sbNPTtKgRh_A1w,8298
+pwact/active_learning/init_bulk/relabel.py,sha256=SvHUdzFj4kxiYkZ5v4elhEnAVqGqmaeEB1TN45ZmbTc,10410
+pwact/active_learning/init_bulk/relax.py,sha256=4T7VI1sBmUWDwLbSn3JvPivHTLNcdSil5DoyKI7DEfM,10406
 pwact/active_learning/label/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/active_learning/label/labeling.py,sha256=xdNWTJ2xIsVWNQpEkFyUBlZ3Cbqo7Zyz3zC1_bZwtT0,14826
+pwact/active_learning/label/labeling.py,sha256=Qh_f27OxQytVaCtcqLj2eKs4usqSpQlnFPtLApM7adQ,14886
 pwact/active_learning/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/active_learning/test/test.py,sha256=iSy52-QUOAlBEQ661ahjr2rTnVyzUvE-oPjpNiG6Ths,1336
+pwact/active_learning/test/test.py,sha256=ZoA4W3VG9-XLQ6onUvCIPq9PkfttEPKdz8GZX46cwIg,3582
 pwact/active_learning/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/active_learning/train/dp_kpu.py,sha256=B3L9l9uwHh4heNkvBsziPUbkWo6uXN_-BOCWCbCXUdw,9259
+pwact/active_learning/train/dp_kpu.py,sha256=cdQzzoigwulRfrHP5AfuEVQn6Rw3RVflHHTvgWs1CQM,9197
 pwact/active_learning/train/train_model.py,sha256=n0m-DS2GBelaMHGKRFUy_JACbyjJ8Q3Nw_6FkHIDeo8,9730
 pwact/active_learning/user_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pwact/active_learning/user_input/cmd_infos.py,sha256=zWONvAXlpYsRgCxG2q43M7fmWLjVG0mbmeL6JKcJCtk,1468
-pwact/active_learning/user_input/init_bulk_input.py,sha256=xbo_0ZJfw2Yle2qw-mM4CkBkTP78cjy-S-bJ33r7R-U,5968
-pwact/active_learning/user_input/iter_input.py,sha256=Kw5UoPFxwvkPMartxJj6qE4UUFJrtaglu6dvh_kDuAc,9611
-pwact/active_learning/user_input/resource.py,sha256=DxpjAkUbc_fdy7_CM8dMqAWiaqm5DyzpIKrXfv754Og,4771
-pwact/active_learning/user_input/scf_param.py,sha256=tQ8HhVOVvBfJQmwFnaIydXyVXAUQQxLfnmbwHsin18o,8807
+pwact/active_learning/user_input/init_bulk_input.py,sha256=NCUAB1xpa67MXHRRWAkmWZjkQbTibE4EjmtlOmr0HdQ,6762
+pwact/active_learning/user_input/iter_input.py,sha256=TLlilMx7oUvXlK-6lbedMXU-FS-IEVnyDsmB14kFd2Y,10657
+pwact/active_learning/user_input/resource.py,sha256=jVahpvdYHXYaeKWxNSLy1YkoZ-QtcUnW-MwJOVbRyD8,6269
+pwact/active_learning/user_input/scf_param.py,sha256=xXS-8bhXF_KdE0Jc9P8UZcbhWb0qKRWRhfBI9t5Rz6M,8883
 pwact/active_learning/user_input/workdir.py,sha256=64J3wBbYzy6ztYHs513YHfEIF5d8zwv_WpF-U9HOEkA,8245
 pwact/active_learning/user_input/train_param/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pwact/active_learning/user_input/train_param/model_param.py,sha256=ogP6Th5--X1nWtO_BmQKGIRCi_UYXpQQ-Ki5OslBTfI,4381
 pwact/active_learning/user_input/train_param/nep_param.py,sha256=NZCJtrJ0_W5V4K4c0j_IXwhlRbq_aKeVSpDSO0Qm_u0,10446
 pwact/active_learning/user_input/train_param/nn_feature_type.py,sha256=ytah4nIU1EuuaOYScSPxwhf3tSQv3lpNxva0CUvGvHw,14625
 pwact/active_learning/user_input/train_param/optimizer_param.py,sha256=npyMZn3CcqKn34k4jPBD4oNdN0z14e8F4CVIZkYBrpY,8063
-pwact/active_learning/user_input/train_param/train_param.py,sha256=OtkZoERG6kauy045ZxHgGYQNTDDjmG1RxbOEWATeQzQ,13080
+pwact/active_learning/user_input/train_param/train_param.py,sha256=wt_PHDrfk5eOygX0wUKzCIsB2OW0XOWicHQPWUEPKyg,13132
 pwact/active_learning/user_input/train_param/work_file_param.py,sha256=tvvxWto8oH7CZPowLjhbvkUn5kQJLE33b2UBfmK_Kxs,11219
 pwact/bin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pwact/data_format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/data_format/configop.py,sha256=tUKUCWcwZ_2hF_KeEdbidmCsvBfbRF_98z6bh63vg_o,11326
+pwact/data_format/configop.py,sha256=VN_F7Ckmdty-kUClfvhzTSnNvl7w9iwsBHMY2CHwo8Q,12525
 pwact/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/utils/constant.py,sha256=UcAFXNBa5FOAaMNBEHNq7DwKAmyPb6vlDOOY5Ki77fE,17345
-pwact/utils/file_operation.py,sha256=sNwm8zuXkCpu6tShPBwaTUFsatGE8XkOjnRVvDN6unY,8293
+pwact/utils/constant.py,sha256=Lt3KYgtzPxccsTk_qT8RdVWP4xS1awgBAEPJ9Oq16Ug,17455
+pwact/utils/file_operation.py,sha256=3IPXqOxOmh1MfqL_YDKMurw5oyY072y8WTplbLW4rXw,8400
 pwact/utils/format_input_output.py,sha256=oYFydQy3-btXzieO2O2LbHFoeRyhPnLVE4c5TNgS-IQ,1798
 pwact/utils/json_operation.py,sha256=BqBsnIjk1URoMW_s2yu7Gk8IBxlir-oo6ivt8P3RIqg,1794
 pwact/utils/pre_al_data_util.py,sha256=QE-axnVYUIyORFiVs-WK9-UaJlMUFY816_rSyYOOJc8,2542
 pwact/utils/slurm_script.py,sha256=GISYPiMezVg5HiJs9MfcVDyycCh9fLbTQ3lLzAQGOIU,8188
 pwact/utils/app_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwact/utils/app_lib/common.py,sha256=ODOs_HDX8O4Bh7YW7BcvsgS1FpZvifaRpQd9yBa7a2Y,5438
+pwact/utils/app_lib/common.py,sha256=KiKZHrk_SDwP9b8ZORor8rXzZbU-vSSjliqlYvjyvPQ,5552
 pwact/utils/app_lib/cp2k.py,sha256=vPTofDEz8Qd1A3gjMkMxXF8qWQLVz3XDc6-hSjRG7j0,10499
-pwact/utils/app_lib/lammps.py,sha256=I3_kIzJzmVaPMHerHa421BR9Sw3YjzbWkZXLjV6M39s,7654
-pwact/utils/app_lib/pwmat.py,sha256=qUNkMb_Zn4XaKUgwUo2S_ft3IhEIlBePTdO8sCYyLos,16458
-pwact-0.1.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pwact-0.1.5.dist-info/METADATA,sha256=4gEdQKdIKynxGV4oCpmfSIhT1HT92ZS5IuQxgWsV9MM,3658
-pwact-0.1.5.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pwact-0.1.5.dist-info/entry_points.txt,sha256=p61auAnpbn8E2WjvHNBA7rb9_NRAOCew4zdcCj33cGc,42
-pwact-0.1.5.dist-info/top_level.txt,sha256=fY1_7sH5Lke4dC9L8MbYM4fT5aat5eCkAmpkIzY1SlM,6
-pwact-0.1.5.dist-info/RECORD,,
+pwact/utils/app_lib/lammps.py,sha256=2oxHJHdDxfDDWWmnjo0gMNwgGvxABwuDgDlb8kbhgfk,8037
+pwact/utils/app_lib/pwmat.py,sha256=l3O_AXExy0Sgkz0RQolrvRg0ZfHLLySFteQZ2dhqfhs,16543
+pwact-0.1.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pwact-0.1.9.dist-info/METADATA,sha256=BGo8wMHO5dDXKeLrjk6NdvCRFjiyl7opgrai1PMZhcE,3658
+pwact-0.1.9.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+pwact-0.1.9.dist-info/entry_points.txt,sha256=p61auAnpbn8E2WjvHNBA7rb9_NRAOCew4zdcCj33cGc,42
+pwact-0.1.9.dist-info/top_level.txt,sha256=fY1_7sH5Lke4dC9L8MbYM4fT5aat5eCkAmpkIzY1SlM,6
+pwact-0.1.9.dist-info/RECORD,,