Mailman 3 December 2022 - Kwant-discuss

Realistic values of hopping parameters
by Yu Li 18 Oct '23

18 Oct '23

Dear all, Now I’m studying some transport property based on multilayered system, with nonmagnetic layer/ferromagnetic layer (NM/FM) stack. May I ask when creating a tight binding system, and setting hoppings by the following function: syst[(lat(1, 0), lat(1, 1))] = t, how to associate the hopping with a realistic system? Such as hoppings between FM and FM atoms, or between FM and NM atoms? I found in many literatures people just simply put t=1, but I assume the value should depend on the type of atoms. My another question is, is it possible to define more than one type of hopping between two sites? For the tight-binding approximation of p electrons, there are two types of hopping integrals: Vppσ, and Vppπ, so I’m wondering if it’s possible to simulate the effect of both hoppings? Thanks a lot for reading my questions! Cheers, Yu Li

4 3

Defining uniaxial strain in specified region of graphene
by shrushti.tapar07＠gmail.com 20 Jan '23

20 Jan '23

I want to create the graphene strained superlattice-like structure, having uniaxial strain defined at the specified region. Please, someone can suggest to me how to define the strained region and interface between unstrained and strained graphene regions. Thanks in Advance Shrushti

4 6

Printing Transmission Amplitude in KWANT
by Subhadeep Chakraborty 16 Dec '22

16 Dec '22

Hi Kwant Users ! I was trying to print the transmission function (or say, transmission amplitude) in KWANT, but couldn't find how to do it. Can anyone suggest if there is any way to do it ? It will be a great help. Thanks a lot.

2 1

Kwant for 3d classical optics
by sebastien.popoff＠espci.fr 16 Dec '22

16 Dec '22

Hi guys, Thanks for the wonderful work on Kwant! I want to use it to simulate disordered systems in optics, I was able to make it works quite simply, see my commented notebook here : https://github.com/wavefrontshaping/WFS.net/blob/master/Kwant_disordered_wa… But I have two issues: 1/ In order to retrieve the internal field for a given input, the only way I found was to get the internal fields for **all** the modes from a lead using `kwant.wave_function()` and then project my input wavefront. It is clearly not efficient as I force the solver to compute the internal field for all the modes instead of directly solving it for one specific input. 2/ One of my goals would be to go to 3d waveguides. There is a picture of a 3d system on the Kwant website (https://kwant-project.org/about#numerical-experiment-flying-qubit) but I did not find anything in the documentation nor in the paper related to the figure to help me to implement a 3d system. Is there a *reasonably* easy way to do it? Thanks! Sebastien

1 0

Different Conductance plot for same program
by sahu.ajit92＠gmail.com 13 Dec '22

13 Dec '22

Dear All, I am using Kwant to calculate the conductance of a Graphene structure. However, it gives different conductance each time I run the code. I didn't change the code. For the same code, I am getting different results each time. Is there some error in my code or am I using the kwant function incorrectly? Please Help Code ----------- import kwant import matplotlib.pyplot as plt Wnr = 99 lnr = 60 a = 2.46 lat = kwant.lattice.honeycomb(a,norbs=1) a,b = lat.sublattices def make_sys(): def rect(pos): x,y = pos return 0<=x<=lnr and 0<=y<=Wnr def delet(pos): x, y = pos return 0<=x<=35 and 20<=y<=80 model1 = kwant.Builder() model1[lat.shape(rect,(1,1))] = 0 model1[lat.neighbors()] = 2.64 del model1[lat.shape(delet, (11,25))] model1.eradicate_dangling() return model1 def lead_attach(model1): def lead1_shape(pos): x, y = pos return 0<y<=20 def lead2_shape(pos): x, y = pos return 80<=y<=Wnr sym = kwant.TranslationalSymmetry(lat.vec((-1,0))) #from the left sym.add_site_family(lat.sublattices[0], other_vectors=[(-1, 2)]) sym.add_site_family(lat.sublattices[1], other_vectors=[(-1, 2)]) lead = kwant.Builder(sym) lead[lat.shape(lead1_shape, (1,2))]=0 lead[lat.neighbors()] =2.64 model1.attach_lead(lead) ########### lead 2 ################# sym1 = kwant.TranslationalSymmetry(lat.vec((-1,0))) #from the left sym1.add_site_family(lat.sublattices[0], other_vectors=[(-1, 2)]) sym1.add_site_family(lat.sublattices[1], other_vectors=[(-1, 2)]) lead2 = kwant.Builder(sym1) lead2[lat.shape(lead2_shape, (2,82))] = 0 lead2[lat.neighbors()] = 2.64 model1.attach_lead(lead) model1.attach_lead(lead2) kwant.plot(model1) return model1 def dos_eng(model1): rho = kwant.kpm.SpectralDensity(model1) eng1, densities = rho.energies, rho.densities return eng1, densities def calc_conductance(sys, energies): data = [] for energy in energies: smatrix = kwant.smatrix(sys, energy) data.append(smatrix.transmission(1, 0)) plt.figure() plt.plot(energies, data) plt.xlim([-3,3]) plt.ylim([0,4]) plt.xlabel("Energy (eV)",fontweight='bold') plt.ylabel("Conductance $(e^2/h)$",fontweight='bold') return data def main(): sys = make_sys() syst = lead_attach(sys) syst = syst.finalized() eng1, densities = dos_eng(syst) cond = calc_conductance(syst,eng1) if __name__ == '__main__': main()

2 1

Resolution of Tkwant
by Clarke, Isobel 05 Dec '22

05 Dec '22

Dear Kwant developers, I was wondering if there is a limit on the resolution of Kwant and Tkwant when calculating the density of an evolved wavefunction. I am currently working on a code to simulate the response of a carbon nanotube spin qubit to an electric dipole spin resonance drive. I am using Kwant to define the carbon nanotube as a scattering region and then apply a Hamiltonian to the system. The lowest eigenvector of the Hamiltonian at t=0 is determined and associated with a tkwant.onebody.WaveFunction. This wavefunction is evolved over time and the density of the wavefunction calculated using kwant.operator.Density. The relevant part of my code is given below: class System: def __init__(self, hamiltonian, pertubation_type, number_of_lattices, potential_type): self.potential_type = potential_type self.hamiltonian = hamiltonian self.number_of_lattices = number_of_lattices self.pertubation_type = pertubation_type self.evolve_state = False def potential(self, z, time): if self.potential_type == 0: #infinite square well total_potential = 0 elif self.potential_type == 1: #parabolic potential total_potential = .5 * (z * self.omega_0_au) ** 2 if self.pertubation_type == "cos": self.pertubation = self.cosine_v_ac else: self.pertubation = self.sine_v_ac total_potential += self.pertubation(time, z, self.eV_0_au, self.pulse_frequency_au, self.total_length_au) return total_potential def kwant_shape(self, site): (z,) = site.pos return (-self.total_length_au / 2 <= z < self.total_length_au / 2) def make_system(self): self.template = kwant.continuum.discretize(self.hamiltonian, grid=self.lattice_size_au) self.syst = kwant.Builder() # add the nanotube to the system self.syst.fill(self.template, self.kwant_shape, (0,)) self.syst = self.syst.finalized() def B_constant(z): return -self.g * self.mu_B_au * self.B_z_au * self.hbar_au / 2 def C_constant(z): return -self.g * self.mu_B_au * self.b_sl_au * z * self.hbar_au / 2 def D_constant(z): return -self.g * self.mu_B_au * self.B_y_au * self.hbar_au / 2 # coefficient for the kinetic energy term A_constant = self.hbar_au ** 2 / (2 * self.m_au) # parameters of hamiltonian self.params = dict(A=A_constant, V=self.potential, B=B_constant, C=C_constant, D=D_constant) self.tparams = self.params.copy() # copy the params array self.tparams['time'] = 0 # initial time = 0 # compute the Hamiltonian matrix hamiltonian = self.syst.hamiltonian_submatrix(params=self.tparams) # compute the eigenvalues (energies) and eigenvectors (wavefunctions). eigenValues, eigenVectors = np.linalg.eig(hamiltonian) # sort the eigenvectors and eigenvalues according the ascending eigenvalues. idx = eigenValues.argsort() self.initial_eigenvalues = eigenValues[idx] eigenVectors = eigenVectors[:, idx] # initial wave functions unperturbed by time dependent part of hamiltonian self.psi_1_init = eigenVectors[:, 0] self.psi_2_init = eigenVectors[:, 1] # an object representing the spin-up state self.spin_up_state = tkwant.onebody.WaveFunction.from_kwant(syst=self.syst, psi_init=self.psi_1_init, energy=eigenValues[0], params=self.params) return self.syst def evolve(self, time_steps): self.evolve_state = True total_osc_time = self.second_to_au(0.5e-8) times_au = np.linspace(0, total_osc_time, num=time_steps) times_SI = np.linspace(0, self.au_to_second(total_osc_time), num=time_steps) density_operator = kwant.operator.Density(self.syst) psi = self.spin_up_state data = {'states': []} for time in times_au: psi.evolve(time) # evolve the wavefunction density = psi.evaluate(density_operator) # compute density data['states'].append({'pdf': density.tolist()}) json_string = json.dumps(data) with open(r'\{}.json'.format(timestr), 'w') as outfile: outfile.write(json_string) self.evolve_state = False return True def main(): lattices = 100 potential = 0 system = System("((A * k_z**2) + V(z, time)) * identity(2) + B(z) * sigma_z + C(z) * sigma_x + D(z) * sigma_y", pertubation_type="sin", number_of_lattices=lattices, potential_type=potential) system.make_system() system.evolve(10) if __name__ == '__main__': main() Please note that I haven't included some conversion functions in the above code. Using this code, I obtain the results shown in the animation attached. The first subplot shows the density of the wavefunction across the carbon nanotube evolving with time. The animation shows an expected smooth Gaussian response for the first few time steps, however the graph then becomes very noisy. I was wondering why this occurs and if it could be due to a limit on the resolution of Tkwant? The second subplot shows the energy of the time-dependent perturbation over time, displaying a sin wave perturbation as a simple 'see-sawing' potential. In addition, I was wondering if you had any advice for making the code run faster? I ran the simulation for 10 time steps over a very short time period to obtain the attached animation and it took around 4 hours on my desktop. Thank you for any help with this. Best wishes, Isobel

4 3

Re: Resolution of Tkwant
by Clarke, Isobel 05 Dec '22

05 Dec '22

Dear Christoph, Thank you so much for your email and for your advice. I have attached the full code for my carbon nanotube system (simplified slightly) which, when run, should output the animation I have also attached. The system is evolved for 5 time steps over a short period of time (0 to 0.5e-8s). It seems that when I increase the number of lattice points, the probability density function becomes 'spiky' over time and the resolution of the graph deteriorates. However, this might just be a problem with my code. Thank you again for any help with this. Best wishes, Isobel ________________________________ From: Christoph Groth Sent: Thursday, December 01, 2022 15:34 To: Clarke, Isobel Cc: kwant-discuss(a)python.org; Buitelaar, Mark Subject: Re: [Kwant] Resolution of Tkwant Clarke, Isobel wrote: > I was wondering if there is a limit on the resolution of Kwant and > Tkwant when calculating the density of an evolved wavefunction. Hi, I’m not aware of any particular issue where a Tkwant simulation “explodes” after some time. Obviously, the numerical calculations have a limited precision. It would be most helpful if you could provide a complete example that demonstrates the problem that you experience. It doesn’t have to be the same physical system that you use in research. It’s actually better if it’s simpler, but one should be able to observe the concrete problems that trouble you. > In addition, I was wondering if you had any advice for making the code > run faster? I ran the simulation for 10 time steps over a very short > time period to obtain the attached animation and it took around > 4 hours on my desktop. As a vague rule of thumb, one needs to step up to a a computing cluster for tkwant when a laptop/desktop is sufficient with kwant alone. (This assumes that one wants to treat similar systems with comparable numbers of orbitals.) Or one has to wait longer... Tkwant calculations need to be integrated over many energies, while with Kwant at zero temperature that’s not necessary. So there’s literally more to do. There are bottlenecks and problems that could be improved in both Kwant and Tkwant, and there may be also possible workarounds. It can help to profile a run to see where time is actually spent. Having a small but representative running example (that ideally does not take four hours!) would help here as well. Cheers Christoph

1 0