From f6207dd4fa608b66f759a40cac16ade8d38ee0bb Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 16:05:45 +0800 Subject: [PATCH 01/13] add runner_device in NEGF.py --- dpnegf/runner/NEGF.py | 17 ++++++++++------- dpnegf/utils/argcheck.py | 6 +++++- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/dpnegf/runner/NEGF.py b/dpnegf/runner/NEGF.py index 16b9132..e9eb918 100644 --- a/dpnegf/runner/NEGF.py +++ b/dpnegf/runner/NEGF.py @@ -54,7 +54,7 @@ def __init__(self, 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, plot_blocks: Optional[bool]=False, - torch_device: Union[str, torch.device]=torch.device('cpu'), + runner_device: Union[str, torch.device]='cpu', AtomicData_options: Optional[dict]=None, n_cpus: Optional[int]=None, e_batch_size: Optional[int]=None, @@ -64,7 +64,9 @@ def __init__(self, # self.model = model # No need to set model as property for memory saving self.results_path = results_path self.cdtype = torch.complex128 - self.torch_device = torch_device + if isinstance(runner_device, str): + runner_device = torch.device(runner_device) + self.runner_device = runner_device self.n_cpus = n_cpus self.e_batch_size = e_batch_size @@ -154,7 +156,7 @@ def __init__(self, stru_options=self.stru_options, unit = self.unit, results_path=self.results_path, - torch_device = self.torch_device) + torch_device = self.runner_device) # if useBloch is None, structure_leads_fold,bloch_sorted_indices,bloch_R_lists = None,None,None struct_device, struct_leads,structure_leads_fold,bloch_sorted_indices,bloch_R_lists = \ self.negf_hamiltonian.initialize(kpoints=self.kpoints, @@ -182,7 +184,7 @@ def __init__(self, e_fermi = {}; chemiPot = {} # calculate Fermi level if self.e_fermi is None: - elec_cal = ElecStruCal(model=model,device=self.torch_device) + elec_cal = ElecStruCal(model=model,device=self.runner_device) nel_atom_lead = self.get_nel_atom_lead( struct_leads, charge={lead_tag: self.stru_options[lead_tag].get("charge", 0) for lead_tag in ["lead_L", "lead_R"]} @@ -234,7 +236,8 @@ def __init__(self, # initialize deviceprop and leadprop self.deviceprop = DeviceProperty(self.negf_hamiltonian, struct_device, results_path=self.results_path, - efermi=self.e_fermi, chemiPot=chemiPot, E_ref=E_ref) + efermi=self.e_fermi, chemiPot=chemiPot, E_ref=E_ref, + runner_device=self.runner_device) self.deviceprop.set_leadLR( lead_L=LeadProperty( hamiltonian=self.negf_hamiltonian, @@ -476,7 +479,7 @@ def poisson_negf_scf(self,interface_poisson,atom_gridpoint_index,err=1e-6,max_it # TODO: add k summation operation free_charge_allk = torch.zeros_like(torch.tensor(self.device_atom_norbs)) for ik,k in enumerate(self.kpoints): - free_charge_allk += np.real(self.free_charge[str(k)].numpy()) * self.wk[ik] + free_charge_allk += np.real(self.free_charge[str(k)].cpu().numpy()) * self.wk[ik] interface_poisson.free_charge[atom_gridpoint_index] = free_charge_allk @@ -594,7 +597,7 @@ def negf_compute(self,scf_require=False,Vbias=None): self.out['k'].append(k) self.out['wk'].append(self.wk[ik]) - self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs),dtype=torch.complex128)}) + self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs),dtype=torch.complex128, device=self.runner_device)}) log.info(f"Properties computation at k = ({', '.join([f'{kk:>6.4f}' for kk in k])})") if scf_require: diff --git a/dpnegf/utils/argcheck.py b/dpnegf/utils/argcheck.py index 6cf38e0..b1f4369 100644 --- a/dpnegf/utils/argcheck.py +++ b/dpnegf/utils/argcheck.py @@ -1068,7 +1068,11 @@ def negf(): Argument("out_current_nscf", bool, optional=True, default=False, doc=doc_out_current_nscf), Argument("out_ldos", bool, optional=True, default=False, doc=doc_out_ldos), Argument("out_lcurrent", bool, optional=True, default=False, doc=doc_out_lcurrent), - Argument("n_cpus", [int, None], optional=True, default=None, doc="Number of CPU cores for parallel self-energy calculation. Default None uses os.cpu_count().") + Argument("n_cpus", [int, None], optional=True, default=None, doc="Number of CPU cores for parallel self-energy calculation. Default None uses os.cpu_count()."), + Argument("runner_device", str, optional=True, default="cpu", + doc="Device used for NEGF Hamiltonian init and recursive Green's function (RGF). " + "'cpu' (default) or 'cuda'. Self-energy calculation always runs on CPU " + "because it goes through joblib+numba.") ] def stru_options(): From ce2ad8d200c3971afc47d8bd85fb79a33dd9ea26 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 16:07:04 +0800 Subject: [PATCH 02/13] add runner_device in density.py --- dpnegf/negf/density.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/dpnegf/negf/density.py b/dpnegf/negf/density.py index 19e6ea2..1a63740 100644 --- a/dpnegf/negf/density.py +++ b/dpnegf/negf/density.py @@ -190,7 +190,7 @@ def integrate(self, deviceprop, kpoint, eta_lead=1e-5, eta_device=0.,Vbias=None, deviceprop.lead_L.self_energy(kpoint=kpoint, energy=e, eta_lead=eta_lead) deviceprop.lead_R.self_energy(kpoint=kpoint, energy=e, eta_lead=eta_lead) deviceprop.cal_green_function(energy=e, kpoint=kpoint, block_tridiagonal=block_tridiagonal, eta_device=eta_device) - gr_gamma_ga = torch.mm(torch.mm(deviceprop.grd[0], deviceprop.lead_R.gamma), deviceprop.grd[0].conj().T).real + gr_gamma_ga = torch.mm(torch.mm(deviceprop.grd[0], deviceprop.lead_R.gamma.to(deviceprop.grd[0].device)), deviceprop.grd[0].conj().T).real gr_gamma_ga = gr_gamma_ga * (deviceprop.lead_R.fermi_dirac(e+deviceprop.mu) - deviceprop.lead_L.fermi_dirac(e+deviceprop.mu)) DM_neq = DM_neq + wlg[i] * gr_gamma_ga else: @@ -292,10 +292,11 @@ def density_integrate_Fiori(self,e_grid,kpoint,Vbias,block_tridiagonal,subblocks x0 = min(lx, tx) x1 = min(rx, ty) - gammaL = torch.zeros(size=(tx, tx), dtype=torch.complex128) - gammaL[:x0, :x0] += deviceprop.lead_L.gamma[:x0, :x0] - gammaR = torch.zeros(size=(ty, ty), dtype=torch.complex128) - gammaR[-x1:, -x1:] += deviceprop.lead_R.gamma[-x1:, -x1:] + gf_device = deviceprop.g_trans.device + gammaL = torch.zeros(size=(tx, tx), dtype=torch.complex128, device=gf_device) + gammaL[:x0, :x0] += deviceprop.lead_L.gamma[:x0, :x0].to(gf_device) + gammaR = torch.zeros(size=(ty, ty), dtype=torch.complex128, device=gf_device) + gammaR[-x1:, -x1:] += deviceprop.lead_R.gamma[-x1:, -x1:].to(gf_device) if not block_tridiagonal: A_Rd = [torch.mm(torch.mm(deviceprop.grd[i],gammaR),deviceprop.grd[i].conj().T) for i in range(len(deviceprop.grd))] From 406b6f7bb2bf3ec8c24c35bc2c97c1cdf66f874d Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 16:07:42 +0800 Subject: [PATCH 03/13] add runner_device in device_property.py --- dpnegf/negf/device_property.py | 38 ++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/dpnegf/negf/device_property.py b/dpnegf/negf/device_property.py index d4179c4..e22c986 100644 --- a/dpnegf/negf/device_property.py +++ b/dpnegf/negf/device_property.py @@ -2,6 +2,7 @@ import logging import torch import os +from typing import Union from dpnegf.negf.negf_utils import update_kmap, update_temp_file,gauss_xw, leggauss from dpnegf.negf.density import Ozaki from dpnegf.utils.constants import Boltzmann, eV2J,pi @@ -24,7 +25,7 @@ def _build_s_in_batched(hd, seinL, seinR, idx0, idy0, idx1, idy1): here are the already-scaled 1j*(seL - seL.mH) * f tensors of shape [B,n,n]). ''' B = seinL.shape[0] - s_in = [torch.zeros((B,) + tuple(blk.shape), dtype=torch.complex128) for blk in hd] + s_in = [torch.zeros((B,) + tuple(blk.shape), dtype=torch.complex128, device=blk.device) for blk in hd] s_in[0][:, :idx0, :idy0] = s_in[0][:, :idx0, :idy0] + seinL[:, :idx0, :idy0] s_in[-1][:, -idx1:, -idy1:] = s_in[-1][:, -idx1:, -idy1:] + seinR[:, -idx1:, -idy1:] return s_in @@ -90,14 +91,17 @@ class DeviceProperty(object): calculate density matrix ''' - def __init__(self, hamiltonian, structure, results_path, e_T=300, - efermi: dict=None, chemiPot: dict=None, E_ref: float=None ) -> None: + def __init__(self, hamiltonian, structure, results_path, e_T=300, + efermi: dict=None, chemiPot: dict=None, E_ref: float=None, + runner_device: Union[str, torch.device]="cpu") -> None: self.greenfuncs = 0 self.hamiltonian = hamiltonian self.structure = structure # ase Atoms self.results_path = results_path self.cdtype = torch.complex128 - self.device = "cpu" + if isinstance(runner_device, str): + runner_device = torch.device(runner_device) + self.device = runner_device self.kBT = Boltzmann * e_T / eV2J self.e_T = e_T # self.efermi = efermi @@ -164,7 +168,7 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr A boolean parameter that indicates whether the last column blocks of the retarded Green's function are needed. ''' assert len(np.array(kpoint).reshape(-1)) == 3 - energy = torch.as_tensor(energy, dtype=torch.complex128) + energy = torch.as_tensor(energy, dtype=torch.complex128, device=self.device) if energy.ndim == 0: energy = energy.reshape(1) assert energy.ndim == 1, f"energy must be 0-d, scalar, or 1-D [B]; got shape {tuple(energy.shape)}" @@ -197,8 +201,9 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr self.V = torch.tensor(0.) else: self.V = Vbias - + assert torch.is_tensor(self.V) + self.V = self.V.to(self.device) if not self.oldV is None: if torch.abs(self.V - self.oldV).sum() > 1e-5: self.newV_flag = True @@ -207,8 +212,15 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr else: self.newV_flag = True # for the first time to run cal_green_function in Poisson-NEGF SCF - if (not (hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): + if (not (hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): self.hd, self.sd, self.hl, self.su, self.sl, self.hu = self.hamiltonian.get_hs_device(self.kpoint, self.V, block_tridiagonal) + # defensive .to(self.device) in case the blocks came back from a cached/legacy path on CPU. + self.hd = [b.to(self.device) for b in self.hd] + self.sd = [b.to(self.device) for b in self.sd] + self.hl = [b.to(self.device) for b in self.hl] + self.su = [b.to(self.device) for b in self.su] + self.sl = [b.to(self.device) for b in self.sl] + self.hu = [b.to(self.device) for b in self.hu] tags = ["g_trans","gr_lc", \ @@ -216,8 +228,8 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr "gnd", "gnl", "gnu", "gin_left", \ "gpd", "gpl", "gpu", "gip_left"] - seL = self.lead_L.se - seR = self.lead_R.se + seL = self.lead_L.se.to(self.device) + seR = self.lead_R.se.to(self.device) if batched_mode: assert seL.ndim == 3 and seR.ndim == 3, f"In batched mode, the self-energy should have shape [B,n,n], but got {seL.shape} and {seR.shape}" else: @@ -254,7 +266,7 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr else: seinL = 1j*(seL-seL.conj().T) * self.lead_L.fermi_dirac(energy+self.E_ref).reshape(-1) seinR = 1j*(seR-seR.conj().T) * self.lead_R.fermi_dirac(energy+self.E_ref).reshape(-1) - s_in = [torch.zeros(i.shape).cdouble() for i in self.hd] + s_in = [torch.zeros(i.shape, dtype=torch.complex128, device=self.device) for i in self.hd] s_in[0][:idx0,:idy0] = s_in[0][:idx0,:idy0] + seinL[:idx0,:idy0] s_in[-1][-idx1:,-idy1:] = s_in[-1][-idx1:,-idy1:] + seinR[-idx1:,-idy1:] else: @@ -363,8 +375,8 @@ def _cal_tc_(self): g_trans = self.g_trans batched = g_trans.ndim == 3 tx, ty = g_trans.shape[-2], g_trans.shape[-1] - gammaL_full = self.lead_L.gamma - gammaR_full = self.lead_R.gamma + gammaL_full = self.lead_L.gamma.to(self.device) + gammaR_full = self.lead_R.gamma.to(self.device) lx = gammaL_full.shape[-2] rx = gammaR_full.shape[-2] x0 = min(lx, tx) @@ -460,7 +472,7 @@ def _cal_local_current_(self): # check the energy grid satisfied the requirement na = len(self.norbs_per_atom) - local_current = torch.zeros(na, na) + local_current = torch.zeros(na, na, device=self.device) hd = self.hamiltonian.get_hs_device(kpoint=self.kpoint, V=self.V, block_tridiagonal=self.block_tridiagonal)[0][0] for i in range(na): From ebc24ba3afc703dd503459529a36af7273760443 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 16:08:11 +0800 Subject: [PATCH 04/13] add runner_device in negf_hamilotnian initialization --- dpnegf/negf/negf_hamiltonian_init.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/dpnegf/negf/negf_hamiltonian_init.py b/dpnegf/negf/negf_hamiltonian_init.py index f8fa663..3dc948d 100644 --- a/dpnegf/negf/negf_hamiltonian_init.py +++ b/dpnegf/negf/negf_hamiltonian_init.py @@ -846,6 +846,15 @@ def get_hs_device(self, kpoint=[0,0,0], V=None, block_tridiagonal=False, only_su HS_device["hl"][ik], HS_device["su"][ik], \ HS_device["sl"][ik], HS_device["hu"][ik] + # move blocks onto torch_device so downstream RGF runs on the chosen device. + hd_k = [b.to(self.torch_device) for b in hd_k] + sd_k = [b.to(self.torch_device) for b in sd_k] + hl_k = [b.to(self.torch_device) for b in hl_k] + su_k = [b.to(self.torch_device) for b in su_k] + sl_k = [b.to(self.torch_device) for b in sl_k] + hu_k = [b.to(self.torch_device) for b in hu_k] + V = torch.as_tensor(V).to(self.torch_device) + if V.shape == torch.Size([]): allorb = sum([hd_k[i].shape[0] for i in range(len(hd_k))]) V = V.repeat(allorb) @@ -855,15 +864,18 @@ def get_hs_device(self, kpoint=[0,0,0], V=None, block_tridiagonal=False, only_su l_slice = slice(counted, counted+hd_k[i].shape[0]) V_sub = V[l_slice].view(-1,1).cdouble() hd_k[i] = hd_k[i] - V_sub * sd_k[i] - if i 0: hl_k[i-1] = hl_k[i-1] - V_sub * sl_k[i-1] counted += hd_k[i].shape[0] - + return hd_k , sd_k, hl_k , su_k, sl_k, hu_k else: HD_k, SD_k = HS_device["HD"][ik], HS_device["SD"][ik] + HD_k = HD_k.to(self.torch_device) + SD_k = SD_k.to(self.torch_device) + V = torch.as_tensor(V).to(self.torch_device) return HD_k - V*SD_k, SD_k, [], [], [], [] def get_hs_lead(self, kpoint, tab, v): From 9e6c0bbaf4dd9b7e014b981b9f9874b80be720e8 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 18:20:43 +0800 Subject: [PATCH 05/13] add runner_device in run.py entrypoints --- dpnegf/entrypoints/run.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/dpnegf/entrypoints/run.py b/dpnegf/entrypoints/run.py index 97ee269..d2a5afa 100644 --- a/dpnegf/entrypoints/run.py +++ b/dpnegf/entrypoints/run.py @@ -63,7 +63,12 @@ def run( in_common_options = {} if jdata.get("device", None): in_common_options.update({"device": jdata["device"]}) - + elif task_options.get("runner_device", None): + # Build the model on runner_device so that plain-tensor attributes + # inside DeePTB modules (e.g. r_max / r_max_dict in trinity.py) are + # placed on the correct device — nn.Module.to() does not move them. + in_common_options.update({"device": task_options["runner_device"]}) + if jdata.get("dtype", None): in_common_options.update({"dtype": jdata["dtype"]}) From 5a05ad3371826cc59148278050556d88b0b84131 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sat, 13 Jun 2026 18:21:00 +0800 Subject: [PATCH 06/13] transfer to cpu before hamiltonian saved --- dpnegf/negf/negf_hamiltonian_init.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/dpnegf/negf/negf_hamiltonian_init.py b/dpnegf/negf/negf_hamiltonian_init.py index 3dc948d..2550466 100644 --- a/dpnegf/negf/negf_hamiltonian_init.py +++ b/dpnegf/negf/negf_hamiltonian_init.py @@ -70,8 +70,9 @@ def __init__(self, if isinstance(torch_device, str): torch_device = torch.device(torch_device) - self.torch_device = torch_device + self.torch_device = torch_device self.model = model + self.model.to(self.torch_device) self.AtomicData_options = AtomicData_options self.model.eval() @@ -417,8 +418,8 @@ def Hamiltonian_initialized(self,kpoints:List[List[float]],useBloch:bool,bloch_f f.create_dataset(f"{key}", data=np.array("None", dtype=h5py.string_dtype())) elif key in ["HL", "SL", "HDL", "SDL", "HLL", "SLL"]: # TODO: HDL,SDL can be saved in reduced form by eliminating zero rows - f.create_dataset(f"{key}_real", data=items.real.numpy().astype(numpy_dtype)) - f.create_dataset(f"{key}_imag", data=items.imag.numpy().astype(numpy_dtype)) + f.create_dataset(f"{key}_real", data=items.real.cpu().numpy().astype(numpy_dtype)) + f.create_dataset(f"{key}_imag", data=items.imag.cpu().numpy().astype(numpy_dtype)) else: raise ValueError(f"Unsupported key {key} in HS_leads") @@ -462,11 +463,11 @@ def Hamiltonian_initialized(self,kpoints:List[List[float]],useBloch:bool,bloch_f sub_block_len = len(item) for idx_block in range(sub_block_len): # group.create_dataset(f"{key}_k{idx_k}_b{idx_block}", data=item[idx_block].numpy()) - group.create_dataset(f"{key}_k{idx_k}_b{idx_block}_real", data=item[idx_block].real.numpy()) - group.create_dataset(f"{key}_k{idx_k}_b{idx_block}_imag", data=item[idx_block].imag.numpy()) + group.create_dataset(f"{key}_k{idx_k}_b{idx_block}_real", data=item[idx_block].real.cpu().numpy()) + group.create_dataset(f"{key}_k{idx_k}_b{idx_block}_imag", data=item[idx_block].imag.cpu().numpy()) else: assert key in ["HD", "SD", "Hall", "Sall"], f"Unsupported key {key} for not block_tridiagnal case" - f.create_dataset(f"{key}", data=items.numpy()) + f.create_dataset(f"{key}", data=items.cpu().numpy()) else: raise ValueError(f"Unsupported key {key} in HS_device") From e613bce08c3057ca5f98164d83831a9df78fa76e Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 14:38:50 +0800 Subject: [PATCH 07/13] add rgf_device; all steps except RGF is on CPU now. --- dpnegf/entrypoints/run.py | 8 +++----- dpnegf/negf/device_property.py | 8 ++++---- dpnegf/runner/NEGF.py | 16 ++++++++-------- dpnegf/utils/argcheck.py | 9 +++++---- 4 files changed, 20 insertions(+), 21 deletions(-) diff --git a/dpnegf/entrypoints/run.py b/dpnegf/entrypoints/run.py index d2a5afa..1ae8ad8 100644 --- a/dpnegf/entrypoints/run.py +++ b/dpnegf/entrypoints/run.py @@ -63,11 +63,9 @@ def run( in_common_options = {} if jdata.get("device", None): in_common_options.update({"device": jdata["device"]}) - elif task_options.get("runner_device", None): - # Build the model on runner_device so that plain-tensor attributes - # inside DeePTB modules (e.g. r_max / r_max_dict in trinity.py) are - # placed on the correct device — nn.Module.to() does not move them. - in_common_options.update({"device": task_options["runner_device"]}) + # Otherwise build on the default device (CPU). The NEGF pipeline runs + # hamiltonian init and Fermi-level calc on CPU; only RGF runs on + # RGF_device, and DeviceProperty handles CPU→RGF_device transfer. if jdata.get("dtype", None): in_common_options.update({"dtype": jdata["dtype"]}) diff --git a/dpnegf/negf/device_property.py b/dpnegf/negf/device_property.py index e22c986..d3b9764 100644 --- a/dpnegf/negf/device_property.py +++ b/dpnegf/negf/device_property.py @@ -93,15 +93,15 @@ class DeviceProperty(object): ''' def __init__(self, hamiltonian, structure, results_path, e_T=300, efermi: dict=None, chemiPot: dict=None, E_ref: float=None, - runner_device: Union[str, torch.device]="cpu") -> None: + rgf_device: Union[str, torch.device]="cpu") -> None: self.greenfuncs = 0 self.hamiltonian = hamiltonian self.structure = structure # ase Atoms self.results_path = results_path self.cdtype = torch.complex128 - if isinstance(runner_device, str): - runner_device = torch.device(runner_device) - self.device = runner_device + if isinstance(rgf_device, str): + rgf_device = torch.device(rgf_device) + self.device = rgf_device self.kBT = Boltzmann * e_T / eV2J self.e_T = e_T # self.efermi = efermi diff --git a/dpnegf/runner/NEGF.py b/dpnegf/runner/NEGF.py index e9eb918..f3f0daa 100644 --- a/dpnegf/runner/NEGF.py +++ b/dpnegf/runner/NEGF.py @@ -54,7 +54,7 @@ def __init__(self, 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, plot_blocks: Optional[bool]=False, - runner_device: Union[str, torch.device]='cpu', + rgf_device: Union[str, torch.device]='cpu', AtomicData_options: Optional[dict]=None, n_cpus: Optional[int]=None, e_batch_size: Optional[int]=None, @@ -64,9 +64,9 @@ def __init__(self, # self.model = model # No need to set model as property for memory saving self.results_path = results_path self.cdtype = torch.complex128 - if isinstance(runner_device, str): - runner_device = torch.device(runner_device) - self.runner_device = runner_device + if isinstance(rgf_device, str): + rgf_device = torch.device(rgf_device) + self.rgf_device = rgf_device self.n_cpus = n_cpus self.e_batch_size = e_batch_size @@ -156,7 +156,7 @@ def __init__(self, stru_options=self.stru_options, unit = self.unit, results_path=self.results_path, - torch_device = self.runner_device) + torch_device = torch.device("cpu")) # if useBloch is None, structure_leads_fold,bloch_sorted_indices,bloch_R_lists = None,None,None struct_device, struct_leads,structure_leads_fold,bloch_sorted_indices,bloch_R_lists = \ self.negf_hamiltonian.initialize(kpoints=self.kpoints, @@ -184,7 +184,7 @@ def __init__(self, e_fermi = {}; chemiPot = {} # calculate Fermi level if self.e_fermi is None: - elec_cal = ElecStruCal(model=model,device=self.runner_device) + elec_cal = ElecStruCal(model=model,device=torch.device("cpu")) nel_atom_lead = self.get_nel_atom_lead( struct_leads, charge={lead_tag: self.stru_options[lead_tag].get("charge", 0) for lead_tag in ["lead_L", "lead_R"]} @@ -237,7 +237,7 @@ def __init__(self, # initialize deviceprop and leadprop self.deviceprop = DeviceProperty(self.negf_hamiltonian, struct_device, results_path=self.results_path, efermi=self.e_fermi, chemiPot=chemiPot, E_ref=E_ref, - runner_device=self.runner_device) + rgf_device=self.rgf_device) self.deviceprop.set_leadLR( lead_L=LeadProperty( hamiltonian=self.negf_hamiltonian, @@ -597,7 +597,7 @@ def negf_compute(self,scf_require=False,Vbias=None): self.out['k'].append(k) self.out['wk'].append(self.wk[ik]) - self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs),dtype=torch.complex128, device=self.runner_device)}) + self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs),dtype=torch.complex128, device=self.rgf_device)}) log.info(f"Properties computation at k = ({', '.join([f'{kk:>6.4f}' for kk in k])})") if scf_require: diff --git a/dpnegf/utils/argcheck.py b/dpnegf/utils/argcheck.py index b1f4369..8526e8f 100644 --- a/dpnegf/utils/argcheck.py +++ b/dpnegf/utils/argcheck.py @@ -1069,10 +1069,11 @@ def negf(): Argument("out_ldos", bool, optional=True, default=False, doc=doc_out_ldos), Argument("out_lcurrent", bool, optional=True, default=False, doc=doc_out_lcurrent), Argument("n_cpus", [int, None], optional=True, default=None, doc="Number of CPU cores for parallel self-energy calculation. Default None uses os.cpu_count()."), - Argument("runner_device", str, optional=True, default="cpu", - doc="Device used for NEGF Hamiltonian init and recursive Green's function (RGF). " - "'cpu' (default) or 'cuda'. Self-energy calculation always runs on CPU " - "because it goes through joblib+numba.") + Argument("rgf_device", str, optional=True, default="cpu", + doc="Device used only for the RGF (recursive Green's function) step. " + "'cpu' (default) or 'cuda'. Hamiltonian initialization always runs " + "on CPU (it is the memory-heavy phase). Self-energy always runs on " + "CPU because it goes through joblib + numba.") ] def stru_options(): From 70579ffa099872f50cb872f16fbecb888e044363 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 14:44:18 +0800 Subject: [PATCH 08/13] update examples --- examples/CNT/input.json | 1 + examples/CNT/run.ipynb | 32 +++++++++++++++++--------------- 2 files changed, 18 insertions(+), 15 deletions(-) diff --git a/examples/CNT/input.json b/examples/CNT/input.json index 4b37c92..06f0a41 100644 --- a/examples/CNT/input.json +++ b/examples/CNT/input.json @@ -3,6 +3,7 @@ "task": "negf", "scf": false, "block_tridiagonal": true, + "rgf_device": "cpu", "ele_T": 300, "unit": "eV", "scf_options":{ diff --git a/examples/CNT/run.ipynb b/examples/CNT/run.ipynb index 3e827bd..6f157c5 100644 --- a/examples/CNT/run.ipynb +++ b/examples/CNT/run.ipynb @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "id": "0f64a6b8", "metadata": {}, "outputs": [ @@ -40,11 +40,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "rm: cannot remove 'output': Directory not empty\n", "DPNEGF INFO ================================================================================\n", "DPNEGF INFO Version Info \n", "DPNEGF INFO --------------------------------------------------------------------------------\n", - "DPNEGF INFO DPNEGF : 0.0.1.dev293+d4ffc8e\n", + "DPNEGF INFO DPNEGF : 0.0.1.dev308+e613bce\n", "DPNEGF INFO DeePTB : 2.2.1.dev62+g155e85e76.d20260602\n", "DPNEGF INFO ================================================================================\n", "\n", @@ -75,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "id": "830d67a4", "metadata": {}, "outputs": [ @@ -98,8 +97,11 @@ "DPNEGF INFO The structure is sorted lexicographically in this version!\n", "DPNEGF INFO Lead principal layers translational equivalence error (on average): 1.732035e-10 (threshold: 1.000000e-05)\n", "DPNEGF INFO Lead principal layers translational equivalence error (on average): 1.732051e-10 (threshold: 1.000000e-05)\n", + "/opt/mamba/envs/dpnegf-dev/lib/python3.10/site-packages/torch/nested/__init__.py:107: UserWarning: The PyTorch API of nested tensors is in prototype stage and will change in the near future. (Triggered internally at ../aten/src/ATen/NestedTensorImpl.cpp:178.)\n", + " return torch._nested_tensor_from_tensor_list(ts, dtype, None, device, None)\n", "DPNEGF INFO The coupling width of lead_L is 112.\n", "DPNEGF INFO The coupling width of lead_R is 112.\n", + "DPNEGF WARNING WARNING, the lead's hamiltonian attained from diffferent methods have slight differences RMSE = 0.0000013.\n", "DPNEGF INFO The Hamiltonian is block tridiagonalized into 18 subblocks.\n", "DPNEGF INFO the number of elements in subblocks: 687922\n", "DPNEGF INFO occupation of subblocks: 16.023585292407684 %\n", @@ -117,21 +119,21 @@ "DPNEGF INFO Calculating Fermi energy in the case of spin-degeneracy.\n", "DPNEGF INFO Fermi energy converged after 4 iterations.\n", "DPNEGF INFO q_cal: 224.00000000003706, total_electrons: 224.0, diff q: 3.7061909097246826e-11\n", - "DPNEGF INFO Estimated E_fermi: -4.510708691306822 based on the valence electrons setting nel_atom : {'C': 4.0} .\n", + "DPNEGF INFO Estimated E_fermi: -4.51070130033087 based on the valence electrons setting nel_atom : {'C': 4.0} .\n", "DPNEGF INFO -----Calculating Fermi level for lead_R-----\n", "DPNEGF INFO KPOINTS kmesh sampling: 6 kpoints\n", "DPNEGF INFO Getting eigenvalues from the model.\n", "DPNEGF INFO Calculating Fermi energy in the case of spin-degeneracy.\n", "DPNEGF INFO Fermi energy converged after 4 iterations.\n", - "DPNEGF INFO q_cal: 224.000000000037, total_electrons: 224.0, diff q: 3.700506567838602e-11\n", - "DPNEGF INFO Estimated E_fermi: -4.510722161956541 based on the valence electrons setting nel_atom : {'C': 4.0} .\n", + "DPNEGF INFO q_cal: 224.00000000003695, total_electrons: 224.0, diff q: 3.694822225952521e-11\n", + "DPNEGF INFO Estimated E_fermi: -4.510758401580564 based on the valence electrons setting nel_atom : {'C': 4.0} .\n", "DPNEGF INFO -------------------------------------------------\n", "DPNEGF INFO Zero bias case detected.\n", - "DPNEGF INFO Fermi level for lead_L: -4.510708691306822\n", - "DPNEGF INFO Fermi level for lead_R: -4.510722161956541\n", - "DPNEGF INFO Electrochemical potential for lead_L: -4.510708691306822\n", - "DPNEGF INFO Electrochemical potential for lead_R: -4.510722161956541\n", - "DPNEGF INFO Reference energy E_ref: -4.510708691306822\n", + "DPNEGF INFO Fermi level for lead_L: -4.51070130033087\n", + "DPNEGF INFO Fermi level for lead_R: -4.510758401580564\n", + "DPNEGF INFO Electrochemical potential for lead_L: -4.51070130033087\n", + "DPNEGF INFO Electrochemical potential for lead_R: -4.510758401580564\n", + "DPNEGF INFO Reference energy E_ref: -4.51070130033087\n", "DPNEGF INFO =================================================\n", "\n", "DPNEGF INFO ------Self-energy calculation------\n", @@ -177,7 +179,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_170135/1724458665.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + "/tmp/ipykernel_64847/1724458665.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " negf_out = torch.load('./output/negf.out.pth')\n" ] } @@ -215,7 +217,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -241,7 +243,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 670009dc5914b7fc64ce55f3ed290eaf159bf78e Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 15:59:36 +0800 Subject: [PATCH 09/13] move necessary green's function in cuda --- dpnegf/negf/device_property.py | 10 +++++++++- dpnegf/runner/NEGF.py | 2 +- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/dpnegf/negf/device_property.py b/dpnegf/negf/device_property.py index d3b9764..755f05f 100644 --- a/dpnegf/negf/device_property.py +++ b/dpnegf/negf/device_property.py @@ -406,9 +406,16 @@ def _cal_dos_(self): ''' dos = 0 #TODO: transfer cal_dos to static method for any k and energy - if (not(hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): + if (not(hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): self.hd, self.sd, self.hl, self.su, self.sl, self.hu = \ self.hamiltonian.get_hs_device(self.kpoint, self.V, self.block_tridiagonal) + # defensive .to(self.device) in case the blocks came back from a cached/legacy path on CPU. + self.hd = [b.to(self.device) for b in self.hd] + self.sd = [b.to(self.device) for b in self.sd] + self.hl = [b.to(self.device) for b in self.hl] + self.su = [b.to(self.device) for b in self.su] + self.sl = [b.to(self.device) for b in self.sl] + self.hu = [b.to(self.device) for b in self.hu] for jj in range(len(self.grd)): if not self.block_tridiagonal or len(self.gru) == 0: @@ -474,6 +481,7 @@ def _cal_local_current_(self): na = len(self.norbs_per_atom) local_current = torch.zeros(na, na, device=self.device) hd = self.hamiltonian.get_hs_device(kpoint=self.kpoint, V=self.V, block_tridiagonal=self.block_tridiagonal)[0][0] + hd = hd.to(self.device) # defensive .to(self.device) in case the block came back from a cached/legacy path on CPU. for i in range(na): for j in range(na): diff --git a/dpnegf/runner/NEGF.py b/dpnegf/runner/NEGF.py index f3f0daa..768f01e 100644 --- a/dpnegf/runner/NEGF.py +++ b/dpnegf/runner/NEGF.py @@ -841,7 +841,7 @@ def negf_compute(self,scf_require=False,Vbias=None): if scf_require==False: self.out["k"] = np.array(self.out["k"]) - self.out['T_avg'] = torch.tensor(self.out['wk']) @ torch.stack(list(self.out["T_k"].values())) + self.out['T_avg'] = torch.tensor(self.out['wk']) @ torch.stack(list(self.out["T_k"].values())).cpu() # TODO:check the following code for multiple k points calculation if self.out_current_nscf: self.out["BIAS_POTENTIAL_NSCF"], self.out["CURRENT_NSCF"] = self.compute_current_nscf(self.uni_grid, self.out["T_avg"]) From 5be176903f7fa905516a01324e3502505ec90041 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 16:00:31 +0800 Subject: [PATCH 10/13] rename DeviceProperty.device as rgf_device --- dpnegf/negf/device_property.py | 50 ++++++++++---------- dpnegf/tests/test_device_property_batched.py | 2 +- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/dpnegf/negf/device_property.py b/dpnegf/negf/device_property.py index 755f05f..9c1f154 100644 --- a/dpnegf/negf/device_property.py +++ b/dpnegf/negf/device_property.py @@ -101,7 +101,7 @@ def __init__(self, hamiltonian, structure, results_path, e_T=300, self.cdtype = torch.complex128 if isinstance(rgf_device, str): rgf_device = torch.device(rgf_device) - self.device = rgf_device + self.rgf_device = rgf_device self.kBT = Boltzmann * e_T / eV2J self.e_T = e_T # self.efermi = efermi @@ -168,7 +168,7 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr A boolean parameter that indicates whether the last column blocks of the retarded Green's function are needed. ''' assert len(np.array(kpoint).reshape(-1)) == 3 - energy = torch.as_tensor(energy, dtype=torch.complex128, device=self.device) + energy = torch.as_tensor(energy, dtype=torch.complex128, device=self.rgf_device) if energy.ndim == 0: energy = energy.reshape(1) assert energy.ndim == 1, f"energy must be 0-d, scalar, or 1-D [B]; got shape {tuple(energy.shape)}" @@ -203,7 +203,7 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr self.V = Vbias assert torch.is_tensor(self.V) - self.V = self.V.to(self.device) + self.V = self.V.to(self.rgf_device) if not self.oldV is None: if torch.abs(self.V - self.oldV).sum() > 1e-5: self.newV_flag = True @@ -215,12 +215,12 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr if (not (hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): self.hd, self.sd, self.hl, self.su, self.sl, self.hu = self.hamiltonian.get_hs_device(self.kpoint, self.V, block_tridiagonal) # defensive .to(self.device) in case the blocks came back from a cached/legacy path on CPU. - self.hd = [b.to(self.device) for b in self.hd] - self.sd = [b.to(self.device) for b in self.sd] - self.hl = [b.to(self.device) for b in self.hl] - self.su = [b.to(self.device) for b in self.su] - self.sl = [b.to(self.device) for b in self.sl] - self.hu = [b.to(self.device) for b in self.hu] + self.hd = [b.to(self.rgf_device) for b in self.hd] + self.sd = [b.to(self.rgf_device) for b in self.sd] + self.hl = [b.to(self.rgf_device) for b in self.hl] + self.su = [b.to(self.rgf_device) for b in self.su] + self.sl = [b.to(self.rgf_device) for b in self.sl] + self.hu = [b.to(self.rgf_device) for b in self.hu] tags = ["g_trans","gr_lc", \ @@ -228,8 +228,8 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr "gnd", "gnl", "gnu", "gin_left", \ "gpd", "gpl", "gpu", "gip_left"] - seL = self.lead_L.se.to(self.device) - seR = self.lead_R.se.to(self.device) + seL = self.lead_L.se.to(self.rgf_device) + seR = self.lead_R.se.to(self.rgf_device) if batched_mode: assert seL.ndim == 3 and seR.ndim == 3, f"In batched mode, the self-energy should have shape [B,n,n], but got {seL.shape} and {seR.shape}" else: @@ -266,7 +266,7 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr else: seinL = 1j*(seL-seL.conj().T) * self.lead_L.fermi_dirac(energy+self.E_ref).reshape(-1) seinR = 1j*(seR-seR.conj().T) * self.lead_R.fermi_dirac(energy+self.E_ref).reshape(-1) - s_in = [torch.zeros(i.shape, dtype=torch.complex128, device=self.device) for i in self.hd] + s_in = [torch.zeros(i.shape, dtype=torch.complex128, device=self.rgf_device) for i in self.hd] s_in[0][:idx0,:idy0] = s_in[0][:idx0,:idy0] + seinL[:idx0,:idy0] s_in[-1][-idx1:,-idy1:] = s_in[-1][-idx1:,-idy1:] + seinR[-idx1:,-idy1:] else: @@ -375,8 +375,8 @@ def _cal_tc_(self): g_trans = self.g_trans batched = g_trans.ndim == 3 tx, ty = g_trans.shape[-2], g_trans.shape[-1] - gammaL_full = self.lead_L.gamma.to(self.device) - gammaR_full = self.lead_R.gamma.to(self.device) + gammaL_full = self.lead_L.gamma.to(self.rgf_device) + gammaR_full = self.lead_R.gamma.to(self.rgf_device) lx = gammaL_full.shape[-2] rx = gammaR_full.shape[-2] x0 = min(lx, tx) @@ -384,8 +384,8 @@ def _cal_tc_(self): gL_shape = (g_trans.shape[0], tx, tx) if batched else (tx, tx) gR_shape = (g_trans.shape[0], ty, ty) if batched else (ty, ty) - gammaL = torch.zeros(size=gL_shape, dtype=self.cdtype, device=self.device) - gammaR = torch.zeros(size=gR_shape, dtype=self.cdtype, device=self.device) + gammaL = torch.zeros(size=gL_shape, dtype=self.cdtype, device=self.rgf_device) + gammaR = torch.zeros(size=gR_shape, dtype=self.cdtype, device=self.rgf_device) if batched: gammaL[:, :x0, :x0] = gammaL[:, :x0, :x0] + gammaL_full[:, :x0, :x0] gammaR[:, -x1:, -x1:] = gammaR[:, -x1:, -x1:] + gammaR_full[:, -x1:, -x1:] @@ -410,12 +410,12 @@ def _cal_dos_(self): self.hd, self.sd, self.hl, self.su, self.sl, self.hu = \ self.hamiltonian.get_hs_device(self.kpoint, self.V, self.block_tridiagonal) # defensive .to(self.device) in case the blocks came back from a cached/legacy path on CPU. - self.hd = [b.to(self.device) for b in self.hd] - self.sd = [b.to(self.device) for b in self.sd] - self.hl = [b.to(self.device) for b in self.hl] - self.su = [b.to(self.device) for b in self.su] - self.sl = [b.to(self.device) for b in self.sl] - self.hu = [b.to(self.device) for b in self.hu] + self.hd = [b.to(self.rgf_device) for b in self.hd] + self.sd = [b.to(self.rgf_device) for b in self.sd] + self.hl = [b.to(self.rgf_device) for b in self.hl] + self.su = [b.to(self.rgf_device) for b in self.su] + self.sl = [b.to(self.rgf_device) for b in self.sl] + self.hu = [b.to(self.rgf_device) for b in self.hu] for jj in range(len(self.grd)): if not self.block_tridiagonal or len(self.gru) == 0: @@ -479,9 +479,9 @@ def _cal_local_current_(self): # check the energy grid satisfied the requirement na = len(self.norbs_per_atom) - local_current = torch.zeros(na, na, device=self.device) + local_current = torch.zeros(na, na, device=self.rgf_device) hd = self.hamiltonian.get_hs_device(kpoint=self.kpoint, V=self.V, block_tridiagonal=self.block_tridiagonal)[0][0] - hd = hd.to(self.device) # defensive .to(self.device) in case the block came back from a cached/legacy path on CPU. + hd = hd.to(self.rgf_device) # defensive .to(self.device) in case the block came back from a cached/legacy path on CPU. for i in range(na): for j in range(na): @@ -510,7 +510,7 @@ def _cal_density_(self, dm_options): ''' dm = Ozaki(**dm_options) - DM_eq, DM_neq = dm.integrate(deviceprop=self.device, kpoint=self.kpoint) + DM_eq, DM_neq = dm.integrate(deviceprop=self.rgf_device, kpoint=self.kpoint) return DM_eq, DM_neq diff --git a/dpnegf/tests/test_device_property_batched.py b/dpnegf/tests/test_device_property_batched.py index f241358..b4b3b9b 100644 --- a/dpnegf/tests/test_device_property_batched.py +++ b/dpnegf/tests/test_device_property_batched.py @@ -58,7 +58,7 @@ def _make_deviceprop(block_sizes, hd, sd, hl, hu, sl, su): dev.structure = None dev.results_path = "/tmp" dev.cdtype = torch.complex128 - dev.device = "cpu" + dev.rgf_device = "cpu" dev.kBT = 0.025 dev.e_T = 300.0 dev.chemiPot = None From 1cffa9b164233d929e7c9e96720b89f379b17664 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 16:22:52 +0800 Subject: [PATCH 11/13] update docstring and temp var --- dpnegf/negf/lead_property.py | 2 +- dpnegf/runner/NEGF.py | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/dpnegf/negf/lead_property.py b/dpnegf/negf/lead_property.py index 9390bda..7658f04 100644 --- a/dpnegf/negf/lead_property.py +++ b/dpnegf/negf/lead_property.py @@ -246,7 +246,7 @@ def _load_self_energy(save_path: str, kpoint, energy, save_format: str): elif save_format == "h5": try: data = read_from_hdf5(save_path, kpoint, energy) - se = torch.as_tensor(data, dtype=torch.complex128) # 自能一般是复数 + se = torch.as_tensor(data, dtype=torch.complex128) # self-energy should be complex except KeyError as e: kx, ky, kz = np.asarray(kpoint, dtype=float).reshape(3) ev = energy.item() if hasattr(energy, "item") else float(energy) diff --git a/dpnegf/runner/NEGF.py b/dpnegf/runner/NEGF.py index 768f01e..cad05cc 100644 --- a/dpnegf/runner/NEGF.py +++ b/dpnegf/runner/NEGF.py @@ -591,13 +591,15 @@ 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 Calculaiton or Loading self.prepare_self_energy(scf_require) for ik, k in enumerate(self.kpoints): self.out['k'].append(k) self.out['wk'].append(self.wk[ik]) - self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs),dtype=torch.complex128, device=self.rgf_device)}) + self.free_charge.update({str(k):torch.zeros_like(torch.tensor(self.device_atom_norbs), + dtype=torch.complex128, device=self.rgf_device)}) log.info(f"Properties computation at k = ({', '.join([f'{kk:>6.4f}' for kk in k])})") if scf_require: @@ -704,9 +706,9 @@ def negf_compute(self,scf_require=False,Vbias=None): # Non-SCF: solve a whole chunk of energies in one batched recursive_gf call. chunk = self.e_batch_size if self.e_batch_size is not None else len(self.uni_grid) for e_chunk in torch.split(self.uni_grid, chunk): - b = len(e_chunk) + e_batch_size = len(e_chunk) log.info( - f"computing green's functions for chunk e=[{float(e_chunk[0]):>6.3f}..{float(e_chunk[-1]):>6.3f}], B={b}" + f"computing green's functions for chunk e=[{float(e_chunk[0]):>6.3f}..{float(e_chunk[-1]):>6.3f}], B={e_batch_size}" ) seL_list, seR_list = [], [] for e in e_chunk: @@ -723,7 +725,7 @@ def negf_compute(self,scf_require=False,Vbias=None): seL_list.append(self.deviceprop.lead_L.se) seR_list.append(self.deviceprop.lead_R.se) - if b > 1: + if e_batch_size > 1: self.deviceprop.lead_L.se = torch.stack(seL_list, dim=0) self.deviceprop.lead_R.se = torch.stack(seR_list, dim=0) # else: leave the per-E [n,n] in place — preserves scalar contract exactly. From d538abf826564fdf84add769875a982909172ec4 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 16:23:06 +0800 Subject: [PATCH 12/13] add TODO for OOM in RGF --- dpnegf/negf/device_property.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dpnegf/negf/device_property.py b/dpnegf/negf/device_property.py index 9c1f154..b82a165 100644 --- a/dpnegf/negf/device_property.py +++ b/dpnegf/negf/device_property.py @@ -214,7 +214,8 @@ def cal_green_function(self, energy, kpoint, eta_device=0., block_tridiagonal=Tr if (not (hasattr(self, "hd") and hasattr(self, "sd"))) or (self.newK_flag or self.newV_flag): self.hd, self.sd, self.hl, self.su, self.sl, self.hu = self.hamiltonian.get_hs_device(self.kpoint, self.V, block_tridiagonal) - # defensive .to(self.device) in case the blocks came back from a cached/legacy path on CPU. + # TODO: if all blocks transferred to GPU, OOM may happen for large systems. + # Optimization should be implemented here. self.hd = [b.to(self.rgf_device) for b in self.hd] self.sd = [b.to(self.rgf_device) for b in self.sd] self.hl = [b.to(self.rgf_device) for b in self.hl] From 564da0070aa28d7bb36326f00e1b9d7b3a5ff731 Mon Sep 17 00:00:00 2001 From: AsymmetryChou <181240085@smail.nju.edu.cn> Date: Sun, 14 Jun 2026 17:14:26 +0800 Subject: [PATCH 13/13] update example: add GPU vs. CPU benchmark --- examples/CNT/bench_results.ipynb | 98 ++++++++++++++++++++ examples/CNT/gpu_acceleration_benchmark.png | Bin 0 -> 209312 bytes examples/CNT/input.json | 1 + 3 files changed, 99 insertions(+) create mode 100644 examples/CNT/bench_results.ipynb create mode 100644 examples/CNT/gpu_acceleration_benchmark.png diff --git a/examples/CNT/bench_results.ipynb b/examples/CNT/bench_results.ipynb new file mode 100644 index 0000000..471d8bb --- /dev/null +++ b/examples/CNT/bench_results.ipynb @@ -0,0 +1,98 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "id": "2fcf3dd3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# 数据准备\n", + "labels = ['RTX 4090', 'CPU (64c)', 'CPU (32c)', 'CPU (16c)']\n", + "rgf_times = [0.429, 1.628, 2.260, 3.552]\n", + "green_times = [0.351, 1.320, 1.944, 3.234]\n", + "\n", + "# 计算加速比 (以 CPU 64核为基准 1x)\n", + "base_time = rgf_times[-1]\n", + "speedups = [base_time / t for t in rgf_times]\n", + "\n", + "# 设置绘图风格\n", + "plt.style.use('seaborn-v0_8-paper')\n", + "fig, ax1 = plt.subplots(figsize=(10, 6), dpi=300)\n", + "\n", + "x = np.arange(len(labels))\n", + "width = 0.35\n", + "\n", + "# 绘制耗时柱状图\n", + "bars1 = ax1.bar(x - width/2, rgf_times, width, label='Total Green Function CalculationTime', color='#2c3e50', alpha=0.85)\n", + "bars2 = ax1.bar(x + width/2, green_times, width, label=' RGF Kernel Time', color='#2980b9', alpha=0.85)\n", + "\n", + "# 装饰器\n", + "ax1.set_ylabel('Execution Time (seconds)', fontsize=12, fontweight='bold')\n", + "ax1.set_title('Computational Efficiency: RTX 4090 vs. Multi-core CPU', fontsize=14, pad=20)\n", + "ax1.set_xticks(x)\n", + "ax1.set_xticklabels(labels, fontsize=11)\n", + "ax1.legend(loc='upper left', frameon=True)\n", + "\n", + "# 添加数值标注\n", + "def autolabel(bars):\n", + " for bar in bars:\n", + " height = bar.get_height()\n", + " ax1.annotate(f'{height:.3f}s', xy=(bar.get_x() + bar.get_width() / 2, height),\n", + " xytext=(0, 3), textcoords=\"offset points\", ha='center', va='bottom', fontsize=9)\n", + "\n", + "autolabel(bars1)\n", + "autolabel(bars2)\n", + "\n", + "# 绘制加速比折线图 (次坐标轴)\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(x, speedups, color='#e74c3c', marker='o', linewidth=2, label='Speedup (vs 64c)')\n", + "ax2.set_ylabel('Speedup Factor', color='#e74c3c', fontsize=12, fontweight='bold')\n", + "ax2.tick_params(axis='y', labelcolor='#e74c3c')\n", + "ax2.set_ylim(0, max(speedups) * 1.2)\n", + "\n", + "# 网格线\n", + "ax1.grid(axis='y', linestyle='--', alpha=0.6)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('gpu_acceleration_benchmark.png')\n", + "plt.show()" + ] + } + ], + "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.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/CNT/gpu_acceleration_benchmark.png b/examples/CNT/gpu_acceleration_benchmark.png new file mode 100644 index 0000000000000000000000000000000000000000..655e51c667cd8cf515389ec9e4d060d007c08714 GIT binary patch literal 209312 zcmeFZhhNTp|2N+0I-d^^AQ?|%I5$L~+LugBv$T~}w0@gA?&bG<(IloX^H*Rrf-U|?XBxp4Lp1H-yJ z28PxD{`(JplI;D^1%HS*oYQnru{LpVzG7$0Ab-Wd#?sos(#&w5ld+w>nY9%k&+%hC zC%N`rb8xV+7vbfl{J+1!V{K>3E0=yi6|b_!=7N?z0|UYuB(JjB?)MmKG(u^{m_K(*>%hSGm9De6OLby7H{~rjKO`=5Xp zrk6PWzdyqNyMFeD=>Pe{xAIC~H~gPJv{|<;@9+Qfhn*`{4ga4%W5_-A|MQaE|Mw;T z_d@;Owfx^}!NBl;579v*y#j|PzP{4Q-uNFf16hx+-@J8;(R=*Ur%$gGYErt2Tva3& zCjv#BhT?lG9vro3Nxm3-;`KMr_3PJX<<}LvPn-Y#`YzF+v}EjOUD5=NTGP?d@#$xW zbt&b`6wOggOf1W5(JiRB`}POh)mVC&6qC9TAN$YmZms5U)D93bAVrViEmKjT2uc&f zS69c;-gDt%u9r;f!<1cI^7bD%@Z-mi*KgmRdMz8IK%>TKq#IT|J)#o(N`Z;t`c)cU zXYPBTBEMCqP*rYyDH${3cC2ZwTI4mZn%lzP+ z88ud|yU0~7QT2#%RRFv4xa;q)H>QT#VrqhT2ivnP)~;KplBk-1w>iYbqpQh&@#*7S z=U&P81>VagOAF(QtfEeG(|TAcn$Qk&6__TO)HAVDs$MxGBA8OBqXG1+7KcC)U&I= zu_kqMOWFJPs!8hH^p4yHV_`0X65SN->`Pa#zN%?o`B==dGf#QfNvkZ2U5bi|ujND4 zmzI{+{`;>IS&6J`%7qV{d^fO~x6Z9e@m^k1T$=xqZp5iqkTu*>y4NB+%Zxhk`&(J{ zv!g*ZQ=(Viubdoeqi#ymOpng7Y}?Pv%Ns;L%I2{+**fOB*rXb1fq)l^k|dPYi0z`9$E(wTR> zzTOlcE>R;bLf?DQv3REU!J2>u?-c!FZKDql8wZ+``WC_)!bNl2v&>>n_IRk|+xIK{ zE_%FBp^>bWrZ3KIP}2EhK1DSlz-j2q=6(@0r62RF7#>tabL-^%n(py#otqqV{QdQ` zxZA|xZu-LFBGZ;F(fDpj@}Yv9S{bjp<~MBI*y=C2bgflz&z?OOpK(50@%P_Mn>M{9 zd+k8`On%Zeznq5SXYuhdo6k&vc{ z&hvZB*my24PMde+q{xm3i@9d_tlt@J-(TOB<#qP#ZIgzGl(tOMB=r>SIa*w#>YK}_ zgMJ>Asr28gk)~gqWz{7T+9K&Z9CrTUj;Os}GpF}@PCWT%{f?L0j$FzU;}w%sPt#A4 z4dOYXlVizaG5)JDW|TSi)}X`NW*o{i6oFr;GtE_j9Q1C9{rk@hwxm$85B!#2jy>bj zx)d(rc*%c{`1g?!Yn5HOR$X>g`I))7x%ap8rsB5}adE0cPo_~RE3iv%_WpPOR@{5| zu<28j)FeH(hm(`Dnw@g~+&QzQh1n2E?~+9Il*G*k&c|PReUZm(*9FTfSFXg~F~kD9 z9$MEK>6Id2-t_gI@Z(c0sd`Bj54MN$tXs22`OaFVr^k)X&(6%0Yd=3>d@+f#frbCV zw{PEkTu@?E3!NxToT?Xa+Q%j)9%dIAR@~oEw1S}_k=&c<;jZ>#_uPLNSzbNo)-i92 zSFR2bu(%ZW^UZX(yJG3`QlZmu=gy-gc0Vr4hw#gw2-v&rC8r2W&nDsW`!ds!OXakw zt?h$prNc_5rqYbN1mzazr=71g)gRSJ{ne~t(2N(JDBCEx!>e`3ae2wpk>0MxXIk%& z_egSSMv9G%ZSF^qK~s^decae=8q-nrcuGf3Z0X48z5Dk+Z#VFWBBv6|Q~j9jR?XP^ z@gI#b(jkJB5Q&A~QbE}}Sy%=#aw3d%wlVIMQ z_-w;oiLlG_Uy58aIWoxT`{KBd=BZQHnR#^MSp>|#bamsi z3b;>MN)3CV#x(=D-|5eb zvD%~-*?s@`&1N2Lq$yD?Y5l0(k80YjjS@C_UF9bn2UJtEG7mLQP0#j6T6}tWS|OLu zZQ`1^%kNWtmHy6ok3^k^Rud|N-G+>Po+z7^YuCJ8RFgjrrimnlwf4;BX^g`tA7r70%?(3PJ1cWFN*|A%4eZGz%PPO?kFP zYDwzyIIJ2rHg8Y|e+&*L6*`X$e0a1=#A_iBJ#qZ1dCRX~*Qhy`;k~R3*ULBU*b$HQ zX!t>oz4)v;c9M(v!O~3MMyZ7dyd^gAd3phYR-M;gJgR7I)xbG=mB)IWYSmTn8twR6 zWAr&JqyDA1zQ@t$9+-c9dt+`Wv%#>UtgNg#(^QdLub?T)X?eDPFSTde-o1P8`1n-U z)YL>dZLP_+Xx;MtWMfE=_i~rHt^06ieluz&TC1Y#*!L%KadGwGqH*{oaz*BF*w=T+ zy*PH7e65}mPuA)<6eRTr9riz}U*oeRoWAwX+6^1jaW+y7N>g!-bRKNyZFwaVxc)$r zq}#*=QaDIcOw|?kwF`Kq5~q;hIM@yd&#InrZ5 zPMn8_hg|FE^mI^ZY3bPas+b@HFRe(Av3q1K0F2DOe|$36AL+eijGf_v33_ty%{^A^ z`}Une-B8R}+$-u-tF(zj2Ef8DPd>A^2v_T{O03+5Y}0hj-Sri$Hl2ShHT+LEq#7ST zeta!DDRwH`ecB2;tctB@F7w^UI4I#Uql8!ajPLanw?nfgOxR@Q>eajM-vByt_*uKt zwhzTaO(dED1to(s*9`e@h5 zh=o#Ad7!KmRKh|J1DrTD6jJ#hN80CeMwNa74$McDUS40j?eNPz;%>h(8ziV22A;-W zrf`>)P(rZ-Y=vVxh3#JbtP3?Q7z%gpZbV0TCgM1tIf^wu>OM7;sFfKjG571heO|kO3SS36((U-E0a?pB4aB#xq8km49;;^MhuxshP!gk-4&<;^Sj@AY9 zNdpD707Dz5@B#VA2cI~XRy-BbCH!qR@PPCNy*wK>bxV9>o+CCVMWt(k`8cKnw(RV$ zacMbs{`>$6a|`acd{ErQXBVxDMt!I^qfmeHQ^FFDd^~epYbUK z?7m+}(JO2*o<-Xbt{?f1cXwEva|B#eL_28WEnP62NeNmK_jjRZw{F|LJ9)dl%RA#) z0?d!~2RE(3p9~H6$$h~0!F`B`h#=*A!)~FM8(2j&xvg>!0iU_`hdVm}>^$0W{EU~E zSL(%G4A)JoXUF>))30A=z$VtcrZA&1eVbws+bbq6{)|UYg!DjsjMj%c`5YEzY}Hb< zn;jNWh)9vR7xsG4#ogVa`stC2Pxjxr(ng9PP(fRBH^51@VZ~ahBFnZ60z7xu^Q9Bm zi^}tm$$h%Zd28~qW$dtursfN_?sOw*`3N!L`e3D^qN0h?Vg)%9h!POVyPTX%pg$6ue=uy*gwZ3_kT_4Um^y}Z$qtQ7-jnt%;Wy&$ZQ zRV4*%{AZm2cu%;vyE>}J3BBoWWxh_4yU2Fgtp9^&uCEhAJ)^W|HKO-1)&Ld~giWB| z@cXH_*B73g87W;ZL6v%c_&5W@i(|W=uA0rF@ z;nP#jIB`^E8GPg<+rAG~DEYBYB{RM2P-NRS8I*YB>&4VB&-D4nmWJb_p5%_s{ZLaQ zi{7bmW5ufVHRt_yn`wXAyB!cdO3Ig|x4XMLMA$xd#flY{=5eTUZor_7qd3IZI`eFu ze%$U?K{szg2iHswJ!x$|+FPNJJrA%*TUwk?Hw1s-9lfX(CJ6+yE$i zA@O_q_wP^G;^r(fm7rl>+;;6!ui|c(KE|M&bs&Y#)5CgFwQauN)-)cv-XG-e?;ooe zY1KX}aOlu^d~ms&$-4c4iW17S&#xIr@piOU1MlpFM`$S_%on_;+Dr*C$vko>4_{%I z2q$jJp>E|GRsoaR9p|K_clDx^WLiX$D~ZxYJ7HnVht)e-4hBBa=P%jb`N4?vE3hS_ zyJ(6X4wAN7>4taw_K2I`bsp)~L$l0HO8M*We-7gc`^>~E$86iW)ks6fMFMrRViQ3k zDwGgMhvOX^8H7-iRMbV2vadCsiHeGf&72iNr;N1&a#zx5nC3Gsq$BS;b;uF6b2dHt1H?#c9?ZnV3Tbk>Ve+WDz@ZI*wHj*gG3pysY0CD&uHH7&PLT+AE48uj(-SIzVvH9>=*up6?S zCw?i@zoZ{fPX_AeRE>Web7aN!cX5$ki61{+kP`D=T3E}-DF4RqD++T4NFv!-PE=Bjlf*^593Sst@? zl%5hj4u!B!|EUs33=9lb{qql}b$8KPP!)Q6wpy;09`(tgty4GoFLQx_>|fIHs;I>xkTPbx~)5!6La?X38a zlh&!R@}Y-j;!gn&gorw)LJ)`{R2=UTJNQ~A@H~z{tNTc?smK-+J3fbBpE#CTnVC%r z>hT*)J9g}_*12)xhTC}ENlN!LUOyXe$0}rVihMF0>TS%-v3KwO>+0%y#B*+fP!Xc9 zpm3?B>FZ&&oqv7nyz%$yEC5iB^X&`l`~3iKKgY@^>E_!d;ID%LhJZQ5qTR4-TQxQ|Y8N;ppwUK)yHEYX z-7oN*&skVlcq(jf@}n+P1N}g)@53Wjp4g0^sLk#9_HpPL(d6av#R_b`-6Sv&i&ovx zFjCc@aJ4Fcd>ZqXWHap-tNO(j^#Wgkq3>*2w{fHY^!(I}J3bwMS$v`5a_Pj#v`C3y zkJ}(Obfxlqza%X#W^glki`LX;pkYTeV1P|!T0yVOvlFJJ*_)rqUQ{U^ub)bGJfuA%dYw^8SjFf1!>nQOo z1T>1nyV1}-)X`fny}A%37kuJ~wBK&G(TeT3Pf|o&J3T&wcA7*~sm1{5 zYEbsJIxN?B|LqJ}txj%4Qoqni9+k^xMvUk+*BQC+Plnx2kSt^&IdKK7Uq*>}-bB-4 zLfZ<41o7JD+xysjo%tY~`dTx5ZK;<+qq>TCn)Jv{VK}rUGUKxPB@SRe| z3fDkyH%@3i~+_OG}p)@|Fa zUULU5PH$Pm$e2BAJwT(G(YlKZe_(GEexM3l1*2`h2H$Uaakr~$Hf#_aia|x?F_Vl64(}13?*hCoGz)FZFt*p~mT?X9f{6e6?7c0qX`?72 zd|k0u%6wu6r$>4umF=8b(BjwUFaIvvnBH<+^k?~G=;lb=j?kQ3;~HjPgG$g7`HrEM z6rG}ulJR=c*bZn6)NdXr|HeQav2;HG@>qInnt^q}A{aAGRUZg|FDsbWKq9U^>sj0M z>r*#Y@N`Mz-mRa%fC48!y%OZi)C}lduXWqXB${erV4ABq+)7(x zjMDb}kbH>HgdX~C=?~oFEL~^|QJx0HZp~xEg(KSNLqqM>7cSg2hVG(JY^Aew9?&ZH zJ4D`YkKRHKGaOLx;>-oCNo;?a?PAS~<1xlx-dx$xv(e%8$!?c2{z?!44o7oE%|Z>@ z&~!t);}q^#vQ^-w){QNih5m$S9CTj8C%p~-<9C>5o=uchXWo^&Xs+VjPv`-J^N}{= zIP`^ph-`}vg2i!*v%|_~9x!ufn1yHn+~3>Ek%*=w;=NRK#T6w5 zr8*Uc5e<$`#t~oCka+Y%^|+UgAJF5}^6iWPXu4AAxKjL1Lz*BfYSZVxP!w!K(l{JM!0whaG^hs&NXe zknEd|8QOS6M@RE}Ex3?6&1X_;<7$Pf3ynb?{4m?7azkh?I9NE=F&=-f;GjQtcJOtO z{-v1nj|dhEt$z|Rg;tmd02~`*B>Ne-(CThio~;zruEMVQ6PeJW!qIOxjkIOP$+j!{ zCD%z@cJh3(8#?thRFttPL4||!KSQkta0Jo~LHV1ppp1jeV7q_+v;M*xF})w<_qO_M z9+WzBX5zyx>w~|%>ijxL-vU0|ZG{FB78^5W_2ms)Hzh?c>3j9Fnr|Mx?OqUR1S!_^ zX?n$W0|$Qgq>e~2*Ut{Bo*IK#MK&jJf1r?NcDkg;%%_RmY^alCjLA_`hf%=A{)w>~ zULt((R1Xi(VIp9o*FmBL+sc z?>B>M*WzXEY_~so@+8*Qxya8(6-AI35>gAGo#|^!dG(9p(IGnCMEs}p@87#O^0pk6 z-EC@U=b*~rvCCBp(*|Fs&P?71E1684<1pzzbTa8%&=YA1Q3wN%o{Dk$M5jx(#l_XX#Ua$ zUbF11B9yCBUhVTI`R6?!j*Q&y2fChDjg{M37a`ukPH%H(9EHx8h`y)bJfMRL3!eD( zlVgbhzFi_fFf+F{Y;LcGQE5~LSr}{1iQ!n5B-kTl`DDj3S|Rv@A(`AYt$r$l*O6bi zy+sR0O1=-(U-r8kYWMa22lmcF$O-+paONYpl9r|%tW?? zW~ZHL^2kg94p$S%?%dVexx~XoCB2ue0Mv_*{u)>P2sG!DR-K<ZL`iH)! zmS=M%PCv53P`T2N)riRhjS`n%omi0fnU2O1i550Lnou*qr~sT9s&XPwKpK>kLmw|> zH{1flC;lMrwHn?I?L7wjNqqly+`Xl_L0+oiL(r%MyeKIq%_~B`C!^N;jMR8T(4gJf zuCD~ijI0P`ylWjf6nxjGv^hwU&BUHxwT}5C^sR(Wbfu=~bL*t8T)KSuB}iQY7!D^G zDrm!V@bOr+j__Sg5*2LrPwZdmB z{{4O(f)3YDnARubZqPuJwF{k6XuqC7@VJCuRxNgO^z{-Yq!>++c&Gy+WTk=dp5g=; z*S=83xpTJ@>nwCmYo2bcC9Ua&u?ZRjahxE_Uv^&dC#5Ru)+PLA_|l^b^~sJOG6gf- z?F4MTp5oTcQ}W%o*N-WZ&(x2IciEP0m#}~*xI^XuWm1?o6$aw??lj3Gf&q;EfS2=& z=!Fhg3aKKHc!gX_3u)7Yu)V&>l+?jKHByZ_FK>F$t_T@E@$s(P&YZ(0%tx^ImV}%0`oBnC%bB3 z3|$^J?5f`{$+ieWA&L3@+a_u76{Hv(P&Eh&L~ejlL<1=oLGHq7q?@%rXLR

x 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

I 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