pwact 0.3.4__tar.gz → 0.4.0.dev0__tar.gz

{pwact-0.3.4 → pwact-0.4.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pwact
-Version: 0.3.4
+Version: 0.4.0.dev0
 Summary: PWACT is an open-source automated active learning platform based on MatPL for efficient data sampling.
 Home-page: https://github.com/LonxunQuantum/PWact
 Author: LonxunQuantum

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/active_learning/explore/run_model_md.py

@@ -24,10 +24,10 @@ from pwact.utils.constant import AL_STRUCTURE, TEMP_STRUCTURE, EXPLORE_FILE_STRU
         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
+    make_md_sys_name, get_md_sys_template_name, make_temp_press_name, make_temp_name, make_lmps_name, make_train_name
 from pwact.utils.file_operation import write_to_file, add_postfix_dir, link_file, read_data, search_files, copy_dir, copy_file, del_file, del_dir, del_file_list, del_file_list_by_patten, mv_file
 from pwact.utils.draw.hist_model_devi import draw_hist_list
-from pwact.utils.app_lib.lammps import make_lammps_input
+from pwact.utils.app_lib.lammps import make_lammps_input, make_lammps_input_from_lmp_in_file
 from pwact.data_format.configop import save_config, get_atom_type
 
 from pwdata import Config
@@ -94,30 +94,40 @@ class Explore(object):
     def make_md_work(self):
         md_work_list = []
         for md_index, md in enumerate(self.md_job):
-            for sys_index in md.sys_idx:
+            for sys_id, sys_index in enumerate(md.sys_idx):
                 char_len = 3 if len(md.sys_idx) < 1000 else len(str(len(md.sys_idx)))
                 md_sys_name = make_md_sys_name(md_index, sys_index, char_len)
                 md_sys_dir = os.path.join(self.md_dir, md_sys_name)
                 if not os.path.exists(md_sys_dir):
                     os.makedirs(md_sys_dir)
-                for temp_index, temp in enumerate(md.temp_list):
-                    if ENSEMBLE.nvt in md.ensemble:#for nvt ensemble
-                        temp_name = make_temp_name(md_index, sys_index, temp_index, char_len)
-                        temp_dir = os.path.join(md_sys_dir, temp_name)
-                        # mkdir: md.000.sys.000/md.000.sys.000.t.000
-                        if not os.path.exists(temp_dir):
+                if md.use_lmps_in:
+                    # for lmp_id, lmps_idx in enumerate(md.lmp_in_idx):
+                    temp_name = make_lmps_name(md_index, sys_index, sys_id, char_len)
+                    temp_dir = os.path.join(md_sys_dir, temp_name)
+                    # mkdir: md.000.sys.000/md.000.sys.000.lmps.000
+                    if not os.path.exists(temp_dir):
                             os.makedirs(temp_dir)
-                        self.set_md_files(len(md_work_list), temp_dir, sys_index, temp_index, None, md)
-                        md_work_list.append(temp_dir)
-                    elif ENSEMBLE.npt in md.ensemble: # for npt ensemble
-                        for press_index, press in enumerate(md.press_list):
-                            temp_press_name = make_temp_press_name(md_index, sys_index, temp_index, press_index, char_len)
-                            temp_press_dir = os.path.join(md_sys_dir, temp_press_name)
-                            # mkdir: md.000.sys.000/md.000.sys.000.p.000.t.000
-                            if not os.path.exists(temp_press_dir):
-                                os.makedirs(temp_press_dir)
-                            self.set_md_files(len(md_work_list), temp_press_dir, sys_index, temp_index, press_index, md)
-                            md_work_list.append(temp_press_dir)
+                    self.set_md_files(len(md_work_list), temp_dir, sys_index, sys_id, None, md)
+                    md_work_list.append(temp_dir)
+                else:
+                    for temp_index, temp in enumerate(md.temp_list):
+                        if ENSEMBLE.nvt in md.ensemble:#for nvt ensemble
+                            temp_name = make_temp_name(md_index, sys_index, temp_index, char_len)
+                            temp_dir = os.path.join(md_sys_dir, temp_name)
+                            # mkdir: md.000.sys.000/md.000.sys.000.t.000
+                            if not os.path.exists(temp_dir):
+                                os.makedirs(temp_dir)
+                            self.set_md_files(len(md_work_list), temp_dir, sys_index, temp_index, None, md)
+                            md_work_list.append(temp_dir)
+                        elif ENSEMBLE.npt in md.ensemble: # for npt ensemble
+                            for press_index, press in enumerate(md.press_list):
+                                temp_press_name = make_temp_press_name(md_index, sys_index, temp_index, press_index, char_len)
+                                temp_press_dir = os.path.join(md_sys_dir, temp_press_name)
+                                # mkdir: md.000.sys.000/md.000.sys.000.p.000.t.000
+                                if not os.path.exists(temp_press_dir):
+                                    os.makedirs(temp_press_dir)
+                                self.set_md_files(len(md_work_list), temp_press_dir, sys_index, temp_index, press_index, md)
+                                md_work_list.append(temp_press_dir)
                            
         self.make_md_slurm_jobs(md_work_list)
              
@@ -218,33 +228,48 @@ class Explore(object):
         
         #3. set lammps input file
         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(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.*")
         restart = 1 if len(restart_file) > 0 else 0 
-        lmp_input_content = make_lammps_input(
-                        md_file=LAMMPS.lammps_sys_config, #save_file
-                        md_type = self.input_param.strategy.md_type,
-                        forcefiled = md_model_paths,
-                        atom_type = atomic_number_list,
-                        ensemble = md_detail.ensemble,
-                        nsteps = md_detail.nsteps,
-                        dt = md_detail.md_dt,
-                        neigh_modify = md_detail.neigh_modify,
-                        trj_freq = md_detail.trj_freq,
-                        mass = md_detail.mass,
-                        temp = md_detail.temp_list[temp_index],
-                        tau_t=md_detail.taut, # for fix
-                        press=press,
-                        tau_p=md_detail.taup if press is not None else None, # for fix    
-                        boundary=True, #true is 'p p p', false is 'f f f'
-                        merge_traj=md_detail.merge_traj,
-                        restart = restart,
-                        model_deviation_file = EXPLORE_FILE_STRUCTURE.model_devi
-        )
+        if md_detail.use_lmps_in: # lammps.in file from user input
+            lmp_input_content = make_lammps_input_from_lmp_in_file(
+                            md_file=LAMMPS.lammps_sys_config, #save_file
+                            md_type = self.input_param.strategy.md_type,
+                            forcefiled = md_model_paths,
+                            lmp_in_file = md_detail.lmp_in_file_list[sys_index],
+                            atom_type = atomic_number_list,
+                            trj_freq = md_detail.trj_freq,
+                            boundary=True, #true is 'p p p', false is 'f f f'
+                            merge_traj=md_detail.merge_traj,
+                            restart = restart,
+                            model_deviation_file = EXPLORE_FILE_STRUCTURE.model_devi
+            )
+        
+        else: # lammps.in from param.json
+            press=md_detail.press_list[press_index] if press_index is not None else None
+            lmp_input_content = make_lammps_input(
+                            md_file=LAMMPS.lammps_sys_config, #save_file
+                            md_type = self.input_param.strategy.md_type,
+                            forcefiled = md_model_paths,
+                            atom_type = atomic_number_list,
+                            ensemble = md_detail.ensemble,
+                            nsteps = md_detail.nsteps,
+                            dt = md_detail.md_dt,
+                            neigh_modify = md_detail.neigh_modify,
+                            trj_freq = md_detail.trj_freq,
+                            mass = md_detail.mass,
+                            temp = md_detail.temp_list[temp_index],
+                            tau_t=md_detail.taut, # for fix
+                            press=press,
+                            tau_p=md_detail.taup if press is not None else None, # for fix    
+                            boundary=True, #true is 'p p p', false is 'f f f'
+                            merge_traj=md_detail.merge_traj,
+                            restart = restart,
+                            model_deviation_file = EXPLORE_FILE_STRUCTURE.model_devi
+            )
         write_to_file(input_lammps_file, lmp_input_content, "w")
         if md_detail.merge_traj is False:
             traj_dir = os.path.join(md_dir, "traj")

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/active_learning/explore/select_image.py

@@ -114,7 +114,8 @@ def select_image(
             rand_candi = pd.concat([rand_candi, tmp_rand_candi])
             remove_candi = pd.concat([remove_candi, tmp_remove_candi])
     right_md, error_md = count_mdstop_info(model_devi_files)
-    md_run_info = "A total of {} MD trajectories were run. with {} trajectories correctly executed and {} trajectories normally completed. \nFor detailed information, refer to File {}.".format(len(right_md) + len(error_md), len(right_md), len(error_md), EXPLORE_FILE_STRUCTURE.md_traj_error_record)
+    md_run_info = "A total of {} MD trajectories were run. with {} trajectories correctly executed and {} trajectories normally completed. \nFor detailed information, refer to File {}."\
+        .format(len(right_md) + len(error_md), len(right_md), len(error_md), EXPLORE_FILE_STRUCTURE.md_traj_error_record)
     
     summary_info, summary = count_info(save_dir, error_pd, accurate_pd, rand_candi, remove_candi, md_run_info)
     print("Image select result:\n {}\n\n".format(summary_info))

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/active_learning/label/labeling.py

@@ -32,10 +32,11 @@ from pwact.utils.constant import DFT_TYPE, VASP, PWDATA, AL_STRUCTURE, TEMP_STRU
 from pwact.utils.slurm_script import get_slurm_job_run_info, split_job_for_group, set_slurm_script_content
 from pwact.utils.format_input_output import get_iter_from_iter_name, get_md_sys_template_name
 from pwact.utils.file_operation import write_to_file, copy_file, copy_dir, search_files, mv_file, add_postfix_dir, del_dir, del_file_list_by_patten, link_file
-from pwact.utils.app_lib.common import link_pseudo_by_atom, set_input_script
+from pwact.utils.app_lib.common import link_pseudo_by_atom, set_input_script, check_convergence
 
 from pwact.data_format.configop import extract_pwdata, save_config, get_atom_type
 from pwdata import Config
+
 class Labeling(object):
     @staticmethod
     def kill_job(root_dir:str, itername:str):
@@ -381,8 +382,9 @@ class Labeling(object):
 
         # scf files to pwdata format
         scf_configs = self.collect_scf_configs()
-        if len(scf_configs) > 0:
-            extract_pwdata(input_data_list=scf_configs,
+        cvg_files, uncvg_files, cvg_infos, cvg_detail_infos = check_convergence(scf_configs, self.resource.dft_style)
+        if len(cvg_files) > 0:
+            extract_pwdata(input_data_list=cvg_files,
                     intput_data_format =DFT_STYLE.get_format_by_postfix(os.path.basename(scf_configs[0])),
                     save_data_path =self.result_dir,
                     save_data_name = INIT_BULK.get_save_format(self.input_param.data_format),
@@ -391,6 +393,8 @@ class Labeling(object):
             )
             # copy to main dir
             copy_dir(self.result_dir, self.real_result_dir)
+        print(cvg_detail_infos)
+        write_to_file(os.path.join(self.input_param.root_dir, EXPLORE_FILE_STRUCTURE.iter_select_file), cvg_detail_infos, mode='a')
 
     def do_post_bigmodel(self):
         # copy the bigmodel labeled.xyz to result

pwact-0.4.0.dev0/pwact/active_learning/test/uma_md.py

@@ -0,0 +1,110 @@
+from ase.io import read
+from ase.units import fs
+from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
+from ase.md.nvtberendsen import NVTBerendsen
+from ase.md.npt import NPT
+from ase.optimize import LBFGS
+import numpy as np
+from sevenn.sevennet_calculator import SevenNetCalculator
+
+traj_name = "tmp.traj"
+xyz_name = "traj.xyz"
+
+calc = SevenNetCalculator()
+fmax = 0.1
+run_step = 10000
+
+T = 300
+P = 1.01325
+P_in_ev_per_ang3 = P / 1602176.6208
+atoms = read("POSCAR")
+if not NPT._isuppertriangular(atoms.get_cell()):
+    a, b, c, alpha, beta, gamma = atoms.cell.cellpar()
+    angles = np.radians((alpha, beta, gamma))
+    sin_a, sin_b, _sin_g = np.sin(angles)
+    cos_a, cos_b, cos_g = np.cos(angles)
+    cos_p = (cos_g - cos_a * cos_b) / (sin_a * sin_b)
+    cos_p = np.clip(cos_p, -1, 1)
+    sin_p = (1 - cos_p**2) ** 0.5
+    new_basis = [
+        (a * sin_b * sin_p, a * sin_b * cos_p, a * cos_b),
+        (0, b * sin_a, b * cos_a),
+        (0, 0, c),
+    ]
+    atoms.set_cell(new_basis, scale_atoms=True)
+    
+atoms.calc = calc
+opt = LBFGS(atoms)
+
+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
+
+def domd():
+    opt.run(fmax=fmax)
+    MaxwellBoltzmannDistribution(atoms, temperature_K=T)
+
+    '''
+    print("Beginning Nose-Hoover NVT equilibration")
+    dyn_nvt = NPT(
+    atoms=atoms,
+    timestep=.5*fs,
+    temperature_K=600,
+    externalstress=P_in_ev_per_ang3,
+    ttime=25*fs,
+    pfactor=None,
+    logfile="nvt.log",
+    loginterval=200
+    )
+    dyn_nvt.run(200000)
+    '''
+
+    print("Beginning Nose-Hoover NPT equilibration")
+    dyn_npt = NPT(
+    atoms=atoms,
+    timestep=.5*fs,
+    temperature_K=T,
+    externalstress=P_in_ev_per_ang3,
+    mask=np.eye(3),
+    ttime=25*fs,
+    pfactor=50*fs, #None nvt
+    trajectory=traj_name,
+    logfile="npt.log",
+    loginterval=100
+    )
+    dyn_npt.run(run_step)
+
+def dolabel():
+    traj = read(traj_name, index=":")
+    output_file = xyz_name
+    f = open(output_file, "w")
+    for i in range(len(traj)):
+        atoms = traj[i]
+        atoms.calc = calc
+        f.write(atoms2xyzstr(atoms))
+    f.close()
+
+if __name__=="__main__":
+    domd()
+    dolabel()

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/active_learning/user_input/iter_input.py

@@ -1,6 +1,7 @@
 import os
 import glob
-from pwact.utils.file_operation import check_model_type
+import subprocess
+from pwact.utils.file_operation import check_model_type, search_file_by_shell
 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 InputParam as TrainParam
@@ -141,10 +142,9 @@ class SysConfig(object):
         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:
+        # sys_configs
         sys_config_prefix = get_parameter("sys_config_prefix", json_dict, None)
         sys_configs = get_required_parameter("sys_configs", json_dict)
         if isinstance(sys_configs, str) or isinstance(sys_configs, dict):
@@ -158,9 +158,21 @@ class ExploreParam(object):
             elif isinstance(sys_config, dict):
                 config = os.path.join(sys_config_prefix, sys_config["config"]) if sys_config_prefix is not None else sys_config["config"]
                 config_format = get_parameter("format", sys_config, PWDATA.pwmat_config)
-            if not os.path.exists(config):
+            if len(glob.glob(config)) < 1:
                 raise Exception("ERROR! The sys_config {} file does not exist!".format(config))
             self.sys_configs.append(SysConfig(config, config_format))
+
+        # lammps.in files
+        lmps_prefix = get_parameter("lmps_prefix", json_dict, None)
+        lmps_in = get_parameter("lmps_in", json_dict, [])
+        if isinstance(lmps_in, str) or isinstance(lmps_in, dict):
+            lmps_in = [lmps_in]
+        self.lmps_in:list[str]=[]
+        for lmp_in_file in lmps_in:
+            lmp_file = os.path.join(lmps_prefix, lmp_in_file) if lmps_prefix is not None else lmp_in_file
+            if not os.path.exists(lmp_file):
+                raise Exception("ERROR! The lammps.in file {} does not exist!".format(lmp_file))
+            self.lmps_in.append(lmp_file)
         
         # set md deatils
         self.md_job_list = self.set_md_details(json_dict["md_jobs"], max_select)
@@ -173,7 +185,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, self.sys_configs))
+                iter_exp_md.append(MdDetail(md_exp_id, md_exp, max_select, self.sys_configs, self.lmps_in))
             iter_md.append(iter_exp_md)
         return iter_md
     
@@ -182,11 +194,16 @@ class ExploreParam(object):
         return res
 
 class MdDetail(object):
-    def __init__(self, md_index: int, json_dict:dict, max_select:int=None, sys_configs:list[SysConfig]=None) -> None:
+    def __init__(self, md_index: int, 
+                        json_dict:dict, 
+                        max_select:int=None, 
+                        sys_configs:list[SysConfig]=None,
+                        lmps_in:list[str]=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
         self.trj_freq = get_parameter("trj_freq", json_dict, 10)
+
+        self.nsteps = get_parameter("nsteps", json_dict, None)
+        self.md_dt = get_parameter("md_dt", json_dict, 0.001) #fs
         
         self.ensemble = get_parameter("ensemble", json_dict, "nve")
         
@@ -199,7 +216,8 @@ class MdDetail(object):
         
         if not isinstance(self.temp_list, list):
             self.temp_list = [self.temp_list]
-            
+
+        #sys_idx
         sys_idx = get_required_parameter("sys_idx", json_dict)
 
         if not isinstance(sys_idx, list):
@@ -212,7 +230,8 @@ class MdDetail(object):
                 _select_sys = max_select
         if not isinstance(_select_sys, list):
             _select_sys = [_select_sys]
-
+        
+        #select_sys
         select_sys = []
         if len(_select_sys) > 0:
             if len(_select_sys) == 1:
@@ -222,20 +241,46 @@ class MdDetail(object):
                 select_sys = _select_sys
             else:
                 raise Exception("The length of the 'select_sys' array needs to be consistent with'sys_idx'" )
+        
+        # from lammps.in
+        _lmps_in_idx = get_parameter("lmps_in_idx", json_dict, [])
+        lmps_in_idx = []
+        if not isinstance(_lmps_in_idx, list):
+            _lmps_in_idx = [_lmps_in_idx]
+        # check lammps.in file
+        if len(_lmps_in_idx) > 0:
+            if len(_lmps_in_idx) == 1:
+                for i in range(0, len(sys_idx)):
+                    lmps_in_idx.append(_lmps_in_idx[0])
+            elif len(_lmps_in_idx) == len(sys_idx):
+                lmps_in_idx = _lmps_in_idx
+            else:
+                raise Exception("The length of the 'lmps_in_idx' array needs to be consistent with'sys_idx'" )
+            self.use_lmps_in = True
+        else:
+            self.use_lmps_in = False
+
         # reset select_sys and sys_idx by sys_configs
         self.sys_idx = []
         self.select_sys = []
+        self.lmp_in_idx = []
         self.config_file_list = []
+        self.lmp_in_file_list = []
         self.config_file_format = []
         file_id = 0
         for index, sys_id in enumerate(sys_idx):
             systems = sys_configs[sys_id].sys_config
+            if self.use_lmps_in:
+                lmp_in_file = lmps_in[lmps_in_idx[index]]
             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])
+                if self.use_lmps_in:
+                    self.lmp_in_idx.append(lmps_in_idx[index])
+                    self.lmp_in_file_list.append(lmp_in_file)
                 file_id += 1
 
         self.kspacing = get_parameter("temps", json_dict, None)

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/data_format/configop.py

@@ -153,17 +153,20 @@ def extract_pwdata(input_data_list:list[str],
         save_data_path = os.path.join(os.getcwd(), save_data_path)
     image_data = None
     for dir in input_data_list:
-        if image_data is not None:
-            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(format=intput_data_format, data_path=dir)
-            
-            if not isinstance(image_data.images, list):
-                image_data.images = [image_data.images]
-        
+        try:
+            if image_data is not None:
+                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(format=intput_data_format, data_path=dir)
+                
+                if not isinstance(image_data.images, list):
+                    image_data.images = [image_data.images]
+        except Exception as e:
+            print("Warning! Read the traj file error {}".format(dir))
+            pass
             # if not isinstance(image_data, list):
             #     image_data = [image_data]
     if interval > 1:

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/utils/app_lib/common.py

@@ -158,4 +158,90 @@ def set_input_script(
         #     )
 
     else:
-        pass
+        pass
+
+def is_convergence(file_path, format):
+    def _is_cvg_vasp(file_path:str):
+        with open(file_path, 'r') as rf:
+            outcar_contents = rf.readlines()
+        nelm = None
+        ediff = None
+        for idx, ii in enumerate(outcar_contents):
+            if 'NELM   =' in ii:
+                nelm = int(ii.split()[2][:-1])
+            if 'EDIFF = ' in ii:
+                ediff = float(ii.split()[-1])
+        
+        with open(os.path.join(os.path.dirname(os.path.abspath(file_path)), "OSZICAR"), 'r') as rf:
+            oszi_contents = rf.readlines()
+        _split = oszi_contents[-2].split()
+        real_nelm = int(_split[1])
+        real_ediff1 = abs(float(_split[3]))
+        real_ediff2 = abs(float(_split[4]))
+
+        if real_nelm < nelm:
+            return True
+        elif real_ediff1 <= ediff and real_ediff2 <=ediff:
+            return True
+        else:
+            False
+
+    def _is_cvg_pwmat(file_path:str):
+        with open(os.path.join(os.path.dirname(os.path.abspath(file_path)), "REPORT"), 'r') as rf:
+            report_contents = rf.readlines()
+        e_error   = None
+        rho_error = None
+        etot_idx = -1
+        drho_idx = -1
+        for idx, ii in enumerate(report_contents):
+            if e_error is None and 'E_ERROR   =' in ii:
+                e_error = abs(float(ii.split()[-1]))
+            if rho_error is None and 'RHO_ERROR =' in ii:
+                rho_error = abs(float(ii.split()[-1]))
+            if 'E_tot(eV)            =' in ii:
+                etot_idx = idx
+            if 'dv_ave, drho_tot     =' in ii:
+                drho_idx = idx
+            if 'niter reached' in ii:
+                break
+            elif 'ending_scf_reason = tol' in ii:
+                return True
+
+        if e_error >= abs(float(report_contents[etot_idx].split()[-1])) or \
+            rho_error >= abs(float(report_contents[drho_idx].split()[-1])):
+            return True
+        return False
+    
+    def _is_cvg_cp2k(file_path:str):
+        with open(os.path.join(os.path.dirname(os.path.abspath(file_path)), "dft.log"), 'r') as rf:
+            report_contents = rf.readlines()
+        for idx, ii in enumerate(report_contents):
+            if 'SCF run NOT converged' in ii:
+                return False
+        return True
+
+    if format == DFT_STYLE.vasp:
+        return _is_cvg_vasp(file_path)
+    elif format == DFT_STYLE.pwmat:
+        return _is_cvg_pwmat(file_path)
+    elif format == DFT_STYLE.cp2k:
+        return _is_cvg_cp2k(file_path)
+    else: # for other format
+        return True
+
+def check_convergence(file_path:list[str], format:str):
+    cvg_files = []
+    uncvg_files = []
+    cvg_infos = ""
+    cvg_detail_infos=""
+    for file in file_path:
+        if is_convergence(file, format):
+            cvg_files.append(file)
+        else:
+            uncvg_files.append(file)
+    cvg_infos += "Number of converged files: {}, number of non-converged files: {}\n".format(len(cvg_files), len(uncvg_files))
+    cvg_detail_infos += cvg_infos
+    if len(uncvg_files) > 0:
+        cvg_detail_infos += "List of non-converged files:\n{}".format("\n".join(uncvg_files))
+    return cvg_files, uncvg_files, cvg_infos, cvg_detail_infos
+    

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/utils/app_lib/lammps.py

@@ -236,3 +236,92 @@ def get_all_dumped_forces(file_name):
     return ret
 
 
+def make_lammps_input_from_lmp_in_file(
+    md_file,
+    md_type,
+    forcefiled,
+    lmp_in_file,
+    atom_type,
+    trj_freq,
+    boundary, #true is 'p p p', false is 'f f f', default is true
+    merge_traj,
+    max_seed=100000,
+    restart=0,
+    model_deviation_file = "model_deviation.out"
+):
+    with open(lmp_in_file, 'r') as rf:
+        lmp_content = rf.readlines()
+    runline_idx = find_first_run_cmd_line(lmp_content)
+    if runline_idx is None:
+        raise Exception("Error! The input lmp.in file: {} is missing the 'RUN' command, please modify it!".format(lmp_in_file))
+    # remove the units boundary atom_stype lines
+    # units           metal
+    # boundary        p p p
+    # atom_style      atomic
+    # remove mass pair_style pair_coeff dump
+    lmp_content = remove_lmps_lines(lmp_content)
+    lmp_content.insert(0, "variable        DUMP_FREQ       equal %d\n" % trj_freq)
+    lmp_content.insert(1, "variable        restart         equal %d\n" % restart)
+    
+    md_script = ""
+    md_script += "units           metal\n"
+    if boundary:
+        md_script += "boundary        p p p\n"
+    else:
+        md_script += "boundary        f f f\n"
+    md_script += "atom_style      atomic\n"
+    md_script += "\n"
+    lmp_content.insert(2, md_script)
+    
+    md_script = (
+        'if "${restart} > 0" then "read_restart lmps.restart.*" else "read_data %s"\n'
+        % md_file
+    )
+    lmp_content.insert(3, md_script)
+    
+    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
+    md_script += "\n"
+    lmp_content.insert(4, md_script)
+    # md_script += "thermo_style    custom step temp pe ke etotal press vol lx ly lz xy xz yz\n"
+    # md_script += "thermo          ${THERMO_FREQ}\n"
+    
+    if merge_traj is True:
+        dump_line = "dump            1 all custom ${DUMP_FREQ} all.lammpstrj id type x y z fx fy fz\n"
+        dump_line += 'if "${restart} > 0" then "dump_modify     1 append yes"\n'
+    else:
+        dump_line = "dump            1 all custom ${DUMP_FREQ} traj/*.lammpstrj id type x y z fx fy fz\n"
+    
+    dump_line += "restart         10000 lmps.restart\n"
+    dump_line += "\n"
+    
+    dump_line += 'if "${restart} == 0" then "velocity        all create ${TEMP} %d"' % (
+            random.randrange(max_seed - 1) + 1
+        )
+        
+    dump_line += "\n"
+    lmp_content.insert(runline_idx, dump_line)
+    
+    return "".join(lmp_content)
+
+def remove_lmps_lines(lmps_lines):
+    removes = ["dump_freq", "units", "boundary", "restart","atom_style", "read_data", "mass", "pair_style", "pair_coeff", "dump"]
+    new_lines = [
+        line for line in lmps_lines 
+        if line.lstrip().startswith('#')
+        or not any(
+            keyword.lower() in line.lower() 
+            for keyword in removes
+        )
+        ]
+    return new_lines
+
+def find_first_run_cmd_line(lmps_lines):
+    for i, line in enumerate(lmps_lines):
+        if 'run' in line.lower():
+            # 计算倒数行数(从1开始计数)
+            return -(len(lmps_lines) - i)
+    return None
+

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/utils/file_operation.py

@@ -288,6 +288,11 @@ def search_files(search_root_dir:str, template:str):
     file_list = glob.glob(os.path.join(search_root_dir, template))
     return file_list
 
+def search_file_by_shell(search_patten:str):
+    result = subprocess.run(["ls"], capture_output=True, text=True)
+    filtered = [line for line in result.stdout.split("\n") if "pattern" in line]
+    return filtered
+
 def str_list_format(input_value):
     input_list = []
     if isinstance(input_value, str):

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/utils/format_input_output.py

@@ -36,6 +36,12 @@ def make_temp_name(md_index:int, sys_index:int, temp_index:int, len_char:int = N
     return "md."+(md_name % md_index)+".sys."+(sys_name % sys_index)+\
         ".t."+ (sys_name % temp_index)
 
+def make_lmps_name(md_index:int, sys_index:int, lmps_index:int, len_char:int = None):
+    md_name = "%03d"
+    sys_name = "%03d" if len_char is None else "%0{}d".format(len_char)
+    return "md."+(md_name % md_index)+".sys."+(sys_name % sys_index)+\
+        ".lmps."+ (sys_name % lmps_index)
+
 def get_sub_md_sys_template_name():
     return "md.*.sys.*/md.*.sys.*"
 

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact/utils/slurm_script.py

@@ -196,7 +196,7 @@ def set_slurm_script_content(
         script = ""
         if gpu_per_node is None or gpu_per_node == 0:
             script += CPU_SCRIPT_HEAD.format(job_name, number_node, cpu_per_node, queue_name)
-            script += "export CUDA_VISIBLE_DEVICES=''\n"
+            # script += "export CUDA_VISIBLE_DEVICES=''\n"
         else:
             script += GPU_SCRIPT_HEAD.format(job_name, number_node, cpu_per_node, gpu_per_node, queue_name)
         

pwact-0.4.0.dev0/pwact/utils/tmp.py

@@ -0,0 +1,161 @@
+from pwdata import Config
+import os, sys, glob
+import numpy as np
+
+def count_pwdata(work_dir):
+    
+    dir_list = glob.glob(os.path.join(work_dir, "*"))
+    res = []
+    for dir in dir_list:
+        # train
+        train_num = np.load(os.path.join(dir, "train/energies.npy")).shape[0]
+        res.append(train_num)
+
+        if os.path.exists(os.path.join(dir, "valid/energies.npy")):
+            test_num = np.load(os.path.join(dir, "valid/energies.npy")).shape[0]
+            res.append(test_num)
+            print("{} {} {}".format( dir, train_num, test_num))
+        else:
+            print("{} {}".format(dir, train_num))
+    print(np.sum(res))
+
+def count_outmlmd():
+    work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/iter.0000/label/scf"
+    mlmds = glob.glob(os.path.join(work_dir, "*/*/*/OUT.MLMD"))
+    print(len(mlmds))
+
+def save_mlmd():
+    work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter"
+    data_list = glob.glob(os.path.join(work_dir, "iter.*/label/scf/*/*/*/OUT.MLMD"))
+    datasets_path = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/mlmd_pwdata"
+    # data_name = datasets_path
+    image_data = None
+    for data_path in data_list:
+        if image_data is not None:
+            tmp_config = Config("pwmat/movement", data_path)
+            # if not isinstance(tmp_config, list):
+            #     tmp_config = [tmp_config]
+            image_data.images.extend(tmp_config.images)
+        else:
+            image_data = Config("pwmat/movement", data_path)
+            
+            if not isinstance(image_data.images, list):
+                image_data.images = [image_data.images]
+        
+            # if not isinstance(image_data, list):
+            #     image_data = [image_data]
+    image_data.to(
+                output_path=datasets_path,
+                save_format="pwmlff/npy",
+                train_ratio = 0.8, 
+                train_data_path="train", 
+                valid_data_path="valid", 
+                random=True,
+                seed = 2024, 
+                retain_raw = False
+                )
+    print(len(image_data.images))
+
+def find_outcar_files(directory):
+    outcar_files = []
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file == 'OUTCAR' or file == "REPORT":
+                outcar_files.append(os.path.join(root, file))
+            
+            
+    return outcar_files
+
+def is_convergence(file_path, format):
+    def _is_cvg_vasp(file_path:str):
+        with open(file_path, 'r') as rf:
+            outcar_contents = rf.readlines()
+        nelm = None
+        ediff = None
+        for idx, ii in enumerate(outcar_contents):
+            if 'NELM   =' in ii:
+                nelm = int(ii.split()[2][:-1])
+            if 'EDIFF = ' in ii:
+                ediff = float(ii.split()[-1])
+        
+        with open(os.path.join(os.path.dirname(os.path.abspath(file_path)), "OSZICAR"), 'r') as rf:
+            oszi_contents = rf.readlines()
+        _split = oszi_contents[-2].split()
+        real_nelm = int(_split[1])
+        real_ediff1 = abs(float(_split[3]))
+        real_ediff2 = abs(float(_split[4]))
+
+        if real_nelm < nelm:
+            return True
+        elif real_ediff1 <= ediff and real_ediff2 <=ediff:
+            return True
+        else:
+            False
+
+    def _is_cvg_pwmat(file_path:str):
+        with open(file_path, 'r') as rf:
+            report_contents = rf.readlines()
+        e_error   = None
+        rho_error = None
+        etot_idx = -1
+        drho_idx = -1
+        for idx, ii in enumerate(report_contents):
+            if e_error is None and 'E_ERROR   =' in ii:
+                e_error = abs(float(ii.split()[-1]))
+            if rho_error is None and 'RHO_ERROR =' in ii:
+                rho_error = abs(float(ii.split()[-1]))
+            if 'E_tot(eV)            =' in ii:
+                etot_idx = idx
+            if 'dv_ave, drho_tot     =' in ii:
+                drho_idx = idx
+            if 'niter reached' in ii:
+                break
+            elif 'ending_scf_reason = tol' in ii:
+                return True
+
+        if e_error >= abs(float(report_contents[etot_idx].split()[-1])) or \
+            rho_error >= abs(float(report_contents[drho_idx].split()[-1])):
+            return True
+        return False
+        
+    if format == "vasp":
+        return _is_cvg_vasp(file_path)
+    elif format == "pwmat":
+        return _is_cvg_pwmat(file_path)
+    elif format == "cp2k":
+        return True
+
+def check_convergence(file_path:list[str], format:str):
+    cvg_files = []
+    uncvg_files = []
+    cvg_infos = ""
+    cvg_detail_infos=""
+    for file in file_path:
+        if is_convergence(file, format):
+            cvg_files.append(file)
+        else:
+            uncvg_files.append(file)
+    
+    cvg_infos += "Number of converged files: {}, number of non-converged files: {}".format(len(cvg_files), len(uncvg_files))
+    cvg_detail_infos += cvg_infos
+    cvg_detail_infos += "\nList of non-converged files:\n{}".format("\n".join(uncvg_files))
+    return cvg_files, uncvg_files, cvg_infos, cvg_detail_infos
+    
+def cvt_config():
+    pwdata = "/data/home/wuxingxing/datas/pwmat_mlff_workdir/auag/pwdata/Ag4Au44"
+    image = Config.read(data_path=pwdata, format="pwmlff/npy")[0][0]
+    image.to(data_path="/share/public/PWMLFF_test_data/pwact_examples/25-pwact-demo/structures/AuAg", data_name="ag4au44-atom.config", format="pwmat/config")
+
+if __name__=="__main__":
+    # count_pwdata(work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/mlmd_pwdata")
+    # count_outmlmd()
+    # save_mlmd()
+    # cvt_config()
+    os.chdir("/share/public/PWMLFF_test_data/pwact_examples/25-pwact-demo/si_pwmat/run_iter_lmps/iter.0000/temp_run_iter_work/02.label/scf")
+    current_dir = os.getcwd()
+    outcar_files = find_outcar_files(current_dir)
+    cvg_files, uncvg_files, cvg_infos, cvg_detail_infos = check_convergence(outcar_files, "pwmat")
+    print(cvg_detail_infos)
+    print(cvg_infos)
+
+    

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pwact
-Version: 0.3.4
+Version: 0.4.0.dev0
 Summary: PWACT is an open-source automated active learning platform based on MatPL for efficient data sampling.
 Home-page: https://github.com/LonxunQuantum/PWact
 Author: LonxunQuantum

{pwact-0.3.4 → pwact-0.4.0.dev0}/pwact.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ pwact/active_learning/slurm/slurm.py
 pwact/active_learning/slurm/slurm_tool.py
 pwact/active_learning/test/__init__.py
 pwact/active_learning/test/test.py
+pwact/active_learning/test/uma_md.py
 pwact/active_learning/train/__init__.py
 pwact/active_learning/train/dp_kpu.py
 pwact/active_learning/train/train_model.py

{pwact-0.3.4 → pwact-0.4.0.dev0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pwact", 
-    version="0.3.4",
+    version="0.4.0.dev",
     author="LonxunQuantum",
     author_email="lonxun@pwmat.com",
     description="PWACT is an open-source automated active learning platform based on MatPL for efficient data sampling.",

pwact-0.3.4/pwact/utils/tmp.py

@@ -1,63 +0,0 @@
-from pwdata import Config
-import os, sys, glob
-import numpy as np
-
-def count_pwdata(work_dir):
-    
-    dir_list = glob.glob(os.path.join(work_dir, "*"))
-    res = []
-    for dir in dir_list:
-        # train
-        train_num = np.load(os.path.join(dir, "train/energies.npy")).shape[0]
-        res.append(train_num)
-
-        if os.path.exists(os.path.join(dir, "valid/energies.npy")):
-            test_num = np.load(os.path.join(dir, "valid/energies.npy")).shape[0]
-            res.append(test_num)
-            print("{} {} {}".format( dir, train_num, test_num))
-        else:
-            print("{} {}".format(dir, train_num))
-    print(np.sum(res))
-
-def count_outmlmd():
-    work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/iter.0000/label/scf"
-    mlmds = glob.glob(os.path.join(work_dir, "*/*/*/OUT.MLMD"))
-    print(len(mlmds))
-
-def save_mlmd():
-    work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter"
-    data_list = glob.glob(os.path.join(work_dir, "iter.*/label/scf/*/*/*/OUT.MLMD"))
-    datasets_path = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/mlmd_pwdata"
-    # data_name = datasets_path
-    image_data = None
-    for data_path in data_list:
-        if image_data is not None:
-            tmp_config = Config("pwmat/movement", data_path)
-            # if not isinstance(tmp_config, list):
-            #     tmp_config = [tmp_config]
-            image_data.images.extend(tmp_config.images)
-        else:
-            image_data = Config("pwmat/movement", data_path)
-            
-            if not isinstance(image_data.images, list):
-                image_data.images = [image_data.images]
-        
-            # if not isinstance(image_data, list):
-            #     image_data = [image_data]
-    image_data.to(
-                output_path=datasets_path,
-                save_format="pwmlff/npy",
-                train_ratio = 0.8, 
-                train_data_path="train", 
-                valid_data_path="valid", 
-                random=True,
-                seed = 2024, 
-                retain_raw = False
-                )
-    print(len(image_data.images))
-
-
-if __name__=="__main__":
-    count_pwdata(work_dir = "/data/home/wuxingxing/datas/debugs/dengjiapei/run_iter/mlmd_pwdata")
-    # count_outmlmd()
-    # save_mlmd()