def make_min(residue):#, fragments):
#### makes minimisation folder
gen.mkdir_directory('MIN')
#### makes em.mdp file for each residue
if not os.path.exists('em_'+residue+'.mdp'):
with open('em_'+residue+'.mdp','w') as em:
em.write('define = \n integrator = steep\nnsteps = 20000\nemtol = 750\nemstep = 0.001\ncutoff-scheme = Verlet\n')
def steer_to_aligned(protein_type, fc, input_file):
gen.mkdir_directory(g_var.merged_directory + 'STEER')
print('Applying ' + fc.replace('_', ' ') + ' position restraints',
end='\r')
os.chdir(g_var.merged_directory)
write_steered_mdp(g_var.merged_directory + fc + '_posres-nvt.mdp',
'-D' + fc.upper() + 'POSRES -DNP', 2000, 0.001)
gromacs([
g_var.args.gmx + ' grompp ' + ' -po md_out-merged_cg2at_steer_' + fc +
' -f ' + fc + '_posres-nvt.mdp ' + ' -p topol_final.top ' +
' -r merged_cg2at_' + protein_type + '.pdb ' + ' -c ' + input_file +
'.pdb ' + ' -o STEER/merged_cg2at_' + protein_type + '_steer_' + fc +
' ' + ' -maxwarn ' + str(2),
'STEER/merged_cg2at_' + protein_type + '_steer_' + fc + '.tpr'
])
os.chdir('STEER')
complete, equil = gromacs([
g_var.args.gmx + ' mdrun -v -nt ' + str(g_var.args.ncpus) +
' -pin on -deffnm merged_cg2at_' + protein_type + '_steer_' + fc +
' -c merged_cg2at_' + protein_type + '_steer_' + fc +
'.pdb -cpo merged_cg2at_' + protein_type + '_steer_' + fc + '.cpt',
'merged_cg2at_' + protein_type + '_steer_' + fc + '.pdb'
])
print('{:<100}'.format(''), end='\r')
return equil
def build_atomistic_system(cg_residues, residue_type, box_vec):
system = {}
atomistic_fragments = {}
#### for each residue type covert to atomistic except protein
# for residue_type in [key for value, key in enumerate(cg_residues) if key not in ['PROTEIN']]:
if residue_type not in system and residue_type != 'ION':
system[residue_type] = 0
#### reset counters for each residue type
print('Converting residue type: ' + residue_type)
#### creates folder for residue type
gen.mkdir_directory(g_var.working_dir + residue_type)
if residue_type in ['ION', 'SOL']:
atomistic_fragments[residue_type] = atomistic_non_protein_solvent(
residue_type, cg_residues[residue_type])
if residue_type in ['ION']:
system, atomistic_fragments = solvent_ion(box_vec, system,
atomistic_fragments,
residue_type)
else:
system, atomistic_fragments = solvent_sol(box_vec, system,
atomistic_fragments,
residue_type)
else:
atomistic_fragments[residue_type] = atomistic_non_protein_non_solvent(
residue_type, cg_residues[residue_type])
system, atomistic_fragments = non_solvent(box_vec, system,
atomistic_fragments,
residue_type)
return system
def build_atomistic_system(residue_type, a):
system = {}
atomistic_fragments = {}
#### for each residue type covert to atomistic except protein
# for residue_type in [key for value, key in enumerate(cg_residues) if key not in ['PROTEIN']]:
if residue_type not in system and residue_type != 'ION':
system[residue_type] = 0
#### reset counters for each residue type
print('Converting residue type: ' + residue_type)
#### creates folder for residue type
gen.mkdir_directory(g_var.working_dir + residue_type)
if residue_type in ['ION', 'SOL']:
atomistic_fragments[
residue_type], solvent_number = atomistic_non_protein_solvent(
residue_type, g_var.cg_residues[residue_type])
if residue_type in ['ION']:
system = solvent_ion(system, atomistic_fragments, residue_type)
else:
if solvent_number != 0:
system['SOL'] = solvent_number
else:
system = solvent_sol(system, atomistic_fragments, residue_type)
else:
atomistic_fragments[
residue_type], solvent_number = atomistic_non_protein_non_solvent(
residue_type, g_var.cg_residues[residue_type])
if solvent_number != 0:
system[residue_type] = solvent_number
else:
system = non_solvent(system, atomistic_fragments, residue_type)
print('{:<100}'.format(''), end='\r')
print('Finished converting: ' + residue_type)
return system
def steered_md_atomistic_to_cg_coord(chain):
os.chdir(g_var.working_dir+'PROTEIN')
gen.mkdir_directory('steered_md')
#### create bog standard mdp file, simulation is only 3 ps in a vaccum so settings should not have any appreciable effect
if not os.path.exists('steered_md.mdp'):
with open('steered_md.mdp', 'w') as steered_md:
steered_md.write('define = -DPOSRES_STEERED\nintegrator = md\nnsteps = 3000\ndt = '+g_var.vst+'\ncontinuation = no\n')
steered_md.write('constraint_algorithm = lincs\nconstraints = all-bonds\nns_type = grid\nnstlist = 25\nrlist = 1\n')
steered_md.write('rcoulomb = 1\nrvdw = 1\ncoulombtype = PME\npme_order = 4\nfourierspacing = 0.16\ntcoupl = V-rescale\n')
steered_md.write('tc-grps = system\ntau_t = 0.1\nref_t = 310\npcoupl = no\npbc = xyz\nDispCorr = no\ngen_vel = yes\ngen_temp = 310\ngen_seed = -1')
#### run grompp on chain
gromacs([g_var.gmx+' grompp '+
'-f steered_md.mdp '+
'-p topol_PROTEIN_at_rep_user_supplied_'+str(chain)+'.top '+
'-c min/PROTEIN_at_rep_user_supplied_'+str(chain)+'.pdb '+
'-r min/PROTEIN_novo_'+str(chain)+'.pdb '+
'-o steered_md/PROTEIN_at_rep_user_supplied_'+str(chain)+' -maxwarn 1 ', 'steered_md/PROTEIN_at_rep_user_supplied_'+str(chain)+'.tpr'])
#### run mdrun on steered MD
os.chdir('steered_md')
gromacs([g_var.gmx+' mdrun -v -pin on -deffnm PROTEIN_at_rep_user_supplied_'+str(chain)+' -c PROTEIN_at_rep_user_supplied_'+str(chain)+'.pdb',
'PROTEIN_at_rep_user_supplied_'+str(chain)+'.pdb'])
#### if no pdb file is created stop script with error message
if os.path.exists('PROTEIN_at_rep_user_supplied_'+str(chain)+'.pdb'):
pass
else:
sys.exit('Steered MD failed!')
def solvent_ion(box_vec, system, atomistic_fragments, residue_type):
#### creates ion pdb with header
gen.mkdir_directory(g_var.working_dir + 'ION/min')
skip = os.path.exists(g_var.working_dir + residue_type + '/' +
residue_type + '_merged.pdb')
if not skip:
pdb_ion = gen.create_pdb(
g_var.working_dir + residue_type + '/' + residue_type +
'_merged.pdb', box_vec)
for resid in atomistic_fragments[residue_type]:
for at_id, atom in enumerate(atomistic_fragments[residue_type][resid]):
#### write ion coordinate out
if not skip:
short_line = atomistic_fragments[residue_type][resid][at_id +
1]
pdb_ion.write(g_var.pdbline % (
(at_id + 1, short_line['atom'], short_line['res_type'],
' ', 1, short_line['coord'][0], short_line['coord'][1],
short_line['coord'][2], 0.00, 0.00)) + '\n')
if atomistic_fragments[residue_type][resid][
at_id + 1]['res_type'] != 'SOL':
if atomistic_fragments[residue_type][resid][
at_id + 1]['res_type'] not in system:
system[atomistic_fragments[residue_type][resid][at_id + 1]
['res_type']] = 1
else:
system[atomistic_fragments[residue_type][resid][at_id + 1]
['res_type']] += 1
return system, atomistic_fragments
def run_nvt(input_file):
print('\nRunning NVT on de novo system', end='\r')
os.chdir(g_var.merged_directory)
gen.mkdir_directory(g_var.merged_directory + 'NVT')
if g_var.user_at_input and g_var.args.disre and g_var.gmx_version:
write_steered_mdp(g_var.merged_directory + 'nvt.mdp',
'-DDISRES -DPOSRESCA', 5000, 0.001)
elif 'PROTEIN' in g_var.system:
write_steered_mdp(g_var.merged_directory + 'nvt.mdp', '-DPOSRESCA',
5000, 0.001)
else:
write_steered_mdp(g_var.merged_directory + 'nvt.mdp', '', 5000, 0.001)
gromacs([
g_var.args.gmx + ' grompp' + ' -po md_out-merged_cg2at_nvt' +
' -f nvt.mdp' + ' -p topol_final.top' + ' -r ' + input_file + '.pdb ' +
' -c ' + input_file + '.pdb ' + ' -o NVT/merged_cg2at_de_novo_nvt' +
' -maxwarn ' + str(2), 'NVT/merged_cg2at_de_novo_nvt.tpr'
])
os.chdir(g_var.merged_directory + 'NVT')
gromacs([
g_var.args.gmx + ' mdrun -v -nt ' + str(g_var.args.ncpus) +
' -pin on -deffnm merged_cg2at_de_novo_nvt' +
' -c merged_cg2at_de_novo_nvt.pdb -cpo merged_cg2at_de_novo_nvt.cpt',
'merged_cg2at_de_novo_nvt.pdb'
])
gen.file_copy_and_check('merged_cg2at_de_novo_nvt.pdb',
g_var.final_dir + 'final_cg2at_de_novo.pdb')
print('Completed NVT, please find final de_novo system: \n' +
g_var.final_dir + 'final_cg2at_de_novo.pdb')
def build_multi_residue_atomistic_system(cg_residues, sys_type):
#### initisation of counters
chain_count=0
coord_atomistic={}
g_var.seq_cg={sys_type:{}}
g_var.ter_res={sys_type:{}}
gen.mkdir_directory(g_var.working_dir+sys_type) ### make and change to protein directory
#### for each residue in protein
residue_type={}
residue_type_mass={}
new_chain = True
for cg_residue_id, residue_number in enumerate(cg_residues[sys_type]):
if np.round((cg_residue_id/len(cg_residues[sys_type]))*100,2).is_integer():
print('Converting de_novo '+sys_type+': ',np.round((cg_residue_id/len(cg_residues[sys_type]))*100,2),'%', end='\r')
resname = cg_residues[sys_type][residue_number][next(iter(cg_residues[sys_type][residue_number]))]['residue_name']
if new_chain:
if chain_count not in coord_atomistic:
if sys_type == 'PROTEIN':
g_var.backbone_coords[chain_count]=[]
coord_atomistic[chain_count]={}
g_var.seq_cg[sys_type][chain_count]=[]
g_var.ter_res[sys_type][chain_count]=[resname, False]
new_chain = False
coord_atomistic[chain_count][residue_number]={}
frag_location=gen.fragment_location(resname) ### get fragment location from database
residue_type[resname], residue_type_mass[resname] = at_mod.get_atomistic(frag_location)
g_var.seq_cg[sys_type] = add_to_sequence(g_var.seq_cg[sys_type], resname, chain_count)
new_chain = False
for group in residue_type[resname]:
for key in list(residue_type[resname][group].keys()):
if key not in cg_residues[sys_type][residue_number]:
del residue_type[resname][group][key]
if len(residue_type[resname][group]) > 0:
center, at_frag_centers, cg_frag_centers, group_fit = at_mod.rigid_fit(residue_type[resname][group], residue_type_mass[resname], residue_number, cg_residues[sys_type][residue_number])
at_connect, cg_connect = at_mod.connectivity(cg_residues[sys_type][residue_number], at_frag_centers, cg_frag_centers, group_fit, group)
for group_bead in group_fit:
if group_bead in g_var.res_top[resname]['CONNECT']:
at_connect, cg_connect, new_chain = at_mod.BB_connectivity(at_connect,cg_connect, cg_residues[sys_type], group_fit[group_bead], residue_number, group_bead)
if sys_type == 'PROTEIN':
g_var.backbone_coords[chain_count].append(np.append(cg_residues[sys_type][residue_number][group_bead]['coord'], 1))
xyz_rot_apply = at_mod.get_rotation(cg_connect, at_connect, center, resname, group, residue_number)
coord_atomistic[chain_count] = at_mod.apply_rotations(coord_atomistic[chain_count],residue_number, group_fit, center, xyz_rot_apply)
if new_chain:
g_var.ter_res[sys_type][chain_count][1] = resname
chain_count+=1
print('Completed initial conversion of '+sys_type+'\n')
g_var.system[sys_type]=chain_count
if sys_type == 'PROTEIN':
for chain in range(chain_count):
g_var.skip_disul[chain]=False
return coord_atomistic
def collect_input():
if not os.path.exists(g_var.args.c):
sys.exit('Cannot find CG input file: '+g_var.args.c)
gen.mkdir_directory(g_var.working_dir)
gen.mkdir_directory(g_var.final_dir)
gen.mkdir_directory(g_var.input_directory)
gen.mkdir_directory(g_var.merged_directory)
#### collates all input files in input directory
if g_var.args.a != None:
for file_num, file_name in enumerate(g_var.args.a):
if not os.path.exists(file_name):
sys.exit('cannot find atomistic input file: '+file_name)
gen.file_copy_and_check(file_name, g_var.input_directory+gen.path_leaf(file_name)[1])
os.chdir(g_var.input_directory)
gromacs([g_var.args.gmx+' editconf -f '+gen.path_leaf(file_name)[1]+' -resnr 0 -o '+g_var.input_directory+'AT_INPUT_'+str(file_num)+'.pdb', g_var.input_directory+'AT_INPUT_'+str(file_num)+'.pdb'])
if not os.path.exists(g_var.input_directory+'AT_INPUT_'+str(file_num)+'.pdb'):
sys.exit('\nFailed to process atomistic input file')
else:
g_var.user_at_input = True
os.chdir(g_var.start_dir)
gen.file_copy_and_check(g_var.args.c, g_var.input_directory+gen.path_leaf(g_var.args.c)[1])
os.chdir(g_var.input_directory)
gromacs([g_var.args.gmx+' -version', 'version.txt'])
gromacs([g_var.args.gmx+' editconf -f '+gen.path_leaf(g_var.args.c)[1]+' -resnr 0 -c -o '+g_var.input_directory+'CG_INPUT.pdb', g_var.input_directory+'CG_INPUT.pdb'])
if not os.path.exists(g_var.input_directory+'CG_INPUT.pdb'):
sys.exit('\nFailed to process coarsegrain input file')
def minimise_protein(protein, p_system, user_at_input):
#### makes em.mdp for each chain
os.chdir(g_var.working_dir+'/PROTEIN')
gen.mkdir_directory(g_var.working_dir+'FORCEFIELD')
copy_tree(f_loc.forcefield_location+f_loc.forcefield+'.ff', g_var.working_dir+'PROTEIN/'+f_loc.forcefield+'.ff/.')
copyfile(f_loc.forcefield_location+'/residuetypes.dat', 'residuetypes.dat')
make_min('PROTEIN')
for chain in range(protein):
pdb2gmx_selections=ask_terminal(chain, p_system)
minimise_protein_chain(chain, 'novo_', ' << EOF \n1\n'+str(pdb2gmx_selections[0])+'\n'+str(pdb2gmx_selections[1]))
pdb2gmx_selections = histidine_protonation(chain, 'novo_', pdb2gmx_selections)
if user_at_input:
minimise_protein_chain(chain, 'at_rep_user_supplied_', pdb2gmx_selections)
os.chdir('..')
def collect_input(cg, at):
if not os.path.exists(cg):
sys.exit('\ncannot find CG input file: '+cg)
gen.mkdir_directory(g_var.working_dir)
gen.mkdir_directory(g_var.final_dir)
gen.mkdir_directory(g_var.input_directory)
if not g_var.at2cg:
gen.mkdir_directory(g_var.merged_directory)
#### collates all input files in input directory
gen.file_copy_and_check(cg, g_var.input_directory+cg.split('/')[-1])
if at != None:
if not os.path.exists(at):
sys.exit('cannot find AT input file: '+at)
gen.file_copy_and_check(at, g_var.input_directory+at.split('/')[-1])
os.chdir(g_var.input_directory)
if cg.split('/')[-1].endswith('.tpr'):
input_sort(cg, 'conversion')
else:
gromacs([g_var.gmx+' editconf -f '+cg.split('/')[-1]+' -resnr 0 -o conversion_input.pdb -pbc', 'conversion_input.pdb'])
#### converts input files into pdb files
if at != None:
# input_sort(at, 'AT')
gromacs([g_var.gmx+' editconf -f '+at.split('/')[-1]+' -resnr 0 -o AT_input.pdb -pbc', 'AT_input.pdb'])
return True
return False
def build_atomistic_system(residue_type):
system={}
#### for each residue type covert to atomistic except protein
print('Converting residue type: ' +residue_type)
#### creates folder for residue type
gen.mkdir_directory(g_var.working_dir+residue_type)
if not os.path.exists(g_var.working_dir+residue_type+'/'+residue_type+'_merged.pdb'):
atomistic_fragments, system[residue_type] = at_np_solvent(residue_type, g_var.cg_residues[residue_type])
write_solvent(atomistic_fragments, residue_type)
elif residue_type in g_var.sol_residues:
atomistic_fragments, system[residue_type] = read_solvent_conversion(residue_type, g_var.cg_residues[residue_type])
else:
system[residue_type]=len(g_var.cg_residues[residue_type])
print('{:<100}'.format(''), end='\r')
print('Finished converting: '+residue_type)
return system
def alchembed(system):
os.chdir(g_var.working_dir+'MERGED')
gen.mkdir_directory('alchembed')
#### runs through each chain and run alchembed on each sequentially
for chain in range(system):
print('Running alchembed on chain: '+str(chain))
#### creates a alchembed mdp for each chain
if not os.path.exists('alchembed_'+str(chain)+'.mdp'):
with open('alchembed_'+str(chain)+'.mdp', 'w') as alchembed:
alchembed.write('define = -DPOSRES\nintegrator = sd\nnsteps = 500\ndt = 0.001\ncontinuation = no\nconstraint_algorithm = lincs')
alchembed.write('\nconstraints = h-bonds\nns_type = grid\nnstlist = 25\nrlist = 1\nrcoulomb = 1\nrvdw = 1\ncoulombtype = PME')
alchembed.write('\npme_order = 4\nfourierspacing = 0.16\ntc-grps = system\ntau_t = 0.1\nref_t = 310\npcoupl = no\ncutoff-scheme = Verlet')
alchembed.write('\npbc = xyz\nDispCorr = no\ngen_vel = yes\ngen_temp = 310\ngen_seed = -1\nfree_energy = yes\ninit_lambda = 0.00')
alchembed.write('\ndelta_lambda = 1e-3\nsc-alpha = 0.1000\nsc-power = 1\nsc-r-power = 6\ncouple-moltype = protein_'+str(chain))
alchembed.write('\ncouple-lambda0 = none\ncouple-lambda1 = vdw')
#### if 1st chain use minimised structure for coordinate input
if chain == 0:
gromacs([g_var.gmx+' grompp '+
'-po md_out-merged_cg2at_alchembed_'+str(chain)+' '+
'-f alchembed_'+str(chain)+'.mdp '+
'-p topol_final.top '+
'-r min/merged_cg2at_at_rep_user_supplied_minimised.pdb '+
'-c min/merged_cg2at_at_rep_user_supplied_minimised.pdb '+
'-o alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+' '+
'-maxwarn 1', 'alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+'.tpr'])
#### if not 1st chain use the previous output of alchembed tfor the input of the next chain
else:
gromacs([g_var.gmx+' grompp '+
'-po md_out-merged_cg2at_alchembed_'+str(chain)+' '+
'-f alchembed_'+str(chain)+'.mdp '+
'-p topol_final.top '+
'-r min/merged_cg2at_at_rep_user_supplied_minimised.pdb '+
'-c alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain-1)+'.pdb '+
'-o alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+' '+
'-maxwarn 1', 'alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+'.tpr'])
os.chdir('alchembed')
#### run alchembed on the chain of interest
gromacs([g_var.gmx+' mdrun -v -pin on -deffnm merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+
' -c merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+'.pdb', 'merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+'.pdb'])
os.chdir('..')
#### copy final output to the FINAL folder
gen.file_copy_and_check('alchembed/merged_cg2at_at_rep_user_supplied_alchembed_'+str(chain)+'.pdb', g_var.final_dir+'final_cg2at_at_rep_user_supplied.pdb')
gen.file_copy_and_check('merged_cg2at_no_steered.pdb', g_var.final_dir+'final_cg2at_no_steered.pdb')
def solvent_ion(system, atomistic_fragments, residue_type):
#### creates ion pdb with header
gen.mkdir_directory(g_var.working_dir + 'ION/MIN')
skip = os.path.exists(g_var.working_dir + residue_type + '/' +
residue_type + '_merged.pdb')
if not skip:
pdb_ion = gen.create_pdb(g_var.working_dir + residue_type + '/' +
residue_type + '_merged.pdb')
for at_id, atom in enumerate(atomistic_fragments[residue_type]):
#### write ion coordinate out
if not skip:
x, y, z = gen.trunc_coord(
[atom['coord'][0], atom['coord'][1], atom['coord'][2]])
pdb_ion.write(g_var.pdbline %
((at_id + 1, atom['atom_name'], atom['residue_name'],
' ', 1, x, y, z, 0.00, 0.00)) + '\n')
if atom['residue_name'] not in system:
system[atom['residue_name']] = 1
else:
system[atom['residue_name']] += 1
return system
def build_atomistic_system(residue_type, a):
system = {}
atomistic_fragments = {}
#### for each residue type covert to atomistic except protein
# for residue_type in [key for value, key in enumerate(cg_residues) if key not in ['PROTEIN']]:
if residue_type not in system and residue_type != 'ION':
system[residue_type] = 0
#### reset counters for each residue type
print('Converting residue type: ' + residue_type)
#### creates folder for residue type
gen.mkdir_directory(g_var.working_dir + residue_type)
if residue_type in ['ION', 'SOL']:
if os.path.exists(g_var.working_dir + 'SOL' +
'/SOL_all.pdb') and residue_type == 'SOL':
atomistic_fragments[residue_type], system[
'SOL'] = read_solvent_conversion(
residue_type, g_var.cg_residues[residue_type])
else:
atomistic_fragments[residue_type], solvent_number = at_np_solvent(
residue_type, g_var.cg_residues[residue_type])
if residue_type in ['ION']:
system = solvent_ion(system, atomistic_fragments, residue_type)
elif not os.path.exists(g_var.working_dir + 'SOL' + '/SOL_all.pdb'):
system['SOL'] = solvent_number
write_solvent(system, atomistic_fragments, residue_type)
else:
if not os.path.exists(g_var.working_dir + residue_type + '/' +
residue_type + '_merged.pdb'):
atomistic_fragments[residue_type], system[
residue_type] = at_np_solvent(residue_type,
g_var.cg_residues[residue_type])
write_solvent(system, atomistic_fragments, residue_type)
else:
system[residue_type] = len(g_var.cg_residues[residue_type])
print('{:<100}'.format(''), end='\r')
print('Finished converting: ' + residue_type)
return system
def collect_input(cg, at):
if not os.path.exists(cg):
sys.exit('\nPrint cannot find CG input file: '+cg)
gen.mkdir_directory(g_var.working_dir)
gen.mkdir_directory(g_var.final_dir)
gen.mkdir_directory(g_var.input_directory)
#### collates all input files in input directory
copyfile(cg, g_var.input_directory+cg.split('/')[-1])
if at != None:
if not os.path.exists(at):
sys.exit('Print cannot find AT input file: '+at)
copyfile(at, g_var.input_directory+at.split('/')[-1])
os.chdir(g_var.input_directory)
#### converts input files into pdb files
gromacs(g_var.gmx+' editconf -f '+cg.split('/')[-1]+' -resnr 0 -o CG_input.pdb')
if at != None:
gromacs(g_var.gmx+' editconf -f '+at.split('/')[-1]+' -resnr 0 -o AT_input.pdb')
return True
return False
def build_protein_atomistic_system(cg_residues, box_vec):
#### initisation of counters
chain_count=0
system={}
backbone_coords={}
backbone_coords[chain_count]=[]
terminal={}
terminal[chain_count]=[]
coordinates_atomistic={}
coordinates_atomistic[chain_count]={}
sequence={}
sequence[chain_count]=[]
print('Converting Protein')
gen.mkdir_directory(g_var.working_dir+'PROTEIN') ### make and change to protein directory
#### for each residue in protein
initial=True
residue_type={}
residue_type_mass={}
for cg_residue_id, residue_number in enumerate(cg_residues):
resname = cg_residues[residue_number][next(iter(cg_residues[residue_number]))]['residue_name']
if cg_residue_id == 0:
terminal[chain_count].append(f_loc.backbone[resname]['ter'])
coordinates_atomistic[chain_count][residue_number]={}
frag_location=at_mod.fragment_location(resname) ### get fragment location from database
residue_type[resname], residue_type_mass[resname] = at_mod.get_atomistic(frag_location)
for group in residue_type[resname]:
center, at_frag_centers, cg_frag_centers, group_fit = at_mod.rigid_fit(residue_type[resname][group], residue_type_mass[resname], residue_number, cg_residues[residue_number])
at_connect, cg_connect = at_mod.connectivity(cg_residues[residue_number], at_frag_centers, cg_frag_centers, group_fit, group)
if 'BB' in group_fit:
BB_connect = []
for atom in group_fit['BB']:
if group_fit['BB'][atom]['atom'] == f_loc.backbone[resname]['N_ter']:
N_ter=atom
if group_fit['BB'][atom]['atom'] == f_loc.backbone[resname]['C_ter']:
C_ter=atom
at_connect, cg_connect, new_chain = BB_connectivity(at_connect,cg_connect, cg_residues, group_fit['BB'], residue_number, N_ter, C_ter)
sequence = at_mod.add_to_sequence(sequence, resname, chain_count)
backbone_coords[chain_count].append(np.append(cg_residues[residue_number]['BB']['coord'], 1))
if resname == 'CYS' and 'BB' not in group_fit:
at_connect, cg_connect, disulphide, disul_at_info, disul_cg_info= find_closest_cysteine(at_connect, cg_connect, cg_residues, group_fit, residue_number)
if len(at_connect) == len(cg_connect):
xyz_rot_apply=at_mod.rotate(np.array(at_connect)-center, np.array(cg_connect)-center, False)
else:
print('atom connections: '+str(len(at_connect))+' does not equal CG connections: '+str(len(cg_connect)))
sys.exit('residue number: '+str(residue_number)+', residue type: '+str(resname)+', group: '+group)
for bead in group_fit:
for atom in group_fit[bead]:
group_fit[bead][atom]['coord'] = at_mod.rotate_atom(group_fit[bead][atom]['coord'], center, xyz_rot_apply)
atom_new = group_fit[bead][atom].copy()
coordinates_atomistic[chain_count][residue_number][atom] = atom_new
#### if disulphide bond found move the S atoms to within 2 A of each other
if 'disulphide' in locals():
if disulphide:
coordinates_atomistic[chain_count][residue_number] = shift_sulphur(residue_number, disul_at_info, disul_cg_info, coordinates_atomistic[chain_count], cg_residues)
disulphide = False
if new_chain:
terminal[chain_count].append(f_loc.backbone[resname]['ter'])
chain_count+=1
if cg_residue_id+1 != len(cg_residues):
backbone_coords[chain_count]=[]
coordinates_atomistic[chain_count]={}
terminal[chain_count]=[]
terminal[chain_count].append(f_loc.backbone[cg_residues[residue_number+1]['BB']['residue_name']]['ter'])
sequence[chain_count]=[]
if g_var.v >=1:
print('\n{0:^15}{1:^12}'.format('chain number', 'length of chain')) # \nchain number\tDelta A\t\tno in pdb\tlength of chain')
print('\n{0:^15}{1:^12}'.format('------------', '---------------'))
for chain in sequence:
print('{0:^15}{1:^12}'.format(chain, len(sequence[chain])))
print()
final_coordinates_atomistic = finalise_novo_atomistic(coordinates_atomistic, cg_residues, box_vec)
system['terminal_residue']=terminal
system['PROTEIN']=chain_count
return system, backbone_coords, final_coordinates_atomistic, sequence
if residue_type not in ['PROTEIN', 'ION']:
print('Minimising individual residues: ' + residue_type)
gro.non_protein_minimise(np_system[residue_type], residue_type)
at_mod_np.merge_minimised(residue_type, np_system, box_vec)
print('Minimising merged: ' + residue_type)
gro.minimise_merged(residue_type, np_system)
system.update(np_system)
build_non_protein_time = np.array(gmtime()[3:6])
non_protein_time = np.array(gmtime()[3:6])
#### creates merged folder
print('\nMerging all residue types to single file. (Or a possibly tea)\n')
if len(system) > 0:
gen.mkdir_directory(g_var.working_dir + 'MERGED')
#### make final topology in merged directory
gro.write_merged_topol(system, '_novo')
#### make minimisation directory
gro.make_min('merged_cg2at')
#### merges provided atomistic protein and residues types into a single pdb file into merged directory
if user_at_input and 'PROTEIN' in system:
at_mod.merge_system_pdbs(system, '_no_steered', cg_residues, box_vec)
at_mod.merge_system_pdbs(system, '_at_rep_user_supplied', cg_residues,
box_vec)
gro.minimise_merged_pdbs(system, '_at_rep_user_supplied')
if len(system) > 1:
gro.alchembed(system['PROTEIN'])
else:
copyfile(
g_var.working_dir +
