tracking=1) """generating our class of scaled parameters""" """this is used for most of the calculations""" lat = hhg(field=param.field, nup=param.N_up, ndown=param.N_down, nx=param.L, ny=0, U=param.U, t=param.t0, F0=param.F0, a=param.a, pbc=param.pbc) """setup our evolution time parameters""" t_p = time_evolution_params(perimeter_params=lat, cycles=2, nsteps=int(2e3), plotting=1) """prepare to load our data to be plotted""" outfile = './Data/expectations:{}sites-{}up-{}down-{}t0-{}U-{}cycles-{}steps-{}pbc:a_scale={:.2f}-J_scale={:.2f}.npz'.\ format(param.L, param.N_up, param.N_down, param.t0, param.U, t_p.cycles, t_p.n_steps, param.pbc, param.a_scale , param.J_scale) expectations = np.load(outfile) """plot out expectations""" """Plotting field""" plt.figure("Control field") plt.xlabel("Time (cycles)") plt.ylabel("$\\Phi(t)$") plt.grid(True) plt.tight_layout() plt.plot(t_p.times, expectations['phi']) plt.plot(t_p.times, expectations['tracking_phi'], ".")
os.environ['MKL_NUM_THREADS'] = '{}'.format(threads) sys.path.append('../') # note cpu_count for logical=False returns the wrong number for multi-socket CPUs. print("logical cores available {}".format(psutil.cpu_count(logical=True))) t_init = time() np.__config__.show() """Generate our class for the unscaled parameters. These are primarily used for saving our data""" param = unscaledparam(L=6, t0=0.52, U=0.6, pbc=False, field=32.9, F0=10, a=4) """Generating our class of scaled parameters. This is used for most of the calculations""" lat = hhg(field=param.field, nup=param.N_up, ndown=param.N_down, nx=param.L, ny=0, U=param.U, t=param.t0, F0=param.F0 , a=param.a, pbc=param.pbc) """setup our evolution time parameters""" t_p = time_evolution_params(perimeter_params=lat, cycles=2, nsteps=int(4e3)) """setup quspin operators and lists""" FHM = Fermi_Hubbard(lat, t_p.cycles) """get inital energy and state""" ti = time() E, psi_0 = FHM.operator_dict['H'].eigsh(k=1, which='SA') print("Initial state and energy calculated. It took {:.2f} seconds to calculate".format(time() - ti)) print("Ground state energy was calculated to be {:.2f}".format(E[0])) """evolve that energy and state""" print('Starting Evolution') ti = time() psi_t = FHM.operator_dict["H"].evolve(psi_0, 0.0, t_p.times) psi_t = np.squeeze(psi_t)
a_scale=1, J_scale=1, tracking=1) """Generating our class of scaled parameters for the twinned system.""" lat2 = hhg(field=param2.field, nup=param2.N_up, ndown=param2.N_down, nx=param2.L, ny=0, U=param2.U, t=param2.t0, F0=param2.F0, a=param2.a, pbc=param2.pbc) """setup our evolution time parameters""" t_p = time_evolution_params(perimeter_params=lat, cycles=10, nsteps=int(2e3)) # plt.figure('current') # plt.plot(t_p.times, J_target(t_p.times)) # plt.plot(t_p.times, expectations['current'], ".") """setup quspin operators and lists""" FHM1 = Fermi_Hubbard(lat, t_p.cycles) FHM2 = Fermi_Hubbard(lat2, t_p.cycles) print("Initial classes built. This took {:.2f} seconds".format(time() - ti)) """get inital energy and state""" print("Determining ground states of the two systems.") ti = time() E1, psi1_0 = FHM1.operator_dict['ham_init'].eigsh(k=1, which='SA') psi1_0 = np.squeeze(psi1_0) E2, psi2_0 = FHM2.operator_dict['ham_init'].eigsh(k=1, which='SA')
E_track, psi_0_track = FHM.operator_dict['H'].eigsh(k=1, which='SA') """start running R tracking and prelim simulation starting with 1000 steps incrimenting by 100 until 10000""" t_a_absolute_err = [] t_a_absolute_err_R_track = [] t_a_relative_err_R_track = [] t_a_absolute_err_R_prime_track = [] t_a_relative_err_R_prime_track = [] t_a_relative_err_delay = [] min_steps = 1000 max_steps = 10000 delta_steps = 100 for j in range(int((max_steps - min_steps) / delta_steps) + 1): # create our time parameters class n_steps = min_steps + j * delta_steps t_p = time_evolution_params(perimeter_params=lat, cycles=2, nsteps=n_steps) # evolve the untracked state psi_t = FHM.operator_dict["H"].evolve(psi_0, 0.0, t_p.times) psi_t = np.squeeze(psi_t) # find expectation from these states current = obs_vs_time(psi_t, t_p.times, dict(J=FHM.operator_dict['current'])) # define the tracked time parameters class and the target J t_p_track = time_evolution_params(perimeter_params=lat_track, cycles=2, nsteps=n_steps) J_target = UnivariateSpline(t_p_track.times, param_track.J_scale * current['J'],