def check_value_scalar(self, string, should_be, significance=8, debug=False): import pyalps val=pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y[0].mean err=pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y[0].error if debug: print('\n') print(string+': '+str(val)+' +- '+str(err)+'\t'+str(abs(should_be-val)/max([err,1e-6]))) print('\n') self.assertLess(abs(should_be-val)/max([err,1e-6]),significance)
def clean(args): resfiles = pyalps.getResultFiles(prefix = args.infile) for resf in resfiles: os.remove(resf) infiles = [f for f in os.listdir(os.getcwd()) if re.match('{}.*in.*'.format(args.infile), f)] for inf in infiles: os.remove(inf)
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 read_results_from_file(path, prefix, X, Y, ForEach=None): """ Input ------------------ path: path to result files prefix: prefix filenames (ending out.h5), if ending with a dot (.), only one simulation is assumed else the separate simulation are identified and merged. X : string, name of parameter Y : string, name of observable returns ----------------- pyalps X-Y-props list """ if prefix[-1]=='.': dataset= pyalps.loadMeasurements(pyalps.getResultFiles(dirname=path,prefix=prefix),Y) if ForEach==None: return pyalps.collectXY(dataset, x=X, y=Y) else: return pyalps.collectXY(dataset, x=X, y=Y, foreach=[ForEach]) else: raise ValueError("Not yet implemented for multiple runs.")
def ReadResults(path, prefix, X, Y): """ Input ------------------ path: path to result files prefix: prefix filenames (ending out.h5), if ending with a dot (.), only one simulation is assumed else the separate simulation are identified and merged. X : string, name of parameter Y : string, name of observable returns ----------------- pyalps X-Y-props list """ if prefix[-1]=='.': dataset= pyalps.loadMeasurements(pyalps.getResultFiles(dirname=path,prefix=filename),args.Y) return pyalps.collectXY(dataset, x=X, y=Y, foreach=['IncNo']) else: all_prefixes=[] for f in os.listdir(path): if fnmatch.fnmatch(f, prefix+'*.out.h5'): before_first_dot=f.split('.')[0]+'.' if before_first_dot not in all_prefixes: all_prefixes.append(before_first_dot) datasetsXY = [] for pre in all_prefixes: tmp_dset= pyalps.loadMeasurements(pyalps.getResultFiles(dirname=path,prefix=pre),args.Y) datasetsXY.append( pyalps.collectXY(tmp_dset, x=X, y=Y, foreach=['IncNo']) ) for i,dxy in enumerate(datasetsXY[0]): #Take the 1st dataset as reference rIncNo = dxy.props['IncNo'] for dslist in datasetsXY[1:]: for dxy2nd in dslist: if rIncNo == dxy2nd.props['IncNo']: datasetsXY[0][i] = pyalps.mergeDataSets([datasetsXY[0][i], dxy2nd]) return datasetsXY[0]
def analyze(args): print 'running analysis' runs = pyalps.getResultFiles(prefix = args.infile) chi_data = get_chi(runs) T = chi_data['T'] chi = [c.mean for c in chi_data['chi']] chi_err = [c.error for c in chi_data['chi']] plt.figure() plt.errorbar(T, chi, yerr = chi_err) yl = plt.ylim() plt.vlines(1. / 0.693035, yl[0], yl[1]) plt.ylim(yl) xl =(min(T), max(T)) plt.xlim(xl) plt.xlabel(r'Temperature $T$') plt.ylabel(r'Magnetic Susceptibility $\chi$') plt.savefig('{}.plot_chi.pdf'.format(args.infile)) idx = [1, len(runs)/3, -2] T = np.array([p['T'] for p in pyalps.loadProperties(runs)]) runsorted = np.array(zip(T, runs), dtype=[('T', 'f8'), ('run', object)]) runsorted.sort(order = 'T') corr_data, T = get_corr([runsorted[i]['run'] for i in idx]) plt.figure() for i in range(len(corr_data)): temp = T[i] corr = corr_data[i] x = corr['dist'] y = [i.mean for i in corr['corr']] ye = [i.error for i in corr['corr']] plt.errorbar(x, y, yerr = ye, label = 'T = {}'.format(temp)) plt.ylim((-0.01, 1.01)) plt.xlabel(r'Distance $r$ in Lattice Units') plt.ylabel(r'Pair Correlation Function $g(r)$') plt.legend() plt.savefig('{}.plot_corr.pdf'.format(args.infile))
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)
def main(): Ws = np.linspace(7.9e10, 1.1e12, 17)#[1e11]#[7.9e10]#np.linspace(2e11,3.2e11,10)#[2e10] nW = len(Ws) # Ns = [L]#range(0,2*L+1)#range(30,86)#[L]#range(0,2*L+1)#range(40,70)#range(0,2*L+1)#range(24,2*L+1)#range(0,2*L+1)#range(23,27) # nN = len(Ns) sigmas = [0,2,5,10]#range(0, 11) nsigma = len(sigmas) Wsigmas = zip(range(nW*nsigma), [[i, j] for i in range(nW) for j in range(nsigma)], [[Wi, sigmai] for Wi in Ws for sigmai in sigmas]) ntasks = len(Wsigmas) start = datetime.datetime.now() pbar = progressbar.ProgressBar(widgets=['Res: '+str(resi)+' ', progressbar.Percentage(), ' ', progressbar.Bar(), ' ', progressbar.Timer()], maxval=ntasks).start() with concurrent.futures.ProcessPoolExecutor(max_workers=numthreads) as executor: futures = [executor.submit(runmps, task, iW, isigma, Wi, sigma) for (task, [iW, isigma], [Wi, sigma]) in Wsigmas] for future in pbar(concurrent.futures.as_completed(futures)): future.result() sys.stderr.flush() end = datetime.datetime.now() #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename)) Es = makeres(nW, nsigma) ns = makeres(nW, nsigma) n2s = makeres(nW, nsigma) corrs = makeres(nW, nsigma) ncorrs = makeres(nW, nsigma) entropy = makeres(nW, nsigma) es = makeres(nW, nsigma) for d in data: for sigma in d: iW = int(sigma.props['iW']) isigma = int(sigma.props['is']) if(sigma.props['observable'] == 'Energy'): Es[iW][isigma] = sigma.y[0] if(sigma.props['observable'] == 'Local density'): ns[iW][isigma] = sigma.y[0] if(sigma.props['observable'] == 'Local density squared'): n2s[iW][isigma] = sigma.y[0] if(sigma.props['observable'] == 'One body density matrix'): corrs[iW][isigma] = sparse.coo_matrix((sigma.y[0], (sigma.x[:,0], sigma.x[:,1]))).toarray() if(sigma.props['observable'] == 'Density density'): ncorrs[iW][isigma] = sparse.coo_matrix((sigma.y[0], (sigma.x[:,0], sigma.x[:,1]))).toarray() if(sigma.props['observable'] == 'Entropy'): entropy[iW][isigma] = sigma.y[0] if(sigma.props['observable'] == 'Entanglement Spectra'): es[iW][isigma] = [[sigma for sigma in reversed(sorted(esi[1]))][0:4] for esi in sigma.y[0]] resultsfile = open(resdir + resifile(resi), 'w') resultsstr = '' resultsstr += 'seed['+str(resi)+']='+str(seed)+';\n' resultsstr += 'L['+str(resi)+']='+str(L)+';\n' resultsstr += 'nmax['+str(resi)+']='+str(nmax)+';\n' resultsstr += 'sweeps['+str(resi)+']='+str(sweeps)+';\n' resultsstr += 'maxstates['+str(resi)+']='+str(maxstates)+';\n' resultsstr += 'Ws['+str(resi)+']='+mathematica(Ws)+';\n' resultsstr += 'ts['+str(resi)+']='+mathematica([JWi(Wi) for Wi in Ws])+';\n' resultsstr += 'Us['+str(resi)+']='+mathematica([UW(Wi) for Wi in Ws])+';\n' resultsstr += 'sigmas['+str(resi)+']='+mathematica(sigmas)+';\n' resultsstr += 'Eres['+str(resi)+']='+mathematica(Es)+';\n' resultsstr += 'nres['+str(resi)+']='+mathematica(ns)+';\n' resultsstr += 'n2res['+str(resi)+']='+mathematica(n2s)+';\n' resultsstr += 'corrres['+str(resi)+']='+mathematica(corrs)+';\n' resultsstr += 'ncorrres['+str(resi)+']='+mathematica(ncorrs)+';\n' resultsstr += 'entropy['+str(resi)+']='+mathematica(entropy)+';\n' resultsstr += 'es['+str(resi)+']='+mathematica(es)+';\n' resultsstr += 'runtime['+str(resi)+']="'+str(end-start)+'";\n' resultsfile.write(resultsstr)
def runTest(testinputfile, outputs='auto', compMethod='auto', pyexec='auto'): """ Run the test according to testinputfile and compare its output against reference files inputs are: ----------- script: a script to be run testinputfile: file containing reference info outputs: - default is 'auto' -> assume file names are identical with reference files list of script outputs - glob pattern - explicit list of files ( order has to be the same as in the .testin.xml file ) compMethod: - default is 'auto' -> try to detect comparison Method to be used (e.g. Monte Carlo or epsilon precise data) """ tstart = strftime("%Y-%b-%d %H:%M:%S", gmtime()) testinputfile = os.path.expandvars(testinputfile) props, inputs, refFileList, whatlist = read_testprop_xml(testinputfile) script = props['SCRIPT'] tmpdir = tempfile.mkdtemp() # execute given script in tmpdir pardir = os.getcwd() shutil.copy(script, tmpdir) if inputs is not None: for f in inputs: shutil.copy(f, tmpdir) # get python executable if pyexec == 'auto': pyexec = sys.executable os.chdir(tmpdir) cmdline = [pyexec, os.path.basename(script)] pyalps.executeCommand(cmdline) if inputs is not None: for f in inputs: os.remove(f) os.chdir(pardir) # copy stylesheet pyalps.tools.copyStylesheet(pardir) # Guess outputs from reference files if outputs == 'auto': outputs = [ os.path.join(tmpdir, os.path.basename(x)) for x in refFileList ] elif type(outputs) == str: print("Using glob '%s' to find outputs" % outputs) outputs = pyalps.getResultFiles( pattern=os.path.basename(outputs), \ dirname=os.path.dirname(outputs) ) if not outputs: print("\nList of output files of %s is empty\n" % script) test_success = False else: missing = [x for x in outputs if not os.path.exists(x)] if missing: for f in missing: print("Output file '%s' does not exist" % f) test_success = False else: # Start test test_success = compareTest(testinputfile, outputs, tmpdir, tstart, compMethod=compMethod) # if something goes wrong above, tmpdir will not be removed # for the moment this is useful, later maybe use try/except shutil.rmtree(tmpdir) return test_success
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()
# Plot binning analysis from all runs of the C++ program pimc in the current directory. import numpy as np import matplotlib.pyplot as plt import pyalps import pyalps.plot import pyalps.load runfiles = pyalps.getResultFiles(prefix='*.run') loader = pyalps.load.Hdf5Loader() ebinning = pyalps.flatten(loader.ReadBinningAnalysis(runfiles,measurements=['Energy'],respath='/simulation/realizations/0/clones/0/results')) tbinning = pyalps.flatten(loader.ReadBinningAnalysis(runfiles,measurements=['KineticEnergy'],respath='/simulation/realizations/0/clones/0/results')) vbinning = pyalps.flatten(loader.ReadBinningAnalysis(runfiles,measurements=['PotentialEnergy'],respath='/simulation/realizations/0/clones/0/results')) for o in (ebinning,tbinning,vbinning): for d in o: d.props['label'] = str(d.props['SWEEPS'])+' sweeps' plt.figure() plt.title(o[0].props['observable']) plt.xlabel('binning level') plt.ylabel('error estimate') pyalps.plot.plot(o) plt.legend() plt.show()
'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]
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] # print mathematica([JW(W)[0] for W in quench(W_i, W_f, xi, tf, dt)]) # print mathematica([UW(W)[0] for W in quench(W_i, W_f, xi, tf, dt)]) # quit() 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'): coords = (s.x[:,0], s.x[:,1]) XY = pyalps.collectXY(data, x='Time', y='Energy', foreach=['tau']) E = [[[(x + 1)*dt, y] for (x, y) in zip(xy.x, xy.y)] for xy in XY][0] XY = pyalps.collectXY(data, x='Time', y='Local density', foreach=['tau']) n = [[[(x + 1)*dt, y] for (x, y) in zip(xy.x, xy.y)] for xy in XY][0]
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: pass file_name = os.path.join(results, lattice_name + "Ti{Ti}_Tf{Tf}_Ts{Ts}_Nx_{Nx}_Ny_{Ny}_J_{J}_J1_{J1}.xml".format(Ti=Ti, Ts=Ts, Tf=Tf, Nx=Nx, Ny=Ny, J=J, J1=J1)) d_xml.tofile(file_name)
'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)) d_xml = data2xml.DataToXML(data=data, looper=True, lattice=LATTICE_LIBRARY)
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 Es = np.array([Ei for (i, Ei) in sorted(zip([int(xi) for xi in en_vs_iter[0].x[0:-1:20]], en_vs_iter[0].y[0:-1:20]))[-40:-1]]) Es2 = Es[1:-1] - Es[0:-2] print Es2
if rIncNo == dxy2nd.props['IncNo']: datasetsXY[0][i] = pyalps.mergeDataSets([datasetsXY[0][i], dxy2nd]) return datasetsXY[0] path=os.path.dirname(args.infile) filename=os.path.basename(args.infile) if args.verbose: print path, filename if args.verbose: print args.X, args.Y print pyalps.getResultFiles(prefix=args.infile) #print dataset renyi_dataG = ReadResults(path, filename, args.X, args.Y) n=args.N if args.verbose: print renyi_dataG if args.outfile!=None: outfile=open(args.outfile,'w') factor={} factor['ising2D']=2
import pyalps fileheader = 'heisenberg' data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=fileheader),'Energy') #print data,len(data) J_En = pyalps.collectXY(data, x='J', y='Energy') print data for x, y in zip(J_En[0].x, J_En[0].y): print x, y
# DEALINGS IN THE SOFTWARE. # # **************************************************************************** import pyalps import numpy as np import matplotlib.pyplot as plt import pyalps.plot ## Please run the tutorial5a.py before this one listobs = ['0', '2'] # we look at convergence of a single flavor (=0) ## load all results data = pyalps.loadDMFTIterations(pyalps.getResultFiles(pattern='parm_u_*.h5'), measurements=listobs, verbose=True) ## create a figure for each BETA grouped = pyalps.groupSets(pyalps.flatten(data), ['U', 'observable']) for sim in grouped: common_props = pyalps.dict_intersect([ d.props for d in sim ]) ## rescale x-axis and set label for d in sim: d.x = d.x * d.props['BETA']/float(d.props['N']) d.y *= -1. d.props['label'] = 'it'+d.props['iteration'] ## plot all iterations for this BETA plt.figure() plt.xlabel(r'$\tau$')
def check_data_length(self,string,should_be, output=False): import pyalps l=len(pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y) self.assertEqual(l,should_be)
'TAUS' : [20.0], 'POWS' : [0.0], 'GS' : ['H'], 'GIS' : [0.0], 'GFS' : [0.0], 'NUMSTEPS' : [500], 'STEPSFORSTORE' : [5], 'SIMID': count }) baseName='tutorial_2d' nmlnameList=pyalps.writeTEBDfiles(parms, baseName) res=pyalps.runTEBD(nmlnameList) #Get magnetization data Magdata=pyalps.load.loadTimeEvolution( pyalps.getResultFiles(prefix='tutorial_2d'), measurements=['Local Magnetization']) #Compute the integrated magnetization across the center for q in Magdata: syssize=q[0].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*(syssize/2) #\Delta M-=<S_n^z(t)> from n=L/2 to L q[0].y=[0.5*(syssize/2)+sum(q[0].y[syssize/2:syssize])] #Plot the integrated magnetization Mag=pyalps.collectXY(Magdata, x='Time', y='Local Magnetization', foreach=['Jz']) plt.figure()
def check_has_observable(self,string, output=False): import pyalps self.assertGreater(len(pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0]), 0)
def main(): Ws = np.linspace(2e11,3.2e11,10)#[2e10] nW = len(Ws) Ns = range(0,2*L+1)#range(23,27) nN = len(Ns) WNs = zip(range(nW*nN), [[i, j] for i in range(nW) for j in range(nN)], [[Wi, Ni] for Wi in Ws for Ni in Ns]) ntasks = len(WNs) start = datetime.datetime.now() pbar = progressbar.ProgressBar(widgets=['Res: '+str(resi)+' ', progressbar.Percentage(), ' ', progressbar.Bar(), ' ', progressbar.Timer()], maxval=ntasks).start() with concurrent.futures.ProcessPoolExecutor(max_workers=numthreads) as executor: futures = [executor.submit(runmps, task, iW, iN, Wi, N) for (task, [iW, iN], [Wi, N]) in WNs] for future in pbar(concurrent.futures.as_completed(futures)): future.result() end = datetime.datetime.now() #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename)) solved = makeres(nW, nN) Es = makeres(nW, nN) ns = makeres(nW, nN) n2s = makeres(nW, nN) corrs = makeres(nW, nN) ncorrs = makeres(nW, nN) for d in data: for s in d: iW = int(s.props['iW']) iN = int(s.props['iN']) solved[iW][iN] = s.props['solved'] if(s.props['observable'] == 'Energy'): Es[iW][iN] = s.y[0] if(s.props['observable'] == 'Local density'): ns[iW][iN] = s.y[0] if(s.props['observable'] == 'Local density squared'): n2s[iW][iN] = s.y[0] if(s.props['observable'] == 'One body density matrix'): corrs[iW][iN] = sparse.coo_matrix((s.y[0], (s.x[:,0], s.x[:,1]))).toarray() if(s.props['observable'] == 'Density density'): ncorrs[iW][iN] = sparse.coo_matrix((s.y[0], (s.x[:,0], s.x[:,1]))).toarray() resultsfile = open(resdir + resifile(resi), 'w') resultsstr = '' resultsstr += 'seed['+str(resi)+']='+str(seed)+';\n' resultsstr += 'L['+str(resi)+']='+str(L)+';\n' resultsstr += 'nmax['+str(resi)+']='+str(nmax)+';\n' resultsstr += 'sweeps['+str(resi)+']='+str(sweeps)+';\n' resultsstr += 'maxstates['+str(resi)+']='+str(maxstates)+';\n' resultsstr += 'periodic['+str(resi)+']='+str(periodic)+';\n' resultsstr += 'twisted['+str(resi)+']='+str(twist)+';\n' resultsstr += 'xi['+str(resi)+']='+mathematica(xi)+';\n' resultsstr += 'Ws['+str(resi)+']='+mathematica(Ws)+';\n' resultsstr += 'ts['+str(resi)+']='+mathematica([JWi(Wi) for Wi in Ws])+';\n' resultsstr += 'Us['+str(resi)+']='+mathematica([UW(Wi) for Wi in Ws])+';\n' resultsstr += 'Ns['+str(resi)+']='+mathematica(Ns)+';\n' resultsstr += 'solved['+str(resi)+']='+mathematica(solved)+';\n' resultsstr += 'Eres['+str(resi)+']='+mathematica(Es)+';\n' resultsstr += 'nres['+str(resi)+']='+mathematica(ns)+';\n' resultsstr += 'n2res['+str(resi)+']='+mathematica(n2s)+';\n' resultsstr += 'corrres['+str(resi)+']='+mathematica(corrs)+';\n' resultsstr += 'ncorrres['+str(resi)+']='+mathematica(ncorrs)+';\n' resultsstr += 'runtime['+str(resi)+']="'+str(end-start)+'";\n' resultsfile.write(resultsstr)
def main(): ts = [0.01]#[0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01]#[1e-10,1e-9,1e-8,1e-7,1e-6,1e-5,1e-4,1e-3,1e-2,1e-1]#[0.01,0.01,0.01,0.01,0.01,0.01,0.01,0.01]#[0.01,0.1]#np.linspace(0.01, 0.05, 5).tolist() nt = len(ts) Us = [1]*nt Ns = range(0, 2*L+1)#range(23,27)#range(25,2*L+1)#[35,36,37]#[32]*12#range(32,40)#range(38, 46)#[40,41,42,43]#range(25, 2*L+1)#range(51,70)#[66,66,66,66,66,66,66,66,66]#[66,67,68]#[66,67,68,69,70]#range(0, 2*L+1) nN = len(Ns) tUNs = zip(range(nt*nN), [[i, j] for i in range(nt) for j in range(nN)], [[Ui, ti, Ni] for (Ui, ti) in zip(Us, ts) for Ni in Ns]) ntasks = len(tUNs) start = datetime.datetime.now() pbar = progressbar.ProgressBar(widgets=[progressbar.Percentage(), ' ', progressbar.Bar(), ' ', progressbar.Timer()], maxval=ntasks).start() # with concurrent.futures.ThreadPoolExecutor(max_workers=numthreads) as executor: with concurrent.futures.ProcessPoolExecutor(max_workers=numthreads) as executor: futures = [executor.submit(runmps, task, it, iN, Ui, ti, N) for (task, [it, iN], [Ui, ti, N]) in tUNs] for future in pbar(concurrent.futures.as_completed(futures)): future.result() end = datetime.datetime.now() #load all measurements for all states data = pyalps.loadEigenstateMeasurements(pyalps.getResultFiles(prefix=basename)) solved = makeres(nt, nN) Es = makeres(nt, nN) ns = makeres(nt, nN) n2s = makeres(nt, nN) corrs = makeres(nt, nN) ncorrs = makeres(nt, nN) for d in data: for s in d: it = int(s.props['it']) iN = int(s.props['iN']) solved[it][iN] = s.props['solved'] if(s.props['observable'] == 'Energy'): Es[it][iN] = s.y[0] if(s.props['observable'] == 'Local density'): ns[it][iN] = s.y[0] if(s.props['observable'] == 'Local density squared'): n2s[it][iN] = s.y[0] if(s.props['observable'] == 'One body density matrix'): corrs[it][iN] = sparse.coo_matrix((s.y[0], (s.x[:,0], s.x[:,1]))).toarray() if(s.props['observable'] == 'Density density'): ncorrs[it][iN] = sparse.coo_matrix((s.y[0], (s.x[:,0], s.x[:,1]))).toarray() resultsfile = open(resdir + 'res.'+str(resi)+'.txt', 'w') resultsstr = '' resultsstr += 'seed['+str(resi)+']='+str(seed)+';\n' resultsstr += 'L['+str(resi)+']='+str(L)+';\n' resultsstr += 'nmax['+str(resi)+']='+str(nmax)+';\n' resultsstr += 'sweeps['+str(resi)+']='+str(sweeps)+';\n' resultsstr += 'maxstates['+str(resi)+']='+str(maxstates)+';\n' resultsstr += 'periodic['+str(resi)+']='+str(periodic)+';\n' resultsstr += 'twisted['+str(resi)+']='+str(twist)+';\n' resultsstr += 'xi['+str(resi)+']='+mathematica(xi)+';\n' resultsstr += 'ts['+str(resi)+']='+mathematica(ts)+';\n' resultsstr += 'Us['+str(resi)+']='+mathematica(Us)+';\n' resultsstr += 'Ns['+str(resi)+']='+mathematica(Ns)+';\n' resultsstr += 'solved['+str(resi)+']='+mathematica(solved)+';\n' resultsstr += 'Eres['+str(resi)+']='+mathematica(Es)+';\n' resultsstr += 'nres['+str(resi)+']='+mathematica(ns)+';\n' resultsstr += 'n2res['+str(resi)+']='+mathematica(n2s)+';\n' resultsstr += 'corrres['+str(resi)+']='+mathematica(corrs)+';\n' resultsstr += 'ncorrres['+str(resi)+']='+mathematica(ncorrs)+';\n' resultsstr += 'runtime['+str(resi)+']="'+str(end-start)+'";\n' resultsfile.write(resultsstr) print 'Res: ' + str(resi)
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']) for d in Mag: d.x = (d.x + 1) * d.props['DT']
def check_value_vector(self, string, index, should_be, significance=8): import pyalps val=pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y.mean[index] err=pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y.error[index] self.assertLess(abs(should_be-val)/max(err,1e-6),significance)
'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 plt.figure() pyalps.plot.plot(stiffness) plt.xlabel(r'$J2$')
def check_no_double_values(self,string, output=False): import pyalps from numpy import diff, sort val=pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),[string])[0][0].y if len(val)>1: self.assertGreater(min(diff(sort(abs(val)))),1e-10)
'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|') plt.figure() pyalps.plot.plot(plotdata) plt.xlim(0, 3)
parms.append({ 'LATTICE': "chain lattice", 'MODEL': "spin", 'local_S': 0.5, 'J': 1, 'L': l, 'CONSERVED_QUANTUMNUMBERS': 'Sz', 'Sz_total': sz }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm2b', parms) res = pyalps.runApplication('sparsediag', input_file) #load all measurements for all states data = pyalps.loadSpectra(pyalps.getResultFiles(prefix='parm2b')) lengths = [] min_energies = {} # extract the ground state energies over all momenta for every simulation for sim in data: l = int(sim[0].props['L']) if l not in lengths: lengths.append(l) sz = int(sim[0].props['Sz_total']) all_energies = [] for sec in sim: all_energies += list(sec.y) min_energies[(l, sz)] = np.min(all_energies) # make a plot of the triplet gap as function of system size
'SYMMETRIZATION': 0, 'U': 3, 't': 0.707106781186547, 'SWEEPS': int(10000 * b / 16.), 'THERMALIZATION': 1000, 'BETA': b }) #write the input file and run the simulation for p in parms: input_file = pyalps.writeParameterFile('parm_beta_' + str(p['BETA']), p) res = pyalps.runDMFT(input_file) listobs = ['0', '1'] data = pyalps.loadMeasurements(pyalps.getResultFiles(pattern='parm_beta_*h5'), respath='/simulation/results/G_tau', what=listobs) for d in pyalps.flatten(data): d.x = d.x * d.props["BETA"] / float(d.props["N"]) d.props['label'] = r'$\beta=$' + str(d.props['BETA']) + '; flavor=' + str( d.props['observable'][len(d.props['observable']) - 1]) plt.figure() plt.xlabel(r'$\tau$') plt.ylabel(r'$G_{flavor}(\tau)$') plt.title( 'DMFT-02: Neel transition for the Hubbard model on the Bethe lattice\n(using the Hybridization expansion impurity solver)' ) pyalps.plot.plot(data) plt.legend()
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()
val = 'SEED' elif val in ['Sweep', 'Sweeps']: val = 'SWEEPS' elif val in ['Thermalization']: val = 'THERMALIZATION' else: val = in_val.replace('_', ' ') return(val) try: if args.debug: cmd.write(str(args)) #define x-value and y-value read_file = pyalps.getResultFiles(prefix=args.prefix) x_val = conv_val(args.x) y_val = conv_val(args.y) val_list = pyalps.loadObservableList(read_file) val_list = list(set(list(chain.from_iterable(val_list)))) no_error_val = ['T', 'h', 'L', 'N', 'local_S', 'THERMALIZATION', 'SEED', 'SWEEPS'] val_list = val_list + no_error_val if args.debug: cmd.write('\nval_list is ' + str(val_list) + '\n') cmd.write('no_error_val is ' + str(no_error_val) + '\n') cmd.write('x_val is ' + x_val + '\n') cmd.write('y_val is ' + y_val + '\n')
import sys, os import numpy as np import matplotlib.pyplot as plt import pyalps from pyalps.plot import plot files = pyalps.getResultFiles(dirname='data') data = pyalps.loadMeasurements(files , ['|m|','m^2', 'Connected Susceptibility', 'Binder Cumulant U2']) for d in pyalps.flatten(data): d.props['M/L'] = d.props['M'] / d.props['L'] m = pyalps.collectXY(data, 'Jx', '|m|', foreach=['L', 'M']) chi = pyalps.collectXY(data, 'Jx', 'Connected Susceptibility', foreach=['L', 'M']) binder = pyalps.collectXY(data, 'Jx', 'Binder Cumulant U2', foreach=['L', 'M']) for d in pyalps.flatten(m): d.x = np.exp(2.*d.props['Jy'])*d.x plt.figure() plot(m) plt.xlabel('$J/\\Gamma$') plt.ylabel('magnetization') plt.legend(loc='best', frameon=False) for d in pyalps.flatten(chi): d.x = np.exp(2.*d.props['Jy'])*d.x plt.figure() plot(chi)
'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('parm8c', parms) pyalps.runApplication('loop', input_file) data = pyalps.loadMeasurements( pyalps.getResultFiles(pattern='parm8c.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 plt.figure() pyalps.plot.plot(stiffness) plt.xlabel(r'$J2$')
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]
name.append(['Energy_normalized','energynormalized']) name.append(['Specific Heat','specheat']) name.append(['Specific Heat Conventional','specheatconv']) name.append(['Specific Heat by FT','specheatft']) name.append(['Magnetic Susceptibility connected','magsuscon']) name.append(['Magnetic Susceptibility connected for Scaling','magsusconsca']) name.append(['Magnetic Susceptibility disconnected','magsusdis']) name.append(['Magnetic Susceptibility disconnected for Scaling','magsusdissca']) name.append(['Binder Ratio of Magnetization connected','bindercon']) name.append(['Binder Ratio of Magnetization disconnected','binderdis']) name.append(['Binder Ratio of Magnetization 1 connected','binder1con']) name.append(['Binder Ratio of Magnetization 1 disconnected','binder1dis']) name.append(['Specific Heat connected','specheatcon']) for i in range(0,len(name)): data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='LRSW_params'),name[i][0]) for item in pyalps.flatten(data): item.props['L'] = int(item.props['L']) graph = pyalps.collectXY(data,x='T',y=name[i][0],foreach=['L']) graph.sort(key=lambda item: item.props['L']) f1 = open(name[i][1]+'.plt','w') f1.write(pyalps.plot.makeGnuplotPlot(graph)) f1.close() f2 = open(name[i][1]+'.dat','w') for j in graph: L=j.props['L'] for k in range(0,len(j.x)): f2.write(str(L)+' '+str(j.x[k])+' '+str(j.y[k].mean)+' '+str(j.y[k].error)+'\n') f2.close() print 'finished to output ' + name[i][1] + '.plt and ' + name[i][1] + '.dat'
'THERMALIZATION' : 50000, 'SWEEPS' : 15000, 'UPDATE' : "ssf", 'cutoff_distance': 3.0, 'L' : l, 'structure_factor': True, 'Targeted Acceptance Ratio': 0.4, 'Each_Measurement': 15 } ) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm',parms) if RUN_SIMULATION: pyalps.runApplication('mc++',input_file,Tmin=5,MPI=1) if ANALYZE: data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm'),['|Structure Factor|^2']) def Get_0k_range(L): return range(0,L*L,L) def Get_k0_range(L): return range(0,L,1) def Get_kk_range(L): return range(0,L*L,L+1) def Get_0k_data(data,L): return data.flatten()[Get_0k_range(L)] def Get_k0_data(data,L): return data.flatten()[Get_k0_range(L)] def Get_kk_data(data,L): return data.flatten()[Get_kk_range(L)] data = pyalps.collectXY(data,x='T',y='|Structure Factor|^2')[0]
L = 4 # Linear lattice size N = 5000 # of simulation steps print '# L:', L, 'N:', N # Scan beta range [0,1] in steps of 0.1 for beta in [0., .1, .2, .3, .4, .5, .6, .7, .8, .9, 1.]: for l in [4, 6, 8]: print '-----------' print 'beta =', beta sim = Simulation(beta, l) sim.run(N / 2, N) sim.save('ising.L_' + str(l) + 'beta_' + str(beta) + '.h5') #how to calculate the Binder Ratio within Python: infiles = pyalps.getResultFiles(pattern='ising.L') data = pyalps.loadMeasurements(pyalps.getResultFiles(pattern='ising.L*'), ['E', 'm^2', 'm^4']) m2 = pyalps.collectXY(data, x='BETA', y='m^2', foreach=['L']) m4 = pyalps.collectXY(data, x='BETA', y='m^4', foreach=['L']) u = [] for i in range(len(m2)): d = pyalps.DataSet() d.propsylabel = 'U4' d.props = m2[i].props d.x = m2[i].x d.y = m4[i].y / m2[i].y / m2[i].y u.append(d)
# 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": coords = (s.x[:, 0], s.x[:, 1]) XY = pyalps.collectXY(data, x="Time", y="Energy", foreach=["tau"]) E = [[[(x + 1) * dt, y] for (x, y) in zip(xy.x, xy.y)] for xy in XY][0] # XY = pyalps.collectXY(data, x='Time', y='Overlap', foreach=['tau'])
'J' : 1 , 'THERMALIZATION' : 1000, 'SWEEPS' : 40000, 'UPDATE' : "cluster", 'MODEL' : "Ising", 'L' : l } ) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm7a',parms) pyalps.runApplication('spinmc',input_file,Tmin=5) # use the following instead if you have MPI #pyalps.runApplication('spinmc',input_file,Tmin=5,MPI=2) pyalps.evaluateSpinMC(pyalps.getResultFiles(prefix='parm7a')) #load the susceptibility and collect it as function of temperature T data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm7a'),['|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 plots plt.figure() pyalps.plot.plot(magnetization_abs) plt.xlabel('Temperature $T$') plt.ylabel('Magnetization $|m|$') plt.title('2D Ising model')
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) resultsfile = open('/home/ubuntu/Dropbox/Amazon EC2/Simulation Results/ALPS-MPS/Results/'+basename.split('/')[-1]+'.txt', 'w') resultsstr = '{'+str(L)+',{'+','.join(["{:d}".format(int(N)) for N in Ns]) + '},{' + ','.join(["{:.20f}".format(en) for en in energies]) + '}}' print(resultsstr) resultsfile.write(resultsstr)
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 Tc_max=2.5 le0=2 le_min=1. le_max=10 lo0=3.66802 lo_min=1 lo_max=15 alpha0=f_alpha(le0,lo0,d=2) beta0 =f_beta(le0,lo0,d=2) gamma0=f_gamma(le0,lo0,d=2) nu0 =f_nu(le0,lo0,d=2)
p['tau' ] = tau # not used in the simulation, but useful in the evaluation below p['ALWAYS_MEASURE'] = 'Local Magnetization' p['chkp_each' ] = ns 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']) numeric_magnetization = [] for d in pyalps.flatten(data): L = d.props['L'] for loc in [1,2]: q = deepcopy(d) q.x = [0] q.y = np.array([ q.y[0][L/2-loc] ]) q.props['loc'] = loc numeric_magnetization.append(q) mag_vs_time = pyalps.collectXY(numeric_magnetization, x='Time', y='Local Magnetization', foreach=['loc']) for d in mag_vs_time: d.x = (d.x + 1.) * d.props['dt'] # convert time index to real time d.props['label'] = 'Numerical at n='+str(d.props['loc'])
return x_values, y_values, y_errors parser = argparse.ArgumentParser(description='Evaluate Renyi entropies for range of L', epilog='(C) Johannes Helmes 2014') parser.add_argument('--infile','-i', help='Prefix of result files',required=True) parser.add_argument('--foreach','-f',default='h',help='Parameter name, (default h)') parser.add_argument('--steps','-s',nargs=2,type=int,help='Number of increment steps to complete U and O, (default=1/2 1)') parser.add_argument('--plot','-p',action='store_true') parser.add_argument('--verbose','-v',action='store_true') args=parser.parse_args() REntropy={} data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix=args.infile),['EG']) if args.verbose: print data renyi_dataG = pyalps.collectXY(data, x='IncNo', y='EG', foreach=[args.foreach]) if args.verbose: print renyi_dataG if (args.steps!=None): IncNosIItoU=range(args.steps[0]) IncNosUtoO=range(args.steps[0],args.steps[1]) #IncNos = [%.1f % i for i in range(args.IncNoRange[0], args.IncNoRange[1])] print IncNosIItoU, IncNosUtoO
#prepare the input parameters parms = [{ 'LATTICE': "square lattice", 'MODEL': "spin", 'MEASURE[Correlations]': True, 'MEASURE[Structure Factor]': True, 'MEASURE[Green Function]': True, 'local_S': 0.5, 'T': 0.3, 'J': 1, 'THERMALIZATION': 10000, 'SWEEPS': 500000, 'L': 4, 'h': 0.1 }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm4', 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()) # print all measurements for s in pyalps.flatten(data): if len(s.x) == 1: print(s.props['observable'], ' : ', s.y[0]) else: for (x, y) in zip(s.x, s.y): print(s.props['observable'], x, ' : ', y)
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT # SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE # FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # # **************************************************************************** import pyalps import numpy as np import matplotlib.pyplot as plt import pyalps.plot data = pyalps.loadSpectra(pyalps.getResultFiles(prefix='ed02a')) data += pyalps.loadSpectra(pyalps.getResultFiles(prefix='ed02b')) lengths = [] min_energies = {} # extract the ground state energies over all momenta for every simulation for sim in data: l = int(sim[0].props['L']) if l not in lengths: lengths.append(l) sz = int(sim[0].props['Sz_total']) s = float(sim[0].props['local_S']) all_energies = [] for sec in sim: all_energies += list(sec.y) min_energies[(l, s, sz)] = np.min(all_energies)
} ) input_file = pyalps.writeInputFiles('parm1',parms) # The queue is loaded from a configuration file which should either be located in the execution directory or in ~/.batchq/configuration q = load_queue(LSFBSub, "brutus") desc = runApplicationBackground('spinmc',input_file,Tmin=5,writexml=True, queue = q, force_resubmit = False ) if not desc.finished(): print "Your simulations has not yet ended, please run this command again later." else: if desc.failed(): print "Your submission has failed" sys.exit(-1) 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) print pyalps.plot.makeGnuplotPlot(plotdata) binder = pyalps.DataSet()
'THERMALIZATION' : 500, 'U' : u, 'J' : j, 't0' : 0.5, 't1' : 1 } ) # For more precise calculations we propose to enhance the SWEEPS #write the input file and run the simulation for p in parms: input_file = pyalps.writeParameterFile('parm_u_'+str(p['U'])+'_j_'+str(p['J']),p) res = pyalps.runDMFT(input_file) listobs = ['0', '2'] # flavor 0 is SYMMETRIZED with 1, flavor 2 is SYMMETRIZED with 3 data = pyalps.loadMeasurements(pyalps.getResultFiles(pattern='parm_u_*h5'), respath='/simulation/results/G_tau', what=listobs, verbose=True) for d in pyalps.flatten(data): d.x = d.x*d.props["BETA"]/float(d.props["N"]) d.y = -d.y d.props['label'] = r'$U=$'+str(d.props['U'])+'; flavor='+str(d.props['observable'][len(d.props['observable'])-1]) plt.figure() plt.yscale('log') plt.xlabel(r'$\tau$') plt.ylabel(r'$G_{flavor}(\tau)$') plt.title('DMFT-05: Orbitally Selective Mott Transition on the Bethe lattice') pyalps.plot.plot(data) plt.legend() plt.show()
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) parmsi['DT'] = 2*tau / steps parmsi['measure_each'] = steps#int(2*tau / dt)
'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() # pyalps.plot.plot(binder_u4) # plt.xlabel('Temperature $T$') # plt.ylabel('Binder Cumulant U4 $g$') # plt.title('2D Ising model')
def runmain(pipe): # ts = np.linspace(0.05, 0.3, 15).tolist() ts = np.linspace(5e10, 2.5e11, 5).tolist() ts = [ts[0]] # ti = int(sys.argv[4]) # if ti >= 0: # ts = [ts[ti]] # ts = [11e10] # ts = [2.5e11] # ts = [8e10] # ts = [np.linspace(0.01, 0.3, 10).tolist()[2]] # ts = [0.3] # ts = np.linspace(0.3, 0.3, 1).tolist() [speckle(t) for t in ts] Ns = range(1, 2 * L + 1, 1) Ns = range(30, 101, 1) Ns = range(50, 80, 1) # Ns = [70] # Ns = range(2*L-5,2*L+1,1) # Ns = [1] # Ns = range(1,15,1) # Ns = range(1,16,1) # Ns = range(1, L, 1) # Ns = range(L+1, 2*L+1, 1) # Ns = [ 16 ] # Ns = range(3,17,1) # Ns = range(1, 16, 1) # Ns = range(1,7,1) # Ns = [7] # Ns = [1,2,3,4,5,6] # Ns = [1] # Ns = range(7,13,1) # Ns = range(1,13,1) # Ns = [6,7,8,9] # Ns = range(1, L+1, 1) # Ns = range(L+1,2*L+1,1) # Ns = [L+1,L+2] # Ns = [L+1] # Do L+2 at some point dims = [len(ts), len(Ns), neigen] ndims = dims + [L] Cdims = dims + [L, L] trunc = np.zeros(dims) E0res = np.zeros(dims) nres = np.zeros(ndims) n2res = np.zeros(ndims) Cres = np.zeros(Cdims) cres = np.zeros(Cdims) trunc.fill(np.NaN) E0res.fill(np.NaN) nres.fill(np.NaN) n2res.fill(np.NaN) Cres.fill(np.NaN) cres.fill(np.NaN) mindims = [len(ts), len(Ns)] nmindims = mindims + [L] Cmindims = mindims + [L, L] truncmin = np.zeros(mindims) E0minres = np.zeros(mindims) nminres = np.zeros(nmindims) n2minres = np.zeros(nmindims) Cminres = np.zeros(Cmindims) cminres = np.zeros(Cmindims) truncmin.fill(np.NaN) E0minres.fill(np.NaN) nminres.fill(np.NaN) n2minres.fill(np.NaN) Cminres.fill(np.NaN) cminres.fill(np.NaN) # E0res = [[[np.NaN for i in range(reps)] for j in range(len(Ns))] for k in range(len(ts))] # E0res = [[[] for j in range(len(Ns))] for k in range(len(ts))] start = datetime.datetime.now() with concurrent.futures.ThreadPoolExecutor( max_workers=numthreads) as executor: futures = [ executor.submit(rundmrg, i, tN[0][0], tN[0][1], tN[1][0], tN[1][1]) for i, tN in enumerate( zip(itertools.product(ts, Ns), itertools.product(range(0, len(ts)), range(0, len(Ns))))) ] pickle.dump(len(futures), pipe) for future in concurrent.futures.as_completed(futures): future.result() pickle.dump(1, pipe) ip = np.zeros([len(ts), len(Ns)]) res = '' res += 'Wres[{0}]={1};\n'.format(resi, mathformat([speckle(Wi) for Wi in ts])) res += 'Jres[{0}]={1};\n'.format( resi, mathformat([JW(speckle(Wi)) for Wi in ts])) res += 'Ures[{0}]={1};\n'.format( resi, mathformat([UW(speckle(Wi)) for Wi in ts])) res += 'Wmres[{0}]={1};\n'.format(resi, mathformat([Wi for Wi in ts])) res += 'Jmres[{0}]={1};\n'.format( resi, mathformat([JW(np.array([Wi, Wi]))[0] for Wi in ts])) res += 'Umres[{0}]={1};\n'.format( resi, mathformat([UW(np.array([Wi]))[0] for Wi in ts])) res += 'neigen[{0}]={1};\n'.format(resi, neigen) res += 'delta[{0}]={1};\n'.format(resi, delta) res += 'trunc[{0}]={1};\n'.format(resi, mathformat(trunc)) res += 'Lres[{0}]={1};\n'.format(resi, L) res += 'sweeps[{0}]={1};\n'.format(resi, sweeps) res += 'maxstates[{0}]={1};\n'.format(resi, maxstates) res += 'warmup[{0}]={1};\n'.format(resi, warmup) res += 'truncerror[{0}]={1};\n'.format(resi, truncerror) res += 'nmax[{0}]={1};\n'.format(resi, nmax) res += 'Nres[{0}]={1};\n'.format(resi, mathformat(Ns)) res += 'tres[{0}]={1};\n'.format(resi, mathformat(ts)) res += 'mures[{0}]={1};\n'.format(resi, mathformat(mu)) data = pyalps.loadEigenstateMeasurements( pyalps.getResultFiles(prefix=filenameprefix)) for d in data: try: it = int(d[0].props['it']) iN = int(d[0].props['iN']) # ip = int(d[0].props['ip']) for s in d: for case in switch(s.props['observable']): if case('Truncation error'): # trunc[it][iN][ip] = s.y[0] # trunc[it][iN] = s.y break if case('Energy'): for i, sy in enumerate(s.y): E0res[it][iN][i] = sy # E0res[it][iN][ip] = s.y[0] # E0res[it][iN] = s.y # for sy in s.y break if case('Local density'): for i, sy in enumerate(make2d(s.y)): nres[it][iN][i] = sy # nres[it][iN][ip] = s.y[0] # nres[it][iN] = s.y break if case('Local density squared'): for i, sy in enumerate(make2d(s.y)): n2res[it][iN][i] = sy # n2res[it][iN][ip] = s.y[0] # n2res[it][iN] = s.y break if case('Onebody density matrix'): for i, sy in enumerate(s.y): for x, y in zip(s.x, sy): Cres[it][iN][i][tuple(x)] = y # for x, y in zip(s.x, s.y[0]): # Cres[it][iN][ip][tuple(x)] = y # for x, y in zip(s.x, s.y[0]): # Cres[it][iN][tuple(x)] = y # for ieig, sy in enumerate(s.y): # for x, y in zip(s.x, sy): # Cres[it][iN][ieig][tuple(x)] = y break for i in range(neigen): Cres[it][iN][i][range(L), range(L)] = nres[it][iN][i] cres[it][iN][i] = Cres[it][iN][i] / np.sqrt( np.outer(nres[it][iN][i], nres[it][iN][i])) # for ieig in range(neigen): # Cres[it][iN][ieig][range(L), range(L)] = nres[it][iN][ieig] # cres[it][iN][ieig] = Cres[it][iN][ieig] / np.sqrt(np.outer(nres[it][iN][ieig], nres[it][iN][ieig])) # except Exception as e: except BufferError as e: print(e.message) # for it in range(len(ts)): # for iN in range(len(Ns)): # try: # m = min(E0res[it][iN]) # ieig = np.where(E0res[it][iN] == m)[0][0] # truncmin[it][iN] = trunc[it][iN][ieig] # E0minres[it][iN] = E0res[it][iN][ieig] # nminres[it][iN] = nres[it][iN][ieig] # n2minres[it][iN] = n2res[it][iN][ieig] # Cminres[it][iN] = Cres[it][iN][ieig] # cminres[it][iN] = cres[it][iN][ieig] # except Exception as e: # print(e.message) end = datetime.datetime.now() res += 'E0res[{0}]={1};\n'.format(resi, mathformat(E0res)) res += 'nres[{0}]={1};\n'.format(resi, mathformat(nres)) res += 'n2res[{0}]={1};\n'.format(resi, mathformat(n2res)) res += 'Cres[{0}]={1};\n'.format(resi, mathformat(Cres)) res += 'cres[{0}]={1};\n'.format(resi, mathformat(cres)) # res += 'truncmin[{0}]={1};\n'.format(resi, mathformat(truncmin)) # res += 'E0minres[{0}]={1};\n'.format(resi, mathformat(E0minres)) # res += 'nminres[{0}]={1};\n'.format(resi, mathformat(nminres)) # res += 'n2minres[{0}]={1};\n'.format(resi, mathformat(n2minres)) # res += 'Cminres[{0}]={1};\n'.format(resi, mathformat(Cminres)) # res += 'cminres[{0}]={1};\n'.format(resi, mathformat(cminres)) res += 'runtime[{0}]=\"{1}\";\n'.format(resi, end - start) resf.write(res) resf.flush() os.fsync(resf.fileno()) if sys.platform == 'linux2': shutil.copy( resfile, '/home/ubuntu/Dropbox/Amazon EC2/Simulation Results/BH-MPS')
#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
'LATTICE': "square lattice", 'T': 2.269186, 'J': 1, 'THERMALIZATION': 1000, 'SWEEPS': 100000, 'UPDATE': "cluster", 'MODEL': "Ising", 'L': l }) #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm1b', parms) pyalps.runApplication('spinmc', input_file, Tmin=5) #load the binning analysis for the absolute value of the magnetization binning = pyalps.loadBinningAnalysis(pyalps.getResultFiles(prefix='parm1b'), '|Magnetization|') binning = pyalps.flatten(binning) #make one plot with all data for dataset in binning: dataset.props['label'] = 'L=' + str(dataset.props['L']) plt.figure() plt.title('Binning analysis for cluster updates') plt.xlabel('binning level') plt.ylabel('Error of |Magnetization|') pyalps.plot.plot(binning) plt.legend() plt.show()
meas_list = [ 'Energy', 'Truncation error', 'One-body Correlation UP', 'One-body Correlation DO', 'Two-body Correlation UP', 'Two-body Correlation DO', 'nUP', 'nDO', 'One-body Correlation UPDO', 'Two-body Correlation UPDO' ] for j in indx_list: fname = '{}'.format(j) try: #Load all measurements on ground state data = pyalps.loadEigenstateMeasurements( pyalps.getResultFiles(prefix=fname), what=meas_list) #Save eigenstate properties as a dictionary prop = data[0][0].props Nmax, L = prop['NMax'], prop['L'] #Extrach properties E0 = data[0][0].y[0] trunc = data[0][1].y[0] obUP = data[0][2].y[0] obDO = data[0][3].y[0] tbUP = data[0][4].y[0] tbDO = data[0][5].y[0] nUP = data[0][6].y[0] nDO = data[0][7].y[0] obUPDO = data[0][8].y[0]
import pyalps import matplotlib.pyplot as plt import pyalps.plot #prepare the input parameters parms = [{ 'LATTICE' : "double dimer", 'LATTICE_LIBRARY' : "dd-graph.xml", 'MODEL' : "dimerized spin", 'MODEL_LIBRARY' : "model-dspin.xml", 'CONSERVED_QUANTUMNUMBERS' : 'Sz', 'local_S0' : 1, 'local_S1' : 0.5, 'J0' : 1, 'J1' : 0.4 }] #write the input file and run the simulation input_file = pyalps.writeInputFiles('parm2c',parms) res = pyalps.runApplication('fulldiag',input_file) #run the evaluation and load all the plots data = pyalps.evaluateFulldiagVersusH(pyalps.getResultFiles(prefix='parm2c'),T = 0.02, DELTA_H=0.025, H_MIN=0., H_MAX=4.0) #make plot for s in pyalps.flatten(data): plt.figure() pyalps.plot.plot(s) plt.show()
def createTest(script, inputs=None, outputs=None, prefix=None, refdir='./ref'): """ Create reference data, .testin.xml file and execute_test.py inputs are: ----------- script: computes results to be tested inputs: Optional list of input files if the application(s) called in 'script' rely on them and the input files are in the same directory as 'script'. If you specified relative paths to another directory, it won't work. outputs or prefix: outputs of script can either be specified with a complete list of output files or as a prefix creates a script called apptest_name_of_script.py, which can be used to execute the test """ if outputs is not None and prefix is not None: raise Exception("Cannot both define outputs and prefix") elif outputs is None and prefix is None: raise Exception("Script output has to be specified") script = os.path.expandvars(script) scriptdir = os.path.dirname(script) if not os.path.exists(refdir): recursive_mkdir(refdir) # Copy input files to refdir to allow execution of script there if inputs is not None: for f in inputs: if not os.path.expandvars(os.path.dirname(f)) == scriptdir: print( "Input files to %s should be in the same directory as %s" % (script, script)) sys.exit(1) shutil.copy(f, refdir) # execute given script in refdir ( creates reference data ) pardir = os.getcwd() os.chdir(refdir) cmdline = [sys.executable, os.path.join(pardir, script)] pyalps.executeCommand(cmdline) if inputs is not None: for f in inputs: os.remove(f) os.chdir(pardir) if prefix is None: reffiles = [os.path.join(refdir, os.path.basename(f)) for f in outputs] else: reffiles = pyalps.getResultFiles(prefix=prefix, dirname=refdir) if not reffiles: print( "Reference files not found. (If you use 'loop' or 'dmrg', try to delete old result files.)" ) sys.exit(1) # acquire a list of all observables allobs = [] try: eigenstatedata = pyalps.loadEigenstateMeasurements(reffiles) except RuntimeError: pass else: try: allobs += [o.props['observable'] for o in eigenstatedata[0][0]] # DMRG eigenstate data has one level of nesting less except TypeError: allobs += [o.props['observable'] for o in eigenstatedata[0]] try: mcdata = pyalps.loadMeasurements(reffiles) except RuntimeError: pass else: allobs += [o.props['observable'] for o in mcdata[0]] allobs = list(set(allobs)) scriptname = os.path.basename(script) scriptname = os.path.splitext(scriptname)[0] scriptname_prefixed = 'apptest_%s.py' % scriptname # Write .xml test-input file refparms = { "TESTNAME": scriptname, "TOLERANCE": "auto", "WRITE_RESULTS_TO_FILE": "yes", "SAVE_OUT_IF_FAIL": "yes" } testinputfile = writeTestInputFile(script, inputs, refparms, reffiles, allobs) pyalps.tools.copyStylesheet(pardir) # Write .py test-start script f = open(scriptname_prefixed, 'w') f.write('#!/usr/bin/env python\n\n') f.write('import sys\n') f.write('from pyalps import apptest\n') f.write( '# Explicitly specify "compMethod=..." and "outputs=..." if needed\n') f.write( "ret = apptest.runTest( '%s', outputs='auto', compMethod='auto', pyexec='auto' )\n" % testinputfile) f.write('if not ret: sys.exit(1)\n') f.close() os.chmod(scriptname_prefixed, 0o755)
import pyalps import matplotlib.pyplot as plt import pyalps.plot data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='params'),(['Value'])) value = pyalps.collectXY(data,x='T', y='Value') plt.figure() pyalps.plot.plot(value) plt.xlabel('T') plt.ylabel('Value') plt.title('Test Plot') plt.show()
'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) plt.xlabel('Hopping $t/U$') plt.ylabel('$\\rho _sL$') plt.legend() plt.title('Scaling plot for Bose-Hubbard model') plt.show()
for i in range(L-1): parms['t'+str(i)] = mathematica(JW(W_i*xi)[i])#','.join([mathematica(JW(W_i))]) # parms['t'+str(i)+'[Time]'] = ','.join([mathematica(JW(W)) for W in quench(W_i, W_f, numsteps, tf / numsteps)]) for i in range(L): parms['U'+str(i)] = mathematica(UW(W_i*xi)[i])#','.join([mathematica(UW(W_i))]) # parms['U'+str(i)+'[Time]'] = ','.join([mathematica(UW(W)) for W in quench(W_i, W_f, numsteps, tf / numsteps)]) resi = 9 basename = 'DynamicsTasks/bhramp.'+str(L)+'.'+str(resi) start = datetime.datetime.now() input_file = pyalps.writeInputFiles(basename+'.ground',[parms]) res = pyalps.runApplication('mps_optim',input_file,writexml=True) initstate = pyalps.getResultFiles(prefix=basename+'.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' parms['measure_each'] = numsteps taus = 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 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)])