def __init__(self,scan_dir="",scan={},
loadsuf=["K_{33}","k_{24}","\\Lambda",
"\\omega","\\gamma_s"],
savesuf=["K_{33}","k_{24}","\\Lambda",
"\\omega","\\gamma_s"],
sfile_format="pdf",obsname = "observables",
datfile="data/input.dat",psiname = "psivsr",
psiloadfilepath="data",obsloadfilepath="data",
psisavefilepath="results",obssavefilepath="results"):
ReadParams.__init__(self,datfile=datfile,
scan=scan,loadsuf=loadsuf,savesuf=savesuf)
self.obsdata = ObservableData(scan=scan,loadsuf=loadsuf,savesuf=savesuf,
datfile=datfile,loadfilepath=obsloadfilepath,
savefilepath=obssavefilepath,
scan_dir=scan_dir,name=obsname)
self.psidata = PsiData(scan=scan,loadsuf=loadsuf,savesuf=savesuf,
datfile=datfile,loadfilepath=psiloadfilepath,
savefilepath=obssavefilepath,
scan_dir = scan_dir,name=psiname)
self.scan_dir=scan_dir
self.sfile_format=sfile_format
self.i_R_c = self.find_R_c_index()
return
def __init__(
self,
datfile="data/input.dat",
scan={},
loadsuf=["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"],
name="observables",
loadfilepath="data"):
ObservableData.__init__(self,
datfile=datfile,
scan=scan,
loadsuf=loadsuf,
name='dummy',
loadfilepath=loadfilepath)
self.name = name
self.double_well_set_scan()
fig = plt.figure()
fig.set_size_inches(width, 2 * height)
ax1 = fig.add_subplot(2, 1, 1)
ax2 = fig.add_subplot(2, 1, 2)
mpts = np.array([16384, 32768, 65536], int) #[1024,2048,4096,8192],int)#,
for i, mpt in enumerate(mpts):
scan['mpt'] = str(mpt)
print(i)
# read in file name info
obs = ObservableData(scan=scan,
loadsuf=loadsuf,
savesuf=loadsuf,
name=f"Evsh-{mpt}")
hs = obs.data[:, 0]
dEdR_cs = obs.data[:, 1]
err_trunc = obs.data[:, 2]
err_round = obs.data[:, 3]
ax1.plot(hs, dEdR_cs, '-', label=rf'$m={mpt}$', color=colors[i])
ax2.plot(hs, err_trunc, '-', label=rf'$m={mpt}$', color=colors[i])
ax2.plot(hs, err_round, '-', color=colors[i])
ax1.set_ylabel(r'$\frac{\partial E}{\partial R_c}$')
ax1.set_xscale('log')
ax1.legend(frameon=False)
Lambda = sys.argv[1]
omega = sys.argv[2]
scan = {}
scan['\\Lambda'] = Lambda
scan['\\omega'] = omega
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for i, k24 in enumerate(k24s):
scan['k_{24}'] = str(k24)
obsfwd = ObservableData(["\\gamma_s"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbkwd = ObservableData(["\\gamma_s"],
scan_dir='scanbackward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
print(k24)
# find all spots where two distinct phases exist (two different radii values)
bool_1 = np.isclose(obsfwd.R(), obsbkwd.R(), rtol=1e-3)
find_j = np.where(bool_1 == False)[0]
if find_j.size > 0: # if two distinct phases exist, then:
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\Lambda'] = Lambda
scan['\\omega'] = omega
loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"]
psistuff = PsiData(scan=scan,loadsuf=loadsuf,savesuf=loadsuf)
rs = psistuff.r()/8.0*1000
psis = psistuff.psi()
observablestuff = ObservableData(scan=scan,loadsuf=loadsuf,savesuf=loadsuf)
print(observablestuff.surfacetwist())
R = observablestuff.R()/8.0*1000
fig = plt.figure()
width = 3.487
height = width
fig.set_size_inches(2*width,height)
ax1 = fig.add_subplot(1,2,1)
print(f"gamma,k24 = {gamma},{k24}")
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for om, omega in enumerate(omegas):
scan['\\omega'] = str(omega)
obs = ObservableData(["\\Lambda"],
scan=scan,
scan_dir='scanforward',
loadsuf=loadsuf,
savesuf=savesuf,
datfile=datfile,
loadfilepath=loadfilepath)
print(omega)
eta_0s = obs_finder(obs, "eta", num_Lambdas)
for observable in observable_list:
dataarray = obs_finder(obs, observable, num_Lambdas)
dataarray = convert_to_NANS(eta_0s, dataarray)
if observable == 'eta':
data2d[observable][om, :] = 2 * np.pi / dataarray
ms_lower = 43
ms_upper = 12
i_Lambda = int(Lambdalist[0])
gamma = pair[0]
k24 = pair[1]
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\omega'] = str(omega)
obsfwd = ObservableData(["\\Lambda"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
Lambdas = obsfwd.data[:, 0]
x, y = obsfwd.surfacetwist()[1:], 2 * np.pi / obsfwd.eta()[1:]
ax.plot(x, y, '.', color=colors[js])
ax.plot(x[-1], y[-1], 'rs')
dums = np.linspace(0.05, 0.25, num=150, endpoint=True)
ax.plot(dums, np.cos(dums), '--')
ax.set_xlabel(r"$\psi(R)$", fontsize=10)
ax.set_ylabel(r"$2\pi/\eta$", fontsize=10)
scan['\\omega'] = omega
loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"]
pre = "frustrated"
psistuff = PsiData(scan=scan,
loadsuf=loadsuf,
savesuf=loadsuf,
name=f"{pre}psivsr")
rs = psistuff.r()
psis = psistuff.psi()
observablestuff = ObservableData(scan=scan,
loadsuf=loadsuf,
savesuf=loadsuf,
name=f"{pre}observables")
R = observablestuff.R()
eta = observablestuff.eta()
dband = 2 * np.pi / eta
axarr[0].plot(rs, (dband - np.cos(psis)) / np.cos(psis) * 100,
'-',
color=colors[0])
axarr[0].set_xlabel(r'$r$', fontsize=10)
axarr[0].set_ylabel('molecular strain (\%)', fontsize=10)
axarr[0].legend(frameon=False)
colors = sns.color_palette()
colors = [colors[2], colors[3]]
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega'] = str(omega)
scan['K_{33}'] = str(K33)
loadsuf = ["K_{33}", "\\Lambda", "\\omega"]
savesuf = ["K_{33}", "\\Lambda", "\\omega"]
obsfwd = ObservableData(name="fw_coexist",
loadfilepath="results",
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbwd = ObservableData(name="bw_coexist",
loadfilepath="results",
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
observables_list = ["E", "R", "eta", "delta", "psi(R)"]
k24s = obsfwd.data[:, 0]
delR = (obsbwd.data[:, 3] - obsfwd.data[:, 3])
ys = np.log(delR)
Lambda = sys.argv[1]
omega = sys.argv[2]
scan = {}
scan['\\Lambda']=Lambda
scan['\\omega']=omega
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for i,k24 in enumerate(k24s):
scan['k_{24}']=str(k24)
obsfwd = ObservableData(["\\gamma_s"],scan_dir='scanforward',scan=scan,
loadsuf=loadsuf,savesuf=savesuf)
obsbkwd = ObservableData(["\\gamma_s"],scan_dir='scanbackward',scan=scan,
loadsuf=loadsuf,savesuf=savesuf)
bkwdexists = os.path.isfile(obsbkwd.observables_fname())
if not bkwdexists:
# save a copy of scanforward data under the scanbackward filename,
# as if the file doesn't exist it's assumed that the scanbackward
# and scanforward files are the same (below the critical point region
# in gamma,k24 space)
np.savetxt(obsbkwd.observables_fname(),obsfwd.data,
fmt='\t'.join(["%13.6e"] + ["%15.8e"]*5))
colors = sns.color_palette()
colors = [colors[0], colors[1]]
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega'] = str(omega)
scan['K_{33}'] = str(K33)
loadsuf = ["K_{33}", "\\Lambda", "\\omega"]
savesuf = ["K_{33}", "\\Lambda", "\\omega"]
obsfwd = ObservableData(name="fw_coexist",
loadfilepath="results",
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbwd = ObservableData(name="bw_coexist",
loadfilepath="results",
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
observables_list = ["gamma", "E", "R", "eta", "delta", "psi(R)"]
k24s = obsfwd.data[:, 0]
gammas = obsfwd.data[:, 1]
ts = (k24s - k24s[0]) / k24s[0]
Lambda = 27
omega = 10
k24s = np.linspace(0.5,1.0,num=51,endpoint=True)
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega']= str(omega)
loadsuf=["K_{33}","\\Lambda","\\omega"]
savesuf=["K_{33}","\\Lambda","\\omega"]
obsfwd = ObservableData(["\\gamma_s","k_{24}"],scan_dir="scanforward",
scan=scan,loadsuf=loadsuf,savesuf=savesuf)
obsbkwd = ObservableData(["\\gamma_s","k_{24}"],scan_dir="scanbackward",
scan=scan,loadsuf=loadsuf,savesuf=savesuf)
fw_coexist = np.empty([len(k24s),7],float)
bw_coexist = np.empty([len(k24s),7],float)
for i,k24 in enumerate(k24s):
fw = np.where(np.isclose(obsfwd.data[:,1].T,k24),obsfwd.data.T,0).T
fw = fw[~np.all(fw==0,axis=1)]
bw = np.where(np.isclose(obsbkwd.data[:,1].T,k24),obsbkwd.data.T,0).T
scan = {}
scan['\\Lambda']=sys.argv[1]
scan['\\omega']=sys.argv[2]
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for k24 in k24s:
scan['k_{24}']=str(k24)
obsfwd = ObservableData(["\\gamma_s"],scan_dir='scanforward',scan=scan,
loadsuf=loadsuf,savesuf=savesuf)
obsbkwd = ObservableData(["\\gamma_s"],scan_dir='scanbackward',scan=scan,
loadsuf=loadsuf,savesuf=savesuf)
obsbkwd.sort_observables()
end_bkwd = obsbkwd.data.shape[0]
datanew = np.concatenate((obsbkwd.data,obsfwd.data[end_bkwd:,:]),axis=0)
np.savetxt(obsbkwd.observables_fname(),datanew,
fmt='\t'.join(["%13.6e"]+["%15.8e"]*5))
gamma = 0.04
k24 = 0.5
Lambda = 600
omega = 20
K33 = 30.0
scan = {}
scan['\\gamma_s'] = str(gamma)
scan['k_{24}'] = str(k24)
scan['\\Lambda'] = str(Lambda)
scan['\\omega'] = str(omega)
scan['K_{33}'] = str(K33)
observablestuff = ObservableData(scan=scan,loadsuf=loadsuf,savesuf=loadsuf,
name=f"observables_frustrated")
delta = observablestuff.delta()
eta = observablestuff.eta()
E0 = observablestuff.E()
print(delta,eta,E0)
psistuff = PsiData(scan=scan,loadsuf=loadsuf,savesuf=savesuf,name=f"psivsr_frustrated",
sfile_format="pdf")
rs = psistuff.r()
psis = psistuff.psi()
psiprimes = psistuff.psiprime()
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega']= str(omega)
scan['K_{33}'] = str(K33)
loadsuf=["K_{33}","\\Lambda","\\omega"]
savesuf=["K_{33}","\\Lambda","\\omega"]
data_path = "../../2019-06-27/coexistence-gaps"
loadfilepath = data_path + "/results"
datfile = data_path + "/data/input.dat"
obsfwd = ObservableData(name="fw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
obsbwd = ObservableData(name="bw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
observable = "R"#"E","R","eta","delta","psi(R)"]
k24s = obsfwd.data[:,0]
k24c = 0.2544
print(f"gamma values closest to gamma_c are {obsfwd.data[0:2,1]}")
ts = (k24s-k24c)/k24c
# I am omitting the first data point as the double well scans at it show that it isn't
# really a minimum.
fig[observable] = plt.figure()
ax[observable] = fig[observable].add_subplot(1,1,1)
fig[observable].set_size_inches(width,height)
gammas = ['0.02','0.06','0.08','0.1','0.12']
for js,gamma in enumerate(gammas):
scan = {}
scan['\\gamma_s']=gamma
scan['k_{24}']=k24
scan['\\omega']=str(omega)
obsfwd = ObservableData(["\\Lambda"],scan_dir='scanforward',scan=scan,loadsuf=loadsuf,
savesuf=savesuf)
if not obsfwd.file_exists:
continue
obsfwd.sort_observables()
obsfwd.remove_duplicates()
Lambdas = obsfwd.data[:,0]
#obsbkwd = ObservableData(["\\Lambda"],scan_dir='scanbackward',scan=scan,loadsuf=loadsuf,
# savesuf=savesuf)
#obsbkwd.sort_observables()
ysfwd = [obsfwd.E(),obsfwd.R(),obsfwd.eta(),obsfwd.delta(),obsfwd.surfacetwist()]
loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega"]
k24s = np.linspace(0.2, 1, num=41, endpoint=True)
Lambda = '600.0'
omega = '20.0'
scan = {}
scan['\\Lambda'] = Lambda
scan['\\omega'] = omega
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for i, k24 in enumerate(k24s):
scan['k_{24}'] = str(k24)
obsbwd = ObservableData(["\\gamma_s"],
scan_dir='scanbackward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf,
datfile='data/inputbwd.dat')
obsbwd.data = obsbwd.data[np.argsort(obsbwd.data[:, 0])]
np.savetxt(obsbwd.observable_sname("observables_scanbackward",
plot_format="txt"),
obsbwd.data,
fmt='\t'.join(["%15.8e"] * 6))
loadsuf = ["K_{33}", "k_{24}", "\\omega", "\\gamma_s"]
savesuf = loadsuf
Lambdas = np.linspace(0, 1000, num=1001, endpoint=True)
i_fwd = 38
ms_fwd = np.array([38, 39], float)
ms_bkwd = np.array([37, 38, 39, 40], float)
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\omega'] = str(omega)
obsfwd = ObservableData(["\\Lambda"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbkwd = ObservableData(["\\Lambda"],
scan_dir='scanbackward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbkwd.sort_observables()
observable_list = ['E', 'R', 'eta', 'delta', 'surfacetwist']
ysfwd = [
obsfwd.E(),
obsfwd.R(),
obsfwd.eta(),
obsfwd.delta(),
i + 1,
sharex=ax[observable_list[0]])
else:
ax[observable] = fig.add_subplot(3, 1, i + 1)
for i, type in enumerate(types):
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\omega'] = omega
scan['\\Lambda'] = Lambda
obsfwd = ObservableData(["strain", "averagetwist"],
scan_dir=f'scanforward{type}',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
Req = obsfwd.R()[0]
print(Req)
strains = obsfwd.data[:, 0]
stresses = np.gradient(obsfwd.E(),
strains) * K22 * q * q / 1000 # stress in kPa
stresses[0] = 0.0
avgtwist = obsfwd.data[:, 1]
minindex = np.argmin(avgtwist)
ysfwd = [stresses, avgtwist, obsfwd.delta()]
if obsfwd.E()[0] > 1e299:
print("bad calculation at Lambda = ", Lambda)
ms_lower = 43
ms_upper = 12
i_Lambda = int(Lambdalist[0])
gamma = pair[0]
k24 = pair[1]
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\omega'] = str(omega)
obsfwd = ObservableData(["\\Lambda"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
Lambdas = obsfwd.data[:, 0]
if js == 1:
obsbkwd = ObservableData(["\\Lambda"],
scan_dir='scanbackward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbkwd.sort_observables()
ysbkwd = [obsbkwd.E(), obsbkwd.eta(), obsbkwd.delta()]
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega']= str(omega)
scan['K_{33}'] = str(K33)
loadsuf=["K_{33}","\\Lambda","\\omega"]
savesuf=["K_{33}","\\Lambda","\\omega"]
data_path = "../../2019-06-27/coexistence-gaps"
loadfilepath = data_path + "/results"
datfile = data_path + "/data/input.dat"
obsfwd = ObservableData(name="fw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
obsbwd = ObservableData(name="bw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
observables_list = ["R"]
k24s = obsfwd.data[:,0]
delRs = obsbwd.data[:,3]-obsfwd.data[:,3]
delRs = delRs[k24s<0.35]
delRs = delRs[1:]
k24s = k24s[k24s<0.35]
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
obs = ObservableData(scan=scan, loadsuf=loadsuf, savesuf=loadsuf)
R_c = obs.data[:, 0]
E = obs.data[:, 1]
dEdR_c = obs.data[:, 2]
err = obs.data[:, 3]
fig = plt.figure()
fig.set_size_inches(width, 3 * height)
ax1 = fig.add_subplot(3, 1, 1)
ax2 = fig.add_subplot(3, 1, 2)
ax3 = fig.add_subplot(3, 1, 3)
scan = {}
scan['\\Lambda'] = str(Lambda)
scan['\\omega']= str(omega)
scan['K_{33}'] = str(K33)
loadsuf=["K_{33}","\\Lambda","\\omega"]
savesuf=["K_{33}","\\Lambda","\\omega"]
data_path = "../../2019-06-27/coexistence-gaps"
loadfilepath = data_path + "/results"
datfile = data_path + "/data/input.dat"
obsfwd = ObservableData(name="fw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
obsbwd = ObservableData(name="bw_coexist",loadfilepath=loadfilepath,scan=scan,
loadsuf=loadsuf,savesuf=savesuf,datfile=datfile)
k24_coexists = obsfwd.data[:,0]
gamma_coexists = obsbwd.data[:,1]
pd = PhaseDiagram(gamma_coexists,k24_coexists)
cmap = pd.TwoColorMap()
fig = plt.figure()
fig.set_size_inches(width,height)
scan['k_{24}'] = k24
scan['\\Lambda'] = Lambda
scan['\\omega'] = omega
loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"]
psistuff = PsiData(scan=scan,
loadsuf=loadsuf,
savesuf=loadsuf,
name=f"psivsr_frustrated")
rs = psistuff.r()
psis = psistuff.psi()
observablestuff = ObservableData(scan=scan,
loadsuf=loadsuf,
savesuf=loadsuf,
name=f"observables_frustrated")
R = observablestuff.R()
eta = observablestuff.eta()
print("radius is ", R)
dband = 2 * np.pi / eta
strain_r = (dband - np.cos(psis)) / np.cos(psis)
axarr[0].plot(rs, strain_r * 100, '-', color=colors[0])
print("tension at fibril centre is ", strain_r[0] * 100, "%.")
print("tension at the fibril surface is ", strain_r[-1] * 100, "%.")
for i,type in enumerate(types):
k24 = k24s[i]
Lambda = Lambdas[i]
q = qs[i]
scan = {}
scan['\\gamma_s']=gamma
scan['k_{24}']=k24
scan['\\omega']=omega
scan['\\Lambda']=Lambda
obsfwd = ObservableData(["strain","averagetwist"],scan_dir='scanforward',
scan=scan,loadsuf=loadsuf,
savesuf=savesuf)
Req = obsfwd.R()[0]
print(Req)
strains = obsfwd.data[:,0]
stresses = np.gradient(obsfwd.E(),strains)*K22*q*q/1000 # stress in kPa
stresses[0] = 0.0
ysfwd = [stresses,obsfwd.data[:,1],obsfwd.delta()]
if obsfwd.E()[0] > 1e299:
print("bad calculation at Lambda = ",Lambda)
for j,observable in enumerate(observable_list):
fig.set_size_inches(width, height)
ax = {}
for i, observable in enumerate(observable_list):
ax[observable] = fig.add_subplot(3, 1, i + 1)
for js, Lambda in enumerate(Lambdas):
scan['\\Lambda'] = Lambda
print(Lambda)
obsfwd = ObservableData(["strain"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
#obsfwd.sort_observables()
#obsfwd.remove_duplicates()
strains = obsfwd.data[:, 0]
stresses = np.gradient(obsfwd.E(), strains)
stresses[0] = 0.0
#ysfwd = [obsfwd.E(),obsfwd.R(),obsfwd.delta(),obsfwd.surfacetwist(),stresses]
ysfwd = [stresses, obsfwd.delta(), obsfwd.surfacetwist()]
if obsfwd.E()[0] > 1e299:
print("bad calculation at Lambda = ", Lambda)
continue
for i, observable in enumerate(observable_list):
breaks = np.copy(Larray) * 0
Lambdas = list(map(str, Larray))
loadsuf = ["K_{33}", "k_{24}", "\\Lambda", "\\omega", "\\gamma_s"]
savesuf = ["K_{33}", "\\omega"]
#observable_list = ["E","R","delta","surfacetwist","stress"]
for js, Lambda in enumerate(Lambdas):
scan['\\Lambda'] = Lambda
obsfwd = ObservableData(["strain"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
#obsfwd.sort_observables()
#obsfwd.remove_duplicates()
if len(obsfwd.data) == 6 or obsfwd.E()[0] > 1e299:
print("bad calculation at Lambda = ", Lambda)
Larray[js] = np.nan
continue
strains = obsfwd.data[:, 0]
stresses = np.gradient(obsfwd.E(), strains)
stresses[0] = 0.0
youngs[js] = (stresses[1] - stresses[0]) / (strains[1] -
strains[0])
fig[observable] = plt.figure()
fig[observable].set_size_inches(width, height)
ax[observable] = fig[observable].add_subplot(1, 1, 1)
for j, omega in enumerate(omegas):
scan = {}
scan['\\Lambda'] = Lambda
scan['k_{24}'] = k24
scan['\\omega'] = omega
obsfwd = ObservableData(["\\gamma_s"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
gammas = obsfwd.data[:, 0]
ysfwd = [
obsfwd.E(),
obsfwd.R(),
obsfwd.eta(),
obsfwd.delta(),
obsfwd.surfacetwist()
]
"""
obsbkwd = ObservableData(["\\gamma_s"],scan_dir='scanbackward',scan=scan,loadsuf=loadsuf,
savesuf=savesuf)
scan = {}
scan['\\Lambda'] = '600.0'
scan['\\omega'] = '20.0'
scan_dir = ""
datfile = 'data/inputfwd.dat'
# load in 2d grid of data in data2d for each observable at the
# specified gamma,k24 pair.
for om, k24 in enumerate(k24s):
scan['k_{24}'] = str(k24)
obs = ObservableData(["\\gamma_s"],
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf,
scan_dir=scan_dir,
datfile=datfile)
print(k24)
for observable in observable_list:
index = obs.ylabelstr_to_column(observable)
datalength = len(obs.data[:, index])
if datalength < num_gammas - 1:
dumarray = np.ones(num_gammas - datalength) * np.nan
dataarray = np.concatenate((obs.data[:, index], dumarray))
else:
dataarray = obs.data[:num_gammas, index]
if observable == 'eta':
data2d[observable][om, :] = 2 * np.pi / dataarray
ms_lower = 43
ms_upper = 12
i_Lambda = int(Lambdalist[0])
gamma = pair[0]
k24 = pair[1]
scan = {}
scan['\\gamma_s'] = gamma
scan['k_{24}'] = k24
scan['\\omega'] = str(omega)
obsfwd = ObservableData(["\\Lambda"],
scan_dir='scanforward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
Lambdas = obsfwd.data[:, 0]
ysfwd = [obsfwd.R(), obsfwd.surfacetwist()]
if js == 1:
obsbkwd = ObservableData(["\\Lambda"],
scan_dir='scanbackward',
scan=scan,
loadsuf=loadsuf,
savesuf=savesuf)
obsbkwd.sort_observables()
ysbkwd = [obsbkwd.R(), obsbkwd.surfacetwist()]
