def single_E_calc(gamma, scan, scan_dir, fwd_ic, bwd_ic): loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] savesuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega"] scan['\\gamma_s'] = str(gamma) ic_dict = {} if scan_dir == "scanforward": ic_dict = fwd_ic elif scan_dir == "scanbackward": ic_dict = bwd_ic scan['Rguess'] = str(ic_dict['Rguess0']) scan['Rupper'] = str(ic_dict['Rupper0']) scan['Rlower'] = str(ic_dict['Rlower0']) scan['etaguess'] = str(ic_dict['etaguess0']) scan['etaupper'] = str(ic_dict['etaupper0']) scan['etalower'] = str(ic_dict['etalower0']) scan['deltaguess'] = str(ic_dict['deltaguess0']) scan['deltaupper'] = str(ic_dict['deltaupper0']) scan['deltalower'] = str(ic_dict['deltalower0']) # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, scan_dir=scan_dir) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei, Ri, etai, deltai, surftwisti = run.get_all_observables('observables', str2float=True) run.concatenate_observables(["\\gamma_s"]) return Ei, Ri, etai, deltai
import numpy as np import subprocess import sys sys.path.append('../../gammak24_singlepoint/') from singlerun import SingleRun if __name__ == "__main__": run = SingleRun("data/input.dat") run.run_exe() run.mv_file('psivsr') run.mv_file('observables') run.concatenate_observables()
scan['\\gamma_s'] = gamma scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega", "\\gamma_s"] savesuf = ["K_{33}", "k_{24}", "d_0", "\\omega", "\\gamma_s"] scan_dir = "scanforward" # first, load the minimum for delta = 0 case, so you know the upper bound for # the energy minimum. scan['\\Lambda'] = '0' scan['\\omega'] = '0' rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) E0, R0, eta0, delta0, surftwist0 = run.get_all_observables( 'observables_Emin', str2float=True) scan['\\omega'] = omega scan['Rguess'] = str(R0) scan['Rupper'] = str(1.5 * R0) scan['Rlower'] = str(0.75 * R0) i = 0 while (i < len(Lambdas)): Lambda = Lambdas[i]
scan['\\gamma_s'] = gamma scan['\\omega'] = omega scan['\\Lambda'] = Lambda loadsuf = savesuf = [ "K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s" ] scan_dir = "scanforward" # first, load the minimum for delta = 0 case, so you know the upper bound for # the energy minimum. rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) strains = np.linspace(0, 0.05, num=501, endpoint=True) #if float(Lambda) > 25.0: # scan['Rguess'] = str(np.log(float(Lambda))) # scan['Rupper'] = str(float(scan['Rguess'])*1.3) # scan['Rlower'] = str(float(scan['Rguess'])*0.75) # scan['deltaguess'] = '0.815' # scan['deltalower'] = '0.81' # scan['etaguess'] = '6.4' # scan['etaupper'] = '6.45' for i, u in enumerate(strains):
if len(sys.argv) < 5: user_input = input("input string of a gamma,k24,Lambda,omega values, " "using comma as delimiter: ") gamma, k24, Lambda, omega = user_input.split(',') else: gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/full3var_psivsr") # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') run.mv_file('psivsr')
from scipy.integrate import simps, romb if __name__ == "__main__": if len(sys.argv) < 5: user_input = input("input string of a gamma,k24,Lambda,omega values, " "using comma as delimiter: ") gamma, k24, Lambda, omega = user_input.split(',') else: gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/derivatives") # run C executable. run.run_exe()
import numpy as np import subprocess import sys sys.path.append('../../modules_gammak24/') from singlerun import SingleRun from readparams import ReadParams if __name__ == "__main__": gamma, k24 = sys.argv[1], sys.argv[2] loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega", "\\gamma_s"] savesuf = ["K_{33}", "k_{24}", "d_0", "\\omega", "\\gamma_s"] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\omega'] = '0' scan['\\Lambda'] = '0' # find minimum for delta = 0 case, so you know the upper bound for # the energy minimum. rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) run.run_exe() run.mv_file('observables', newname='observables_Emin')
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda']=Lambda scan['\\omega']= omega loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"] # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,executable="../../../bin/samplecalc_testEvspsip_s") # run C executable. run.run_exe() dataname = run.mv_file('Evspsip_s') data = np.loadtxt(dataname) psip_ss = data[:,0] Es = data[:,1] dEdpsip_ss = data[:,2] # determine where the min of Es occurs i_min = np.argmin(Es) # determine where the zero of dEdpsip_ss occur (should be at the same spot
gammas = np.array([0.025,0.05,0.075,0.1,0.125,0.15,0.175],float) scan = {} scan['k_{24}'] = k24 scan['\Lambda']=Lambda scan['\omega']=omega for gamma in gammas: scan['\gamma_s'] = str(gamma) run = SingleRun("data/input.dat",scan) run.run_exe() run.mv_file('psivsr') run.mv_file('observables') Rguess,etaguess,deltaguess = run.get_xvals() scan['Rguess'] = Rguess scan['Rupper'] = str(1.5*float(Rguess)) scan['Rlower'] = str(0.75*float(Rguess)) if not np.isnan(float(etaguess)):
def single_E_calc(gamma,scan,loadsuf,savesuf,scan_dir): scan['\\gamma_s'] = str(gamma) k240 = 0.33 k24 = float(scan['k_{24}']) t = (k24-k240)/k240 if scan_dir == "scanforward": #Rguess0 = 0.045 #Rupper0 = 0.6 #Rlower0 = 0.4 Rguess0 = lower_Rguess(t) Rupper0 = Rguess0*1.1 Rlower0 = Rguess0*0.9 etaguess0 = 6.295 etalower0 = 6.29 etaupper0 = 6.3 deltaguess0 = 0.8 deltalower0 = 0.799 deltaupper0 = 0.805 else: #Rguess0 = 0.7 #Rupper0 = 0.9 #Rlower0 = 0.6 Rguess0 = upper_Rguess(t) Rupper0 = Rguess0*1.1 Rlower0 = Rguess0*0.9 etaguess0 = 6.34 etalower0 = 6.32 etaupper0 = 6.36 deltaguess0 = 0.813 deltalower0 = 0.808 deltaupper0 = 0.816 scan['Rguess'] = str(Rguess0) scan['Rupper'] = str(Rupper0) scan['Rlower'] = str(Rlower0) scan['etaguess'] = str(etaguess0) scan['etaupper'] = str(etaupper0) scan['etalower'] = str(etalower0) scan['deltaguess'] = str(deltaguess0) scan['deltaupper'] = str(deltaupper0) scan['deltalower'] = str(deltalower0) # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=savesuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,scan_dir=scan_dir) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei,Ri,etai,deltai,surftwisti = run.get_all_observables('observables',str2float=True) run.concatenate_observables(["\\gamma_s"]) return Ei,Ri
start_time = time.time() if len(sys.argv) < 5: user_input = input("input string of a gamma,k24,Lambda,omega values, " "using comma as delimiter: ") gamma, k24, Lambda, omega = user_input.split(',') else: gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/full_onerun") # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables')
gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/EvsR_s") # run C executable. run.run_exe() dataname = run.mv_file('EvsR_s') data = np.loadtxt(dataname) R_ss = data[:, 0] Es = data[:, 1] dEdR_ss = data[:, 2] # determine where the min of Es occurs i_min = np.argmin(Es) # determine where the zero of dEdR_ss occur (should be at the same spot # as where the min above occurs according to calculus).
from readparams import ReadParams if __name__ == "__main__": gamma = str(0.04) k24 = str(0.5) Lambda = str(600.0) omega = str(20.0) scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/psi-with-hermite-fit", valgrind=False) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('psivsr') run.mv_file('hermite-psivsr')
if len(sys.argv) < 5: user_input = input("input string of a gamma,k24,Lambda,omega values, " "using comma as delimiter: ") gamma, k24, Lambda, omega = user_input.split(',') else: gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = str(Lambda) scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/psivsr_calculation") # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') run.mv_file('psivsr')
# see user_inputs.md for details on what typically goes in these inputs. # o_L_input = input("input string of omega Lambda values, " # "using comma as delimiter: ") #omegas_Lambdas = np.array(o_L_input.split(','),float) omegas_Lambdas = np.linspace(0, 10, num=101, endpoint=True) scan = {} for o_L in omegas_Lambdas: scan['\omega'] = str(o_L) scan['\Lambda'] = str(o_L) run = SingleRun("data/input.dat", scan) run.run_exe() #run.mv_file('psivsr') run.mv_file('observables') Rguess, etaguess, deltaguess = run.get_xvals() scan['Rguess'] = Rguess scan['Rupper'] = str(1.5 * float(Rguess)) scan['Rlower'] = str(0.75 * float(Rguess)) if not np.isnan(float(etaguess)): scan['etaguess'] = etaguess
savesuf = ["K_{33}", "k_{24}", "\\omega", "\\gamma_s"] scan_dir = "scanforward" i = 0 while (i < len(Lambdas)): Lambda = Lambdas[i] scan['\\Lambda'] = str(Lambda) # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, scan_dir=scan_dir, executable="../../../bin/full3var_with_modulus") # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei, Ri, etai, deltai, surftwisti, modulusi = run.get_all_observables( 'observables', str2float=True) if (Ei > 0.1 * FAILED_E): # if the energy calculation fails, this will be true.
scan = {} scan['k_{24}'] = k24 scan['\Lambda'] = Lambda scan['\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega", "\\gamma_s"] savesuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega"] for gamma in gammas: scan['\gamma_s'] = str(gamma) rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) run.run_exe() #run.mv_file('psivsr') run.mv_file('observables') Rguess, etaguess, deltaguess = run.get_xvals() scan['Rguess'] = Rguess scan['Rupper'] = str(1.5 * float(Rguess)) scan['Rlower'] = str(0.75 * float(Rguess)) if not np.isnan(float(etaguess)): scan['etaguess'] = etaguess
scan_dir = "scantmp" i = len(gammas) - 1 while (i >= 0): gamma = gammas[i] scan['\\gamma_s'] = str(gamma) # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf, datfile=datfile) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, scan_dir=scan_dir, tmp_path=tmp_path) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei, Ri, etai, deltai, surftwisti = run.get_all_observables( 'observables', str2float=True) if (Ei > 0.1 * FAILED_E and gamma > 0.15): # if the energy calculation fails, this will be true. print('hi')
import numpy as np import subprocess import sys sys.path.append('../../modules_gammak24/') from singlerun import SingleRun if __name__ == "__main__": datfile = "data/input.dat" executable = "../../../bin/gamma_k24_space" scan = {'\Lambda': sys.argv[1], '\omega': sys.argv[2]} run = SingleRun(datfile, executable=executable, scan=scan, suffixlist=["K_{33}", "\\Lambda", "d_0", "\\omega"]) run.run_exe() run.mv_file('energy') run.mv_file('surfacetwist') run.mv_file('radius') run.mv_file('eta') run.mv_file('delta')
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\omega'] = omega scan['\\Lambda'] = Lambda loadsuf = savesuf = [ "K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s" ] # first, load the minimum for delta = 0 case, so you know the upper bound for # the energy minimum. rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) #strains = np.linspace(0,0.05,num=501,endpoint=True) strains = np.array([0.0, 0.0020157, 0.0034803, 0.004315], float) #if float(Lambda) > 25.0: # scan['Rguess'] = str(np.log(float(Lambda))) # scan['Rupper'] = str(float(scan['Rguess'])*1.3) # scan['Rlower'] = str(float(scan['Rguess'])*0.75) # scan['deltaguess'] = '0.815' # scan['deltalower'] = '0.81' # scan['etaguess'] = '6.4' # scan['etaupper'] = '6.45'
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda']=Lambda scan['\\omega']= omega loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"] # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,executable="../../../bin/f2_func") # run C executable. run.run_exe() dataname = run.mv_file('f2_func') data = np.loadtxt(dataname) zetas = data[:,0] f2s = data[:,1] df2dxis = data[:,2] df2dzetas = data[:,3] # plot Es vs psip_Rs and dEdpsip_Rs vs psip_Rs
scan['k_{24}'] = k24 scan['\\gamma_s'] = str(gamma) loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "d_0", "\\omega", "\\gamma_s"] savesuf = ["K_{33}", "k_{24}", "d_0", "\\gamma_s"] for i, Lambda in enumerate(Lambdas): omega = omegas[i] scan['\\Lambda'] = str(Lambda) scan['\\omega'] = str(omega) rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) run = SingleRun(rp) run.run_exe() #run.mv_file('psivsr') run.mv_file('observables') Rguess, etaguess, deltaguess = run.get_xvals() scan['Rguess'] = Rguess scan['Rupper'] = str(1.5 * float(Rguess)) scan['Rlower'] = str(0.75 * float(Rguess)) if not np.isnan(float(etaguess)): scan['etaguess'] = etaguess
scan['Rguess'] = str(Rguess0) scan['Rupper'] = str(Rupper0) scan['Rlower'] = str(Rlower0) for j,gnew in enumerate(gnews): scan['\\gamma_s'] = str(gnew) print(gnew,k24) # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=savesuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,scan_dir=scan_dir) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei,Ri,etai,deltai,surftwisti = run.get_all_observables('observables',str2float=True) if (np.isnan(Ri) or Ri <= 0) and gnew > 0.15:
def single_E_calc(gamma, scan, loadsuf, savesuf, scan_dir): scan['\\gamma_s'] = str(gamma) if scan_dir == "scanforward": Rguess0 = 0.044 Rlower0 = 0.04 Rupper0 = 0.05 etaguess0 = 6.29 etalower0 = 6.3 etaupper0 = 6.287 deltaguess0 = 0.74 deltalower0 = 0.72 deltaupper0 = 0.8 else: Rguess0 = 1.5 Rlower0 = 1.0 Rupper0 = 2.0 etaguess0 = 6.4 etalower0 = 6.38 etaupper0 = 6.42 deltaguess0 = 0.815 deltalower0 = 0.813 deltaupper0 = 0.816 scan['Rguess'] = str(Rguess0) scan['Rupper'] = str(Rupper0) scan['Rlower'] = str(Rlower0) scan['etaguess'] = str(etaguess0) scan['etaupper'] = str(etaupper0) scan['etalower'] = str(etalower0) scan['deltaguess'] = str(deltaguess0) scan['deltaupper'] = str(deltaupper0) scan['deltalower'] = str(deltalower0) # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=savesuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, scan_dir=scan_dir) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') # load the final values of E, R, eta, delta, and surface twist. Ei, Ri, etai, deltai, surftwisti = run.get_all_observables('observables', str2float=True) run.concatenate_observables(["\\gamma_s"]) return Ei, Ri
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda']=Lambda scan['\\omega']= omega scan['mpt'] = str(2**power2) loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"] # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,executable="../../../bin/EvsR_c-different-grid-sizes",valgrind=False) # run C executable. start = time.time() run.run_exe() totaltime = time.time()-start with open("data/timings.txt","a") as myfile: myfile.write(f"{scan['mpt']}\t{totaltime:e}\n") # move file written by C executable from temporary data path to true data path run.mv_file(f"EvsR_c-{scan['mpt']}")
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\omega']= omega scan['\\Lambda']= Lambda loadsuf=savesuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"] scan_dir = "scanforward" # first, load the minimum for delta = 0 case, so you know the upper bound for # the energy minimum. rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=savesuf) run = SingleRun(rp) strains = np.linspace(0,0.05,num=501,endpoint=True) for i,u in enumerate(strains): if i == 0: # for the zero strain case, I need to determine what eta_eq is, # so I run the full 3 variable (R,eta,delta) minimization. executable = "../../../bin/full3var_onerun" else:
scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda']=Lambda scan['\\omega']= omega loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"] # read in file name info rp = ReadParams(scan=scan,loadsuf=loadsuf,savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp,executable="../../../bin/samplecalc_testenergy") # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('psivsr_discrete') c_data = np.loadtxt("data/_psivsr_3.0000e+01_1.0000e-01_1.0000e+03_5.0000e+00_4.0000e-02.txt") d_data = np.loadtxt("data/_psivsr_discrete_3.0000e+01_1.0000e-01_1.0000e+03_5.0000e+00_4.0000e-02.txt") c_rs = c_data[:,0] c_psis = c_data[:,1]
user_input = input("input string of a gamma,k24,Lambda,omega values, " "using comma as delimiter: ") gamma, k24, Lambda, omega = user_input.split(',') else: gamma, k24, Lambda, omega = sys.argv[1], sys.argv[2], sys.argv[ 3], sys.argv[4] scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/full4var_psivsr", valgrind=True) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables') run.mv_file('psivsr')
import time sys.path.append('../../scripts/') from singlerun import SingleRun from readparams import ReadParams if __name__ == "__main__": gamma = str(0.04) k24 = str(0.5) Lambda = str(600.0) omega = str(20.0) scan = {} scan['k_{24}'] = k24 scan['\\gamma_s'] = gamma scan['\\Lambda'] = Lambda scan['\\omega'] = omega loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"] # read in file name info rp = ReadParams(scan=scan, loadsuf=loadsuf, savesuf=loadsuf) # create a class to do calculations with current parameters in scan. run = SingleRun(rp, executable="../../../bin/EvsR_c", valgrind=False) # run C executable. run.run_exe() # move file written by C executable from temporary data path to true data path run.mv_file('observables')