Module _core_scoring_sasa_

create_sasa_method( (SasaMethodEnum)method, (float)probe_radius, (SasaRadii)radii_set) -> SasaMethod :
    Very (very) basic implementation until I understand the regular  implementation used by constraints/features/etc.
    Also used for me to debug everything else before creating the real factory.
    

    C++ signature :
        boost::shared_ptr<core::scoring::sasa::SasaMethod> create_sasa_method(core::scoring::sasa::SasaMethodEnum,double,core::scoring::sasa::SasaRadii)

get_legrand_2way_orientation( (xyzVector_Real)a_xyz, (xyzVector_Real)b_xyz, (int)phi_a2b_index, (int)theta_a2b_index, (int)phi_b2a_index, (int)theta_b2a_index, (float)distance_ijxyz) -> None :
    Gets the orientation of a to b (i to j, see below). Does this by calculating two angles, aphi and theta. (j)
    This function is the same as the function above but get the orientation of a to b simultaneously with the
    orientation of b to a.  The same result could be achieved by making two separate get_2way_orientation() calls
    but this method does it more efficiently by avoiding an atan2 and acos call.  Instead, once you compute the
    phi and theta for a on b, you can add/subtrate pi factors to get the phi and theta for b on a.
    Still not sure how this method returns the correct values, though.
    (ronj)
    

    C++ signature :
        void get_legrand_2way_orientation(numeric::xyzVector<double>,numeric::xyzVector<double>,int {lvalue},int {lvalue},int {lvalue},int {lvalue},double)

get_legrand_atomic_overlap( (float)radius_a, (float)radius_b, (float)distance_ijxyz, (int)degree_of_overlap) -> None :
    getting overlap from a to b (or i to j, as the atoms are referred to in calc_per_atom_sasa below).
    this returns the degree of overlap between two atoms adapted from erics code in area.c GetD2 and returns value
    from 1 to 100. This calculation is based on the law of cosines.
    See LeGrand and Merz, Journal of Computational Chemistry 14(3):349-52 (1993).
    Note that equation (4) is wrong, the denominator should be 2*ri*riq  instead of  2*ri*rq   (j)
    The function gets passed in the sasa radius of atom i (plus the probe radius), the sasa radius of atom j (plus
    the probe radius), the distance between the atom centers, and a reference to the degree of overlap (represented
    as an int). The degree of overlap that's returned can be thought of as how much of atom a is covered by atom b.
    A value of 100 means that atom a is completely covered up by atom b. A value of 1 means that not much of the surface
    of 'a' is covered up by 'b'.
    The law of cosines relates the cosine of one angle of a triangle to the lengths of its sides. More specifically,
    c^2 = a^2 + b^2 - 2*a*b*cos theta, where theta is the angle between sides a and b.  For the function we want to
    compute the angle of the cone of intersection between spheres 'a' and 'b'.  Let the radius of atom a be ri, and the
    radius of atom b be rq, and the distance between atom centers be riq.  Let the angle between ri and riq be theta_iq.
    The cosine of theta_iq will be equivalent to ( ri^2 + riq^2 - rq^2 ) / 2 * ri * riq
    

    C++ signature :
        void get_legrand_atomic_overlap(double,double,double,int {lvalue})

get_legrand_orientation( (xyzVector_Real)a_xyz, (xyzVector_Real)b_xyz, (int)phi_index, (int)theta_index, (float)distance_ijxyz) -> None :
    Gets the orientation of a to b (i to j, see below). Does this by calculating two angles, aphi and theta. (j)
    This function is used to get two indexes (phi and theta) which are used to get the index of a dot on the
    surface of the 'a' sphere. When calculating how much surface area sphere b covers on a, we can get the degree
    of overlap from the function above, but it's not necessarily the case that the vector that connects the center
    of atom 'a' and atom 'b' goes through one of the predetermined dot locations on the surface of 'a'. In fact,
    it's very unlikely that the vector goes through a predetermined dot.  Instead, what is done is the actual point
    of intersection (the outermost point of a on the line from the center of 'a' to center of 'b') is converted
    to spherical polar coordinates. Then, the values are used to find the location of the closest predetermined
    point on the surface of 'a' using a lookup table. So what this function needs to do is convert the
    cartesian coordinate of the actual point of intersection into polar coordinates.
    To get the spherical, polar coordinates of a cartesian point x,y,z, use these equations:
    r = sqrt( x^2 + y^2 + z^2 )
    theta = arccos( z / r )
    phi = arctan( y / x )
    Then, once we have the true phi and theta, we need to translate this into an index (or offset) for the correct
    value in the database file. There are 64 phi angle bin and 64 theta bins in the database file sampling/SASA-angles.dat.
    We need to convert the phi and theta into indexes for this file by multiplying them by num_phi / 2*pi.
    Note: I think phi and theta have been reversed in the function below. The code below uses the following:
    phi = arccos( z )
    theta = arctan( y / x )
    After a couple of weeks trying to write tests for this function, I have been unsuccessful in figuring out why
    it's doing what it does.  Despite using the wrong equations, it seems to work.  Comparing the total residue
    SASA values calculated by calc_per_atom_sasa() below results in a correlation of 0.98 against what the program
    NACCESS finds for the same residues. This test was done on a small 110aa protein.  I also looked at the per-atom
    total SASA and the correlation for all atoms (mini v. NACCESS) was approximately 0.94. I'm using exactly the same
    van der Waals radii for both programs so I feel like the correlations should be 1.0. Explanations for the
    differences can be 1) this method is doing something wrong in calculating the closest surface point, 2) this
    method is correct but the masks that are in the database are not aligned to the surface points correctly, 3) the
    differences are solely due to the different way that the two program calculate surface area.
    (ronj)
    

    C++ signature :
        void get_legrand_orientation(numeric::xyzVector<double>,numeric::xyzVector<double>,int {lvalue},int {lvalue},double)

    ////////////////////////////////////////////////////////////////////////////////////////
    / Functions used for molecular surface approximation
    / LeGrand S, Merz KM. Rapid approximation to molecular surface area via the use of Boolean logic and look-up tables.
    /  J Comput Chem 1993;14:349-352.
    /
    /  Implementation: Jerry Tsai
    /  C++ Translation: Jeff Gray
    /  Note: JAB - As the refactor is in progress, they stay as separate(but renamed) functions as many are used all over Rosetta for various purposes
      Returns const access to the angles FArray, which contains the information in the SASA database file sampling/SASA-angles.dat.
     Adding this in so that the values in the SASA database files can be used in SASA-based scores. (ronj)
    

    C++ signature :
        ObjexxFCL::FArray2D<int> get_legrand_sasa_angles()

Returns: object :

    Returns const access to the masks FArray, which contains the information in the SASA database file sampling/SASA-masks.dat.
    Adding this in so that the values in the SASA database files can be used in SASA-based scores. (ronj)
    

    C++ signature :
        ObjexxFCL::FArray2D<ObjexxFCL::ubyte> get_legrand_sasa_masks()

Returns: object :

get_sasa_method_from_string( (str)method) -> SasaMethodEnum :
    ////////////////////////////////////////////////////////////////////////////////////////////
      Enum Management.  Can go in separate file if it gets large.
    
    
    
     Gets sasa enum from string passed by options system.
    

    C++ signature :
        core::scoring::sasa::SasaMethodEnum get_sasa_method_from_string(std::string)

get_sasa_radii_parameter_name( (SasaRadii)radii_set) -> str :
    Get string name of SASA radii used to obtain extra parameter index from atom_type_set
    

    C++ signature :
        std::string get_sasa_radii_parameter_name(core::scoring::sasa::SasaRadii)

get_sasa_radii_set_from_string( (str)radii_set) -> SasaRadii :
    Gets sasa radii enum from string passed by options system.
    

    C++ signature :
        core::scoring::sasa::SasaRadii get_sasa_radii_set_from_string(std::string)

get_sc_bb_sasa( (Pose)pose, (AtomID_Map_T_double_T)atom_sasa) -> pair_Real_Real :
    ////////////////////////////////////////////////////////////////////////////////////////////
      Convenience Functions
    
    
     Calculate the sidechain and backbone sasa from atom sasa
    

    C++ signature :
        std::pair<double, double> get_sc_bb_sasa(core::pose::Pose,core::id::AtomID_Map<double>)

get_sc_bb_sasa_per_res( (Pose)pose, (AtomID_Map_T_double_T)atom_sasa) -> object :
    core/scoring/sasa/util.hh:43

    C++ signature :
        std::pair<utility::vector1<double, std::allocator<double> >, utility::vector1<double, std::allocator<double> > > get_sc_bb_sasa_per_res(core::pose::Pose,core::id::AtomID_Map<double>)

    Reads in the SASA database files sampling/SASA-angles.dat and sampling/SASA-masks.dat into FArrays above.
    

    C++ signature :
        void input_legrand_sasa_dats()

Returns: None :

LeGrand

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaMethodEnum.LeGrand

SasaMethodType_total

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaMethodEnum.SasaMetho dType_total

SasaRadii_total

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaRadii.SasaRadii_tota l

chothia

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaRadii.chothia

legacy

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaRadii.legacy

naccess

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaRadii.naccess

reduce

Value:

rosetta.core.scoring.sasa._core_scoring_sasa_.SasaRadii.reduce