|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Matrix | |
---|---|
RdcPanda |
Uses of Matrix in RdcPanda |
---|
Methods in RdcPanda that return Matrix | |
---|---|
Matrix |
PdbRdc.bestFit(java.util.Vector<Pdb> pdbVec,
java.util.Vector nhRdc,
java.util.Vector<Dipolar> cahaRdc,
double[] rdc1Cal,
double[] rdc2Cal,
double[] eigenValues)
Best fit Two sets of RDC data from one medium such as NH and CH please note that the rotation matrix returned by the eigenValueDecomposition method is rather arbitrary so we need to make sure that only the righ handedone are returned. |
Matrix |
PdbRdc.bestFit4RDCs(java.util.Vector pdbVec,
java.util.Vector nhRdc,
java.util.Vector cahaRdc,
java.util.Vector cacoRdc,
java.util.Vector conRdc,
double[] rdc1Cal,
double[] rdc2Cal,
double[] eigenValues)
Best fit Two sets of RDC data from one medium such as NH and CH please note that the rotation matrix returned by the eigenValueDecomposition method is rather arbitrary so we need to make sure only the righ handedone are returned. |
Matrix |
Matrix.copy()
Make a deep copy of a matrix. |
Matrix |
PdbRdc.eulerFit_old(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
double[] rmsds,
double resolution,
boolean debug)
Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
PdbRdc.eulerFit(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec1,
java.util.Vector<Dipolar> rdcVec2,
double Syy,
double Szz,
double[] rmsds,
double resolution,
boolean debug)
Note: Lincong's has a serious bug. |
Matrix |
PdbRdc.eulerFit4RDCs(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec1,
java.util.Vector<Dipolar> rdcVec2,
java.util.Vector<Dipolar> rdcVecCaCo,
java.util.Vector<Dipolar> rdcVecCoN,
double Syy,
double Szz,
double[] rmsds,
double resolution,
boolean debug)
Note: Lincong's has a serious bug. |
Matrix |
PdbRdc.eulerFitHB(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double[] saupe,
Matrix rot,
double[] rmsds,
double resolution,
double weight4HB,
java.util.Vector pdbVecS1,
java.util.Vector hbVec,
Matrix mat4Dirs,
boolean debug)
Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
PdbRdc.eulerFitPrintEnsemble(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec1,
java.util.Vector<Dipolar> rdcVec2,
double Syy,
double Szz,
double[] rmsds,
double resolution,
boolean debug,
double RdcRmsdThreshold)
print out all pdb orientations in which rdc rmsd is smaler than some threshold, in grid search. |
Matrix |
Matrix.eulerMat(double alpha,
double beta,
double gamma)
A method for generating an euler Matrix from three Euler angles. |
Matrix |
PdbRdc.fit4MissingRdc(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
double[] rmsds,
double resolution,
boolean debug)
Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
PdbRdc.fit4MissingRdcHB(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
java.util.Vector pdbVecA,
double[] rmsds,
double resolution,
double weight4HB,
java.util.Vector hbVec,
boolean debug)
Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
PdbRdc.fit4MissingRdcHB2(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double Syy,
double Szz,
java.util.Vector pdbVecA1,
java.util.Vector pdbVecA2,
double[] rmsds,
double resolution,
double weight4HB,
java.util.Vector hbVec1,
java.util.Vector hbVec2,
boolean debug)
Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
EigenvalueDecomposition.getD()
Return the block diagonal eigenvalue matrix |
Matrix |
SingularValueDecomposition.getS()
Return the diagonal matrix of singular values. |
Matrix |
SingularValueDecomposition.getU()
Return the left singular vectors. |
Matrix |
SingularValueDecomposition.getV()
Return the right singular vectors. |
Matrix |
EigenvalueDecomposition.getV()
Return the eigenvector matrix |
static Matrix |
Matrix.identity(int m,
int n)
Generate identity matrix. |
Matrix |
Matrix.minus(Matrix B)
C = A - B. |
Matrix |
PhiPsi.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 |
PhiPsi.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$. |
Matrix |
Peak.noeAssignMat(java.util.Vector h1Vec,
java.util.Vector asgVec)
Compute the possbile NOE assignment matrix, an idea not further pursued. |
Matrix |
Matrix.plus(Matrix B)
C = A + B. |
Matrix |
ppGlobal.RgCal(double[] nToh,
double gamma)
compute global rotation (Rg) with two no colinear vectors Rg is the same as the last method Here the input are the NH vector and one Euler angle gamma for the N(i)->CA(i) vector accounting the rotation of the peptide plane along the NH vector. |
Matrix |
ppGlobal.RgCal(double[] nToh,
double[] nToca)
compute global rotation (Rg) with two noncolinear vectors, Rg is the rotation matrix for rotating the PDB coordinate system into the following system: +z-axis along the bond NH(i)->N(i), "->" means from atom N(i) to atom NH(i). |
Matrix |
PhiPsi.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 |
ppGlobal.RgCal(double[] nToh,
double[] nToca,
boolean rightHand)
Rg cal. |
Matrix |
PhiPsi.RgCal(double[] nToh,
double[] nToca,
boolean rightHand)
Rg cal. |
Matrix |
Matrix.rotationMat(double theta,
java.lang.String axis)
make a 3x3 rotation matrix with a rotation angle theta and along an axis Please note that only axis only take +/-x, y, z A method by Lincong Wang. |
Matrix[] |
sp3Carbon.tetrahedral(double[] center,
Matrix mat,
sp3Carbon atomC)
Compute the coordinates of sp3 atoms from a sp3Carbon object. |
Matrix |
Matrix.times(double s)
Multiply a matrix by a scalar, C = s*A. |
Matrix |
Matrix.times(Matrix B)
Linear algebraic matrix multiplication, A * B. |
Matrix |
Matrix.transpose()
Matrix transpose. |
Matrix |
Matrix.uminus()
-a of every elements. |
Methods in RdcPanda with parameters of type Matrix | |
---|---|
double |
PdbRdc.BackCal(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc)
For back-computing RDCs. |
double |
PdbRdc.BackCal(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size)
For back-computing RDCs. |
double |
PdbRdc.BackCalCACO(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size,
boolean isPrint)
For back-computing RDCs. |
double |
PdbRdc.BackCalCACOOnePdb(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio)
compute rdc rmsd for only one pdb. |
double |
PdbRdc.BackCalCON(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size,
boolean isPrint)
For back-computing RDCs from Co at residue i to N at residue i+1. |
double |
PdbRdc.BackCalCONOnePdb(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio)
compute rdc rmsd for only one pdb from Co at residue i to N at residue i+1. |
double |
PdbRdc.BackCalNH(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc)
For back-computing NH RDCs since the NH RDC of the fiest residue is NOT used in the DFS-based refinement. |
double |
PdbRdc.BackCalNH(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size)
For back-computing NH RDCs since the NH RDC of the fiest residue is NOT used in the DFS-based refinement. |
double |
PdbRdc.BackCalNHOne(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size)
compute the RDC deviation for one residue. |
double |
PdbRdc.BackCalOne(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio,
double[] rdcBc,
double[] squareRmsd,
int[] size)
compute rdc deviation for one residue For back-computing RDCs. |
double |
PdbRdc.BackCalOnePdb(java.util.Vector<Pdb> pdbVec,
java.util.Vector<Dipolar> rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz,
double rdcRatio)
compute rdc rmsd for only one pdb. |
double[] |
PdbRdc.BackCalRdcs(java.util.Vector pdbVec,
java.util.Vector rdcVec,
java.lang.String atom1,
java.lang.String atom2,
Matrix mm,
double Sxx,
double Syy,
double Szz)
For back-computing RDCs. |
double[] |
PhiPsi.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[] |
PhiPsi.caByNextPeptidePlane(double[] n1,
Matrix rg)
Ca by next peptide plane. |
Matrix |
PdbRdc.eulerFitHB(java.util.Vector pdbVec,
java.util.Vector rdcVec1,
java.util.Vector rdcVec2,
double[] saupe,
Matrix rot,
double[] rmsds,
double resolution,
double weight4HB,
java.util.Vector pdbVecS1,
java.util.Vector hbVec,
Matrix mat4Dirs,
boolean debug)
Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions. |
Matrix |
Matrix.minus(Matrix B)
C = A - B. |
double[] |
PhiPsi.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. |
java.util.Vector |
Pdb.newPdb(java.util.Vector pdbVec,
Matrix R)
compute new PDB coordinates after the rotation by matrix R. |
Matrix |
PhiPsi.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 |
PhiPsi.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$. |
java.util.Vector |
PhiPsi.phiCal(double Syy,
double Szz,
double rdc,
Matrix rg)
Compute the Phi angles. |
java.util.Vector |
PhiPsi.phiCal(double Syy,
double Szz,
double rdc,
Matrix Rg,
boolean isHelix)
Compute the Phi angles. |
java.util.Vector |
PhiPsi.phiCal(double Syy,
double Szz,
double rdc,
Matrix Rg,
boolean isHelix,
int curResNo,
java.util.Vector vecTalos)
Compute the Phi angles. |
java.util.Vector |
Loops.phiCalAll(double Syy,
double Szz,
double rdc,
Matrix Rg)
Compute the Phi angles from RDC equations. |
java.util.Vector |
PhiPsi.phiCalBackward(double Syy,
double Szz,
double rdc,
double psi,
Matrix rg)
Compute the Psi angles. |
java.util.Vector |
PhiPsi.phiCalLoop(double Syy,
double Szz,
double rdc,
Matrix Rg)
Compute the Phi angles for loop fragment. |
boolean |
PhiPsi.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. |
boolean |
PhiPsi.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 |
PhiPsi.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 |
PhiPsi.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 |
Loops.phiPsiChainAll(double[] rdcArrCH,
double[] rdcArrNH,
int[] isChRDC,
int[] isNhRDC,
Matrix rg,
double Syy,
double Szz,
int i,
int resNo,
int N,
double[] ppS,
java.util.Vector ppVec,
boolean rightHand,
int resNoStart)
A recusive function to compute all the backbone (phi, psi) angles for a fragment. |
boolean |
PhiPsi.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. |
Matrix |
Matrix.plus(Matrix B)
C = A + B. |
java.util.Vector |
PhiPsi.psiCal(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg)
Compute the Psi angles. |
java.util.Vector |
PhiPsi.psiCal(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg,
boolean isHelix)
Compute the Psi angles. |
java.util.Vector |
PhiPsi.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 |
Loops.psiCalAll(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg)
Compute the Psi angles. |
java.util.Vector |
PhiPsi.psiCalBackward(double Syy,
double Szz,
double rdc,
Matrix rg)
Compute the Phi angles. |
java.util.Vector |
PhiPsi.psiCalLoop(double Syy,
double Szz,
double rdc,
double phi,
Matrix rg)
Compute the Psi angles for loops. |
Matrix[] |
sp3Carbon.tetrahedral(double[] center,
Matrix mat,
sp3Carbon atomC)
Compute the coordinates of sp3 atoms from a sp3Carbon object. |
Matrix |
Matrix.times(Matrix B)
Linear algebraic matrix multiplication, A * B. |
Constructors in RdcPanda with parameters of type Matrix | |
---|---|
EigenvalueDecomposition(Matrix Arg,
boolean issymmetric)
Check for symmetry, then construct the eigenvalue decomposition |
|
SingularValueDecomposition(Matrix Arg)
Construct the singular value decomposition. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |