pwact 0.1.28__py3-none-any.whl → 0.2.1__py3-none-any.whl

pwact/active_learning/user_input/init_bulk_input.py

@@ -26,13 +26,15 @@ class InitBulkParam(object):
             sys_configs = [sys_configs]
 
         # set sys_config detail
-        self.dft_style = get_required_parameter("dft_style", json_dict).lower()
+        self.dft_style = get_parameter("dft_style", json_dict, "PWMAT").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
+        self.is_bigmodel=False
+        self.is_direct = False
         for index, config in enumerate(sys_configs):
             stage = Stage(config, index, sys_config_prefix, self.dft_style)
             self.sys_config.append(stage)
@@ -42,22 +44,46 @@ class InitBulkParam(object):
                 self.is_aimd = True
             if stage.scf:
                 self.is_scf = True
+            if stage.bigmodel:
+                self.is_bigmodel = True
+            if stage.direct:
+                self.is_direct = 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_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)
+        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,
+                                    is_bigmodel=self.is_bigmodel,
+                                    is_direct=self.is_direct)
+        
         # 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_bigmodel:
+                if config.bigmodel_input_idx >= len(self.dft_input.bigmodel_input_list):
+                    raise Exception("Error! for script '{}' 'bigmodel_input_idx' {} not in 'bigmodel_input'!".format(os.path.basename(config.config_file), config.bigmodel_input_idx))
+                config.set_bigmodel_input_file(self.dft_input.bigmodel_input_list[config.bigmodel_input_idx])
+
+            if self.is_direct:
+                if config.direct_input_idx >= len(self.dft_input.direct_input_list):
+                    raise Exception("Error! for script '{}' 'direct_input_idx' {} not in 'direct_input'!".format(os.path.basename(config.config_file), config.direct_input_idx))
+                config.set_direct_input_file(self.dft_input.direct_input_list[config.direct_input_idx])
+
+            # check and set aimd etot.input file
             if self.is_aimd:
                 if config.aimd_input_idx >= len(self.dft_input.aimd_input_list):
                     raise Exception("Error! for config '{}' 'aimd_input_idx' {} not in 'aimd_input'!".format(os.path.basename(config.config_file), config.aimd_input_idx))
@@ -77,16 +103,29 @@ class Stage(object):
         self.format = get_parameter("format", json_dict, PWDATA.pwmat_config).lower()
         self.pbc = get_parameter("pbc", json_dict, [1,1,1])
         # extract config file to Config object, then use it
-        self.relax = get_parameter("relax", json_dict, True)
+        self.relax = get_parameter("relax", json_dict, False)
         self.relax_input_idx = get_parameter("relax_input_idx", json_dict, 0)
         self.relax_input_file = None
         
-        self.aimd = get_parameter("aimd", json_dict, True)
+        self.aimd = get_parameter("aimd", json_dict, False)
         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)
+        self.scf_input_idx = get_parameter("scf_input_idx", json_dict, 0)
+        self.scf_input_file = None
 
+        self.bigmodel = get_parameter("bigmodel", json_dict, False)
+        self.bigmodel_input_idx = get_parameter("bigmodel_input_idx", json_dict, 0)
+        self.bigmodel_script = None
+
+        self.direct = get_parameter("direct", json_dict, False)
+        self.direct_input_idx = get_parameter("direct_input_idx", json_dict, 0)
+        self.direct_script = None
+        
+        if self.bigmodel and self.aimd:
+            raise Exception("ERROR! The 'aimd' and 'bigmodel' cannot be set simultaneously!")
+        
         super_cell = get_parameter("super_cell", json_dict, [])
         super_cell = str_list_format(super_cell)
         if len(super_cell) > 0:
@@ -131,3 +170,13 @@ class Stage(object):
         self.aimd_flag_symm = input_file.flag_symm
         self.use_dftb = input_file.use_dftb
         self.use_skf = input_file.use_skf
+
+    def set_bigmodel_input_file(self, input_file:DFTInput):
+        self.bigmodel_input_file = input_file.input_file
+        self.bigmodel_kspacing = input_file.kspacing 
+        self.bigmodel_flag_symm = input_file.flag_symm
+
+    def set_direct_input_file(self, input_file:DFTInput):
+        self.direct_input_file = input_file.input_file
+        self.direct_kspacing = input_file.kspacing 
+        self.direct_flag_symm = input_file.flag_symm

pwact/active_learning/user_input/iter_input.py

@@ -105,6 +105,18 @@ class StrategyParam(object):
             if self.compress:
                 error_log = "Error! the kpu uncertainty does not support compress, please set the 'compress' in strategy dict to be false!"
                 raise Exception(error_log)
+        
+        self.direct = get_parameter("direct", json_dict, False)
+        if self.direct:
+            self.direct_script = get_parameter("direct_script", json_dict, None)
+            if self.direct_script is not None:
+                self.direct_script = os.path.abspath(self.direct_script)
+                if not os.path.exists(self.direct_script):
+                    raise Exception("ERROR! The direct script {} does not exist!".format(self.direct_script))
+            else:
+                raise Exception("ERROR! The direct script does not exist!")
+        else:
+            self.direct_script = None
 
     def to_dict(self):
         res = {}

pwact/active_learning/user_input/resource.py

@@ -20,10 +20,22 @@ class Resource(object):
             if "-in" in self.explore_resource.command:
                 self.explore_resource.command = self.explore_resource.command.split('-in')[0].strip()
             self.explore_resource.command = "{} -in {} > {}".format(self.explore_resource.command, LAMMPS.input_lammps, SLURM_OUT.md_out)
-
+        else:
+            if "explore" in json_dict.keys():
+                self.explore_resource = self.get_resource(get_required_parameter("explore", json_dict))
+            else:
+                self.explore_resource = None
         # check dft resource
-        self.dft_resource = self.get_resource(get_required_parameter("dft", json_dict))
-        
+        if "dft" in json_dict.keys():
+            self.dft_resource = self.get_resource(get_required_parameter("dft", json_dict))
+        else:
+            self.dft_resource = ResourceDetail("mpirun -np 1 PWmat", 1, 1, 1, 1, 1, None, None, None)
+
+        if "direct" in json_dict.keys():
+            self.direct_resource = self.get_resource(get_required_parameter("direct", json_dict))
+        else:
+            self.direct_resource = None
+
         if "scf" in json_dict.keys():
             self.scf_resource = self.get_resource(get_parameter("scf", json_dict, None))
         else:
@@ -33,11 +45,11 @@ class Resource(object):
         #     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():
+        if DFT_STYLE.vasp.lower() == dft_style:
             self.dft_resource.command = "{} > {}".format(self.dft_resource.command, SLURM_OUT.dft_out)
-        elif DFT_STYLE.pwmat.lower() == dft_style.lower():
+        elif DFT_STYLE.pwmat.lower() == dft_style:
             self.dft_resource.command = "{} > {}".format(self.dft_resource.command, SLURM_OUT.dft_out)
-        elif DFT_STYLE.cp2k.lower() == dft_style.lower():
+        elif DFT_STYLE.cp2k.lower() == dft_style:
             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:
@@ -114,7 +126,7 @@ class ResourceDetail(object):
         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!")
         # check param
-        if "$SLURM_NTASKS".lower() in command.lower():
+        if "$SLURM".lower() in command.lower():
             pass
         else:
             if "mpirun -np" in command:

pwact/active_learning/user_input/scf_param.py

@@ -10,7 +10,9 @@ class SCFParam(object):
         is_scf:bool=False, 
         root_dir:str=None, 
         dft_style:str=None,
-        scf_style:str=None) -> None:# for scf relabel in init_bulk
+        scf_style:str=None,
+        is_bigmodel:bool=False,
+        is_direct:bool=False) -> None:# for scf relabel in init_bulk
         
         self.dft_style = dft_style
         self.root_dir = root_dir
@@ -24,12 +26,18 @@ class SCFParam(object):
 
         if is_scf:
             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)
+                if dft_style == DFT_STYLE.bigmodel:
+                    self.bigmodel_script = get_required_parameter("bigmodel_script", json_dict)
+                else:
+                    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 dft_style == DFT_STYLE.bigmodel:
+                    self.bigmodel_script = get_required_parameter("bigmodel_script", json_dict)
+                else:
+                    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)
@@ -40,6 +48,16 @@ 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
+
+        if is_bigmodel: # init_bulk
+            json_bigmodel = get_required_parameter("bigmodel_input", json_dict)
+            self.bigmodel_input_list = self.set_input(json_bigmodel, flag_symm=3) 
+
+        if is_direct: # init_bulk
+            json_direct = get_required_parameter("direct_input", json_dict)
+            self.direct_input_list = self.set_input(json_direct, flag_symm=3) 
+
+        self.scf_max_num = get_parameter("scf_max_num", json_dict, None)
         # for pwmat, use 'pseudo' key
         # for vasp is INCAR file, use 'pseudo' key        
         pseudo = get_parameter("pseudo", json_dict, [])

pwact/active_learning/user_input/train_param/nep_param.py

@@ -250,11 +250,11 @@ class NepParam(object):
             error_log = "the input 'l_max' should has 3 values. The values should be [4, 0, 0] (only use three body features), [4, 2, 0] (use 3 and 4 body features) or [4, 2, 1] (use 3,4,5 body features).\n"
             raise Exception(error_log)
         if "fitting_net" in model_dict.keys():
-            self.neuron = self.get_parameter("network_size", model_dict["fitting_net"], [100]) # number of neurons in the hidden layer
+            self.neuron = self.get_parameter("network_size", model_dict["fitting_net"], [40]) # number of neurons in the hidden layer
             if not isinstance(self.neuron, list):
                 self.neuron = [self.neuron]
         else:
-            self.neuron = [100]
+            self.neuron = [40]
         if self.neuron[-1] != 1:
             self.neuron.append(1) # output layer of fitting net
         self.set_feature_params()

pwact/active_learning/user_input/train_param/optimizer_param.py

@@ -6,7 +6,7 @@ class OptimizerParam(object):
 
     def set_optimizer(self, json_source:dict, nep_param:NepParam=None):
         optimizer_dict = get_parameter("optimizer", json_source, {})
-        self.opt_name = get_parameter("optimizer", optimizer_dict, "LKF")
+        self.opt_name = get_parameter("optimizer", optimizer_dict, "ADAM")
         self.batch_size = get_parameter("batch_size", optimizer_dict, 1)
         self.epochs = get_parameter("epochs", optimizer_dict, 30)
         self.print_freq = get_parameter("print_freq", optimizer_dict, 10)

pwact/active_learning/user_input/train_param/work_file_param.py

@@ -231,7 +231,7 @@ class WorkFileStructure(object):
         # self._set_data_file_paths(trainSetDir, dRFeatureInputDir, dRFeatureOutputDir, trainDataPath, validDataPath)
 
     def set_nep_native_file_paths(self):
-        self.nep_model_file = "nep_to_lmps.txt"
+        self.nep_model_file = "nep5.txt"
                                  
     def get_data_file_structure(self):
         file_dict = {}

pwact/main.py

@@ -5,7 +5,7 @@ import glob
 import sys
 import json
 import argparse
-from pwact.utils.constant import TEMP_STRUCTURE, UNCERTAINTY, AL_WORK, AL_STRUCTURE, LABEL_FILE_STRUCTURE, EXPLORE_FILE_STRUCTURE
+from pwact.utils.constant import TEMP_STRUCTURE, UNCERTAINTY, AL_WORK, AL_STRUCTURE, LABEL_FILE_STRUCTURE, EXPLORE_FILE_STRUCTURE, DFT_STYLE
 from pwact.utils.format_input_output import make_iter_name
 from pwact.utils.file_operation import write_to_file, del_file_list, search_files, del_dir, copy_dir
 from pwact.utils.json_operation import convert_keys_to_lowercase
@@ -79,18 +79,23 @@ def run_iter():
             if jj == 2 and not input_param.reserve_work: # delete temp_work_dir under current iteration after the labeling done
                 del_file_list([os.path.join(input_param.root_dir, iter_name, TEMP_STRUCTURE.tmp_run_iter_dir)])
 
-    print("Active learning done! \nYou could use cmd 'al_pwmlff gather_pwdata' to collect all datas sampled from iterations.")
+    print("Active learning done! \nYou could use cmd 'pwact gather_pwdata' to collect all datas sampled from iterations.")
 
 def run_fp(itername:str, resource : Resource, input_param: InputParam):
     lab = Labeling(itername, resource, input_param)
     #1. if the label work done before, back up and do new work
     lab.back_label()
     #2. make scf work
-    lab.make_scf_work()
-    #3. do scf work
-    lab.do_scf_jobs()
-    #4. collect scf configs outcar or movement, then to pwdata format
-    lab.do_post_labeling()
+    if input_param.dft_style == DFT_STYLE.bigmodel:
+        lab.make_bigmodel_work()
+        lab.do_bigmodel_jobs()
+        lab.do_post_bigmodel()
+    else:
+        lab.make_scf_work()
+        #3. do scf work
+        lab.do_scf_jobs()
+        #4. collect scf configs outcar or movement, then to pwdata format
+        lab.do_post_labeling()
     
 def do_training_work(itername:str, resource : Resource, input_param: InputParam):
     mtrain = ModelTrian(itername, resource, input_param)
@@ -129,8 +134,13 @@ def do_exploring_work(itername:str, resource : Resource, input_param: InputParam
     summary = "{}  {}\n".format(itername, summary)
     write_to_file(os.path.join(input_param.root_dir, EXPLORE_FILE_STRUCTURE.iter_select_file), summary, mode='a')
 
+    if input_param.strategy.direct:
+        md.make_drct_work()
+        md.do_drct_jobs()
+        md.post_drct()
     print("config selection done!")
-    # 5. do post process after lammps md running
+
+    # 5. do post process 
     md.post_process_md()
     print("exploring done!")
 
@@ -236,7 +246,6 @@ def kill_job():
     # system_json = json.load(open(sys.argv[3]))
     # if "work_dir" in system_json.keys():
     #     os.chdir(system_json["work_dir"])
-    os.chdir("/data/home/wuxingxing/codespace/dev_pwact/al_dir/si_5_pwmat/init_bulk")
     try:
         with open("./PID", 'r') as rf:
             pid_str_info = rf.readline().split()

pwact/utils/app_lib/do_direct_sample.py

@@ -0,0 +1,145 @@
+from maml.sampling.direct import DIRECTSampler, BirchClustering, SelectKFromClusters
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mtick
+from ase.io import read
+import subprocess, os, sys
+
+write_file = "select.xyz"
+if os.path.exists(write_file):
+    os.remove(write_file)
+filenames = ["candidate.xyz"]
+k = 1
+threshold = .04
+def load_ase_MD_traj(filenames: list):
+    """
+    Load .traj to pymatgen structures
+    """
+    structs = []
+    trajs = []
+    lens = []
+    for filename in filenames:
+        traj = read(filename,index=":")
+        structs += [i for i in traj]
+        trajs.append(traj)
+        lens.append(len(traj))
+    return structs, trajs, lens
+
+structures, trajs, lens = load_ase_MD_traj(filenames)
+n_image = len(structures)
+
+DIRECT_sampler = DIRECTSampler(
+    clustering=BirchClustering(n=None, threshold_init=threshold), select_k_from_clusters=SelectKFromClusters(k=k)
+)
+
+DIRECT_selection = DIRECT_sampler.fit_transform(structures)
+n, m = DIRECT_selection["PCAfeatures"].shape
+
+explained_variance = DIRECT_sampler.pca.pca.explained_variance_ratio_
+DIRECT_selection["PCAfeatures_unweighted"] = DIRECT_selection["PCAfeatures"] / explained_variance[:m]
+
+plt.plot(
+    range(1, explained_variance.shape[0]+1),
+    explained_variance * 100,
+    "o-",
+)
+plt.xlabel("i$^{\mathrm{th}}$ PC", size=20)
+plt.ylabel("Explained variance", size=20)
+ax = plt.gca()
+ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+plt.tight_layout()
+plt.savefig("PCA_variance.png",dpi=360)
+plt.close()
+
+def plot_PCAfeature_coverage(all_features, selected_indexes, method="DIRECT"):
+    fig, ax = plt.subplots(figsize=(5, 5))
+    selected_features = all_features[selected_indexes]
+    plt.plot(all_features[:, 0], all_features[:, 1], "*", alpha=0.5, label=f"All {len(all_features):,} structures")
+    plt.plot(
+        selected_features[:, 0],
+        selected_features[:, 1],
+        "*",
+        alpha=0.5,
+        label=f"{method} sampled {len(selected_features):,}",
+    )
+    legend = plt.legend(frameon=False, fontsize=14, loc="upper left", bbox_to_anchor=(-0.02, 1.02), reverse=True)
+    #for lh in legend.legendHandles:
+    #    lh.set_alpha(1)
+    plt.ylabel("PC 2", size=20)
+    plt.xlabel("PC 1", size=20)
+
+all_features = DIRECT_selection["PCAfeatures_unweighted"]
+selected_indexes = DIRECT_selection["selected_indexes"]
+plot_PCAfeature_coverage(all_features, selected_indexes)
+plt.tight_layout()
+plt.savefig("PCA_direct.png",dpi=360)
+plt.close()
+
+#manual_selection_index = np.arange(0, n_image, int(n_image/n))
+#plot_PCAfeature_coverage(all_features, manual_selection_index, "Manually")
+#plt.tight_layout()
+#plt.savefig("PCA_manually.png",dpi=360)
+#plt.close()
+
+def calculate_feature_coverage_score(all_features, selected_indexes, n_bins=100):
+    selected_features = all_features[selected_indexes]
+    n_all = np.count_nonzero(
+        np.histogram(all_features, bins=np.linspace(min(all_features), max(all_features), n_bins))[0]
+    )
+    n_select = np.count_nonzero(
+        np.histogram(selected_features, bins=np.linspace(min(all_features), max(all_features), n_bins))[0]
+    )
+    return n_select / n_all
+
+def calculate_all_FCS(all_features, selected_indexes, b_bins=100):
+    select_scores = [
+        calculate_feature_coverage_score(all_features[:, i], selected_indexes, n_bins=b_bins)
+        for i in range(all_features.shape[1])
+    ]
+    return select_scores
+
+all_features = DIRECT_selection["PCAfeatures_unweighted"]
+scores_DIRECT = calculate_all_FCS(all_features, DIRECT_selection["selected_indexes"], b_bins=100)
+#scores_MS = calculate_all_FCS(all_features, manual_selection_index, b_bins=100)
+x = np.arange(len(scores_DIRECT))
+x_ticks = [f"PC {n+1}" for n in range(len(x))]
+
+plt.figure(figsize=(15, 4))
+plt.bar(
+    x,
+    scores_DIRECT,
+    width=0.3,
+    label=f"DIRECT, $\overline{{\mathrm{{Coverage\ score}}}}$ = {np.mean(scores_DIRECT):.3f}",
+)
+#plt.bar(
+#    x + 0.3, scores_MS, width=0.3, label=f"Manual, $\overline{{\mathrm{{Coverage\ score}}}}$ = {np.mean(scores_MS):.3f}"
+#)
+plt.xticks(x, x_ticks, size=16)
+plt.yticks(np.linspace(0, 1.0, 6), size=16)
+plt.ylabel("Coverage score", size=20)
+plt.legend(shadow=True, loc="lower right", fontsize=16)
+plt.tight_layout()
+plt.savefig("Cov_score.png",dpi=360)
+plt.close()
+
+def get2index(num: int, list_lens: list):
+    for idx, i in enumerate(list_lens):
+        if num >= i:
+            num -= i
+        else:
+            break
+    return idx, num
+
+indices = DIRECT_selection["selected_indexes"]
+select_idx = []
+for ii,index in enumerate(indices):
+    idx, num = get2index(index, lens)
+    atoms = trajs[idx][num]
+    angles = atoms.cell.cellpar()[-3:]
+    if angles.max() > 140 or angles.min() < 40:
+        continue
+    else:
+        atoms.set_scaled_positions(atoms.get_scaled_positions())
+        atoms.write(write_file,format="extxyz",append=True)
+        select_idx.append(idx)
+np.savetxt("select_idx.dat",np.array(indices),fmt="%8d")

pwact/utils/app_lib/do_eqv2model.py

@@ -0,0 +1,41 @@
+from ase.io import read
+from fairchem.core import OCPCalculator
+import os
+output_file = 'train.xyz'
+traj = read("select.xyz", index=":")
+calc = OCPCalculator(
+    checkpoint_path="/share/public/PWMLFF_test_data/eqv2-models/eqV2_31M_omat.pt",
+    cpu=False,
+)
+
+def atoms2xyzstr(atoms):
+    num_atom = atoms.get_global_number_of_atoms()
+    vol = atoms.get_volume()
+    pos = atoms.positions
+    forces = atoms.get_forces()
+    energy = atoms.get_potential_energy()
+    cell = atoms.cell
+    virial = -atoms.get_stress(voigt=False) * vol
+    xyzstr = "%d\n" % num_atom
+    xyz_head = 'Lattice="%.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f" Properties=species:S:1:pos:R:3:forces:R:3 energy=%.8f' 
+    xyz_format = (cell[0,0],cell[0,1],cell[0,2],cell[1,0],cell[1,1],cell[1,2],cell[2,0],cell[2,1],cell[2,2],energy)
+    if virial is not None:
+        xyz_head += ' virial="%.8f %.8f %.8f %.8f %.8f %.8f %.8f %.8f %.8f"'
+        xyz_format += (
+            virial[0,0], virial[0,1], virial[0,2],
+            virial[1,0], virial[1,1], virial[1,2],
+            virial[2,0], virial[2,1], virial[2,2]
+            )
+    xyz_head += '\n'
+    xyzstr += xyz_head % xyz_format
+    for i in range(num_atom):
+        xyzstr += "%2s %14.8f %14.8f %14.8f %14.8f %14.8f %14.8f\n" %\
+        (atoms[i].symbol,pos[i,0],pos[i,1],pos[i,2],forces[i,0],forces[i,1],forces[i,2])
+    return xyzstr
+
+f = open(output_file, "w")
+for i in range(len(traj)):
+    atoms = traj[i]
+    atoms.calc = calc
+    f.write(atoms2xyzstr(atoms))
+f.close()

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

pwact/utils/constant.py

@@ -41,6 +41,7 @@ class SLURM_JOB_TYPE:
     vasp_scf = "vasp/scf"
     vasp_aimd = "vasp/aimd"
     lammps = "lammps"
+    direct = "direct"
 
 '''
 description: 
@@ -138,6 +139,7 @@ class DFT_STYLE:
     pwmat = "pwmat"
     cp2k = "cp2k"
     lammps = "lammps"
+    bigmodel="bigmodel"
 
     '''
     description: 
@@ -156,6 +158,8 @@ class DFT_STYLE:
                 return PWDATA.cp2k_scf
             else:
                 return PWDATA.vasp_poscar
+        if dft_style.lower() == DFT_STYLE.bigmodel.lower():
+            return PWDATA.extxyz
 
     @staticmethod
     def get_normal_config(dft_style:str): # the input config file name of pwmat vasp and cp2k
@@ -249,17 +253,6 @@ class DFT_STYLE:
         scf_list = [_.lower() for _ in scf_list]
         return scf_list
     
-    '''
-    description: 
-        the files in scf does not need reserve
-    return {*}
-    author: wuxingxing
-    '''    
-    @staticmethod
-    def get_scf_del_list():
-        del_list = ["final.config"]
-        return del_list
-    
     @staticmethod
     def get_aimd_config(dft_style:str):
         if dft_style == DFT_STYLE.pwmat:
@@ -357,6 +350,20 @@ class INIT_BULK:
     scf_tag = "tag.scf.success"
     scf_tag_failed ="tag.scf.failed"
 
+    bigmodel="bigmodel"
+    bigmodel_job = "bigmodel.job"
+    bigmodel_tag = "tag.bigmodel.success"
+    bigmodel_tag_failed ="tag.bigmodel.failed"
+    bigmodel_traj = "traj.xyz"
+    
+    direct="direct"
+    direct_job = "direct.job"
+    direct_tag = "tag.direct.success"
+    direct_tag_failed ="tag.direct.failed"
+    candidate_xyz="candidate.xyz"
+    candidate_idx="candidate.json"
+    direct_traj = "select.xyz"
+
     collection = "collection"
     npy_format_save_dir = "PWdata"
     npy_format_name = "datapath.txt"
@@ -407,17 +414,24 @@ class TRAIN_FILE_STRUCTUR:
 
     # nep model
     nep_model_name ="nep_model.ckpt"
-    nep_model_lmps = "nep_to_lmps.txt"
+    nep_model_lmps = "nep5.txt"
 
 class EXPLORE_FILE_STRUCTURE:
     kpu= "kpu"
     md = "md"
     select = "select"
+    direct = "direct"
     md_tag = "tag.md.success"
     md_tag_faild = "tag.md.error"
     md_job = "md.job"
+    direct_tag = "tag.direct.success"
+    direct_tag_faild = "tag.direct.error"
+    direct_job = "direct.job"
     # selected image info file names
     candidate = "candidate.csv"
+    candidate_xyz="candidate.xyz"
+    select_idx = "select_idx.dat"
+    select_xyz = "select.xyz"
     # candidate_random = "candidate_random.csv"
     candidate_delete = "candidate_delete.csv"
     failed = "fail.csv"
@@ -446,11 +460,17 @@ class EXPLORE_FILE_STRUCTURE:
 
 
 class LABEL_FILE_STRUCTURE:
+    bigmodel="bigmodel"
     scf = "scf"
     result = "result"
     scf_tag = "tag.scf.success"
     scf_tag_failed = "tag.scf.failed"
     scf_job = "scf.job"
+    bigmodel_job="bigmodel.job"
+    bigmodel_tag = "tag.bigmodel.success"
+    bigmodel_tag_failed = "tag.bigmodel.failed"
+    train_xyz = "train.xyz"
+
 
 class LAMMPS:
     input_lammps="in.lammps"

pwact/utils/file_operation.py

@@ -318,8 +318,15 @@ def get_file_extension(file_name:str, split_char = "."):
 @Author       :wuxingxing
 """
 
-def get_random_nums(start, end, n):
-    numsArray = set()
-    while len(numsArray) < n:
-        numsArray.add(random.randint(start, end-1))
-    return list(numsArray)
+def get_random_nums(start, end, n, seed=None):
+    if seed is not None:
+        local_random = random.Random(seed)  # 独立的随机实例
+        numsArray = set()
+        while len(numsArray) < n:
+            numsArray.add(local_random.randint(start, end-1))
+        return list(numsArray)
+    else:
+        numsArray = set()
+        while len(numsArray) < n:
+            numsArray.add(random.randint(start, end-1))
+        return list(numsArray)