Module _core_sequence_

align_naive( (__CPP_Sequence__)seq1, (__CPP_Sequence__)seq2) -> SequenceAlignment :
    Generate a naive sequence alignment between two sequences.
    

    C++ signature :
        core::sequence::SequenceAlignment align_naive(boost::shared_ptr<core::sequence::Sequence>,boost::shared_ptr<core::sequence::Sequence>)

align_poses_naive( (Pose)pose1, (Pose)pose2) -> SequenceAlignment :
    core/sequence/util.hh:135

    C++ signature :
        core::sequence::SequenceAlignment align_poses_naive(core::pose::Pose {lvalue},core::pose::Pose {lvalue})

alignment_from_pose( (Pose)pose) -> SequenceAlignment :
    core/sequence/util.hh:146

    C++ signature :
        core::sequence::SequenceAlignment alignment_from_pose(core::pose::Pose {lvalue})

alignment_into_pose( (SequenceAlignment)aln, (Pose)pose) -> None :
    core/sequence/util.hh:151

    C++ signature :
        void alignment_into_pose(core::sequence::SequenceAlignment,core::pose::Pose {lvalue})

calpha_superimpose_with_mapping( (Pose)mod_pose, (Pose)ref_pose, (SequenceMapping)mapping) -> float :
    core/sequence/util.hh:165

    C++ signature :
        double calpha_superimpose_with_mapping(core::pose::Pose {lvalue},core::pose::Pose,core::id::SequenceMapping)

get_abego( (Pose)pose [, (int)level=1]) -> vector1_string :
    utility for getting abego
    

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > get_abego(core::pose::Pose [,unsigned long=1])

get_maximum_scores( (__CPP_ScoringScheme__)ss, (__CPP_Sequence__)seq) -> vector1_Real :
    core/sequence/util.hh:141

    C++ signature :
        utility::vector1<double, std::allocator<double> > get_maximum_scores(boost::shared_ptr<core::sequence::ScoringScheme>,boost::shared_ptr<core::sequence::Sequence>)

map_seq1_seq2( (__CPP_Sequence__)seq1, (__CPP_Sequence__)seq2) -> SequenceMapping :
    Generates a mapping of sequence 1 onto sequence 2 using dynamic
    programming with a simple scoring framework.
    

    C++ signature :
        core::id::SequenceMapping map_seq1_seq2(boost::shared_ptr<core::sequence::Sequence>,boost::shared_ptr<core::sequence::Sequence>)

mapping_to_alignment( (SequenceMapping)mapping, (__CPP_Sequence__)seq1, (__CPP_Sequence__)seq2) -> SequenceAlignment :
    Constructs a SequenceAlignment from the given SequenceMapping and
    the two sequences.
    

    C++ signature :
        core::sequence::SequenceAlignment mapping_to_alignment(core::id::SequenceMapping,boost::shared_ptr<core::sequence::Sequence>,boost::shared_ptr<core::sequence::Sequence>)

n_correctly_aligned_positions( (SequenceAlignment)candidate_aln, (SequenceAlignment)true_aln) -> int :
    core/sequence/util.hh:92

    C++ signature :
        unsigned long n_correctly_aligned_positions(core::sequence::SequenceAlignment {lvalue},core::sequence::SequenceAlignment {lvalue})

read_alignment_file( (str)filename, (str)seq1, (str)seq2, (DerivedSequenceMapping)mapping) -> None :
    helper function for reading a SequenceMapping from an alignment
    file.
    

    C++ signature :
        void read_alignment_file(std::string,std::string {lvalue},std::string {lvalue},core::sequence::DerivedSequenceMapping {lvalue})

read_all_alignments( (str)format, (vector1_string)files, (object)alignments) -> None :
    Populates the non-null vector <alignments> with all of the sequence
    alignments found in <files>. Each alignment is required to have
    format <format>.
    

    C++ signature :
        void read_all_alignments(std::string,utility::vector1<std::string, std::allocator<std::string> >,utility::vector1<core::sequence::SequenceAlignment, std::allocator<core::sequence::SequenceAlignment> >*)

read_aln( (str)format, (str)filename) -> object :
    core/sequence/util.hh:70

    C++ signature :
        utility::vector1<core::sequence::SequenceAlignment, std::allocator<core::sequence::SequenceAlignment> > read_aln(std::string,std::string)

read_fasta_file( (str)filename) -> object :
    Read in sequences from a fasta-formatted file.
    

    C++ signature :
        utility::vector1<boost::shared_ptr<core::sequence::Sequence>, std::allocator<boost::shared_ptr<core::sequence::Sequence> > > read_fasta_file(std::string)

read_fasta_file_return_str( (str)filename) -> str :
    core/sequence/util.hh:59

    C++ signature :
        std::string read_fasta_file_return_str(std::string)

read_fasta_file_str( (str)filename) -> vector1_string :
    core/sequence/util.hh:58

    C++ signature :
        utility::vector1<std::string, std::allocator<std::string> > read_fasta_file_str(std::string)

read_general_aln( (std_istream)input) -> object :
    read generalized alignment format.
    

    C++ signature :
        utility::vector1<core::sequence::SequenceAlignment, std::allocator<core::sequence::SequenceAlignment> > read_general_aln(std::istream {lvalue})

read_general_aln_file( (str)filename) -> object :
    core/sequence/util.hh:85

    C++ signature :
        utility::vector1<core::sequence::SequenceAlignment, std::allocator<core::sequence::SequenceAlignment> > read_general_aln_file(std::string)

read_grishin_aln_file( (str)filename) -> object :
    core/sequence/util.hh:81

    C++ signature :
        utility::vector1<core::sequence::SequenceAlignment, std::allocator<core::sequence::SequenceAlignment> > read_grishin_aln_file(std::string)

    core/sequence/util.hh:72

    C++ signature :
        utility::vector1<boost::shared_ptr<core::sequence::Sequence>, std::allocator<boost::shared_ptr<core::sequence::Sequence> > > seqs_from_cmd_lines()

Returns: object :

simple_mapping_from_file( (str)filename) -> DerivedSequenceMapping :
    Read in a SequenceMapping from a file. File
    format is super-simple, it just contains single
    lines like this that claim that residue resi and
    resj are aligned: resi resj
    

    C++ signature :
        core::sequence::DerivedSequenceMapping simple_mapping_from_file(std::string)

steal_alignment( (SequenceAlignment)aln_to_steal, (object)seqs) -> SequenceAlignment :
    takes the sequences in the provided vector1 and makes them match
    the alignment in aln_to_steal by matching gaps. This assumes that the
    ungapped sequences at index j in the vector1< SequenceOP > match the
    ungapped sequences at index j in aln_to_steal.
    

    C++ signature :
        core::sequence::SequenceAlignment steal_alignment(core::sequence::SequenceAlignment,utility::vector1<boost::shared_ptr<core::sequence::Sequence>, std::allocator<boost::shared_ptr<core::sequence::Sequence> > >)

transitive_map( (SequenceMapping)map1, (SequenceMapping)map2) -> SequenceMapping :
    Assuming that map1 maps sequence A to sequence B, and map2 maps
    sequence B to sequence C, this function returns the SequenceMapping
    representing the direct map of sequence A to sequence C.
    

    C++ signature :
        core::id::SequenceMapping transitive_map(core::id::SequenceMapping,core::id::SequenceMapping)

diagonal

Value:

rosetta.core.sequence._core_sequence_.AlignMove.diagonal