Dear (t)kwant community, applying an AC voltage in a time-dependent setting involves tkwant.leads.add_voltage(sys,phase) as proposed in https://gitlab.kwant-project.org/jbweston/tkwant-tutorial/blob/master/1_syst..., where phase is the voltage phase, with which the hopping from a newly created (set of) system-site(s) is transformed in a Peierls-substitution like manner. The documentation says, that "phase" should be a callable returning either a scalar, or a sequence of values, where the number of elements in this sequence is corresponding to the number of orbitals on a site. For my purpose, I am working with norbs = 2, trying to simulate a system of spinfull fermions on a lattice, of say, after setting the quantization axis, spin-up and spin-down electrons. The phase I defined like this by a minor change of the original tutorial: def faraday_flux(time, V_dynamic): omega = 0.5 t_upper = pi / omega if time <= 0: return [0,0] if 0 < time < t_upper: return [V_dynamic * (time - sin(omega * time) / omega)/2,V_dynamic * (time - sin(omega * time) / omega)/2] return [V_dynamic * (time - t_upper) + V_dynamic * t_upper/2,V_dynamic * (time - t_upper) + V_dynamic * t_upper/2] Then, after finishing my system and adding leads to it, I call tkwant.leads.add_voltage(syst, 0, faraday_flux) in order to apply this dynamic phase "faraday_flux" to lead 0. *Is* this the proper way to define the same ac voltage phase for both orbitals*?* If I call a single scalar only (instead of a list of scalars), I get the same current-time characteristics. I would actually expect calling a single scalar for a system with 2 orbitals per site should not work in first place, and if it is handled cleverly, it should definitively not yield the same result (since one part of the electron hilbertspace has a vanishing probability of hopping onto the system and thus a vanishing current, which in turn should be present in the total current). I observe the current with the following sequence: 1. generate system: make_syst(lat,params,...) 2. add ac voltage: tkwant.leads.add_voltage(syst,0,faraday_flux) 3. finalize system 4. define operator kwant.operator.Current(fsyst, spinc, where=interface,sum=True) 5. define solver with tkwant.manybody.State(fsyst, tmax, occupation, params=params) 6. propagate solver in time with solver.evolve(time) and evaluate the current with the solver at a specific time solver.evaluate(operator) I am using tkwant.manybody.State in order to incorporate a specific chemical potential and temperature in the lead, which, to my knowledge, is not possible with the kwant.wave_function (correct me if I am wrong!). Another reason I would not use kwant.wave_function is because it is just computing wave functions for specific energies, I am however interested in quantities that are already integrated over the energy. As a reference, I am using the voltage_raise tkwant tutorial, which can be found here: https://gitlab.kwant-project.org/jbweston/tkwant/blob/k-integration/tutorial... . One other thing which I have not been able to figure out yet: How to access the individual spin components for a 2-orbital system of the manybody-wavefunction? This is possible with kwant.wave_function as shown in https://kwant-project.org/doc/dev/tutorial/operators , however when it comes to the time-dependent equivalent, I am a bit clueless. My aim is to observe a spin-resolved current, where I only address the individual components of my observables originating from a single contribution of spin-up (-down) electrons only. Subsequently I started to ask myself, how to measure a spin-current? Is defining the operator as above with setting spinc = sigma_z doing the job? Thank you for your answers in advance! Best, Rudolf