pwact 0.1.27__py3-none-any.whl → 0.2.0__py3-none-any.whl

pwact/active_learning/user_input/train_param/work_file_param.py

@@ -7,9 +7,6 @@ class WorkFileStructure(object):
     '''
     description: 
     param {*} self
-    param {*} work_dir:  is the work path, model training, feature generation, and inference work \
-                            are all carried out under the modified directory\
-                                if the user does not set it, it defaults to json_dir
     param {*} json_dir: The trained models, features, and inference results are collected in this directory
     return {*}
     author: wuxingxing
@@ -20,27 +17,32 @@ class WorkFileStructure(object):
         self.reserve_work_dir = reserve_work_dir
         self.reserve_feature = reserve_feature
         self.movement_name = "MOVEMENT"
-        self.raw_path = []
+        # self.raw_path = []
         self.train_feature_path = []
+        self.valid_feature_path = []
         self.test_feature_path = []
-        self.datasets_path = []
+        # self.datasets_path = []
         self.model_load_path = ""
-
+        
+        self.train_data_path = []
+        self.valid_data_path = []
+        self.test_data_path  = []
+        
+        if self.model_type == "NN" or self.model_type == "LINEAR":
+            self._set_NN_PWdata_dirs() 
     # def _set_training_path(self, train_raw_path:list, train_feature_path:list, train_dir: str):
     #     self.raw_path = train_raw_path
     #     self.train_feature_path = train_feature_path
     #     self.train_dir = os.path.join(self.json_dir, train_dir)
 
-    def _set_alive_atomic_energy(self, alive_atomic_energy:bool):
-        self.alive_atomic_energy = alive_atomic_energy
 
-    def _set_data_file_paths(self, trainSetDir:str, dRFeatureInputDir:str, dRFeatureOutputDir:str,\
-                        trainDataPath:str, validDataPath:str):
-        self.trainSetDir = trainSetDir
-        self.dRFeatureInputDir = dRFeatureInputDir# it is not used 2024.04.03
-        self.dRFeatureOutputDir = dRFeatureOutputDir# it is not used 2024.04.03
-        self.trainDataPath = trainDataPath
-        self.validDataPath = validDataPath
+    # def _set_data_file_paths(self, trainSetDir:str, dRFeatureInputDir:str, dRFeatureOutputDir:str,\
+    #                     trainDataPath:str, validDataPath:str):
+    #     self.trainSetDir = trainSetDir
+    #     self.dRFeatureInputDir = dRFeatureInputDir# it is not used 2024.04.03
+    #     self.dRFeatureOutputDir = dRFeatureOutputDir# it is not used 2024.04.03
+    #     self.trainDataPath = trainDataPath
+    #     self.validDataPath = validDataPath
 
     def _set_p_matrix_paths(self, p_path, save_p_matrix:bool):
         self.save_p_matrix = save_p_matrix
@@ -56,30 +58,12 @@ class WorkFileStructure(object):
         self.model_load_path = model_load_path
 
     def set_inference_paths(self, json_input:dict, is_nep_txt:bool=False):
-        # load test files and check if they are exist
-        raw_path = get_parameter("raw_files", json_input, [])
-        for raw_data in raw_path:
-            if os.path.exists(raw_data) is False:
-                raise Exception("Error! test data: {} file not exist!".format(raw_data))
-        raw_path = [os.path.abspath(_) for _ in raw_path]
-        self.raw_path = raw_path
-        datasets_path = get_parameter("datasets_path", json_input, [])
-        if isinstance(datasets_path, list) is False:
-            datasets_path = [datasets_path]
-        for data_path in datasets_path:
-            if os.path.exists(data_path) is False:
-                raise Exception("{} file is not exists, please check!".format(data_path))
-        
         test_dir_name = get_parameter("test_dir_name", json_input, "test_result")
-        self.test_dir = os.path.join(self.json_dir, test_dir_name)
-
-        '''test_feature_path = get_parameter("test_feature_path", json_input, [])
-        for feat_path in test_feature_path:
-            if os.path.exists(feat_path) is False:
-                raise Exception("Error! test_feature_path {} does not exist!".format(feat_path))
-        test_feature_path = [os.path.abspath(_) for _ in test_feature_path]
-        self.test_feature_path = test_feature_path'''
-        self.datasets_path = [os.path.abspath(_) for _ in datasets_path]
+        
+        if json_input["model_type"].upper() in ["LINEAR", "NN"]:
+            self.test_dir = os.path.join(self.nn_work, test_dir_name)
+        else:
+            self.test_dir = os.path.join(self.json_dir, test_dir_name)
 
         if not json_input["model_type"].upper() == "LINEAR":
             if is_nep_txt:
@@ -90,8 +74,8 @@ class WorkFileStructure(object):
                 if os.path.exists(self.model_load_path) is False:
                     raise Exception("the model_load_path is not exist: {}, please speccified 'model_load_path' at json file".format(self.model_load_path))
         
-        if "trainDataPath" in json_input.keys():# for test, people could set the 'trainSetDir' to 'valid', so the valid data in train dir could be used for valid
-            self.trainDataPath = json_input["trainDataPath"]
+        # if "trainDataPath" in json_input.keys():# for test, people could set the 'trainSetDir' to 'valid', so the valid data in train dir could be used for valid
+        #     self.trainDataPath = json_input["trainDataPath"]
 
         '''alive_atomic_energy = is_alive_atomic_energy(datasets_path)
         self._set_alive_atomic_energy(alive_atomic_energy)'''
@@ -109,11 +93,17 @@ class WorkFileStructure(object):
     def set_train_feature_path(self, feature_path:list):
         self.train_feature_path.extend(feature_path)
 
+    def set_valid_feature_path(self, feature_path:list):
+        self.valid_feature_path.extend(feature_path)
+
     def set_test_feature_path(self, feature_path:list):
         self.test_feature_path.extend(feature_path)
 
+    # delete in 2025
     def set_datasets_path(self, datasets_path:list):
-        self.datasets_path.extend(datasets_path)
+        pass
+        # self.datasets_path.extend(datasets_path)
+
 
     '''
     description: 
@@ -143,7 +133,6 @@ class WorkFileStructure(object):
         best_model_path = os.path.join(self.json_dir, "best_model.ckpt")
         forcefield_name = get_parameter("forcefield_name", json_input, "forcefield.ff")
         forcefield_dir = get_parameter("forcefield_dir", json_input, "forcefield")
-        self.set_forcefield_path(forcefield_dir, forcefield_name)
         # p matix, resume p matrix when recover is not realized
         # p matrix should extract to checkpoint files or a single file.
         # current not realized
@@ -156,79 +145,112 @@ class WorkFileStructure(object):
 
         # common dir 
         model_store_dir = get_parameter("model_store_dir", json_input, "model_record")
-        model_store_dir = os.path.join(self.json_dir, model_store_dir)
+        if self.model_type == "NN":
+            model_store_dir = os.path.join(self.nn_work, model_store_dir)
+            self.forcefield_dir = os.path.join(self.nn_work, forcefield_dir)
+            self.forcefield_name = forcefield_name
+        else:
+            self.forcefield_dir = os.path.join(self.json_dir, forcefield_dir)
+            self.forcefield_name = forcefield_name
+            model_store_dir = os.path.join(self.json_dir, model_store_dir)
         self._set_model_paths(model_store_dir = model_store_dir, \
                                     model_name = model_name, best_model_path=best_model_path)
-        self._set_PWdata_dirs(json_input)
+        
+        # self._set_PWdata_dirs(json_input)
 
     def set_train_valid_file(self, json_input:dict):
         # set trian movement file path
-        raw_path = get_parameter("raw_files", json_input, [])
-        for raw_data in raw_path:
-            if os.path.exists(raw_data) is False:
-                raise Exception("Error! train data: {} file not exist!".format(raw_data))
-        # set train feature path
-        raw_path = [os.path.abspath(_) for _ in raw_path]
-        self.raw_path = raw_path
-        datasets_path = get_parameter("datasets_path", json_input, [])
-        for data_path in datasets_path:
-            if os.path.exists(data_path) is False:
-                raise Exception("Error! train data: {} file not exist!".format(data_path))
-        datasets_path = [os.path.abspath(_) for _ in datasets_path]
-        self.datasets_path = datasets_path
-        '''if len(raw_path) > 0:
-            raw_path = sorted(raw_path)
+        self.format = get_parameter("format", json_input, "pwmat/movement").lower() # used in new file and raw_file
+        if self.model_type.upper() in ["NN", "LINEAR"]:
+            if self.format != "pwmat/movement":
+                raise Exception("Error! For NN or Linear model, the input 'format' should be 'pwmat/movement'!")
+        train_data = get_parameter("train_data", json_input, [])
+        
+        for _train_data in train_data:
+            if os.path.exists(_train_data) is False:
+                raise Exception("Error! train data: {} file not exist!".format(_train_data))
+            else:
+                self.train_data_path.append(os.path.abspath(_train_data))
+        valid_data = get_parameter("valid_data", json_input, [])
+        for _valid_data in valid_data:
+            if os.path.exists(_valid_data) is False:
+                raise Exception("Error! valid data: {} file not exist!".format(_valid_data))
+            else:
+                self.valid_data_path.append(os.path.abspath(_valid_data))
+        test_data = get_parameter("test_data", json_input, [])
+        for _test_data in test_data:
+            if os.path.exists(_test_data) is False:
+                raise Exception("Error! test data: {} file not exist!".format(_test_data))
+            else:
+                self.test_data_path.append(os.path.abspath(_test_data))
+
+        if self.format == "pwmat/movement": # for nn
+            self.alive_atomic_energy = False
+            if len(self.train_data_path) > 0:
+                alive_atomic_energy = is_alive_atomic_energy(self.train_data_path)
+                self.alive_atomic_energy = alive_atomic_energy
+
+            if len(self.valid_data_path) > 0:
+                alive_atomic_energy = is_alive_atomic_energy(self.valid_data_path)
+                self.alive_atomic_energy = alive_atomic_energy
+            
+            if len(self.test_data_path) > 0:
+                alive_atomic_energy = is_alive_atomic_energy(self.test_data_path)
+                self.alive_atomic_energy = alive_atomic_energy
+
+    def set_nn_file(self, json_input:dict):
+        self.train_feature_path = []
+        self.valid_feature_path = []
+        self.test_feature_path  = []
         train_feature_path = get_parameter("train_feature_path", json_input, [])
         for feat_path in train_feature_path:
             if os.path.exists(feat_path) is False:
-                raise Exception("Error! train movement: {} file not exist!".format(feat_path))
-        train_feature_path = [os.path.abspath(_) for _ in train_feature_path]
-        self._set_training_path(raw_path=raw_path, 
-                                      train_feature_path=train_feature_path,
-                                      train_dir=os.path.join(self.work_dir, "feature"))
-        
-        alive_atomic_energy = get_parameter("alive_atomic_energy", json_input, False)
-        alive_atomic_energy = is_alive_atomic_energy(raw_path)
-        self._set_alive_atomic_energy(alive_atomic_energy)'''
+                raise Exception("Error! train_feature_path: {} file not exist!".format(feat_path))
+        self.train_feature_path = [os.path.abspath(_) for _ in train_feature_path]
 
-    def _set_PWdata_dirs(self, json_input:dict):
+        valid_feature_path = get_parameter("valid_feature_path", json_input, [])
+        for feat_path in valid_feature_path:
+            if os.path.exists(feat_path) is False:
+                raise Exception("Error! valid_feature_path: {} file not exist!".format(feat_path))
+        self.valid_feature_path = [os.path.abspath(_) for _ in valid_feature_path]
+
+        test_feature_path = get_parameter("test_feature_path", json_input, [])
+        for feat_path in test_feature_path:
+            if os.path.exists(feat_path) is False:
+                raise Exception("Error! test_feature_path: {} file not exist!".format(feat_path))
+        self.test_feature_path = [os.path.abspath(_) for _ in test_feature_path]
+        
+    def _set_NN_PWdata_dirs(self):
         # set Pwdata dir file structure, they are used in feature generation
-        trainSetDir = get_parameter("trainSetDir", json_input, 'PWdata')
-        dRFeatureInputDir = get_parameter("dRFeatureInputDir", json_input, 'input')# it is not used 2024.04.03
-        dRFeatureOutputDir = get_parameter("dRFeatureOutputDir", json_input, 'output')# it is not used 2024.04.03
-        trainDataPath = get_parameter("trainDataPath", json_input, 'train')
-        validDataPath = get_parameter("validDataPath", json_input, 'valid')
-        self._set_data_file_paths(trainSetDir, dRFeatureInputDir, dRFeatureOutputDir, trainDataPath, validDataPath)
+        self.nn_work = os.path.join(os.getcwd(), "work_dir") # the work dir of nn training or test 
+        self.trainSetDir = 'PWdata'
+        self.dRFeatureInputDir = 'input'# it is not used 2024.04.03
+        self.dRFeatureOutputDir = 'output'# it is not used 2024.04.03
+        # self.trainDataPath = 'train'
+        # self.validDataPath = 'valid'
+        # self._set_data_file_paths(trainSetDir, dRFeatureInputDir, dRFeatureOutputDir, trainDataPath, validDataPath)
 
     def set_nep_native_file_paths(self):
-        self.nep_train_xyz_path = "train.xyz"
-        self.nep_test_xyz_path = "test.xyz"
-        self.nep_in_file = "nep.in"
-        self.nep_model_file = "nep_to_lmps.txt"
-        self.nep_restart_file = "nep.restart"
+        self.nep_model_file = "nep5.txt"
                                  
     def get_data_file_structure(self):
         file_dict = {}
         file_dict["trainSetDir"] = self.trainSetDir
         file_dict["dRFeatureInputDir"] = self.dRFeatureInputDir
         file_dict["dRFeatureOutputDir"] = self.dRFeatureOutputDir
-        file_dict["trainDataPath"] = self.trainDataPath
-        file_dict["validDataPath"] = self.validDataPath
+        # file_dict["trainDataPath"] = self.trainDataPath
+        # file_dict["validDataPath"] = self.validDataPath
         return file_dict
 
-    def set_forcefield_path(self, forcefield_dir:str, forcefield_name:str):
-        self.forcefield_dir = os.path.join(self.json_dir, forcefield_dir)
-        self.forcefield_name = forcefield_name
-
     def to_dict(self):
         dicts = {}
-        # dicts["work_dir"] = self.work_dir
-        # dicts["reserve_work_dir"] = self.reserve_work_dir
-
+        dicts["format"] = self.format     
         if self.model_load_path is not None and os.path.exists(self.model_load_path):
             dicts["model_load_file"] = self.model_load_path
-        if len(self.datasets_path) > 0:
-            dicts["datasets_path"] = self.datasets_path
-            # dicts["model_store_dir"] = self.model_store_dir
-
+        if len(self.train_data_path) > 0:
+            dicts["train_data"] = self.train_data_path
+        if len(self.valid_data_path) > 0:
+            dicts["valid_data"] = self.valid_data_path
+        if len(self.test_data_path) > 0:
+            dicts["test_data"] = self.test_data_path
         return dicts

pwact/data_format/configop.py

@@ -58,9 +58,9 @@ def save_config(config, input_format:str = None, wrap = False, direct = True, so
         write_to_file(os.path.join(save_path, CP2K.cell_txt), lattice_line, 'w')
 
     else:
-        config.to(output_path=save_path, 
+        config.to(data_path  =save_path, 
                 data_name    =save_name, 
-                save_format  =save_format, 
+                format       =save_format, 
                 direct       =direct, 
                 sort         =sort, 
                 wrap         =wrap
@@ -90,9 +90,9 @@ def do_super_cell(config_file, input_format:str=None, supercell_matrix:list[int]
     # Make a supercell     
     supercell = make_supercell(config, supercell_matrix, pbc)
     # Write out the structure
-    supercell.to(output_path = save_path,
-                data_name = save_name,
-                save_format = save_format,
+    supercell.to(data_path = save_path,
+                data_name  = save_name,
+                format     = save_format,
                 direct = direct,
                 sort = sort)
     return os.path.join(save_path, save_name)
@@ -101,9 +101,9 @@ def do_scale(config, input_format:str=None, scale_factor:float=None,
             direct:bool=True, sort:bool=True, save_format:str=None, save_path:str=None, save_name:str=None):
     config = Config(format=input_format, data_path=config)
     scaled_struct = scale_cell(config, scale_factor)
-    scaled_struct.to(output_path = save_path,
-                    data_name = save_name,
-                    save_format = save_format,
+    scaled_struct.to(data_path = save_path,
+                    data_name  = save_name,
+                    format     = save_format,
                     direct = direct,
                     sort = sort)
      
@@ -123,9 +123,9 @@ def do_pertub(config, input_format:str=None, pert_num:int=None, cell_pert_fracti
             atom_pert_distance = atom_pert_distance)
 
     for tmp_perturbed_idx, tmp_pertubed_struct in enumerate(perturbed_structs):
-        tmp_pertubed_struct.to(output_path = save_path,
+        tmp_pertubed_struct.to(data_path  = save_path,
                                 data_name = "{}_{}".format(tmp_perturbed_idx, save_name),
-                                save_format = save_format,
+                                format    = save_format,
                                 direct = direct,
                                 sort = sort)
 
@@ -133,35 +133,33 @@ def do_pertub(config, input_format:str=None, pert_num:int=None, cell_pert_fracti
 
 '''
 description: 
-    if merge is ture, save pwdata to datasets_path/data_name ...
-    else:
-        save pwdata to datasets_path/data_name/train or valid
+    save the inputfiles to pwmlff/npy format data
 return {*}
 author: wuxingxing
 '''
-def extract_pwdata(data_list:list[str], 
-                data_format:str="pwmat/movement", 
-                datasets_path="PWdata", 
-                train_valid_ratio:float=0.8, 
-                data_shuffle:bool=True,
-                merge_data:bool=False,
+def extract_pwdata(input_data_list:list[str], 
+                intput_data_format:str="pwmat/movement", 
+                save_data_path:str="./",
+                save_data_name="PWdata", 
+                save_data_format="extxyz",
+                data_shuffle:bool=False,
                 interval:int=1
                 ):
     # if data_format == DFT_STYLE.cp2k:
     #     raise Exception("not relized cp2k pwdata convert")
 
-    if not os.path.isabs(datasets_path):
+    if not os.path.isabs(save_data_path):
         # data_name = datasets_path
-        datasets_path = os.path.join(os.getcwd(), datasets_path)
+        save_data_path = os.path.join(os.getcwd(), save_data_path)
     image_data = None
-    for data_path in data_list:
+    for dir in input_data_list:
         if image_data is not None:
-            tmp_config = Config(data_format, data_path)
+            tmp_config = Config(format=intput_data_format, data_path=dir)
             # if not isinstance(tmp_config, list):
             #     tmp_config = [tmp_config]
             image_data.images.extend(tmp_config.images)
         else:
-            image_data = Config(data_format, data_path)
+            image_data = Config(format=intput_data_format, data_path=dir)
             
             if not isinstance(image_data.images, list):
                 image_data.images = [image_data.images]
@@ -176,14 +174,10 @@ def extract_pwdata(data_list:list[str],
         image_data.images = tmp
 
     image_data.to(
-                output_path=datasets_path,
-                save_format=PWDATA.pwmlff_npy,
-                train_ratio = train_valid_ratio, 
-                train_data_path="train", 
-                valid_data_path="valid", 
-                random=data_shuffle,
-                seed = 2024, 
-                retain_raw = False
+                data_path  =save_data_path,
+                data_name  =save_data_name,
+                format     =save_data_format,
+                random=data_shuffle
                 )
     
 if __name__ == "__main__":
@@ -275,8 +269,7 @@ if __name__ == "__main__":
                 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
+    extract_pwdata(input_data_list=data_list, 
+            intput_data_format="vasp/outcar", 
+            save_data_path=datasets_path
             )

pwact/main.py

@@ -24,14 +24,14 @@ from pwact.active_learning.environment import check_envs
 
 from pwact.data_format.configop import extract_pwdata
 from pwact.active_learning.explore.select_image import select_image, print_select_image
-from pwact.utils.process_tool import kill_process
+from pwact.utils.process_tool import kill_process, get_pid
 def run_iter():
     system_json = json.load(open(sys.argv[2]))
     if "work_dir" in system_json.keys():
         os.chdir(system_json["work_dir"])
-    pid = os.getpid()
+    pid = get_pid()
     with open("./PID", 'w') as wf:
-        wf.write(str(pid))
+        wf.write(pid)
 
     system_info = convert_keys_to_lowercase(system_json)
     machine_json = json.load(open(sys.argv[3]))
@@ -149,9 +149,9 @@ def init_bulk():
     system_info = convert_keys_to_lowercase(system_json)
     if "work_dir" in system_json.keys():
         os.chdir(system_json["work_dir"])
-    pid = os.getpid()
+    pid = get_pid()
     with open("./PID", 'w') as wf:
-        wf.write(str(pid))
+        wf.write(pid)
 
     machine_info = convert_keys_to_lowercase(json.load(open(sys.argv[3])))
     input_param = InitBulkParam(system_info)
@@ -163,35 +163,6 @@ def init_bulk():
     init_bulk_run(resource, input_param)
     print("Init Bulk Work Done!")
 
-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('-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='./')
-    args = parser.parse_args(input_cmds)
-    print(args.work_dir)
-    os.chdir(args.work_dir)
-
-    extract_pwdata(data_list=args.input, 
-                data_format=args.format, 
-                datasets_path=args.savepath, 
-                train_valid_ratio=args.train_valid_ratio, 
-                data_shuffle=args.data_shuffle,
-                merge_data=args.merge,
-                interval = args.gap
-                )
-    
-
 def gather_pwmata(input_cmds):
     parser = argparse.ArgumentParser()
     parser.add_argument('-i', '--input_dir', help="specify the dir above the iterations, the default dir is current dir './'\nthe result could be found in './final_pwdata'", type=str, default='./')
@@ -267,10 +238,12 @@ def kill_job():
     #     os.chdir(system_json["work_dir"])
     try:
         with open("./PID", 'r') as rf:
-            pid = rf.readline()
-    except:
+            pid_str_info = rf.readline().split()
+            pid = pid_str_info[1]
+            jobid = pid_str_info[3] if "job" in pid_str_info else None
+    except :
         raise Exception("Error parsing PID file !")
-    kill_process(int(pid))
+    kill_process(pid, jobid)
     if sys.argv[2].lower() == "init_bulk":
         # search all jobs
         init_scancel_jobs(os.getcwd())
@@ -349,7 +322,7 @@ def main():
 
     elif "to_pwdata".upper() == sys.argv[1].upper():#these function may use pwdata command
         print("\n\nWarning! This method has been abandoned, new conversion methods refer to the pwdata documentation http://doc.lonxun.com/PWMLFF/Appendix-2/\n\n")
-        to_pwdata(sys.argv[2:])
+        # to_pwdata(sys.argv[2:])
  
     elif "run".upper() == sys.argv[1].upper():
         if len(sys.argv) == 2 or "-h".upper() == sys.argv[2].upper() or \

pwact/utils/app_lib/cp2k.py

@@ -194,6 +194,7 @@ def make_cp2k_input_from_external(cell, coord_file, exinput_path, gaussian_base_
     # read the input content as string
     with open(exinput_path) as f:
         exinput = f.readlines()
+    exinput = [line.upper() for line in exinput]
     # replace the cell string
     start_cell = 0
     end_cell = 0
@@ -210,7 +211,9 @@ def make_cp2k_input_from_external(cell, coord_file, exinput_path, gaussian_base_
     end_dft = 0
     basis_set_file_name = -1
     potential_file_name = -1
-
+    start_kpoint = -1
+    end_kpoint = -1
+    kpoint_line = 0
     # delete the BASIS_SET_FILE_NAME and POTENTIAL_FILE_NAME line
     for line_idx, line in enumerate(exinput):
         line = line.upper()
@@ -222,15 +225,50 @@ def make_cp2k_input_from_external(cell, coord_file, exinput_path, gaussian_base_
             basis_set_file_name = line_idx
         if "POTENTIAL_FILE_NAME" in line:
             potential_file_name = line_idx
+        if "&KPOINTS" in line:
+            start_kpoint = line_idx
+        if "&END KPOINTS" in line:
+            end_kpoint = line_idx
+        if "MONKHORST-PACK" in line:
+            kpoint_line = line_idx
+    
     if start_dft == end_dft:
         raise Exception("{} extarcted error! Can not find DFT set!".format(exinput_path))
+    
+    # set kspacing and pseudo file
+    if gaussian_base_param["KSPACING"] is not None and kpoint_line > 0:
+        raise Exception("The 'kspacing' in 'gaussian_param' and 'KPOINTS' in {} file cannot be set set simultaneously!".format(os.path.basename(exinput_path)))
+    elif gaussian_base_param["KSPACING"] is None and kpoint_line == 0:
+        kspacing_content = make_kspacing_kpoints(cell, 0.5)
+    elif gaussian_base_param["KSPACING"] is not None:
+        kspacing_content = make_kspacing_kpoints(cell, gaussian_base_param["KSPACING"])
+    else:
+        kspacing_content = "\n".join(exinput[start_kpoint:end_kpoint+1])
     basis_set_file_name, potential_file_name = sorted([basis_set_file_name, potential_file_name], reverse=True)
-    if basis_set_file_name != -1:
-        exinput.pop(basis_set_file_name)
-    if potential_file_name != -1:
-        exinput.pop(potential_file_name)
+    if kpoint_line > 0:
+        if start_kpoint > basis_set_file_name:
+            for del_idx in list(range(end_kpoint, start_kpoint-1, -1)):
+                exinput.pop(del_idx)
+            if basis_set_file_name != -1:
+                exinput.pop(basis_set_file_name)
+            if potential_file_name != -1:
+                exinput.pop(potential_file_name)
+        else:
+            if basis_set_file_name != -1:
+                exinput.pop(basis_set_file_name)
+            if potential_file_name != -1:
+                exinput.pop(potential_file_name)
+            for del_idx in list(range(end_kpoint, start_kpoint-1, -1)):
+                exinput.pop(del_idx)
+    else:
+        if basis_set_file_name != -1:
+            exinput.pop(basis_set_file_name)
+        if potential_file_name != -1:
+            exinput.pop(potential_file_name)
+    
     exinput.insert(start_dft+1, "    BASIS_SET_FILE_NAME {}\n".format(gaussian_base_param["BASIS_SET_FILE_NAME"]))
     exinput.insert(start_dft+2, "    POTENTIAL_FILE_NAME {}\n".format(gaussian_base_param["POTENTIAL_FILE_NAME"]))
+    exinput.insert(start_dft+3, kspacing_content)
     
     for line_idx, line in enumerate(exinput):
         line = line.upper()
@@ -326,6 +364,25 @@ def get_atom_type_from_config(coord_file:str):
             continue
     return res
 
+def _reciprocal_box(box):
+    rbox = np.linalg.inv(box)
+    rbox = rbox.T
+    return rbox
+
+def make_kspacing_kpoints(lattice, kspacing):
+    rbox = _reciprocal_box(lattice)
+    kpoints = [
+        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]
+    ret = "    &KPOINTS\n"
+    ret += "        SCHEME MONKHORST-PACK %d %d %d\n" % (kpoints[0], kpoints[1], kpoints[2])
+    ret += "    &END KPOINTS\n"
+    return ret
+    # ret = _make_pwmat_kp_mp(kpoints)
+
 # if __name__=="__main__":
 #     import dpdata
 #     poscar = "/data/home/wuxingxing/datas/al_dir/si_4_vasp/init_bulk/collection/init_config_0/0.9_scale.poscar"

pwact/utils/app_lib/lammps.py

@@ -24,7 +24,7 @@ def make_pair_style(md_type, forcefiled, atom_type:list[int], dump_info:str):
         pair_names = ""
         for fi in forcefiled:
             pair_names += "{} ".format(os.path.basename(fi))
-        pair_style = "pair_style   pwmlff   {} {} {}\n".format(len(forcefiled), pair_names, dump_info)
+        pair_style = "pair_style   matpl  {} {}\n".format(pair_names, dump_info)
     atom_names = " ".join(map(str, atom_type))
     pair_style += "pair_coeff       * * {}\n".format(atom_names)
     return pair_style