diff --git a/docs/hands_on/tutorial2_2d_mat.ipynb b/docs/hands_on/tutorial2_2d_mat.ipynb new file mode 100644 index 0000000..35c01d6 --- /dev/null +++ b/docs/hands_on/tutorial2_2d_mat.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "078cef78", + "metadata": {}, + "source": [ + "# Tutorial 2: Quantum Transport in 2D materials" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c514189b", + "metadata": { + "vscode": { + "languageId": "shellscript" + } + }, + "outputs": [], + "source": [ + "dptb esk bn_spds.json -o hbn_spd_model\n", + "dptb config -m hbn_spd_model/sktb.json -tr -sk ./\n", + "\n", + "\"onsite\": {\n", + " \"method\": \"strain\"\n", + "}\n", + "\n", + "dptb train input.json -i ../extra_baseline/hbn_spd_model/sktb.json -o train_out\n", + "dptb run band.json -i train/train_out/checkpoint/nnsk.best.pth -o band_plot" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "026e2584", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "band.json\tband_plot\textr_baseline\ttrain\n" + ] + } + ], + "source": [ + "import os\n", + "from pathlib import Path\n", + "workdir='../../examples/graphene'\n", + "wd = Path(workdir)\n", + "if not wd.is_dir():\n", + " raise FileNotFoundError(f\"Workdir '{wd}' not found. Please adjust 'workdir'.\")\n", + "os.chdir(wd)\n", + "print(\"\\t\".join(sorted(os.listdir(\".\"))))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "664ee3cc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DPNEGF INFO ================================================================================\n", + "DPNEGF INFO Version Info \n", + "DPNEGF INFO --------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DPNEGF INFO DPNEGF : 0.1.1.dev97+bccd946\n", + "DPNEGF INFO DeePTB : 2.1.2.dev53+5b97981\n", + "DPNEGF INFO ================================================================================\n", + "\n" + ] + } + ], + "source": [ + "from dpnegf.utils.loggers import set_log_handles\n", + "import logging\n", + "from pathlib import Path\n", + "\n", + "\n", + "results_path = '../band_plot'\n", + "log_path = os.path.join(results_path, 'log')\n", + "log_level = logging.INFO\n", + "set_log_handles(log_level, Path(log_path) if log_path else None)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5c4797d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DPNEGF INFO The ['overlap_param'] are frozen!\n", + "DPNEGF INFO The ['overlap_param'] are frozen!\n" + ] + } + ], + "source": [ + "from dptb.nn.build import build_model\n", + "\n", + "model = \"./train/train_out/checkpoint/nnsk.best.pth\" # the model for demonstration\n", + "\n", + "model = build_model(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "31407e92", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Atoms(symbols='C2', pbc=True, cell=[[2.5039999485, 0.0, 0.0], [-1.2519999743, 2.1685275665, 0.0], [0.0, 0.0, 30.0]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from ase.io import read\n", + "structure = \"./train/data/POSCAR\" \n", + "atoms = read(structure)\n", + "atoms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1041ae1c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DPNEGF WARNING eig_solver is not set, using default 'torch'.\n", + "DPNEGF INFO KPOINTS klist: 300 kpoints\n", + "DPNEGF INFO The eigenvalues are already in data. will use them.\n", + "DPNEGF INFO Calculating Fermi energy in the case of spin-degeneracy.\n", + "DPNEGF INFO Fermi energy converged after 20 iterations.\n", + "DPNEGF INFO q_cal: 8.000001001159495, total_electrons: 8.0, diff q: 1.001159494862236e-06\n", + "DPNEGF INFO Estimated E_fermi: -4.0844590057224 based on the valence electrons setting nel_atom : {'C': 4} .\n", + "DPNEGF INFO No Fermi energy provided, using estimated value: -4.0845 eV\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from dptb.postprocess.bandstructure.band import Band\n", + "import shutil\n", + "\n", + "task_options = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 110],\n", + " [0.5, 0, 0, 84],\n", + " [0.3333333, 0.3333333, 0, 95],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"emin\":-20,\n", + " \"emax\": 20,\n", + " \"nel_atom\":{\"C\": 4},\n", + " \"ref_band\": \"/personal/zjj/transiesta_cal/graphene_formal/dptb_train_input/data/data_graphene_siesta2/eigs.npy\"\n", + "\n", + " }\n", + "\n", + "if os.path.isdir(results_path):\n", + " shutil.rmtree(results_path, ignore_errors=True) \n", + "\n", + "band = Band(model, results_path)\n", + "AtomicData_options = { \"pbc\": True}\n", + "band.get_bands(data = atoms, \n", + " kpath_kwargs = task_options,\n", + " AtomicData_options = AtomicData_options)\n", + "band.band_plot(emin = task_options['emin'],\n", + " emax = task_options['emax'],\n", + " ref_band = task_options['ref_band'],)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dpnegf-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/dpnegf/negf/lead_property.py b/dpnegf/negf/lead_property.py index cf5258f..b8b9e02 100644 --- a/dpnegf/negf/lead_property.py +++ b/dpnegf/negf/lead_property.py @@ -103,7 +103,6 @@ def __init__(self, tab, hamiltonian, structure, results_path, voltage, def self_energy(self, kpoint, energy, eta_lead: float=1e-5, method: str="Lopez-Sancho", - save: bool=False, save_path: str=None, save_format: str="h5", se_info_display: bool=False, @@ -134,58 +133,132 @@ def self_energy(self, kpoint, energy, if not isinstance(energy, torch.Tensor): energy = torch.tensor(energy) # Energy relative to Ef - if save_path is None: - parent_dir = os.path.join(self.results_path, "self_energy") - if not os.path.exists(parent_dir): - os.makedirs(parent_dir) - if save_format == "pth": - save_path = os.path.join(parent_dir, - f"se_{self.tab}_k{kpoint[0]}_{kpoint[1]}_{kpoint[2]}_E{energy}.pth") - elif save_format == "h5": - if self.tab == "lead_L": - save_path = os.path.join(parent_dir, "self_energy_leadL.h5") - elif self.tab == "lead_R": - save_path = os.path.join(parent_dir, "self_energy_leadR.h5") - else: - raise ValueError(f"Unsupported tab {self.tab} for saving self energy.") - else: - raise ValueError(f"Unsupported save format {save_format}. Only 'pth' and 'h5' are supported.") + save_path = self._get_save_path(kpoint, energy, save_format, save_path) + # log.info(f"Self energy save path: {save_path}") + + # Try load + if os.path.isfile(save_path): + if se_info_display: + log.info(f"Loading {self.tab} self-energy from {save_path}") + self.se = self._load_self_energy(save_path, kpoint, energy, save_format) + return + + # If not loaded, just compute + if se_info_display: + log.info(f"Computing {self.tab} self-energy (method={method}) " + f"at k={kpoint}, E={energy.item():.6f}") + + self.se = self.self_energy_cal( kpoint, + energy, + eta_lead=eta_lead, + method=method, + HS_inmem=HS_inmem) - # If the file in save_path exists, then directly load it - if os.path.exists(save_path): - if se_info_display: - log.info(f"Loading self energy from {save_path}") + def _get_save_path(self, kpoint, energy, save_format: str, save_path: str = None): + """ + Generate the save path for self-energy files. + Parameters + ---------- + kpoint : array-like + The k-point (length 3). + energy : torch.Tensor or float + Energy value. + save_format : str + File format, supports "pth" or "h5". + save_path : str, optional + User-specified save path. If None, use default under results_path/self_energy. + + Returns + ------- + str + Full path to the save file. + """ + # Ensure kpoint is array for string formatting + kx, ky, kz = np.asarray(kpoint, dtype=float).reshape(3) + energy_val = energy.item() if hasattr(energy, "item") else float(energy) + + # Case 1: User provided save_path + if save_path is not None: + # If it's a directory, append default filename if os.path.isdir(save_path): if save_format == "pth": - save_path = os.path.join(save_path, f"se_{self.tab}_k{kpoint[0]}_{kpoint[1]}_{kpoint[2]}_E{energy}.pth") + return os.path.join(save_path, + f"se_{self.tab}_k{kx:.4f}_{ky:.4f}_{kz:.4f}_E{energy_val:.6f}.pth") elif save_format == "h5": - save_path = os.path.join(save_path, f"self_energy_{self.tab}.h5") + if self.tab == "lead_L": + return os.path.join(save_path, "self_energy_leadL.h5") + elif self.tab == "lead_R": + return os.path.join(save_path, "self_energy_leadR.h5") else: - raise ValueError(f"Unsupported save format {save_format}. Only 'pth' and 'h5' are supported.") - + raise ValueError(f"Unsupported save_format {save_format}") + return save_path # direct file path given by user + + # Case 2: Default path under results_path + parent_dir = os.path.join(self.results_path, "self_energy") + os.makedirs(parent_dir, exist_ok=True) + + if save_format == "pth": + return os.path.join(parent_dir, + f"se_{self.tab}_k{kx:.4f}_{ky:.4f}_{kz:.4f}_E{energy_val:.6f}.pth") + + elif save_format == "h5": + if self.tab == "lead_L": + return os.path.join(parent_dir, "self_energy_leadL.h5") + elif self.tab == "lead_R": + return os.path.join(parent_dir, "self_energy_leadR.h5") + else: + raise ValueError(f"Unsupported tab {self.tab} for h5 save.") - assert os.path.exists(save_path), f"Cannot find the self energy file {save_path}" - if save_path.endswith(".pth"): - # if the save_path is a directory, then the self energy file is stored in the directory - self.se = torch.load(save_path, weights_only=False) - elif save_path.endswith(".h5"): - try: - self.se = read_from_hdf5(save_path, kpoint, energy) - self.se = torch.from_numpy(self.se) - except KeyError as e: - log.error(f"Cannot find the self energy for kpoint {kpoint} and energy {energy} in {save_path}.") - raise e + else: + raise ValueError(f"Unsupported save_format {save_format}, only 'pth' and 'h5' are supported.") + + @staticmethod + def _load_self_energy(save_path: str, kpoint, energy, save_format: str): + """ + Load self-energy from file. + + Parameters + ---------- + save_path : str + Path to the saved self-energy file. + kpoint : array-like + The k-point (length 3). + energy : torch.Tensor or float + Energy value. + save_format : str + File format, supports "pth" or "h5". + + Returns + ------- + torch.Tensor + Loaded self-energy tensor. + """ + if save_format == "pth": + try: + se = torch.load(save_path, weights_only=False) + except Exception as e: + raise IOError(f"Failed to load self-energy from {save_path} (pth format).") from e + + elif save_format == "h5": + try: + data = read_from_hdf5(save_path, kpoint, energy) + se = torch.as_tensor(data, dtype=torch.complex128) # 自能一般是复数 + except KeyError as e: + kx, ky, kz = np.asarray(kpoint, dtype=float).reshape(3) + ev = energy.item() if hasattr(energy, "item") else float(energy) + raise KeyError( + f"Cannot find self-energy in {save_path} " + f"for k=({kx:.4f},{ky:.4f},{kz:.4f}), E={ev:.6f}" + ) from e + except Exception as e: + raise IOError(f"Failed to read HDF5 self-energy from {save_path}.") from e - return - else: - if se_info_display: - log.info("-"*50) - log.info(f"Not find stored {self.tab} self energy. Calculating it at kpoint {kpoint} and energy {energy}.") - log.info("-"*50) - - self.self_energy_cal(kpoint, energy, eta_lead=eta_lead, method=method,HS_inmem=HS_inmem) + raise ValueError(f"Unsupported save_format {save_format}, only 'pth' and 'h5' are supported.") + + return se + def self_energy_cal(self, kpoint, @@ -193,16 +266,44 @@ def self_energy_cal(self, eta_lead: float=1e-5, method: str="Lopez-Sancho", HS_inmem: bool=True): - + """ + Calculates the self-energy for a lead in a quantum transport calculation. + This method computes the self-energy matrix for a given k-point and energy, + using either the standard or Bloch-based approach depending on the object's configuration. + Parameters + ---------- + kpoint : array-like + The k-point in reciprocal space at which to calculate the self-energy. + energy : float or torch.Tensor + The energy value at which to evaluate the self-energy. + eta_lead : float, optional + Small imaginary part added to the energy for numerical stability (default: 1e-5). + method : str, optional + The method used for self-energy calculation (default: "Lopez-Sancho"). + HS_inmem : bool, optional + If False, deletes Hamiltonian and overlap matrices from memory after calculation (default: True). + This is useful for large systems to save memory. + Returns + ------- + se : torch.Tensor + The calculated self-energy matrix for the specified k-point and energy. + Notes + ----- + - If `useBloch` is True, the calculation unfolds the k-points and applies Bloch phase factors. + - The method caches Hamiltonian and overlap matrices for efficiency unless `HS_inmem` is False. + - The shape of the returned self-energy matrix is consistent with the reduced Hamiltonian blocks. + """ subblocks = self.hamiltonian.get_hs_device(kpoint, only_subblocks=True) # calculate self energy if not self.useBloch: - if not hasattr(self, "HL") or abs(self.voltage_old-self.voltage)>1e-6 or max(abs(self.kpoint-torch.tensor(kpoint)))>1e-6: + if not hasattr(self, "HL") \ + or abs(self.voltage_old-self.voltage)>1e-6 \ + or max(abs(self.kpoint-torch.tensor(kpoint)))>1e-6: + self.HLk, self.HLLk, self.HDLk, self.SLk, self.SLLk, self.SDLk \ = self.hamiltonian.get_hs_lead(kpoint, tab=self.tab, v=self.voltage) self.voltage_old = self.voltage self.kpoint = torch.tensor(kpoint) - HDL_reduced, SDL_reduced = self.HDL_reduced(self.HDLk, self.SDLk,subblocks) @@ -354,40 +455,99 @@ def gamma(self): -# ) +def compute_all_self_energy(eta, lead_L, lead_R, kpoints_grid, energy_grid, + self_energy_save_path=None, n_jobs=-1, batch_size=200): + """ + Computes and saves self-energy matrices for all combinations of k-points and energy values + for left and right leads. + + The self-energy calculations are performed in parallel batches, and results are saved as HDF5 files. + Temporary files are merged into final output files for each lead. + Parameters + ---------- + eta : float + Small imaginary part added to energy for numerical stability. + lead_L : Lead + lead object containing Left lead Hamiltonian and results path. + lead_R : Lead + lead object containing Right lead Hamiltonian and results path. + kpoints_grid : array-like + List or array of k-points to compute self-energy for. + energy_grid : array-like + List or array of energy values to compute self-energy for. + self_energy_save_path : str or None, optional + Directory to save self-energy files. If None, uses lead_L's results_path. + n_jobs : int, optional + Number of parallel jobs to use. Default is -1 (use all available CPUs). + batch_size : int, optional + Number of (k, e) tasks per parallel batch. Default is 200. + + Returns + ------- + None + Results are saved to disk as HDF5 files. + """ + if self_energy_save_path is None: + if lead_L.results_path != lead_R.results_path: + log.warning("The results_path of lead_L and lead_R are different. " + "Self energy files will be saved in lead_L's results_path.") + self_energy_save_path = os.path.join(lead_L.results_path, "self_energy") -def compute_all_self_energy(eta, lead_L, lead_R, kpoints_grid, energy_grid, n_jobs=-1, batch_size=200): total_tasks = [(k, e) for k in kpoints_grid for e in energy_grid] if len(total_tasks) <= batch_size: Parallel(n_jobs=n_jobs, backend="loky")( - delayed(self_energy_worker)(k, e, eta, lead_L, lead_R) + delayed(self_energy_worker)(k, e, eta, lead_L, lead_R, self_energy_save_path) for k, e in total_tasks ) - else: for i in range(0, len(total_tasks), batch_size): batch = total_tasks[i:i+batch_size] Parallel(n_jobs=n_jobs, backend="loky")( - delayed(self_energy_worker)(k, e, eta, lead_L, lead_R) + delayed(self_energy_worker)(k, e, eta, lead_L, lead_R, self_energy_save_path) for k, e in batch ) - save_path_L = os.path.join(lead_L.results_path, "self_energy", "self_energy_leadL.h5") - save_path_R = os.path.join(lead_R.results_path, "self_energy", "self_energy_leadR.h5") - merge_hdf5_files(os.path.join(lead_L.results_path, "self_energy"), save_path_L, pattern="tmp_leadL_*.h5") - merge_hdf5_files(os.path.join(lead_R.results_path, "self_energy"), save_path_R, pattern="tmp_leadR_*.h5") + save_path_L = os.path.join(self_energy_save_path, "self_energy_leadL.h5") + save_path_R = os.path.join(self_energy_save_path, "self_energy_leadR.h5") + + merge_hdf5_files(self_energy_save_path, save_path_L, pattern="tmp_leadL_*.h5") + merge_hdf5_files(self_energy_save_path, save_path_R, pattern="tmp_leadR_*.h5") -def self_energy_worker(k, e, eta, lead_L, lead_R): +def self_energy_worker(k, e, eta, lead_L, lead_R, self_energy_save_path): + """ + Calculates the self-energy for left and right leads at a given k-point and energy, + and saves the results to HDF5 files. - save_tmp_L = os.path.join(lead_L.results_path, "self_energy", f"tmp_leadL_k{k[0]}_{k[1]}_{k[2]}_E{e:.8f}.h5") - save_tmp_R = os.path.join(lead_R.results_path, "self_energy", f"tmp_leadR_k{k[0]}_{k[1]}_{k[2]}_E{e:.8f}.h5") + Parameters + ---------- + k : array-like + The k-point in reciprocal space, typically a 3-element array or list. + e : float + The energy value at which to calculate the self-energy. + eta : float + A small imaginary part added to the energy for numerical stability. + lead_L : object + The left lead object, which must implement a `self_energy_cal` method. + lead_R : object + The right lead object, which must implement a `self_energy_cal` method. + self_energy_save_path : str + Directory path where the self-energy HDF5 files will be saved. + + Returns + ------- + None + The function saves the calculated self-energies to files and does not return anything. + """ + + save_tmp_L = os.path.join(self_energy_save_path, f"tmp_leadL_k{k[0]}_{k[1]}_{k[2]}_E{e:.8f}.h5") + save_tmp_R = os.path.join(self_energy_save_path, f"tmp_leadR_k{k[0]}_{k[1]}_{k[2]}_E{e:.8f}.h5") seL = lead_L.self_energy_cal(kpoint=k, energy=e, eta_lead=eta) seR = lead_R.self_energy_cal(kpoint=k, energy=e, eta_lead=eta) @@ -448,4 +608,17 @@ def merge_hdf5_files(tmp_dir, output_path, pattern, remove=True): os.remove(path) # log.info(f"Deleted tmp file: {path}") except Exception as e: - log.warning(f"Failed to delete {path}: {e}") \ No newline at end of file + log.warning(f"Failed to delete {path}: {e}") + + +def _has_saved_self_energy(root: str) -> bool: + from pathlib import Path + p = Path(root) if root is not None else None + if p is None or not p.exists(): + return False + + patterns = ("*.h5", "*.pth") + for pat in patterns: + if any(p.rglob(pat)): + return True + return False \ No newline at end of file diff --git a/dpnegf/runner/NEGF.py b/dpnegf/runner/NEGF.py index 8887ca7..3be097e 100644 --- a/dpnegf/runner/NEGF.py +++ b/dpnegf/runner/NEGF.py @@ -6,7 +6,7 @@ from dpnegf.utils.elec_struc_cal import ElecStruCal from dpnegf.negf.density import Ozaki,Fiori from dpnegf.negf.device_property import DeviceProperty -from dpnegf.negf.lead_property import LeadProperty, compute_all_self_energy +from dpnegf.negf.lead_property import LeadProperty, compute_all_self_energy, _has_saved_self_energy from dpnegf.negf.negf_utils import is_fully_covered import ase from dpnegf.utils.constants import Boltzmann, eV2J @@ -21,7 +21,6 @@ from pyinstrument import Profiler import os - log = logging.getLogger(__name__) @@ -49,7 +48,7 @@ def __init__(self, sgf_solver: str, e_fermi: float=None, use_saved_HS: bool=False, saved_HS_path: str=None, - self_energy_save: bool=False, self_energy_save_path: str=None, se_info_display: bool=False, + use_saved_se: bool=False, self_energy_save_path: str=None, se_info_display: bool=False, out_tc: bool=False,out_dos: bool=False,out_density: bool=False,out_potential: bool=False, out_current: bool=False,out_current_nscf: bool=False,out_ldos: bool=False,out_lcurrent: bool=False, results_path: Optional[str]=None, @@ -80,9 +79,9 @@ def __init__(self, self.saved_HS_path = saved_HS_path self.sgf_solver = sgf_solver - self.self_energy_save = self_energy_save - self.self_energy_save_path = self_energy_save_path - self.se_info_display = se_info_display + self.use_saved_se = use_saved_se # whether to use the saved self-energy or not + self.self_energy_save_path = self_energy_save_path # The directory to save the self-energy or for saved self-energy + self.se_info_display = se_info_display # whether to display the self-energy information after calculation self.pbc = self.stru_options["pbc"] if self.stru_options["lead_L"]["useBloch"] or self.stru_options["lead_R"]["useBloch"]: @@ -403,13 +402,13 @@ def compute(self): self.negf_compute(scf_require=False,Vbias=self.potential_at_orb) else: - # profiler = Profiler() - # profiler.start() + profiler = Profiler() + profiler.start() self.negf_compute(scf_require=False,Vbias=None) - # profiler.stop() - # output_path = os.path.join(self.results_path, "profile_report.html") - # with open(output_path, 'w') as report_file: - # report_file.write(profiler.output_html()) + profiler.stop() + output_path = os.path.join(self.results_path, "profile_report.html") + with open(output_path, 'w') as report_file: + report_file.write(profiler.output_html()) def poisson_negf_scf(self,interface_poisson,atom_gridpoint_index,err=1e-6,max_iter=1000, mix_method:str='linear', mix_rate:float=0.3, tolerance:float=1e-7,Gaussian_sigma:float=3.0): @@ -513,8 +512,49 @@ def poisson_negf_scf(self,interface_poisson,atom_gridpoint_index,err=1e-6,max_it # if iter_count <= max_iter: # profiler.stop() # with open('profile_report.html', 'w') as report_file: - # report_file.write(profiler.output_html()) - + # report_file.write(profiler.output_html())、 + + def prepare_self_energy(self, scf_require: bool) -> None: + """ + Prepares the self-energy for the NEGF calculation. + + Depending on the calculation settings, this method either loads previously saved self-energy data + or computes and saves new self-energy values for the device leads. The computation method varies + based on whether self-consistent field (SCF) calculations are required and whether Dirichlet boundary + conditions are applied to the leads. + + Parameters: + ---------- + scf_require (bool): Indicates whether SCF calculations are required. + """ + # self energy calculation + log.info(msg="------Self-energy calculation------") + if self.self_energy_save_path is None: + self.self_energy_save_path = os.path.join(self.results_path, "self_energy") + os.makedirs(self.self_energy_save_path, exist_ok=True) + + if self.use_saved_se: + assert _has_saved_self_energy(self.self_energy_save_path), "No saved self-energy found in {}".format(self.self_energy_save_path) + log.info(msg="Using saved self-energy from {}".format(self.self_energy_save_path)) + log.info(msg="Ensure the saved self-energy is consistent with the current calculation setting!") + else: + log.info(msg="Calculating self-energy and saving to {}".format(self.self_energy_save_path)) + if scf_require and self.poisson_options["with_Dirichlet_leads"]: + # For the Dirichlet leads, the self-energy of the leads is only calculated once and saved. + # In each iteration, the self-energy of the leads is not updated. + # for ik, k in enumerate(self.kpoints): + # for e in self.density.integrate_range: + # self.deviceprop.lead_L.self_energy(kpoint=k, energy=e, eta_lead=self.eta_lead, save=True) + # self.deviceprop.lead_R.self_energy(kpoint=k, energy=e, eta_lead=self.eta_lead, save=True) + compute_all_self_energy(self.eta_lead, self.deviceprop.lead_L, self.deviceprop.lead_R, + self.kpoints, self.density.integrate_range, self.self_energy_save_path) + elif not self.scf: + # In non-scf case, the self-energy of the leads is calculated for each energy point in the energy grid. + compute_all_self_energy(self.eta_lead, self.deviceprop.lead_L, self.deviceprop.lead_R, + self.kpoints, self.uni_grid, self.self_energy_save_path) + log.info(msg="-----------------------------------\n") + + def negf_compute(self,scf_require=False,Vbias=None): @@ -522,26 +562,7 @@ def negf_compute(self,scf_require=False,Vbias=None): self.out['k']=[];self.out['wk']=[] if hasattr(self, "uni_grid"): self.out["uni_grid"] = self.uni_grid - # self energy calculation - log.info(msg="------Self-energy calculation------") - selfen_parent_dir = os.path.join(self.results_path,"self_energy") - if not os.path.exists(selfen_parent_dir): - os.makedirs(selfen_parent_dir) - if scf_require and self.poisson_options["with_Dirichlet_leads"]: - # For the Dirichlet leads, the self-energy of the leads is only calculated once and saved. - # In each iteration, the self-energy of the leads is not updated. - # for ik, k in enumerate(self.kpoints): - # for e in self.density.integrate_range: - # self.deviceprop.lead_L.self_energy(kpoint=k, energy=e, eta_lead=self.eta_lead, save=True) - # self.deviceprop.lead_R.self_energy(kpoint=k, energy=e, eta_lead=self.eta_lead, save=True) - compute_all_self_energy(self.eta_lead, self.deviceprop.lead_L, self.deviceprop.lead_R, - self.kpoints, self.density.integrate_range) - elif not self.scf: - # In non-scf case, the self-energy of the leads is calculated for each energy point in the energy grid. - compute_all_self_energy(self.eta_lead, self.deviceprop.lead_L, self.deviceprop.lead_R, - self.kpoints, self.uni_grid) - log.info(msg="-----------------------------------\n") - + self.prepare_self_energy(scf_require) for ik, k in enumerate(self.kpoints): @@ -627,7 +648,6 @@ def negf_compute(self,scf_require=False,Vbias=None): kpoint=k, eta_lead=self.eta_lead, method=self.sgf_solver, - save=self.self_energy_save, save_path=self.self_energy_save_path, se_info_display=self.se_info_display ) @@ -641,7 +661,6 @@ def negf_compute(self,scf_require=False,Vbias=None): kpoint=k, eta_lead=self.eta_lead, method=self.sgf_solver, - save=self.self_energy_save, save_path=self.self_energy_save_path, se_info_display=self.se_info_display ) @@ -736,7 +755,6 @@ def negf_compute(self,scf_require=False,Vbias=None): kpoint=k, eta_lead=self.eta_lead, method=self.sgf_solver, - save=self.self_energy_save, save_path=self.self_energy_save_path, se_info_display=self.se_info_display ) diff --git a/dpnegf/tests/test_negf_negf_hamiltonian_init.py b/dpnegf/tests/test_negf_negf_hamiltonian_init.py index 58b24ac..562919a 100644 --- a/dpnegf/tests/test_negf_negf_hamiltonian_init.py +++ b/dpnegf/tests/test_negf_negf_hamiltonian_init.py @@ -75,8 +75,7 @@ def test_negf_Hamiltonian(root_directory): energy=e, kpoint=kpoints[0], eta_lead=negf_json['task_options']["eta_lead"], - method=negf_json['task_options']["sgf_solver"], - save=False + method=negf_json['task_options']["sgf_solver"] ) print("lead_L self energy:",deviceprop.lead_L.se) print("lead_R self energy:",deviceprop.lead_R.se) diff --git a/dpnegf/utils/argcheck.py b/dpnegf/utils/argcheck.py index 25601d3..14fa572 100644 --- a/dpnegf/utils/argcheck.py +++ b/dpnegf/utils/argcheck.py @@ -1047,8 +1047,8 @@ def negf(): Argument("stru_options", dict, optional=False, sub_fields=stru_options(), doc=doc_stru_options), Argument("poisson_options", dict, optional=True, default={}, sub_fields=[], sub_variants=[poisson_options()], doc=doc_poisson_options), Argument("sgf_solver", str, optional=True, default="Sancho-Rubio", doc=doc_sgf_solver), - Argument("self_energy_save", bool, optional=True, default=False, doc="whether to save the self energy"), - Argument("self_energy_save_path", str, optional=True, default=None, doc="the path to save the self energy"), + Argument("use_saved_se", bool, optional=True, default=False, doc="whether to use saved self energy"), + Argument("self_energy_save_path", str, optional=True, default=None, doc="the directory to save the self energy or load the self energy"), Argument("se_info_display", bool, optional=True, default=False, doc="whether to display the self energy information"), Argument("espacing", [int, float], optional=False, doc=doc_espacing), Argument("emin", [int, float], optional=False, doc=doc_emin), diff --git a/examples/graphene/band.json b/examples/graphene/band.json new file mode 100644 index 0000000..160ed40 --- /dev/null +++ b/examples/graphene/band.json @@ -0,0 +1,18 @@ +{ + "structure":"train/data/POSCAR", + "task_options": { + "task": "band", + "kline_type":"abacus", + "kpath":[ + [0, 0, 0, 50], + [0.5, 0, 0, 50], + [0.3333333, 0.3333333, 0, 50], + [0, 0, 0, 1] + ], + "nkpoints":151, + "klabels":["G", "M", "K", "G"], + "emin":-20, + "emax":20, + "nel_atom":{"C":4} + } +} \ No newline at end of file diff --git a/examples/graphene/extr_baseline/c_spds.json b/examples/graphene/extr_baseline/c_spds.json new file mode 100644 index 0000000..5da4b2c --- /dev/null +++ b/examples/graphene/extr_baseline/c_spds.json @@ -0,0 +1,11 @@ +{ + "common_options": { + "basis": { + "C": [ + "2s", + "2p", + "d*" + ] + } + } +} \ No newline at end of file diff --git a/examples/graphene/extr_baseline/grap_spd_model/sktb.json b/examples/graphene/extr_baseline/grap_spd_model/sktb.json new file mode 100644 index 0000000..50ad48a --- /dev/null +++ b/examples/graphene/extr_baseline/grap_spd_model/sktb.json @@ -0,0 +1,212 @@ +{ + "version": 2, + "unit": "eV", + "model_options": { + "nnsk": { + "onsite": { + "method": "uniform" + }, + "hopping": { + "method": "poly4pow", + "rs": { + "C-C": 4.39 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": false, + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "common_options": { + "basis": { + "C": [ + "2s", + "2p", + "d*" + ] + }, + "dtype": "float32", + "device": "cuda", + "overlap": true + }, + "model_params": { + "onsite": { + "C-2s-0": [ + -0.10686016082763672 + ], + "C-2p-0": [ + 0.12751197814941406 + ], + "C-d*-0": [ + 0.0 + ] + }, + "hopping": { + "C-C-2s-2s-0": [ + -6.684751033782959, + 4.326050281524658, + 7.401242733001709, + -24.684650421142578, + 7.83709192276001, + -0.5529974102973938 + ], + "C-C-2s-2p-0": [ + -6.9853434562683105, + -0.15866073966026306, + 11.681811332702637, + -10.92180347442627, + -1.95439612865448, + 1.0654785633087158 + ], + "C-C-2s-d*-0": [ + -0.00010646219016052783, + 6.032549572410062e-05, + -0.00012444439926184714, + 0.0001085955009330064, + -0.00013242202112451196, + 0.822330117225647 + ], + "C-C-2p-2p-0": [ + 6.175818920135498, + -0.6068210601806641, + -9.516790390014648, + 14.982359886169434, + -2.222520351409912, + -0.3968461751937866 + ], + "C-C-2p-2p-1": [ + -2.7375760078430176, + 1.839799165725708, + 2.1155834197998047, + -7.809864044189453, + 2.5414087772369385, + 1.215492844581604 + ], + "C-C-2p-d*-0": [ + -8.977071411209181e-05, + 4.293958772905171e-05, + 0.0001835303846746683, + 0.00033714837627485394, + 0.00011189249926246703, + -0.8198558688163757 + ], + "C-C-2p-d*-1": [ + -0.00015152650303207338, + 0.00021211523562669754, + 2.822246460709721e-05, + -0.00032705828198231757, + 0.0003069117374252528, + 0.8305988311767578 + ], + "C-C-d*-d*-0": [ + 9.454079554416239e-05, + -9.590329136699438e-05, + 0.00011994513624813408, + -6.711072637699544e-05, + 0.0002700634067878127, + 0.8173061013221741 + ], + "C-C-d*-d*-1": [ + 0.0001105186966015026, + -5.8947422076016665e-05, + 0.00023174105444923043, + 1.3896875316277146e-05, + 0.00017471887986175716, + 0.8142954707145691 + ], + "C-C-d*-d*-2": [ + -0.00010158663644688204, + 0.0003293976478744298, + 4.862011701334268e-05, + -7.672052015550435e-05, + 0.00016208819579333067, + 0.8196141719818115 + ] + }, + "overlap": { + "C-C-2s-2s-0": [ + 0.2466021627187729, + -0.20137032866477966, + -0.22465133666992188, + 0.9475207924842834, + -0.3242596387863159, + 0.35583510994911194 + ], + "C-C-2s-2p-0": [ + 0.30228379368782043, + -0.19255711138248444, + -0.40023675560951233, + 1.26386559009552, + -0.3918810188770294, + -5.578631680691615e-05 + ], + "C-C-2s-d*-0": [ + -9.066608618013561e-05, + -4.845444345846772e-05, + 7.032023859210312e-06, + -0.0003356275847181678, + -3.039978037122637e-05, + -0.740434467792511 + ], + "C-C-2p-2p-0": [ + -0.31055670976638794, + 0.0015619457699358463, + 0.7435058951377869, + -1.2593721151351929, + 0.22618918120861053, + -0.00022265399456955492 + ], + "C-C-2p-2p-1": [ + 0.13884934782981873, + -0.12665610015392303, + -0.11550959944725037, + 0.5953179597854614, + -0.22506600618362427, + 0.875838041305542 + ], + "C-C-2p-d*-0": [ + 0.00012514149420894682, + -6.299408414633945e-05, + 0.0003052930405829102, + -0.00024931083316914737, + -3.0835799407213926e-05, + 0.737001895904541 + ], + "C-C-2p-d*-1": [ + -9.066608618013561e-05, + -4.8454414354637265e-05, + 7.032198482193053e-06, + -0.00033562741009518504, + -3.040030424017459e-05, + -0.740434467792511 + ], + "C-C-d*-d*-0": [ + -9.120674803853035e-05, + 0.0001677007821854204, + 1.4481425751000643e-05, + 0.0002868282899726182, + 0.00019680232799146324, + 0.7440820932388306 + ], + "C-C-d*-d*-1": [ + 5.5082375183701515e-05, + 0.00013481048517860472, + 6.67735148454085e-05, + 0.00022058241302147508, + 0.00018173769058194011, + 0.741083025932312 + ], + "C-C-d*-d*-2": [ + 0.00012257523485459387, + -0.0001119638400268741, + 0.00022559240460395813, + 0.00034283509012311697, + 0.00016658403910696507, + 0.7432126402854919 + ] + } + } +} \ No newline at end of file diff --git a/examples/graphene/extr_baseline/input_templete.json b/examples/graphene/extr_baseline/input_templete.json new file mode 100644 index 0000000..1272931 --- /dev/null +++ b/examples/graphene/extr_baseline/input_templete.json @@ -0,0 +1,85 @@ +{ + "common_options": { + "basis": { + "C": [ + "2s", + "2p", + "d*" + ] + }, + "device": "cpu", + "dtype": "float32", + "overlap": true, + "seed": 3982377700 + }, + "train_options": { + "num_epoch": 2, + "batch_size": 1, + "optimizer": { + "lr": 0.01, + "type": "Adam" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.999 + }, + "loss_options": { + "train": { + "method": "eigvals", + "diff_on": false, + "eout_weight": 0.001, + "diff_weight": 0.01 + } + }, + "save_freq": 1, + "validation_freq": 10, + "display_freq": 100, + "ref_batch_size": 1, + "val_batch_size": 1, + "max_ckpt": 4 + }, + "model_options": { + "nnsk": { + "onsite": { + "method": "uniform" + }, + "hopping": { + "method": "poly4pow", + "rs": { + "C-C": 4.39 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": [ + "overlap" + ], + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "data_options": { + "train": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + }, + "validation": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + }, + "reference": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + } + } +} \ No newline at end of file diff --git a/examples/graphene/train/data/POSCAR b/examples/graphene/train/data/POSCAR new file mode 100644 index 0000000..22a41d8 --- /dev/null +++ b/examples/graphene/train/data/POSCAR @@ -0,0 +1,10 @@ +C + 1.0000000000000000 + 2.5039999485000002 0.0000000000000000 0.0000000000000000 + -1.2519999743000001 2.1685275664999999 0.0000000000000000 + 0.0000000000000000 0.0000000000000000 30.0000000000000000 + C + 2 +Cartesian + -0.0000000012853333 1.4456850884267272 15.0000000000000000 + 1.2519999003653348 0.7228424780732728 15.0000000000000000 diff --git a/examples/graphene/train/data/kpath.0/band_structure.png b/examples/graphene/train/data/kpath.0/band_structure.png new file mode 100644 index 0000000..8d1e9a6 Binary files /dev/null and b/examples/graphene/train/data/kpath.0/band_structure.png differ diff --git a/examples/graphene/train/data/kpath.0/eigenvalues.npy b/examples/graphene/train/data/kpath.0/eigenvalues.npy new file mode 100644 index 0000000..deee94b Binary files /dev/null and b/examples/graphene/train/data/kpath.0/eigenvalues.npy differ diff --git a/examples/graphene/train/data/kpath.0/info.json b/examples/graphene/train/data/kpath.0/info.json new file mode 100644 index 0000000..cb9046c --- /dev/null +++ b/examples/graphene/train/data/kpath.0/info.json @@ -0,0 +1,12 @@ +{ + "nframes": 1, + "natoms": 2, + "pos_type": "ase", + "pbc": true, + "bandinfo": { + "band_min": 0, + "band_max": 8, + "emin": null, + "emax": null + } +} diff --git a/examples/graphene/train/data/kpath.0/kpoints.npy b/examples/graphene/train/data/kpath.0/kpoints.npy new file mode 100644 index 0000000..747b537 Binary files /dev/null and b/examples/graphene/train/data/kpath.0/kpoints.npy differ diff --git a/examples/graphene/train/data/kpath.0/xdat.traj b/examples/graphene/train/data/kpath.0/xdat.traj new file mode 100644 index 0000000..9d6bd8c Binary files /dev/null and b/examples/graphene/train/data/kpath.0/xdat.traj differ diff --git a/examples/graphene/train/input.json b/examples/graphene/train/input.json new file mode 100644 index 0000000..4abbc5e --- /dev/null +++ b/examples/graphene/train/input.json @@ -0,0 +1,71 @@ +{ + "common_options": { + "basis": { + "C": [ + "2s", + "2p", + "d*" + ] + }, + "device": "cpu", + "dtype": "float32", + "overlap": true, + "seed": 3982377700 + }, + "train_options": { + "num_epoch": 5000, + "batch_size": 1, + "optimizer": { + "lr": 0.01, + "type": "Adam" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.9995 + }, + "loss_options": { + "train": { + "method": "eigvals", + "diff_on": false, + "eout_weight": 0.001, + "diff_weight": 0.01 + } + }, + "save_freq": 1, + "validation_freq": 10, + "display_freq": 100, + "ref_batch_size": 1, + "val_batch_size": 1, + "max_ckpt": 4 + }, + "model_options": { + "nnsk": { + "onsite": { + "method": "strain" + }, + "hopping": { + "method": "poly4pow", + "rs": { + "C-C": 4.39 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": [ + "overlap" + ], + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "data_options": { + "train": { + "root": "./data", + "prefix": "kpath", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + } + } +} \ No newline at end of file diff --git a/examples/graphene/train/train_out/checkpoint/nnsk.best.pth b/examples/graphene/train/train_out/checkpoint/nnsk.best.pth new file mode 120000 index 0000000..7b032ac --- /dev/null +++ b/examples/graphene/train/train_out/checkpoint/nnsk.best.pth @@ -0,0 +1 @@ +/personal/DeepTB/dptb_Zjj/dpnegf/examples/graphene/train/train_out/checkpoint/nnsk.ep5000.pth \ No newline at end of file diff --git a/examples/graphene/train/train_out/checkpoint/nnsk.ep5000.pth b/examples/graphene/train/train_out/checkpoint/nnsk.ep5000.pth new file mode 100644 index 0000000..068090b Binary files /dev/null and b/examples/graphene/train/train_out/checkpoint/nnsk.ep5000.pth differ diff --git a/examples/hBN/band.json b/examples/hBN/band.json new file mode 100644 index 0000000..b60fe88 --- /dev/null +++ b/examples/hBN/band.json @@ -0,0 +1,18 @@ +{ + "structure":"train/data/POSCAR", + "task_options": { + "task": "band", + "kline_type":"abacus", + "kpath":[ + [0, 0, 0, 50], + [0.5, 0, 0, 50], + [0.3333333, 0.3333333, 0, 50], + [0, 0, 0, 1] + ], + "nkpoints":151, + "klabels":["G", "M", "K", "G"], + "emin":-25, + "emax":20, + "nel_atom":{"B":3,"N":5} + } +} \ No newline at end of file diff --git a/examples/hBN/extra_baseline/bn_spds.json b/examples/hBN/extra_baseline/bn_spds.json new file mode 100644 index 0000000..3a372fc --- /dev/null +++ b/examples/hBN/extra_baseline/bn_spds.json @@ -0,0 +1,16 @@ +{ + "common_options": { + "basis": { + "B": [ + "2s", + "2p", + "d*" + ], + "N": [ + "2s", + "2p", + "d*" + ] + } + } +} \ No newline at end of file diff --git a/examples/hBN/extra_baseline/hbn_spd_model/sktb.json b/examples/hBN/extra_baseline/hbn_spd_model/sktb.json new file mode 100644 index 0000000..9ca6084 --- /dev/null +++ b/examples/hBN/extra_baseline/hbn_spd_model/sktb.json @@ -0,0 +1,477 @@ +{ + "version": 2, + "unit": "eV", + "model_options": { + "nnsk": { + "onsite": { + "method": "uniform" + }, + "hopping": { + "method": "poly2pow", + "rs": { + "B-B": 4.22, + "B-N": 4.04, + "N-B": 4.04, + "N-N": 3.85 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": false, + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "common_options": { + "basis": { + "B": [ + "2s", + "2p", + "d*" + ], + "N": [ + "2s", + "2p", + "d*" + ] + }, + "dtype": "float32", + "device": "cuda", + "overlap": true + }, + "model_params": { + "onsite": { + "B-2s-0": [ + -0.05371570587158203 + ], + "B-2p-0": [ + 0.11017870903015137 + ], + "B-d*-0": [ + 0.0 + ], + "N-2s-0": [ + -0.15561676025390625 + ], + "N-2p-0": [ + 0.1445450782775879 + ], + "N-d*-0": [ + 0.0 + ] + }, + "hopping": { + "B-B-2s-2s-0": [ + -4.038558483123779, + -1.199519157409668, + 2.6829679012298584, + -1.6895099878311157 + ], + "B-B-2s-2p-0": [ + -4.128350734710693, + -1.6135889291763306, + 2.751228094100952, + -1.3629639148712158 + ], + "B-B-2s-d*-0": [ + 0.0017082728445529938, + -0.00010188308078795671, + 0.000718078576028347, + 0.37305518984794617 + ], + "B-B-2p-2p-0": [ + 3.9094669818878174, + 1.5527981519699097, + -2.3236680030822754, + 0.9059035181999207 + ], + "B-B-2p-2p-1": [ + -1.7056468725204468, + -0.2540814280509949, + 1.0908770561218262, + -2.4367024898529053 + ], + "B-B-2p-d*-0": [ + -0.0017082728445529938, + 0.00010188308078795671, + -0.000718078576028347, + -0.37305518984794617 + ], + "B-B-2p-d*-1": [ + 0.0017082728445529938, + -0.00010188308078795671, + 0.000718078576028347, + -0.37305518984794617 + ], + "B-B-d*-d*-0": [ + -0.0017082728445529938, + 0.00010188308078795671, + -0.000718078576028347, + 0.37305518984794617 + ], + "B-B-d*-d*-1": [ + -0.0017082728445529938, + 0.00010188308078795671, + -0.000718078576028347, + -0.37305518984794617 + ], + "B-B-d*-d*-2": [ + -0.0017082728445529938, + 0.00010188308078795671, + -0.000718078576028347, + -0.37305518984794617 + ], + "N-B-2s-2s-0": [ + -5.041027069091797, + 3.3467164039611816, + 0.5421984195709229, + 0.0005886993603780866 + ], + "N-B-2p-2s-0": [ + -4.393885612487793, + -2.106684923171997, + 3.2828798294067383, + -1.4983776807785034 + ], + "N-B-d*-2s-0": [ + -0.0023875299375504255, + -0.0005914703942835331, + -0.0028732563368976116, + -0.4312877655029297 + ], + "N-B-2p-2p-0": [ + 4.577764511108398, + 2.0131304264068604, + -2.9041666984558105, + 1.1945785284042358 + ], + "N-B-2p-2p-1": [ + -1.9847829341888428, + 2.879638671875, + -1.1304956674575806, + -0.03383827209472656 + ], + "N-B-d*-2p-0": [ + -0.0023875299375504255, + -0.0005914703942835331, + -0.0028732563368976116, + -0.4312877655029297 + ], + "N-B-d*-2p-1": [ + -0.0023875299375504255, + -0.0005914703942835331, + -0.0028732563368976116, + -0.4312877655029297 + ], + "N-B-d*-d*-0": [ + 0.0012587409000843763, + 0.0005593118839897215, + 0.0009227871196344495, + 0.4214722514152527 + ], + "N-B-d*-d*-1": [ + 0.0012587409000843763, + 0.0005593118839897215, + 0.0009227871196344495, + -0.4214722514152527 + ], + "N-B-d*-d*-2": [ + 0.0012587409000843763, + 0.0005593118839897215, + 0.0009227871196344495, + 0.4214722514152527 + ], + "N-B-2s-2p-0": [ + -5.908745288848877, + 2.9499411582946777, + 1.29582941532135, + -0.0018063357565551996 + ], + "N-B-2s-d*-0": [ + 0.0009504631161689758, + -0.00042798847425729036, + 0.0015698844799771905, + 0.4099060297012329 + ], + "N-B-2p-d*-0": [ + 0.0009504631161689758, + -0.00042798847425729036, + 0.0015698844799771905, + 0.4099060297012329 + ], + "N-B-2p-d*-1": [ + -0.0009504631161689758, + 0.00042798847425729036, + -0.0015698844799771905, + -0.4099060297012329 + ], + "N-N-2s-2s-0": [ + -5.928829193115234, + -2.148087739944458, + 5.178451061248779, + 2.231917142868042 + ], + "N-N-2s-2p-0": [ + -6.170498847961426, + 3.439049482345581, + 1.229480504989624, + 0.0035096562933176756 + ], + "N-N-2s-d*-0": [ + 0.0012703586835414171, + -0.00015861238352954388, + 0.001094977604225278, + 0.5266291499137878 + ], + "N-N-2p-2p-0": [ + 5.38631010055542, + 2.6419241428375244, + -3.6682467460632324, + -1.4427080154418945 + ], + "N-N-2p-2p-1": [ + -2.285525321960449, + 3.412506341934204, + -1.3955022096633911, + 0.20774821937084198 + ], + "N-N-2p-d*-0": [ + 0.001571853761561215, + -2.4328939616680145e-05, + -0.0001450164709240198, + 0.5258426070213318 + ], + "N-N-2p-d*-1": [ + 0.0012703586835414171, + -0.00015861238352954388, + 0.001094977604225278, + 0.5266291499137878 + ], + "N-N-d*-d*-0": [ + 0.0012703586835414171, + -0.00015861238352954388, + 0.001094977604225278, + 0.5266291499137878 + ], + "N-N-d*-d*-1": [ + 0.001571853761561215, + -2.4328939616680145e-05, + -0.0001450164709240198, + 0.5258426070213318 + ], + "N-N-d*-d*-2": [ + 0.0005028393352404237, + -0.001955810934305191, + -0.0007955109467729926, + 0.5363121032714844 + ] + }, + "overlap": { + "B-B-2s-2s-0": [ + 0.20485031604766846, + -0.17363706231117249, + 0.006893493700772524, + -0.0032229996286332607 + ], + "B-B-2s-2p-0": [ + 0.24623462557792664, + 0.06719570606946945, + -0.18939271569252014, + -1.784712791442871 + ], + "B-B-2s-d*-0": [ + -0.0014473807532340288, + -0.000488920253701508, + -0.0011009315494447947, + 0.26260989904403687 + ], + "B-B-2p-2p-0": [ + -0.2841918468475342, + -0.12392652779817581, + 0.24365650117397308, + -1.409106969833374 + ], + "B-B-2p-2p-1": [ + 0.10009986162185669, + -0.1610490381717682, + 0.0626494288444519, + 0.004236152861267328 + ], + "B-B-2p-d*-0": [ + -0.0014473807532340288, + -0.000488920253701508, + -0.0011009315494447947, + -0.26260989904403687 + ], + "B-B-2p-d*-1": [ + 0.0014473807532340288, + 0.000488920253701508, + 0.0011009315494447947, + -0.26260989904403687 + ], + "B-B-d*-d*-0": [ + -0.0014473807532340288, + -0.000488920253701508, + -0.0011009315494447947, + -0.26260989904403687 + ], + "B-B-d*-d*-1": [ + -0.0014473807532340288, + -0.000488920253701508, + -0.0011009315494447947, + -0.26260989904403687 + ], + "B-B-d*-d*-2": [ + -0.0014473807532340288, + -0.000488920253701508, + -0.0011009315494447947, + -0.26260989904403687 + ], + "N-B-2s-2s-0": [ + 0.19150348007678986, + -0.17817053198814392, + 0.014571275562047958, + -0.001921347575262189 + ], + "N-B-2p-2s-0": [ + 0.22621256113052368, + 0.08030299842357635, + -0.1885663866996765, + 1.6908323764801025 + ], + "N-B-d*-2s-0": [ + 0.0011789548443630338, + -0.001103704096749425, + 0.0007307003252208233, + -0.34559008479118347 + ], + "N-B-2p-2p-0": [ + -0.2685352563858032, + -0.13696980476379395, + 0.24854600429534912, + 1.37538743019104 + ], + "N-B-2p-2p-1": [ + 0.0985078290104866, + -0.16014429926872253, + 0.0642596036195755, + 0.0005193660035729408 + ], + "N-B-d*-2p-0": [ + 0.0011789548443630338, + -0.001103704096749425, + 0.0007307003252208233, + 0.34559008479118347 + ], + "N-B-d*-2p-1": [ + -0.0011789548443630338, + 0.001103704096749425, + -0.0007307003252208233, + 0.34559008479118347 + ], + "N-B-d*-d*-0": [ + -0.0010213993955403566, + -0.0007757929270155728, + -0.0015712291933596134, + 0.3408437669277191 + ], + "N-B-d*-d*-1": [ + -0.0010213993955403566, + -0.0007757929270155728, + -0.0015712291933596134, + -0.3408437669277191 + ], + "N-B-d*-d*-2": [ + 0.0010213993955403566, + 0.0007757929270155728, + 0.0015712291933596134, + -0.3408437669277191 + ], + "N-B-2s-2p-0": [ + 0.2480807900428772, + -0.14911773800849915, + -0.05014884099364281, + 0.003565874882042408 + ], + "N-B-2s-d*-0": [ + -0.001136684324592352, + -0.002417572308331728, + -0.0016107913106679916, + 0.33359917998313904 + ], + "N-B-2p-d*-0": [ + -0.001136684324592352, + -0.002417572308331728, + -0.0016107913106679916, + -0.33359917998313904 + ], + "N-B-2p-d*-1": [ + -0.001136684324592352, + -0.002417572308331728, + -0.0016107913106679916, + -0.33359917998313904 + ], + "N-N-2s-2s-0": [ + 0.18359141051769257, + -0.2061317414045334, + 0.04202547296881676, + -0.00020195427350699902 + ], + "N-N-2s-2p-0": [ + 0.23071497678756714, + -0.13267643749713898, + -0.055204350501298904, + -0.0023973402567207813 + ], + "N-N-2s-d*-0": [ + 0.0016565254190936685, + 0.0014474809868261218, + 0.00041490281000733376, + -0.45187631249427795 + ], + "N-N-2p-2p-0": [ + -0.2622714042663574, + -0.1595517098903656, + 0.2705942988395691, + 1.4069056510925293 + ], + "N-N-2p-2p-1": [ + 0.10322311520576477, + -0.17261548340320587, + 0.073711097240448, + 0.000982851255685091 + ], + "N-N-2p-d*-0": [ + -0.0016565254190936685, + -0.0014474809868261218, + -0.00041490281000733376, + 0.45187631249427795 + ], + "N-N-2p-d*-1": [ + -0.0016565254190936685, + -0.0014474809868261218, + -0.00041490281000733376, + -0.45187631249427795 + ], + "N-N-d*-d*-0": [ + -0.0016565254190936685, + -0.0014474809868261218, + -0.00041490281000733376, + 0.45187631249427795 + ], + "N-N-d*-d*-1": [ + -0.0016565254190936685, + -0.0014474809868261218, + -0.00041490281000733376, + 0.45187631249427795 + ], + "N-N-d*-d*-2": [ + -0.0016565254190936685, + -0.0014474809868261218, + -0.00041490281000733376, + 0.45187631249427795 + ] + } + } +} \ No newline at end of file diff --git a/examples/hBN/extra_baseline/input_templete.json b/examples/hBN/extra_baseline/input_templete.json new file mode 100644 index 0000000..172ac9a --- /dev/null +++ b/examples/hBN/extra_baseline/input_templete.json @@ -0,0 +1,93 @@ +{ + "common_options": { + "basis": { + "B": [ + "2s", + "2p", + "d*" + ], + "N": [ + "2s", + "2p", + "d*" + ] + }, + "device": "cpu", + "dtype": "float32", + "overlap": true, + "seed": 3982377700 + }, + "train_options": { + "num_epoch": 2, + "batch_size": 1, + "optimizer": { + "lr": 0.01, + "type": "Adam" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.999 + }, + "loss_options": { + "train": { + "method": "eigvals", + "diff_on": false, + "eout_weight": 0.001, + "diff_weight": 0.01 + } + }, + "save_freq": 1, + "validation_freq": 10, + "display_freq": 100, + "ref_batch_size": 1, + "val_batch_size": 1, + "max_ckpt": 4 + }, + "model_options": { + "nnsk": { + "onsite": { + "method": "uniform" + }, + "hopping": { + "method": "poly2pow", + "rs": { + "B-B": 4.22, + "B-N": 4.04, + "N-B": 4.04, + "N-N": 3.85 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": [ + "overlap" + ], + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "data_options": { + "train": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + }, + "validation": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + }, + "reference": { + "root": "path/to/dataset", + "prefix": "prexfix_for_dataset", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + } + } +} \ No newline at end of file diff --git a/examples/hBN/train/data/POSCAR b/examples/hBN/train/data/POSCAR new file mode 100644 index 0000000..2671929 --- /dev/null +++ b/examples/hBN/train/data/POSCAR @@ -0,0 +1,10 @@ +N B + 1.0000000000000000 + 2.5039999485000002 0.0000000000000000 0.0000000000000000 + -1.2519999743000001 2.1685275664999999 0.0000000000000000 + 0.0000000000000000 0.0000000000000000 30.0000000000000000 + N B + 1 1 +Cartesian + -0.0000000012853333 1.4456850884267272 15.0000000000000000 + 1.2519999003653348 0.7228424780732728 15.0000000000000000 diff --git a/examples/hBN/train/data/kpath.0/band_structure.png b/examples/hBN/train/data/kpath.0/band_structure.png new file mode 100644 index 0000000..3d641f1 Binary files /dev/null and b/examples/hBN/train/data/kpath.0/band_structure.png differ diff --git a/examples/hBN/train/data/kpath.0/eigenvalues.npy b/examples/hBN/train/data/kpath.0/eigenvalues.npy new file mode 100644 index 0000000..3d45c9e Binary files /dev/null and b/examples/hBN/train/data/kpath.0/eigenvalues.npy differ diff --git a/examples/hBN/train/data/kpath.0/info.json b/examples/hBN/train/data/kpath.0/info.json new file mode 100644 index 0000000..cb9046c --- /dev/null +++ b/examples/hBN/train/data/kpath.0/info.json @@ -0,0 +1,12 @@ +{ + "nframes": 1, + "natoms": 2, + "pos_type": "ase", + "pbc": true, + "bandinfo": { + "band_min": 0, + "band_max": 8, + "emin": null, + "emax": null + } +} diff --git a/examples/hBN/train/data/kpath.0/kpoints.npy b/examples/hBN/train/data/kpath.0/kpoints.npy new file mode 100644 index 0000000..747b537 Binary files /dev/null and b/examples/hBN/train/data/kpath.0/kpoints.npy differ diff --git a/examples/hBN/train/data/kpath.0/xdat.traj b/examples/hBN/train/data/kpath.0/xdat.traj new file mode 100644 index 0000000..0cf248d Binary files /dev/null and b/examples/hBN/train/data/kpath.0/xdat.traj differ diff --git a/examples/hBN/train/input.json b/examples/hBN/train/input.json new file mode 100644 index 0000000..eb04861 --- /dev/null +++ b/examples/hBN/train/input.json @@ -0,0 +1,79 @@ +{ + "common_options": { + "basis": { + "B": [ + "2s", + "2p", + "d*" + ], + "N": [ + "2s", + "2p", + "d*" + ] + }, + "device": "cpu", + "dtype": "float32", + "overlap": true, + "seed": 3982377700 + }, + "train_options": { + "num_epoch": 5000, + "batch_size": 1, + "optimizer": { + "lr": 0.01, + "type": "Adam" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.9995 + }, + "loss_options": { + "train": { + "method": "eigvals", + "diff_on": false, + "eout_weight": 0.001, + "diff_weight": 0.01 + } + }, + "save_freq": 1, + "validation_freq": 10, + "display_freq": 100, + "ref_batch_size": 1, + "val_batch_size": 1, + "max_ckpt": 4 + }, + "model_options": { + "nnsk": { + "onsite": { + "method": "strain" + }, + "hopping": { + "method": "poly2pow", + "rs": { + "B-B": 4.22, + "B-N": 4.04, + "N-B": 4.04, + "N-N": 3.85 + }, + "w": 0.2 + }, + "soc": {}, + "freeze": [ + "overlap" + ], + "push": false, + "std": 0.01, + "atomic_radius": "cov" + } + }, + "data_options": { + "train": { + "root": "./data", + "prefix": "kpath", + "get_eigenvalues": true, + "type": "DefaultDataset", + "get_Hamiltonian": false + } + } +} \ No newline at end of file diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.best.pth b/examples/hBN/train/train_out/checkpoint/nnsk.best.pth new file mode 120000 index 0000000..bf27b36 --- /dev/null +++ b/examples/hBN/train/train_out/checkpoint/nnsk.best.pth @@ -0,0 +1 @@ +/personal/DeepTB/dptb_Zjj/dpnegf/examples/hBN/train/train_out/checkpoint/nnsk.ep5000.pth \ No newline at end of file diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.ep4997.pth b/examples/hBN/train/train_out/checkpoint/nnsk.ep4997.pth new file mode 100644 index 0000000..dcff150 Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.ep4997.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.ep4998.pth b/examples/hBN/train/train_out/checkpoint/nnsk.ep4998.pth new file mode 100644 index 0000000..56a9cd1 Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.ep4998.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.ep4999.pth b/examples/hBN/train/train_out/checkpoint/nnsk.ep4999.pth new file mode 100644 index 0000000..edc595a Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.ep4999.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.ep5000.pth b/examples/hBN/train/train_out/checkpoint/nnsk.ep5000.pth new file mode 100644 index 0000000..b32035a Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.ep5000.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.iter4997.pth b/examples/hBN/train/train_out/checkpoint/nnsk.iter4997.pth new file mode 100644 index 0000000..14e5196 Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.iter4997.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.iter4998.pth b/examples/hBN/train/train_out/checkpoint/nnsk.iter4998.pth new file mode 100644 index 0000000..f8a4bce Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.iter4998.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.iter4999.pth b/examples/hBN/train/train_out/checkpoint/nnsk.iter4999.pth new file mode 100644 index 0000000..0acb1df Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.iter4999.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.iter5000.pth b/examples/hBN/train/train_out/checkpoint/nnsk.iter5000.pth new file mode 100644 index 0000000..f08dc10 Binary files /dev/null and b/examples/hBN/train/train_out/checkpoint/nnsk.iter5000.pth differ diff --git a/examples/hBN/train/train_out/checkpoint/nnsk.latest.pth b/examples/hBN/train/train_out/checkpoint/nnsk.latest.pth new file mode 120000 index 0000000..1137c9d --- /dev/null +++ b/examples/hBN/train/train_out/checkpoint/nnsk.latest.pth @@ -0,0 +1 @@ +/personal/DeepTB/dptb_Zjj/dpnegf/examples/hBN/train/train_out/checkpoint/nnsk.iter5000.pth \ No newline at end of file