def rotate_by_euler(self, x_turn, y_turn, z_turn, x_trans=0, y_trans=0, z_trans=0, rad=False, com=False): """ Rotate this Structure instance around its centre. Arguments: *x_turn,y_turn,z_turn* Euler angles (in radians if rad == True, else in degrees) used to rotate structure, in order XYZ. *x_trans, y_trans, z_trans* extra translational movement if required. *com* centre of mass around which to rotate the structure. If False, rotates around centre of mass of structure. """ mat = Vector.euler_to_matrix(x_turn, y_turn, z_turn, rad) if not com: com = self.CoM.copy() newcom = com.matrix_transform(mat) offset = com - newcom self.matrix_transform(mat) self.translate(x_trans + offset.x, y_trans + offset.y, z_trans + offset.z)
def get_pos_vector(self): """ Return: Vector instance containing 3D coordinates of the atom. """ return Vector.Vector(self.x, self.y, self.z)
def write_sasd_to_pdb(dens_map,sasds,pdb): """ Outputs sasds to .pdb file Arguments: *dens_map* Solvent accessible surface on masked array *sasds* dictionary of sasds *pdb* .pdb file sasds were calculated on """ if not os.path.exists('./Jwalk_results'): os.makedirs('./Jwalk_results') apix = dens_map.apix origin = dens_map.origin path_coord = {} for xl in sasds: a = [] for (x,y,z) in sasds[xl]: a.append([(x*apix)+origin[0], (y*apix)+origin[1], (z*apix)+origin[2]]) path_coord[xl] = a with open('./Jwalk_results/%s_crosslinks.pdb' % pdb[:-4],'w') as pdb: m_count = 1 for xl in path_coord: (aa1,chain1,res1)=xl[0] (aa2,chain2,res2)=xl[1] sasd=xl[2] count = 1 pdb.write('MODEL %d %s%d%s-%s%d%s\n' % (m_count,res1,aa1,chain1,res2,aa2,chain2)) m_count = m_count+1 for (x,y,z) in path_coord[xl]: p=Vector.Vector(x,y,z) a=p.to_atom() a.record_name = 'ATOM' a.serial = count a.atom_name = 'C' a.alt_loc = '' a.res = 'GLY' a.chain = 'A' a.res_no = count a.icode = '' a.occ = 1 a.temp_fac = 0 a.elem = 'C' a.charge = '' #print a.__dict__ #atom = BioPyAtom(a) pdb.write(a.write_to_PDB()) count +=1 pdb.write('END\n')
def randomise_position(self, max_trans, max_rot, v_grain=30, rad=False, verbose=False): """ Randomise the position of the Structure instance using random rotations and translations. Arguments: *max_trans* Maximum translation permitted *max_rot* Maximum rotation permitted (in degree if rad=False) *v_grain* Graning Level for the generation of random vetors (default=30) Return: Transformed position of Structure object """ t_v = Vector.random_vector(-v_grain, v_grain).unit() r_v = Vector.random_vector(-v_grain, v_grain).unit() if max_trans <= 0: t_dist = 0 else: t_dist = randrange(max_trans) if max_rot <= 0: r_ang = 0 else: r_ang = randrange(max_rot) t_v = t_v.times(t_dist) self.rotate_by_axis_angle(r_v.x, r_v.y, r_v.z, r_ang, t_v.x, t_v.y, t_v.z, rad=rad) #self.translate(t_v.x, t_v.y, t_v.z) if verbose: print(r_v.x, r_v.y, r_v.z, r_ang, t_v.x, t_v.y, t_v.z) return (r_v.x, r_v.y, r_v.z, r_ang, t_v.x, t_v.y, t_v.z)
def spiral_sweep(self, structure_instance, axis, dist, no_of_structs, loc_ang_range, loc_axis, flag, atom_com_ind=False,write=False): """ Generate an ensemble of Structure Instance Arguments: *structure_instance* Input Structure Instance *axis* 3-ple, axis for translation *dist* int, translation range (Angstroms) *no_of_structs* int, number of structures to output *loc_axis* 3-ple, axis for local rotation around centre of mass *loc_ang_range* tuple, rotation range for local rotation (degrees) *flag* string, prefix name for outputted pdb files *atom_com_ind* int, index of atom to rotate around. If False, rotates around centre of mass. *write* True will write out each Structure Instance in the ensemble as single PDB. Return: list of Structure Instance in which each item is [structure_instance_name,structure_instance] """ ensemble_list=[] file_name0='mod_0' ensemble_list.append([file_name0,structure_instance]) count=0 # Work out distance between adjacent structures grain = dist/no_of_structs # Make axis into vector of length 1 axis = Vector.Vector(axis[0], axis[1], axis[2]).unit() for r in range(no_of_structs): file_name=flag+str(r+1)+".pdb" # Translate structure along axis structure_instance.translate(axis.x*r*grain,axis.y*r*grain,axis.z*r*grain) # Rotation around centre of mass loc_grain = (loc_ang_range[1]-loc_ang_range[0])/no_of_structs if atom_com_ind: loc_point = self[atom_com_ind].get_pos_vector() structure_instance.rotate_by_axis_angle(loc_axis[0],loc_axis[1],loc_axis[2], r*loc_grain, com=loc_point) else: structure_instance.rotate_by_axis_angle(loc_axis[0],loc_axis[1],loc_axis[2], r*loc_grain) if write==True: structure_instance.write_to_PDB(file_name) ensemble_list.append([file_name[:-4],structure_instance]) else: ensemble_list.append([file_name[:-4],structure_instance]) structure_instance.reset_position() return ensemble_list
def get_torsion_angles(self): """ Return: List of torsion angles in Structure instance. """ vectorList = self.vectorise() angles = [] for v in range(len(vectorList) - 2): angles.append( Vector.altTorsion(vectorList[v], vectorList[v + 1].reverse(), vectorList[v + 2])) return angles
def calculate_centroid(self): """Return centre of mass of structure as a Vector instance.""" x_Total = 0.0 y_Total = 0.0 z_Total = 0.0 natom = 0.0 for atom in self.atomList: x = atom.get_x() y = atom.get_y() z = atom.get_z() x_Total += x y_Total += y z_Total += z natom += 1 x_CoM = x_Total / natom y_CoM = y_Total / natom z_CoM = z_Total / natom return Vector.Vector(x_CoM, y_CoM, z_CoM)
def __init__(self, ul_list, x, y, z): """ Constructor to initialise the Vector gene. Arguments: *ul_list* A list containing the min and max translation allowed for the VectorGene. *x* x coordinate of a component. *y* y coordinate of a component. *z* z coordinate of a component. """ self.ul_list = ul_list self.x = x self.y = y self.z = z self.value = Vector(x, y, z)
def rotate_by_axis_angle(self, x, y, z, turn, x_trans=0, y_trans=0, z_trans=0, rad=False, com=False): """ Rotate the Structure instance around its centre. Arguments: *turn* angle (in radians if rad == True, else in degrees) to rotate map. *x,y,z* axis to rotate about, ie. x,y,z = 0,0,1 rotates the structure round the xy-plane. *x_trans, y_trans, z_trans* extra translational movement if required. *com* centre of mass around which to rotate the structure. If False, rotates around centre of mass of structure. """ mat = Vector.axis_angle_to_matrix(x, y, z, turn, rad) if not com: com = self.CoM.copy() newcom = com.matrix_transform(mat) offset = com - newcom self.matrix_transform(mat) self.translate(x_trans + offset.x, y_trans + offset.y, z_trans + offset.z)
def calculate_centre_of_mass(self): """ Return: Center of mass of structure as a Vector instance. """ x_momentTotal = 0.0 y_momentTotal = 0.0 z_momentTotal = 0.0 massTotal = 0.0 for atom in self.atomList: x = atom.get_x() y = atom.get_y() z = atom.get_z() m = atom.get_mass() x_momentTotal += x * m y_momentTotal += y * m z_momentTotal += z * m massTotal += m x_CoM = x_momentTotal / massTotal y_CoM = y_momentTotal / massTotal z_CoM = z_momentTotal / massTotal return Vector.Vector(x_CoM, y_CoM, z_CoM)
def VQ(D, n, epochs, alpha0=0.5, lam0=False): """ Function to clusters a set of vectors (D) into a number (n) of codebook vectors Arguments: *n* number of VQ points to generate *epochs* number of iterations to run the algorithm *alpha0* NOTE: Ask Daven regarding this parameter. *lam0* NOTE: Ask Daven regarding this parameter. """ if not lam0: lam0 = n / 2. dlen, dim = D.shape neurons = (np.random.rand(n, dim - 1) - 0.5) * 0.2 train_len = epochs * dlen #random.seed(int(100*time())) den_sum = sum(D[:, 3]) den_culm = [] den_culm.append(D[0, 3]) for i in range(1, dlen): den_culm.append(den_culm[i - 1] + D[i, 3]) den_culm = np.matrix(den_culm) den_rand = den_sum * np.random.rand(train_len, 1) sample_inds = [] for j in range(train_len): #if j%100000 == 0: # print str(j)+' j' min_index = den_rand[j] < den_culm sample_inds.append(np.nonzero(min_index)[1][0, 0]) lam = lam0 * (0.01 / lam0)**(np.arange(train_len) / float(train_len)) alpha = alpha0 * (0.005 / alpha0)**(np.arange(train_len) / float(train_len)) for i in range(train_len): #if i%5000 == 0: # print i x = D[sample_inds[i], :3] x = np.array([int(y) for y in x]) known = np.array([not math.isnan(y) for y in x]) X = np.repeat([x], [n], axis=0) #x[ones((n,1), dtype='i'), known] X = np.array(X[:, known], dtype='i') Dx = np.matrix(neurons[:, known] - X) inds = sorted(enumerate(np.power(Dx, 2) * np.matrix(known).T), key=lambda t: t[1]) inds = np.array([a[0] for a in inds]) ranking = np.zeros(len(inds)) ranking[inds] = range(n) h = map(math.exp, -ranking / lam[i]) H = np.repeat([h], [len(known)], axis=0).T neurons = neurons + (alpha[i] * H) * (X - neurons[:, known]) return [Vector(x[0], x[1], x[2]) for x in neurons]
from TEMPy.StructureParser import PDBParser from TEMPy.MapParser import MapParser import numpy as np # define point for rotation # tempy examples use COM from input structure # rotating against 0 0 0 doesn't seem to work import TEMPy.Vector as Vector com = Vector.Vector(90, 90, 90) # read in map target_map = MapParser.readMRC('GLIC_pH5_half1_unfil.mrc') #read target map # rotate along x, y, z target_map = target_map.rotate_by_axis_angle(1, 0, 0, np.rad2deg(-3.1396619777494124), com) target_map = target_map.rotate_by_axis_angle(0, 1, 0, np.rad2deg(0.0005038746980934731), com) target_map = target_map.rotate_by_axis_angle(0, 0, 1, np.rad2deg(2.125868534775962), com) # translate along x, y, z target_map = target_map.translate(-42, -58, 5) # save map target_map.write_to_MRC_file('moved.mrc') # Writing out to MRC file