Beispiel #1
0
    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:

        # smallest gamma value that they both exist at
        jsmall = find_j[0]

        # largest gamma value that they both exist at
        jlarge = find_j[-1]

        # find the point where the fwd E becomes larger than the bkwd E
        j = (np.argmin(
            np.abs(obsfwd.E()[jsmall:jlarge + 1] -
                   obsbkwd.E()[jsmall:jlarge + 1])) + len(obsfwd.E()[:jsmall]))
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)



ax1.plot(rs,psis,'.',label=rf'$\Lambda={Lambda}$')

ax1.set_xlabel(r'$r$' ' ' r'$(\si{\nano\meter})$',fontsize=24)
ax1.set_ylabel(r'$\psi(r)$',fontsize=24)
Beispiel #3
0
        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):

Beispiel #4
0
                            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()]
    #ysbkwd = [obsbkwd.E(),obsbkwd.R(),obsbkwd.eta(),obsbkwd.delta(),obsbkwd.surfacetwist()]


    for i,observable in enumerate(observable_list):


        if observable == 'surfacetwist':
            ylabel = r'$\psi(R)$'
        elif observable == 'eta':
            ylabel = r'$2\pi/\eta$'
            ysfwd[i] = 2*np.pi/ysfwd[i]
        elif observable == 'delta':
            ylabel = r'$\delta/\delta_0$'
            ysfwd[i] = ysfwd[i]/np.sqrt(2/3)
        elif len(observable) > 1:
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)

fibrilstrain = FibrilStrain(psistuff, observablestuff, sfile_format='pdf')

rs, thetas = fibrilstrain.mesh_polar(grid_skip=4)
        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)

        ysbkwd = [obsbkwd.R(),obsbkwd.surfacetwist()]


        g_small,g_large,g_eq = find_metastable(obsfwd.R(),obsbkwd.R(),
                                               obsfwd.E(),obsbkwd.E())

        print(g_small,g_large,g_eq)
    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()]

    for i, observable in enumerate(observable_list):

        if observable == 'surfacetwist':
            ylabel = r'$\psi(R)$'
        else:
Beispiel #8
0
    ts = ts[1:]

    print(ts)

    tcs = np.linspace(0.003,0.2,num=100,endpoint=True)

    fig = plt.figure()
    fig.set_size_inches(width,height)

    ax = fig.add_subplot(1,1,1)


    ylabel=observable

    Rlin = obsfwd.R(observables_num=7)[1:]

    Rfrust = obsbwd.R(observables_num=7)[1:]

    ax.plot(ts,Rfrust-Rlin,
            '^',color=colors[2],markersize=3)

    if observable != "E":

        ax.plot(tcs,y_scaling(tcs,0.5,0.25),'--',color='k',lw=1,
                label=r'$t^{\frac{1}{2}}$')

    #ax.set_xlim(0.002,8)
    ax.set_yscale('log')
    ax.set_xscale('log')
Beispiel #9
0
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(),
    obsfwd.surfacetwist()
]
ysbkwd = [
    obsbkwd.E(),
    obsbkwd.R(),
    obsbkwd.eta(),
    obsbkwd.delta(),
    obsbkwd.surfacetwist()
]

for i, observable in enumerate(observable_list):

    fig[observable] = plt.figure()

gammacoexist = []
k24coexist = []

# 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,datfile='data/inputfwd.dat')
    obsbkwd = ObservableData(["\\gamma_s"],scan_dir='scanbackward',scan=scan,
                             loadsuf=loadsuf,savesuf=savesuf,datfile='data/inputbwd.dat')
    bwdlen = len(obsbkwd.R())

    print(k24)
    # find all spots where two distinct phases exist (two different radii values)
    bool_1 = np.isclose(obsfwd.R()[:bwdlen],obsbkwd.R(),rtol=1e-3)
    find_j = np.where(bool_1==False)[0]

    if find_j.size > 0:   # if two distinct phases exist, then:

        # smallest gamma value that they both exist at
        jsmall = find_j[0]

        # largest gamma value that they both exist at
        jlarge = find_j[-1]

        # find the point where the fwd E becomes larger than the bkwd E
loadsuf=["K_{33}","k_{24}","\\Lambda","\\omega","\\gamma_s"]


psistuff = PsiData(scan=scan,loadsuf=loadsuf,savesuf=loadsuf,
                   name=f"psivsr{type}")

rs = psistuff.r()*R_units
psis = psistuff.psi()*180/np.pi

observablestuff = ObservableData(scan=scan,loadsuf=loadsuf,savesuf=loadsuf,
                                 name=f"observables{type}")

print(observablestuff.surfacetwist())

R = observablestuff.R()*R_units


fig = plt.figure()
width  = 4
height = width
fig.set_size_inches(2*width,height)

ax1 = fig.add_subplot(1,2,1)



ax1.plot(rs,psis,'.',label=rf'$\Lambda={Lambda}$')

ax1.set_xlabel(r'$r$' ' ' r'$(\si{\nano\meter})$',fontsize=24)
ax1.set_ylabel(r'$\psi(r)$' + " (" + r"$^\circ$" + ")",fontsize=24)
Beispiel #12
0
    ax = {}

    q = 24.0  # um^{-1}

    K_22 = 6  # pN

    for i, observable in enumerate(observable_list):

        ax[observable] = fig.add_subplot(3, 1, i + 1)

    obsfwd = ObservableData(["strain", "averagetwist"],
                            scan_dir='scanforward',
                            scan=scan,
                            loadsuf=loadsuf,
                            savesuf=savesuf)
    Req = obsfwd.R()[0] / q * 1000  # nm

    strains = obsfwd.data[:, 0]
    stresses = np.gradient(obsfwd.E(), strains) * K_22 * q * q / 1e3  # in kPa
    stresses[0] = 0.0

    ysfwd = [stresses, obsfwd.surfacetwist(), obsfwd.delta()]
    if obsfwd.E()[0] > 1e299:
        print("bad calculation at Lambda = ", Lambda)

    for i, observable in enumerate(observable_list):

        if observable == 'surfacetwist':
            ylabel = r'$\psi(R)$' + ' (' + r'$\si{\radian}$' + ')'
        elif observable == "stress":
            ylabel = r"$\sigma$" + ' (' + r'$\si{\kilo\pascal}$' + ')'
Beispiel #13
0
        ax[observable] = fig[observable].add_subplot(1,1,1)


    for j,Lambda in enumerate(Lambdas):

        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)

        ysbkwd = [obsbkwd.R(),obsbkwd.surfacetwist()]


        g_small,g_large,g_eq = find_metastable(obsfwd.R(),obsbkwd.R(),
                                               obsfwd.E(),obsbkwd.E())

        print(g_small,g_large,g_eq)
        """
Beispiel #14
0
    ax[observable] = fig[observable].add_subplot(1,1,1)


for j,k24 in enumerate(k24s):

    scan = {}
    scan['\\Lambda']=str(Lambda)
    scan['k_{24}']=str(k24)
    scan['\\omega']=str(omega)

    obsfwd = ObservableData(["\\gamma_s"],scan_dir='scanforward',scan=scan,loadsuf=loadsuf,
                            savesuf=savesuf)

    gammas = obsfwd.data[:,0]

    ysfwd = [obsfwd.R(),obsfwd.surfacetwist()]


    obsbkwd = ObservableData(["\\gamma_s"],scan_dir='scanbackward',scan=scan,loadsuf=loadsuf,
                             savesuf=savesuf)

    ysbkwd = [obsbkwd.R(),obsbkwd.surfacetwist()]


    g_small,g_large,g_eq = find_metastable(obsfwd.R(),obsbkwd.R(),
                                           obsfwd.E(),obsbkwd.E())

    print(g_small,g_large,g_eq)

    for i,observable in enumerate(observable_list):