Module _protocols_membrane_geometry_

average_antiparallel_embeddings( (object)parts) -> EmbeddingDef :
    Average EmbeddingDefs after first inverting some vectors accounting for topology
    Get average center and normal from a vector of EmbeddingDefs
    

    C++ signature :
        boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> average_antiparallel_embeddings(utility::vector1<boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef>, std::allocator<boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> > >)

average_embeddings( (object)parts) -> EmbeddingDef :
    Average EmbeddingDefs as they are (without vector inversion accounting for topology)
    Get average center and normal from a vector of EmbeddingDefs
    

    C++ signature :
        boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> average_embeddings(utility::vector1<boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef>, std::allocator<boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> > >)

center_of_mass( (Pose)pose, (int)start, (int)stop) -> xyzVector_Real :
    ///////////// Utility Functions from Docking Protocol - Geometry Util for Center of Mass ////////////////
     Center of Mass
     Calculates the center of mass of a pose - Stop and start positions (or residues)
                 used ot find the starting and finishing locations
                                the start and stop positions (or residues) within the pose are used to
                                find the starting and finishing locations
    
     Monica Berrondo, Modified by Javier Castellanos and Rebecca Alford
    

    C++ signature :
        numeric::xyzVector<double> center_of_mass(core::pose::Pose,long,long)

check_vector( (xyzVector_Real)vector) -> None :
    Check reasonable range of vector
    

    C++ signature :
        void check_vector(numeric::xyzVector<double>)

compute_structure_based_embedding( (Pose)pose) -> EmbeddingDef :
    Compute Membrane Center/Normal from Membrane Spanning
    topology, uses topology from MembraneInfo
    

    C++ signature :
        boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> compute_structure_based_embedding(core::pose::Pose)

compute_structure_based_embedding( (Pose)pose, (SpanningTopology)topo) -> EmbeddingDef :
    Compute Membrane Center/Normal from Membrane Spanning
    topology
    

    C++ signature :
        boost::shared_ptr<protocols::membrane::geometry::EmbeddingDef> compute_structure_based_embedding(core::pose::Pose,core::conformation::membrane::SpanningTopology)

compute_structure_based_embedding( (Pose)pose, (xyzVector_Real)center, (xyzVector_Real)normal) -> None :
    Compute Membrane Center/Normal from Membrane Spanning
    topology, uses topology from MembraneInfo
    

    C++ signature :
        void compute_structure_based_embedding(core::pose::Pose,numeric::xyzVector<double> {lvalue},numeric::xyzVector<double> {lvalue})

compute_structure_based_embedding( (Pose)pose, (SpanningTopology)topology, (xyzVector_Real)center, (xyzVector_Real)normal) -> None :
    Compute Membrane Center/Normal from Membrane Spanning
    topology
    

    C++ signature :
        void compute_structure_based_embedding(core::pose::Pose,core::conformation::membrane::SpanningTopology,numeric::xyzVector<double> {lvalue},numeric::xyzVector<double> {lvalue})

get_chain_and_z( (Pose)pose) -> object :
    Get z-coord and chainID
    Helper function that creates input for SpanningTopology
                        which is not built at the time the Pose is built
                        returns a pair of vectors:
                        vector1 is z-coord of CA atoms of the pose
                        vector2 is chainID of CA atoms of the pose
    

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

get_secstruct( (Pose)pose) -> vector1_char :
    Get secondary structure of the pose
    Helper function that gets the secondary structure vector from the pose
    

    C++ signature :
        utility::vector1<char, std::allocator<char> > get_secstruct(core::pose::Pose {lvalue})

membrane_axis( (Pose), (int)jumpnum) -> xyzVector_Real :
    Calculates translation axis lying in the membrane (= projection of COM axis into the membrane plane)
    

    C++ signature :
        numeric::xyzVector<double> membrane_axis(core::pose::Pose {lvalue},int)

membrane_normal_to_length_15( (Pose)pose) -> None :
    Normalize normal vector to length 15 for visualization
    

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

reorder_membrane_foldtree( (Pose)pose) -> None :
    Set membrane residue to root of foldtree
    Requires MembraneInfo to be constructed beforehand;
                 use AddMembraneMover to do that
    

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

residue_center_of_mass( (Pose)pose, (int)start, (int)stop) -> int :
    Residue Center of Mass
    Calcualte the center of mass of a pose.
    Monica Berrondo, Modified by Javier Castellanos and Rebecca Alford
    

    C++ signature :
        long residue_center_of_mass(core::pose::Pose,long,long)

return_nearest_residue( (Pose)pose, (int)begin, (int)end, (xyzVector_Real)center) -> int :
    Return nearest residue
    Find the residue nearest some position passed in (normally a center of mass)
    Monica Berrondo, Modified by Javier Castellanos and Rebecca Alford
    

    C++ signature :
        long return_nearest_residue(core::pose::Pose,long,long,numeric::xyzVector<double>)

split_topology_by_jump( (Pose)pose, (int)jumpnum, (SpanningTopology)topo, (Pose)pose_up, (Pose)pose_down, (SpanningTopology)topo_up, (SpanningTopology)topo_down) -> None :
    Splits the SpanningTopology object into two objects, depending on
                given jump number
    This is useful for calculating an embedding for parts of the
                structure: this can now easily be accomplished by creating two
                empty topology objects, call this function, and then use both topology
                objects and subposes to call compute_structure_based_membrane_embedding
    

    C++ signature :
        void split_topology_by_jump(core::pose::Pose,unsigned long,core::conformation::membrane::SpanningTopology,core::pose::Pose {lvalue},core::pose::Pose {lvalue},core::conformation::membrane::SpanningTopology {lvalue},core::conformation::membrane::SpanningTopology {lvalue})