Пример #1
0
        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):


            if observable == 'surfacetwist':
                ylabel = r'$<\psi>$' + ' (' + r"$\si{\radian}$" + ')'
            elif observable == "stress":
                ylabel = r"$\tilde{\sigma}$" + ' (' + r"$\si{\kilo\pascal}$" + ')'
            elif observable == 'delta':
                ylabel = r'$\delta/\delta_0$'
                ysfwd[j] = ysfwd[j]/np.sqrt(2/3)
Пример #2
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:
        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)

        for j, observable in enumerate(observable_list):

            if observable == 'surfacetwist':
                ylabel = r'$<\psi>$' + ' (' + r"$\si{\radian}$" + ')'
            elif observable == "stress":
                ylabel = r"$\tilde{\sigma}$" + ' (' + r"$\si{\kilo\pascal}$" + ')'
            elif observable == 'delta':
                ylabel = r'$\delta/\delta_0$'
                ysfwd[j] = ysfwd[j] / np.sqrt(2 / 3)
            elif len(observable) > 1:
                ylabel = fr'$\{observable}$'
            else:
Пример #4
0
        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):

            if observable == 'surfacetwist':
                ylabel = r'$\psi(R)$'
            elif observable == "stress":
                ylabel = r"$\sigma$"
            elif observable == 'delta':
                ylabel = r'$\delta/\delta_0$'
                ysfwd[i] = ysfwd[i] / np.sqrt(2 / 3)
            elif len(observable) > 1:
                ylabel = fr'$\{observable}$'
        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)
        """
Пример #6
0
                            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()]

    ysfwd = [obsfwd.E(), obsfwd.eta(), obsfwd.delta()]

    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]
            if js == 1:
                ysbkwd[i] = 2 * np.pi / ysbkwd[i]
        elif observable == 'delta':
            ylabel = r'$\delta/\delta_0$'
            ysfwd[i] = ysfwd[i] / np.sqrt(2 / 3)
Пример #7
0
                        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()
    ax[observable] = fig[observable].add_subplot(1, 1, 1)
        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)

        if type == "no-core":
            # incompatibility between the no core and core case so need to do this hack
            deltas = obsfwd.eta() 
        else:
            deltas = obsfwd.delta()
            
        ysfwd = [stresses,avgtwist,deltas]
        
        if obsfwd.E()[0] > 1e299:
            print("bad calculation at Lambda = ",Lambda)



        for j,observable in enumerate(observable_list):


            if observable == 'surfacetwist':
                ylabel = r'$<\psi>$' + ' (' + r"$\si{\radian}$" + ')'
            elif observable == "stress":
                ylabel = r"$\tilde{\sigma}$" + ' (' + r"$\si{\kilo\pascal}$" + ')'
Пример #9
0
    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()

    R0s = np.copy(rs[:len(rs)-10:5])
Пример #10
0

    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)
        """

        for i,observable in enumerate(observable_list):