def compress_image(filename, s): """Plots the original image found at 'filename' and the rank s approximation of the image found at 'filename.' States the number of entries used to store the original image and the approximation. Parameters: filename (str): Image file path. s (int): Rank of new image. """ original = imread(filename) / 255 #grayscale if len(original.shape) == 2: reduced, num = SVD.svd_approx(original, s) #plot plt.subplot(121) plt.imshow(original, cmap='gray') plt.axis('off') plt.title('Entries Stored: ' + str(original.size)) plt.subplot(122) plt.imshow(reduced, cmap='gray') plt.axis('off') plt.title('Entries Stored: ' + str(num)) plt.suptitle('Difference: ' + str(original.size - num)) plt.show() #color else: R, num1 = SVD.svd_approx(original[:, :, 0], s) G, num2 = SVD.svd_approx(original[:, :, 1], s) B, num3 = SVD.svd_approx(original[:, :, 2], s) R = np.clip(R, 0, 1) G = np.clip(G, 0, 1) B = np.clip(B, 0, 1) num = num1 + num2 + num3 reduced = np.dstack((R, G, B)) #plot plt.subplot(121) plt.imshow(original) plt.axis('off') plt.title('Entries Stored: ' + str(original.size)) plt.subplot(122) plt.imshow(reduced) plt.axis('off') plt.title('Entries Stored: ' + str(num)) plt.suptitle('Difference: ' + str(original.size - num)) plt.show()
def cur_with_repeat(M, e): """ CUR decomposition of M, allowing for repeat selection of columns with retained energy e """ r = 50 mean_val = np.squeeze(np.asarray(np.true_divide(M.sum(1), (M != 0).sum(1)))) for i in range(M.shape[0]): for j in range(M.shape[1]): if M[i, j] != 0: M[i, j] = M[i, j] - mean_val[i] temp = np.squeeze(np.asarray(np.sum(np.square(M), axis=0))) col_prob = temp / float(sum(temp)) temp = np.squeeze(np.asarray(np.sum(np.square(M), axis=1))) row_prob = temp / float(sum(temp)) rows = np.random.choice(len(row_prob), r, replace=True, p=row_prob) cols = np.random.choice(len(col_prob), r, replace=True, p=col_prob) R = (M[rows, :].T / np.sqrt(r * row_prob[rows])).T C = M[:, cols] / np.sqrt(r * col_prob[cols]) W = M[rows[:, None], cols] S, V, D = SVD.svd_for_cur(W, 0.9) product = [D.T, l.matrix_power(l.pinv(V), 2), S.T] U = l.multi_dot(product) Y = l.multi_dot([C, U, R]) Y = (Y.T + mean_val).T return C, U, R, Y
def testSVD(): dataset = load_dataset.loaddata('./data-new/train.txt', '0') trainset, testset = split_train_and_test(dataset, 10, 1, 1) # testset = load_dataset.loaddata('./data-new/test.txt','1') trainset = load_dataset.construct_trainset(dataset) svd = SVD.SVD() svd.fit(trainset) targets = [score for (_, _, score) in testset] items = [[userid, itemid] for (userid, itemid, score) in testset] # items = [[userid,itemid]for (userid,itemid) in testset] predictions = svd.predict_all(items) p = [score for (_, _, score) in predictions] # fid=open('result1.txt','w') # # index=0 # for ruid,riid,score in predictions: # fid.write(ruid+','+riid+',') # fid.write(str(score)) # fid.write(',') # fid.write(str(targets[index])) # index+=1 # fid.write('\n') # # # fid.close() score = RMSE(p, targets) print(score)
def test_ready(N, p): #tests ready(M) M = SVD.prepare(N, p) rMin, OptM = SVD.APIndexCode(M) size = ready(OptM) print(size) #test_ready(10, .3)
def imageToWFA(img,Maxerror): Maxerror = Maxerror/10 img = img.convert('LA') img_array = numpy.array(img) n = 1 currentState = n - 1 images = [img_array] I = [1] F = [[0]] A = [[[0]],[[0]],[[0]],[[0]]] F[0][0] = getImageF(img_array) I[0] = 1 while currentState < n: currentImage = images[currentState] for j in range(4): subImageF = getImageF(currentImage,j) new_array = getSubImage(currentImage,j) MatrixA = getLinearMatrix(images) B = getLinearMatrix([new_array]) x = SVD.calculWeights(MatrixA,B) item = 0 for i in range(len(images)): valX = x[i][0] item += valX*getImageF(images[i]) error = math.floor(abs(item-getImageF(new_array))*10000)/100 stateExist = False if error <= Maxerror: stateExist = True for xIndex in range(len(x)): A[j][currentState][xIndex] = x[xIndex][0] if subImageF != 0.0 and stateExist == False: n += 1 J = 0 while J < 4: A[J].append([0]) for H in range(len(A[J])): while len(A[J][H]) < n: A[J][H].append(0) J += 1 I.append(0) F.append([subImageF]) A[j][currentState][n-1] = 1 newImage = getSubImage(currentImage,j) images.append(newImage) currentState += 1 wfa = WFA(n,I,F,A) return wfa
def symop(self, matrixA, matrixB, title=""): a = SVD.SVDSuperimposer() a.set(matrixA[1], matrixB[1]) x = [] x.append(matrixA[0]) x.append(matrixB[0]) COM = self.get_center_of_mass(x) print "COMPARISON " + title print "Centroid: " print COM a.run() R = np.transpose(a.get_rot()) print "Rotation Matrix:" print R print title + " Rotation Angle: " + self.getangle(R) angle = self.getangle(R) print title + " RMSD: " + a.get_rms() print '-----'
def test(N): #test SVD decoding with APIC p = .3 M = SVD.prepare(N, p) T = np.random.rand(N, 1) print(T) [Rmin, OptM] = SVD.APIndexCode(M) print(Rmin) X = SVDenc(OptM, T, Rmin) A = np.zeros((N, N)) for i in range(N): for j in range(N): if M[i][j] > .001 and M[i][j] != 1: A[i][j] = T[j][0] message = [] for i in range(N): t = SVDdec(OptM, X, i, A[i][:]) message.append(t) print(message)
def calcula_superposicion_SVD(pdbh1,pdbh2,originalPDBname,fittedPDBname,test=False): """ Calcula matriz de rotacion que aplicada sobre coords1 minimiza RMSD respecto a coords2 y crea archivo con formato PDB con la superposicion resultante. Emplea el algoritmo de 'Single Value Decomposition' del paquete SVD. """ def calcula_centro(coords): centro = [0,0,0] for coord in (coords): for dim in range(0,3): centro[dim] += coord[dim] for dim in range(0,3): centro[dim] /= len(coords) return centro def calcula_coordenadas_centradas(coords,centro): ccoords,total = [],0 for coord in (coords): ccoords.append(coord) for dim in range(0,3): ccoords[total][dim] -= centro[dim] total+=1 return ccoords def calcula_coordenadas_rotadas(coords,rotacion): rcoords = [0,0,0] for i in range(0,3): tmp = 0.0 for j in range(0,3): tmp += coords[j] * rotacion[i][j] rcoords[i] = tmp return rcoords # escribe fichero PDB con coordenadas originales pdbfile = open(originalPDBname, 'w') print >> pdbfile, "HEADER %s\n" % pdbh1['file'], for res in (pdbh1['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", print >> pdbfile, "HEADER %s\n" % pdbh2['file'], for res in (pdbh2['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", pdbfile.close() ## prepara coordenadas de atomos CA alineados (equivalentes) coords1,coords2 = pdbh1['align_coords'],pdbh2['align_coords'] centro1 = calcula_centro(coords1) centro2 = calcula_centro(coords2) ccoords1 = calcula_coordenadas_centradas(coords1,centro1) ccoords2 = calcula_coordenadas_centradas(coords2,centro2) ## prepara matriz producto para descomposicion matricial SVD matriz = U.Sigma.V matriz = [[0,0,0],[0,0,0],[0,0,0]] peso = 1.0/len(ccoords1) # todos los residuos cuentan igual for i in range(0,3): for j in range(0,3): tmp = 0.0 for k in range(0,len(ccoords1)): tmp += ccoords1[k][i] * ccoords2[k][j] * peso matriz[i][j]=tmp; if(test == True): for i in range(0,3): print "mat %f %f %f\n" % (matriz[i][0],matriz[i][1],matriz[i][2]), ## invoca descomposicion en valores singulares y comprueba matrix/determinante [U, Sigma, V] = SVD.svd( matriz ) if(test==True): for i in range(0,3): print "U %f %f %f\n" % (U[i][0],U[i][1],U[i][2]), for i in range(0,3): print "Vt %f %f %f\n" % (V[i][0],V[i][1],V[i][2]), rotacion = [[0,0,0],[0,0,0],[0,0,0]] for i in range(0,3): for j in range(0,3): rotacion[i][j]= U[j][0]*V[i][0] + U[j][1]*V[i][1] + U[j][2]*V[i][2] ## evalua error de la superposicion rmsd = 0.0 for n in range(0,len(coords1)): coords1_rot = calcula_coordenadas_rotadas(ccoords1[n],rotacion) for i in range(0,3): desv = ccoords2[n][i]-coords1_rot[i] rmsd += desv*desv rmsd /= len(coords1) ## imprime superposicion de todos los atomos en formato PDB pdbfile = open(fittedPDBname, 'w') # pdb superpuesto, coordenadas rotadas (1) print >> pdbfile, "HEADER %s (rotated)\n" % pdbh1['file'], print >> pdbfile, "REMARK Rotation matrix:\n", for i in range(0,3): print >> pdbfile, "REMARK %f %f %f\n" % \ (rotacion[i][0],rotacion[i][1],rotacion[i][2]), print >> pdbfile, "REMARK centroid: %f %f %f\n" % (centro1[0],centro1[1],centro1[2]), print >> pdbfile, "REMARK partner centroid: %f %f %f\n" % \ (centro2[0],centro2[1],centro2[2]), for res in (pdbh1['coords']): for atomo in res.split("\n"): if(atomo == ''): break atcoords = extrae_coords_atomo(res,atomo[12:16]) atcoords[0] -= centro1[0] # centralo atcoords[1] -= centro1[1] atcoords[2] -= centro1[2] coords_rot = calcula_coordenadas_rotadas(atcoords,rotacion) # trasladalo al pdb referencia atcoords[0] = centro2[0] + coords_rot[0] atcoords[1] = centro2[1] + coords_rot[1] atcoords[2] = centro2[2] + coords_rot[2] print >> pdbfile, "%s%8.3f%8.3f%8.3f%s" % \ (atomo[0:30],atcoords[0],atcoords[1],atcoords[2],atomo[54:]) print >> pdbfile, "TER\n", # pdb de referencia, coordenadas originales (2) print >> pdbfile, "HEADER %s\n" % pdbh2['file'], for res in (pdbh2['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", pdbfile.close() return sqrt(rmsd)
def CompletionGradient(X,shape,ObservedList,R,Ls,alpha=0,XoriginalTensor=None,isProd=False): #X is Dense Vector with only observed elements #Observed must be given as list of coordinate tuples #TrueX is 3 dimensional array N = 3 Xns = [critical.unfold(X,n,shape,ObservedList) for n in xrange(N)] print "unfolded" As = [zeros((shape[n],R)) for n in xrange(N)] #As = [SVD.getLeadingSingularVects(Xns[n],R) for n in xrange(N)] Rev = 100 for i in xrange(Rev): Asadd = [SVD.getLeadingSingularVects(Xns[n],R) for n in xrange(N)] for k in xrange(N): As[k] += Asadd[k] for k in xrange(N): As[k] /= Rev #As[k] += random.randn(shape[k],R)*0.01 n,m,l=shape def lossfunc(U,V,W): #print "loss start" XO = critical.HadamardProdOfSparseTensor(U,V,W,ObservedList) loss = norm(XO - X) #print "loss end" return loss #Xinit = flattenAs(As) #print "start bfgs" J = alg.createUnitTensor(3,R) #Mask = getMaskTensor(ObservedList,shape) U,V,W = As Ls[:] = [L*alpha if not L==None else 0 for L in Ls] Lu,Lv,Lw=Ls beta = 1e-8 isProd = False if not isProd: LuUse = alpha * Lu + beta * eye(n) LvUse = alpha * Lv + beta * eye(m) LwUse = alpha * Lw + beta * eye(l) #print U.shape, V.shape, W.shape Xest = XoriginalTensor #memory consuming threshold = 0.5*const.ConvergenceThreshold_NewCompletion maxiter=700 bfgs_maxiter=3 errorold = inf errorTest = inf expandedX = 0 Dw,Kw = separateLaplacian(Lw,l) Dv,Kv = separateLaplacian(Lv,m) Du,Ku = separateLaplacian(Lu,n) import itertools for steps in itertools.count(): if isProd: DSu = alpha * trace(dot(W.T*Dw,W)) * trace(dot(V.T*Dv,V)) KSu = alpha * trace(dot(W.T,dot(Kw,W))) * trace(dot(V.T,dot(Kv,V))) LuUse = DSu * Du - KSu * Ku + eye(n) #print "optimization of U" #print [U.shape,V.shape,W.shape] grad = lambda U:critical.Gradient(X,ObservedList,(U,V,W),LuUse,shape,R,0) loss = lambda U:lossfunc(U,V,W) U = LBFGS_matrix(loss,U,grad,maxiter=bfgs_maxiter) #print [U.shape,V.shape,W.shape] if isProd: DSv = alpha * trace(dot(U.T*Du,U)) * trace(dot(W.T*Dw,W)) KSv = alpha * trace(dot(U.T,dot(Ku,U))) * trace(dot(W.T,dot(Kw,W))) LvUse = DSv * Dv - KSv * Kv + eye(m) #print "optimization of V" grad = lambda V:critical.Gradient(X,ObservedList,(U,V,W),LvUse,shape,R,1) loss = lambda V:lossfunc(U,V,W) V = LBFGS_matrix(loss,V,grad,maxiter=bfgs_maxiter) if isProd: DSw = alpha * trace(dot(U.T*Du,U)) * trace(dot(V.T*Dv,V)) KSw = alpha * trace(dot(U.T,dot(Ku,U))) * trace(dot(V.T,dot(Kv,V))) LwUse = DSw * Dw - KSw * Kw + eye(l) #print "optimization of W" grad = lambda W:critical.Gradient(X,ObservedList,(U,V,W),LwUse,shape,R,2) loss = lambda W:lossfunc(U,V,W) W = LBFGS_matrix(loss,W,grad,maxiter=bfgs_maxiter) #grad = lambda (U,V,W) if False: XO = critical.HadamardProdOfSparseTensor(U,V,W,ObservedList) normrate = norm(XO) / norm(X) qubicnormrate = normrate ** (1.0 / 3) U /= qubicnormrate V /= qubicnormrate W /= qubicnormrate if steps % 20 == 1: Xest = alg.expand(J,[U,V,W]) errorTest = norm(Xest - XoriginalTensor) #print U errorObserved = lossfunc(U,V,W) if steps % 20 == 1: print "iter:",steps," err:",errorTest ," oberr:",errorObserved, " diff:", errorObserved-errorold, "norm;", norm(Xest) faultThreshold = 1e4 if errorObserved > faultThreshold or errorObserved != errorObserved: #やりなおし print "-----Try Again-----" print steps," steps, observation error=",errorObserved return CompletionGradient(X,shape,ObservedList,R,Ls,alpha,XoriginalTensor) if abs(errorObserved - errorold) < threshold or steps >= maxiter: expandedX = alg.expand(J,[U,V,W]) print "estimation finished in ",(steps+1),"steps." break errorold = errorObserved return expandedX
def classificationSVD(indice): scores = [0.] * 10 for label in range(10): scores[label] = SVD.distance_de_base(label, indice, M) return np.argmin(scores), scores[np.argmin(scores)]
# coding:utf8 ''' Created on 2018年3月7日 @author: XuXianda ''' import SVD from numpy import * from numpy import linalg as la matData = mat(SVD.loadExData2()) #我们试一下默认的推荐 print 'The default recommendation:' print SVD.recommend(matData, 2) #然后,我们试一下使用SVD的推荐效果 U, Sigma, VT = la.svd(matData) print 'The recommendation using SVD:' print SVD.recommend(matData, 2, estMethod=SVD.svdEst)
def calcula_superposicion_SVD(pdbh1, pdbh2, originalPDBname, fittedPDBname, test=False): """ Calcula matriz de rotacion que aplicada sobre coords1 minimiza RMSD respecto a coords2 y crea archivo con formato PDB con la superposicion resultante. Emplea el algoritmo de 'Single Value Decomposition' del paquete SVD. """ def calcula_centro(coords): centro = [0, 0, 0] for coord in (coords): for dim in range(0, 3): centro[dim] += coord[dim] for dim in range(0, 3): centro[dim] /= len(coords) return centro def calcula_coordenadas_centradas(coords, centro): ccoords, total = [], 0 for coord in (coords): ccoords.append(coord) for dim in range(0, 3): ccoords[total][dim] -= centro[dim] total += 1 return ccoords def calcula_coordenadas_rotadas(coords, rotacion): rcoords = [0, 0, 0] for i in range(0, 3): tmp = 0.0 for j in range(0, 3): tmp += coords[j] * rotacion[i][j] rcoords[i] = tmp return rcoords # escribe fichero PDB con coordenadas originales pdbfile = open(originalPDBname, 'w') print >> pdbfile, "HEADER %s\n" % pdbh1['file'], for res in (pdbh1['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", print >> pdbfile, "HEADER %s\n" % pdbh2['file'], for res in (pdbh2['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", pdbfile.close() ## prepara coordenadas de atomos CA alineados (equivalentes) coords1, coords2 = pdbh1['align_coords'], pdbh2['align_coords'] centro1 = calcula_centro(coords1) centro2 = calcula_centro(coords2) ccoords1 = calcula_coordenadas_centradas(coords1, centro1) ccoords2 = calcula_coordenadas_centradas(coords2, centro2) ## prepara matriz producto para descomposicion matricial SVD matriz = U.Sigma.V matriz = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] peso = 1.0 / len(ccoords1) # todos los residuos cuentan igual for i in range(0, 3): for j in range(0, 3): tmp = 0.0 for k in range(0, len(ccoords1)): tmp += ccoords1[k][i] * ccoords2[k][j] * peso matriz[i][j] = tmp if (test == True): for i in range(0, 3): print "mat %f %f %f\n" % (matriz[i][0], matriz[i][1], matriz[i][2]), ## invoca descomposicion en valores singulares y comprueba matrix/determinante [U, Sigma, V] = SVD.svd(matriz) if (test == True): for i in range(0, 3): print "U %f %f %f\n" % (U[i][0], U[i][1], U[i][2]), for i in range(0, 3): print "Vt %f %f %f\n" % (V[i][0], V[i][1], V[i][2]), rotacion = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] for i in range(0, 3): for j in range(0, 3): rotacion[i][ j] = U[j][0] * V[i][0] + U[j][1] * V[i][1] + U[j][2] * V[i][2] ## evalua error de la superposicion rmsd = 0.0 for n in range(0, len(coords1)): coords1_rot = calcula_coordenadas_rotadas(ccoords1[n], rotacion) for i in range(0, 3): desv = ccoords2[n][i] - coords1_rot[i] rmsd += desv * desv rmsd /= len(coords1) ## imprime superposicion de todos los atomos en formato PDB pdbfile = open(fittedPDBname, 'w') # pdb superpuesto, coordenadas rotadas (1) print >> pdbfile, "HEADER %s (rotated)\n" % pdbh1['file'], print >> pdbfile, "REMARK Rotation matrix:\n", for i in range(0, 3): print >> pdbfile, "REMARK %f %f %f\n" % \ (rotacion[i][0],rotacion[i][1],rotacion[i][2]), print >> pdbfile, "REMARK centroid: %f %f %f\n" % (centro1[0], centro1[1], centro1[2]), print >> pdbfile, "REMARK partner centroid: %f %f %f\n" % \ (centro2[0],centro2[1],centro2[2]), for res in (pdbh1['coords']): for atomo in res.split("\n"): if (atomo == ''): break atcoords = extrae_coords_atomo(res, atomo[12:16]) atcoords[0] -= centro1[0] # centralo atcoords[1] -= centro1[1] atcoords[2] -= centro1[2] coords_rot = calcula_coordenadas_rotadas(atcoords, rotacion) # trasladalo al pdb referencia atcoords[0] = centro2[0] + coords_rot[0] atcoords[1] = centro2[1] + coords_rot[1] atcoords[2] = centro2[2] + coords_rot[2] print >> pdbfile, "%s%8.3f%8.3f%8.3f%s" % \ (atomo[0:30],atcoords[0],atcoords[1],atcoords[2],atomo[54:]) print >> pdbfile, "TER\n", # pdb de referencia, coordenadas originales (2) print >> pdbfile, "HEADER %s\n" % pdbh2['file'], for res in (pdbh2['coords']): print >> pdbfile, res, print >> pdbfile, "TER\n", pdbfile.close() return sqrt(rmsd)
def centerData(X): X = X.copy() X -= np.mean(X, axis=0) return X X_centered = centerData(X) """ Use SVD on the centered data """ U, D, V = SVD(X_centered) """ Calculate the principal components """ new_dim = 2 X_new = U[:, :new_dim] * D[:new_dim] #we need to transpose X because the dimensions are on the columns in this case #X_new = PCs.T.dot(X_centered.T) names = loadtxt("short_names.txt", comments="#", dtype=str, delimiter="\n",
import PCA_centra import PCA_norm import SVD import ISOMAP if __name__ == '__main__': resfile = open('../result/result.csv', 'w') resfile.write('algorithm, dataset, K, accuracy\n') PCA_centra.main(resfile) PCA_norm.main(resfile) SVD.main(resfile) ISOMAP.main(resfile) resfile.close()
基于SVD的评分估计 ''' n=shape(dataMat)[1] simTotal=0.0 ratSimTotal=0.0 #奇异值分解,只利用包含90%能量值的奇异值 U,Sigma,VT=la.svd(dataMat) #对奇异值构建对角矩阵 Sig4=mat(eye(4)*Sigma[:4]) #利用U矩阵将物品转换到低维空间 xformedItems=dataMat.T*U[:,:4]*Sig4.I for j in range(n): userRating=dataMat[user,j] if userRating==0 or j==item: continue similarity=simMeas(xformedItems[item,:].T,xformedItems[j,:].T) print("the %d and %d similarity is: %f" % (item,j,similarity)) simTotal+=similarity ratSimTotal+=similarity*userRating if simTotal==0: return 0 else: return ratSimTotal/simTotal if __name__=='__main__': myMat=mat(SVD.loadExData()) myMat[0,1]=myMat[0,0]=myMat[1,0]=myMat[2,0]=4 myMat[3,3]=2 print(recommend(myMat,1,estMethod=svdEst,simMeas=SVD.pearsSim))
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon Nov 13 13:26:54 2017 """ import time import SVD import data import CUR import collaborative import errors start = time.time() U, sigma, V, Y = SVD.svd_retained_energy(data.M.todense(), 1) end = time.time() svd_time = end - start print("SVD") errors.calc_error(Y) print("Runtime: ", svd_time, " s") print("\n\n") start = time.time() U, sigma, V, Y = SVD.svd_retained_energy(data.M.todense(), 0.9) end = time.time() svdret_time = end - start print("SVD with 90% retained energy") errors.calc_error(Y) print("Runtime: ", svd_time, " s") print("\n\n") start = time.time()
def main(self, filetype): self.set = 1 for pdb in self.pdbs: print "Autoloading detected PDB file: %s" % pdb print ", ".join([str(x) for x in pdb.list_chains()]) commonAA = pdb.commonAA( 123, 531 ) #Only use amino acids 123-531 for superimposing and computing RMSD. f = open('input.txt', 'r') l = [] matrices = [] matrices.append([]) for line in f: if line.strip() == "": matrices.append(l) l = [] else: l.append(map(float, line.split(' '))) flag = 1 while flag: towrite1 = [] matrix_static = [] matrix_moving = [] towrite2 = [] counter1 = 1 counter2 = 1 input2 = question("What subunit is the static reference? (eg 5A)") input2 = input2.strip() matrixID2 = int(re.findall(r'\d+', input2)[0]) chainID2 = re.findall(r'\D+', input2)[0].upper() input2 = input2.upper() input1 = question("What subunit is moving? (eg 1A)") input1 = input1.strip() matrixID1 = int(re.findall(r'\d+', input1)[0]) chainID1 = re.findall(r'\D+', input1)[0].upper() input1 = input1.upper() for pdb in self.pdbs: for atom in pdb.backbone: if atom['chain'] == chainID1 and atom[ 'res num'] in commonAA: a = matrices[matrixID1] * np.transpose(atom.coord()) temp = Patom(str(atom), 1) temp['x'] = float(a[0]) temp['y'] = float(a[1]) temp['z'] = float(a[2]) temp['line num'] = counter1 counter1 += 1 towrite1.append(temp) if atom['chain'] == chainID2 and atom[ 'res num'] in commonAA: a = matrices[matrixID2] * np.transpose(atom.coord()) temp = Patom(str(atom), 1) temp['x'] = float(a[0]) temp['y'] = float(a[1]) temp['z'] = float(a[2]) temp['line num'] = counter2 counter2 += 1 towrite2.append(temp) file = open("output/%s%s.pdb" % (filetype, input1), 'w') for i in towrite1: file.write(str(i) + '\n') file.close() file = open("output/%s%s.pdb" % (filetype, input2), 'w') for i in towrite2: file.write(str(i) + '\n') file.close() matrix_static = self.coordmatrix(towrite1) matrix_moving = self.coordmatrix(towrite2) a = SVD.SVDSuperimposer() static = [towrite1, matrix_static] moving = [towrite2, matrix_moving] self.symop(static, moving, "%s-to-%s" % (input1, input2)) continue_check = question("Continue? (Y/n)", ['', 'y', 'Y', 'n', 'N']) if continue_check not in ['', 'y', 'Y']: flag = 0