def d(T, d_max, s):
    return d_max * exp(-s * T)


if __name__ == "__main__":
    seed(76567)
    d_max = 10000
    s = 1e-4

    E, E_tot_0, E_tot_5, last_bend = 0, 0, 0, 0
    E_list_0, bend_list_0 = zeros(1), zeros(1)
    E_list_5, bend_list_5 = zeros(1), zeros(1)

    protein_0 = Protein(15, 1e-15)
    protein_5 = Protein(15, 500)
    protein_5.potentials = protein_0.potentials

    it = 0

    while (protein_0.valid_bends < 5000):
        it += 1
        print(protein_0.valid_bends, it)
        if protein_0.bend_protein():
            E_list_0 = append(E_list_0, E)
            E_tot_0 += E * (protein_0.valid_bends - last_bend)
            last_bend = protein_0.valid_bends
            E = protein_0.u
            E_list_0 = append(E_list_0, E)
            bend_list_0 = append(bend_list_0, [last_bend, last_bend])
Пример #2
0
from Protein_class import Protein
path.__delitem__(0)

from numpy import linspace, flip, zeros, append, savez, array
from numpy.random import seed

if __name__ == "__main__":
    seed(669311)

    bends_per_T = 600
    num_T = 51
    T_min, T_max = 0.0000000000001, 1500
    n_monomers = 30

    T_list = flip(linspace(T_min, T_max, num_T), 0)
    protein = Protein(n_monomers, 0)
    E_list = zeros(1)
    L_list = array([n_monomers])
    bend_list = zeros(1)

    E, L, last_bend = 0, n_monomers, 0

    for T_ind in range(num_T):
        print(T_list[T_ind])
        protein.T = T_list[T_ind]
        E_tot, L_tot = 0, 0
        while (protein.valid_bends < bends_per_T * (T_ind + 1)):
            if protein.bend_protein():
                E_list = append(E_list, E)
                L_list = append(L_list, L)
                bend_list = append(bend_list, protein.valid_bends)
    s = 5 * 1e-4
    num_T = 151
    length = 30

    T_list = linspace(0.00001, 1500, num_T)
    E, E_tot, L_tot, L, last_bend = 0, 0, 0, length, 0
    E_list, L_list = zeros(num_T), zeros(num_T)
    seed_list = [
        1337, 1, 10352, 9234, 999922, 999999999, 235359, 863286248, 124872,
        4652742
    ]

    for k in range(len(seed_list)):

        seed(seed_list[k])
        protein = Protein(length, 0)
        U_mat = protein.potentials

        print("\n{}\n".format(k))

        for i in range(num_T):

            print(T_list[i], d(T_list[i], d_max, s))

            protein = Protein(length, T_list[i])
            protein.potentials = U_mat
            E, E_tot, L_tot, L, last_bend = 0, 0, 0, length, 0

            while (protein.valid_bends < d(T_list[i], d_max, s)):
                if protein.bend_protein():
                    L_tot += L * (protein.valid_bends - last_bend)
Пример #4
0
 E, E_tot, L_tot, L, last_bend = 0, 0, 0, length, 0
 E_list, L_list = zeros(num_T), zeros(num_T)
 old_seed_list = [
     1337, 1, 10352, 9234, 999922, 999999999, 235359, 863286248, 124872,
     4652742
 ]
 seed_list = [
     186072, 895242, 418811, 153930, 446805, 511978, 537066, 436767, 457513,
     739423
 ]
 for k in range(len(seed_list)):
     print("\n{}\n".format(k))
     seed(seed_list[k])
     for i in range(num_T):
         print(T_list[i], d(T_list[i], d_max, s))
         protein = Protein(length, T_list[i])
         E, E_tot, L_tot, L, last_bend = 0, 0, 0, length, 0
         while (protein.valid_bends < d(T_list[i], d_max, s)):
             if protein.bend_protein():
                 L_tot += L * (protein.valid_bends - last_bend)
                 E_tot += E * (protein.valid_bends - last_bend)
                 last_bend = protein.valid_bends
                 L = protein.L
                 E = protein.u
         E_tot += E * (protein.valid_bends - last_bend)
         L_tot += L * (protein.valid_bends - last_bend)
         E_list[i] += E_tot / protein.valid_bends
         L_list[i] += L_tot / protein.valid_bends
 for i in range(num_T):
     E_list[i] = E_list[i] / len(seed_list)
     L_list[i] = L_list[i] / len(seed_list)
from numpy import savez, empty, load, copy
from numpy.random import seed

if __name__=="__main__":
    seed(6443578)

    T = 510
    n_monomers = 30
    max_bends = 1e6

    npzfile = load(abs_path + r'/Data_files/Oppgave_4_1_{}_pot.npz'.format(str(n_monomers)))
    potentials = copy(npzfile['potentials'])
    npzfile.close()

    protein = Protein(n_monomers, T)
    lowest_E = 0
    lowest_L = 0
    protein_lowest_E = empty(n_monomers)

    protein.potentials = potentials
    print (potentials-protein.potentials)

    E, L, last_bend_or_change_T = 0, n_monomers, 0

    while (protein.valid_bends < max_bends):
        if (protein.valid_bends%1000==0):
            print (protein.valid_bends)
        if protein.bend_protein():
            if (protein.u < lowest_E):
                lowest_E = protein.u
Пример #6
0
from sys import path
from os.path import dirname

abs_path = dirname(dirname(__file__))
path.insert(0, abs_path + r'/Protein_class')
from Protein_class import Protein
path.__delitem__(0)

from numpy.random import seed

if __name__ == "__main__":
    seed(27643)

    protein = Protein(10, 300)

    protein.plot_protein()

    protein.bend_protein()

    protein.plot_protein()

    while (protein.valid_bends < 2):
        protein.bend_protein()

    protein.plot_protein()
    start = time()

    while (len(seed_list) < 128):

        new_seed = randint(10, int(4294967290 / 2)) * 2 - randint(0, 2)
        valid_seed = True
        for old_seed in seed_list:
            if old_seed == new_seed:
                valid_seed = False

        if valid_seed:
            print("\n{}\n".format(len(seed_list) + 1))
            seed((new_seed))
            seed_list = append(seed_list, new_seed)
            protein0 = Protein(length, 0)

            for i in range(41):

                print(T_list[i], d(T_list[i], d_max, s))

                protein = Protein(length, T_list[i])
                protein.potentials = protein0.potentials
                E, E_tot, L_tot, L, last_bend = 0, 0, 0, length, 0

                while (protein.valid_bends < d(T_list[i], d_max, s)):
                    if protein.bend_protein():
                        L_tot += L * (protein.valid_bends - last_bend)
                        E_tot += E * (protein.valid_bends - last_bend)
                        last_bend = protein.valid_bends
                        L = protein.L