Module _core_util_

add_covalent_linkage( (Pose)pose, (int)resA_pos, (int)resB_pos, (int)resA_At, (int)resB_At, (bool)remove_hydrogens) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     : Adds an arbitrary covalent linkage between two atoms (resA_At and resB_At) in two residues (at positions resA_pos and resB_pos).
     :  This is useful for adding covalent linkages between metal-binding side-chains and metal atoms.  This code was shamelessly
     stolen from Florian's EnzConstraintParameters.cc in protocols/toolbox/match_enzdes_utils, and was modified to permit deletion of
     unnecessary protons.  NOTE: THIS CODE MODIFIES THE RESIDUE TYPE LIST, AND IS CURRENTLY NOT THREADSAFE.
     :  Vikram K. Mulligan (vmullig@uw.edu), Florian Richter (flosopher@gmail.com)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void add_covalent_linkage(core::pose::Pose {lvalue},unsigned long,unsigned long,unsigned long,unsigned long,bool)

add_covalent_linkages_to_metal( (Pose)pose, (int)metal_position, (vector1_AtomID)liganding_atomids [, (bool)remove_hydrogens=True]) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function to add covalent linkages between a metal atom and all the liganding atoms provided in a vector of AtomIDs.
     The inputs are:
        pose (The pose to be modified)
        metal_position (The residue number of the metal in the pose)
        liganding_atomids (A list of AtomIDs on other residues that will be covalently linked to the metal)
        remove_hydrogens (Should hydrogens on the liganding atoms be removed automatically?  Default true.)
     This function uses core::pose::add_covalent_linkage, which can strip off extraneous hydrogens.
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void add_covalent_linkages_to_metal(core::pose::Pose {lvalue},unsigned long,utility::vector1<core::id::AtomID, std::allocator<core::id::AtomID> > {lvalue} [,bool=True])

auto_setup_all_metal_bonds( (Pose)pose [, (float)dist_cutoff_multiplier=1.05 [, (bool)remove_hydrogens=True]]) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function to auto-detect and add covalent connections to all metal ions in a pose.
     This function iteratively calls auto_setup_metal_bonds.
     Inputs:
                pose (The pose that we'll operate on, changed by operation)
        dist_cutoff_multiplier (A float for the distance cutoff multiplier; the cutoff is the sum of the Lennard-Jones radii times the multiplier)
       remove_hydrogesn (Should hydrogens on the liganding atoms be auto-removed?  Default true.)
     Vikram K. Mulligan (vmulligan@uw.edu)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void auto_setup_all_metal_bonds(core::pose::Pose {lvalue} [,double=1.05 [,bool=True]])

auto_setup_all_metal_constraints( (Pose)pose, (__CPP_ScoreFunction__)sfxn, (float)distance_constraint_multiplier, (float)angle_constraint_multiplie) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function to set up distance and angle constraints between metals and the residues that bind them.
     This function constrains the distances to be whatever they are in the input pose.  This version
     sets the weights for the constraints terms in the scorefunction to 1.0 if they're off, or scales the
     constraints themselves appropriately if they're already on.
     Inputs:
                pose (The pose that we'll operate on, changed by operation)
       sfxn (An owning pointer to the scorefunction, changed by operation)
       distance_constraint_multiplier (A float for the strength of the metal - binding atom distance constraint.  A value of 2.0 doubles
       it, for example.)
       angle_constraint_multiplier (A float for the strength of the metal - binding atom - binding atom parent angle constraint.)
     Vikram K. Mulligan (vmulligan@uw.edu)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void auto_setup_all_metal_constraints(core::pose::Pose {lvalue},boost::shared_ptr<core::scoring::ScoreFunction>,double,double)

auto_setup_all_metal_constraints( (Pose)pose, (float)distance_constraint_multiplier, (float)angle_constraint_multiplier) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function to set up distance and angle constraints between metals and the residues that bind them.
     This function constrains the distances to be whatever they are in the input pose.  This version
     does not set the weights for the constraints terms in the scorefunction.
     Inputs:
                pose (The pose that we'll operate on, changed by operation)
       distance_constraint_multiplier (A float for the strength of the metal - binding atom distance constraint.  A value of 2.0 doubles
       it, for example.)
       angle_constraint_multiplier (A float for the strength of the metal - binding atom - binding atom parent angle constraint.)
     Vikram K. Mulligan (vmulligan@uw.edu)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void auto_setup_all_metal_constraints(core::pose::Pose {lvalue},double,double)

auto_setup_metal_bonds( (Pose)pose, (int)metal_position [, (float)dist_cutoff_multiplier=1.05 [, (bool)remove_hydrogens=True]]) -> None :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function to auto-detect and add covalent connections to a particular metal ion.
     This function calls find_metalbinding_atoms and then passes the list of metal binding atoms to add_covalent_linkages_to_metal.
     Inputs:
                pose (The pose that we'll operate on, changed by operation)
                metal_postion (The residue number of the metal)
        dist_cutoff_multiplier (A float for the distance cutoff multiplier; the cutoff is the sum of the Lennard-Jones radii times the multiplier)
       remove_hydrogesn (Should hydrogens on the liganding atoms be auto-removed?  Default true.)
     Vikram K. Mulligan (vmulligan@uw.edu)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        void auto_setup_metal_bonds(core::pose::Pose {lvalue},unsigned long [,double=1.05 [,bool=True]])

find_metalbinding_atoms( (Pose)pose, (int)metal_position [, (float)dist_cutoff_multiplier=1.05]) -> vector1_AtomID :
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     Function that generates a list of metal-binding atoms that coordinate a metal in a protein.
     This function generates the list by looping through all residues and checking all metal-binding atoms of all
     metal-binding residues, so it's not super speedy.
     Inputs:
                pose (The pose that we'll operate on, unchanged by operation)
                metal_postion (The residue number of the metal)
        dist_cutoff_multiplier (A float for the distance cutoff multiplier; the cutoff is the sum of the Lennard-Jones radii times the multiplier)
     Vikram K. Mulligan (vmulligan@uw.edu)
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    

    C++ signature :
        utility::vector1<core::id::AtomID, std::allocator<core::id::AtomID> > find_metalbinding_atoms(core::pose::Pose,unsigned long [,double=1.05])

getMLweight( (ScoreFunction)scorefxn, (Pose), (MoveMap)) -> float :
    get the optimal weight on the xtal ML energy considering only movable DOFs
    

    C++ signature :
        double getMLweight(core::scoring::ScoreFunction {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap {lvalue})

getMLweight( (ScoreFunction)scorefxn, (Pose)) -> float :
    get the optimal weight on the xtal ML energy
    

    C++ signature :
        double getMLweight(core::scoring::ScoreFunction {lvalue},core::pose::Pose {lvalue})

getMLweight_cart( (ScoreFunction)scorefxn, (Pose), (MoveMap)) -> float :
    get the optimal weight on the xtal ML energy considering only movable DOFs
    

    C++ signature :
        double getMLweight_cart(core::scoring::ScoreFunction {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap {lvalue})

getMLweight_cart( (ScoreFunction)scorefxn, (Pose)) -> float :
    get the optimal weight on the xtal ML energy
    

    C++ signature :
        double getMLweight_cart(core::scoring::ScoreFunction {lvalue},core::pose::Pose {lvalue})

rebuild_disulfide( (Pose)pose, (vector1_pair_Size_Size)disulfides [, (PackerTask)packer_task=0 [, (__CPP_ScoreFunction__)packer_score=0 [, (MoveMap)mm=0 [, (__CPP_ScoreFunction__)minimizer_score=0]]]]) -> None :
    Rebuild a number of pairs of cysteines (and possibly surrounding
     residues) so that they form near-ideal disulfide bonds
    

    C++ signature :
        void rebuild_disulfide(core::pose::Pose {lvalue},utility::vector1<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long> > > [,boost::shared_ptr<core::pack::task::PackerTask>=0 [,boost::shared_ptr<core::scoring::ScoreFunction>=0 [,boost::shared_ptr<core::kinematics::MoveMap>=0 [,boost::shared_ptr<core::scoring::ScoreFunction>=0]]]])

rebuild_disulfide( (Pose)pose, (int)lower_res, (int)upper_res [, (PackerTask)packer_task=0 [, (__CPP_ScoreFunction__)packer_score=0 [, (MoveMap)mm=0 [, (__CPP_ScoreFunction__)minimizer_score=0]]]]) -> None :
    Rebuild a pair of cysteines (and possibly surrounding residues) so
     that they form a near-ideal disulfide bond
    

    C++ signature :
        void rebuild_disulfide(core::pose::Pose {lvalue},unsigned long,unsigned long [,boost::shared_ptr<core::pack::task::PackerTask>=0 [,boost::shared_ptr<core::scoring::ScoreFunction>=0 [,boost::shared_ptr<core::kinematics::MoveMap>=0 [,boost::shared_ptr<core::scoring::ScoreFunction>=0]]]])

remove_cutpoint_variants( (Pose)pose) -> None :
    Removes cutpoint variants from `pose` by scanning the fold tree
    

    C++ signature :
        void remove_cutpoint_variants(core::pose::Pose {lvalue})

switch_to_residue_type_set( (Pose)pose, (str)type_set_name [, (bool)allow_sloppy_match=False]) -> None :
    the function allows a pose to use a different residue_type_set to
    represent all its residues, such as from fullatom residues to centroid
    residues, or vice versa. During the switch, corresponding atoms will be
    copied. Redundant atoms will be removed (in case from fullatom to centroid)
    and missing atoms will be built by ideal geometry (in the case from centroid
    to fullatom).
    

    C++ signature :
        void switch_to_residue_type_set(core::pose::Pose {lvalue},std::string [,bool=False])