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 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 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 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 call(self,parm, output=False): import pyalps import subprocess input_file = pyalps.writeInputFiles('parm',parm) if not output: return subprocess.call('mc++ parm.in.xml', stdout=self.oblivion, stderr=subprocess.STDOUT, shell=True) else: return subprocess.call('mc++ parm.in.xml', shell=True)
def compute(self): of = self.interpreter.filePool.create_file() os.unlink(of.name) os.mkdir(of.name) dir = basic.Directory dir.name = of.name o = self.interpreter.filePool.create_file() if self.hasInputFromPort('simulationid'): base_name = self.getInputFromPort('simulationid') else: base_name = os.path.basename(o.name) print(base_name) ofile = basic.File() ofile.name = os.path.join(dir.name, base_name + '.in.xml') if self.hasInputFromPort('parms'): input_values = self.forceGetInputListFromPort('parms') l = [] for p in input_values: if isinstance(p, list): l += p else: l += [p] if self.hasInputFromPort('baseseed'): baseseed = self.getInputFromPort('baseseed') else: baseseed = pyalps.generateSeed() Module.annotate(self, {'baseseed': baseseed}) pyalps.writeInputFiles(os.path.join(dir.name, base_name), l, baseseed) pyalps.copyStylesheet(dir.name) self.setResult("output_dir", dir) self.setResult("output_file", ofile)
def gen_sitediff_lattice(paras): """Generate site different lattice `GRAPH` for given `LATTICE`. :paras: dict Parameters dict contain `LATTICE` and its parameters. :returns: TODO """ paras_ = dict(paras) # get a copy. basename = '.for_get_graph' input_xml = pyalps.writeInputFiles(basename, [paras_]) graph = _get_graph(input_xml) new_graph = _set_sitediff(graph) new_lattice_lib = _gen_new_lattice_lib(new_graph, paras_) paras['LATTICE_LIBRARY'] = new_lattice_lib os.system('rm -rf ' + basename + '*') return paras
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)
parms['te_order'] = 'second' 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)
#prepare the input parameters parms = [] for l in [6, 8, 10]: parms.append({ 'LATTICE': "ladder", 'MODEL': "spin", 'local_S': 0.5, 'J0': 1, 'J1': 1, 'L': l, 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'Sz_total': 0 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm_ladder', parms) res = pyalps.runApplication('sparsediag', input_file) #load all measurements for all states data = pyalps.loadSpectra(pyalps.getResultFiles(prefix='parm_ladder')) # collect spectra over all momenta for every simulation spectra = {} for sim in data: l = int(sim[0].props['L']) all_energies = [] spectrum = pyalps.DataSet() for sec in sim: all_energies += list(sec.y) spectrum.x = np.concatenate( (spectrum.x,
parms['U'+str(i)] = U[i] parms['N_total'] = 1 basename = 'Tasks/bhstestts3' # basename = 'Tasks/bhq1' parmslist = [] for N in range(L+1, 2*L+1): parmsi = deepcopy(parms) parmsi['N_total'] = N parmslist.append(parmsi) #write the input file and run the simulation input_file = pyalps.writeInputFiles(basename,parmslist) res = pyalps.runApplication('mps_optim',input_file,writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename)) results = [] for d in data: for s in d: if(s.props['observable'] == 'Energy'): results += [(s.props['N_total'], s.y[0])] Ns = [res[0] for res in sorted(results)] energies = [res[1] for res in sorted(results)] # print(energies)
## common model parameters model = OrderedDict() model['LATTICE'] = 'open chain lattice' model['L'] = 10 model['MODEL'] = 'hardcore boson' model['CONSERVED_QUANTUMNUMBERS'] = 'N' model['N_total'] = 5 model['t'] = 1. model['MAXSTATES'] = 40 ## ground state simulation for ground state ground_parms = deepcopy(model) ground_parms['V'] = 10. ground_parms['SWEEPS'] = 4 input_file = pyalps.writeInputFiles(basename + '.ground', [ground_parms]) res = pyalps.runApplication('mps_optim', input_file) initstate = pyalps.getResultFiles(prefix=basename + '.ground')[0].replace( 'xml', 'chkp') def quench(g_i, g_f, steps, dt, p=1): t = (1. + np.arange(steps)) * dt return g_i + (t / t[-1])**p * (g_f - g_i) def list_to_string(ll): return ','.join([str(li) for li in ll])
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 = [] # Change system sizes here, if desired for L in [10, 12]: parms.append({ 'LATTICE': "chain lattice", 'MODEL': "spin", 'local_S': 0.5, 'Jxy': 0, 'Jz': -1, 'Gamma': 0.5, 'NUMBER_EIGENVALUES': 5, 'L': L }) prefix = 'ed04a' input_file = pyalps.writeInputFiles(prefix, parms) # res = pyalps.runApplication('sparsediag', input_file, MPI=2, mpirun='mpirun') res = pyalps.runApplication('sparsediag', input_file) data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=prefix)) # To perform CFT assignments, we need to calculate the ground state # and the first excited state for each L. # The output of the above load operation will be a hierarchical list sorted # by L, so we can just iterate through it E0 = {} E1 = {} for Lsets in data: L = pyalps.flatten(Lsets)[0].props['L'] # Make a big list of all energy values allE = [] for q in pyalps.flatten(Lsets):
import pyalps import numpy as np params = [] MCS = 65536 for L in [16, 24, 32]: for T in np.linspace(1.1, 1.15, 51): params.append({ 'ALGORITHM' : 'cluster', 'MODEL' : 'Potts' 'q' : 2, 'LATTICE' : 'square lattice', 'L' : L, 'T' : T, 'J' : 1.0, 'SWEEPS' : MCS, 'THERMALIZATION' : MCS >> 3, }) pyalps.writeInputFiles('params', params)
#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
f = list() g = list() i = list() e4 = list() e5 = list() e6 = list() file_name1 = 'e4-' + str(num) file_name2 = 'e5-' + str(num) file_name3 = 'e6-' + str(num) #e4 parms[0]['Nup_total'] = Nup parms[0]['Ndown_total'] = 0 input_file = pyalps.writeInputFiles(file_name1, parms) res = pyalps.runApplication('dmrg', input_file, writexml=True) data = pyalps.loadEigenstateMeasurements( pyalps.getResultFiles(prefix=file_name1)) for s in data[0]: f.append(s.y[0]) for m in range(0, len(f), 2): e4.append(f[m]) print(f) # e5 parms[0]['Nup_total'] = Nup + 1 parms[0]['Ndown_total'] = 1
import pyalps.plot #prepare the input parameters parms= [] for m in [20,40,60]: parms.append({ 'LATTICE_LIBRARY' : 'my_lattices.xml', 'LATTICE' : 'open chain lattice with special edges 32', 'MODEL' : 'spin', 'local_S0' : '0.5', 'local_S1' : '1', 'CONSERVED_QUANTUMNUMBERS' : 'N,Sz', 'Sz_total' : 0, 'J' : 1, 'SWEEPS' : 4, 'NUMBER_EIGENVALUES' : 1, 'MAXSTATES' : m }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm_spin_one_multiple',parms) res = pyalps.runApplication('mps_optim',input_file,writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix='parm_spin_one_multiple')) # print properties of the eigenvector for each run: for run in data: for s in run: print(s.props['observable'], ' : ', s.y[0])
parms['N_total'] = L parms['init_state'] = 'local_quantumnumbers' parms['initial_local_N'] = ','.join(['1']*L) parms['te_order'] = 'second' parms['update_each'] = 1 for i in range(L-1): parms['t'+str(i)+'[Time]'] = ','.join([mathematica(JW(W)) for W in quench(7.9e10, 1.1e12, numsteps, tf / numsteps)]) for i in range(L): parms['U'+str(i)+'[Time]'] = ','.join([mathematica(UW(W)) for W in quench(7.9e10, 1.1e12, numsteps, tf / numsteps)]) resi = 32 basename = 'DynamicsTasks/bhd.'+str(L)+'.'+str(resi) start = datetime.datetime.now() input_file = pyalps.writeInputFiles(basename,[parms]) res = pyalps.runApplication('mps_evolve',input_file,writexml=True) end = datetime.datetime.now() data = pyalps.loadIterationMeasurements(pyalps.getResultFiles(prefix=basename), what=['Local density', 'Local density squared', 'One body density matrix', 'Density density']) # print data[0][0][0] # quit() t = [] nt = [] n2t = [] corrt = [] ncorrt = [] for d1 in data: for s1 in d1:
'MEASURE_ENERGY' : True, }] #write the input file and run the simulation 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'
#prepare the input parameters parms = [] for l in [10, 12, 14, 16]: parms.append({ 'LATTICE': "chain lattice", 'MODEL': "spin", 'local_S': 0.5, 'J': 1, 'L': l, 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'Sz_total': 0 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm_chain', parms) res = pyalps.runApplication('sparsediag', input_file) #load all measurements for all states data = pyalps.loadSpectra(pyalps.getResultFiles(prefix='parm_chain')) # collect spectra over all momenta for every simulation spectra = {} for sim in data: l = int(sim[0].props['L']) all_energies = [] spectrum = pyalps.DataSet() for sec in sim: all_energies += list(sec.y) spectrum.x = np.concatenate( (spectrum.x,
#prepare the input parameters parms = [] for l in [6, 8, 10]: parms.append({ 'LATTICE': "ladder", 'MODEL': "spin", 'local_S': 0.5, 'J0': 0, 'J1': 1, 'L': l, 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'Sz_total': 0 }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm_dimers', parms) res = pyalps.runApplication('sparsediag', input_file) #load all measurements for all states data = pyalps.loadSpectra(pyalps.getResultFiles(prefix='parm_dimers')) # collect spectra over all momenta for every simulation spectra = {} for sim in data: l = int(sim[0].props['L']) all_energies = [] spectrum = pyalps.DataSet() for sec in sim: all_energies += list(sec.y) spectrum.x = np.concatenate( (spectrum.x,
#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])
parms.append( { 'LATTICE' : "square lattice", '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'])
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')
p['initial_local_S'] = ','.join(['0.5'] * 50) 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
for J in Jlist: Geometry=np.genfromtxt(args.geofile+'.geo',dtype=str) if (args.half): Geometry = Geometry[:len(Geometry)/2] for i,IncEl in enumerate(Geometry): parms.append( { 'LATTICE' : "bilayer", 'LATTICE_LIBRARY' : "bilayerlib.xml", 'Interaction' : 'A', 'beta' : beta, 'THERMALIZATION': args.therm, 'SWEEPS' : args.sweeps, 'Interlayer': J, 'L' : args.length, 'M' : 100, 'IncStep': IncEl, 'IncNo' : i } ) cuts=np.append(np.arange(0,len(parms),args.partsize),len(parms)) print cuts path=os.path.dirname(args.infile) for i,[s,e] in enumerate(zip(cuts[:-1],cuts[1:])): fname=path+'/'+os.path.basename(args.infile)+'.'+str(i) input_file = pyalps.writeInputFiles(fname,parms[s:e])
parms.append({ '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$')
parms = [ { 'optimization' : 'singlesite', 'LATTICE' : 'open chain lattice', 'L' : 20, 'MODEL' : 'spin', 'local_S0' : '0.5', 'local_S1' : '1', 'CONSERVED_QUANTUMNUMBERS' : 'N,Sz', 'Sz_total' : 9, 'J' : 1, 'SWEEPS' : 4, 'NUMBER_EIGENVALUES' : 1, 'MAXSTATES' : 50, 'MEASURE_LOCAL[Spin]' : 'Sz', # 'init_state' : 'local_quantumnumbers', # 'initial_local_Sz' : ','.join(['0.5']*10+['-0.5']*1+['0.5']*9),#'0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,-0.5',#'1,0,0,0,0,0,0,0,0,0', # 'initial_local_S' : ','.join(['0.5']*20+['-0.5']*0),#'0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,-0.5',#'1,0,0,0,0,0,0,0,0,0', } ] #write the input file and run the simulation input_file = pyalps.writeInputFiles('SingleSite3/parm_spin_one',parms) res = pyalps.runApplication('mps_optim',input_file,writexml=True) #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix='SingleSite3/parm_spin_one')) # print properties of the eigenvector: for s in data[0]: print s.props['observable'], ' : ', s.y[0]
parms.append({ '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()
parms["t" + str(i) + "[Time]"] = ",".join([mathematica(JW(W)[i]) for W in quench(W_i, W_f, xi, tf, dt)]) 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: