def coulomb_energy(r, switchd, nbcutoff): ''' given a distance, calculate the coulomb energy ''' Uel_kCpM1 = np.zeros(len(r)) Uel1 = np.zeros(len(r)) coor = np.zeros((4, 3)) charge = np.zeros(4) charge[0] = charge[-1] = 2 e = 1 for (i, ri) in enumerate(r): coor[-1, 0] = ri # (Uel_kCpM1[i], Uel1[i]) = coulomb.coulomb(coor, charge, e, ARGS.temperature, switchd, nbcutoff) (Uel_kCpM1[i], Uel1[i]) = coulomb.screen_coulomb( coor, charge, e, ARGS.temperature, 9.61, switchd, nbcutoff) # screened return (Uel_kCpM1, Uel1)
def coulomb_energy(r, switchd, nbcutoff): ''' given a distance, calculate the coulomb energy ''' Uel_kCpM1 = np.zeros(len(r)) Uel1 = np.zeros(len(r)) coor = np.zeros((4, 3)) charge = np.zeros(4) charge[0] = charge[-1] = 2 e = 1 for (i, ri) in enumerate(r): coor[-1, 0] = ri # (Uel_kCpM1[i], Uel1[i]) = coulomb.coulomb(coor, charge, e, ARGS.temperature, switchd, nbcutoff) (Uel_kCpM1[i], Uel1[i]) = coulomb.screen_coulomb(coor, charge, e, ARGS.temperature, 9.61, switchd, nbcutoff) # screened return (Uel_kCpM1, Uel1)
def dna_mc_save_info(ARGS, cg_dna, aa_dna, cg_pro, aa_pro, vecXYZ, lp, trialbeads, beadgroups, group_masks, all_beads, dna_bead_masks, aa_pgroup_masks, cg_pgroup_masks, all_proteins, aa_all, aa_pro_mask, aa_dna_mask, bp_per_bead, dna_type='b'): ''' this function perform nsteps Monte-Carlo moves on the cg_dna ''' timestr = time.strftime("_%y%m%d_%H%M%S") # prefix for output files all_dcd_name = ARGS.pdb[:-4] + timestr + '.dcd' aa_all_dcd_out = aa_all.open_dcd_write(all_dcd_name) if False: aa_all.send_coordinates_to_vmd(2222, 0) # create the coarse-grained DNA and protein dcd and pdb files cg_dna_dcd_name = 'cg_dna' + timestr + '.dcd' cg_pro_dcd_name = 'cg_pro' + timestr + '.dcd' cg_dna_dcd_out = cg_dna.open_dcd_write(cg_dna_dcd_name) cg_pro_dcd_out = cg_pro.open_dcd_write(cg_pro_dcd_name) cg_dna.write_dcd_step(cg_dna_dcd_out, 0, 1) cg_pro.write_dcd_step(cg_pro_dcd_out, 0, 1) cg_dna_pdb_name = 'cg_dna' + timestr + '.pdb' cg_pro_pdb_name = 'cg_pro' + timestr + '.pdb' cg_dna.write_pdb(cg_dna_pdb_name, 0, 'w') cg_pro.write_pdb(cg_pro_pdb_name, 0, 'w') # create a dummy sasmol object for the 3 orientation vectors for each bead # will write these out to dcd files to store the coordinates along the way vecX_mol = sasmol.SasMol(0) vecY_mol = sasmol.SasMol(0) vecZ_mol = sasmol.SasMol(0) error, mask = cg_dna.get_subset_mask('(all)') error = cg_dna.copy_molecule_using_mask(vecX_mol, mask, 0) error = cg_dna.copy_molecule_using_mask(vecY_mol, mask, 0) error = cg_dna.copy_molecule_using_mask(vecZ_mol, mask, 0) # the np.array recast these so they vecX_mol.setCoor(np.array([vecXYZ[0]])) vecY_mol.setCoor(np.array([vecXYZ[1]])) # do not update with vecXYZ vecZ_mol.setCoor(np.array([vecXYZ[2]])) vecX_dcd_name = 'vecX' + timestr + '.dcd' vecY_dcd_name = 'vecY' + timestr + '.dcd' vecZ_dcd_name = 'vecZ' + timestr + '.dcd' vecX_dcd_out = vecX_mol.open_dcd_write(vecX_dcd_name) vecY_dcd_out = vecY_mol.open_dcd_write(vecY_dcd_name) vecZ_dcd_out = vecZ_mol.open_dcd_write(vecZ_dcd_name) vecX_mol.write_dcd_step(vecX_dcd_out, 0, 1) vecY_mol.write_dcd_step(vecY_dcd_out, 0, 1) vecZ_mol.write_dcd_step(vecZ_dcd_out, 0, 1) # initialize variables for each run steps_from_0 = np.zeros(ARGS.nsteps, dtype='int64') xyz = np.copy(vecXYZ) d_coor = np.copy(cg_dna.coor()[0]) # unique memory for each p_coor = np.copy(cg_pro.coor()[0]) # unique memory for each # vectors between beads u, and average distance l (u, l) = dna_move.checkU(d_coor) # s print "(u, l) =", (u, l) # debug info lpl = lp / l # setup the presistence length paramater # yet to use a, and z type dna dna_energy_width = {'a': 0, 'b': 46., 'z': 0} w = dna_energy_width[dna_type.lower()] if w > l: w = np.floor(l) # print '~~~ %.2f > %.2f ~~~~~~~~~~~~~~~~~~~~~~~~' % (w, l) print ('>>> setting chain width (w) to %d (chain width < distance' % w, ' btwn beads)') dna_diam = {'a': 25.5, 'b': 23.7, 'z': 18.4} dna_bead_radius = 4.5 pro_bead_radius = 1.0 # 2A min seperation of CA atoms in database pro_pro_test = pro_bead_radius + pro_bead_radius dna_pro_test = dna_bead_radius + pro_bead_radius # calculate the energy of the starting positions wca0 = np.zeros((cg_dna.natoms(), cg_dna.natoms())) Ub0 = dna_move.energyBend(lpl, u, l) (Uwca0, wca0) = dna_move.f_energy_wca(w, d_coor, wca0, 0) U_T0 = Ub0 + Uwca0 # print '(Ub0, Uwca0, Ub0/U_T0, Uwca0/U_T0) = ', (Ub0, Uwca0, Ub0/U_T0, # Uwca0/U_T0) n_accept = 0 # total times configuration was accepted n_reject = 0 # total times configuration was rejected n_written = 0 # total times dcd write has been called fail_tally = 0 # number of times failed for particular iteration n_from_reload = 0 # number of stps since last reload n_reload = [0] # listt containing the i_goback values # this should not actually be >=, come back to this assert np.size(ARGS.theta_max) - 1 >= np.max(beadgroups), ( 'each group needs its own theta_max: %d < %d' % (np.size(ARGS.theta_max) - 1, np.max(beadgroups))) rg_old = cg_dna.calcrg(0) rg = np.zeros(ARGS.nsteps) Uel_kCpM = np.zeros(ARGS.nsteps) Uel = np.zeros(ARGS.nsteps) Uwca = np.zeros(ARGS.nsteps) Ub = np.zeros(ARGS.nsteps) # Main MC loop # while n_accept < ARGS.nsteps: # Choose a bead to rotate trial_bead = trialbeads[int((trialbeads.size) * np.random.random())] # Determine rotation to perform theta_max = ARGS.theta_max[beadgroups[trial_bead]] # option to scale thetaZ separatly thetaZ_max = 0 * np.float(theta_max) # thetaZ_max = np.float(theta_max) # option to scale thetaZ separatly thetaZ = 2 * thetaZ_max * np.random.random() - thetaZ_max thetaX = 2 * theta_max * np.random.random() - theta_max thetaY = 2 * theta_max * np.random.random() - theta_max thetaXYZ = [ thetaX / ARGS.n_soft, thetaY / ARGS.n_soft, thetaZ / ARGS.n_soft] # print theta_max, thetaXYZ if len(group_masks) == 0 or beadgroups[trial_bead] == len(group_masks): # Only DNA will be moving, create place-holder dummy coordinates p_coor_rot = np.zeros((0, 3)) else: p_mask = group_masks[beadgroups[trial_bead]] p_ind_rot = mask2ind(p_mask) p_ind_fix = mask2ind(-(p_mask - 1)) p_coor_rot = p_coor[p_ind_rot] p_coor_fix = p_coor[p_ind_fix] # generate a newly rotated model (d_coor[trial_bead:], xyz[:, trial_bead:], p_coor_rot ) = dna_move.beadRotate(d_coor[trial_bead - 1:], xyz[:, trial_bead - 1:], thetaXYZ, ARGS.n_soft, p_coor_rot) # store the rotated protein coordinates if beadgroups[trial_bead] < len(group_masks): p_coor[p_ind_rot] = p_coor_rot # verify the Rg_new < Rg_old * 1.01 d_coor_old = np.copy(cg_dna.coor()[0]) cg_dna.setCoor(np.array([(d_coor)])) # update dna coordinates rg_new = cg_dna.calcrg(0) rg_pass = True if rg_pass: # calculate the change in energy (dU) and the boltzman factor (p) (u, l) = dna_move.checkU(d_coor) Ub1 = dna_move.energyBend(lpl, u, l) # ~~~~ DNA interaction energy ~~~~~~# (Uwca1, wca1) = dna_move.f_energy_wca(w, d_coor, wca0, trial_bead) U_T1 = Ub1 + Uwca1 dU = U_T1 - U_T0 with warnings.catch_warnings(): warnings.filterwarnings('error') # need this for np warnings try: p = np.exp(-dU) except Warning: if dU > 99: p = 0 # s print 'energy was large, setting probability to 0' elif dU < 0: p = 1 # s print 'energy was negative, setting probability to # 1' else: print 'Warning: ~~> unclear OverflowError <~~ dU = ', dU print 'not sure where the error originated from' test = np.random.random() if p <= test: dna_pass = False # print 'step failed because of DNA energy' else: dna_pass = True # now check for collisions protein involved collisions if len(p_coor_rot) > 0: # only if proteins were rotated # ~~~~ Check for overlap, DNA-protein or protein-protein ~~~~~~# d_coor_fix = d_coor[trial_bead:] d_coor_rot = d_coor[:trial_bead] # check for protein-protein overlap if 1 == f_overlap2(p_coor_rot, p_coor_fix, pro_pro_test): print 'Protein-Protein' # print 'collision, set p=0' collisionless = False # print 'currently ignoring DNA-protein overlap' # check for DNA-protein overlap elif 1 == f_overlap2(p_coor_rot, d_coor_fix, dna_pro_test): print 'Potein-DNA (rot-fix)' # print 'collision, set p=0' collisionless = False print 'ignoring this for now' elif 1 == f_overlap2(p_coor_fix, d_coor_rot, dna_pro_test): print 'Potein-DNA (fix-rot)' # print 'collision, set p=0' collisionless = False else: # passed all collision tests collisionless = True if not collisionless: print 'failed because of collision' # there are no proteins rotated -> no possible collisions else: collisionless = True if rg_pass and dna_pass and collisionless: rg_old = rg_new n_from_reload += 1 steps_from_0[n_accept] = n_from_reload + n_reload[-1] # calculate the electrostatic energy of this configuration charge = bp_per_bead * 2 # in units of C (2C per bp) # These are kinda random... switchd = 200 nbcutoff = 350 e = 78.54 # dielectric constant for pure water # e = 1 # dielectric constant for vacuum # (Uel_kCpM1, Uel1) = coulomb.coulomb(cg_dna.coor(), # charge, e, ARGS.temperature, switchd, nbcutoff) ld = 9.61 # debye screening constant in Angstroms (Uel_kCpM1, Uel1) = coulomb.screen_coulomb(cg_dna.coor(), charge, e, ARGS.temperature, ld, switchd, nbcutoff) # store the energies for analysis rg[n_accept] = rg_new Uel_kCpM[n_accept] = Uel_kCpM1 Uel[n_accept] = Uel1 Uwca[n_accept] = Uwca1 Ub[n_accept] = Ub1 n_accept += 1 # increment accept counter # cg_dna.setCoor(d_coor) # <-- DO NOT use setCoor, want uniuqe mem # cg_pro.setCoor(p_coor) # <-- DO NOT use setCoor, want uniuqe mem cg_pro.setCoor(np.array([(p_coor)])) # update protein coordinates vecXYZ = np.copy(xyz) # update dna orientations vecX_mol.setCoor(np.array([vecXYZ[0]])) # independent of vecXYZ[0] vecY_mol.setCoor(np.array([vecXYZ[1]])) # independent of vecXYZ[1] vecZ_mol.setCoor(np.array([vecXYZ[2]])) # independent of vecXYZ[2] wca0 = np.copy(wca1) # update DNA WCA energy U_T0 = U_T1 # update total energy # print output regarding trial print "trial_bead(%3d) = %2d\t failed attempts = %2d" % (n_accept, trial_bead, fail_tally) fail_tally = 0 # reset fail_tally # print out the Rg print 'Rg = ', cg_dna.calcrg(0) # write out the accepted configuration for go-back use if ARGS.goback > 0: # these are incremented by one because the original coordinates # are saved (that is not the case for aa_all) cg_dna.write_dcd_step(cg_dna_dcd_out, 0, n_written + 1) cg_pro.write_dcd_step(cg_pro_dcd_out, 0, n_written + 1) vecX_mol.write_dcd_step(vecX_dcd_out, 0, n_written + 1) vecY_mol.write_dcd_step(vecY_dcd_out, 0, n_written + 1) vecZ_mol.write_dcd_step(vecZ_dcd_out, 0, n_written + 1) # recover an all atom representation and save coordinates to a dcd # this requires re-inserting the aa-coordinates which takes added # time so only do when designated if 0 == n_accept % ARGS.n_dcd_write: # ~~recover aa-DNA~~ error = dna_move.recover_aaDNA_model(cg_dna, aa_dna, vecXYZ, all_beads, dna_bead_masks) # ~~recover aa-Protein~~ dna_move.recover_aaPro_model(aa_pgroup_masks, cg_pgroup_masks, cg_pro, all_proteins, aa_pro) # ~~Combine aa Complete Structure~~ aa_all.set_coor_using_mask(aa_pro, 0, aa_pro_mask) aa_all.set_coor_using_mask(aa_dna, 0, aa_dna_mask) # ~~Write DCD step~~ n_written += 1 aa_all.write_dcd_step(aa_all_dcd_out, 0, n_written) else: # default ARGS.goback is -1 so this returns FALSE without user # input if fail_tally == ARGS.goback: i_goback = rewind(ARGS, n_accept, cg_dna_dcd_name, cg_dna, cg_pro_dcd_name, cg_pro, vecX_dcd_name, vecX_mol, vecY_mol, vecY_dcd_name, vecZ_mol, vecZ_dcd_name, vecXYZ) # revert dna coordinates cg_dna.setCoor(np.array([(d_coor_old)])) d_coor = np.copy(cg_dna.coor()[0]) # reset the dna coordinates # reset the reference energy (u, l) = checkU(d_coor) (Uwca0, wca0) = f_energy_wca(w, d_coor, wca0, 0) Ub0 = energyBend(lpl, u, l) U_T0 = Ub0 + Uwca0 n_from_reload = 0 n_reload.append(steps_from_0[i_goback - 1]) fail_tally = 0 # reset the fail counter else: fail_tally += 1 # increment bead reject counter # increment total reject counter n_reject += 1 # revert dna coordinates cg_dna.setCoor(np.array([(d_coor_old)])) d_coor = np.copy(cg_dna.coor()[0]) # reset the dna coordinates p_coor = np.copy(cg_pro.coor()[0]) # reset the protein coordinates xyz = np.copy(vecXYZ) # reset the dna orientations # save previous coordinates again if not ARGS.keep_unique: # ~~Write DCD step~~ n_written += 1 aa_all.write_dcd_step(aa_all_dcd_out, 0, n_written) cg_dna.write_dcd_step(cg_dna_all_dcd_out, 0, n_written + 1) cg_pro.write_dcd_step(cg_pro_all_dcd_out, 0, n_written + 1) aa_all.close_dcd_write(aa_all_dcd_out) os.remove(vecX_dcd_name) os.remove(vecY_dcd_name) os.remove(vecZ_dcd_name) if ARGS.keep_cg_files: cg_dna.close_dcd_write(cg_dna_dcd_out) cg_pro.close_dcd_write(cg_pro_dcd_out) else: os.remove(cg_dna_pdb_name) os.remove(cg_pro_pdb_name) os.remove(cg_dna_dcd_name) os.remove(cg_pro_dcd_name) if ARGS.goback > 0: np.savetxt(timestr + 'n_from_0.txt', steps_from_0, fmt='%d') print "accepted %d moves" % n_accept print "rejected %d moves" % n_reject # print n_reload # print steps_from_0 return (rg, Uel_kCpM, Uel, Uwca, Ub)
def dna_mc_save_info(ARGS, cg_dna, aa_dna, cg_pro, aa_pro, vecXYZ, lp, trialbeads, beadgroups, group_masks, all_beads, dna_bead_masks, aa_pgroup_masks, cg_pgroup_masks, all_proteins, aa_all, aa_pro_mask, aa_dna_mask, bp_per_bead, dna_type='b'): ''' this function perform nsteps Monte-Carlo moves on the cg_dna ''' timestr = time.strftime("_%y%m%d_%H%M%S") # prefix for output files all_dcd_name = ARGS.pdb[:-4] + timestr + '.dcd' aa_all_dcd_out = aa_all.open_dcd_write(all_dcd_name) if False: aa_all.send_coordinates_to_vmd(2222, 0) # create the coarse-grained DNA and protein dcd and pdb files cg_dna_dcd_name = 'cg_dna' + timestr + '.dcd' cg_pro_dcd_name = 'cg_pro' + timestr + '.dcd' cg_dna_dcd_out = cg_dna.open_dcd_write(cg_dna_dcd_name) cg_pro_dcd_out = cg_pro.open_dcd_write(cg_pro_dcd_name) cg_dna.write_dcd_step(cg_dna_dcd_out, 0, 1) cg_pro.write_dcd_step(cg_pro_dcd_out, 0, 1) cg_dna_pdb_name = 'cg_dna' + timestr + '.pdb' cg_pro_pdb_name = 'cg_pro' + timestr + '.pdb' cg_dna.write_pdb(cg_dna_pdb_name, 0, 'w') cg_pro.write_pdb(cg_pro_pdb_name, 0, 'w') # create a dummy sasmol object for the 3 orientation vectors for each bead # will write these out to dcd files to store the coordinates along the way vecX_mol = sasmol.SasMol(0) vecY_mol = sasmol.SasMol(0) vecZ_mol = sasmol.SasMol(0) error, mask = cg_dna.get_subset_mask('(all)') error = cg_dna.copy_molecule_using_mask(vecX_mol, mask, 0) error = cg_dna.copy_molecule_using_mask(vecY_mol, mask, 0) error = cg_dna.copy_molecule_using_mask(vecZ_mol, mask, 0) # the np.array recast these so they vecX_mol.setCoor(np.array([vecXYZ[0]])) vecY_mol.setCoor(np.array([vecXYZ[1]])) # do not update with vecXYZ vecZ_mol.setCoor(np.array([vecXYZ[2]])) vecX_dcd_name = 'vecX' + timestr + '.dcd' vecY_dcd_name = 'vecY' + timestr + '.dcd' vecZ_dcd_name = 'vecZ' + timestr + '.dcd' vecX_dcd_out = vecX_mol.open_dcd_write(vecX_dcd_name) vecY_dcd_out = vecY_mol.open_dcd_write(vecY_dcd_name) vecZ_dcd_out = vecZ_mol.open_dcd_write(vecZ_dcd_name) vecX_mol.write_dcd_step(vecX_dcd_out, 0, 1) vecY_mol.write_dcd_step(vecY_dcd_out, 0, 1) vecZ_mol.write_dcd_step(vecZ_dcd_out, 0, 1) # initialize variables for each run steps_from_0 = np.zeros(ARGS.nsteps, dtype='int64') xyz = np.copy(vecXYZ) d_coor = np.copy(cg_dna.coor()[0]) # unique memory for each p_coor = np.copy(cg_pro.coor()[0]) # unique memory for each # vectors between beads u, and average distance l (u, l) = dna_move.checkU(d_coor) # s print "(u, l) =", (u, l) # debug info lpl = lp / l # setup the presistence length paramater # yet to use a, and z type dna dna_energy_width = {'a': 0, 'b': 46., 'z': 0} w = dna_energy_width[dna_type.lower()] if w > l: w = np.floor(l) # print '~~~ %.2f > %.2f ~~~~~~~~~~~~~~~~~~~~~~~~' % (w, l) print('>>> setting chain width (w) to %d (chain width < distance' % w, ' btwn beads)') dna_diam = {'a': 25.5, 'b': 23.7, 'z': 18.4} dna_bead_radius = 4.5 pro_bead_radius = 1.0 # 2A min seperation of CA atoms in database pro_pro_test = pro_bead_radius + pro_bead_radius dna_pro_test = dna_bead_radius + pro_bead_radius # calculate the energy of the starting positions wca0 = np.zeros((cg_dna.natoms(), cg_dna.natoms())) Ub0 = dna_move.energyBend(lpl, u, l) (Uwca0, wca0) = dna_move.f_energy_wca(w, d_coor, wca0, 0) U_T0 = Ub0 + Uwca0 # print '(Ub0, Uwca0, Ub0/U_T0, Uwca0/U_T0) = ', (Ub0, Uwca0, Ub0/U_T0, # Uwca0/U_T0) n_accept = 0 # total times configuration was accepted n_reject = 0 # total times configuration was rejected n_written = 0 # total times dcd write has been called fail_tally = 0 # number of times failed for particular iteration n_from_reload = 0 # number of stps since last reload n_reload = [0] # listt containing the i_goback values # this should not actually be >=, come back to this assert np.size(ARGS.theta_max) - 1 >= np.max(beadgroups), ( 'each group needs its own theta_max: %d < %d' % (np.size(ARGS.theta_max) - 1, np.max(beadgroups))) rg_old = cg_dna.calcrg(0) rg = np.zeros(ARGS.nsteps) Uel_kCpM = np.zeros(ARGS.nsteps) Uel = np.zeros(ARGS.nsteps) Uwca = np.zeros(ARGS.nsteps) Ub = np.zeros(ARGS.nsteps) # Main MC loop # while n_accept < ARGS.nsteps: # Choose a bead to rotate trial_bead = trialbeads[int((trialbeads.size) * np.random.random())] # Determine rotation to perform theta_max = ARGS.theta_max[beadgroups[trial_bead]] # option to scale thetaZ separatly thetaZ_max = 0 * np.float(theta_max) # thetaZ_max = np.float(theta_max) # option to scale thetaZ separatly thetaZ = 2 * thetaZ_max * np.random.random() - thetaZ_max thetaX = 2 * theta_max * np.random.random() - theta_max thetaY = 2 * theta_max * np.random.random() - theta_max thetaXYZ = [ thetaX / ARGS.n_soft, thetaY / ARGS.n_soft, thetaZ / ARGS.n_soft ] # print theta_max, thetaXYZ if len(group_masks) == 0 or beadgroups[trial_bead] == len(group_masks): # Only DNA will be moving, create place-holder dummy coordinates p_coor_rot = np.zeros((0, 3)) else: p_mask = group_masks[beadgroups[trial_bead]] p_ind_rot = mask2ind(p_mask) p_ind_fix = mask2ind(-(p_mask - 1)) p_coor_rot = p_coor[p_ind_rot] p_coor_fix = p_coor[p_ind_fix] # generate a newly rotated model (d_coor[trial_bead:], xyz[:, trial_bead:], p_coor_rot) = dna_move.beadRotate(d_coor[trial_bead - 1:], xyz[:, trial_bead - 1:], thetaXYZ, ARGS.n_soft, p_coor_rot) # store the rotated protein coordinates if beadgroups[trial_bead] < len(group_masks): p_coor[p_ind_rot] = p_coor_rot # verify the Rg_new < Rg_old * 1.01 d_coor_old = np.copy(cg_dna.coor()[0]) cg_dna.setCoor(np.array([(d_coor)])) # update dna coordinates rg_new = cg_dna.calcrg(0) rg_pass = True if rg_pass: # calculate the change in energy (dU) and the boltzman factor (p) (u, l) = dna_move.checkU(d_coor) Ub1 = dna_move.energyBend(lpl, u, l) # ~~~~ DNA interaction energy ~~~~~~# (Uwca1, wca1) = dna_move.f_energy_wca(w, d_coor, wca0, trial_bead) U_T1 = Ub1 + Uwca1 dU = U_T1 - U_T0 with warnings.catch_warnings(): warnings.filterwarnings('error') # need this for np warnings try: p = np.exp(-dU) except Warning: if dU > 99: p = 0 # s print 'energy was large, setting probability to 0' elif dU < 0: p = 1 # s print 'energy was negative, setting probability to # 1' else: print 'Warning: ~~> unclear OverflowError <~~ dU = ', dU print 'not sure where the error originated from' test = np.random.random() if p <= test: dna_pass = False # print 'step failed because of DNA energy' else: dna_pass = True # now check for collisions protein involved collisions if len(p_coor_rot) > 0: # only if proteins were rotated # ~~~~ Check for overlap, DNA-protein or protein-protein ~~~~~~# d_coor_fix = d_coor[trial_bead:] d_coor_rot = d_coor[:trial_bead] # check for protein-protein overlap if 1 == f_overlap2(p_coor_rot, p_coor_fix, pro_pro_test): print 'Protein-Protein' # print 'collision, set p=0' collisionless = False # print 'currently ignoring DNA-protein overlap' # check for DNA-protein overlap elif 1 == f_overlap2(p_coor_rot, d_coor_fix, dna_pro_test): print 'Potein-DNA (rot-fix)' # print 'collision, set p=0' collisionless = False print 'ignoring this for now' elif 1 == f_overlap2(p_coor_fix, d_coor_rot, dna_pro_test): print 'Potein-DNA (fix-rot)' # print 'collision, set p=0' collisionless = False else: # passed all collision tests collisionless = True if not collisionless: print 'failed because of collision' # there are no proteins rotated -> no possible collisions else: collisionless = True if rg_pass and dna_pass and collisionless: rg_old = rg_new n_from_reload += 1 steps_from_0[n_accept] = n_from_reload + n_reload[-1] # calculate the electrostatic energy of this configuration charge = bp_per_bead * 2 # in units of C (2C per bp) # These are kinda random... switchd = 200 nbcutoff = 350 e = 78.54 # dielectric constant for pure water # e = 1 # dielectric constant for vacuum # (Uel_kCpM1, Uel1) = coulomb.coulomb(cg_dna.coor(), # charge, e, ARGS.temperature, switchd, nbcutoff) ld = 9.61 # debye screening constant in Angstroms (Uel_kCpM1, Uel1) = coulomb.screen_coulomb(cg_dna.coor(), charge, e, ARGS.temperature, ld, switchd, nbcutoff) # store the energies for analysis rg[n_accept] = rg_new Uel_kCpM[n_accept] = Uel_kCpM1 Uel[n_accept] = Uel1 Uwca[n_accept] = Uwca1 Ub[n_accept] = Ub1 n_accept += 1 # increment accept counter # cg_dna.setCoor(d_coor) # <-- DO NOT use setCoor, want uniuqe mem # cg_pro.setCoor(p_coor) # <-- DO NOT use setCoor, want uniuqe mem cg_pro.setCoor(np.array([(p_coor)])) # update protein coordinates vecXYZ = np.copy(xyz) # update dna orientations vecX_mol.setCoor(np.array([vecXYZ[0]])) # independent of vecXYZ[0] vecY_mol.setCoor(np.array([vecXYZ[1]])) # independent of vecXYZ[1] vecZ_mol.setCoor(np.array([vecXYZ[2]])) # independent of vecXYZ[2] wca0 = np.copy(wca1) # update DNA WCA energy U_T0 = U_T1 # update total energy # print output regarding trial print "trial_bead(%3d) = %2d\t failed attempts = %2d" % ( n_accept, trial_bead, fail_tally) fail_tally = 0 # reset fail_tally # print out the Rg print 'Rg = ', cg_dna.calcrg(0) # write out the accepted configuration for go-back use if ARGS.goback > 0: # these are incremented by one because the original coordinates # are saved (that is not the case for aa_all) cg_dna.write_dcd_step(cg_dna_dcd_out, 0, n_written + 1) cg_pro.write_dcd_step(cg_pro_dcd_out, 0, n_written + 1) vecX_mol.write_dcd_step(vecX_dcd_out, 0, n_written + 1) vecY_mol.write_dcd_step(vecY_dcd_out, 0, n_written + 1) vecZ_mol.write_dcd_step(vecZ_dcd_out, 0, n_written + 1) # recover an all atom representation and save coordinates to a dcd # this requires re-inserting the aa-coordinates which takes added # time so only do when designated if 0 == n_accept % ARGS.n_dcd_write: # ~~recover aa-DNA~~ error = dna_move.recover_aaDNA_model(cg_dna, aa_dna, vecXYZ, all_beads, dna_bead_masks) # ~~recover aa-Protein~~ dna_move.recover_aaPro_model(aa_pgroup_masks, cg_pgroup_masks, cg_pro, all_proteins, aa_pro) # ~~Combine aa Complete Structure~~ aa_all.set_coor_using_mask(aa_pro, 0, aa_pro_mask) aa_all.set_coor_using_mask(aa_dna, 0, aa_dna_mask) # ~~Write DCD step~~ n_written += 1 aa_all.write_dcd_step(aa_all_dcd_out, 0, n_written) else: # default ARGS.goback is -1 so this returns FALSE without user # input if fail_tally == ARGS.goback: i_goback = rewind(ARGS, n_accept, cg_dna_dcd_name, cg_dna, cg_pro_dcd_name, cg_pro, vecX_dcd_name, vecX_mol, vecY_mol, vecY_dcd_name, vecZ_mol, vecZ_dcd_name, vecXYZ) # revert dna coordinates cg_dna.setCoor(np.array([(d_coor_old)])) d_coor = np.copy(cg_dna.coor()[0]) # reset the dna coordinates # reset the reference energy (u, l) = checkU(d_coor) (Uwca0, wca0) = f_energy_wca(w, d_coor, wca0, 0) Ub0 = energyBend(lpl, u, l) U_T0 = Ub0 + Uwca0 n_from_reload = 0 n_reload.append(steps_from_0[i_goback - 1]) fail_tally = 0 # reset the fail counter else: fail_tally += 1 # increment bead reject counter # increment total reject counter n_reject += 1 # revert dna coordinates cg_dna.setCoor(np.array([(d_coor_old)])) d_coor = np.copy(cg_dna.coor()[0]) # reset the dna coordinates p_coor = np.copy(cg_pro.coor()[0]) # reset the protein coordinates xyz = np.copy(vecXYZ) # reset the dna orientations # save previous coordinates again if not ARGS.keep_unique: # ~~Write DCD step~~ n_written += 1 aa_all.write_dcd_step(aa_all_dcd_out, 0, n_written) cg_dna.write_dcd_step(cg_dna_all_dcd_out, 0, n_written + 1) cg_pro.write_dcd_step(cg_pro_all_dcd_out, 0, n_written + 1) aa_all.close_dcd_write(aa_all_dcd_out) os.remove(vecX_dcd_name) os.remove(vecY_dcd_name) os.remove(vecZ_dcd_name) if ARGS.keep_cg_files: cg_dna.close_dcd_write(cg_dna_dcd_out) cg_pro.close_dcd_write(cg_pro_dcd_out) else: os.remove(cg_dna_pdb_name) os.remove(cg_pro_pdb_name) os.remove(cg_dna_dcd_name) os.remove(cg_pro_dcd_name) if ARGS.goback > 0: np.savetxt(timestr + 'n_from_0.txt', steps_from_0, fmt='%d') print "accepted %d moves" % n_accept print "rejected %d moves" % n_reject # print n_reload # print steps_from_0 return (rg, Uel_kCpM, Uel, Uwca, Ub)