pwact 0.1.7__py3-none-any.whl → 0.1.10__py3-none-any.whl

pwact/active_learning/environment.py

@@ -1,4 +1,16 @@
 import subprocess
+import pkg_resources
 def check_envs():
     # for pwmat
-    subprocess.call("module load pwmat", shell=True)
+    pass
+    # check pwdata
+    # try:
+    #     package_version = pkg_resources.get_distribution('pwdata').version
+    #     if pkg_resources.parse_version(min_version) <= pkg_resources.parse_version(package_version) <= pkg_resources.parse_version(max_version):
+    #         print(f"{package_name} version {package_version} is within the required range [{min_version}, {max_version}].")
+    #         return True
+    #     else:
+    #         print(f"{package_name} version {package_version} is NOT within the required range [{min_version}, {max_version}].")
+    #         return False
+
+    # check PWMLFF???

pwact/active_learning/explore/run_model_md.py

@@ -21,7 +21,7 @@ from pwact.active_learning.explore.select_image import select_image
 from pwact.active_learning.user_input.resource import Resource
 from pwact.active_learning.user_input.iter_input import InputParam, MdDetail
 from pwact.utils.constant import AL_STRUCTURE, TEMP_STRUCTURE, EXPLORE_FILE_STRUCTURE, TRAIN_FILE_STRUCTUR, \
-        FORCEFILED, ENSEMBLE, LAMMPS, LAMMPS_CMD, UNCERTAINTY, DFT_STYLE, SLURM_OUT, SLURM_JOB_TYPE, PWDATA
+        FORCEFILED, ENSEMBLE, LAMMPS, LAMMPS_CMD, UNCERTAINTY, DFT_STYLE, SLURM_OUT, SLURM_JOB_TYPE, PWDATA, MODEL_TYPE
 
 from pwact.utils.format_input_output import get_iter_from_iter_name, get_sub_md_sys_template_name,\
     make_md_sys_name, get_md_sys_template_name, make_temp_press_name, make_temp_name, make_train_name
@@ -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,
@@ -192,11 +190,14 @@ class Explore(object):
                                     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)
         
@@ -246,13 +247,16 @@ class Explore(object):
     def set_forcefiled_file(self, md_dir:str):
         model_name = ""
         md_model_paths = []
-        if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
-            model_name += TRAIN_FILE_STRUCTUR.script_dp_name
-        elif self.input_param.strategy.md_type == FORCEFILED.fortran_lmps:
-            if self.input_param.strategy.compress:
-                raise Exception("ERROR! The compress model does not support fortran lammps md! Please change the 'md_type' to 2!")
-            else:
-                model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.fortran_dp, TRAIN_FILE_STRUCTUR.fortran_dp_name)
+        if self.input_param.train.model_type == MODEL_TYPE.nep:
+            model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.nep_model_lmps)
+        elif self.input_param.train.model_type == MODEL_TYPE.dp:
+            if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
+                model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name)
+            elif self.input_param.strategy.md_type == FORCEFILED.fortran_lmps:
+                if self.input_param.strategy.compress:
+                    raise Exception("ERROR! The compress model does not support fortran lammps md! Please change the 'md_type' to 2!")
+                else:
+                    model_name += "{}/{}".format(TRAIN_FILE_STRUCTUR.fortran_dp, TRAIN_FILE_STRUCTUR.fortran_dp_name)
 
         for model_index in range(self.input_param.strategy.model_num):
             model_name_i = "{}/{}".format(make_train_name(model_index), model_name)

pwact/active_learning/slurm.py

@@ -154,31 +154,33 @@ class SlurmJob(object):
     def check_lammps_out_file(self):
         # read last line of md.log file
         md_dirs = self.get_slurm_works_dir()
-        for md_dir in md_dirs:
-            tag_md_file = os.path.join(md_dir, "tag.md.success")
-            md_log = os.path.join(md_dir, "md.log")
-            if os.path.exists(tag_md_file):
-                continue
-            if not os.path.exists(md_log):
-                return False
-
-            with open(md_log, "rb") as file:
-                file.seek(-2, 2)  # 定位到文件末尾前两个字节
-                while file.read(1) != b'\n':  # 逐字节向前查找换行符
-                    file.seek(-2, 1)  # 向前移动两个字节
-                last_line = file.readline().decode().strip()  # 读取最后一行并去除换行符和空白字符
-            if "ERROR: there are two atoms" in last_line:
-                with open(tag_md_file, 'w') as wf:
-                    wf.writelines("ERROR: there are two atoms too close")
-                return True
-            elif "Total wall time" in last_line:
-                with open(tag_md_file, 'w') as wf:
-                    wf.writelines("Job Done!")
-                return True
-            else:
-                return False
+        try:
+            for md_dir in md_dirs:
+                tag_md_file = os.path.join(md_dir, "tag.md.success")
+                md_log = os.path.join(md_dir, "md.log")
+                if os.path.exists(tag_md_file):
+                    continue
+                if not os.path.exists(md_log):
+                    return False
 
-        return True
+                with open(md_log, "rb") as file:
+                    file.seek(-2, 2)  # 定位到文件末尾前两个字节
+                    while file.read(1) != b'\n':  # 逐字节向前查找换行符
+                        file.seek(-2, 1)  # 向前移动两个字节
+                    last_line = file.readline().decode().strip()  # 读取最后一行并去除换行符和空白字符
+                if "ERROR: there are two atoms" in last_line:
+                    with open(tag_md_file, 'w') as wf:
+                        wf.writelines("ERROR: there are two atoms too close")
+                    return True
+                elif "Total wall time" in last_line:
+                    with open(tag_md_file, 'w') as wf:
+                        wf.writelines("Job Done!")
+                    return True
+                else:
+                    return False
+            return True
+        except Exception as e:
+            return False
 
 
 class Mission(object):
@@ -302,7 +304,7 @@ class Mission(object):
         for job in self.job_list:
             if job.status == JobStatus.terminated:
                 if job.submit_num <= JobStatus.submit_limit.value:
-                    print("resubmit job: {}, the time is {}\n".format(job.submit_cmd, job.submit_num))
+                    print("resubmit job {}: {}, the time is {}\n".format(job.jobid, job.submit_cmd, job.submit_num))
                     job.submit()
                 else:
                     job.status = JobStatus.resubmit_failed                    

pwact/active_learning/test/test.py

@@ -36,7 +36,33 @@ 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 config", type=str, default='atom.config')
@@ -44,33 +70,6 @@ if __name__=="__main__":
     # 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)
-
-    # work_dir = "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory"
-    # data_list = [
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_000_2650",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_001_2650",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_002_2650",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_003_2650",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_004_3858",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_005_3860",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_006_3860",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_007_3859",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_008_700",
-    #     "/data/home/wuxingxing/datas/PWMLFF_library_data/HfO2/hfo2_dpgen/HfO2_liutheory/mvms/sys_009_700"]
-    # work_dir = "/data/home/wuxingxing/datas/al_dir/HfO2/baseline_model"
-
-    # train_job = os.path.join(work_dir, "init_model/train.job")
-    # train_json = os.path.join(work_dir, "init_model/train.json")
-
-    # json_dict = json.load(open(train_json))
-    # for data in data_list:
-    #     data_dir = os.path.join(work_dir, os.path.basename(data))
-    #     if os.path.exists(data_dir):
-    #         shutil.rmtree(data_dir)
-    #     os.makedirs(data_dir)
-    #     shutil.copyfile(train_job, os.path.join(data_dir, "train.job"))
-    #     json_dict["datasets_path"].append(data)
-    #     json.dump(json_dict, open(os.path.join(data_dir, "train.json"), "w"), indent=4)
-    
+    # 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/train_model.py

@@ -9,7 +9,7 @@ from pwact.active_learning.user_input.iter_input import InputParam
 
 from pwact.utils.format_input_output import make_train_name, get_seed_by_time, get_iter_from_iter_name, make_iter_name
 from pwact.utils.constant import AL_STRUCTURE, UNCERTAINTY, TEMP_STRUCTURE, MODEL_CMD, \
-    TRAIN_INPUT_PARAM, TRAIN_FILE_STRUCTUR, FORCEFILED, LABEL_FILE_STRUCTURE, SLURM_OUT
+    TRAIN_INPUT_PARAM, TRAIN_FILE_STRUCTUR, FORCEFILED, LABEL_FILE_STRUCTURE, SLURM_OUT, MODEL_TYPE
 
 from pwact.utils.file_operation import save_json_file, write_to_file, del_dir, search_files, add_postfix_dir, mv_file, copy_dir, del_file_list
 '''
@@ -106,18 +106,20 @@ class ModelTrian(object):
         script = ""
         pwmlff = self.resource.train_resource.command
         script += "{} {} {} >> {}\n\n".format(pwmlff, MODEL_CMD.train, TRAIN_FILE_STRUCTUR.train_json, SLURM_OUT.train_out)
-        if self.input_param.strategy.compress:
-            script += "    {} {} {} -d {} -o {} -s {} >> {}\n\n".format(pwmlff, MODEL_CMD.compress, model_path, \
-                self.input_param.strategy.compress_dx, self.input_param.strategy.compress_order, TRAIN_FILE_STRUCTUR.compree_dp_name, SLURM_OUT.train_out)
-            cmp_model_path = "{}".format(TRAIN_FILE_STRUCTUR.compree_dp_name)
+
+        # do nothing for nep model
+        if self.input_param.train.model_type == MODEL_TYPE.dp:
+            if self.input_param.strategy.compress:
+                script += "    {} {} {} -d {} -o {} -s {}/{} >> {}\n\n".format(pwmlff, MODEL_CMD.compress, model_path, \
+                    self.input_param.strategy.compress_dx, self.input_param.strategy.compress_order, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.compree_dp_name, SLURM_OUT.train_out)
+                cmp_model_path = "{}/{}".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.compree_dp_name)
             
-        if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
-            if cmp_model_path is None:
-                # script model_record/dp_model.ckpt the torch_script_module.pt will in model_record dir
-                script += "    {} {} {} >> {}\n".format(pwmlff, MODEL_CMD.script, model_path, SLURM_OUT.train_out)
-                script += "    mv ./{}/{} .\n\n".format(TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name)
-            else:
-                script += "    {} {} {} >> {}\n\n".format(pwmlff, MODEL_CMD.script, cmp_model_path, SLURM_OUT.train_out)
+            if self.input_param.strategy.md_type == FORCEFILED.libtorch_lmps:
+                if cmp_model_path is None:
+                    # script model_record/dp_model.ckpt the torch_script_module.pt will in model_record dir
+                    script += "    {} {} {} {}/{} >> {}\n".format(pwmlff, MODEL_CMD.script, model_path, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name, SLURM_OUT.train_out)
+                else:
+                    script += "    {} {} {} {}/{} >> {}\n\n".format(pwmlff, MODEL_CMD.script, cmp_model_path, TRAIN_FILE_STRUCTUR.model_record, TRAIN_FILE_STRUCTUR.script_dp_name, SLURM_OUT.train_out)
         return script
 
     '''

pwact/active_learning/user_input/iter_input.py

@@ -3,7 +3,7 @@ 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
+from pwact.active_learning.user_input.train_param.train_param import InputParam as TrainParam
 from pwact.active_learning.user_input.scf_param import SCFParam
 class InputParam(object):
     # _instance = None
@@ -12,7 +12,8 @@ class InputParam(object):
         if not os.path.isabs(self.root_dir):
             self.root_dir = os.path.realpath(self.root_dir)
         self.record_file = get_parameter("record_file", json_dict, "al.record")
-        print("Warning! record_file not provided, automatically set to {}! ".format(self.record_file))
+        if "record_file" not in json_dict.keys():
+            print("Warning! record_file not provided, automatically set to {}! ".format(self.record_file))
         
         self.reserve_work = get_parameter("reserve_work", json_dict, False)
         # self.reserve_feature = get_parameter("reserve_feature", json_dict, False)

pwact/active_learning/user_input/resource.py

@@ -69,7 +69,10 @@ class Resource(object):
         env_script = ""
         if len(source_list) > 0:
             for source in source_list:
-                if "source" != source.split()[0].lower():
+                if "source" != source.split()[0].lower() and \
+                    "export" != source.split()[0].lower() and \
+                        "module" != source.split()[0].lower() and \
+                            "conda" != source.split()[0].lower():
                     tmp_source = "source {}\n".format(source)
                 else:
                     tmp_source = "{}\n".format(source)
@@ -104,4 +107,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

@@ -165,7 +165,7 @@ class DFTInput(object):
 
             if "MP_N123" in key_values and self.kspacing is not None:
                 error_info = "ERROR! The 'kspacing' in DFT/input/{} dict and 'MP_N123' in {} file cannot coexist.\n".format(os.path.basename(self.input_file), os.path.basename(self.input_file))
-                error_info += "If 'MP_N123' is not indicated in DFT/input/{}, we will use 'kspacing' param to generate the 'MP_N123' parameter\n".format(os.path.basename(self.input_file))
+                error_info += "If 'MP_N123' is not indicated in DFT/input/{}, the 'kspacing' param will be used to generate the 'MP_N123' parameter\n".format(os.path.basename(self.input_file))
                 raise Exception(error_info)
             elif "MP_N123" not in key_values and self.kspacing is None:
                 self.kspacing  = 0.5

pwact/active_learning/user_input/train_param/model_param.py

@@ -31,7 +31,8 @@ class NetParam(object):
         if "type_" in self.net_type:
             dicts["physical_property"] = self.physical_property
         #dicts["bias"] = self.bias, 
-        #dicts["resnet_dt"] = self. resnet_dt, 
+        # if self.resnet_dt is False:
+        #     dicts["resnet_dt"] = self.resnet_dt
         #dicts["activation"] = self.activation
         return dicts
 
@@ -40,6 +41,7 @@ class ModelParam(object):
         self.type_embedding_net = None
         self.embedding_net = None
         self.fitting_net = None
+        self.nep_param:NetParam = None
 
     '''
     description: 
@@ -75,7 +77,9 @@ class ModelParam(object):
     def set_nn_fitting_net(self, fitting_net_dict:dict):
         # fitting_net_dict = get_parameter("fitting_net",json_input, {})
         network_size = get_parameter("network_size", fitting_net_dict,[15,15,1])
-        if network_size[-1] != 1:
+        if not isinstance(network_size, list):
+            network_size = [network_size]
+        if len(network_size) > 1 and network_size[-1] != 1:
             raise Exception("Error: The last layer of the fitting network should have a size of 1 for etot energy, but the input size is {}!".format(network_size[-1]))
         bias = True # get_parameter("bias", fitting_net_dict, True)
         resnet_dt = False # get_parameter("resnet_dt", fitting_net_dict, False)
@@ -91,4 +95,3 @@ class ModelParam(object):
     #     #     dicts[self.fitting_net.net_type] = self.fitting_net.to_dict()
     #     return self.fitting_net.to_dict_std()
 
-