def rundmrg(i, t, N, it, iN): storagedir = bhdir + '/' + str(i) os.makedirs(storagedir) # parms = [dict(parmsbase.items() + {'N_total': N, 't': t, 'it': it, 'iN': iN}.items())] parms = [ dict( parmsbase.items() + { 'N_total': N, 't': 'get(x,' + ",".join([str(Ji) for Ji in JW(speckle(t))]) + ')', 'U': 'get(x,' + ",".join([str(Ui) for Ui in UW(speckle(t))]) + ')', 'it': it, 'iN': iN, 'storagedir': storagedir, 'seed': str(int(time.time())) }.items()) ] # parms = [x for x in itertools.chain(parms, parms)] # parms = [dict(parm.items() + {'ip': j, 'seed': seed0 + j}.items()) for j, parm in enumerate(parms)] input_file = pyalps.writeInputFiles(filenameprefix + str(i), parms) pyalps.runApplication(app(appname), input_file, writexml=True) # checkpoints = glob.glob(filenameprefix + str(i) + '*.chkp') # [shutil.rmtree(chkp) for chkp in checkpoints] shutil.rmtree(storagedir)
def runmc(i, t, mu, it, imu): parms = [dict(parmsbase.items() + {'t': t, 'mu': str(mu) + '-' + getnu, 'it': it, 'imu': imu}.items())] input_file = pyalps.writeInputFiles(filenameprefix + str(i), parms) if limit > 0: pyalps.runApplication('/opt/alps/bin/'+app, input_file, writexml=True, Tmin=5, T=limit) else: pyalps.runApplication('/opt/alps/bin/'+app, input_file, writexml=True, Tmin=5)
def rundmrg(i, t, N, it, iN): parms = [dict(parmsbase.items() + {'N_total': N, 't': t, 'it': it, 'iN': iN}.items())] # parms = [x for x in itertools.chain(parms, parms)] parms = [x for x in itertools.chain.from_iterable(itertools.repeat(parms, reps))] parms = [dict(parm.items() + {'ip': j}.items()) for j, parm in enumerate(parms)] input_file = pyalps.writeInputFiles(filenameprefix + str(i), parms) pyalps.runApplication('/opt/alps/bin/dmrg2', input_file, writexml=True)
def runmps(task, iW, isigma, Wi, sigma): parmsi = deepcopy(parms) parmsi['iW'] = iW parmsi['is'] = isigma t = JW(speckle(Wi, sigma)) U = UW(speckle(Wi, sigma)) for i in range(L): parmsi['t'+str(i)] = t[i] for i in range(L): parmsi['U'+str(i)] = U[i] # try: # if ximax == 0: # raise ValueError # ns = VarArray(L, nmax) # E = Sum([n*(n-1) for n in ns], (0.5*U).tolist()) # model = Model(Minimize(E), [Sum(ns) == N]) # solver = model.load('SCIP') # solver.setTimeLimit(60) # solved = solver.solve() # parmsi['solved'] = solved # except: # basen = N // L # ns = [basen] * L # rem = N % L # excessi = [i for (xii, i) in xisort[:rem]] # for i in excessi: # ns[i] += 1 # parmsi['initial_local_N'] = ','.join([str(n) for n in ns]) input_file = pyalps.writeInputFiles(basename + str(task), [parmsi]) pyalps.runApplication('mps_optim', input_file, writexml=True)
def run_dmrg(nsite, J2): #prepare the input parameters parms = [{ 'LATTICE_LIBRARY': 'j1j2_%d.xml' % nsite, 'LATTICE': 'J1J2', 'MODEL': 'spin', 'local_S0': '0.5', # local_S0 means type 0 site, right? 'CONSERVED_QUANTUMNUMBERS': 'N,Sz', 'Sz_total': 0, 'J0': 1, 'J1': J2, 'SWEEPS': 4, 'NUMBER_EIGENVALUES': 1, 'MAXSTATES': 400 }] #write the input file and run the simulation prefix = 'data/j1j2_%dJ2%s' % (nsite, J2) input_file = pyalps.writeInputFiles(prefix, parms) res = pyalps.runApplication('dmrg', input_file, writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements( pyalps.getResultFiles(prefix=prefix)) # print properties of the eigenvector for each run: for run in data: for s in run: print('%s : %s' % (s.props['observable'], s.y[0]))
def runmps(task, it, iN, Ui, ti, N): parmsi = deepcopy(parms) parmsi['it'] = it parmsi['iN'] = iN t = xi * ti if twist: t[0] *= -1 U = xi * Ui for i in range(L): parmsi['t'+str(i)] = t[i] for i in range(L): parmsi['U'+str(i)] = U[i] parmsi['N_total'] = N try: if ximax == 0: raise ValueError ns = VarArray(L, nmax) E = Sum([n*(n-1) for n in ns], U.tolist()) model = Model(Minimize(E), [Sum(ns) == N]) solver = model.load('SCIP') solver.setTimeLimit(600) solved = solver.solve() parmsi['solved'] = solved except: basen = N // L ns = [basen] * L rem = N % L excessi = [i for (xii, i) in xisort[:rem]] for i in excessi: ns[i] += 1 parmsi['initial_local_N'] = ','.join([str(n) for n in ns]) # subprocess.call(['mkdir Tasks/Task.'+str(task)], shell=True) # input_file = pyalps.writeInputFiles('Tasks/Task.' + str(task) + '/bh.' + str(L) + '.' + str(resi) + '.' + str(task), [parmsi]) input_file = pyalps.writeInputFiles(basename + str(task), [parmsi]) # subprocess.call(['bash','-c','read']) pyalps.runApplication('mps_optim', input_file)
def runmps(task, iW, iN, Wi, N): parmsi = deepcopy(parms) parmsi['iW'] = iW parmsi['iN'] = iN W = Wi * xi t = JW(W) U = UW(W) if twist: t[0] *= -1 for i in range(L): parmsi['t'+str(i)] = t[i] for i in range(L): parmsi['U'+str(i)] = U[i] parmsi['N_total'] = N try: if ximax == 0: raise ValueError ns = VarArray(L, nmax) E = Sum([n*(n-1) for n in ns], U.tolist()) model = Model(Minimize(E), [Sum(ns) == N]) solver = model.load('SCIP') solver.setTimeLimit(600) solved = solver.solve() parmsi['solved'] = solved except: basen = N // L ns = [basen] * L rem = N % L excessi = [i for (xii, i) in xisort[:rem]] for i in excessi: ns[i] += 1 parmsi['initial_local_N'] = ','.join([str(n) for n in ns]) input_file = pyalps.writeInputFiles(basename + str(task), [parmsi]) pyalps.runApplication('mps_optim', input_file, writexml=True)
p['initial_local_Sz'] = ','.join(['-0.5'] * 25 + ['0.5'] * 25) p['te_order'] = 'second' p['DT'] = dt p['TIMESTEPS'] = nsteps p['tau'] = tau # not used in the simulation, but useful in the evaluation below p['Jz'] = z p['ALWAYS_MEASURE'] = 'Local Magnetization' p['chkp_each'] = nsteps p['measure_each'] = 5 p['COMPLEX'] = 1 parms.append(p) ## write input files and run application input_file = pyalps.writeInputFiles(basename, parms) res = pyalps.runApplication('mps_evolve', input_file) ## simulation results data = pyalps.loadIterationMeasurements(pyalps.getResultFiles(prefix=basename), what=['Local Magnetization']) for q in pyalps.flatten(data): L = q.props['L'] #Compute the integrated flow of magnetization through the center \Delta M=\sum_{n>L/2}^{L} (<S_n^z(t)>+1/2) #\Delta M= L/4 loc = 0.5 * (L / 2) #\Delta M-=<S_n^z(t)> from n=L/2 to L q.y = np.array([0.5 * (L / 2) - sum(q.y[0][L / 2:L])]) #Plot the Error in the magnetization one site to the right of the chain center Mag = pyalps.collectXY(data, x='Time', y='Local Magnetization', foreach=['Jz'])
'hz': hz, 'cg': cg, 'sg': sg, 'SWEEPS': sweeps, 'NUM_WARMUP_STATES': warmup_states, 'NUMBER_EIGENVALUES': 1, 'MAXSTATES': max_states, 'MEASURE_LOCAL[nUP]': 'nUP', 'MEASURE_LOCAL[nDO]': 'nDO', 'MEASURE_CORRELATIONS[One-body Correlation UP]': "bdagUP:bUP", 'MEASURE_CORRELATIONS[One-body Correlation DO]': "bdagDO:bDO", 'MEASURE_CORRELATIONS[One-body Correlation UPDO]': "bdagUP:bDO", 'MEASURE_CORRELATIONS[Two-body Correlation UP]': "nUP:nUP", 'MEASURE_CORRELATIONS[Two-body Correlation DO]': "nDO:nDO", 'MEASURE_CORRELATIONS[Two-body Correlation UPDO]': "nUP:nDO" }] #Write the input file and run the simulation input_file = pyalps.writeInputFiles(filename, parms) res = pyalps.runApplication('dmrg', input_file, writexml=False, MPI=None) #Load measurements for the ground state data = pyalps.loadEigenstateMeasurements( pyalps.getResultFiles(prefix=filename)) #Print the properties of the ground state if __name__ == '__main__': for s in data[0]: print s.props['observable'], ' : ', s.y[0]
'T' : t, 'D' : 1., 'THERMALIZATION' : 50000, 'SWEEPS' : 100000, 'UPDATE' : "ssf", 'cutoff_distance': 1.8, 'L' : l, 'Each_Measurement': 15 } ) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm',parms) #pyalps.runApplication('mc++',input_file,Tmin=5) # use the following instead if you have MPI pyalps.runApplication('mc++',input_file,Tmin=5,MPI=1) def f_alpha(Le, Lo, b=2, d=2): return 2-d*log(b)/log(Le) def f_beta(Le, Lo, b=2, d=2): return (d*log(b)-log(Lo))/log(Le) def f_gamma(Le, Lo, b=2, d=2): return log(b)/log(Le)*(2*log(Lo)/log(b)-d) def f_nu(Le, Lo, b=2, d=2): return log(b)/log(Le) #load the susceptibility and collect it as function of temperature T data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),['M', 'c_V', 'BinderCumulant', 'susceptibility']) Tc0=2.269 Tc_min=2
'ALGORITHM': 'loop', 'SEED': 0, 'BETA': 2 * l, 'J0': 1, 'J1': 1, 'J2': j2, 'THERMALIZATION': 5000, 'SWEEPS': 50000, 'MODEL': "spin", 'L': l, 'W': l / 2 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('mc08b', parms) pyalps.runApplication('loop', input_file) data = pyalps.loadMeasurements( pyalps.getResultFiles(pattern='mc08b.task*.out.h5'), ['Binder Ratio of Staggered Magnetization', 'Stiffness']) binder = pyalps.collectXY(data, x='J2', y='Binder Ratio of Staggered Magnetization', foreach=['L']) stiffness = pyalps.collectXY(data, x='J2', y='Stiffness', foreach=['L']) for q in stiffness: q.y = q.y * q.props['L'] #make plot
import pyalps #prepare the input parameters parms = [{ 'LATTICE' : "chain lattice", 'MODEL' : "spin", 'local_S' : 0.5, 'J' : 1, 'L' : 16, 'CONSERVED_QUANTUMNUMBERS' : 'Sz', 'Sz_total' : 0, 'TRANSLATION_SYMMETRY' : 'true', 'NUMBER_EIGENVALUES' : 5, 'TOTAL_MOMENTUM' : "0" }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('heisenberg',parms) res = pyalps.runApplication('sparsediag',input_file)
parms['update_each'] = 1 xi = (1 + 0.5 * np.random.uniform(-1, 1, L)) for i in range(L-1): parms['t'+str(i)] = mathematica(JW(W_i*xi)[i]) for i in range(L): parms['U'+str(i)] = mathematica(UW(W_i*xi)[i]) resi = 302 basename = 'DynamicsTasks/bhramp.'+str(L)+'.'+str(resi) # gbasename = basename gbasename = 'DynamicsTasks/bhramp.'+str(L)+'.300' start = datetime.datetime.now() input_file = pyalps.writeInputFiles(gbasename+'.ground',[parms]) res = pyalps.runApplication('mps_optim',input_file,writexml=True) initstate = pyalps.getResultFiles(prefix=gbasename+'.ground')[0].replace('xml', 'chkp') parms['initfile'] = initstate parms['MEASURE_OVERLAP[Overlap]'] = initstate parms['always_measure'] = 'Overlap,Local density,Local density squared,One body density matrix,Density density' taus = [1e-6]#np.linspace(1e-7, 2e-7, 2)#[1e-7,1.1e-7,1.2e-7] parmslist = [] for tau in taus: parmsi = deepcopy(parms) parmsi['tau'] = tau steps = round(2*tau / dt) parmsi['TIMESTEPS'] = steps#int(2*tau / dt)
import numpy as np #prepare the input parameters parms = [{ 'LATTICE': "ladder", 'MODEL': "spin", 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'local_S': 0.5, 'J0': 1, 'J1': 1, 'L': 6 }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('ed06b', parms) res = pyalps.runApplication('fulldiag', input_file) #run the evaluation and load all the plots data = pyalps.evaluateFulldiagVersusT(pyalps.getResultFiles(prefix='ed06b'), DELTA_T=0.05, T_MIN=0.05, T_MAX=5.0) #make plot for s in pyalps.flatten(data): plt.figure() plt.title("Antiferromagnetic Heisenberg ladder") pyalps.plot.plot(s) plt.show()
# Preparing and running the simulation using Python import pyalps parms = [{ 'LATTICE': 'inhomogeneous simple cubic lattice', 'L': 120, 'MODEL': 'boson Hubbard', 'Nmax': 20, 't': 1., 'U': 8.11, 'mu': '4.05 - (0.0073752*(x-(L-1)/2.)*(x-(L-1)/2.) + 0.0036849*(y-(L-1)/2.)*(y-(L-1)/2.) + 0.0039068155*(z-(L-1)/2.)*(z-(L-1)/2.))', 'T': 1., 'THERMALIZATION': 1500, 'SWEEPS': 7000, 'SKIP': 50, 'MEASURE[Local Density]': 1 }] input_file = pyalps.writeInputFiles('parm2a', parms) res = pyalps.runApplication('dwa', input_file) # Evaluating and plotting in Python import pyalps import pyalps.plot as aplt data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm2a'), 'Local Density') aplt.plot3D(data, centeredAtOrigin=True)
parms['t'] = 0.3 parms['U'] = 1 resi = 1000 try: shutil.rmtree('SingleSite') os.mkdir('SingleSite') except: pass basename = 'SingleSite/ss.' parms['N_total'] = 14 # parms['initial_local_N'] = '3,2,2,2,2,2,2,2,2,2'#'1,1,1,1,1,1,1,1,0,0'#'2,2,1,1,1,1,1,1,1,1' input_file = pyalps.writeInputFiles(basename + str(resi), [parms]) pyalps.runApplication('mps_optim', input_file, writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename)) for d in data: for s in d: if(s.props['observable'] == 'Energy'): print s.y[0] if(s.props['observable'] == 'Local density'): print s.y[0] iters = pyalps.loadIterationMeasurements(pyalps.getResultFiles(prefix=basename), what=['Energy']) # print iters en_vs_iter = pyalps.collectXY(iters, x='iteration', y='Energy') # print en_vs_iter
#prepare the input parameters parms = [ { 'LATTICE' : "open chain lattice", 'MODEL' : "spin", 'CONSERVED_QUANTUMNUMBERS' : 'N,Sz', 'Sz_total' : 0, 'J' : 1, 'SWEEPS' : 4, 'NUMBER_EIGENVALUES' : 1, 'L' : 32, 'MAXSTATES' : 100 } ] #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm_spin_one_half',parms) res = pyalps.runApplication('dmrg',input_file,writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix='parm_spin_one_half')) # print properties of the eigenvector: for s in data[0]: print(s.props['observable'], ' : ', s.y[0]) # load and plot iteration history iter = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm_spin_one_half'), what=['Iteration Energy','Iteration Truncation Error']) plt.figure() pyalps.plot.plot(iter[0][0]) plt.title('Iteration history of ground state energy (S=1/2)')
for i in range(L): parms["U" + str(i) + "[Time]"] = ",".join([mathematica(UW(W)[i]) for W in quench(W_i, W_f, xi, tf, dt)]) parmslist = [parms] # for tau in taus: # parmsi = deepcopy(parms) # parmsi['tau'] = tau # parmsi['TIMESTEPS'] = int(2*tau / dt) # for i in range(L-1): # parmsi['t'+str(i)+'[Time]'] = ','.join([mathematica(JW(W)[i]) for W in quench(W_i, W_f, xi, 2*tau, dt)]) # for i in range(L): # parmsi['U'+str(i)+'[Time]'] = ','.join([mathematica(UW(W)[i]) for W in quench(W_i, W_f, xi, 2*tau, dt)]) # parmslist.append(parmsi) input_file = pyalps.writeInputFiles(basename + ".dynamic", parmslist) res = pyalps.runApplication("mps_evolve", input_file, writexml=True) end = datetime.datetime.now() ## simulation results data = pyalps.loadIterationMeasurements( pyalps.getResultFiles(prefix=basename + ".dynamic"), what=["Energy", "Local density", "Local density squared", "One body density matrix", "Density density"], ) coords = [] for d1 in data: for s1 in d1: for d in s1: for s in d: if s.props["observable"] == "One body density matrix":
temp = "temp" try: os.mkdir(temp) except: pass try: os.mkdir(os.path.join(temp, timestamp)) except: pass input_file = pyalps.writeInputFiles(os.path.join(os.getcwd(), temp, timestamp), parms) #run the simulation res = pyalps.runApplication('fulldiag',input_file, writexml=True) print res #load all measurements for all states # data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix='parm1a')) result_name = 'nx{nx}_ny{ny}_J{J}_J1{J1}_f{f}'.format(nx=Nx, ny=Ny, J=J, f=dilution, J1=J1) data = pyalps.evaluateFulldiagVersusT(pyalps.getResultFiles(prefix=str(timestamp)),DELTA_T=args.Ts, T_MIN=args.Ti, T_MAX=args.Tf) # print 'data = ', data d_xml = data2xml.DataToXML(data=data, ed=True) results = 'results' try: os.mkdir(results) except:
parms.append({ 'LATTICE': "ladder", 'MODEL': "spin", 'local_S': 0.5, 'T': 0.08, 'J0': 1, 'J1': 1, 'THERMALIZATION': 1000, 'SWEEPS': 10000, 'L': 20, 'h': h }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm3b', parms) res = pyalps.runApplication('dirloop_sse', input_file, Tmin=5) #load the magnetization and collect it as function of field h data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm3b'), 'Magnetization Density') magnetization = pyalps.collectXY(data, x='h', y='Magnetization Density') #make plot plt.figure() pyalps.plot.plot(magnetization) plt.xlabel('Field $h$') plt.ylabel('Magnetization $m$') plt.ylim(0.0, 0.5) plt.title('Quantum Heisenberg ladder') plt.show()
parms = [] for t in [1.5, 2, 2.5]: parms.append({ 'LATTICE': "square lattice", 'T': t, 'J': 1, 'THERMALIZATION': 1000, 'SWEEPS': 100000, 'UPDATE': "cluster", 'MODEL': "Ising", 'L': 8 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm1', parms) pyalps.runApplication('spinmc', input_file, Tmin=5, writexml=True) #get the list of result files result_files = pyalps.getResultFiles(prefix='parm1') print("Loading results from the files: ", result_files) #print the observables stored in those files: print("The files contain the following mesurements:", end=' ') print(pyalps.loadObservableList(result_files)) #load a selection of measurements: data = pyalps.loadMeasurements(result_files, ['|Magnetization|', 'Magnetization^2']) #make a plot for the magnetization: collect Magnetziation as function of T plotdata = pyalps.collectXY(data, 'T', '|Magnetization|')
2.35 ]: parms.append({ 'LATTICE': "square lattice", 'T': t, 'J': 1, 'THERMALIZATION': 5000, 'SWEEPS': 150000, 'UPDATE': "cluster", 'MODEL': "Ising", 'L': l }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm7b', parms) pyalps.runApplication('spinmc', input_file, Tmin=5) # use the following instead if you have MPI #pyalps.runApplication('spinmc',input_file,Tmin=5,MPI=4) pyalps.evaluateSpinMC(pyalps.getResultFiles(prefix='parm7b')) #load the susceptibility and collect it as function of temperature T # data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm7b'),['|Magnetization|', 'Connected Susceptibility', 'Specific Heat', 'Binder Cumulant', 'Binder Cumulant U2']) # magnetization_abs = pyalps.collectXY(data,x='T',y='|Magnetization|',foreach=['L']) # connected_susc = pyalps.collectXY(data,x='T',y='Connected Susceptibility',foreach=['L']) # spec_heat = pyalps.collectXY(data,x='T',y='Specific Heat',foreach=['L']) # binder_u4 = pyalps.collectXY(data,x='T',y='Binder Cumulant',foreach=['L']) # binder_u2 = pyalps.collectXY(data,x='T',y='Binder Cumulant U2',foreach=['L']) # # #make a plot of the Binder cumulant: # plt.figure()
for t in [1.5,2,2.5]: parms.append( { 'LATTICE' : "square lattice", 'T' : t, 'J' : 1 , 'THERMALIZATION' : 1000, 'SWEEPS' : 100000, 'UPDATE' : "cluster", 'MODEL' : "Ising", 'L' : 8 } ) input_file = pyalps.writeInputFiles('parm1',parms) desc = pyalps.runApplication('spinmc',input_file,Tmin=5,writexml=True) result_files = pyalps.getResultFiles(prefix='parm1') print result_files print pyalps.loadObservableList(result_files) data = pyalps.loadMeasurements(result_files,['|Magnetization|','Magnetization^2']) print data plotdata = pyalps.collectXY(data,'T','|Magnetization|') plt.figure() pyalps.plot.plot(plotdata) plt.xlim(0,3) plt.ylim(0,1) plt.title('Ising model') plt.show() print pyalps.plot.convertToText(plotdata) print pyalps.plot.makeGracePlot(plotdata)
#prepare the input parameters parms = [{ 'LATTICE': "chain lattice", 'MODEL': "spin", 'local_S': 1, 'J': 1, 'L': 4, 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'MEASURE_STRUCTURE_FACTOR[Structure Factor S]': 'Sz', 'MEASURE_CORRELATIONS[Diagonal spin correlations]=': 'Sz', 'MEASURE_CORRELATIONS[Offdiagonal spin correlations]': 'Splus:Sminus' }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('ed01a', parms) res = pyalps.runApplication('sparsediag', input_file) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix='ed01a')) # print properties of ground states in all sectors: for sector in data[0]: print '\nSector with Sz =', sector[0].props['Sz'], print 'and k =', sector[0].props['TOTAL_MOMENTUM'] for s in sector: if pyalps.size(s.y[0]) == 1: print s.props['observable'], ' : ', s.y[0] else: for (x, y) in zip(s.x, s.y[0]): print s.props['observable'], '(', x, ') : ', y
import matplotlib.pyplot as plt import pyalps.plot #prepare the input parameters parms = [{ 'LATTICE': "chain lattice", 'MODEL': "spin", 'local_S': 0.5, 'L': 40, 'J': -1, 'CUTOFF': 1000 }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm6a', parms) res = pyalps.runApplication('qwl', input_file) #run the evaluation and load all the plots data = pyalps.evaluateQWL(pyalps.getResultFiles(prefix='parm6a'), DELTA_T=0.1, T_MIN=0.1, T_MAX=10.0) #make plot for s in pyalps.flatten(data): plt.figure() plt.title("Ferromagnetic Heisenberg chain") pyalps.plot.plot(s) plt.show()
'LATTICE': "square lattice", 'MODEL': "boson Hubbard", 'T': 0.05, 'L': l, 't': t, 'U': 1.0, 'mu': 0.5, 'NONLOCAL': 0, 'Nmax': 2, 'THERMALIZATION': 15000, 'SWEEPS': 600000 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('mc05b', parms) res = pyalps.runApplication('worm', input_file, Tmin=5) #load the magnetization and collect it as function of field h data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='mc05b'), 'Stiffness') rhos = pyalps.collectXY(data, x='t', y='Stiffness', foreach=['L']) # multiply with the system size for the scaling plot for s in rhos: s.y = s.y * float(s.props['L']) #make plot plt.figure() pyalps.plot.plot(rhos) plt.xlabel('Hopping $t/U$') plt.ylabel('$\
'J' : J, 'J1' : J1, 'THERMALIZATION': 5000, 'SWEEPS' : 50000, 'ALGORITHM' : "loop", # 'MEASURE[Winding Number]': 1, # 'MEASURE_CORRELATIONS[Diagonal spin correlations]':"Sz", } ) #write the input file and run the simulation input_file = pyalps.writeInputFiles(os.path.join(os.getcwd(), temp, timestamp, lattice_name), parms) pyalps.runApplication('loop', input_file, writexml=True) data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix=lattice_name)) results = 'results' try: os.mkdir(results) except: pass file_name = os.path.join(results, lattice_name + "_beta_{beta}_Nx_{Nx}_Ny_{Ny}_J_{J}_J1_{J1}.xml".format(beta=beta, Nx=Nx, Ny=Ny, J=J, J1=J1))
'LATTICE': "square lattice", 'MODEL': "boson Hubbard", 'T': 0.1, 'L': L, 't': t, 'mu': 0.5, 'U': 1.0, 'Nmax': 2, 'THERMALIZATION': 100000, 'SWEEPS': 2000000, 'SKIP': 500, 'MEASURE[Winding Number]': 1 }) input_file = pyalps.writeInputFiles('parm1b', parms) res = pyalps.runApplication('dwa', input_file, Tmin=5, writexml=True) # Evaluating the simulation and preparing plots using Python import pyalps import matplotlib.pyplot as plt import pyalps.plot as aplt data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm1b'), 'Stiffness') rhos = pyalps.collectXY(data, x='t', y='Stiffness', foreach=['L']) for rho in rhos: rho.y = rho.y * float(rho.props['L']) plt.figure() aplt.plot(rhos)
parms = [] parms.append( { 'LATTICE' : "open ladder", 'L' : 10, 'MODEL_LIBRARY' : "mymodels.xml", 'MODEL' : "fermion Hubbard", 'CONSERVED_QUANTUMNUMBERS' : 'Nup,Ndown', 'Nup_total' : 10, 'Ndown_total' : 10, 't0' : "1+0.6*I", 'ct0' : "1-0.6*I", 't1' : 0.1, 'U' : 0., 'SWEEPS' : 6, 'MAXSTATES' : 400, 'COMPLEX' : 1, } ) #write the input file and run the simulation input_file = pyalps.writeInputFiles(basename,parms) res = pyalps.runApplication('mps_optim',input_file,writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename), ['Energy']) en_exact = -28.1129977 print('Exact energy for MAXSTATES=inf ::', en_exact) for d in pyalps.flatten(data): print(d.props['observable'], '=', d.y)