|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.ObjectRdcPanda.PhiPsi
public class PhiPsi
Various methods for exact solution and systematic search including the computation of rotation to the frist peptide plane the DFS-search and solver of the quartic equation and the computation of \phi and \psi angles from two vectors in consecutive planse etc. Written by Lincong Wang (2001-2005).
Nested Class Summary | |
---|---|
static class |
PhiPsi.PPComparator
The Class PPComparator. |
Constructor Summary | |
---|---|
PhiPsi()
Instantiates a new phi psi. |
|
PhiPsi(double phiT,
double psiT,
double r_score)
Instantiates a new phi psi. |
|
PhiPsi(int No)
Instantiates a new phi psi. |
|
PhiPsi(int no,
java.lang.String re,
double x,
double y)
Instantiates a new phi psi. |
|
PhiPsi(int no,
java.lang.String re,
double x,
double y,
double phi_lo,
double phi_up,
double psi_lo,
double psi_up)
Instantiates a new phi psi. |
Method Summary | |
---|---|
double[] |
addCoords(double[] n1,
double[] n2)
adding two vectors. |
void |
backwardCoords(java.util.Vector pdbVec2)
Testing the Computation of backbone structure backwards. |
double[] |
ca2caDirCal(double phi,
double psi,
double[] ca1,
Matrix rg)
A method for computing the the Vector CA(i)-->CA(i+1), between the CA(i) and CA(i+1) begin with an frame defined in the peptide plane i. |
double[] |
caByNextPeptidePlane(double[] n1,
Matrix rg)
Ca by next peptide plane. |
boolean |
coefPhiBackward(double Syy,
double Szz,
double rdc,
double[][] mat,
double[] coefs)
Method for generating coefs for the quartic equation for computing phi_i from NH RDCs for residue i by working backwards from the residue i+1. |
boolean |
coefPsiBackward(double Syy,
double Szz,
double rdc,
double[][] mat,
double[] coefs)
Method for generating coefs for the quartic equation. |
double |
danSeq(double[] ha,
double[] co,
double psi)
A method for computing the distance dN(i, i+1), between the NH(i) and NH(i+1) begin with an frame defined in the peptide plane i. |
double |
dCaCa(double phi,
double psi)
A method for computing the distance Ca(i, i+1), between the CA(i) and CA(i+1) begin with an frame defined in the peptide plane i. |
boolean |
dirCaCa(double[] ca1,
double[] ca3,
double theta2,
double[][] solutions)
Compute the CA directions of residues 2 and 3 specified by polar angles (theta, phi), given the CA coordinates for residue 1 and 3 and the theta polar angle for residue 2. |
double[] |
dirCos(double[] vec)
cal the directioal cosines of the vector vec. |
double |
dnaIntra(double phi)
A method for computing the distance dN(i, i+1), between the NH(i) and NH(i+1) begin with an frame defined in the peptide plane i. |
double |
dNNseq(double phi,
double psi)
A method for computing the distance dN(i, i+1), between the NH(i) and NH(i+1) begin with an frame defined in the peptide plane i. |
void |
dNNtest()
There is another method for computing these angles, see the backup file. |
double[][] |
extractRestraints(int begin,
int end,
java.util.Vector h1Vec,
java.util.Vector asgVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double a1,
double a2)
The method right now may have ERROR! To extract all the sequential restraints (both RDCs and NOEs) involving the backbone nuclei (HA and NH) located in the turn or the loop. |
double |
getPhi()
Gets the phi. |
double |
getPhiLower()
Gets the phi lower. |
double |
getPhiUpper()
Gets the phi upper. |
double |
getPsi()
Gets the psi. |
double |
getPsiLower()
Gets the psi lower. |
double |
getPsiUpper()
Gets the psi upper. |
double |
getRamaScore()
Gets the rama score. |
java.lang.String |
getResidue()
Gets the residue. |
int |
getResidueNo()
Gets the residue no. |
double |
interAngle(double[] v1,
double[] v2)
calculate the angles between two vectors v1 and v2 The returned angle is in the [0,Pi] range. |
double |
internuclearDistance(double[] n1,
double[] n2)
Compute the internuclear vector between two atoms. |
double[] |
internuclearVec(double[] n1,
double[] n2)
Compute the internuclear vector between two atoms. |
double |
length(double[] v1)
calculate the length between two vectors v1 and v2 The returned angle is the [0,Pi] region. |
java.util.Vector |
longTurn(java.util.Vector h1Vec,
java.util.Vector asgVec,
java.util.Vector pdbVec1,
java.util.Vector pdbVec2,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
int no1,
int no2,
double a1,
double a2)
Compute the loop (18 - 23) by randomly changing the 18, 19 backbone dihedral angles. |
boolean |
loop34To41(double[][] restraints,
double Syy,
double Szz,
int no1,
int no2,
double[] n,
double[] nh,
double[] ca,
double[] n2,
double[] nh2,
double[] ca2,
java.util.Vector phiPsiVec,
double[] rdcRmsd)
Loop34 to41. |
void |
loop50To56(java.util.Vector h1Vec,
java.util.Vector asgVec2,
java.util.Vector pdbVec,
java.util.Vector h56To59Pdb,
java.util.Vector chRdcVec,
java.util.Vector nhRdcVec,
double Syy,
double Szz,
int no1,
int no2,
double a1,
double a2)
Compute the loop L50-L56 given the orientation of the peptide planes L50 and L56. |
boolean |
loop59To65(double[][] restraints,
double Syy,
double Szz,
int no1,
int no2,
double[] n,
double[] nh,
double[] ca,
double[] n2,
double[] nh2,
double[] ca2,
java.util.Vector phiPsiVec,
double[] rdcRmsd)
Compute the loop Y59 <--> K63 given the absolute coordinates for Y59 and E64. |
double[] |
newNCA(double phi,
double psi,
Matrix rg)
Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles. |
Matrix |
newRG(double phi,
double psi,
Matrix rg)
Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$. |
Matrix |
newRG(double phi,
double psi,
Matrix rg,
boolean rightHand)
Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$. |
void |
nh2ca2Cal()
Test the computation of psi1, phi2, psi2 given the peptide plane for residue 1 an d3 and phi1 without knowing the relative position between two planes. |
void |
noeDisVsPhi()
Noe dis vs phi. |
void |
noeDisVsPsi()
Noe dis vs psi. |
java.util.Vector |
phiCal(double Syy,
double Szz,
double rdc,
Matrix rg)
Compute the Phi angles. |
java.util.Vector |
phiCal(double Syy,
double Szz,
double rdc,
Matrix Rg,
boolean isHelix)
Compute the Phi angles. |
java.util.Vector |
phiCal(double Syy,
double Szz,
double rdc,
Matrix Rg,
boolean isHelix,
int curResNo,
java.util.Vector vecTalos)
Compute the Phi angles. |
java.util.Vector |
phiCalBackward(double Syy,
double Szz,
double rdc,
double psi,
Matrix rg)
Compute the Psi angles. |
java.util.Vector |
phiCalLoop(double Syy,
double Szz,
double rdc,
Matrix Rg)
Compute the Phi angles for loop fragment. |
java.util.Vector |
phiCalNoe(double d)
Compute the Phi angles from the NOE distances, given the coordinates for ca and nh. |
void |
phiPsiBackwardTest(java.util.Vector rdcNH,
java.util.Vector rdcCH)
Phi psi backward test. |
boolean |
phiPsiByCa(Matrix rg,
double[] cacaVec,
double[][] solutions)
********************************************************************************* This method compute the \Phi and \Psi pair from the coordinates of CA(i) and CA(i+1) EXACTLY assuming the six angles are known. |
java.util.Vector |
phiPsiByPP13(double[] u1,
double[] v1,
double[] n2ca3,
double[] n2nh3,
double phi1)
computation of psi1, phi2, psi2 given the peptide planes for residue 1 an d3 and phi1 without knowing the relative position between two planes. |
boolean |
phiPsiByPP14(double[] ca1,
double[] n4,
double[] ca4,
double[] nh4,
Matrix rg1,
Matrix rg4,
java.util.Vector solutionVec)
Compute the CA directions of residues 2 and 3 specified by polar angles (theta, phi), given the CA coordinates for residue 1 and 3 and the theta polar angle for residue 2. |
boolean |
phiPsiByRdcNoe(java.util.Vector asgVec,
double[][] restraints,
double Syy,
double Szz,
double[] n0,
double[] nh0,
double[] ca0,
Matrix rg,
int depth,
int N,
double[] ppS,
java.util.Vector ppVec,
double[] nToNHVec2,
double[] nToCAVec2,
double[] ca2)
A recusive function to compute all the backbone (phi, psi) angles for an $m$-residue fragment This is a version for real computation, NOT for collecting running statistics. |
boolean |
phiPsiChain(double[] rdcArr1,
double[] rdcArr2,
Matrix rg,
double Syy,
double Szz,
int i,
int N,
double[] ppS,
java.util.Vector ppVec,
boolean rightHand,
boolean isHelix)
A recusive function to compute all the backbone (phi, psi) angles for an $N$-residue fragment This is a version for real computation, NOT for collecting running statistics. |
boolean |
phiPsiChainTalos(double[] rdcArr1,
double[] rdcArr2,
Matrix rg,
double Syy,
double Szz,
int i,
int N,
double[] ppS,
java.util.Vector ppVec,
boolean rightHand,
boolean isHelix,
int firstResNo,
java.util.Vector vecTalos)
A recusive function to compute all the backbone (phi, psi) angles for an $N$-residue fragment This is a version for real computation, NOT for collecting running statistics. |
void |
printArray(double[] n1)
Prints the array. |
java.util.Vector |
psiCal(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg)
Compute the Psi angles. |
java.util.Vector |
psiCal(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg,
boolean isHelix)
Compute the Psi angles. |
java.util.Vector |
psiCal(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg,
boolean isHelix,
int curResNo,
java.util.Vector vecTalos)
Compute the Psi angles. |
java.util.Vector |
psiCalBackward(double Syy,
double Szz,
double rdc,
Matrix rg)
Compute the Phi angles. |
java.util.Vector |
psiCalLoop(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg)
Compute the Psi angles for loops. |
java.util.Vector |
psiCalNoe(double d)
Compute the Phi angles from the NOE distances, given the coordinates for ca and nh. |
boolean |
quadraticSolve(double[] coefs,
double[] solutions)
Method for solving the quadratic equation generated from the NOE distance as shown in the above. |
boolean |
quarticCoefPhi(double Syy,
double Szz,
double rdc,
double[][] mat,
double[] coefs)
Method for generating coefs for the quartic equation for computing CH . |
boolean |
quarticCoefPsi(double Syy,
double Szz,
double rdc,
double[][] mat,
double[] coefs)
Method for generating coefs for the quartic equation. |
java.util.Vector |
quarticSolve(double[] coefs)
Method is for computing \Phi or \Psi using Two RDC in one medium by solving a Quartic eqaution It differs from the method for solving RDCs in two media . |
double[][] |
restraintsBackward(int begin,
int end,
java.util.Vector h1Vec,
java.util.Vector asgVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double a1,
double a2)
To extract all the sequential restraints (both RDCs and NOEs) involving the backbone nuclei (HA and NH) located in the turn or the loop. |
Matrix |
RgCal(double[] nToh,
double[] nToca)
Compute the global rotation matrix for rotating a coordinate frame such as the PDB frame where the two vectors NH(i)->N(i) (nToh) and N(i)->CA(i) (nToca) defined into the following frame: +Z-axis along the bond NH(i)->N(i), "->" means from nuclear NH(i) to nuclear N(i). |
Matrix |
RgCal(double[] nToh,
double[] nToca,
boolean rightHand)
Rg cal. |
void |
setPhi(double f1)
Sets the phi. |
void |
setPsi(double f1)
Sets the psi. |
java.util.Vector<PhiPsi> |
talosAngleReader(java.lang.String talosFile)
A very simple reader for talos angle. |
void |
testDirCaCa()
Test dir ca ca. |
void |
testNOEs()
Testing the methods for computing the \phi and \psi angle from NOE disances. |
void |
testPhiPsiByCa(java.util.Vector pdbVec)
Test phi psi by ca. |
java.lang.String |
toString()
|
java.util.Vector |
turnByCaCa(java.util.Vector h1Vec,
java.util.Vector asgVec,
java.util.Vector pdbVec1,
java.util.Vector pdbVec2,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
int no1,
int no2,
double a1,
double a2)
Compute the turns (8 - 11) by randomly changing the. |
double |
vdwEnergy(java.util.Vector pdbVec1,
java.util.Vector pdbVec2,
int[] count)
Vdw energy. |
Methods inherited from class java.lang.Object |
---|
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public PhiPsi(double phiT, double psiT, double r_score)
phiT
- the phi tpsiT
- the psi tr_score
- the r_scorepublic PhiPsi()
public PhiPsi(int No)
No
- the nopublic PhiPsi(int no, java.lang.String re, double x, double y)
no
- the nore
- the rex
- the xy
- the ypublic PhiPsi(int no, java.lang.String re, double x, double y, double phi_lo, double phi_up, double psi_lo, double psi_up)
no
- the nore
- the rex
- the xy
- the yphi_lo
- the phi_lophi_up
- the phi_uppsi_lo
- the psi_lopsi_up
- the psi_upMethod Detail |
---|
public int getResidueNo()
public java.lang.String getResidue()
public double getPhi()
public void setPhi(double f1)
f1
- the new phipublic double getPsi()
public void setPsi(double f1)
f1
- the new psipublic double getRamaScore()
public double getPhiLower()
public double getPhiUpper()
public double getPsiLower()
public double getPsiUpper()
public java.lang.String toString()
toString
in class java.lang.Object
public void printArray(double[] n1)
n1
- the n1public double length(double[] v1)
v1
- the v1
public double interAngle(double[] v1, double[] v2)
v1
- the v1v2
- the v2
public double[] dirCos(double[] vec)
vec
- the vec
public double[] internuclearVec(double[] n1, double[] n2)
n1
- the coordinate for atom 1n2
- the coordinate for atom 2
public double internuclearDistance(double[] n1, double[] n2)
n1
- the coordinate for atom 1n2
- the coordinate for atom 2
public double[] addCoords(double[] n1, double[] n2)
n1
- the coordinate (direction cosine) for vector n1n2
- the coordinate (direction cosine) for vector n2
public Matrix RgCal(double[] nToh, double[] nToca)
nToh
- the direction cosine of N->NH vectornToca
- the direction cosine of N->CA vector
public Matrix RgCal(double[] nToh, double[] nToca, boolean rightHand)
nToh
- the n tohnToca
- the n tocarightHand
- the right hand
public boolean quadraticSolve(double[] coefs, double[] solutions)
coefs
- coefs generated by the above methodssolutions
- for returning all the real solutions if there are
public java.util.Vector phiCalNoe(double d)
d
- the intra noe distance bewteen NH(i) and HA(i) of residue i+1
public java.util.Vector psiCalNoe(double d)
d
- the intra noe distance bewteen NH(i) and HA(i) of residue i+1
public void testNOEs()
public void noeDisVsPhi()
public double dnaIntra(double phi)
phi
- The backbone \phi angle
public double danSeq(double[] ha, double[] co, double psi)
psi
- The backbone \psi angleha
- the coordinate of HA (i)co
- the coordinate of CO (i)
public double dNNseq(double phi, double psi)
phi
- The backbone \phi anglepsi
- The backbone \psi angle
public void noeDisVsPsi()
public double dCaCa(double phi, double psi)
phi
- The backbone \phi anglepsi
- The backbone \psi angle
public boolean dirCaCa(double[] ca1, double[] ca3, double theta2, double[][] solutions)
ca1
- the coordinate of the CA nucleus of residue ica3
- the coordinate of the CA nucleus of residue i+2theta2
- the polar theta angle of CA2CA vector between residues i and i+1.solutions
- double[][] allAngles = new double[2][3];
public double[] caByNextPeptidePlane(double[] n1, Matrix rg)
n1
- the n1rg
- the rg
public void testDirCaCa()
public boolean phiPsiByCa(Matrix rg, double[] cacaVec, double[][] solutions)
rg
- the rotation matrix from a unique global frame to a
local frame specified in the peptide plane isolutions
- double[][] solutions = new double[2][3]; //since only two pairscacaVec
- the caca vec
public java.util.Vector turnByCaCa(java.util.Vector h1Vec, java.util.Vector asgVec, java.util.Vector pdbVec1, java.util.Vector pdbVec2, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, int no1, int no2, double a1, double a2)
no1
- the first residue of the fragment (turn and loop)no2
- the last residue of the fragment (turn and loop)h1Vec
- resonance assignment sorted by H1 CS shift.asgVec
- the merged resonacs assigement and HN and HA NOEsrdcVec1
- the CH RDCrdcVec2
- the NH RDCa1
- the constant used to convert the intensity to distancea2
- the constant used to convert the intensity to distancepdbVec1
- the structure for the beginning side of turn or looppdbVec2
- the structure for the end side of turn or loopSyy
- the diagnolized Saupe elementsSzz
- the diagnolized Saupe elements
public java.util.Vector longTurn(java.util.Vector h1Vec, java.util.Vector asgVec, java.util.Vector pdbVec1, java.util.Vector pdbVec2, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, int no1, int no2, double a1, double a2)
no1
- the first residue of the fragment (turn and loop)no2
- the last residue of the fragment (turn and loop)h1Vec
- resonance assignment sorted by H1 CS shift.asgVec
- the merged resonance assigement and HN and HA NOEsrdcVec1
- the CH RDCrdcVec2
- the NH RDCa1
- the constant used to convert the intensity to distancea2
- the constant used to convert the intensity to distancepdbVec1
- the structure for the beginning side of turn or looppdbVec2
- the structure for the end side of turn or loopSyy
- the diagnolized Saupe elementsSzz
- the diagnolized Saupe elements
public double[] ca2caDirCal(double phi, double psi, double[] ca1, Matrix rg)
phi
- The backbone \phi anglepsi
- The backbone \psi anglerg
- the rotation matrix to the peptide plane ica1
- the ca1
public void dNNtest()
public void testPhiPsiByCa(java.util.Vector pdbVec)
pdbVec
- the pdb vecpublic void nh2ca2Cal()
public java.util.Vector phiPsiByPP13(double[] u1, double[] v1, double[] n2ca3, double[] n2nh3, double phi1)
u1
- the n2ca vector of residue 1v1
- the n2nh vector of residue 1n2ca3
- the n2ca vector of residue 3n2nh3
- the n2nh vector of residue 3phi1
- the phi angle of residue 1.
public boolean quarticCoefPhi(double Syy, double Szz, double rdc, double[][] mat, double[] coefs)
rdc
- Rdc data of CH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsmat
- the elements of the Matrix M as appeared in the math derivationcoefs
- the five coefs of the quartic equation and others for checking the final solution
public boolean quarticCoefPsi(double Syy, double Szz, double rdc, double[][] mat, double[] coefs)
rdc
- Rdc data of NH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsmat
- the elements of the Matrix M as appeared in the math derivationcoefs
- the five coefs of the quartic equation and others for checking the final solution
public java.util.Vector quarticSolve(double[] coefs)
coefs
- coefs generated by the coef generating methods
public java.util.Vector phiCal(double Syy, double Szz, double rdc, Matrix rg)
rdc
- Rdc data of CH vectorrg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elements
public java.util.Vector phiCal(double Syy, double Szz, double rdc, Matrix Rg, boolean isHelix)
rdc
- Rdc data of CH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsRg
- the rgisHelix
- the is helix
public java.util.Vector phiCalLoop(double Syy, double Szz, double rdc, Matrix Rg)
rdc
- Rdc data of CH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsRg
- the rg
public java.util.Vector phiCal(double Syy, double Szz, double rdc, Matrix Rg, boolean isHelix, int curResNo, java.util.Vector vecTalos)
rdc
- Rdc data of CH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsRg
- the rgisHelix
- the is helixcurResNo
- the cur res novecTalos
- the vec talos
public java.util.Vector psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg)
rdc
- Rdc data of NH vectorphi
- the computed \phi value for the same residuerg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elements
public java.util.Vector psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg, boolean isHelix)
rdc
- Rdc data of NH vectorphi
- the computed \phi value for the same residuerg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsisHelix
- the is helix
public java.util.Vector psiCalLoop(double Syy, double Szz, double rdc, double phi, Matrix rg)
rdc
- Rdc data of NH vectorphi
- the computed \phi value for the same residuerg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elements
public java.util.Vector psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg, boolean isHelix, int curResNo, java.util.Vector vecTalos)
rdc
- Rdc data of NH vectorphi
- the computed \phi value for the same residuerg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsisHelix
- the is helixcurResNo
- the cur res novecTalos
- the vec talos
public boolean coefPhiBackward(double Syy, double Szz, double rdc, double[][] mat, double[] coefs)
rdc
- Rdc data of NH vectorSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsmat
- the elements of the Matrix M as appeared in the math derivationcoefs
- the five coefs of the quartic equation and others for checking the final solution
public boolean coefPsiBackward(double Syy, double Szz, double rdc, double[][] mat, double[] coefs)
rdc
- Rdc data of CH vector of residue iSyy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementsmat
- the elements of the Matrix M as appeared in the math derivationcoefs
- the five coefs of the quartic equation and others for checking the final solution
public java.util.Vector psiCalBackward(double Syy, double Szz, double rdc, Matrix rg)
rdc
- Rdc data of CH vectorrg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i+1$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elements
public java.util.Vector phiCalBackward(double Syy, double Szz, double rdc, double psi, Matrix rg)
rdc
- Rdc data of NH vectorrg
- the rotation matrix rotate a POF to a frame defined in the peptine plane $i$Syy
- diagonilized Saupe elements computed by SVD with both CH and NH RDCs.Szz
- diagonilized Saupe elementspsi
- the psi
public void phiPsiBackwardTest(java.util.Vector rdcNH, java.util.Vector rdcCH)
rdcNH
- the rdc nhrdcCH
- the rdc chpublic void backwardCoords(java.util.Vector pdbVec2)
pdbVec2
- the pdb vec2public boolean phiPsiChain(double[] rdcArr1, double[] rdcArr2, Matrix rg, double Syy, double Szz, int i, int N, double[] ppS, java.util.Vector ppVec, boolean rightHand, boolean isHelix)
rdcArr1
- an array of CH RDCs for the fragmentrdcArr2
- an array of NH RDCs for the fragmentrg
- a matrix to rotate the POF to a coodinate system defined in the first peptide plane.Syy
- Saupe elements computed from both NH and CH rdcsSzz
- Saupe elements computed from both NH and CH rdcsi
- the current depth of the depth-first search. Begin the call with i = 0;N
- the total depth of the depth-first search.ppS
- a temporary array for saving intermediate (\phi, \psi) angles.ppVec
- an array for saving and returning final (\phi, \psi) angles.rightHand
- make sure the computed rg has the same handedness as the rotating matrix by the SVD methodisHelix
- the is helix
public boolean phiPsiChainTalos(double[] rdcArr1, double[] rdcArr2, Matrix rg, double Syy, double Szz, int i, int N, double[] ppS, java.util.Vector ppVec, boolean rightHand, boolean isHelix, int firstResNo, java.util.Vector vecTalos)
rdcArr1
- an array of CH RDCs for the fragmentrdcArr2
- an array of NH RDCs for the fragmentrg
- a matrix to rotate the POF to a coodinate system defined in the first peptide plane.Syy
- Saupe elements computed from both NH and CH rdcsSzz
- Saupe elements computed from both NH and CH rdcsi
- the current depth of the depth-first search. Begin the call with i = 0;N
- the total depth of the depth-first search.ppS
- a temporary array for saving intermediate (\phi, \psi) angles.ppVec
- an array for saving and returning final (\phi, \psi) angles.rightHand
- make sure the computed rg has the same handedness as the rotating matrix by the SVD methodisHelix
- the is helixfirstResNo
- the first res novecTalos
- the vec talos
public double[][] extractRestraints(int begin, int end, java.util.Vector h1Vec, java.util.Vector asgVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double a1, double a2)
begin
- the first residue of the fragment (turn and loop)end
- the last residue of the fragment (turn and loop)h1Vec
- resonance assignment sorted by H1 CS shift.asgVec
- the merged resonacs assigement and HN and HA NOEsrdcVec1
- the CH RDCrdcVec2
- the NH RDCa1
- the constant used to convert the intensity to distancea2
- the constant used to convert the intensity to distance
public double[][] restraintsBackward(int begin, int end, java.util.Vector h1Vec, java.util.Vector asgVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double a1, double a2)
begin
- the first residue of the fragment (turn and loop) such as 22.end
- the last residue of the fragment (turn and loop) such as 18h1Vec
- resonance assignment sorted by H1 CS shift.asgVec
- the merged resonacs assigement and HN and HA NOEsrdcVec1
- the CH RDCrdcVec2
- the NH RDCa1
- the constant used to convert the intensity to distancea2
- the constant used to convert the intensity to distance
public boolean phiPsiByRdcNoe(java.util.Vector asgVec, double[][] restraints, double Syy, double Szz, double[] n0, double[] nh0, double[] ca0, Matrix rg, int depth, int N, double[] ppS, java.util.Vector ppVec, double[] nToNHVec2, double[] nToCAVec2, double[] ca2)
asgVec
- has the resonance assignment and NOE peaklistrestraints
- a double array, and the elements of each row is {chRdc, nhRdc, dna, dan, dnn}rg
- a matrix to rotate the POF to a coodinate system defined in the first peptide plane.Syy
- Saupe elements computed from both NH and CH rdcsSzz
- Saupe elements computed from both NH and CH rdcsdepth
- the current depth of the depth-first search. Begin with i = 0;N
- the total depth of the depth-first search, the same as the number of residuesppS
- a temporary array for saving intermediate (\phi, \psi) angles.ppVec
- an array for returning final (\phi, \psi) angles.ca2
- the coordinate of the CA nucleus of the end side of the loop
We need a method to search all the possible NOEs based two proton CSs, which can be used for
identify possible sequential NOE assignment.
// double dnaCal = 0.0, danCal = 0.0, dnnCal = 0.0;
// double [] noeScore = new double[5];
// for (i=0; in0
- the n0nh0
- the nh0ca0
- the ca0nToNHVec2
- the n to nh vec2nToCAVec2
- the n to ca vec2
public boolean loop34To41(double[][] restraints, double Syy, double Szz, int no1, int no2, double[] n, double[] nh, double[] ca, double[] n2, double[] nh2, double[] ca2, java.util.Vector phiPsiVec, double[] rdcRmsd)
restraints
- the restraintsSyy
- the syySzz
- the szzno1
- the no1no2
- the no2n
- the nnh
- the nhca
- the can2
- the n2nh2
- the nh2ca2
- the ca2phiPsiVec
- the phi psi vecrdcRmsd
- the rdc rmsd
public boolean phiPsiByPP14(double[] ca1, double[] n4, double[] ca4, double[] nh4, Matrix rg1, Matrix rg4, java.util.Vector solutionVec)
ca1
- the coordinate of the CA nucleus of residue in4
- the n4ca4
- the ca4nh4
- the nh4rg1
- the rg1rg4
- the rg4solutionVec
- the solution vec
public double[] newNCA(double phi, double psi, Matrix rg)
phi
- the \Phi angle of residue $i$phi
- the \Phi angle of residue $i$rg
- the first rotation matrix to the coordinate frame defined in the Math derivation
public Matrix newRG(double phi, double psi, Matrix rg)
phi
- the \Psi angle of residue $i$rg
- the rotation matrix to the coordinate frame defined in the peptide plane $i$ as in the Math derivationpsi
- the psi
public Matrix newRG(double phi, double psi, Matrix rg, boolean rightHand)
phi
- the \Psi angle of residue $i$rg
- the rotation matrix to the coordinate frame defined in the peptide plane $i$ as in the Math derivationpsi
- the psirightHand
- the right hand
public double vdwEnergy(java.util.Vector pdbVec1, java.util.Vector pdbVec2, int[] count)
pdbVec1
- the pdb vec1pdbVec2
- the pdb vec2count
- the count
public java.util.Vector<PhiPsi> talosAngleReader(java.lang.String talosFile)
talosFile
- the name of the file
public void loop50To56(java.util.Vector h1Vec, java.util.Vector asgVec2, java.util.Vector pdbVec, java.util.Vector h56To59Pdb, java.util.Vector chRdcVec, java.util.Vector nhRdcVec, double Syy, double Szz, int no1, int no2, double a1, double a2)
no1
- L50no2
- L56pdbVec
- the coordinates for the entire protein minus the loop (E51-L63)h56To59Pdb
- the RDC-oriented helix L56-Y59h1Vec
- the h1 vecasgVec2
- the asg vec2chRdcVec
- the ch rdc vecnhRdcVec
- the nh rdc vecSyy
- the syySzz
- the szza1
- the a1a2
- the a2public boolean loop59To65(double[][] restraints, double Syy, double Szz, int no1, int no2, double[] n, double[] nh, double[] ca, double[] n2, double[] nh2, double[] ca2, java.util.Vector phiPsiVec, double[] rdcRmsd)
no1
- the N-terminal of the loop. (Y59 in ubiquitin)no2
- the C-terminal of the loop. (K63 in ubiquitin)n
- the amide coordinate of the beginning residue (Y59) of the loopnh
- the amide proton coordinate of the beginning residue (Y59) of the loopca
- the CA coordinate of the beginning residue (Y59) of the loopn2
- the amide coordinate of the ending residue (E64) of the loopnh2
- the amide proton coordinate of the ending residue (E64) of the loopca2
- the CA coordinate of the beginning residue (E64) of the loopphiPsiVec
- for returning the backbone angles.restraints
- the restraintsSyy
- the syySzz
- the szzrdcRmsd
- the rdc rmsd
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |