Package rosetta :: Package numeric :: Package model_quality :: Module _numeric_model_quality_

[frames] | no frames]

Module _numeric_model_quality_

Classes

[hide private]

RmsData
RmsData is a class intended to replace the global rms_obj namespace from rosetta++.

RmsDataAP

RmsDataCAP

Functions

[hide private]

BlankMatrixMult(...)
BlankMatrixMult( (object)A, (int)n, (int)np, (int)transposeA, (object)B, (int)m, (int)transposeB, (object)AxB_out) -> None : numeric/model_quality/rms.hh:63

COMAS(...)
COMAS( (object)C, (object)WT, (int)NAT, (float)XC, (float)YC, (float)ZC) -> None : /////////////////////////////////////////////////////////////////////////////

MatrixMult(...)
MatrixMult( (object)A, (int)n, (int)np, (int)transposeA, (object)B, (int)m, (int)transposeB, (object)AxB_out) -> None : numeric/model_quality/rms.hh:120

calc_rms(...)
calc_rms( (vector1_xyzVector_Real)p1_coords, (vector1_xyzVector_Real)p2_coords) -> float : numeric/model_quality/rms.hh:37

calc_rms_fast(...)
calc_rms_fast( (float)rms_out, (object)xx, (object)yy, (object)ww, (int)npoints, (float)ctx) -> None : numeric/model_quality/rms.hh:88

det3(...)
det3( (object)m) -> float : /////////////////////////////////////////////////////////////////////////////

erfcc(...)
erfcc( (float)x) -> float : numeric/model_quality/maxsub.hh:74

findUU(...)
findUU( (object)XX, (object)YY, (object)WW, (int)Npoints, (object)UU, (float)sigma3) -> None : numeric/model_quality/rms.hh:108

fixEigenvector(...)
fixEigenvector( (object)m_v) -> None : numeric/model_quality/rms.hh:78

maxsub(...)
maxsub( (int)nsup, (object)xe, (object)xp, (float)rms, (float)psi, (int)nali, (float)zscore, (float)evalue, (float)score [, (float)rsmtol=4.0 [, (float)distance_tolerance=7.0]]) -> None : numeric/model_quality/maxsub.hh:70

rms_wrapper(...)
rms_wrapper( (int)natoms, (object)p1a, (object)p2a) -> float : numeric/model_quality/rms.hh:44

rms_wrapper_slow_and_correct(...)
rms_wrapper_slow_and_correct( (int)natoms, (object)p1a, (object)p2a) -> float : numeric/model_quality/rms.hh:51

rmsfitca2(...)
rmsfitca2( (int)npoints, (object)xx, (object)yy, (object)ww, (int)natsel, (float)esq) -> None : /////////////////////////////////////////////////////////////////////////////

rmsfitca3(...)
rmsfitca3( (int)npoints, (object)xx0, (object)xx, (object)yy0, (object)yy, (float)esq) -> None : ///////////////////////////////////////////////////////////////

rsym_eigenval(...)
rsym_eigenval( (object)m, (object)ev) -> None : /////////////////////////////////////////////////////////////////////////////

rsym_evector(...)
rsym_evector( (object)m, (object)ev, (object)mvec) -> None : /////////////////////////////////////////////////////////////////////////////

rsym_rotation(...)
rsym_rotation( (object)mm, (object)m, (object)ev, (object)rot) -> None : /////////////////////////////////////////////////////////////////////////////

Variables

[hide private]

__package__ = None

Function Details

[hide private]

BlankMatrixMult(...)


BlankMatrixMult( (object)A, (int)n, (int)np, (int)transposeA, (object)B, (int)m, (int)transposeB, (object)AxB_out) -> None :
    numeric/model_quality/rms.hh:63

    C++ signature :
        void BlankMatrixMult(ObjexxFCL::FArray2A<double>,int,int,int,ObjexxFCL::FArray2A<double>,int,int,ObjexxFCL::FArray2A<double>)

COMAS(...)


COMAS( (object)C, (object)WT, (int)NAT, (float)XC, (float)YC, (float)ZC) -> None :
    /////////////////////////////////////////////////////////////////////////////
    
     
     
     C - [in/out]? -
     WT - [in/out]? -
     NAT - [in/out]? -
     XC - [in/out]? -
     YC - [in/out]? -
     ZC - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
    
     @references
    
     
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void COMAS(ObjexxFCL::FArray1A<double>,ObjexxFCL::FArray1A<double>,int,double {lvalue},double {lvalue},double {lvalue})

MatrixMult(...)


MatrixMult( (object)A, (int)n, (int)np, (int)transposeA, (object)B, (int)m, (int)transposeB, (object)AxB_out) -> None :
    numeric/model_quality/rms.hh:120

    C++ signature :
        void MatrixMult(ObjexxFCL::FArray2A<double>,int,int,int,ObjexxFCL::FArray2A<double>,int,int,ObjexxFCL::FArray2A<double>)

calc_rms(...)


calc_rms( (vector1_xyzVector_Real)p1_coords, (vector1_xyzVector_Real)p2_coords) -> float :
    numeric/model_quality/rms.hh:37

    C++ signature :
        double calc_rms(utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > >,utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > >)

calc_rms_fast(...)


calc_rms_fast( (float)rms_out, (object)xx, (object)yy, (object)ww, (int)npoints, (float)ctx) -> None :
    numeric/model_quality/rms.hh:88

    C++ signature :
        void calc_rms_fast(float {lvalue},ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray1A<double>,int,double)

det3(...)


det3( (object)m) -> float :
    /////////////////////////////////////////////////////////////////////////////
    
     determinant of a 3x3 matrix
    
      cute factoid: det of a 3x3 is the dot product of one row with the cross
     product of the other two. This explains why a right hand coordinate system
     has a positive determinant. cute huh?
    
     m - [in/out]? -
    
     
     @global_read
    
     @global_write
    
     @remarks
    
     @references
    
     charlie strauss 2001
    
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        double det3(ObjexxFCL::FArray2A<double>)

erfcc(...)


erfcc( (float)x) -> float :
    numeric/model_quality/maxsub.hh:74

    C++ signature :
        double erfcc(double)

findUU(...)


findUU( (object)XX, (object)YY, (object)WW, (int)Npoints, (object)UU, (float)sigma3) -> None :
    numeric/model_quality/rms.hh:108

    C++ signature :
        void findUU(ObjexxFCL::FArray2<double> {lvalue},ObjexxFCL::FArray2<double> {lvalue},ObjexxFCL::FArray1<double>,int,ObjexxFCL::FArray2<double> {lvalue},double {lvalue})

findUU( (vector1_xyzVector_Real)XX, (vector1_xyzVector_Real)YY, (vector1_Real)WW, (int)Npoints, (xyzMatrix_Real)UU, (float)sigma3) -> None :
    numeric/model_quality/rms.hh:98

    C++ signature :
        void findUU(utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > > {lvalue},utility::vector1<numeric::xyzVector<double>, std::allocator<numeric::xyzVector<double> > > {lvalue},utility::vector1<double, std::allocator<double> >,int,numeric::xyzMatrix<double> {lvalue},double {lvalue})

fixEigenvector(...)


fixEigenvector( (object)m_v) -> None :
    numeric/model_quality/rms.hh:78

    C++ signature :
        void fixEigenvector(ObjexxFCL::FArray2A<double>)

maxsub(...)


maxsub( (int)nsup, (object)xe, (object)xp, (float)rms, (float)psi, (int)nali, (float)zscore, (float)evalue, (float)score [, (float)rsmtol=4.0 [, (float)distance_tolerance=7.0]]) -> None :
    numeric/model_quality/maxsub.hh:70

    C++ signature :
        void maxsub(int {lvalue},ObjexxFCL::FArray1A<double>,ObjexxFCL::FArray1A<double>,double {lvalue},double {lvalue},int {lvalue},double {lvalue},double {lvalue},double {lvalue} [,double=4.0 [,double=7.0]])

rms_wrapper(...)


rms_wrapper( (int)natoms, (object)p1a, (object)p2a) -> float :
    numeric/model_quality/rms.hh:44

    C++ signature :
        double rms_wrapper(int,ObjexxFCL::FArray2D<double>,ObjexxFCL::FArray2D<double>)

rms_wrapper_slow_and_correct(...)


rms_wrapper_slow_and_correct( (int)natoms, (object)p1a, (object)p2a) -> float :
    numeric/model_quality/rms.hh:51

    C++ signature :
        double rms_wrapper_slow_and_correct(int,ObjexxFCL::FArray2D<double>,ObjexxFCL::FArray2D<double>)

rmsfitca2(...)


rmsfitca2( (int)npoints, (object)xx, (object)yy, (object)ww, (int)natsel, (float)esq) -> None :
    /////////////////////////////////////////////////////////////////////////////
    
     computes the rms between two weighted point vectors.
    
        xx_0,yy_0 are the input vectors of of points and ww is their weights
       xx,yy are by product output vectors of the same points offset to remove center of mass
       det is an out value of the determinant of the cross moment matrix
       returned value is the rms
    
       most of this is double for good reasons.  first there are some large
       differences of small numbers.  and second the rsymm_eignen() function can
       internally have numbers larger than the largest double number.
       (you could do some fancy foot work to rescale things if you really
       had a problem with this.)
    
     npoints - [in/out]? -
     xx - [in/out]? -
     yy - [in/out]? -
     ww - [in/out]? -
     natsel - [in/out]? -
     esq - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
       det is a double precision real
      (xx,yy) can be same arrays as (xx_0,yy_0) if desired
    
     @references
    
     charlie strauss 2001
    
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void rmsfitca2(int,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray1A<double>,int,double {lvalue})

rmsfitca3(...)


rmsfitca3( (int)npoints, (object)xx0, (object)xx, (object)yy0, (object)yy, (float)esq) -> None :
    ///////////////////////////////////////////////////////////////
    
     
        This function gets its alignment info via a namespace!
       Alignment (rotation matrix) and rms(esq) are computed on the basis
       of residues previously designated by calls to add_rms().
       However, the rotation is applied to all Npoints of XX0,yy0 with the
       results returned in xx,yy.
    
       most of this is double for good reasons.
       first there are some large differences of small numbers.
       second the rsymm_eignen() function can internally have numbers
       larger than the largest double number.  (you could do some fancy foot work
       to rescale m_moment if you really had a problem with this.)
    
     npoints - [in/out]? -
     xx0 - [in/out]? -
     xx - [in/out]? -
     yy0 - [in/out]? -
     yy - [in/out]? -
     esq - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
       NOTE: det is a double precision real
       NOTE: (xx,yy) can be same arrays as (xx_0,yy_0) if desired
    
     @references
    
     
    /////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void rmsfitca3(int,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,double {lvalue})

rsym_eigenval(...)


rsym_eigenval( (object)m, (object)ev) -> None :
    /////////////////////////////////////////////////////////////////////////////
    
     computes the eigen values of a real symmetric 3x3 matrix
    
      the method used is a deterministic analytic result that I hand factored.(whew!)
     Amusingly, while I suspect this factorization is not yet optimal in the
     number of calcs required
     I cannot find a signifcantly better one.
      (if it were optimal I suspect I would not have to compute imaginary numbers that
      I know must eventually cancel out to give a net real result.)
     this method relys on the fact that an analytic factoring of an order 3 polynomial exists.
     m(3,3) is a 3x3 real symmetric matrix: only the upper triangle is actually used
      ev(3) is a real vector of eigen values, not neccesarily in sorted order.
    
     m - [in/out]? -
     ev - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
    
     @references
    
     charlie strauss 2001
    
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void rsym_eigenval(ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray1A<double>)

rsym_evector(...)


rsym_evector( (object)m, (object)ev, (object)mvec) -> None :
    /////////////////////////////////////////////////////////////////////////////
    
      Author: charlie strauss (cems) 2001
     given original matrix plus its eigen values
     compute the eigen vectors.
     USAGE notice: for computing min rms rotations be sure to call this
     with the lowest eigen value in Ev(3).
    
     The minimal factorization of the eigenvector problem I have derived below has a puzzling
     or, rather, interesting assymetry.  Namely, it doesn't matter what
      either ZZ=M(3,3) is or what Ev(3) is!
      One reason for this is that of course all we need to  know is contained in the
      M matrix in the firstplace, so the eigen values overdetermine the problem
      We are just exploiting the redundant info in the eigen values to hasten the solution.
      What I dont know is if infact there exists any symmetic form using the eigen values.
    
     we deliberately introduce another assymetry for numerical stability, and
     to force proper rotations  (since eigen vectors are not unique within a sign change).
       first, we explicitly numerically norm the vectors to 1 rather than assuming the
       algebra will do it with enough accuracy. ( and its faster to boot!)
       second, we explicitly compute the third vector as being the cross product of the
       previous two rather than using the M matrix and third eigen value.
       If you arrange the eigen values so that the third eigen value is the lowest
       then this guarantees a stable result under the case of either very small
       eigen value or degenerate eigen values.
       this norm, and ignoring the third eigen value also gaurentee us the even if the
       eigen vectors are not perfectly accurate that, at least, the matrix
       that results is a pure orthonormal rotation matrix, which for most applications
       is the most important form of accuracy.
    
     
     m - [in/out]? -
     ev - [in/out]? -
     mvec - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
    
     @references
    
     
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void rsym_evector(ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray1A<double>,ObjexxFCL::FArray2A<double>)

rsym_rotation(...)


rsym_rotation( (object)mm, (object)m, (object)ev, (object)rot) -> None :
    /////////////////////////////////////////////////////////////////////////////
    
     finds a (proper) rotation matrix that minimizes the rms.
    
     this computes the rotation matrix based on the eigenvectors of m that gives the
     the mimimum rms.  this is determined using mm the cross moments matrix.
    
     for best results the third eigen value should be the
     smallest eigen value!
    
    
     mm - [in/out]? -
     m - [in/out]? -
     ev - [in/out]? -
     rot - [in/out]? -
    
     @global_read
    
     @global_write
    
     @remarks
    
     @references
    
     charlie strauss (cems) 2001
    
    //////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void rsym_rotation(ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray2A<double>,ObjexxFCL::FArray1A<double>,ObjexxFCL::FArray2A<double>)